/*

 * 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 <e32std.h>

 #include <random.h>

 #include <cryptostrength.h>

 #include <securityerr.h>

 #include <pbedata.h>

 #include "pkcs5kdf.h"

 #include "pbe.h"

 #include <pbencryptor.h>

 #include "pbesymmetricfactory.h"

 EXPORT_C CPBEncryptElement* CPBEncryptElement::NewL(const TPBPassword& aPassword)

 	{

 	CPBEncryptElement* self = NewLC(aPassword);

 	CleanupStack::Pop();

 	return self;

 	}

 EXPORT_C CPBEncryptElement* CPBEncryptElement::NewLC(const TPBPassword& aPassword)

 	{

 	CPBEncryptElement* self = new(ELeave) CPBEncryptElement;

 	CleanupStack::PushL(self);

 	self->ConstructL(aPassword.Password());

 	return self;

 	}

 EXPORT_C CPBEncryptElement* CPBEncryptElement::NewL(const TPBPassword& aPassword, 

 	const TPBECipher aCipher)

 	{

 	CPBEncryptElement* self = NewLC(aPassword, aCipher);

 	CleanupStack::Pop();

 	return self;

 	}

 EXPORT_C CPBEncryptElement* CPBEncryptElement::NewLC(const TPBPassword& aPassword, 

 	const TPBECipher aCipher)

 	{

 	CPBEncryptElement* self = new(ELeave) CPBEncryptElement;

 	CleanupStack::PushL(self);

 	self->ConstructL(aPassword.Password(), aCipher);

 	return self;

 	}

 EXPORT_C CPBEncryptElement* CPBEncryptElement::NewL(const TPBPassword& aPassword, 

 	const CPBEncryptParms& aParms)

 	{

 	CPBEncryptElement* self = NewLC(aPassword, aParms);

 	CleanupStack::Pop();

 	return self;

 	}

 EXPORT_C CPBEncryptElement* CPBEncryptElement::NewLC(const TPBPassword& aPassword, 

 	const CPBEncryptParms& aParms)

 	{

 	CPBEncryptElement* self = new(ELeave) CPBEncryptElement;

 	CleanupStack::PushL(self);

 	self->ConstructL(aPassword.Password(), aParms);

 	return self;

 	}

 EXPORT_C CPBEncryptElement* CPBEncryptElement::NewL(

 	const CPBEncryptionData& aData, const TPBPassword& aPassword)

 	{

 	CPBEncryptElement* self = CPBEncryptElement::NewLC(aData, aPassword);

 	CleanupStack::Pop();

 	return self;

 	}

 EXPORT_C CPBEncryptElement* CPBEncryptElement::NewLC(

 	const CPBEncryptionData& aData, const TPBPassword& aPassword)

 	{

 	CPBEncryptElement* self = new(ELeave) CPBEncryptElement;

 	CleanupStack::PushL(self);

 	self->ConstructL(aData, aPassword);

 	return self;

 	}

 CPBEncryptElement::CPBEncryptElement(void) 

 	{

 	}

 CPBEncryptElement::~CPBEncryptElement(void)

 	{

 	delete iData;

 	delete iEncryptKey;

 	}

 void CPBEncryptElement::ConstructL(const TDesC8& aPassword)

 	{

 	// Construct based on cryptography strength

 	if (TCrypto::Strength() == TCrypto::EStrong)

 		{

 		ConstructL(aPassword, KPBEDefaultStrongCipher);

 		}

 	else

 		{

 		ConstructL(aPassword, KPBEDefaultWeakCipher);

 		}

 	}

 void CPBEncryptElement::ConstructL(const TDesC8& aPassword, TPBECipher aCipher)

 	{

 	TBuf8<KPBEMaxCipherIVBytes> iv(KPBEMaxCipherIVBytes);

 	iv.SetLength(PBE::GetBlockBytes(aCipher));

 	TRandom::RandomL(iv);

 	TBuf8<KPBEDefaultSaltBytes> encryptSalt(KPBEDefaultSaltBytes);

 	TRandom::RandomL(encryptSalt);

 	TBuf8<KPBEDefaultSaltBytes> authSalt(KPBEDefaultSaltBytes);

 	TRandom::RandomL(authSalt);

 	iData = CPBEncryptionData::NewL(aPassword, aCipher, authSalt, encryptSalt,

 		iv, KDefaultIterations);

 	MakeEncryptKeyL(PBE::GetKeyBytes(aCipher), aPassword);

 	}

 void CPBEncryptElement::ConstructL(const CPBEncryptionData& aData, 

 	const TPBPassword& aPassword)

 	{

 	iData = CPBEncryptionData::NewL(aData);

 	if(!AuthenticateL(aPassword))

 		{

 		User::Leave(KErrBadPassphrase);

 		}

 	}

 void CPBEncryptElement::ConstructL(const TDesC8& aPassword,

 	const CPBEncryptParms& aParms)

 	{

 	TUint keySize = PBE::GetKeyBytes(aParms.Cipher());

 	TBuf8<KPBEDefaultSaltBytes> authSalt(KPBEDefaultSaltBytes);

 	TRandom::RandomL(authSalt);

 	//Recreate parms with given data and create a totally new auth

 	iData = CPBEncryptionData::NewL(aPassword, authSalt, aParms);

 	MakeEncryptKeyL(keySize, aPassword);

 	}

 const CPBEncryptionData& CPBEncryptElement::EncryptionData(void) const

 	{

 	return *iData;

 	}

 CPBEncryptor* CPBEncryptElement::NewEncryptL() const 

 	{

 	CPBEncryptor* encryptor = NewEncryptLC();

 	CleanupStack::Pop();

 	return encryptor;

 	}

 CPBEncryptor* CPBEncryptElement::NewEncryptLC() const

 	{

 	CPBEncryptor* encryptor = CPBEncryptorElement::NewLC( 

 		iData->EncryptParms().Cipher(), *iEncryptKey, 

 		iData->EncryptParms().IV());

 	return encryptor;

 	}

 TBool CPBEncryptElement::AuthenticateL(const TPBPassword& aPassword)

 	{

 	TBool retval = EFalse;

 	//create a new auth to test against the existing one

 	//therefore we use the same key size, and salt as the current one

 	CPBAuthData* auth = CPBAuthData::NewLC(aPassword.Password(),

 		iData->AuthData().Salt(), iData->AuthData().Key().Size(),

 		iData->AuthData().Iterations());

 	if(*auth==iData->AuthData())

 		{

 		//We've got a valid password, regenerate the key so they can decrypt

 		//stuff.  We don't the change the length of iEncryptKey as we assume the

 		//previous key size is appropriate for the new one

 		MakeEncryptKeyL(PBE::GetKeyBytes(iData->EncryptParms().Cipher()),

 			aPassword.Password());

 		retval = ETrue;

 		}

 	CleanupStack::PopAndDestroy(auth);

 	return retval;

 	}

 CPBDecryptor* CPBEncryptElement::NewDecryptL() const

 	{

 	CPBDecryptor* decryptor = NewDecryptLC();

 	CleanupStack::Pop();

 	return decryptor;

 	}

 CPBDecryptor* CPBEncryptElement::NewDecryptLC() const

 	{

 	CPBDecryptor* decryptor = CPBDecryptorElement::NewLC(

 		iData->EncryptParms().Cipher(), *iEncryptKey,

 		iData->EncryptParms().IV());

 	return decryptor;

 	}

 // Warning: This function is only valid BEFORE you call NewEncryptL

 // After creating the cipher, ask it about itself, not me!

 // This is _very_ dodgy as I assume all sorts of things about the encryptor.

 // 1) That it uses SSLv3 or similar style padding

 // 2) That it stores the IV for that stream at the front.

 // This is here for specific application that requires this and aren't able to

 // actually construct the cipher and ask it.  In almost all other cases you

 // should construct the cipher and ask it.

 TInt CPBEncryptElement::MaxCiphertextLength(TInt aPlaintextLength) const

 	{

 	TUint blocksize = PBE::GetBlockBytes(iData->EncryptParms().Cipher());

 	TUint padding = blocksize - aPlaintextLength % blocksize;

 	//len = inputLength + padding

 	return aPlaintextLength + padding;

 	}

 // Warning: This function is only valid BEFORE you call NewDecryptL

 // After creating the cipher, ask it about itself, not me!

 TInt CPBEncryptElement::MaxPlaintextLength(TInt aCiphertextLength) const

 	{

 	/*It's impossible to determine anything about how much padding will be

 	 * removed.  So we'll return a max length that is longer than will

 	 * ever happen by at most a blocksize - 1.

 	 */

 	//totallength = inputlength - 1 byte of padding min

 	return aCiphertextLength - 1;

 	}

 void CPBEncryptElement::MakeEncryptKeyL(TUint aKeySize, const TDesC8& aPassword)

 	{

 	iEncryptKey = HBufC8::NewMaxL(aKeySize);

 	TPtr8 encryptKeyBuf = iEncryptKey->Des();

 	iData->EncryptParms().DeriveKeyL(aPassword, encryptKeyBuf);

 	}

 EXPORT_C TPBPassword::TPBPassword(const TDesC8& aPassword)

 	{

 	iPassword.Set(aPassword);

 	}

 EXPORT_C TPBPassword::TPBPassword(const TDesC16& aPassword)

 	{

 	iPassword.Set(reinterpret_cast<const TUint8*>(aPassword.Ptr()), aPassword.Size());

 	}

 EXPORT_C const TDesC8& TPBPassword::Password(void) const

 	{

 	return iPassword;

 	}