// Copyright (C) 2002 IAIK
// https://sic.tech/
//
// Copyright (C) 2003 - 2025 Stiftung Secure Information and 
//                           Communication Technologies SIC
// https://sic.tech/
//
// All rights reserved.
//
// This source is provided for inspection purposes and recompilation only,
// unless specified differently in a contract with IAIK. This source has to
// be kept in strict confidence and must not be disclosed to any third party
// under any circumstances. Redistribution in source and binary forms, with
// or without modification, are <not> permitted in any case!
//
// THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
// OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
// OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
// SUCH DAMAGE.
//
// $Header: /IAIK-CMS/current/src/demo/keystore/SetupCMSKeyStore.java 42    12.02.25 17:58 Dbratko $
// $Revision: 42 $
//

package demo.keystore;

import iaik.asn1.CodingException;
import iaik.asn1.ObjectID;
import iaik.asn1.structures.AlgorithmID;
import iaik.asn1.structures.GeneralName;
import iaik.asn1.structures.GeneralNames;
import iaik.asn1.structures.Name;
import iaik.asn1.structures.PolicyInformation;
import iaik.asn1.structures.PolicyQualifierInfo;
import iaik.cms.SecurityProvider;
import iaik.cms.Utils;
import iaik.pkcs.pkcs1.MGF1ParameterSpec;
import iaik.pkcs.pkcs1.MaskGenerationAlgorithm;
import iaik.pkcs.pkcs1.RSAPssParameterSpec;
import iaik.security.rsa.RSAPssKeyPairGenerator;
import iaik.x509.SimpleChainVerifier;
import iaik.x509.X509Certificate;
import iaik.x509.X509ExtensionException;
import iaik.x509.extensions.AuthorityKeyIdentifier;
import iaik.x509.extensions.BasicConstraints;
import iaik.x509.extensions.CertificatePolicies;
import iaik.x509.extensions.ExtendedKeyUsage;
import iaik.x509.extensions.KeyUsage;
import iaik.x509.extensions.SubjectAltName;
import iaik.x509.extensions.SubjectKeyIdentifier;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.math.BigInteger;
import java.security.InvalidAlgorithmParameterException;
import java.security.InvalidKeyException;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.KeyStore;
import java.security.KeyStoreException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.security.NoSuchProviderException;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.cert.CertificateException;
import java.util.Calendar;
import java.util.GregorianCalendar;
import java.util.Random;

import demo.DemoUtil;


/**
 * Creates a default KeyStore in the current working directory.
 * These keys are used by many demos included in IAIK-JCE.
 * The aliases and the password for accessing the keys and
 * certificates can be found in {@link demo.keystore.CMSKeyStoreConstants CMSKeyStoreConstants}.
 *
 * @see CMSKeyStoreConstants
 */
public class SetupCMSKeyStore implements CMSKeyStoreConstants {

  // the keylength of the CA certificate shall be 1024
  private final static int CA_KEYLENGTH = 2048;

  // the key store to create
  KeyStore key_store;
  // the file where the key store shall be saved
  String keystore_file;
  // takes the existing keys from the KeyStore and only creates new certificates
  boolean create_only_certificates = true;

  // the private keys
  
  // CA keys
  KeyPair ca_dsa = null;
  KeyPair ca_rsa = null;
  KeyPair ca_rsa_pss = null;
  
  // RSA for signing
  KeyPair rsa2048_sign_1 = null;
  KeyPair rsa2048_sign_2 = null;
  KeyPair rsa2048_sign_3 = null;
  // RSA for encrypting
  KeyPair rsa2048_crypt_1 = null;
  KeyPair rsa2048_crypt_2 = null;
  KeyPair rsa2048_crypt_3 = null;
  // RSA-PSS for signing
  KeyPair rsapss2048_sha1_sign = null;
  KeyPair rsapss2048_sha256_sign = null;
  KeyPair rsapss2048_sha384_sign = null;
  KeyPair rsapss2048_sha512_sign = null;

  // DSA signing
  KeyPair dsa1024 = null;
  // DSA with SHA224
  KeyPair dsa2048 = null;
  // DSA with SHA256
  KeyPair dsa3072 = null;
  
  // DH key exchange
  KeyPair esdh2048_1 = null;
  KeyPair esdh2048_2 = null;
  KeyPair ssdh2048_1 = null;
  KeyPair ssdh2048_2 = null;
  
  // TSP Server
  KeyPair tsp_server = null;

  // create RSA keys and certificates
  boolean create_rsa;
  // create RSA-PSS key and certificates
  boolean create_rsa_pss;
  // create DSA keys and certificates
  boolean create_dsa;
  // create DSA SHA-2 keys and certificates
  boolean create_dsa_sha2;
  // create ESDH keys and certificates
  boolean create_esdh;
  // create SSDH keys and certificates
  boolean create_ssdh;
  // create TSP server key and certificate
  boolean create_tspserver;

  /**
   * The KeyStore file name.
   */
  String ks_filename = KS_FILENAME;
  
  
  /**
   * Default Constructor.
   */
  public SetupCMSKeyStore() {
    this(KS_FILENAME);
  } 
  
  /**
   * Creates a SetupCMSKeyStore for the given keystore filename.
   * 
   * @param ksFileName the KeyStore filename
   */
  public SetupCMSKeyStore(String ksFileName) {
    ks_filename = ksFileName;
    create_rsa = true;
    create_rsa_pss = true;
    create_dsa = true;
    create_dsa_sha2 = ((create_dsa) && (Utils.getIaikProviderVersion() >= 3.18));
    create_esdh = create_ssdh = Utils.isClassAvailable("iaik.security.dh.ESDHPublicKey");
    create_tspserver = true;

  } 

  /**
   * Generate a KeyPair using the specified algorithm with the given size.
   *
   * @param algorithm the algorithm to use
   * @param bits the length of the key (modulus) in bits
   * @return the KeyPair
   */
  private static KeyPair generateKeyPair(String algorithm, int bits) 
        throws NoSuchAlgorithmException {

        KeyPairGenerator generator = null;
    try {
          generator = KeyPairGenerator.getInstance(algorithm, "IAIK"); 
        } catch (NoSuchProviderException ex) {
          throw new NoSuchAlgorithmException("Provider IAIK not found!");
        }
        generator.initialize(bits);
        KeyPair kp = generator.generateKeyPair();
        return kp;
  }
  
  /**
   * Generates a RSASSA-PSS KeyPair.
   * 
   * @param int keyLength the key length
   * @param hashAlgID the hash algorithm id (for the RSA-PSS params)
   * @param saltLength the salt length to be used
   * 
   * @return the key pair 
   */
  private static KeyPair generateRSAPssKeyPair(int keyLength, 
    AlgorithmID hashAlgID, int saltLength) throws NoSuchAlgorithmException {
    KeyPair kp = null;

    
      KeyPairGenerator keyGen = null;
      try {
        keyGen = KeyPairGenerator.getInstance("RSASSA-PSS", "IAIK");
      } catch (NoSuchProviderException e) {
        throw new NoSuchAlgorithmException(e.toString());
      }

      // initialization with parameters for demonstration purposes (cast required)
      RSAPssKeyPairGenerator rsaPsskeyGen = (RSAPssKeyPairGenerator) keyGen;

      RSAPssParameterSpec pssParamSpec = null;
      if (hashAlgID != null) {
        // create PSS parameters for specifying hash, mgf algorithms and salt length:
        // hash and mgf algorithm ids
        AlgorithmID hashID = (AlgorithmID) hashAlgID.clone();
        AlgorithmID mgfID = (AlgorithmID) AlgorithmID.mgf1.clone();
        mgfID.setParameter(hashID.toASN1Object());
        // hash and mgf engines
        MessageDigest hashEngine = hashID.getMessageDigestInstance();
        MaskGenerationAlgorithm mgfEngine = mgfID.getMaskGenerationAlgorithmInstance();
        MGF1ParameterSpec mgf1ParamSpec = new MGF1ParameterSpec(hashID);
        mgf1ParamSpec.setHashEngine(hashEngine);
        try {
          mgfEngine.setParameters(mgf1ParamSpec);
        } catch (InvalidAlgorithmParameterException e) {
          throw new NoSuchAlgorithmException(e.toString());
        }
        // create the RSAPssParameterSpec
        pssParamSpec = new RSAPssParameterSpec(hashID, mgfID,
            saltLength);
        // set engines
        pssParamSpec.setHashEngine(hashEngine);
        pssParamSpec.setMGFEngine(mgfEngine);
      }   
      // initialize key pair generator
      if (pssParamSpec != null) {
        rsaPsskeyGen.initialize(keyLength, pssParamSpec);
      } else {
        rsaPsskeyGen.initialize(keyLength);
      }
      kp = rsaPsskeyGen.generateKeyPair();
   
    return kp;
  }
  
  /**
   * Creates a certificate from the given values.
   *
   * @param subject the subject of the certificate
   * @param publicKey the public key to include
   * @param issuer the issuer of the certificate
   * @param privateKey the private key for signing the certificate
   * @param algorithm the signature algorithm to use
   * @param keyID the key id for the AuthotityKeyIdentifier extension
   * @param forSigning if the certificate to be created shall be used for signing or encryption
   * @param tspServer whether to create a TSP server certificate
   *
   * @return the certificate just created
   */
  private static X509Certificate createCertificate(Name subject, PublicKey publicKey, 
      Name issuer, PrivateKey privateKey, AlgorithmID algorithm, byte[] keyID, 
      boolean forSigning, boolean tspServer) {

    // create a new certificate
    X509Certificate cert = new X509Certificate();

    try {
      // set the values
      cert.setSerialNumber(new BigInteger(20, new Random()));
      cert.setSubjectDN(subject);
      cert.setPublicKey(publicKey);
      cert.setIssuerDN(issuer);

      GregorianCalendar date = new GregorianCalendar();
      // not before now
      cert.setValidNotBefore(date.getTime());

      if (issuer.equals(subject)) {
        // CA certificate
        date.add(Calendar.YEAR, 10); 
        BasicConstraints basicConstraints = new BasicConstraints(true);
        cert.addExtension(basicConstraints);
        KeyUsage keyUsage = new KeyUsage(KeyUsage.keyCertSign | KeyUsage.cRLSign);
        cert.addExtension(keyUsage);
      } else { 
        date.add(Calendar.YEAR, 9);
        KeyUsage keyUsage = null;
        if (forSigning) {
          keyUsage = new KeyUsage(KeyUsage.digitalSignature |
                                  KeyUsage.nonRepudiation);
          if (tspServer) {
            // certificate for time stamp server
            ExtendedKeyUsage extKeyUsage = new ExtendedKeyUsage(ExtendedKeyUsage.timeStamping);
            extKeyUsage.setCritical(true);
            cert.addExtension(extKeyUsage);
          }
        } else {                  
          if (publicKey.getAlgorithm().toUpperCase().endsWith("DH")) {
            keyUsage = new KeyUsage(KeyUsage.keyAgreement) ; 
          } else { 
            keyUsage = new KeyUsage(KeyUsage.keyEncipherment |
                                    KeyUsage.dataEncipherment);
          }                          
        }                          
        cert.addExtension(keyUsage);
        AuthorityKeyIdentifier authID = new AuthorityKeyIdentifier();
        authID.setKeyIdentifier(keyID);
        cert.addExtension(authID);
        GeneralNames generalNames = new GeneralNames();
        generalNames.addName(new GeneralName(GeneralName.rfc822Name, "smimetest@iaik.tugraz.at"));
        SubjectAltName subjectAltName = new SubjectAltName(generalNames);
        cert.addExtension(subjectAltName);
      }
      String explicitText = "This certificate may be used for testing purposes only";
      PolicyQualifierInfo policyQualifier = new PolicyQualifierInfo(null, null, explicitText);
      PolicyInformation[] policyInformations = 
        { new PolicyInformation(new ObjectID("1.3.6.1.4.1.2706.2.2.4.1.1.1.1"),
                              new PolicyQualifierInfo[] { policyQualifier }) };
      CertificatePolicies certPolicies = new CertificatePolicies(policyInformations);                        
      
      SubjectKeyIdentifier subjectKeyID = new SubjectKeyIdentifier(cert.getPublicKey());
      cert.addExtension(subjectKeyID);
        
      cert.addExtension(certPolicies);                              
      cert.setValidNotAfter(date.getTime());
      // and sign the certificate
      cert.sign(algorithm ,privateKey);
    } catch (CertificateException ex) {
      throw new RuntimeException("Error creating the certificate: "+ex.getMessage());
    } catch (InvalidKeyException ex) {
      throw new RuntimeException("Error creating the certificate: "+ex.getMessage());
    } catch (NoSuchAlgorithmException ex) {
      throw new RuntimeException("Error creating the certificate: "+ex.getMessage());
    } catch (X509ExtensionException ex) {
      throw new RuntimeException("Error adding extension: "+ex.getMessage());   
    } catch (CodingException ex) {
      throw new RuntimeException("Error adding SubjectKeyIdentifier extension: "+ex.getMessage());   
    }     
    return cert;
  }

  /**
   * Load or create a KeyStore and initialize it.
   */
  private void initializeKeyStore() {
 
    BufferedReader reader = null;
    if (!DemoUtil.CREATE_DEMO_KEYSTORE_AUTOMATICAllY) {
      reader = new BufferedReader(new InputStreamReader(System.in));
    }
    String line;

    try {
      // default directory is the current user dir
      String keystore_dir = System.getProperty("user.dir");
      File ks = new File(keystore_dir, ks_filename);

      // KeyStore does already exist
      if (ks.exists()) {
        keystore_file = ks.getAbsolutePath();
        if (create_only_certificates) {
          System.out.println("Create only new certificates from already existing keys!");
        }
        else {
          System.out.println("Existing KeyStore will be deleted!");
        }
        System.out.println("KeyStore: "+keystore_file);
      }
      else {
        // there is no KeyStore -> create also new keys
        create_only_certificates = false;
        
        if (!DemoUtil.CREATE_DEMO_KEYSTORE_AUTOMATICAllY) {
          while (true) {
            System.out.print("Create new KeyStore in directory: "+keystore_dir+" [y]");
            line = readLine(reader);
            if (line.length() == 0 || line.equals("y")) {
              ks = new File(keystore_dir, ks_filename);
              keystore_file = ks.getAbsolutePath();
              System.out.println("KeyStore will be saved to: "+keystore_file);
              break;
            }
            System.out.print("Enter directory: ");
            keystore_dir = reader.readLine();
          }
        } else {
          System.out.print("Create new KeyStore in directory: "+keystore_dir+" ...");
          ks = new File(keystore_dir, ks_filename);
          keystore_file = ks.getAbsolutePath();
          System.out.println("KeyStore will be saved to: "+keystore_file);
        }
      }
      
      // get a new KeyStore object
      key_store = SecurityProvider.getSecurityProvider().getKeyStore("IAIKKeyStore");
      
      if (create_only_certificates) {
        // take private keys from existing KeyStore
        FileInputStream fis = null;
        try {
          fis = new FileInputStream(ks); 
          key_store.load(fis, KS_PASSWORD);
        } finally {
          if (fis != null) {
            try {
              fis.close();
            } catch (IOException ex) {
              // ignore
            }
          }
        }
      }
      else {
        // create a new KeyStore
        key_store.load(null, null);
      }
      
    } catch (Exception ex) {
      System.out.println("Error creating new IAIK KeyStore!");
      throw new RuntimeException("Error creating new KeyStore: "+ex.getMessage());
    }
  }

  /**
   * Save the KeyStore to disk.
   */
  private void saveKeyStore() {
    FileOutputStream os = null;
    try {
      // write the KeyStore to disk
      os = new FileOutputStream(keystore_file);
      key_store.store(os, KS_PASSWORD);

    } catch (Exception ex) {
      System.out.println("Error saving KeyStore!");
      ex.printStackTrace();
    } finally {
      if (os != null) {
        try {
          os.close();
        } catch (IOException ex) {
          // ignore
        }
      }
    }
  }

  /**
   * Adds the private key and the certificate chain to the key store.
   *
   * @param keyPair the key pair with the private key to be added
   * @param chain the certificate chain to be added
   * @param alias the alias for the keystore entry
   *
   * @throws KeyStoreException if an error occurs when trying to add the key
   */
  public void addToKeyStore(KeyPair keyPair, X509Certificate[] chain, String alias) throws KeyStoreException {
    key_store.setKeyEntry(alias, keyPair.getPrivate(), KS_PASSWORD, chain);
  }
  
  /**
   * Returns a KeyPair form the KeyStore.
   *
   * @return the KeyPair of the given type
   *
   * @throws Exception if some error occurs
   */
  private KeyPair getKeyPair(String type) throws Exception {
    KeyPair kp = null;
    PrivateKey privKey = (PrivateKey)key_store.getKey(type, KS_PASSWORD);
    if (privKey != null) {
      PublicKey pubKey = key_store.getCertificateChain(type)[0].getPublicKey();
      kp = new KeyPair(pubKey, privKey);
    }
    return kp;
  }

  /**
   * Get all private keys from the KeyStore.
   */
  private void getPrivateKeys() {
    // RSA    
    try {
      ca_rsa = getKeyPair(CA_RSA);
      // for signing
      rsa2048_sign_1 = getKeyPair(RSA_2048_SIGN_1);
      rsa2048_sign_2 = getKeyPair(RSA_2048_SIGN_2);
      rsa2048_sign_3 = getKeyPair(RSA_2048_SIGN_3);
      // for encrypting
      rsa2048_crypt_1 = getKeyPair(RSA_2048_CRYPT_1);
      rsa2048_crypt_2 = getKeyPair(RSA_2048_CRYPT_2);
      rsa2048_crypt_3 = getKeyPair(RSA_2048_CRYPT_3);
    } catch (Exception ex) {
      System.out.println("Unable to get RSA keys from KeyStore: " + ex.toString());
      create_rsa = false;
    }
    // DSA
    try {
      ca_dsa = getKeyPair(CA_DSA);
      dsa1024 = getKeyPair(DSA_1024);
    } catch (Exception ex) {
      System.out.println("Unable to get DSA keys from KeyStore: " + ex.toString());
      create_dsa = false;
    }
    // DSA with SHA-2
    try {
      dsa2048 = getKeyPair(DSA_2048);
      dsa3072 = getKeyPair(DSA_3072);
    } catch (Exception ex) {
      System.out.println("Unable to get DSA SHA-2 keys from KeyStore: " + ex.toString());
      create_dsa_sha2 = false;
    }
    // ESDH
    try {
      esdh2048_1 = getKeyPair(ESDH_2048_1);
      esdh2048_2 = getKeyPair(ESDH_2048_2);
    } catch (Exception ex) {
      System.out.println("Unable to get ESDH keys from KeyStore: " + ex.toString());
      create_esdh = false;
    }
    // SSDH
    try {
      ssdh2048_1 = getKeyPair(SSDH_2048_1);
      ssdh2048_2 = getKeyPair(SSDH_2048_2);
    } catch (Exception ex) {
      System.out.println("Unable to get SSDH keys from KeyStore: " + ex.toString());
      create_ssdh = false;
    }
    // TSP server
    try {
      tsp_server = getKeyPair(TSP_SERVER);
    } catch (Exception ex) {
      System.out.println("Unable to get TSP server key from KeyStore: " + ex.toString());
      create_tspserver = false;
    }
    
    // RSA-PSS    
    try {
      ca_rsa_pss = getKeyPair(CA_RSAPSS);
      // for signing
      rsapss2048_sha1_sign = getKeyPair(RSAPSS_2048_SHA1_SIGN);
      rsapss2048_sha256_sign = getKeyPair(RSAPSS_2048_SHA256_SIGN);
      rsapss2048_sha384_sign = getKeyPair(RSAPSS_2048_SHA384_SIGN);
      rsapss2048_sha512_sign = getKeyPair(RSAPSS_2048_SHA512_SIGN);
    } catch (Exception ex) {
      System.out.println("Unable to get RSA-PSS keys from KeyStore: " + ex.toString());
      create_rsa_pss = false;
    }
    
  }

  /**
   * Generates new prviate keys.
   */
  private void generatePrivateKeys() {
    try {
          // first create the KeyPairs
          if (create_rsa) {
            try {
          System.out.println("generate RSA KeyPair for CA certificate ["+CA_KEYLENGTH+" bits]...");
              ca_rsa = generateKeyPair("RSA", CA_KEYLENGTH);
          System.out.println("Generate RSA signing keys...");
          System.out.println("generate RSA KeyPair for a test certificate [2048 bits]...");
          rsa2048_sign_1 = generateKeyPair("RSA", 2048);
          System.out.println("generate second RSA KeyPair for a test certificate [2048 bits]...");
          rsa2048_sign_2 = generateKeyPair("RSA", 2048);
          System.out.println("generate third RSA KeyPair for a test certificate [2048 bits]...");
          rsa2048_sign_3 = generateKeyPair("RSA", 2048);
          System.out.println("Generate RSA encryption keys...");
          System.out.println("generate RSA KeyPair for a test certificate [2048 bits]...");
          rsa2048_crypt_1 = generateKeyPair("RSA", 2048); 
          System.out.println("generate second RSA KeyPair for a test certificate [2048 bits]...");
          rsa2048_crypt_2 = generateKeyPair("RSA", 2048); 
          System.out.println("generate third RSA KeyPair for a test certificate [2048 bits]...");
          rsa2048_crypt_3 = generateKeyPair("RSA", 2048); 
          
            } catch (NoSuchAlgorithmException ex) {
          create_rsa = false;
          System.out.println("No implementation for RSA! RSA certificates are not created!\n");
            }
          }
          
      if (create_rsa_pss) {
        try {
          System.out.println("generate RSA-PSS KeyPair for CA certificate 2048 bits]...");
          ca_rsa_pss = generateRSAPssKeyPair(2048, AlgorithmID.sha256, 32);
          System.out.println("Generate RSA-PSS signing keys...");
          System.out.println("generate RSA-PSS KeyPair for a test certificate [2048 bits, SHA-1]...");
          rsapss2048_sha1_sign = generateRSAPssKeyPair(2048, AlgorithmID.sha1, 32);
          System.out.println("generate RSA-PSS KeyPair for a test certificate [2048 bits, SHA-256]...");
          rsapss2048_sha256_sign = generateRSAPssKeyPair(2048, AlgorithmID.sha256, 32);
          System.out.println("generate RSA-PSS KeyPair for a test certificate [2048 bits, SHA-384]...");
          rsapss2048_sha384_sign = generateRSAPssKeyPair(2048, AlgorithmID.sha384, 48);
          System.out.println("generate RSA-PSS KeyPair for a test certificate [2048 bits, SHA-512]...");
          rsapss2048_sha512_sign = generateRSAPssKeyPair(2048,  AlgorithmID.sha512, 64);
          
        } catch (NoSuchAlgorithmException ex) {
          create_rsa_pss = false;
          System.out.println("No implementation for RSA! RSA certificates are not created!\n");
        }
      }
      
      if (create_dsa) {
            try {
          System.out.println("generate DSA KeyPair for CA certificate [3072 bits]...");
              ca_dsa = generateKeyPair("SHA256withDSA", 3072);
              System.out.println("generate DSA KeyPair for a test certificate [1024 bits]...");
          dsa1024 = generateKeyPair("DSA", 1024);
            } catch (NoSuchAlgorithmException ex) {
          create_dsa = false;
          System.out.println("No implementation for DSA! DSA certificates are not created!\n");
            }
      }
      
      if (create_dsa_sha2) {
        try {
          System.out.println("generate DSA SHA-224 KeyPair for a test certificate [2048 bits]...");
          dsa2048 = generateKeyPair("SHA224withDSA", 2048);
          System.out.println("generate DSA SHA-256 KeyPair for a test certificate [3072 bits]...");
          dsa3072 = generateKeyPair("SHA256withDSA", 3072);
        } catch (NoSuchAlgorithmException ex) {
          create_dsa = false;
          System.out.println("No implementation for SHA2-DSA! SHA2-DSA certificates are not created!\n");
        }
      }
      
      if (create_esdh) {
        try {
          System.out.println("generate ESDH KeyPair for a test certificate [2048 bits]...");
          esdh2048_1 = generateKeyPair("ESDH", 2048);
          System.out.println("generate second ESDH KeyPair for a test certificate [2048 bits]...");
          esdh2048_2 = generateKeyPair("ESDH", 2048);
            } catch (NoSuchAlgorithmException ex) {
          create_esdh = false;
          System.out.println("No implementation for ESDH! ESDH certificates are not created!\n");
            }
          }  
          
          if (create_ssdh) {
        try {
          System.out.println("generate SSDH KeyPair for a test certificate [2048 bits]...");
          // key alg id the same as ESDH
          ssdh2048_1 = generateKeyPair("ESDH", 2048);
          System.out.println("generate second SSDH KeyPair for a test certificate [2048 bits]...");
          ssdh2048_2 = generateKeyPair("ESDH", 2048);
        } catch (NoSuchAlgorithmException ex) {
          create_ssdh = false;
          System.out.println("No implementation for SSDH! SSDH certificates are not created!\n");
            }
          }
      
      if (create_tspserver) {
        try {
          System.out.println("generate RSA KeyPair for a tsp server test certificate [2048 bits]...");
          tsp_server = generateKeyPair("RSA", 2048);
        } catch (NoSuchAlgorithmException ex) {
          create_tspserver = false;
          System.out.println("No implementation for RSA! TSP server certificate not created!\n");
        }
      }
      
                  
    } catch (Exception ex) {
      System.out.println("Exception: "+ex);
    }
  }
  
  /**
   * Generates the certificates.
   */
  public void generateCertificates() {

    try {

      // Now create the certificates
      Name issuer = new Name();
      issuer.addRDN(ObjectID.country, "AT");
      issuer.addRDN(ObjectID.organization ,"IAIK");
      issuer.addRDN(ObjectID.organizationalUnit ,"JavaSecurity");

      Name subject = new Name();
      subject.addRDN(ObjectID.country, "AT");
      subject.addRDN(ObjectID.organization ,"IAIK");
      subject.addRDN(ObjectID.organizationalUnit ,"JavaSecurity");
      
      AlgorithmID rsaPssSigningAlg = DemoUtil.createPssAlgorithmID(AlgorithmID.sha256, AlgorithmID.mgf1, 32);

      //
      // create self signed CA certs
      //
      X509Certificate caRSA = null;
      X509Certificate caRSAPSS = null;
      X509Certificate caDSA = null;
      X509Certificate[] chain = new X509Certificate[1];
      // for verifying the created certificates
      SimpleChainVerifier verifier = new SimpleChainVerifier();

      if (create_rsa) {
        issuer.addRDN(ObjectID.commonName ,"IAIK RSA Test CA");
        System.out.println("create self signed RSA CA certificate...");
        caRSA = createCertificate(issuer, 
                                  ca_rsa.getPublic(),
                                  issuer,
                                  ca_rsa.getPrivate(),
                                  (AlgorithmID)AlgorithmID.sha256WithRSAEncryption.clone(),
                                  null,
                                  true,
                                  false);
        // verify the self signed certificate
        caRSA.verify();
        // set the CA cert as trusted root
        verifier.addTrustedCertificate(caRSA);
        chain[0] = caRSA;
        addToKeyStore(ca_rsa, chain, CA_RSA);
        issuer.removeRDN(ObjectID.commonName);
      }
      
      if (create_rsa_pss) {
        issuer.addRDN(ObjectID.commonName ,"IAIK RSA-PSS Test CA");
        System.out.println("create self signed RSA-PSS CA certificate...");
        caRSAPSS = createCertificate(issuer, 
                                  ca_rsa_pss.getPublic(),
                                  issuer,
                                  ca_rsa_pss.getPrivate(),
                                  (AlgorithmID)rsaPssSigningAlg.clone(),
                                  null,
                                  true,
                                  false);
        // verify the self signed certificate
        caRSAPSS.verify();
        // set the CA cert as trusted root
        verifier.addTrustedCertificate(caRSAPSS);
        chain[0] = caRSAPSS;
        addToKeyStore(ca_rsa_pss, chain, CA_RSAPSS);
        issuer.removeRDN(ObjectID.commonName);
      }

      if (create_dsa) {
        issuer.addRDN(ObjectID.commonName ,"IAIK DSA Test CA");
        System.out.println("create self signed DSA CA certificate...");
        caDSA = createCertificate(issuer, 
                                  ca_dsa.getPublic(),
                                  issuer,
                                  ca_dsa.getPrivate(),
                                  (AlgorithmID)AlgorithmID.dsaWithSHA256.clone(),
                                  null,
                                  true,
                                  false);
        // verify the self signed certificate
        caDSA.verify();
        // set the CA cert as trusted root
        verifier.addTrustedCertificate(caDSA);
        chain[0] = caDSA;
        addToKeyStore(ca_dsa, chain, CA_DSA);
        issuer.removeRDN(ObjectID.commonName);
      }

      //
      // create certificates
      //
      chain = new X509Certificate[2];
            
      // create a RSA certificate
      if (create_rsa) {
        issuer.addRDN(ObjectID.commonName ,"IAIK RSA Test CA");
        SubjectKeyIdentifier subjectKeyID = (SubjectKeyIdentifier)caRSA.getExtension(SubjectKeyIdentifier.oid);
        subject.removeRDN(ObjectID.commonName);
        
        // 2048
        subject.addRDN(ObjectID.commonName ,"RSA 2048 bit Demo Signing Certificate 1");
        System.out.println("create 2048 bit RSA demo certificate...");
        chain[0] = createCertificate(subject,
                                     rsa2048_sign_1.getPublic(),
                                     issuer, 
                                     ca_rsa.getPrivate(),
                                     (AlgorithmID)AlgorithmID.sha256WithRSAEncryption.clone(),
                                     subjectKeyID.get(),
                                     true,
                                     false);
        chain[1] = caRSA;
        verifier.verifyChain(chain);
       
        addToKeyStore(rsa2048_sign_1, chain, RSA_2048_SIGN_1);
        subject.removeRDN(ObjectID.commonName);
        
        subject.addRDN(ObjectID.commonName ,"RSA 2048 bit Demo Signing Certificate 2");
        System.out.println("create second 2048 bit RSA demo certificate...");
        chain[0] = createCertificate(subject,
                                     rsa2048_sign_2.getPublic(),
                                     issuer, 
                                     ca_rsa.getPrivate(),
                                     (AlgorithmID)AlgorithmID.sha256WithRSAEncryption.clone(),
                                     subjectKeyID.get(),
                                     true,
                                     false);
        chain[1] = caRSA;
        verifier.verifyChain(chain);
       
        addToKeyStore(rsa2048_sign_2, chain, RSA_2048_SIGN_2);
        subject.removeRDN(ObjectID.commonName);
        
        subject.addRDN(ObjectID.commonName ,"RSA 2048 bit Demo Signing Certificate 3");
        System.out.println("create third 2048 bit RSA demo certificate...");
        chain[0] = createCertificate(subject,
                                     rsa2048_sign_3.getPublic(),
                                     issuer, 
                                     ca_rsa.getPrivate(),
                                     (AlgorithmID)AlgorithmID.sha256WithRSAEncryption.clone(),
                                     subjectKeyID.get(),
                                     true,
                                     false);
        chain[1] = caRSA;
        verifier.verifyChain(chain);
       
        addToKeyStore(rsa2048_sign_3, chain, RSA_2048_SIGN_3);
        subject.removeRDN(ObjectID.commonName);
      
        // for encrypting
        System.out.println("Create RSA demo certificates to be used for encryption...");
 
        // 2048
       
        subject.addRDN(ObjectID.commonName ,"RSA 2048 bit Demo Encryption Certificate 1");
        System.out.println("create 2048 bit RSA demo encryption certificate...");
        chain[0] = createCertificate(subject, 
                                     rsa2048_crypt_1.getPublic(),
                                     issuer,
                                     ca_rsa.getPrivate(),
                                     (AlgorithmID)AlgorithmID.sha256WithRSAEncryption.clone(),
                                     subjectKeyID.get(),
                                     false,
                                     false);
        chain[1] = caRSA;
        verifier.verifyChain(chain);
        addToKeyStore(rsa2048_crypt_1, chain, RSA_2048_CRYPT_1);
        subject.removeRDN(ObjectID.commonName); 
        
        subject.addRDN(ObjectID.commonName ,"RSA 2048 bit Demo Encryption Certificate 2");
        System.out.println("create second 2048 bit RSA demo encryption certificate...");
        chain[0] = createCertificate(subject, 
                                     rsa2048_crypt_2.getPublic(),
                                     issuer,
                                     ca_rsa.getPrivate(),
                                     (AlgorithmID)AlgorithmID.sha256WithRSAEncryption.clone(),
                                     subjectKeyID.get(),
                                     false,
                                     false);
        chain[1] = caRSA;
        verifier.verifyChain(chain);
        addToKeyStore(rsa2048_crypt_2, chain, RSA_2048_CRYPT_2);
        subject.removeRDN(ObjectID.commonName);  
        
        subject.addRDN(ObjectID.commonName ,"RSA 2048 bit Demo Encryption Certificate 3");
        System.out.println("create third 2048 bit RSA demo encryption certificate...");
        chain[0] = createCertificate(subject, 
                                     rsa2048_crypt_3.getPublic(),
                                     issuer,
                                     ca_rsa.getPrivate(),
                                     (AlgorithmID)AlgorithmID.sha256WithRSAEncryption.clone(),
                                     subjectKeyID.get(),
                                     false,
                                     false);
        chain[1] = caRSA;
        verifier.verifyChain(chain);
        addToKeyStore(rsa2048_crypt_3, chain, RSA_2048_CRYPT_3);
        subject.removeRDN(ObjectID.commonName);  
        issuer.removeRDN(ObjectID.commonName);
      }
      
      // create a RSA-PSS certificate
      if (create_rsa_pss) {
        issuer.addRDN(ObjectID.commonName ,"IAIK RSA-PSS Test CA");
        SubjectKeyIdentifier subjectKeyID = (SubjectKeyIdentifier)caRSAPSS.getExtension(SubjectKeyIdentifier.oid);
       
       
        // 2048
      
        // SHA-1
        subject.addRDN(ObjectID.commonName ,"RSA-PSS 2048 bit SHA-1 Demo Signing Certificate");
        System.out.println("create 2048 bit RSA-PSS (SHA-1) demo certificate...");
        chain[0] = createCertificate(subject,
                                     rsapss2048_sha1_sign.getPublic(),
                                     issuer, 
                                     ca_rsa_pss.getPrivate(),
                                     (AlgorithmID)rsaPssSigningAlg.clone(),
                                     subjectKeyID.get(),
                                     true,
                                     false);
        chain[1] = caRSAPSS;
        verifier.verifyChain(chain);
       
        addToKeyStore(rsapss2048_sha1_sign, chain, RSAPSS_2048_SHA1_SIGN);
        subject.removeRDN(ObjectID.commonName);
        
        // SHA-256
        subject.addRDN(ObjectID.commonName ,"RSA-PSS 2048 bit SHA-256 Demo Signing Certificate");
        System.out.println("create 2048 bit RSA-PSS (SHA-256) demo certificate...");
        chain[0] = createCertificate(subject,
                                     rsapss2048_sha256_sign.getPublic(),
                                     issuer, 
                                     ca_rsa_pss.getPrivate(),
                                     (AlgorithmID)rsaPssSigningAlg.clone(),
                                     subjectKeyID.get(),
                                     true,
                                     false);
        chain[1] = caRSAPSS;
        verifier.verifyChain(chain);
       
        addToKeyStore(rsapss2048_sha256_sign, chain, RSAPSS_2048_SHA256_SIGN);
        subject.removeRDN(ObjectID.commonName);
        
        // SHA-384
        subject.addRDN(ObjectID.commonName ,"RSA-PSS 2048 bit SHA-384 Demo Signing Certificate");
        System.out.println("create 2048 bit RSA-PSS (SHA-384) demo certificate...");
        chain[0] = createCertificate(subject,
                                     rsapss2048_sha384_sign.getPublic(),
                                     issuer, 
                                     ca_rsa_pss.getPrivate(),
                                     (AlgorithmID)rsaPssSigningAlg.clone(),
                                     subjectKeyID.get(),
                                     true,
                                     false);
        chain[1] = caRSAPSS;
        verifier.verifyChain(chain);
       
        addToKeyStore(rsapss2048_sha384_sign, chain, RSAPSS_2048_SHA384_SIGN);
        subject.removeRDN(ObjectID.commonName);
        
        // SHA-512
        subject.addRDN(ObjectID.commonName ,"RSA-PSS 2048 bit SHA-512 Demo Signing Certificate");
        System.out.println("create 2048 bit RSA-PSS (SHA-512) demo certificate...");
        chain[0] = createCertificate(subject,
                                     rsapss2048_sha512_sign.getPublic(),
                                     issuer, 
                                     ca_rsa_pss.getPrivate(),
                                     (AlgorithmID)rsaPssSigningAlg.clone(),
                                     subjectKeyID.get(),
                                     true,
                                     false);
        chain[1] = caRSAPSS;
        verifier.verifyChain(chain);
       
        addToKeyStore(rsapss2048_sha512_sign, chain, RSAPSS_2048_SHA512_SIGN);
        subject.removeRDN(ObjectID.commonName);
      
       
      }
      
      // create a DSA test certificate
      if (create_dsa) {
        issuer.addRDN(ObjectID.commonName ,"IAIK DSA Test CA");
        SubjectKeyIdentifier subjectKeyID = (SubjectKeyIdentifier)caDSA.getExtension(SubjectKeyIdentifier.oid);
        
        // 1024
        subject.addRDN(ObjectID.commonName ,"DSA 1024 bit Demo Certificate");
        System.out.println("create 1024 bit DSA demo certificate...");
        chain[0] = createCertificate(subject, 
                                     dsa1024.getPublic(),
                                     issuer, 
                                     ca_dsa.getPrivate(),
                                     (AlgorithmID)AlgorithmID.dsaWithSHA256.clone(),
                                     subjectKeyID.get(),
                                     true,
                                     false);
        subject.removeRDN(ObjectID.commonName);
        chain[1] = caDSA;
        verifier.verifyChain(chain);
        addToKeyStore(dsa1024, chain, DSA_1024);
        issuer.removeRDN(ObjectID.commonName);
      }
      
      // create SHA-2 DSA test certificates
      if (create_dsa_sha2) {
        issuer.addRDN(ObjectID.commonName ,"IAIK DSA Test CA");
        // 2048
        subject.addRDN(ObjectID.commonName ,"DSA SHA-224 2048 bit Test Certificate");
        System.out.println("create 2048 bit SHA224withDSA test certificate...");
        SubjectKeyIdentifier subjectKeyID = (SubjectKeyIdentifier)caDSA.getExtension(SubjectKeyIdentifier.oid);
        chain[0] = createCertificate(subject, dsa2048.getPublic(),
              issuer, ca_dsa.getPrivate(), AlgorithmID.dsaWithSHA256, subjectKeyID.get(), true, false);
        subject.removeRDN(ObjectID.commonName);
        chain[1] = caDSA;
        verifier.verifyChain(chain);
        addToKeyStore(dsa2048, chain, DSA_2048);
        
        // 3072
        subject.addRDN(ObjectID.commonName ,"DSA SHA-256 3072 bit Test Certificate");
        System.out.println("create 3072 bit SHA256withDSA test certificate...");
        chain[0] = createCertificate(subject, dsa3072.getPublic(),
              issuer, ca_dsa.getPrivate(), AlgorithmID.dsaWithSHA256, subjectKeyID.get(), true, false);
        subject.removeRDN(ObjectID.commonName);
        chain[1] = caDSA;
        verifier.verifyChain(chain);
        addToKeyStore(dsa3072, chain, DSA_3072);
        issuer.removeRDN(ObjectID.commonName);
      }
      
      
      // create a ESDH test certificate
      if (create_esdh) {
        issuer.addRDN(ObjectID.commonName ,"IAIK RSA Test CA");
        SubjectKeyIdentifier subjectKeyID = (SubjectKeyIdentifier)caRSA.getExtension(SubjectKeyIdentifier.oid);
      
        // 2048
        subject.addRDN(ObjectID.commonName ,"ESDH 2048 bit Demo Certificate 1");
        System.out.println("create 2048 bit ESDH demo certificate...");
        chain[0] = createCertificate(subject,
                                     esdh2048_1.getPublic(),
                                     issuer,
                                     ca_rsa.getPrivate(), 
                                     (AlgorithmID)AlgorithmID.sha256WithRSAEncryption.clone(),
                                     subjectKeyID.get(),
                                     false,
                                     false);
        subject.removeRDN(ObjectID.commonName);
        chain[1] = caRSA;
        verifier.verifyChain(chain);
        addToKeyStore(esdh2048_1, chain, ESDH_2048_1);
        
        subject.addRDN(ObjectID.commonName ,"ESDH 2048 bit Demo Certificate 2");
        System.out.println("create second 2048 bit ESDH demo certificate...");
        chain[0] = createCertificate(subject,
                                     esdh2048_2.getPublic(),
                                     issuer,
                                     ca_rsa.getPrivate(), 
                                     (AlgorithmID)AlgorithmID.sha256WithRSAEncryption.clone(),
                                     subjectKeyID.get(),
                                     false,
                                     false);
        subject.removeRDN(ObjectID.commonName);
        chain[1] = caRSA;
        verifier.verifyChain(chain);
        addToKeyStore(esdh2048_2, chain, ESDH_2048_2);
        
        issuer.removeRDN(ObjectID.commonName);
      }
      
          // create a SSDH test certificate
      if (create_ssdh) {
        issuer.addRDN(ObjectID.commonName ,"IAIK RSA Test CA");
        SubjectKeyIdentifier subjectKeyID = (SubjectKeyIdentifier)caRSA.getExtension(SubjectKeyIdentifier.oid);
        // 2048
        subject.addRDN(ObjectID.commonName ,"SSDH 2048 bit Demo Certificate 1");
        System.out.println("create 2048 bit SSDH demo certificate...");
        chain[0] = createCertificate(subject,
                                     ssdh2048_1.getPublic(),
                                     issuer, 
                                     ca_rsa.getPrivate(), 
                                     (AlgorithmID)AlgorithmID.sha256WithRSAEncryption.clone(),
                                     subjectKeyID.get(),
                                     false,
                                     false);
        subject.removeRDN(ObjectID.commonName);
        chain[1] = caRSA;
        verifier.verifyChain(chain);
        addToKeyStore(ssdh2048_1, chain, SSDH_2048_1);
     
        subject.addRDN(ObjectID.commonName ,"SSDH 2048 bit Demo Certificate 2");
        System.out.println("create second 2048 bit SSDH demo certificate...");
        chain[0] = createCertificate(subject,
                                     ssdh2048_2.getPublic(),
                                     issuer, 
                                     ca_rsa.getPrivate(),
                                     (AlgorithmID)AlgorithmID.sha256WithRSAEncryption.clone(),
                                     subjectKeyID.get(),
                                     false, 
                                     false);
        subject.removeRDN(ObjectID.commonName);
        chain[1] = caRSA;
        verifier.verifyChain(chain);
        addToKeyStore(ssdh2048_2, chain, SSDH_2048_2);
        issuer.removeRDN(ObjectID.commonName);
      }
      
      if (create_tspserver) {
        issuer.addRDN(ObjectID.commonName ,"IAIK RSA Test CA");
        SubjectKeyIdentifier subjectKeyID = (SubjectKeyIdentifier)caRSA.getExtension(SubjectKeyIdentifier.oid);
        subject.addRDN(ObjectID.commonName ,"IAIK TSP Demo Server Certificate");
        System.out.println("create 2048 bit RSA TSP demo server certificate...");
        chain[0] = createCertificate(subject,
                                     tsp_server.getPublic(),
                                     issuer,
                                     ca_rsa.getPrivate(),
                                     (AlgorithmID)AlgorithmID.sha256WithRSAEncryption.clone(),
                                     subjectKeyID.get(),
                                     true,
                                     true);
        chain[1] = caRSA;
        verifier.verifyChain(chain);
        addToKeyStore(tsp_server, chain, TSP_SERVER);
        subject.removeRDN(ObjectID.commonName);
      
      }
      
           System.out.println("\nCertificates created!");
 
    } catch (Exception ex) {
      System.out.println("Exception: "+ex);
    }
  }
  
  /**
   * Starts the keystore setup.
   */
  public static void start() {
        SetupCMSKeyStore suks = new SetupCMSKeyStore();
    suks.initializeKeyStore();
    if (suks.create_only_certificates) {
        suks.getPrivateKeys();
    }
    else {
          suks.generatePrivateKeys();
        }
        suks.generateCertificates();
    suks.saveKeyStore();
  }
  
  /**
   * Reads the next line from the given BufferedReader.
   * 
   * @param reader the reader from which to read the line
   * 
   * @return the line just read
   * 
   * @throws IOException if an I/O error occurs
   */
  private final static String readLine(BufferedReader reader) throws IOException {
    String line = reader.readLine();
    if (line != null) {
      line = line.trim();
    } else {
      line = "";
    }
    return line;
  }
  
  /**
   * Creates the test certificates.
   */
  public static void main(String arg[]) throws IOException {

        DemoUtil.initDemos();
    start();    
//    if (!DemoUtil.CREATE_DEMO_KEYSTORE_AUTOMATICAllY) {
//      System.in.read();
//    }  
  }
}