/*

 * 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 "symmetriccipherstepbase.h"

 #include <bigint.h>

 /**

 Common setup of a crypto SPI symmetric cipher.

 @param aArc4Check Determines whether the check is run on the cipher type for ARC4 and if it matches, sets up the CCryptoParams accordingly.

 @param aRc2Check Determines whether the check is run on the cipher type for RC2 and if it matches, sets up the CCryptoParams accordingly.

 @param aOperationMode On return is the operation mode read in from the config file and used in the initial setup of the cipher.

 @param aCipher On return the symmetric cipher implementation.

 @param aKey On return aCipher's key object.  This is should not be deleted until after aCipher is deleted.

 @return The error value from the call to the symmetric cipher creation function.

 */

 void CSymmetricCipherStepBase::SetupCipherL(TBool aArc4Check, TBool aRc2Check, TVariantPtrC& aOperationMode, CSymmetricCipher*& aCipher, CKey*& aKey)

 	{	

 	TPtrC keyPath;

 	TVariantPtrC algorithm;

 	TVariantPtrC paddingMode;

 	if(	!GetStringFromConfig(ConfigSection(),KConfigEncryptKey, keyPath) ||

 		!GetStringFromConfig(ConfigSection(),KConfigAlgorithmUid, algorithm) || 

 		!GetStringFromConfig(ConfigSection(),KConfigOperationMode, aOperationMode) ||

 		!GetStringFromConfig(ConfigSection(),KConfigPaddingMode, paddingMode ))

 		{

 		User::Leave(KErrNotFound);

 		}

 	// Create key 

 	TKeyProperty keyProperty;

 	CCryptoParams* params = CCryptoParams::NewLC(); 

 	CFileReader* keyData = CFileReader::NewLC(keyPath);

 	params->AddL( *keyData, KSymmetricKeyParameterUid);

 	aKey=CKey::NewL(keyProperty, *params);

 	CleanupStack::PushL(aKey);

 	CCryptoParams* xparams = NULL;	

 	if ((aArc4Check) && (TUid(algorithm) == KArc4Uid))

 		{

 		// Set the RC4 DiscardBytes to 0

 		xparams = CCryptoParams::NewLC();

 		xparams->AddL(NULL, KARC4DiscardBytes);

 		// Create a Symmetric Cipher with the values from the ini file

 		CSymmetricCipherFactory::CreateSymmetricCipherL(aCipher, algorithm, *aKey, KCryptoModeEncryptUid, aOperationMode, paddingMode, xparams);

 		CleanupStack::PopAndDestroy(xparams);

 		CleanupStack::Pop(aKey);

 		CleanupStack::PopAndDestroy(2, params);

 		}

 	else if ((aRc2Check) && (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);

 		// Create a Symmetric Cipher with the values from the ini file

 		CSymmetricCipherFactory::CreateSymmetricCipherL(aCipher, algorithm, *aKey, KCryptoModeEncryptUid, aOperationMode, paddingMode, xparams);

 		CleanupStack::PopAndDestroy(xparams);

 		CleanupStack::Pop(aKey);

 		CleanupStack::PopAndDestroy(2, params);

 		}

 	else

 		{

 		// Create a Symmetric Cipher with the values from the ini file

 		CSymmetricCipherFactory::CreateSymmetricCipherL(aCipher, algorithm, *aKey, KCryptoModeEncryptUid, aOperationMode, paddingMode, xparams);

 		CleanupStack::Pop(aKey);

 		CleanupStack::PopAndDestroy(2, params);

 		}

 	}

 /**

 When running in CTR mode call this function to calculate the block size of a cipher.

 @param aCipher The cipher whose block size is returned.

 @return The block size in bits.

 */	

 TInt CSymmetricCipherStepBase::CtrModeCalcBlockSizeL(CSymmetricCipher& aCipher)

 	{

   	// aCipher MUST be running in CTR mode

 	aCipher.SetOperationModeL(KOperationModeCBCUid);

 	TInt blockSize = aCipher.BlockSize();

 	aCipher.SetOperationModeL(KOperationModeCTRUid);

 	return blockSize;	

 	}

 /**

 Read in the plaintext from the course file listed in the configuration file.

 @param aPlaintext Descriptor pointing to the plaintext.

 @param aReader This CFileReader pointer must be NULL when passed in. It must not be deleted until after the client has finished with the plaintext.

 */	

 HBufC8* CSymmetricCipherStepBase::ReadInPlaintextL()

 	{

 	TPtrC plaintextPath;

 	if(!GetStringFromConfig(ConfigSection(),KConfigSourcePath, plaintextPath))

 		{

 		User::Leave(KErrNotFound);

 		}

 	return ReadFileL(plaintextPath);

 	}

 /**

 Read in the ciphertext from the course file listed in the configuration file.

 @param aCiphertext Descriptor pointing to the ciphertext.

 @param aReader This CFileReader pointer must be NULL when passed in. It must not be deleted until after the client has finished with the ciphertext.

 */

 HBufC8* CSymmetricCipherStepBase::ReadInCiphertextL()

 	{

 	TPtrC ciphertextPath;

 	if(!GetStringFromConfig(ConfigSection(),KConfigEncryptedPath, ciphertextPath))

 		{

 		User::Leave(KErrNotFound);

 		}

 	return ReadFileL(ciphertextPath);

 	}

 /**

 Read in the IV from the course file listed in the configuration file.

 @param aIV Descriptor pointing to the IV.

 @param aReader This CFileReader pointer must be NULL when passed in. It must not be deleted until after the client has finished with the IV.

 */

 HBufC8* CSymmetricCipherStepBase::ReadInIvL()

 	{

 	TPtrC ivPath;

 	if(!GetStringFromConfig(ConfigSection(),KConfigIVPath, ivPath))

 		{

 		User::Leave(KErrNotFound);

 		}

 	return ReadFileL(ivPath);

 	}

 /**

 @param aCounter

 */	

 HBufC8* CSymmetricCipherStepBase::CtrModeIncrementCounterL(TDesC8& aCounter)

 	{

 	RInteger bigInt = RInteger::NewL(aCounter);

 	CleanupClosePushL(bigInt);

 	++bigInt;

 	HBufC8* result = bigInt.BufferLC();

 	CleanupStack::Pop(result);

 	CleanupStack::PopAndDestroy();

 	return result;

 	}

 HBufC8* CSymmetricCipherStepBase::ReadInHexCiphertextL()

 	{

 	HBufC8* hex = ReadInCiphertextL();

 	CleanupStack::PushL(hex);

 	HBufC8* result = ConvertFromHexFormatToRawL((*hex));

 	CleanupStack::PopAndDestroy(hex);

 	return result;

 	}

 HBufC8* CSymmetricCipherStepBase::ReadInHexPlaintextL()

 	{

 	HBufC8* hex = ReadInPlaintextL();

 	CleanupStack::PushL(hex);

 	HBufC8* result = ConvertFromHexFormatToRawL((*hex));

 	CleanupStack::PopAndDestroy(hex);

 	return result;

 	}	

 HBufC8* CSymmetricCipherStepBase::ReadInHexPlainTextL(TPtrC aFile)

 	{

 	HBufC8* data = ReadFileL(aFile);

 	CleanupStack::PushL(data);

 	HBufC8* result = ConvertFromHexFormatToRawL(*data);

 	CleanupStack::PopAndDestroy(data);

 	return result;

 	}	

 HBufC8* CSymmetricCipherStepBase::ReadFileL(TPtrC aFile)

 	{

 	CFileReader* reader = CFileReader::NewL(aFile);

 	CleanupStack::PushL(reader);

 	TPtrC8 ptr(*reader);

 	HBufC8* fileData = ptr.AllocL();

 	CleanupStack::PopAndDestroy(reader);

 	return fileData;

 	}

 HBufC8* CSymmetricCipherStepBase::ReadInHexIvL()

 	{

 	HBufC8* hex = ReadInIvL();

 	CleanupStack::PushL(hex);

 	HBufC8* result = ConvertFromHexFormatToRawL((*hex));

 	CleanupStack::PopAndDestroy(hex);

 	return result;

 	}

 HBufC8* CSymmetricCipherStepBase::ConvertFromHexFormatToRawL(TDesC8& aInput)

 	{

 	TBuf8<2> hexPair;

 	HBufC8* result = HBufC8::NewLC(aInput.Length()/2);

 	TUint8 val;

 	for(TInt i = 0 ; i < aInput.Length()-1 ; i+=2)

 		{

 		hexPair = aInput.Mid(i,2);

 		TLex8 lex(hexPair);

 		User::LeaveIfError(lex.Val(val, EHex));

 		result->Des().Append(val);			

 		}

 	CleanupStack::Pop(result);

 	return result;	

 	}