/*

* 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:  Methods that allows to encrypt and decrypt data.

*

*/

#include <e32def.h>

#include <string.h>

#include <random.h>

#include <stdlib.h>

// reading different cipher algorithm

#include <3des.h>

#include <des.h>

#include <rijndael.h>

#include <nullcipher.h>

#include <blocktransformation.h>

#include <padding.h>

#include <cbcmode.h>

#include <bufferedtransformation.h>

#include <msymmetriccipher.h>

/** A port of gnu useful functions to Symbian **/

#include "xmlsecc_config.h"

#include "xmlsecc_globals.h"

#include "xmlsec_error_flag.h"

#include "xmlsecc_padding.h"

#include "xmlsecc_cryptowrapper.h"

// set block size according to "Symmetric ciphers - How To"

//#define MAX_BLOCKSIZE 16

const TInt KBlockSize( 8 );

const TInt KAESBlockSize( 16 );

#define CTX_MAGIC_NORMAL 0x24091964

#define CTX_MAGIC_SECURE 0x46919042

const TInt KDESKeySize( 8 );

const TInt K3DESKeySize( 24 );

const TInt KAESKeySize128( 16 );

const TInt KAESKeySize192( 24 );

const TInt KAESKeySize256( 32 );

/* The handle structure.  */

struct sc_cipher_handle

{

  int magic;

  size_t actual_handle_size;     /* Allocated size of this handle. */

  CSymmetricCipher* iEncryptor;				// CBlockTransformation

  CSymmetricCipher* iDecryptor;

  HBufC8* iKey;

  TInt algo;

  size_t blocksize;

  int mode;

  unsigned int flags;

  HBufC8* iv; 

  int unused;  /* in IV */

};

// Call Symbian random generator 

void doRandomizeL(unsigned char* buffer, size_t length)

    {  

	HBufC8* hbuf = HBufC8::NewLC(length);   

    TPtr8 ptr = hbuf->Des();

    ptr.FillZ(ptr.MaxLength());

    CSystemRandom* rand=CSystemRandom::NewLC();

    rand->GenerateBytesL(ptr);

    memcpy(buffer, hbuf->Ptr(), length);

    CleanupStack::PopAndDestroy(rand);    

    CleanupStack::PopAndDestroy(hbuf);	

    }

/**

  - Function: void sc_randomize (unsigned char *BUFFER, size_t LENGTH,

           enum sc_random_level LEVEL)

 **/

TInt sc_randomize(unsigned char* buffer, size_t length, enum sc_random_level level)

    {

	TInt leaveValue( KErrNone );

    TRAP(leaveValue, doRandomizeL (buffer, length));

    if ( leaveValue != KErrNone )

        {

        xmlSecSetErrorFlag( leaveValue );

        }

    return leaveValue;

    }

/* Retrieve the block length used with algorithm A. */

size_t sc_cipher_get_algo_blklen (int algo)

{

    switch (algo) {

    	// set block size according to "Symmetric ciphers - How To"

    	case SC_CIPHER_AES128:

    	case SC_CIPHER_AES192: 

    	case SC_CIPHER_AES256: 

    	 	return KAESBlockSize;				 	

		case SC_CIPHER_NONE:

		case SC_CIPHER_3DES:

		case SC_CIPHER_DES:

		default:

		    return KBlockSize;	// 8 bytes

    }

}

/* Set the IV to be used for the encryption context C to IV with

   length IVLEN.  The length should match the required length. */

TInt

sc_cipher_setiv( sc_cipher_hd_t c, const byte *iv, unsigned int ivlen )

    {

    TInt error( KErrNone );

    if( iv ) {

	    if (c->iv) 

	    {

	    	delete c->iv;

	    	c->iv = NULL;

	    }    

		if( ivlen != c->blocksize )

		{

		/*

		    log_info("WARNING: cipher_setiv: ivlen=%u blklen=%u\n",

			     ivlen, (unsigned) c->blocksize );	

		 */     		

		}

		if (ivlen > c->blocksize)

		  ivlen = c->blocksize;

		TInt len = ivlen;

	 	TRAP( error, c->iv = HBufC8::NewL(ivlen) );

        if ( error )    //!= KErrNone

            {

            xmlSecSetErrorFlag( error );

            }

	 	else

	 	    {

	 	    TPtrC8 ptr(iv, ivlen);

		    *(c->iv) = ptr;   

	 	    }

    }

    c->unused = 0;

    return error;

    }

/* Set the proper Symbian data structures */

void

cipher_encrypt_prerequisiteL (sc_cipher_hd_t c)

{

  if (c->iEncryptor)

    return;

  	// Generate key and encryptor/decryptor

  	CBlockTransformation* bT_encrypt = NULL;

  	CBlockTransformation* encryptor = NULL;

  	switch(c->algo)

  	{

		case SC_CIPHER_AES128:

		case SC_CIPHER_AES192:

		case SC_CIPHER_AES256:

			bT_encrypt = CAESEncryptor::NewLC(c->iKey->Des());			

			CleanupStack::Pop(bT_encrypt);		

		 	break;			 	

		case SC_CIPHER_3DES:

			bT_encrypt = C3DESEncryptor::NewLC(c->iKey->Des());

			CleanupStack::Pop(bT_encrypt);			

			break;

		case SC_CIPHER_DES:

			bT_encrypt = CDESEncryptor::NewLC(c->iKey->Des());

			CleanupStack::Pop(bT_encrypt);	

			break;		

  		case SC_CIPHER_NONE:

		 	c->iEncryptor = CNullCipher::NewL();

			break;	  	

		default:

			User::Leave(KErrNotSupported);

		    break;	  		

  	}

  	switch (c->mode)

  	{

  		case SC_CIPHER_MODE_ECB:

  			break;

      	case SC_CIPHER_MODE_CBC:

			CleanupStack::PushL(bT_encrypt);			

			encryptor = CModeCBCEncryptor::NewLC(bT_encrypt, c->iv->Des());		

			CleanupStack::Pop(encryptor);		

			CleanupStack::Pop(bT_encrypt);	

	  		break;

  		default:

  			break;

  	}

	CleanupStack::PushL(encryptor);

	if (!c->iEncryptor)

	{

		if (!encryptor)

			{

			User::Leave(KErrGeneral);

			}

		CPadding* ePadding = CXmlSecPadding::NewLC(encryptor->BlockSize());

		c->iEncryptor = CBufferedEncryptor::NewL(encryptor, ePadding);

		CleanupStack::Pop(ePadding);

	}

	CleanupStack::Pop(encryptor); 	

}

static TInt

cipher_encrypt_doProcessL (sc_cipher_hd_t c, byte *outbuf, const byte *inbuf,

		unsigned int nbytes, int last)

    {

	TInt rc(KErrNone);

    switch( c->mode ) {

	  case SC_CIPHER_MODE_ECB:

      case SC_CIPHER_MODE_CBC:

        {

        TUint blockSize = c->iEncryptor->BlockSize();     

		if ((c->mode == SC_CIPHER_MODE_CBC) 

				&& (nbytes%blockSize && !last)

	            && !(nbytes > blockSize

	                && (c->flags & SC_CIPHER_CBC_CTS)))

		{

			rc = KErrArgument;

		}

		else if ((c->mode == SC_CIPHER_MODE_ECB) 

					&& (nbytes%blockSize && !last))

		{

			rc = KErrArgument;	

		}

		else 

		{

			TInt outlen;

			if (last)

				outlen = c->iEncryptor->MaxFinalOutputLength(nbytes);

			else

				outlen = c->iEncryptor->MaxOutputLength(nbytes);

			HBufC8 *result = HBufC8::NewLC(outlen);

			TPtr8 resultActual= result->Des();

			resultActual.FillZ(resultActual.MaxLength());

			resultActual.SetLength(0);

			// could improve memory usage later by allocating a smaller buffer

			HBufC8 *input = HBufC8::NewLC(nbytes);

			TPtrC8 inbufPtr(inbuf, nbytes);

			*input = inbufPtr;

		    TInt j(0);

			for(; j+blockSize<nbytes; j+=blockSize)

			{//	encryption in blocks of size blocksize

				c->iEncryptor->Process(input->Mid(j,blockSize), resultActual);

			}

			if (last)	

			{

				c->iEncryptor->ProcessFinalL(input->Mid(j), resultActual);

				// we delete iEncryptor once the decryption finishes

				// so that the next decryption can use a different key or iv

				delete c->iEncryptor;

				c->iEncryptor = NULL;		

			}

			else

				c->iEncryptor->Process(input->Mid(j,blockSize), resultActual);

			memcpy(outbuf, result->Ptr(), result->Size());

			CleanupStack::PopAndDestroy(input);

			CleanupStack::PopAndDestroy(result);

	    }

        }	

	break;

	/*

      case SC_CIPHER_MODE_CFB:

	do_cfb_encrypt(c, outbuf, inbuf, nbytes );

	break;

      case SC_CIPHER_MODE_CTR:

	do_ctr_encrypt(c, outbuf, inbuf, nbytes );

	break;

      case SC_CIPHER_MODE_STREAM:

        c->cipher->stencrypt ( &c->context.c,

                               outbuf, (byte*)inbuf, nbytes );

        break;

      case SC_CIPHER_MODE_NONE:

	if( inbuf != outbuf )

	    memmove( outbuf, inbuf, nbytes );

	break;

	*/

      default:

        rc = KErrNotSupported;

        break;

    }

	return rc;		

    }

/****************

 * Encrypt INBUF to OUTBUF with the mode selected at open.

 * inbuf and outbuf may overlap or be the same.

 * Depending on the mode some contraints apply to NBYTES.

 */

static TInt

cipher_encrypt (sc_cipher_hd_t c, byte *outbuf,

		const byte *inbuf, unsigned int nbytes, int last)

{

	TInt leaveValue;

	TInt ret(KErrNone);

	// Perform Symbian prerequisite data structure initialization

    TRAP(leaveValue, cipher_encrypt_prerequisiteL (c));

	if (leaveValue) //!= KErrNone;

	    {

	    xmlSecSetErrorFlag( leaveValue );

		return leaveValue;

	    }

	// Symbian encryption

	TRAP(leaveValue, ret=cipher_encrypt_doProcessL (c, outbuf, inbuf, nbytes, last));

	if (leaveValue) //!= KErrNone

	    {

	    xmlSecSetErrorFlag( leaveValue );

		return leaveValue;

	    }

    return ret;

}

/****************

 * Encrypt IN and write it to OUT.  If IN is NULL, in-place encryption has

 * been requested.

 */

int

sc_cipher_encrypt (sc_cipher_hd_t h, void *out, size_t outsize,

                     const void *in, size_t inlen, int last)

{

  int err;

  if (!in)

    /* Caller requested in-place encryption. */

    /* Actullay cipher_encrypt() does not need to know about it, but

     * we may change this to get better performance. */

    err = cipher_encrypt (h, (byte *)out, (byte *)out, outsize, last);

  else if (outsize < ((h->flags & SC_CIPHER_CBC_MAC) ?

                      h->blocksize : inlen))

    err = KErrArgument;

  else if ((h->mode == SC_CIPHER_MODE_ECB

	    || (h->mode == SC_CIPHER_MODE_CBC

		&& (! ((h->flags & SC_CIPHER_CBC_CTS)

		       && (inlen > h->blocksize)))))

	   && ((inlen % h->blocksize) && !last))	// let Symbian do the padding

    err = KErrArgument;

  else

    err = cipher_encrypt (h, (byte *)out, (byte *)in, inlen, last);

  if (err && out)

    memset (out, 0x42, outsize); /* Failsafe: Make sure that the

                                    plaintext will never make it into

                                    OUT. */

  return err;

}

/* Set the proper Symbian data structures */

void

cipher_decrypt_prerequisiteL (sc_cipher_hd_t c)

{

  if (c->iDecryptor)

    return;

  	// Generate key and encryptor/decryptor

  	CBlockTransformation* bT_decrypt = NULL;

  	CBlockTransformation* decryptor = NULL;

  	switch(c->algo)

  	{

		case SC_CIPHER_AES128:

		case SC_CIPHER_AES192:

		case SC_CIPHER_AES256:		

			bT_decrypt = CAESDecryptor::NewLC(c->iKey->Des());

			CleanupStack::Pop(bT_decrypt);		

		 	break;			 

		case SC_CIPHER_3DES:

			bT_decrypt = C3DESDecryptor::NewLC(c->iKey->Des());

			CleanupStack::Pop(bT_decrypt);	

			break;

		case SC_CIPHER_DES:

			bT_decrypt = CDESDecryptor::NewLC(c->iKey->Des());

			CleanupStack::Pop(bT_decrypt);	

			break;		

  		case SC_CIPHER_NONE:

			c->iDecryptor = CNullCipher::NewL();

			break;	  	

		default:

			User::Leave(KErrNotSupported);

		    break;	  		

  	}

  	switch (c->mode)

  	{

  		case SC_CIPHER_MODE_ECB:

  			break;

      	case SC_CIPHER_MODE_CBC:						

			CleanupStack::PushL(bT_decrypt);

			decryptor = CModeCBCDecryptor::NewLC(bT_decrypt, c->iv->Des());		

			CleanupStack::Pop(decryptor);	

			CleanupStack::Pop(bT_decrypt);	

	  		break;

  		default:

  			break;

  	}

	CleanupStack::PushL(decryptor);

	if (!c->iDecryptor)

	{

		if (!decryptor)

			{

			User::Leave(KErrGeneral);

			}

		CPadding* dPadding = CXmlSecPadding::NewLC(decryptor->BlockSize());

		c->iDecryptor = CBufferedDecryptor::NewL(decryptor, dPadding);

		CleanupStack::Pop(dPadding);

	}

	CleanupStack::Pop(decryptor); 	

}

static TInt

cipher_decrypt_doProcessL (sc_cipher_hd_t c, byte *outbuf, const byte *inbuf,

		unsigned int nbytes, int* outputLen, int last)

    {

	TInt rc(KErrNone);

    switch( c->mode ) {

	  case SC_CIPHER_MODE_ECB:

      case SC_CIPHER_MODE_CBC:

        {

        TUint blockSize = c->iDecryptor->BlockSize();     

		if ((c->mode == SC_CIPHER_MODE_CBC) 

				&& nbytes%blockSize

	            && !(nbytes > blockSize

	                && (c->flags & SC_CIPHER_CBC_CTS)))

		{

			rc = KErrArgument;

		}

		else if ((c->mode == SC_CIPHER_MODE_ECB) 

					&& nbytes%blockSize)

		{

			rc = KErrArgument;

		}	

		else

		{

			TInt outlen;

			if (last)

				outlen = c->iDecryptor->MaxFinalOutputLength(nbytes);

			else

				outlen = c->iDecryptor->MaxOutputLength(nbytes);			

			HBufC8 *result = HBufC8::NewLC(outlen);

			TPtr8 resultActual= result->Des();

			resultActual.FillZ(resultActual.MaxLength());

			resultActual.SetLength(0);

			//  could improve memory usage later by allocating a smaller buffer

			HBufC8* input = HBufC8::NewLC(nbytes);

			TPtrC8 inbufPtr(inbuf, nbytes);

			*input = inbufPtr;

		    TInt j=0;

			for(; j+blockSize<nbytes; j+=blockSize)

			{	//	decryption in blocks of size blocksize

				c->iDecryptor->Process(input->Mid(j,blockSize), resultActual);

			}			

			if (last)	

			{

				c->iDecryptor->ProcessFinalL(input->Mid(j), resultActual);

				*outputLen = result->Size();

				// we delete iDecryptor once the decryption finishes

				// so that the next decryption can use a different key or iv

				delete c->iDecryptor;

				c->iDecryptor = NULL;		

			}

			else

				c->iDecryptor->Process(input->Mid(j,blockSize), resultActual);

			memcpy(outbuf, result->Ptr(), result->Size());