diff -r 675a964f4eb5 -r 35751d3474b7 crypto/weakcryptospi/test/tcryptospi/src/symmetriccipherobjectreusestep.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/crypto/weakcryptospi/test/tcryptospi/src/symmetriccipherobjectreusestep.cpp Thu Sep 10 14:01:51 2009 +0300 @@ -0,0 +1,399 @@ +/* +* 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: +* Example CTestStep derived implementation +* +*/ + + +/** + @file + @internalTechnology +*/ +#include "symmetriccipherobjectreusestep.h" + +#include "filewriter.h" +#include "filecompare.h" + +using namespace CryptoSpi; + + +CSymmetricCipherObjectReuseStep::CSymmetricCipherObjectReuseStep(TInt aOffset) : iOffset(aOffset) + { + } + + +CSymmetricCipherObjectReuseStep::~CSymmetricCipherObjectReuseStep() + { + } + + +TVerdict CSymmetricCipherObjectReuseStep::doTestStepPreambleL() + { + SetTestStepResult(EPass); + return TestStepResult(); + } + + +TVerdict CSymmetricCipherObjectReuseStep::doTestStepL() + { + INFO_PRINTF1(_L("*** Symmetric Cipher - Object Reuse ***")); + INFO_PRINTF2(_L("HEAP CELLS: %d"), User::CountAllocCells()); + if (TestStepResult()==EPass) + { + + //Assume failure, unless all is successful + SetTestStepResult(EFail); + + TPtrC keyPath; + TPtrC srcPath; + TVariantPtrC algorithm; + TVariantPtrC operationMode; + TVariantPtrC paddingMode; + + if( !GetStringFromConfig(ConfigSection(),KConfigEncryptKey, keyPath) || + !GetStringFromConfig(ConfigSection(),KConfigSourcePath, srcPath) || + !GetStringFromConfig(ConfigSection(),KConfigAlgorithmUid, algorithm) || + !GetStringFromConfig(ConfigSection(),KConfigOperationMode, operationMode) || + !GetStringFromConfig(ConfigSection(),KConfigPaddingMode, paddingMode )) + { + User::Leave(KErrNotFound); + } + else + { + + //Create an instance of TKeyProperty + TKeyProperty keyProperty; + + //Load the key data using the + CFileReader* keyData = CFileReader::NewLC(keyPath); + + CCryptoParams* params = CCryptoParams::NewLC(); + params->AddL( *keyData, KSymmetricKeyParameterUid); + + CKey* key=CKey::NewL(keyProperty, *params); + CleanupStack::PushL(key); + + CCryptoParams* xparams = NULL; + + if (TUid(algorithm) == KArc4Uid) + { + //Set the RC4 DiscardBytes to 0 + xparams = CCryptoParams::NewL(); + xparams->AddL(NULL, KARC4DiscardBytes); + CleanupStack::PushL(xparams); + } + + if (TUid(algorithm) == KRc2Uid) + { + TInt keylen = TPtrC8(*keyData).Length() * 8; + xparams = CCryptoParams::NewLC(); + + //Set the RC2 EffectiveKeyLen according to the input key size + xparams->AddL( keylen, KRC2EffectiveKeyLenBits); + } + + INFO_PRINTF1(_L("Creating Symmetric Cipher Object...")); + + // Create a Symmetric Cipher with the values from the ini config file + CryptoSpi::CSymmetricCipher * impl = NULL; + TRAPD(err,CSymmetricCipherFactory::CreateSymmetricCipherL + ( + impl, + algorithm, + *key, + KCryptoModeEncryptUid, + operationMode, + paddingMode, + xparams)); + + if(impl && (err == KErrNone)) + { + CleanupStack::PushL(impl); + + const TInt KObjectReuseItterations = 5; // 5 iterations should be enough to check the object reuse feature + // the no of iteration is reduced, to reduce the time taken for execution + + //Boolean to denote the state + TBool testPass = ETrue; + + /*************** Encrypt/Decrypt Reuse Loop ****************/ + for(TInt index = 0; index < KObjectReuseItterations; index++) + { + INFO_PRINTF3(_L("i=%d : START HEAP CELLS: %d"),index, User::CountAllocCells()); + + //-----RESET IMPLEMENTATION OBJECT (NORMAL LOGGING)---------- + + impl->Reset(); + + TRAP(err,impl->SetKeyL(*key)); + + if(err != KErrNone) + { + ERR_PRINTF3(_L("*** ERROR:%d - SetKeyL() i=%d ***"),err,index); + User::Leave(err); + } + + TRAP(err,impl->SetCryptoModeL(KCryptoModeEncryptUid)); + + if(err != KErrNone) + { + ERR_PRINTF3(_L("*** ERROR:%d - SetCryptoModeL() i=%d ***"),err,index); + User::Leave(err); + } + + if(TUid(algorithm) != KArc4Uid) + { + + impl->SetOperationModeL(operationMode); + + if(err != KErrNone) + { + ERR_PRINTF3(_L("*** ERROR:%d - SetOperationModeL() i=%d ***"),err,index); + User::Leave(err); + } + + TRAP(err,impl->SetPaddingModeL(paddingMode)); + + if(err != KErrNone) + { + ERR_PRINTF3(_L("*** ERROR:%d - SetPaddingModeL() i=%d ***"),err,index); + User::Leave(err); + } + + } + + //------------------------------------------------------ + + //find out the block size for this algorithm + TInt blockSize(0); + + if (TUid(operationMode) == KOperationModeCTRUid) + { + blockSize = CtrModeCalcBlockSizeL(*impl); + } + else + { + blockSize = impl->BlockSize(); + } + + HBufC8* iv = NULL; + + if ((TUid(operationMode) == KOperationModeCBCUid) || (TUid(operationMode) == KOperationModeCTRUid)) + { + // block size is in bits so to allocate the correct number of bytes divide by 8 + // iv is left on the cleanup stack for the duration of the test and deleted in a conditional at the end of the outer block. + // If this conditional block changes, take care to update the condition for deleting this allocated IV, near the end of this function. + iv = HBufC8::NewLC(blockSize/8); + + // blocksize is in bits so to allocate the correct number of 8 byte chunks divide by 64 + for(TInt i = 0 ; i Des().Append(_L8("12345678")); + } + + TRAP_LOG(err,impl->SetIvL(iv->Des())); + } + + // convert to bytesize + blockSize/=8; + blockSize += iOffset; + + //read from src file + CFileReader* srcData = CFileReader::NewLC(srcPath,blockSize); + + // first step is to read from the src file one block + // at a time, encrypt that block and then write + // the encrypted block out to a temporary file. + CFileWriter* encryptedDataWriter = CFileWriter::NewLC(TPtrC(KTempEncryptedFilePath)); + + TInt numBlocks = srcData->NumBlocks(); + + INFO_PRINTF1(_L("Starting Incremental Encryption...")); + + for(TInt i = 1 ; i <= numBlocks ; i++) + { + TRAP_LOG(err,srcData->ReadBlockL()); + + //Create buffer for encrypted data + TInt maxOutputLength = impl->MaxFinalOutputLength(TPtrC8(*srcData).Length()); + HBufC8* encrypted = HBufC8::NewLC(maxOutputLength); + TPtr8 encryptedPtr = encrypted->Des(); + + if(i == numBlocks) + { + TRAP(err,impl->ProcessFinalL(*srcData, encryptedPtr)); + + if(err != KErrNone) + { + ERR_PRINTF3(_L("*** ERROR:%d - ProcessFinalL() Block=%d ***"),err,i); + User::Leave(err); + } + } + else + { + TRAP(err,impl->ProcessL(*srcData, encryptedPtr)); + + if(err != KErrNone) + { + ERR_PRINTF3(_L("*** ERROR:%d - ProcessL() Block=%d ***"),err,i); + User::Leave(err); + } + } + + TRAP_LOG(err,encryptedDataWriter->WriteBlockL(encryptedPtr)); + + CleanupStack::PopAndDestroy(encrypted); + } + + CleanupStack::PopAndDestroy(encryptedDataWriter); + + //Switch to Decrypt Crypto Mode + TRAP(err,impl->SetCryptoModeL(KCryptoModeDecryptUid)); + + if(err != KErrNone) + { + ERR_PRINTF3(_L("*** ERROR:%d - SetCryptoModeL() i=%d ***"),err,index); + User::Leave(err); + } + + //If in CTR mode need to reset the keystream to the start of the sequence used for encryption. + if(TUid(operationMode) == KOperationModeCTRUid) + { + impl->SetIvL(iv->Des()); + } + + + // the next step is to read the previously encrypted data + // from the temporary file decrypting this one block + // at a time and outputing this to a temporary file. + CFileReader* encryptedDataReader = CFileReader::NewLC(TPtrC(KTempEncryptedFilePath),blockSize); + CFileWriter* decryptedDataWriter = CFileWriter::NewLC(TPtrC(KTempDecryptedFilePath)); + + numBlocks = encryptedDataReader->NumBlocks(); + + INFO_PRINTF1(_L("Starting Incremental Decryption...")); + + for(TInt i = 1 ; i <= numBlocks ; i++) + { + encryptedDataReader->ReadBlockL(); + //Create buffer for encrypted data + TInt maxOutputLength = impl->MaxFinalOutputLength(TPtrC8(*encryptedDataReader).Length()); + HBufC8* decrypted = HBufC8::NewLC(maxOutputLength); + TPtr8 decryptedPtr = decrypted->Des(); + + //Perform the decryption operation + if(i == numBlocks) + { + TRAP(err,impl->ProcessFinalL(*encryptedDataReader, decryptedPtr)); + + if(err != KErrNone) + { + ERR_PRINTF3(_L("*** ERROR:%d - ProcessFinalL() Block=%d ***"),err,i); + User::Leave(err); + } + } + else + { + TRAP(err,impl->ProcessL(*encryptedDataReader, decryptedPtr)); + + if(err != KErrNone) + { + ERR_PRINTF3(_L("*** ERROR:%d - ProcessL() Block=%d ***"),err,i); + User::Leave(err); + } + } + + TRAP_LOG(err,decryptedDataWriter->WriteBlockL(decryptedPtr)); + + CleanupStack::PopAndDestroy(decrypted); + } + + CleanupStack::PopAndDestroy(decryptedDataWriter); + CleanupStack::PopAndDestroy(encryptedDataReader); + CleanupStack::PopAndDestroy(srcData); + + if((TUid(operationMode) == KOperationModeCBCUid) || (TUid(operationMode) == KOperationModeCTRUid)) + { + // Iv is left on the cleanupstack at creation. + // If it becomes possible for operationMode to be modified during + // the test this needs to be re-engineered. + CleanupStack::PopAndDestroy(iv); + } + + + // compare the src with the file thats been + // encrypted then decrypted + // Note: Returning 0 means that the files match + if(!TFileCompare::CompareL(srcPath,TPtrC(KTempDecryptedFilePath))) + { + INFO_PRINTF2(_L("*** PASS = Source File and Decrypted Data Match - i=%d ***"),index); + } + else + { + testPass = EFalse; + ERR_PRINTF2(_L("*** ERROR: Source File and Decrypted Data Mismatch - i=%d ***"),index); + } + + RFs rFs; + rFs.Connect(); + rFs.Delete( KTempDecryptedFilePath ); + rFs.Delete( KTempEncryptedFilePath ); + rFs.Close(); + + INFO_PRINTF3(_L("*** i=%d : END HEAP CELLS: %d ***"),index, User::CountAllocCells()); + } + + /*************** END OF LOOP ****************/ + + CleanupStack::PopAndDestroy(impl); + + if(testPass == EFalse) + { + ERR_PRINTF1(_L("*** TEST FAIL : Symmetric Cipher - Object Reuse ***")); + } + else + { + INFO_PRINTF1(_L("*** TEST PASS : Symmetric Cipher - Object Reuse ***")); + SetTestStepResult(EPass); + } + + } + else + { + ERR_PRINTF2(_L("*** FAIL: Failed to Create Symmetric Object - %d ***"), err); + User::Leave(err); + } + + if (TUid(algorithm) == KArc4Uid || TUid(algorithm) == KRc2Uid) + { + CleanupStack::PopAndDestroy(xparams); + } + + CleanupStack::PopAndDestroy(key); + CleanupStack::PopAndDestroy(params); + CleanupStack::PopAndDestroy(keyData); + } + } + INFO_PRINTF2(_L("HEAP CELLS: %d"), User::CountAllocCells()); + + return TestStepResult(); + + } + + +TVerdict CSymmetricCipherObjectReuseStep::doTestStepPostambleL() + { + return TestStepResult(); + }