diff -r 000000000000 -r 2c201484c85f crypto/weakcrypto/test/tpkcs5kdf/tactionderivekey.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcrypto/test/tpkcs5kdf/tactionderivekey.cpp	Wed Jul 08 11:25:26 2009 +0100
@@ -0,0 +1,224 @@
+/*
+* 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
+	pos = 0;
+	TPtrC8 kdfTemp = Input::ParseElement(deriveKey, KKdfStart, KKdfEnd, pos, err);
+	if (err == KErrNone)
+		iKdf = kdfTemp.AllocL();
+	
+	pos = 0;
+	TPtrC8 passwdTemp = Input::ParseElement(deriveKey, KPasswdStart, KPasswdEnd, pos, err);
+	iPasswd = HBufC8::NewL(passwdTemp.Length());
+	*iPasswd = passwdTemp;
+
+	pos = 0;
+	TPtrC8 iterationsTemp = Input::ParseElement(deriveKey, KIterationsStart, KIterationsEnd, pos, err);
+	iIterations = HBufC8::NewL(iterationsTemp.Length() + 1); //added 1 for the null zero used later
+	*iIterations = iterationsTemp;
+
+	pos = 0;
+	TPtrC8 saltTemp = Input::ParseElement(deriveKey, KSaltStart, KSaltEnd, pos, err);
+	iSalt = HBufC8::NewL(saltTemp.Length());
+	*iSalt = saltTemp;
+	Hex(*iSalt);
+
+	pos = 0;
+	TPtrC8 keyTemp = Input::ParseElement(deriveKey, KKeyStart, KKeyEnd, pos, err);
+	iKey = HBufC8::NewL(keyTemp.Length());
+	*iKey = keyTemp;
+	Hex(*iKey);
+
+	iOutput = HBufC8::NewL(iKey->Length());
+
+	pos = 0;
+	iLeaveInPerformAction = Input::ParseIntElement(deriveKey, 
+		KLeaveInPerformAction, KLeaveInPerformActionEnd, pos, 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);
+    }