/*

* Copyright (c) 2008-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 Mac Implementation

* Software Mac Implementation

* MAC plugin header

*

*/

/**

 @file

*/

#include "macimpl.h"

#include "pluginconfig.h"

/**

 * HMAC plugin headers

 */ 

#include "md2impl.h"

#include "md4impl.h"

#include "md5impl.h"

#include "sha1impl.h"

#include "sha2impl.h"

#include "hmacimpl.h"

using namespace SoftwareCrypto;

using namespace CryptoSpi;

CMacImpl* CMacImpl::NewL(const CKey& aKey, const TUid aImplementationId, const CCryptoParams* aAlgorithmParams)

	{

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

	CleanupStack::PushL(self);

	self->ConstructL(aKey, aImplementationId, aAlgorithmParams);

	CleanupStack::Pop();

	return self;

	}

CMacImpl::CMacImpl() 

	{

	}

void CMacImpl::ConstructL(const CKey& aKey, const TUid aImplementationId, const CCryptoParams* /*aAlgorithmParams*/) 

	{

	iImplementationUid = aImplementationId; 

	iKey = CryptoSpi::CKey::NewL(aKey);

	MSoftwareHash* hashImpl = NULL;

	switch (aImplementationId.iUid)

		{

		case KCryptoPluginMacHashMd2:

			{

			hashImpl = CMD2Impl::NewL();

			CleanupClosePushL(*hashImpl);

			iHmacImpl=CHMacImpl::NewL(*iKey, hashImpl);

			iBase = EHashBased;

			}

			break;

		case KCryptoPluginMacHashMd5:

			{

			hashImpl = CMD5Impl::NewL();

			CleanupClosePushL(*hashImpl);

			iHmacImpl=CHMacImpl::NewL(*iKey, hashImpl);

			iBase = EHashBased;

			}

			break;

		case KCryptoPluginMacHashMd4:

			{

			hashImpl = CMD4Impl::NewL();

			CleanupClosePushL(*hashImpl);

			iHmacImpl=CHMacImpl::NewL(*iKey, hashImpl);

			iBase = EHashBased;

			}

			break;

		case KCryptoPluginMacHashSha1:

			{

			hashImpl = CSHA1Impl::NewL();

			CleanupClosePushL(*hashImpl);

			iHmacImpl=CHMacImpl::NewL(*iKey, hashImpl);

			iBase = EHashBased;

			}

			break;

		case KCryptoPluginMacHashSha224:

			{

			hashImpl = CSHA2Impl::NewL(KCryptoPluginSha224);

			CleanupClosePushL(*hashImpl);

			iHmacImpl=CHMacImpl::NewL(*iKey, hashImpl);

			iBase = EHashBased;

			}

			break;

		case KCryptoPluginMacHashSha256:

			{

			hashImpl = CSHA2Impl::NewL(KCryptoPluginSha256);

			CleanupClosePushL(*hashImpl);

			iHmacImpl=CHMacImpl::NewL(*iKey, hashImpl);

			iBase = EHashBased;

			}

			break;

		case KCryptoPluginMacHashSha384:

			{

			hashImpl = CSHA2Impl::NewL(KCryptoPluginSha384);

			CleanupClosePushL(*hashImpl);

			iHmacImpl=CHMacImpl::NewL(*iKey, hashImpl);

			iBase = EHashBased;

			}

			break;

		case KCryptoPluginMacHashSha512:

			{

			hashImpl = CSHA2Impl::NewL(KCryptoPluginSha512);

			CleanupClosePushL(*hashImpl);

			iHmacImpl=CHMacImpl::NewL(*iKey, hashImpl);

			iBase = EHashBased;

			}

			break;

		case KCryptoPluginMacAesXcbcMac96:

			{

			CSymmetricCipher* symmetricCipher = NULL;

			CryptoSpi::CSymmetricCipherFactory::CreateSymmetricCipherL(symmetricCipher,

														CryptoSpi::KAesUid, *iKey,

														CryptoSpi::KCryptoModeEncryptUid,

														CryptoSpi::KOperationModeCBCUid,

														CryptoSpi::KPaddingModeNoneUid,

														NULL);

			iCmacImpl= CCMacImpl::NewL(*iKey, symmetricCipher, CryptoSpi::KAlgorithmCipherAesXcbcMac96);

			iBase = ECipherBased;

			}

			break;

		case KCryptoPluginMacAesXcbcPrf128:

			{

			TBuf8<16> tempKey;

			tempKey.SetLength(16);

			CryptoSpi::CCryptoParams* keyParams = CryptoSpi::CCryptoParams::NewLC();

			keyParams->AddL(tempKey, CryptoSpi::KSymmetricKeyParameterUid);

			CryptoSpi::CKey* key = CryptoSpi::CKey::NewLC(aKey.KeyProperty(),*keyParams);

			CSymmetricCipher* symmetricCipher = NULL;

			CryptoSpi::CSymmetricCipherFactory::CreateSymmetricCipherL(symmetricCipher,

														CryptoSpi::KAesUid, *key,

														CryptoSpi::KCryptoModeEncryptUid,

														CryptoSpi::KOperationModeCBCUid,

														CryptoSpi::KPaddingModeNoneUid,

														NULL);

			CleanupStack::PopAndDestroy(2, keyParams); //key and keyParams

			iCmacImpl= CCMacImpl::NewL(*iKey, symmetricCipher, CryptoSpi::KAlgorithmCipherAesXcbcPrf128);

			iBase = ECipherBased;

			}

			break;

		default:

			User::Leave(KErrNotSupported);

		}

	if(iBase == EHashBased)

		{

		CleanupStack::PopAndDestroy(hashImpl);

		}

	}

CMacImpl::~CMacImpl()

	{

	delete iKey;

	if(iHmacImpl)

		{

		iHmacImpl->Close();

		}

	delete iCmacImpl;

	}

void CMacImpl::Reset()

	{

	if (iBase == EHashBased)

		{

		iHmacImpl->Reset();

		}

	else if (iBase == ECipherBased)

		{

		iCmacImpl->Reset();

		}

	}

void CMacImpl::Close()

	{

	delete this;	

	}

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

	{

	aPluginCharacteristics=NULL;

	TInt macNum=sizeof(KMacCharacteristics)/sizeof(TMacCharacteristics*);

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

		{

		if (KMacCharacteristics[i]->iMacChar.iImplementationUID==ImplementationUid().iUid)

			{

			aPluginCharacteristics = KMacCharacteristics[i];

			break;

			}

		}	

	}

const CExtendedCharacteristics* CMacImpl::GetExtendedCharacteristicsL()

	{

	return (iBase == EHashBased) ? iHmacImpl->GetExtendedCharacteristicsL(): iCmacImpl->GetExtendedCharacteristicsL();

	}

TAny* CMacImpl::GetExtension(TUid aExtensionId)

	{

	return (iBase == EHashBased) ? iHmacImpl->GetExtension(aExtensionId): NULL;

	}

TUid CMacImpl::ImplementationUid() const

	{

	return iImplementationUid;

	}

TPtrC8 CMacImpl::MacL(const TDesC8& aMessage)

	{

	return (iBase == EHashBased) ? iHmacImpl->Hash(aMessage):iCmacImpl->MacL(aMessage);

	}		

void CMacImpl::UpdateL(const TDesC8& aMessage)

	{

	(iBase == EHashBased) ? iHmacImpl->Update(aMessage):iCmacImpl->UpdateL(aMessage);

	}

TPtrC8 CMacImpl::FinalL(const TDesC8& aMessage)

	{

	return (iBase == EHashBased) ? iHmacImpl->Final(aMessage):iCmacImpl->FinalL(aMessage);

	}

void CMacImpl::ReInitialiseAndSetKeyL(const CKey& aKey)

	{

	delete iKey;

	iKey = NULL;

	iKey = CryptoSpi::CKey::NewL(aKey);

	if (iBase == EHashBased)

		{

		iHmacImpl->SetKeyL(aKey);

		iHmacImpl->Reset();

		}

	else if (iBase == ECipherBased)

		{

		iCmacImpl->ReInitialiseAndSetKeyL(aKey);

		}

	}

MMac* CMacImpl::ReplicateL()

	{

	CMacImpl* that= new(ELeave) CMacImpl();

	CleanupStack::PushL(that);

	that->iImplementationUid = iImplementationUid;

	that->iBase = iBase;

	that->iKey=CKey::NewL(*iKey);

	if(iBase == EHashBased)

		{

		that->iHmacImpl=static_cast<CHMacImpl*>(iHmacImpl->ReplicateL());

		}

	else if (iBase == ECipherBased)

		{

		that->iCmacImpl= iCmacImpl->ReplicateL();

		}

	CleanupStack::Pop(that);

	return that;

	}

MMac* CMacImpl::CopyL()

	{

	CMacImpl* that= new(ELeave) CMacImpl();

	CleanupStack::PushL(that);

	that->iImplementationUid = iImplementationUid;

	that->iBase = iBase;

	that->iKey=CKey::NewL(*iKey);

	if(iBase == EHashBased)

		{

		that->iHmacImpl=static_cast<CHMacImpl*>(iHmacImpl->CopyL());

		}

	else if (iBase == ECipherBased)

		{

		that->iCmacImpl= iCmacImpl->CopyL();

		}

	CleanupStack::Pop(that);

	return that;

	}