/*
* 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 <e32def_private.h>

_LIT(KTxtEPOC32EX,"tcrypto: mainL failed");
_LIT(KTxtPressAnyKey," [press any key]");

#define RNG_TESTS
//#define RNG_USE_SVR
//#define KEYLEN 16
#define KEYLEN 24
//#define KEYLEN 32

#define USE_CBCMODE
//#define DISABLE_AES_CHECKS

//#define PADDING_PKCS7

//#define BUFLEN 256
#define BUFLEN (256*16)
#define LOOPCOUNT 10000


// public
CConsoleBase* console; // write all your messages to this

// private
LOCAL_C void mainL();

GLDEF_C TInt E32Main() // main function called by E32
    {
	__UHEAP_MARK;
	CTrapCleanup* cleanup=CTrapCleanup::New(); // get clean-up stack
	TRAPD(error,mainL()); // more initialization, then do example
	__ASSERT_ALWAYS(!error,User::Panic(KTxtEPOC32EX,error));
	delete cleanup; // destroy clean-up stack
	__UHEAP_MARKEND;
	return 0; // and return
    }

LOCAL_D RTest test(_L("tcrypto"));

_LIT(KLddFileName,"cryptoldd.ldd");
_LIT(KPddFileName,"crypto.h4.pdd");

LOCAL_C void mainL() // initialize and call example code under cleanup stack
    {
#if 0
	test.Printf(KTxtPressAnyKey);
	test.Getch(); // get and ignore character
	test.Printf(_L("\n"));
#endif

	test.Title();

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

    TInt r;

    test.Start(_L(" @SYMTestCaseID:SEC-CRYPTOSPI-CRYPTO-0001 Loading Physical Device "));
    r=User::LoadPhysicalDevice(KPddFileName);
    test(r==KErrNone || r==KErrAlreadyExists);

	test.Next(_L("Re-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);

	test.Next(_L("Re-Loading Logical Device"));
	r=User::LoadLogicalDevice(KLddFileName);
	test(r==KErrNone || r==KErrAlreadyExists);
	
    test.Next(_L("Open Device"));
    RDevice device;
    r=device.Open(RCryptoDriver::Name());
    test(r==KErrNone);

    test.Next(_L("Get Device Capabilities"));
    RCryptoDriver::TCaps caps;
    TPckg<RCryptoDriver::TCaps>capsPckg(caps);
    capsPckg.FillZ(); // Zero 'caps' so we can tell if GetCaps has really filled it
    device.GetCaps(capsPckg);
    TVersion expectedVer(RCryptoDriver::VersionRequired());
    test(caps.iVersion.iMajor==expectedVer.iMajor);
    test(caps.iVersion.iMinor==expectedVer.iMinor);
    test(caps.iVersion.iBuild==expectedVer.iBuild);

	test.Next(_L("Close Device"));
    device.Close();

    test.Next(_L("Open Logical Channel"));
    RCryptoDriver ldd;
    r=ldd.Open();
    test(r==KErrNone);

	test.Next(_L("GetHwVersions"));
    RCryptoDriver::THwVersionsBuf hwVersionsBuf;
    hwVersionsBuf.FillZ(); // Zero 'config' so we can tell if GetConfig has really filled it
    r=ldd.GetHwVersions(hwVersionsBuf);
    test(r==KErrNone);
	test.Printf(_L("RNG h/w version 0x%x\n"), hwVersionsBuf().iRngHwVersion);
	test.Printf(_L("DES/3DES h/w version 0x%x\n"), hwVersionsBuf().iDes3DesHwVersion);
	test.Printf(_L("SHA1/MD5 h/w version 0x%x\n"), hwVersionsBuf().iSha1Md5HwVersion);
	test.Printf(_L("AES h/w version 0x%x\n"), hwVersionsBuf().iAesHwVersion);
	test.Printf(_L("PKA h/w version 0x%x\n"), hwVersionsBuf().iPkaHwVersion);

	test.Next(_L("GetConfig"));
    RCryptoDriver::TConfigBuf configBuf;
    configBuf.FillZ(); // Zero 'config' so we can tell if GetConfig has really filled it
    r=ldd.GetConfig(configBuf);
    test(r==KErrNone);
	
	{
	test.Next(_L("Open Logical Channel 2nd time"));
	RCryptoDriver lddB;
	r=lddB.Open();
	test(r==KErrNone);
	
	test.Next(_L("GetConfig"));
	RCryptoDriver::TConfigBuf configBuf;
	configBuf.FillZ(); // Zero 'config' so we can tell if GetConfig has really filled it
	r=lddB.GetConfig(configBuf);
	test(r==KErrNone);
	lddB.Close();
	}
	
    RCryptoDriver::TConfig& config=configBuf();

    test.Next(_L("SetConfig"));
    TInt setting = configBuf().iFakeDriverSetting+1;
    configBuf().iFakeDriverSetting = setting;
    r=ldd.SetConfig(configBuf); // Use SetConfig to change setting
    test(r==KErrNone);

    configBuf.FillZ();
    r=ldd.GetConfig(configBuf);
    test(r==KErrNone);
    test(configBuf().iFakeDriverSetting==setting);

    test.Next(_L("Check access by wrong client"));
    RCryptoDriver ldd2=ldd;
    r=ldd2.Duplicate(RThread(),EOwnerProcess);
    test(r==KErrAccessDenied);

    test.Next(_L("Check handle duplication"));
    ldd2=ldd;
    r=ldd2.Duplicate(RThread(),EOwnerThread);
    test(r==KErrNone);
    ldd2.Close();

	
    TRequestStatus status;
    TRequestStatus status2;
	TInt startCount;
	TInt endCount;


	{
    test.Next(_L("Random h/w use 2nd chan"));
	HBufC8 *hbuf = HBufC8::NewLC(20);
	TPtr8 buf = hbuf->Des();
	buf.SetLength(buf.MaxLength());
	ldd.Random(status,buf);
	User::WaitForRequest(status);

	test.Printf(_L("    Try 2nd chan"));
	RCryptoDriver lddB;
    r=lddB.Open();
    test(r==KErrNone);
	buf.SetLength(buf.MaxLength());
	lddB.Random(status,buf);
	User::WaitForRequest(status);

	test.Printf(_L("    Try re-using 1st chan\n"));
	buf.SetLength(buf.MaxLength());
	ldd.Random(status,buf);
	User::WaitForRequest(status);

	lddB.Close();
	CleanupStack::PopAndDestroy(hbuf);
	}
	



#ifdef RNG_TESTS
    test.Next(_L("Random (h/w)"));
#ifdef __MARM__
	HBufC8 *hbuf = HBufC8::NewLC(32768);
#else
	HBufC8 *hbuf = HBufC8::NewLC(1024);
#endif
	TPtr8 buf = hbuf->Des();
	buf.SetLength(buf.MaxLength());
	startCount = User::NTickCount();
	for(TInt i=0; i<100; ++i)
		{
		// Should discard existing contents of buf
		ldd.Random(status,buf);
		//	User::After(20);
		//	return;
		User::WaitForRequest(status);
		}
	endCount = User::NTickCount();
	test.Printf(_L("Duration in ticks (h/w) = %d\n"), endCount - startCount);
	
#ifndef __MARM__
	{
	TUint32 *p = (TUint32 *) &buf[0];
	test.Printf(_L("buf =\n    "));
	for(TInt i = 0 ; i<256; ++i)
		{
		if(i && (i%16 == 0))
			{
			test.Printf(_L("\n    "));
			}
		test.Printf(_L("%08x "), p[i]);
		}
	test.Printf(_L("\n"));
	}
	
#endif
	
	{
    test.Next(_L("Random (s/w)"));
#ifdef RNG_USE_SVR
 	RRandomSession rs;
	TRAPD(ret,rs.ConnectL());
	User::LeaveIfError(ret);
	CleanupClosePushL(rs);
#endif

	TInt startCount = User::NTickCount();
	for(TInt i=0; i<100; ++i)
		{
		// Should discard existing contents of buf
#ifdef RNG_USE_SVR
		User::LeaveIfError(rs.GetRandom(buf));
#else
		TRandom::RandomL(buf);
#endif
		}
	TInt endCount = User::NTickCount();
	test.Printf(_L("Duration in ticks (s/w) = %d\n"), endCount - startCount);
	
#ifdef RNG_USE_SVR
	CleanupStack::PopAndDestroy(&rs);
#endif
	}
	

#ifdef __MARM__
	const TInt end = 10;
#else
	const TInt end = 1;
#endif

	for(TInt i = 0 ; i<end; ++i)
		{
		test.Printf(_L("buf[%d] = 0x%x\n"), i, buf[i]);
		}
    r=status.Int();
    test(r==KErrNone);

	CleanupStack::PopAndDestroy(hbuf);

#endif

    test.Next(_L("Random - Generating key & IV for AES tests"));
	test.Printf(_L("Generating random key\n"));
	// Generate random 16 byte key
	TBuf8<KEYLEN> key;
	key.SetLength(key.MaxLength());
	ldd.Random(status, key);
	User::WaitForRequest(status);
	key[0] = 'K';
	key[1] = 'E';
	key[2] = 'Y';
	key[3] = '*';
	for(int z=4; z<KEYLEN; ++z) key[z] = z;

	test.Printf(_L("Generating random IV\n"));
	// Generate random 16 byte IV
	TBuf8<16> iv;
	iv.SetLength(iv.MaxLength());
	ldd.Random(status, iv);
	User::WaitForRequest(status);
	iv[0] = 'I';
	iv[1] = 'V';
	iv[2] = '*';
	iv[3] = '*';

	TBuf8<BUFLEN> plaintext;
	plaintext.SetLength(BUFLEN);
	plaintext[0] = 'P';
	plaintext[1] = 'L';
	plaintext[2] = 'A';
	plaintext[3] = 'I';
	plaintext[4] = 'N';
	plaintext.SetLength(BUFLEN);
	for(int i=0; i<BUFLEN; ++i)
		{
		plaintext[i] = i;
		}
	


    test.Next(_L("AES - S/W"));

#ifdef PADDING_PKCS7
	CPadding *pad = CPaddingPKCS7::NewLC(16);
#else
	CPadding *pad = CPaddingNone::NewLC(16);
#endif

#ifdef USE_CBCMODE
	// CBC
	test.Printf(_L("    CBC\n"));
	CAESEncryptor *rawaes = CAESEncryptor::NewLC(key); // pad, rawaes
	CModeCBCEncryptor *cbc = CModeCBCEncryptor::NewL(rawaes, iv);
	CleanupStack::Pop(rawaes); // pad
	CleanupStack::PushL(cbc);  // pad, cbc

	CBufferedEncryptor *aes = CBufferedEncryptor::NewL(cbc, pad);
	CleanupStack::Pop(cbc); // pad
	CleanupStack::Pop(pad); //
	CleanupStack::PushL(aes); //aes
#else
	// ECB
	test.Printf(_L("    ECB\n"));
	CAESEncryptor *rawaes = CAESEncryptor::NewLC(key); // pad, rawaes
	CBufferedEncryptor *aes = CBufferedEncryptor::NewL(rawaes, pad);
	CleanupStack::Pop(rawaes); // pad
	CleanupStack::Pop(pad); // 
	CleanupStack::PushL(aes); // aes
#endif	
	
	{
	TBuf8<10> b1;
	b1 = _L8("0123456789");
	TBuf8<6> b2;
	b2 = _L8("012345");
	TBuf8<64> b3;
	
	test.Printf(_L("Test of Process/ProcessFinal\n"));
	aes->Reset();
	aes->Process(b1,b3);
	aes->ProcessFinalL(b2, b3);
	aes->Reset();
	}
	
	test.Printf(_L("About to s/w encrypt\n"));
	TBuf8<BUFLEN> sw;
	sw.SetLength(0);
	aes->ProcessFinalL(plaintext, sw);

	test.Printf(_L("sw =\n    "));
	for(TInt i = 0 ; i<256; ++i)
		{
		if(i && (i%16 == 0))
			{
			test.Printf(_L("\n    "));
			}
		test.Printf(_L("%02x "), sw[i]);
		}
	test.Printf(_L("\n"));

	aes->Reset();
	test.Printf(_L("S/W - Encrypt %d bytes %d times\n"), BUFLEN, LOOPCOUNT);
	startCount = User::NTickCount();
	for(int z=0; z < LOOPCOUNT; ++z)
		{
		//aes->Reset();
		sw.SetLength(0);
		//aes->ProcessFinalL(plaintext, sw);
		aes->Process(plaintext, sw);
		}
	endCount = User::NTickCount();
	test.Printf(_L("Duration in ticks (s/w) = %d\n"), endCount - startCount);


	CleanupStack::PopAndDestroy(aes);

    test.Next(_L("AES - H/W"));

	
	test.Printf(_L("Setting config\n"));
#ifdef USE_CBCMODE
	r = ldd.SetAesConfig(ETrue, RCryptoDriver::ECbcMode, key, iv);
	test.Printf(_L("    CBC\n"));
#else
	r = ldd.SetAesConfig(ETrue, RCryptoDriver::EEcbMode, key, iv);
	test.Printf(_L("    ECB\n"));
#endif
	test(r==KErrNone);
	

	test.Printf(_L("H/W - Encrypt %d bytes %d times\n"), BUFLEN, LOOPCOUNT);
	TBuf8<BUFLEN> tmp2;
	startCount = User::NTickCount();
	for(int z=0; z < LOOPCOUNT; ++z)
		{
		tmp2.SetLength(0);
		ldd.AesRead(status2, tmp2, tmp2.MaxLength());
		ldd.AesWrite(status, plaintext);
		User::WaitForRequest(status);	
		User::WaitForRequest(status2);
#ifdef DISABLE_AES_CHECKS
		tmp2.SetLength(BUFLEN);
#endif
		}
	endCount = User::NTickCount();
	test.Printf(_L("Duration in ticks (h/w) = %d\n"), endCount - startCount);

	
#ifndef DISABLE_AES_CHECKS
#ifdef __MARM__
	test.Printf(_L("Compare tmp2 and sw\n"));
	test(tmp2==sw);
#else
	test.Printf(_L("Compare tmp2 and plaintext\n"));
    test(tmp2==plaintext);
#endif
#endif





//	User::Panic(_L("Fake app crash"), 42);

    test.Next(_L("Close Logical Channel"));
    ldd.Close();

    __KHEAP_MARKEND;

    test.Next(_L("Unload Logical Device"));
    r=User::FreeLogicalDevice(RCryptoDriver::Name());
    test(r==KErrNone);

    test.Next(_L("Unload Physical Device"));
    TName pddName(RCryptoDriver::Name());
    _LIT(KVariantExtension,".h4");
    pddName.Append(KVariantExtension);
    r=User::FreePhysicalDevice(pddName);
    test(r==KErrNone);

    test.End();

	test.Printf(KTxtPressAnyKey);
	test.Getch(); // get and ignore character
	test.Close();
    }


// End of file