/*

 * Copyright (c) 2007-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: 

 *

 */

 /**

  @file

  @internalComponent

  @released

 */

 #include "cryptodriver.h"

 #include <e32base.h>

 #include <e32cons.h>

 #include <e32test.h>

 #include <e32debug.h>

 #include <rijndael.h>

 #include <cbcmode.h>

 #include <padding.h>

 #include <bufferedtransformation.h>

 #include <random.h>

 #include "keys.h"

 #include <cryptospi/cryptospidef.h>

 #include "cryptosymmetriccipherapi.h"

 #include "kmsclient.h"

 #include <f32file.h>

 //#include "kmsservercommon.h"

 using namespace CryptoSpi;

 _LIT(KTxtEPOC32EX,"temb: mainL failed");

 //_LIT(KTxtPressAnyKey," [press any key]");

 //#define KEYLEN 16

 #define KEYLEN 24

 //#define KEYLEN 32

 #define PKCS7PAD

 //#define BUFLEN 256

 #define BUFLEN (256*16)

 #define LOOPCOUNT 10000

 LOCAL_D RTest test(_L("Embedded Key Tests"));

 class CTestConsole:public CConsoleBase

 	{

 	public:

 		static CTestConsole* NewL(CConsoleBase* aCon);

 		TInt Create(const TDesC16& aTitle,TSize aSize) {return iCon->Create(aTitle,aSize);};

 		void Read(TRequestStatus& aStatus) {iCon->Read(aStatus);};

 		void ReadCancel(void) {iCon->ReadCancel();};

 		void Write(const TDesC16& aString);

 		TPoint CursorPos(void) const {return iCon->CursorPos();};

 		void SetCursorPosAbs(const TPoint& aPos) {iCon->SetCursorPosAbs(aPos);};

 		void SetCursorPosRel(const TPoint& aPos) {iCon->SetCursorPosRel(aPos);};

 		void SetCursorHeight(TInt aHeight) {iCon->SetCursorHeight(aHeight);};

 		void SetTitle(const TDesC16& aTitle) {iCon->SetTitle(aTitle);};

 		void ClearScreen(void) {iCon->ClearScreen();};

 		void ClearToEndOfLine(void) {iCon->ClearToEndOfLine();};

 		TSize ScreenSize(void) const {return iCon->ScreenSize();};

 		TKeyCode KeyCode(void) const {return iCon->KeyCode();};

 		TUint KeyModifiers(void) const {return iCon->KeyModifiers();};

 		~CTestConsole(void);

 		void SetLogFile(RFile &aFile);

 	private:

 		CTestConsole(void);

 		CConsoleBase* iCon;

 		RFile* iFile;

 	};

 CTestConsole* CTestConsole::NewL(CConsoleBase* aCon)

 	{

 	CTestConsole* self;

 	self=new (ELeave) CTestConsole;

 	self->iCon=aCon;

 	self->iFile=NULL;

 	return self;

 	}

 CTestConsole::CTestConsole(void):CConsoleBase()

 	{

 	}

 CTestConsole::~CTestConsole(void)

 	{

 	delete iCon;

 	if (iFile)

 		{

 		iFile->Close();

 		}

 	}

 void CTestConsole::Write(const TDesC16& aString)

 	{

 	iCon->Write(aString);

 	if (iFile)

 		{

 		TUint8 space[200];

 		TPtr8 ptr(space,200);

 		ptr.Copy(aString);

 		iFile->Write(ptr);

 		}

 	}

 void CTestConsole::SetLogFile(RFile &aFile)

 	{

 	iFile = &aFile;

 	}

 // private

 LOCAL_C void mainL();

 GLDEF_C TInt E32Main() // main function called by E32

     {

 	CTrapCleanup* cleanup=CTrapCleanup::New(); // get clean-up stack

 	//

 	// Run the tests

 	//

 	__UHEAP_MARK;

 	TRAPD(error,mainL()); // more initialization, then do example

 	__ASSERT_ALWAYS(!error,User::Panic(KTxtEPOC32EX,error));

 	__UHEAP_MARKEND;

 	delete cleanup; // destroy clean-up stack

 	return 0; // and return

     }

 _LIT(KLddFileName,"cryptoldd.ldd");

 _LIT(KPddFileName,"crypto.h4.pdd");

 LOCAL_C void mainL() // initialize and call example code under cleanup stack

     {

 	test.Title();

 	CTestConsole *con = CTestConsole::NewL(test.Console());

 	RFs fs;

 	User::LeaveIfError(fs.Connect());

 	CleanupClosePushL(fs);

 	TDriveUnit sysDrive (fs.GetSystemDrive());

 	TBuf<24> logFile (sysDrive.Name());

 	logFile.Append(_L("\\temblog.txt"));

 	RFile file;

 	User::LeaveIfError(file.Replace(fs, logFile, EFileShareAny|EFileWrite));

 	CleanupClosePushL(file);

 	con->SetLogFile(file);

 	test.SetConsole(con);

     TInt r;

 	RDebug::Printf("Hello from user side\n");

     test.Start(_L(" @SYMTestCaseID:SEC-CRYPTOSPI-TEMB-0001 Load driver "));

     test.Next(_L("Loading Physical Device"));

     r=User::LoadPhysicalDevice(KPddFileName);

     test(r==KErrNone || r==KErrAlreadyExists);

     test.Next(_L("Loading Logical Device"));

     r=User::LoadLogicalDevice(KLddFileName);

     test(r==KErrNone || r==KErrAlreadyExists);

 	//

 	// Generate key and IV

 	//

     test.Start(_L("Random - Generating key & IV for AES tests"));

 	test.Printf(_L("\tGenerating random key\n"));

 	// Generate random 16 byte key

 	TBuf8<KEYLEN> key;

 	key.SetLength(key.MaxLength());

 	TRandom::RandomL(key);

 	key[0] = 'K';

 	key[1] = 'E';

 	key[2] = 'Y';

 	key[3] = '*';

 	for(int z=4; z<KEYLEN; ++z) key[z] = z;

 	test.Printf(_L("\tGenerating random IV\n"));

 	// Generate random 16 byte IV

 	TBuf8<16> iv;

 	iv.SetLength(iv.MaxLength());

 	TRandom::RandomL(iv);

 	iv[0] = 'I';

 	iv[1] = 'V';

 	iv[2] = '*';

 	iv[3] = '*';

 	TBuf8<BUFLEN> plaintext;

 	plaintext.FillZ();

 	plaintext.SetLength(BUFLEN);

 	plaintext[0] = 'P';

 	plaintext[1] = 'L';

 	plaintext[2] = 'A';

 	plaintext[3] = 'I';

 	plaintext[4] = 'N';

 	for(int i=0; i<BUFLEN; ++i)

 		{

 		plaintext[i] = i;

 		}

 	//

 	// KMS tests

 	//

     test.Next(_L("KMS - Store key"));

 	TBuf8<BUFLEN+16> kmsData;

 	kmsData.FillZ();

 	kmsData.SetLength(0);

 	do

 		{

 		RKeyMgmtSession kms;

 		User::LeaveIfError(kms.Connect());

 		CleanupClosePushL(kms);

 		TKeyHandle keyHandle;

 		User::LeaveIfError(kms.StoreKey(key, keyHandle));

 		_LIT_SECURITY_POLICY_PASS(KAlwaysPass);

 		User::LeaveIfError(kms.AddUsage(keyHandle, 0 /* operation */, KAlwaysPass));

 		test.Next(_L("KMS - Attempt to use key via embedded key handle"));

 		TPckgBuf<TKeyHandle> keyHandlePkg;

 		keyHandlePkg() = keyHandle;

 		TKeyProperty keyProperty = {KAesUid, KNullUid, KSymmetricKeyUid, KNonExtractableKey};

 		CCryptoParams* keyParam =CCryptoParams::NewLC();

 		keyParam->AddL(keyHandlePkg, KSymmetricKeyParameterUid);

 		CKey *ckey=CKey::NewL(keyProperty, *keyParam);

 		CleanupStack::PopAndDestroy(keyParam);

 		CleanupStack::PushL(ckey);

 		CryptoSpi::CSymmetricCipher *aes = 0;

 		CSymmetricCipherFactory::CreateSymmetricCipherL(aes,

 														KAesUid,

 														*ckey,

 														KCryptoModeEncryptUid,

 														KOperationModeCBCUid,

 														KPaddingModePKCS7Uid,

 														NULL);

 		CleanupStack::PopAndDestroy(ckey);

 		CleanupStack::PushL(aes);

 		aes->SetOperationModeL(CryptoSpi::KOperationModeCBCUid);

 		aes->SetIvL(iv);		

 		aes->ProcessFinalL(plaintext, kmsData);

 		CleanupStack::PopAndDestroy(aes);

 		CleanupStack::PopAndDestroy(&kms);

 		} while(false);

 	//

 	// Encrypt using legacy API

 	//

 	TBuf8<BUFLEN+16> sw;

 	sw.FillZ();

 	sw.SetLength(0);

 	do 

 		{ 

 		test.Next(_L("Encrypt using key directly (non-KMS)"));

 		// ECB

 		test.Printf(_L("    CBC\n"));

 		CAESEncryptor *rawaes = CAESEncryptor::NewLC(key); // rawaes

 		CModeCBCEncryptor *cbc = CModeCBCEncryptor::NewL(rawaes, iv);

 		CleanupStack::Pop(rawaes); //

 		CleanupStack::PushL(cbc);  // cbc

 #ifdef PKCS7PAD

 		CPadding *pad = CPaddingPKCS7::NewLC(16); // cbc, pad

 #else

 		CPadding *pad = CPaddingNone::NewLC(16); // cbc, pad

 #endif

 		CBufferedEncryptor *aes = CBufferedEncryptor::NewL(cbc, pad);

 		CleanupStack::Pop(pad); // cbc

 		CleanupStack::Pop(cbc);

 		CleanupStack::PushL(aes); // aes

 		test.Printf(_L("About to s/w encrypt (old api)\n"));

 		aes->ProcessFinalL(plaintext, sw);

 		CleanupStack::PopAndDestroy(aes);

 		} while(false);

 	test.Printf(_L("Checking KMS encrypt and direct encrypt had the same result\n"));

 	test(kmsData == sw);

     test.End();

 	test.Printf(_L("\r\n0 tests failed out of 1\r\n"));

 	// test.Printf(KTxtPressAnyKey);

 	// test.Getch(); // get and ignore character

 	test.Close();

 	CleanupStack::PopAndDestroy(&file);

 	CleanupStack::PopAndDestroy(&fs);

     }

 // End of file