/*

 * 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 "tactionderivekey.h"

 #include "t_input.h"

 #include <pkcs5kdf.h>

 #include <pkcs12kdf.h>

 #include <stdlib.h>

 _LIT8(KKdfStart, "<kdf>");

 _LIT8(KKdfEnd, "</kdf>");

 _LIT8(KPKCS12Kdf, "pkcs#12");

 _LIT8(KDeriveKeyStart, "<derivekey>");

 _LIT8(KDeriveKeyEnd, "</derivekey>");

 _LIT8(KKeyStart, "<key>");

 _LIT8(KKeyEnd, "</key>");

 _LIT8(KPasswdStart, "<passwd>");

 _LIT8(KPasswdEnd, "</passwd>");

 _LIT8(KSaltStart, "<salt>");

 _LIT8(KSaltEnd, "</salt>");

 _LIT8(KIterationsStart, "<iterations>");

 _LIT8(KIterationsEnd, "</iterations>");

 _LIT8(KLeaveInPerformAction, "<leaveinperformaction>");

 _LIT8(KLeaveInPerformActionEnd, "</leaveinperformaction>");

 CTestAction* CActionDeriveKey::NewL(RFs& aFs,

 									   CConsoleBase& aConsole,

 									   Output& aOut, 

 									   const TTestActionSpec& aTestActionSpec)

 	{

 	CTestAction* self = CActionDeriveKey::NewLC(aFs, aConsole,

 		aOut, aTestActionSpec);

 	CleanupStack::Pop();

 	return self;

 	}

 CTestAction* CActionDeriveKey::NewLC(RFs& aFs,

 										CConsoleBase& aConsole,

 										Output& aOut, 

 										const TTestActionSpec& aTestActionSpec)

 	{

 	CActionDeriveKey* self = new(ELeave) CActionDeriveKey(aFs, aConsole, aOut);

 	CleanupStack::PushL(self);

 	self->ConstructL(aTestActionSpec);

 	return self;

 	}

 CActionDeriveKey::~CActionDeriveKey()

 	{

 	delete iBody;

 	}

 CActionDeriveKey::CActionDeriveKey(RFs& aFs, 

 								 CConsoleBase& aConsole,

 								 Output& aOut)

 : CTestAction(aConsole, aOut), iFs(aFs)

 	{

 	}

 void CActionDeriveKey::ConstructL(const TTestActionSpec& aTestActionSpec)

 	{

 	CTestAction::ConstructL(aTestActionSpec);

 	iBody = HBufC8::NewL(aTestActionSpec.iActionBody.Length());

 	iBody->Des().Copy(aTestActionSpec.iActionBody);

 	}

 void CActionDeriveKey::DoPerformPrerequisite(TRequestStatus& aStatus)

 	{

 	TRequestStatus* status = &aStatus;

 	TInt err = KErrNone;

 	TInt pos = 0;

 	TPtrC8 deriveKey = Input::ParseElement(*iBody, KDeriveKeyStart, KDeriveKeyEnd, pos, err);

 	// KDF is only explicitly specified for PKCS#12 derived keys

 	TPtrC8 kdfTemp = Input::ParseElement(deriveKey, KKdfStart, KKdfEnd, pos=0, err);

 	if (err == KErrNone)

 		iKdf = kdfTemp.AllocL();

 	TPtrC8 passwdTemp = Input::ParseElement(deriveKey, KPasswdStart, KPasswdEnd, pos=0, err);

 	iPasswd = HBufC8::NewL(passwdTemp.Length());

 	*iPasswd = passwdTemp;

 	TPtrC8 iterationsTemp = Input::ParseElement(deriveKey, KIterationsStart, KIterationsEnd, pos=0, err);

 	iIterations = HBufC8::NewL(iterationsTemp.Length() + 1); //added 1 for the null zero used later

 	*iIterations = iterationsTemp;

 	TPtrC8 saltTemp = Input::ParseElement(deriveKey, KSaltStart, KSaltEnd, pos=0, err);

 	iSalt = HBufC8::NewL(saltTemp.Length());

 	*iSalt = saltTemp;

 	Hex(*iSalt);

 	TPtrC8 keyTemp = Input::ParseElement(deriveKey, KKeyStart, KKeyEnd, pos=0, err);

 	iKey = HBufC8::NewL(keyTemp.Length());

 	*iKey = keyTemp;

 	Hex(*iKey);

 	iOutput = HBufC8::NewL(iKey->Length());

 	iLeaveInPerformAction = Input::ParseIntElement(deriveKey, 

 		KLeaveInPerformAction, KLeaveInPerformActionEnd, pos=0, err);

 	if (err)

 		{

 		iLeaveInPerformAction = 0;

 		}

 	User::RequestComplete(status, KErrNone);

 	iActionState = CTestAction::EAction;

 	}

 void CActionDeriveKey::DoPerformPostrequisite(TRequestStatus& aStatus)

 	{

 	TRequestStatus* status = &aStatus;

 	delete iKey;

 	delete iSalt;

 	delete iIterations;

 	delete iPasswd;

 	delete iOutput;

 	delete iKdf;

 	iKdf = 0;

 	iFinished = ETrue;

 	User::RequestComplete(status, KErrNone);

 	}

 void CActionDeriveKey::DoReportAction(void)

 	{

 	}

 void CActionDeriveKey::DoCheckResult(TInt)

 	{

 	}

 void CActionDeriveKey::PerformAction(TRequestStatus& aStatus)

 	{

 	TRequestStatus* status = &aStatus;

 	iResult = EFalse;

 	if (iLeaveInPerformAction)

 		{

 		User::Leave(KErrArgument);

 		}

 	iOutput->Des().SetLength(iKey->Length());

 	TUint8* nptr= (TUint8*)(iIterations->Des().PtrZ()); 

 	TUint32 i = strtoul((char*)nptr, 0, 10); 

 	iConsole.Printf(_L("."));

 	TPtr8 outputActual = iOutput->Des();

 	TPtr8 passwdActual = iPasswd->Des();

 	if (iKdf != 0 && *iKdf == KPKCS12Kdf)

 		{

 		// convert the password to PKCS#12 password format

 		HBufC* pwdNative = HBufC::NewLC(iPasswd->Length());

 		pwdNative->Des().Copy(*iPasswd);

 		HBufC8* pwdPKCS12 = PKCS12KDF::GeneratePasswordLC(*pwdNative);

 		PKCS12KDF::DeriveKeyL(outputActual, PKCS12KDF::EIDByteEncryptKey, *pwdPKCS12, *iSalt, i);

 		CleanupStack::PopAndDestroy(2, pwdNative);

 		}

 	else	// PKCS#5

 		{

 		TPtr8 saltActual = iSalt->Des();

 		TPKCS5KDF::DeriveKeyL(outputActual, passwdActual, saltActual,i);

 		}

 	if(*iOutput == *iKey)

 		{

 		iResult = ETrue;

 		}

 	User::RequestComplete(status, KErrNone);

 	iActionState = CTestAction::EPostrequisite;

 	}

 void CActionDeriveKey::Hex(HBufC8& aString)

 /**

 	Convert the supplied hex string into the binary equivalent.

 	@param	aString			Hex string.  On entry this contains

 							a sequence of hexadecimal characters,

 							e.g., "3037AFC8EA".  On exit it is

 							half the original length and each two-digit

 							hex number is reduced to the matching

 							byte value.

  */

     {

     TPtr8 ptr=aString.Des();

     if (aString.Length()%2)

         {

         ptr.SetLength(0);

         return;

         }

     TInt i;

     for (i=0;i<aString.Length();i+=2)

         {

         TUint8 tmp;

         tmp=(TUint8)(aString[i]-(aString[i]>'9'?('A'-10):'0'));

         tmp*=16;

         tmp|=(TUint8)(aString[i+1]-(aString[i+1]>'9'?('A'-10):'0'));

         ptr[i/2]=tmp;

         }

     ptr.SetLength(aString.Length()/2);

     }