JonasSecurityServiceImpl.java

package org.objectweb.jonas.security;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.Reader;
import java.io.StringReader;
import java.security.NoSuchAlgorithmException;

import javax.management.MBeanServer;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;

import org.objectweb.jonas.common.Log;
import org.objectweb.jonas.jmx.JmxService;
import org.objectweb.jonas.jmx.JonasObjectName;
import org.objectweb.jonas.security.lib.wrapper.JResourceManagerWrapper;
import org.objectweb.jonas.security.realm.factory.JResource;
import org.objectweb.jonas.security.realm.factory.JResourceDS;
import org.objectweb.jonas.security.realm.factory.JResourceLDAP;
import org.objectweb.jonas.security.realm.factory.JResourceMemory;
import org.objectweb.jonas.security.realm.lib.HashHelper;
import org.objectweb.jonas.service.AbsServiceImpl;
import org.objectweb.jonas.service.ServiceException;
import org.objectweb.jonas.service.ServiceManager;

import org.objectweb.util.monolog.api.BasicLevel;
import org.objectweb.util.monolog.api.Logger;


public class JonasSecurityServiceImpl extends AbsServiceImpl implements SecurityService, JonasSecurityServiceImplMBean {

    private static Logger logger = null;

    public static final String CLASS = "jonas.service.security.class";

    protected static final String CONFIG_FILE = "conf" + File.separator + "jonas-realm.xml";

    private MBeanServer mbeanServer = null;

    private JResources jResources;

    private Context ictx = null;

    public void doInit(Context ctx) throws ServiceException {
        if (logger == null) {
            logger = Log.getLogger(Log.JONAS_SECURITY_PREFIX);
        }

        // JResources
        jResources = new JResources(this);

        //Get the initial Context
        try {
            ictx = new InitialContext();
        } catch (NamingException e) {
            logger.log(BasicLevel.ERROR, "Cannot create initial context during the mail service initializing");
            throw new ServiceException("Cannot create initial context during the mail service initializing", e);
        }

        // Get the JMX Server via JMX Service
        try {
            mbeanServer = ((JmxService) ServiceManager.getInstance().getJmxService()).getJmxServer();
        } catch (Exception e) {
            // the JMX service may not be started
            mbeanServer = null;
        }

        logger.log(BasicLevel.DEBUG,  "JonasSecurityService initialized");
    }

    public void removeJResource(String resourceName) throws Exception {

        // remove the given resource of the list
        JResource jResource = jResources.remove(resourceName);

        // remove the resource into the jndi
        try {
            ictx.unbind(resourceName);
            logger.log(BasicLevel.DEBUG, "jResource " + resourceName + " remove from the registry.");
        } catch (NamingException e) {
            // nothing
        }

        try {
            // Remove mbeans of the resources
            jResource.removeMBeans();

            // register security factory mbean
            if (jResource instanceof JResourceMemory) {
                mbeanServer.unregisterMBean(JonasObjectName.securityMemoryFactory(resourceName));
            } else if (jResource instanceof JResourceDS) {
                mbeanServer.unregisterMBean(JonasObjectName.securityDatasourceFactory(resourceName));
            } else if (jResource instanceof JResourceLDAP) {
                mbeanServer.unregisterMBean(JonasObjectName.securityLdapFactory(resourceName));
            }
        } catch (ServiceException se) {
            // Jmx Service not available, do nothing
        } catch (Exception e) {
            logger.log(BasicLevel.ERROR, "Can not unregister the MBean for the resource " + resourceName + " : " + e.getMessage());
            throw new ServiceException("Can not unregister the MBean for the resource " + resourceName + " : " + e.getMessage());
        }

    }


    public void doStart() throws ServiceException {
        try {
            // register security service mbean
            mbeanServer.registerMBean(this, JonasObjectName.securityService());
        } catch (ServiceException se) {
            // Jmx Service not available, do nothing
        } catch (Exception e) {
            logger.log(BasicLevel.ERROR, "SecurityService: Cannot start the Security service:\n" + e);
            throw new ServiceException("SecurityService: Cannot start the Security service", e);
        }

        createRealm();
    }


    public void doStop() {

        // Unregister MBean
        try {
            // Unregister Security Service MBean : SecurityServiceImplMBean
            ((JmxService) ServiceManager.getInstance().getJmxService()).getJmxServer().unregisterMBean(JonasObjectName.securityService());
        } catch (ServiceException se) {
            // Jmx Service not available, do nothing
        } catch (Exception e) {
            logger.log(BasicLevel.ERROR, "Cannot stop the security service:\n" + e);
            throw new ServiceException("Cannot stop the security service", e);
        }
    }

    public JResource getJResource(String name) {
        return jResources.getJResource(name);
    }


    private void createRealm() throws ServiceException {

        // Execute the digester for the parsing of the jonas-realm.xml file.
        File configFile = null;
        Reader reader = null;
        try {
            configFile = getConfigFile();
            reader = new FileReader(configFile);
        } catch (FileNotFoundException e) {
            logger.log(BasicLevel.ERROR, "Cannot find config file " + configFile);
            throw new ServiceException(e.getMessage(), e);
        }

        try {
            JResourceManagerWrapper.addResources(jResources, reader, configFile.getPath());
        } catch (Exception e1) {
            String err = "Cannot add security resource from '" + configFile + "'";
            logger.log(BasicLevel.ERROR, err);
            throw new ServiceException(err, e1);
        }
    }

    protected File getConfigFile() throws FileNotFoundException {
        String fileName = System.getProperty("jonas.base");
        fileName = fileName + File.separator + CONFIG_FILE;
        File file = new File(fileName);
        if (!file.exists()) {
            String err = "Can't find configuration file : " + fileName;
            throw new FileNotFoundException(err);
        }
        return (file);
    }

    public String toXML() {
        return jResources.toXML();
    }


    public String encryptPassword(String string, String algo) throws NoSuchAlgorithmException {
        String encrypt = HashHelper.hashPassword(string, algo);
        // Prefix with algorithm
        return "{" + algo.toUpperCase() + "}" + encrypt;
    }


    public boolean isValidAlgorithm(String algo) {
        boolean b = true;
        try {
            encryptPassword("test", algo);
        } catch (NoSuchAlgorithmException nsae) {
            b = false;
        }
        return b;
    }

    public void addResources(String xml) throws Exception {

        try {
            JResourceManagerWrapper.addResources(jResources, new StringReader(xml), "");
        } catch (Exception e1) {
            String err = "Cannot add security resource from xml '" + xml + "'";
            logger.log(BasicLevel.ERROR, err);
            throw new ServiceException(err, e1);
        }
    }


    public void addJResourceMemory(String name) throws Exception {

        // Build a new JResourceMemory
        JResourceMemory jResourceMemory = new JResourceMemory();
        jResourceMemory.setName(name);

        // Build xml
        StringBuffer xml = new StringBuffer(JResources.HEADER_XML);
        xml.append("<jonas-realm>");
        xml.append("<jonas-memoryrealm>");
        xml.append(jResourceMemory.toXML());
        xml.append("</jonas-memoryrealm>");
        xml.append("</jonas-realm>");

        // Add the resource
        addResources(xml.toString());

    }


    public void addJResourceDS(String name,
                               String dsName,
                               String userTable,
                               String userTableUsernameCol,
                               String userTablePasswordCol,
                               String roleTable,
                               String roleTableUsernameCol,
                               String roleTableRolenameCol,
                               String algorithm) throws Exception {

        // Build a new JResourceDS
        JResourceDS jResourceDS = new JResourceDS();
        jResourceDS.setName(name);
        jResourceDS.setDsName(dsName);
        jResourceDS.setUserTable(userTable);
        jResourceDS.setUserTableUsernameCol(userTableUsernameCol);
        jResourceDS.setUserTablePasswordCol(userTablePasswordCol);
        jResourceDS.setRoleTable(roleTable);
        jResourceDS.setRoleTableUsernameCol(roleTableUsernameCol);
        jResourceDS.setRoleTableRolenameCol(roleTableRolenameCol);
        jResourceDS.setAlgorithm(algorithm);

        // Build xml
        StringBuffer xml = new StringBuffer(JResources.HEADER_XML);
        xml.append("<jonas-realm>");
        xml.append("<jonas-dsrealm>");
        xml.append(jResourceDS.toXML());
        xml.append("</jonas-dsrealm>");
        xml.append("</jonas-realm>");

        // Add the resource
        addResources(xml.toString());

    }


    public void addJResourceLDAP(String name,
                                 String initialContextFactory,
                                 String providerUrl,
                                 String securityAuthentication,
                                 String securityPrincipal,
                                 String securityCredentials,
                                 String securityProtocol,
                                 String language,
                                 String referral,
                                 String stateFactories,
                                 String authenticationMode,
                                 String userPasswordAttribute,
                                 String userRolesAttribute,
                                 String roleNameAttribute,
                                 String baseDN,
                                 String userDN,
                                 String userSearchFilter,
                                 String roleDN,
                                 String roleSearchFilter,
                                 String algorithm) throws Exception {

        // Build a new JResourceLDAP
        JResourceLDAP jResourceLDAP = new JResourceLDAP();
        jResourceLDAP.setName(name);
        jResourceLDAP.setInitialContextFactory(initialContextFactory);
        jResourceLDAP.setProviderUrl(providerUrl);
        jResourceLDAP.setSecurityAuthentication(securityAuthentication);
        jResourceLDAP.setSecurityPrincipal(securityPrincipal);
        jResourceLDAP.setSecurityCredentials(securityCredentials);
        jResourceLDAP.setSecurityProtocol(securityProtocol);
        jResourceLDAP.setLanguage(language);
        jResourceLDAP.setReferral(referral);
        jResourceLDAP.setStateFactories(stateFactories);
        jResourceLDAP.setAuthenticationMode(authenticationMode);
        jResourceLDAP.setUserPasswordAttribute(userPasswordAttribute);
        jResourceLDAP.setUserRolesAttribute(userRolesAttribute);
        jResourceLDAP.setRoleNameAttribute(roleNameAttribute);
        jResourceLDAP.setBaseDN(baseDN);
        jResourceLDAP.setUserDN(userDN);
        jResourceLDAP.setUserSearchFilter(userSearchFilter);
        jResourceLDAP.setRoleDN(roleDN);
        jResourceLDAP.setRoleSearchFilter(roleSearchFilter);
        jResourceLDAP.setAlgorithm(algorithm);

        // Build xml
        StringBuffer xml = new StringBuffer(JResources.HEADER_XML);
        xml.append("<jonas-realm>");
        xml.append("<jonas-ldaprealm>");
        xml.append(jResourceLDAP.toXML());
        xml.append("</jonas-ldaprealm>");
        xml.append("</jonas-realm>");

        // Add the resource
        addResources(xml.toString());

    }

    public void bindResource(String name, JResource jResource) {
        // bind the resource into the jndi
        try {
            ictx.rebind(jResource.getName(), jResource);
            logger.log(BasicLevel.DEBUG, "jResource " + jResource.getName() + " bound into the registry.");
        } catch (NamingException e) {
            // nothing
        }

        try {
            // register security factory mbean
            if (jResource instanceof JResourceMemory) {
                mbeanServer.registerMBean(jResource, JonasObjectName.securityMemoryFactory(jResource.getName()));
            } else if (jResource instanceof JResourceDS) {
                mbeanServer.registerMBean(jResource, JonasObjectName.securityDatasourceFactory(jResource.getName()));
            } else if (jResource instanceof JResourceLDAP) {
                mbeanServer.registerMBean(jResource, JonasObjectName.securityLdapFactory(jResource.getName()));
            }
        } catch (ServiceException se) {
            // Jmx Service not available, do nothing
        } catch (Exception e) {
            logger.log(BasicLevel.ERROR, "Can not register the MBean for the resource " + jResource.getName() + " : " + e.getMessage());
            throw new ServiceException("Can not register the MBean for the resource " + jResource.getName() + " : " + e.getMessage());
        }

    }
}

---