crypto/weakcryptospi/test/tcryptospi/src/symmetriccipherctrmodeoutoforderstep.cpp
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/crypto/weakcryptospi/test/tcryptospi/src/symmetriccipherctrmodeoutoforderstep.cpp Thu Sep 10 14:01:51 2009 +0300
@@ -0,0 +1,190 @@
+/*
+* 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
+ @internalTechnology
+*/
+
+#include "symmetriccipherctrmodeoutoforderstep.h"
+
+using namespace CryptoSpi;
+
+CSymmetricCipherCtrModeOutOfOrderStep::CSymmetricCipherCtrModeOutOfOrderStep()
+ {
+ SetTestStepName(KSymmetricCipherCtrModeOutOfOrderStep);
+ }
+
+
+TVerdict CSymmetricCipherCtrModeOutOfOrderStep::doTestStepPreambleL()
+ {
+ SetTestStepResult(EPass);
+ return TestStepResult();
+ }
+
+
+TVerdict CSymmetricCipherCtrModeOutOfOrderStep::doTestStepL()
+ {
+ INFO_PRINTF1(_L("*** Symmetric Cipher - Counter mode out of order operation ***"));
+ INFO_PRINTF2(_L("HEAP CELLS: %d"), User::CountAllocCells());
+
+ if (TestStepResult() != EPass)
+ {
+ return TestStepResult();
+ }
+
+ //Assume failure, unless all is successful
+ SetTestStepResult(EFail);
+
+ TVariantPtrC operationMode;
+
+ CSymmetricCipher* impl = NULL;
+ CKey* key = NULL;
+ SetupCipherL(EFalse, EFalse, operationMode, impl, key);
+
+ INFO_PRINTF1(_L("Plugin loaded."));
+
+ CleanupStack::PushL(key);
+ CleanupStack::PushL(impl);
+
+
+ if (TUid(operationMode) != KOperationModeCTRUid)
+ {
+ ERR_PRINTF2(_L("*** FAIL: This test supports CTR operation mode only and not mode id: %d ***"), (TUid(operationMode)).iUid);
+ CleanupStack::PopAndDestroy(2, key);
+ INFO_PRINTF2(_L("HEAP CELLS: %d"), User::CountAllocCells());
+ return TestStepResult();
+ }
+
+
+ HBufC8* plaintext = ReadInPlaintextL();
+ CleanupStack::PushL(plaintext);
+
+
+ TInt blockSize = CtrModeCalcBlockSizeL(*impl)/8;
+
+ if (plaintext->Length() < ((blockSize * 2) + 1))
+ {
+ ERR_PRINTF2(_L("*** FAIL: Plaintext argument is not long enough for this test, length(B) = %d ***"), plaintext->Length());
+ CleanupStack::PopAndDestroy(3, key);
+ INFO_PRINTF2(_L("HEAP CELLS: %d"), User::CountAllocCells());
+ return TestStepResult();
+ }
+
+ // This will store our calculated version of the ciphertext to compare with that in the .ini file
+ TUint8* calculatedCiphertext = new (ELeave) TUint8[plaintext->Length()];
+ CleanupStack::PushL(calculatedCiphertext);
+ // Ptr to the first block of the calculated ciphertext
+ TPtr8 calcCipherPtr1(calculatedCiphertext, blockSize);
+ // Ptr to the remaining blocks of the calculated ciphertext
+ TPtr8 calcCipherPtr2((calculatedCiphertext + blockSize), (plaintext->Length() - blockSize));
+
+ // Ptr to the first block of the .ini file's plaintext
+ TPtrC8 knownPlainPtr1(plaintext->Ptr(), blockSize);
+ // Ptr to the remaining blocks of the .ini file's plaintext
+ TPtrC8 knownPlainPtr2((plaintext->Ptr() + blockSize), (plaintext->Length() - blockSize));
+
+
+ HBufC8* iv = ReadInIvL();
+ CleanupStack::PushL(iv);
+
+ // Increment IV to the value for the second block so we can encrypt blocks 2+ first
+ HBufC8* incrementedIv1 = CtrModeIncrementCounterL((*iv));
+ CleanupStack::PushL(incrementedIv1);
+
+ impl->SetIvL(*incrementedIv1);
+
+
+ INFO_PRINTF1(_L("Setup complete. Encrypting blocks 2+."));
+ impl->ProcessL(knownPlainPtr2, calcCipherPtr2);
+
+ INFO_PRINTF1(_L("Blocks 2+ encrypted. Reseting and encrypting block 1."));
+ impl->SetIvL((*iv));
+ impl->ProcessL(knownPlainPtr1, calcCipherPtr1);
+
+
+ HBufC8* knownCiphertext = ReadInCiphertextL();
+ CleanupStack::PushL(knownCiphertext);
+
+ // Check that calculated ciphertext matches the expected value
+ TPtrC8 wholeCalcCiphertext(calculatedCiphertext, (plaintext->Length()));
+ if (wholeCalcCiphertext.Compare((*knownCiphertext)) != 0)
+ {
+ ERR_PRINTF1(_L("*** FAIL: Calculated ciphertext does not match expected value ***"));
+ CleanupStack::PopAndDestroy(7, key);
+ INFO_PRINTF2(_L("HEAP CELLS: %d"), User::CountAllocCells());
+ return TestStepResult();
+ }
+ else
+ {
+ INFO_PRINTF1(_L("Calculated ciphertext matches the expected value."));
+ }
+
+
+ // **** SWITCH TO DECRYPTION NOW ****
+
+ // This will store our calculated version of the plaintext to compare with that in the .ini file
+ TUint8* calculatedPlaintext = new (ELeave) TUint8[plaintext->Length()];
+ CleanupStack::PushL(calculatedPlaintext);
+ // Ptr to the first block of the calculated plaintext
+ TPtr8 calcPlainPtr1(calculatedPlaintext, (blockSize * 2));
+ // Ptr to the remaining blocks of the calculated plaintext
+ TPtr8 calcPlainPtr2((calculatedPlaintext + (blockSize * 2)), (plaintext->Length() - (blockSize * 2)));
+
+ // Ptr to the first 2 blocks of the ciphertext
+ TPtrC8 knownCipherPtr1(wholeCalcCiphertext.Ptr(), (blockSize * 2));
+ // Ptr to the remaining blocks of the ciphertext
+ TPtrC8 knownCipherPtr2((wholeCalcCiphertext.Ptr() + (blockSize * 2)), (wholeCalcCiphertext.Length() - (blockSize * 2)));
+
+
+ // Increment IV to the value for the third block so we can decrypt blocks 3+ first
+ HBufC8* incrementedIv2 = CtrModeIncrementCounterL(*incrementedIv1);
+ CleanupStack::PushL(incrementedIv2);
+ impl->SetIvL(*incrementedIv2);
+
+ INFO_PRINTF1(_L("Setup complete. Decrypting blocks 3+."));
+ impl->ProcessL(knownCipherPtr2, calcPlainPtr2);
+
+ INFO_PRINTF1(_L("Blocks 3+ encrypted. Reseting and encrypting blocks 1 and 2."));
+ impl->SetIvL((*iv));
+ impl->ProcessL(knownCipherPtr1, calcPlainPtr1);
+
+ TPtrC8 wholeCalcPlaintext(calculatedPlaintext, (plaintext->Length()));
+
+ if (wholeCalcPlaintext.Compare((*plaintext)) != 0)
+ {
+ ERR_PRINTF1(_L("*** FAIL: Calculated plaintext does not match expected value ***"));
+ }
+ else
+ {
+ INFO_PRINTF1(_L("*** PASS: Calculated plaintext matches the original one ***"));
+ SetTestStepResult(EPass);
+ }
+
+ CleanupStack::PopAndDestroy(9, key);
+
+ INFO_PRINTF2(_L("HEAP CELLS: %d"), User::CountAllocCells());
+
+ return TestStepResult();
+ }
+
+
+TVerdict CSymmetricCipherCtrModeOutOfOrderStep::doTestStepPostambleL()
+ {
+ return TestStepResult();
+ }