/*

* Copyright (c) 1997-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 CWTLSCertificate::ConstructL(const TDesC8& aBinaryData, TInt& aPos)

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

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

* hash.

*

*/

#include <wtlscert.h>

#include <wtlskeys.h>

#include "wtlsdec.h"

#include <hash.h>

enum TEncAlgorithmType

	{

	EEncRSA = 0x02

	};

enum TEncSigAlgorithmType

	{

	EEncRSAwithSHA1 = 0x02

	};

const TInt KMinAlgIdLength = 2;

const TInt KMinExpLengthBytes = 1;

const TInt KMaxExpLengthBytes = 65535;

const TInt KMinModLengthBytes = 1;

const TInt KMaxModLengthBytes = 65535;

//WTLS RSA signature result

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

	{

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

	CleanupStack::Pop();

	return self;

	}

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

	{

	CWTLSRSASignatureResult* self = new(ELeave) CWTLSRSASignatureResult;

	CleanupStack::PushL(self);

	self->ConstructL(aDigestAlgorithm, aDigest);

	return self;

	}

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

	{

	return aResult == *iDigest;

	}

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

	{

	iDigestAlgorithm = CAlgorithmIdentifier::NewL(aDigestAlgorithm);

	iDigest = aDigest.AllocL();

	}

//WTLS KeyFactory

CRSAPublicKey* TWTLSKeyFactory::RSAPublicKeyL(const TDesC8& aEncoding) const

	{

	return CWTLSRSAPublicKey::NewL(aEncoding);

	}

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

	{

	return CWTLSRSASignatureResult::NewL(aDigestAlgorithm, aDigest);

	}

CDSAPublicKey* TWTLSKeyFactory::DSAPublicKeyL(const CDSAParameters& /*aParams*/, const TDesC8& /*aEncoding*/) const

	{

	User::Leave(KErrNotSupported);

	return NULL;

	}

CDSAPublicKey* TWTLSKeyFactory::DSAPublicKeyL(const TDesC8& /*aParams*/, const TDesC8& /*aEncoding*/) const

	{

	User::Leave(KErrNotSupported);

	return NULL;

	}

CDSASignature* TWTLSKeyFactory::DSASignatureL(const TDesC8& /*aEncoding*/) const

{

	User::Leave(KErrNotSupported);

	return NULL;	

}

CDSAParameters* TWTLSKeyFactory::DSAParametersL(const TDesC8& /*aParamsEncoding*/) const

{

	User::Leave(KErrNotSupported);

	return NULL;	

}

//validity period

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

	{

	TInt pos = 0;

	return CWTLSValidityPeriod::NewL(aBinaryData, pos);

	}

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

	{

	TInt pos = 0;

	return CWTLSValidityPeriod::NewLC(aBinaryData, pos);

	}

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

	{

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

	CleanupStack::Pop();

	return self;

	}

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

	{

	CWTLSValidityPeriod* self = new(ELeave) CWTLSValidityPeriod;

	CleanupStack::PushL(self);

	self->ConstructL(aBinaryData, aPos);

	return self;

	}

CWTLSValidityPeriod::CWTLSValidityPeriod()

	{

	}

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

	{

	TWTLSDecTime timeDec;

	iStart = timeDec.DecodeL(aBinaryData, aPos);

	iFinish = timeDec.DecodeL(aBinaryData, aPos);

	}

//algorithm id

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

	{

	TInt pos = 0;

	return CWTLSAlgorithmIdentifier::NewL(aBinaryData, pos);

	}

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

	{

	TInt pos = 0;

	return CWTLSAlgorithmIdentifier::NewLC(aBinaryData, pos);

	}

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

	{

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

	CleanupStack::Pop();

	return self;

	}

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

	{

	CWTLSAlgorithmIdentifier* self = new(ELeave) CWTLSAlgorithmIdentifier;

	CleanupStack::PushL(self);

	self->ConstructL(aBinaryData, aPos);

	return self;

	}

CWTLSAlgorithmIdentifier::CWTLSAlgorithmIdentifier()

	{

	}

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

	{

	if ((aBinaryData.Length() - aPos) < KMinAlgIdLength)

		{

		User::Leave(KErrArgument);

		}

	switch (aBinaryData[aPos])

		{

		case EEncRSA:

			{

			iAlgorithmId = ERSA;

			aPos++;

			if (aBinaryData[aPos] != 0)

				{

				User::Leave(KErrArgument);

				}

			aPos++;

			iEncodedParams = HBufC8::NewL(1);

			*iEncodedParams = KNullDesC8;

			break;

			}

		default:

			//we only support RSA just now...

			{

			User::Leave(KErrNotSupported);

			}

		}

	}

//signing algorithm id

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

	{

	TInt pos = 0;

	return CWTLSSigningAlgorithmIdentifier::NewL(aBinaryData, pos);

	}

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

	{

	TInt pos = 0;

	return CWTLSSigningAlgorithmIdentifier::NewLC(aBinaryData, pos);

	}

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

	{

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

	CleanupStack::Pop();

	return self;

	}

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

	{

	CWTLSSigningAlgorithmIdentifier* self = new(ELeave) CWTLSSigningAlgorithmIdentifier;

	CleanupStack::PushL(self);

	self->ConstructL(aBinaryData, aPos);

	return self;

	}

CWTLSSigningAlgorithmIdentifier::CWTLSSigningAlgorithmIdentifier()

	{

	}

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

	{

	if ((aBinaryData.Length() - aPos) < 1)

		{

		User::Leave(KErrArgument);

		}

	switch (aBinaryData[aPos])

		{

		case EEncRSAwithSHA1:

			{

			TAlgorithmId asym = ERSA;

			TAlgorithmId dig = ESHA1;

			iAsymmetricAlgorithm = CAlgorithmIdentifier::NewL(asym, KNullDesC8);

			iDigestAlgorithm = CAlgorithmIdentifier::NewL(dig, KNullDesC8);

			aPos++;

			break;

			}

		default:

			//we only support RSA-SHA1 just now...

			{

			User::Leave(KErrNotSupported);

			}

		}

	}

//wtls subject public key info

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

	{

	TInt pos = 0;

	return CWTLSSubjectPublicKeyInfo::NewL(aBinaryData, pos);

	}

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

	{

	TInt pos = 0;

	return CWTLSSubjectPublicKeyInfo::NewLC(aBinaryData, pos);

	}

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

	{

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

	CleanupStack::Pop();

	return self;

	}

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

	{

	CWTLSSubjectPublicKeyInfo* self = new(ELeave) CWTLSSubjectPublicKeyInfo;

	CleanupStack::PushL(self);

	self->ConstructL(aBinaryData, aPos);

	return self;

	}

CWTLSSubjectPublicKeyInfo::CWTLSSubjectPublicKeyInfo()

	{

	}

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

	{

	iAlgId = CWTLSAlgorithmIdentifier::NewL(aBinaryData, aPos);

	if (iAlgId->Algorithm() != ERSA)

		{

		User::Leave(KErrNotSupported);

		}

	TInt totalLength = aBinaryData.Length();

	TInt tempPos = aPos;

	const TPtrC8 expEnc = aBinaryData.Right(totalLength - aPos);

	TWTLSDecVector exp(expEnc, KMinExpLengthBytes, KMaxExpLengthBytes);

	exp.InitL();

	aPos += exp.EncodingLength();

	const TPtrC8 modEnc = aBinaryData.Right(totalLength - aPos);

	TWTLSDecVector mod(modEnc, KMinModLengthBytes, KMaxModLengthBytes);

	mod.InitL();

	aPos+= mod.EncodingLength();

	iEncodedKeyData = (aBinaryData.Mid(tempPos, aPos - tempPos)).AllocL();

	}

//wtls certificate

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

	{

	TInt pos = 0;

	return CWTLSCertificate::NewL(aBinaryData, pos);

	}

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

	{

	TInt pos = 0;

	return CWTLSCertificate::NewLC(aBinaryData, pos);

	}

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

	{

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

	CleanupStack::Pop();

	return self;

	}

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

	{

	CWTLSCertificate* self = new(ELeave) CWTLSCertificate;

	CleanupStack::PushL(self);

	self->ConstructL(aBinaryData, aPos);

	return self;

	}

EXPORT_C CWTLSCertificate* CWTLSCertificate::NewL(RReadStream& aStream)

	{

	CWTLSCertificate* self = CWTLSCertificate::NewLC(aStream);

	CleanupStack::Pop();//self

	return self;

	}

EXPORT_C CWTLSCertificate* CWTLSCertificate::NewLC(RReadStream& aStream)

	{

	CWTLSCertificate* self = new(ELeave) CWTLSCertificate;

	CleanupStack::PushL(self);

	self->InternalizeL(aStream);

	return self;

	}

/*

EXPORT_C CWTLSCertificate* CWTLSCertificate::NewL(CCertStore& aStore, const CCertStoreEntry& aEntry)

	{

	CWTLSCertificate* self = CWTLSCertificate::NewLC(aStore, aEntry);

	CleanupStack::Pop();//self

	return self;

	}

EXPORT_C CWTLSCertificate* CWTLSCertificate::NewLC(CCertStore& aStore, const CCertStoreEntry& aEntry)

	{

	CWTLSCertificate* self = new(ELeave) CWTLSCertificate;

	CleanupStack::PushL(self);

	aStore.LoadL(*self, aEntry);

	return self;

	}

*/

EXPORT_C CWTLSCertificate* CWTLSCertificate::NewL(const CWTLSCertificate& aCert)

	{

	CWTLSCertificate* self = CWTLSCertificate::NewLC(aCert);

	CleanupStack::Pop();//self

	return self;

	}

EXPORT_C CWTLSCertificate* CWTLSCertificate::NewLC(const CWTLSCertificate& aCert)

	{

	CWTLSCertificate* self = new(ELeave) CWTLSCertificate;

	CleanupStack::PushL(self);

	self->ConstructL(aCert);

	return self;

	}

EXPORT_C CWTLSCertificate::~CWTLSCertificate()

	{

	delete iIssuerName;

	delete iSubjectName;

	if (iDataElements != NULL)

		{

		for (TInt i = 0; i < KWTLSCertMaxDataElements; i++)

			{

			delete iDataElements->At(i);

			}

		delete iDataElements;

		}

	}

EXPORT_C TBool CWTLSCertificate::IsEqualL(const CWTLSCertificate& aCert) const

	{

	return	(*(iFingerprint) == (*(aCert.iFingerprint)));

	}

	//extra accessors

EXPORT_C const TPtrC8 CWTLSCertificate::SignedDataL() const

	{

	return iEncoding->Left(iEncoding->Length() - (iSignature->Length() +2));

	}

EXPORT_C TInt CWTLSCertificate::Version() const

	{

	return iVersion;

	}

EXPORT_C const CWTLSName& CWTLSCertificate::IssuerName() const

	{

	return *iIssuerName;

	}

EXPORT_C const CWTLSName& CWTLSCertificate::SubjectName() const

	{

	return *iSubjectName;

	}

EXPORT_C HBufC* CWTLSCertificate::IssuerL() const

	{

	return iIssuerName->DisplayNameL();

	}

EXPORT_C HBufC* CWTLSCertificate::SubjectL() const

	{

	return iSubjectName->DisplayNameL();

	}

EXPORT_C TBool CWTLSCertificate::IsSelfSignedL() const

	{

	return iSubjectName->ExactMatchL(*iIssuerName);

	}

EXPORT_C const TPtrC8* CWTLSCertificate::DataElementEncoding(const TUint aIndex) const

	{

	return iDataElements->At(aIndex);

	}

EXPORT_C void CWTLSCertificate::InternalizeL(RReadStream& aStream)

	{

	if (iIssuerName != NULL) //just to check cert is uninitialised

		{

		User::Leave(KErrArgument);

		}

	iKeyFactory = new(ELeave) TWTLSKeyFactory;

	TInt len = aStream.ReadInt32L();

	iEncoding = HBufC8::NewL(aStream,len);

	TInt pos = 0;

	ConstructCertL(*iEncoding, pos);

	TWTLSDecUnsignedInteger decInt;

	TInt sigLength = decInt.DecodeShortL(*iEncoding, pos, 2);

	iSignature = (iEncoding->Mid(pos, sigLength)).AllocL();

	CSHA1* hash = CSHA1::NewL();

	CleanupStack::PushL(hash);

	iFingerprint = hash->Final(Encoding()).AllocL();

	CleanupStack::PopAndDestroy();

	InitEncodedDataElementsL();

	}

EXPORT_C TBool CWTLSCertificate::IsTCAL() const

	{

	TBool isTCA = EFalse;

	TPtrC8 nameData = SubjectName().NameData();

	CWTLSStructuredText* sText = NULL; //inited to get rid of warning

	TRAPD(err, sText = CWTLSStructuredText::NewL(nameData) );

	if( err == KErrNone )

	    {

		const TWTLSStructuredTextField* sTextField = sText->FieldByName(KWTLSTCAType);

		if(sTextField != NULL)

			{

			if(sTextField->Value().Compare(KWTLSTCAValue) == 0)

				{

				isTCA = ETrue;

				}