Authentification via LDAP

Centraliser l'authentification : Intégrer les annuaires d'entreprise

Dans de nombreuses organisations, la gestion des identités et des accès est centralisée au sein d'un annuaire LDAP (Lightweight Directory Access Protocol), comme Microsoft Active Directory, OpenLDAP, ou d'autres. Au lieu de dupliquer les informations utilisateur et de gérer les mots de passe dans chaque application, il est souvent préférable de déléguer l'authentification à cet annuaire centralisé.

Spring Security fournit un support de première classe pour l'intégration avec les serveurs LDAP. Cela permet à votre application Spring Boot de vérifier les informations d'identification des utilisateurs directement auprès de l'annuaire LDAP, sans avoir besoin de stocker les mots de passe localement. Spring Security peut également récupérer les groupes LDAP d'un utilisateur pour les utiliser comme rôles ou autorités dans la gestion des autorisations.

L'intégration LDAP est particulièrement pertinente dans les environnements d'entreprise où un système d'authentification unifié est déjà en place.

Composants clés de l'intégration LDAP dans Spring Security

L'intégration LDAP dans Spring Security repose sur plusieurs composants clés :

• LdapContextSource : Configure les détails de connexion au serveur LDAP (URL, base DN, identifiants du gestionnaire si nécessaire). Spring Boot peut souvent auto-configurer ce bean à partir des propriétés.
• LdapAuthenticator : Interface responsable de la vérification des informations d'identification de l'utilisateur auprès du serveur LDAP. Les implémentations courantes sont :
  • BindAuthenticator : Tente de se connecter (bind) au serveur LDAP en utilisant le DN (Distinguished Name) de l'utilisateur et le mot de passe fourni. C'est la méthode la plus simple et la plus courante.
  • PasswordComparisonAuthenticator : Se connecte avec un utilisateur technique (manager), recherche l'entrée de l'utilisateur, récupère l'attribut contenant le mot de passe haché et le compare en utilisant un PasswordEncoder configuré. Moins courant et nécessite un accès en lecture à l'attribut du mot de passe.
• LdapAuthoritiesPopulator : Interface responsable de la récupération des rôles ou des autorités de l'utilisateur depuis l'annuaire LDAP (généralement en recherchant les groupes auxquels l'utilisateur appartient). DefaultLdapAuthoritiesPopulator est l'implémentation standard.

Spring Security combine ces composants (souvent via un LdapAuthenticationProvider) pour effectuer le processus complet d'authentification et de récupération des autorités.

Configuration facile avec les propriétés Spring Boot

Spring Boot simplifie grandement la configuration de base pour l'authentification LDAP via les propriétés dans application.properties ou application.yml. Si le starter spring-security-ldap est présent, Spring Boot tente d'auto-configurer l'authentification LDAP.

Propriétés essentielles :

# application.properties

# URL(s) du serveur LDAP
spring.ldap.urls=ldap://ldap.example.com:389
# Base DN (point de départ pour les recherches)
spring.ldap.base=dc=example,dc=com

# Optionnel : Identifiants pour un utilisateur technique (manager) si nécessaire
# pour la recherche d'utilisateurs ou de groupes (non requis pour Bind simple)
# spring.ldap.username=cn=admin,dc=example,dc=com
# spring.ldap.password=admin_password

Propriétés pour l'authentification (Bind Authentication est souvent la plus simple) :

# --- Option 1: Bind Authentication avec User DN Patterns --- 
# Modèle pour construire le DN de l'utilisateur à partir du username saisi
# {0} sera remplacé par le username
spring.ldap.authentication.user-dn-patterns=uid={0},ou=people

# --- Option 2: Bind Authentication avec User Search --- 
# Base DN spécifique pour la recherche d'utilisateurs (si différente de spring.ldap.base)
# spring.ldap.authentication.user-search-base=ou=users
# Filtre LDAP pour trouver l'entrée de l'utilisateur basé sur le username saisi
# spring.ldap.authentication.user-search-filter=(uid={0}) # ou (sAMAccountName={0}) pour Active Directory

Propriétés pour récupérer les autorités (groupes) :

# Base DN pour la recherche des groupes
spring.ldap.authentication.group-search-base=ou=groups
# Filtre pour trouver les groupes dont l'utilisateur est membre
# {0} est le DN complet de l'utilisateur, {1} est le username
spring.ldap.authentication.group-search-filter=(uniqueMember={0}) # Filtre standard
# ou (member={0}) pour Active Directory (parfois)

# Attribut du groupe contenant son nom (utilisé pour générer l'autorité)
# spring.ldap.authentication.group-role-attribute=cn 

Avec ces propriétés, Spring Boot configure un LdapAuthenticationProvider qui utilise généralement une authentification par Bind et un DefaultLdapAuthoritiesPopulator pour récupérer les groupes et les mapper en autorités (par défaut, préfixées par `ROLE_`). Vous n'avez souvent rien de plus à faire pour une configuration LDAP standard.

Configuration Manuelle (Java Config)

Si les propriétés ne suffisent pas (besoin de configuration plus avancée du LdapContextSource, personnalisation fine de l'authenticator ou du populator), vous pouvez configurer l'authentification LDAP manuellement dans votre configuration de sécurité Java.

L'approche classique utilise AuthenticationManagerBuilder :

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.crypto.password.LdapShaPasswordEncoder; // Exemple si password compare est utilisé

@Configuration
public class LdapSecurityConfig { // S'ajoute à votre config SecurityFilterChain

    @Autowired
    public void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth
            .ldapAuthentication()
                // Configuration de la recherche utilisateur
                .userDnPatterns("uid={0},ou=people") // Ou .userSearchBase/Filter
                // Configuration de la recherche groupe
                .groupSearchBase("ou=groups")
                .groupSearchFilter("(uniqueMember={0})")
                .groupRoleAttribute("cn") // Optionnel
                // Configuration de la connexion au serveur LDAP
                .contextSource()
                    .url("ldap://ldap.example.com:389/dc=example,dc=com") // URL + Base DN
                    // .managerDn("cn=admin,dc=example,dc=com") // Si recherche nécessite un manager
                    // .managerPassword("admin_password")       // Si recherche nécessite un manager
                    .and()
                // Configuration de la comparaison de mot de passe (moins courant)
                // Si vous n'utilisez PAS la comparaison, ne mettez pas cette partie
                .passwordCompare() 
                    // Doit correspondre au hachage LDAP (ex: SSHA)
                    // .passwordEncoder(new LdapShaPasswordEncoder()) 
                    .passwordAttribute("userPassword"); // Attribut LDAP contenant le hash
    }
}

Vous pouvez également définir les beans LdapContextSource, LdapAuthenticator, et LdapAuthoritiesPopulator vous-même et les injecter dans un LdapAuthenticationProvider personnalisé que vous enregistrez ensuite.

Dépendances nécessaires

Pour utiliser l'authentification LDAP avec Spring Security, vous avez besoin de la dépendance suivante :

    org.springframework.security
    spring-security-ldap

// build.gradle (Gradle)
implementation 'org.springframework.security:spring-security-ldap'

// Vous aurez aussi besoin de implementation 'org.springframework.boot:spring-boot-starter-security'

La dépendance org.springframework.boot:spring-boot-starter-data-ldap est nécessaire si vous souhaitez utiliser LdapTemplate pour des opérations LDAP autres que l'authentification, ou si vous comptez sur son auto-configuration pour créer le bean LdapContextSource basé sur les propriétés.

Conclusion : Intégration transparente avec les annuaires

Spring Security facilite grandement l'intégration de votre application Spring Boot avec des annuaires LDAP pour l'authentification et la récupération des rôles. Grâce à l'auto-configuration via les propriétés, la mise en place pour des scénarios courants est souvent très rapide. Pour des besoins plus spécifiques, la configuration Java offre toute la flexibilité nécessaire pour adapter le processus d'authentification à la structure et aux exigences de votre annuaire LDAP.