/*

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

*

*/

/* A wrapper for gcrypt.h */

#ifndef __SYMBIANCRYPTO_CRYPTO_WRAPPER_H__

#define __SYMBIANCRYPTO_CRYPTO_WRAPPER_H__    

#include <e32def.h>

#include "xmlsecc_config.h"

#include "xmlsecc_evpwrapper.h"

#ifdef __cplusplus

extern "C" {

#endif /* __cplusplus */ 

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

 *                                  

 *   symmetric cipher functions     

 *                                  

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

/* Port SC_CIPHER_HD */

#ifndef _SC_GCC_ATTR_DEPRECATED

#define _SC_GCC_ATTR_DEPRECATED

#endif

struct sc_cipher_handle;

typedef struct sc_cipher_handle *sc_cipher_hd_t;

typedef struct sc_cipher_handle *SC_CIPHER_HD _SC_GCC_ATTR_DEPRECATED;

typedef struct sc_cipher_handle *ScCipherHd _SC_GCC_ATTR_DEPRECATED;

typedef sc_cipher_hd_t 	ScCipherHd;

#define	ISLAST	1

#define NOTLAST	0

/* data type compatibility */

typedef unsigned char 			byte;

/* Module specification structure for ciphers.  */

typedef struct sc_cipher_spec

{

  const char *name;

  const char **aliases;

  size_t blocksize;

  size_t keylen;

  size_t contextsize;

} sc_cipher_spec_t;

/* All symmetric encryption algorithms are identified by their IDs.

   More IDs may be registered at runtime. */

enum sc_cipher_algos

  {

    SC_CIPHER_NONE        = 0,

    SC_CIPHER_IDEA        = 1,

    SC_CIPHER_3DES        = 2,

    SC_CIPHER_CAST5       = 3,

    SC_CIPHER_BLOWFISH    = 4,

    SC_CIPHER_SAFER_SK128 = 5,

    SC_CIPHER_DES_SK      = 6,

    SC_CIPHER_AES128      = 7,

    SC_CIPHER_AES192      = 8,

    SC_CIPHER_AES256      = 9,

    SC_CIPHER_TWOFISH     = 10,

    /* Other cipher numbers are above 300 for OpenPGP reasons. */

    SC_CIPHER_ARCFOUR     = 301,  /* Fully compatible with RSA's RC4 (tm). */

    SC_CIPHER_DES         = 302,  /* Yes, this is single key 56 bit DES. */

    SC_CIPHER_TWOFISH128  = 303,

    SC_CIPHER_SERPENT128  = 304,

    SC_CIPHER_SERPENT192  = 305,

    SC_CIPHER_SERPENT256  = 306,

    SC_CIPHER_RFC2268_40  = 307,  /* Ron's Cipher 2 (40 bit). */

    SC_CIPHER_RFC2268_128 = 308   /* Ron's Cipher 2 (128 bit). */

  };

/* The supported encryption modes.  Note that not all of them are

   supported for each algorithm. */

enum sc_cipher_modes 

  {

    SC_CIPHER_MODE_NONE   = 0,  /* Not yet specified. */

    SC_CIPHER_MODE_ECB    = 1,  /* Electronic codebook. */

    SC_CIPHER_MODE_CFB    = 2,  /* Cipher feedback. */

    SC_CIPHER_MODE_CBC    = 3,  /* Cipher block chaining. */

    SC_CIPHER_MODE_STREAM = 4,  /* Used with stream ciphers. */

    SC_CIPHER_MODE_OFB    = 5,  /* Outer feedback. */

    SC_CIPHER_MODE_CTR    = 6   /* Counter. */

  };

/* Flags used with the open function. */ 

enum sc_cipher_flags

  {

    SC_CIPHER_SECURE      = 1,  /* Allocate in secure memory. */

    SC_CIPHER_ENABLE_SYNC = 2,  /* Enable CFB sync mode. */

    SC_CIPHER_CBC_CTS     = 4,  /* Enable CBC cipher text stealing (CTS). */

    SC_CIPHER_CBC_MAC     = 8   /* Enable CBC message auth. code (MAC). */

  };

/* To avoid that a compiler optimizes certain memset calls away, these

   macros may be used instead. */

#define wipememory2(_ptr,_set,_len) do { \

              volatile char *_vptr=(volatile char *)(_ptr); \

              size_t _vlen=(_len); \

              while(_vlen) { *_vptr=(_set); _vptr++; _vlen--; } \

                  } while(0)

#define wipememory(_ptr,_len) wipememory2(_ptr,0,_len)

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

 *                                  

 *   random generating functions    

 *                                  

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

/* The possible values for the random quality.  The rule of thumb is

   to use STRONG for session keys and VERY_STRONG for key material.

   WEAK is currently an alias for STRONG and should not be used

   anymore - use sc_create_nonce instead. */

typedef enum sc_random_level

  {

    SC_WEAK_RANDOM = 0,

    SC_STRONG_RANDOM = 1,

    SC_VERY_STRONG_RANDOM = 2

  }

sc_random_level_t;

/* Fill BUFFER with LENGTH bytes of random, using random numbers of

   quality LEVEL. */

TInt sc_randomize (unsigned char *buffer, size_t length,

                     enum sc_random_level level);

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

size_t sc_cipher_get_algo_blklen (int algo);

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

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

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

/* Encrypt the plaintext of size INLEN in IN using the cipher handle H

   into the buffer OUT which has an allocated length of OUTSIZE.  For

   most algorithms it is possible to pass NULL for in and 0 for INLEN

   and do a in-place decryption of the data provided in OUT.  */

int sc_cipher_encrypt (sc_cipher_hd_t h,

                                  void *out, size_t outsize,

                                  const void *in, size_t inlen, int last);

/* The counterpart to sc_cipher_encrypt.  */

int sc_cipher_decrypt (sc_cipher_hd_t h,

                                  void *out, size_t outsize,

                                  const void *in, size_t inlen, int *outlen, int last);

/* Create a handle for algorithm ALGO to be used in MODE.  FLAGS may

   be given as an bitwise OR of the sc_cipher_flags values. */

int sc_cipher_open (sc_cipher_hd_t *handle,

                              int algo, int mode, unsigned int flags);

/* Close the cioher handle H and release all resource. */

void sc_cipher_close (sc_cipher_hd_t h);

/* Retrieved the key length used with algorithm A. */

size_t sc_cipher_get_algo_keylen (int algo);

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

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

int

sc_cipher_setkey (sc_cipher_hd_t c, byte *key, unsigned int keylen);

/* Set specification blocksize in context */

void set_ctx_blocksize(sc_cipher_hd_t c, size_t bklen);

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

 *                                  

 *   cryptograhic hash functions    

 *                                  

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

#define XMLSEC_SYMBIAN_MAX_DIGEST_SIZE		32

/* Algorithm IDs for the hash functions we know about. Not all of them

   are implemnted. */

enum sc_md_algos

  {

    SC_MD_NONE    = 0,  

    SC_MD_MD5     = 1,

    SC_MD_SHA1    = 2,

    SC_MD_RMD160  = 3,

    SC_MD_MD2     = 5,

    SC_MD_TIGER   = 6,   /* TIGER/192. */

    SC_MD_HAVAL   = 7,   /* HAVAL, 5 pass, 160 bit. */

    SC_MD_SHA256  = 8,

    SC_MD_SHA384  = 9,

    SC_MD_SHA512  = 10,

    SC_MD_MD4     = 301,

    SC_MD_CRC32               = 302,

    SC_MD_CRC32_RFC1510       = 303,

    SC_MD_CRC24_RFC2440       = 304

  };

/* Flags used with the open function.  */

enum sc_md_flags

  {

    SC_MD_FLAG_SECURE = 1,  /* Allocate all buffers in "secure"

                                 memory.  */

    SC_MD_FLAG_HMAC   = 2   /* Make an HMAC out of this

                                 algorithm.  */

  };

/* Forward declaration.  */

struct sc_md_handle;

typedef struct sc_md_handle *sc_md_hd_t;

/* Compatibility types, do not use them.  */

typedef struct sc_md_handle *SC_MD_HD _SC_GCC_ATTR_DEPRECATED;

typedef struct sc_md_handle *ScMDHd _SC_GCC_ATTR_DEPRECATED;

/* Create a message digest object for algorithm ALGO.  FLAGS may be

   given as an bitwise OR of the sc_md_flags values.  ALGO may be

   given as 0 if the algorithms to be used are later set using

   gcry_md_enable.  */

int sc_md_open (sc_md_hd_t *h, int algo, unsigned int flags);

/* Release the message digest object HD.  */

void sc_md_close (sc_md_hd_t hd);

/* Pass LENGTH bytes of data in BUFFER to the digest object HD so that

   it can update the digest values.  This is the actual hash

   function. */

void sc_md_write (sc_md_hd_t hd, unsigned char *buffer, size_t length);

/* Read out the final digest from HD return the digest value for

   algorithm ALGO. */

const unsigned char *sc_md_read (sc_md_hd_t hd, int algo);

/* Retrieve the length in bytes of the digest yielded by algorithm

   ALGO. */

unsigned int sc_md_get_algo_dlen (sc_md_hd_t hd);

/* Finalize the digest calculation.  This is not really needed because

   sc_md_read() does this implicitly. */

void sc_md_final(sc_md_hd_t a);

/* Set key for HMAC */

int sc_md_setkey(sc_md_hd_t hd, unsigned char *buffer, size_t length);

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

 *                                  

 *            RSA Sign functions    

 *                                  

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

/* data type compatibility */

// OpenSSL

//typedef ScMDHd				EVP_MD_CTX;

#define EVP_MD_CTX	ScMDHd

#define sc_sign_init(a,b)		sc_md_open(a,b,SC_MD_FLAG_SECURE)	

#define sc_sign_update(a,b,c)	sc_md_write(a,b,c)

/* Signature final */

TInt sc_sign_final(sc_md_hd_t hd,unsigned char *outbuf, unsigned int *outlen, EVP_PKEY *pkey);

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

 *                                  

 *          RSA Verify functions    

 *                                  

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

#define sc_verify_init(a,b)  		sc_md_open(a,b,SC_MD_FLAG_SECURE)

#define sc_verify_update(a,b,c) 	sc_md_write(a,b,c)

/* Verify final */

TInt sc_verify_final(sc_md_hd_t hd, unsigned char *signature, unsigned int len, EVP_PKEY *pkey);

#ifdef __cplusplus

}

#endif /* __cplusplus */

#endif /* __SYMBIANCRYPTO_CRYPTO_WRAPPER_H__ */

#define __SYMBIANCRYPTO_CRYPTO_WRAPPER_H__