Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * JBoss, Home of Professional Open Source.
   * Copyright 2010, Red Hat, Inc., and individual contributors
   * as indicated by the @author tags. See the copyright.txt file in the
   * distribution for a full listing of individual contributors.
   *
   * This is free software; you can redistribute it and/or modify it
   * under the terms of the GNU Lesser General Public License as
   * published by the Free Software Foundation; either version 2.1 of
  * the License, or (at your option) any later version.
  *
  * This software is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this software; if not, write to the Free
  * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
  * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
  */
 
 package org.jboss.as.security;
 
 import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.AUTHENTICATION;
 import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.OP_ADDR;
 import static org.jboss.as.security.Constants.ACL;
 import static org.jboss.as.security.Constants.ACL_MODULE;
 import static org.jboss.as.security.Constants.ADDITIONAL_PROPERTIES;
 import static org.jboss.as.security.Constants.ALGORITHM;
 import static org.jboss.as.security.Constants.AUDIT;
 import static org.jboss.as.security.Constants.AUTHORIZATION;
 import static org.jboss.as.security.Constants.AUTH_MODULE;
 import static org.jboss.as.security.Constants.CACHE_TYPE;
 import static org.jboss.as.security.Constants.CIPHER_SUITES;
 import static org.jboss.as.security.Constants.CLASSIC;
 import static org.jboss.as.security.Constants.CLIENT_ALIAS;
 import static org.jboss.as.security.Constants.CLIENT_AUTH;
 import static org.jboss.as.security.Constants.FLAG;
 import static org.jboss.as.security.Constants.IDENTITY_TRUST;
 import static org.jboss.as.security.Constants.JASPI;
 import static org.jboss.as.security.Constants.JSSE;
 import static org.jboss.as.security.Constants.KEYSTORE;
 import static org.jboss.as.security.Constants.LOGIN_MODULE;
 import static org.jboss.as.security.Constants.LOGIN_MODULE_STACK;
 import static org.jboss.as.security.Constants.LOGIN_MODULE_STACK_REF;
 import static org.jboss.as.security.Constants.MAPPING;
 import static org.jboss.as.security.Constants.MAPPING_MODULE;
 import static org.jboss.as.security.Constants.PASSWORD;
 import static org.jboss.as.security.Constants.POLICY_MODULE;
 import static org.jboss.as.security.Constants.PROTOCOLS;
 import static org.jboss.as.security.Constants.PROVIDER;
 import static org.jboss.as.security.Constants.PROVIDER_ARGUMENT;
 import static org.jboss.as.security.Constants.PROVIDER_MODULE;
 import static org.jboss.as.security.Constants.SERVER_ALIAS;
 import static org.jboss.as.security.Constants.SERVICE_AUTH_TOKEN;
 import static org.jboss.as.security.Constants.TRUST_MODULE;
 import static org.jboss.as.security.Constants.TYPE;
 import static org.jboss.as.security.Constants.URL;
 
 import java.util.List;
 import java.util.Map;
 
Add a security domain configuration.

Author(s):
Marcus Moyses
Brian Stansberry
Jason T. Greene
    private static final String CACHE_CONTAINER_NAME = "security";
    static final SecurityDomainAdd INSTANCE = new SecurityDomainAdd();

    
Private to ensure a singleton.
    private SecurityDomainAdd() {
    }
    protected void populateModel(ModelNode operationModelNode modelthrows OperationFailedException {
    }
    protected void performRuntime(OperationContext contextModelNode operationfinal ModelNode modelfinal ServiceVerificationHandler verificationHandlerfinal List<ServiceController<?>> newControllers) {
        PathAddress address = PathAddress.pathAddress(operation.get());
        final String securityDomain = address.getLastElement().getValue();
        // This needs to run after all child resources so that they can detect a fresh state
        context.addStep(new OperationStepHandler() {
            @Override
            public void execute(OperationContext contextModelNode operationthrows OperationFailedException {
                final Resource resource = context.readResource(.);
                launchServices(contextsecurityDomain, Resource.Tools.readModel(resource), verificationHandlernewControllers);
                // Rollback handled by the parent step
                context.completeStep(..);
            }
        }, ..);
    }
    void launchServices(OperationContext contextString securityDomainModelNode modelthrows OperationFailedException {
        launchServices(contextsecurityDomainmodelnullnull);
    }
    public void launchServices(OperationContext contextString securityDomainModelNode modelServiceVerificationHandler verificationHandlerList<ServiceController<?>> newControllersthrows OperationFailedException {
        final ApplicationPolicy applicationPolicy = createApplicationPolicy(contextsecurityDomainmodel);
        final JSSESecurityDomain jsseSecurityDomain = createJSSESecurityDomain(contextsecurityDomainmodel);
        final String cacheType = getAuthenticationCacheType(model);
        final SecurityDomainService securityDomainService = new SecurityDomainService(securityDomain,
                applicationPolicyjsseSecurityDomaincacheType);
        final ServiceTarget target = context.getServiceTarget();
        // some login modules may require the TransactionManager
        final Injector<TransactionManagertransactionManagerInjector = new Injector<TransactionManager>() {
            public void inject(final TransactionManager valuethrows InjectionException {
                TransactionManagerLocator.setTransactionManager(value);
            }
            public void uninject() {
            }
        };
        ServiceBuilder<SecurityDomainContextbuilder = target
                .addService(..append(securityDomain), securityDomainService)
                        securityDomainService.getSecurityManagementInjector())
                .addDependency(.Configuration.class,
                        securityDomainService.getConfigurationInjector())
                        transactionManagerInjector);
        if ("infinispan".equals(cacheType)) {
            builder.addDependency(EmbeddedCacheManagerService.getServiceName(),
                    EmbeddedCacheManager.classsecurityDomainService.getCacheManagerInjector());
        }
        if (verificationHandler != null) {
            builder.addListener(verificationHandler);
        }
        if (newControllers != null) {
            newControllers.add(controller);
        }
    }
    private ApplicationPolicy createApplicationPolicy(OperationContext contextString securityDomainfinal ModelNode model)
            throws OperationFailedException {
        final ApplicationPolicy applicationPolicy = new ApplicationPolicy(securityDomain);
        boolean create;
        create = processClassicAuth(contextsecurityDomainmodelapplicationPolicy);
        create |= processJASPIAuth(contextsecurityDomainmodelapplicationPolicy);
        create |= processAuthorization(contextsecurityDomainmodelapplicationPolicy);
        create |= processACL(contextsecurityDomainmodelapplicationPolicy);
        create |= processAudit(contextsecurityDomainmodelapplicationPolicy);
        create |= processIdentityTrust(contextsecurityDomainmodelapplicationPolicy);
        create |= processMapping(contextsecurityDomainmodelapplicationPolicy);
        return create ? applicationPolicy : null;
    }
    private boolean processMapping(OperationContext contextString securityDomainModelNode nodeApplicationPolicy applicationPolicy)
            throws OperationFailedException {
        node = peek(node);
        if (node == null) { return false; }
        for (Property moduleProperty : node.asPropertyList()) {
            ModelNode module = moduleProperty.getValue();
            MappingInfo mappingInfo = new MappingInfo(securityDomain);
            String codeName = extractCode(contextmodule.);
            String mappingType;
            if (module.hasDefined()) {
                mappingType = ..resolveModelAttribute(contextmodule).asString();
            } else {
                mappingType = ..toString();
            }
            Map<StringObjectoptions = extractOptions(contextmodule);
            MappingModuleEntry entry = new MappingModuleEntry(codeNameoptionsmappingType);
            mappingInfo.add(entry);
            applicationPolicy.setMappingInfo(mappingTypemappingInfo);
            ModelNode moduleName = ..resolveModelAttribute(contextmodule);
            if (moduleName.isDefined() && moduleName.asString().length() > 0) {
                mappingInfo.setJBossModuleName(moduleName.asString());
            }
        }
        return true;
    }
    private boolean processIdentityTrust(OperationContext contextString securityDomainModelNode nodeApplicationPolicy applicationPolicy)
            throws OperationFailedException {
        node = peek(node);
        if (node == null) { return false; }
        IdentityTrustInfo identityTrustInfo = new IdentityTrustInfo(securityDomain);
        for (Property moduleProperty : node.asPropertyList()) {
            ModelNode module = moduleProperty.getValue();
            String codeName = ..resolveModelAttribute(contextmodule).asString();
            String flag = ..resolveModelAttribute(contextmodule).asString();
            ControlFlag controlFlag = ControlFlag.valueOf(flag);
            Map<StringObjectoptions = extractOptions(contextmodule);
            IdentityTrustModuleEntry entry = new IdentityTrustModuleEntry(codeNameoptions);
            entry.setControlFlag(controlFlag);
            identityTrustInfo.add(entry);
            ModelNode moduleName = ..resolveModelAttribute(contextmodule);
            if (moduleName.isDefined() && moduleName.asString().length() > 0) {
                identityTrustInfo.setJBossModuleName(moduleName.asString());
            }
        }
        applicationPolicy.setIdentityTrustInfo(identityTrustInfo);
        return true;
    }
    private boolean processAudit(OperationContext contextString securityDomainModelNode nodeApplicationPolicy applicationPolicy)
            throws OperationFailedException {
        node = peek(node);
        if (node == null) { return false; }
        AuditInfo auditInfo = new AuditInfo(securityDomain);
        for (Property moduleProperty : node.asPropertyList()) {
            ModelNode module = moduleProperty.getValue();
            String codeName = ..resolveModelAttribute(contextmodule).asString();
            Map<StringObjectoptions = extractOptions(contextmodule);
            AuditProviderEntry entry = new AuditProviderEntry(codeNameoptions);
            auditInfo.add(entry);
            ModelNode moduleName = ..resolveModelAttribute(contextmodule);
            if (moduleName.isDefined() && moduleName.asString().length() > 0) {
                auditInfo.setJBossModuleName(moduleName.asString());
            }
        }
        applicationPolicy.setAuditInfo(auditInfo);
        return true;
    }
    private boolean processACL(OperationContext contextString securityDomainModelNode nodeApplicationPolicy applicationPolicy)
            throws OperationFailedException {
        node = peek(node);
        if (node == null) { return false; }
        ACLInfo aclInfo = new ACLInfo(securityDomain);
        for (Property moduleProperty : node.asPropertyList()) {
            ModelNode module = moduleProperty.getValue();
            String codeName = ..resolveModelAttribute(contextmodule).asString();
            String flag = ..resolveModelAttribute(contextmodule).asString();
            ControlFlag controlFlag = ControlFlag.valueOf(flag);
            Map<StringObjectoptions = extractOptions(contextmodule);
            ACLProviderEntry entry = new ACLProviderEntry(codeNameoptions);
            entry.setControlFlag(controlFlag);
            aclInfo.add(entry);
            ModelNode moduleName = ..resolveModelAttribute(contextmodule);
            if (moduleName.isDefined() && moduleName.asString().length() > 0) {
                aclInfo.setJBossModuleName(moduleName.asString());
            }
        }
        applicationPolicy.setAclInfo(aclInfo);
        return true;
    }
    private boolean processAuthorization(OperationContext contextString securityDomainModelNode nodeApplicationPolicy applicationPolicy)
            throws OperationFailedException {
        node = peek(node);
        if (node == null) { return false; }
        AuthorizationInfo authzInfo = new AuthorizationInfo(securityDomain);
        for (Property moduleProperty : node.asPropertyList()) {
            ModelNode module = moduleProperty.getValue();
            String codeName = extractCode(contextmodule.);
            String flag = ..resolveModelAttribute(contextmodule).asString();
            ControlFlag controlFlag = ControlFlag.valueOf(flag);
            Map<StringObjectoptions = extractOptions(contextmodule);
            AuthorizationModuleEntry authzModuleEntry = new AuthorizationModuleEntry(codeNameoptions);
            authzModuleEntry.setControlFlag(controlFlag);
            authzInfo.add(authzModuleEntry);
            ModelNode moduleName = ..resolveModelAttribute(contextmodule);
            if (moduleName.isDefined() && moduleName.asString().length() > 0) {
                authzInfo.setJBossModuleName(moduleName.asString());
            }
        }
        applicationPolicy.setAuthorizationInfo(authzInfo);
        return true;
    }
    private boolean processJASPIAuth(OperationContext contextString securityDomainModelNode nodeApplicationPolicy applicationPolicy)
            throws OperationFailedException {
        node = peek(node);
        if (node == null) { return false; }
        JASPIAuthenticationInfo authenticationInfo = new JASPIAuthenticationInfo(securityDomain);
        Map<StringLoginModuleStackHolderholders = new HashMap<StringLoginModuleStackHolder>();
        List<Propertystacks = node.get().asPropertyList();
        for (Property stack : stacks) {
            String name = stack.getName();
            ModelNode stackNode = stack.getValue();
            final LoginModuleStackHolder holder = new LoginModuleStackHolder(namenull);
            holders.put(nameholder);
            authenticationInfo.add(holder);
            if (stackNode.hasDefined()) {
                processLoginModules(contextstackNode.get(), authenticationInfonew LoginModuleContainer() {
                    public void addAppConfigurationEntry(AppConfigurationEntry entry) {
                        holder.addAppConfigurationEntry(entry);
                    }
                });
            }
        }
        for (Property moduleProperty : node.get().asPropertyList()) {
            ModelNode authModule = moduleProperty.getValue();
            String code = extractCode(contextauthModule.);
            String loginStackRef = null;
            if (authModule.hasDefined()) {
                loginStackRef = ..resolveModelAttribute(contextauthModule).asString();
            }
            Map<StringObjectoptions = extractOptions(contextauthModule);
            AuthModuleEntry entry = new AuthModuleEntry(codeoptionsloginStackRef);
            if (authModule.hasDefined()) {
                String flag = ..resolveModelAttribute(contextauthModule).asString();
                entry.setControlFlag(ControlFlag.valueOf(flag));
            }
            if (loginStackRef != null) {
                if (!holders.containsKey(loginStackRef)) {
                    throw ..loginModuleStackIllegalArgument(loginStackRef);
                }
                entry.setLoginModuleStackHolder(holders.get(loginStackRef));
            }
            authenticationInfo.add(entry);
            ModelNode moduleName = ..resolveModelAttribute(contextauthModule);
            if (moduleName.isDefined() && moduleName.asString().length() > 0) {
                authenticationInfo.setJBossModuleName(moduleName.asString());
            }
        }
        applicationPolicy.setAuthenticationInfo(authenticationInfo);
        return true;
    }
    private static String extractCode(OperationContext contextModelNode nodeMap<StringStringsubstitutionsthrows OperationFailedException {
        String code = ..resolveModelAttribute(contextnode).asString();
        if (substitutions.containsKey(code)) { code = substitutions.get(code); }
        return code;
    }
    private ModelNode peek(ModelNode nodeString... args) {
        for (String arg : args) {
            if (!node.hasDefined(arg)) { return null; }
            node = node.get(arg);
        }
        return node;
    }
    private boolean processClassicAuth(OperationContext contextString securityDomainModelNode nodeApplicationPolicy applicationPolicy)
            throws OperationFailedException {
        node = peek(node);
        if (node == null) { return false; }
        final AuthenticationInfo authenticationInfo = new AuthenticationInfo(securityDomain);
        if (node.hasDefined(.)) {
            processLoginModules(contextnode.get(), authenticationInfonew LoginModuleContainer() {
                public void addAppConfigurationEntry(AppConfigurationEntry entry) {
                    authenticationInfo.add(entry);
                }
            });
        }
        //Check for module
        applicationPolicy.setAuthenticationInfo(authenticationInfo);
        return true;
    }
    private interface LoginModuleContainer {
        void addAppConfigurationEntry(AppConfigurationEntry entry);
    }
    private void processLoginModules(OperationContext contextModelNode nodeBaseAuthenticationInfo authInfoLoginModuleContainer container)
            throws OperationFailedException {
        for (Property moduleProperty : node.asPropertyList()) {
            ModelNode module = moduleProperty.getValue();
            String codeName = extractCode(contextmodule.);
            String flag = ..resolveModelAttribute(contextmodule).asString();
            LoginModuleControlFlag controlFlag = getControlFlag(flag);
            Map<StringObjectoptions = extractOptions(contextmodule);
            AppConfigurationEntry entry = new AppConfigurationEntry(codeNamecontrolFlagoptions);
            container.addAppConfigurationEntry(entry);
            ModelNode moduleName = ..resolveModelAttribute(contextmodule);
            if (moduleName.isDefined() && moduleName.asString().length() > 0) {
                authInfo.setJBossModuleName(moduleName.asString());
            }
        }
    }
    private Map<StringObjectextractOptions(OperationContext contextModelNode modulethrows OperationFailedException {
        return new LinkedHashMap<StringObject>(..unwrap(contextmodule));
    }
    private JSSESecurityDomain createJSSESecurityDomain(OperationContext contextString securityDomainModelNode node)
            throws OperationFailedException {
        node = peek(node);
        if (node == null) { return null; }
        final JBossJSSESecurityDomain jsseSecurityDomain = new JBossJSSESecurityDomain(securityDomain);
        processKeyStore(contextnodenew KeyStoreConfig() {
            public void setKeyStorePassword(String valuethrows Exception {
                jsseSecurityDomain.setKeyStorePassword(value);
            }
            public void setKeyStoreType(String value) {
                jsseSecurityDomain.setKeyStoreType(value);
            }
            public void setKeyStoreURL(String valuethrows IOException {
                jsseSecurityDomain.setKeyStoreURL(value);
            }
            public void setKeyStoreProvider(String value) {
                jsseSecurityDomain.setKeyStoreProvider(value);
            }
            public void setKeyStoreProviderArgument(String value) {
                jsseSecurityDomain.setKeyStoreProviderArgument(value);
            }
        });
        processKeyStore(contextnode.new KeyStoreConfig() {
            public void setKeyStorePassword(String valuethrows Exception {
                jsseSecurityDomain.setTrustStorePassword(value);
            }
            public void setKeyStoreType(String value) {
                jsseSecurityDomain.setTrustStoreType(value);
            }
            public void setKeyStoreURL(String valuethrows IOException {
                jsseSecurityDomain.setTrustStoreURL(value);
            }
            public void setKeyStoreProvider(String value) {
                jsseSecurityDomain.setTrustStoreProvider(value);
            }
            public void setKeyStoreProviderArgument(String value) {
                jsseSecurityDomain.setTrustStoreProviderArgument(value);
            }
        });
        processKeyManager(contextnode.new KeyManagerConfig() {
            public void setKeyManagerFactoryAlgorithm(String value) {
                jsseSecurityDomain.setKeyManagerFactoryAlgorithm(value);
            }
            public void setKeyManagerFactoryProvider(String value) {
                jsseSecurityDomain.setKeyManagerFactoryProvider(value);
            }
        });
        processKeyManager(contextnode.new KeyManagerConfig() {
            public void setKeyManagerFactoryAlgorithm(String value) {
                jsseSecurityDomain.setTrustManagerFactoryAlgorithm(value);
            }
            public void setKeyManagerFactoryProvider(String value) {
                jsseSecurityDomain.setTrustManagerFactoryProvider(value);
            }
        });
        String value;
        if (node.hasDefined()) {
            value = ..resolveModelAttribute(contextnode).asString();
            jsseSecurityDomain.setClientAlias(value);
        }
        if (node.hasDefined()) {
            value = ..resolveModelAttribute(contextnode).asString();
            jsseSecurityDomain.setServerAlias(value);
        }
        if (node.hasDefined()) {
            boolean clientAuth = ..resolveModelAttribute(contextnode).asBoolean();
            jsseSecurityDomain.setClientAuth(clientAuth);
        }
        if (node.hasDefined()) {
            value = ..resolveModelAttribute(contextnode).asString();
            try {
                jsseSecurityDomain.setServiceAuthToken(value);
            } catch (Exception e) {
                throw ..runtimeException(e);
            }
        }
        if (node.hasDefined()) {
            value = ..resolveModelAttribute(contextnode).asString();
            jsseSecurityDomain.setCipherSuites(value);
        }
        if (node.hasDefined()) {
            value = ..resolveModelAttribute(contextnode).asString();
            jsseSecurityDomain.setProtocols(value);
        }
        if (node.hasDefined()) {
            Properties properties = new Properties();
            properties.putAll(..unwrap(contextnode));
            jsseSecurityDomain.setAdditionalProperties(properties);
        }
        return jsseSecurityDomain;
    }
    private interface KeyStoreConfig {
        void setKeyStorePassword(String valuethrows Exception;
        void setKeyStoreType(String value);
        void setKeyStoreURL(String valuethrows IOException;
        void setKeyStoreProvider(String value);
        void setKeyStoreProviderArgument(String value);
    }
    private void processKeyStore(OperationContext contextModelNode nodeString nameKeyStoreConfig config)
            throws OperationFailedException {
        final ModelNode value = peek(nodename);
        final ModelNode type = peek(nodename);
        final ModelNode url = peek(nodename);
        final ModelNode provider = peek(nodename);
        final ModelNode providerArgument = peek(nodename);
        if (value != null) {
            try {
                config.setKeyStorePassword(context.resolveExpressions(value).asString());
            } catch (Exception e) {
                throw ..runtimeException(e);
            }
        }
        if (type != null) {
            config.setKeyStoreType(context.resolveExpressions(type).asString());
        }
        if (url != null) {
            try {
                config.setKeyStoreURL(context.resolveExpressions(url).asString());
            } catch (Exception e) {
                throw ..runtimeException(e);
            }
        }
        if (provider != null) {
            config.setKeyStoreProvider(context.resolveExpressions(provider).asString());
        }
        if (providerArgument != null) {
            config.setKeyStoreProviderArgument(context.resolveExpressions(providerArgument).asString());
        }
    }
    private interface KeyManagerConfig {
        void setKeyManagerFactoryAlgorithm(String value);
        void setKeyManagerFactoryProvider(String value);
    }
    private void processKeyManager(OperationContext contextModelNode nodeString nameKeyManagerConfig config)
            throws OperationFailedException {
        final ModelNode algorithm = peek(nodename);
        final ModelNode provider = peek(nodename);
        if (algorithm != null) {
            config.setKeyManagerFactoryAlgorithm(context.resolveExpressions(algorithm).asString());
        }
        if (provider != null) {
            config.setKeyManagerFactoryProvider(context.resolveExpressions(provider).asString());
        }
    }
    private LoginModuleControlFlag getControlFlag(String flag) {
        switch (ModuleFlag.valueOf(flag.toUpperCase(.))) {
            case :
                return .;
            case :
                return .;
            case :
                return .;
            case :
            default:
                return .;
        }
    }
        String type = null;
        if (node.hasDefined()) {
            type = node.get().asString();
        }
        return type;
    }
New to GrepCode? Check out our FAQ X