/*

* Copyright (c) 2005-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 <e32std.h>

#include <hash.h>

#include <cryptospi/cryptospidef.h>

#include <cryptospi/cryptohashapi.h>

#include <cryptospi/plugincharacteristics.h>

#include "hashshim.h"

#define EXPANDLOOP

//

// HMAC implementation

//

CHMAC::CHMAC()

	{

	}

CHMAC::CHMAC(CMessageDigest* aDigest)

	:CMessageDigest(),

	iDigest(aDigest),

	iInnerPad(KMaxBlockSize),

	iOuterPad(KMaxBlockSize)

	{

	}

CHMAC::CHMAC(const CHMAC& aMD)

	:CMessageDigest(aMD), 

	iDigest(NULL),

	iInnerPad(aMD.iInnerPad), 

	iOuterPad(aMD.iOuterPad),

	iBlockSize(aMD.iBlockSize)

	{

	}

EXPORT_C CHMAC::~CHMAC(void)

	{

	delete iDigest;

	}

EXPORT_C CHMAC* CHMAC::NewL(const TDesC8& aKey,CMessageDigest* aDigest)

	{		

	CHMAC* self = CHMACShim::NewL(aKey, aDigest);

	if (! self)

		{			

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

		// derived legacy class so fallback to old implementation.			

		self=new(ELeave) CHMAC(aDigest);

		CleanupStack::PushL(self);

		self->InitialiseL(aKey);

		CleanupStack::Pop(self);

		}

	return self;	

	}

// These methods are now deprecated. This is because hashes and HMACs

// should be implemented as plugins to the SPI framework. However, for

// binary compatibility reasons, these methods must be left here.

// There are no tests (hence no coverage) for HMACs outside the plugin

// framework, but this original code is left unmodified.

//

#ifdef _BullseyeCoverage

#pragma suppress_warnings on

#pragma BullseyeCoverage off

#pragma suppress_warnings off

#endif

void CHMAC::InitialiseL(const TDesC8& aKey)

	{

	InitBlockSizeL();

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

		}

	}

void CHMAC::InitBlockSizeL()

 	{

	 if (iDigest)

		{

	 	iBlockSize = iDigest->BlockSize();

		}

	 if(iBlockSize > KMaxBlockSize)

		 {

		 User::Leave(KErrNotSupported);

		 }

 	 iInnerPad.SetLength(iBlockSize);

 	 iOuterPad.SetLength(iBlockSize);

 	 iInnerPadCopy.SetLength(iBlockSize);

 	 iOuterPadCopy.SetLength(iBlockSize);

   	}

EXPORT_C CMessageDigest* CHMAC::CopyL(void)

	{

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

	CleanupStack::PushL(that);

	that->iDigest=iDigest ? iDigest->CopyL() : NULL;

	CleanupStack::Pop();

	return that;

	}

EXPORT_C CMessageDigest*  CHMAC::ReplicateL(void)

	{

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

	CleanupStack::PushL(that);

	that->iDigest=iDigest ? iDigest->ReplicateL() : NULL;

	that->Reset();

	CleanupStack::Pop();

	return that;

	}

EXPORT_C TInt CHMAC::BlockSize(void)

	{

	return iBlockSize;

	}

EXPORT_C TInt CHMAC::HashSize(void)

	{

	return iDigest ? iDigest->HashSize() : 0;

	}

EXPORT_C void CHMAC::Reset(void)

	{

	if (iDigest)

		{

		iDigest->Reset();

		iDigest->Update(iInnerPad);

		}

	}

//	JCS, There may be a more efficient method but I can't find it

//	because using the DoFinal/DoUpdate functions directly calls

//	Store/Restore at inappropriate times and scribbles over stored

//	data

//	This is the only way I've found to both generate a hash value

//	and get this in the correctly updated state

EXPORT_C TPtrC8 CHMAC::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);

	}

EXPORT_C void CHMAC::Update(const TDesC8& aMessage)

	{

	if(iDigest)

		{

		iDigest->Update(aMessage);

		}

	}

EXPORT_C TPtrC8 CHMAC::Final(const TDesC8& aMessage)

	{

	TPtrC8 ptr(KNullDesC8());

	if(iDigest)

		{

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

		iDigest->Update(iOuterPad);

		iDigest->Final(ptr);

		Reset();

		}

	return (ptr);

	}

EXPORT_C TPtrC8 CHMAC::Final()

	{

	TPtrC8 ptr(KNullDesC8());

	if(iDigest)

		{

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

		iDigest->Update(iOuterPad);

		iDigest->Final(ptr);

		Reset();

		}

	return (ptr);

	}

void CHMAC::RestoreState()

	{

	iOuterPad.Copy(iOuterPadCopy);

	iInnerPad.Copy(iInnerPadCopy);

	if (iDigest)

		iDigest->RestoreState();

	}

void CHMAC::StoreState()

	{

	iOuterPadCopy.Copy(iOuterPad);

	iInnerPadCopy.Copy(iInnerPad);

	if (iDigest)

		iDigest->StoreState();

	}