JResourceMemory.java

package org.objectweb.jonas.security.realm.factory;

import java.security.NoSuchAlgorithmException;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.ArrayList;

import javax.naming.BinaryRefAddr;
import javax.naming.NamingException;
import javax.naming.Reference;
import javax.naming.StringRefAddr;

import org.objectweb.util.monolog.api.BasicLevel;
import org.objectweb.jonas.common.JNDIUtils;
import org.objectweb.jonas.jmx.JonasObjectName;
import org.objectweb.jonas.security.realm.lib.XML;
import org.objectweb.jonas.security.realm.principals.User;
import org.objectweb.jonas.security.realm.principals.Group;
import org.objectweb.jonas.security.realm.principals.Role;
import org.objectweb.jonas.security.realm.lib.HashHelper;

public class JResourceMemory extends JResource implements JResourceMemoryMBean {

    private Hashtable groups = new Hashtable();

    private Hashtable roles = new Hashtable();

    private static final String FACTORY_TYPE = "org.objectweb.jonas.security.realm.factory.JResourceMemory";

    private static final String FACTORY_NAME = "org.objectweb.jonas.security.realm.factory.JResourceMemoryFactory";

    public JResourceMemory() throws Exception {
        super();
    }

    public void addUser(User user) throws Exception {

        if (getUsers().get(user.getName()) != null) {
            throw new Exception("User " + user.getName() + " already exists.");
        }

        // Add group if the group was not present
        String[] userGroups = user.getArrayGroups();
        String groupName = null;
        for (int g = 0; g < userGroups.length; g++) {
            groupName = userGroups[g];
            if (!groups.containsKey(groupName)) {
                addGroup(new Group(groupName));
            }
        }

        // Add role if the role was not present
        String[] userRoles = user.getArrayRoles();
        String roleName = null;
        for (int g = 0; g < userRoles.length; g++) {
            roleName = userRoles[g];
            if (!roles.containsKey(roleName)) {
                addRole(new Role(roleName));
            }
        }

        // Add user
        getUsers().put(user.getName(), user);

        //Add Mbean
        String userName = user.getName();
        try {
            // register security service mbean
            getMBeanServer().registerMBean(user, JonasObjectName.user(getName(), userName));
        } catch (Exception e) {
            getLogger().log(BasicLevel.ERROR, "Cannot register user '" + userName + "' in JMX server : " + e.getMessage());
        }
    }

    public void addGroup(Group group) throws Exception {

        if (groups.get(group.getName()) != null) {
            throw new Exception("Group " + group.getName() + " already exists.");
        }

        // Add role if the role was not present
        String[] groupRoles = group.getArrayRoles();
        String roleName = null;
        for (int g = 0; g < groupRoles.length; g++) {
            roleName = groupRoles[g];
            if (!roles.containsKey(roleName)) {
                addRole(new Role(roleName));
            }
        }

        // Add group
        groups.put(group.getName(), group);

        //Add Mbean
        String groupName = group.getName();
        try {
            // register security service mbean
            getMBeanServer().registerMBean(group, JonasObjectName.group(getName(), groupName));
        } catch (Exception e) {
            getLogger().log(BasicLevel.ERROR, "Cannot register group '" + groupName + "' in JMX server : " + e.getMessage());
        }
    }

    public void addRole(Role role) throws Exception {

        if (roles.get(role.getName()) != null) {
            throw new Exception("Role " + role.getName() + " already exists.");
        }

        // Add role
        roles.put(role.getName(), role);

        //Add Mbean
        String roleName = role.getName();
        try {
            // register security service mbean
            getMBeanServer().registerMBean(role, JonasObjectName.role(getName(), roleName));
        } catch (Exception e) {
            getLogger().log(BasicLevel.ERROR, "Cannot register role '" + roleName + "' in JMX server : " + e.getMessage());
        }
    }

    public User findUser(String name) throws JResourceException {
        if (name == null) {
            return null;
        }
        return ((User) getUsers().get(name));
    }

    public boolean isValidUser(User user, String credentials) {

        boolean validated = false;

        //Get algorithm and hashpassword
        String pass = user.getHashPassword().getPassword();
        String algo = user.getHashPassword().getAlgorithm();

        // Crypt password ?
        if (algo != null) {
            try {
                validated = HashHelper.hashPassword(credentials, algo).equalsIgnoreCase(pass);
            } catch (NoSuchAlgorithmException nsae) {
                getLogger().log(BasicLevel.ERROR, "Can't make a password with the algorithm " + algo + ". "
                        + nsae.getMessage());
            }
        } else {
            // clear
            validated = credentials.equals(pass);
        }
        return validated;
    }

    public Hashtable getGroups() {
        return groups;
    }

    public Hashtable getRoles() {
        return roles;
    }

    public ArrayList getArrayListCombinedRoles(User user) throws JResourceException {
        ArrayList allCombinedRoles = new ArrayList();

        // Return empty array if user null
        if (user == null) {
            return allCombinedRoles;
        }

        // Add all user roles
        String[] userRoles = user.getArrayRoles();
        for (int r = 0; r < userRoles.length; r++) {
            String roleName = userRoles[r];
            if (!allCombinedRoles.contains(roleName)) {
                allCombinedRoles.add(roleName);
            }
        }

        // Add roles of each group
        String[] userGroups = user.getArrayGroups();
        for (int g = 0; g < userGroups.length; g++) {
            String groupName = userGroups[g];

            // For each roles of the given group
            Group group = (Group) groups.get(groupName);
            if (group == null) {
                continue;
            }

            String[] groupRoles = group.getArrayRoles();
            for (int gr = 0; gr < groupRoles.length; gr++) {
                String roleName = groupRoles[gr];
                if (!allCombinedRoles.contains(roleName)) {
                    allCombinedRoles.add(roleName);
                }
            }
        }

        return allCombinedRoles;
    }

    public void setGroups(Hashtable groups) {
        this.groups = groups;
    }

    public void setRoles(Hashtable roles) {
        this.roles = roles;
    }

    public void addUser(String username, String password) throws Exception {
        addUser(new User(username, password));
    }

    public void addGroup(String groupname) throws Exception {
        addGroup(new Group(groupname));
    }

    public void addRole(String rolename) throws Exception {
        addRole(new Role(rolename));
    }

    public void removeUser(String username) throws Exception {
        if (getUsers().get(username) == null) {
            throw new Exception("Can not remove user " + username + ". This user doesn't exist");
        }
        getUsers().remove(username);

        // Remove Mbean
        try {
            // register security service mbean
            getMBeanServer().unregisterMBean(JonasObjectName.user(getName(), username));
        } catch (Exception e) {
            getLogger().log(BasicLevel.ERROR, "Cannot unregister user '" + username + "' in JMX server : " + e.getMessage());
        }

    }

    public void removeGroup(String groupname) throws Exception {
        if (groups.get(groupname) == null) {
            throw new Exception("Can not remove group " + groupname + ". This group doesn't exist");
        }
        groups.remove(groupname);
        // Remove Mbean
        try {
            // register security service mbean
            getMBeanServer().unregisterMBean(JonasObjectName.group(getName(), groupname));
        } catch (Exception e) {
            getLogger().log(BasicLevel.ERROR, "Cannot unregister group '" + groupname + "' in JMX server : "
                    + e.getMessage());
        }
    }

    public void removeRole(String rolename) throws Exception {
        if (roles.get(rolename) == null) {
            throw new Exception("Can not remove role " + rolename + ". This role doesn't exist");
        }
        roles.remove(rolename);

        // Remove Mbean
        try {
            // register security service mbean
            getMBeanServer().unregisterMBean(JonasObjectName.role(getName(), rolename));
        } catch (Exception e) {
            getLogger().log(BasicLevel.ERROR, "Cannot unregister role '" + rolename + "' in JMX server : " + e.getMessage());
        }
    }

    public String toXML() {
        StringBuffer xml = new StringBuffer("    <memoryrealm name=\"");
        xml.append(getName());
        xml.append("\">\n");

        // Roles
        xml.append("      <roles>\n");
        XML.xmlHashtable(xml, getRoles(), "        ");
        xml.append("      </roles>\n");

        // Groups
        xml.append("      <groups>\n");
        XML.xmlHashtable(xml, getGroups(), "        ");
        xml.append("      </groups>\n");

        // Users
        xml.append("      <users>\n");
        XML.xmlHashtable(xml, getUsers(), "        ");
        xml.append("      </users>\n");

        xml.append("    </memoryrealm>");
        return xml.toString();
    }

    public String toString() {
        return this.toXML();
    }

    public Reference getReference() throws NamingException {

        // Build the reference to the factory FACTORY_TYPE
        Reference reference = new Reference(FACTORY_TYPE, FACTORY_NAME, null);

        // Add name
        reference.add(new StringRefAddr("name", getName()));

        // Add users
        byte[] bytes = JNDIUtils.getBytesFromObject(getUsers(), getLogger());
        if (bytes != null) {
            reference.add(new BinaryRefAddr("users", bytes));
        }

        // Add groups
        bytes = JNDIUtils.getBytesFromObject(groups, getLogger());
        if (bytes != null) {
            reference.add(new BinaryRefAddr("groups", bytes));
        }

        // Add roles
        bytes = JNDIUtils.getBytesFromObject(roles, getLogger());
        if (bytes != null) {
            reference.add(new BinaryRefAddr("roles", bytes));
        }

        return reference;

    }

    public String[] listRoles() {
        String[] s = new String[roles.size()];
        int i = 0;
        for (Enumeration e = roles.keys(); e.hasMoreElements(); i++) {
            s[i] = (String) e.nextElement();
        }
        return s;
    }

    public String[] listGroups() {
        String[] s = new String[groups.size()];
        int i = 0;
        for (Enumeration e = groups.keys(); e.hasMoreElements(); i++) {
            s[i] = (String) e.nextElement();
        }
        return s;
    }

    public void removeMBeans() throws JResourceException {

        boolean error = false;
        // Remove users MBeans
        for (Enumeration e = getUsers().elements(); e.hasMoreElements();) {
            User u = (User) e.nextElement();
            try {
                // unregister user mbean
                getMBeanServer().unregisterMBean(JonasObjectName.user(getName(), u.getName()));
            } catch (Exception ex) {
                error = true;
                getLogger().log(BasicLevel.ERROR, "Cannot unregister mbean user '" + u.getName() + "' in JMX server : "
                        + ex.getMessage());
            }
        }

        // Remove roles MBeans
        for (Enumeration e = roles.elements(); e.hasMoreElements();) {
            Role r = (Role) e.nextElement();
            try {
                // unregister role mbean
                getMBeanServer().unregisterMBean(JonasObjectName.role(getName(), r.getName()));
            } catch (Exception ex) {
                error = true;
                getLogger().log(BasicLevel.ERROR, "Cannot unregister mbean role '" + r.getName() + "' in JMX server : "
                        + ex.getMessage());
            }
        }

        // Remove groups MBeans
        for (Enumeration e = groups.elements(); e.hasMoreElements();) {
            Group g = (Group) e.nextElement();
            try {
                // unregister group mbean
                getMBeanServer().unregisterMBean(JonasObjectName.group(getName(), g.getName()));
            } catch (Exception ex) {
                error = true;
                getLogger().log(BasicLevel.ERROR, "Cannot unregister mbean group '" + g.getName() + "' in JMX server : "
                        + ex.getMessage());
            }
        }

        if (error) {
            throw new JResourceException(
                    "There was errors during the remove of the MBeans of this resource. See the traces.");
        }

    }

}

---