/*

* Copyright (c) 2002-2010 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 "bufferedtransformation.h"

#include <cryptospi/cryptospidef.h>

#include <cryptopanic.h>

#include <e32cmn.h>

#include <cryptospi/symmetriccipherplugin.h>

#include "blocktransformation.h"

#include "bufferedtransformationshim.h"

#include "padding.h"

#include "../common/inlines.h"

EXPORT_C CBufferedTransformation::~CBufferedTransformation()

	{

	delete iBT;

	delete iPadding;

	delete iInputStoreBuf;

	}

void CBufferedTransformation::Process(const TDesC8& aInput, TDes8& aOutput)

	{

	__ASSERT_DEBUG(aOutput.MaxLength() >= MaxOutputLength(aInput.Length()), User::Panic(KCryptoPanic, ECryptoPanicOutputDescriptorOverflow));

	TInt blockSize = iBT->BlockSize();

	if ( (aInput.Size() + iInputStore.Size()) < blockSize )

		{

		iInputStore.Append(aInput);

		}

	else

		{

		TInt outputIndex = aOutput.Size();

		aOutput.Append(iInputStore);

		TInt inputIndex = blockSize - iInputStore.Size();

		aOutput.Append(aInput.Mid(0, inputIndex));

		TPtr8 transformBuf((TUint8*)(aOutput.Ptr()) + outputIndex, blockSize,

			blockSize);

		//This should read: 

		//TPtr8 transformBuf(aOutput.Mid(outputIndex, blockSize));

		//but in the wonderful world of descriptors, Mid returns a TPtrC8 even

		//when called on a TPtr8.  Fantastic eh?

		iBT->Transform(transformBuf);

		outputIndex += blockSize;

		TInt len = aInput.Size() - blockSize;

		for (; inputIndex<=len; inputIndex+=blockSize)

			{

			aOutput.Append(aInput.Mid(inputIndex, blockSize));			

			transformBuf.Set((TUint8*)(aOutput.Ptr()) + outputIndex, blockSize,

				blockSize);

			iBT->Transform(transformBuf);

			outputIndex += blockSize;

			}

		iInputStore.Zero();

		if (inputIndex < aInput.Size())

			iInputStore.Append(aInput.Mid(inputIndex));

		}

	}

TInt CBufferedTransformation::MaxOutputLength(TInt aInputLength) const

	{

	TInt rem = (aInputLength + iInputStore.Size()) % (iBT->BlockSize());

	return ((aInputLength + iInputStore.Size()) - rem);

	}

void CBufferedTransformation::Reset()

	{

	iBT->Reset();

	iInputStore.Zero();

	}

TInt CBufferedTransformation::BlockSize() const

	{

	return (iBT->BlockSize());

	}

TInt CBufferedTransformation::KeySize() const

	{

	return (iBT->KeySize());

	}

EXPORT_C CBlockTransformation* CBufferedTransformation::BlockTransformer() const

{

	return (iBT);

}

CBufferedTransformation::CBufferedTransformation()

	: iInputStore(0,0,0)

	{

	}

void CBufferedTransformation::ConstructL(CBlockTransformation* aBT, CPadding* aPadding)

	{

	iInputStoreBuf = HBufC8::NewL(aBT->BlockSize());

	iInputStore.Set(iInputStoreBuf->Des());

	// Take ownership last - doesn't take ownership if we leave

	iBT = aBT;

	iPadding = aPadding;

	}

// CBufferedEncryptor

EXPORT_C CBufferedEncryptor* CBufferedEncryptor::NewL(

	CBlockTransformation* aBT, CPadding* aPadding)

	{

	CBufferedEncryptor* self = CBufferedEncryptorShim::NewL(aBT, aPadding);

	if (! self)

		{			

		// not able to use CryptoSpi, possibly due to an exterally 

		// derived legacy class so fallback to old implementation.			

		self = NewLC(aBT,aPadding);

		CleanupStack::Pop(self);

		}	

	return self;

	}

EXPORT_C CBufferedEncryptor* CBufferedEncryptor::NewLC(

	CBlockTransformation* aBT, CPadding* aPadding)

	{

	CBufferedEncryptor* self = new (ELeave) CBufferedEncryptor();

	CleanupStack::PushL(self);

	self->ConstructL(aBT, aPadding);

	return self;

	}

void CBufferedEncryptor::ConstructL(CBlockTransformation* aBT, CPadding* aPadding) 

	{

	CBufferedTransformation::ConstructL(aBT, aPadding);

	}

CBufferedEncryptor::CBufferedEncryptor()

	{

	}

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

	{

	__ASSERT_DEBUG(aOutput.MaxLength() >= MaxFinalOutputLength(aInput.Length()), User::Panic(KCryptoPanic, ECryptoPanicOutputDescriptorOverflow));

	Process(aInput, aOutput);

	TInt outputIndex = aOutput.Size();

	iPadding->PadL(iInputStore, aOutput);

	assert(aOutput.Size() % iBT->BlockSize() == 0);

	TUint blockSize = iBT->BlockSize();

	TInt len = aOutput.Size() - outputIndex;

	for(TInt i=len; i>0; i-=blockSize)

		{

		TPtr8 transformBuf((TUint8*)(aOutput.Ptr()) + outputIndex, blockSize,

			blockSize);

		iBT->Transform(transformBuf);

		outputIndex+=blockSize;

		}

	iInputStore.Zero();

	}

TInt CBufferedEncryptor::MaxFinalOutputLength(TInt aInputLength) const

	{

    return iPadding->MaxPaddedLength(iInputStore.Size() + aInputLength);

	}

// CBufferedDecryptor

EXPORT_C CBufferedDecryptor* CBufferedDecryptor::NewL(

	CBlockTransformation* aBT, CPadding* aPadding)

	{

	CBufferedDecryptor* self = CBufferedDecryptorShim::NewL(aBT, aPadding);

	if (! self)

		{			

		// not able to use CryptoSpi, possibly due to an exterally 

		// derived legacy class so fallback to old implementation.			

		self = NewLC(aBT,aPadding);

		CleanupStack::Pop(self);

		}	

	return self;

	}

EXPORT_C CBufferedDecryptor* CBufferedDecryptor::NewLC(

	CBlockTransformation* aBT, CPadding* aPadding)

	{

	CBufferedDecryptor* self = new (ELeave) CBufferedDecryptor();

	CleanupStack::PushL(self);

	self->ConstructL(aBT, aPadding);

	return self;

	}

CBufferedDecryptor::CBufferedDecryptor()

	{

	}

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

	{

	__ASSERT_DEBUG(aOutput.MaxLength() >= MaxFinalOutputLength(aInput.Length()), User::Panic(KCryptoPanic, ECryptoPanicOutputDescriptorOverflow));

	assert((aInput.Size() + iInputStore.Size()) % iPadding->BlockSize()==0);

	assert(aInput.Size() + iInputStore.Size() !=0 );

	assert(iPadding->BlockSize() % BlockSize() == 0);

	//1) Decrypt into aOutput up till the last full _padding_ blocksize

	//If this panics with descriptor problems, you've probably called

	//ProcessFinalL with a non-_padding_ blocksized aligned amount of data.

	TInt lenToDecrypt = aInput.Size() - iPadding->BlockSize();

	if(lenToDecrypt > 0)

		{

		Process(aInput.Left(lenToDecrypt), aOutput);

		assert(iInputStore.Size()==0);

		}

	else

		{

		lenToDecrypt = 0;

		}

	//2) Decrypt the last _padding_ blocksize into a new buffer

	HBufC8* padBuf = HBufC8::NewLC(iPadding->BlockSize());

	TPtr8 padPtr = padBuf->Des(); 

	Process(aInput.Mid(lenToDecrypt), padPtr);

	assert(iInputStore.Size()==0);

	//3) Unpad that last _padding_ blocksize into aOutput

	// Note that padding systems must always, like everything else in crypto,

	// _append_ data.

	iPadding->UnPadL(padPtr, aOutput);

	CleanupStack::PopAndDestroy(padBuf);

	}

TInt CBufferedDecryptor::MaxFinalOutputLength(TInt aInputLength) const

	{

	return iPadding->MaxUnPaddedLength(aInputLength + iInputStore.Size());

	}

void CBufferedDecryptor::ConstructL(CBlockTransformation* aBT, CPadding* aPadding) 

	{

	CBufferedTransformation::ConstructL(aBT, aPadding);

	}