From 056cc163f539f272778cfa2dba7848c650da4f5e Mon Sep 17 00:00:00 2001 From: Richard Levitte Date: Tue, 13 Aug 2002 12:30:27 +0000 Subject: [PATCH] Merge in demo engines from 0.9.7-stable. --- demos/engines/cluster_labs/Makefile | 114 ++ demos/engines/cluster_labs/cluster_labs.h | 35 + demos/engines/cluster_labs/hw_cluster_labs.c | 718 +++++++ demos/engines/cluster_labs/hw_cluster_labs.ec | 8 + .../cluster_labs/hw_cluster_labs_err.c | 151 ++ .../cluster_labs/hw_cluster_labs_err.h | 95 + demos/engines/ibmca/Makefile | 114 ++ demos/engines/ibmca/hw_ibmca.c | 917 +++++++++ demos/engines/ibmca/hw_ibmca.ec | 8 + demos/engines/ibmca/hw_ibmca_err.c | 154 ++ demos/engines/ibmca/hw_ibmca_err.h | 98 + demos/engines/ibmca/ica_openssl_api.h | 189 ++ demos/engines/rsaref/Makefile | 2 +- demos/engines/zencod/Makefile | 114 ++ demos/engines/zencod/hw_zencod.c | 1736 +++++++++++++++++ demos/engines/zencod/hw_zencod.ec | 8 + demos/engines/zencod/hw_zencod.h | 160 ++ demos/engines/zencod/hw_zencod_err.c | 151 ++ demos/engines/zencod/hw_zencod_err.h | 95 + 19 files changed, 4866 insertions(+), 1 deletion(-) create mode 100644 demos/engines/cluster_labs/Makefile create mode 100644 demos/engines/cluster_labs/cluster_labs.h create mode 100644 demos/engines/cluster_labs/hw_cluster_labs.c create mode 100644 demos/engines/cluster_labs/hw_cluster_labs.ec create mode 100644 demos/engines/cluster_labs/hw_cluster_labs_err.c create mode 100644 demos/engines/cluster_labs/hw_cluster_labs_err.h create mode 100644 demos/engines/ibmca/Makefile create mode 100644 demos/engines/ibmca/hw_ibmca.c create mode 100644 demos/engines/ibmca/hw_ibmca.ec create mode 100644 demos/engines/ibmca/hw_ibmca_err.c create mode 100644 demos/engines/ibmca/hw_ibmca_err.h create mode 100644 demos/engines/ibmca/ica_openssl_api.h create mode 100644 demos/engines/zencod/Makefile create mode 100644 demos/engines/zencod/hw_zencod.c create mode 100644 demos/engines/zencod/hw_zencod.ec create mode 100644 demos/engines/zencod/hw_zencod.h create mode 100644 demos/engines/zencod/hw_zencod_err.c create mode 100644 demos/engines/zencod/hw_zencod_err.h diff --git a/demos/engines/cluster_labs/Makefile b/demos/engines/cluster_labs/Makefile new file mode 100644 index 0000000000..956193f093 --- /dev/null +++ b/demos/engines/cluster_labs/Makefile @@ -0,0 +1,114 @@ +LIBNAME= libclabs +SRC= hw_cluster_labs.c +OBJ= hw_cluster_labs.o +HEADER= hw_cluster_labs.h + +CC= gcc +PIC= -fPIC +CFLAGS= -g -I../../../include $(PIC) -DENGINE_DYNAMIC_SUPPORT -DFLAT_INC +AR= ar r +RANLIB= ranlib + +LIB= $(LIBNAME).a +SHLIB= $(LIBNAME).so + +all: + @echo 'Please choose a system to build on:' + @echo '' + @echo 'tru64: Tru64 Unix, Digital Unix, Digital OSF/1' + @echo 'solaris: Solaris' + @echo 'irix: IRIX' + @echo 'hpux32: 32-bit HP/UX' + @echo 'hpux64: 64-bit HP/UX' + @echo 'aix: AIX' + @echo 'gnu: Generic GNU-based system (gcc and GNU ld)' + @echo '' + +FORCE.update: +update: FORCE.update + perl ../../../util/mkerr.pl -conf hw_cluster_labs.ec \ + -nostatic -staticloader -write hw_cluster_labs.c + +gnu: $(SHLIB).gnu +tru64: $(SHLIB).tru64 +solaris: $(SHLIB).solaris +irix: $(SHLIB).irix +hpux32: $(SHLIB).hpux32 +hpux64: $(SHLIB).hpux64 +aix: $(SHLIB).aix + +$(LIB): $(OBJ) + $(AR) $(LIB) $(OBJ) + - $(RANLIB) $(LIB) + +LINK_SO= \ + ld -r -o $(LIBNAME).o $$ALLSYMSFLAGS $(LIB) && \ + (nm -Pg $(LIBNAME).o | grep ' [BDT] ' | cut -f1 -d' ' > $(LIBNAME).exp; \ + $$SHAREDCMD $$SHAREDFLAGS -o $(SHLIB) $(LIBNAME).o -L ../../.. -lcrypto -lc) + +$(SHLIB).gnu: $(LIB) + ALLSYMSFLAGS='--whole-archive' \ + SHAREDFLAGS='-shared -Wl,-soname=$(SHLIB)' \ + SHAREDCMD='$(CC)'; \ + $(LINK_SO) + touch $(SHLIB).gnu +$(SHLIB).tru64: $(LIB) + ALLSYMSFLAGS='-all' \ + SHAREDFLAGS='-shared' \ + SHAREDCMD='$(CC)'; \ + $(LINK_SO) + touch $(SHLIB).tru64 +$(SHLIB).solaris: $(LIB) + ALLSYMSFLAGS='-z allextract' \ + SHAREDFLAGS='-G -h $(SHLIB)' \ + SHAREDCMD='$(CC)'; \ + $(LINK_SO) + touch $(SHLIB).solaris +$(SHLIB).irix: $(LIB) + ALLSYMSFLAGS='-all' \ + SHAREDFLAGS='-shared -Wl,-soname,$(SHLIB)' \ + SHAREDCMD='$(CC)'; \ + $(LINK_SO) + touch $(SHLIB).irix +$(SHLIB).hpux32: $(LIB) + ALLSYMSFLAGS='-Fl' \ + SHAREDFLAGS='+vnocompatwarnings -b -z +s +h $(SHLIB)' \ + SHAREDCMD='/usr/ccs/bin/ld'; \ + $(LINK_SO) + touch $(SHLIB).hpux32 +$(SHLIB).hpux64: $(LIB) + ALLSYMSFLAGS='+forceload' \ + SHAREDFLAGS='-b -z +h $(SHLIB)' \ + SHAREDCMD='/usr/ccs/bin/ld'; \ + $(LINK_SO) + touch $(SHLIB).hpux64 +$(SHLIB).aix: $(LIB) + ALLSYMSFLAGS='-bnogc' \ + SHAREDFLAGS='-G -bE:$(LIBNAME).exp -bM:SRE' \ + SHAREDCMD='$(CC)'; \ + $(LINK_SO) + touch $(SHLIB).aix + +depend: + sed -e '/^# DO NOT DELETE.*/,$$d' < Makefile > Makefile.tmp + echo '# DO NOT DELETE THIS LINE -- make depend depends on it.' >> Makefile.tmp + gcc -M $(CFLAGS) $(SRC) >> Makefile.tmp + perl ../../../util/clean-depend.pl < Makefile.tmp > Makefile.new + rm -f Makefile.tmp Makefile + mv Makefile.new Makefile + +# DO NOT DELETE THIS LINE -- make depend depends on it. + +rsaref.o: ../../../include/openssl/asn1.h ../../../include/openssl/bio.h +rsaref.o: ../../../include/openssl/bn.h ../../../include/openssl/crypto.h +rsaref.o: ../../../include/openssl/dh.h ../../../include/openssl/dsa.h +rsaref.o: ../../../include/openssl/e_os2.h ../../../include/openssl/engine.h +rsaref.o: ../../../include/openssl/err.h ../../../include/openssl/lhash.h +rsaref.o: ../../../include/openssl/opensslconf.h +rsaref.o: ../../../include/openssl/opensslv.h +rsaref.o: ../../../include/openssl/ossl_typ.h ../../../include/openssl/rand.h +rsaref.o: ../../../include/openssl/rsa.h ../../../include/openssl/safestack.h +rsaref.o: ../../../include/openssl/stack.h ../../../include/openssl/symhacks.h +rsaref.o: ../../../include/openssl/ui.h rsaref.c rsaref_err.c rsaref_err.h +rsaref.o: source/des.h source/global.h source/md2.h source/md5.h source/rsa.h +rsaref.o: source/rsaref.h diff --git a/demos/engines/cluster_labs/cluster_labs.h b/demos/engines/cluster_labs/cluster_labs.h new file mode 100644 index 0000000000..d0926796f0 --- /dev/null +++ b/demos/engines/cluster_labs/cluster_labs.h @@ -0,0 +1,35 @@ +typedef int cl_engine_init(void); +typedef int cl_mod_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, + const BIGNUM *m, BN_CTX *cgx); +typedef int cl_mod_exp_crt(BIGNUM *r, BIGNUM *a, const BIGNUM *p, + const BIGNUM *q, const BIGNUM *dmp1, const BIGNUM *dmq1, + const BIGNUM *iqmp, BN_CTX *ctx); +typedef int cl_rsa_mod_exp(BIGNUM *r0, const BIGNUM *I, RSA *rsa); +typedef int cl_rsa_pub_enc(int flen, const unsigned char *from, + unsigned char *to, RSA *rsa, int padding); +typedef int cl_rsa_pub_dec(int flen, const unsigned char *from, + unsigned char *to, RSA *rsa, int padding); +typedef int cl_rsa_priv_enc(int flen, const unsigned char *from, + unsigned char *to, RSA *rsa, int padding); +typedef int cl_rsa_priv_dec(int flen, const unsigned char *from, + unsigned char *to, RSA *rsa, int padding); +typedef int cl_rand_bytes(unsigned char *buf, int num); +typedef DSA_SIG *cl_dsa_sign(const unsigned char *dgst, int dlen, DSA *dsa); +typedef int cl_dsa_verify(const unsigned char *dgst, int dgst_len, + DSA_SIG *sig, DSA *dsa); + + +static const char *CLUSTER_LABS_LIB_NAME = "cluster_labs"; +static const char *CLUSTER_LABS_F1 = "hw_engine_init"; +static const char *CLUSTER_LABS_F2 = "hw_mod_exp"; +static const char *CLUSTER_LABS_F3 = "hw_mod_exp_crt"; +static const char *CLUSTER_LABS_F4 = "hw_rsa_mod_exp"; +static const char *CLUSTER_LABS_F5 = "hw_rsa_priv_enc"; +static const char *CLUSTER_LABS_F6 = "hw_rsa_priv_dec"; +static const char *CLUSTER_LABS_F7 = "hw_rsa_pub_enc"; +static const char *CLUSTER_LABS_F8 = "hw_rsa_pub_dec"; +static const char *CLUSTER_LABS_F20 = "hw_rand_bytes"; +static const char *CLUSTER_LABS_F30 = "hw_dsa_sign"; +static const char *CLUSTER_LABS_F31 = "hw_dsa_verify"; + + diff --git a/demos/engines/cluster_labs/hw_cluster_labs.c b/demos/engines/cluster_labs/hw_cluster_labs.c new file mode 100644 index 0000000000..00c14f2755 --- /dev/null +++ b/demos/engines/cluster_labs/hw_cluster_labs.c @@ -0,0 +1,718 @@ +/* crypto/engine/hw_cluster_labs.c */ +/* Written by Jan Tschirschwitz (jan.tschirschwitz@cluster-labs.com + * for the OpenSSL project 2000. + */ +/* ==================================================================== + * Copyright (c) 1999 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). + * + */ + +#define MSC_VER /* only used cryptic.h */ + +#include +#include +#include +#include +#include + +#ifndef NO_HW +#ifndef NO_HW_CLUSTER_LABS + +#ifdef FLAT_INC +#include "cluster_labs.h" +#else +#include "vendor_defns/cluster_labs.h" +#endif + +#define CL_LIB_NAME "cluster_labs engine" +#include "hw_cluster_labs_err.c" + + +static int cluster_labs_destroy(ENGINE *e); +static int cluster_labs_init(ENGINE *e); +static int cluster_labs_finish(ENGINE *e); +static int cluster_labs_ctrl(ENGINE *e, int cmd, long i, void *p, void (*f)()); + + +/* BIGNUM stuff */ +/* This function is aliased to mod_exp (with the mont stuff dropped). */ +static int cluster_labs_mod_exp_mont(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, + const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx); + +/* RSA stuff */ +#ifndef OPENSSL_NO_RSA +static int cluster_labs_rsa_pub_enc(int flen, const unsigned char *from, + unsigned char *to, RSA *rsa, int padding); +static int cluster_labs_rsa_pub_dec(int flen, const unsigned char *from, + unsigned char *to, RSA *rsa, int padding); +static int cluster_labs_rsa_priv_enc(int flen, const unsigned char *from, + unsigned char *to, RSA *rsa, int padding); +static int cluster_labs_rsa_priv_dec(int flen, const unsigned char *from, + unsigned char *to, RSA *rsa, int padding); +static int cluster_labs_rsa_mod_exp(BIGNUM *r0, const BIGNUM *I, RSA *rsa); +#endif + +/* DSA stuff */ +#ifndef OPENSSL_NO_DSA +DSA_SIG *cluster_labs_dsa_sign(const unsigned char *dgst, int dlen, DSA *dsa); +static int cluster_labs_dsa_verify(const unsigned char *dgst, int dgst_len, + DSA_SIG *sig, DSA *dsa); +static int cluster_labs_dsa_mod_exp(DSA *dsa, BIGNUM *rr, BIGNUM *a1, + BIGNUM *p1, BIGNUM *a2, BIGNUM *p2, BIGNUM *m, + BN_CTX *ctx, BN_MONT_CTX *in_mont); +static int cluster_labs_mod_exp_dsa(DSA *dsa, BIGNUM *r, BIGNUM *a, + const BIGNUM *p, const BIGNUM *m, BN_CTX *ctx, + BN_MONT_CTX *m_ctx); +#endif + +/* DH stuff */ +#ifndef OPENSSL_NO_DH +/* This function is alised to mod_exp (with the DH and mont dropped). */ +static int cluster_labs_mod_exp_dh(const DH *dh, BIGNUM *r, const BIGNUM *a, const BIGNUM *p, + const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx); +#endif + +/* RANDOM stuff */ +static int cluster_labs_rand_bytes(unsigned char *buf, int num); + +/* The definitions for control commands specific to this engine */ +#define CLUSTER_LABS_CMD_SO_PATH ENGINE_CMD_BASE +static const ENGINE_CMD_DEFN cluster_labs_cmd_defns[] = + { + { CLUSTER_LABS_CMD_SO_PATH, + "SO_PATH", + "Specifies the path to the 'cluster labs' shared library", + ENGINE_CMD_FLAG_STRING + }, + {0, NULL, NULL, 0} + }; + +/* Our internal RSA_METHOD that we provide pointers to */ +#ifndef OPENSSL_NO_RSA +static RSA_METHOD cluster_labs_rsa = + { + "Cluster Labs RSA method", + cluster_labs_rsa_pub_enc, /* rsa_pub_enc */ + cluster_labs_rsa_pub_dec, /* rsa_pub_dec */ + cluster_labs_rsa_priv_enc, /* rsa_priv_enc */ + cluster_labs_rsa_priv_dec, /* rsa_priv_dec */ + cluster_labs_rsa_mod_exp, /* rsa_mod_exp */ + cluster_labs_mod_exp_mont, /* bn_mod_exp */ + NULL, /* init */ + NULL, /* finish */ + 0, /* flags */ + NULL, /* apps_data */ + NULL, /* rsa_sign */ + NULL /* rsa_verify */ + }; +#endif + +/* Our internal DSA_METHOD that we provide pointers to */ +#ifndef OPENSSL_NO_DSA +static DSA_METHOD cluster_labs_dsa = + { + "Cluster Labs DSA method", + cluster_labs_dsa_sign, /* dsa_do_sign */ + NULL, /* dsa_sign_setup */ + cluster_labs_dsa_verify, /* dsa_do_verify */ + cluster_labs_dsa_mod_exp, /* dsa_mod_exp */ + cluster_labs_mod_exp_dsa, /* bn_mod_exp */ + NULL, /* init */ + NULL, /* finish */ + 0, /* flags */ + NULL /* app_data */ + }; +#endif + +/* Our internal DH_METHOD that we provide pointers to */ +#ifndef OPENSSL_NO_DH +static DH_METHOD cluster_labs_dh = + { + "Cluster Labs DH method", + NULL, /* generate key */ + NULL, /* compute key */ + cluster_labs_mod_exp_dh, /* bn_mod_exp */ + NULL, /* init */ + NULL, /* finish */ + 0, /* flags */ + NULL /* app_data */ + }; +#endif + +static RAND_METHOD cluster_labs_rand = + { + /* "Cluster Labs RAND method", */ + NULL, /* seed */ + cluster_labs_rand_bytes, /* bytes */ + NULL, /* cleanup */ + NULL, /* add */ + cluster_labs_rand_bytes, /* pseudorand */ + NULL, /* status */ + }; + +static const char *engine_cluster_labs_id = "cluster_labs"; +static const char *engine_cluster_labs_name = "Cluster Labs hardware engine support"; + +/* engine implementation */ +/*-----------------------*/ +static int bind_helper(ENGINE *e) + { + + if(!ENGINE_set_id(e, engine_cluster_labs_id) || + !ENGINE_set_name(e, engine_cluster_labs_name) || +#ifndef OPENSSL_NO_RSA + !ENGINE_set_RSA(e, &cluster_labs_rsa) || +#endif +#ifndef OPENSSL_NO_DSA + !ENGINE_set_DSA(e, &cluster_labs_dsa) || +#endif +#ifndef OPENSSL_NO_DH + !ENGINE_set_DH(e, &cluster_labs_dh) || +#endif + !ENGINE_set_RAND(e, &cluster_labs_rand) || + !ENGINE_set_destroy_function(e, cluster_labs_destroy) || + !ENGINE_set_init_function(e, cluster_labs_init) || + !ENGINE_set_finish_function(e, cluster_labs_finish) || + !ENGINE_set_ctrl_function(e, cluster_labs_ctrl) || + !ENGINE_set_cmd_defns(e, cluster_labs_cmd_defns)) + return 0; + /* Ensure the error handling is set up */ + ERR_load_CL_strings(); + return 1; + } + +#ifndef ENGINE_DYNAMIC_SUPPORT +static ENGINE *engine_cluster_labs(void) + { + ENGINE *ret = ENGINE_new(); + + if(!ret) + return NULL; + if(!bind_helper(ret)) + { + ENGINE_free(ret); + return NULL; + } + return ret; + } + +void ENGINE_load_cluster_labs(void) + { + + ENGINE *cluster_labs = engine_cluster_labs(); + + if(!cluster_labs) return; + ENGINE_add(cluster_labs); + ENGINE_free(cluster_labs); + ERR_clear_error(); + } +#endif /* !ENGINE_DYNAMIC_SUPPORT */ + +static int cluster_labs_destroy(ENGINE *e) + { + + ERR_unload_CL_strings(); + return 1; + } + + + +/* This is a process-global DSO handle used for loading and unloading + * the Cluster Labs 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 *cluster_labs_dso = NULL; + +/* These are the function pointers that are (un)set when the library has + * successfully (un)loaded. */ +static cl_engine_init *p_cl_engine_init = NULL; +static cl_mod_exp *p_cl_mod_exp = NULL; +static cl_mod_exp_crt *p_cl_mod_exp_crt = NULL; +static cl_rsa_mod_exp *p_cl_rsa_mod_exp = NULL; +static cl_rsa_priv_enc *p_cl_rsa_priv_enc = NULL; +static cl_rsa_priv_dec *p_cl_rsa_priv_dec = NULL; +static cl_rsa_pub_enc *p_cl_rsa_pub_enc = NULL; +static cl_rsa_pub_dec *p_cl_rsa_pub_dec = NULL; +static cl_rand_bytes *p_cl_rand_bytes = NULL; +static cl_dsa_sign *p_cl_dsa_sign = NULL; +static cl_dsa_verify *p_cl_dsa_verify = NULL; + + +int cluster_labs_init(ENGINE *e) + { + + cl_engine_init *p1; + cl_mod_exp *p2; + cl_mod_exp_crt *p3; + cl_rsa_mod_exp *p4; + cl_rsa_priv_enc *p5; + cl_rsa_priv_dec *p6; + cl_rsa_pub_enc *p7; + cl_rsa_pub_dec *p8; + cl_rand_bytes *p20; + cl_dsa_sign *p30; + cl_dsa_verify *p31; + + /* engine already loaded */ + if(cluster_labs_dso != NULL) + { + CLerr(CL_F_CLUSTER_LABS_INIT,CL_R_ALREADY_LOADED); + goto err; + } + /* try to load engine */ + cluster_labs_dso = DSO_load(NULL, CLUSTER_LABS_LIB_NAME, NULL,0); + if(cluster_labs_dso == NULL) + { + CLerr(CL_F_CLUSTER_LABS_INIT,CL_R_DSO_FAILURE); + goto err; + } + /* bind functions */ + if( !(p1 = (cl_engine_init *)DSO_bind_func( + cluster_labs_dso, CLUSTER_LABS_F1)) || + !(p2 = (cl_mod_exp *)DSO_bind_func( + cluster_labs_dso, CLUSTER_LABS_F2)) || + !(p3 = (cl_mod_exp_crt *)DSO_bind_func( + cluster_labs_dso, CLUSTER_LABS_F3)) || + !(p4 = (cl_rsa_mod_exp *)DSO_bind_func( + cluster_labs_dso, CLUSTER_LABS_F4)) || + !(p5 = (cl_rsa_priv_enc *)DSO_bind_func( + cluster_labs_dso, CLUSTER_LABS_F5)) || + !(p6 = (cl_rsa_priv_dec *)DSO_bind_func( + cluster_labs_dso, CLUSTER_LABS_F6)) || + !(p7 = (cl_rsa_pub_enc *)DSO_bind_func( + cluster_labs_dso, CLUSTER_LABS_F7)) || + !(p8 = (cl_rsa_pub_dec *)DSO_bind_func( + cluster_labs_dso, CLUSTER_LABS_F8)) || + !(p20= (cl_rand_bytes *)DSO_bind_func( + cluster_labs_dso, CLUSTER_LABS_F20)) || + !(p30= (cl_dsa_sign *)DSO_bind_func( + cluster_labs_dso, CLUSTER_LABS_F30)) || + !(p31= (cl_dsa_verify *)DSO_bind_func( + cluster_labs_dso, CLUSTER_LABS_F31))) + { + CLerr(CL_F_CLUSTER_LABS_INIT,CL_R_DSO_FAILURE); + goto err; + } + + /* copy function pointers */ + p_cl_engine_init = p1; + p_cl_mod_exp = p2; + p_cl_mod_exp_crt = p3; + p_cl_rsa_mod_exp = p4; + p_cl_rsa_priv_enc = p5; + p_cl_rsa_priv_dec = p6; + p_cl_rsa_pub_enc = p7; + p_cl_rsa_pub_dec = p8; + p_cl_rand_bytes = p20; + p_cl_dsa_sign = p30; + p_cl_dsa_verify = p31; + + + + /* cluster labs engine init */ + if(p_cl_engine_init()== 0){ + CLerr(CL_F_CLUSTER_LABS_INIT,CL_R_INIT_FAILED); + goto err; + } + + return(1); + +err: + /* reset all pointers */ + if(cluster_labs_dso) + DSO_free(cluster_labs_dso); + + cluster_labs_dso = NULL; + p_cl_engine_init = NULL; + p_cl_mod_exp = NULL; + p_cl_mod_exp_crt = NULL; + p_cl_rsa_mod_exp = NULL; + p_cl_rsa_priv_enc = NULL; + p_cl_rsa_priv_dec = NULL; + p_cl_rsa_pub_enc = NULL; + p_cl_rsa_pub_dec = NULL; + p_cl_rand_bytes = NULL; + p_cl_dsa_sign = NULL; + p_cl_dsa_verify = NULL; + + return(0); + } + + +static int cluster_labs_finish(ENGINE *e) + { + + if(cluster_labs_dso == NULL) + { + CLerr(CL_F_CLUSTER_LABS_FINISH,CL_R_NOT_LOADED); + return 0; + } + if(!DSO_free(cluster_labs_dso)) + { + CLerr(CL_F_CLUSTER_LABS_FINISH,CL_R_DSO_FAILURE); + return 0; + } + + cluster_labs_dso = NULL; + p_cl_engine_init = NULL; + p_cl_mod_exp = NULL; + p_cl_rsa_mod_exp = NULL; + p_cl_mod_exp_crt = NULL; + p_cl_rsa_priv_enc = NULL; + p_cl_rsa_priv_dec = NULL; + p_cl_rsa_pub_enc = NULL; + p_cl_rsa_pub_dec = NULL; + p_cl_rand_bytes = NULL; + p_cl_dsa_sign = NULL; + p_cl_dsa_verify = NULL; + + return(1); + + } + +static int cluster_labs_ctrl(ENGINE *e, int cmd, long i, void *p, void (*f)()) + { + int initialised = ((cluster_labs_dso == NULL) ? 0 : 1); + + switch(cmd) + { + case CLUSTER_LABS_CMD_SO_PATH: + if(p == NULL) + { + CLerr(CL_F_CLUSTER_LABS_CTRL,ERR_R_PASSED_NULL_PARAMETER); + return 0; + } + if(initialised) + { + CLerr(CL_F_CLUSTER_LABS_CTRL,CL_R_ALREADY_LOADED); + return 0; + } + CLUSTER_LABS_LIB_NAME = (const char *)p; + return 1; + default: + break; + } + CLerr(CL_F_CLUSTER_LABS_CTRL,CL_R_COMMAND_NOT_IMPLEMENTED); + return 0; + } + + +static int cluster_labs_mod_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, + const BIGNUM *m, BN_CTX *ctx) + { + + if(cluster_labs_dso == NULL) + { + CLerr(CL_F_CLUSTER_LABS_MOD_EXP,CL_R_NOT_LOADED); + return 0; + } + if(p_cl_mod_exp == NULL) + { + CLerr(CL_F_CLUSTER_LABS_MOD_EXP,CL_R_FUNCTION_NOT_BINDED); + return 0; + } + + return p_cl_mod_exp(r, a, p, m, ctx); + + } + +static int cluster_labs_mod_exp_crt(BIGNUM *r, BIGNUM *a, const BIGNUM *p, + const BIGNUM *q, const BIGNUM *dmp1, const BIGNUM *dmq1, + const BIGNUM *iqmp, BN_CTX *ctx) + { + + if(cluster_labs_dso == NULL) + { + CLerr(CL_F_CLUSTER_LABS_MOD_EXP_CRT,CL_R_NOT_LOADED); + return 0; + } + if(p_cl_mod_exp_crt == NULL) + { + CLerr(CL_F_CLUSTER_LABS_MOD_EXP_CRT,CL_R_FUNCTION_NOT_BINDED); + return 0; + } + + return p_cl_mod_exp_crt(r, a, p, q,dmp1, dmq1, iqmp, ctx); + + } + +static int cluster_labs_rsa_mod_exp(BIGNUM *r0, const BIGNUM *I, RSA *rsa) + { + + if(cluster_labs_dso == NULL) + { + CLerr(CL_F_CLUSTER_LABS_RSA_MOD_EXP,CL_R_NOT_LOADED); + return 0; + } + if(p_cl_rsa_mod_exp == NULL) + { + CLerr(CL_F_CLUSTER_LABS_RSA_MOD_EXP,CL_R_FUNCTION_NOT_BINDED); + return 0; + } + + return p_cl_rsa_mod_exp(r0, I, rsa); + + } + +DSA_SIG *cluster_labs_dsa_sign(const unsigned char *dgst, int dlen, DSA *dsa) + { + + if(cluster_labs_dso == NULL) + { + CLerr(CL_F_CLUSTER_LABS_DSA_SIGN,CL_R_NOT_LOADED); + return 0; + } + if(p_cl_dsa_sign == NULL) + { + CLerr(CL_F_CLUSTER_LABS_DSA_SIGN,CL_R_FUNCTION_NOT_BINDED); + return 0; + } + + return p_cl_dsa_sign(dgst, dlen, dsa); + + } + +static int cluster_labs_dsa_verify(const unsigned char *dgst, int dgst_len, + DSA_SIG *sig, DSA *dsa) + { + + if(cluster_labs_dso == NULL) + { + CLerr(CL_F_CLUSTER_LABS_DSA_VERIFY,CL_R_NOT_LOADED); + return 0; + } + + if(p_cl_dsa_verify == NULL) + { + CLerr(CL_F_CLUSTER_LABS_DSA_VERIFY,CL_R_FUNCTION_NOT_BINDED); + return 0; + } + + return p_cl_dsa_verify(dgst, dgst_len, sig, dsa); + + } + +static int cluster_labs_dsa_mod_exp(DSA *dsa, BIGNUM *rr, BIGNUM *a1, + BIGNUM *p1, BIGNUM *a2, BIGNUM *p2, BIGNUM *m, + BN_CTX *ctx, BN_MONT_CTX *in_mont) + { + BIGNUM t; + int status = 0; + + BN_init(&t); + /* let rr = a1 ^ p1 mod m */ + if (!cluster_labs_mod_exp(rr,a1,p1,m,ctx)) goto end; + /* let t = a2 ^ p2 mod m */ + if (!cluster_labs_mod_exp(&t,a2,p2,m,ctx)) goto end; + /* let rr = rr * t mod m */ + if (!BN_mod_mul(rr,rr,&t,m,ctx)) goto end; + status = 1; +end: + BN_free(&t); + + return(1); + + } + +static int cluster_labs_mod_exp_dsa(DSA *dsa, BIGNUM *r, BIGNUM *a, + const BIGNUM *p, const BIGNUM *m, BN_CTX *ctx, + BN_MONT_CTX *m_ctx) + { + return cluster_labs_mod_exp(r, a, p, m, ctx); + } + +/* This function is aliased to mod_exp (with the mont stuff dropped). */ +static int cluster_labs_mod_exp_mont(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, + const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx) + { + return cluster_labs_mod_exp(r, a, p, m, ctx); + } + + +/* This function is aliased to mod_exp (with the dh and mont dropped). */ +static int cluster_labs_mod_exp_dh(const DH *dh, BIGNUM *r, const BIGNUM *a, const BIGNUM *p, + const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx) + { + return cluster_labs_mod_exp(r, a, p, m, ctx); + } + + +static int cluster_labs_rsa_pub_enc(int flen, const unsigned char *from, + unsigned char *to, RSA *rsa, int padding) + { + + if(cluster_labs_dso == NULL) + { + CLerr(CL_F_CLUSTER_LABS_RSA_PUB_ENC,CL_R_NOT_LOADED); + return 0; + } + if(p_cl_rsa_priv_enc == NULL) + { + CLerr(CL_F_CLUSTER_LABS_RSA_PUB_ENC,CL_R_FUNCTION_NOT_BINDED); + return 0; + } + + return p_cl_rsa_pub_enc(flen, from, to, rsa, padding); + + } + +static int cluster_labs_rsa_pub_dec(int flen, const unsigned char *from, + unsigned char *to, RSA *rsa, int padding) + { + + if(cluster_labs_dso == NULL) + { + CLerr(CL_F_CLUSTER_LABS_RSA_PUB_DEC,CL_R_NOT_LOADED); + return 0; + } + if(p_cl_rsa_priv_enc == NULL) + { + CLerr(CL_F_CLUSTER_LABS_RSA_PUB_DEC,CL_R_FUNCTION_NOT_BINDED); + return 0; + } + + return p_cl_rsa_pub_dec(flen, from, to, rsa, padding); + + } + + +static int cluster_labs_rsa_priv_enc(int flen, const unsigned char *from, + unsigned char *to, RSA *rsa, int padding) + { + + if(cluster_labs_dso == NULL) + { + CLerr(CL_F_CLUSTER_LABS_RSA_PRIV_ENC,CL_R_NOT_LOADED); + return 0; + } + + if(p_cl_rsa_priv_enc == NULL) + { + CLerr(CL_F_CLUSTER_LABS_RSA_PRIV_ENC,CL_R_FUNCTION_NOT_BINDED); + return 0; + } + + return p_cl_rsa_priv_enc(flen, from, to, rsa, padding); + + } + +static int cluster_labs_rsa_priv_dec(int flen, const unsigned char *from, + unsigned char *to, RSA *rsa, int padding) + { + + if(cluster_labs_dso == NULL) + { + CLerr(CL_F_CLUSTER_LABS_RSA_PRIV_DEC,CL_R_NOT_LOADED); + return 0; + } + if(p_cl_rsa_priv_dec == NULL) + { + CLerr(CL_F_CLUSTER_LABS_RSA_PRIV_DEC,CL_R_FUNCTION_NOT_BINDED); + return 0; + } + + return p_cl_rsa_priv_dec(flen, from, to, rsa, padding); + + } + +/************************************************************************************ +* Symmetric algorithms +************************************************************************************/ +/* this will be come soon! */ + +/************************************************************************************ +* Random generator +************************************************************************************/ + +static int cluster_labs_rand_bytes(unsigned char *buf, int num){ + + if(cluster_labs_dso == NULL) + { + CLerr(CL_F_CLUSTER_LABS_RAND_BYTES,CL_R_NOT_LOADED); + return 0; + } + if(p_cl_mod_exp_crt == NULL) + { + CLerr(CL_F_CLUSTER_LABS_RAND_BYTES,CL_R_FUNCTION_NOT_BINDED); + return 0; + } + + return p_cl_rand_bytes(buf, num); + +} + + +/* 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) + { + fprintf(stderr, "bind_fn CLUSTER_LABS\n"); + if(id && (strcmp(id, engine_cluster_labs_id) != 0)) { + fprintf(stderr, "bind_fn return(0) first\n"); + return 0; + } + if(!bind_helper(e)) { + fprintf(stderr, "bind_fn return(1) first\n"); + return 0; + } + fprintf(stderr, "bind_fn return(1)\n"); + return 1; + } +IMPLEMENT_DYNAMIC_CHECK_FN() +IMPLEMENT_DYNAMIC_BIND_FN(bind_fn) +#endif /* ENGINE_DYNAMIC_SUPPORT */ + +#endif /* !NO_HW_CLUSTER_LABS */ +#endif /* !NO_HW */ + diff --git a/demos/engines/cluster_labs/hw_cluster_labs.ec b/demos/engines/cluster_labs/hw_cluster_labs.ec new file mode 100644 index 0000000000..1f64786542 --- /dev/null +++ b/demos/engines/cluster_labs/hw_cluster_labs.ec @@ -0,0 +1,8 @@ +# configuration file for util/mkerr.pl +# +# use like this: +# +# perl ../../../util/mkerr.pl -conf hw_cluster_labs.ec \ +# -nostatic -staticloader -write *.c + +L CL hw_cluster_labs_err.h hw_cluster_labs_err.c diff --git a/demos/engines/cluster_labs/hw_cluster_labs_err.c b/demos/engines/cluster_labs/hw_cluster_labs_err.c new file mode 100644 index 0000000000..a7fa4083b1 --- /dev/null +++ b/demos/engines/cluster_labs/hw_cluster_labs_err.c @@ -0,0 +1,151 @@ +/* hw_cluster_labs_err.c */ +/* ==================================================================== + * Copyright (c) 1999-2002 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 + * openssl-core@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). + * + */ + +/* NOTE: this file was auto generated by the mkerr.pl script: any changes + * made to it will be overwritten when the script next updates this file, + * only reason strings will be preserved. + */ + +#include +#include +#include "hw_cluster_labs_err.h" + +/* BEGIN ERROR CODES */ +#ifndef OPENSSL_NO_ERR +static ERR_STRING_DATA CL_str_functs[]= + { +{ERR_PACK(0,CL_F_CLUSTER_LABS_CTRL,0), "CLUSTER_LABS_CTRL"}, +{ERR_PACK(0,CL_F_CLUSTER_LABS_DSA_SIGN,0), "CLUSTER_LABS_DSA_SIGN"}, +{ERR_PACK(0,CL_F_CLUSTER_LABS_DSA_VERIFY,0), "CLUSTER_LABS_DSA_VERIFY"}, +{ERR_PACK(0,CL_F_CLUSTER_LABS_FINISH,0), "CLUSTER_LABS_FINISH"}, +{ERR_PACK(0,CL_F_CLUSTER_LABS_INIT,0), "CLUSTER_LABS_INIT"}, +{ERR_PACK(0,CL_F_CLUSTER_LABS_MOD_EXP,0), "CLUSTER_LABS_MOD_EXP"}, +{ERR_PACK(0,CL_F_CLUSTER_LABS_MOD_EXP_CRT,0), "CLUSTER_LABS_MOD_EXP_CRT"}, +{ERR_PACK(0,CL_F_CLUSTER_LABS_RAND_BYTES,0), "CLUSTER_LABS_RAND_BYTES"}, +{ERR_PACK(0,CL_F_CLUSTER_LABS_RSA_MOD_EXP,0), "CLUSTER_LABS_RSA_MOD_EXP"}, +{ERR_PACK(0,CL_F_CLUSTER_LABS_RSA_PRIV_DEC,0), "CLUSTER_LABS_RSA_PRIV_DEC"}, +{ERR_PACK(0,CL_F_CLUSTER_LABS_RSA_PRIV_ENC,0), "CLUSTER_LABS_RSA_PRIV_ENC"}, +{ERR_PACK(0,CL_F_CLUSTER_LABS_RSA_PUB_DEC,0), "CLUSTER_LABS_RSA_PUB_DEC"}, +{ERR_PACK(0,CL_F_CLUSTER_LABS_RSA_PUB_ENC,0), "CLUSTER_LABS_RSA_PUB_ENC"}, +{0,NULL} + }; + +static ERR_STRING_DATA CL_str_reasons[]= + { +{CL_R_ALREADY_LOADED ,"already loaded"}, +{CL_R_COMMAND_NOT_IMPLEMENTED ,"command not implemented"}, +{CL_R_DSO_FAILURE ,"dso failure"}, +{CL_R_FUNCTION_NOT_BINDED ,"function not binded"}, +{CL_R_INIT_FAILED ,"init failed"}, +{CL_R_NOT_LOADED ,"not loaded"}, +{0,NULL} + }; + +#endif + +#ifdef CL_LIB_NAME +static ERR_STRING_DATA CL_lib_name[]= + { +{0 ,CL_LIB_NAME}, +{0,NULL} + }; +#endif + + +static int CL_lib_error_code=0; +static int CL_error_init=1; + +static void ERR_load_CL_strings(void) + { + if (CL_lib_error_code == 0) + CL_lib_error_code=ERR_get_next_error_library(); + + if (CL_error_init) + { + CL_error_init=0; +#ifndef OPENSSL_NO_ERR + ERR_load_strings(CL_lib_error_code,CL_str_functs); + ERR_load_strings(CL_lib_error_code,CL_str_reasons); +#endif + +#ifdef CL_LIB_NAME + CL_lib_name->error = ERR_PACK(CL_lib_error_code,0,0); + ERR_load_strings(0,CL_lib_name); +#endif + } + } + +static void ERR_unload_CL_strings(void) + { + if (CL_error_init == 0) + { +#ifndef OPENSSL_NO_ERR + ERR_unload_strings(CL_lib_error_code,CL_str_functs); + ERR_unload_strings(CL_lib_error_code,CL_str_reasons); +#endif + +#ifdef CL_LIB_NAME + ERR_unload_strings(0,CL_lib_name); +#endif + CL_error_init=1; + } + } + +static void ERR_CL_error(int function, int reason, char *file, int line) + { + if (CL_lib_error_code == 0) + CL_lib_error_code=ERR_get_next_error_library(); + ERR_PUT_error(CL_lib_error_code,function,reason,file,line); + } diff --git a/demos/engines/cluster_labs/hw_cluster_labs_err.h b/demos/engines/cluster_labs/hw_cluster_labs_err.h new file mode 100644 index 0000000000..afc175b133 --- /dev/null +++ b/demos/engines/cluster_labs/hw_cluster_labs_err.h @@ -0,0 +1,95 @@ +/* ==================================================================== + * Copyright (c) 2001-2002 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 + * openssl-core@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). + * + */ + +#ifndef HEADER_CL_ERR_H +#define HEADER_CL_ERR_H + +/* BEGIN ERROR CODES */ +/* The following lines are auto generated by the script mkerr.pl. Any changes + * made after this point may be overwritten when the script is next run. + */ +static void ERR_load_CL_strings(void); +static void ERR_unload_CL_strings(void); +static void ERR_CL_error(int function, int reason, char *file, int line); +#define CLerr(f,r) ERR_CL_error((f),(r),__FILE__,__LINE__) + +/* Error codes for the CL functions. */ + +/* Function codes. */ +#define CL_F_CLUSTER_LABS_CTRL 100 +#define CL_F_CLUSTER_LABS_DSA_SIGN 101 +#define CL_F_CLUSTER_LABS_DSA_VERIFY 102 +#define CL_F_CLUSTER_LABS_FINISH 103 +#define CL_F_CLUSTER_LABS_INIT 104 +#define CL_F_CLUSTER_LABS_MOD_EXP 105 +#define CL_F_CLUSTER_LABS_MOD_EXP_CRT 106 +#define CL_F_CLUSTER_LABS_RAND_BYTES 107 +#define CL_F_CLUSTER_LABS_RSA_MOD_EXP 108 +#define CL_F_CLUSTER_LABS_RSA_PRIV_DEC 109 +#define CL_F_CLUSTER_LABS_RSA_PRIV_ENC 110 +#define CL_F_CLUSTER_LABS_RSA_PUB_DEC 111 +#define CL_F_CLUSTER_LABS_RSA_PUB_ENC 112 + +/* Reason codes. */ +#define CL_R_ALREADY_LOADED 100 +#define CL_R_COMMAND_NOT_IMPLEMENTED 101 +#define CL_R_DSO_FAILURE 102 +#define CL_R_FUNCTION_NOT_BINDED 103 +#define CL_R_INIT_FAILED 104 +#define CL_R_NOT_LOADED 105 + +#ifdef __cplusplus +} +#endif +#endif diff --git a/demos/engines/ibmca/Makefile b/demos/engines/ibmca/Makefile new file mode 100644 index 0000000000..72f3546359 --- /dev/null +++ b/demos/engines/ibmca/Makefile @@ -0,0 +1,114 @@ +LIBNAME= libibmca +SRC= hw_ibmca.c +OBJ= hw_ibmca.o +HEADER= hw_ibmca.h + +CC= gcc +PIC= -fPIC +CFLAGS= -g -I../../../include $(PIC) -DENGINE_DYNAMIC_SUPPORT -DFLAT_INC +AR= ar r +RANLIB= ranlib + +LIB= $(LIBNAME).a +SHLIB= $(LIBNAME).so + +all: + @echo 'Please choose a system to build on:' + @echo '' + @echo 'tru64: Tru64 Unix, Digital Unix, Digital OSF/1' + @echo 'solaris: Solaris' + @echo 'irix: IRIX' + @echo 'hpux32: 32-bit HP/UX' + @echo 'hpux64: 64-bit HP/UX' + @echo 'aix: AIX' + @echo 'gnu: Generic GNU-based system (gcc and GNU ld)' + @echo '' + +FORCE.update: +update: FORCE.update + perl ../../../util/mkerr.pl -conf hw_ibmca.ec \ + -nostatic -staticloader -write hw_ibmca.c + +gnu: $(SHLIB).gnu +tru64: $(SHLIB).tru64 +solaris: $(SHLIB).solaris +irix: $(SHLIB).irix +hpux32: $(SHLIB).hpux32 +hpux64: $(SHLIB).hpux64 +aix: $(SHLIB).aix + +$(LIB): $(OBJ) + $(AR) $(LIB) $(OBJ) + - $(RANLIB) $(LIB) + +LINK_SO= \ + ld -r -o $(LIBNAME).o $$ALLSYMSFLAGS $(LIB) && \ + (nm -Pg $(LIBNAME).o | grep ' [BDT] ' | cut -f1 -d' ' > $(LIBNAME).exp; \ + $$SHAREDCMD $$SHAREDFLAGS -o $(SHLIB) $(LIBNAME).o -L ../../.. -lcrypto -lc) + +$(SHLIB).gnu: $(LIB) + ALLSYMSFLAGS='--whole-archive' \ + SHAREDFLAGS='-shared -Wl,-soname=$(SHLIB)' \ + SHAREDCMD='$(CC)'; \ + $(LINK_SO) + touch $(SHLIB).gnu +$(SHLIB).tru64: $(LIB) + ALLSYMSFLAGS='-all' \ + SHAREDFLAGS='-shared' \ + SHAREDCMD='$(CC)'; \ + $(LINK_SO) + touch $(SHLIB).tru64 +$(SHLIB).solaris: $(LIB) + ALLSYMSFLAGS='-z allextract' \ + SHAREDFLAGS='-G -h $(SHLIB)' \ + SHAREDCMD='$(CC)'; \ + $(LINK_SO) + touch $(SHLIB).solaris +$(SHLIB).irix: $(LIB) + ALLSYMSFLAGS='-all' \ + SHAREDFLAGS='-shared -Wl,-soname,$(SHLIB)' \ + SHAREDCMD='$(CC)'; \ + $(LINK_SO) + touch $(SHLIB).irix +$(SHLIB).hpux32: $(LIB) + ALLSYMSFLAGS='-Fl' \ + SHAREDFLAGS='+vnocompatwarnings -b -z +s +h $(SHLIB)' \ + SHAREDCMD='/usr/ccs/bin/ld'; \ + $(LINK_SO) + touch $(SHLIB).hpux32 +$(SHLIB).hpux64: $(LIB) + ALLSYMSFLAGS='+forceload' \ + SHAREDFLAGS='-b -z +h $(SHLIB)' \ + SHAREDCMD='/usr/ccs/bin/ld'; \ + $(LINK_SO) + touch $(SHLIB).hpux64 +$(SHLIB).aix: $(LIB) + ALLSYMSFLAGS='-bnogc' \ + SHAREDFLAGS='-G -bE:$(LIBNAME).exp -bM:SRE' \ + SHAREDCMD='$(CC)'; \ + $(LINK_SO) + touch $(SHLIB).aix + +depend: + sed -e '/^# DO NOT DELETE.*/,$$d' < Makefile > Makefile.tmp + echo '# DO NOT DELETE THIS LINE -- make depend depends on it.' >> Makefile.tmp + gcc -M $(CFLAGS) $(SRC) >> Makefile.tmp + perl ../../../util/clean-depend.pl < Makefile.tmp > Makefile.new + rm -f Makefile.tmp Makefile + mv Makefile.new Makefile + +# DO NOT DELETE THIS LINE -- make depend depends on it. + +rsaref.o: ../../../include/openssl/asn1.h ../../../include/openssl/bio.h +rsaref.o: ../../../include/openssl/bn.h ../../../include/openssl/crypto.h +rsaref.o: ../../../include/openssl/dh.h ../../../include/openssl/dsa.h +rsaref.o: ../../../include/openssl/e_os2.h ../../../include/openssl/engine.h +rsaref.o: ../../../include/openssl/err.h ../../../include/openssl/lhash.h +rsaref.o: ../../../include/openssl/opensslconf.h +rsaref.o: ../../../include/openssl/opensslv.h +rsaref.o: ../../../include/openssl/ossl_typ.h ../../../include/openssl/rand.h +rsaref.o: ../../../include/openssl/rsa.h ../../../include/openssl/safestack.h +rsaref.o: ../../../include/openssl/stack.h ../../../include/openssl/symhacks.h +rsaref.o: ../../../include/openssl/ui.h rsaref.c rsaref_err.c rsaref_err.h +rsaref.o: source/des.h source/global.h source/md2.h source/md5.h source/rsa.h +rsaref.o: source/rsaref.h diff --git a/demos/engines/ibmca/hw_ibmca.c b/demos/engines/ibmca/hw_ibmca.c new file mode 100644 index 0000000000..881b16a7cb --- /dev/null +++ b/demos/engines/ibmca/hw_ibmca.c @@ -0,0 +1,917 @@ +/* crypto/engine/hw_ibmca.c */ +/* Written by Geoff Thorpe (geoff@geoffthorpe.net) for the OpenSSL + * project 2000. + */ +/* ==================================================================== + * Copyright (c) 1999 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). + * + */ + +/* (C) COPYRIGHT International Business Machines Corp. 2001 */ + +#include +#include +#include +#include + +#ifndef OPENSSL_NO_HW +#ifndef OPENSSL_NO_HW_IBMCA + +#ifdef FLAT_INC +#include "ica_openssl_api.h" +#else +#include "vendor_defns/ica_openssl_api.h" +#endif + +#define IBMCA_LIB_NAME "ibmca engine" +#include "hw_ibmca_err.c" + +static int ibmca_destroy(ENGINE *e); +static int ibmca_init(ENGINE *e); +static int ibmca_finish(ENGINE *e); +static int ibmca_ctrl(ENGINE *e, int cmd, long i, void *p, void (*f)()); + +static const char *IBMCA_F1 = "icaOpenAdapter"; +static const char *IBMCA_F2 = "icaCloseAdapter"; +static const char *IBMCA_F3 = "icaRsaModExpo"; +static const char *IBMCA_F4 = "icaRandomNumberGenerate"; +static const char *IBMCA_F5 = "icaRsaCrt"; + +ICA_ADAPTER_HANDLE handle=0; + +/* BIGNUM stuff */ +static int ibmca_mod_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, + const BIGNUM *m, BN_CTX *ctx); + +static int ibmca_mod_exp_crt(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, + const BIGNUM *q, const BIGNUM *dmp1, const BIGNUM *dmq1, + const BIGNUM *iqmp, BN_CTX *ctx); + +#ifndef OPENSSL_NO_RSA +/* RSA stuff */ +static int ibmca_rsa_mod_exp(BIGNUM *r0, const BIGNUM *I, RSA *rsa); +#endif + +/* This function is aliased to mod_exp (with the mont stuff dropped). */ +static int ibmca_mod_exp_mont(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, + const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx); + +#ifndef OPENSSL_NO_DSA +/* DSA stuff */ +static int ibmca_dsa_mod_exp(DSA *dsa, BIGNUM *rr, BIGNUM *a1, + BIGNUM *p1, BIGNUM *a2, BIGNUM *p2, BIGNUM *m, + BN_CTX *ctx, BN_MONT_CTX *in_mont); +static int ibmca_mod_exp_dsa(DSA *dsa, BIGNUM *r, BIGNUM *a, + const BIGNUM *p, const BIGNUM *m, BN_CTX *ctx, + BN_MONT_CTX *m_ctx); +#endif + +#ifndef OPENSSL_NO_DH +/* DH stuff */ +/* This function is alised to mod_exp (with the DH and mont dropped). */ +static int ibmca_mod_exp_dh(const DH *dh, BIGNUM *r, + const BIGNUM *a, const BIGNUM *p, + const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx); +#endif + +/* RAND stuff */ +static int ibmca_rand_bytes(unsigned char *buf, int num); +static int ibmca_rand_status(void); + + +/* WJH - check for more commands, like in nuron */ + +/* The definitions for control commands specific to this engine */ +#define IBMCA_CMD_SO_PATH ENGINE_CMD_BASE +static const ENGINE_CMD_DEFN ibmca_cmd_defns[] = { + {IBMCA_CMD_SO_PATH, + "SO_PATH", + "Specifies the path to the 'atasi' shared library", + ENGINE_CMD_FLAG_STRING}, + {0, NULL, NULL, 0} + }; + +#ifndef OPENSSL_NO_RSA +/* Our internal RSA_METHOD that we provide pointers to */ +static RSA_METHOD ibmca_rsa = + { + "Ibmca RSA method", + NULL, + NULL, + NULL, + NULL, + ibmca_rsa_mod_exp, + ibmca_mod_exp_mont, + NULL, + NULL, + 0, + NULL, + NULL, + NULL + }; +#endif + +#ifndef OPENSSL_NO_DSA +/* Our internal DSA_METHOD that we provide pointers to */ +static DSA_METHOD ibmca_dsa = + { + "Ibmca DSA method", + NULL, /* dsa_do_sign */ + NULL, /* dsa_sign_setup */ + NULL, /* dsa_do_verify */ + ibmca_dsa_mod_exp, /* dsa_mod_exp */ + ibmca_mod_exp_dsa, /* bn_mod_exp */ + NULL, /* init */ + NULL, /* finish */ + 0, /* flags */ + NULL /* app_data */ + }; +#endif + +#ifndef OPENSSL_NO_DH +/* Our internal DH_METHOD that we provide pointers to */ +static DH_METHOD ibmca_dh = + { + "Ibmca DH method", + NULL, + NULL, + ibmca_mod_exp_dh, + NULL, + NULL, + 0, + NULL + }; +#endif + +static RAND_METHOD ibmca_rand = + { + /* "IBMCA RAND method", */ + NULL, + ibmca_rand_bytes, + NULL, + NULL, + ibmca_rand_bytes, + ibmca_rand_status, + }; + +/* Constants used when creating the ENGINE */ +static const char *engine_ibmca_id = "ibmca"; +static const char *engine_ibmca_name = "Ibmca hardware engine support"; + +/* This internal function is used by ENGINE_ibmca() and possibly by the + * "dynamic" ENGINE support too */ +static int bind_helper(ENGINE *e) + { +#ifndef OPENSSL_NO_RSA + const RSA_METHOD *meth1; +#endif +#ifndef OPENSSL_NO_DSA + const DSA_METHOD *meth2; +#endif +#ifndef OPENSSL_NO_DH + const DH_METHOD *meth3; +#endif + if(!ENGINE_set_id(e, engine_ibmca_id) || + !ENGINE_set_name(e, engine_ibmca_name) || +#ifndef OPENSSL_NO_RSA + !ENGINE_set_RSA(e, &ibmca_rsa) || +#endif +#ifndef OPENSSL_NO_DSA + !ENGINE_set_DSA(e, &ibmca_dsa) || +#endif +#ifndef OPENSSL_NO_DH + !ENGINE_set_DH(e, &ibmca_dh) || +#endif + !ENGINE_set_RAND(e, &ibmca_rand) || + !ENGINE_set_destroy_function(e, ibmca_destroy) || + !ENGINE_set_init_function(e, ibmca_init) || + !ENGINE_set_finish_function(e, ibmca_finish) || + !ENGINE_set_ctrl_function(e, ibmca_ctrl) || + !ENGINE_set_cmd_defns(e, ibmca_cmd_defns)) + return 0; + +#ifndef OPENSSL_NO_RSA + /* We know that the "PKCS1_SSLeay()" functions hook properly + * to the ibmca-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! */ + meth1 = RSA_PKCS1_SSLeay(); + ibmca_rsa.rsa_pub_enc = meth1->rsa_pub_enc; + ibmca_rsa.rsa_pub_dec = meth1->rsa_pub_dec; + ibmca_rsa.rsa_priv_enc = meth1->rsa_priv_enc; + ibmca_rsa.rsa_priv_dec = meth1->rsa_priv_dec; +#endif + +#ifndef OPENSSL_NO_DSA + /* Use the DSA_OpenSSL() method and just hook the mod_exp-ish + * bits. */ + meth2 = DSA_OpenSSL(); + ibmca_dsa.dsa_do_sign = meth2->dsa_do_sign; + ibmca_dsa.dsa_sign_setup = meth2->dsa_sign_setup; + ibmca_dsa.dsa_do_verify = meth2->dsa_do_verify; +#endif + +#ifndef OPENSSL_NO_DH + /* Much the same for Diffie-Hellman */ + meth3 = DH_OpenSSL(); + ibmca_dh.generate_key = meth3->generate_key; + ibmca_dh.compute_key = meth3->compute_key; +#endif + + /* Ensure the ibmca error handling is set up */ + ERR_load_IBMCA_strings(); + return 1; + } + +static ENGINE *engine_ibmca(void) + { + ENGINE *ret = ENGINE_new(); + if(!ret) + return NULL; + if(!bind_helper(ret)) + { + ENGINE_free(ret); + return NULL; + } + return ret; + } + +void ENGINE_load_ibmca(void) + { + /* Copied from eng_[openssl|dyn].c */ + ENGINE *toadd = engine_ibmca(); + if(!toadd) return; + ENGINE_add(toadd); + ENGINE_free(toadd); + ERR_clear_error(); + } + +/* Destructor (complements the "ENGINE_ibmca()" constructor) */ +static int ibmca_destroy(ENGINE *e) + { + /* Unload the ibmca error strings so any error state including our + * functs or reasons won't lead to a segfault (they simply get displayed + * without corresponding string data because none will be found). */ + ERR_unload_IBMCA_strings(); + return 1; + } + + +/* This is a process-global DSO handle used for loading and unloading + * the Ibmca 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 *ibmca_dso = NULL; + +/* These are the function pointers that are (un)set when the library has + * successfully (un)loaded. */ + +static unsigned int (ICA_CALL *p_icaOpenAdapter)(); +static unsigned int (ICA_CALL *p_icaCloseAdapter)(); +static unsigned int (ICA_CALL *p_icaRsaModExpo)(); +static unsigned int (ICA_CALL *p_icaRandomNumberGenerate)(); +static unsigned int (ICA_CALL *p_icaRsaCrt)(); + +/* utility function to obtain a context */ +static int get_context(ICA_ADAPTER_HANDLE *p_handle) + { + unsigned int status=0; + + status = p_icaOpenAdapter(0, p_handle); + if(status != 0) + return 0; + return 1; + } + +/* similarly to release one. */ +static void release_context(ICA_ADAPTER_HANDLE handle) + { + p_icaCloseAdapter(handle); + } + +/* (de)initialisation functions. */ +static int ibmca_init(ENGINE *e) + { + + void (*p1)(); + void (*p2)(); + void (*p3)(); + void (*p4)(); + void (*p5)(); + + if(ibmca_dso != NULL) + { + IBMCAerr(IBMCA_F_IBMCA_INIT,IBMCA_R_ALREADY_LOADED); + goto err; + } + /* Attempt to load libatasi.so/atasi.dll/whatever. Needs to be + * changed unfortunately because the Ibmca drivers don't have + * standard library names that can be platform-translated well. */ + /* TODO: Work out how to actually map to the names the Ibmca + * drivers really use - for now a symbollic link needs to be + * created on the host system from libatasi.so to atasi.so on + * unix variants. */ + + /* WJH XXX check name translation */ + + ibmca_dso = DSO_load(NULL, IBMCA_LIBNAME, NULL, + /* DSO_FLAG_NAME_TRANSLATION */ 0); + if(ibmca_dso == NULL) + { + IBMCAerr(IBMCA_F_IBMCA_INIT,IBMCA_R_DSO_FAILURE); + goto err; + } + + if(!(p1 = DSO_bind_func( + ibmca_dso, IBMCA_F1)) || + !(p2 = DSO_bind_func( + ibmca_dso, IBMCA_F2)) || + !(p3 = DSO_bind_func( + ibmca_dso, IBMCA_F3)) || + !(p4 = DSO_bind_func( + ibmca_dso, IBMCA_F4)) || + !(p5 = DSO_bind_func( + ibmca_dso, IBMCA_F5))) + { + IBMCAerr(IBMCA_F_IBMCA_INIT,IBMCA_R_DSO_FAILURE); + goto err; + } + + /* Copy the pointers */ + + p_icaOpenAdapter = (unsigned int (ICA_CALL *)())p1; + p_icaCloseAdapter = (unsigned int (ICA_CALL *)())p2; + p_icaRsaModExpo = (unsigned int (ICA_CALL *)())p3; + p_icaRandomNumberGenerate = (unsigned int (ICA_CALL *)())p4; + p_icaRsaCrt = (unsigned int (ICA_CALL *)())p5; + + if(!get_context(&handle)) + { + IBMCAerr(IBMCA_F_IBMCA_INIT,IBMCA_R_UNIT_FAILURE); + goto err; + } + + return 1; + err: + if(ibmca_dso) + DSO_free(ibmca_dso); + + p_icaOpenAdapter = NULL; + p_icaCloseAdapter = NULL; + p_icaRsaModExpo = NULL; + p_icaRandomNumberGenerate = NULL; + + return 0; + } + +static int ibmca_finish(ENGINE *e) + { + if(ibmca_dso == NULL) + { + IBMCAerr(IBMCA_F_IBMCA_FINISH,IBMCA_R_NOT_LOADED); + return 0; + } + release_context(handle); + if(!DSO_free(ibmca_dso)) + { + IBMCAerr(IBMCA_F_IBMCA_FINISH,IBMCA_R_DSO_FAILURE); + return 0; + } + ibmca_dso = NULL; + + return 1; + } + +static int ibmca_ctrl(ENGINE *e, int cmd, long i, void *p, void (*f)()) + { + int initialised = ((ibmca_dso == NULL) ? 0 : 1); + switch(cmd) + { + case IBMCA_CMD_SO_PATH: + if(p == NULL) + { + IBMCAerr(IBMCA_F_IBMCA_CTRL,ERR_R_PASSED_NULL_PARAMETER); + return 0; + } + if(initialised) + { + IBMCAerr(IBMCA_F_IBMCA_CTRL,IBMCA_R_ALREADY_LOADED); + return 0; + } + IBMCA_LIBNAME = (const char *)p; + return 1; + default: + break; + } + IBMCAerr(IBMCA_F_IBMCA_CTRL,IBMCA_R_CTRL_COMMAND_NOT_IMPLEMENTED); + return 0; + } + + +static int ibmca_mod_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, + const BIGNUM *m, BN_CTX *ctx) + { + /* I need somewhere to store temporary serialised values for + * use with the Ibmca API calls. A neat cheat - I'll use + * BIGNUMs from the BN_CTX but access their arrays directly as + * byte arrays . This way I don't have to clean anything + * up. */ + + BIGNUM *argument=NULL; + BIGNUM *result=NULL; + BIGNUM *key=NULL; + int to_return; + int inLen, outLen, tmpLen; + + + ICA_KEY_RSA_MODEXPO *publKey=NULL; + unsigned int rc; + + to_return = 0; /* expect failure */ + + if(!ibmca_dso) + { + IBMCAerr(IBMCA_F_IBMCA_MOD_EXP,IBMCA_R_NOT_LOADED); + goto err; + } + /* Prepare the params */ + BN_CTX_start(ctx); + argument = BN_CTX_get(ctx); + result = BN_CTX_get(ctx); + key = BN_CTX_get(ctx); + + if( !argument || !result || !key) + { + IBMCAerr(IBMCA_F_IBMCA_MOD_EXP,IBMCA_R_BN_CTX_FULL); + goto err; + } + + + if(!bn_wexpand(argument, m->top) || !bn_wexpand(result, m->top) || + !bn_wexpand(key, sizeof(*publKey)/BN_BYTES)) + + { + IBMCAerr(IBMCA_F_IBMCA_MOD_EXP,IBMCA_R_BN_EXPAND_FAIL); + goto err; + } + + publKey = (ICA_KEY_RSA_MODEXPO *)key->d; + + if (publKey == NULL) + { + goto err; + } + memset(publKey, 0, sizeof(ICA_KEY_RSA_MODEXPO)); + + publKey->keyType = CORRECT_ENDIANNESS(ME_KEY_TYPE); + publKey->keyLength = CORRECT_ENDIANNESS(sizeof(ICA_KEY_RSA_MODEXPO)); + publKey->expOffset = (char *) publKey->keyRecord - (char *) publKey; + + /* A quirk of the card: the exponent length has to be the same + as the modulus (key) length */ + + outLen = BN_num_bytes(m); + +/* check for modulus length SAB*/ + if (outLen > 256 ) { + IBMCAerr(IBMCA_F_IBMCA_MOD_EXP,IBMCA_R_MEXP_LENGTH_TO_LARGE); + goto err; + } +/* check for modulus length SAB*/ + + + publKey->expLength = publKey->nLength = outLen; +/* SAB Check for underflow condition + the size of the exponent is less than the size of the parameter + then we have a big problem and will underflow the keyRecord + buffer. Bad stuff could happen then +*/ +if (outLen < BN_num_bytes(p)){ + IBMCAerr(IBMCA_F_IBMCA_MOD_EXP,IBMCA_R_UNDERFLOW_KEYRECORD); + goto err; +} +/* SAB End check for underflow */ + + + BN_bn2bin(p, &publKey->keyRecord[publKey->expLength - + BN_num_bytes(p)]); + BN_bn2bin(m, &publKey->keyRecord[publKey->expLength]); + + + + publKey->modulusBitLength = CORRECT_ENDIANNESS(publKey->nLength * 8); + publKey->nOffset = CORRECT_ENDIANNESS(publKey->expOffset + + publKey->expLength); + + publKey->expOffset = CORRECT_ENDIANNESS((char *) publKey->keyRecord - + (char *) publKey); + + tmpLen = outLen; + publKey->expLength = publKey->nLength = CORRECT_ENDIANNESS(tmpLen); + + /* Prepare the argument */ + + memset(argument->d, 0, outLen); + BN_bn2bin(a, (unsigned char *)argument->d + outLen - + BN_num_bytes(a)); + + inLen = outLen; + + /* Perform the operation */ + + if( (rc = p_icaRsaModExpo(handle, inLen,(unsigned char *)argument->d, + publKey, &outLen, (unsigned char *)result->d)) + !=0 ) + + { + printf("rc = %d\n", rc); + IBMCAerr(IBMCA_F_IBMCA_MOD_EXP,IBMCA_R_REQUEST_FAILED); + goto err; + } + + + /* Convert the response */ + BN_bin2bn((unsigned char *)result->d, outLen, r); + to_return = 1; + err: + BN_CTX_end(ctx); + return to_return; + } + +#ifndef OPENSSL_NO_RSA +static int ibmca_rsa_mod_exp(BIGNUM *r0, const BIGNUM *I, RSA *rsa) + { + BN_CTX *ctx; + int to_return = 0; + + if((ctx = BN_CTX_new()) == NULL) + goto err; + if(!rsa->p || !rsa->q || !rsa->dmp1 || !rsa->dmq1 || !rsa->iqmp) + { + if(!rsa->d || !rsa->n) + { + IBMCAerr(IBMCA_F_IBMCA_RSA_MOD_EXP, + IBMCA_R_MISSING_KEY_COMPONENTS); + goto err; + } + to_return = ibmca_mod_exp(r0, I, rsa->d, rsa->n, ctx); + } + else + { + to_return = ibmca_mod_exp_crt(r0, I, rsa->p, rsa->q, rsa->dmp1, + rsa->dmq1, rsa->iqmp, ctx); + } + err: + if(ctx) + BN_CTX_free(ctx); + return to_return; + } +#endif + +/* Ein kleines chinesisches "Restessen" */ +static int ibmca_mod_exp_crt(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, + const BIGNUM *q, const BIGNUM *dmp1, + const BIGNUM *dmq1, const BIGNUM *iqmp, BN_CTX *ctx) + { + + BIGNUM *argument = NULL; + BIGNUM *result = NULL; + BIGNUM *key = NULL; + + int to_return = 0; /* expect failure */ + + char *pkey=NULL; + ICA_KEY_RSA_CRT *privKey=NULL; + int inLen, outLen; + + int rc; + unsigned int offset, pSize, qSize; +/* SAB New variables */ + unsigned int keyRecordSize; + unsigned int pbytes = BN_num_bytes(p); + unsigned int qbytes = BN_num_bytes(q); + unsigned int dmp1bytes = BN_num_bytes(dmp1); + unsigned int dmq1bytes = BN_num_bytes(dmq1); + unsigned int iqmpbytes = BN_num_bytes(iqmp); + + /* Prepare the params */ + + BN_CTX_start(ctx); + argument = BN_CTX_get(ctx); + result = BN_CTX_get(ctx); + key = BN_CTX_get(ctx); + + if(!argument || !result || !key) + { + IBMCAerr(IBMCA_F_IBMCA_MOD_EXP_CRT,IBMCA_R_BN_CTX_FULL); + goto err; + } + + if(!bn_wexpand(argument, p->top + q->top) || + !bn_wexpand(result, p->top + q->top) || + !bn_wexpand(key, sizeof(*privKey)/BN_BYTES )) + { + IBMCAerr(IBMCA_F_IBMCA_MOD_EXP_CRT,IBMCA_R_BN_EXPAND_FAIL); + goto err; + } + + + privKey = (ICA_KEY_RSA_CRT *)key->d; +/* SAB Add check for total size in bytes of the parms does not exceed + the buffer space we have + do this first +*/ + keyRecordSize = pbytes+qbytes+dmp1bytes+dmq1bytes+iqmpbytes; + if ( keyRecordSize > sizeof(privKey->keyRecord )) { + IBMCAerr(IBMCA_F_IBMCA_MOD_EXP_CRT,IBMCA_R_OPERANDS_TO_LARGE); + goto err; + } + + if ( (qbytes + dmq1bytes) > 256 ){ + IBMCAerr(IBMCA_F_IBMCA_MOD_EXP_CRT,IBMCA_R_OPERANDS_TO_LARGE); + goto err; + } + + if ( pbytes + dmp1bytes > 256 ) { + IBMCAerr(IBMCA_F_IBMCA_MOD_EXP_CRT,IBMCA_R_OPERANDS_TO_LARGE); + goto err; + } + +/* end SAB additions */ + + memset(privKey, 0, sizeof(ICA_KEY_RSA_CRT)); + privKey->keyType = CORRECT_ENDIANNESS(CRT_KEY_TYPE); + privKey->keyLength = CORRECT_ENDIANNESS(sizeof(ICA_KEY_RSA_CRT)); + privKey->modulusBitLength = + CORRECT_ENDIANNESS(BN_num_bytes(q) * 2 * 8); + + /* + * p,dp & qInv are 1 QWORD Larger + */ + privKey->pLength = CORRECT_ENDIANNESS(BN_num_bytes(p)+8); + privKey->qLength = CORRECT_ENDIANNESS(BN_num_bytes(q)); + privKey->dpLength = CORRECT_ENDIANNESS(BN_num_bytes(dmp1)+8); + privKey->dqLength = CORRECT_ENDIANNESS(BN_num_bytes(dmq1)); + privKey->qInvLength = CORRECT_ENDIANNESS(BN_num_bytes(iqmp)+8); + + offset = (char *) privKey->keyRecord + - (char *) privKey; + + qSize = BN_num_bytes(q); + pSize = qSize + 8; /* 1 QWORD larger */ + + +/* SAB probably aittle redundant, but we'll verify that each of the + components which make up a key record sent ot the card does not exceed + the space that is allocated for it. this handles the case where even if + the total length does not exceed keyrecord zied, if the operands are funny sized +they could cause potential side affects on either the card or the result */ + + if ( (pbytes > pSize) || (dmp1bytes > pSize) || + (iqmpbytes > pSize) || ( qbytes >qSize) || + (dmq1bytes > qSize) ) { + IBMCAerr(IBMCA_F_IBMCA_MOD_EXP_CRT, IBMCA_R_OPERANDS_TO_LARGE); + goto err; + + } + + + privKey->dpOffset = CORRECT_ENDIANNESS(offset); + + offset += pSize; + privKey->dqOffset = CORRECT_ENDIANNESS(offset); + + offset += qSize; + privKey->pOffset = CORRECT_ENDIANNESS(offset); + + offset += pSize; + privKey->qOffset = CORRECT_ENDIANNESS(offset); + + offset += qSize; + privKey->qInvOffset = CORRECT_ENDIANNESS(offset); + + pkey = (char *) privKey->keyRecord; + + +/* SAB first check that we don;t under flow the buffer */ + if ( pSize < pbytes ) { + IBMCAerr(IBMCA_F_IBMCA_MOD_EXP_CRT, IBMCA_R_UNDERFLOW_CONDITION); + goto err; + } + + /* pkey += pSize - BN_num_bytes(p); WROING this should be dmp1) */ + pkey += pSize - BN_num_bytes(dmp1); + BN_bn2bin(dmp1, pkey); + pkey += BN_num_bytes(dmp1); /* move the pointer */ + + BN_bn2bin(dmq1, pkey); /* Copy over dmq1 */ + + pkey += qSize; /* move pointer */ + pkey += pSize - BN_num_bytes(p); /* set up for zero padding of next field */ + + BN_bn2bin(p, pkey); + pkey += BN_num_bytes(p); /* increment pointer by number of bytes moved */ + + BN_bn2bin(q, pkey); + pkey += qSize ; /* move the pointer */ + pkey += pSize - BN_num_bytes(iqmp); /* Adjust for padding */ + BN_bn2bin(iqmp, pkey); + + /* Prepare the argument and response */ + + outLen = CORRECT_ENDIANNESS(privKey->qLength) * 2; /* Correct endianess is used + because the fields were converted above */ + + if (outLen > 256) { + IBMCAerr(IBMCA_F_IBMCA_MOD_EXP_CRT,IBMCA_R_OUTLEN_TO_LARGE); + goto err; + } + + /* SAB check for underflow here on the argeument */ + if ( outLen < BN_num_bytes(a)) { + IBMCAerr(IBMCA_F_IBMCA_MOD_EXP_CRT,IBMCA_R_UNDERFLOW_CONDITION); + goto err; + } + + BN_bn2bin(a, (unsigned char *)argument->d + outLen - + BN_num_bytes(a)); + inLen = outLen; + + memset(result->d, 0, outLen); + + /* Perform the operation */ + + if ( (rc = p_icaRsaCrt(handle, inLen, (unsigned char *)argument->d, + privKey, &outLen, (unsigned char *)result->d)) != 0) + { + printf("rc = %d\n", rc); + IBMCAerr(IBMCA_F_IBMCA_MOD_EXP_CRT,IBMCA_R_REQUEST_FAILED); + goto err; + } + + /* Convert the response */ + + BN_bin2bn((unsigned char *)result->d, outLen, r); + to_return = 1; + + err: + BN_CTX_end(ctx); + return to_return; + + } + +#ifndef OPENSSL_NO_DSA +/* This code was liberated and adapted from the commented-out code in + * dsa_ossl.c. Because of the unoptimised form of the Ibmca acceleration + * (it doesn't have a CRT form for RSA), this function means that an + * Ibmca system running with a DSA server certificate can handshake + * around 5 or 6 times faster/more than an equivalent system running with + * RSA. Just check out the "signs" statistics from the RSA and DSA parts + * of "openssl speed -engine ibmca dsa1024 rsa1024". */ +static int ibmca_dsa_mod_exp(DSA *dsa, BIGNUM *rr, BIGNUM *a1, + BIGNUM *p1, BIGNUM *a2, BIGNUM *p2, BIGNUM *m, + BN_CTX *ctx, BN_MONT_CTX *in_mont) + { + BIGNUM t; + int to_return = 0; + + BN_init(&t); + /* let rr = a1 ^ p1 mod m */ + if (!ibmca_mod_exp(rr,a1,p1,m,ctx)) goto end; + /* let t = a2 ^ p2 mod m */ + if (!ibmca_mod_exp(&t,a2,p2,m,ctx)) goto end; + /* let rr = rr * t mod m */ + if (!BN_mod_mul(rr,rr,&t,m,ctx)) goto end; + to_return = 1; + end: + BN_free(&t); + return to_return; + } + + +static int ibmca_mod_exp_dsa(DSA *dsa, BIGNUM *r, BIGNUM *a, + const BIGNUM *p, const BIGNUM *m, BN_CTX *ctx, + BN_MONT_CTX *m_ctx) + { + return ibmca_mod_exp(r, a, p, m, ctx); + } +#endif + +/* This function is aliased to mod_exp (with the mont stuff dropped). */ +static int ibmca_mod_exp_mont(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, + const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx) + { + return ibmca_mod_exp(r, a, p, m, ctx); + } + +#ifndef OPENSSL_NO_DH +/* This function is aliased to mod_exp (with the dh and mont dropped). */ +static int ibmca_mod_exp_dh(DH const *dh, BIGNUM *r, + const BIGNUM *a, const BIGNUM *p, + const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx) + { + return ibmca_mod_exp(r, a, p, m, ctx); + } +#endif + +/* Random bytes are good */ +static int ibmca_rand_bytes(unsigned char *buf, int num) + { + int to_return = 0; /* assume failure */ + unsigned int ret; + + + if(handle == 0) + { + IBMCAerr(IBMCA_F_IBMCA_RAND_BYTES,IBMCA_R_NOT_INITIALISED); + goto err; + } + + ret = p_icaRandomNumberGenerate(handle, num, buf); + if (ret < 0) + { + IBMCAerr(IBMCA_F_IBMCA_RAND_BYTES,IBMCA_R_REQUEST_FAILED); + goto err; + } + to_return = 1; + err: + return to_return; + } + +static int ibmca_rand_status(void) + { + 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_ibmca_id) != 0)) /* WJH XXX */ + return 0; + if(!bind_helper(e)) + return 0; + return 1; + } +IMPLEMENT_DYNAMIC_CHECK_FN() +IMPLEMENT_DYNAMIC_BIND_FN(bind_fn) +#endif /* ENGINE_DYNAMIC_SUPPORT */ + + +#endif /* !OPENSSL_NO_HW_IBMCA */ +#endif /* !OPENSSL_NO_HW */ diff --git a/demos/engines/ibmca/hw_ibmca.ec b/demos/engines/ibmca/hw_ibmca.ec new file mode 100644 index 0000000000..f68646d237 --- /dev/null +++ b/demos/engines/ibmca/hw_ibmca.ec @@ -0,0 +1,8 @@ +# configuration file for util/mkerr.pl +# +# use like this: +# +# perl ../../../util/mkerr.pl -conf hw_ibmca.ec \ +# -nostatic -staticloader -write *.c + +L IBMCA hw_ibmca_err.h hw_ibmca_err.c diff --git a/demos/engines/ibmca/hw_ibmca_err.c b/demos/engines/ibmca/hw_ibmca_err.c new file mode 100644 index 0000000000..c4053f6d30 --- /dev/null +++ b/demos/engines/ibmca/hw_ibmca_err.c @@ -0,0 +1,154 @@ +/* hw_ibmca_err.c */ +/* ==================================================================== + * Copyright (c) 1999-2002 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 + * openssl-core@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). + * + */ + +/* NOTE: this file was auto generated by the mkerr.pl script: any changes + * made to it will be overwritten when the script next updates this file, + * only reason strings will be preserved. + */ + +#include +#include +#include "hw_ibmca_err.h" + +/* BEGIN ERROR CODES */ +#ifndef OPENSSL_NO_ERR +static ERR_STRING_DATA IBMCA_str_functs[]= + { +{ERR_PACK(0,IBMCA_F_IBMCA_CTRL,0), "IBMCA_CTRL"}, +{ERR_PACK(0,IBMCA_F_IBMCA_FINISH,0), "IBMCA_FINISH"}, +{ERR_PACK(0,IBMCA_F_IBMCA_INIT,0), "IBMCA_INIT"}, +{ERR_PACK(0,IBMCA_F_IBMCA_MOD_EXP,0), "IBMCA_MOD_EXP"}, +{ERR_PACK(0,IBMCA_F_IBMCA_MOD_EXP_CRT,0), "IBMCA_MOD_EXP_CRT"}, +{ERR_PACK(0,IBMCA_F_IBMCA_RAND_BYTES,0), "IBMCA_RAND_BYTES"}, +{ERR_PACK(0,IBMCA_F_IBMCA_RSA_MOD_EXP,0), "IBMCA_RSA_MOD_EXP"}, +{0,NULL} + }; + +static ERR_STRING_DATA IBMCA_str_reasons[]= + { +{IBMCA_R_ALREADY_LOADED ,"already loaded"}, +{IBMCA_R_BN_CTX_FULL ,"bn ctx full"}, +{IBMCA_R_BN_EXPAND_FAIL ,"bn expand fail"}, +{IBMCA_R_CTRL_COMMAND_NOT_IMPLEMENTED ,"ctrl command not implemented"}, +{IBMCA_R_DSO_FAILURE ,"dso failure"}, +{IBMCA_R_MEXP_LENGTH_TO_LARGE ,"mexp length to large"}, +{IBMCA_R_MISSING_KEY_COMPONENTS ,"missing key components"}, +{IBMCA_R_NOT_INITIALISED ,"not initialised"}, +{IBMCA_R_NOT_LOADED ,"not loaded"}, +{IBMCA_R_OPERANDS_TO_LARGE ,"operands to large"}, +{IBMCA_R_OUTLEN_TO_LARGE ,"outlen to large"}, +{IBMCA_R_REQUEST_FAILED ,"request failed"}, +{IBMCA_R_UNDERFLOW_CONDITION ,"underflow condition"}, +{IBMCA_R_UNDERFLOW_KEYRECORD ,"underflow keyrecord"}, +{IBMCA_R_UNIT_FAILURE ,"unit failure"}, +{0,NULL} + }; + +#endif + +#ifdef IBMCA_LIB_NAME +static ERR_STRING_DATA IBMCA_lib_name[]= + { +{0 ,IBMCA_LIB_NAME}, +{0,NULL} + }; +#endif + + +static int IBMCA_lib_error_code=0; +static int IBMCA_error_init=1; + +static void ERR_load_IBMCA_strings(void) + { + if (IBMCA_lib_error_code == 0) + IBMCA_lib_error_code=ERR_get_next_error_library(); + + if (IBMCA_error_init) + { + IBMCA_error_init=0; +#ifndef OPENSSL_NO_ERR + ERR_load_strings(IBMCA_lib_error_code,IBMCA_str_functs); + ERR_load_strings(IBMCA_lib_error_code,IBMCA_str_reasons); +#endif + +#ifdef IBMCA_LIB_NAME + IBMCA_lib_name->error = ERR_PACK(IBMCA_lib_error_code,0,0); + ERR_load_strings(0,IBMCA_lib_name); +#endif + } + } + +static void ERR_unload_IBMCA_strings(void) + { + if (IBMCA_error_init == 0) + { +#ifndef OPENSSL_NO_ERR + ERR_unload_strings(IBMCA_lib_error_code,IBMCA_str_functs); + ERR_unload_strings(IBMCA_lib_error_code,IBMCA_str_reasons); +#endif + +#ifdef IBMCA_LIB_NAME + ERR_unload_strings(0,IBMCA_lib_name); +#endif + IBMCA_error_init=1; + } + } + +static void ERR_IBMCA_error(int function, int reason, char *file, int line) + { + if (IBMCA_lib_error_code == 0) + IBMCA_lib_error_code=ERR_get_next_error_library(); + ERR_PUT_error(IBMCA_lib_error_code,function,reason,file,line); + } diff --git a/demos/engines/ibmca/hw_ibmca_err.h b/demos/engines/ibmca/hw_ibmca_err.h new file mode 100644 index 0000000000..da64bde5f2 --- /dev/null +++ b/demos/engines/ibmca/hw_ibmca_err.h @@ -0,0 +1,98 @@ +/* ==================================================================== + * Copyright (c) 2001-2002 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 + * openssl-core@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). + * + */ + +#ifndef HEADER_IBMCA_ERR_H +#define HEADER_IBMCA_ERR_H + +/* BEGIN ERROR CODES */ +/* The following lines are auto generated by the script mkerr.pl. Any changes + * made after this point may be overwritten when the script is next run. + */ +static void ERR_load_IBMCA_strings(void); +static void ERR_unload_IBMCA_strings(void); +static void ERR_IBMCA_error(int function, int reason, char *file, int line); +#define IBMCAerr(f,r) ERR_IBMCA_error((f),(r),__FILE__,__LINE__) + +/* Error codes for the IBMCA functions. */ + +/* Function codes. */ +#define IBMCA_F_IBMCA_CTRL 100 +#define IBMCA_F_IBMCA_FINISH 101 +#define IBMCA_F_IBMCA_INIT 102 +#define IBMCA_F_IBMCA_MOD_EXP 103 +#define IBMCA_F_IBMCA_MOD_EXP_CRT 104 +#define IBMCA_F_IBMCA_RAND_BYTES 105 +#define IBMCA_F_IBMCA_RSA_MOD_EXP 106 + +/* Reason codes. */ +#define IBMCA_R_ALREADY_LOADED 100 +#define IBMCA_R_BN_CTX_FULL 101 +#define IBMCA_R_BN_EXPAND_FAIL 102 +#define IBMCA_R_CTRL_COMMAND_NOT_IMPLEMENTED 103 +#define IBMCA_R_DSO_FAILURE 104 +#define IBMCA_R_MEXP_LENGTH_TO_LARGE 105 +#define IBMCA_R_MISSING_KEY_COMPONENTS 106 +#define IBMCA_R_NOT_INITIALISED 107 +#define IBMCA_R_NOT_LOADED 108 +#define IBMCA_R_OPERANDS_TO_LARGE 109 +#define IBMCA_R_OUTLEN_TO_LARGE 110 +#define IBMCA_R_REQUEST_FAILED 111 +#define IBMCA_R_UNDERFLOW_CONDITION 112 +#define IBMCA_R_UNDERFLOW_KEYRECORD 113 +#define IBMCA_R_UNIT_FAILURE 114 + +#ifdef __cplusplus +} +#endif +#endif diff --git a/demos/engines/ibmca/ica_openssl_api.h b/demos/engines/ibmca/ica_openssl_api.h new file mode 100644 index 0000000000..c77e0fd5c0 --- /dev/null +++ b/demos/engines/ibmca/ica_openssl_api.h @@ -0,0 +1,189 @@ + +#ifndef __ICA_OPENSSL_API_H__ +#define __ICA_OPENSSL_API_H__ + +/** + ** abstract data types for API + **/ + +#define ICA_ADAPTER_HANDLE int + +#if defined(linux) || defined (_AIX) +#define ICA_CALL +#endif + +#if defined(WIN32) || defined(_WIN32) +#define ICA_CALL __stdcall +#endif + +/*------------------------------------------------* + | RSA defines and typedefs | + *------------------------------------------------*/ + /* + * All data elements of the RSA key are in big-endian format + * Modulus-Exponent form of key + * + */ + #define MAX_EXP_SIZE 256 + #define MAX_MODULUS_SIZE 256 + #define MAX_MODEXP_SIZE (MAX_EXP_SIZE + MAX_MODULUS_SIZE) + + #define MAX_OPERAND_SIZE MAX_EXP_SIZE + + typedef unsigned char ICA_KEY_RSA_MODEXPO_REC[MAX_MODEXP_SIZE]; + /* + * All data elements of the RSA key are in big-endian format + * Chinese Remainder Thereom(CRT) form of key + * Used only for Decrypt, the encrypt form is typically Modulus-Exponent + * + */ + #define MAX_BP_SIZE 136 + #define MAX_BQ_SIZE 128 + #define MAX_NP_SIZE 136 + #define MAX_NQ_SIZE 128 + #define MAX_QINV_SIZE 136 + #define MAX_RSACRT_SIZE (MAX_BP_SIZE+MAX_BQ_SIZE+MAX_NP_SIZE+MAX_NQ_SIZE+MAX_QINV_SIZE) + +#define RSA_GEN_OPERAND_MAX 256 /* bytes */ + +typedef unsigned char ICA_KEY_RSA_CRT_REC[MAX_RSACRT_SIZE]; +/*------------------------------------------------* + | RSA key token types | + *------------------------------------------------*/ + +#define RSA_PUBLIC_MODULUS_EXPONENT 3 +#define RSA_PKCS_PRIVATE_CHINESE_REMAINDER 6 + +#define KEYTYPE_MODEXPO 1 +#define KEYTYPE_PKCSCRT 2 + + +/*------------------------------------------------* + | RSA Key Token format | + *------------------------------------------------*/ + +/* + * NOTE: All the fields in the ICA_KEY_RSA_MODEXPO structure + * (lengths, offsets, exponents, modulus, etc.) are + * stored in big-endian format + */ + +typedef struct _ICA_KEY_RSA_MODEXPO +{ unsigned int keyType; /* RSA key type. */ + unsigned int keyLength; /* Total length of the token. */ + unsigned int modulusBitLength; /* Modulus n bit length. */ + /* -- Start of the data length.*/ + unsigned int nLength; /* Modulus n = p * q */ + unsigned int expLength; /* exponent (public or private)*/ + /* e = 1/d * mod(p-1)(q-1) */ + /* -- Start of the data offsets*/ + unsigned int nOffset; /* Modulus n . */ + unsigned int expOffset; /* exponent (public or private)*/ + unsigned char reserved[112]; /* reserved area */ + /* -- Start of the variable -- */ + /* -- length token data. -- */ + ICA_KEY_RSA_MODEXPO_REC keyRecord; +} ICA_KEY_RSA_MODEXPO; +#define SZ_HEADER_MODEXPO (sizeof(ICA_KEY_RSA_MODEXPO) - sizeof(ICA_KEY_RSA_MODEXPO_REC)) + +/* + * NOTE: All the fields in the ICA_KEY_RSA_CRT structure + * (lengths, offsets, exponents, modulus, etc.) are + * stored in big-endian format + */ + +typedef struct _ICA_KEY_RSA_CRT +{ unsigned int keyType; /* RSA key type. */ + unsigned int keyLength; /* Total length of the token. */ + unsigned int modulusBitLength; /* Modulus n bit length. */ + /* -- Start of the data length.*/ +#if _AIX + unsigned int nLength; /* Modulus n = p * q */ +#endif + unsigned int pLength; /* Prime number p . */ + unsigned int qLength; /* Prime number q . */ + unsigned int dpLength; /* dp = d * mod(p-1) . */ + unsigned int dqLength; /* dq = d * mod(q-1) . */ + unsigned int qInvLength; /* PKCS: qInv = Ap/q */ + /* -- Start of the data offsets*/ +#if _AIX + unsigned int nOffset; /* Modulus n . */ +#endif + unsigned int pOffset; /* Prime number p . */ + unsigned int qOffset; /* Prime number q . */ + unsigned int dpOffset; /* dp . */ + unsigned int dqOffset; /* dq . */ + unsigned int qInvOffset; /* qInv for PKCS */ +#if _AIX + unsigned char reserved[80]; /* reserved area */ +#else + unsigned char reserved[88]; /* reserved area */ +#endif + /* -- Start of the variable -- */ + /* -- length token data. -- */ + ICA_KEY_RSA_CRT_REC keyRecord; +} ICA_KEY_RSA_CRT; +#define SZ_HEADER_CRT (sizeof(ICA_KEY_RSA_CRT) - sizeof(ICA_KEY_RSA_CRT_REC)) + +unsigned int +icaOpenAdapter( unsigned int adapterId, + ICA_ADAPTER_HANDLE *pAdapterHandle ); + +unsigned int +icaCloseAdapter( ICA_ADAPTER_HANDLE adapterHandle ); + +unsigned int +icaRsaModExpo( ICA_ADAPTER_HANDLE hAdapterHandle, + unsigned int inputDataLength, + unsigned char *pInputData, + ICA_KEY_RSA_MODEXPO *pKeyModExpo, + unsigned int *pOutputDataLength, + unsigned char *pOutputData ); + +unsigned int +icaRsaCrt( ICA_ADAPTER_HANDLE hAdapterHandle, + unsigned int inputDataLength, + unsigned char *pInputData, + ICA_KEY_RSA_CRT *pKeyCrt, + unsigned int *pOutputDataLength, + unsigned char *pOutputData ); + +unsigned int +icaRandomNumberGenerate( ICA_ADAPTER_HANDLE hAdapterHandle, + unsigned int outputDataLength, + unsigned char *pOutputData ); + +/* Specific macros and definitions to not have IFDEF;s all over the + main code */ + +#if (_AIX) +static const char *IBMCA_LIBNAME = "/lib/libica.a(shr.o)"; +#elif (WIN32) +static const char *IBMCA_LIBNAME = "cryptica"; +#else +static const char *IBMCA_LIBNAME = "ica"; +#endif + +#if (WIN32) +/* + The ICA_KEY_RSA_MODEXPO & ICA_KEY_RSA_CRT lengths and + offsets must be in big-endian format. + +*/ +#define CORRECT_ENDIANNESS(b) ( \ + (((unsigned long) (b) & 0x000000ff) << 24) | \ + (((unsigned long) (b) & 0x0000ff00) << 8) | \ + (((unsigned long) (b) & 0x00ff0000) >> 8) | \ + (((unsigned long) (b) & 0xff000000) >> 24) \ + ) +#define CRT_KEY_TYPE RSA_PKCS_PRIVATE_CHINESE_REMAINDER +#define ME_KEY_TYPE RSA_PUBLIC_MODULUS_EXPONENT +#else +#define CORRECT_ENDIANNESS(b) (b) +#define CRT_KEY_TYPE KEYTYPE_PKCSCRT +#define ME_KEY_TYPE KEYTYPE_MODEXPO +#endif + + + +#endif /* __ICA_OPENSSL_API_H__ */ diff --git a/demos/engines/rsaref/Makefile b/demos/engines/rsaref/Makefile index 5fbcda3576..003e35df2e 100644 --- a/demos/engines/rsaref/Makefile +++ b/demos/engines/rsaref/Makefile @@ -48,7 +48,7 @@ $(LIB): $(OBJ) LINK_SO= \ ld -r -o $(LIBNAME).o $$ALLSYMSFLAGS $(LIB) install/librsaref.a && \ - (nm -Pg $(LIBNAME).o | grep ' [BD] ' | cut -f1 -d' ' > $(LIBNAME).exp; \ + (nm -Pg $(LIBNAME).o | grep ' [BDT] ' | cut -f1 -d' ' > $(LIBNAME).exp; \ $$SHAREDCMD $$SHAREDFLAGS -o $(SHLIB) $(LIBNAME).o -L ../../.. -lcrypto -lc) $(SHLIB).gnu: $(LIB) install/librsaref.a diff --git a/demos/engines/zencod/Makefile b/demos/engines/zencod/Makefile new file mode 100644 index 0000000000..5b6a339ab2 --- /dev/null +++ b/demos/engines/zencod/Makefile @@ -0,0 +1,114 @@ +LIBNAME= libzencod +SRC= hw_zencod.c +OBJ= hw_zencod.o +HEADER= hw_zencod.h + +CC= gcc +PIC= -fPIC +CFLAGS= -g -I../../../include $(PIC) -DENGINE_DYNAMIC_SUPPORT -DFLAT_INC +AR= ar r +RANLIB= ranlib + +LIB= $(LIBNAME).a +SHLIB= $(LIBNAME).so + +all: + @echo 'Please choose a system to build on:' + @echo '' + @echo 'tru64: Tru64 Unix, Digital Unix, Digital OSF/1' + @echo 'solaris: Solaris' + @echo 'irix: IRIX' + @echo 'hpux32: 32-bit HP/UX' + @echo 'hpux64: 64-bit HP/UX' + @echo 'aix: AIX' + @echo 'gnu: Generic GNU-based system (gcc and GNU ld)' + @echo '' + +FORCE.update: +update: FORCE.update + perl ../../../util/mkerr.pl -conf hw_zencod.ec \ + -nostatic -staticloader -write hw_zencod.c + +gnu: $(SHLIB).gnu +tru64: $(SHLIB).tru64 +solaris: $(SHLIB).solaris +irix: $(SHLIB).irix +hpux32: $(SHLIB).hpux32 +hpux64: $(SHLIB).hpux64 +aix: $(SHLIB).aix + +$(LIB): $(OBJ) + $(AR) $(LIB) $(OBJ) + - $(RANLIB) $(LIB) + +LINK_SO= \ + ld -r -o $(LIBNAME).o $$ALLSYMSFLAGS $(LIB) && \ + (nm -Pg $(LIBNAME).o | grep ' [BDT] ' | cut -f1 -d' ' > $(LIBNAME).exp; \ + $$SHAREDCMD $$SHAREDFLAGS -o $(SHLIB) $(LIBNAME).o -L ../../.. -lcrypto -lc) + +$(SHLIB).gnu: $(LIB) + ALLSYMSFLAGS='--whole-archive' \ + SHAREDFLAGS='-shared -Wl,-soname=$(SHLIB)' \ + SHAREDCMD='$(CC)'; \ + $(LINK_SO) + touch $(SHLIB).gnu +$(SHLIB).tru64: $(LIB) + ALLSYMSFLAGS='-all' \ + SHAREDFLAGS='-shared' \ + SHAREDCMD='$(CC)'; \ + $(LINK_SO) + touch $(SHLIB).tru64 +$(SHLIB).solaris: $(LIB) + ALLSYMSFLAGS='-z allextract' \ + SHAREDFLAGS='-G -h $(SHLIB)' \ + SHAREDCMD='$(CC)'; \ + $(LINK_SO) + touch $(SHLIB).solaris +$(SHLIB).irix: $(LIB) + ALLSYMSFLAGS='-all' \ + SHAREDFLAGS='-shared -Wl,-soname,$(SHLIB)' \ + SHAREDCMD='$(CC)'; \ + $(LINK_SO) + touch $(SHLIB).irix +$(SHLIB).hpux32: $(LIB) + ALLSYMSFLAGS='-Fl' \ + SHAREDFLAGS='+vnocompatwarnings -b -z +s +h $(SHLIB)' \ + SHAREDCMD='/usr/ccs/bin/ld'; \ + $(LINK_SO) + touch $(SHLIB).hpux32 +$(SHLIB).hpux64: $(LIB) + ALLSYMSFLAGS='+forceload' \ + SHAREDFLAGS='-b -z +h $(SHLIB)' \ + SHAREDCMD='/usr/ccs/bin/ld'; \ + $(LINK_SO) + touch $(SHLIB).hpux64 +$(SHLIB).aix: $(LIB) + ALLSYMSFLAGS='-bnogc' \ + SHAREDFLAGS='-G -bE:$(LIBNAME).exp -bM:SRE' \ + SHAREDCMD='$(CC)'; \ + $(LINK_SO) + touch $(SHLIB).aix + +depend: + sed -e '/^# DO NOT DELETE.*/,$$d' < Makefile > Makefile.tmp + echo '# DO NOT DELETE THIS LINE -- make depend depends on it.' >> Makefile.tmp + gcc -M $(CFLAGS) $(SRC) >> Makefile.tmp + perl ../../../util/clean-depend.pl < Makefile.tmp > Makefile.new + rm -f Makefile.tmp Makefile + mv Makefile.new Makefile + +# DO NOT DELETE THIS LINE -- make depend depends on it. + +rsaref.o: ../../../include/openssl/asn1.h ../../../include/openssl/bio.h +rsaref.o: ../../../include/openssl/bn.h ../../../include/openssl/crypto.h +rsaref.o: ../../../include/openssl/dh.h ../../../include/openssl/dsa.h +rsaref.o: ../../../include/openssl/e_os2.h ../../../include/openssl/engine.h +rsaref.o: ../../../include/openssl/err.h ../../../include/openssl/lhash.h +rsaref.o: ../../../include/openssl/opensslconf.h +rsaref.o: ../../../include/openssl/opensslv.h +rsaref.o: ../../../include/openssl/ossl_typ.h ../../../include/openssl/rand.h +rsaref.o: ../../../include/openssl/rsa.h ../../../include/openssl/safestack.h +rsaref.o: ../../../include/openssl/stack.h ../../../include/openssl/symhacks.h +rsaref.o: ../../../include/openssl/ui.h rsaref.c rsaref_err.c rsaref_err.h +rsaref.o: source/des.h source/global.h source/md2.h source/md5.h source/rsa.h +rsaref.o: source/rsaref.h diff --git a/demos/engines/zencod/hw_zencod.c b/demos/engines/zencod/hw_zencod.c new file mode 100644 index 0000000000..308e18710f --- /dev/null +++ b/demos/engines/zencod/hw_zencod.c @@ -0,0 +1,1736 @@ +/* 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!!!) + */ +ENGINE *ENGINE_zencod ( void ) +{ + + ENGINE *eng = ENGINE_new () ; + + if ( !eng ) { + return NULL ; + } + if ( !bind_helper ( eng ) ) { + ENGINE_free ( eng ) ; + return NULL ; + } + + return eng ; +} + + +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 stucture ... */ +} ; + +/* The one for MD5 ... */ +static const EVP_MD engine_md5_md = +{ + NID_md5, + NID_md5WithRSAEncryption, + MD5_DIGEST_LENGTH, + EVP_MD_FLAG_ONESHOT, + /* 0, */ /* EVP_MD_FLAG_ONESHOT = x0001 digest can only handle a single block + * XXX: set according to device info ... */ + engine_md5_init, + engine_md5_update, + engine_md5_final, + engine_md_copy, /* dev_crypto_md5_copy */ + engine_md_cleanup, /* dev_crypto_md5_cleanup */ + EVP_PKEY_RSA_method, + MD5_CBLOCK, + /* sizeof ( EVP_MD * ) + sizeof ( MD5_CTX ) */ + sizeof ( ZEN_MD_DATA ) + /* sizeof ( MD_CTX_DATA ) The message digest data stucture ... */ +} ; + + +/* The one for RC4 ... */ +#define EVP_RC4_KEY_SIZE 16 + +/* Try something static ... */ +typedef struct +{ + unsigned int len ; + unsigned int first ; + unsigned char rc4_state [ 260 ] ; +} NEW_ZEN_RC4_KEY ; + +#define rc4_data(ctx) ( (EVP_RC4_KEY *) ( ctx )->cipher_data ) + +static const EVP_CIPHER engine_rc4 = +{ + NID_rc4, + 1, + 16, /* EVP_RC4_KEY_SIZE should be 128 bits */ + 0, /* FIXME: key should be up to 256 bytes */ + EVP_CIPH_VARIABLE_LENGTH, + engine_rc4_init_key, + engine_rc4_cipher, + engine_cipher_cleanup, + sizeof ( NEW_ZEN_RC4_KEY ), + NULL, + NULL, + NULL +} ; + +/* The one for RC4_40 ... */ +static const EVP_CIPHER engine_rc4_40 = +{ + NID_rc4_40, + 1, + 5, /* 40 bits */ + 0, + EVP_CIPH_VARIABLE_LENGTH, + engine_rc4_init_key, + engine_rc4_cipher, + engine_cipher_cleanup, + sizeof ( NEW_ZEN_RC4_KEY ), + NULL, + NULL, + NULL +} ; + +/* The one for DES ... */ + +/* Try something static ... */ +typedef struct +{ + unsigned char des_key [ 24 ] ; + unsigned char des_iv [ 8 ] ; +} ZEN_DES_KEY ; + +static const EVP_CIPHER engine_des_cbc = + { + NID_des_cbc, + 8, 8, 8, + 0 | EVP_CIPH_CBC_MODE, + engine_des_init_key, + engine_des_cbc_cipher, + engine_cipher_cleanup, + sizeof(ZEN_DES_KEY), + EVP_CIPHER_set_asn1_iv, + EVP_CIPHER_get_asn1_iv, + NULL, + NULL + }; + +/* The one for 3DES ... */ + +/* Try something static ... */ +typedef struct +{ + unsigned char des3_key [ 24 ] ; + unsigned char des3_iv [ 8 ] ; +} ZEN_3DES_KEY ; + +#define des_data(ctx) ( (DES_EDE_KEY *) ( ctx )->cipher_data ) + +static const EVP_CIPHER engine_des_ede3_cbc = + { + NID_des_ede3_cbc, + 8, 8, 8, + 0 | EVP_CIPH_CBC_MODE, + engine_des_ede3_init_key, + engine_des_ede3_cbc_cipher, + engine_cipher_cleanup, + sizeof(ZEN_3DES_KEY), + EVP_CIPHER_set_asn1_iv, + EVP_CIPHER_get_asn1_iv, + NULL, + NULL + }; + + +/* General function cloned on hw_openbsd_dev_crypto one ... */ +static int engine_digests ( ENGINE *e, const EVP_MD **digest, const int **nids, int nid ) +{ + +#ifdef DEBUG_ZENCOD_MD + fprintf ( stderr, "\t=>Function : static int engine_digests () called !\n" ) ; +#endif + + if ( !digest ) { + /* We are returning a list of supported nids */ + *nids = engine_digest_nids ; + return engine_digest_nids_num ; + } + /* We are being asked for a specific digest */ + if ( nid == NID_md5 ) { + *digest = &engine_md5_md ; + } + else if ( nid == NID_sha1 ) { + *digest = &engine_sha1_md ; + } + else { + *digest = NULL ; + return 0 ; + } + return 1 ; +} + + +/* SHA stuff Functions + */ +static int engine_sha1_init ( EVP_MD_CTX *ctx ) +{ + + int to_return = 0 ; + + /* Test with zenbridge library ... */ + to_return = ptr_zencod_sha1_init ( (ZEN_MD_DATA *) ctx->md_data ) ; + to_return = !to_return ; + + return to_return ; +} + + +static int engine_sha1_update ( EVP_MD_CTX *ctx, const void *data, unsigned long count ) +{ + + zen_nb_t input ; + int to_return = 0 ; + + /* Convert parameters ... */ + input.len = count ; + input.data = (unsigned char *) data ; + + /* Test with zenbridge library ... */ + to_return = ptr_zencod_sha1_update ( (ZEN_MD_DATA *) ctx->md_data, (const zen_nb_t *) &input ) ; + to_return = !to_return ; + + return to_return ; +} + + +static int engine_sha1_final ( EVP_MD_CTX *ctx, unsigned char *md ) +{ + + zen_nb_t output ; + int to_return = 0 ; + + /* Convert parameters ... */ + output.len = SHA_DIGEST_LENGTH ; + output.data = md ; + + /* Test with zenbridge library ... */ + to_return = ptr_zencod_sha1_do_final ( (ZEN_MD_DATA *) ctx->md_data, (zen_nb_t *) &output ) ; + to_return = !to_return ; + + return to_return ; +} + + + +/* MD5 stuff Functions + */ +static int engine_md5_init ( EVP_MD_CTX *ctx ) +{ + + int to_return = 0 ; + + /* Test with zenbridge library ... */ + to_return = ptr_zencod_md5_init ( (ZEN_MD_DATA *) ctx->md_data ) ; + to_return = !to_return ; + + return to_return ; +} + + +static int engine_md5_update ( EVP_MD_CTX *ctx, const void *data, unsigned long count ) +{ + + zen_nb_t input ; + int to_return = 0 ; + + /* Convert parameters ... */ + input.len = count ; + input.data = (unsigned char *) data ; + + /* Test with zenbridge library ... */ + to_return = ptr_zencod_md5_update ( (ZEN_MD_DATA *) ctx->md_data, (const zen_nb_t *) &input ) ; + to_return = !to_return ; + + return to_return ; +} + + +static int engine_md5_final ( EVP_MD_CTX *ctx, unsigned char *md ) +{ + + zen_nb_t output ; + int to_return = 0 ; + + /* Convert parameters ... */ + output.len = MD5_DIGEST_LENGTH ; + output.data = md ; + + /* Test with zenbridge library ... */ + to_return = ptr_zencod_md5_do_final ( (ZEN_MD_DATA *) ctx->md_data, (zen_nb_t *) &output ) ; + to_return = !to_return ; + + return to_return ; +} + + +static int engine_md_cleanup ( EVP_MD_CTX *ctx ) +{ + + ZEN_MD_DATA *zen_md_data = (ZEN_MD_DATA *) ctx->md_data ; + + if ( zen_md_data->HashBuffer != NULL ) { + OPENSSL_free ( zen_md_data->HashBuffer ) ; + zen_md_data->HashBufferSize = 0 ; + ctx->md_data = NULL ; + } + + return 1 ; +} + + +static int engine_md_copy ( EVP_MD_CTX *to, const EVP_MD_CTX *from ) +{ + const ZEN_MD_DATA *from_md = (ZEN_MD_DATA *) from->md_data ; + ZEN_MD_DATA *to_md = (ZEN_MD_DATA *) to->md_data ; + + to_md->HashBuffer = OPENSSL_malloc ( from_md->HashBufferSize ) ; + memcpy ( to_md->HashBuffer, from_md->HashBuffer, from_md->HashBufferSize ) ; + + return 1; +} + + +/* General function cloned on hw_openbsd_dev_crypto one ... */ +static int engine_ciphers ( ENGINE *e, const EVP_CIPHER **cipher, const int **nids, int nid ) +{ + + if ( !cipher ) { + /* We are returning a list of supported nids */ + *nids = engine_cipher_nids ; + return engine_cipher_nids_num ; + } + /* We are being asked for a specific cipher */ + if ( nid == NID_rc4 ) { + *cipher = &engine_rc4 ; + } + else if ( nid == NID_rc4_40 ) { + *cipher = &engine_rc4_40 ; + } + else if ( nid == NID_des_cbc ) { + *cipher = &engine_des_cbc ; + } + else if ( nid == NID_des_ede3_cbc ) { + *cipher = &engine_des_ede3_cbc ; + } + else { + *cipher = NULL ; + return 0 ; + } + + return 1 ; +} + + +static int engine_rc4_init_key ( EVP_CIPHER_CTX *ctx, const unsigned char *key, const unsigned char *iv, int enc ) +{ + int to_return = 0 ; + int i = 0 ; + int nb = 0 ; + NEW_ZEN_RC4_KEY *tmp_rc4_key = NULL ; + + tmp_rc4_key = (NEW_ZEN_RC4_KEY *) ( ctx->cipher_data ) ; + tmp_rc4_key->first = 0 ; + tmp_rc4_key->len = ctx->key_len ; + tmp_rc4_key->rc4_state [ 0 ] = 0x00 ; + tmp_rc4_key->rc4_state [ 2 ] = 0x00 ; + nb = 256 / ctx->key_len ; + for ( i = 0; i < nb ; i++ ) { + memcpy ( &( tmp_rc4_key->rc4_state [ 4 + i*ctx->key_len ] ), key, ctx->key_len ) ; + } + + to_return = 1 ; + + return to_return ; +} + + +static int engine_rc4_cipher ( EVP_CIPHER_CTX *ctx, unsigned char *out, const unsigned char *in, unsigned int in_len ) +{ + + zen_nb_t output, input ; + zen_nb_t rc4key ; + int to_return = 0 ; + NEW_ZEN_RC4_KEY *tmp_rc4_key = NULL ; + + /* Convert parameters ... */ + input.len = in_len ; + input.data = (unsigned char *) in ; + output.len = in_len ; + output.data = (unsigned char *) out ; + + tmp_rc4_key = ( (NEW_ZEN_RC4_KEY *) ( ctx->cipher_data ) ) ; + rc4key.len = 260 ; + rc4key.data = &( tmp_rc4_key->rc4_state [ 0 ] ) ; + + /* Test with zenbridge library ... */ + to_return = ptr_zencod_rc4_cipher ( &output, &input, (const zen_nb_t *) &rc4key, &( tmp_rc4_key->rc4_state [0] ), &( tmp_rc4_key->rc4_state [3] ), !tmp_rc4_key->first ) ; + to_return = !to_return ; + + /* Update encryption state ... */ + tmp_rc4_key->first = 1 ; + tmp_rc4_key = NULL ; + + return to_return ; +} + + +static int engine_des_init_key ( EVP_CIPHER_CTX *ctx, const unsigned char *key, const unsigned char *iv, int enc ) +{ + + ZEN_DES_KEY *tmp_des_key = NULL ; + int to_return = 0 ; + + tmp_des_key = (ZEN_DES_KEY *) ( ctx->cipher_data ) ; + memcpy ( &( tmp_des_key->des_key [ 0 ] ), key, 8 ) ; + memcpy ( &( tmp_des_key->des_key [ 8 ] ), key, 8 ) ; + memcpy ( &( tmp_des_key->des_key [ 16 ] ), key, 8 ) ; + memcpy ( &( tmp_des_key->des_iv [ 0 ] ), iv, 8 ) ; + + to_return = 1 ; + + return to_return ; +} + + +static int engine_des_cbc_cipher ( EVP_CIPHER_CTX *ctx, unsigned char *out, const unsigned char *in, unsigned int inl ) +{ + + zen_nb_t output, input ; + zen_nb_t deskey_1, deskey_2, deskey_3, iv ; + int to_return = 0 ; + + /* Convert parameters ... */ + input.len = inl ; + input.data = (unsigned char *) in ; + output.len = inl ; + output.data = out ; + + /* Set key parameters ... */ + deskey_1.len = 8 ; + deskey_2.len = 8 ; + deskey_3.len = 8 ; + deskey_1.data = (unsigned char *) ( (ZEN_DES_KEY *) ( ctx->cipher_data ) )->des_key ; + deskey_2.data = (unsigned char *) &( (ZEN_DES_KEY *) ( ctx->cipher_data ) )->des_key [ 8 ] ; + deskey_3.data = (unsigned char *) &( (ZEN_DES_KEY *) ( ctx->cipher_data ) )->des_key [ 16 ] ; + + /* Key correct iv ... */ + memcpy ( ( (ZEN_DES_KEY *) ( ctx->cipher_data ) )->des_iv, ctx->iv, 8 ) ; + iv.len = 8 ; + iv.data = (unsigned char *) ( (ZEN_DES_KEY *) ( ctx->cipher_data ) )->des_iv ; + + if ( ctx->encrypt == 0 ) { + memcpy ( ctx->iv, &( input.data [ input.len - 8 ] ), 8 ) ; + } + + /* Test with zenbridge library ... */ + to_return = ptr_zencod_xdes_cipher ( &output, &input, + (zen_nb_t *) &deskey_1, (zen_nb_t *) &deskey_2, (zen_nb_t *) &deskey_3, &iv, ctx->encrypt ) ; + to_return = !to_return ; + + /* But we need to set up the rigth iv ... + * Test ENCRYPT or DECRYPT mode to set iv ... */ + if ( ctx->encrypt == 1 ) { + memcpy ( ctx->iv, &( output.data [ output.len - 8 ] ), 8 ) ; + } + + return to_return ; +} + + +static int engine_des_ede3_init_key ( EVP_CIPHER_CTX *ctx, const unsigned char *key, const unsigned char *iv, int enc ) +{ + + ZEN_3DES_KEY *tmp_3des_key = NULL ; + int to_return = 0 ; + + tmp_3des_key = (ZEN_3DES_KEY *) ( ctx->cipher_data ) ; + memcpy ( &( tmp_3des_key->des3_key [ 0 ] ), key, 24 ) ; + memcpy ( &( tmp_3des_key->des3_iv [ 0 ] ), iv, 8 ) ; + + to_return = 1; + + return to_return ; +} + + +static int engine_des_ede3_cbc_cipher ( EVP_CIPHER_CTX *ctx, unsigned char *out, const unsigned char *in, + unsigned int in_len ) +{ + + zen_nb_t output, input ; + zen_nb_t deskey_1, deskey_2, deskey_3, iv ; + int to_return = 0 ; + + /* Convert parameters ... */ + input.len = in_len ; + input.data = (unsigned char *) in ; + output.len = in_len ; + output.data = out ; + + /* Set key ... */ + deskey_1.len = 8 ; + deskey_2.len = 8 ; + deskey_3.len = 8 ; + deskey_1.data = (unsigned char *) ( (ZEN_3DES_KEY *) ( ctx->cipher_data ) )->des3_key ; + deskey_2.data = (unsigned char *) &( (ZEN_3DES_KEY *) ( ctx->cipher_data ) )->des3_key [ 8 ] ; + deskey_3.data = (unsigned char *) &( (ZEN_3DES_KEY *) ( ctx->cipher_data ) )->des3_key [ 16 ] ; + + /* Key correct iv ... */ + memcpy ( ( (ZEN_3DES_KEY *) ( ctx->cipher_data ) )->des3_iv, ctx->iv, 8 ) ; + iv.len = 8 ; + iv.data = (unsigned char *) ( (ZEN_3DES_KEY *) ( ctx->cipher_data ) )->des3_iv ; + + if ( ctx->encrypt == 0 ) { + memcpy ( ctx->iv, &( input.data [ input.len - 8 ] ), 8 ) ; + } + + /* Test with zenbridge library ... */ + to_return = ptr_zencod_xdes_cipher ( &output, &input, + (zen_nb_t *) &deskey_1, (zen_nb_t *) &deskey_2, (zen_nb_t *) &deskey_3, &iv, ctx->encrypt ) ; + to_return = !to_return ; + + if ( ctx->encrypt == 1 ) { + memcpy ( ctx->iv, &( output.data [ output.len - 8 ] ), 8 ) ; + } + + return to_return ; +} + + +static int engine_cipher_cleanup ( EVP_CIPHER_CTX *ctx ) +{ + + /* Set the key pointer ... */ + if ( ctx->cipher->nid == NID_rc4 || ctx->cipher->nid == NID_rc4_40 ) { + } + else if ( ctx->cipher->nid == NID_des_cbc ) { + } + else if ( ctx->cipher->nid == NID_des_ede3_cbc ) { + } + + return 1 ; +} + + +#endif /* !OPENSSL_NO_HW_ZENCOD */ +#endif /* !OPENSSL_NO_HW */ diff --git a/demos/engines/zencod/hw_zencod.ec b/demos/engines/zencod/hw_zencod.ec new file mode 100644 index 0000000000..1552c79be6 --- /dev/null +++ b/demos/engines/zencod/hw_zencod.ec @@ -0,0 +1,8 @@ +# configuration file for util/mkerr.pl +# +# use like this: +# +# perl ../../../util/mkerr.pl -conf hw_zencod.ec \ +# -nostatic -staticloader -write *.c + +L ZENCOD hw_zencod_err.h hw_zencod_err.c diff --git a/demos/engines/zencod/hw_zencod.h b/demos/engines/zencod/hw_zencod.h new file mode 100644 index 0000000000..195345d8c6 --- /dev/null +++ b/demos/engines/zencod/hw_zencod.h @@ -0,0 +1,160 @@ +/* File : /crypto/engine/vendor_defns/hw_zencod.h */ +/* ==================================================================== + * Written by Donnat Frederic (frederic.donnat@zencod.com) from ZENCOD + * for "zencod" ENGINE integration in OpenSSL project. + */ + + + #ifndef _HW_ZENCOD_H_ +#define _HW_ZENCOD_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif /* __cplusplus */ + +#define ZENBRIDGE_MAX_KEYSIZE_RSA 2048 +#define ZENBRIDGE_MAX_KEYSIZE_RSA_CRT 1024 +#define ZENBRIDGE_MAX_KEYSIZE_DSA_SIGN 1024 +#define ZENBRIDGE_MAX_KEYSIZE_DSA_VRFY 1024 + +/* Library version computation */ +#define ZENBRIDGE_VERSION_MAJOR(x) (((x) >> 16) | 0xff) +#define ZENBRIDGE_VERSION_MINOR(x) (((x) >> 8) | 0xff) +#define ZENBRIDGE_VERSION_PATCH(x) (((x) >> 0) | 0xff) +#define ZENBRIDGE_VERSION(x, y, z) ((x) << 16 | (y) << 8 | (z)) + +/* + * Memory type + */ +typedef struct zencod_number_s { + unsigned long len; + unsigned char *data; +} zen_nb_t; + +#define KEY zen_nb_t + + +/* + * Misc + */ +typedef int t_zencod_lib_version (void); +typedef int t_zencod_hw_version (void); +typedef int t_zencod_test (void); +typedef int t_zencod_dump_key (FILE *stream, char *msg, KEY *key); + + +/* + * Key managment tools + */ +typedef KEY *t_zencod_new_number (unsigned long len, unsigned char *data); +typedef int t_zencod_init_number (KEY *n, unsigned long len, unsigned char *data); +typedef unsigned long t_zencod_bytes2bits (unsigned char *n, unsigned long bytes); +typedef unsigned long t_zencod_bits2bytes (unsigned long bits); + + +/* + * RSA API + */ +/* Compute modular exponential : y = x**e | n */ +typedef int t_zencod_rsa_mod_exp (KEY *y, KEY *x, KEY *n, KEY *e); +/* Compute modular exponential : y1 = (x | p)**edp | p, y2 = (x | p)**edp | p, y = y2 + (qinv * (y1 - y2) | p) * q */ +typedef int t_zencod_rsa_mod_exp_crt (KEY *y, KEY *x, KEY *p, KEY *q, + KEY *edp, KEY *edq, KEY *qinv); + + +/* + * DSA API + */ +typedef int t_zencod_dsa_do_sign (unsigned int hash, KEY *data, KEY *random, + KEY *p, KEY *q, KEY *g, KEY *x, KEY *r, KEY *s); +typedef int t_zencod_dsa_do_verify (unsigned int hash, KEY *data, + KEY *p, KEY *q, KEY *g, KEY *y, + KEY *r, KEY *s, KEY *v); + + +/* + * DH API + */ + /* Key generation : compute public value y = g**x | n */ +typedef int t_zencod_dh_generate_key (KEY *y, KEY *x, KEY *g, KEY *n, int gen_x); +typedef int t_zencod_dh_compute_key (KEY *k, KEY *y, KEY *x, KEY *n); + + +/* + * RNG API + */ +#define ZENBRIDGE_RNG_DIRECT 0 +#define ZENBRIDGE_RNG_SHA1 1 +typedef int t_zencod_rand_bytes (KEY *rand, unsigned int flags); + + +/* + * Math API + */ +typedef int t_zencod_math_mod_exp (KEY *r, KEY *a, KEY *e, KEY *n); + + + + +/* + * Symetric API + */ +/* Define a data structure for digests operations */ +typedef struct ZEN_data_st +{ + unsigned int HashBufferSize ; + unsigned char *HashBuffer ; +} ZEN_MD_DATA ; + +/* + * Functions for Digest (MD5, SHA1) stuff + */ +/* output : output data buffer */ +/* input : input data buffer */ +/* algo : hash algorithm, MD5 or SHA1 */ +/* typedef int t_zencod_hash ( KEY *output, const KEY *input, int algo ) ; + * typedef int t_zencod_sha_hash ( KEY *output, const KEY *input, int algo ) ; + */ +/* For now separate this stuff that mad it easier to test */ +typedef int t_zencod_md5_init ( ZEN_MD_DATA *data ) ; +typedef int t_zencod_md5_update ( ZEN_MD_DATA *data, const KEY *input ) ; +typedef int t_zencod_md5_do_final ( ZEN_MD_DATA *data, KEY *output ) ; + +typedef int t_zencod_sha1_init ( ZEN_MD_DATA *data ) ; +typedef int t_zencod_sha1_update ( ZEN_MD_DATA *data, const KEY *input ) ; +typedef int t_zencod_sha1_do_final ( ZEN_MD_DATA *data, KEY *output ) ; + + +/* + * Functions for Cipher (RC4, DES, 3DES) stuff + */ +/* output : output data buffer */ +/* input : input data buffer */ +/* key : rc4 key data */ +/* index_1 : value of index x from RC4 key structure */ +/* index_2 : value of index y from RC4 key structure */ +/* Be carefull : RC4 key should be expanded before calling this method (Should we provide an expand function ??) */ +typedef int t_zencod_rc4_cipher ( KEY *output, const KEY *input, const KEY *key, + unsigned char *index_1, unsigned char *index_2, int mode ) ; + +/* output : output data buffer */ +/* input : input data buffer */ +/* key_1 : des first key data */ +/* key_2 : des second key data */ +/* key_3 : des third key data */ +/* iv : initial vector */ +/* mode : xdes mode (encrypt or decrypt) */ +/* Be carefull : In DES mode key_1 = key_2 = key_3 (as far as i can see !!) */ +typedef int t_zencod_xdes_cipher ( KEY *output, const KEY *input, const KEY *key_1, + const KEY *key_2, const KEY *key_3, const KEY *iv, int mode ) ; + + +#undef KEY + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + +#endif /* !_HW_ZENCOD_H_ */ diff --git a/demos/engines/zencod/hw_zencod_err.c b/demos/engines/zencod/hw_zencod_err.c new file mode 100644 index 0000000000..8ed0fffc9c --- /dev/null +++ b/demos/engines/zencod/hw_zencod_err.c @@ -0,0 +1,151 @@ +/* hw_zencod_err.c */ +/* ==================================================================== + * Copyright (c) 1999-2002 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 + * openssl-core@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). + * + */ + +/* NOTE: this file was auto generated by the mkerr.pl script: any changes + * made to it will be overwritten when the script next updates this file, + * only reason strings will be preserved. + */ + +#include +#include +#include "hw_zencod_err.h" + +/* BEGIN ERROR CODES */ +#ifndef OPENSSL_NO_ERR +static ERR_STRING_DATA ZENCOD_str_functs[]= + { +{ERR_PACK(0,ZENCOD_F_ZENCOD_BN_MOD_EXP,0), "ZENCOD_BN_MOD_EXP"}, +{ERR_PACK(0,ZENCOD_F_ZENCOD_CTRL,0), "ZENCOD_CTRL"}, +{ERR_PACK(0,ZENCOD_F_ZENCOD_DH_COMPUTE,0), "ZENCOD_DH_COMPUTE"}, +{ERR_PACK(0,ZENCOD_F_ZENCOD_DH_GENERATE,0), "ZENCOD_DH_GENERATE"}, +{ERR_PACK(0,ZENCOD_F_ZENCOD_DSA_DO_SIGN,0), "ZENCOD_DSA_DO_SIGN"}, +{ERR_PACK(0,ZENCOD_F_ZENCOD_DSA_DO_VERIFY,0), "ZENCOD_DSA_DO_VERIFY"}, +{ERR_PACK(0,ZENCOD_F_ZENCOD_FINISH,0), "ZENCOD_FINISH"}, +{ERR_PACK(0,ZENCOD_F_ZENCOD_INIT,0), "ZENCOD_INIT"}, +{ERR_PACK(0,ZENCOD_F_ZENCOD_RAND,0), "ZENCOD_RAND"}, +{ERR_PACK(0,ZENCOD_F_ZENCOD_RSA_MOD_EXP,0), "ZENCOD_RSA_MOD_EXP"}, +{ERR_PACK(0,ZENCOD_F_ZENCOD_RSA_MOD_EXP_CRT,0), "ZENCOD_RSA_MOD_EXP_CRT"}, +{0,NULL} + }; + +static ERR_STRING_DATA ZENCOD_str_reasons[]= + { +{ZENCOD_R_ALREADY_LOADED ,"already loaded"}, +{ZENCOD_R_BAD_KEY_COMPONENTS ,"bad key components"}, +{ZENCOD_R_BN_EXPAND_FAIL ,"bn expand fail"}, +{ZENCOD_R_CTRL_COMMAND_NOT_IMPLEMENTED ,"ctrl command not implemented"}, +{ZENCOD_R_DSO_FAILURE ,"dso failure"}, +{ZENCOD_R_NOT_LOADED ,"not loaded"}, +{ZENCOD_R_REQUEST_FAILED ,"request failed"}, +{ZENCOD_R_UNIT_FAILURE ,"unit failure"}, +{0,NULL} + }; + +#endif + +#ifdef ZENCOD_LIB_NAME +static ERR_STRING_DATA ZENCOD_lib_name[]= + { +{0 ,ZENCOD_LIB_NAME}, +{0,NULL} + }; +#endif + + +static int ZENCOD_lib_error_code=0; +static int ZENCOD_error_init=1; + +static void ERR_load_ZENCOD_strings(void) + { + if (ZENCOD_lib_error_code == 0) + ZENCOD_lib_error_code=ERR_get_next_error_library(); + + if (ZENCOD_error_init) + { + ZENCOD_error_init=0; +#ifndef OPENSSL_NO_ERR + ERR_load_strings(ZENCOD_lib_error_code,ZENCOD_str_functs); + ERR_load_strings(ZENCOD_lib_error_code,ZENCOD_str_reasons); +#endif + +#ifdef ZENCOD_LIB_NAME + ZENCOD_lib_name->error = ERR_PACK(ZENCOD_lib_error_code,0,0); + ERR_load_strings(0,ZENCOD_lib_name); +#endif + } + } + +static void ERR_unload_ZENCOD_strings(void) + { + if (ZENCOD_error_init == 0) + { +#ifndef OPENSSL_NO_ERR + ERR_unload_strings(ZENCOD_lib_error_code,ZENCOD_str_functs); + ERR_unload_strings(ZENCOD_lib_error_code,ZENCOD_str_reasons); +#endif + +#ifdef ZENCOD_LIB_NAME + ERR_unload_strings(0,ZENCOD_lib_name); +#endif + ZENCOD_error_init=1; + } + } + +static void ERR_ZENCOD_error(int function, int reason, char *file, int line) + { + if (ZENCOD_lib_error_code == 0) + ZENCOD_lib_error_code=ERR_get_next_error_library(); + ERR_PUT_error(ZENCOD_lib_error_code,function,reason,file,line); + } diff --git a/demos/engines/zencod/hw_zencod_err.h b/demos/engines/zencod/hw_zencod_err.h new file mode 100644 index 0000000000..1b5dcb5685 --- /dev/null +++ b/demos/engines/zencod/hw_zencod_err.h @@ -0,0 +1,95 @@ +/* ==================================================================== + * Copyright (c) 2001-2002 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 + * openssl-core@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). + * + */ + +#ifndef HEADER_ZENCOD_ERR_H +#define HEADER_ZENCOD_ERR_H + +/* BEGIN ERROR CODES */ +/* The following lines are auto generated by the script mkerr.pl. Any changes + * made after this point may be overwritten when the script is next run. + */ +static void ERR_load_ZENCOD_strings(void); +static void ERR_unload_ZENCOD_strings(void); +static void ERR_ZENCOD_error(int function, int reason, char *file, int line); +#define ZENCODerr(f,r) ERR_ZENCOD_error((f),(r),__FILE__,__LINE__) + +/* Error codes for the ZENCOD functions. */ + +/* Function codes. */ +#define ZENCOD_F_ZENCOD_BN_MOD_EXP 100 +#define ZENCOD_F_ZENCOD_CTRL 101 +#define ZENCOD_F_ZENCOD_DH_COMPUTE 102 +#define ZENCOD_F_ZENCOD_DH_GENERATE 103 +#define ZENCOD_F_ZENCOD_DSA_DO_SIGN 104 +#define ZENCOD_F_ZENCOD_DSA_DO_VERIFY 105 +#define ZENCOD_F_ZENCOD_FINISH 106 +#define ZENCOD_F_ZENCOD_INIT 107 +#define ZENCOD_F_ZENCOD_RAND 108 +#define ZENCOD_F_ZENCOD_RSA_MOD_EXP 109 +#define ZENCOD_F_ZENCOD_RSA_MOD_EXP_CRT 110 + +/* Reason codes. */ +#define ZENCOD_R_ALREADY_LOADED 100 +#define ZENCOD_R_BAD_KEY_COMPONENTS 101 +#define ZENCOD_R_BN_EXPAND_FAIL 102 +#define ZENCOD_R_CTRL_COMMAND_NOT_IMPLEMENTED 103 +#define ZENCOD_R_DSO_FAILURE 104 +#define ZENCOD_R_NOT_LOADED 105 +#define ZENCOD_R_REQUEST_FAILED 106 +#define ZENCOD_R_UNIT_FAILURE 107 + +#ifdef __cplusplus +} +#endif +#endif -- 2.25.1