--- /dev/null
+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
--- /dev/null
+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";
+
+
--- /dev/null
+/* 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 <stdio.h>
+#include <openssl/crypto.h>
+#include <openssl/dso.h>
+#include <openssl/des.h>
+#include <openssl/engine.h>
+
+#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 */
+
--- /dev/null
+# 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
--- /dev/null
+/* 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 <stdio.h>
+#include <openssl/err.h>
+#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);
+ }
--- /dev/null
+/* ====================================================================
+ * 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
--- /dev/null
+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
--- /dev/null
+/* crypto/engine/hw_ibmca.c */\r
+/* Written by Geoff Thorpe (geoff@geoffthorpe.net) for the OpenSSL\r
+ * project 2000.\r
+ */\r
+/* ====================================================================\r
+ * Copyright (c) 1999 The OpenSSL Project. All rights reserved.\r
+ *\r
+ * Redistribution and use in source and binary forms, with or without\r
+ * modification, are permitted provided that the following conditions\r
+ * are met:\r
+ *\r
+ * 1. Redistributions of source code must retain the above copyright\r
+ * notice, this list of conditions and the following disclaimer.\r
+ *\r
+ * 2. Redistributions in binary form must reproduce the above copyright\r
+ * notice, this list of conditions and the following disclaimer in\r
+ * the documentation and/or other materials provided with the\r
+ * distribution.\r
+ *\r
+ * 3. All advertising materials mentioning features or use of this\r
+ * software must display the following acknowledgment:\r
+ * "This product includes software developed by the OpenSSL Project\r
+ * for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"\r
+ *\r
+ * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to\r
+ * endorse or promote products derived from this software without\r
+ * prior written permission. For written permission, please contact\r
+ * licensing@OpenSSL.org.\r
+ *\r
+ * 5. Products derived from this software may not be called "OpenSSL"\r
+ * nor may "OpenSSL" appear in their names without prior written\r
+ * permission of the OpenSSL Project.\r
+ *\r
+ * 6. Redistributions of any form whatsoever must retain the following\r
+ * acknowledgment:\r
+ * "This product includes software developed by the OpenSSL Project\r
+ * for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"\r
+ *\r
+ * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY\r
+ * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\r
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR\r
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR\r
+ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\r
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT\r
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)\r
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,\r
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\r
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED\r
+ * OF THE POSSIBILITY OF SUCH DAMAGE.\r
+ * ====================================================================\r
+ *\r
+ * This product includes cryptographic software written by Eric Young\r
+ * (eay@cryptsoft.com). This product includes software written by Tim\r
+ * Hudson (tjh@cryptsoft.com).\r
+ *\r
+ */\r
+\r
+/* (C) COPYRIGHT International Business Machines Corp. 2001 */\r
+\r
+#include <stdio.h>\r
+#include <openssl/crypto.h>\r
+#include <openssl/dso.h>\r
+#include <openssl/engine.h>\r
+\r
+#ifndef OPENSSL_NO_HW\r
+#ifndef OPENSSL_NO_HW_IBMCA\r
+\r
+#ifdef FLAT_INC\r
+#include "ica_openssl_api.h"\r
+#else\r
+#include "vendor_defns/ica_openssl_api.h"\r
+#endif\r
+\r
+#define IBMCA_LIB_NAME "ibmca engine"\r
+#include "hw_ibmca_err.c"\r
+\r
+static int ibmca_destroy(ENGINE *e);\r
+static int ibmca_init(ENGINE *e);\r
+static int ibmca_finish(ENGINE *e);\r
+static int ibmca_ctrl(ENGINE *e, int cmd, long i, void *p, void (*f)());\r
+\r
+static const char *IBMCA_F1 = "icaOpenAdapter";\r
+static const char *IBMCA_F2 = "icaCloseAdapter";\r
+static const char *IBMCA_F3 = "icaRsaModExpo";\r
+static const char *IBMCA_F4 = "icaRandomNumberGenerate";\r
+static const char *IBMCA_F5 = "icaRsaCrt";\r
+\r
+ICA_ADAPTER_HANDLE handle=0;\r
+\r
+/* BIGNUM stuff */\r
+static int ibmca_mod_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,\r
+ const BIGNUM *m, BN_CTX *ctx);\r
+\r
+static int ibmca_mod_exp_crt(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,\r
+ const BIGNUM *q, const BIGNUM *dmp1, const BIGNUM *dmq1,\r
+ const BIGNUM *iqmp, BN_CTX *ctx);\r
+\r
+#ifndef OPENSSL_NO_RSA \r
+/* RSA stuff */\r
+static int ibmca_rsa_mod_exp(BIGNUM *r0, const BIGNUM *I, RSA *rsa);\r
+#endif\r
+\r
+/* This function is aliased to mod_exp (with the mont stuff dropped). */\r
+static int ibmca_mod_exp_mont(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,\r
+ const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx);\r
+\r
+#ifndef OPENSSL_NO_DSA \r
+/* DSA stuff */\r
+static int ibmca_dsa_mod_exp(DSA *dsa, BIGNUM *rr, BIGNUM *a1,\r
+ BIGNUM *p1, BIGNUM *a2, BIGNUM *p2, BIGNUM *m,\r
+ BN_CTX *ctx, BN_MONT_CTX *in_mont);\r
+static int ibmca_mod_exp_dsa(DSA *dsa, BIGNUM *r, BIGNUM *a,\r
+ const BIGNUM *p, const BIGNUM *m, BN_CTX *ctx,\r
+ BN_MONT_CTX *m_ctx);\r
+#endif\r
+\r
+#ifndef OPENSSL_NO_DH \r
+/* DH stuff */\r
+/* This function is alised to mod_exp (with the DH and mont dropped). */\r
+static int ibmca_mod_exp_dh(const DH *dh, BIGNUM *r, \r
+ const BIGNUM *a, const BIGNUM *p,\r
+ const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx);\r
+#endif\r
+\r
+/* RAND stuff */\r
+static int ibmca_rand_bytes(unsigned char *buf, int num);\r
+static int ibmca_rand_status(void);\r
+\r
+\r
+/* WJH - check for more commands, like in nuron */\r
+\r
+/* The definitions for control commands specific to this engine */\r
+#define IBMCA_CMD_SO_PATH ENGINE_CMD_BASE\r
+static const ENGINE_CMD_DEFN ibmca_cmd_defns[] = {\r
+ {IBMCA_CMD_SO_PATH,\r
+ "SO_PATH",\r
+ "Specifies the path to the 'atasi' shared library",\r
+ ENGINE_CMD_FLAG_STRING},\r
+ {0, NULL, NULL, 0}\r
+ };\r
+\r
+#ifndef OPENSSL_NO_RSA \r
+/* Our internal RSA_METHOD that we provide pointers to */\r
+static RSA_METHOD ibmca_rsa =\r
+ {\r
+ "Ibmca RSA method",\r
+ NULL,\r
+ NULL,\r
+ NULL,\r
+ NULL,\r
+ ibmca_rsa_mod_exp,\r
+ ibmca_mod_exp_mont,\r
+ NULL,\r
+ NULL,\r
+ 0,\r
+ NULL,\r
+ NULL,\r
+ NULL\r
+ };\r
+#endif\r
+\r
+#ifndef OPENSSL_NO_DSA\r
+/* Our internal DSA_METHOD that we provide pointers to */\r
+static DSA_METHOD ibmca_dsa =\r
+ {\r
+ "Ibmca DSA method",\r
+ NULL, /* dsa_do_sign */\r
+ NULL, /* dsa_sign_setup */\r
+ NULL, /* dsa_do_verify */\r
+ ibmca_dsa_mod_exp, /* dsa_mod_exp */\r
+ ibmca_mod_exp_dsa, /* bn_mod_exp */\r
+ NULL, /* init */\r
+ NULL, /* finish */\r
+ 0, /* flags */\r
+ NULL /* app_data */\r
+ };\r
+#endif\r
+\r
+#ifndef OPENSSL_NO_DH\r
+/* Our internal DH_METHOD that we provide pointers to */\r
+static DH_METHOD ibmca_dh =\r
+ {\r
+ "Ibmca DH method",\r
+ NULL,\r
+ NULL,\r
+ ibmca_mod_exp_dh,\r
+ NULL,\r
+ NULL,\r
+ 0,\r
+ NULL\r
+ };\r
+#endif\r
+\r
+static RAND_METHOD ibmca_rand =\r
+ {\r
+ /* "IBMCA RAND method", */\r
+ NULL,\r
+ ibmca_rand_bytes,\r
+ NULL,\r
+ NULL,\r
+ ibmca_rand_bytes,\r
+ ibmca_rand_status,\r
+ };\r
+\r
+/* Constants used when creating the ENGINE */\r
+static const char *engine_ibmca_id = "ibmca";\r
+static const char *engine_ibmca_name = "Ibmca hardware engine support";\r
+\r
+/* This internal function is used by ENGINE_ibmca() and possibly by the\r
+ * "dynamic" ENGINE support too */\r
+static int bind_helper(ENGINE *e)\r
+ {\r
+#ifndef OPENSSL_NO_RSA\r
+ const RSA_METHOD *meth1;\r
+#endif\r
+#ifndef OPENSSL_NO_DSA\r
+ const DSA_METHOD *meth2;\r
+#endif\r
+#ifndef OPENSSL_NO_DH\r
+ const DH_METHOD *meth3;\r
+#endif\r
+ if(!ENGINE_set_id(e, engine_ibmca_id) ||\r
+ !ENGINE_set_name(e, engine_ibmca_name) ||\r
+#ifndef OPENSSL_NO_RSA\r
+ !ENGINE_set_RSA(e, &ibmca_rsa) ||\r
+#endif\r
+#ifndef OPENSSL_NO_DSA\r
+ !ENGINE_set_DSA(e, &ibmca_dsa) ||\r
+#endif\r
+#ifndef OPENSSL_NO_DH\r
+ !ENGINE_set_DH(e, &ibmca_dh) ||\r
+#endif\r
+ !ENGINE_set_RAND(e, &ibmca_rand) ||\r
+ !ENGINE_set_destroy_function(e, ibmca_destroy) ||\r
+ !ENGINE_set_init_function(e, ibmca_init) ||\r
+ !ENGINE_set_finish_function(e, ibmca_finish) ||\r
+ !ENGINE_set_ctrl_function(e, ibmca_ctrl) ||\r
+ !ENGINE_set_cmd_defns(e, ibmca_cmd_defns))\r
+ return 0;\r
+\r
+#ifndef OPENSSL_NO_RSA\r
+ /* We know that the "PKCS1_SSLeay()" functions hook properly\r
+ * to the ibmca-specific mod_exp and mod_exp_crt so we use\r
+ * those functions. NB: We don't use ENGINE_openssl() or\r
+ * anything "more generic" because something like the RSAref\r
+ * code may not hook properly, and if you own one of these\r
+ * cards then you have the right to do RSA operations on it\r
+ * anyway! */ \r
+ meth1 = RSA_PKCS1_SSLeay();\r
+ ibmca_rsa.rsa_pub_enc = meth1->rsa_pub_enc;\r
+ ibmca_rsa.rsa_pub_dec = meth1->rsa_pub_dec;\r
+ ibmca_rsa.rsa_priv_enc = meth1->rsa_priv_enc;\r
+ ibmca_rsa.rsa_priv_dec = meth1->rsa_priv_dec;\r
+#endif\r
+\r
+#ifndef OPENSSL_NO_DSA\r
+ /* Use the DSA_OpenSSL() method and just hook the mod_exp-ish\r
+ * bits. */\r
+ meth2 = DSA_OpenSSL();\r
+ ibmca_dsa.dsa_do_sign = meth2->dsa_do_sign;\r
+ ibmca_dsa.dsa_sign_setup = meth2->dsa_sign_setup;\r
+ ibmca_dsa.dsa_do_verify = meth2->dsa_do_verify;\r
+#endif\r
+\r
+#ifndef OPENSSL_NO_DH\r
+ /* Much the same for Diffie-Hellman */\r
+ meth3 = DH_OpenSSL();\r
+ ibmca_dh.generate_key = meth3->generate_key;\r
+ ibmca_dh.compute_key = meth3->compute_key;\r
+#endif\r
+\r
+ /* Ensure the ibmca error handling is set up */\r
+ ERR_load_IBMCA_strings(); \r
+ return 1;\r
+ }\r
+\r
+static ENGINE *engine_ibmca(void)\r
+ {\r
+ ENGINE *ret = ENGINE_new();\r
+ if(!ret)\r
+ return NULL;\r
+ if(!bind_helper(ret))\r
+ {\r
+ ENGINE_free(ret);\r
+ return NULL;\r
+ }\r
+ return ret;\r
+ }\r
+\r
+void ENGINE_load_ibmca(void)\r
+ {\r
+ /* Copied from eng_[openssl|dyn].c */\r
+ ENGINE *toadd = engine_ibmca();\r
+ if(!toadd) return;\r
+ ENGINE_add(toadd);\r
+ ENGINE_free(toadd);\r
+ ERR_clear_error();\r
+ }\r
+\r
+/* Destructor (complements the "ENGINE_ibmca()" constructor) */\r
+static int ibmca_destroy(ENGINE *e)\r
+ {\r
+ /* Unload the ibmca error strings so any error state including our\r
+ * functs or reasons won't lead to a segfault (they simply get displayed\r
+ * without corresponding string data because none will be found). */\r
+ ERR_unload_IBMCA_strings(); \r
+ return 1;\r
+ }\r
+\r
+\r
+/* This is a process-global DSO handle used for loading and unloading\r
+ * the Ibmca library. NB: This is only set (or unset) during an\r
+ * init() or finish() call (reference counts permitting) and they're\r
+ * operating with global locks, so this should be thread-safe\r
+ * implicitly. */\r
+\r
+static DSO *ibmca_dso = NULL;\r
+\r
+/* These are the function pointers that are (un)set when the library has\r
+ * successfully (un)loaded. */\r
+\r
+static unsigned int (ICA_CALL *p_icaOpenAdapter)();\r
+static unsigned int (ICA_CALL *p_icaCloseAdapter)();\r
+static unsigned int (ICA_CALL *p_icaRsaModExpo)();\r
+static unsigned int (ICA_CALL *p_icaRandomNumberGenerate)();\r
+static unsigned int (ICA_CALL *p_icaRsaCrt)();\r
+\r
+/* utility function to obtain a context */\r
+static int get_context(ICA_ADAPTER_HANDLE *p_handle)\r
+ {\r
+ unsigned int status=0;\r
+\r
+ status = p_icaOpenAdapter(0, p_handle);\r
+ if(status != 0)\r
+ return 0;\r
+ return 1;\r
+ }\r
+\r
+/* similarly to release one. */\r
+static void release_context(ICA_ADAPTER_HANDLE handle)\r
+ {\r
+ p_icaCloseAdapter(handle);\r
+ }\r
+\r
+/* (de)initialisation functions. */\r
+static int ibmca_init(ENGINE *e)\r
+ {\r
+\r
+ void (*p1)();\r
+ void (*p2)();\r
+ void (*p3)();\r
+ void (*p4)();\r
+ void (*p5)();\r
+\r
+ if(ibmca_dso != NULL)\r
+ {\r
+ IBMCAerr(IBMCA_F_IBMCA_INIT,IBMCA_R_ALREADY_LOADED);\r
+ goto err;\r
+ }\r
+ /* Attempt to load libatasi.so/atasi.dll/whatever. Needs to be\r
+ * changed unfortunately because the Ibmca drivers don't have\r
+ * standard library names that can be platform-translated well. */\r
+ /* TODO: Work out how to actually map to the names the Ibmca\r
+ * drivers really use - for now a symbollic link needs to be\r
+ * created on the host system from libatasi.so to atasi.so on\r
+ * unix variants. */\r
+\r
+ /* WJH XXX check name translation */\r
+\r
+ ibmca_dso = DSO_load(NULL, IBMCA_LIBNAME, NULL,\r
+ /* DSO_FLAG_NAME_TRANSLATION */ 0);\r
+ if(ibmca_dso == NULL)\r
+ {\r
+ IBMCAerr(IBMCA_F_IBMCA_INIT,IBMCA_R_DSO_FAILURE);\r
+ goto err;\r
+ }\r
+\r
+ if(!(p1 = DSO_bind_func(\r
+ ibmca_dso, IBMCA_F1)) ||\r
+ !(p2 = DSO_bind_func(\r
+ ibmca_dso, IBMCA_F2)) ||\r
+ !(p3 = DSO_bind_func(\r
+ ibmca_dso, IBMCA_F3)) ||\r
+ !(p4 = DSO_bind_func(\r
+ ibmca_dso, IBMCA_F4)) ||\r
+ !(p5 = DSO_bind_func(\r
+ ibmca_dso, IBMCA_F5)))\r
+ {\r
+ IBMCAerr(IBMCA_F_IBMCA_INIT,IBMCA_R_DSO_FAILURE);\r
+ goto err;\r
+ }\r
+\r
+ /* Copy the pointers */\r
+\r
+ p_icaOpenAdapter = (unsigned int (ICA_CALL *)())p1;\r
+ p_icaCloseAdapter = (unsigned int (ICA_CALL *)())p2;\r
+ p_icaRsaModExpo = (unsigned int (ICA_CALL *)())p3;\r
+ p_icaRandomNumberGenerate = (unsigned int (ICA_CALL *)())p4;\r
+ p_icaRsaCrt = (unsigned int (ICA_CALL *)())p5;\r
+\r
+ if(!get_context(&handle))\r
+ {\r
+ IBMCAerr(IBMCA_F_IBMCA_INIT,IBMCA_R_UNIT_FAILURE);\r
+ goto err;\r
+ }\r
+\r
+ return 1;\r
+ err:\r
+ if(ibmca_dso)\r
+ DSO_free(ibmca_dso);\r
+\r
+ p_icaOpenAdapter = NULL;\r
+ p_icaCloseAdapter = NULL;\r
+ p_icaRsaModExpo = NULL;\r
+ p_icaRandomNumberGenerate = NULL;\r
+\r
+ return 0;\r
+ }\r
+\r
+static int ibmca_finish(ENGINE *e)\r
+ {\r
+ if(ibmca_dso == NULL)\r
+ {\r
+ IBMCAerr(IBMCA_F_IBMCA_FINISH,IBMCA_R_NOT_LOADED);\r
+ return 0;\r
+ }\r
+ release_context(handle);\r
+ if(!DSO_free(ibmca_dso))\r
+ {\r
+ IBMCAerr(IBMCA_F_IBMCA_FINISH,IBMCA_R_DSO_FAILURE);\r
+ return 0;\r
+ }\r
+ ibmca_dso = NULL;\r
+\r
+ return 1;\r
+ }\r
+\r
+static int ibmca_ctrl(ENGINE *e, int cmd, long i, void *p, void (*f)())\r
+ {\r
+ int initialised = ((ibmca_dso == NULL) ? 0 : 1);\r
+ switch(cmd)\r
+ {\r
+ case IBMCA_CMD_SO_PATH:\r
+ if(p == NULL)\r
+ {\r
+ IBMCAerr(IBMCA_F_IBMCA_CTRL,ERR_R_PASSED_NULL_PARAMETER);\r
+ return 0;\r
+ }\r
+ if(initialised)\r
+ {\r
+ IBMCAerr(IBMCA_F_IBMCA_CTRL,IBMCA_R_ALREADY_LOADED);\r
+ return 0;\r
+ }\r
+ IBMCA_LIBNAME = (const char *)p;\r
+ return 1;\r
+ default:\r
+ break;\r
+ }\r
+ IBMCAerr(IBMCA_F_IBMCA_CTRL,IBMCA_R_CTRL_COMMAND_NOT_IMPLEMENTED);\r
+ return 0;\r
+ }\r
+\r
+\r
+static int ibmca_mod_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,\r
+ const BIGNUM *m, BN_CTX *ctx)\r
+ {\r
+ /* I need somewhere to store temporary serialised values for\r
+ * use with the Ibmca API calls. A neat cheat - I'll use\r
+ * BIGNUMs from the BN_CTX but access their arrays directly as\r
+ * byte arrays <grin>. This way I don't have to clean anything\r
+ * up. */\r
+\r
+ BIGNUM *argument=NULL;\r
+ BIGNUM *result=NULL;\r
+ BIGNUM *key=NULL;\r
+ int to_return;\r
+ int inLen, outLen, tmpLen;\r
+\r
+\r
+ ICA_KEY_RSA_MODEXPO *publKey=NULL;\r
+ unsigned int rc;\r
+\r
+ to_return = 0; /* expect failure */\r
+\r
+ if(!ibmca_dso)\r
+ {\r
+ IBMCAerr(IBMCA_F_IBMCA_MOD_EXP,IBMCA_R_NOT_LOADED);\r
+ goto err;\r
+ }\r
+ /* Prepare the params */\r
+ BN_CTX_start(ctx);\r
+ argument = BN_CTX_get(ctx);\r
+ result = BN_CTX_get(ctx);\r
+ key = BN_CTX_get(ctx);\r
+\r
+ if( !argument || !result || !key)\r
+ {\r
+ IBMCAerr(IBMCA_F_IBMCA_MOD_EXP,IBMCA_R_BN_CTX_FULL);\r
+ goto err;\r
+ }\r
+\r
+\r
+ if(!bn_wexpand(argument, m->top) || !bn_wexpand(result, m->top) ||\r
+ !bn_wexpand(key, sizeof(*publKey)/BN_BYTES))\r
+\r
+ {\r
+ IBMCAerr(IBMCA_F_IBMCA_MOD_EXP,IBMCA_R_BN_EXPAND_FAIL);\r
+ goto err;\r
+ }\r
+\r
+ publKey = (ICA_KEY_RSA_MODEXPO *)key->d;\r
+\r
+ if (publKey == NULL)\r
+ {\r
+ goto err;\r
+ }\r
+ memset(publKey, 0, sizeof(ICA_KEY_RSA_MODEXPO));\r
+\r
+ publKey->keyType = CORRECT_ENDIANNESS(ME_KEY_TYPE);\r
+ publKey->keyLength = CORRECT_ENDIANNESS(sizeof(ICA_KEY_RSA_MODEXPO));\r
+ publKey->expOffset = (char *) publKey->keyRecord - (char *) publKey;\r
+\r
+ /* A quirk of the card: the exponent length has to be the same\r
+ as the modulus (key) length */\r
+\r
+ outLen = BN_num_bytes(m);\r
+\r
+/* check for modulus length SAB*/\r
+ if (outLen > 256 ) {\r
+ IBMCAerr(IBMCA_F_IBMCA_MOD_EXP,IBMCA_R_MEXP_LENGTH_TO_LARGE);\r
+ goto err;\r
+ }\r
+/* check for modulus length SAB*/\r
+\r
+\r
+ publKey->expLength = publKey->nLength = outLen;\r
+/* SAB Check for underflow condition\r
+ the size of the exponent is less than the size of the parameter\r
+ then we have a big problem and will underflow the keyRecord\r
+ buffer. Bad stuff could happen then\r
+*/\r
+if (outLen < BN_num_bytes(p)){\r
+ IBMCAerr(IBMCA_F_IBMCA_MOD_EXP,IBMCA_R_UNDERFLOW_KEYRECORD);\r
+ goto err;\r
+}\r
+/* SAB End check for underflow */\r
+\r
+\r
+ BN_bn2bin(p, &publKey->keyRecord[publKey->expLength -\r
+ BN_num_bytes(p)]);\r
+ BN_bn2bin(m, &publKey->keyRecord[publKey->expLength]);\r
+\r
+\r
+\r
+ publKey->modulusBitLength = CORRECT_ENDIANNESS(publKey->nLength * 8);\r
+ publKey->nOffset = CORRECT_ENDIANNESS(publKey->expOffset + \r
+ publKey->expLength);\r
+\r
+ publKey->expOffset = CORRECT_ENDIANNESS((char *) publKey->keyRecord - \r
+ (char *) publKey);\r
+\r
+ tmpLen = outLen;\r
+ publKey->expLength = publKey->nLength = CORRECT_ENDIANNESS(tmpLen);\r
+\r
+ /* Prepare the argument */\r
+\r
+ memset(argument->d, 0, outLen);\r
+ BN_bn2bin(a, (unsigned char *)argument->d + outLen -\r
+ BN_num_bytes(a));\r
+\r
+ inLen = outLen;\r
+\r
+ /* Perform the operation */\r
+\r
+ if( (rc = p_icaRsaModExpo(handle, inLen,(unsigned char *)argument->d,\r
+ publKey, &outLen, (unsigned char *)result->d))\r
+ !=0 )\r
+\r
+ {\r
+ printf("rc = %d\n", rc);\r
+ IBMCAerr(IBMCA_F_IBMCA_MOD_EXP,IBMCA_R_REQUEST_FAILED);\r
+ goto err;\r
+ }\r
+\r
+\r
+ /* Convert the response */\r
+ BN_bin2bn((unsigned char *)result->d, outLen, r);\r
+ to_return = 1;\r
+ err:\r
+ BN_CTX_end(ctx);\r
+ return to_return;\r
+ }\r
+\r
+#ifndef OPENSSL_NO_RSA \r
+static int ibmca_rsa_mod_exp(BIGNUM *r0, const BIGNUM *I, RSA *rsa)\r
+ {\r
+ BN_CTX *ctx;\r
+ int to_return = 0;\r
+\r
+ if((ctx = BN_CTX_new()) == NULL)\r
+ goto err;\r
+ if(!rsa->p || !rsa->q || !rsa->dmp1 || !rsa->dmq1 || !rsa->iqmp)\r
+ {\r
+ if(!rsa->d || !rsa->n)\r
+ {\r
+ IBMCAerr(IBMCA_F_IBMCA_RSA_MOD_EXP,\r
+ IBMCA_R_MISSING_KEY_COMPONENTS);\r
+ goto err;\r
+ }\r
+ to_return = ibmca_mod_exp(r0, I, rsa->d, rsa->n, ctx);\r
+ }\r
+ else\r
+ {\r
+ to_return = ibmca_mod_exp_crt(r0, I, rsa->p, rsa->q, rsa->dmp1,\r
+ rsa->dmq1, rsa->iqmp, ctx);\r
+ }\r
+ err:\r
+ if(ctx)\r
+ BN_CTX_free(ctx);\r
+ return to_return;\r
+ }\r
+#endif\r
+\r
+/* Ein kleines chinesisches "Restessen" */\r
+static int ibmca_mod_exp_crt(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,\r
+ const BIGNUM *q, const BIGNUM *dmp1,\r
+ const BIGNUM *dmq1, const BIGNUM *iqmp, BN_CTX *ctx)\r
+ {\r
+\r
+ BIGNUM *argument = NULL;\r
+ BIGNUM *result = NULL;\r
+ BIGNUM *key = NULL;\r
+\r
+ int to_return = 0; /* expect failure */\r
+\r
+ char *pkey=NULL;\r
+ ICA_KEY_RSA_CRT *privKey=NULL;\r
+ int inLen, outLen;\r
+\r
+ int rc;\r
+ unsigned int offset, pSize, qSize;\r
+/* SAB New variables */\r
+ unsigned int keyRecordSize;\r
+ unsigned int pbytes = BN_num_bytes(p);\r
+ unsigned int qbytes = BN_num_bytes(q);\r
+ unsigned int dmp1bytes = BN_num_bytes(dmp1);\r
+ unsigned int dmq1bytes = BN_num_bytes(dmq1);\r
+ unsigned int iqmpbytes = BN_num_bytes(iqmp);\r
+\r
+ /* Prepare the params */\r
+\r
+ BN_CTX_start(ctx);\r
+ argument = BN_CTX_get(ctx);\r
+ result = BN_CTX_get(ctx);\r
+ key = BN_CTX_get(ctx);\r
+\r
+ if(!argument || !result || !key)\r
+ {\r
+ IBMCAerr(IBMCA_F_IBMCA_MOD_EXP_CRT,IBMCA_R_BN_CTX_FULL);\r
+ goto err;\r
+ }\r
+\r
+ if(!bn_wexpand(argument, p->top + q->top) ||\r
+ !bn_wexpand(result, p->top + q->top) ||\r
+ !bn_wexpand(key, sizeof(*privKey)/BN_BYTES ))\r
+ {\r
+ IBMCAerr(IBMCA_F_IBMCA_MOD_EXP_CRT,IBMCA_R_BN_EXPAND_FAIL);\r
+ goto err;\r
+ }\r
+\r
+\r
+ privKey = (ICA_KEY_RSA_CRT *)key->d;\r
+/* SAB Add check for total size in bytes of the parms does not exceed\r
+ the buffer space we have\r
+ do this first\r
+*/\r
+ keyRecordSize = pbytes+qbytes+dmp1bytes+dmq1bytes+iqmpbytes;\r
+ if ( keyRecordSize > sizeof(privKey->keyRecord )) {\r
+ IBMCAerr(IBMCA_F_IBMCA_MOD_EXP_CRT,IBMCA_R_OPERANDS_TO_LARGE);\r
+ goto err;\r
+ }\r
+\r
+ if ( (qbytes + dmq1bytes) > 256 ){\r
+ IBMCAerr(IBMCA_F_IBMCA_MOD_EXP_CRT,IBMCA_R_OPERANDS_TO_LARGE);\r
+ goto err;\r
+ }\r
+\r
+ if ( pbytes + dmp1bytes > 256 ) {\r
+ IBMCAerr(IBMCA_F_IBMCA_MOD_EXP_CRT,IBMCA_R_OPERANDS_TO_LARGE);\r
+ goto err;\r
+ }\r
+\r
+/* end SAB additions */\r
+ \r
+ memset(privKey, 0, sizeof(ICA_KEY_RSA_CRT));\r
+ privKey->keyType = CORRECT_ENDIANNESS(CRT_KEY_TYPE);\r
+ privKey->keyLength = CORRECT_ENDIANNESS(sizeof(ICA_KEY_RSA_CRT));\r
+ privKey->modulusBitLength = \r
+ CORRECT_ENDIANNESS(BN_num_bytes(q) * 2 * 8);\r
+\r
+ /*\r
+ * p,dp & qInv are 1 QWORD Larger\r
+ */\r
+ privKey->pLength = CORRECT_ENDIANNESS(BN_num_bytes(p)+8);\r
+ privKey->qLength = CORRECT_ENDIANNESS(BN_num_bytes(q));\r
+ privKey->dpLength = CORRECT_ENDIANNESS(BN_num_bytes(dmp1)+8);\r
+ privKey->dqLength = CORRECT_ENDIANNESS(BN_num_bytes(dmq1));\r
+ privKey->qInvLength = CORRECT_ENDIANNESS(BN_num_bytes(iqmp)+8);\r
+\r
+ offset = (char *) privKey->keyRecord\r
+ - (char *) privKey;\r
+\r
+ qSize = BN_num_bytes(q);\r
+ pSize = qSize + 8; /* 1 QWORD larger */\r
+\r
+\r
+/* SAB probably aittle redundant, but we'll verify that each of the\r
+ components which make up a key record sent ot the card does not exceed\r
+ the space that is allocated for it. this handles the case where even if\r
+ the total length does not exceed keyrecord zied, if the operands are funny sized\r
+they could cause potential side affects on either the card or the result */\r
+\r
+ if ( (pbytes > pSize) || (dmp1bytes > pSize) ||\r
+ (iqmpbytes > pSize) || ( qbytes >qSize) ||\r
+ (dmq1bytes > qSize) ) {\r
+ IBMCAerr(IBMCA_F_IBMCA_MOD_EXP_CRT, IBMCA_R_OPERANDS_TO_LARGE);\r
+ goto err;\r
+\r
+ }\r
+ \r
+\r
+ privKey->dpOffset = CORRECT_ENDIANNESS(offset);\r
+\r
+ offset += pSize;\r
+ privKey->dqOffset = CORRECT_ENDIANNESS(offset);\r
+\r
+ offset += qSize;\r
+ privKey->pOffset = CORRECT_ENDIANNESS(offset);\r
+\r
+ offset += pSize;\r
+ privKey->qOffset = CORRECT_ENDIANNESS(offset);\r
+\r
+ offset += qSize;\r
+ privKey->qInvOffset = CORRECT_ENDIANNESS(offset);\r
+\r
+ pkey = (char *) privKey->keyRecord;\r
+\r
+\r
+/* SAB first check that we don;t under flow the buffer */\r
+ if ( pSize < pbytes ) {\r
+ IBMCAerr(IBMCA_F_IBMCA_MOD_EXP_CRT, IBMCA_R_UNDERFLOW_CONDITION);\r
+ goto err;\r
+ }\r
+\r
+ /* pkey += pSize - BN_num_bytes(p); WROING this should be dmp1) */\r
+ pkey += pSize - BN_num_bytes(dmp1);\r
+ BN_bn2bin(dmp1, pkey); \r
+ pkey += BN_num_bytes(dmp1); /* move the pointer */\r
+\r
+ BN_bn2bin(dmq1, pkey); /* Copy over dmq1 */\r
+\r
+ pkey += qSize; /* move pointer */\r
+ pkey += pSize - BN_num_bytes(p); /* set up for zero padding of next field */\r
+\r
+ BN_bn2bin(p, pkey);\r
+ pkey += BN_num_bytes(p); /* increment pointer by number of bytes moved */\r
+\r
+ BN_bn2bin(q, pkey);\r
+ pkey += qSize ; /* move the pointer */\r
+ pkey += pSize - BN_num_bytes(iqmp); /* Adjust for padding */\r
+ BN_bn2bin(iqmp, pkey);\r
+\r
+ /* Prepare the argument and response */\r
+\r
+ outLen = CORRECT_ENDIANNESS(privKey->qLength) * 2; /* Correct endianess is used \r
+ because the fields were converted above */\r
+\r
+ if (outLen > 256) {\r
+ IBMCAerr(IBMCA_F_IBMCA_MOD_EXP_CRT,IBMCA_R_OUTLEN_TO_LARGE);\r
+ goto err;\r
+ }\r
+\r
+ /* SAB check for underflow here on the argeument */\r
+ if ( outLen < BN_num_bytes(a)) {\r
+ IBMCAerr(IBMCA_F_IBMCA_MOD_EXP_CRT,IBMCA_R_UNDERFLOW_CONDITION);\r
+ goto err;\r
+ }\r
+\r
+ BN_bn2bin(a, (unsigned char *)argument->d + outLen -\r
+ BN_num_bytes(a));\r
+ inLen = outLen;\r
+\r
+ memset(result->d, 0, outLen);\r
+\r
+ /* Perform the operation */\r
+\r
+ if ( (rc = p_icaRsaCrt(handle, inLen, (unsigned char *)argument->d,\r
+ privKey, &outLen, (unsigned char *)result->d)) != 0)\r
+ {\r
+ printf("rc = %d\n", rc);\r
+ IBMCAerr(IBMCA_F_IBMCA_MOD_EXP_CRT,IBMCA_R_REQUEST_FAILED);\r
+ goto err;\r
+ }\r
+\r
+ /* Convert the response */\r
+\r
+ BN_bin2bn((unsigned char *)result->d, outLen, r);\r
+ to_return = 1;\r
+\r
+ err:\r
+ BN_CTX_end(ctx);\r
+ return to_return;\r
+\r
+ }\r
+\r
+#ifndef OPENSSL_NO_DSA\r
+/* This code was liberated and adapted from the commented-out code in\r
+ * dsa_ossl.c. Because of the unoptimised form of the Ibmca acceleration\r
+ * (it doesn't have a CRT form for RSA), this function means that an\r
+ * Ibmca system running with a DSA server certificate can handshake\r
+ * around 5 or 6 times faster/more than an equivalent system running with\r
+ * RSA. Just check out the "signs" statistics from the RSA and DSA parts\r
+ * of "openssl speed -engine ibmca dsa1024 rsa1024". */\r
+static int ibmca_dsa_mod_exp(DSA *dsa, BIGNUM *rr, BIGNUM *a1,\r
+ BIGNUM *p1, BIGNUM *a2, BIGNUM *p2, BIGNUM *m,\r
+ BN_CTX *ctx, BN_MONT_CTX *in_mont)\r
+ {\r
+ BIGNUM t;\r
+ int to_return = 0;\r
+\r
+ BN_init(&t);\r
+ /* let rr = a1 ^ p1 mod m */\r
+ if (!ibmca_mod_exp(rr,a1,p1,m,ctx)) goto end;\r
+ /* let t = a2 ^ p2 mod m */\r
+ if (!ibmca_mod_exp(&t,a2,p2,m,ctx)) goto end;\r
+ /* let rr = rr * t mod m */\r
+ if (!BN_mod_mul(rr,rr,&t,m,ctx)) goto end;\r
+ to_return = 1;\r
+ end:\r
+ BN_free(&t);\r
+ return to_return;\r
+ }\r
+\r
+\r
+static int ibmca_mod_exp_dsa(DSA *dsa, BIGNUM *r, BIGNUM *a,\r
+ const BIGNUM *p, const BIGNUM *m, BN_CTX *ctx,\r
+ BN_MONT_CTX *m_ctx)\r
+ {\r
+ return ibmca_mod_exp(r, a, p, m, ctx);\r
+ }\r
+#endif\r
+\r
+/* This function is aliased to mod_exp (with the mont stuff dropped). */\r
+static int ibmca_mod_exp_mont(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,\r
+ const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx)\r
+ {\r
+ return ibmca_mod_exp(r, a, p, m, ctx);\r
+ }\r
+\r
+#ifndef OPENSSL_NO_DH \r
+/* This function is aliased to mod_exp (with the dh and mont dropped). */\r
+static int ibmca_mod_exp_dh(DH const *dh, BIGNUM *r, \r
+ const BIGNUM *a, const BIGNUM *p, \r
+ const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx)\r
+ {\r
+ return ibmca_mod_exp(r, a, p, m, ctx);\r
+ }\r
+#endif\r
+\r
+/* Random bytes are good */\r
+static int ibmca_rand_bytes(unsigned char *buf, int num)\r
+ {\r
+ int to_return = 0; /* assume failure */\r
+ unsigned int ret;\r
+\r
+\r
+ if(handle == 0)\r
+ {\r
+ IBMCAerr(IBMCA_F_IBMCA_RAND_BYTES,IBMCA_R_NOT_INITIALISED);\r
+ goto err;\r
+ }\r
+\r
+ ret = p_icaRandomNumberGenerate(handle, num, buf);\r
+ if (ret < 0)\r
+ {\r
+ IBMCAerr(IBMCA_F_IBMCA_RAND_BYTES,IBMCA_R_REQUEST_FAILED);\r
+ goto err;\r
+ }\r
+ to_return = 1;\r
+ err:\r
+ return to_return;\r
+ }\r
+\r
+static int ibmca_rand_status(void)\r
+ {\r
+ return 1;\r
+ }\r
+\r
+/* This stuff is needed if this ENGINE is being compiled into a self-contained\r
+ * shared-library. */\r
+#ifdef ENGINE_DYNAMIC_SUPPORT\r
+static int bind_fn(ENGINE *e, const char *id)\r
+ {\r
+ if(id && (strcmp(id, engine_ibmca_id) != 0)) /* WJH XXX */\r
+ return 0;\r
+ if(!bind_helper(e))\r
+ return 0;\r
+ return 1;\r
+ }\r
+IMPLEMENT_DYNAMIC_CHECK_FN()\r
+IMPLEMENT_DYNAMIC_BIND_FN(bind_fn)\r
+#endif /* ENGINE_DYNAMIC_SUPPORT */\r
+\r
+\r
+#endif /* !OPENSSL_NO_HW_IBMCA */\r
+#endif /* !OPENSSL_NO_HW */\r
--- /dev/null
+# 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
--- /dev/null
+/* 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 <stdio.h>
+#include <openssl/err.h>
+#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);
+ }
--- /dev/null
+/* ====================================================================
+ * 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
--- /dev/null
+
+#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__ */
--- /dev/null
+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
--- /dev/null
+/* crypto/engine/hw_zencod.c */
+ /* Written by Fred Donnat (frederic.donnat@zencod.com) for "zencod"
+ * engine integration in order to redirect crypto computing on a crypto
+ * hardware accelerator zenssl32 ;-)
+ *
+ * Date : 25 jun 2002
+ * Revision : 17 Ju7 2002
+ * Version : zencod_engine-0.9.7
+ */
+
+/* ====================================================================
+ * Copyright (c) 1999-2001 The OpenSSL Project. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in
+ * the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * 3. All advertising materials mentioning features or use of this
+ * software must display the following acknowledgment:
+ * "This product includes software developed by the OpenSSL Project
+ * for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
+ *
+ * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
+ * endorse or promote products derived from this software without
+ * prior written permission. For written permission, please contact
+ * licensing@OpenSSL.org.
+ *
+ * 5. Products derived from this software may not be called "OpenSSL"
+ * nor may "OpenSSL" appear in their names without prior written
+ * permission of the OpenSSL Project.
+ *
+ * 6. Redistributions of any form whatsoever must retain the following
+ * acknowledgment:
+ * "This product includes software developed by the OpenSSL Project
+ * for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
+ * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
+ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ * ====================================================================
+ *
+ * This product includes cryptographic software written by Eric Young
+ * (eay@cryptsoft.com). This product includes software written by Tim
+ * Hudson (tjh@cryptsoft.com).
+ *
+ */
+
+
+/* ENGINE general include */
+#include <stdio.h>
+#include <openssl/crypto.h>
+#include <openssl/dso.h>
+#include <openssl/engine.h>
+
+#ifndef OPENSSL_NO_HW
+#ifndef OPENSSL_NO_HW_ZENCOD
+
+#ifdef FLAT_INC
+# include "hw_zencod.h"
+#else
+# include "vendor_defns/hw_zencod.h"
+#endif
+
+#define ZENCOD_LIB_NAME "zencod engine"
+#include "hw_zencod_err.c"
+
+#define FAIL_TO_SOFTWARE -15
+
+#define ZEN_LIBRARY "zenbridge"
+
+#if 0
+# define PERROR(s) perror(s)
+# define CHEESE() fputs("## [ZenEngine] ## " __FUNCTION__ "\n", stderr)
+#else
+# define PERROR(s)
+# define CHEESE()
+#endif
+
+
+/* Sorry ;) */
+#ifndef WIN32
+static inline void esrever ( unsigned char *d, int l )
+{
+ for(;--l>0;--l,d++){*d^=*(d+l);*(d+l)^=*d;*d^=*(d+l);}
+}
+
+static inline void ypcmem ( unsigned char *d, const unsigned char *s, int l )
+{
+ for(d+=l;l--;)*--d=*s++;
+}
+#else
+static __inline void esrever ( unsigned char *d, int l )
+{
+ for(;--l>0;--l,d++){*d^=*(d+l);*(d+l)^=*d;*d^=*(d+l);}
+}
+
+static __inline void ypcmem ( unsigned char *d, const unsigned char *s, int l )
+{
+ for(d+=l;l--;)*--d=*s++;
+}
+#endif
+
+
+#define BIGNUM2ZEN(n, bn) (ptr_zencod_init_number((n), \
+ (unsigned long) ((bn)->top * BN_BITS2), \
+ (unsigned char *) ((bn)->d)))
+
+#define ZEN_BITS(n, bytes) (ptr_zencod_bytes2bits((unsigned char *) (n), (unsigned long) (bytes)))
+#define ZEN_BYTES(bits) (ptr_zencod_bits2bytes((unsigned long) (bits)))
+
+
+/* Function for ENGINE detection and control */
+static int zencod_destroy ( ENGINE *e ) ;
+static int zencod_init ( ENGINE *e ) ;
+static int zencod_finish ( ENGINE *e ) ;
+static int zencod_ctrl ( ENGINE *e, int cmd, long i, void *p, void (*f) () ) ;
+
+/* BIGNUM stuff */
+static int zencod_bn_mod_exp ( BIGNUM *r, const BIGNUM *a, const BIGNUM *p, const BIGNUM *m, BN_CTX *ctx ) ;
+
+/* RSA stuff */
+#ifndef OPENSSL_NO_RSA
+static int RSA_zencod_rsa_mod_exp ( BIGNUM *r0, const BIGNUM *I, RSA *rsa ) ;
+static int RSA_zencod_bn_mod_exp ( BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
+ const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx ) ;
+#endif
+
+/* DSA stuff */
+#ifndef OPENSSL_NO_DSA
+static int DSA_zencod_bn_mod_exp ( DSA *dsa, BIGNUM *r, BIGNUM *a, const BIGNUM *p, const BIGNUM *m, BN_CTX *ctx,
+ BN_MONT_CTX *m_ctx ) ;
+
+static DSA_SIG *DSA_zencod_do_sign ( const unsigned char *dgst, int dlen, DSA *dsa ) ;
+static int DSA_zencod_do_verify ( const unsigned char *dgst, int dgst_len, DSA_SIG *sig,
+ DSA *dsa ) ;
+#endif
+
+/* DH stuff */
+#ifndef OPENSSL_NO_DH
+static int DH_zencod_bn_mod_exp ( const DH *dh, BIGNUM *r, const BIGNUM *a, const BIGNUM *p, const BIGNUM *m, BN_CTX *ctx,
+ BN_MONT_CTX *m_ctx ) ;
+static int DH_zencod_generate_key ( DH *dh ) ;
+static int DH_zencod_compute_key ( unsigned char *key, const BIGNUM *pub_key, DH *dh ) ;
+#endif
+
+/* Rand stuff */
+static void RAND_zencod_seed ( const void *buf, int num ) ;
+static int RAND_zencod_rand_bytes ( unsigned char *buf, int num ) ;
+static int RAND_zencod_rand_status ( void ) ;
+
+/* Digest Stuff */
+static int engine_digests ( ENGINE *e, const EVP_MD **digest, const int **nids, int nid ) ;
+
+/* Cipher Stuff */
+static int engine_ciphers ( ENGINE *e, const EVP_CIPHER **cipher, const int **nids, int nid ) ;
+
+
+#define ZENCOD_CMD_SO_PATH ENGINE_CMD_BASE
+static const ENGINE_CMD_DEFN zencod_cmd_defns [ ] =
+{
+ { ZENCOD_CMD_SO_PATH,
+ "SO_PATH",
+ "Specifies the path to the 'zenbridge' shared library",
+ ENGINE_CMD_FLAG_STRING},
+ { 0, NULL, NULL, 0 }
+} ;
+
+
+#ifndef OPENSSL_NO_RSA
+/* Our internal RSA_METHOD specific to zencod ENGINE providing pointers to our function */
+static RSA_METHOD zencod_rsa =
+{
+ "ZENCOD RSA method",
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ RSA_zencod_rsa_mod_exp,
+ RSA_zencod_bn_mod_exp,
+ NULL,
+ NULL,
+ 0,
+ NULL,
+ NULL,
+ NULL
+} ;
+#endif
+
+#ifndef OPENSSL_NO_DSA
+/* Our internal DSA_METHOD specific to zencod ENGINE providing pointers to our function */
+static DSA_METHOD zencod_dsa =
+{
+ "ZENCOD DSA method",
+ DSA_zencod_do_sign,
+ NULL,
+ DSA_zencod_do_verify,
+ NULL,
+ DSA_zencod_bn_mod_exp,
+ NULL,
+ NULL,
+ 0,
+ NULL
+} ;
+#endif
+
+#ifndef OPENSSL_NO_DH
+/* Our internal DH_METHOD specific to zencod ENGINE providing pointers to our function */
+static DH_METHOD zencod_dh =
+{
+ "ZENCOD DH method",
+ DH_zencod_generate_key,
+ DH_zencod_compute_key,
+ DH_zencod_bn_mod_exp,
+ NULL,
+ NULL,
+ 0,
+ NULL
+} ;
+#endif
+
+/* Our internal RAND_meth specific to zencod ZNGINE providing pointers to our function */
+static RAND_METHOD zencod_rand =
+{
+ RAND_zencod_seed,
+ RAND_zencod_rand_bytes,
+ NULL,
+ NULL,
+ RAND_zencod_rand_bytes,
+ RAND_zencod_rand_status
+} ;
+
+
+/* Constants used when creating the ENGINE */
+static const char *engine_zencod_id = "zencod";
+static const char *engine_zencod_name = "ZENCOD hardware engine support";
+
+
+/* This internal function is used by ENGINE_zencod () and possibly by the
+ * "dynamic" ENGINE support too ;-)
+ */
+static int bind_helper ( ENGINE *e )
+{
+
+#ifndef OPENSSL_NO_RSA
+ const RSA_METHOD *meth_rsa ;
+#endif
+#ifndef OPENSSL_NO_DSA
+ const DSA_METHOD *meth_dsa ;
+#endif
+#ifndef OPENSSL_NO_DH
+ const DH_METHOD *meth_dh ;
+#endif
+
+ const RAND_METHOD *meth_rand ;
+
+
+ if ( !ENGINE_set_id ( e, engine_zencod_id ) ||
+ !ENGINE_set_name ( e, engine_zencod_name ) ||
+#ifndef OPENSSL_NO_RSA
+ !ENGINE_set_RSA ( e, &zencod_rsa ) ||
+#endif
+#ifndef OPENSSL_NO_DSA
+ !ENGINE_set_DSA ( e, &zencod_dsa ) ||
+#endif
+#ifndef OPENSSL_NO_DH
+ !ENGINE_set_DH ( e, &zencod_dh ) ||
+#endif
+ !ENGINE_set_RAND ( e, &zencod_rand ) ||
+
+ !ENGINE_set_destroy_function ( e, zencod_destroy ) ||
+ !ENGINE_set_init_function ( e, zencod_init ) ||
+ !ENGINE_set_finish_function ( e, zencod_finish ) ||
+ !ENGINE_set_ctrl_function ( e, zencod_ctrl ) ||
+ !ENGINE_set_cmd_defns ( e, zencod_cmd_defns ) ||
+ !ENGINE_set_digests ( e, engine_digests ) ||
+ !ENGINE_set_ciphers ( e, engine_ciphers ) ) {
+ return 0 ;
+ }
+
+#ifndef OPENSSL_NO_RSA
+ /* We know that the "PKCS1_SSLeay()" functions hook properly
+ * to the Zencod-specific mod_exp and mod_exp_crt so we use
+ * those functions. NB: We don't use ENGINE_openssl() or
+ * anything "more generic" because something like the RSAref
+ * code may not hook properly, and if you own one of these
+ * cards then you have the right to do RSA operations on it
+ * anyway!
+ */
+ meth_rsa = RSA_PKCS1_SSLeay () ;
+
+ zencod_rsa.rsa_pub_enc = meth_rsa->rsa_pub_enc ;
+ zencod_rsa.rsa_pub_dec = meth_rsa->rsa_pub_dec ;
+ zencod_rsa.rsa_priv_enc = meth_rsa->rsa_priv_enc ;
+ zencod_rsa.rsa_priv_dec = meth_rsa->rsa_priv_dec ;
+ /* meth_rsa->rsa_mod_exp */
+ /* meth_rsa->bn_mod_exp */
+ zencod_rsa.init = meth_rsa->init ;
+ zencod_rsa.finish = meth_rsa->finish ;
+#endif
+
+#ifndef OPENSSL_NO_DSA
+ /* We use OpenSSL meth to supply what we don't provide ;-*)
+ */
+ meth_dsa = DSA_OpenSSL () ;
+
+ /* meth_dsa->dsa_do_sign */
+ zencod_dsa.dsa_sign_setup = meth_dsa->dsa_sign_setup ;
+ /* meth_dsa->dsa_do_verify */
+ zencod_dsa.dsa_mod_exp = meth_dsa->dsa_mod_exp ;
+ /* zencod_dsa.bn_mod_exp = meth_dsa->bn_mod_exp ; */
+ zencod_dsa.init = meth_dsa->init ;
+ zencod_dsa.finish = meth_dsa->finish ;
+#endif
+
+#ifndef OPENSSL_NO_DH
+ /* We use OpenSSL meth to supply what we don't provide ;-*)
+ */
+ meth_dh = DH_OpenSSL () ;
+
+ /* zencod_dh.generate_key = meth_dh->generate_key ; */
+ /* zencod_dh.compute_key = meth_dh->compute_key ; */
+ /* zencod_dh.bn_mod_exp = meth_dh->bn_mod_exp ; */
+ zencod_dh.init = meth_dh->init ;
+ zencod_dh.finish = meth_dh->finish ;
+
+#endif
+
+ /* We use OpenSSL (SSLeay) meth to supply what we don't provide ;-*)
+ */
+ meth_rand = RAND_SSLeay () ;
+
+ /* meth_rand->seed ; */
+ /* zencod_rand.seed = meth_rand->seed ; */
+ /* meth_rand->bytes ; */
+ /* zencod_rand.bytes = meth_rand->bytes ; */
+ zencod_rand.cleanup = meth_rand->cleanup ;
+ zencod_rand.add = meth_rand->add ;
+ /* meth_rand->pseudorand ; */
+ /* zencod_rand.pseudorand = meth_rand->pseudorand ; */
+ /* zencod_rand.status = meth_rand->status ; */
+ /* meth_rand->status ; */
+
+ /* Ensure the zencod error handling is set up */
+ ERR_load_ZENCOD_strings () ;
+ return 1 ;
+}
+
+
+/* As this is only ever called once, there's no need for locking
+ * (indeed - the lock will already be held by our caller!!!)
+ */
+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 <openssl/evp.h>
+#include <openssl/sha.h>
+#include <openssl/md5.h>
+#include <openssl/rc4.h>
+#include <openssl/des.h>
+
+
+/* Some variables declaration ... */
+/* DONS:
+ * Disable symetric computation except DES and 3DES, but let part of the code
+ */
+/* static int engine_digest_nids [ ] = { NID_sha1, NID_md5 } ; */
+static int engine_digest_nids [ ] = { } ;
+static int engine_digest_nids_num = 0 ;
+/* static int engine_cipher_nids [ ] = { NID_rc4, NID_rc4_40, NID_des_cbc, NID_des_ede3_cbc } ; */
+static int engine_cipher_nids [ ] = { NID_des_cbc, NID_des_ede3_cbc } ;
+static int engine_cipher_nids_num = 2 ;
+
+
+/* Function prototype ... */
+/* SHA stuff */
+static int engine_sha1_init ( EVP_MD_CTX *ctx ) ;
+static int engine_sha1_update ( EVP_MD_CTX *ctx, const void *data, unsigned long count ) ;
+static int engine_sha1_final ( EVP_MD_CTX *ctx, unsigned char *md ) ;
+
+/* MD5 stuff */
+static int engine_md5_init ( EVP_MD_CTX *ctx ) ;
+static int engine_md5_update ( EVP_MD_CTX *ctx, const void *data, unsigned long count ) ;
+static int engine_md5_final ( EVP_MD_CTX *ctx, unsigned char *md ) ;
+
+static int engine_md_cleanup ( EVP_MD_CTX *ctx ) ;
+static int engine_md_copy ( EVP_MD_CTX *to, const EVP_MD_CTX *from ) ;
+
+
+/* RC4 Stuff */
+static int engine_rc4_init_key ( EVP_CIPHER_CTX *ctx, const unsigned char *key, const unsigned char *iv, int enc ) ;
+static int engine_rc4_cipher ( EVP_CIPHER_CTX *ctx, unsigned char *out, const unsigned char *in, unsigned int inl ) ;
+
+/* DES Stuff */
+static int engine_des_init_key ( EVP_CIPHER_CTX *ctx, const unsigned char *key, const unsigned char *iv, int enc ) ;
+static int engine_des_cbc_cipher ( EVP_CIPHER_CTX *ctx, unsigned char *out, const unsigned char *in, unsigned int inl ) ;
+
+/* 3DES Stuff */
+static int engine_des_ede3_init_key ( EVP_CIPHER_CTX *ctx, const unsigned char *key, const unsigned char *iv, int enc ) ;
+static int engine_des_ede3_cbc_cipher ( EVP_CIPHER_CTX *ctx, unsigned char *out,const unsigned char *in, unsigned int inl ) ;
+
+static int engine_cipher_cleanup ( EVP_CIPHER_CTX *ctx ) ; /* cleanup ctx */
+
+
+/* The one for SHA ... */
+static const EVP_MD engine_sha1_md =
+{
+ NID_sha1,
+ NID_sha1WithRSAEncryption,
+ SHA_DIGEST_LENGTH,
+ EVP_MD_FLAG_ONESHOT,
+ /* 0, */ /* EVP_MD_FLAG_ONESHOT = x0001 digest can only handle a single block
+ * XXX: set according to device info ... */
+ engine_sha1_init,
+ engine_sha1_update,
+ engine_sha1_final,
+ engine_md_copy, /* dev_crypto_sha_copy */
+ engine_md_cleanup, /* dev_crypto_sha_cleanup */
+ EVP_PKEY_RSA_method,
+ SHA_CBLOCK,
+ /* sizeof ( EVP_MD * ) + sizeof ( SHA_CTX ) */
+ sizeof ( ZEN_MD_DATA )
+ /* sizeof ( MD_CTX_DATA ) The message digest data stucture ... */
+} ;
+
+/* The one for MD5 ... */
+static const EVP_MD engine_md5_md =
+{
+ NID_md5,
+ NID_md5WithRSAEncryption,
+ MD5_DIGEST_LENGTH,
+ EVP_MD_FLAG_ONESHOT,
+ /* 0, */ /* EVP_MD_FLAG_ONESHOT = x0001 digest can only handle a single block
+ * XXX: set according to device info ... */
+ engine_md5_init,
+ engine_md5_update,
+ engine_md5_final,
+ engine_md_copy, /* dev_crypto_md5_copy */
+ engine_md_cleanup, /* dev_crypto_md5_cleanup */
+ EVP_PKEY_RSA_method,
+ MD5_CBLOCK,
+ /* sizeof ( EVP_MD * ) + sizeof ( MD5_CTX ) */
+ sizeof ( ZEN_MD_DATA )
+ /* sizeof ( MD_CTX_DATA ) The message digest data stucture ... */
+} ;
+
+
+/* The one for RC4 ... */
+#define EVP_RC4_KEY_SIZE 16
+
+/* Try something static ... */
+typedef struct
+{
+ unsigned int len ;
+ unsigned int first ;
+ unsigned char rc4_state [ 260 ] ;
+} NEW_ZEN_RC4_KEY ;
+
+#define rc4_data(ctx) ( (EVP_RC4_KEY *) ( ctx )->cipher_data )
+
+static const EVP_CIPHER engine_rc4 =
+{
+ NID_rc4,
+ 1,
+ 16, /* EVP_RC4_KEY_SIZE should be 128 bits */
+ 0, /* FIXME: key should be up to 256 bytes */
+ EVP_CIPH_VARIABLE_LENGTH,
+ engine_rc4_init_key,
+ engine_rc4_cipher,
+ engine_cipher_cleanup,
+ sizeof ( NEW_ZEN_RC4_KEY ),
+ NULL,
+ NULL,
+ NULL
+} ;
+
+/* The one for RC4_40 ... */
+static const EVP_CIPHER engine_rc4_40 =
+{
+ NID_rc4_40,
+ 1,
+ 5, /* 40 bits */
+ 0,
+ EVP_CIPH_VARIABLE_LENGTH,
+ engine_rc4_init_key,
+ engine_rc4_cipher,
+ engine_cipher_cleanup,
+ sizeof ( NEW_ZEN_RC4_KEY ),
+ NULL,
+ NULL,
+ NULL
+} ;
+
+/* The one for DES ... */
+
+/* Try something static ... */
+typedef struct
+{
+ unsigned char des_key [ 24 ] ;
+ unsigned char des_iv [ 8 ] ;
+} ZEN_DES_KEY ;
+
+static const EVP_CIPHER engine_des_cbc =
+ {
+ NID_des_cbc,
+ 8, 8, 8,
+ 0 | EVP_CIPH_CBC_MODE,
+ engine_des_init_key,
+ engine_des_cbc_cipher,
+ engine_cipher_cleanup,
+ sizeof(ZEN_DES_KEY),
+ EVP_CIPHER_set_asn1_iv,
+ EVP_CIPHER_get_asn1_iv,
+ NULL,
+ NULL
+ };
+
+/* The one for 3DES ... */
+
+/* Try something static ... */
+typedef struct
+{
+ unsigned char des3_key [ 24 ] ;
+ unsigned char des3_iv [ 8 ] ;
+} ZEN_3DES_KEY ;
+
+#define des_data(ctx) ( (DES_EDE_KEY *) ( ctx )->cipher_data )
+
+static const EVP_CIPHER engine_des_ede3_cbc =
+ {
+ NID_des_ede3_cbc,
+ 8, 8, 8,
+ 0 | EVP_CIPH_CBC_MODE,
+ engine_des_ede3_init_key,
+ engine_des_ede3_cbc_cipher,
+ engine_cipher_cleanup,
+ sizeof(ZEN_3DES_KEY),
+ EVP_CIPHER_set_asn1_iv,
+ EVP_CIPHER_get_asn1_iv,
+ NULL,
+ NULL
+ };
+
+
+/* General function cloned on hw_openbsd_dev_crypto one ... */
+static int engine_digests ( ENGINE *e, const EVP_MD **digest, const int **nids, int nid )
+{
+
+#ifdef DEBUG_ZENCOD_MD
+ fprintf ( stderr, "\t=>Function : static int engine_digests () called !\n" ) ;
+#endif
+
+ if ( !digest ) {
+ /* We are returning a list of supported nids */
+ *nids = engine_digest_nids ;
+ return engine_digest_nids_num ;
+ }
+ /* We are being asked for a specific digest */
+ if ( nid == NID_md5 ) {
+ *digest = &engine_md5_md ;
+ }
+ else if ( nid == NID_sha1 ) {
+ *digest = &engine_sha1_md ;
+ }
+ else {
+ *digest = NULL ;
+ return 0 ;
+ }
+ return 1 ;
+}
+
+
+/* SHA stuff Functions
+ */
+static int engine_sha1_init ( EVP_MD_CTX *ctx )
+{
+
+ int to_return = 0 ;
+
+ /* Test with zenbridge library ... */
+ to_return = ptr_zencod_sha1_init ( (ZEN_MD_DATA *) ctx->md_data ) ;
+ to_return = !to_return ;
+
+ return to_return ;
+}
+
+
+static int engine_sha1_update ( EVP_MD_CTX *ctx, const void *data, unsigned long count )
+{
+
+ zen_nb_t input ;
+ int to_return = 0 ;
+
+ /* Convert parameters ... */
+ input.len = count ;
+ input.data = (unsigned char *) data ;
+
+ /* Test with zenbridge library ... */
+ to_return = ptr_zencod_sha1_update ( (ZEN_MD_DATA *) ctx->md_data, (const zen_nb_t *) &input ) ;
+ to_return = !to_return ;
+
+ return to_return ;
+}
+
+
+static int engine_sha1_final ( EVP_MD_CTX *ctx, unsigned char *md )
+{
+
+ zen_nb_t output ;
+ int to_return = 0 ;
+
+ /* Convert parameters ... */
+ output.len = SHA_DIGEST_LENGTH ;
+ output.data = md ;
+
+ /* Test with zenbridge library ... */
+ to_return = ptr_zencod_sha1_do_final ( (ZEN_MD_DATA *) ctx->md_data, (zen_nb_t *) &output ) ;
+ to_return = !to_return ;
+
+ return to_return ;
+}
+
+
+
+/* MD5 stuff Functions
+ */
+static int engine_md5_init ( EVP_MD_CTX *ctx )
+{
+
+ int to_return = 0 ;
+
+ /* Test with zenbridge library ... */
+ to_return = ptr_zencod_md5_init ( (ZEN_MD_DATA *) ctx->md_data ) ;
+ to_return = !to_return ;
+
+ return to_return ;
+}
+
+
+static int engine_md5_update ( EVP_MD_CTX *ctx, const void *data, unsigned long count )
+{
+
+ zen_nb_t input ;
+ int to_return = 0 ;
+
+ /* Convert parameters ... */
+ input.len = count ;
+ input.data = (unsigned char *) data ;
+
+ /* Test with zenbridge library ... */
+ to_return = ptr_zencod_md5_update ( (ZEN_MD_DATA *) ctx->md_data, (const zen_nb_t *) &input ) ;
+ to_return = !to_return ;
+
+ return to_return ;
+}
+
+
+static int engine_md5_final ( EVP_MD_CTX *ctx, unsigned char *md )
+{
+
+ zen_nb_t output ;
+ int to_return = 0 ;
+
+ /* Convert parameters ... */
+ output.len = MD5_DIGEST_LENGTH ;
+ output.data = md ;
+
+ /* Test with zenbridge library ... */
+ to_return = ptr_zencod_md5_do_final ( (ZEN_MD_DATA *) ctx->md_data, (zen_nb_t *) &output ) ;
+ to_return = !to_return ;
+
+ return to_return ;
+}
+
+
+static int engine_md_cleanup ( EVP_MD_CTX *ctx )
+{
+
+ ZEN_MD_DATA *zen_md_data = (ZEN_MD_DATA *) ctx->md_data ;
+
+ if ( zen_md_data->HashBuffer != NULL ) {
+ OPENSSL_free ( zen_md_data->HashBuffer ) ;
+ zen_md_data->HashBufferSize = 0 ;
+ ctx->md_data = NULL ;
+ }
+
+ return 1 ;
+}
+
+
+static int engine_md_copy ( EVP_MD_CTX *to, const EVP_MD_CTX *from )
+{
+ const ZEN_MD_DATA *from_md = (ZEN_MD_DATA *) from->md_data ;
+ ZEN_MD_DATA *to_md = (ZEN_MD_DATA *) to->md_data ;
+
+ to_md->HashBuffer = OPENSSL_malloc ( from_md->HashBufferSize ) ;
+ memcpy ( to_md->HashBuffer, from_md->HashBuffer, from_md->HashBufferSize ) ;
+
+ return 1;
+}
+
+
+/* General function cloned on hw_openbsd_dev_crypto one ... */
+static int engine_ciphers ( ENGINE *e, const EVP_CIPHER **cipher, const int **nids, int nid )
+{
+
+ if ( !cipher ) {
+ /* We are returning a list of supported nids */
+ *nids = engine_cipher_nids ;
+ return engine_cipher_nids_num ;
+ }
+ /* We are being asked for a specific cipher */
+ if ( nid == NID_rc4 ) {
+ *cipher = &engine_rc4 ;
+ }
+ else if ( nid == NID_rc4_40 ) {
+ *cipher = &engine_rc4_40 ;
+ }
+ else if ( nid == NID_des_cbc ) {
+ *cipher = &engine_des_cbc ;
+ }
+ else if ( nid == NID_des_ede3_cbc ) {
+ *cipher = &engine_des_ede3_cbc ;
+ }
+ else {
+ *cipher = NULL ;
+ return 0 ;
+ }
+
+ return 1 ;
+}
+
+
+static int engine_rc4_init_key ( EVP_CIPHER_CTX *ctx, const unsigned char *key, const unsigned char *iv, int enc )
+{
+ int to_return = 0 ;
+ int i = 0 ;
+ int nb = 0 ;
+ NEW_ZEN_RC4_KEY *tmp_rc4_key = NULL ;
+
+ tmp_rc4_key = (NEW_ZEN_RC4_KEY *) ( ctx->cipher_data ) ;
+ tmp_rc4_key->first = 0 ;
+ tmp_rc4_key->len = ctx->key_len ;
+ tmp_rc4_key->rc4_state [ 0 ] = 0x00 ;
+ tmp_rc4_key->rc4_state [ 2 ] = 0x00 ;
+ nb = 256 / ctx->key_len ;
+ for ( i = 0; i < nb ; i++ ) {
+ memcpy ( &( tmp_rc4_key->rc4_state [ 4 + i*ctx->key_len ] ), key, ctx->key_len ) ;
+ }
+
+ to_return = 1 ;
+
+ return to_return ;
+}
+
+
+static int engine_rc4_cipher ( EVP_CIPHER_CTX *ctx, unsigned char *out, const unsigned char *in, unsigned int in_len )
+{
+
+ zen_nb_t output, input ;
+ zen_nb_t rc4key ;
+ int to_return = 0 ;
+ NEW_ZEN_RC4_KEY *tmp_rc4_key = NULL ;
+
+ /* Convert parameters ... */
+ input.len = in_len ;
+ input.data = (unsigned char *) in ;
+ output.len = in_len ;
+ output.data = (unsigned char *) out ;
+
+ tmp_rc4_key = ( (NEW_ZEN_RC4_KEY *) ( ctx->cipher_data ) ) ;
+ rc4key.len = 260 ;
+ rc4key.data = &( tmp_rc4_key->rc4_state [ 0 ] ) ;
+
+ /* Test with zenbridge library ... */
+ to_return = ptr_zencod_rc4_cipher ( &output, &input, (const zen_nb_t *) &rc4key, &( tmp_rc4_key->rc4_state [0] ), &( tmp_rc4_key->rc4_state [3] ), !tmp_rc4_key->first ) ;
+ to_return = !to_return ;
+
+ /* Update encryption state ... */
+ tmp_rc4_key->first = 1 ;
+ tmp_rc4_key = NULL ;
+
+ return to_return ;
+}
+
+
+static int engine_des_init_key ( EVP_CIPHER_CTX *ctx, const unsigned char *key, const unsigned char *iv, int enc )
+{
+
+ ZEN_DES_KEY *tmp_des_key = NULL ;
+ int to_return = 0 ;
+
+ tmp_des_key = (ZEN_DES_KEY *) ( ctx->cipher_data ) ;
+ memcpy ( &( tmp_des_key->des_key [ 0 ] ), key, 8 ) ;
+ memcpy ( &( tmp_des_key->des_key [ 8 ] ), key, 8 ) ;
+ memcpy ( &( tmp_des_key->des_key [ 16 ] ), key, 8 ) ;
+ memcpy ( &( tmp_des_key->des_iv [ 0 ] ), iv, 8 ) ;
+
+ to_return = 1 ;
+
+ return to_return ;
+}
+
+
+static int engine_des_cbc_cipher ( EVP_CIPHER_CTX *ctx, unsigned char *out, const unsigned char *in, unsigned int inl )
+{
+
+ zen_nb_t output, input ;
+ zen_nb_t deskey_1, deskey_2, deskey_3, iv ;
+ int to_return = 0 ;
+
+ /* Convert parameters ... */
+ input.len = inl ;
+ input.data = (unsigned char *) in ;
+ output.len = inl ;
+ output.data = out ;
+
+ /* Set key parameters ... */
+ deskey_1.len = 8 ;
+ deskey_2.len = 8 ;
+ deskey_3.len = 8 ;
+ deskey_1.data = (unsigned char *) ( (ZEN_DES_KEY *) ( ctx->cipher_data ) )->des_key ;
+ deskey_2.data = (unsigned char *) &( (ZEN_DES_KEY *) ( ctx->cipher_data ) )->des_key [ 8 ] ;
+ deskey_3.data = (unsigned char *) &( (ZEN_DES_KEY *) ( ctx->cipher_data ) )->des_key [ 16 ] ;
+
+ /* Key correct iv ... */
+ memcpy ( ( (ZEN_DES_KEY *) ( ctx->cipher_data ) )->des_iv, ctx->iv, 8 ) ;
+ iv.len = 8 ;
+ iv.data = (unsigned char *) ( (ZEN_DES_KEY *) ( ctx->cipher_data ) )->des_iv ;
+
+ if ( ctx->encrypt == 0 ) {
+ memcpy ( ctx->iv, &( input.data [ input.len - 8 ] ), 8 ) ;
+ }
+
+ /* Test with zenbridge library ... */
+ to_return = ptr_zencod_xdes_cipher ( &output, &input,
+ (zen_nb_t *) &deskey_1, (zen_nb_t *) &deskey_2, (zen_nb_t *) &deskey_3, &iv, ctx->encrypt ) ;
+ to_return = !to_return ;
+
+ /* But we need to set up the rigth iv ...
+ * Test ENCRYPT or DECRYPT mode to set iv ... */
+ if ( ctx->encrypt == 1 ) {
+ memcpy ( ctx->iv, &( output.data [ output.len - 8 ] ), 8 ) ;
+ }
+
+ return to_return ;
+}
+
+
+static int engine_des_ede3_init_key ( EVP_CIPHER_CTX *ctx, const unsigned char *key, const unsigned char *iv, int enc )
+{
+
+ ZEN_3DES_KEY *tmp_3des_key = NULL ;
+ int to_return = 0 ;
+
+ tmp_3des_key = (ZEN_3DES_KEY *) ( ctx->cipher_data ) ;
+ memcpy ( &( tmp_3des_key->des3_key [ 0 ] ), key, 24 ) ;
+ memcpy ( &( tmp_3des_key->des3_iv [ 0 ] ), iv, 8 ) ;
+
+ to_return = 1;
+
+ return to_return ;
+}
+
+
+static int engine_des_ede3_cbc_cipher ( EVP_CIPHER_CTX *ctx, unsigned char *out, const unsigned char *in,
+ unsigned int in_len )
+{
+
+ zen_nb_t output, input ;
+ zen_nb_t deskey_1, deskey_2, deskey_3, iv ;
+ int to_return = 0 ;
+
+ /* Convert parameters ... */
+ input.len = in_len ;
+ input.data = (unsigned char *) in ;
+ output.len = in_len ;
+ output.data = out ;
+
+ /* Set key ... */
+ deskey_1.len = 8 ;
+ deskey_2.len = 8 ;
+ deskey_3.len = 8 ;
+ deskey_1.data = (unsigned char *) ( (ZEN_3DES_KEY *) ( ctx->cipher_data ) )->des3_key ;
+ deskey_2.data = (unsigned char *) &( (ZEN_3DES_KEY *) ( ctx->cipher_data ) )->des3_key [ 8 ] ;
+ deskey_3.data = (unsigned char *) &( (ZEN_3DES_KEY *) ( ctx->cipher_data ) )->des3_key [ 16 ] ;
+
+ /* Key correct iv ... */
+ memcpy ( ( (ZEN_3DES_KEY *) ( ctx->cipher_data ) )->des3_iv, ctx->iv, 8 ) ;
+ iv.len = 8 ;
+ iv.data = (unsigned char *) ( (ZEN_3DES_KEY *) ( ctx->cipher_data ) )->des3_iv ;
+
+ if ( ctx->encrypt == 0 ) {
+ memcpy ( ctx->iv, &( input.data [ input.len - 8 ] ), 8 ) ;
+ }
+
+ /* Test with zenbridge library ... */
+ to_return = ptr_zencod_xdes_cipher ( &output, &input,
+ (zen_nb_t *) &deskey_1, (zen_nb_t *) &deskey_2, (zen_nb_t *) &deskey_3, &iv, ctx->encrypt ) ;
+ to_return = !to_return ;
+
+ if ( ctx->encrypt == 1 ) {
+ memcpy ( ctx->iv, &( output.data [ output.len - 8 ] ), 8 ) ;
+ }
+
+ return to_return ;
+}
+
+
+static int engine_cipher_cleanup ( EVP_CIPHER_CTX *ctx )
+{
+
+ /* Set the key pointer ... */
+ if ( ctx->cipher->nid == NID_rc4 || ctx->cipher->nid == NID_rc4_40 ) {
+ }
+ else if ( ctx->cipher->nid == NID_des_cbc ) {
+ }
+ else if ( ctx->cipher->nid == NID_des_ede3_cbc ) {
+ }
+
+ return 1 ;
+}
+
+
+#endif /* !OPENSSL_NO_HW_ZENCOD */
+#endif /* !OPENSSL_NO_HW */
--- /dev/null
+# 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
--- /dev/null
+/* 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 <stdio.h>
+
+#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_ */
--- /dev/null
+/* 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 <stdio.h>
+#include <openssl/err.h>
+#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);
+ }
--- /dev/null
+/* ====================================================================
+ * 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
projects / oweals / openssl.git / commitdiff