Comment vous authentifier auprès d'un serveur Active Directory à l'aide de Spring Security?
J'écris une application Web Spring qui demande aux utilisateurs de se connecter. Mon entreprise dispose d'un serveur Active Directory que j'aimerais utiliser à cet effet. Cependant, j'ai du mal à utiliser Spring Security pour se connecter au serveur.
J'utilise Spring 2.5.5 et Spring Security 2.0.3, ainsi que Java 1.6.
Si je change l'URL LDAP à la mauvaise adresse IP, cela ne déclenche pas d'exception ou quoi que ce soit, donc je me demande si c'est même en essayant de se connecter au serveur pour commencer.
Bien que l'application Web démarre très bien, toutes les informations que j'entre dans la page de connexion sont rejetées. J'avais précédemment utilisé un InMemoryDaoImpl, qui fonctionnait bien, donc le reste de mon application semble être configuré correctement.
Voici mes beans liés à la sécurité:
<beans:bean id="ldapAuthProvider" class="org.springframework.security.providers.ldap.LdapAuthenticationProvider">
<beans:constructor-arg>
<beans:bean class="org.springframework.security.providers.ldap.authenticator.BindAuthenticator">
<beans:constructor-arg ref="initialDirContextFactory" />
<beans:property name="userDnPatterns">
<beans:list>
<beans:value>CN={0},OU=SBSUsers,OU=Users,OU=MyBusiness,DC=Acme,DC=com</beans:value>
</beans:list>
</beans:property>
</beans:bean>
</beans:constructor-arg>
</beans:bean>
<beans:bean id="userDetailsService" class="org.springframework.security.userdetails.ldap.LdapUserDetailsManager">
<beans:constructor-arg ref="initialDirContextFactory" />
</beans:bean>
<beans:bean id="initialDirContextFactory" class="org.springframework.security.ldap.DefaultInitialDirContextFactory">
<beans:constructor-arg value="ldap://192.168.123.456:389/DC=Acme,DC=com" />
</beans:bean>
J'ai eu la même expérience que je me suis cogné la tête contre le mur et j'ai fini par écrire un fournisseur d'authentification personnalisé qui effectue une requête LDAP sur le serveur Active Directory.
Donc, mes beans liés à la sécurité sont:
<beans:bean id="contextSource"
class="org.springframework.security.ldap.DefaultSpringSecurityContextSource">
<beans:constructor-arg value="ldap://hostname.queso.com:389/" />
</beans:bean>
<beans:bean id="ldapAuthenticationProvider"
class="org.queso.ad.service.authentication.LdapAuthenticationProvider">
<beans:property name="authenticator" ref="ldapAuthenticator" />
<custom-authentication-provider />
</beans:bean>
<beans:bean id="ldapAuthenticator"
class="org.queso.ad.service.authentication.LdapAuthenticatorImpl">
<beans:property name="contextFactory" ref="contextSource" />
<beans:property name="principalPrefix" value="QUESO\" />
</beans:bean>
Ensuite, la classe LdapAuthenticationProvider:
/**
* Custom Spring Security authentication provider which tries to bind to an LDAP server with
* the passed-in credentials; of note, when used with the custom {@link LdapAuthenticatorImpl},
* does <strong>not</strong> require an LDAP username and password for initial binding.
*
* @author Jason
*/
public class LdapAuthenticationProvider implements AuthenticationProvider {
private LdapAuthenticator authenticator;
public Authentication authenticate(Authentication auth) throws AuthenticationException {
// Authenticate, using the passed-in credentials.
DirContextOperations authAdapter = authenticator.authenticate(auth);
// Creating an LdapAuthenticationToken (rather than using the existing Authentication
// object) allows us to add the already-created LDAP context for our app to use later.
LdapAuthenticationToken ldapAuth = new LdapAuthenticationToken(auth, "ROLE_USER");
InitialLdapContext ldapContext = (InitialLdapContext) authAdapter
.getObjectAttribute("ldapContext");
if (ldapContext != null) {
ldapAuth.setContext(ldapContext);
}
return ldapAuth;
}
public boolean supports(Class clazz) {
return (UsernamePasswordAuthenticationToken.class.isAssignableFrom(clazz));
}
public LdapAuthenticator getAuthenticator() {
return authenticator;
}
public void setAuthenticator(LdapAuthenticator authenticator) {
this.authenticator = authenticator;
}
}
Ensuite, la classe LdapAuthenticatorImpl:
/**
* Custom Spring Security LDAP authenticator which tries to bind to an LDAP server using the
* passed-in credentials; does <strong>not</strong> require "master" credentials for an
* initial bind prior to searching for the passed-in username.
*
* @author Jason
*/
public class LdapAuthenticatorImpl implements LdapAuthenticator {
private DefaultSpringSecurityContextSource contextFactory;
private String principalPrefix = "";
public DirContextOperations authenticate(Authentication authentication) {
// Grab the username and password out of the authentication object.
String principal = principalPrefix + authentication.getName();
String password = "";
if (authentication.getCredentials() != null) {
password = authentication.getCredentials().toString();
}
// If we have a valid username and password, try to authenticate.
if (!("".equals(principal.trim())) && !("".equals(password.trim()))) {
InitialLdapContext ldapContext = (InitialLdapContext) contextFactory
.getReadWriteContext(principal, password);
// We need to pass the context back out, so that the auth provider can add it to the
// Authentication object.
DirContextOperations authAdapter = new DirContextAdapter();
authAdapter.addAttributeValue("ldapContext", ldapContext);
return authAdapter;
} else {
throw new BadCredentialsException("Blank username and/or password!");
}
}
/**
* Since the InitialLdapContext that's stored as a property of an LdapAuthenticationToken is
* transient (because it isn't Serializable), we need some way to recreate the
* InitialLdapContext if it's null (e.g., if the LdapAuthenticationToken has been serialized
* and deserialized). This is that mechanism.
*
* @param authenticator
* the LdapAuthenticator instance from your application's context
* @param auth
* the LdapAuthenticationToken in which to recreate the InitialLdapContext
* @return
*/
static public InitialLdapContext recreateLdapContext(LdapAuthenticator authenticator,
LdapAuthenticationToken auth) {
DirContextOperations authAdapter = authenticator.authenticate(auth);
InitialLdapContext context = (InitialLdapContext) authAdapter
.getObjectAttribute("ldapContext");
auth.setContext(context);
return context;
}
public DefaultSpringSecurityContextSource getContextFactory() {
return contextFactory;
}
/**
* Set the context factory to use for generating a new LDAP context.
*
* @param contextFactory
*/
public void setContextFactory(DefaultSpringSecurityContextSource contextFactory) {
this.contextFactory = contextFactory;
}
public String getPrincipalPrefix() {
return principalPrefix;
}
/**
* Set the string to be prepended to all principal names prior to attempting authentication
* against the LDAP server. (For example, if the Active Directory wants the domain-name-plus
* backslash prepended, use this.)
*
* @param principalPrefix
*/
public void setPrincipalPrefix(String principalPrefix) {
if (principalPrefix != null) {
this.principalPrefix = principalPrefix;
} else {
this.principalPrefix = "";
}
}
}
Et enfin, la classe LdapAuthenticationToken:
/**
* <p>
* Authentication token to use when an app needs further access to the LDAP context used to
* authenticate the user.
* </p>
*
* <p>
* When this is the Authentication object stored in the Spring Security context, an application
* can retrieve the current LDAP context thusly:
* </p>
*
* <pre>
* LdapAuthenticationToken ldapAuth = (LdapAuthenticationToken) SecurityContextHolder
* .getContext().getAuthentication();
* InitialLdapContext ldapContext = ldapAuth.getContext();
* </pre>
*
* @author Jason
*
*/
public class LdapAuthenticationToken extends AbstractAuthenticationToken {
private static final long serialVersionUID = -5040340622950665401L;
private Authentication auth;
transient private InitialLdapContext context;
private List<GrantedAuthority> authorities = new ArrayList<GrantedAuthority>();
/**
* Construct a new LdapAuthenticationToken, using an existing Authentication object and
* granting all users a default authority.
*
* @param auth
* @param defaultAuthority
*/
public LdapAuthenticationToken(Authentication auth, GrantedAuthority defaultAuthority) {
this.auth = auth;
if (auth.getAuthorities() != null) {
this.authorities.addAll(Arrays.asList(auth.getAuthorities()));
}
if (defaultAuthority != null) {
this.authorities.add(defaultAuthority);
}
super.setAuthenticated(true);
}
/**
* Construct a new LdapAuthenticationToken, using an existing Authentication object and
* granting all users a default authority.
*
* @param auth
* @param defaultAuthority
*/
public LdapAuthenticationToken(Authentication auth, String defaultAuthority) {
this(auth, new GrantedAuthorityImpl(defaultAuthority));
}
public GrantedAuthority[] getAuthorities() {
GrantedAuthority[] authoritiesArray = this.authorities.toArray(new GrantedAuthority[0]);
return authoritiesArray;
}
public void addAuthority(GrantedAuthority authority) {
this.authorities.add(authority);
}
public Object getCredentials() {
return auth.getCredentials();
}
public Object getPrincipal() {
return auth.getPrincipal();
}
/**
* Retrieve the LDAP context attached to this user's authentication object.
*
* @return the LDAP context
*/
public InitialLdapContext getContext() {
return context;
}
/**
* Attach an LDAP context to this user's authentication object.
*
* @param context
* the LDAP context
*/
public void setContext(InitialLdapContext context) {
this.context = context;
}
}
Vous remarquerez qu'il y a quelques bits dont vous pourriez ne pas avoir besoin.
Par exemple, mon application devait conserver le contexte LDAP correctement connecté pour une utilisation ultérieure par l'utilisateur une fois connecté - le but de l'application est de permettre aux utilisateurs de se connecter via leurs informations d'identification AD, puis d'exécuter d'autres fonctions liées à AD. Donc, à cause de cela, j'ai un jeton d'authentification personnalisé, LdapAuthenticationToken, que je passe (plutôt que le jeton d'authentification par défaut de Spring) qui me permet de joindre le contexte LDAP. Dans LdapAuthenticationProvider.authenticate (), je crée ce jeton et le redistribue; dans LdapAuthenticatorImpl.authenticate (), j'attache le contexte connecté à l'objet de retour afin qu'il puisse être ajouté à l'objet d'authentification Spring de l'utilisateur.
De plus, dans LdapAuthenticationProvider.authenticate (), j'attribue à tous les utilisateurs connectés le rôle ROLE_USER - c'est ce qui me permet ensuite de tester ce rôle dans mes éléments d'interception-url. Vous voudrez faire correspondre ce rôle au rôle que vous souhaitez tester, ou même attribuer des rôles basés sur des groupes Active Directory ou autre.
Enfin, et corollaire à cela, la façon dont j'ai implémenté LdapAuthenticationProvider.authenticate () donne à tous les utilisateurs possédant des comptes AD valides le même rôle ROLE_USER. De toute évidence, dans cette méthode, vous pouvez effectuer des tests supplémentaires sur l'utilisateur (c'est-à-dire, l'utilisateur est-il dans un groupe AD spécifique?) Et attribuer des rôles de cette façon, ou même tester une condition avant même d'accorder à l'utilisateur l'accès à tous.
Pour référence, Spring Security 3.1 a un fournisseur d'authentification spécifiquement pour Active Directory .
Juste pour mettre cela à jour. Spring Security 3.0 a un package complet avec des implémentations par défaut consacrées à ldap-bind ainsi qu'à l'authentification par requête et comparaison.
Comme dans la réponse de Luc ci-dessus:
Spring Security 3.1 dispose d'un fournisseur d'authentification spécifiquement pour Active Directory.
Voici comment cela peut être facilement réalisé à l'aide d'ActiveDirectoryLdapAuthenticationProvider.
Dans resources.groovy:
ldapAuthProvider1(ActiveDirectoryLdapAuthenticationProvider,
"mydomain.com",
"ldap://mydomain.com/"
)
Dans Config.groovy:
grails.plugin.springsecurity.providerNames = ['ldapAuthProvider1']
C'est tout le code dont vous avez besoin. Vous pouvez à peu près supprimer tous les autres paramètres grails.plugin.springsecurity.ldap. * Dans Config.groovy car ils ne s'appliquent pas à cette configuration AD.
Pour la documentation, voir: http://docs.spring.io/spring-security/site/docs/3.1.x/reference/springsecurity-single.html#ldap-active-directory
J'ai pu m'authentifier auprès d'Active Directory en utilisant Spring Security 2.0.4.
J'ai documenté les paramètres
http://maniezhilan.blogspot.com/2008/10/spring-security-204-with-active.html
Si vous utilisez Spring security 4 vous pouvez également l'implémenter en utilisant une classe donnée
- SecurityConfig.Java
@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
static final Logger LOGGER = LoggerFactory.getLogger(SecurityConfig.class);
@Autowired
protected void configureGlobal(AuthenticationManagerBuilder auth) throws Exception {
auth.authenticationProvider(activeDirectoryLdapAuthenticationProvider());
}
@Override
protected void configure(HttpSecurity http) throws Exception {
http
.authorizeRequests()
.antMatchers("/").permitAll()
.anyRequest().authenticated();
.and()
.formLogin()
.and()
.logout();
}
@Bean
public AuthenticationProvider activeDirectoryLdapAuthenticationProvider() {
ActiveDirectoryLdapAuthenticationProvider authenticationProvider =
new ActiveDirectoryLdapAuthenticationProvider("<domain>", "<url>");
authenticationProvider.setConvertSubErrorCodesToExceptions(true);
authenticationProvider.setUseAuthenticationRequestCredentials(true);
return authenticationProvider;
}
}
D'après la réponse de Luc ci-dessus:
Pour référence, Spring Security 3.1 dispose d'un fournisseur d'authentification [spécifiquement pour Active Directory] [1].
J'ai essayé ce qui précède avec Spring Security 3.1.1: il y a quelques légères modifications par rapport à ldap - les groupes Active Directory dont l'utilisateur est membre apparaissent comme cas d'origine.
Auparavant, sous ldap, les groupes étaient capitalisés et préfixés avec "ROLE_", ce qui les rendait faciles à trouver avec une recherche de texte dans un projet, mais pouvait évidemment rencontrer des problèmes dans un groupe unix si, pour une raison étrange, 2 groupes distincts n'étaient différenciés que par cas ( comptes et comptes).
De plus, la syntaxe nécessite une spécification manuelle du nom et du port du contrôleur de domaine, ce qui rend la redondance un peu effrayante. Il existe sûrement un moyen de rechercher l'enregistrement DNS SRV pour le domaine en Java, c'est-à-dire l'équivalent de (du guide de Samba 4):
$ Host -t SRV _ldap._tcp.samdom.example.com.
_ldap._tcp.samdom.example.com has SRV record 0 100 389 samba.samdom.example.com.
suivi d'une recherche A régulière:
$ Host -t A samba.samdom.example.com.
samba.samdom.example.com has address 10.0.0.1
(En fait, vous devrez peut-être également rechercher l'enregistrement _kerberos SRV ...)
Ce qui précède était avec Samba4.0rc1, nous passons progressivement de l'environnement LDAP Samba 3.x à Samba AD one.
L'authentification LDAP sans SSL n'est pas sûre que quiconque peut voir les informations d'identification de l'utilisateur lorsqu'elles sont transférées vers le serveur LDAP. Je suggère d'utiliser le protocole LDAPS:\pour l'authentification. Il ne nécessite aucun changement majeur sur la partie ressort, mais vous pouvez rencontrer des problèmes liés aux certificats. Voir Authentification LDAP Active Directory dans Spring avec SSL pour plus de détails