TOC

Spring LDAP Overview

Spring LDAP Présentation

1. Vue d'ensemble

Les serveurs d'annuaire LDAP sont des magasins de données hiérarchiques optimisés en lecture. En règle générale, ils sont utilisés pour stocker les informations relatives aux utilisateurs requises pour l'authentification et l'autorisation des utilisateurs.

Dans cet article, nous allons explorer les API Spring LDAP pour authentifier et rechercher des utilisateurs, ainsi que pour créer et modifier des utilisateurs dans le serveur d'annuaire. Le même ensemble d'API peut être utilisé pour gérer tout autre type d'entrées dans LDAP.

2. Dépendances Maven

Commençons par ajouter la dépendance Maven requise: 


    org.springframework.ldap
    spring-ldap-core
    2.3.1.RELEASE

La dernière version de cette dépendance peut être trouvée dansspring-ldap-core.

3. Préparation des données

Pour les besoins de cet article, créons d'abord l'entrée LDAP suivante: 

ou=users,dc=example,dc=com (objectClass=organizationalUnit)

Sous ce nœud, nous allons créer de nouveaux utilisateurs, modifier les utilisateurs existants, authentifier les utilisateurs existants et rechercher des informations.

4. API Spring LDAP

4.1. Définition du beanContextSource &LdapTemplate

ContextSource est utilisé pour créer lesLdapTemplate. Nous verrons l'utilisation deContextSource lors de l'authentification des utilisateurs dans la section suivante: 

@Bean
public LdapContextSource contextSource() {
    LdapContextSource contextSource = new LdapContextSource();

    contextSource.setUrl(env.getRequiredProperty("ldap.url"));
    contextSource.setBase(
      env.getRequiredProperty("ldap.partitionSuffix"));
    contextSource.setUserDn(
      env.getRequiredProperty("ldap.principal"));
    contextSource.setPassword(
      env.getRequiredProperty("ldap.password"));

    return contextSource;
}

LdapTemplate est utilisé pour la création et la modification des entrées LDAP: 

@Bean
public LdapTemplate ldapTemplate() {
    return new LdapTemplate(contextSource());
}

4.2. Authentification d'utilisateur

Implémentons maintenant une simple logique pour authentifier un utilisateur existant: 

public void authenticate(String username, String password) {
    contextSource
      .getContext(
        "cn=" +
         username +
         ",ou=users," +
         env.getRequiredProperty("ldap.partitionSuffix"), password);
}

4.3. Création d'utilisateur

Ensuite, créons un nouvel utilisateur et stockons un hachage SHA du mot de passe dans LDAP.

Au moment de l'authentification, le serveur LDAP génère le hachage SHA du mot de passe fourni et le compare à celui stocké: 

public void create(String username, String password) {
    Name dn = LdapNameBuilder
      .newInstance()
      .add("ou", "users")
      .add("cn", username)
      .build();
    DirContextAdapter context = new DirContextAdapter(dn);

    context.setAttributeValues(
      "objectclass",
      new String[]
        { "top",
          "person",
          "organizationalPerson",
          "inetOrgPerson" });
    context.setAttributeValue("cn", username);
    context.setAttributeValue("sn", username);
    context.setAttributeValue
      ("userPassword", digestSHA(password));

    ldapTemplate.bind(context);
}

digestSHA() est une méthode personnalisée qui renvoie la chaîne encodée en Base64 du hachage SHA du mot de passe fourni.

Enfin, la méthodebind() deLdapTemplate est utilisée pour créer une entrée dans le serveur LDAP.

4.4. Modification de l'utilisateur

Nous pouvons modifier un utilisateur ou une entrée existante avec la méthode suivante: 

public void modify(String username, String password) {
    Name dn = LdapNameBuilder.newInstance()
      .add("ou", "users")
      .add("cn", username)
      .build();
    DirContextOperations context
      = ldapTemplate.lookupContext(dn);

    context.setAttributeValues
      ("objectclass",
          new String[]
            { "top",
              "person",
              "organizationalPerson",
              "inetOrgPerson" });
    context.setAttributeValue("cn", username);
    context.setAttributeValue("sn", username);
    context.setAttributeValue("userPassword",
      digestSHA(password));

    ldapTemplate.modifyAttributes(context);
}

La méthodelookupContext() est utilisée pour trouver l'utilisateur fourni.

4.5. Recherche d'utilisateurs

Nous pouvons rechercher des utilisateurs existants à l'aide de filtres de recherche: 

public List search(String username) {
    return ldapTemplate
      .search(
        "ou=users",
        "cn=" + username,
        (AttributesMapper) attrs -> (String) attrs.get("cn").get());
}

LeAttributesMapper est utilisé pour obtenir la valeur d'attribut souhaitée à partir des entrées trouvées. En interne, SpringLdapTemplate appelle lesAttributesMapper pour toutes les entrées trouvées et crée une liste des valeurs d'attribut.

5. Essai

spring-ldap-test fournit un serveur LDAP intégré basé sur ApacheDS 1.5.5. Pour configurer le serveur LDAP intégré à des fins de test, nous devons configurer le bean Spring suivant: 

@Bean
public TestContextSourceFactoryBean testContextSource() {
    TestContextSourceFactoryBean contextSource
      = new TestContextSourceFactoryBean();

    contextSource.setDefaultPartitionName(
      env.getRequiredProperty("ldap.partition"));
    contextSource.setDefaultPartitionSuffix(
      env.getRequiredProperty("ldap.partitionSuffix"));
    contextSource.setPrincipal(
      env.getRequiredProperty("ldap.principal"));
    contextSource.setPassword(
      env.getRequiredProperty("ldap.password"));
    contextSource.setLdifFile(
      resourceLoader.getResource(
        env.getRequiredProperty("ldap.ldiffile")));
    contextSource.setPort(
      Integer.valueOf(
        env.getRequiredProperty("ldap.port")));
    return contextSource;
}

Testons notre méthode de recherche d'utilisateurs avec JUnit: 

@Test
public void
  givenLdapClient_whenCorrectSearchFilter_thenEntriesReturned() {
    List users = ldapClient
      .search(SEARCH_STRING);

    assertThat(users, Matchers.containsInAnyOrder(USER2, USER3));
}

6. Conclusion

Dans cet article, nous avons présenté les API Spring LDAP et développé des méthodes simples d'authentification, de recherche, de création et de modification d'utilisateur sur un serveur LDAP.

Comme toujours, le code source complet est disponible enthis Github project. Les tests sont créés sous le profil Maven "live" et peuvent donc être exécutés à l'aide de l'option "-P live".

Related