two problems in your module:
1. if a user doesn't belong any group, authentication will fail.
2. it only works if user is a immediate member of a group
e.g. user tom is a member of Uk_its, uk_its is a member of world_its, if
access grant to world_its, tom doesn't have access.
here is fixed code:
private void setupUserRoles(InitialLdapContext ctx, String userDN) throws
NamingException
{
log.debug("Performing authorization.");
String principalRoleAttributeName = (String)
options.get(PRINCIPAL_ROLE_ATTRIBUTE_NAME);
if(principalRoleAttributeName == null)
principalRoleAttributeName="memberOf";
String roleNameAttributeName = (String)
options.get(ROLE_NAME_ATTRIBUTE_NAME);
if(roleNameAttributeName == null) roleNameAttributeName="cn";
// we want only the attribute containing the roles returned
String[] getattrs = {principalRoleAttributeName};
// get the attributes for the user
Attributes attrs = ctx.getAttributes(userDN,getattrs);
Attribute attr = attrs.get(principalRoleAttributeName);
if(attr !=null){
NamingEnumeration roles = attr.getAll();
while (roles.hasMore())
{
String roleName = (String)roles.next();
// we want only the attribute containing the role name returned
String[] rgetattrs = {roleNameAttributeName};
// get the attributes for the role
Attributes rattrs = ctx.getAttributes(roleName,rgetattrs);
Attribute rattr = rattrs.get(roleNameAttributeName);
try
{
String shortRoleName = (String)rattr.get();
Principal p = super.createIdentity(shortRoleName);
log.debug("Assign user to role " + shortRoleName + " from role DN
" + roleName);
userRoles.addMember(p);
//add recursive search here to search indirect roles
setupUserRoles(ctx, roleName );
}
catch(Exception x)
{
x.printStackTrace();
}
}
}
}
"zparticle" wrote : I've recently written a new login module for use with
ActiveDirectory. Our schema didn't work with the LdapLoginModule at all.
Perhaps this will help you. Our directory is set up a bit odd so I had write
something new. Our AD is split into locations, for instance Building #1,
Building #2. There is no single place in our AD to find users. We want the
Windows network login and password to be used to log into the applications but
the users are entered into AD with their full names. The network id is an
attribute.
|
| The code below handles the authentication and authorization of the users in
AD. see the comments for an example of the login-config and how to use the
various parameters.
|
|
| | /*
| | * JBoss, the OpenSource WebOS
| | *
| | * Distributable under LGPL license.
| | * See terms of license at gnu.org.
| | */
| | //package org.jboss.security.auth.spi;
| |
| | import java.security.acl.Group;
| | import java.security.Principal;
| | import java.util.Iterator;
| | import java.util.Map.Entry;
| | import java.util.Properties;
| | import java.util.Set;
| | import java.util.StringTokenizer;
| | import javax.naming.Context;
| | import javax.naming.NamingEnumeration;
| | import javax.naming.NamingException;
| | import javax.naming.directory.Attribute;
| | import javax.naming.directory.Attributes;
| | import javax.naming.directory.BasicAttributes;
| | import javax.naming.directory.SearchResult;
| | import javax.naming.ldap.InitialLdapContext;
| | import javax.security.auth.login.LoginException;
| |
| | import org.jboss.security.SimpleGroup;
| | import org.jboss.security.SimplePrincipal;
| | import org.jboss.security.auth.spi.UsernamePasswordLoginModule;
| |
| | /**
| | * An implementation of LoginModule that authenticates against an LDAP
server
| | * using JNDI, based on the configuration properties.
| | * <p>
| | * The LoginModule options include whatever options your LDAP JNDI
provider
| | * supports. Examples of standard property names are:
| | * <ul>
| | * <li><code>Context.INITIAL_CONTEXT_FACTORY =
"java.naming.factory.initial"</code>
| | * <li><code>Context.SECURITY_PROTOCOL =
"java.naming.security.protocol"</code>
| | * <li><code>Context.PROVIDER_URL = "java.naming.provider.url"</code>
| | * <li><code>Context.SECURITY_AUTHENTICATION =
"java.naming.security.authentication"</code>
| | * </ul>
| | * <p>
| | * The Context.SECURITY_PRINCIPAL is set to the distinguished name of
the user
| | * as obtained by the callback handler.
| | * <p>
| | * Additional module properties include:
| | * <ul>
| | * <li>principalSerachStartDNs : A ; delimited list of DNs to search
under to find the
| | * user.
| | * <p>
| | * OU=Users,OU=IT,OU=Departments,OU=Building
1,DC=company,DC=com;OU=Users,OU=Finance,OU=Departments,OU=Building
1,DC=company,DC=com;
| | * <p>
| | * an opaque Object using the
<code>org.jboss.security.plugins.ObjectCallback</code> type
| | * of Callback rather than as a char[] password using a JAAS
PasswordCallback.
| | * <li>principalIDAttributeName : The name of the attribute that is the
id to match an object as the user
| | * that is logging in. If the user logs in with the network id then
sAMAccountName should be used here.
| | * <li>principalSearchObjectClass : Used to narrow the list of matching
objects to a specific type during the
| | * search. Uses the objectClass attribute. This is typically set to
user.
| | * <li>principalRoleAttributeName : The name of the attribute that
contains the user roles
| | * <li>roleNameAttributeName : The name of the attribute in the role CN
that is the name of the role for the user
| | * <li>performAuthentication : Defaults to true, if false the users
password is not verified. The users roles are set up.
| | *
| | * This class was based on the LdapLoginModule class by [EMAIL
PROTECTED]
| | *
| | * <p>Example login-config.xml<p>
| | <pre>
| | <application-policy name = "ldap">
| | <authentication>
| | <login-module code = "ActiveDirectoryLoginModule" flag =
"required" >
| | <module-option
name="java.naming.factory.initial">com.sun.jndi.ldap.LdapCtxFactory</module-option>
| | <module-option
name="java.naming.provider.url">ldap://127.0.0.1:389</module-option>
| | <module-option
name="java.naming.security.authentication">simple</module-option>
| | <module-option
name="java.naming.security.principal">CN=ldap,OU=Service
Accounts,DC=company,DC=com</module-option>
| | <module-option
name="java.naming.security.credentials">password</module-option>
| | <module-option name="principalSearchStartDNs">
| | OU=Users,OU=IT,OU=Departments,OU=Interlocken
380,DC=mcdata,DC=com
| | </module-option>
| | <module-option
name="principalIDAttrbuteName">sAMAccountName</module-option>
| | <module-option
name="principalSearchObjectClass">user</module-option>
| | <module-option
name="principalRoleAttributeName">memberOf</module-option>
| | <module-option
name="roleNameAttributeName">cn</module-option>
| | </login-module>
| | </authentication>
| | </application-policy>
| | </pre>
| | *
| | * @author [EMAIL PROTECTED]
| | */
| | public class ActiveDirectoryLoginModule extends
UsernamePasswordLoginModule
| | {
| | private static final String PRINCIPAL_SEARCH_DNS =
"principalSearchStartDNs";
| | private static final String PRINCIPAL_ID_ATTRIBUTE_NAME =
"principalIDAttributeName";
| | private static final String PRINCIPAL_SEARCH_OBJECT_CLASS =
"principalSearchObjectClass";
| | private static final String PRINCIPAL_ROLE_ATTRIBUTE_NAME =
"principalRoleAttributeName";
| | private static final String ROLE_NAME_ATTRIBUTE_NAME =
"roleNameAttributeName";
| | private static final String PERFORM_AUTHENTICATION =
"performAuthentication";
| |
| | public ActiveDirectoryLoginModule()
| | {
| | }
| |
| | private transient SimpleGroup userRoles = new SimpleGroup("Roles");
| |
| | /** Overriden to return an empty password string as typically one
cannot
| | obtain a user's password. We also override the validatePassword so
| | this is ok.
| | @return and empty password String
| | */
| | protected String getUsersPassword() throws LoginException
| | {
| | return "";
| | }
| |
| | /** Overriden by subclasses to return the Groups that correspond to
the
| | to the role sets assigned to the user. Subclasses should create at
| | least a Group named "Roles" that contains the roles assigned to the
user.
| | A second common group is "CallerPrincipal" that provides the
application
| | identity of the user rather than the security domain identity.
| | @return Group[] containing the sets of roles
| | */
| | protected Group[] getRoleSets() throws LoginException
| | {
| | Group[] roleSets = {userRoles};
| | return roleSets;
| | }
| |
| | /** Validate the inputPassword by creating a ldap InitialContext
with the
| | SECURITY_CREDENTIALS set to the password.
| |
| | @param inputPassword the password to validate.
| | @param expectedPassword ignored
| | */
| | protected boolean validatePassword(String inputPassword, String
expectedPassword)
| | {
| | boolean isValid = false;
| |
| | String ldapAccount =
(String)options.get("java.naming.security.principal");
| | Object ldapAccountPW =
options.get("java.naming.security.credentials");
| |
| | String performAuthentication = (String)
options.get(PERFORM_AUTHENTICATION);
| | if(performAuthentication == null) performAuthentication="true";
| | boolean doAuth =
"true".equals(performAuthentication.toLowerCase());
| |
| | if (doAuth && inputPassword != null)
| | {
| | log.debug("Performing authentication.");
| | // See if this is an empty password that should be disallowed
| | if (inputPassword.length() == 0)
| | {
| | super.log.debug("Rejecting empty password");
| | return false;
| | }
| |
| | try
| | {
| | // first log in as the account to use to search with and
find the user DN
| | InitialLdapContext ctx = createLdapInitContext(ldapAccount,
ldapAccountPW);
| | if(ctx!=null) // we logged in now go find the user
| | {
| | String username = getUsername();
| | String userDN = findUser(ctx,username);
| | ctx.close();
| | if(userDN!=null)
| | {
| | // Validate the password by trying to create an
initial context
| | InitialLdapContext uctx =
createLdapInitContext(userDN, inputPassword);
| | setupUserRoles(uctx,userDN);
| | uctx.close();
| | isValid = true;
| | }
| | }
| | }
| | catch (NamingException e)
| | {
| | super.log.debug("Failed to validate password", e);
| | }
| | }
| | else if(!doAuth) // don't validate the password just set up the
roles
| | {
| | log.debug("Skipping authentication.");
| | isValid = true;
| | try
| | {
| | // first log in as the account to use to search with and
find the user DN
| | InitialLdapContext ctx = createLdapInitContext(ldapAccount,
ldapAccountPW);
| | if(ctx!=null) // we logged in now go find the user
| | {
| | String username = getUsername();
| | String userDN = findUser(ctx,username);
| | if(userDN!=null)
| | setupUserRoles(ctx,userDN);
| | ctx.close();
| | }
| | }
| | catch (NamingException e)
| | {
| | super.log.debug("Failed to validate password", e);
| | }
| | }
| | return isValid;
| | }
| |
| | /**
| | * @param ctx The ldap context
| | * @param userDN String containing the full DN for the user
| | */
| | private void setupUserRoles(InitialLdapContext ctx, String userDN)
throws NamingException
| | {
| | log.debug("Performing authorization.");
| | String principalRoleAttributeName = (String)
options.get(PRINCIPAL_ROLE_ATTRIBUTE_NAME);
| | if(principalRoleAttributeName == null)
principalRoleAttributeName="memberOf";
| |
| | String roleNameAttributeName = (String)
options.get(ROLE_NAME_ATTRIBUTE_NAME);
| | if(roleNameAttributeName == null) roleNameAttributeName="cn";
| |
| | // we want only the attribute containing the roles returned
| | String[] getattrs = {principalRoleAttributeName};
| |
| | // get the attributes for the user
| | Attributes attrs = ctx.getAttributes(userDN,getattrs);
| | Attribute attr = attrs.get(principalRoleAttributeName);
| | NamingEnumeration roles = attr.getAll();
| |
| | while (roles.hasMore())
| | {
| | String roleName = (String)roles.next();
| |
| | // we want only the attribute containing the role name
returned
| | String[] rgetattrs = {roleNameAttributeName};
| |
| | // get the attributes for the role
| | Attributes rattrs = ctx.getAttributes(roleName,rgetattrs);
| | Attribute rattr = rattrs.get(roleNameAttributeName);
| |
| | try
| | {
| | String shortRoleName = (String)rattr.get();
| | Principal p = super.createIdentity(shortRoleName);
| | log.debug("Assign user to role " + shortRoleName + " from
role DN " + roleName);
| | userRoles.addMember(p);
| | }
| | catch(Exception x)
| | {
| | x.printStackTrace();
| | }
| | }
| | }
| |
| | /**
| | * @param ctx The ldap context
| | * @param username The name the user used to log in
| | * @return String containing the full DN for the user
| | */
| | private String findUser(InitialLdapContext ctx, String username)
throws NamingException
| | {
| | String userDN = null;
| |
| | // get all of the starting search points
| | String principalSearchStartDNs = (String)
options.get(PRINCIPAL_SEARCH_DNS);
| | if (principalSearchStartDNs == null) principalSearchStartDNs = "";
| | StringTokenizer st = new
StringTokenizer(principalSearchStartDNs,";");
| | String[] searchHere = new String[st.countTokens()];
| | int index=0;
| | while(st.hasMoreTokens()) searchHere[index++]=st.nextToken();
| |
| | String principalIDAttributeName = (String)
options.get(PRINCIPAL_ID_ATTRIBUTE_NAME);
| | if (principalIDAttributeName == null) principalIDAttributeName =
"sAMAccountName";
| |
| | String principalSearchObjectClass = (String)
options.get(PRINCIPAL_SEARCH_OBJECT_CLASS);
| | if(principalSearchObjectClass == null)
principalSearchObjectClass="user";
| |
| | // set up the attrs to make a match on
| | BasicAttributes matchAttrs = new BasicAttributes(true);
| | matchAttrs.put(principalIDAttributeName, username);
| | matchAttrs.put("objectClass", principalSearchObjectClass);
| |
| | for(int searchAt=0;searchAt<searchHere.length &&
userDN==null;searchAt++)
| | {
| | super.log.debug("Searching At: "+searchHere[searchAt]);
| | NamingEnumeration answer = ctx.search(searchHere[searchAt],
matchAttrs);
| | while (answer.hasMore() && userDN==null)
| | {
| | super.log.debug("Found a result");
| | SearchResult sr = (SearchResult) answer.next();
| | Attributes attrs = sr.getAttributes();
| | Attribute dn = attrs.get("distinguishedName");
| | userDN = (String)dn.get();
| | }
| | }
| | super.log.debug("Returning userDN: "+userDN);
| | return userDN;
| | }
| |
| | private InitialLdapContext createLdapInitContext(String username,
Object credential) throws NamingException
| | {
| | Properties env = new Properties();
| | // Map all option into the JNDI InitialLdapContext env
| | Iterator iter = options.entrySet().iterator();
| | while (iter.hasNext())
| | {
| | Entry entry = (Entry) iter.next();
| | env.put(entry.getKey(), entry.getValue());
| | }
| |
| | // Set defaults for key values if they are missing
| | String factoryName =
env.getProperty(Context.INITIAL_CONTEXT_FACTORY);
| | if (factoryName == null)
| | {
| | factoryName = "com.sun.jndi.ldap.LdapCtxFactory";
| | env.setProperty(Context.INITIAL_CONTEXT_FACTORY, factoryName);
| | }
| | String authType =
env.getProperty(Context.SECURITY_AUTHENTICATION);
| | if (authType == null)
| | env.setProperty(Context.SECURITY_AUTHENTICATION, "simple");
| | String protocol = env.getProperty(Context.SECURITY_PROTOCOL);
| | String providerURL = (String) options.get(Context.PROVIDER_URL);
| | if (providerURL == null)
| | providerURL = "ldap://localhost:" + ((protocol != null &&
protocol.equals("ssl")) ? "636" : "389");
| | env.setProperty(Context.PROVIDER_URL, providerURL);
| | env.setProperty(Context.SECURITY_PRINCIPAL, username);
| | env.put(Context.SECURITY_CREDENTIALS, credential);
| |
| | super.log.debug("Logging into LDAP server, env=" + env);
| | InitialLdapContext ctx = new InitialLdapContext(env, null);
| | super.log.debug("Logged into LDAP server, " + ctx);
| | return ctx;
| | }
| |
| | }
| |
| |
View the original post :
http://www.jboss.org/index.html?module=bb&op=viewtopic&p=3866681#3866681
Reply to the post :
http://www.jboss.org/index.html?module=bb&op=posting&mode=reply&p=3866681
-------------------------------------------------------
SF email is sponsored by - The IT Product Guide
Read honest & candid reviews on hundreds of IT Products from real users.
Discover which products truly live up to the hype. Start reading now.
http://ads.osdn.com/?ad_id=6595&alloc_id=14396&op=click
_______________________________________________
JBoss-user mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/jboss-user