/*

* Copyright (c) 2003-2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description: 

* ** IMPORTANT ** PublishedPartner API's in this file are published to 3rd party developers via the 

* Symbian website. Changes to these API's should be treated as PublishedAll API changes and the Security TA should be consulted.

* Asymmetric keys implementation

*

*/

/**

 @file 

 @internalAll

*/

#ifndef __ASYMMETRICKEYS_H__

#define __ASYMMETRICKEYS_H__

#include <e32base.h>

#include <random.h>

#include <bigint.h>

/** 

* Defines the various ways of representing supported RSA private keys.

* 

* @publishedPartner

* @released 

*/

enum TRSAPrivateKeyType 

	{

	/** 

	 * Standard type of RSA private key

	 * 

	 * This consists of the modulus (n) and decryption exponent (d).

	 */

	EStandard,

	/** 

	 * CRT (Chinese Remainder Theorem) type of RSA private key

	 *

	 * This consists of the the first factor (p), the second factor (q), 

	 * the first factor's CRT exponent (dP), the second factor's CRT exponent (dQ),

	 * and the (first) CRT coefficient (qInv). The two factors, p and q, are the

	 * first two prime factors of the RSA modulus, n.

	 */

	EStandardCRT

	//We may support types like this in the future (currently these are a patent

	//minefield):

	//EMulti, //multi prime version of EStandard

	//EMultiCRT //multi prime version of EStandardCRT

	};

/** 

* Concrete class representing the parameters common to both an RSA public and

* private key.

* 

* See ANSI X9.31 and RSA PKCS#1

*

* @publishedPartner

* @released 

*/

class CRSAParameters : public CBase

	{

public:

	/** 

	 * Gets the RSA parameter, n (the modulus)

	 *

	 * @return	The RSA parameter, n

	 */

	IMPORT_C const TInteger& N(void) const;

	/** Destructor */

	IMPORT_C virtual ~CRSAParameters(void);

protected:

	/** 

	 * Constructor 

	 *

	 * @param aN	The RSA parameter, n (the modulus)

	 */

	IMPORT_C CRSAParameters(RInteger& aN);

	/** Default constructor */

	IMPORT_C CRSAParameters(void);

protected:

	/** The RSA modulus, n, a positive integer */

	RInteger iN;

private:

	CRSAParameters(const CRSAParameters&);

	CRSAParameters& operator=(const CRSAParameters&);

	};

/** 

* Representation of an RSA public key.  

* 

* An RSA public key is identified by its modulus (n) and its encryption exponent

* (e).

* 

* @publishedPartner

* @released 

*/

class CRSAPublicKey : public CRSAParameters

	{

public:

	/**

	 * Creates a new CRSAPublicKey object from a specified 

	 * modulus and encryption exponent.

	 * 

	 * @param aN	The RSA parameter, n (the modulus)

	 * @param aE	The RSA parameter, e (the encryption exponent)

	 * @return		A pointer to a new CRSAPublicKey object

	 *

	 * @leave KErrArgument	If either aN or aE are not positive integers,

	 *						and releases ownership. 

	 */

	IMPORT_C static CRSAPublicKey* NewL(RInteger& aN, RInteger& aE);

	/**

	 * Creates a new CRSAPublicKey object from a specified 

	 * modulus and encryption exponent.

	 * 

	 * The returned pointer is put onto the cleanup stack.

	 * 

	 * @param aN	The RSA parameter, n (the modulus)

	 * @param aE	The RSA parameter, e (the encryption exponent)

	 * @return		A pointer to a new CRSAPublicKey object

	 * 

	 * @leave KErrArgument	If either aN or aE are not positive integers,

	 *	 					and releases ownership. 

	 */

	IMPORT_C static CRSAPublicKey* NewLC(RInteger& aN, RInteger& aE);

	/** 

	 * Gets the RSA parameter, e (the encryption exponent)

	 *

	 * @return	The RSA parameter, e

	 */

	IMPORT_C const TInteger& E(void) const;

	/** Destructor */

	IMPORT_C virtual ~CRSAPublicKey(void);

protected:

	/**

	 * Constructor 

	 *

	 * @param aN	The RSA parameter, n (the modulus)

	 * @param aE	The RSA parameter, e (the encryption exponent)

	 */	

	IMPORT_C CRSAPublicKey(RInteger& aN, RInteger& aE);

	/** Default constructor */

	IMPORT_C CRSAPublicKey(void);

protected:

	/** The RSA encryption exponent, e */

	RInteger iE;

private:

	CRSAPublicKey(const CRSAPublicKey&);

	CRSAPublicKey& operator=(const CRSAPublicKey&);

	void ConstructL();

	};

/** 

* Non-exported container class for the various ways of representing an RSA

* private key.

*

* To instantiate a representation of an RSA private key, find a

* subclass of this appropriate to your key type.  

*

* @publishedPartner

* @released 

*/

class CRSAPrivateKey : public CRSAParameters

	{

public:

	/**

	 * Constructor

	 * 

	 * @param aKeyType	The type of the RSA private key

	 * @param aN		The RSA parameter, n (the modulus)

	 * @internalAll 

	 */

	CRSAPrivateKey(const TRSAPrivateKeyType aKeyType, RInteger& aN);

public:

	/**

	 * Gets the type of RSA private key

	 *

	 * @return	The RSA private key type

	 */

	inline const TRSAPrivateKeyType PrivateKeyType() const {return (iKeyType);};

protected:

	/** The type of the RSA private key */

	const TRSAPrivateKeyType iKeyType;

private:

	CRSAPrivateKey(const CRSAPrivateKey&);

	CRSAPrivateKey& operator=(const CRSAPrivateKey&);

	};

/** 

* The 'classical' representation of a RSA private key.

* 

* Such a private key is composed of a modulus (n) and a decryption exponent (d).

*   

* @publishedPartner

* @released 

*/

class CRSAPrivateKeyStandard : public CRSAPrivateKey

	{

public:

	/**

	 * Creates a new CRSAPrivateKeyStandard object from a specified 

	 * modulus and decryption exponent.

	 * 

	 * @param aN	The RSA parameter, n (the modulus)

	 * @param aD	The RSA parameter, d (the decryption exponent)

	 * @return		A pointer to a new CRSAPrivateKeyStandard object

	 * 

	 * @leave KErrArgument	If either aN or aD are not positive integers,

	 *	 					and releases ownership. 

	 */

	IMPORT_C static CRSAPrivateKeyStandard* NewL(RInteger& aN, RInteger& aD);

	/**

	 * Creates a new CRSAPrivateKeyStandard object from a specified 

	 * modulus and decryption exponent.

	 * 

	 * The returned pointer is put onto the cleanup stack.

	 * 

	 * @param aN	The RSA parameter, n (the modulus)

	 * @param aD	The RSA parameter, d (the decryption exponent)

	 * @return		A pointer to a new CRSAPrivateKeyStandard object

	 * 

	 * @leave KErrArgument	If either aN or aD are not positive integers,

	 *	 					and releases ownership. 

	 */

	IMPORT_C static CRSAPrivateKeyStandard* NewLC(RInteger& aN, RInteger& aD);

	/** 

	 * Gets the RSA parameter, d (the decryption exponent)

	 *

	 * @return	The RSA parameter, d

	 */

	IMPORT_C const TInteger& D(void) const;

	/** Destructor */

	IMPORT_C virtual ~CRSAPrivateKeyStandard(void);

protected:

	/** 

	 * Constructor

	 * 

	 * @param aN	The RSA parameter, n (the modulus)

	 * @param aD	The RSA parameter, d (the decryption exponent)

	 */	 

	IMPORT_C CRSAPrivateKeyStandard(RInteger& aN, RInteger& aD);

protected:

	/** The RSA decryption exponent, d */

	RInteger iD;

private:

	CRSAPrivateKeyStandard(const CRSAPrivateKeyStandard&);

	CRSAPrivateKeyStandard& operator=(const CRSAPrivateKeyStandard&);

	void ConstructL();

	};

/** 

* An alternate representation of an RSA private key providing significant

* speed enhancements through its use of the Chinese Remainder Theorem (CRT).

*

* Here, a private key is represented by a modulus (n), the two prime factors of

* the modulus (p, q), p's CRT exponent (dP), q's CRT exponent (dQ), and the CRT

* coefficient (qInv).  See PKCS#1 at http://www.rsasecurity.com/rsalabs/pkcs/

* for more information.

*

* @publishedPartner

* @released 

*/

class CRSAPrivateKeyCRT : public CRSAPrivateKey

	{

public:

	/**

	 * Creates a new CRSAPrivateKeyCRT object from a specified 

	 * modulus and decryption exponent.

	 * 

	 * @param iN	The RSA parameter, n (the modulus)

	 * @param aP	The RSA parameter, p (the first factor)

	 * @param aQ	The RSA parameter, q (the second factor)

	 * @param aDP	The RSA parameter, dP (the first factor's CRT exponent)

	 * @param aDQ	The RSA parameter, dQ (the second factor's CRT exponent)

	 * @param aQInv	The RSA parameter, qInv (the CRT coefficient)

	 * @return		A pointer to a new CRSAPrivateKeyCRT object

	 * 

	 * @leave KErrArgument	If any of the parameters are not positive integers,

	 *	 					and releases ownership. 

	 */

	IMPORT_C static CRSAPrivateKeyCRT* NewL(RInteger& iN, RInteger& aP, 

		RInteger& aQ, RInteger& aDP, RInteger& aDQ, RInteger& aQInv);

	/**

	 * Creates a new CRSAPrivateKeyCRT object from a specified 

	 * modulus and decryption exponent.

	 * 

	 * The returned pointer is put onto the cleanup stack.

	 * 

	 * @param iN	The RSA parameter, n (the modulus)

	 * @param aP	The RSA parameter, p (the first factor)

	 * @param aQ	The RSA parameter, q (the second factor)

	 * @param aDP	The RSA parameter, dP (the first factor's CRT exponent)

	 * @param aDQ	The RSA parameter, dQ (the second factor's CRT exponent)

	 * @param aQInv	The RSA parameter, qInv (the CRT coefficient)

	 * @return		A pointer to a new CRSAPrivateKeyCRT object

	 * 

	 * @leave KErrArgument	If any of the parameters are not positive integers,

	 *	 					and releases ownership. 

	 */

	IMPORT_C static CRSAPrivateKeyCRT* NewLC(RInteger& iN, RInteger& aP, 

		RInteger& aQ, RInteger& aDP, RInteger& aDQ, RInteger& aQInv);

	/** Destructor */

	IMPORT_C virtual ~CRSAPrivateKeyCRT(void);

	/**

	 * Gets the RSA parameter, p (the first factor) 

	 *

	 * @return	The first factor

	 */

	IMPORT_C const TInteger& P(void) const;

	/**

	 * Gets the RSA parameter, q (the second factor) 

	 *

	 * @return	The second factor

	 */

	IMPORT_C const TInteger& Q(void) const;

	/**

	 * Gets the RSA parameter, dP (the first factor's CRT exponent) 

	 *

	 * @return	The first factor's CRT exponent

	 */

	IMPORT_C const TInteger& DP(void) const;

	/**

	 * Gets the RSA parameter, dQ (the second factor's CRT exponent) 

	 *

	 * @return	The second factor's CRT exponent

	 */

	IMPORT_C const TInteger& DQ(void) const;

	/**

	 * Gets the RSA parameter, qInv (the CRT coefficient) 

	 *

	 * @return	The CRT coefficient

	 */

	IMPORT_C const TInteger& QInv(void) const;

protected:

	/**

	 * Constructor

	 * 

	 * @param aN	The RSA parameter, n (the modulus)

	 * @param aP	The RSA parameter, p (the first factor)

	 * @param aQ	The RSA parameter, q (the second factor)

	 * @param aDP	The RSA parameter, dP (the first factor's CRT exponent)

	 * @param aDQ	The RSA parameter, dQ (the second factor's CRT exponent)

	 * @param aQInv	The RSA parameter, qInv (the CRT coefficient)

	 */

	IMPORT_C CRSAPrivateKeyCRT(RInteger& aN, RInteger& aP, RInteger& aQ, 

		RInteger& aDP, RInteger& aDQ, RInteger& aQInv);

protected:

	/** The RSA parameter, p, which is the first factor */

	RInteger iP;

	/** The RSA parameter, q, which is the second factor */

	RInteger iQ;

	/** The RSA parameter, dP, which is the first factor's CRT exponent */

	RInteger iDP;

	/** The RSA parameter, dQ, which is the second factor's CRT exponent */

	RInteger iDQ;

	/** The RSA parameter, qInv, which is the CRT coefficient */

	RInteger iQInv;

private:

	CRSAPrivateKeyCRT(const CRSAPrivateKeyCRT&);

	CRSAPrivateKeyCRT& operator=(const CRSAPrivateKeyCRT&);

	void ConstructL();

	};

/** 

* This class is capable of generating an RSA public/private key pair.

*

* By default, it generates 2 prime (standard) CRT private keys.

*

* @publishedPartner

* @released 

*/

class CRSAKeyPair : public CBase

	{

public:

	/**

	 * Creates a new RSA key pair

	 * 

	 * @param aModulusBits	The length of the modulus, n (in bits)

	 * @param aKeyType		The type of the RSA key

	 * @return				A pointer to a new CRSAKeyPair object

	 * 

	 * @leave KErrNotSupported	If the type of RSA key is not supported

	 */

	IMPORT_C static CRSAKeyPair* NewL(TUint aModulusBits, 

		TRSAPrivateKeyType aKeyType = EStandardCRT);

	/**

	 * Creates a new RSA key pair

	 * 

	 * The returned pointer is put onto the cleanup stack.

	 * 

	 * @param aModulusBits	The length of the modulus, n (in bits)

	 * @param aKeyType		The type of the RSA key

	 * @return				A pointer to a new CRSAKeyPair object

	 * 

	 * @leave KErrNotSupported	If the type of RSA key is not supported

	 */

	IMPORT_C static CRSAKeyPair* NewLC(TUint aModulusBits, 

		TRSAPrivateKeyType aKeyType = EStandardCRT);

	/** 

	 * Gets the RSA public key

	 *

	 * @return	A CRSAPublicKey object

	 */

	IMPORT_C const CRSAPublicKey& PublicKey(void) const;

	/** 

	 * Gets the RSA private key

	 *

	 * @return	A CRSAPrivateKey object

	 */

	IMPORT_C const CRSAPrivateKey& PrivateKey(void) const;

	/** The destructor frees all resources owned by the object, prior to its destruction. */

	IMPORT_C virtual ~CRSAKeyPair(void);

protected:

	/** Default destructor */

	IMPORT_C CRSAKeyPair(void);

protected:

	/** The RSA public key */

	CRSAPublicKey* iPublic;

	/** The RSA private key */

	CRSAPrivateKey* iPrivate;

private:

	void ConstructL(TUint aModulusBits, TRSAPrivateKeyType aKeyType, 

		TUint aPublicExponent);

	CRSAKeyPair(const CRSAKeyPair&);

	CRSAKeyPair& operator=(const CRSAKeyPair&);

	};

/** 

* Representation of the parameters used to generate the primes in a

* CDSAParameters object.

* 

* Given such a certificate, one can ensure that the DSA

* primes contained in CDSAParameters were generated correctly.

* 

* @see CDSAParameters::ValidatePrimesL() 

* 

* @publishedPartner

* @released 

*/

class CDSAPrimeCertificate : public CBase

	{

public:

	/** 

	 * Creates a new DSA prime certificate from a specified 

	 * seed and counter value.

	 * 

	 * @param aSeed		The seed from a DSA key generation process

	 * @param aCounter	The counter value from a DSA key generation process

	 * @return			A pointer to a new CDSAPrimeCertificate object

	 */

	IMPORT_C static CDSAPrimeCertificate* NewL(const TDesC8& aSeed, 

		TUint aCounter);

	/** 

	 * Creates a new DSA prime certificate from a specified 

	 * seed and counter value.

	 *

	 * The returned pointer is put onto the cleanup stack.

	 * 

	 * @param aSeed		The seed from a DSA key generation process

	 * @param aCounter	The counter value from a DSA key generation process

	 * @return			A pointer to a new CDSAPrimeCertificate object

	 */

	IMPORT_C static CDSAPrimeCertificate* NewLC(const TDesC8& aSeed,

		TUint aCounter);

	/**

	 * Gets the seed of the DSA prime certificate

	 *

	 * @return	The seed

	 */ 

	IMPORT_C const TDesC8& Seed(void) const;

	/**

	 * Gets the counter value of the DSA prime certificate

	 *

	 * @return	The counter's value

	 */

	IMPORT_C TUint Counter(void) const;

	/** Destructor */

	IMPORT_C virtual ~CDSAPrimeCertificate(void);

protected:

	/** 

	 * Constructor 

	 *

	 * @param aCounter	The DSA key generation counter

	 */

	IMPORT_C CDSAPrimeCertificate(TUint aCounter);

	/** Default constructor */

	IMPORT_C CDSAPrimeCertificate(void);

	/** @internalAll */

	void ConstructL(const TDesC8& aSeed);