// 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/DemoUtil.java 29    12.02.25 17:58 Dbratko $
// $Revision: 29 $
//

package demo;

import java.io.IOException;
import java.security.AlgorithmParameters;
import java.security.InvalidAlgorithmParameterException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.security.Provider;
import java.security.Security;
import java.security.spec.InvalidParameterSpecException;
import java.util.Random;

import iaik.asn1.ObjectID;
import iaik.asn1.structures.AlgorithmID;
import iaik.cms.SecurityProvider;
import iaik.pkcs.pkcs1.MGF1ParameterSpec;
import iaik.pkcs.pkcs1.MaskGenerationAlgorithm;
import iaik.pkcs.pkcs1.RSAPssParameterSpec;
import iaik.security.provider.IAIK;
import iaik.security.random.MetaSeedGenerator;
import iaik.security.random.SecRandom;
import iaik.security.random.SeedGenerator;

/**
 * Some basic utility methods used by the demos.
 */
public class DemoUtil {
  
  /** Debug flag for all demos */
  public final static boolean DEMO_DEBUG = true;
  
  /**
   * Base OID for IAIK-CMS demos.
   */
  public final static ObjectID IAIK_JAVA_SECURITY_DEMO_CMS_OID = new ObjectID("1.3.6.1.4.1.2706.2.2.4", "IAIK JavaSecurity CMS Demo");
  
  /**
   * Greeting message.
   */
  final static String[] GREETING = {
    "*                                                                            *",
    "*         Welcome to the IAIK-CMS/SMIMEv4 Demo Programs                      *",
    "*                                                                            *",
    "* These simple programs show how to use the IAIK-CMS library. Please         *", 
    "* see  the  documentation and  the source code  for more information.        *",
    "*                                                                            *",
    "*                                                                            *",
    "* NOTE that most of the demos require certificates to work, they are         *", 
    "* taken from a keystore file (cms.keystore) located  in your current         *",
    "* working directory. If yet not exist, the keystore can be generated         *",
    "* by calling demo.keystore.SetupCMSKeyStore.                                 *",
    "*                                                                            *",
    "",
  };

  
  /**
   * Whether to {@link demo.keystore.SetupCMSKeyStore create} a new demo keystore automatically
   * if it is not present or to explicitly ask if to create it.
   */
  public static boolean CREATE_DEMO_KEYSTORE_AUTOMATICAllY = false;
  /**
   * Initialization done?
   */
  static boolean initialized_ = false;
  
  /**
   * Version number of the IAIK-JCE crypto provider.
   */
  static double iaikProviderVersion_ = -1;
  
  /**
   * Empty constructor.
   */
  DemoUtil() {
    // empty
  }
  
  /** Perform a some initial setup to allow the demos to work */
  public synchronized static void initDemos() {
    initDemos(true);
  }
  
  /**
   *  Perform a some initial setup to allow the demos to work
   *  
   *  @param quickStart whether to init the random generator with a
   *                    (not strong) seed for quick start (ONLY FOR 
   *                    DEMO PURPOSES; NOT FOR PRODUCTION ENVIRONMENT!)
   */
  public synchronized static void initDemos(boolean quickStart) {
    
    if( initialized_ ) {
      return;
    }
    initialized_ = true;
    for( int i=0; i<GREETING.length; i++ ) {
      System.out.println(GREETING[i]);
    }
    initRandom(quickStart);
    addIaikProvider();
  }
  

  /**
   * Adds the IAIK JCE as a first security provider. 
   */
  public static void addIaikProvider() {
    IAIK.addAsProvider();
    Provider iaikProv = Security.getProvider("IAIK");
    iaikProviderVersion_ = iaikProv.getVersion();
  }
  
  /**
   * Gets the version number of the IAIK-JCE provider used for this demos.
   *
   * @return the version number of the IAIK JCA/JCE provider
   */
  public static double getIaikProviderVersion() {
    if (iaikProviderVersion_ == -1) {
      addIaikProvider();   
    }    
    return iaikProviderVersion_; 
  }  
  
  /**
   * Adds the cryptography provider with the given name.
   *
   * Note that it may <em>not</em> be enough to just add it as a provider;
   * see the {@link iaik.cms.SecurityProvider SecurityProvider} class for more information.
   *
   * @param name the name of the provider to be added
   */
  public static void addProvider(String name) {
    try {
      Class clazz = Class.forName(name);
      Provider provider = (Provider)clazz.newInstance();
      Security.addProvider(provider);
    } catch (ClassNotFoundException ex) {
      System.out.println("Provider IAIK not found. Add iaik_jce.jar or iaik_jce_full.jar to your classpath.");
      System.out.println("If you are going to use a different provider please take a look at Readme.html!");
      System.exit(0);
    } catch (Exception ex) {
      System.out.println("Error adding provider:");
      ex.printStackTrace(System.err);
      System.exit(0);
    }
  }
  
  /**
   * Setup the random number generator for a quick start.
   * THIS IS NOT SECURE AND SHOULD BE USED FOR DEMO PURPOSES ONLY.
   * ANY CRYPTOGRAPHIC KEY DERIVED IN THIS WAY IS WEAK AND NO STRONGER THAN 20 BIT!!!
   */
  public static void initRandom() {
    System.out.println("Quick-starting random number generator (not for use in production systems!)...");
    Random random = new Random();
    byte[] seed = new byte[20];
    random.nextBytes(seed);
    MetaSeedGenerator.setSeed(seed);
    SeedGenerator.setDefault(MetaSeedGenerator.class);
  }
  
  /**
   * Setup the random number generator for a quick start.
   * THIS IS NOT SECURE AND SHOULD BE USED FOR DEMO PURPOSES ONLY.
   * ANY CRYPTOGRAPHIC KEY DERIVED IN THIS WAY IS WEAK AND NO STRONGER THAN 20 BIT!!!
   * 
   * @param quick whether to init the random generator with a (not strong) seed 
   *                for quick start (only for demonstration purposes)
   */
  public static void initRandom(boolean quick) {
    if (quick) {
      System.out.println("Quick-starting random number generator (not for use in production systems!)...");
      Random random = new Random();
      byte[] seed = new byte[20];
      random.nextBytes(seed);
      MetaSeedGenerator.setSeed(seed);
      SeedGenerator.setDefault(MetaSeedGenerator.class);
    } else {
      // create a new Thread which initializes the Secure Random Number generator
      (new Thread() {
        public void run() {
          setPriority(Thread.MIN_PRIORITY);
          SecRandom.getDefault().nextInt();
        }
      }).start();
    }
  }
  
  /**
   * Creates a RSA-PSS AlgorithmID with the supplied parameters (hash algorithm id,
   * mask generation function, salt length).
   *
   * @param hashID the hash algorithm to be used
   * @param mgfID the mask generation function to be used
   * @param saltLength the salt length to be used
   *
   * @return the RSA-PSS algorithm id with the given parameters 
   *
   * @throws InvalidAlgorithmParameterException if the parameters cannot be created/set
   * @throws NoSuchAlgorithmException if there is no AlgorithmParameters implementation
   *                                     for RSA-PSS
   */
  public static AlgorithmID createPssAlgorithmID(AlgorithmID hashID, AlgorithmID mgfID, int saltLength)
    throws InvalidAlgorithmParameterException, NoSuchAlgorithmException {
        
    SecurityProvider provider = SecurityProvider.getSecurityProvider();
    AlgorithmID rsaPssID = (AlgorithmID)AlgorithmID.rsassaPss.clone();
    mgfID.setParameter(hashID.toASN1Object());
    // create a RSAPssParameterSpec
    RSAPssParameterSpec pssParamSpec = new RSAPssParameterSpec(hashID, mgfID, saltLength);
    // optionally set hash and mgf engines
    MessageDigest hashEngine = provider.getMessageDigest(hashID);
    pssParamSpec.setHashEngine(hashEngine);
    MaskGenerationAlgorithm mgfEngine = provider.getMaskGenerationAlgorithm(mgfID);
    MGF1ParameterSpec mgf1Spec = new MGF1ParameterSpec(hashID);
    mgf1Spec.setHashEngine(hashEngine);
    mgfEngine.setParameters(mgf1Spec);
    pssParamSpec.setMGFEngine(mgfEngine);
  
    AlgorithmParameters pssParams = null;
    try {
      pssParams = provider.getAlgorithmParameters(SecurityProvider.IMPLEMENTATION_NAME_RSA_PSS);
      pssParams.init(pssParamSpec);
  
  
    } catch (InvalidParameterSpecException ex) {
      throw new InvalidAlgorithmParameterException("Cannot init PSS params: " + ex.getMessage());  
    }    
   
    rsaPssID.setAlgorithmParameters(pssParams);
    return rsaPssID;
  }  
  
  
  /**
   * Wait for the user to press the return key on System.in.
   */
  public static void waitKey() {
    try {
      System.out.println("Hit the <RETURN> key.");
      do {
        System.in.read();
      } while( System.in.available() > 0 );
    } catch( IOException e ) {
      // ignore
    }
  }
  
}