मैं तुमने किया ही पीटने-मेरी-सिर के खिलाफ-दीवार अनुभव नहीं था, और एक कस्टम प्रमाणीकरण प्रदाता है कि एक LDAP करता लेखन समाप्त हो गया सक्रिय निर्देशिका सर्वर के खिलाफ क्वेरी।
तो मेरी सुरक्षा से संबंधित सेम हैं:
<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>
फिर 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;
}
}
फिर 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 = "";
}
}
}
और अंत में, 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;
}
}
आप देखेंगे कि वहां कुछ बिट्स हैं जिनकी आपको आवश्यकता नहीं हो सकती है।
उदाहरण के लिए, मेरे ऐप को लॉग इन किए गए उपयोगकर्ता द्वारा आगे के उपयोग के लिए सफलतापूर्वक लॉग-इन एलडीएपी संदर्भ को बनाए रखने की आवश्यकता है - ऐप का उद्देश्य उपयोगकर्ताओं को उनके एडी प्रमाण-पत्रों के माध्यम से लॉग इन करना है और फिर आगे एडी- संबंधित कार्यों। तो इसके कारण, मेरे पास एक कस्टम प्रमाणीकरण टोकन है, LdapAuthenticationToken, जो मैं चारों ओर पास करता हूं (स्प्रिंग के डिफ़ॉल्ट प्रमाणीकरण टोकन के बजाय) जो मुझे एलडीएपी संदर्भ संलग्न करने की अनुमति देता है। LdapAuthenticationProvider.authenticate() में, मैं उस टोकन को बना देता हूं और उसे वापस भेजता हूं; LdapAuthenticatorImpl.authenticate() में, मैं लॉग-इन संदर्भ को रिटर्न ऑब्जेक्ट में संलग्न करता हूं ताकि इसे उपयोगकर्ता के स्प्रिंग प्रमाणीकरण ऑब्जेक्ट में जोड़ा जा सके।
इसके अलावा, LdapAuthenticationProvider.authenticate() में, मैं सभी लॉग-इन उपयोगकर्ताओं को ROLE_USER भूमिका नियुक्त करता हूं - यही कारण है कि मैं अपने इंटरसेप्ट-यूआरएल तत्वों में उस भूमिका के लिए परीक्षण करने देता हूं। आप इस मैच को जो भी भूमिका निभाना चाहते हैं, या सक्रिय निर्देशिका समूहों या जो भी हो, के आधार पर भूमिकाएं असाइन करना चाहेंगे।
अंत में, और इसके लिए एक अनुशासनिक तरीका, जिस तरह से मैंने LdapAuthenticationProvider.authenticate() लागू किया है, वैध उपयोगकर्ताओं के साथ सभी उपयोगकर्ताओं को समान ROLE_USER भूमिका देता है। जाहिर है, उस विधि में, आप उपयोगकर्ता पर आगे के परीक्षण कर सकते हैं (यानी, एक विशिष्ट एडी समूह में उपयोगकर्ता है?) और सभी पर उपयोगकर्ता पहुंच प्रदान करने से पहले कुछ शर्तों के लिए भी परीक्षण करें, या यहां तक कि कुछ शर्त के लिए भी परीक्षण करें।
यह वास्तव में एक स्पष्ट प्रश्न के रूप में इतना उत्तर नहीं है - क्या आपके पास वसंत सुरक्षा पैकेज के लिए लॉगिंग चालू है? –
मैंने सब कुछ के लिए लॉगिंग चालू कर दी है। लॉग इन होने वाले किसी भी संदेश को न देखें ... मैंने अपने प्रश्न 4 लॉग कॉन्फ़िगरेशन के साथ अपना प्रश्न अपडेट किया है। – Michael
मुझे इसके लिए आवश्यक जार फ़ाइलों को बताएं। कृपया – addy