Logo Search packages:      
Sourcecode: openssl version File versions  Download package

hw_zencod.c

/* crypto/engine/hw_zencod.c */
 /* Written by Fred Donnat (frederic.donnat@zencod.com) for "zencod"
 * engine integration in order to redirect crypto computing on a crypto
 * hardware accelerator zenssl32  ;-)
 *
 * Date : 25 jun 2002
 * Revision : 17 Ju7 2002
 * Version : zencod_engine-0.9.7
 */

/* ====================================================================
 * Copyright (c) 1999-2001 The OpenSSL Project.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * 3. All advertising materials mentioning features or use of this
 *    software must display the following acknowledgment:
 *    "This product includes software developed by the OpenSSL Project
 *    for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
 *
 * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
 *    endorse or promote products derived from this software without
 *    prior written permission. For written permission, please contact
 *    licensing@OpenSSL.org.
 *
 * 5. Products derived from this software may not be called "OpenSSL"
 *    nor may "OpenSSL" appear in their names without prior written
 *    permission of the OpenSSL Project.
 *
 * 6. Redistributions of any form whatsoever must retain the following
 *    acknowledgment:
 *    "This product includes software developed by the OpenSSL Project
 *    for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
 *
 * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
 * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
 * OF THE POSSIBILITY OF SUCH DAMAGE.
 * ====================================================================
 *
 * This product includes cryptographic software written by Eric Young
 * (eay@cryptsoft.com).  This product includes software written by Tim
 * Hudson (tjh@cryptsoft.com).
 *
 */


/* ENGINE general include */
#include <stdio.h>
#include <openssl/crypto.h>
#include <openssl/dso.h>
#include <openssl/engine.h>

#ifndef OPENSSL_NO_HW
#ifndef OPENSSL_NO_HW_ZENCOD

#ifdef FLAT_INC
#  include "hw_zencod.h"
#else
#  include "vendor_defns/hw_zencod.h"
#endif

#define ZENCOD_LIB_NAME "zencod engine"
#include "hw_zencod_err.c"

#define FAIL_TO_SOFTWARE            -15

#define     ZEN_LIBRARY "zenbridge"

#if 0
#  define PERROR(s)     perror(s)
#  define CHEESE()      fputs("## [ZenEngine] ## " __FUNCTION__ "\n", stderr)
#else
#  define PERROR(s)
#  define CHEESE()
#endif


/* Sorry ;) */
#ifndef WIN32
static inline void esrever ( unsigned char *d, int l )
{
      for(;--l>0;--l,d++){*d^=*(d+l);*(d+l)^=*d;*d^=*(d+l);}
}

static inline void ypcmem ( unsigned char *d, const unsigned char *s, int l )
{
      for(d+=l;l--;)*--d=*s++;
}
#else
static __inline void esrever ( unsigned char *d, int l )
{
      for(;--l>0;--l,d++){*d^=*(d+l);*(d+l)^=*d;*d^=*(d+l);}
}

static __inline void ypcmem ( unsigned char *d, const unsigned char *s, int l )
{
      for(d+=l;l--;)*--d=*s++;
}
#endif


#define BIGNUM2ZEN(n, bn)     (ptr_zencod_init_number((n), \
                              (unsigned long) ((bn)->top * BN_BITS2), \
                              (unsigned char *) ((bn)->d)))

#define ZEN_BITS(n, bytes)    (ptr_zencod_bytes2bits((unsigned char *) (n), (unsigned long) (bytes)))
#define ZEN_BYTES(bits) (ptr_zencod_bits2bytes((unsigned long) (bits)))


/* Function for ENGINE detection and control */
static int zencod_destroy ( ENGINE *e ) ;
static int zencod_init ( ENGINE *e ) ;
static int zencod_finish ( ENGINE *e ) ;
static int zencod_ctrl ( ENGINE *e, int cmd, long i, void *p, void (*f) () ) ;

/* BIGNUM stuff */
static int zencod_bn_mod_exp ( BIGNUM *r, const BIGNUM *a, const BIGNUM *p, const BIGNUM *m, BN_CTX *ctx ) ;

/* RSA stuff */
#ifndef OPENSSL_NO_RSA
static int RSA_zencod_rsa_mod_exp ( BIGNUM *r0, const BIGNUM *I, RSA *rsa ) ;
static int RSA_zencod_bn_mod_exp ( BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
            const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx ) ;
#endif

/* DSA stuff */
#ifndef OPENSSL_NO_DSA
static int DSA_zencod_bn_mod_exp ( DSA *dsa, BIGNUM *r, BIGNUM *a, const BIGNUM *p, const BIGNUM *m, BN_CTX *ctx,
            BN_MONT_CTX *m_ctx ) ;

static DSA_SIG *DSA_zencod_do_sign ( const unsigned char *dgst, int dlen, DSA *dsa ) ;
static int DSA_zencod_do_verify ( const unsigned char *dgst, int dgst_len, DSA_SIG *sig,
            DSA *dsa ) ;
#endif

/* DH stuff */
#ifndef OPENSSL_NO_DH
static int DH_zencod_bn_mod_exp ( const DH *dh, BIGNUM *r, const BIGNUM *a, const BIGNUM *p, const BIGNUM *m, BN_CTX *ctx,
            BN_MONT_CTX *m_ctx ) ;
static int DH_zencod_generate_key ( DH *dh ) ;
static int DH_zencod_compute_key ( unsigned char *key, const BIGNUM *pub_key, DH *dh ) ;
#endif

/* Rand stuff */
static void RAND_zencod_seed ( const void *buf, int num ) ;
static int RAND_zencod_rand_bytes ( unsigned char *buf, int num ) ;
static int RAND_zencod_rand_status ( void ) ;

/* Digest Stuff */
static int engine_digests ( ENGINE *e, const EVP_MD **digest, const int **nids, int nid ) ;

/* Cipher Stuff */
static int engine_ciphers ( ENGINE *e, const EVP_CIPHER **cipher, const int **nids, int nid ) ;


#define ZENCOD_CMD_SO_PATH                ENGINE_CMD_BASE
static const ENGINE_CMD_DEFN zencod_cmd_defns [ ] =
{
      { ZENCOD_CMD_SO_PATH,
        "SO_PATH",
        "Specifies the path to the 'zenbridge' shared library",
        ENGINE_CMD_FLAG_STRING},
      { 0, NULL, NULL, 0 }
} ;


#ifndef OPENSSL_NO_RSA
/* Our internal RSA_METHOD specific to zencod ENGINE providing pointers to our function */
static RSA_METHOD zencod_rsa =
{
      "ZENCOD RSA method",
      NULL,
      NULL,
      NULL,
      NULL,
      RSA_zencod_rsa_mod_exp,
      RSA_zencod_bn_mod_exp,
      NULL,
      NULL,
      0,
      NULL,
      NULL,
      NULL
} ;
#endif

#ifndef OPENSSL_NO_DSA
/* Our internal DSA_METHOD specific to zencod ENGINE providing pointers to our function */
static DSA_METHOD zencod_dsa =
{
      "ZENCOD DSA method",
      DSA_zencod_do_sign,
      NULL,
      DSA_zencod_do_verify,
      NULL,
      DSA_zencod_bn_mod_exp,
      NULL,
      NULL,
      0,
      NULL
} ;
#endif

#ifndef OPENSSL_NO_DH
/* Our internal DH_METHOD specific to zencod ENGINE providing pointers to our function */
static DH_METHOD zencod_dh =
{
      "ZENCOD DH method",
      DH_zencod_generate_key,
      DH_zencod_compute_key,
      DH_zencod_bn_mod_exp,
      NULL,
      NULL,
      0,
      NULL
} ;
#endif

/* Our internal RAND_meth specific to zencod ZNGINE providing pointers to  our function */
static RAND_METHOD zencod_rand =
{
      RAND_zencod_seed,
      RAND_zencod_rand_bytes,
      NULL,
      NULL,
      RAND_zencod_rand_bytes,
      RAND_zencod_rand_status
} ;


/* Constants used when creating the ENGINE */
static const char *engine_zencod_id = "zencod";
static const char *engine_zencod_name = "ZENCOD hardware engine support";


/* This internal function is used by ENGINE_zencod () and possibly by the
 * "dynamic" ENGINE support too   ;-)
 */
static int bind_helper ( ENGINE *e )
{

#ifndef OPENSSL_NO_RSA
      const RSA_METHOD *meth_rsa ;
#endif
#ifndef OPENSSL_NO_DSA
      const DSA_METHOD *meth_dsa ;
#endif
#ifndef OPENSSL_NO_DH
      const DH_METHOD *meth_dh ;
#endif

      const RAND_METHOD *meth_rand ;


      if ( !ENGINE_set_id ( e, engine_zencod_id ) ||
                  !ENGINE_set_name ( e, engine_zencod_name ) ||
#ifndef OPENSSL_NO_RSA
                  !ENGINE_set_RSA ( e, &zencod_rsa ) ||
#endif
#ifndef OPENSSL_NO_DSA
                  !ENGINE_set_DSA ( e, &zencod_dsa ) ||
#endif
#ifndef OPENSSL_NO_DH
                  !ENGINE_set_DH ( e, &zencod_dh ) ||
#endif
                  !ENGINE_set_RAND ( e, &zencod_rand ) ||

                  !ENGINE_set_destroy_function ( e, zencod_destroy ) ||
                  !ENGINE_set_init_function ( e, zencod_init ) ||
                  !ENGINE_set_finish_function ( e, zencod_finish ) ||
                  !ENGINE_set_ctrl_function ( e, zencod_ctrl ) ||
                  !ENGINE_set_cmd_defns ( e, zencod_cmd_defns ) ||
                  !ENGINE_set_digests ( e, engine_digests ) ||
                  !ENGINE_set_ciphers ( e, engine_ciphers ) ) {
            return 0 ;
      }

#ifndef OPENSSL_NO_RSA
      /* We know that the "PKCS1_SSLeay()" functions hook properly
       * to the Zencod-specific mod_exp and mod_exp_crt so we use
       * those functions. NB: We don't use ENGINE_openssl() or
       * anything "more generic" because something like the RSAref
       * code may not hook properly, and if you own one of these
       * cards then you have the right to do RSA operations on it
       * anyway!
       */
      meth_rsa = RSA_PKCS1_SSLeay () ;

      zencod_rsa.rsa_pub_enc = meth_rsa->rsa_pub_enc ;
      zencod_rsa.rsa_pub_dec = meth_rsa->rsa_pub_dec ;
      zencod_rsa.rsa_priv_enc = meth_rsa->rsa_priv_enc ;
      zencod_rsa.rsa_priv_dec = meth_rsa->rsa_priv_dec ;
      /* meth_rsa->rsa_mod_exp */
      /* meth_rsa->bn_mod_exp */
      zencod_rsa.init = meth_rsa->init ;
      zencod_rsa.finish = meth_rsa->finish ;
#endif

#ifndef OPENSSL_NO_DSA
      /* We use OpenSSL meth to supply what we don't provide ;-*)
       */
      meth_dsa = DSA_OpenSSL () ;

      /* meth_dsa->dsa_do_sign */
      zencod_dsa.dsa_sign_setup = meth_dsa->dsa_sign_setup ;
      /* meth_dsa->dsa_do_verify */
      zencod_dsa.dsa_mod_exp = meth_dsa->dsa_mod_exp ;
      /* zencod_dsa.bn_mod_exp = meth_dsa->bn_mod_exp ; */
      zencod_dsa.init = meth_dsa->init ;
      zencod_dsa.finish = meth_dsa->finish ;
#endif

#ifndef OPENSSL_NO_DH
      /* We use OpenSSL meth to supply what we don't provide ;-*)
       */
      meth_dh = DH_OpenSSL () ;

      /* zencod_dh.generate_key = meth_dh->generate_key ; */
      /* zencod_dh.compute_key = meth_dh->compute_key ; */
      /* zencod_dh.bn_mod_exp = meth_dh->bn_mod_exp ; */
      zencod_dh.init = meth_dh->init ;
      zencod_dh.finish = meth_dh->finish ;

#endif

      /* We use OpenSSL (SSLeay) meth to supply what we don't provide ;-*)
       */
      meth_rand = RAND_SSLeay () ;

      /* meth_rand->seed ; */
      /* zencod_rand.seed = meth_rand->seed ; */
      /* meth_rand->bytes ; */
      /* zencod_rand.bytes = meth_rand->bytes ; */
      zencod_rand.cleanup = meth_rand->cleanup ;
      zencod_rand.add = meth_rand->add ;
      /* meth_rand->pseudorand ; */
      /* zencod_rand.pseudorand = meth_rand->pseudorand ; */
      /* zencod_rand.status = meth_rand->status ; */
      /* meth_rand->status ; */

      /* Ensure the zencod error handling is set up */
      ERR_load_ZENCOD_strings () ;
      return 1 ;
}


/* As this is only ever called once, there's no need for locking
 * (indeed - the lock will already be held by our caller!!!)
 */
static ENGINE *ENGINE_zencod ( void )
{

      ENGINE *eng = ENGINE_new () ;

      if ( !eng ) {
            return NULL ;
      }
      if ( !bind_helper ( eng ) ) {
            ENGINE_free ( eng ) ;
            return NULL ;
      }

      return eng ;
}


#ifdef ENGINE_DYNAMIC_SUPPORT
static
#endif
void ENGINE_load_zencod ( void )
{
      /* Copied from eng_[openssl|dyn].c */
      ENGINE *toadd = ENGINE_zencod ( ) ;
      if ( !toadd ) return ;
      ENGINE_add ( toadd ) ;
      ENGINE_free ( toadd ) ;
      ERR_clear_error ( ) ;
}


/* This is a process-global DSO handle used for loading and unloading
 * the ZENBRIDGE library.
 * NB: This is only set (or unset) during an * init () or finish () call
 * (reference counts permitting) and they're  * operating with global locks,
 * so this should be thread-safe * implicitly.
 */
static DSO *zencod_dso = NULL ;

static t_zencod_test *ptr_zencod_test = NULL ;
static t_zencod_bytes2bits *ptr_zencod_bytes2bits = NULL ;
static t_zencod_bits2bytes *ptr_zencod_bits2bytes = NULL ;
static t_zencod_new_number *ptr_zencod_new_number = NULL ;
static t_zencod_init_number *ptr_zencod_init_number = NULL ;

static t_zencod_rsa_mod_exp *ptr_zencod_rsa_mod_exp = NULL ;
static t_zencod_rsa_mod_exp_crt *ptr_zencod_rsa_mod_exp_crt = NULL ;
static t_zencod_dsa_do_sign *ptr_zencod_dsa_do_sign = NULL ;
static t_zencod_dsa_do_verify *ptr_zencod_dsa_do_verify = NULL ;
static t_zencod_dh_generate_key *ptr_zencod_dh_generate_key = NULL ;
static t_zencod_dh_compute_key *ptr_zencod_dh_compute_key = NULL ;
static t_zencod_rand_bytes *ptr_zencod_rand_bytes = NULL ;
static t_zencod_math_mod_exp *ptr_zencod_math_mod_exp = NULL ;

static t_zencod_md5_init *ptr_zencod_md5_init = NULL ;
static t_zencod_md5_update *ptr_zencod_md5_update = NULL ;
static t_zencod_md5_do_final *ptr_zencod_md5_do_final = NULL ;
static t_zencod_sha1_init *ptr_zencod_sha1_init = NULL ;
static t_zencod_sha1_update *ptr_zencod_sha1_update = NULL ;
static t_zencod_sha1_do_final *ptr_zencod_sha1_do_final = NULL ;

static t_zencod_xdes_cipher *ptr_zencod_xdes_cipher = NULL ;
static t_zencod_rc4_cipher *ptr_zencod_rc4_cipher = NULL ;

/* These are the static string constants for the DSO file name and the function
 * symbol names to bind to.
 */
static const char *ZENCOD_LIBNAME = ZEN_LIBRARY ;

static const char *ZENCOD_Fct_0 = "test_device" ;
static const char *ZENCOD_Fct_1 = "zenbridge_bytes2bits" ;
static const char *ZENCOD_Fct_2 = "zenbridge_bits2bytes" ;
static const char *ZENCOD_Fct_3 = "zenbridge_new_number" ;
static const char *ZENCOD_Fct_4 = "zenbridge_init_number" ;

static const char *ZENCOD_Fct_exp_1 = "zenbridge_rsa_mod_exp" ;
static const char *ZENCOD_Fct_exp_2 = "zenbridge_rsa_mod_exp_crt" ;
static const char *ZENCOD_Fct_dsa_1 = "zenbridge_dsa_do_sign" ;
static const char *ZENCOD_Fct_dsa_2 = "zenbridge_dsa_do_verify" ;
static const char *ZENCOD_Fct_dh_1 = "zenbridge_dh_generate_key" ;
static const char *ZENCOD_Fct_dh_2 = "zenbridge_dh_compute_key" ;
static const char *ZENCOD_Fct_rand_1 = "zenbridge_rand_bytes" ;
static const char *ZENCOD_Fct_math_1 = "zenbridge_math_mod_exp" ;

static const char *ZENCOD_Fct_md5_1 = "zenbridge_md5_init" ;
static const char *ZENCOD_Fct_md5_2 = "zenbridge_md5_update" ;
static const char *ZENCOD_Fct_md5_3 = "zenbridge_md5_do_final" ;
static const char *ZENCOD_Fct_sha1_1 = "zenbridge_sha1_init" ;
static const char *ZENCOD_Fct_sha1_2 = "zenbridge_sha1_update" ;
static const char *ZENCOD_Fct_sha1_3 = "zenbridge_sha1_do_final" ;

static const char *ZENCOD_Fct_xdes_1 = "zenbridge_xdes_cipher" ;
static const char *ZENCOD_Fct_rc4_1 = "zenbridge_rc4_cipher" ;

/* Destructor (complements the "ENGINE_zencod ()" constructor)
 */
static int zencod_destroy (ENGINE *e )
{

      ERR_unload_ZENCOD_strings () ;

      return 1 ;
}


/* (de)initialisation functions. Control Function
 */
static int zencod_init ( ENGINE *e )
{

      t_zencod_test *ptr_0 ;
      t_zencod_bytes2bits *ptr_1 ;
      t_zencod_bits2bytes *ptr_2 ;
      t_zencod_new_number *ptr_3 ;
      t_zencod_init_number *ptr_4 ;
      t_zencod_rsa_mod_exp *ptr_exp_1 ;
      t_zencod_rsa_mod_exp_crt *ptr_exp_2 ;
      t_zencod_dsa_do_sign *ptr_dsa_1 ;
      t_zencod_dsa_do_verify *ptr_dsa_2 ;
      t_zencod_dh_generate_key *ptr_dh_1 ;
      t_zencod_dh_compute_key *ptr_dh_2 ;
      t_zencod_rand_bytes *ptr_rand_1 ;
      t_zencod_math_mod_exp *ptr_math_1 ;
      t_zencod_md5_init *ptr_md5_1 ;
      t_zencod_md5_update *ptr_md5_2 ;
      t_zencod_md5_do_final *ptr_md5_3 ;
      t_zencod_sha1_init *ptr_sha1_1 ;
      t_zencod_sha1_update *ptr_sha1_2 ;
      t_zencod_sha1_do_final *ptr_sha1_3 ;
      t_zencod_xdes_cipher *ptr_xdes_1 ;
      t_zencod_rc4_cipher *ptr_rc4_1 ;

      CHEESE () ;

      /*
       * We Should add some tests for non NULL parameters or bad value !!
       * Stuff to be done ...
       */

      if ( zencod_dso != NULL ) {
            ZENCODerr ( ZENCOD_F_ZENCOD_INIT, ZENCOD_R_ALREADY_LOADED ) ;
            goto err ;
      }
      /* Trying to load the Library "cryptozen"
       */
      zencod_dso = DSO_load ( NULL, ZENCOD_LIBNAME, NULL, 0 ) ;
      if ( zencod_dso == NULL ) {
            ZENCODerr ( ZENCOD_F_ZENCOD_INIT, ZENCOD_R_DSO_FAILURE ) ;
            goto err ;
      }

      /* Trying to load Function from the Library
       */
      if ( ! ( ptr_1 = (t_zencod_bytes2bits*) DSO_bind_func ( zencod_dso, ZENCOD_Fct_1 ) ) ||
                  ! ( ptr_2 = (t_zencod_bits2bytes*) DSO_bind_func ( zencod_dso, ZENCOD_Fct_2 ) ) ||
                  ! ( ptr_3 = (t_zencod_new_number*) DSO_bind_func ( zencod_dso, ZENCOD_Fct_3 ) ) ||
                  ! ( ptr_4 = (t_zencod_init_number*) DSO_bind_func ( zencod_dso, ZENCOD_Fct_4 ) ) ||
                  ! ( ptr_exp_1 = (t_zencod_rsa_mod_exp*) DSO_bind_func ( zencod_dso, ZENCOD_Fct_exp_1 ) ) ||
                  ! ( ptr_exp_2 = (t_zencod_rsa_mod_exp_crt*) DSO_bind_func ( zencod_dso, ZENCOD_Fct_exp_2 ) ) ||
                  ! ( ptr_dsa_1 = (t_zencod_dsa_do_sign*) DSO_bind_func ( zencod_dso, ZENCOD_Fct_dsa_1 ) ) ||
                  ! ( ptr_dsa_2 = (t_zencod_dsa_do_verify*) DSO_bind_func ( zencod_dso, ZENCOD_Fct_dsa_2 ) ) ||
                  ! ( ptr_dh_1 = (t_zencod_dh_generate_key*) DSO_bind_func ( zencod_dso, ZENCOD_Fct_dh_1 ) ) ||
                  ! ( ptr_dh_2 = (t_zencod_dh_compute_key*) DSO_bind_func ( zencod_dso, ZENCOD_Fct_dh_2 ) ) ||
                  ! ( ptr_rand_1 = (t_zencod_rand_bytes*) DSO_bind_func ( zencod_dso, ZENCOD_Fct_rand_1 ) ) ||
                  ! ( ptr_math_1 = (t_zencod_math_mod_exp*) DSO_bind_func ( zencod_dso, ZENCOD_Fct_math_1 ) ) ||
                  ! ( ptr_0 = (t_zencod_test *) DSO_bind_func ( zencod_dso, ZENCOD_Fct_0 ) ) ||
                  ! ( ptr_md5_1 = (t_zencod_md5_init *) DSO_bind_func ( zencod_dso, ZENCOD_Fct_md5_1 ) ) ||
                  ! ( ptr_md5_2 = (t_zencod_md5_update *) DSO_bind_func ( zencod_dso, ZENCOD_Fct_md5_2 ) ) ||
                  ! ( ptr_md5_3 = (t_zencod_md5_do_final *) DSO_bind_func ( zencod_dso, ZENCOD_Fct_md5_3 ) ) ||
                  ! ( ptr_sha1_1 = (t_zencod_sha1_init *) DSO_bind_func ( zencod_dso, ZENCOD_Fct_sha1_1 ) ) ||
                  ! ( ptr_sha1_2 = (t_zencod_sha1_update *) DSO_bind_func ( zencod_dso, ZENCOD_Fct_sha1_2 ) ) ||
                  ! ( ptr_sha1_3 = (t_zencod_sha1_do_final *) DSO_bind_func ( zencod_dso, ZENCOD_Fct_sha1_3 ) ) ||
                  ! ( ptr_xdes_1 = (t_zencod_xdes_cipher *) DSO_bind_func ( zencod_dso, ZENCOD_Fct_xdes_1 ) ) ||
                  ! ( ptr_rc4_1 = (t_zencod_rc4_cipher *) DSO_bind_func ( zencod_dso, ZENCOD_Fct_rc4_1 ) ) ) {

            ZENCODerr ( ZENCOD_F_ZENCOD_INIT, ZENCOD_R_DSO_FAILURE ) ;
            goto err ;
      }

      /* The function from "cryptozen" Library have been correctly loaded so copy them
       */
      ptr_zencod_test = ptr_0 ;
      ptr_zencod_bytes2bits = ptr_1 ;
      ptr_zencod_bits2bytes = ptr_2 ;
      ptr_zencod_new_number = ptr_3 ;
      ptr_zencod_init_number = ptr_4 ;
      ptr_zencod_rsa_mod_exp = ptr_exp_1 ;
      ptr_zencod_rsa_mod_exp_crt = ptr_exp_2 ;
      ptr_zencod_dsa_do_sign = ptr_dsa_1 ;
      ptr_zencod_dsa_do_verify = ptr_dsa_2 ;
      ptr_zencod_dh_generate_key = ptr_dh_1 ;
      ptr_zencod_dh_compute_key = ptr_dh_2 ;
      ptr_zencod_rand_bytes = ptr_rand_1 ;
      ptr_zencod_math_mod_exp = ptr_math_1 ;
      ptr_zencod_test = ptr_0 ;
      ptr_zencod_md5_init = ptr_md5_1 ;
      ptr_zencod_md5_update = ptr_md5_2 ;
      ptr_zencod_md5_do_final = ptr_md5_3 ;
      ptr_zencod_sha1_init = ptr_sha1_1 ;
      ptr_zencod_sha1_update = ptr_sha1_2 ;
      ptr_zencod_sha1_do_final = ptr_sha1_3 ;
      ptr_zencod_xdes_cipher = ptr_xdes_1 ;
      ptr_zencod_rc4_cipher = ptr_rc4_1 ;

      /* We should peform a test to see if there is actually any unit runnig on the system ...
       * Even if the cryptozen library is loaded the module coul not be loaded on the system ...
       * For now we may just open and close the device !!
       */

      if ( ptr_zencod_test () != 0 ) {
            ZENCODerr ( ZENCOD_F_ZENCOD_INIT, ZENCOD_R_UNIT_FAILURE ) ;
            goto err ;
      }

      return 1 ;
err :
      if ( zencod_dso ) {
            DSO_free ( zencod_dso ) ;
      }
      zencod_dso = NULL ;
      ptr_zencod_bytes2bits = NULL ;
      ptr_zencod_bits2bytes = NULL ;
      ptr_zencod_new_number = NULL ;
      ptr_zencod_init_number = NULL ;
      ptr_zencod_rsa_mod_exp = NULL ;
      ptr_zencod_rsa_mod_exp_crt = NULL ;
      ptr_zencod_dsa_do_sign = NULL ;
      ptr_zencod_dsa_do_verify = NULL ;
      ptr_zencod_dh_generate_key = NULL ;
      ptr_zencod_dh_compute_key = NULL ;
      ptr_zencod_rand_bytes = NULL ;
      ptr_zencod_math_mod_exp = NULL ;
      ptr_zencod_test = NULL ;
      ptr_zencod_md5_init = NULL ;
      ptr_zencod_md5_update = NULL ;
      ptr_zencod_md5_do_final = NULL ;
      ptr_zencod_sha1_init = NULL ;
      ptr_zencod_sha1_update = NULL ;
      ptr_zencod_sha1_do_final = NULL ;
      ptr_zencod_xdes_cipher = NULL ;
      ptr_zencod_rc4_cipher = NULL ;

      return 0 ;
}


static int zencod_finish ( ENGINE *e )
{

      CHEESE () ;

      /*
       * We Should add some tests for non NULL parameters or bad value !!
       * Stuff to be done ...
       */
      if ( zencod_dso == NULL ) {
            ZENCODerr ( ZENCOD_F_ZENCOD_FINISH, ZENCOD_R_NOT_LOADED ) ;
            return 0 ;
      }
      if ( !DSO_free ( zencod_dso ) ) {
            ZENCODerr ( ZENCOD_F_ZENCOD_FINISH, ZENCOD_R_DSO_FAILURE ) ;
            return 0 ;
      }

      zencod_dso = NULL ;

      ptr_zencod_bytes2bits = NULL ;
      ptr_zencod_bits2bytes = NULL ;
      ptr_zencod_new_number = NULL ;
      ptr_zencod_init_number = NULL ;
      ptr_zencod_rsa_mod_exp = NULL ;
      ptr_zencod_rsa_mod_exp_crt = NULL ;
      ptr_zencod_dsa_do_sign = NULL ;
      ptr_zencod_dsa_do_verify = NULL ;
      ptr_zencod_dh_generate_key = NULL ;
      ptr_zencod_dh_compute_key = NULL ;
      ptr_zencod_rand_bytes = NULL ;
      ptr_zencod_math_mod_exp = NULL ;
      ptr_zencod_test = NULL ;
      ptr_zencod_md5_init = NULL ;
      ptr_zencod_md5_update = NULL ;
      ptr_zencod_md5_do_final = NULL ;
      ptr_zencod_sha1_init = NULL ;
      ptr_zencod_sha1_update = NULL ;
      ptr_zencod_sha1_do_final = NULL ;
      ptr_zencod_xdes_cipher = NULL ;
      ptr_zencod_rc4_cipher = NULL ;

      return 1 ;
}


static int zencod_ctrl ( ENGINE *e, int cmd, long i, void *p, void (*f) () )
{

      int initialised = ( ( zencod_dso == NULL ) ? 0 : 1 ) ;

      CHEESE () ;

      /*
       * We Should add some tests for non NULL parameters or bad value !!
       * Stuff to be done ...
       */
      switch ( cmd ) {
      case ZENCOD_CMD_SO_PATH :
            if ( p == NULL ) {
                  ZENCODerr ( ZENCOD_F_ZENCOD_CTRL, ERR_R_PASSED_NULL_PARAMETER ) ;
                  return 0 ;
            }
            if ( initialised ) {
                  ZENCODerr ( ZENCOD_F_ZENCOD_CTRL, ZENCOD_R_ALREADY_LOADED ) ;
                  return 0 ;
            }
            ZENCOD_LIBNAME = (const char *) p ;
            return 1 ;
      default :
            break ;
      }

      ZENCODerr ( ZENCOD_F_ZENCOD_CTRL, ZENCOD_R_CTRL_COMMAND_NOT_IMPLEMENTED ) ;

      return 0 ;
}


/* BIGNUM stuff Functions
 */
static int zencod_bn_mod_exp ( BIGNUM *r, const BIGNUM *a, const BIGNUM *p, const BIGNUM *m, BN_CTX *ctx )
{
      zen_nb_t y, x, e, n;
      int ret;

      CHEESE () ;

      if ( !zencod_dso ) {
            ENGINEerr(ZENCOD_F_ZENCOD_BN_MOD_EXP, ZENCOD_R_NOT_LOADED);
            return 0;
      }

      if ( !bn_wexpand(r, m->top + 1) ) {
            ENGINEerr(ZENCOD_F_ZENCOD_BN_MOD_EXP, ZENCOD_R_BN_EXPAND_FAIL);
            return 0;
      }

      memset(r->d, 0, BN_num_bytes(m));

      ptr_zencod_init_number ( &y, (r->dmax - 1) * sizeof (BN_ULONG) * 8, (unsigned char *) r->d ) ;
      BIGNUM2ZEN ( &x, a ) ;
      BIGNUM2ZEN ( &e, p ) ;
      BIGNUM2ZEN ( &n, m ) ;

      /* Must invert x and e parameter due to BN mod exp prototype ... */
      ret = ptr_zencod_math_mod_exp ( &y, &e, &x, &n ) ;

      if ( ret )  {
            PERROR("zenbridge_math_mod_exp");
            ENGINEerr(ZENCOD_F_ZENCOD_BN_MOD_EXP, ZENCOD_R_REQUEST_FAILED);
            return 0;
      }

      r->top = (BN_num_bits(m) + BN_BITS2 - 1) / BN_BITS2;

      return 1;
}


/* RSA stuff Functions
 */
#ifndef OPENSSL_NO_RSA
static int RSA_zencod_rsa_mod_exp ( BIGNUM *r0, const BIGNUM *i, RSA *rsa )
{

      CHEESE () ;

      if ( !zencod_dso ) {
            ENGINEerr(ZENCOD_F_ZENCOD_RSA_MOD_EXP_CRT, ZENCOD_R_NOT_LOADED);
            return 0;
      }

      if ( !rsa->p || !rsa->q || !rsa->dmp1 || !rsa->dmq1 || !rsa->iqmp ) {
            ENGINEerr(ZENCOD_F_ZENCOD_RSA_MOD_EXP_CRT, ZENCOD_R_BAD_KEY_COMPONENTS);
            return 0;
      }

      /* Do in software if argument is too large for hardware */
      if ( RSA_size(rsa) * 8 > ZENBRIDGE_MAX_KEYSIZE_RSA_CRT ) {
            const RSA_METHOD *meth;

            meth = RSA_PKCS1_SSLeay();
            return meth->rsa_mod_exp(r0, i, rsa);
      } else {
            zen_nb_t y, x, p, q, dmp1, dmq1, iqmp;

            if ( !bn_expand(r0, RSA_size(rsa) * 8) ) {
                  ENGINEerr(ZENCOD_F_ZENCOD_RSA_MOD_EXP_CRT, ZENCOD_R_BN_EXPAND_FAIL);
                  return 0;
            }
            r0->top = (RSA_size(rsa) * 8 + BN_BITS2 - 1) / BN_BITS2;

            BIGNUM2ZEN ( &x, i ) ;
            BIGNUM2ZEN ( &y, r0 ) ;
            BIGNUM2ZEN ( &p, rsa->p ) ;
            BIGNUM2ZEN ( &q, rsa->q ) ;
            BIGNUM2ZEN ( &dmp1, rsa->dmp1 ) ;
            BIGNUM2ZEN ( &dmq1, rsa->dmq1 ) ;
            BIGNUM2ZEN ( &iqmp, rsa->iqmp ) ;

            if ( ptr_zencod_rsa_mod_exp_crt ( &y, &x, &p, &q, &dmp1, &dmq1, &iqmp ) < 0 ) {
                  PERROR("zenbridge_rsa_mod_exp_crt");
                  ENGINEerr(ZENCOD_F_ZENCOD_RSA_MOD_EXP_CRT, ZENCOD_R_REQUEST_FAILED);
                  return 0;
            }

            return 1;
      }
}


/* This function is aliased to RSA_mod_exp (with the mont stuff dropped).
 */
static int RSA_zencod_bn_mod_exp ( BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
            const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx )
{

      CHEESE () ;

      if ( !zencod_dso ) {
            ENGINEerr(ZENCOD_F_ZENCOD_RSA_MOD_EXP, ZENCOD_R_NOT_LOADED);
            return 0;
      }

      /* Do in software if argument is too large for hardware */
      if ( BN_num_bits(m) > ZENBRIDGE_MAX_KEYSIZE_RSA ) {
            const RSA_METHOD *meth;

            meth = RSA_PKCS1_SSLeay();
            return meth->bn_mod_exp(r, a, p, m, ctx, m_ctx);
      } else {
            zen_nb_t y, x, e, n;

            if ( !bn_expand(r, BN_num_bits(m)) ) {
                  ENGINEerr(ZENCOD_F_ZENCOD_RSA_MOD_EXP, ZENCOD_R_BN_EXPAND_FAIL);
                  return 0;
            }
            r->top = (BN_num_bits(m) + BN_BITS2 - 1) / BN_BITS2;

            BIGNUM2ZEN ( &x, a ) ;
            BIGNUM2ZEN ( &y, r ) ;
            BIGNUM2ZEN ( &e, p ) ;
            BIGNUM2ZEN ( &n, m ) ;

            if ( ptr_zencod_rsa_mod_exp ( &y, &x, &n, &e ) < 0 ) {
                  PERROR("zenbridge_rsa_mod_exp");
                  ENGINEerr(ZENCOD_F_ZENCOD_RSA_MOD_EXP, ZENCOD_R_REQUEST_FAILED);
                  return 0;
            }

            return 1;
      }
}
#endif /* !OPENSSL_NO_RSA */


#ifndef OPENSSL_NO_DSA
/* DSA stuff Functions
 */
static DSA_SIG *DSA_zencod_do_sign ( const unsigned char *dgst, int dlen, DSA *dsa )
{
      zen_nb_t p, q, g, x, y, r, s, data;
      DSA_SIG *sig;
      BIGNUM *bn_r = NULL;
      BIGNUM *bn_s = NULL;
      char msg[20];

      CHEESE();

      if ( !zencod_dso ) {
            ENGINEerr(ZENCOD_F_ZENCOD_DSA_DO_SIGN, ZENCOD_R_NOT_LOADED);
            goto FAILED;
      }

      if ( dlen > 160 ) {
            ENGINEerr(ZENCOD_F_ZENCOD_DSA_DO_SIGN, ZENCOD_R_REQUEST_FAILED);
            goto FAILED;
      }

      /* Do in software if argument is too large for hardware */
      if ( BN_num_bits(dsa->p) > ZENBRIDGE_MAX_KEYSIZE_DSA_SIGN ||
            BN_num_bits(dsa->g) > ZENBRIDGE_MAX_KEYSIZE_DSA_SIGN ) {
            const DSA_METHOD *meth;
            ENGINEerr(ZENCOD_F_ZENCOD_DSA_DO_SIGN, ZENCOD_R_BAD_KEY_COMPONENTS);
            meth = DSA_OpenSSL();
            return meth->dsa_do_sign(dgst, dlen, dsa);
      }

      if ( !(bn_s = BN_new()) || !(bn_r = BN_new()) ) {
            ENGINEerr(ZENCOD_F_ZENCOD_DSA_DO_SIGN, ZENCOD_R_BAD_KEY_COMPONENTS);
            goto FAILED;
      }

      if ( !bn_expand(bn_r, 160) || !bn_expand(bn_s, 160) ) {
            ENGINEerr(ZENCOD_F_ZENCOD_DSA_DO_SIGN, ZENCOD_R_BN_EXPAND_FAIL);
            goto FAILED;
      }

      bn_r->top = bn_s->top = (160 + BN_BITS2 - 1) / BN_BITS2;
      BIGNUM2ZEN ( &p, dsa->p ) ;
      BIGNUM2ZEN ( &q, dsa->q ) ;
      BIGNUM2ZEN ( &g, dsa->g ) ;
      BIGNUM2ZEN ( &x, dsa->priv_key ) ;
      BIGNUM2ZEN ( &y, dsa->pub_key ) ;
      BIGNUM2ZEN ( &r, bn_r ) ;
      BIGNUM2ZEN ( &s, bn_s ) ;
      q.len = x.len = 160;

      ypcmem(msg, dgst, 20);
      ptr_zencod_init_number ( &data, 160, msg ) ;

      if ( ptr_zencod_dsa_do_sign ( 0, &data, &y, &p, &q, &g, &x, &r, &s ) < 0 ) {
            PERROR("zenbridge_dsa_do_sign");
            ENGINEerr(ZENCOD_F_ZENCOD_DSA_DO_SIGN, ZENCOD_R_REQUEST_FAILED);
            goto FAILED;
      }

      if ( !( sig = DSA_SIG_new () ) ) {
            ENGINEerr(ZENCOD_F_ZENCOD_DSA_DO_SIGN, ZENCOD_R_REQUEST_FAILED);
            goto FAILED;
      }
      sig->r = bn_r;
      sig->s = bn_s;
      return sig;

 FAILED:
      if (bn_r)
            BN_free(bn_r);
      if (bn_s)
            BN_free(bn_s);
      return NULL;
}


static int DSA_zencod_do_verify ( const unsigned char *dgst, int dlen, DSA_SIG *sig, DSA *dsa )
{
      zen_nb_t data, p, q, g, y, r, s, v;
      char msg[20];
      char v_data[20];
      int ret;

      CHEESE();

      if ( !zencod_dso ) {
            ENGINEerr(ZENCOD_F_ZENCOD_DSA_DO_VERIFY, ZENCOD_R_NOT_LOADED);
            return 0;
      }

      if ( dlen > 160 ) {
            ENGINEerr(ZENCOD_F_ZENCOD_DSA_DO_SIGN, ZENCOD_R_REQUEST_FAILED);
            return 0;
      }

      /* Do in software if argument is too large for hardware */
      if ( BN_num_bits(dsa->p) > ZENBRIDGE_MAX_KEYSIZE_DSA_SIGN ||
            BN_num_bits(dsa->g) > ZENBRIDGE_MAX_KEYSIZE_DSA_SIGN ) {
            const DSA_METHOD *meth;
            ENGINEerr(ZENCOD_F_ZENCOD_DSA_DO_SIGN, ZENCOD_R_BAD_KEY_COMPONENTS);
            meth = DSA_OpenSSL();
            return meth->dsa_do_verify(dgst, dlen, sig, dsa);
      }

      BIGNUM2ZEN ( &p, dsa->p ) ;
      BIGNUM2ZEN ( &q, dsa->q ) ;
      BIGNUM2ZEN ( &g, dsa->g ) ;
      BIGNUM2ZEN ( &y, dsa->pub_key ) ;
      BIGNUM2ZEN ( &r, sig->r ) ;
      BIGNUM2ZEN ( &s, sig->s ) ;
      ptr_zencod_init_number ( &v, 160, v_data ) ;
      ypcmem(msg, dgst, 20);
      ptr_zencod_init_number ( &data, 160, msg ) ;

      if ( ( ret = ptr_zencod_dsa_do_verify ( 0, &data, &p, &q, &g, &y, &r, &s, &v ) ) < 0 ) {
            PERROR("zenbridge_dsa_do_verify");
            ENGINEerr(ZENCOD_F_ZENCOD_DSA_DO_VERIFY, ZENCOD_R_REQUEST_FAILED);
            return 0;
      }

      return ( ( ret == 0 ) ? 1 : ret ) ;
}


static int DSA_zencod_bn_mod_exp ( DSA *dsa, BIGNUM *r, BIGNUM *a, const BIGNUM *p, const BIGNUM *m,
                       BN_CTX *ctx, BN_MONT_CTX *m_ctx )
{
      CHEESE () ;

      return zencod_bn_mod_exp ( r, a, p, m, ctx ) ;
}
#endif /* !OPENSSL_NO_DSA */


#ifndef OPENSSl_NO_DH
/* DH stuff Functions
 */
static int DH_zencod_generate_key ( DH *dh )
{
      BIGNUM *bn_prv = NULL;
      BIGNUM *bn_pub = NULL;
      zen_nb_t y, x, g, p;
      int generate_x;

      CHEESE();

      if ( !zencod_dso ) {
            ENGINEerr(ZENCOD_F_ZENCOD_DH_GENERATE, ZENCOD_R_NOT_LOADED);
            return 0;
      }

      /* Private key */
      if ( dh->priv_key ) {
            bn_prv = dh->priv_key;
            generate_x = 0;
      } else {
            if (!(bn_prv = BN_new())) {
                  ENGINEerr(ZENCOD_F_ZENCOD_DH_GENERATE, ZENCOD_R_BN_EXPAND_FAIL);
                  goto FAILED;
            }
            generate_x = 1;
      }

      /* Public key */
      if ( dh->pub_key )
            bn_pub = dh->pub_key;
      else
            if ( !( bn_pub = BN_new () ) ) {
                  ENGINEerr(ZENCOD_F_ZENCOD_DH_GENERATE, ZENCOD_R_BN_EXPAND_FAIL);
                  goto FAILED;
            }

      /* Expand */
      if ( !bn_wexpand ( bn_prv, dh->p->dmax ) ||
          !bn_wexpand ( bn_pub, dh->p->dmax ) ) {
            ENGINEerr(ZENCOD_F_ZENCOD_DH_GENERATE, ZENCOD_R_BN_EXPAND_FAIL);
            goto FAILED;
      }
      bn_prv->top = dh->p->top;
      bn_pub->top = dh->p->top;

      /* Convert all keys */
      BIGNUM2ZEN ( &p, dh->p ) ;
      BIGNUM2ZEN ( &g, dh->g ) ;
      BIGNUM2ZEN ( &y, bn_pub ) ;
      BIGNUM2ZEN ( &x, bn_prv ) ;
      x.len = DH_size(dh) * 8;

      /* Adjust the lengths of P and G */
      p.len = ptr_zencod_bytes2bits ( p.data, ZEN_BYTES ( p.len ) ) ;
      g.len = ptr_zencod_bytes2bits ( g.data, ZEN_BYTES ( g.len ) ) ;

      /* Send the request to the driver */
      if ( ptr_zencod_dh_generate_key ( &y, &x, &g, &p, generate_x ) < 0 ) {
            perror("zenbridge_dh_generate_key");
            ENGINEerr(ZENCOD_F_ZENCOD_DH_GENERATE, ZENCOD_R_REQUEST_FAILED);
            goto FAILED;
      }

      dh->priv_key = bn_prv;
      dh->pub_key  = bn_pub;

      return 1;

 FAILED:
      if (!dh->priv_key && bn_prv)
            BN_free(bn_prv);
      if (!dh->pub_key && bn_pub)
            BN_free(bn_pub);

      return 0;
}


static int DH_zencod_compute_key ( unsigned char *key, const BIGNUM *pub_key, DH *dh )
{
      zen_nb_t y, x, p, k;

      CHEESE();

      if ( !zencod_dso ) {
            ENGINEerr(ZENCOD_F_ZENCOD_DH_COMPUTE, ZENCOD_R_NOT_LOADED);
            return 0;
      }

      if ( !dh->priv_key ) {
            ENGINEerr(ZENCOD_F_ZENCOD_DH_COMPUTE, ZENCOD_R_BAD_KEY_COMPONENTS);
            return 0;
      }

      /* Convert all keys */
      BIGNUM2ZEN ( &y, pub_key ) ;
      BIGNUM2ZEN ( &x, dh->priv_key ) ;
      BIGNUM2ZEN ( &p, dh->p ) ;
      ptr_zencod_init_number ( &k, p.len, key ) ;

      /* Adjust the lengths */
      p.len = ptr_zencod_bytes2bits ( p.data, ZEN_BYTES ( p.len ) ) ;
      y.len = ptr_zencod_bytes2bits ( y.data, ZEN_BYTES ( y.len ) ) ;
      x.len = ptr_zencod_bytes2bits ( x.data, ZEN_BYTES ( x.len ) ) ;

      /* Call the hardware */
      if ( ptr_zencod_dh_compute_key ( &k, &y, &x, &p ) < 0 ) {
            ENGINEerr(ZENCOD_F_ZENCOD_DH_COMPUTE, ZENCOD_R_REQUEST_FAILED);
            return 0;
      }

      /* The key must be written MSB -> LSB */
      k.len = ptr_zencod_bytes2bits ( k.data, ZEN_BYTES ( k.len ) ) ;
      esrever ( key, ZEN_BYTES ( k.len ) ) ;

      return ZEN_BYTES ( k.len ) ;
}


static int DH_zencod_bn_mod_exp ( const DH *dh, BIGNUM *r, const BIGNUM *a, const BIGNUM *p, const BIGNUM *m, BN_CTX *ctx,
            BN_MONT_CTX *m_ctx )
{
      CHEESE () ;

      return zencod_bn_mod_exp ( r, a, p, m, ctx ) ;
}
#endif      /* !OPENSSL_NO_DH */


/* RAND stuff Functions
 */
static void RAND_zencod_seed ( const void *buf, int num )
{
      /* Nothing to do cause our crypto accelerator provide a true random generator */
}


static int RAND_zencod_rand_bytes ( unsigned char *buf, int num )
{
      zen_nb_t r;

      CHEESE();

      if ( !zencod_dso ) {
            ENGINEerr(ZENCOD_F_ZENCOD_RAND, ZENCOD_R_NOT_LOADED);
            return 0;
      }

      ptr_zencod_init_number ( &r, num * 8, buf ) ;

      if ( ptr_zencod_rand_bytes ( &r, ZENBRIDGE_RNG_DIRECT ) < 0 ) {
            PERROR("zenbridge_rand_bytes");
            ENGINEerr(ZENCOD_F_ZENCOD_RAND, ZENCOD_R_REQUEST_FAILED);
            return 0;
      }

      return 1;
}


static int RAND_zencod_rand_status ( void )
{
      CHEESE () ;

      return 1;
}


/* This stuff is needed if this ENGINE is being compiled into a self-contained
 * shared-library.
 */
#ifdef ENGINE_DYNAMIC_SUPPORT
static int bind_fn ( ENGINE *e, const char *id )
{

      if ( id && ( strcmp ( id, engine_zencod_id ) != 0 ) ) {
            return 0 ;
      }
      if ( !bind_helper ( e ) )  {
            return 0 ;
      }

      return 1 ;
}

IMPLEMENT_DYNAMIC_CHECK_FN ()
IMPLEMENT_DYNAMIC_BIND_FN ( bind_fn )
#endif /* ENGINE_DYNAMIC_SUPPORT */




/*
 * Adding "Digest" and "Cipher" tools ...
 * This is in development ... ;-)
 * In orfer to code this, i refer to hw_openbsd_dev_crypto and openssl engine made by Geoff Thorpe (if i'm rigth),
 * and evp, sha md5 definitions etc ...
 */
/* First add some include ... */
#include <openssl/evp.h>
#include <openssl/sha.h>
#include <openssl/md5.h>
#include <openssl/rc4.h>
#include <openssl/des.h>


/* Some variables declaration ... */
/* DONS:
 * Disable symetric computation except DES and 3DES, but let part of the code
 */
/* static int engine_digest_nids [ ] = { NID_sha1, NID_md5 } ; */
static int engine_digest_nids [ ] = {  } ;
static int engine_digest_nids_num = 0 ;
/* static int engine_cipher_nids [ ] = { NID_rc4, NID_rc4_40, NID_des_cbc, NID_des_ede3_cbc } ; */
static int engine_cipher_nids [ ] = { NID_des_cbc, NID_des_ede3_cbc } ;
static int engine_cipher_nids_num = 2 ;


/* Function prototype ... */
/*  SHA stuff */
static int engine_sha1_init ( EVP_MD_CTX *ctx ) ;
static int engine_sha1_update ( EVP_MD_CTX *ctx, const void *data, unsigned long count ) ;
static int engine_sha1_final ( EVP_MD_CTX *ctx, unsigned char *md ) ;

/*  MD5 stuff */
static int engine_md5_init ( EVP_MD_CTX *ctx ) ;
static int engine_md5_update ( EVP_MD_CTX *ctx, const void *data, unsigned long count ) ;
static int engine_md5_final ( EVP_MD_CTX *ctx, unsigned char *md ) ;

static int engine_md_cleanup ( EVP_MD_CTX *ctx ) ;
static int engine_md_copy ( EVP_MD_CTX *to, const EVP_MD_CTX *from ) ;


/* RC4 Stuff */
static int engine_rc4_init_key ( EVP_CIPHER_CTX *ctx, const unsigned char *key, const unsigned char *iv, int enc ) ;
static int engine_rc4_cipher ( EVP_CIPHER_CTX *ctx, unsigned char *out, const unsigned char *in, unsigned int inl ) ;

/* DES Stuff */
static int engine_des_init_key ( EVP_CIPHER_CTX *ctx, const unsigned char *key, const unsigned char *iv, int enc ) ;
static int engine_des_cbc_cipher ( EVP_CIPHER_CTX *ctx, unsigned char *out, const unsigned char *in, unsigned int inl ) ;

/*  3DES Stuff */
static int engine_des_ede3_init_key ( EVP_CIPHER_CTX *ctx, const unsigned char *key, const unsigned char *iv, int enc ) ;
static int engine_des_ede3_cbc_cipher ( EVP_CIPHER_CTX *ctx, unsigned char *out,const unsigned char *in, unsigned int inl ) ;

static int engine_cipher_cleanup ( EVP_CIPHER_CTX *ctx ) ;  /* cleanup ctx */


/* The one for SHA ... */
static const EVP_MD engine_sha1_md =
{
      NID_sha1,
      NID_sha1WithRSAEncryption,
      SHA_DIGEST_LENGTH,
      EVP_MD_FLAG_ONESHOT,
      /* 0, */                /* EVP_MD_FLAG_ONESHOT = x0001 digest can only handle a single block
                        * XXX: set according to device info ... */
      engine_sha1_init,
      engine_sha1_update,
      engine_sha1_final,
      engine_md_copy,         /* dev_crypto_sha_copy */
      engine_md_cleanup,            /* dev_crypto_sha_cleanup */
      EVP_PKEY_RSA_method,
      SHA_CBLOCK,
      /* sizeof ( EVP_MD * ) + sizeof ( SHA_CTX ) */
      sizeof ( ZEN_MD_DATA )
      /* sizeof ( MD_CTX_DATA )     The message digest data stucture ... */
} ;

/* The one for MD5 ... */
static const EVP_MD engine_md5_md =
{
      NID_md5,
      NID_md5WithRSAEncryption,
      MD5_DIGEST_LENGTH,
      EVP_MD_FLAG_ONESHOT,
      /* 0, */                /* EVP_MD_FLAG_ONESHOT = x0001 digest can only handle a single block
                        * XXX: set according to device info ... */
      engine_md5_init,
      engine_md5_update,
      engine_md5_final,
      engine_md_copy,         /* dev_crypto_md5_copy */
      engine_md_cleanup,            /* dev_crypto_md5_cleanup */
      EVP_PKEY_RSA_method,
      MD5_CBLOCK,
      /* sizeof ( EVP_MD * ) + sizeof ( MD5_CTX ) */
      sizeof ( ZEN_MD_DATA )
      /* sizeof ( MD_CTX_DATA )     The message digest data stucture ... */
} ;


/* The one for RC4 ... */
#define EVP_RC4_KEY_SIZE                  16

/* Try something static ... */
typedef struct
{
      unsigned int len ;
      unsigned int first ;
      unsigned char rc4_state [ 260 ] ;
} NEW_ZEN_RC4_KEY ;

#define rc4_data(ctx)                     ( (EVP_RC4_KEY *) ( ctx )->cipher_data )

static const EVP_CIPHER engine_rc4 =
{
      NID_rc4,
      1,
      16,                     /* EVP_RC4_KEY_SIZE should be 128 bits */
      0,                      /* FIXME: key should be up to 256 bytes */
      EVP_CIPH_VARIABLE_LENGTH,
      engine_rc4_init_key,
      engine_rc4_cipher,
      engine_cipher_cleanup,
      sizeof ( NEW_ZEN_RC4_KEY ),
      NULL,
      NULL,
      NULL
} ;

/* The one for RC4_40 ... */
static const EVP_CIPHER engine_rc4_40 =
{
      NID_rc4_40,
      1,
      5,                      /* 40 bits */
      0,
      EVP_CIPH_VARIABLE_LENGTH,
      engine_rc4_init_key,
      engine_rc4_cipher,
      engine_cipher_cleanup,
      sizeof ( NEW_ZEN_RC4_KEY ),
      NULL,
      NULL,
      NULL
} ;

/* The one for DES ... */

/* Try something static ... */
typedef struct
{
      unsigned char des_key [ 24 ] ;
      unsigned char des_iv [ 8 ] ;
} ZEN_DES_KEY ;

static const EVP_CIPHER engine_des_cbc =
      {
      NID_des_cbc,
      8, 8, 8,
      0 | EVP_CIPH_CBC_MODE,
      engine_des_init_key,
      engine_des_cbc_cipher,
      engine_cipher_cleanup,
      sizeof(ZEN_DES_KEY),
      EVP_CIPHER_set_asn1_iv,
      EVP_CIPHER_get_asn1_iv,
      NULL,
      NULL
      };

/* The one for 3DES ... */

/* Try something static ... */
typedef struct
{
      unsigned char des3_key [ 24 ] ;
      unsigned char des3_iv [ 8 ] ;
} ZEN_3DES_KEY ;

#define des_data(ctx)                      ( (DES_EDE_KEY *) ( ctx )->cipher_data )

static const EVP_CIPHER engine_des_ede3_cbc =
      {
      NID_des_ede3_cbc,
      8, 8, 8,
      0 | EVP_CIPH_CBC_MODE,
      engine_des_ede3_init_key,
      engine_des_ede3_cbc_cipher,
      engine_cipher_cleanup,
      sizeof(ZEN_3DES_KEY),
      EVP_CIPHER_set_asn1_iv,
      EVP_CIPHER_get_asn1_iv,
      NULL,
      NULL
      };


/* General function cloned on hw_openbsd_dev_crypto one ... */
static int engine_digests ( ENGINE *e, const EVP_MD **digest, const int **nids, int nid )
{

#ifdef DEBUG_ZENCOD_MD
      fprintf ( stderr, "\t=>Function : static int engine_digests () called !\n" ) ;
#endif

      if ( !digest ) {
            /* We are returning a list of supported nids */
            *nids = engine_digest_nids ;
            return engine_digest_nids_num ;
      }
      /* We are being asked for a specific digest */
      if ( nid == NID_md5 ) {
            *digest = &engine_md5_md ;
      }
      else if ( nid == NID_sha1 ) {
            *digest = &engine_sha1_md ;
      }
      else {
            *digest = NULL ;
            return 0 ;
      }
      return 1 ;
}


/* SHA stuff Functions
 */
static int engine_sha1_init ( EVP_MD_CTX *ctx )
{

      int to_return = 0 ;

      /* Test with zenbridge library ... */
      to_return = ptr_zencod_sha1_init ( (ZEN_MD_DATA *) ctx->md_data ) ;
      to_return = !to_return ;

      return to_return ;
}


static int engine_sha1_update ( EVP_MD_CTX *ctx, const void *data, unsigned long count )
{

      zen_nb_t input ;
      int to_return = 0 ;

      /* Convert parameters ... */
      input.len = count ;
      input.data = (unsigned char *) data ;

      /* Test with zenbridge library ... */
      to_return = ptr_zencod_sha1_update ( (ZEN_MD_DATA *) ctx->md_data, (const zen_nb_t *) &input ) ;
      to_return = !to_return ;

      return to_return ;
}


static int engine_sha1_final ( EVP_MD_CTX *ctx, unsigned char *md )
{

      zen_nb_t output ;
      int to_return = 0 ;

      /* Convert parameters ... */
      output.len = SHA_DIGEST_LENGTH ;
      output.data = md ;

      /* Test with zenbridge library ... */
      to_return = ptr_zencod_sha1_do_final ( (ZEN_MD_DATA *) ctx->md_data, (zen_nb_t *) &output ) ;
      to_return = !to_return ;

      return to_return ;
}



/* MD5 stuff Functions
 */
static int engine_md5_init ( EVP_MD_CTX *ctx )
{

      int to_return = 0 ;

      /* Test with zenbridge library ... */
      to_return = ptr_zencod_md5_init ( (ZEN_MD_DATA *) ctx->md_data ) ;
      to_return = !to_return ;

      return to_return ;
}


static int engine_md5_update ( EVP_MD_CTX *ctx, const void *data, unsigned long count )
{

      zen_nb_t input ;
      int to_return = 0 ;

      /* Convert parameters ... */
      input.len = count ;
      input.data = (unsigned char *) data ;

      /* Test with zenbridge library ... */
      to_return = ptr_zencod_md5_update ( (ZEN_MD_DATA *) ctx->md_data, (const zen_nb_t *) &input ) ;
      to_return = !to_return ;

      return to_return ;
}


static int engine_md5_final ( EVP_MD_CTX *ctx, unsigned char *md )
{

      zen_nb_t output ;
      int to_return = 0 ;

      /* Convert parameters ... */
      output.len = MD5_DIGEST_LENGTH ;
      output.data = md ;

      /* Test with zenbridge library ... */
      to_return = ptr_zencod_md5_do_final ( (ZEN_MD_DATA *) ctx->md_data, (zen_nb_t *) &output ) ;
      to_return = !to_return ;

      return to_return ;
}


static int engine_md_cleanup ( EVP_MD_CTX *ctx )
{

      ZEN_MD_DATA *zen_md_data = (ZEN_MD_DATA *) ctx->md_data ;

      if ( zen_md_data->HashBuffer != NULL ) {
            OPENSSL_free ( zen_md_data->HashBuffer ) ;
            zen_md_data->HashBufferSize = 0 ;
            ctx->md_data = NULL ;
      }

      return 1 ;
}


static int engine_md_copy ( EVP_MD_CTX *to, const EVP_MD_CTX *from )
{
      const ZEN_MD_DATA *from_md = (ZEN_MD_DATA *) from->md_data ;
      ZEN_MD_DATA *to_md = (ZEN_MD_DATA *) to->md_data ;

      to_md->HashBuffer = OPENSSL_malloc ( from_md->HashBufferSize ) ;
      memcpy ( to_md->HashBuffer, from_md->HashBuffer, from_md->HashBufferSize ) ;

      return 1;
}


/* General function cloned on hw_openbsd_dev_crypto one ... */
static int engine_ciphers ( ENGINE *e, const EVP_CIPHER **cipher, const int **nids, int nid )
{

      if ( !cipher ) {
            /* We are returning a list of supported nids */
            *nids = engine_cipher_nids ;
            return engine_cipher_nids_num ;
      }
      /* We are being asked for a specific cipher */
      if ( nid == NID_rc4 ) {
            *cipher = &engine_rc4 ;
      }
      else if ( nid == NID_rc4_40 ) {
            *cipher = &engine_rc4_40 ;
      }
      else if ( nid == NID_des_cbc ) {
            *cipher = &engine_des_cbc ;
      }
      else if ( nid == NID_des_ede3_cbc ) {
            *cipher = &engine_des_ede3_cbc ;
      }
      else {
            *cipher = NULL ;
            return 0 ;
      }

      return 1 ;
}


static int engine_rc4_init_key ( EVP_CIPHER_CTX *ctx, const unsigned char *key, const unsigned char *iv, int enc )
{
      int to_return = 0 ;
      int i = 0 ;
      int nb = 0 ;
      NEW_ZEN_RC4_KEY *tmp_rc4_key = NULL ;

      tmp_rc4_key = (NEW_ZEN_RC4_KEY *) ( ctx->cipher_data ) ;
      tmp_rc4_key->first = 0 ;
      tmp_rc4_key->len = ctx->key_len ;
      tmp_rc4_key->rc4_state [ 0 ] = 0x00 ;
      tmp_rc4_key->rc4_state [ 2 ] = 0x00 ;
      nb = 256 / ctx->key_len ;
      for ( i = 0; i < nb ; i++ ) {
            memcpy ( &( tmp_rc4_key->rc4_state [ 4 + i*ctx->key_len ] ), key, ctx->key_len ) ;
      }

      to_return = 1 ;

      return to_return ;
}


static int engine_rc4_cipher ( EVP_CIPHER_CTX *ctx, unsigned char *out, const unsigned char *in, unsigned int in_len )
{

      zen_nb_t output, input ;
      zen_nb_t rc4key ;
      int to_return = 0 ;
      NEW_ZEN_RC4_KEY *tmp_rc4_key = NULL ;

      /* Convert parameters ... */
      input.len = in_len ;
      input.data = (unsigned char *) in ;
      output.len = in_len ;
      output.data = (unsigned char *) out ;

      tmp_rc4_key = ( (NEW_ZEN_RC4_KEY *) ( ctx->cipher_data ) ) ;
      rc4key.len = 260 ;
      rc4key.data = &( tmp_rc4_key->rc4_state [ 0 ] ) ;

      /* Test with zenbridge library ... */
      to_return = ptr_zencod_rc4_cipher ( &output, &input, (const zen_nb_t *) &rc4key, &( tmp_rc4_key->rc4_state [0] ), &( tmp_rc4_key->rc4_state [3] ), !tmp_rc4_key->first ) ;
      to_return = !to_return ;

      /* Update encryption state ... */
      tmp_rc4_key->first = 1 ;
      tmp_rc4_key = NULL ;

      return to_return ;
}


static int engine_des_init_key ( EVP_CIPHER_CTX *ctx, const unsigned char *key, const unsigned char *iv, int enc )
{

      ZEN_DES_KEY *tmp_des_key = NULL ;
      int to_return = 0 ;

      tmp_des_key = (ZEN_DES_KEY *) ( ctx->cipher_data ) ;
      memcpy ( &( tmp_des_key->des_key [ 0 ] ), key, 8 ) ;
      memcpy ( &( tmp_des_key->des_key [ 8 ] ), key, 8 ) ;
      memcpy ( &( tmp_des_key->des_key [ 16 ] ), key, 8 ) ;
      memcpy ( &( tmp_des_key->des_iv [ 0 ] ), iv, 8 ) ;

      to_return = 1 ;

      return to_return ;
}


static int engine_des_cbc_cipher ( EVP_CIPHER_CTX *ctx, unsigned char *out, const unsigned char *in, unsigned int inl )
{

      zen_nb_t output, input ;
      zen_nb_t deskey_1, deskey_2, deskey_3, iv ;
      int to_return = 0 ;

      /* Convert parameters ... */
      input.len = inl ;
      input.data = (unsigned char *) in ;
      output.len = inl ;
      output.data = out ;

      /* Set key parameters ... */
      deskey_1.len = 8 ;
      deskey_2.len = 8 ;
      deskey_3.len = 8 ;
      deskey_1.data = (unsigned char *) ( (ZEN_DES_KEY *) ( ctx->cipher_data ) )->des_key ;
      deskey_2.data =  (unsigned char *) &( (ZEN_DES_KEY *) ( ctx->cipher_data ) )->des_key [ 8 ] ;
      deskey_3.data =  (unsigned char *) &( (ZEN_DES_KEY *) ( ctx->cipher_data ) )->des_key [ 16 ] ;

      /* Key correct iv ... */
      memcpy ( ( (ZEN_DES_KEY *) ( ctx->cipher_data ) )->des_iv, ctx->iv, 8 ) ;
      iv.len = 8 ;
      iv.data = (unsigned char *) ( (ZEN_DES_KEY *) ( ctx->cipher_data ) )->des_iv ;

      if ( ctx->encrypt == 0 ) {
            memcpy ( ctx->iv, &( input.data [ input.len - 8 ] ), 8 ) ;
      }

      /* Test with zenbridge library ... */
      to_return = ptr_zencod_xdes_cipher ( &output, &input,
                  (zen_nb_t *) &deskey_1, (zen_nb_t *) &deskey_2, (zen_nb_t *) &deskey_3, &iv, ctx->encrypt ) ;
      to_return = !to_return ;

      /* But we need to set up the rigth iv ...
       * Test ENCRYPT or DECRYPT mode to set iv ... */
      if ( ctx->encrypt == 1 ) {
            memcpy ( ctx->iv, &( output.data [ output.len - 8 ] ), 8 ) ;
      }

      return to_return ;
}


static int engine_des_ede3_init_key ( EVP_CIPHER_CTX *ctx, const unsigned char *key, const unsigned char *iv, int enc )
{

      ZEN_3DES_KEY *tmp_3des_key = NULL ;
      int to_return = 0 ;

      tmp_3des_key = (ZEN_3DES_KEY *) ( ctx->cipher_data ) ;
      memcpy ( &( tmp_3des_key->des3_key [ 0 ] ), key, 24 ) ;
      memcpy ( &( tmp_3des_key->des3_iv [ 0 ] ), iv, 8 ) ;

      to_return = 1;

      return to_return ;
}


static int engine_des_ede3_cbc_cipher ( EVP_CIPHER_CTX *ctx, unsigned char *out, const unsigned char *in,
      unsigned int in_len )
{

      zen_nb_t output, input ;
      zen_nb_t deskey_1, deskey_2, deskey_3, iv ;
      int to_return = 0 ;

      /* Convert parameters ... */
      input.len = in_len ;
      input.data = (unsigned char *) in ;
      output.len = in_len ;
      output.data = out ;

      /* Set key ... */
      deskey_1.len = 8 ;
      deskey_2.len = 8 ;
      deskey_3.len = 8 ;
      deskey_1.data =  (unsigned char *) ( (ZEN_3DES_KEY *) ( ctx->cipher_data ) )->des3_key ;
      deskey_2.data =  (unsigned char *) &( (ZEN_3DES_KEY *) ( ctx->cipher_data ) )->des3_key [ 8 ] ;
      deskey_3.data =  (unsigned char *) &( (ZEN_3DES_KEY *) ( ctx->cipher_data ) )->des3_key [ 16 ] ;

      /* Key correct iv ... */
      memcpy ( ( (ZEN_3DES_KEY *) ( ctx->cipher_data ) )->des3_iv, ctx->iv, 8 ) ;
      iv.len = 8 ;
      iv.data = (unsigned char *) ( (ZEN_3DES_KEY *) ( ctx->cipher_data ) )->des3_iv ;

      if ( ctx->encrypt == 0 ) {
            memcpy ( ctx->iv, &( input.data [ input.len - 8 ] ), 8 ) ;
      }

      /* Test with zenbridge library ... */
      to_return = ptr_zencod_xdes_cipher ( &output, &input,
                  (zen_nb_t *) &deskey_1, (zen_nb_t *) &deskey_2, (zen_nb_t *) &deskey_3, &iv, ctx->encrypt ) ;
      to_return = !to_return ;

      if ( ctx->encrypt == 1 ) {
            memcpy ( ctx->iv, &( output.data [ output.len - 8 ] ), 8 ) ;
      }

      return to_return ;
}


static int engine_cipher_cleanup ( EVP_CIPHER_CTX *ctx )
{

      /* Set the key pointer ... */
      if ( ctx->cipher->nid == NID_rc4 || ctx->cipher->nid == NID_rc4_40 ) {
      }
      else if ( ctx->cipher->nid == NID_des_cbc ) {
      }
      else if ( ctx->cipher->nid == NID_des_ede3_cbc ) {
      }

      return 1 ;
}


#endif /* !OPENSSL_NO_HW_ZENCOD */
#endif /* !OPENSSL_NO_HW */

Generated by  Doxygen 1.6.0   Back to index