sl@0: /*
sl@0: * Copyright (c) 2005-2006 Nokia Corporation and/or its subsidiary(-ies).
sl@0: * All rights reserved.
sl@0: * This component and the accompanying materials are made available
sl@0: * under the terms of "Eclipse Public License v1.0"
sl@0: * which accompanies this distribution, and is available
sl@0: * at the URL "http://www.eclipse.org/legal/epl-v10.html".
sl@0: *
sl@0: * Initial Contributors:
sl@0: * Nokia Corporation - initial contribution.
sl@0: *
sl@0: * Contributors:
sl@0: *
sl@0: * Description:  Contains implementation for encryption/decryption.
sl@0: *
sl@0: */
sl@0: 
sl@0: 
sl@0: // INCLUDE FILES
sl@0: 
sl@0: #define EMULATOR ((defined(__WINS__) || defined(__WINSCW__)))
sl@0: 
sl@0: #include <e32def.h>
sl@0: //#include <des.h>
sl@0: #include <hash.h>
sl@0: #include <errno.h>
sl@0: #include <string.h>
sl@0: 
sl@0: // EXTERNAL FUNCTION PROTOTYPES
sl@0: extern "C" char *crypt_des(const char *key, const char *setting);
sl@0: extern "C" char *crypt_md5(const char *pw, const char *salt);
sl@0: 
sl@0: // LOCAL CONSTANTS AND MACROS
sl@0: #define BYTE_SIZE	8
sl@0: #define ENCRYPTION  0
sl@0: #define DECRYPTION  1
sl@0: 
sl@0: // STATIC DATA
sl@0: #if !EMULATOR
sl@0: TBuf8<BYTE_SIZE> desKey;				// For persistence between calls 
sl@0: 										// to setkey() and encrypt()
sl@0: static TInt bSetkeyInvoked = 0;
sl@0: #else
sl@0: #include <sys/types.h>
sl@0: #include "wsd_solution.h"
sl@0: #define bSetkeyInvoked (GetGlobals()->bSetkeyInvoked)
sl@0: #endif
sl@0: 
sl@0: // LOCAL FUNCTION PROTOTYPES
sl@0: static unsigned char GetByte(const char *bitVector);
sl@0: static void DesEncryptionL(const TDes8& aKey, TDes8& aInputBlock);
sl@0: static void DesDecryptionL(const TDes8& aKey, TDes8& aInputBlock);
sl@0: 
sl@0: // LOCAL class declaration
sl@0: class CEncDecHack : public CBase
sl@0: {
sl@0: public:
sl@0: 	virtual void Transform(TDes8& aBlock){}
sl@0: };
sl@0: 
sl@0: typedef CEncDecHack* (*LookupFuncEncDecObjCreator)(const TDesC8& aKey, TBool aCheckWeakKey);
sl@0: 
sl@0: _LIT(KCryptoDll,"cryptography.dll");
sl@0: 
sl@0: // -----------------------------------------------------------------------------
sl@0: // function_name: _setkey
sl@0: //
sl@0: // Prepares a byte array for the key from the contents of the incoming bit vector.
sl@0: // Key thus constructed is statically stored for use during encryption/decryption.
sl@0: //
sl@0: // Returns: void
sl@0: // -----------------------------------------------------------------------------
sl@0: //
sl@0: extern "C"
sl@0: void _setkey (const char *key)
sl@0: {
sl@0: #if !EMULATOR
sl@0:     // Reset the contents of the 'key' descriptor
sl@0:     desKey.Delete(0,desKey.Length());
sl@0: #endif
sl@0: 
sl@0: #if !EMULATOR    
sl@0: 	// Pack the contents of the bit vector into a TDes derived object
sl@0: 	for( int i = 0 ; i < BYTE_SIZE ; ++i)
sl@0: 	{
sl@0: 		desKey.Append( GetByte( &key[i * BYTE_SIZE] ) );
sl@0: 	}
sl@0: #else
sl@0: 	for(int i=0 ; i<64 ; ++i)
sl@0: 	{
sl@0: 		(GetGlobals()->desKey)[i] = key[i];
sl@0: 	}
sl@0: #endif
sl@0: 
sl@0: 	bSetkeyInvoked = 1;
sl@0: }
sl@0: 
sl@0: // -----------------------------------------------------------------------------
sl@0: // function_name: _encrypt
sl@0: //
sl@0: // Performs either encryption or decryption of the data block. Prior to invoking
sl@0: // Symbian OS cryptography APIs for encryptions/decryption, this function
sl@0: // packs the contents of the bit vector into a byte array of size eight. The byte
sl@0: // array obtained after encryption/decryption is unpacked to present the output
sl@0: // in the form of a bit vector. The incoming data block is modified in place 
sl@0: // during the process.
sl@0: //
sl@0: // Assumption: User of the libcrypt library is expected the create a cleanupstack
sl@0: //
sl@0: // Returns: void
sl@0: // -----------------------------------------------------------------------------
sl@0: //
sl@0: extern "C"
sl@0: void _encrypt (char block[], int edflag)
sl@0: {
sl@0: #if EMULATOR
sl@0: 	TBuf8<BYTE_SIZE> desKey;
sl@0: #endif
sl@0: 
sl@0: 	// Determine if setkey() is invoked by the user
sl@0: 	if(!bSetkeyInvoked)
sl@0: 	{
sl@0: 		// Initialize the key with default values
sl@0: 		for(int i = 0 ; i < BYTE_SIZE ; ++i)
sl@0: 		{
sl@0: 			desKey.Append((unsigned char)0);
sl@0: 		}
sl@0: 		bSetkeyInvoked = 1;
sl@0: 	}
sl@0: #if EMULATOR
sl@0: 	else
sl@0: 	{
sl@0: 		for(int i=0 ; i<BYTE_SIZE ; ++i)
sl@0: 		{
sl@0: 			desKey.Append( GetByte( (const char*)&(GetGlobals()->desKey)[i * BYTE_SIZE] ));
sl@0: 		}
sl@0: 	}
sl@0: #endif
sl@0: 
sl@0: 	// Determine whether encryption or decryption is requested
sl@0: 	if(edflag != ENCRYPTION)
sl@0: 	{
sl@0: 		if(edflag != DECRYPTION)
sl@0: 		{
sl@0: 			// Unrecognized flag parameter
sl@0: 			errno = EPERM;
sl@0: 			return;
sl@0: 		}
sl@0: 	}
sl@0: 	
sl@0: 	// Pack the contents of the input bit vector into a "byte" array
sl@0: 	TBuf8<BYTE_SIZE> inputBlock;
sl@0: 	TInt nIterator;
sl@0: 	for(nIterator = 0 ; nIterator < BYTE_SIZE ; ++nIterator)
sl@0: 	{
sl@0: 		inputBlock.Append( GetByte( &block[nIterator * BYTE_SIZE] ) );
sl@0: 	}
sl@0: 	
sl@0: 	TInt error = KErrNone;
sl@0: 	typedef void (*DesOperation)(const TDes8&, TDes8&);
sl@0: 	DesOperation funcOperationL = NULL;
sl@0: 
sl@0: 	switch(edflag)
sl@0: 	{
sl@0: 		case ENCRYPTION:		  // Encryption
sl@0: 		funcOperationL = DesEncryptionL;
sl@0: 		break;
sl@0: 
sl@0: 		case DECRYPTION:		  // Decryption
sl@0: 		funcOperationL = DesDecryptionL;
sl@0: 		break;
sl@0: 	}
sl@0: 
sl@0: 	TRAP(error, (*funcOperationL)(desKey, inputBlock));
sl@0: 	
sl@0: 	if(error == KErrNone)
sl@0: 	{
sl@0: 		unsigned char chTemp;
sl@0: 		int k = 0;
sl@0: 
sl@0: 		// Create the bit vector from the "byte" array (unpack)
sl@0: 		for(int i = 0 ; i < BYTE_SIZE ; ++i)
sl@0: 		{
sl@0: 			chTemp = inputBlock[i];
sl@0: 			for(int j = 0 ; j < BYTE_SIZE ; ++j)
sl@0: 			{
sl@0: 				block[k++] = ((chTemp & 0x80) >> 7);
sl@0: 				chTemp <<= 1;
sl@0: 			}
sl@0: 		}
sl@0: 	}
sl@0: 	else
sl@0: 	{
sl@0: 		// Set the errno flag to indicate failure
sl@0: 		errno = EPERM;
sl@0: 	}
sl@0: }
sl@0: 
sl@0: // -----------------------------------------------------------------------------
sl@0: // function_name: _crypt
sl@0: //
sl@0: // Uses MD5-based algorithm or DES encryption mechanism to encode a constant
sl@0: // string using "key" as the key. Salt determines the algorithm to be used.
sl@0: //
sl@0: // Returns: pointer to a static data buffer containing the encoded "string"
sl@0: // -----------------------------------------------------------------------------
sl@0: //
sl@0: extern "C" 
sl@0: char* _crypt (const char *key, const char *salt)
sl@0: {
sl@0: 	// Identify the algorithm to be used as part of crypt
sl@0: 	if(strstr(salt, "$1$"))
sl@0: 	{
sl@0: 		// MD5-based algorithm
sl@0: 		return crypt_md5(key, salt);
sl@0: 	}
sl@0: 	else
sl@0: 	{
sl@0: 		return crypt_des(key, salt);
sl@0: 	}
sl@0: }
sl@0: 
sl@0: // -----------------------------------------------------------------------------
sl@0: // function_name: GetByte
sl@0: //
sl@0: // Packs the "bits" in the bit vector into a byte
sl@0: //
sl@0: // Returns: Byte composed of the bits from the bit vector
sl@0: // -----------------------------------------------------------------------------
sl@0: //
sl@0: LOCAL_C unsigned char GetByte(const char *bitVector)
sl@0: {
sl@0: 	unsigned char chTemp = 0;
sl@0: 
sl@0: 	for(int nIterator = 0 ; nIterator < BYTE_SIZE ; ++nIterator)
sl@0: 	{
sl@0: 		chTemp |= ( bitVector[nIterator] << (BYTE_SIZE - nIterator - 1) );
sl@0: 	}
sl@0: 	return chTemp;
sl@0: }
sl@0: 
sl@0: // -----------------------------------------------------------------------------
sl@0: // function_name: DesEncryptionL
sl@0: //
sl@0: // Function to encrypt the input data bytes by invoking Symbian OS API for
sl@0: // DES algorithm for encryption
sl@0: //
sl@0: // Assumption: 1. BLOCKSIZE within the cryptography library is 8 for 
sl@0: // 				  DES encryption
sl@0: //			   2. The input key is not checked against a set of known
sl@0: //				  weak key values
sl@0: //
sl@0: // Returns: void, however, this function leaves if there is insufficient
sl@0: //          memory
sl@0: // -----------------------------------------------------------------------------
sl@0: //
sl@0: LOCAL_C void DesEncryptionL(const TDes8& aKey, TDes8& aInputBlock)
sl@0: {
sl@0: 	// Construct the encryptor object
sl@0: /*	CDESEncryptor *pEncryptor = CDESEncryptor::NewL(aKey, EFalse);
sl@0: 	
sl@0: 	if(!pEncryptor)
sl@0: 	{
sl@0: 		User::Leave(KErrNoMemory);
sl@0: 	}
sl@0: 	
sl@0: 	// Invoke DES trasnformation to encrypt the input data
sl@0: 	pEncryptor->Transform(aInputBlock);
sl@0: 	
sl@0: 	delete pEncryptor;
sl@0: */
sl@0: 	RLibrary library;
sl@0:     User::LeaveIfError(library.Load(KCryptoDll));
sl@0:     
sl@0:     #ifdef __WINSCW__
sl@0:    	TLibraryFunction func = library.Lookup(102); // CDESEncryptor::NewL
sl@0:     #else
sl@0:     TLibraryFunction func = library.Lookup(59);  //CDESEncryptor::NewL
sl@0: 	#endif // ifdef __WINSCW__
sl@0: 	
sl@0:     if (func == NULL)
sl@0:     {
sl@0:         library.Close();
sl@0:         User::Leave(KErrNotFound);
sl@0:     }
sl@0:     LookupFuncEncDecObjCreator  objCreatorFuncion = reinterpret_cast<LookupFuncEncDecObjCreator> (func);
sl@0:     CEncDecHack* pEncryptor = reinterpret_cast<CEncDecHack*>(objCreatorFuncion(aKey, EFalse));
sl@0:     pEncryptor->Transform(aInputBlock);
sl@0:     delete pEncryptor;
sl@0:     library.Close();
sl@0: }
sl@0: 
sl@0: // -----------------------------------------------------------------------------
sl@0: // function_name: DesDecryptionL
sl@0: //
sl@0: // Function to encrypt the input data bytes by invoking Symbian OS API for
sl@0: // DES algorithm for decryption
sl@0: //
sl@0: // Assumption: 1. BLOCKSIZE within the cryptography library is 8 for 
sl@0: // 				  DES decryption
sl@0: //			   2. The input key is not checked against a set of known
sl@0: //				  weak key values
sl@0: //
sl@0: // Returns: void, however, this function leaves if there is insufficient
sl@0: //          memory
sl@0: // -----------------------------------------------------------------------------
sl@0: //
sl@0: LOCAL_C void DesDecryptionL(const TDes8& aKey, TDes8& aInputBlock)
sl@0: {
sl@0: 	// Construct the decryptor object
sl@0: /*	CDESDecryptor *pDecryptor = CDESDecryptor::NewL(aKey, EFalse);
sl@0: 	
sl@0: 	if(!pDecryptor)
sl@0: 	{
sl@0: 		User::Leave(KErrNoMemory);
sl@0: 	}
sl@0: 	
sl@0: 	// Invoke DES decryption on the cipher text
sl@0: 	pDecryptor->Transform(aInputBlock);
sl@0: 	
sl@0: 	delete pDecryptor;
sl@0: */
sl@0:     RLibrary library;
sl@0:     User::LeaveIfError(library.Load(KCryptoDll));
sl@0:     
sl@0: 	#ifdef __WINSCW__
sl@0:     TLibraryFunction func = library.Lookup(101); // CDESDecryptor::NewL
sl@0: 	#else
sl@0:     TLibraryFunction func = library.Lookup(57);  //CDESDecryptor::NewL
sl@0: 	#endif // ifdef __WINSCW
sl@0: 	
sl@0:     if (func == NULL)
sl@0:     {
sl@0:         library.Close();
sl@0:         return;
sl@0:     }
sl@0:     LookupFuncEncDecObjCreator  objCreatorFuncion = reinterpret_cast<LookupFuncEncDecObjCreator> (func);
sl@0:     CEncDecHack* pDecryptor = reinterpret_cast<CEncDecHack*>(objCreatorFuncion(aKey, EFalse));
sl@0:     pDecryptor->Transform(aInputBlock);
sl@0:     delete pDecryptor;
sl@0:     library.Close();
sl@0: }
sl@0: 
sl@0: extern "C" {
sl@0: 
sl@0: // -----------------------------------------------------------------------------
sl@0: // function_name: Deallocate2DimensionalUchar
sl@0: //
sl@0: // To deallocate storage alloted for the two dimensional array
sl@0: //
sl@0: // Returns: void
sl@0: // -----------------------------------------------------------------------------
sl@0: //
sl@0: void Deallocate2DimensionalUchar(unsigned char **buffer, int row)
sl@0: {
sl@0: 		int m;
sl@0: 		for(m=0 ; m<row ; ++m)
sl@0: 		{
sl@0: 			User::Free((TAny *)buffer[m]);
sl@0: 		}
sl@0: 		User::Free((TAny *)buffer);
sl@0: }
sl@0: 	
sl@0: // -----------------------------------------------------------------------------
sl@0: // function_name: Deallocate2DimensionalUint
sl@0: //
sl@0: // To deallocate storage alloted for the two dimensional array
sl@0: //
sl@0: // Returns: void
sl@0: // -----------------------------------------------------------------------------
sl@0: //
sl@0: void Deallocate2DimensionalUint(__uint32_t **buffer, int row)
sl@0: {
sl@0: 		int m;
sl@0: 		for(m=0 ; m<row ; ++m)
sl@0: 		{
sl@0: 			User::Free((TAny *)buffer[m]);
sl@0: 		}
sl@0: 		User::Free((TAny *)buffer);
sl@0: }
sl@0: 
sl@0: // -----------------------------------------------------------------------------
sl@0: // function_name: Allocate2DimensionalUchar
sl@0: //
sl@0: // Function to allocate storage for a two dimensional array from the heap. 
sl@0: // If heap exhaustion occurs during the course of allocating memory to the array,
sl@0: // the previously allocated storage will be deleted prior to returning to the
sl@0: // caller.
sl@0: //
sl@0: // Returns: non-zero if allocation is successful, 0 if it fails
sl@0: // -----------------------------------------------------------------------------
sl@0: //
sl@0: int Allocate2DimensionalUchar(unsigned char ***buffer, int row, int column)
sl@0: {
sl@0: 	*buffer = (unsigned char **)User::Alloc(row * sizeof(unsigned char *));
sl@0: 	if(NULL == *buffer)
sl@0: 	{
sl@0: 		return 0;
sl@0: 	}
sl@0: 	for(int m=0 ; m<row ; ++m)
sl@0: 	{
sl@0: 		(*buffer)[m] = (unsigned char *)User::Alloc(column * sizeof(unsigned char));
sl@0: 		if(NULL == (*buffer)[m])
sl@0: 		{
sl@0: 			// Insufficient heap memory
sl@0: 			if(m)
sl@0: 			{
sl@0: 				// Deallocate the previously allocated storage
sl@0: 				Deallocate2DimensionalUchar(*buffer, m);
sl@0: 			}
sl@0: 			return 0;
sl@0: 		}
sl@0: 	}
sl@0: 	
sl@0: 	return 1;
sl@0: }
sl@0: 
sl@0: // -----------------------------------------------------------------------------
sl@0: // function_name: Allocate2DimensionalUint
sl@0: //
sl@0: // Function to allocate storage for a two dimensional array of type unsigned int
sl@0: // from the heap. If heap exhaustion occurs while allocating memory to the array,
sl@0: // the previously allocated storage will be deleted prior to returning to the
sl@0: // caller.
sl@0: //
sl@0: // Returns: non-zero if allocation is successful, 0 if it fails
sl@0: // -----------------------------------------------------------------------------
sl@0: //
sl@0: int Allocate2DimensionalUint(__uint32_t ***buffer, int row, int column)
sl@0: {
sl@0: 	*buffer = (__uint32_t **)User::Alloc(row * sizeof(__uint32_t *));
sl@0: 	if(NULL == *buffer)
sl@0: 	{
sl@0: 		return 0;
sl@0: 	}
sl@0: 	for(int m=0 ; m<row ; ++m)
sl@0: 	{
sl@0: 		(*buffer)[m] = (__uint32_t *)User::Alloc(column * sizeof(__uint32_t));
sl@0: 		if(NULL == (*buffer)[m])
sl@0: 		{
sl@0: 			// Insufficient heap memory
sl@0: 			if(m)
sl@0: 			{
sl@0: 				// Deallocate the previously allocated storage
sl@0: 				Deallocate2DimensionalUint(*buffer, m);
sl@0: 			}
sl@0: 			return 0;
sl@0: 		}
sl@0: 	}
sl@0: 	
sl@0: 	return 1;
sl@0: }
sl@0: 
sl@0: }	// <<end extern "C">>