Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * JBoss, Home of Professional Open Source.
   * Copyright 2011, 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.security;
 
 import java.io.File;
 import java.net.URL;
 
 
 import  org.jboss.security.plugins.SecurityKeyManager;

A security domain used to configure SSL.

Author(s):
Marcus Moyses
 
 public class JBossJSSESecurityDomain implements JSSESecurityDomain
 {
 
    private KeyStore keyStore;
 
    
    private KeyManager[] keyManagers;
 
    private String keyStoreType = "JKS";
 
    private URL keyStoreURL;
 
    private char[] keyStorePassword;
 
    private String keyStoreProvider;
    
 
 
 
    private KeyStore trustStore;
 
    
    private TrustManager[] trustManagers;
 
    private String trustStoreType = "JKS";
 
    private URL trustStoreURL;
 
    private char[] trustStorePassword;
 
    private String trustStoreProvider;
    
 
 
 
    private String clientAlias;
    
    private String serverAlias;
 
    private boolean clientAuth;
 
   private char[] serviceAuthToken;
   
   private String[] cipherSuites;
   
   private String[] protocols;
   
   private String name;
   public JBossJSSESecurityDomain(String securityDomainName)
   {
      this. = securityDomainName;
   }
   public String getKeyStoreType()
   {
      return ;
   }
   public void setKeyStoreType(String keyStoreType)
   {
      this. = keyStoreType;
   }
   public String getKeyStoreURL()
   {
      String url = null;
      if ( != null)
         url = .toExternalForm();
      return url;
   }
   public void setKeyStoreURL(String keyStoreURLthrows IOException
   {
      this. = validateStoreURL(keyStoreURL);
   }
   {
      return ;
   }
   public void setKeyStoreProvider(String keyStoreProvider)
   {
      this. = keyStoreProvider;
   }
   {
      return ;
   }
   
   {
      return ;
   }
   public void setKeyStoreProviderArgument(String keyStoreProviderArgument)
   {
      this. = keyStoreProviderArgument;
   }
   public void setKeyManagerFactoryProvider(String keyManagerFactoryProvider)
   {
      this. = keyManagerFactoryProvider;
   }
   {
      return ;
   }
   public void setKeyManagerFactoryAlgorithm(String keyManagerFactoryAlgorithm)
   {
      this. = keyManagerFactoryAlgorithm;
   }
   public String getTrustStoreType()
   {
      return ;
   }
   public void setTrustStoreType(String trustStoreType)
   {
      this. = trustStoreType;
   }
   public String getTrustStoreURL()
   {
      String url = null;
      if ( != null)
         url = .toExternalForm();
      return url;
   }
   public void setTrustStoreURL(String trustStoreURLthrows IOException
   {
      this. = validateStoreURL(trustStoreURL);
   }
   {
      return ;
   }
   public void setTrustStoreProvider(String trustStoreProvider)
   {
      this. = trustStoreProvider;
   }
   
   {
      return ;
   }
   public void setTrustStoreProviderArgument(String trustStoreProviderArgument)
   {
      this. = trustStoreProviderArgument;
   }
   {
      return ;
   }
   public void setTrustManagerFactoryProvider(String trustManagerFactoryProvider)
   {
      this. = trustManagerFactoryProvider;
   }
   {
      return ;
   }
   public void setTrustManagerFactoryAlgorithm(String trustManagerFactoryAlgorithm)
   {
      this. = trustManagerFactoryAlgorithm;
   }
 
   public String getClientAlias()
   {
      return ;
   }
   public void setClientAlias(String clientAlias)
   {
      this. = clientAlias;
   }
 
   public String getServerAlias()
   {
      return ;
   }
   public void setServerAlias(String serverAlias)
   {
      this. = serverAlias;
   }
 
   public boolean isClientAuth()
   {
      return ;
   }
   public void setClientAuth(boolean clientAuth)
   {
      this. = clientAuth;
   }
 
   public KeyStore getKeyStore()
   {
      return ;
   }
 
   public KeyStore getTrustStore()
   {
      return ;
   }
   public void setKeyStorePassword(String keyStorePasswordthrows Exception
   {
      this. = Util.loadPassword(keyStorePassword);
   }
   public void setTrustStorePassword(String trustStorePasswordthrows Exception
   {
      this. = Util.loadPassword(trustStorePassword);
   }
   public void setServiceAuthToken(String serviceAuthTokenthrows Exception
   {
      this. = Util.loadPassword(serviceAuthToken);
   }
   public KeyManager[] getKeyManagers() throws SecurityException
   {
      return ;
   }
   {
      return ;
   }
   public String getSecurityDomain()
   {
      return ;
   }
   public Key getKey(String aliasString serviceAuthTokenthrows Exception
   {
      PicketBoxLogger.LOGGER.traceJSSEDomainGetKey(alias);
      Key key = .getKey(alias);
      if (key == null || key instanceof PublicKey)
      {
         return key;
      }
      verifyServiceAuthToken(serviceAuthToken);
      return key;
   }
   public Certificate getCertificate(String aliasthrows Exception
   {
      PicketBoxLogger.LOGGER.traceJSSEDomainGetCertificate(alias);
      return .getCertificate(alias);
   }
   public void reloadKeyAndTrustStore() throws Exception
   {
   }
   
   public String[] getCipherSuites()
   {
      return ;
   }
   
   public void setCipherSuites(String cipherSuites)
   {
      String[] cs = cipherSuites.split(",");
      this. = cs;
   }
    public String[] getProtocols()
   {
      return ;
   }
   
   public void setProtocols(String protocols)
   {
      String[] p = protocols.split(",");
      this. = p;
   }
 
   {
      return ;
   }
   
   public void setAdditionalProperties(Properties properties)
   {
      this. = properties;
   }
   private URL validateStoreURL(String storeURLthrows IOException
   {
      URL url = null;
      // First see if this is a URL
      try
      {
         url = new URL(storeURL);
      }
      catch (MalformedURLException e)
      {
         // Not a URL or a protocol without a handler
      }
      // Next try to locate this as file path
      if (url == null)
      {
         File tst = new File(storeURL);
         if (tst.exists())
            url = tst.toURI().toURL();
      }
      // Last try to locate this as a classpath resource
      if (url == null)
      {
         ClassLoader loader = SecurityActions.getContextClassLoader();
         if (loader != null)
            url = loader.getResource(storeURL);
      }
      // Fail if no valid key store was located
      if (url == null)
      {
         throw PicketBoxMessages.MESSAGES.failedToValidateURL(storeURL);
      }
      return url;
   }
   private void verifyServiceAuthToken(String serviceAuthTokenthrows SecurityException
   {
      if (this. == null)
      {
         throw PicketBoxMessages.MESSAGES.missingServiceAuthToken(this.getSecurityDomain());
      }
      boolean verificationSuccessful = true;
      char[] ca = serviceAuthToken.toCharArray();
      if (this..length == ca.length)
      {
         for (int i = 0; i < this..lengthi++)
         {
            if (this.[i] != ca[i])
            {
               verificationSuccessful = false;
               break;
            }
         }
         if (verificationSuccessful)
         {
            return;
         }
      }
      throw PicketBoxMessages.MESSAGES.failedToVerifyServiceAuthToken();
   }
   @SuppressWarnings({"rawtypes""unchecked"})
   private void loadKeyAndTrustStore() throws Exception
   {
	  InputStream is = null;
      if ( != null)
      {
         if ( != null)
         {
            if ( != null)
            {
               ClassLoader loader = SecurityActions.getContextClassLoader();
               Class clazz = loader.loadClass();
               Class[] ctorSig = {String.class};
               Constructor ctor = clazz.getConstructor(ctorSig);
               Object[] ctorArgs = {};
               Provider provider = (Providerctor.newInstance(ctorArgs);
                = KeyStore.getInstance(provider);
            }
            else
                = KeyStore.getInstance();
         }
         else
             = KeyStore.getInstance();
         is = null;
         try
         {
        	 if ((!"PKCS11".equalsIgnoreCase() && !"PKCS11IMPLKS".equalsIgnoreCase()))
             {
                 // not a PKCS11 keystore: we need a URL
                 if ( != null)
        		    is = .openStream();
                 else
                     throw PicketBoxMessages.MESSAGES.invalidNullKeyStoreURL();
        	 }
        	 .load(is);
         }
         finally
         {
        	 safeClose(is);
         }
         
         String algorithm = null;
         if ( != null)
            algorithm = ;
         else
            algorithm = KeyManagerFactory.getDefaultAlgorithm();
         if ( != null)
             = KeyManagerFactory.getInstance(algorithm);
         else
             = KeyManagerFactory.getInstance(algorithm);
         for (int i = 0; i < .i++)
         {
            [i] = new SecurityKeyManager((X509KeyManager[i], );
         }
      }
      if ( != null)
      {
         if ( != null)
         {
            if ( != null)
            {
               ClassLoader loader = Thread.currentThread().getContextClassLoader();
               Class clazz = loader.loadClass();
               Class[] ctorSig = {String.class};
               Constructor ctor = clazz.getConstructor(ctorSig);
               Object[] ctorArgs = {};
               Provider provider = (Providerctor.newInstance(ctorArgs);
                = KeyStore.getInstance(provider);
            }
            else
                = KeyStore.getInstance();
         }
         else
             = KeyStore.getInstance();
         is = null;
         try
         {
        	 if ((!"PKCS11".equalsIgnoreCase() && !"PKCS11IMPLKS".equalsIgnoreCase()))
        	 {
                 // not a PKCS11 truststore: we need a URL
                 if ( != null)
        		    is = .openStream();
                 else
                    throw PicketBoxMessages.MESSAGES.invalidNullKeyStoreURL();
        	 }
        	 .load(is);
         }
         finally
         {
        	 safeClose(is);
         }
         String algorithm = null;
         if ( != null)
            algorithm = ;
         else
            algorithm = TrustManagerFactory.getDefaultAlgorithm();
         if ( != null)
             = TrustManagerFactory.getInstance(algorithm);
         else
             = TrustManagerFactory.getInstance(algorithm);
      }
      else if ( != null)
      {
          = ;
         String algorithm = null;
         if ( != null)
            algorithm = ;
         else
            algorithm = TrustManagerFactory.getDefaultAlgorithm();
          = TrustManagerFactory.getInstance(algorithm);
      }
   }
   private void safeClose(InputStream fis)
   {
      try
      {
         if(fis != null)
         {
            fis.close();
         }
      }
      catch(Exception e)
      {}
   }
New to GrepCode? Check out our FAQ X