/*

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

* X509CERTEXT.CPP

*

*/

#include <s32strm.h>

#include <x509certext.h>

#include <asn1dec.h>

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

	{

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

	dec.InitL();

	if (dec.Tag() != EASN1OctetString)

		{

		User::Leave(KErrArgument);

		}

	TInt end = aPos + dec.LengthDER();

	aPos += dec.LengthDERHeader();//add on header for octet string here

//pass in binary data with aPos set to start of contents octets of octet string

//we cheat a little here; since we know an octet string is just the contents octets, 

//we just pass in a reference to the contents octets, and save alloc'ing the whole thang

	DoConstructL(aBinaryData, aPos);	

	if (aPos != end)

		{

		User::Leave(KErrArgument);

		}

	}

//1) basic constraints...

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

	{

	TInt pos = 0;

	return CX509BasicConstraintsExt::NewL(aBinaryData, pos);

	}

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

	{

	TInt pos = 0;

	return CX509BasicConstraintsExt::NewLC(aBinaryData, pos);

	}

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

	{

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

	CleanupStack::Pop();

	return self;

	}

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

	{

	CX509BasicConstraintsExt* self = new(ELeave) CX509BasicConstraintsExt;

	CleanupStack::PushL(self);

	self->ConstructL(aBinaryData, aPos);

	return self;

	}

void CX509BasicConstraintsExt::DoConstructL(const TDesC8& aBinaryData, TInt& aPos)

	{

//sequence of 2 optional components, a bool and an int

	TASN1DecSequence encSeq;

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

	TInt count = seq->Count();

	TInt pos = 0;

	if (pos < count)

		{

		TBool doneInt = EFalse;

		TASN1DecGeneric* curr = seq->At(pos);

		pos++;

		if (curr->Tag() == EASN1Boolean)

			{

			TASN1DecBoolean encBool;

			iIsCA = encBool.DecodeDERL(*curr);

			}

		else

			{

			TASN1DecInteger encInt;

			iMaxChainLen = encInt.DecodeDERShortL(*curr);

			doneInt = ETrue;

			}

		if (pos < count)

			{

			if (doneInt)

				{

				User::Leave(KErrArgument);

				}

			curr = seq->At(pos);

			pos++;

			TASN1DecInteger encInt;

			iMaxChainLen = encInt.DecodeDERShortL(*curr);

			if (iMaxChainLen < 0)

				{

				User::Leave(KErrArgument);

				}

			}

		}

	if (pos != count)

		{

		User::Leave(KErrArgument);

		}

	CleanupStack::PopAndDestroy();//seq

	}

CX509BasicConstraintsExt::CX509BasicConstraintsExt()

	:iIsCA(EFalse), iMaxChainLen(KMaxTInt)

	{

	}

CX509BasicConstraintsExt::~CX509BasicConstraintsExt()

	{

	}

EXPORT_C TBool CX509BasicConstraintsExt::IsCA() const

	{

	return iIsCA;

	}

EXPORT_C TInt CX509BasicConstraintsExt::MaxChainLength() const

	{

	return iMaxChainLen;

	}

//2) alt name

//#pragma message ("creating empty CX509AltNameExt and destroying it kills process")

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

	{

	TInt pos = 0;

	return CX509AltNameExt::NewL(aBinaryData, pos);

	}

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

	{

	TInt pos = 0;

	return CX509AltNameExt::NewLC(aBinaryData, pos);

	}

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

	{

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

	CleanupStack::Pop();

	return self;

	}

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

	{

	CX509AltNameExt* self = new(ELeave) CX509AltNameExt;

	CleanupStack::PushL(self);

	self->ConstructL(aBinaryData, aPos);

	return self;

	}

void CX509AltNameExt::DoConstructL(const TDesC8& aBinaryData, TInt& aPos)

	{

	// The sequence should have at least 1 name here, previously this was checked

	// but now zero lengths sequences are tolerated.

	//

	// RFC 3280 requires that CAs ensure that the SubjectAltName is not empty if it exists. The 

	// behaviour of the client is undefined if this condition occurs. Since this code will 

	// normally be used as a client (i.e. not the CA) and there should be no need to validate 

	// the SubjectAltName we do not enfore a minimum sequence length.

	// This avoids TLS connections being dropped unecessarily.

	TASN1DecSequence encSeq;

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

	TInt count = seq->Count();

	iAuthorityName = new(ELeave) CArrayPtrFlat<CX509GeneralName> (1);

	TASN1DecGeneric* gen;

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

		{

		gen = seq->At(i);

		CX509GeneralName* gn = CX509GeneralName::NewLC(gen->Encoding());

		iAuthorityName->AppendL(gn);

		CleanupStack::Pop();//gn

		}

	CleanupStack::PopAndDestroy();

	}

CX509AltNameExt::~CX509AltNameExt()

	{

	if (iAuthorityName != NULL)

		{

		iAuthorityName->ResetAndDestroy();

		delete iAuthorityName;

		}

	}

EXPORT_C const CArrayPtrFlat<CX509GeneralName>& CX509AltNameExt::AltName() const

	{

	return *iAuthorityName;

	}

EXPORT_C TBool CX509AltNameExt::Match(const CX509AltNameExt& aExt) const

	{

	TBool res = EFalse;

	const CArrayPtrFlat<CX509GeneralName>& otherGNs = aExt.AltName();

	TInt otherGNCount = otherGNs.Count();

	TInt thisGNCount = iAuthorityName->Count();

	if (otherGNCount != thisGNCount)

		{

		}

	else

		{

		res = ETrue;

		for (TInt j = 0; j < otherGNCount; j++)

				{

				const CX509GeneralName* otherGN = otherGNs.At(j);

				const CX509GeneralName* thisGN = iAuthorityName->At(j);

				if (!thisGN->ExactMatch(*otherGN))

					{

					res = EFalse;

					}

				}

		}

	return res;

	}

CX509AltNameExt::CX509AltNameExt()

	{

	}

//3) key usage

CX509BitString::~CX509BitString()

	{

	delete iData;

	}

TBool CX509BitString::IsSet(TInt aBit) const

	{

	if (aBit < iLength)//offset from zero

		{

		TPtrC8 d(iData->Des());

		TUint8 oct = d[(aBit/8)];

		TUint mask = (1 << (7-(aBit % 8)));

		return (oct & mask);

		}

	return EFalse;

	}

CX509BitString::CX509BitString(HBufC8* aData, TInt aLength)

	:iData(aData), iLength(aLength)

	{

	}

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

	{

	TInt pos = 0;

	return CX509KeyUsageExt::NewL(aBinaryData, pos);

	}

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

	{

	TInt pos = 0;

	return CX509KeyUsageExt::NewLC(aBinaryData, pos);

	}

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

	{

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

	CleanupStack::Pop();

	return self;

	}

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

	{

	CX509KeyUsageExt* self = new(ELeave) CX509KeyUsageExt;

	CleanupStack::PushL(self);

	self->ConstructL(aBinaryData, aPos);

	return self;

	}

void CX509KeyUsageExt::DoConstructL(const TDesC8& aBinaryData, TInt& aPos)

	{

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

	gen.InitL();

	if (gen.Tag() != EASN1BitString)

		{

		User::Leave(KErrArgument);

		}

	TPtrC8 p(gen.GetContentDER());

	if (p.Length() < 2)

		{

		User::Leave(KErrArgument);

		}

	TPtrC8 pData(p.Right(p.Length() - 1));

	TInt paddingLength = p[0];

	TInt bitStringLength = (pData.Length() * 8) - paddingLength;

	HBufC8* bitString = pData.AllocL();

	CleanupStack::PushL(bitString);

	iData = new(ELeave) CX509BitString(bitString, bitStringLength);

	CleanupStack::Pop();//bitstring

	aPos += gen.LengthDER();

	}

CX509KeyUsageExt::CX509KeyUsageExt()

	{

	}

CX509KeyUsageExt::~CX509KeyUsageExt()

	{

	delete iData;

	}

EXPORT_C TBool CX509KeyUsageExt::IsSet(TX509KeyUsage aUsage) const

	{

	return iData->IsSet(aUsage);

	}

//4) name constraints

CX509GeneralSubtree* CX509GeneralSubtree::NewL(const TDesC8& aBinaryData)

	{

	TInt pos = 0;

	return CX509GeneralSubtree::NewL(aBinaryData, pos);

	}

CX509GeneralSubtree* CX509GeneralSubtree::NewLC(const TDesC8& aBinaryData)

	{

	TInt pos = 0;

	return CX509GeneralSubtree::NewLC(aBinaryData, pos);

	}

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

	{

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

	CleanupStack::Pop();

	return self;

	}

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

	{

	CX509GeneralSubtree* self = new(ELeave) CX509GeneralSubtree;

	CleanupStack::PushL(self);

	self->ConstructL(aBinaryData, aPos);

	return self;

	}

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

	{

	TASN1DecSequence encSeq;

	CArrayPtrFlat<TASN1DecGeneric>* seq = encSeq.DecodeDERLC(aBinaryData, aPos, 1, KMaxTInt);//(seq here must have at least 1 name)

	TInt count = seq->Count();

	TInt pos = 0;

	TASN1DecGeneric* curr = seq->At(pos);

	pos++;

	iName = CX509GeneralName::NewL(curr->Encoding());

	if (pos < count)

		{

		TBool doneMax = EFalse;

		curr = seq->At(pos);

		pos++;

		if (curr->Class() != EContextSpecific)

				{

				User::Leave(KErrArgument);

				}

			switch(curr->Tag())

				{

				case 0:

					{

					TASN1DecInteger encInt;

					iMinDist = encInt.DecodeDERShortL(*curr);

					break;

					}

				case 1:

					{

					TASN1DecInteger encInt;

					iMaxDist = encInt.DecodeDERShortL(*curr);

					doneMax = ETrue;

					break;

					}

				}

			if (pos < count)

				{

				curr = seq->At(pos);

				if ((doneMax) || (curr->Class() != EContextSpecific) || (curr->Tag() != 1))

					{

					User::Leave(KErrArgument);

					}

				TASN1DecInteger encInt;

				iMaxDist = encInt.DecodeDERShortL(*curr);

				}

		}

	if (pos != count)

		{

		User::Leave(KErrArgument);

		}

	CleanupStack::PopAndDestroy();

	}

CX509GeneralSubtree::~CX509GeneralSubtree()

	{

	delete iName;

	}

EXPORT_C const CX509GeneralName& CX509GeneralSubtree::Name() const

	{

	return *iName;

	}

EXPORT_C TInt CX509GeneralSubtree::MinDistance() const

	{

	return iMinDist;

	}

EXPORT_C TInt CX509GeneralSubtree::MaxDistance() const

	{

	return iMaxDist;

	}

CX509GeneralSubtree::CX509GeneralSubtree()

	:iMaxDist(KMaxTInt), iMinDist(0)

	{

	}

//

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

	{

	TInt pos = 0;

	return CX509NameConstraintsExt::NewL(aBinaryData, pos);

	}

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

	{

	TInt pos = 0;

	return CX509NameConstraintsExt::NewLC(aBinaryData, pos);

	}

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

	{

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

	CleanupStack::Pop();

	return self;

	}

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

	{

	CX509NameConstraintsExt* self = new(ELeave) CX509NameConstraintsExt;

	CleanupStack::PushL(self);

	self->ConstructL(aBinaryData, aPos);

	return self;

	}

void CX509NameConstraintsExt::DoConstructL(const TDesC8& aBinaryData, TInt& aPos)

	{

	TASN1DecSequence encSeq;

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

	TInt count = seq->Count();

	TInt pos = 0;

	iExcludedSubtrees = new(ELeave) CArrayPtrFlat<CX509GeneralSubtree> (1);

	iPermittedSubtrees = new(ELeave) CArrayPtrFlat<CX509GeneralSubtree> (1);

	TBool doneExcluded = EFalse;

	if (pos < count)

		{

		TASN1DecGeneric* curr = seq->At(pos);

		pos++;

		if (curr->Class() != EContextSpecific)

			{

			User::Leave(KErrArgument);

			}

		switch (curr->Tag())

			{

			case 0:

				{

				AddSubtreesL(*iPermittedSubtrees, curr->Encoding());

				break;

				}

			case 1:

				{

				AddSubtreesL(*iExcludedSubtrees, curr->Encoding());

				doneExcluded = ETrue;

				break;

				}

			default:

				{

				User::Leave(KErrArgument);

				}

			}

		if (pos < count)

			{

			curr = seq->At(pos);

			pos++;

			if ((curr->Class() != EContextSpecific) || (curr->Tag() != 1) || (doneExcluded))

				{

				User::Leave(KErrArgument);

				}

			AddSubtreesL(*iExcludedSubtrees, curr->Encoding());

			}

		}

	CleanupStack::PopAndDestroy();//seq

	}

void CX509NameConstraintsExt::AddSubtreesL(	CArrayPtrFlat<CX509GeneralSubtree>& aSubtrees,

											const TDesC8& aBinaryData)

	{

	TASN1DecSequence encSeq;

	TInt pos = 0;

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

	TInt count = seq->Count();

	TASN1DecGeneric* gen;

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

		{

		gen = seq->At(i);

		CX509GeneralSubtree* subtree = CX509GeneralSubtree::NewLC(gen->Encoding());

		aSubtrees.AppendL(subtree);

		CleanupStack::Pop();

		}

	CleanupStack::PopAndDestroy();

	}

EXPORT_C CX509NameConstraintsExt::~CX509NameConstraintsExt()

	{

	if (iExcludedSubtrees != NULL)

		{

		iExcludedSubtrees->ResetAndDestroy();