/*
* 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