csu3_am335x/EVSE/GPL/openssl-1.0.2g/demos/engines/zencod/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 perform 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 structure ...
         */
};

/* 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 structure ...
         */
};

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