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