/*

 * 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 ** 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 

  @publishedAll

  @released 

 */

 #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.

 * 

 */

 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

 *

 */

 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).

 * 

 */

 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.  

 *

 */

 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).

 *   

 */

 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.

 *

 */

 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.

 *

 */

 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() 

 * 

 */

 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);

 protected:

 	/** The DSA key generation seed */

 	const HBufC8* iSeed;

 	/** The DSA key generation counter */

 	TUint iCounter;

 private:

 	CDSAPrimeCertificate(const CDSAPrimeCertificate&);

 	CDSAPrimeCertificate& operator=(const CDSAPrimeCertificate&);

 	};

 /** 

 * Concrete class representing the parameters common to both a DSA public and

 * private key. 

 *

 * See FIPS 186-2, Digital Signature Standard

 * 

 */

 class CDSAParameters : public CBase

 	{

 public:

 	/**

 	 * Gets the DSA parameter, p (the prime)

 	 * 

 	 * @return	The DSA parameter, p

 	 */

 	IMPORT_C const TInteger& P(void) const;

 	/**

 	 * Gets the DSA parameter, q (the subprime)

 	 * 

 	 * @return	The DSA parameter, q

 	 */

 	IMPORT_C const TInteger& Q(void) const;

 	/**

 	 * Gets the DSA parameter, g (the base)

 	 * 

 	 * @return	The DSA parameter, g

 	 */

 	IMPORT_C const TInteger& G(void) const;

 	/**

 	 * Validates the primes regenerated from a DSA prime certificate 

 	 *

 	 * @param aCert	The DSA prime certificate that contains the seed and 

 	 *				counter value from a DSA key generation process

 	 * @return		Whether or not the primes are valid	

 	 */

 	IMPORT_C TBool ValidatePrimesL(const CDSAPrimeCertificate& aCert) const;

 	/** 

 	 * Whether or not the prime is of a valid length 

 	 * 

 	 * It is valid if the length of the prime modulus is between KMinPrimeLength

 	 * and KMaxPrimeLength bits, and the prime is a multiple of KPrimeLengthMultiple. 

 	 *

 	 * @param aPrimeBits	The prime modulus

 	 * @return				ETrue, if within the constraints; EFalse, otherwise.

 	 */

 	IMPORT_C static TBool ValidPrimeLength(TUint aPrimeBits);

 	/** Destructor */

 	IMPORT_C virtual ~CDSAParameters(void);

 	/** 

 	 * Creates a new DSA parameters object from a specified 

 	 * prime, subprime, and base.

 	 * 

 	 * @param aP	The DSA parameter, p (the prime)

 	 * @param aQ	The DSA parameter, g (the subprime)

 	 * @param aG	The DSA parameter, g (the base)

 	 * @return		A pointer to a new CDSAParameters object

 	 */

 	IMPORT_C static CDSAParameters* NewL(RInteger& aP, RInteger& aQ, 

 		RInteger& aG);

 public:

 	/** @internalAll */

 	static TBool GeneratePrimesL(const TDesC8& aSeed, TUint& aCounter, 

 		RInteger& aP, TUint aL, RInteger& aQ, TBool aUseInputCounter=EFalse);

 protected:

 	/** 

 	 * Constructor

 	 * 

 	 * @param aP	The DSA parameter, p (the prime)

 	 * @param aQ	The DSA parameter, g (the subprime)

 	 * @param aG	The DSA parameter, g (the base)

 	 */

 	IMPORT_C CDSAParameters(RInteger& aP, RInteger& aQ, RInteger& aG);

 	/** Default constructor */

 	IMPORT_C CDSAParameters(void);

 protected:

 	/** 

 	 * The DSA parameter, p (the prime).

 	 * 

 	 * A prime modulus whose length is between KMinPrimeLength and KMaxPrimeLength bits,

 	 * and is a multiple of KPrimeLengthMultiple. 

 	 */

 	RInteger iP;

 	/** 

 	 * The DSA parameter, q (the subprime)

 	 * 

 	 * This is a 160-bit prime divisor of <code>p-1</code>. 

 	 */

 	RInteger iQ;

 	/** 

 	 * The DSA parameter, g (the base)

 	 * 

 	 * <code>g = h^((p-1)/q) mod p</code>,

 	 * 

 	 * where h is any integer less than <code>p-1</code> such that <code>g &gt; 1</code> 

 	 */

 	RInteger iG;

 private:

 	CDSAParameters(const CDSAParameters&);

 	CDSAParameters& operator=(const CDSAParameters&);

 	};

 /**

 * Representation of a DSA public key.  

 *

 */

 class CDSAPublicKey : public CDSAParameters

 	{

 public:

 	/** 

 	 * Creates a new DSA public key object from a specified

 	 * primes, base, and public key. 

 	 * 

 	 * @param aP	The DSA parameter, p (the prime)

 	 * @param aQ	The DSA parameter, q (the subprime)

 	 * @param aG	The DSA parameter, g (the base)

 	 * @param aY	The DSA parameter, y (the public key)

 	 * @return		A pointer to a new CDSAPublicKey object

 	 */

 	IMPORT_C static CDSAPublicKey* NewL(RInteger& aP, RInteger& aQ, 

 		RInteger& aG, RInteger& aY);

 	/** 

 	 * Creates a new DSA public key object from a specified

 	 * primes, base, and public key. 

 	 * 

 	 * The returned pointer is put onto the cleanup stack.

 	 * 

 	 * @param aP	The DSA parameter, p (the prime)

 	 * @param aQ	The DSA parameter, q (the subprime)

 	 * @param aG	The DSA parameter, g (the base)

 	 * @param aY	The DSA parameter, y (the public key)

 	 * @return		A pointer to a new CDSAPublicKey object

 	 */

 	IMPORT_C static CDSAPublicKey* NewLC(RInteger& aP, RInteger& aQ, 

 		RInteger& aG, RInteger& aY);

 	/**

 	 * Gets the DSA parameter, y (the public key)

 	 *

 	 * @return	The DSA parameter, y

 	 */

 	IMPORT_C const TInteger& Y(void) const;

 	/** Destructor */

 	IMPORT_C virtual ~CDSAPublicKey(void);

 protected:

 	/** 

 	 * Constructor

 	 * 

 	 * @param aP	The DSA parameter, p (the prime)

 	 * @param aQ	The DSA parameter, q (the subprime)

 	 * @param aG	The DSA parameter, g (the base)

 	 * @param aY	The DSA parameter, y (the public key)

 	 */

 	IMPORT_C CDSAPublicKey(RInteger& aP, RInteger& aQ, RInteger& aG, 

 		RInteger& aY);

 	/** Default constructor */

 	IMPORT_C CDSAPublicKey(void);

 protected:

 	/** 

 	 * The DSA parameter, y, which is the public key 

 	 *

 	 * <code>y = g^x mod p</code>

 	 */

 	RInteger iY;

 private:

 	CDSAPublicKey(const CDSAPublicKey&);

 	CDSAPublicKey& operator=(const CDSAPublicKey&);

 	};

 /** 

 * Representation of a DSA private key.  

 * 

 */

 class CDSAPrivateKey : public CDSAParameters

 	{

 public:

 	/** 

 	 * Creates a new DSA private key object from a specified

 	 * primes, base, and private key. 

 	 * 

 	 * @param aP	The DSA parameter, p (the prime)

 	 * @param aQ	The DSA parameter, q (the subprime)

 	 * @param aG	The DSA parameter, g (the base)

 	 * @param aX	The DSA parameter, x (the private key)

 	 * @return		A pointer to a new CDSAPrivateKey object

 	 */

 	IMPORT_C static CDSAPrivateKey* NewL(RInteger& aP, RInteger& aQ, 

 		RInteger& aG, RInteger& aX);

 	/** 

 	 * Creates a new DSA private key object from a specified

 	 * primes, base, and private key. 

 	 * 

 	 * The returned pointer is put onto the cleanup stack.

 	 * 

 	 * @param aP	The DSA parameter, p (the prime)

 	 * @param aQ	The DSA parameter, q (the subprime)

 	 * @param aG	The DSA parameter, g (the base)

 	 * @param aX	The DSA parameter, x (the private key)

 	 * @return		A pointer to a new CDSAPrivateKey object

 	 */

 	IMPORT_C static CDSAPrivateKey* NewLC(RInteger& aP, RInteger& aQ, 

 		RInteger& aG, RInteger& aX);

 	/**

 	 * Gets the DSA parameter, x (the private key)

 	 *

 	 * @return	The DSA parameter, x

 	 */

 	IMPORT_C const TInteger& X(void) const;

 	/** Destructor */

 	IMPORT_C virtual ~CDSAPrivateKey(void);

 protected:

 	/** 

 	 * Constructor

 	 * 

 	 * @param aP	The DSA parameter, p (the prime)

 	 * @param aQ	The DSA parameter, q (the subprime)

 	 * @param aG	The DSA parameter, g (the base)

 	 * @param aX	The DSA parameter, x (the private key)

 	 */

 	IMPORT_C CDSAPrivateKey(RInteger& aP, RInteger& aQ, RInteger& aG, 

 		RInteger& aX);

 	/** Default constructor */

 	IMPORT_C CDSAPrivateKey(void);

 protected:

 	/** 

 	 * The DSA parameter, x, which is the private key 

 	 *

 	 * A pseudorandomly generated integer whose value is between 0 and q.

 	*/

 	RInteger iX;

 private:

 	CDSAPrivateKey(const CDSAPrivateKey&);

 	CDSAPrivateKey& operator=(const CDSAPrivateKey&);

 	};

 /** 

 * This class is capable of generating a DSA public/private key pair.

 * 

 */

 class CDSAKeyPair : public CBase

 	{

 public:

 	/** 

 	 * Creates a new DSA key pair and also a DSA prime certificate

 	 * 

 	 * @param aSize	The length (in bits) of the DSA parameter, p (the prime)

 	 * @return		A pointer to a new CDSAKeyPair object

 	 */

 	IMPORT_C static CDSAKeyPair* NewL(TUint aSize);

 	/** 

 	 * Creates a new DSA key pair and also a DSA prime certificate

 	 * 

 	 * The returned pointer is put onto the cleanup stack.

 	 * 

 	 * @param aSize	The length (in bits) of the DSA parameter, p (the prime)

 	 * @return		A pointer to a new CDSAKeyPair object

 	 */

 	IMPORT_C static CDSAKeyPair* NewLC(TUint aSize);

 	/** 

 	 * Gets the DSA public key

 	 *

 	 * @return	The DSA public key object

 	 */

 	IMPORT_C const CDSAPublicKey& PublicKey(void) const;

 	/** 

 	 * Gets the DSA private key

 	 *

 	 * @return	The DSA private key object

 	 */

 	IMPORT_C const CDSAPrivateKey& PrivateKey(void) const;

 	/** 

 	 * Gets the DSA prime certificate (i.e., the seed and counter)

 	 *

 	 * @return	The DSA prime certificate object

 	 */

 	IMPORT_C const CDSAPrimeCertificate& PrimeCertificate(void) const;

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

 	IMPORT_C virtual ~CDSAKeyPair(void);

 protected:

 	/** Default constructor */

 	IMPORT_C CDSAKeyPair(void);

 protected:

 	/** The DSA public key */

 	CDSAPublicKey* iPublic;

 	/** The DSA private key */

 	CDSAPrivateKey* iPrivate;

 	/** The DSA prime certificate */

 	CDSAPrimeCertificate* iPrimeCertificate;

 private:

 	void ConstructL(TUint aSize);

 	CDSAKeyPair(const CDSAKeyPair&);

 	CDSAKeyPair& operator=(const CDSAKeyPair&);

 	};

 /** 

 * Concrete class representing the parameters common to both 

 * a Diffie-Hellman (DH) public and private key.  

 * 

 */

 class CDHParameters : public CBase

 	{

 public:

 	/**

 	 * Gets the DH parameter, n

 	 *

 	 * @return	An integer representing the DH parameter, n

 	 */

 	IMPORT_C const TInteger& N(void) const;

 	/**

 	 * Gets the DH parameter, g

 	 *

 	 * @return	An integer representing the DH parameter, g

 	 */

 	IMPORT_C const TInteger& G(void) const;

 	/** Destructor */

 	IMPORT_C virtual ~CDHParameters(void);

 protected:

 	/** 

 	 * Constructor

 	 * 

 	 * @param aN	The DH parameter, n

 	 * @param aG	The DH parameter, g

 	 */

 	IMPORT_C CDHParameters(RInteger& aN, RInteger& aG);

 	/** Default constructor */

 	IMPORT_C CDHParameters(void);

 protected:

 	/**

 	 * The DH parameter, n (a prime number)

 	 * 

 	 * <code>X = g^x mod n</code> (note the case sensitivity)

 	 */

 	RInteger iN;

 	/** 

 	 * The DH parameter, g (the generator) 

 	 *

 	 * <code>X = g^x mod n</code> (note the case sensitivity)

 	 */

 	RInteger iG;

 private:

 	CDHParameters(const CDHParameters&);

 	CDHParameters& operator=(const CDHParameters&);

 	};

 /** 

 * Representation of a Diffie-Hellman (DH) public key.  

 * 

 */

 class CDHPublicKey : public CDHParameters

 	{

 public:

 	/** 

 	 * Creates a new DH public key from a specified 

 	 * large prime, generator, and random large integer.

 	 * 

 	 * @param aN	The DH parameter, n (a large prime)

 	 * @param aG	The DH parameter, g (the generator)

 	 * @param aX	The DH value, X

 	 * @return		A pointer to a new CDHPublicKey object

 	 */

 	IMPORT_C static CDHPublicKey* NewL(RInteger& aN, RInteger& aG, 

 		RInteger& aX);

 	/** 

 	 * Creates a new DH public key from a specified 

 	 * large prime, generator, and random large integer.

 	 *

 	 * The returned pointer is put onto the cleanup stack.

 	 * 

 	 * @param aN	The DH parameter, n (a large prime)

 	 * @param aG	The DH parameter, g (the generator)

 	 * @param aX	The DH value, X

 	 * @return		A pointer to a new CDHPublicKey object

 	 */

 	IMPORT_C static CDHPublicKey* NewLC(RInteger& aN, RInteger& aG, 

 		RInteger& aX);

 	/** 

 	 * Gets the DH value, X

 	 * 

 	 * @return	The DH value, X

 	 */	

 	IMPORT_C const TInteger& X(void) const;

 	/** Destructor */

 	IMPORT_C virtual ~CDHPublicKey(void);

 protected:

 	/** 

 	 * Constructor

 	 * 

 	 * @param aN	The DH parameter, n (a large prime)

 	 * @param aG	The DH parameter, g (the generator)

 	 * @param aX	The DH value, X

 	 */

 	IMPORT_C CDHPublicKey(RInteger& aN, RInteger& aG, RInteger& aX);

 	/** Constructor */

 	IMPORT_C CDHPublicKey(void);

 protected:

 	/** 

 	 * The DH value, X

 	 *

 	 * <code>X = g^x mod n</code> (note the case sensitivity)

 	 */

 	RInteger iX;

 private:

 	CDHPublicKey(const CDHPublicKey&);

 	CDHPublicKey& operator=(const CDHPublicKey&);

 	};

 /** 

 * Representation of a Diffie-Hellman (DH) private key.  

 * 

 */

 class CDHPrivateKey : public CDHParameters

 	{

 public:

 	/** 

 	 * Creates a new DH private key from a specified 

 	 * large prime, generator, and random large integer.

 	 * 

 	 * @param aN	The DH parameter, n (a large prime)

 	 * @param aG	The DH parameter, g (the generator)

 	 * @param ax	The DH value, x (a random large integer)

 	 * @return		A pointer to a new CDHPrivateKey object

 	 */

 	IMPORT_C static CDHPrivateKey* NewL(RInteger& aN, RInteger& aG, 

 		RInteger& ax);

 	/** 

 	 * Creates a new DH private key from a specified 

 	 * large prime, generator, and random large integer.

 	 *

 	 * The returned pointer is put onto the cleanup stack.

 	 * 

 	 * @param aN	The DH parameter, n (a large prime)

 	 * @param aG	The DH parameter, g (the generator)

 	 * @param ax	The DH value, x (a random large integer)

 	 * @return		A pointer to a new CDHPrivateKey object

 	 */

 	IMPORT_C static CDHPrivateKey* NewLC(RInteger& aN, RInteger& aG, 

 		RInteger& ax);

 	/** 

 	 * Gets the DH value, x, which is a random large integer.

 	 * 

 	 * @return	The DH value, x

 	 */	

 	IMPORT_C const TInteger& x(void) const;

 	/** Destructor */

 	IMPORT_C virtual ~CDHPrivateKey(void);

 protected:

 	/** 

 	 * Constructor

 	 * 

 	 * @param aN	The DH parameter, n (a large prime)

 	 * @param aG	The DH parameter, g (the generator)

 	 * @param ax	The DH value, x (a random large integer)

 	 */

 	IMPORT_C CDHPrivateKey(RInteger& aN, RInteger& aG, RInteger& ax);

 	/** Constructor */

 	IMPORT_C CDHPrivateKey(void);

 protected:

 	/** 

 	 * The DH value, x, which is a random large integer.

 	 *

 	 * <code>X = g^x mod n</code> (note the case sensitivity)

 	 */

 	RInteger ix;

 private:

 	CDHPrivateKey(const CDHPrivateKey&);

 	CDHPrivateKey& operator=(const CDHPrivateKey&);

 	};

 /** 

 * This class is capable of generating a Diffie-Hellman (DH) public/private key pair.

 * 

 */

 class CDHKeyPair : public CBase

 	{

 public:

 	/**

 	 * Creates a new DH key pair from a random large integer,

 	 * and a specified large prime and generator.

 	 *

 	 * @param aN	The DH parameter, n (a large prime)

 	 * @param aG	The DH parameter, g (the generator)

 	 * @return		A pointer to a new CDHKeyPair object

 	 * 

 	 * @leave KErrArgument	If aG is out of bounds 

 	 */

 	IMPORT_C static CDHKeyPair* NewL(RInteger& aN, RInteger& aG);

 	/**

 	 * Creates a new DH key pair from a random large integer,

 	 * and a specified large prime and generator.

 	 *

 	 * The returned pointer is put onto the cleanup stack.

 	 *

 	 * @param aN	The DH parameter, n (a large prime)

 	 * @param aG	The DH parameter, g (the generator)

 	 * @return		A pointer to a new CDHKeyPair object

 	 * 

 	 * @leave KErrArgument	If aG is out of bounds 

 	 */

 	IMPORT_C static CDHKeyPair* NewLC(RInteger& aN, RInteger& aG);

 	/**

 	 * Creates a new DH key pair from a specified 

 	 * large prime, generator, and random large integer.

 	 *

 	 * @param aN	The DH parameter, n (a large prime)

 	 * @param aG	The DH parameter, g (the generator)

 	 * @param ax	The DH value, x (a random large integer)

 	 * @return		A pointer to a new CDHKeyPair object

 	 * 

 	 * @leave KErrArgument	If either aG or ax are out of bounds 

 	 */

 	IMPORT_C static CDHKeyPair* NewL(RInteger& aN, RInteger& aG, RInteger& ax);

 	/**

 	 * Creates a new DH key pair from a specified 

 	 * large prime, generator, and random large integer.

 	 *

 	 * The returned pointer is put onto the cleanup stack.

 	 *

 	 * @param aN	The DH parameter, n (a large prime)

 	 * @param aG	The DH parameter, g (the generator)

 	 * @param ax	The DH value, x (a random large integer)

 	 * @return		A pointer to a new CDHKeyPair object

 	 * 

 	 * @leave KErrArgument	If either aG or ax are out of bounds 

 	 */

 	IMPORT_C static CDHKeyPair* NewLC(RInteger& aN, RInteger& aG, RInteger& ax);

 	/**

 	 * Gets the DH public key

 	 *

 	 * @return	The DH public key

 	 */

 	IMPORT_C const CDHPublicKey& PublicKey(void) const;

 	/**

 	 * Gets the DH private key

 	 *

 	 * @return	The DH private key

 	 */

 	IMPORT_C const CDHPrivateKey& PrivateKey(void) const;

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

 	IMPORT_C virtual ~CDHKeyPair(void);

 protected:

 	/** Default constructor */

 	IMPORT_C CDHKeyPair(void);

 	/** 

 	 * Constructor

 	 *

 	 * @param aN	The DH parameter, n (a large prime)

 	 * @param aG	The DH parameter, g (the generator)

 	 */

 	IMPORT_C void ConstructL(RInteger& aN, RInteger& aG);

 	/** 

 	 * Constructor

 	 *

 	 * @param aN	The DH parameter, n (a large prime)

 	 * @param aG	The DH parameter, g (the generator)

 	 * @param ax	The DH value, x (a random large integer)

 	 */

 	IMPORT_C void ConstructL(RInteger& aN, RInteger& aG, RInteger& ax);

 protected:	

 	/** The DH public key */

 	CDHPublicKey* iPublic;

 	/** The DH private key */

 	CDHPrivateKey* iPrivate;

 private:

 	CDHKeyPair(const CDHKeyPair&);

 	CDHKeyPair& operator=(const CDHKeyPair&);

 	};

 #endif	//	__ASYMMETRICKEYS_H__