/*

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

#include <e32def.h>

#include <cryptostrength.h>

#include <cryptospi/cryptospidef.h>

#include "keys.h"

#include <cryptospi/plugincharacteristics.h>

#include "pluginconfig.h"

#include <cryptopanic.h>

#include <securityerr.h>

using namespace HwCrypto;

#define BytesToBits(byteCount) (byteCount*8)

//

// Implementation of Symmetric Cipher class

//

CH4CipherImpl::CH4CipherImpl(TUint8 aBlockBytes,

							 TUid aCryptoMode,

							 TUid aOperationMode,

							 TUid aPaddingMode) 

	: iBlockBytes(aBlockBytes),

	  iCryptoMode(aCryptoMode),

	  iOperationMode(aOperationMode),

	  iPaddingMode(aPaddingMode)

	{

	}

void CH4CipherImpl::ConstructL(const CKey& aKey) 

	{

	SetKeyL(aKey);		

	SetOperationModeL(iOperationMode);

	SetCryptoModeL(iCryptoMode);	

	SetPaddingModeL(iPaddingMode);

	iPartialBlock.ReAllocL(iBlockBytes);

	iPaddingBlock.ReAllocL(iBlockBytes);

	iIv.ReAllocL(iBlockBytes);

	//	iIv.SetLength(iBlockBytes);

	//	TRandom::RandomL(iIv);

	}

CExtendedCharacteristics* CH4CipherImpl::CreateExtendedCharacteristicsL()

	{

	// All Symbian software plug-ins have unlimited concurrency, cannot be reserved

	// for exclusive use and are not CERTIFIED to be standards compliant.		

	//	return CExtendedCharacteristics::NewL(KMaxTInt, iStandardsConformance, EFalse);	

	return 0;	

	}

CH4CipherImpl::~CH4CipherImpl()

	{			

	delete iPadding;

	iIv.Close();

	iPartialBlock.Close();

	iPaddingBlock.Close();	

	delete iKey;	

	iStandardsConformance.Close();	

	}

void CH4CipherImpl::Close()

	{

	delete this;

	}

TAny* CH4CipherImpl::GetExtension(TUid /*aExtensionId*/) 

	{

	return 0;

	}

void CH4CipherImpl::GetCharacteristicsL(const TAny*& aPluginCharacteristics)

	{

	TInt numCiphers = sizeof(KSymmetricCipherCharacteristics)/sizeof(TSymmetricCipherCharacteristics*);

	TInt32 implUid = ImplementationUid().iUid;

	for (TInt i = 0; i < numCiphers; ++i)

		{

		if (KSymmetricCipherCharacteristics[i]->cmn.iImplementationUID == implUid)

			{

			aPluginCharacteristics = KSymmetricCipherCharacteristics[i];

			break;

			}

		}	

	}

void CH4CipherImpl::Reset()

	{

	iPartialBlock.Zero();

	iPaddingBlock.Zero();

	// Reconfigure h/w based on iCryptoMode/iOperationMode/iKey/iIv

	TRAP_IGNORE(DoSetupL());

	iNeedToSetupHw = EFalse;

	}	

TInt CH4CipherImpl::GetKeyStrength() const

	{

	return BytesToBits(iKey->Length());

	}

HBufC8* CH4CipherImpl::ExtractKeyDataLC(const CKey& aKey) const

	{

	const TDesC8& keyContent = aKey.GetTDesC8L(KSymmetricKeyParameterUid);

	return keyContent.AllocLC();

	}

TInt CH4CipherImpl::KeySize() const

	{

	// return key size in BITS

	return BytesToBits(iKeyBytes);

	}

void CH4CipherImpl::SetKeyL(const CKey& aKey)

	{

	HBufC8* key = ExtractKeyDataLC(aKey);

	TInt keyLength(key->Length());

	const TKeyProperty &keyProps = aKey.KeyProperty();

	if(keyProps.iKeyType != KSymmetricKeyUid)

		{

		User::Leave(KErrArgument);

		}

	if(keyProps.iKeyAttribute == KNonEmbeddedKeyUid)

		{

		// Not an embedded key, so key is the actual key data and we

		// can therefore check its strength...

		TCrypto::IsSymmetricWeakEnoughL(BytesToBits(keyLength));

		if (! IsValidKeyLength(keyLength))

			{

			User::Leave(KErrNotSupported);

			}

		}

	delete iKey;	

	CleanupStack::Pop(key);

	iKey = key;

	iKeyBytes = keyLength;

	// H/W needs reconfiguring

	iNeedToSetupHw = ETrue;

	}	

TInt CH4CipherImpl::BlockSize() const

	{

	// return block size in BITS

	return BytesToBits(iBlockBytes);

	}

void CH4CipherImpl::SetCryptoModeL(TUid aCryptoMode)

	{

	switch (aCryptoMode.iUid)

		{

		case KCryptoModeEncrypt:

		case KCryptoModeDecrypt:

			break;

		default:

			User::Leave(KErrNotSupported);

		}

	iCryptoMode = aCryptoMode;		

	// H/W needs reconfiguring

	iNeedToSetupHw = ETrue;

	}

void CH4CipherImpl::SetOperationModeL(TUid aOperationMode)

	{

	switch (aOperationMode.iUid)

		{

		case KOperationModeNone:

		case KOperationModeECB:

		case KOperationModeCBC:

			break;

		default:

			User::Leave(KErrNotSupported);

		}

	iOperationMode = aOperationMode;		

	// H/W needs reconfiguring

	iNeedToSetupHw = ETrue;

	}

void CH4CipherImpl::SetPaddingModeL(TUid aPaddingMode)

	{

	if(!iPadding || (aPaddingMode != iPaddingMode))

		{

		CPadding* padding(0);

		switch (aPaddingMode.iUid)

			{

			case KPaddingModeNone:

				padding = CPaddingNone::NewL(iBlockBytes);

				break;

			case KPaddingModeSSLv3:

			padding = CPaddingSSLv3::NewL(iBlockBytes);

			break;

			case KPaddingModePKCS7:

				padding = CPaddingPKCS7::NewL(iBlockBytes);

				break;

			default:

				User::Leave(KErrNotSupported);

			}

		delete iPadding;

		iPadding = padding;

		iPaddingMode = aPaddingMode;

		}

	// H/W needs reconfiguring

	iNeedToSetupHw = ETrue;

	}

void CH4CipherImpl::SetIvL(const TDesC8& aIv)

	{

	if (iOperationMode.iUid != KOperationModeCBC)

		{

		User::Leave(KErrNotSupported);

		}

	if (aIv.Length() != iBlockBytes) 

		{

		User::Leave(KErrArgument);

		}

	iIv = aIv;	

	// H/W needs reconfiguring

	iNeedToSetupHw = ETrue;

	}

TInt CH4CipherImpl::MaxOutputLength(TInt aInputLength) const

	{	

	// The maximum output length required for Process is equal to the

	// size of the number of whole input blocks available.

	//

	// The block bytes is a power of two so we can use this to avoid

	// doing a real mod operation

	TUint partialBlockLength(iPartialBlock.Length());

	return (partialBlockLength + aInputLength) & ~TUint32(iBlockBytes - 1);

	}	

TInt CH4CipherImpl::MaxFinalOutputLength(TInt aInputLength) const

	{

	if (iCryptoMode.iUid == KCryptoModeEncrypt)

		{

		return iPadding->MaxPaddedLength(iPartialBlock.Length() + aInputLength);

		}

	else

		{

		return iPadding->MaxUnPaddedLength(aInputLength + iPartialBlock.Length());

		}

	}

void CH4CipherImpl::ProcessL(const TDesC8& aInput, TDes8& aOutput)

	{

	if(iNeedToSetupHw)

		{

		// Reconfigure h/w based on iCryptoMode/iOperationMode/iKey/iIv

		DoSetupL();

		iNeedToSetupHw = EFalse;

		}

	TInt inputLength(aInput.Length());	

	if (MaxOutputLength(inputLength) > aOutput.MaxLength())

		{

		User::Leave(KErrOverflow);

		}	

	TInt partialBlockLength(iPartialBlock.Length()); // partial data written to h/w last time

	TUint32 totalInput = partialBlockLength + inputLength;

	// Pass new data to h/w driver

	DoWriteL(aInput.Ptr(), inputLength);

	if(totalInput < iBlockBytes)

		{

		// Keep a copy of the partial block which is inside the h/w

		// driver in case we need to calculate pad for it later...

		if(inputLength) iPartialBlock.Append(aInput);

		// Not enough written yet for more data to be available yet.

		return;

		}

	else

		{

		// We have completed the previous partial block so we no

		// longer need to keep a copy of it

		iPartialBlock.Zero();

		// Work out length of partial block at end of current data

		TUint32 trailing = TUint32(partialBlockLength + inputLength) & TUint32(iBlockBytes - 1);

		// Keep a copy of the partial block data

		if(trailing) iPartialBlock.Append(aInput.Right(trailing));

		}

	//

	// Work out how much data is available for reading.

	//

	// The h/w processes data a block at a time, and we only ever read

	// a multiple of the block size so the available data will always

	// be a multiple of the blocksize.

	TUint32 availableData = totalInput & ~TUint32(iBlockBytes - 1);

	if (availableData)

		{

		// Read available data

		DoReadL(aOutput, availableData);

		}

	}

void CH4CipherImpl::ProcessFinalL(const TDesC8& aInput, TDes8& aOutput)

	{

	if(iNeedToSetupHw)

		{

		// Reconfigure h/w based on iCryptoMode/iOperationMode/iKey/iIv

		DoSetupL();

		iNeedToSetupHw = EFalse;

		}

	if(MaxFinalOutputLength(aInput.Length()) > aOutput.MaxLength() - aOutput.Length())

		{

		User::Leave(KErrOverflow);

		}

	if(iCryptoMode.iUid == KCryptoModeEncrypt)

		{

		// process everything up to the last (possibly empty block)

		ProcessL(aInput, aOutput);

		// pad the plaintext

		iPaddingBlock.Zero();

		iPadding->PadL(iPartialBlock, iPaddingBlock);

		TUint32 padLength = iPaddingBlock.Length();

		// Make sure pad worked

		if(padLength & TUint32(iBlockBytes-1))

			{

			User::Leave(KErrInvalidPadding);

			}

		if(padLength > 0)

			{

			// Padding created

			// We have already written iPartialBlock data to the h/w

			// so skip those bytes which are in the pad.

			TUint32 partialLength = iPartialBlock.Length();

			if(partialLength)

				{

				// Make sure the pad algorithm did not change the bytes at

				// the start of the block....

				if(iPaddingBlock.Left(partialLength) != iPartialBlock)

					{

					User::Leave(KErrInvalidPadding);

					}

				}

			// Pass new data to h/w driver

			DoWriteL(iPaddingBlock.Ptr() + partialLength, padLength - partialLength);

			// Have now written an exact multiple of blocks to h/w so clear partial

			iPartialBlock.Zero();

			// Read data

			DoReadL(aOutput, padLength);

			}

		}

	else

		{

		// Decrypt

		// Input length (including inputstore) must be a multiple of the 

		// block size in length

		if ((aInput.Length() + iPartialBlock.Length()) & (iBlockBytes - 1)) 

			{

			User::Leave(KErrArgument);

			}

		// process everything up to the last (possibly empty block)

		ProcessL(aInput, aOutput);

		ASSERT(iPartialBlock.Length()==0); // all the blocks should have been decrypted

		// Retrieve last decrypted block.

		iPaddingBlock = aOutput.Right(iBlockBytes);

		aOutput.SetLength(aOutput.Length() - iBlockBytes);

		// Unpad the last block and (re)append to output

		iPadding->UnPadL(iPaddingBlock, aOutput);

		iPaddingBlock.Zero();

		iPartialBlock.Zero();

		}

	}

// End of file