/*
* Copyright (c) 2002-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 "pkcs5kdf.h"
#include "pkcs12kdf.h"
#include "pbedata.h"
#include "pbesymmetricfactory.h"
#include "cryptostrength.h"

EXPORT_C CPBEncryptionData* CPBEncryptionData::NewL(const TDesC8& aPassword,
	TPBECipher aCipher, const TDesC8& aAuthSalt, 
	const TDesC8& aEncryptSalt, const TDesC8& aIV, TUint aIterations)
	{
	CPBEncryptionData* self = NewLC(aPassword, aCipher, aAuthSalt, aEncryptSalt,
		aIV, aIterations);
	CleanupStack::Pop(self);
	return self;
	}

EXPORT_C CPBEncryptionData* CPBEncryptionData::NewLC(const TDesC8& aPassword,
	TPBECipher aCipher, const TDesC8& aAuthSalt, 
	const TDesC8& aEncryptSalt, const TDesC8& aIV, TUint aIterations)
	{
	CPBEncryptionData* self = new(ELeave)CPBEncryptionData();
	CleanupStack::PushL(self);
	self->ConstructL(aPassword, aCipher, aAuthSalt, aEncryptSalt, aIV,
		aIterations);
	return self;
	}

EXPORT_C CPBEncryptionData* CPBEncryptionData::NewL(
	const CPBEncryptionData& aData)
	{
	CPBEncryptionData* self = NewLC(aData);
	CleanupStack::Pop(self);
	return self;
	}

EXPORT_C CPBEncryptionData* CPBEncryptionData::NewLC(
	const CPBEncryptionData& aData)
	{
	CPBEncryptionData* self = new(ELeave)CPBEncryptionData(); 
	CleanupStack::PushL(self);
	self->ConstructL(aData);
	return self;
	}

EXPORT_C CPBEncryptionData* CPBEncryptionData::NewL(
	const TDesC8& aPassword, const TDesC8& aAuthSalt,
	const CPBEncryptParms& aParms)
/**
	This factory function takes the user-supplied password
	and the randomly-generated authentication salt, along
	with the encryption paramaters.  It is provided so the
	encryption parameters can be extended without having to
	provide multiple factory functions.

	@param	aPassword		User-supplied password.  This
							password is not transformed so
							if it needs to be in a particular
							format, e.g. for PKCS#12, the
							transformation must be applied before
							this function is called.
	@param	aAuthSalt		The salt is used to derive the
							authentication key; not the encryption
							key.
	@param	aParms			Encryption parameters describe how the
							data is encrypted.
	@return					New instance of CPBEncryptionData.
 */
	{
	CPBEncryptionData* self = new(ELeave) CPBEncryptionData;
	CleanupStack::PushL(self);
	self->ConstructL(aPassword, aAuthSalt, aParms);
	CleanupStack::Pop(self);
	return self;
	}

void CPBEncryptionData::ConstructL(
	const TDesC8& aPassword, const TDesC8& aAuthSalt,
	const CPBEncryptParms& aParms)
/**
	Second-phase constructor for factory function with
	same signature.
 */
	{
	iParms = CPBEncryptParms::NewL(aParms);
	iAuth = CPBAuthData::NewL(
		aPassword,
		aAuthSalt,
		PBE::GetKeyBytes(aParms.Cipher()),
		aParms.Iterations());
	}

// HPRE-5TDFK2: Remove Store/estor.dll dependency on Cryptography/pbe.dll
// This method is DUPLICATED in common/generic/syslibs/store/ucrypt/ue_strm.cpp
EXPORT_C CPBEncryptionData::CPBEncryptionData(void)
	{
	}

// HPRE-5TDFK2: Remove Store/estor.dll dependency on Cryptography/pbe.dll
// This method is DUPLICATED in common/generic/syslibs/store/ucrypt/ue_strm.cpp
CPBEncryptionData::~CPBEncryptionData(void)
	{
	delete iParms;
	delete iAuth;
	}

void CPBEncryptionData::ConstructL(const TDesC8& aPassword,
	TPBECipher aCipher, const TDesC8& aAuthSalt, 
	const TDesC8& aEncryptSalt, const TDesC8& aIV, TUint aIterations)
	{
	iParms = CPBEncryptParms::NewL(aCipher, aEncryptSalt, aIV, aIterations);
	iAuth = CPBAuthData::NewL(aPassword, aAuthSalt,
		PBE::GetKeyBytes(aCipher), aIterations);
	}

void CPBEncryptionData::ConstructL(const CPBEncryptionData& aData)
	{
	iParms = CPBEncryptParms::NewL(aData.EncryptParms());
	iAuth = CPBAuthData::NewL(aData.AuthData());
	}

EXPORT_C const CPBEncryptParms& CPBEncryptionData::EncryptParms(void) const
	{
	return *iParms;
	} 
EXPORT_C const CPBAuthData& CPBEncryptionData::AuthData(void) const
	{
	return *iAuth;
	}

/* CPBEncryptParms */
EXPORT_C CPBEncryptParms* CPBEncryptParms::NewL()
/**
	This factory function allocates an encryption
	parameters object with default settings.  The
	individual settings can be retrieved and modified
	with the accessor and mutator functions after
	this object has been created.

	This factory function is provided so that individual
	parameters can be modified without providing many
	factory functions.

	@return					New instance of CPBEncryptParms.
 */
	{
	CPBEncryptParms* self = NewLC();
	CleanupStack::Pop(self);
	return self;
	}

EXPORT_C CPBEncryptParms* CPBEncryptParms::NewLC()
/**
	Similar to the NewL overload which takes no
	arguments, this function additionally puts the
	allocated instance of CPBEncryptParms on the
	cleanup stack.

	@return					New instance of CPBEncryptParms.
 */
	{
	CPBEncryptParms* self = new(ELeave) CPBEncryptParms;
	CleanupStack::PushL(self);
	self->ConstructL();
	return self;
	}

void CPBEncryptParms::ConstructL()
/**
	Initialize this object with default cipher, kdf (PKCS#5,)
	salt length, iteration count, and IV.
 */
	{
	iData = new(ELeave) TParamsData;
	iData->iKdf = EKdfPkcs5;
	
	iSalt = HBufC8::NewMaxL(KPBEDefaultSaltBytes);
	TPtr8 saltDes = iSalt->Des();
	TRandom::RandomL(saltDes);
	
	iIterations = KDefaultIterations;
	
	iIV = HBufC8::NewMaxL(KPBEMaxCipherIVBytes);
	
	SetCipher(
			(TCrypto::Strength() == TCrypto::EStrong)
		?	KPBEDefaultStrongCipher : KPBEDefaultWeakCipher );
	}

EXPORT_C CPBEncryptParms* CPBEncryptParms::NewL(TPBECipher aCipher,
	const TDesC8& aSalt, const TDesC8& aIV, TUint aIterations)
	{
	CPBEncryptParms* self = NewLC(aCipher, aSalt, aIV, aIterations);
	CleanupStack::Pop(self);
	return self;
	}

EXPORT_C CPBEncryptParms* CPBEncryptParms::NewLC(TPBECipher aCipher,
	const TDesC8& aSalt, const TDesC8& aIV, TUint aIterations) 
	{
	CPBEncryptParms* self = new(ELeave)CPBEncryptParms();
	CleanupStack::PushL(self);
	self->ConstructL(aCipher, aSalt, aIV, aIterations);
	return self;
	}

EXPORT_C CPBEncryptParms* CPBEncryptParms::NewL(const CPBEncryptParms& aParms)
	{
	CPBEncryptParms* self = NewLC(aParms);
	CleanupStack::Pop(self);
	return self;
	}

EXPORT_C CPBEncryptParms* CPBEncryptParms::NewLC(const CPBEncryptParms& aParms)
	{
	CPBEncryptParms* self = new(ELeave)CPBEncryptParms();
	CleanupStack::PushL(self);
	self->ConstructL(aParms);
	return self;
	}

// HPRE-5TDFK2: Remove Store/estor.dll dependency on Cryptography/pbe.dll
// This method is DUPLICATED in common/generic/syslibs/store/ucrypt/ue_strm.cpp
EXPORT_C CPBEncryptParms::CPBEncryptParms()
	{
	}

// HPRE-5TDFK2: Remove Store/estor.dll dependency on Cryptography/pbe.dll
// This method is DUPLICATED in common/generic/syslibs/store/ucrypt/ue_strm.cpp
CPBEncryptParms::~CPBEncryptParms()
	{
	delete iData;
	delete iSalt;
	delete iIV;	
	}

void CPBEncryptParms::ConstructL(TPBECipher aCipher, const TDesC8& aSalt,
	const TDesC8& aIV, TUint aIterations)
	{
	iData = new(ELeave) TParamsData;
	iData->iCipher = aCipher;
	iData->iKdf = EKdfPkcs5;
	iSalt = aSalt.AllocL();
	iIV = aIV.AllocL();
	iIterations = aIterations;
	}

void CPBEncryptParms::ConstructL(const CPBEncryptParms& aParms)
	{
	iData = new(ELeave) TParamsData;
	iData->iCipher = aParms.Cipher();
	iData->iKdf = aParms.iData->iKdf;
	iSalt = aParms.Salt().AllocL();
	iIterations = aParms.Iterations();
	iIV = aParms.IV().AllocL();
	}

EXPORT_C TPBECipher CPBEncryptParms::Cipher() const
	{
	return iData->iCipher;
	}

EXPORT_C void CPBEncryptParms::SetCipher(TPBECipher aCipher)
 /**
  *	Replace the current cipher.  This function resizes the
  *	IV and replaces its existing contents.
  *	
  *	@param aCipher	New cipher.
  * 
  * @deprecated		Use SetCipherL instead.
  * @see			SetCipherL
  */
	{
	TPtr8 ivDes = iIV->Des();
	ivDes.SetLength(PBE::GetBlockBytes(aCipher));
	TRandom::RandomL(ivDes);
	
	iData->iCipher = aCipher;
	}

EXPORT_C CPBEncryptParms::TKdf CPBEncryptParms::Kdf() const
/**
	Accessor function returns the key derivation function
	(KDF) specified by this object.

	@return					KDF specified by this object.
 */
	{
	return iData->iKdf;
	}

EXPORT_C void CPBEncryptParms::SetKdf(CPBEncryptParms::TKdf aKdf)
/**
	Replace the current key derivation function.

	@param	aKdf			Key derivation function.
 */
	{
	iData->iKdf = aKdf;
	}

EXPORT_C TPtrC8 CPBEncryptParms::Salt() const
	{
	return TPtrC8(*iSalt);
	}

EXPORT_C void CPBEncryptParms::ResizeSaltL(TInt aNewLen)
/**
	Resize the current salt and replace its contents.

	@param	aNewLen			New salt length.
 */
	{
	iSalt = iSalt->ReAllocL(aNewLen);
	TPtr8 saltDes = iSalt->Des();
	TRandom::RandomL(saltDes);
	}

EXPORT_C TInt CPBEncryptParms::Iterations() const
	{
	return iIterations;
	}

EXPORT_C void CPBEncryptParms::SetIterations(TInt aIterCount)
/**
	Replace the current iteration count with the supplied value.
	
	@param	aIterCount		Number of iterations to apply in
							the KDF.
 */
	{
	ASSERT(aIterCount >= 0);
	iIterations = aIterCount;
	}

EXPORT_C TPtrC8 CPBEncryptParms::IV() const
	{
	return TPtrC8(*iIV);
	}

EXPORT_C void CPBEncryptParms::SetIV(const TDesC8& aNewIv)
/**
	Replace the initialization vector.
	
	@param	aNewIv			New initialization vector length.
							This must have no more than
							KPBEMaxCipherIVBytes bytes.
 */
	{
	iIV->Des().Copy(aNewIv);
	}

void CPBEncryptParms::DeriveKeyL(const TDesC8& aPassword, TDes8& aKeyBuf) const
/**
	Derive a key from this object's kdf, salt, amd iteration count.
	
	@param	aPassword		User-supplied password used to generate key.
	@param	aKeyBuf			Buffer to populate with new key.
							On entry it must be set to the required
							key length.
 */
	{
	switch (iData->iKdf)
		{
	case CPBEncryptParms::EKdfPkcs5:
		TPKCS5KDF::DeriveKeyL(aKeyBuf, aPassword, *iSalt, iIterations);
		break;
	
	case CPBEncryptParms::EKdfPkcs12:
		PKCS12KDF::DeriveKeyL(aKeyBuf, PKCS12KDF::EIDByteEncryptKey, aPassword, *iSalt, iIterations);
		break;
	
	default:
		ASSERT(EFalse);
		break;
		}
	}

/* CPBAuthData */

EXPORT_C CPBAuthData* CPBAuthData::NewL(const TDesC8& aPassword,
	const TDesC8& aSalt, TUint aKeySize, TUint aIterations)
	{
	CPBAuthData* self = NewLC(aPassword, aSalt, aKeySize, aIterations);
	CleanupStack::Pop(self);
	return self;
	}

EXPORT_C CPBAuthData* CPBAuthData::NewLC(const TDesC8& aPassword,
	const TDesC8& aSalt, TUint aKeySize, TUint aIterations) 
	{
	CPBAuthData* self = new(ELeave)CPBAuthData();
	CleanupStack::PushL(self);
	self->ConstructL(aPassword, aSalt, aKeySize, aIterations);
	return self;
	}

EXPORT_C CPBAuthData* CPBAuthData::NewL(const CPBAuthData& aData)
	{
	CPBAuthData* self = NewLC(aData);
	CleanupStack::Pop(self);
	return self;
	}

EXPORT_C CPBAuthData* CPBAuthData::NewLC(const CPBAuthData& aData)
	{
	CPBAuthData* self = new(ELeave)CPBAuthData();
	CleanupStack::PushL(self);
	self->ConstructL(aData);
	return self;
	}

// HPRE-5TDFK2: Remove Store/estor.dll dependency on Cryptography/pbe.dll
// This method is DUPLICATED in common/generic/syslibs/store/ucrypt/ue_strm.cpp
EXPORT_C CPBAuthData::CPBAuthData()
	{
	}

// HPRE-5TDFK2: Remove Store/estor.dll dependency on Cryptography/pbe.dll
// This method is DUPLICATED in common/generic/syslibs/store/ucrypt/ue_strm.cpp
CPBAuthData::~CPBAuthData()
	{
	delete iAuthKey;
	delete iSalt;
	}

void CPBAuthData::ConstructL(const TDesC8& aPassword, const TDesC8& aSalt, 
	TUint aKeySize, TUint aIterations)
	{
	iSalt = aSalt.AllocL();
	iIterations = aIterations;
	iAuthKey = HBufC8::NewMaxL(aKeySize);
	TPtr8 authKeyPtr = iAuthKey->Des();
	TPKCS5KDF::DeriveKeyL(authKeyPtr, aPassword, *iSalt, iIterations);
	}

void CPBAuthData::ConstructL(const CPBAuthData& aData)
	{
	iAuthKey = aData.Key().AllocL();
	iSalt = aData.Salt().AllocL();
	iIterations = aData.Iterations();
	}

EXPORT_C TPtrC8 CPBAuthData::Key() const
	{
	return TPtrC8(*iAuthKey);
	}

EXPORT_C TPtrC8 CPBAuthData::Salt() const
	{
	return TPtrC8(*iSalt);
	}

EXPORT_C TInt CPBAuthData::Iterations() const
	{
	return iIterations;
	}

EXPORT_C TBool CPBAuthData::operator==(const CPBAuthData& aAuth) const
	{
	//if the key's are equal, the its true, as the other members are used in key derivation
	return (*iAuthKey == aAuth.Key());
	}