/*

* 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: 

* software hmac implementation

* software hmac implementation

*

*/

/**

 @file

*/

#include "hmacimpl.h"

#include "pluginconfig.h"

#include "md2impl.h"

#include "md5impl.h"

#include "sha1impl.h"

#include "keys.h"

#include "md4impl.h"

using namespace SoftwareCrypto;

CHMacImpl* CHMacImpl::NewL(const CKey& aKey, MSoftwareHash* aHash)

	{

	CHMacImpl* self=NewLC(aKey, aHash);

	CleanupStack::Pop();

	return self;

	}

CHMacImpl* CHMacImpl::NewLC(const CKey& aKey, MSoftwareHash* aHash)

	{

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

	CleanupStack::PushL(self);

	self->ConstructL(aKey, aHash);

	return self;

	}

CHMacImpl* CHMacImpl::NewL(MSoftwareHash* aHash)

	{

	CHMacImpl* self=NewLC(aHash);

	CleanupStack::Pop();

	return self;

	}

CHMacImpl* CHMacImpl::NewLC(MSoftwareHash* aHash)

	{

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

	CleanupStack::PushL(self);

	self->ConstructL(aHash);

	return self;

	}

CHMacImpl::CHMacImpl()

	{

	}

CHMacImpl::CHMacImpl(const CHMacImpl& aMD)

	: 	iDigest(NULL), iInnerPad(aMD.iInnerPad), 

		iOuterPad(aMD.iOuterPad), iBlockSize(aMD.iBlockSize)

	{

	}

CHMacImpl::~CHMacImpl()

	{

	if (iDigest)

		{

		iDigest->Close();	

		}

	}

void CHMacImpl::ConstructL(const CKey& aKey, MSoftwareHash* aHash)

	{

	//Clone the hash implementation

	iDigest=static_cast<MSoftwareHash*>(aHash->ReplicateL());

	InitBlockSizeL();

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

	Initialise(keyContent);	

	}

void CHMacImpl::ConstructL(MSoftwareHash* aHash)

	{

	//Clone the hash implementation

	iDigest=static_cast<MSoftwareHash*>(aHash->ReplicateL());

	InitBlockSizeL();

	}

void CHMacImpl::InitBlockSizeL()

	{

	 const TCharacteristics* ptr(NULL);

	 iDigest->GetCharacteristicsL(ptr);

	 const THashCharacteristics* hashPtr=static_cast<const THashCharacteristics*>(ptr);

	 iBlockSize = hashPtr->iBlockSize/8;

	 iInnerPad.SetLength(iBlockSize);

	 iOuterPad.SetLength(iBlockSize);

	 iInnerPadCopy.SetLength(iBlockSize);

	 iOuterPadCopy.SetLength(iBlockSize);

	}

void CHMacImpl::Initialise(const TDesC8& aKey)

	{

	// initialisation

	if (iDigest)

		{

		iDigest->Reset();

		if( (TUint32)aKey.Size() > iBlockSize)

			{

			iInnerPad = iDigest->Final(aKey);

			}

		else 

			{

			iInnerPad = aKey;

			}

		TUint i;

		for (i=iInnerPad.Size();i<iBlockSize;i++)

			iInnerPad.Append(0);

		iOuterPad=iInnerPad;

		const TUint8 Magic1=0x36, Magic2=0x5c;

		for (i=0;i<iBlockSize;i++)

			{

			iInnerPad[i]^=Magic1;

			iOuterPad[i]^=Magic2;

			}

		//start inner hash

		iDigest->Hash(iInnerPad);

		}

	}

MHash* CHMacImpl::CopyL()

	{

	CHMacImpl* that=new(ELeave) CHMacImpl(*this);

	CleanupStack::PushL(that);

	that->iDigest=iDigest ? static_cast<MSoftwareHash*>(iDigest->CopyL()) : NULL;

	CleanupStack::Pop();

	return that;

	}

MHash* CHMacImpl::ReplicateL()

	{

	CHMacImpl* that=new(ELeave) CHMacImpl(*this);

	CleanupStack::PushL(that);

	that->iDigest=iDigest ? static_cast<MSoftwareHash*>(iDigest->ReplicateL()) : NULL;

	that->Reset();

	CleanupStack::Pop();

	return that;

	}

void CHMacImpl::Reset()

	{

	if (iDigest)

		{

		iDigest->Reset();

		iDigest->Update(iInnerPad);

		}

	}

TPtrC8 CHMacImpl::Hash(const TDesC8& aMessage)

	{

	TPtrC8 ptr(KNullDesC8());

	TPtrC8 finalPtr(KNullDesC8());

	StoreState();

	if (iDigest)

		{

		ptr.Set(iDigest->Final(aMessage));

		iDigest->Update(iOuterPad);

		finalPtr.Set(iDigest->Final(ptr));

		}

	RestoreState();

	if(iDigest)

		{

		iDigest->Update(aMessage);

		}

	return (finalPtr);

	}

void CHMacImpl::Update(const TDesC8& aMessage)

	{

	if(iDigest)

		{

		iDigest->Update(aMessage);

		}

	}

TPtrC8 CHMacImpl::Final(const TDesC8& aMessage)

	{

	TPtrC8 ptr(KNullDesC8());

	if(iDigest)

		{

		ptr.Set(iDigest->Final(aMessage));

		iDigest->Update(iOuterPad);

		iDigest->Final(ptr);

		Reset();

		}

	return (ptr);

	}

void CHMacImpl::RestoreState()

	{

	iOuterPad.Copy(iOuterPadCopy);

	iInnerPad.Copy(iInnerPadCopy);

	if (iDigest)

		{

		iDigest->RestoreState();

		}

	}

void CHMacImpl::StoreState()

	{

	iOuterPadCopy.Copy(iOuterPad);

	iInnerPadCopy.Copy(iInnerPad);

	if (iDigest)

		{

		iDigest->StoreState();	

		}

	}

void CHMacImpl::SetKeyL(const CKey& aKey)

	{

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

	Initialise(keyContent);	

	}

void CHMacImpl::Close()

	{

	delete this;	

	}

void CHMacImpl::GetCharacteristicsL(const TCharacteristics*& aPluginCharacteristics)

	{

	iDigest->GetCharacteristicsL(aPluginCharacteristics);	

	}

const CExtendedCharacteristics* CHMacImpl::GetExtendedCharacteristicsL()

	{

	return iDigest->GetExtendedCharacteristicsL();

	}

// Methods which are not supported can be excluded from the coverage.

#ifdef _BullseyeCoverage

#pragma suppress_warnings on

#pragma BullseyeCoverage off

#pragma suppress_warnings off

#endif

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

	{

	return NULL;	

	}

void CHMacImpl::SetOperationModeL(TUid /*aOperationMode*/)

	{

	User::Leave(KErrNotSupported);

	}