import static org.argeo.util.naming.LdapObjs.top;
import java.net.URI;
-import java.nio.channels.UnsupportedAddressTypeException;
+import java.security.PrivilegedAction;
import java.util.ArrayList;
import java.util.Dictionary;
+import java.util.Hashtable;
import java.util.Iterator;
import java.util.List;
import javax.naming.directory.BasicAttributes;
import javax.naming.ldap.LdapName;
import javax.naming.ldap.Rdn;
+import javax.security.auth.Subject;
+import javax.security.auth.kerberos.KerberosTicket;
+import org.argeo.util.CurrentSubject;
import org.argeo.util.directory.DirectoryConf;
import org.argeo.util.directory.DirectoryDigestUtils;
import org.argeo.util.directory.HierarchyUnit;
import org.argeo.util.directory.ldap.AbstractLdapDirectory;
+import org.argeo.util.directory.ldap.LdapDao;
import org.argeo.util.directory.ldap.LdapEntry;
import org.argeo.util.directory.ldap.LdapEntryWorkingCopy;
import org.argeo.util.directory.ldap.LdapNameUtils;
*/
protected AbstractLdapDirectory scope(User user) {
- throw new UnsupportedAddressTypeException();
+ if (getDirectoryDao() instanceof LdapDao) {
+ return scopeLdap(user);
+ } else if (getDirectoryDao() instanceof LdifDao) {
+ return scopeLdif(user);
+ } else {
+ throw new IllegalStateException("Unsupported DAO " + getDirectoryDao().getClass());
+ }
}
protected DirectoryUserAdmin scopeLdap(User user) {
} else {
properties.put(Context.SECURITY_AUTHENTICATION, "GSSAPI");
}
- return new DirectoryUserAdmin(null, properties, true);
+ DirectoryUserAdmin scopedDirectory = new DirectoryUserAdmin(null, properties, true);
+ scopedDirectory.init();
+ return scopedDirectory;
}
protected DirectoryUserAdmin scopeLdif(User user) {
// scopedUserAdmin.users = Collections.unmodifiableNavigableMap(users);
// FIXME do it better
((LdifDao) getDirectoryDao()).scope((LdifDao) scopedUserAdmin.getDirectoryDao());
+ scopedUserAdmin.init();
return scopedUserAdmin;
}
@Override
public Role getRoleByPath(String path) {
- return (Role) doGetRole(pathToName(path));
+ LdapEntry entry = doGetRole(pathToName(path));
+ if (!(entry instanceof Role)) {
+ return null;
+// throw new IllegalStateException("Path must be a UserAdmin Role.");
+ } else {
+ return (Role) entry;
+ }
}
protected List<Role> getAllRoles(DirectoryUser user) {
List<Role> allRoles = new ArrayList<Role>();
if (user != null) {
- collectRoles(user, allRoles);
+ collectRoles((LdapEntry) user, allRoles);
allRoles.add(user);
} else
collectAnonymousRoles(allRoles);
return allRoles;
}
- private void collectRoles(DirectoryUser user, List<Role> allRoles) {
+ private void collectRoles(LdapEntry user, List<Role> allRoles) {
List<LdapEntry> allEntries = new ArrayList<>();
- LdapEntry entry = (LdapEntry) user;
+ LdapEntry entry = user;
collectGroups(entry, allEntries);
for (LdapEntry e : allEntries) {
- allRoles.add((Role) e);
+ if (e instanceof Role)
+ allRoles.add((Role) e);
}
// Attributes attrs = user.getAttributes();
// // TODO centralize attribute name
@Override
public Authorization getAuthorization(User user) {
- if (user == null || user instanceof DirectoryUser) {
- return new LdifAuthorization(user, getAllRoles((DirectoryUser) user));
+ if (user == null) {// anonymous
+ return new LdifAuthorization(user, getAllRoles(null));
+ }
+ LdapName userName = toLdapName(user.getName());
+ if (isExternal(userName) && user instanceof LdapEntry) {
+ List<Role> allRoles = new ArrayList<Role>();
+ collectRoles((LdapEntry) user, allRoles);
+ return new LdifAuthorization(user, allRoles);
} else {
- // bind
- DirectoryUserAdmin scopedUserAdmin = (DirectoryUserAdmin) scope(user);
- try {
- DirectoryUser directoryUser = (DirectoryUser) scopedUserAdmin.getRole(user.getName());
- if (directoryUser == null)
- throw new IllegalStateException("No scoped user found for " + user);
- LdifAuthorization authorization = new LdifAuthorization(directoryUser,
- scopedUserAdmin.getAllRoles(directoryUser));
- return authorization;
- } finally {
- scopedUserAdmin.destroy();
+
+ Subject currentSubject = CurrentSubject.current();
+ if (currentSubject != null //
+ && getRealm().isPresent() //
+ && !currentSubject.getPrivateCredentials(Authorization.class).isEmpty() //
+ && !currentSubject.getPrivateCredentials(KerberosTicket.class).isEmpty()) //
+ {
+ // TODO not only Kerberos but also bind scope with kept password ?
+ Authorization auth = currentSubject.getPrivateCredentials(Authorization.class).iterator().next();
+ // bind with authenticating user
+ DirectoryUserAdmin scopedUserAdmin = Subject.doAs(currentSubject,
+ (PrivilegedAction<DirectoryUserAdmin>) () -> (DirectoryUserAdmin) scope(
+ new AuthenticatingUser(auth.getName(), new Hashtable<>())));
+ return getAuthorizationFromScoped(scopedUserAdmin, user);
}
+
+ if (user instanceof DirectoryUser) {
+ return new LdifAuthorization(user, getAllRoles((DirectoryUser) user));
+ } else {
+ // bind with authenticating user
+ DirectoryUserAdmin scopedUserAdmin = (DirectoryUserAdmin) scope(user);
+ return getAuthorizationFromScoped(scopedUserAdmin, user);
+ }
+ }
+ }
+
+ private Authorization getAuthorizationFromScoped(DirectoryUserAdmin scopedUserAdmin, User user) {
+ try {
+ DirectoryUser directoryUser = (DirectoryUser) scopedUserAdmin.getRole(user.getName());
+ if (directoryUser == null)
+ throw new IllegalStateException("No scoped user found for " + user);
+ LdifAuthorization authorization = new LdifAuthorization(directoryUser,
+ scopedUserAdmin.getAllRoles(directoryUser));
+ return authorization;
+ } finally {
+ scopedUserAdmin.destroy();
}
}
return getRole(name);
} else {
wc.getModifiedData().put(dn, attrs);
- LdapEntry newRole = newRole(dn, type, attrs);
+ LdapEntry newRole = doCreateRole(dn, type, attrs);
wc.getNewData().put(dn, newRole);
return (Role) newRole;
}
}
- protected LdapEntry newRole(LdapName dn, int type, Attributes attrs) {
+ private LdapEntry doCreateRole(LdapName dn, int type, Attributes attrs) {
LdapEntry newRole;
BasicAttribute objClass = new BasicAttribute(objectClass.name());
if (type == Role.USER) {
objClass.add(top.name());
objClass.add(extensibleObject.name());
attrs.put(objClass);
- newRole = newUser(dn, attrs);
+ newRole = newUser(dn);
} else if (type == Role.GROUP) {
String groupObjClass = getGroupObjectClass();
objClass.add(groupObjClass);
// objClass.add(LdifName.extensibleObject.name());
objClass.add(top.name());
attrs.put(objClass);
- newRole = newGroup(dn, attrs);
+ newRole = newGroup(dn);
} else
throw new IllegalArgumentException("Unsupported type " + type);
return newRole;
@Override
public Iterable<? extends Role> getHierarchyUnitRoles(HierarchyUnit hierarchyUnit, String filter, boolean deep) {
- LdapName dn = LdapNameUtils.toLdapName(hierarchyUnit.getContext());
+ LdapName dn = LdapNameUtils.toLdapName(hierarchyUnit.getBase());
try {
return getRoles(dn, filter, deep);
} catch (InvalidSyntaxException e) {
/*
* ROLES CREATION
*/
- protected LdapEntry newUser(LdapName name, Attributes attrs) {
+ protected LdapEntry newUser(LdapName name) {
// TODO support devices, applications, etc.
- return new LdifUser(this, name, attrs);
+ return new LdifUser(this, name);
}
- protected LdapEntry newGroup(LdapName name, Attributes attrs) {
- return new LdifGroup(this, name, attrs);
+ protected LdapEntry newGroup(LdapName name) {
+ return new LdifGroup(this, name);
}
projects / lgpl / argeo-commons.git / blobdiff