/*
* 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">>