--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/cryptoplugins/cryptospiplugins/test/h4drv/crypto_h4_plugin/tasync.cpp Thu Sep 10 14:01:51 2009 +0300
@@ -0,0 +1,359 @@
+/*
+* 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>
+
+_LIT(KTxtEPOC32EX,"tasync: mainL failed");
+_LIT(KTxtPressAnyKey," [press any key]");
+
+//#define KEYLEN 16
+#define KEYLEN 24
+//#define KEYLEN 32
+
+//#define BUFLEN 256
+//#define BUFLEN (256*16)
+#define BUFLEN 32
+#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("tasync"));
+
+LOCAL_D void dumpBuffer(const TDesC &aName, const TDesC8 &aBuf);
+
+LOCAL_C void encryptL(const TDesC8 &aKey, const TDesC8 &aIV, const TDesC8 &aPlainText,
+ TDes8 &aCipherText);
+LOCAL_C void decryptL(const TDesC8 &aKey, const TDesC8 &aIV, const TDesC8 &aCiphertext,
+ TDes8 &aPlaintext);
+
+LOCAL_C void mainL() // initialize and call example code under cleanup stack
+ {
+ test.Title();
+ //
+ // Generate key and IV
+ //
+ test.Start(_L(" @SYMTestCaseID:SEC-CRYPTOSPI-ASYNC-0001 Generating key & IV for AES tests "));
+ test.Next(_L("Generating key\n"));
+ // Generate 16 byte key
+ TBuf8<KEYLEN> key;
+ key.SetLength(KEYLEN);
+ key[0] = 'K';
+ key[1] = 'E';
+ key[2] = 'Y';
+ key[3] = '*';
+ for(int z=4; z<KEYLEN; ++z) key[z] = z;
+
+
+ test.Next(_L("Generating IV\n"));
+ TBuf8<16> iv;
+ iv.SetLength(iv.MaxLength());
+ iv[0] = 'I';
+ iv[1] = 'V';
+ iv[2] = '*';
+ iv[3] = '*';
+
+ TBuf8<BUFLEN> plaintext;
+ plaintext.FillZ();
+ plaintext.SetLength(plaintext.MaxLength());
+ plaintext[0] = 'P';
+ plaintext[1] = 'L';
+ plaintext[2] = 'A';
+ plaintext[3] = 'I';
+ plaintext[4] = 'N';
+ plaintext[5] = '1';
+ for(int i=6; i<BUFLEN/2; ++i)
+ {
+ plaintext[i] = i;
+ }
+ plaintext[BUFLEN/2] = 'P';
+ plaintext[BUFLEN/2+1] = 'L';
+ plaintext[BUFLEN/2+2] = 'A';
+ plaintext[BUFLEN/2+3] = 'I';
+ plaintext[BUFLEN/2+4] = 'N';
+ plaintext[BUFLEN/2+5] = '2';
+ for(int i=BUFLEN/2+6; i<BUFLEN; ++i)
+ {
+ plaintext[i] = i;
+ }
+ test.End();
+
+ TBuf8<BUFLEN+16> ciphertext;
+ encryptL(key, iv, plaintext, ciphertext);
+
+ TBuf8<BUFLEN> plaintext2;
+ decryptL(key, iv, ciphertext, plaintext2);
+
+ test.Printf(_L("Checking plaintext2 == plaintext\n"));
+ test(plaintext2 == plaintext);
+
+ test.Printf(KTxtPressAnyKey);
+ test.Getch(); // get and ignore character
+ test.Close();
+
+ }
+
+LOCAL_C void encryptL(const TDesC8 &aKey, const TDesC8 &aIV, const TDesC8 &aPlaintext,
+ TDes8 &aCiphertext)
+ {
+ RDebug::Printf("Starting tasync encryption tests\n");
+
+ TPtrC8 chunk1(aPlaintext.Left(16));
+ TPtrC8 chunk2(aPlaintext.Mid(16, aPlaintext.Length()-16));
+
+
+ //
+ // Encrypt using legacy API - Reference
+ //
+ TBuf8<BUFLEN+16> sw;
+ sw.FillZ();
+ sw.SetLength(0);
+
+ test.Start(_L("AES - S/W - Reference encrypt"));
+
+ test.Printf(_L(" CBC\n"));
+ CAESEncryptor *rawaes = CAESEncryptor::NewLC(aKey); // rawaes
+ CModeCBCEncryptor *cbc = CModeCBCEncryptor::NewL(rawaes, aIV);
+ CleanupStack::Pop(rawaes); //
+ CleanupStack::PushL(cbc); // cbc
+
+ CPadding *pad = CPaddingPKCS7::NewLC(16); // cbc, pad
+ 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->Process(chunk1, sw);
+ aes->ProcessFinalL(chunk2, sw);
+ dumpBuffer(_L("sw"), sw);
+
+ CleanupStack::PopAndDestroy(aes);
+
+ //
+ // Encrypt using legacy API
+ //
+ test.Start(_L("AES - S/W - Legacy API - Parallel encrypt"));
+
+ test.Printf(_L(" CBC2\n"));
+ TBuf8<BUFLEN+16> sw2;
+ sw2.FillZ();
+ sw2.SetLength(0);
+ CAESEncryptor *rawaes2 = CAESEncryptor::NewLC(aKey); // rawaes2
+ CModeCBCEncryptor *cbc2 = CModeCBCEncryptor::NewL(rawaes2, aIV);
+ CleanupStack::Pop(rawaes2); //
+ CleanupStack::PushL(cbc2); // cbc2
+
+ CPadding *pad2 = CPaddingPKCS7::NewLC(16); // cbc2, pad2
+ CBufferedEncryptor *aes2 = CBufferedEncryptor::NewL(cbc2, pad2);
+ CleanupStack::Pop(pad2); // cbc2
+ CleanupStack::Pop(cbc2);
+ CleanupStack::PushL(aes2); // aes2
+
+ test.Printf(_L(" CBC3\n"));
+ TBuf8<BUFLEN+16> sw3;
+ sw3.FillZ();
+ sw3.SetLength(0);
+ CAESEncryptor *rawaes3 = CAESEncryptor::NewLC(aKey); // rawaes3
+ CModeCBCEncryptor *cbc3 = CModeCBCEncryptor::NewL(rawaes3, aIV);
+ CleanupStack::Pop(rawaes3); //
+ CleanupStack::PushL(cbc3); // cbc3
+
+ CPadding *pad3 = CPaddingPKCS7::NewLC(16); // cbc3, pad3
+ CBufferedEncryptor *aes3 = CBufferedEncryptor::NewL(cbc3, pad3);
+ CleanupStack::Pop(pad3); // cbc3
+ CleanupStack::Pop(cbc3);
+ CleanupStack::PushL(aes3); // aes3
+
+ test.Printf(_L("About to parallel encrypt\n"));
+#if 1
+ // Parallel
+ aes2->Process(chunk1, sw2);
+ aes3->Process(chunk1, sw3);
+ aes2->ProcessFinalL(chunk2, sw2);
+ aes3->ProcessFinalL(chunk2, sw3);
+#else
+ // Sequential
+ aes2->Process(chunk1, sw2);
+ aes2->ProcessFinalL(chunk2, sw2);
+ aes3->Process(chunk1, sw3);
+ aes3->ProcessFinalL(chunk2, sw3);
+#endif
+
+ dumpBuffer(_L("sw2"), sw2);
+ dumpBuffer(_L("sw3"), sw3);
+
+
+ CleanupStack::PopAndDestroy(aes3);
+ CleanupStack::PopAndDestroy(aes2);
+
+ test.Printf(_L("Checking sw2 == sw3\n"));
+ test(sw2 == sw3);
+
+ test.Printf(_L("Checking sw2 == sw\n"));
+ test(sw2 == sw);
+
+ aCiphertext = sw;
+
+ test.End();
+ }
+
+LOCAL_C void decryptL(const TDesC8 &aKey, const TDesC8 &aIV, const TDesC8 &aCiphertext,
+ TDes8 &aPlaintext)
+ {
+ RDebug::Printf("Starting tasync decryption tests\n");
+
+ TPtrC8 chunk1(aCiphertext.Left(16));
+ TPtrC8 chunk2(aCiphertext.Mid(16, aCiphertext.Length()-16));
+
+ //
+ // Decrypt using legacy API - Reference
+ //
+ TBuf8<BUFLEN+16> sw;
+ sw.FillZ();
+ sw.SetLength(0);
+
+ test.Start(_L("AES - S/W - Reference decrypt"));
+
+ test.Printf(_L(" CBC\n"));
+ CAESDecryptor *rawaes = CAESDecryptor::NewLC(aKey); // rawaes
+ CModeCBCDecryptor *cbc = CModeCBCDecryptor::NewL(rawaes, aIV);
+ CleanupStack::Pop(rawaes); //
+ CleanupStack::PushL(cbc); // cbc
+
+ CPadding *pad = CPaddingPKCS7::NewLC(16); // cbc, pad
+ CBufferedDecryptor *aes = CBufferedDecryptor::NewL(cbc, pad);
+ CleanupStack::Pop(pad); // cbc
+ CleanupStack::Pop(cbc);
+ CleanupStack::PushL(aes); // aes
+
+ test.Printf(_L("About to s/w decrypt (old api)\n"));
+ aes->Process(chunk1, sw);
+ aes->ProcessFinalL(chunk2, sw);
+ dumpBuffer(_L("sw"), sw);
+
+ CleanupStack::PopAndDestroy(aes);
+
+ //
+ // Decrypt using legacy API
+ //
+ test.Start(_L("AES - S/W - Legacy API - Parallel decrypt"));
+
+ test.Printf(_L(" CBC2\n"));
+ TBuf8<BUFLEN+16> sw2;
+ sw2.FillZ();
+ sw2.SetLength(0);
+ CAESDecryptor *rawaes2 = CAESDecryptor::NewLC(aKey); // rawaes2
+ CModeCBCDecryptor *cbc2 = CModeCBCDecryptor::NewL(rawaes2, aIV);
+ CleanupStack::Pop(rawaes2); //
+ CleanupStack::PushL(cbc2); // cbc2
+
+ CPadding *pad2 = CPaddingPKCS7::NewLC(16); // cbc2, pad2
+ CBufferedDecryptor *aes2 = CBufferedDecryptor::NewL(cbc2, pad2);
+ CleanupStack::Pop(pad2); // cbc2
+ CleanupStack::Pop(cbc2);
+ CleanupStack::PushL(aes2); // aes2
+
+ test.Printf(_L(" CBC3\n"));
+ TBuf8<BUFLEN+16> sw3;
+ sw3.FillZ();
+ sw3.SetLength(0);
+ CAESDecryptor *rawaes3 = CAESDecryptor::NewLC(aKey); // rawaes3
+ CModeCBCDecryptor *cbc3 = CModeCBCDecryptor::NewL(rawaes3, aIV);
+ CleanupStack::Pop(rawaes3); //
+ CleanupStack::PushL(cbc3); // cbc3
+
+ CPadding *pad3 = CPaddingPKCS7::NewLC(16); // cbc3, pad3
+ CBufferedDecryptor *aes3 = CBufferedDecryptor::NewL(cbc3, pad3);
+ CleanupStack::Pop(pad3); // cbc3
+ CleanupStack::Pop(cbc3);
+ CleanupStack::PushL(aes3); // aes3
+
+ test.Printf(_L("About to parallel decrypt\n"));
+
+ // Parallel
+ aes2->Process(chunk1, sw2);
+ aes3->Process(chunk1, sw3);
+ aes2->ProcessFinalL(chunk2, sw2);
+ aes3->ProcessFinalL(chunk2, sw3);
+
+ dumpBuffer(_L("sw2"), sw2);
+ dumpBuffer(_L("sw3"), sw3);
+
+
+ CleanupStack::PopAndDestroy(aes3);
+ CleanupStack::PopAndDestroy(aes2);
+
+ test.Printf(_L("Checking sw2 == sw3\n"));
+ test(sw2 == sw3);
+
+ test.Printf(_L("Checking sw2 == sw\n"));
+ test(sw2 == sw);
+
+ aPlaintext = sw;
+
+ test.End();
+ }
+
+
+
+LOCAL_D void dumpBuffer(const TDesC &aName, const TDesC8 &aBuf)
+ {
+ test.Printf(_L("%S ="), &aName);
+ TInt len = aBuf.Length();
+ for(TInt i = 0 ; i < len; ++i)
+ {
+ if(i%16 == 0)
+ {
+ test.Printf(_L("\n "));
+ }
+ test.Printf(_L("%02x "), aBuf[i]);
+ }
+ test.Printf(_L("\n"));
+ }
+
+
+// End of file