/*

* Copyright (c) 1998-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 <x509keys.h>

#include <asn1dec.h>

#include <asn1enc.h>

#include <x509cert.h>

#include "x509keyencoder.h"

CX509RSAPublicKey::CX509RSAPublicKey()

{}

//RSA public key

EXPORT_C CX509RSAPublicKey* CX509RSAPublicKey::NewL(const TDesC8& aBinaryData)

	{

	TInt pos = 0;

	return CX509RSAPublicKey::NewL(aBinaryData, pos);

	}

EXPORT_C CX509RSAPublicKey* CX509RSAPublicKey::NewLC(const TDesC8& aBinaryData)

	{

	TInt pos = 0;

	return CX509RSAPublicKey::NewLC(aBinaryData, pos);

	}

EXPORT_C CX509RSAPublicKey* CX509RSAPublicKey::NewL(const TDesC8& aBinaryData, TInt& aPos)

	{

	CX509RSAPublicKey* self = CX509RSAPublicKey::NewLC(aBinaryData, aPos);

	CleanupStack::Pop();

	return self;

	}

EXPORT_C CX509RSAPublicKey* CX509RSAPublicKey::NewLC(const TDesC8& aBinaryData, TInt& aPos)

	{

	CX509RSAPublicKey* self = new(ELeave) CX509RSAPublicKey();

	CleanupStack::PushL(self);

	self->ConstructL(aBinaryData, aPos);

	return self;

	}

void CX509RSAPublicKey::ConstructL(const TDesC8& aBinaryData, TInt& aPos)

	{

	TASN1DecGeneric gen(aBinaryData.Right(aBinaryData.Length() - aPos));

	gen.InitL();

	TInt end = aPos + gen.LengthDER();

	aPos += gen.LengthDERHeader();

	if (gen.Tag() != EASN1Sequence)

		{

		User::Leave(KErrArgument);

		}

	TASN1DecInteger encInt;

	iN = encInt.DecodeDERLongL(aBinaryData, aPos);

	iE = encInt.DecodeDERLongL(aBinaryData, aPos);

	// RSA Public keys, modulus and exponent must be positive integers

	if(!iN.IsPositive() || !iE.IsPositive())

		{

		User::Leave(KErrArgument);

		}

	if (aPos != end)

		{

		User::Leave(KErrArgument);

		}

	}

// Encodes public key to DER

EXPORT_C HBufC8* TASN1EncRSAPublicKey::EncodeDERL(const CRSAPublicKey& aKey) const

	{

	CASN1EncSequence* sequence = CASN1EncSequence::NewLC();

	CASN1EncBigInt* encModulus = CASN1EncBigInt::NewLC(aKey.N());

	sequence->AddAndPopChildL(encModulus);

	CASN1EncBigInt* encPublicExponent = CASN1EncBigInt::NewLC(aKey.E());

	sequence->AddAndPopChildL(encPublicExponent);

	HBufC8* der = HBufC8::NewMaxLC(sequence->LengthDER());

	TUint pos = 0;

	TPtr8 derptr(der->Des());

	sequence->WriteDERL(derptr, pos);

	CleanupStack::Pop(der);

	CleanupStack::PopAndDestroy(sequence);

	return der;

	}

// Decodes public key from DER

EXPORT_C CRSAPublicKey* TASN1DecRSAPublicKey::DecodeDERL(const TDesC8& aDER, 

														 TInt& aPos) const

	{

	// Enter into the containing SEQUENCE and verify if it is indeed there

	TASN1DecGeneric gen(aDER.Right(aDER.Length() - aPos));

	gen.InitL();

	TInt end = aPos + gen.LengthDER();

	aPos += gen.LengthDERHeader();

	if (gen.Tag() != EASN1Sequence)

		User::Leave(KErrArgument);

	// Decode modulus and public exponent (two large integers)

	TASN1DecInteger encInt;

	RInteger modulus = encInt.DecodeDERLongL(aDER, aPos);

	CleanupStack::PushL(modulus);

	RInteger publicExponent = encInt.DecodeDERLongL(aDER, aPos);

	CleanupStack::PushL(publicExponent);

	if (aPos != end)

		User::Leave(KErrArgument);

	// Construct a new key without copying

	CRSAPublicKey* key = CRSAPublicKey::NewL(modulus, publicExponent);

	CleanupStack::Pop(2); // modulus, publicExponent - owned by public key

	return key;

	}

// Decodes RSA key pair from DER-encoded buffer

EXPORT_C void TASN1DecRSAKeyPair::DecodeDERL(const TDesC8& aDER, 

												TInt& aPos, 

												CRSAPublicKey*& aPublicKey,

												CRSAPrivateKey*& aPrivateKey,

												TRSAPrivateKeyType aKeyType /*=EStandardCRT*/)

{

	aPublicKey = NULL;

	aPrivateKey = NULL;

	// Enter into the containing SEQUENCE and verify if it is 

	// indeed there

	TASN1DecGeneric gen(aDER.Right(aDER.Length() - aPos));

	gen.InitL();

	TInt end = aPos + gen.LengthDER();

	aPos += gen.LengthDERHeader();

	if (gen.Tag() != EASN1Sequence)

		User::Leave(KErrArgument);

	TASN1DecInteger encInt;

	// Decode and discard version, which is an integer

	encInt.DecodeDERShortL(aDER, aPos);

	// Decode public key components

	// Decode modulus

	RInteger publicModulus = encInt.DecodeDERLongL(aDER, aPos);

	CleanupStack::PushL(publicModulus);

	// Decode public exponent

	RInteger publicExponent = encInt.DecodeDERLongL(aDER, aPos);

	CleanupStack::PushL(publicExponent);

	//	Construct public key

	CRSAPublicKey* publicKey = CRSAPublicKey::NewL(publicModulus, publicExponent);

	CleanupStack::Pop(2, &publicModulus); // Now owned by publicKey

	CleanupStack::PushL(publicKey);

	// Decode private key components

	// Copy modulus

	RInteger privateModulus = RInteger::NewL(publicKey->N());

	CleanupStack::PushL(privateModulus);					  

	// Decode private exponent

	RInteger privateExponent = encInt.DecodeDERLongL(aDER, aPos);

	CleanupStack::PushL(privateExponent);

	// Decode prime 1

	RInteger p = encInt.DecodeDERLongL(aDER, aPos);

	CleanupStack::PushL(p);

	// Decode prime 2

	RInteger q = encInt.DecodeDERLongL(aDER, aPos);

	CleanupStack::PushL(q);

	// Decode exponent 1

	RInteger dmp1 = encInt.DecodeDERLongL(aDER, aPos);

	CleanupStack::PushL(dmp1);

	// Decode exponent 2

	RInteger dmq1 = encInt.DecodeDERLongL(aDER, aPos);

	CleanupStack::PushL(dmq1);

	// Decode coefficient

	RInteger the_iqmp = encInt.DecodeDERLongL(aDER, aPos);

	CleanupStack::PushL(the_iqmp);

	// We now should be at the end of the encoding. If not, the 

	// input encoding contains extra fields, and they are not 

	// supported.

	if (aPos != end)

		User::Leave(KErrArgument);

//	Construct private key

	CRSAPrivateKey* privateKey = NULL;

	if (EStandardCRT==aKeyType)

	{

		privateKey = CRSAPrivateKeyCRT::NewL(privateModulus, p, q, dmp1, dmq1, the_iqmp);

	}

	else if (EStandard==aKeyType)

	{

		privateKey = CRSAPrivateKeyStandard::NewL(privateModulus, privateExponent);

	}

	else

		User::Leave(KErrNotSupported);

	CleanupStack::Pop(8,publicKey);	 // publicKey, privateModulus, privateExponent,

	                                 // p, q, dmp1, dmq1, iqmp

//	Cleanup the TIntegers not owned by private key objects

	if (EStandard==aKeyType)

	{

		p.Close();

		q.Close();

		dmp1.Close();

		dmq1.Close();

		the_iqmp.Close();

	}

	else

	{

		privateExponent.Close();

	}

	aPublicKey = publicKey;

	aPrivateKey = privateKey;	

}

// TX509RSAKeyEncoder Class Implementation

EXPORT_C TX509RSAKeyEncoder::TX509RSAKeyEncoder(const CRSAPublicKey& aPublicKey, TAlgorithmId aDigestAlg)

	: TX509KeyEncoder(aDigestAlg),

	  iPublicKey(aPublicKey)

	{

	}

EXPORT_C CASN1EncBase* TX509RSAKeyEncoder::EncodeKeyLC() const

	{

	// Create higher-level sequence that will contain OID and the public key

	CASN1EncSequence* subjectPubKeyInfo = CASN1EncSequence::NewLC();

	// The next-level sequence will contain OID of the algorithm followed by NULL

	CASN1EncSequence* seq = CASN1EncSequence::NewLC();

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

	seq->AddAndPopChildL(oid);

	CASN1EncNull* null = CASN1EncNull::NewLC();

	seq->AddAndPopChildL(null);

	subjectPubKeyInfo->AddAndPopChildL(seq);

	// Add the key itself to the higher-level sequence as a bit string

	// Obtain a copy of the entity's public key

	TASN1EncRSAPublicKey keyencoder;

	HBufC8* encoding = keyencoder.EncodeDERL(iPublicKey);

	CleanupStack::PushL(encoding);

	CASN1EncBitString* pubkeyenc = CASN1EncBitString::NewLC(*encoding);

	subjectPubKeyInfo->AddAndPopChildL(pubkeyenc);

	CleanupStack::PopAndDestroy(encoding);

	return subjectPubKeyInfo;

	}

// Returns ASN.1 sequence containing encoded signature algorithm.

EXPORT_C CASN1EncSequence* TX509RSAKeyEncoder::EncodeSignatureAlgorithmLC() const

	{

	CASN1EncSequence* seq = CASN1EncSequence::NewLC();

	CASN1EncObjectIdentifier* oid = NULL;

	// Determine OID string for the current combination of algorithms.

	switch(iDigestAlg)

		{

		default:

			User::Leave(KErrNotSupported);

			break;

		case EMD2:

			oid = CASN1EncObjectIdentifier::NewLC(KMD2WithRSA);

			break;

		case EMD5:

			oid = CASN1EncObjectIdentifier::NewLC(KMD5WithRSA);

			break;

		case ESHA1:

			oid = CASN1EncObjectIdentifier::NewLC(KSHA1WithRSA);

			break;

		}

	// Add algorithm OID to the sequence.

	seq->AddAndPopChildL(oid);

	// Add NULL after OID.

	CASN1EncNull* null = CASN1EncNull::NewLC();

	seq->AddAndPopChildL(null);

	return seq;

	}