Sécurité de printemps LDAP et se souvenir de moi

il y a deux problèmes de configuration des fonctionnalités RememberMe avec LDAP:

• sélection de la bonne RememberMe de mise en œuvre (Jetons contre PersistentTokens)
• sa configuration utilisant la Configuration Java de Spring

je vais les prendre pas à pas.

la fonctionnalité "remember me" ( TokenBasedRememberMeServices ) basée sur un jeton fonctionne de la manière suivante lors de l'authentification:

• l'utilisateur est authentifié (agaisnt AD) et nous connaissons actuellement l'identifiant et le mot de passe de l'utilisateur
• nous construisons valeur username + expirationTime + password + staticKey et en créons un hash MD5
• nous créons un cookie qui contient nom d'utilisateur + expiration + le hash calculé

lorsque l'utilisateur veut revenir au service et être authentifié en utilisant le me fonctionnalité nous:

• vérifier si le témoin existe et s'il n'est pas expiré
• afficher l'identifiant de l'utilisateur à partir du cookie et appeler le service de messagerie fourni par L'utilisateur qui est censé retourner les informations relatives à l'identifiant de l'utilisateur, y compris le mot de passe
• nous calculons ensuite le hash à partir des données retournées et vérifions que le hash dans le cookie correspond à la valeur que nous avons calculée.
• si elle correspond, nous retournons l'objet D'authentification de l'utilisateur

le processus de vérification du hachage est requis afin de s'assurer que personne ne peut créer un "faux" cookie remember me, qui les laisserait usurper l'identité d'un autre utilisateur. Le problème est que ce processus repose sur la possibilité de charger le mot de passe à partir de notre dépôt - mais c'est impossible avec Active Directory - nous ne pouvons pas charger le mot de passe en clair basé sur le nom d'utilisateur.

cela rend l'implémentation basée sur les tokens Impropre à l'utilisation avec la publicité (à moins que nous ne commencions à créer un magasin utilisateur local qui contient le mot de passe ou un autre justificatif d'identité secret basé sur l'utilisateur et je ne suggère pas cette approche car je ne connais pas d'autres détails de votre application, bien que ce soit une bonne façon de procéder).

l'autre implémentation remember me est basée sur des tokens persistants ( PersistentTokenBasedRememberMeServices ) et fonctionne comme ceci (d'une manière un peu simplifiée)):

• lorsque l'utilisateur s'authentifie, nous générons un jeton aléatoire
• nous stockons le jeton dans le stockage avec les informations sur l'ID de l'utilisateur associé à lui
• nous créons un cookie qui inclut le token ID

lorsque l'utilisateur veut nous authentifier:

• vérifiez si nous avons le cookie avec token ID disponible
• vérifier si l'ID du token existe dans la base de données
• charger les données de l'utilisateur à partir des informations de la base de données

comme vous pouvez le voir, le mot de passe n'est plus nécessaire, bien que nous ayons maintenant besoin d'un stockage token (typiquement base de données, nous pouvons utiliser en mémoire pour tester) qui est utilisé à la place de la vérification de mot de passe.

et cela nous amène à la partie configuration. La configuration de base pour les tokens persistants souvenez-vous de moi ressemble à ceci:

@Override
protected void configure(HttpSecurity http) throws Exception {           
    ....
    String internalSecretKey = "internalSecretKey";
    http.rememberMe().rememberMeServices(rememberMeServices(internalSecretKey)).key(internalSecretKey);
}

 @Bean
 public RememberMeServices rememberMeServices(String internalSecretKey) {
     BasicRememberMeUserDetailsService rememberMeUserDetailsService = new BasicRememberMeUserDetailsService();
     InMemoryTokenRepositoryImpl rememberMeTokenRepository = new InMemoryTokenRepositoryImpl();
     PersistentTokenBasedRememberMeServices services = new PersistentTokenBasedRememberMeServices(staticKey, rememberMeUserDetailsService, rememberMeTokenRepository);
     services.setAlwaysRemember(true);
     return services;
 }

cette implémentation utilisera le stockage en mémoire token qui doit être remplacé par JdbcTokenRepositoryImpl pour la production. Le UserDetailsService fourni est responsable du chargement de données supplémentaires pour l'utilisateur identifié par L'identifiant de l'utilisateur chargé à partir du cookie remember me. La mise en œuvre la plus simple peut ressembler à ceci:

public class BasicRememberMeUserDetailsService implements UserDetailsService {
     public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
         return new User(username, "", Collections.<GrantedAuthority>emptyList());
     }
}

vous pouvez également fournir un autre UserDetailsService mise en œuvre qui charge attributs supplémentaires ou adhésions de groupe à partir de votre annonce ou base de données interne, selon vos besoins. Il pourrait ressembler à ceci:

@Bean
public RememberMeServices rememberMeServices(String internalSecretKey) {
    LdapContextSource ldapContext = getLdapContext();

    String searchBase = "OU=Users,DC=test,DC=company,DC=com";
    String searchFilter = "(&(objectClass=user)(sAMAccountName={0}))";
    FilterBasedLdapUserSearch search = new FilterBasedLdapUserSearch(searchBase, searchFilter, ldapContext);
    search.setSearchSubtree(true);

    LdapUserDetailsService rememberMeUserDetailsService = new LdapUserDetailsService(search);
    rememberMeUserDetailsService.setUserDetailsMapper(new CustomUserDetailsServiceImpl());

    InMemoryTokenRepositoryImpl rememberMeTokenRepository = new InMemoryTokenRepositoryImpl();

    PersistentTokenBasedRememberMeServices services = new PersistentTokenBasedRememberMeServices(internalSecretKey, rememberMeUserDetailsService, rememberMeTokenRepository);
    services.setAlwaysRemember(true);
    return services;
}

@Bean
public LdapContextSource getLdapContext() {
    LdapContextSource source = new LdapContextSource();
    source.setUserDn("user@"+DOMAIN);
    source.setPassword("password");
    source.setUrl(URL);
    return source;
}

cette fonctionnalité vous permettra de vous souvenir de moi qui fonctionne avec LDAP et fournit les données chargées à l'intérieur de RememberMeAuthenticationToken qui seront disponibles dans le SecurityContextHolder.getContext().getAuthentication() . Il pourra également RÉUTILISER votre logique existante pour l'analyse des données LDAP dans un objet utilisateur ( CustomUserDetailsServiceImpl ).

en tant qu'élément distinct sujet, il y a aussi un problème avec le code affiché dans la question, vous devriez remplacer le:

    authManagerBuilder
            .authenticationProvider(activeDirectoryLdapAuthenticationProvider())
            .userDetailsService(userDetailsService())
    ;

avec:

    authManagerBuilder
            .authenticationProvider(activeDirectoryLdapAuthenticationProvider())
    ;

l'appel à userDetailsService ne doit être fait que pour ajouter une authentification basée sur DAO (par exemple contre une base de données) et doit être appelé avec une réelle implémentation du service de détails utilisateur. Votre configuration actuelle peut conduire à des boucles infinies.