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

[Benoît Marchal <adresse@cachée>]

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 Opérationnelle du Système d'Information (DOSI)

( Aix * Marseille Université
Coordonnées: 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

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:

adresse@cachée">

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
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