/*

* Copyright (c) 2006-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: 

*

*/

#include "3desimpl.h"

#include "destables.h"

#include "common/inlines.h"

#include "des.inl"

#include "pluginconfig.h"

#include "symmetriccipherimpl.h"

#include <cryptostrength.h>

using namespace SoftwareCrypto;

/* C3DesImpl */

C3DesImpl::C3DesImpl(

	TUid aCryptoMode,

	TUid aOperationMode,

	TUid aPadding) :

	CDesImpl(KDesBlockBytes, aCryptoMode, aOperationMode, aPadding)

	{

	}

C3DesImpl* C3DesImpl::NewL(const CKey& aKey, TUid aCryptoMode, TUid aOperationMode, TUid aPadding)

	{

	C3DesImpl* self = C3DesImpl::NewLC(aKey, aCryptoMode, aOperationMode, aPadding);

	CleanupStack::Pop(self);

	return self;

	}

C3DesImpl* C3DesImpl::NewLC(const CKey& aKey, TUid aCryptoMode, TUid aOperationMode, TUid aPadding)

	{

	C3DesImpl* self = new(ELeave) C3DesImpl(aCryptoMode, aOperationMode, aPadding);

	CleanupStack::PushL(self);

	self->ConstructL(aKey);

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

	TCrypto::IsSymmetricWeakEnoughL(BytesToBits(keyContent.Size()) - keyContent.Size());

	return self;

	}

C3DesImpl::~C3DesImpl()

	{

	// make sure key information isn't visible to other processes if the

	// page is reused.

	Mem::FillZ(&iK1, sizeof(iK1));

	Mem::FillZ(&iK2, sizeof(iK2));

	Mem::FillZ(&iK3, sizeof(iK3));

	}

void C3DesImpl::ConstructL(const CKey& aKey)

	{

	CDesImpl::ConstructL(aKey);

	SetKeySchedule();

	}	

CExtendedCharacteristics* C3DesImpl::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, EFalse);

	}

const CExtendedCharacteristics* C3DesImpl::GetExtendedCharacteristicsL()

	{

	return C3DesImpl::CreateExtendedCharacteristicsL();

	}

TUid C3DesImpl::ImplementationUid() const

	{

	return KCryptoPlugin3DesUid;

	}

TBool C3DesImpl::IsValidKeyLength(TInt aKeyBytes) const

	{

	return (aKeyBytes == K3DesKeyBytes);

	}

TInt C3DesImpl::GetKeyStrength() const

	{

	// Exclude parity bits from each subkey

	return BytesToBits(K3DesKeyBytes - (3 * 8));

	}	

void C3DesImpl::TransformEncrypt(

	TUint8* aBuffer,

	TUint aNumBlocks)

	{			

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

		{		

		ModeEncryptStart(aBuffer);

		TUint32 l, r;

		// Split the block into 2 word-sized big endian portions

		GetBlockBigEndian(aBuffer, l, r);

		IPerm(l,r);

		// The mode is applied to the entire operation and NOT 

		// for each DES transform

		TUid opMode = iOperationMode;

		iOperationMode = KOperationModeECBUid;

		DoTransform(l, r, iK1);

		DoTransform(r, l, iK2);

		DoTransform(l, r, iK3);

		iOperationMode = opMode;

		FPerm(l,r);

		// Put the portions back into the block as little endian

		PutBlockBigEndian(aBuffer, r, l);

		ModeEncryptEnd(aBuffer);

		aBuffer += KDesBlockBytes;

		}

	}

void C3DesImpl::TransformDecrypt(

	TUint8* aBuffer,

	const TUint aNumBlocks)

	{	

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

		{		

		ModeDecryptStart(aBuffer);

		TUint32 l, r;

		// Split the block into 2 word-sized big endian portions

		GetBlockBigEndian(aBuffer, l, r);

		IPerm(l,r);

		// The mode is applied to the entire operation and NOT 

		// for each DES transform

		TUid opMode = iOperationMode;

		iOperationMode = KOperationModeECBUid;

		DoTransform(l, r, iK1);

		DoTransform(r, l, iK2);

		DoTransform(l, r, iK3);

		iOperationMode = opMode;

		FPerm(l,r);

		// Put the portions back into the block as little endian

		PutBlockBigEndian(aBuffer, r, l);	

		ModeDecryptEnd(aBuffer);

		aBuffer += K3DesBlockBytes;

		}

	}	

void C3DesImpl::SetKeySchedule()

	{

	if (iCryptoMode.iUid == KCryptoModeEncrypt)

		{

		// Encrypt -> Decrypt -> Encrypt

		// Encryptor key	

		SetEncryptKeySchedule(iKey->Mid(0, KDesKeyBytes), iK1);

		// Decryptor key

		SetDecryptKeySchedule(iKey->Mid(KDesKeyBytes, 2 * KDesKeyBytes), iK2);

		// Encryptor key

		SetEncryptKeySchedule(iKey->Mid(2 * KDesKeyBytes), iK3);

		}

	else 

		{

		// Decrypt -> Encrypt -> Decrypt

		// Key order is reversed !

		ASSERT(iCryptoMode.iUid == KCryptoModeDecrypt);

		// Decryptor key	

		SetDecryptKeySchedule(iKey->Mid(0, KDesKeyBytes), iK3);

		// Encryptor key

		SetEncryptKeySchedule(iKey->Mid(KDesKeyBytes, 2 * KDesKeyBytes), iK2);

		// Decryptor key

		SetDecryptKeySchedule(iKey->Mid(2 * KDesKeyBytes), iK1);

		}	

	}