Re: [sympa-fr] Scenariod'autorisation-RequêteLDAP

[Antoine Boursier <adresse@cachée>]

Bonjour tout le monde,

J'arrive au bout :)

J'ai réussi à faire fonctionner ma customCondition.

Je la met en fin de mail pour ceux que ça intéresse.

Sur ma lancée, j'ai voulu faire le même check pour les "editors" et "owners".

Je remplace juste "return 1 if $list->is_list_member($sender);" par "return 1 if $list->is_admin('owner',$sender);"

CustomCondition::customsubscriber([listname],[sender])             smtp,dkim,smime,md5    -> do_it
CustomCondition::customowner([listname],[sender])             smtp,dkim,smime,md5    -> do_it
true()                           smtp,dkim,md5,smime    -> reject(reason='send_subscriber')

Je me rend compte (au premier abord) en faisant mon test. Qu'une fois que la 1ere Custom condition renvoi 0, il n'éxécute pas la 2nde.

Et donc me rejette malgré le fait que je sois propriétaire (avec mon adresse lille3).

Une idée ?

Merci, bonne journée et bon week-end à tous.

#!/usr/bin/perl
package CustomCondition::customsubscriber;

use lib '/opt/sympa/bin/Sympa/';
use Sympa::List;
use Net::LDAP;

use constant LDAP_HOST => '' ;
use constant LDAP_BIND_DN => '' ;
use constant LDAP_PASSWORD => '' ;
use constant LDAP_BASE => '' ;

sub verify {
    my ($listname,$sender) = @_;
    my $list = Sympa::List->new($listname);
    return 1 if $list->is_list_member($sender);
    my $allowedDomains = "univ-lille.fr|univ-lille1.fr|univ-lille2.fr|univ-lille3.fr";
    my $ldapFilter = "(|(mail=%s)(mailForwardingAddress=%s))";
    my $attrs = [ "mail","mailForwardingAddress","supannAutreMail" ];
    $ldapFilter =~ s/\%s/$sender/sg;

    my $ldap = Net::LDAP->new(LDAP_HOST, version => 3);
    $ldap->bind(LDAP_BIND_DN, password => LDAP_PASSWORD);
    my $search = $ldap->search(base => LDAP_BASE, filter => $ldapFilter, attrs => $attrs, scope => 'one');
    my $entry = $search->shift_entry;
    if ($entry != "") {
        foreach my $attr (@$attrs){
            my $mail = $entry->get_value($attr);
            my $sender = lc($mail);
            return 0 if ($sender !~ /$allowedDomains/i);
            return 1 if $list->is_list_member($sender);
        }
    }
    return 0
}
1;

On 01/22/2018 09:06 AM, David Verdin wrote:

Non, un simple espace suffit.

D'après les logs, c'est un require qui plante. Je soupçonne Log.

Rempalce use Log;

par use Sympa::Log;

Ça devrait résoudre le problème.

bonne journée,

David

On 19/01/2018 15:48, Benoît Marchal wrote:

Bonjour,

Juste un truc bête, mais il me semble qu'il faut au moins une tabulation entre CustomCondition::... et smtp,dkim, ...

Cdlt

----- Le 19 Jan 18, à 14:48, Antoine Boursier <adresse@cachée> a écrit :

Bonjour à tous,

Après avoir bloqué quelques jours sur ces customs conditions, j'en suis toujous au même point.

J'ai essayé chacun de vos scripts, sans réussir à les faire fonctionner.

Du coup je suis passé sur quelque chose de beaucoup plus simple pour juste tester l'exécution du scénario. Et j'ai toujours les mêmes erreurs.

Voici ce que contient mon scenario d'envoi :

title.gettext Private, moderated for non subscribers

CustomCondition::test([sender],[listname]) smtp,dkim,md5,smime    -> do_it
true() smtp,dkim,md5,smime    -> reject

Et le test.pm

#!/usr/bin/perl
package CustomCondition::test;
use strict;
use Log;
sub verify {
    my $sender = shift;
    my $listname = shift;
    do_log ('info', 'arg :', $sender);
    do_log ('info', 'arg :', $listname);
    return 1;
}
1;

Je vous met les logs d'erreurs en PJ si ça peut aider.

Merci une fois de plus pour votre aide.

Bonne journée,

Antoine Boursier

On 01/09/2018 08:15 PM, David VERDIN wrote:

Je me demande si ce genre de choses ne trouverait pas utilement sa place dans le cœur de Sympa.
Comme règle de scénario standard.

----- Original Message -----
From: Benoît Marchal <adresse@cachée>
To: sympa-fr <adresse@cachée>
Sent: Tue, 09 Jan 2018 17:33:07 +0100 (CET)
Subject: Re: [sympa-fr] Scenariod'autorisation-RequêteLDAP

Et bien on a retrouvé. 
En tout cas merci beaucoup car cela nous sert encore aujourd'hui. 

Bonne soirée 

----- Le 9 Jan 18, à 17:25, LALOT Dominique <adresse@cachée> a écrit : 

Salut Benoit,

On y voit encore TRACEDOM. Tiens ça doit être moi

A utiliser sans modération.. Et bien pratique quand on change de domaine, voire
valider des mails alternatifs.

A+

Dom

--
Dominique LALOT
Responsable Pôle Environnement Numérique
Direction O p érationnelle du Système d'Information (DOSI)
( Aix * Marseille U niversité
Coordonnées: [ http://annuaire.univ-amu.fr/personnel/detail/bGFsb3Q= |
http://annuaire.univ-amu.fr/personnel/detail/bGFsb3Q= ]

De : adresse@cachée <adresse@cachée> de
la part de Benoît Marchal <adresse@cachée>
Envoyé : mardi 9 janvier 2018 13:26:52
À : sympa-fr
Objet : Re: [sympa-fr] Scenario d'autorisation -RequêteLDAP
Bonjour,

Nous avons eu le même souci en 2012 lors de la création de l'université de
Lorraine, fusion des 4 universités lorraines.

J'avais fait un truc du genre en reprenant une idée de quelqu'un :

le fichier

custom_conditions/is_subscriber.pm

!/usr/bin/perl
use lib '/home/sympa/bin';
package CustomCondition::is_subscriber;
use strict;
use List;
use ULSympa;
use Log; # optional : we log parameters

sub verify {
my $listName = shift;
my $sender = shift;
my $robot = (scalar @_ )? $_[$#_]:"";

# BM : Création de l'objet List
my $list = ( $listName =~ /\@/ || $robot eq "")? new List($listName) : new List
($listName, $robot);
return -1 if( !defined($list));

my @alternatemail=ULSympa::alternate($sender);
#do_log ('info', "custom: is_subscriber(new): sender : ".$sender." pour la liste
".$listName.(( $robot ne "" )? "@".$robot:""));
foreach my $mail (@alternatemail){
#do_log ('info', "custom: is_subscriber: mail teste : ".$mail);
return 1 if $list->is_user($mail);
}

#do_log ('info', "TRACEDOM sender: $sender -> $list_name");
return -1;
}

## Packages must return true.
1;

Il y a un petit patch pour récupérer le robot de la liste s'il n'est pas connu
dans le premier paramètre passé à la fonction.

Et le module ULSympa.pm

package ULSympa;

use Exporter;
use vars qw(@ISA @EXPORT @EXPORT_OK %EXPORT_TAGS $VERSION);
@ISA = ('Exporter');
@EXPORT = qw( &alternate);

use Net::LDAP;

use strict;

my $refLDAP =
{
hosts => [ "<mon server ldap>" ],
basedn => "ou=people, dc=univ-lorraine, dc=fr",
filter => "(|(mail=%s)(udlMailAlias=%s))",
attrs => [ "mail", "udlMailAlias" ],
#filter => "(|(mail=%s)(udlOldMails=%s)(udlMailAlias=%s))",
#attrs => [ "mail", "udlOldMails", "udlMailAlias" ],
};

my $checkMail = "<listes des anciens domaines en les séparant par un pipe>";

##########################################################################################
# recoit une adresse mail en parametre
# retourne un tableau de toutes les adresses mail valides
##########################################################################################
sub alternate {
my $mail2check = shift;
return $mail2check unless ($mail2check =~ /\@/);
my @TMailsValides = (lc($mail2check));
my $refAttrs = $$refLDAP{attrs};
return @TMailsValides if ($mail2check !~ /$checkMail/i);

my $ldap = Net::LDAP->new($$refLDAP{hosts}) or return @TMailsValides;
my $mesg = $ldap->bind('', version => 3 ) or return @TMailsValides;
my $filter = "$$refLDAP{filter}";
$filter =~ s/\%s/$mail2check/sg;

$mesg = $ldap->search ( # perform a search
base => $$refLDAP{basedn},
filter => $filter,
attrs => $$refLDAP{attrs},
scope => "one"
);
$ldap->unbind();
return @TMailsValides if ($mesg->count == 0);

my $entry = $mesg->shift_entry;
foreach my $attr (@$refAttrs){
my $refVal = $entry->get_value($attr, asref =>1);
next unless (defined($refVal));
foreach my $val (@$refVal){
my $mail = lc($val);
next unless($mail =~ /\@/);
push (@TMailsValides, $mail) unless (grep /^$mail$/, @TMailsValides);
}
}
return @TMailsValides;
}

## Packages must return true.
1;

C'est un peu compliqué que la solution de david, mais présentent l'avantage de
prendre systématiquement l'ensemble des adresses d'une personne, si c'est connu
de l'annuaire de l'établissement. Ce qui est le cas chez nous.

A ce jour, on a supprimé le test avec $checkMail, puis que nous n'avons plus les
anciennes adresses (ou alors, elles sont dans l'annuaire).

Cela s'utilise comme David le donne.

Pas de souci pour aider si besoin.

Cordialement
----- Le 9 Jan 18, à 12:50, David Verdin <adresse@cachée> a écrit :

Bonjour,

À la louche, je dirais que c'est un bon candidat pour une custom condition: [
https://www.sympa.org/manual/authorization-scenarios#custom_perl_package_conditions
|
https://www.sympa.org/manual/authorization-scenarios#custom_perl_package_conditions
]

Un truc dans ce genre, peut-être, certainement améliorable : #!/usr/bin/perl
package CustomCondition::lilletruc;
use strict;
use List;
sub verify {
my ($sender, $listname) = @_;
return 0 unless ($sender && $listname);
my $list = List::new($listname);
return 0 unless ($list);
if ($list->is_user($sender) {
return 1;
}
return 0 unless ($sender =~ m{ univ-lille\.fr });
$sender =~ s{univ-lille\.fr}{univ-lille1.fr};
if ($list->is_user($sender) {
return 1;
}
$sender =~ s{univ-lille1\.fr}{univ-lille2.fr};
if ($list->is_user($sender) {
return 1;
}
$sender =~ s{univ-lille2\.fr}{univ-lille3.fr};
if ($list->is_user($sender) {
return 1;
}
return 0;
}
1;

Après, tu mets cette ligne dans ton scénario :
CustomCondition:: lilletruc ([sender],[listname]) smtp,smime,md5,dkim -> do_it()

Le scénario renvoie 1 si la personne est abonnée. Si l'adresse d'expédition
n'est pas abonnée et que c'est du univ-lille.fr, il essaie de substituer avec
du lille 1 2 ou 3.

Voilà. Le scénario n'est pas testé, donc à prendre avec des pincettes mais ça
vous fait une base de départ.

Bonne journée !

David

On 09/01/2018 12:22, Antoine BOURSIER wrote:

Bonjour à tous,

Je me permet de vous solliciter une fois de plus, pour un soucis sur un scenario
d'autorisation.

Nous avons historiquement à l'université, 3 types d'adresses mails
(@univ-lille1.fr, @univ-lille2.fr et @univ-lille3.fr).
Cette année, les 3 universités de Lille fusionnent et tout le monde utilisera à
terme une adresse en univ-lille.fr.

J'aimerais pouvoir mettre en place un scénario, qui autorise un utilisateur qui
écrit avec son adresse @univ-lille.fr à écrire à une liste, si celui-ci est
abonné avec son adresse en @univ-lille(1|2|3).fr.

J'ai pensé à faire une recherche LDAP pour récupérer l'ancienne adresse mail de
l'utilisateur et vérifier si celui-ci est abonné à la liste, mais je ne trouve
pas le moyen de le mettre en oeuvre.
Comment utiliser le résultat d'une requête LDAP avec la condition
"is_subscriber" du scénario, au lieu de "search" ?

Si quelqu'un a déjà eu l'occasion de travailler sur des scénario complexes ou à
une idée sur la façon de procéder, je suis preneur :)

PS : Je ne peux pas abonné les deux types d'adresses à la même liste. Les mails
étant transférés d'une boite à l'autre, cela causerait des doublons.

Merci à vous et bonne journée à tous.

Antoine Boursier

Administrateur Systèmes
Direction des systèmes d'information | Cellule Systèmes & Hébergements
[ mailto:adresse@cachée | adresse@cachée ]
Université de Lille | Sciences Humaines et Sociales

--
"Mieux vaut viser la perfection et la rater que viser la médiocrité et
l'atteindre."
- Francis Blanche

--
Benoît MARCHAL
Sous direction Infrastructure & Services
Direction du Numérique
Université de Lorraine
Tél : 03.72.74.11.39
mél : adresse@cachée

--

--

Benoît MARCHAL Sous direction Infrastructure & Services Direction du Numérique Université de Lorraine Tél : 03.72.74.11.39 mél : adresse@cachée

-- 
"Mieux vaut viser la perfection et la rater que viser la médiocrité et l'atteindre."
- Francis Blanche

--

Antoine Boursier

Administrateur Systèmes
Direction des systèmes d'information | Cellule Système
adresse@cachée
Tél : +33 (0)3 20 41 71 97 | Interne : 17197
Université de Lille | Sciences Humaines et Sociales