--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcrypto/test/tsymmetric/tactionvector.cpp Fri Jun 11 15:32:35 2010 +0300
@@ -0,0 +1,264 @@
+/*
+* 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 "tactionvector.h"
+#include "symmetric.h"
+
+CTestAction* CActionVector::NewL(RFs& aFs,
+ CConsoleBase& aConsole,
+ Output& aOut,
+ const TTestActionSpec& aTestActionSpec)
+{
+ CTestAction* self = CActionVector::NewLC(aFs, aConsole,
+ aOut, aTestActionSpec);
+ CleanupStack::Pop();
+ return self;
+}
+
+CTestAction* CActionVector::NewLC(RFs& aFs,
+ CConsoleBase& aConsole,
+ Output& aOut,
+ const TTestActionSpec& aTestActionSpec)
+{
+ CActionVector* self = new(ELeave) CActionVector(aFs, aConsole, aOut);
+ CleanupStack::PushL(self);
+ self->ConstructL(aTestActionSpec);
+ return self;
+ }
+
+CActionVector::~CActionVector()
+{
+ delete iEncryptor;
+ delete iDecryptor;
+}
+
+CActionVector::CActionVector(RFs& aFs,
+ CConsoleBase& aConsole,
+ Output& aOut)
+
+: CCryptoTestAction(aFs, aConsole, aOut)
+{}
+
+
+void CActionVector::DoPerformPrerequisiteL()
+{
+ TInt err = KErrNone;
+ TInt pos = 0;
+ TPtrC8 vector = Input::ParseElement(*iBody, KVectorStart, KVectorEnd, pos, err);
+
+ DoInputParseL(vector);
+
+ CBlockTransformation* encryptor = NULL;
+ CBlockTransformation* decryptor = NULL;
+ iEncryptor = 0;
+ iDecryptor = 0;
+
+ switch (iCipherType)
+ {
+ case (EDESECB):
+ {
+ encryptor = CDESEncryptor::NewLC(iKey->Des());
+ decryptor = CDESDecryptor::NewL(iKey->Des());
+ CleanupStack::Pop(encryptor);
+ }
+ break;
+ case(EDESCBC):
+ {
+ CBlockTransformation* desEncryptor = NULL;
+ CBlockTransformation* desDecryptor = NULL;
+
+ desEncryptor = CDESEncryptor::NewLC(iKey->Des());
+ desDecryptor = CDESDecryptor::NewLC(iKey->Des());
+
+ encryptor = CModeCBCEncryptor::NewL(desEncryptor, iIV->Des());
+ CleanupStack::PushL(encryptor);
+ decryptor = CModeCBCDecryptor::NewL(desDecryptor, iIV->Des());
+
+ CleanupStack::Pop(3, desEncryptor);
+ }
+ break;
+ case (E3DESECB):
+ {
+ encryptor = C3DESEncryptor::NewLC(iKey->Des());
+ decryptor = C3DESDecryptor::NewL(iKey->Des());
+ CleanupStack::Pop(encryptor);
+ }
+ break;
+ case (E3DESCBC):
+ {
+ CBlockTransformation* the3DESencryptor = NULL;
+ CBlockTransformation* the3DESdecryptor = NULL;
+
+ the3DESencryptor = C3DESEncryptor::NewLC(iKey->Des());
+ the3DESdecryptor = C3DESDecryptor::NewLC(iKey->Des());
+
+ encryptor = CModeCBCEncryptor::NewL(the3DESencryptor, iIV->Des());
+ CleanupStack::PushL(encryptor);
+ decryptor = CModeCBCDecryptor::NewL(the3DESdecryptor, iIV->Des());
+
+ CleanupStack::Pop(3, the3DESencryptor);
+ }
+ break;
+ case (EAESECB):
+ {
+ encryptor = CAESEncryptor::NewLC(iKey->Des());
+ decryptor = CAESDecryptor::NewL(iKey->Des());
+
+ CleanupStack::Pop(encryptor);
+ }
+ break;
+ case (ERC2ECB):
+ {
+ encryptor = CRC2Encryptor::NewLC(iKey->Des(), iEffectiveKeyLen);
+ decryptor = CRC2Decryptor::NewL(iKey->Des(), iEffectiveKeyLen);
+ CleanupStack::Pop(encryptor);
+ }
+ break;
+ case (ERC2CBC):
+ {
+ CBlockTransformation* theRC2encryptor = NULL;
+ CBlockTransformation* theRC2decryptor = NULL;
+
+ theRC2encryptor = CRC2Encryptor::NewLC(iKey->Des(), iEffectiveKeyLen);
+ theRC2decryptor = CRC2Decryptor::NewLC(iKey->Des(), iEffectiveKeyLen);
+
+ encryptor = CModeCBCEncryptor::NewL(theRC2encryptor, iIV->Des());
+ CleanupStack::PushL(encryptor);
+ decryptor = CModeCBCDecryptor::NewL(theRC2decryptor, iIV->Des());
+
+ CleanupStack::Pop(3, theRC2encryptor);
+ }
+ break;
+ case (ERC4):
+ {
+ iEncryptor = CARC4::NewL(*iKey,0);
+ iDecryptor = CARC4::NewL(*iKey,0);
+ }
+ break;
+ case (ECipherNull):
+ {
+ iEncryptor = CNullCipher::NewL();
+ iDecryptor = CNullCipher::NewL();
+ }
+ break;
+
+ default:
+ {
+ ASSERT(0);
+ User::Leave(KErrNotSupported);
+ }
+ }
+
+ CleanupStack::PushL(encryptor);
+ CleanupStack::PushL(decryptor);
+
+ if(!iEncryptor && !iDecryptor)
+ {
+ CPaddingSSLv3* dPadding = CPaddingSSLv3::NewLC(decryptor->BlockSize());
+ CPaddingSSLv3* ePadding = CPaddingSSLv3::NewLC(encryptor->BlockSize());
+ iEncryptor = CBufferedEncryptor::NewL(encryptor, ePadding);
+ CleanupStack::Pop(ePadding);
+ iDecryptor = CBufferedDecryptor::NewL(decryptor, dPadding);
+ CleanupStack::Pop(dPadding);
+ }
+
+ iEResult = HBufC8::NewMaxL(iEncryptor->MaxOutputLength(iInput->Length()));
+ iDResult = HBufC8::NewMaxL(iDecryptor->MaxOutputLength(iEResult->Size()));
+
+ CleanupStack::Pop(2, encryptor);
+}
+
+void CActionVector::DoPerformActionL()
+{
+// First perform the test blockwise (ie passing in one block at a time)
+ TUint blockSize = iEncryptor->BlockSize();
+ TUint index = 0;
+ while (index <= (iInput->Size() - blockSize))
+ {
+ TPtr8 theEncryptResult((TUint8*)&(iEResult->operator[](index)), blockSize, blockSize);
+ theEncryptResult.FillZ(theEncryptResult.MaxLength());
+ theEncryptResult.SetLength(0);
+
+ TPtrC8 theEncryptInput(iInput->Mid(index, blockSize));
+ iEncryptor->Process(theEncryptInput, theEncryptResult);
+
+ if (iOutput->Mid(index, blockSize) == theEncryptResult)
+ iResult = ETrue;
+ else
+ break; // No point doing any more
+
+ index+=blockSize;
+ }
+
+ if (*iOutput==*iEResult)
+ {
+ iResult = ETrue;
+
+ index = 0;
+ while (index <= (iEResult->Size()- blockSize))
+ {
+ TPtr8 theDecryptResult((TUint8*)&(iDResult->operator[](index)), blockSize, blockSize);
+ theDecryptResult.FillZ(theDecryptResult.MaxLength());
+ theDecryptResult.SetLength(0);
+
+ TPtrC8 theDecryptInput(iEResult->Mid(index, blockSize));
+ iDecryptor->Process(theDecryptInput, theDecryptResult);
+
+ if(iInput->Mid(index, blockSize) != theDecryptResult)
+ {
+ iResult = EFalse;
+ break; // No point doing any more
+ }
+
+ index+=blockSize;
+ }
+
+ if (*iInput!=*iDResult)
+ iResult = EFalse;
+ }
+
+
+ iEncryptor->Reset();
+ iDecryptor->Reset();
+// Now, if input is longer than a single block, repeat passing all the data
+ if ((TUint)iInput->Size() > blockSize)
+ {
+ TPtr8 theEncryptResult(iEResult->Des());
+ theEncryptResult.FillZ(theEncryptResult.MaxLength());
+ theEncryptResult.SetLength(0);
+
+ TPtrC8 theInput(*iInput);
+ iEncryptor->Process(theInput, theEncryptResult);
+
+ if (*iOutput!=*iEResult)
+ {
+ iResult = EFalse;
+ }
+ else
+ {
+ TPtr8 theDecryptResult(iDResult->Des());
+ theDecryptResult.FillZ(theDecryptResult.MaxLength());
+ theDecryptResult.SetLength(0);
+
+ iDecryptor->Process(*iEResult, theDecryptResult);
+ if (*iInput!=*iDResult)
+ iResult = EFalse;
+ }
+ }
+}
+