/*

 * 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 <x509gn.h>

 #include "asn1dec.h"

 /*

  * __SECURITY_PLATSEC_ARCH__: Changes for platform security

  *

  * If this macro is defined, the represenation of TPtrC arrays is changed from

  * using CPtrCArray to RArray<TPtrC>.  This is because CPtrCArray is supplied by

  * bafl.dll, which is not trusted for TCB.  x509 needs to be trusted for TCB so

  * it can be used by software install, hence this dependency was removed.

  *

  * This changes is implmented as a series of macros for the basic operations,

  * to minimise the amount of conditional compilation.

  */

 #define REP_INIT_L		/* do nothing */

 #define REP_FINAL 		iRep.Close()

 #define REP_APPEND_L(X)	User::LeaveIfError(iRep.Append(X))

 #define REP_COUNT		iRep.Count()

 #define REP_AT(X)		iRep[X]

 #define REP_VAL			iRep

 #define REP_VAL_TYPE	RArray<TPtrC>

 _LIT(KX509RFC822HostDomainSeparator,"@");

 _LIT(KX509SubdomainSeparator,".");

 _LIT(KX509URISchemeSpecificStart, "//");

 _LIT(KX509URIUserPasswordEnd, "@");

 _LIT(KX509URIPortStart, ":");

 _LIT(KX509URIurlPathStart, "/");

 const TInt KX509URISchemeSpecificStartLength = 2;

 const TInt KX509URIUserPasswordEndLength = 1;

 const TInt KX509MaxDNSNameLabelLength = 63;

 //superclass: common functionality for DNS names & RFC 822 email addresses

 EXPORT_C CX509DomainName::~CX509DomainName()

 	{

 	REP_FINAL;

 	delete iName;

 	}

 CX509DomainName::CX509DomainName()

 	{

 	}

 EXPORT_C TPtrC CX509DomainName::Name() const 

 	{

 	return *iName;

 	}

 EXPORT_C TBool CX509DomainName::IsWithinSubtree(const CX509DomainName& aName) const

    	{

    	TInt myCount = REP_COUNT;

    	TInt otherCount = aName.REP_COUNT;

    	if (otherCount > myCount)

    		{

    		return EFalse;

    		}

    	for (TInt i = otherCount-1; i >= 0; i--)

    		{

    		myCount--;

    		if ( KErrNotFound == REP_AT(myCount).MatchF(aName.REP_AT(i)) )

    			{

    			return EFalse;

    			}

    		}

    	return ETrue;

    	}

 TBool CX509DomainName::AddDomainL(TInt& aPos)

 	{

 	TInt end = iName->Length();

 	FOREVER

 		{

 		if (!(AddSubdomainL(aPos)))

 			{

 			return EFalse;

 			}

 		if (aPos == end)

 			{

 			break;

 			}

 		AddSubdomainSeparatorL(aPos);

 		}

 	return ETrue;

 	}

 TBool CX509DomainName::AddSubdomainL(TInt& aPos)

 	{

 	TBool res = EFalse;

 	TInt end = iName->Length();

 	if (aPos >= end)

 		{

 		return res;

 		}

 	TPtrC whatsLeft(&(iName->operator[] (aPos)), end - aPos);

 	TInt subdomainEnd = whatsLeft.FindF(KX509SubdomainSeparator);

 	if (subdomainEnd == 0)

 		{

 		return res;

 		}

 	if (subdomainEnd == KErrNotFound)

 		{

 		subdomainEnd = end - aPos;

 		}

 	TPtrC subdomain(&whatsLeft[0], subdomainEnd);

 	if (IsValidString(subdomain))

 		{

 		REP_APPEND_L(subdomain);

 		res = ETrue;

 		}

 	aPos = aPos + subdomainEnd;

 	return res;

 	}

 TBool CX509DomainName::AddSubdomainSeparatorL(TInt& aPos)

 	{

 	TBool res = EFalse;

 	TInt end = iName->Length();

 	if (end <= aPos)

 		{

 		return res;

 		}

 	TPtrC whatsLeft(&(iName->operator[] (aPos)), end - aPos);

 	TInt separatorEnd = whatsLeft.FindF(KX509SubdomainSeparator);

 	if (separatorEnd == 0)

 		{

 		TPtrC separator(&whatsLeft[0], 1);

 		REP_APPEND_L(separator);

 		aPos++;

 		res = ETrue;

 		}

 	return res;

 	}

 TBool CX509DomainName::IsValidString(const TDesC& aStr) const

 	{

 	TInt pos=0;

 	TInt end=aStr.Length()-1;

 	if (end < 0)

 		{

 		return ETrue;	

 		}

 	while (pos<end && IsValidChar(aStr[pos]))

 		{

 		pos++;

 		}

 	return (pos==end && IsValidChar(aStr[end]));

 	}

 TBool CX509DomainName::IsAlpha(const TChar& aChar) const 

 	{

 	return (	((aChar >= 97) && (aChar <= 122))	||

 				((aChar >= 65) && (aChar <= 90))	);

 	}

 TBool CX509DomainName::IsAlphaOrNum(const TChar& aChar) const

 	{

 	return ((IsAlpha(aChar)) ||

 			((aChar >= 48) && (aChar <= 57)) || (aChar == 42));

 	}

 TBool CX509DomainName::IsValidChar(const TChar& aChar) const

 	{

 	//default implementation: must be letter, number or hyphen

 	return ((IsAlphaOrNum(aChar)) ||

 			(aChar == 45) || (aChar == 42));

 	}

 //RFC 822 email address

 //subtree

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

 	{

 	CX509RFC822NameSubtree* self = CX509RFC822NameSubtree::NewLC(aBinaryData);

 	CleanupStack::Pop();//self

 	return self;

 	}

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

 	{

 	CX509RFC822NameSubtree* self = new(ELeave) CX509RFC822NameSubtree;

 	CleanupStack::PushL(self);

 	self->ConstructL(aBinaryData);

 	return self;

 	}

 void CX509RFC822NameSubtree::ConstructL(const TDesC8& aBinaryData)

 	{

 	TInt pos = 0;

 	TASN1DecIA5String encStr;

 	iName = encStr.DecodeDERL(aBinaryData, pos);

 	REP_INIT_L;

 	//now, parse your data

 	pos = 0;	

 	AddLocalHostL(pos);

 	AddSubdomainSeparatorL(pos);

 	if (!(AddDomainL(pos)))

 		{

 		User::Leave(KErrArgument);

 		}

 	}

 TBool CX509RFC822NameSubtree::AddLocalHostL(TInt& aPos)

 	{

 	TInt localHostLength = iName->FindF(KX509RFC822HostDomainSeparator);

 	if ((localHostLength != KErrNotFound) && (localHostLength > 0))

 		{

 		TPtrC localHost(&(iName->operator[] (aPos)), localHostLength);		

 		//the local host name is not checked here as it caused defect PDEF108960 

 		//and for compatability with IE and Firefox.

 		REP_APPEND_L(localHost);

 		aPos = aPos + localHostLength;

 		aPos++;		//skip the @ symbol

 		return ETrue;

 		}

 	return EFalse;	//local host not found

 	}

 EXPORT_C const REP_VAL_TYPE& CX509RFC822NameSubtree::Rep() const

 	{

 	return REP_VAL;

 	}

 TBool CX509RFC822NameSubtree::IsValidChar(const TChar& aChar) const

 	{

 	//we permit "." here, 'cos it's allowed in local host names

 	//and must have been stripped out by domain parsing code,

 	//since it's the separator char

 	return (	(aChar == 33)						||

 				((aChar >= 35) && (aChar <= 40))	||

 				(aChar == 42)						||

 				(aChar == 43)						||

 				((aChar >= 45) && (aChar <= 57))	||

 				(aChar == 61)						||

 				(aChar == 63)						||

 				((aChar >= 65) && (aChar <= 90))	||

 				((aChar >= 94) && (aChar <= 126))	);

 	}

 //full rfc 822 name: exactly as subtree, but requires local host and full domain name

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

 	{

 	CX509RFC822Name* self = CX509RFC822Name::NewLC(aBinaryData);

 	CleanupStack::Pop();//self

 	return self;

 	}

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

 	{

 	CX509RFC822Name* self = new(ELeave) CX509RFC822Name;

 	CleanupStack::PushL(self);

 	self->ConstructL(aBinaryData);

 	return self;

 	}

 void CX509RFC822Name::ConstructL(const TDesC8& aBinaryData)

 	{

 	TInt pos = 0;

 	TASN1DecIA5String encStr;

 	iName = encStr.DecodeDERL(aBinaryData, pos);

 	REP_INIT_L;

 	//now, parse your data

 	pos = 0;	

 	if (! ((AddLocalHostL(pos)) && (AddDomainL(pos))) )

 		{

 		User::Leave(KErrArgument);

 		}

 	}

 //DNS Name subtree

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

 	{

 	CX509DNSNameSubtree* self = CX509DNSNameSubtree::NewLC(aBinaryData);

 	CleanupStack::Pop();//self

 	return self;

 	}

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

 	{

 	CX509DNSNameSubtree* self = new(ELeave) CX509DNSNameSubtree;

 	CleanupStack::PushL(self);

 	self->ConstructL(aBinaryData);

 	return self;

 	}

 void CX509DNSNameSubtree::ConstructL(const TDesC8& aBinaryData)

 	{

 	TInt pos = 0;

 	TASN1DecIA5String encStr;

 	iName = encStr.DecodeDERL(aBinaryData, pos);

 	REP_INIT_L;

 	pos = 0;

 	AddSubdomainSeparatorL(pos);//a subtree may start with a period

 	if (!(AddDomainL(pos)))

 		{

 		User::Leave(KErrArgument);

 		}

 	}

 EXPORT_C const REP_VAL_TYPE& CX509DNSNameSubtree::Rep() const

 	{

 	return REP_VAL;

 	}

 TBool CX509DNSNameSubtree::IsValidString(const TDesC& aStr) const

 	{

 	//must be <= 63 chars long

 	//must start with letter, end with letter or number

 	TInt len = aStr.Length();

 	return (	(len <= KX509MaxDNSNameLabelLength) &&

 				(IsAlphaOrNum(aStr[0]))				&&

 				(IsAlphaOrNum(aStr[len-1]))			&&

 				(CX509DomainName::IsValidString(aStr))				);

 	}

 //dns name: exactly as subtree but requires full domain name

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

 	{

 	CX509DNSName* self = CX509DNSName::NewLC(aBinaryData);

 	CleanupStack::Pop();//self

 	return self;

 	}

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

 	{

 	CX509DNSName* self = new(ELeave) CX509DNSName;

 	CleanupStack::PushL(self);

 	self->ConstructL(aBinaryData);

 	return self;

 	}

 EXPORT_C CX509DNSName* CX509DNSName::NewL(const CX509DNSName& aName)

 	{

 	CX509DNSName* self = CX509DNSName::NewLC(aName);

 	CleanupStack::Pop();//self

 	return self;

 	}

 EXPORT_C CX509DNSName* CX509DNSName::NewLC(const CX509DNSName& aName)

 	{	

 	CX509DNSName* self = new(ELeave) CX509DNSName;

 	CleanupStack::PushL(self);

 	self->ConstructL(aName);

 	return self;	

 	}

 EXPORT_C CX509DNSName* CX509DNSName::NewL(const TDesC& aNameString)

 	{

 	CX509DNSName* self = CX509DNSName::NewLC(aNameString);

 	CleanupStack::Pop();//self

 	return self;	

 	}

 EXPORT_C CX509DNSName* CX509DNSName::NewLC(const TDesC& aNameString)

 	{

 	CX509DNSName* self = new(ELeave) CX509DNSName;

 	CleanupStack::PushL(self);

 	self->ConstructL(aNameString);

 	return self;

 	}

 void CX509DNSName::ConstructL(const TDesC& aNameString)

 	{

 	TInt pos = 0;

 	REP_INIT_L;

 	iName = aNameString.AllocL();

 	AddSubdomainSeparatorL(pos);//a subtree may start with a period

 	if (!(AddDomainL(pos)))

 		{

 		User::Leave(KErrArgument);

 		}

 	}

 void CX509DNSName::ConstructL(const TDesC8& aBinaryData)

 	{

 	TInt pos = 0;

 	TASN1DecIA5String encStr;

 	iName = encStr.DecodeDERL(aBinaryData, pos);

 	ParseNameL();

 	}

 void CX509DNSName::ConstructL(const CX509DNSName& aName)

 	{

 	iName = aName.iName->AllocL();

 	ParseNameL();

 	}

 void CX509DNSName::ParseNameL()

 	{

 	REP_INIT_L;

 	TInt pos = 0;

 	if  (!AddDomainL(pos))

 		{

 		User::Leave(KErrArgument);

 		}

 	}

 //URI: must be of 'ip-based' form (rfc 1738 section 3.1)

 //_and_ contain a domain name (not an IP address)

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

 	{

 	CX509IPBasedURI* self = CX509IPBasedURI::NewLC(aBinaryData);

 	CleanupStack::Pop();//self

 	return self;

 	}

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

 	{

 	CX509IPBasedURI* self = new(ELeave) CX509IPBasedURI;

 	CleanupStack::PushL(self);

 	self->ConstructL(aBinaryData);

 	return self;

 	}

 void CX509IPBasedURI::ConstructL(const TDesC8& aBinaryData)

 	{

 	TInt pos = 0;

 	TASN1DecIA5String encStr;

 	iName = encStr.DecodeDERL(aBinaryData, pos);

 	iHost = CX509DNSName::NewL(ExtractHostNameL());

 	}

 EXPORT_C CX509IPBasedURI::~CX509IPBasedURI()

 	{

 	delete iName;

 	delete iHost;

 	}

 CX509IPBasedURI::CX509IPBasedURI()

 	:iHost(NULL), iName(NULL)

 	{

 	}

 EXPORT_C const CX509DNSName& CX509IPBasedURI::Host() const

 	{

 	return *iHost;

 	}

 EXPORT_C TPtrC CX509IPBasedURI::Name() const

 	{

 	return iName->Des();

 	}

 TPtrC CX509IPBasedURI::ExtractHostNameL() const

 	{

 	TInt hostStart;

 	TInt hostEnd;

 	TInt len = iName->Length();

 	TInt schemeSpecificStart = (iName->FindF(KX509URISchemeSpecificStart) + KX509URISchemeSpecificStartLength);

 	TInt userPasswordEnd = (iName->FindF(KX509URIUserPasswordEnd)) + KX509URIUserPasswordEndLength;

 	hostStart = ((userPasswordEnd == 0)? schemeSpecificStart : userPasswordEnd);

 	if (hostStart == KErrNotFound)

 		{

 		User::Leave(KErrArgument);

 		}

 	TPtrC whatsLeft(&(iName->operator[](hostStart)), len - hostStart);

 	TInt newlen = whatsLeft.Length();

 	TInt portStart = whatsLeft.FindF(KX509URIPortStart);

 	TInt urlPathStart = whatsLeft.FindF(KX509URIurlPathStart);

 	if (portStart == KErrNotFound)

 		{

 		if (urlPathStart == KErrNotFound)

 			{

 			hostEnd = newlen;

 			}

 		else

 			{

 			hostEnd = urlPathStart;

 			}

 		}

 	else

 		{

 		if (urlPathStart == KErrNotFound)

 			{

 			hostEnd = portStart;

 			}

 		else //both are there, choose the first one

 			{

 			hostEnd = ((urlPathStart > portStart)? portStart: urlPathStart);

 			}

 		}

 	TPtrC host(&(iName->operator[](hostStart)), hostEnd);

 	return host;

 	}

 //IP Address

 //subnet mask

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

 	{

 	CX509IPSubnetMask* self = CX509IPSubnetMask::NewLC(aBinaryData);

 	CleanupStack::Pop();//self;

 	return self;

 	}

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

 	{

 	CX509IPSubnetMask* self = new(ELeave) CX509IPSubnetMask;

 	CleanupStack::PushL(self);

 	self->ConstructL(aBinaryData);

 	return self;

 	}

 void CX509IPSubnetMask::ConstructL(const TDesC8& aBinaryData)

 	{

 	//!!!need to correct this when we have octet strings going!!!

 	TASN1DecGeneric encAddr(aBinaryData);

 	encAddr.InitL();

 	iName = encAddr.GetContentDER().AllocL();// = CASN1OctetString::DecodeDERL(aBinaryData, pos);

 	TInt len = iName->Length();

 	if (!((len == 8) || (len == 32)))

 		{

 		User::Leave(KErrArgument);

 		}

 	}

 EXPORT_C CX509IPSubnetMask::~CX509IPSubnetMask()

 	{

 	delete iName;

 	}

 EXPORT_C TPtrC8 CX509IPSubnetMask::BaseAddress() const

 	{

 	TInt half = iName->Length()/2;

 	TPtrC8 ptr(&(iName->operator [] (0)), half);

 	return ptr;

 	}

 EXPORT_C TPtrC8 CX509IPSubnetMask::Mask() const

 	{

 	TInt half = iName->Length()/2;

 	TPtrC8 ptr(&(iName->operator [] (half)), half);

 	return ptr;

 	}

 CX509IPSubnetMask::CX509IPSubnetMask()

 	:iName(NULL)

 	{

 	}

 //ip address

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

 	{

 	CX509IPAddress* self = CX509IPAddress::NewLC(aBinaryData);

 	CleanupStack::Pop();//self

 	return self;

 	}

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

 	{

 	CX509IPAddress* self = new(ELeave) CX509IPAddress;

 	CleanupStack::PushL(self);

 	self->ConstructL(aBinaryData);

 	return self;

 	}

 void CX509IPAddress::ConstructL(const TDesC8& aBinaryData)

 	{

 	TASN1DecGeneric encAddr(aBinaryData);

 	encAddr.InitL();

 	iName = encAddr.GetContentDER().AllocL();

 	TInt len = iName->Length();

 	if (!(len == 4 || len == 16))

 		{

 		User::Leave(KErrArgument);

 		}

 	}

 EXPORT_C CX509IPAddress::~CX509IPAddress()

 	{

 	delete iName;

 	}

 EXPORT_C TBool CX509IPAddress::IsWithinSubtree(const CX509IPSubnetMask& aName) const

 	{

 	TInt addrLen = iName->Length();

 	if (((aName.iName->Length())/2) !=  addrLen)

 		{

 		return EFalse;

 		}

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

 		{

 		//stop stupid compiler warning

 		TUint8 masked = (TUint8) ((iName->operator [] (i)) & (aName.iName->operator [] (i + addrLen)));

 		if (masked != (aName.iName->operator [] (i)))

 			{

 			return EFalse;

 			}

 		}

 	return ETrue;

 	}

 EXPORT_C TPtrC8 CX509IPAddress::Address() const

 	{

 	return iName->Des();

 	}

 CX509IPAddress::CX509IPAddress()

 	:iName(NULL)

 	{

 	}

 //*******************X.509 General Name**********************//

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

 	{

 	TInt pos = 0;

 	return CX509GeneralName::NewL(aBinaryData, pos);

 	}

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

 	{

 	TInt pos = 0;

 	return CX509GeneralName::NewLC(aBinaryData, pos);

 	}

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

 	{

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

 	CleanupStack::Pop();

 	return self;

 	}

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

 	{

 	CX509GeneralName* self = new(ELeave) CX509GeneralName;

 	CleanupStack::PushL(self);

 	self->ConstructL(aBinaryData, aPos);

 	return self;

 	}

 EXPORT_C CX509GeneralName* CX509GeneralName::NewL(const CX509GeneralName& aName)

 	{

 	CX509GeneralName* self = CX509GeneralName::NewLC(aName);

 	CleanupStack::Pop();

 	return self;

 	}

 EXPORT_C CX509GeneralName* CX509GeneralName::NewLC(const CX509GeneralName& aName)

 	{

 	CX509GeneralName* self = new(ELeave) CX509GeneralName(aName.iTag);

 	CleanupStack::PushL(self);

 	self->ConstructL(aName.iData->Des());

 	return self;

 	}

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

 	{

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

 	gen.InitL();

 	aPos += gen.LengthDER();//add on header info

 	if (gen.Class() != EContextSpecific)

 		{

 		User::Leave(KErrArgument);

 		}

 	iData = gen.Tag() == 4 ? gen.GetContentDER().AllocL(): gen.Encoding().AllocL();

 	iTag = gen.Tag();

 	}

 void CX509GeneralName::ConstructL(const TDesC8& aData)

 	{

 	iData = aData.AllocL();

 	}

 CX509GeneralName::CX509GeneralName(TGNType aType)

 	:iTag(aType)

 	{

 	}

 CX509GeneralName::CX509GeneralName()

 	{

 	}

 EXPORT_C TGNType CX509GeneralName::Tag() const

 	{

 	return iTag;

 	}

 EXPORT_C TPtrC8 CX509GeneralName::Data() const

 	{

 	return iData->Des();

 	}

 EXPORT_C TBool CX509GeneralName::ExactMatch(const CX509GeneralName& /*aName*/) const

 	{

 	return EFalse;

 	}

 EXPORT_C CX509GeneralName::~CX509GeneralName()

 	{

 	delete iData;

 	}