/*
* 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);
		}	
	}