/*

* Copyright (c) 2004-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: 

*

*/

#include <asn1enc.h>

#include <pbe.h>

#include <asymmetrickeys.h>

#include <bigint.h>

#include "asnpkcs.h"

const TInt KPkcs8Version = 0;      // PKCS#8 version 0 

const TInt KPkcs8RSATwoPrime = 0;  // We support only two-prime RSA. 

/*static*/ void TASN1EncPKCS8::AddAttributesL(CASN1EncSequence& aSeq, const TDesC8& aAttribute)

	{

	if (aAttribute != KNullDesC8)

		{

		CASN1EncEncoding* encoded = CASN1EncEncoding::NewLC(aAttribute);

		aSeq.AddAndPopChildL(encoded);		

		}

	}

/**

 * Given a ASN1 sequence representing a private key and a CPBEncryptor object,

 * it returns an ASN1 octet string containing the key sequence encrypted by

 * the given encryptor.

 *

 * @param aKeySeq The key sequence to be encrypted.

 * @param aEncryptor The CPBEncryptor object used to encrypt the given key.

 * @return An ASN1 octet string containing the encrypted key.

 */

/*static*/ CASN1EncOctetString* TASN1EncPKCS8::EncryptKeySequenceL(CASN1EncSequence& aKeySeq, CPBEncryptor& aEncryptor)

	{

	//	Make an octet string of the key sequence

	TUint seqLen = aKeySeq.LengthDER();

	HBufC8* octetData = HBufC8::NewMaxLC(seqLen);

	TPtr8 oct(octetData->Des());

	oct.FillZ();

	TUint writePos = 0;

	aKeySeq.WriteDERL(oct, writePos);

	// Encrypt it

        HBufC8* encryptedData = HBufC8::NewLC(aEncryptor.MaxFinalOutputLength(seqLen)); 

        TPtr8 encrypted(encryptedData->Des());  

	aEncryptor.ProcessFinalL(*octetData, encrypted);

	CASN1EncOctetString* octet = CASN1EncOctetString::NewL(encrypted);

	CleanupStack::PopAndDestroy(2, octetData); // encryptedData, octetData

	return octet;

	}

/*static*/ CASN1EncOctetString* TASN1EncPKCS8::ElementToOctetL(CASN1EncBase& aAsnElement)

	{

	//	Make an octet string from the structure

	HBufC8* octetData = HBufC8::NewMaxLC(aAsnElement.LengthDER());

	TPtr8 oct(octetData->Des());

	oct.FillZ();

	TUint writePos = 0;

	aAsnElement.WriteDERL(oct, writePos);

	CASN1EncOctetString* octet = CASN1EncOctetString::NewL(oct);

	CleanupStack::PopAndDestroy(octetData);

	return octet;

	}

/*static*/ CASN1EncSequence* TASN1EncPKCS8::EncryptedSequenceL(CASN1EncSequence& aPrivateKeySequence, 

                                                               CPBEncryptor& aEncryptor, CPBEncryptParms& aData)

	{

	// Main ASN1 sequence

	CASN1EncSequence* seq = CASN1EncSequence::NewLC();

	// PKCS#5 PBE sequence

	CASN1EncSequence* pkcs5Seq = TASN1EncPKCS5::EncodeDERL(aData);

	CleanupStack::PushL(pkcs5Seq);

	seq->AddAndPopChildL(pkcs5Seq);

	// Encrypt the Private Key Sequence

	CASN1EncOctetString* octet = EncryptKeySequenceL(aPrivateKeySequence, aEncryptor);

	CleanupStack::PushL(octet);

	seq->AddAndPopChildL(octet);

	CleanupStack::Pop(seq);

	return seq;

	}

/*static*/ const RInteger TASN1EncPKCS8::CalculateRSAPrivExpL(const CRSAPrivateKeyCRT& aPrivateKey, const CRSAPublicKey& aPublicKey)

	{

	const TInteger& e = aPublicKey.E();

	RInteger pTemp = RInteger::NewL(aPrivateKey.P());

	CleanupStack::PushL(pTemp);

	RInteger qTemp = RInteger::NewL(aPrivateKey.Q());

	CleanupStack::PushL(qTemp);

  	--pTemp;

    	--qTemp;

	//phi = (p-1)(q-1)

	RInteger phi = pTemp.TimesL(qTemp);

	CleanupStack::PopAndDestroy(2, &pTemp);  // qTemp, pTemp

 	CleanupStack::PushL(phi);

    	//d = e^(-1) mod ((p-1)(q-1))

   	 RInteger d = e.InverseModL(phi);

    	CleanupStack::PopAndDestroy(&phi); 

	return d;	

	}

/**

 * Encodes the given private key using the pkcs#8 standard.

 *

 * The returned ASN1 sequence respects the following grammar:

 * 

 *	PrivateKeyInfo ::= SEQUENCE {

 *	version Version,

 *	privateKeyAlgorithm PrivateKeyAlgorithmIdentifier,

 *	privateKey PrivateKey,

 *	attributes [0] IMPLICIT Attributes OPTIONAL }

 *	

 *	Version ::= INTEGER

 *	PrivateKeyAlgorithmIdentifier ::= AlgorithmIdentifier

 *	PrivateKey ::= OCTET STRING

 *	Attributes ::= SET OF Attribute

 *

 *

 * @param aKeyPair A key pair containing the private key we wish to encode.

 * @return A CASN1EncSequence encoding the private key. The sequence

 *         follows the grammar specified above. 

 * @internalComponent

 * @released

 */

/*static*/ EXPORT_C CASN1EncSequence* TASN1EncPKCS8::EncodeL(const CRSAPrivateKeyCRT& aPrivateKey, 

														  const CRSAPublicKey& aPublicKey, 

														  const TDesC8& aAttributes)

	{

	// Main ASN1 sequence

	CASN1EncSequence* seq = CASN1EncSequence::NewLC();

	// Start with PKCS#8 header

	CASN1EncInt* version = CASN1EncInt::NewLC(KPkcs8Version); 

	seq->AddAndPopChildL(version);

	//	Algorithm sequence

	CASN1EncSequence* algSeq = CASN1EncSequence::NewLC();

	CASN1EncObjectIdentifier* oid = CASN1EncObjectIdentifier::NewLC(KRSA);

	algSeq->AddAndPopChildL(oid);

	//	No other parameters

	CASN1EncNull* nullparams = CASN1EncNull::NewLC();

	algSeq->AddAndPopChildL(nullparams);

	seq->AddAndPopChildL(algSeq);

	// The actual private key sequence		

	CASN1EncSequence* keySeq = CASN1EncSequence::NewLC();

	//	TASN1DecGeneric* versionData = theData->operator[](seqIndex);

	CASN1EncInt* rsaVersion = CASN1EncInt::NewLC(KPkcs8RSATwoPrime); 

	keySeq->AddAndPopChildL(rsaVersion);

	//	The modulus	

	const TInteger& modulus = aPrivateKey.N();

	CASN1EncBigInt* mod = CASN1EncBigInt::NewLC(modulus);

	keySeq->AddAndPopChildL(mod);

	//	The public exponent

	const TInteger& e = aPublicKey.E();

	CASN1EncBigInt* publicExp = CASN1EncBigInt::NewLC(e);

	keySeq->AddAndPopChildL(publicExp);

	// The private exponent

	RInteger d = CalculateRSAPrivExpL(aPrivateKey, aPublicKey);

	CleanupStack::PushL(d);

	CASN1EncBigInt* privateExp = CASN1EncBigInt::NewLC(d);

	keySeq->AddAndPopChildL(privateExp);

	CleanupStack::PopAndDestroy(&d);  // RSA Private Exponent 

	//	The prime1

	const TInteger& p = aPrivateKey.P();

	CASN1EncBigInt* prime1 = CASN1EncBigInt::NewLC(p);

	keySeq->AddAndPopChildL(prime1);

	//	The prime2

	const TInteger& q = aPrivateKey.Q();

	CASN1EncBigInt* prime2 = CASN1EncBigInt::NewLC(q);

	keySeq->AddAndPopChildL(prime2);

	//	The exponent 1	

	const TInteger& dp = aPrivateKey.DP();

	CASN1EncBigInt* theExp1 = CASN1EncBigInt::NewLC(dp);

	keySeq->AddAndPopChildL(theExp1);

	//	The exponent 2

	const TInteger& dq = aPrivateKey.DQ();

	CASN1EncBigInt* theExp2 = CASN1EncBigInt::NewLC(dq);

	keySeq->AddAndPopChildL(theExp2);

	//	The coefficient

	const TInteger& coeff = aPrivateKey.QInv();

	CASN1EncBigInt* coefficient = CASN1EncBigInt::NewLC(coeff);

	keySeq->AddAndPopChildL(coefficient);

	CASN1EncOctetString* octet = ElementToOctetL(*keySeq);

	CleanupStack::PushL(octet);

	//	Now add the octet of the key sequence to the sequence

	seq->AddAndPopChildL(octet);

  	CleanupStack::PopAndDestroy(keySeq);

	AddAttributesL(*seq, aAttributes);

  	CleanupStack::Pop(seq);

	return seq;

	}

/**

 * Encodes an RSA key in encrypted format.

 * 

 * @param aPrivateKey The private key to be encoded (must be in CRT format)

 * @param aPublicKey The corresponding public key.

 * @param aEncryptor The object used to encrypt the data.

 * @param aData The encryption parameters of the given encryptor.

 *              These parameters are stored in the resulting sequence.

 *

 * @return An ASN1 Sequence encoding the encrypted key.

 */

/*static*/ EXPORT_C CASN1EncSequence* TASN1EncPKCS8::EncodeEncryptedL(const CRSAPrivateKeyCRT& aPrivateKey, const CRSAPublicKey& aPublicKey, 

                                                                      CPBEncryptor& aEncryptor, CPBEncryptParms& aData, const TDesC8& aAttributes)

	{

	// Now generate a PrivateKeyInfo type 

	CASN1EncSequence* privKeySeq = EncodeL(aPrivateKey, aPublicKey, aAttributes);

	CleanupStack::PushL(privKeySeq);

	CASN1EncSequence* seq = EncryptedSequenceL(*privKeySeq, aEncryptor, aData);

	CleanupStack::PopAndDestroy(privKeySeq);

	return seq;

	}

/**

 * Return the ASN1 PKCS#8 encoding of a DSA private key.

 *

 * The private key syntax for this key type is defined in 

 * the PKCS#11 document. 

 *

 * @param aPrivateKey The private key to be encoded (must be in CRT format)

 *

 * @return An ASN1 Sequence encoding the key.

 */	

/*static*/ EXPORT_C CASN1EncSequence* TASN1EncPKCS8::EncodeL(const CDSAPrivateKey& aPrivateKey, 

													          const TDesC8& aAttributes)

	{

	// Main ASN1 sequence

	CASN1EncSequence* seq = CASN1EncSequence::NewLC();

	//	version

	CASN1EncInt* version = CASN1EncInt::NewLC(KPkcs8Version);

	seq->AddAndPopChildL(version);

	//	Algorithm sequence

	CASN1EncSequence* algSeq = CASN1EncSequence::NewLC();

	CASN1EncObjectIdentifier* oid = CASN1EncObjectIdentifier::NewLC(KDSA);

	algSeq->AddAndPopChildL(oid);

	seq->AddAndPopChildL(algSeq);

	// DSA Parameters	

	CASN1EncSequence* keySeq = CASN1EncSequence::NewLC();

	//	The modulus	P

	const TInteger& modulus1 = aPrivateKey.P();

	CASN1EncBigInt* mod = CASN1EncBigInt::NewLC(modulus1);

	keySeq->AddAndPopChildL(mod);

	//	The modulus	Q

	const TInteger& modulus2 = aPrivateKey.Q();

	CASN1EncBigInt* mod2 = CASN1EncBigInt::NewLC(modulus2);

	keySeq->AddAndPopChildL(mod2);

	//	The base G 

	const TInteger& base = aPrivateKey.G();

	CASN1EncBigInt* b = CASN1EncBigInt::NewLC(base);

	keySeq->AddAndPopChildL(b);

	algSeq->AddAndPopChildL(keySeq);

	//	The private key X

	const TInteger& priv = aPrivateKey.X();	

	CASN1EncBigInt* x = CASN1EncBigInt::NewLC(priv);

	CASN1EncOctetString* octet = ElementToOctetL(*x);

	CleanupStack::PopAndDestroy(x);

	CleanupStack::PushL(octet);

	seq->AddAndPopChildL(octet);

	AddAttributesL(*seq, aAttributes);

	CleanupStack::Pop(seq);

	return seq;	

	}

/**

 * Encodes a DSA key in encrypted format.

 * 

 * @param aPrivateKey The private key to be encoded.

 * @param aEncryptor The object used to encrypt the data.

 * @param aData The encryption parameters of the given encryptor.

 *              These parameters are stored in the resulting sequence.

 *

 * @return An ASN1 Sequence encoding the encrypted key.

 */

/*static*/ EXPORT_C CASN1EncSequence* TASN1EncPKCS8::EncodeEncryptedL(const CDSAPrivateKey& aPrivateKey, CPBEncryptor& aEncryptor, 

                                                                      CPBEncryptParms& aData, const TDesC8& aAttributes)

	{

	// Now generate a PrivateKeyInfo type 

	CASN1EncSequence* privKeySeq = EncodeL(aPrivateKey, aAttributes);

	CleanupStack::PushL(privKeySeq);

	CASN1EncSequence* seq = EncryptedSequenceL(*privKeySeq, aEncryptor, aData);

	CleanupStack::PopAndDestroy(privKeySeq);

	return seq;

	}