/*

 * Copyright (c) 2005-2006 Nokia Corporation and/or its subsidiary(-ies).

 * All rights reserved.

 * This component and the accompanying materials are made available

 * under the terms of "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:  Contains implementation for encryption/decryption.

 *

 */

 // INCLUDE FILES

 #define EMULATOR ((defined(__WINS__) || defined(__WINSCW__)))

 #include <e32def.h>

 //#include <des.h>

 #include <hash.h>

 #include <errno.h>

 #include <string.h>

 // EXTERNAL FUNCTION PROTOTYPES

 extern "C" char *crypt_des(const char *key, const char *setting);

 extern "C" char *crypt_md5(const char *pw, const char *salt);

 // LOCAL CONSTANTS AND MACROS

 #define BYTE_SIZE	8

 #define ENCRYPTION  0

 #define DECRYPTION  1

 // STATIC DATA

 #if !EMULATOR

 TBuf8<BYTE_SIZE> desKey;				// For persistence between calls 

 										// to setkey() and encrypt()

 static TInt bSetkeyInvoked = 0;

 #else

 #include <sys/types.h>

 #include "wsd_solution.h"

 #define bSetkeyInvoked (GetGlobals()->bSetkeyInvoked)

 #endif

 // LOCAL FUNCTION PROTOTYPES

 static unsigned char GetByte(const char *bitVector);

 static void DesEncryptionL(const TDes8& aKey, TDes8& aInputBlock);

 static void DesDecryptionL(const TDes8& aKey, TDes8& aInputBlock);

 // LOCAL class declaration

 class CEncDecHack : public CBase

 {

 public:

 	virtual void Transform(TDes8& aBlock){}

 };

 typedef CEncDecHack* (*LookupFuncEncDecObjCreator)(const TDesC8& aKey, TBool aCheckWeakKey);

 _LIT(KCryptoDll,"cryptography.dll");

 // -----------------------------------------------------------------------------

 // function_name: _setkey

 //

 // Prepares a byte array for the key from the contents of the incoming bit vector.

 // Key thus constructed is statically stored for use during encryption/decryption.

 //

 // Returns: void

 // -----------------------------------------------------------------------------

 //

 extern "C"

 void _setkey (const char *key)

 {

 #if !EMULATOR

     // Reset the contents of the 'key' descriptor

     desKey.Delete(0,desKey.Length());

 #endif

 #if !EMULATOR    

 	// Pack the contents of the bit vector into a TDes derived object

 	for( int i = 0 ; i < BYTE_SIZE ; ++i)

 	{

 		desKey.Append( GetByte( &key[i * BYTE_SIZE] ) );

 	}

 #else

 	for(int i=0 ; i<64 ; ++i)

 	{

 		(GetGlobals()->desKey)[i] = key[i];

 	}

 #endif

 	bSetkeyInvoked = 1;

 }

 // -----------------------------------------------------------------------------

 // function_name: _encrypt

 //

 // Performs either encryption or decryption of the data block. Prior to invoking

 // Symbian OS cryptography APIs for encryptions/decryption, this function

 // packs the contents of the bit vector into a byte array of size eight. The byte

 // array obtained after encryption/decryption is unpacked to present the output

 // in the form of a bit vector. The incoming data block is modified in place 

 // during the process.

 //

 // Assumption: User of the libcrypt library is expected the create a cleanupstack

 //

 // Returns: void

 // -----------------------------------------------------------------------------

 //

 extern "C"

 void _encrypt (char block[], int edflag)

 {

 #if EMULATOR

 	TBuf8<BYTE_SIZE> desKey;

 #endif

 	// Determine if setkey() is invoked by the user

 	if(!bSetkeyInvoked)

 	{

 		// Initialize the key with default values

 		for(int i = 0 ; i < BYTE_SIZE ; ++i)

 		{

 			desKey.Append((unsigned char)0);

 		}

 		bSetkeyInvoked = 1;

 	}

 #if EMULATOR

 	else

 	{

 		for(int i=0 ; i<BYTE_SIZE ; ++i)

 		{

 			desKey.Append( GetByte( (const char*)&(GetGlobals()->desKey)[i * BYTE_SIZE] ));

 		}

 	}

 #endif

 	// Determine whether encryption or decryption is requested

 	if(edflag != ENCRYPTION)

 	{

 		if(edflag != DECRYPTION)

 		{

 			// Unrecognized flag parameter

 			errno = EPERM;

 			return;

 		}

 	}

 	// Pack the contents of the input bit vector into a "byte" array

 	TBuf8<BYTE_SIZE> inputBlock;

 	TInt nIterator;

 	for(nIterator = 0 ; nIterator < BYTE_SIZE ; ++nIterator)

 	{

 		inputBlock.Append( GetByte( &block[nIterator * BYTE_SIZE] ) );

 	}

 	TInt error = KErrNone;

 	typedef void (*DesOperation)(const TDes8&, TDes8&);

 	DesOperation funcOperationL = NULL;

 	switch(edflag)

 	{

 		case ENCRYPTION:		  // Encryption

 		funcOperationL = DesEncryptionL;

 		break;

 		case DECRYPTION:		  // Decryption

 		funcOperationL = DesDecryptionL;

 		break;

 	}

 	TRAP(error, (*funcOperationL)(desKey, inputBlock));

 	if(error == KErrNone)

 	{

 		unsigned char chTemp;

 		int k = 0;

 		// Create the bit vector from the "byte" array (unpack)

 		for(int i = 0 ; i < BYTE_SIZE ; ++i)

 		{

 			chTemp = inputBlock[i];

 			for(int j = 0 ; j < BYTE_SIZE ; ++j)

 			{

 				block[k++] = ((chTemp & 0x80) >> 7);

 				chTemp <<= 1;

 			}

 		}

 	}

 	else

 	{

 		// Set the errno flag to indicate failure

 		errno = EPERM;

 	}

 }

 // -----------------------------------------------------------------------------

 // function_name: _crypt

 //

 // Uses MD5-based algorithm or DES encryption mechanism to encode a constant

 // string using "key" as the key. Salt determines the algorithm to be used.

 //

 // Returns: pointer to a static data buffer containing the encoded "string"

 // -----------------------------------------------------------------------------

 //

 extern "C" 

 char* _crypt (const char *key, const char *salt)

 {

 	// Identify the algorithm to be used as part of crypt

 	if(strstr(salt, "$1$"))

 	{

 		// MD5-based algorithm

 		return crypt_md5(key, salt);

 	}

 	else

 	{

 		return crypt_des(key, salt);

 	}

 }

 // -----------------------------------------------------------------------------

 // function_name: GetByte

 //

 // Packs the "bits" in the bit vector into a byte

 //

 // Returns: Byte composed of the bits from the bit vector

 // -----------------------------------------------------------------------------

 //

 LOCAL_C unsigned char GetByte(const char *bitVector)

 {

 	unsigned char chTemp = 0;

 	for(int nIterator = 0 ; nIterator < BYTE_SIZE ; ++nIterator)

 	{

 		chTemp |= ( bitVector[nIterator] << (BYTE_SIZE - nIterator - 1) );

 	}

 	return chTemp;

 }

 // -----------------------------------------------------------------------------

 // function_name: DesEncryptionL

 //

 // Function to encrypt the input data bytes by invoking Symbian OS API for

 // DES algorithm for encryption

 //

 // Assumption: 1. BLOCKSIZE within the cryptography library is 8 for 

 // 				  DES encryption

 //			   2. The input key is not checked against a set of known

 //				  weak key values

 //

 // Returns: void, however, this function leaves if there is insufficient

 //          memory

 // -----------------------------------------------------------------------------

 //

 LOCAL_C void DesEncryptionL(const TDes8& aKey, TDes8& aInputBlock)

 {

 	// Construct the encryptor object

 /*	CDESEncryptor *pEncryptor = CDESEncryptor::NewL(aKey, EFalse);

 	if(!pEncryptor)

 	{

 		User::Leave(KErrNoMemory);

 	}

 	// Invoke DES trasnformation to encrypt the input data

 	pEncryptor->Transform(aInputBlock);

 	delete pEncryptor;

 */

 	RLibrary library;

     User::LeaveIfError(library.Load(KCryptoDll));

     #ifdef __WINSCW__

    	TLibraryFunction func = library.Lookup(102); // CDESEncryptor::NewL

     #else

     TLibraryFunction func = library.Lookup(59);  //CDESEncryptor::NewL

 	#endif // ifdef __WINSCW__

     if (func == NULL)

     {

         library.Close();

         User::Leave(KErrNotFound);

     }

     LookupFuncEncDecObjCreator  objCreatorFuncion = reinterpret_cast<LookupFuncEncDecObjCreator> (func);

     CEncDecHack* pEncryptor = reinterpret_cast<CEncDecHack*>(objCreatorFuncion(aKey, EFalse));

     pEncryptor->Transform(aInputBlock);

     delete pEncryptor;

     library.Close();

 }

 // -----------------------------------------------------------------------------

 // function_name: DesDecryptionL

 //

 // Function to encrypt the input data bytes by invoking Symbian OS API for

 // DES algorithm for decryption

 //

 // Assumption: 1. BLOCKSIZE within the cryptography library is 8 for 

 // 				  DES decryption

 //			   2. The input key is not checked against a set of known

 //				  weak key values

 //

 // Returns: void, however, this function leaves if there is insufficient

 //          memory

 // -----------------------------------------------------------------------------

 //

 LOCAL_C void DesDecryptionL(const TDes8& aKey, TDes8& aInputBlock)

 {

 	// Construct the decryptor object

 /*	CDESDecryptor *pDecryptor = CDESDecryptor::NewL(aKey, EFalse);

 	if(!pDecryptor)

 	{

 		User::Leave(KErrNoMemory);

 	}

 	// Invoke DES decryption on the cipher text

 	pDecryptor->Transform(aInputBlock);

 	delete pDecryptor;

 */

     RLibrary library;

     User::LeaveIfError(library.Load(KCryptoDll));

 	#ifdef __WINSCW__

     TLibraryFunction func = library.Lookup(101); // CDESDecryptor::NewL

 	#else

     TLibraryFunction func = library.Lookup(57);  //CDESDecryptor::NewL

 	#endif // ifdef __WINSCW

     if (func == NULL)

     {

         library.Close();

         return;

     }

     LookupFuncEncDecObjCreator  objCreatorFuncion = reinterpret_cast<LookupFuncEncDecObjCreator> (func);

     CEncDecHack* pDecryptor = reinterpret_cast<CEncDecHack*>(objCreatorFuncion(aKey, EFalse));

     pDecryptor->Transform(aInputBlock);

     delete pDecryptor;

     library.Close();

 }

 extern "C" {

 // -----------------------------------------------------------------------------

 // function_name: Deallocate2DimensionalUchar

 //

 // To deallocate storage alloted for the two dimensional array

 //

 // Returns: void

 // -----------------------------------------------------------------------------

 //

 void Deallocate2DimensionalUchar(unsigned char **buffer, int row)

 {

 		int m;

 		for(m=0 ; m<row ; ++m)

 		{

 			User::Free((TAny *)buffer[m]);

 		}

 		User::Free((TAny *)buffer);

 }

 // -----------------------------------------------------------------------------

 // function_name: Deallocate2DimensionalUint

 //

 // To deallocate storage alloted for the two dimensional array

 //

 // Returns: void

 // -----------------------------------------------------------------------------

 //

 void Deallocate2DimensionalUint(__uint32_t **buffer, int row)

 {

 		int m;

 		for(m=0 ; m<row ; ++m)

 		{

 			User::Free((TAny *)buffer[m]);

 		}

 		User::Free((TAny *)buffer);

 }

 // -----------------------------------------------------------------------------

 // function_name: Allocate2DimensionalUchar

 //

 // Function to allocate storage for a two dimensional array from the heap. 

 // If heap exhaustion occurs during the course of allocating memory to the array,

 // the previously allocated storage will be deleted prior to returning to the

 // caller.

 //

 // Returns: non-zero if allocation is successful, 0 if it fails

 // -----------------------------------------------------------------------------

 //

 int Allocate2DimensionalUchar(unsigned char ***buffer, int row, int column)

 {

 	*buffer = (unsigned char **)User::Alloc(row * sizeof(unsigned char *));

 	if(NULL == *buffer)

 	{

 		return 0;

 	}

 	for(int m=0 ; m<row ; ++m)

 	{

 		(*buffer)[m] = (unsigned char *)User::Alloc(column * sizeof(unsigned char));

 		if(NULL == (*buffer)[m])

 		{

 			// Insufficient heap memory

 			if(m)

 			{

 				// Deallocate the previously allocated storage

 				Deallocate2DimensionalUchar(*buffer, m);

 			}

 			return 0;

 		}

 	}

 	return 1;

 }

 // -----------------------------------------------------------------------------

 // function_name: Allocate2DimensionalUint

 //

 // Function to allocate storage for a two dimensional array of type unsigned int

 // from the heap. If heap exhaustion occurs while allocating memory to the array,

 // the previously allocated storage will be deleted prior to returning to the

 // caller.

 //

 // Returns: non-zero if allocation is successful, 0 if it fails

 // -----------------------------------------------------------------------------

 //

 int Allocate2DimensionalUint(__uint32_t ***buffer, int row, int column)

 {

 	*buffer = (__uint32_t **)User::Alloc(row * sizeof(__uint32_t *));

 	if(NULL == *buffer)

 	{

 		return 0;

 	}

 	for(int m=0 ; m<row ; ++m)

 	{

 		(*buffer)[m] = (__uint32_t *)User::Alloc(column * sizeof(__uint32_t));

 		if(NULL == (*buffer)[m])

 		{

 			// Insufficient heap memory

 			if(m)

 			{

 				// Deallocate the previously allocated storage

 				Deallocate2DimensionalUint(*buffer, m);

 			}

 			return 0;

 		}

 	}

 	return 1;

 }

 }	// <<end extern "C">>