/*
   Copyright (C) 2000 - 2007 Grid Systems, S.A.
   
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License, version 2, as
   published by the Free Software Foundation.
   
   This program 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 General Public License for more details.
  
  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  */
  package com.gridsystems.innergrid.api;
  
  import java.io.File;
  import java.io.FileInputStream;
  import java.io.FileNotFoundException;
  import java.io.IOException;
  import java.io.InputStream;
  import java.security.KeyManagementException;
  import java.security.KeyStore;
  import java.security.KeyStoreException;
  import java.security.NoSuchAlgorithmException;
  import java.security.UnrecoverableKeyException;
  import java.security.cert.CertificateException;
  
  import javax.net.ssl.KeyManagerFactory;
  import javax.net.ssl.SSLContext;
  import javax.net.ssl.SSLSocketFactory;
  import javax.net.ssl.TrustManager;
  import javax.net.ssl.TrustManagerFactory;
  
  import com.gridsystems.innergrid.kernel.KernelException;
  
  /**
   * SSLConnectionInfo implementation to accept any certificate from a given keystore file.
   *
   * @author Xmas
   * @author Rodrigo Ruiz
   * @version 2.0
   */
  public class AcceptCertificateOfKeyStore implements SSLConnectionInfo {
  
    /**
     * Path to the Keystore file.
     */
    private File keystorefile;
  
    /**
     * Password to access the Keystore file.
     */
    private String keystorepassword;
  
    /**
     * Constructor.
     *
     * @param kfilepath a string with the path to the Keystore file.
     * @param kpassword a string with the password to access the Keystore file.
     */
    public AcceptCertificateOfKeyStore(String kfilepath, String kpassword) {
      this(new File(kfilepath), kpassword);
    }
  
    /**
     * Constructor.
     *
     * @param kfile     The Keystore file.
     * @param kpassword The password to access the Keystore file.
     */
    public AcceptCertificateOfKeyStore(File kfile, String kpassword) {
      keystorefile = kfile;
      keystorepassword = kpassword;
    }
  
    /**
     * Gets the path to the Keystore file.
     *
     * @return a string with the path to the Keystore file.
     */
    public String getKeystoreFile() {
      return keystorefile.getPath();
    }
  
    /**
     * Gets the path to the Keystore file.
     *
     * @return a string with the path to the Keystore file.
     */
    public File getKeystore() {
      return keystorefile;
    }
  
    /**
     * Gets the password to access the Keystore file.
     *
    * @return a string with the password to access the Keystore file.
    */
   public String getKeystorePassword() {
     return (keystorepassword);
   }
 
   /**
    * Get SSL Socket Factory For use with KeyStore file.
    *
    * @return A SSLSocketFactory to establish connection
    * @throws KernelException If error
    */
   public SSLSocketFactory getSSLSocketFactory() throws KernelException {
 
     File keystoreFile = getKeystore();
     if (!keystoreFile.exists()) {
       // CLT032=Can not read keystore file ({0})
       throw new CKernelException("CLT032", keystoreFile.getPath());
     }
 
     String keystorePass = getKeystorePassword();
     if (keystorePass == null) {
       keystorePass = "changeit";
     }
 
     // You can't use ssl without a server certificate.
     // Create a KeyStore ( to get server certs )
     KeyStore kstore = initKeyStore(keystoreFile, keystorePass);
 
     //  protocol for the SSL ie - TLS, SSL v3 etc.
     final String algorithm = "SunX509";
 
     try {
 
       //  Key manager will extract the server key
       KeyManagerFactory kmf = KeyManagerFactory.getInstance(algorithm);
       kmf.init(kstore, keystorePass.toCharArray());
 
       //  Algorithm used to encode the certificate ie - SunX509
       TrustManagerFactory tmf;
       tmf = TrustManagerFactory.getInstance(algorithm);
       tmf.init(kstore);
 
       //  If client authentication is needed, set up TrustManager
       TrustManager[] tm = null;
       tm = tmf.getTrustManagers();
 
       // Create a SSLContext ( to create the ssl factory )
       // This is the only way to use server sockets with JSSE 1.0.1
       final String protocol = "TLS";
       SSLContext context = SSLContext.getInstance(protocol); // SSL
 
       // initialize context with the key managers
       context.init(kmf.getKeyManagers(), tm, new java.security.SecureRandom());
       return (SSLSocketFactory) context.getSocketFactory();
 
     } catch (NoSuchAlgorithmException e) {
       // CLT031=Certificate verify failed
       throw new CKernelException(e, "CLT031");
     } catch (KeyStoreException e) {
       // CLT031=Certificate verify failed
       throw new CKernelException(e, "CLT031");
     } catch (UnrecoverableKeyException e) {
       // CLT031=Certificate verify failed
       throw new CKernelException(e, "CLT031");
     } catch (KeyManagementException e) {
       // CLT031=Certificate verify failed
       throw new CKernelException(e, "CLT031");
     }
   }
 
   /**
    * Initializes a keystore.
    *
    * @param keystoreFile Path to keystore file
    * @param keyPass Password to access to keystore
    *
    * @return keystore Information of file if KeyStore class format
    * @throws KernelException If error
    */
   private KeyStore initKeyStore(File keystoreFile, String keyPass)
     throws KernelException {
 
     String path = keystoreFile.getAbsolutePath();
     try {
       final String defaultKeystoreType = "JKS";
       KeyStore kstore = KeyStore.getInstance(defaultKeystoreType);
       InputStream istream = new FileInputStream(keystoreFile);
       kstore.load(istream, keyPass.toCharArray());
       return kstore;
     } catch (FileNotFoundException fnfe) {
       fnfe.printStackTrace();
       // CLT032=Can not read keystore file ({0})
       throw new CKernelException(fnfe, "CLT032", path);
     } catch (IOException ioe) {
       ioe.printStackTrace();
       // CLT033=Keystore file is not valid ({0}) or incorrect password
       throw new CKernelException(ioe, "CLT033", path);
     } catch (KeyStoreException e) {
       e.printStackTrace();
       // CLT031=Certificate verify failed
       throw new CKernelException(e, "CLT031");
     } catch (NoSuchAlgorithmException e) {
       e.printStackTrace();
       // CLT031=Certificate verify failed
       throw new CKernelException(e, "CLT031");
     } catch (CertificateException e) {
       e.printStackTrace();
       // CLT031=Certificate verify failed
       throw new CKernelException(e, "CLT031");
     }
   }
 }