/*

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

* -- FingerPrint Note:

* Developers have to be aware that if they are going to change the fingerprint for this certificate

* for a different hash, then there are other places that need to reflect this change

* -- Location

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

* EXPORT_C void CX509Certificate::InternalizeL(RReadStream& aStream)

* Also change the CWTLSCertificate and search for other occurences of the current

* hash.

* -- TeletexString type support Note:

* If the certificate has decoded the members from TeletexString then the return value 

* may be incorrect because TeletexString type is not fully supported by this library.

* Instead the decode methods perform a direct conversion from 8 to 16bits by adding 

* null characters in the second byte of each character. This will work as expected 

* for cases where the string contains ASCII data.

*

*/

#include <x509cert.h>

#include <x509certext.h>

#include "X509time.h"

#include <x509keys.h>

#include <keyidentifierutil.h>

#include <asn1enc.h>

#include <asn1dec.h>

EXPORT_C CPKCS1SignatureResult* CPKCS1SignatureResult::NewL(const CAlgorithmIdentifier& aDigestAlgorithm, const TDesC8& aDigest)

	{

	CPKCS1SignatureResult* self = CPKCS1SignatureResult::NewLC(aDigestAlgorithm, aDigest);

	CleanupStack::Pop();

	return self;

	}

EXPORT_C CPKCS1SignatureResult* CPKCS1SignatureResult::NewLC(const CAlgorithmIdentifier& aDigestAlgorithm, const TDesC8& aDigest)

	{

	CPKCS1SignatureResult* self = new(ELeave) CPKCS1SignatureResult;

	CleanupStack::PushL(self);

	self->ConstructL(aDigestAlgorithm, aDigest);

	return self;

	}

void CPKCS1SignatureResult::ConstructL(const CAlgorithmIdentifier& aDigestAlgorithm, const TDesC8& aDigest)

	{

	iDigestAlgorithm = CAlgorithmIdentifier::NewL(aDigestAlgorithm);

	iDigest = aDigest.AllocL();

	}

EXPORT_C TBool CPKCS1SignatureResult::VerifyL(const TDesC8& aResult)

	{

	TBool res = EFalse;

	TRAPD(err, res = DoVerifyL(aResult));

	if ((err != KErrNone) && (err != KErrArgument))

		{

		User::Leave(err);

		}

	return res;

	}

TBool CPKCS1SignatureResult::DoVerifyL(const TDesC8& aResult)

	{

	TBool res = EFalse;

	TASN1DecSequence decSeq;

	TInt pos = 0;

	TInt len = aResult.Length();

	const CArrayPtrFlat<TASN1DecGeneric>* seq = decSeq.DecodeDERLC(aResult, pos);

	if (seq->Count() == 2)

		{

		const TASN1DecGeneric* gen1 = seq->At(0);

		const TASN1DecGeneric* gen2 = seq->At(1);

		CAlgorithmIdentifier* algId = CX509AlgorithmIdentifier::NewLC(gen1->Encoding());

		HBufC8* digest = gen2->GetContentDER().AllocL();

		if ((*algId == *iDigestAlgorithm) && (*digest == *iDigest)  && (pos == len))

			{

			res = ETrue;

			}

		delete digest;

		CleanupStack::PopAndDestroy();

		}

	CleanupStack::PopAndDestroy();

	return res;

	}

EXPORT_C CRSAPublicKey* TX509KeyFactory::RSAPublicKeyL(const TDesC8& aEncoding) const

	{

	return CX509RSAPublicKey::NewL(aEncoding);

	}

EXPORT_C CRSASignatureResult* TX509KeyFactory::RSASignatureResultL(const CAlgorithmIdentifier& aDigestAlgorithm, TDesC8& aDigest) const

	{

	return CPKCS1SignatureResult::NewL(aDigestAlgorithm, aDigest);

	}

EXPORT_C CDSAPublicKey* TX509KeyFactory::DSAPublicKeyL(const TDesC8& aParamsEncoding, const TDesC8& aEncoding) const

	{

	return CX509DSAPublicKey::NewL(aParamsEncoding, aEncoding);

	}

EXPORT_C CDSAPublicKey* TX509KeyFactory::DSAPublicKeyL(const CDSAParameters& aParams, const TDesC8& aEncoding) const

	{

	return CX509DSAPublicKey::NewL(aParams, aEncoding);

	}

EXPORT_C CDSASignature* TX509KeyFactory::DSASignatureL(const TDesC8& aEncoding) const

	{

	return CX509DSASignature::NewL(aEncoding);

	}

EXPORT_C CDSAParameters* TX509KeyFactory::DSAParametersL(const TDesC8& aParamsEncoding) const

{

	return (CX509DSAPublicKey::DSAParametersL(aParamsEncoding));

}

//CX509ValidityPeriod

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

	{

	TInt pos = 0;

	return CX509ValidityPeriod::NewL(aBinaryData, pos);

	}

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

	{

	TInt pos = 0;

	return CX509ValidityPeriod::NewLC(aBinaryData, pos);

	}

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

	{

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

	CleanupStack::Pop();

	return self;

	}

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

	{

	CX509ValidityPeriod* self = new(ELeave) CX509ValidityPeriod;

	CleanupStack::PushL(self);

	self->ConstructL(aBinaryData, aPos);

	return self;

	}

CX509ValidityPeriod::CX509ValidityPeriod()

	{

	}

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

	{

	TASN1DecSequence encSeq;

	CArrayPtrFlat<TASN1DecGeneric>* seq = encSeq.DecodeDERLC(aBinaryData, aPos);

	if (seq->Count() != 2)

		{

		User::Leave(KErrArgument);

		}

	TASN1DecX509Time decTime;

	iStart = decTime.DecodeDERL(*(seq->At(0)));

	iFinish = decTime.DecodeDERL(*(seq->At(1)));

	CleanupStack::PopAndDestroy();//seq + contents

	}

//algorithm id

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

	{

	TInt pos = 0;

	return CX509AlgorithmIdentifier::NewL(aBinaryData, pos);

	}

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

	{

	TInt pos = 0;

	return CX509AlgorithmIdentifier::NewLC(aBinaryData, pos);

	}

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

	{

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

	CleanupStack::Pop();

	return self;

	}

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

	{

	CX509AlgorithmIdentifier* self = new(ELeave) CX509AlgorithmIdentifier;

	CleanupStack::PushL(self);

	self->InitializeL(aBinaryData, aPos);

	return self;

	}

EXPORT_C CX509AlgorithmIdentifier* CX509AlgorithmIdentifier::NewL(TAlgorithmId aAlgorithmId, const TDesC8& aEncodedParams)

 	{

	CX509AlgorithmIdentifier* self = CX509AlgorithmIdentifier::NewLC(aAlgorithmId, aEncodedParams);

 	CleanupStack::Pop();

 	return self;	

 	}

EXPORT_C CX509AlgorithmIdentifier* CX509AlgorithmIdentifier::NewLC(TAlgorithmId aAlgorithmId, const TDesC8& aEncodedParams)

 	{

 	CX509AlgorithmIdentifier* self = new(ELeave) CX509AlgorithmIdentifier(aAlgorithmId);

 	CleanupStack::PushL(self);

 	self->ConstructL(aEncodedParams);

 	return self;				

 	}

CX509AlgorithmIdentifier::CX509AlgorithmIdentifier(TAlgorithmId& aAlgorithmId):CAlgorithmIdentifier(aAlgorithmId)

 	{

 	}

CX509AlgorithmIdentifier::CX509AlgorithmIdentifier()

	{

	}

void CX509AlgorithmIdentifier::InitializeL(const TDesC8& aBinaryData, TInt& aPos)

	{

	TASN1DecSequence encSeq;

	CArrayPtrFlat<TASN1DecGeneric>* seq = encSeq.DecodeDERLC(aBinaryData, aPos, 1, KMaxTInt);

	TInt count = seq->Count();

	TASN1DecObjectIdentifier encOID;

	HBufC* oid = encOID.DecodeDERL(*(seq->At(0)));

	CleanupStack::PushL(oid);

	TPtrC oidDes(oid->Des()); 

	if (oidDes == KDSA)

		{

		//optional params

		if (count > 1)//if we still have stuff left

			{

			TASN1DecGeneric* gen = seq->At(1);

			iEncodedParams = gen->Encoding().AllocL();

			}

		else

			{

			iEncodedParams = HBufC8::NewL(1);

			*iEncodedParams = KNullDesC8;

			}

		iAlgorithmId = EDSA;

		CleanupStack::PopAndDestroy(2);//seq, oid

		return;

		}

	if (count > 1)

		{

		TASN1DecGeneric* gen = seq->At(1);

		if (oidDes == KDH)

			{

			iEncodedParams = gen->Encoding().AllocL();

			iAlgorithmId = EDH;

			CleanupStack::PopAndDestroy(2);//seq, oid

			return;

			}

		if (oidDes == KRSA)

			{

			iAlgorithmId = ERSA;

			TASN1DecNull null;

			null.DecodeDERL(*gen);//just to check the syntax is OK

			iEncodedParams = HBufC8::NewL(1);

			*iEncodedParams = KNullDesC8;

			CleanupStack::PopAndDestroy(2);//seq, oid

			return;

			}

		if (oidDes == KMD5)

			{

			iAlgorithmId = EMD5;

			TASN1DecNull null;

			null.DecodeDERL(*gen);//just to check the syntax is OK

			iEncodedParams = HBufC8::NewL(1);

			*iEncodedParams = KNullDesC8;

			CleanupStack::PopAndDestroy(2);//seq, oid

			return;

			}

		if (oidDes == KMD2)

			{

			iAlgorithmId = EMD2;

			TASN1DecNull null;

			null.DecodeDERL(*gen);//just to check the syntax is OK

			iEncodedParams = HBufC8::NewL(1);

			*iEncodedParams = KNullDesC8;

			CleanupStack::PopAndDestroy(2);//seq, oid

			return;

			}

		if (oidDes == KSHA1)

			{

			iAlgorithmId = ESHA1;

			TASN1DecNull null;

			null.DecodeDERL(*gen);//just to check the syntax is OK

			iEncodedParams = HBufC8::NewL(1);

			*iEncodedParams = KNullDesC8;

			CleanupStack::PopAndDestroy(2);//seq, oid

			return;

			}

		}

	User::Leave(KErrNotSupported);

	}

EXPORT_C CASN1EncSequence* CX509AlgorithmIdentifier::EncodeASN1DERLC() const

	{

	// the root sequence contains the signed object

	CASN1EncSequence* root = CASN1EncSequence::NewLC();

	//encode the oid

	CASN1EncObjectIdentifier* oid(NULL);

	switch (iAlgorithmId)

		{

	case EDSA:

		oid=CASN1EncObjectIdentifier::NewLC(KDSA);

		break;

	case EDH:

		oid=CASN1EncObjectIdentifier::NewLC(KDH);

		break;

	case ERSA:

		oid=CASN1EncObjectIdentifier::NewLC(KRSA);

		break;

	case EMD5:

		oid=CASN1EncObjectIdentifier::NewLC(KMD5);

		break;

	case EMD2:

		oid=CASN1EncObjectIdentifier::NewLC(KMD2);

		break;

	case ESHA1:

		oid=CASN1EncObjectIdentifier::NewLC(KSHA1);

		break;

	default:

		User::Leave(KErrNotSupported);

		}

	root->AddAndPopChildL(oid);

	//Encode parameters

	if (*iEncodedParams!=KNullDesC8)

		{

		CASN1EncEncoding* enc=CASN1EncEncoding::NewLC(*iEncodedParams);

		root->AddAndPopChildL(enc);

		}

	else

		{

		if (iAlgorithmId!=EDSA)

			{

			CASN1EncNull* enc=CASN1EncNull::NewLC();

			root->AddAndPopChildL(enc);				

			}

		}

	return root;		

	}

//signing algorithm id

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

	{

	TInt pos = 0;

	return CX509SigningAlgorithmIdentifier::NewL(aBinaryData, pos);

	}

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

	{

	TInt pos = 0;

	return CX509SigningAlgorithmIdentifier::NewLC(aBinaryData, pos);

	}

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

	{

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

	CleanupStack::Pop();

	return self;

	}

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

	{

	CX509SigningAlgorithmIdentifier* self = new(ELeave) CX509SigningAlgorithmIdentifier;

	CleanupStack::PushL(self);

	self->ConstructL(aBinaryData, aPos);

	return self;

	}

EXPORT_C CX509SigningAlgorithmIdentifier* CX509SigningAlgorithmIdentifier::NewL(const CAlgorithmIdentifier& aAsymmetricAlgorithm, const CAlgorithmIdentifier& aDigestAlgorithm)

 	{

 	CX509SigningAlgorithmIdentifier* self = CX509SigningAlgorithmIdentifier::NewLC(aAsymmetricAlgorithm, aDigestAlgorithm);

 	CleanupStack::Pop();

 	return self;

 	}

EXPORT_C CX509SigningAlgorithmIdentifier* CX509SigningAlgorithmIdentifier::NewLC(const CAlgorithmIdentifier& aAsymmetricAlgorithm, const CAlgorithmIdentifier& aDigestAlgorithm)

 	{

 	CX509SigningAlgorithmIdentifier* self = new(ELeave) CX509SigningAlgorithmIdentifier;

 	CleanupStack::PushL(self);

 	self->ConstructL(aAsymmetricAlgorithm, aDigestAlgorithm);

 	return self;

 	}

CX509SigningAlgorithmIdentifier::CX509SigningAlgorithmIdentifier()

	{

	}

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

	{

	TASN1DecSequence encSeq;

	CArrayPtrFlat<TASN1DecGeneric>* seq = encSeq.DecodeDERLC(aBinaryData, aPos, 1, KMaxTInt);

	TInt count = seq->Count();

	TASN1DecObjectIdentifier encOID;

	HBufC* oid = encOID.DecodeDERL(*(seq->At(0)));

	CleanupStack::PushL(oid);

	TPtrC oidDes(oid->Des()); 

	//none of the signing algorithms we support have parameters here...

	HBufC8* encodedParams = HBufC8::NewLC(1);

	*encodedParams = KNullDesC8;

	if (oidDes == KDSAWithSHA1)

		{

		//should be no params, but we allow params encoded as NULL for interop reasons

		TAlgorithmId algId = EDSA;

		TAlgorithmId digestId = ESHA1;

		iDigestAlgorithm = CAlgorithmIdentifier::NewL(digestId, encodedParams->Des());

		iAsymmetricAlgorithm = CAlgorithmIdentifier::NewL(algId, encodedParams->Des());

		if (count == 1)

			{			

			CleanupStack::PopAndDestroy(3);//seq, oid, encodedParams

			return;

			}

		}

	if (oidDes == KMD2WithRSA)

		{

		TAlgorithmId algId = ERSA;

		TAlgorithmId digestId = EMD2;

		iDigestAlgorithm = CAlgorithmIdentifier::NewL(digestId, encodedParams->Des());

		iAsymmetricAlgorithm = CAlgorithmIdentifier::NewL(algId, encodedParams->Des());

		}

	if (oidDes == KMD5WithRSA)

		{

		TAlgorithmId algId = ERSA;

		TAlgorithmId digestId = EMD5;

		iDigestAlgorithm = CAlgorithmIdentifier::NewL(digestId, encodedParams->Des());

		iAsymmetricAlgorithm = CAlgorithmIdentifier::NewL(algId, encodedParams->Des());

		}

	if (oidDes == KSHA1WithRSA)

		{

		TAlgorithmId algId = ERSA;

		TAlgorithmId digestId = ESHA1;

		iDigestAlgorithm = CAlgorithmIdentifier::NewL(digestId, encodedParams->Des());

		iAsymmetricAlgorithm = CAlgorithmIdentifier::NewL(algId, encodedParams->Des());

		}

		//???not sure if we should just leave here...

	if (iDigestAlgorithm == NULL)

		{	

		User::Leave(KErrNotSupported);

		}

	else

		{

		if (count != 2)

			{

			// Shouldn't ever get here, since RFC2459 mandates having 2

			// data items.  However, some people miss out the second

			// when it's NULL, so we'll not report and error here

			}

		else

			{

			TASN1DecGeneric* gen = seq->At(1);

			TASN1DecNull null;

			null.DecodeDERL(*gen);//just to check the syntax is OK

			}

		}

	CleanupStack::PopAndDestroy(3);//seq, oid, encodedParams

	}

void CX509SigningAlgorithmIdentifier::ConstructL(const CAlgorithmIdentifier& aAsymmetricAlgorithm, const CAlgorithmIdentifier& aDigestAlgorithm)

 	{

 	iDigestAlgorithm = CAlgorithmIdentifier::NewL(aDigestAlgorithm);

 	iAsymmetricAlgorithm = CAlgorithmIdentifier::NewL(aAsymmetricAlgorithm);

 	};

//subject public key info

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

	{

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

	CleanupStack::Pop();

	return self;

	}

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

	{

	CX509SubjectPublicKeyInfo* self = new(ELeave) CX509SubjectPublicKeyInfo;

	CleanupStack::PushL(self);

	self->ConstructL(aBinaryData, aPos);

	return self;

	}

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

	{

	TInt pos = 0;

	return CX509SubjectPublicKeyInfo::NewL(aBinaryData, pos);

	}

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

	{

	TInt pos = 0;

	return CX509SubjectPublicKeyInfo::NewLC(aBinaryData, pos);

	}

CX509SubjectPublicKeyInfo::CX509SubjectPublicKeyInfo()

	{

	}

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

	{