/*
* Copyright (c) 2004-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 <asn1enc.h>
#include <asn1dec.h>
#include <pbedata.h>
#include <rc2.h>

#include "asnpkcs.h"

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

/** OpenSSL PKCS8 Effective Key Length Compatibility.*/
const TUint KPkcs8CompatibilityBits = 128;

#endif


_LIT(Kpkcs5PBES2, "1.2.840.113549.1.5.13");
_LIT(Kpkcs5PBKDF2, "1.2.840.113549.1.5.12");
_LIT(KDESCBC, "1.3.14.3.2.7");
_LIT(K3DESCBC, "1.2.840.113549.3.7");
_LIT(KRC2CBC, "1.2.840.113549.3.2");

// pbe12Algorithm Ids
_LIT(KPbeWithSHA1And128BitRC4, "1.2.840.113549.1.12.1.1");
_LIT(KPbeWithSHA1And40BitRC4, "1.2.840.113549.1.12.1.2");
_LIT(KPbeWithSHA1And3_KeyTripleDES_CBC, "1.2.840.113549.1.12.1.3");
_LIT(KPbeWithSHA1And2_KeyTripleDES_CBC, "1.2.840.113549.1.12.1.4");
_LIT(KPbeWithSHA1And128BitRC2_CBC, "1.2.840.113549.1.12.1.5");
_LIT(KPbeWithSHA1And40BitRC2_CBC, "1.2.840.113549.1.12.1.6");
//The size of the Initialization vector
const TInt KIvSize = 8;


/*
* //For RC2
* SEQUENCE
* 	OID -- pkcs5PBES2
*	SEQUENCE
*		SEQUENCE
*		OID -- pkcs5PBKDF2
*		SEQUENCE
*			OCTET STRING -- salt
*			INTEGER -- iteration count
*			INTEGER -- effective key length in octets
* 	SEQUENCE
*		OID -- algorithm id (rc2)
*		SEQUENCE
*			INTEGER -- RC2 parameter version 58 = 128, 160 = 40
*			OCTET STRING -- iv
*
* //For DES and 3DES
* SEQUENCE
* 	OID -- pkcs5PBES2
*	SEQUENCE
*		SEQUENCE
*		OID -- pkcs5PBKDF2
*		SEQUENCE
*			OCTET STRING -- salt
*			INTEGER -- iteration count
* 	SEQUENCE
*		OID -- algorithm id (des, 3des)
*		OCTET STRING -- iv
*/

EXPORT_C CASN1EncSequence* TASN1EncPKCS5::EncodeDERL(const CPBEncryptParms& aParms)
	{
	CASN1EncSequence* seq = CASN1EncSequence::NewLC();
	CASN1EncObjectIdentifier* pbes2 = CASN1EncObjectIdentifier::NewLC(Kpkcs5PBES2);
	seq->AddChildL(pbes2);
	CleanupStack::Pop(pbes2);

	CASN1EncSequence* seq1 = CASN1EncSequence::NewLC();
	seq->AddChildL(seq1);
	CleanupStack::Pop(seq1);

	CASN1EncSequence* seq2 = CASN1EncSequence::NewLC();
	seq1->AddChildL(seq2);
	CleanupStack::Pop(seq2);

	CASN1EncObjectIdentifier* pbkdf2 = CASN1EncObjectIdentifier::NewLC(Kpkcs5PBKDF2);
	seq2->AddChildL(pbkdf2);
	CleanupStack::Pop(pbkdf2);

	CASN1EncSequence* seq3 = CASN1EncSequence::NewLC();
	seq2->AddChildL(seq3);
	CleanupStack::Pop(seq3);

	CASN1EncOctetString* salt = CASN1EncOctetString::NewLC(aParms.Salt());
	seq3->AddChildL(salt);
	CleanupStack::Pop(salt);

	CASN1EncInt* iterations = CASN1EncInt::NewLC(aParms.Iterations());
	seq3->AddChildL(iterations);
	CleanupStack::Pop(iterations);

	CASN1EncInt* keysize = 0;
	switch(aParms.Cipher())
		{
		case ECipherDES_CBC:
		case ECipher3DES_CBC: 
			break;
		case ECipherRC2_CBC_40:
 			keysize = CASN1EncInt::NewLC(KSSLCompatibilityBits/8);  // effective key length in *octets*
			seq3->AddChildL(keysize);
			CleanupStack::Pop(keysize);
			break;
		case ECipherRC2_CBC_128:
 			keysize = CASN1EncInt::NewLC(KSSLCompatibilityBits/8);  // effective key length in *octets*
			seq3->AddChildL(keysize);
			CleanupStack::Pop(keysize);
			break;
		case ECipherRC2_CBC_40_16:
 			keysize = CASN1EncInt::NewLC(KPkcs8CompatibilityBits/8);  // effective key length in *octets*
			seq3->AddChildL(keysize);
			CleanupStack::Pop(keysize);
			break;
		case ECipherRC2_CBC_128_16:
 			keysize = CASN1EncInt::NewLC(KPkcs8CompatibilityBits/8);  // effective key length in *octets*
			seq3->AddChildL(keysize);
			CleanupStack::Pop(keysize);
			break;
		default:
			User::Leave(KErrNotSupported);
			break;
		}

	CASN1EncSequence* seq4 = CASN1EncSequence::NewLC();
	seq1->AddChildL(seq4);
	CleanupStack::Pop(seq4);

	CASN1EncObjectIdentifier* algid = 0;
	switch(aParms.Cipher())
		{
		case ECipherDES_CBC:
			algid = CASN1EncObjectIdentifier::NewLC(KDESCBC);
			break;
		case ECipher3DES_CBC:
			algid = CASN1EncObjectIdentifier::NewLC(K3DESCBC);
			break;
		case ECipherRC2_CBC_40:
		case ECipherRC2_CBC_128:
		case ECipherRC2_CBC_40_16:
		case ECipherRC2_CBC_128_16:
			algid = CASN1EncObjectIdentifier::NewLC(KRC2CBC);
			break;
		default:
			User::Leave(KErrNotSupported);
			break;
		}
	seq4->AddChildL(algid);
	CleanupStack::Pop(algid);

	CASN1EncSequence* seq5 = 0;
	CASN1EncInt* keysize1 = 0;
	CASN1EncOctetString* iv = 0;
	switch(aParms.Cipher())
		{
		case ECipherDES_CBC:
		case ECipher3DES_CBC:
			iv = CASN1EncOctetString::NewLC(aParms.IV());
			seq4->AddChildL(iv);
			CleanupStack::Pop(iv);
			break;
		case ECipherRC2_CBC_40:
		case ECipherRC2_CBC_40_16:
			seq5 = CASN1EncSequence::NewLC();
			seq4->AddChildL(seq5);
			CleanupStack::Pop(seq5);

			keysize1 = CASN1EncInt::NewLC(160); //encoding for 40 bit
			seq5->AddChildL(keysize1);
			CleanupStack::Pop(keysize1);

			iv = CASN1EncOctetString::NewLC(aParms.IV());
			seq5->AddChildL(iv);
			CleanupStack::Pop(iv);
			break;
		case ECipherRC2_CBC_128:
		case ECipherRC2_CBC_128_16:
			seq5 = CASN1EncSequence::NewLC();
			seq4->AddChildL(seq5);
			CleanupStack::Pop(seq5);
			
			keysize1 = CASN1EncInt::NewLC(58); //encoding for 128 bit
			seq5->AddChildL(keysize1);
			CleanupStack::Pop(keysize1);

			iv = CASN1EncOctetString::NewLC(aParms.IV());
			seq5->AddChildL(iv);
			CleanupStack::Pop(iv);
			break;
		default:
			User::Leave(KErrNotSupported);
			break;
		}
	CleanupStack::Pop(seq);
	return seq;
	}

EXPORT_C CPBEncryptParms* TASN1DecPKCS5::DecodeDERL(const TDesC8& aBinaryData)
	{
	TASN1DecGeneric seqGen(aBinaryData);
	seqGen.InitL();
	if (seqGen.Tag() != EASN1Sequence)
		{
		User::Leave(KErrArgument);
		}
	
	//Decode the Algorithm Identifier Sequence
	TASN1DecSequence seq;
	CArrayPtrFlat<TASN1DecGeneric>* seqContents = seq.DecodeDERLC(seqGen);

	//PbeAlgorithm Id
	if (seqContents->At(0)->Tag() != EASN1ObjectIdentifier)
		{
		User::Leave(KErrArgument);
		}	
	CPBEncryptParms* params = NULL;	
	TASN1DecObjectIdentifier oid;
	HBufC* oiddes = oid.DecodeDERL(*(seqContents->At(0)));
	CleanupStack::PushL(oiddes);
	//Algorithm Id is a pkcs-12Pbe Algorithm Id.
	if(*oiddes != Kpkcs5PBES2)
		{
		// Initialise to impossible value
		TPBECipher cipher = (TPBECipher) -1; 
		// Pbe12Algorithm Ids
		if(*oiddes == KPbeWithSHA1And128BitRC4)
			{
			cipher = ECipherARC4_128;
			}
		else if(*oiddes == KPbeWithSHA1And40BitRC4)
			{
			cipher = ECipherARC4_40;
			}
		else if(*oiddes == KPbeWithSHA1And3_KeyTripleDES_CBC)
			{
			cipher = ECipher3DES_CBC;
			}
		else if(*oiddes == KPbeWithSHA1And2_KeyTripleDES_CBC)
			{
			cipher = ECipher2Key3DES_CBC;
			}
		else if(*oiddes == KPbeWithSHA1And128BitRC2_CBC)
			{
			cipher = ECipherRC2_CBC_128_16; 
			}
		else if(*oiddes == KPbeWithSHA1And40BitRC2_CBC)
			{
			cipher = ECipherRC2_CBC_40_5; 
			}
	    else
        	{
        	User::Leave(KErrNotSupported);
        	}	 
        
        TInt seqContentsCount = seqContents->Count();
		
		//All pkcs-12Pbe algorithms require the Algorithm Parameters.
		//Algorithm Parameters are not OPTIONAL for pkcs-12Pbe algorithms.
		
		//seqContentsCount should be equal to 2.That is, the Algorithm Id 
		//and associated Algorithm Parameters have to be present.
		if(seqContentsCount != 2)
			{
			User::Leave(KErrArgument);	
			}
		//This if statement checks if the pkcs-12PbeParams Sequence is present in the 
		//AlgorithmIdentifier Sequence Since pkcs-12PbeParams are OPTIONAL
		else 
			{
			//Set the Initialization vector size to 8 bytes.
			TBuf8<KIvSize> iv(KIvSize);
			// Initialized to NULL, if salt is not present.
			TPtrC8 salt;
			TInt iterations; 

			const TASN1DecGeneric* seqContentsAt1 = seqContents->At(1);
			if (seqContentsAt1->Tag() != EASN1Sequence || seqContentsAt1->Class() != EUniversal)
				{
				User::Leave(KErrArgument);
				}
				
			CArrayPtrFlat<TASN1DecGeneric>* seq1Contents = seq.DecodeDERLC(*seqContentsAt1);
			const TASN1DecGeneric* seq1ContentsAt0 = seq1Contents->At(0);
			if (seq1ContentsAt0->Tag() != EASN1OctetString || seq1ContentsAt0->Class() != EUniversal)
				{
				User::Leave(KErrArgument);
				}
			salt.Set(seq1ContentsAt0->GetContentDER());
			const TASN1DecGeneric* seq1ContentsAt1 = seq1Contents->At(1);
			if (seq1ContentsAt1->Tag() != EASN1Integer || seq1ContentsAt1->Class() != EUniversal)
				{
				User::Leave(KErrArgument);
				}
			TASN1DecInteger integer;
			iterations = integer.DecodeDERShortL(*seq1ContentsAt1);
			if (iterations <= 0)
				{
				User::Leave(KErrArgument);
				}
			params = CPBEncryptParms::NewL(cipher, salt, iv, iterations);
			params->SetKdf(CPBEncryptParms::EKdfPkcs12);
			CleanupStack::PopAndDestroy(seq1Contents);
			}
		}
	//Algorithm Id is a pkcs-5Pbe Algorithm Id.
   	 else if (*oiddes == Kpkcs5PBES2)
    	{
    	if (seqContents->At(1)->Tag() != EASN1Sequence)
			{
			User::Leave(KErrArgument);
			}
		CArrayPtrFlat<TASN1DecGeneric>* seq1Contents = seq.DecodeDERLC(*(seqContents->At(1)));

		if (seq1Contents->At(0)->Tag() != EASN1Sequence)
			{
			User::Leave(KErrArgument);
			}
		CArrayPtrFlat<TASN1DecGeneric>* seq2Contents = seq.DecodeDERLC(*(seq1Contents->At(0)));

		if (seq2Contents->At(0)->Tag() != EASN1ObjectIdentifier)
			{
			User::Leave(KErrArgument);
			}
		HBufC* oid1des = oid.DecodeDERL(*(seq2Contents->At(0)));
		CleanupStack::PushL(oid1des);
		
		if(*oid1des != Kpkcs5PBKDF2)
			{
			User::Leave(KErrNotSupported);
			}
		if (seq2Contents->At(1)->Tag() != EASN1Sequence)
			{
			User::Leave(KErrArgument);
			}
		CArrayPtrFlat<TASN1DecGeneric>* seq3Contents = seq.DecodeDERLC(*(seq2Contents->At(1)));

		if (seq3Contents->At(0)->Tag() != EASN1OctetString)
			{
			User::Leave(KErrArgument);
			}
		TASN1DecOctetString octet;
		HBufC8* salt = octet.DecodeDERL(*(seq3Contents->At(0)));
		CleanupStack::PushL(salt);
		
		if (seq3Contents->At(1)->Tag() != EASN1Integer)
			{
			User::Leave(KErrArgument);
			}
		TASN1DecInteger integer;
		TInt iterations = integer.DecodeDERShortL(*(seq3Contents->At(1)));

		if (seq1Contents->At(1)->Tag() != EASN1Sequence)
			{
			User::Leave(KErrArgument);
			}
		CArrayPtrFlat<TASN1DecGeneric>* seq4Contents = seq.DecodeDERLC(*(seq1Contents->At(1)));
	
		TPBECipher cipher = (TPBECipher) -1; // Initialise to impossible value
		if (seq4Contents->At(0)->Tag() != EASN1ObjectIdentifier)
			{
			User::Leave(KErrArgument);
			}
		HBufC* oid2des = oid.DecodeDERL(*(seq4Contents->At(0)));
		CleanupStack::PushL(oid2des);
		
		CArrayPtrFlat<TASN1DecGeneric>* seq5Contents = 0; 

		if(*oid2des == K3DESCBC)
			{
			cipher = ECipher3DES_CBC;
		CleanupStack::PushL(seq5Contents);
			}
		else if(*oid2des == KDESCBC)
			{
			cipher = ECipherDES_CBC;
		CleanupStack::PushL(seq5Contents);
			}
		else if(*oid2des == KRC2CBC)
			{
			// RC2 has an additional parameter, the effective key lenght in octets.
			if (seq3Contents->At(2)->Tag() != EASN1Integer)
				{
				User::Leave(KErrArgument);
				}		
			TInt effectiveKeyLength =  integer.DecodeDERShortL(*(seq3Contents->At(2)));

			if (seq4Contents->At(1)->Tag() != EASN1Sequence)
				{
				User::Leave(KErrArgument);
				}
			seq5Contents = seq.DecodeDERLC(*(seq4Contents->At(1)));
			if (seq5Contents->At(0)->Tag() != EASN1Integer)
				{
				User::Leave(KErrArgument);
				}
			TInt keysize = integer.DecodeDERShortL(*(seq5Contents->At(0)));
			switch(keysize)
				{
				// These values come from the PKCS#5 v2 specs
				case 160:
					if (effectiveKeyLength == 16)
						{
						cipher = ECipherRC2_CBC_40_16;					
						}
					else 
						{
						if (effectiveKeyLength == 128)
							{
							cipher = ECipherRC2_CBC_40;
							}
						else 
							{
							User::Leave(KErrNotSupported); // Unsupported effective key length!						
							}
						}
					break;
				case 58:
					if (effectiveKeyLength == 16)
						{
						cipher = ECipherRC2_CBC_128_16;					
						}
					else 
						{
						if (effectiveKeyLength == 128)
							{
							cipher = ECipherRC2_CBC_128;
							}
						else 
							{
							User::Leave(KErrNotSupported); // Unsupported effective key length!						
							}
						}			
					break;
				case 120:
					//would be RC_CBC_64 but we don't support that
				default:
					User::Leave(KErrNotSupported);
					break;
				}
			}
		else 
			{
			User::Leave(KErrNotSupported);
			}	

		HBufC8* iv = 0;
		switch(cipher)
			{
			case ECipher3DES_CBC:
			case ECipherDES_CBC:
				if (seq4Contents->At(1)->Tag() != EASN1OctetString)
					{
					User::Leave(KErrArgument);
					}
				iv = octet.DecodeDERL(*(seq4Contents->At(1)));	
			CleanupStack::PushL(iv);
				break;
			case ECipherRC2_CBC_40:
			case ECipherRC2_CBC_128:
			case ECipherRC2_CBC_40_16:
			case ECipherRC2_CBC_128_16:	
				if (seq5Contents->At(1)->Tag() != EASN1OctetString)
					{
					User::Leave(KErrArgument);
					}
				iv = octet.DecodeDERL(*(seq5Contents->At(1)));
			CleanupStack::PushL(iv);
				break;
			default:
				User::Leave(KErrNotSupported);
				break;
			}

		params = CPBEncryptParms::NewL(cipher, *salt, *iv,
		iterations);
	CleanupStack::PopAndDestroy(9); //iv, seq5contents, oid2des, seq4Contents,
	//salt, seq3Contents, oid1des, seq2Contents, seq1Contents
    	}
	else
		{
		User::Leave(KErrNotSupported);
		}
	CleanupStack::PopAndDestroy(2, seqContents);
	return params;
	}