1 /* crypto/engine/hw_zencod.c */
3 * Written by Fred Donnat (frederic.donnat@zencod.com) for "zencod" * engine
4 * integration in order to redirect crypto computing on a crypto * hardware
5 * accelerator zenssl32 ;-) * * Date : 25 jun 2002 * Revision : 17 Ju7 2002
6 * * Version : zencod_engine-0.9.7
9 /* ====================================================================
10 * Copyright (c) 1999-2001 The OpenSSL Project. All rights reserved.
12 * Redistribution and use in source and binary forms, with or without
13 * modification, are permitted provided that the following conditions
16 * 1. Redistributions of source code must retain the above copyright
17 * notice, this list of conditions and the following disclaimer.
19 * 2. Redistributions in binary form must reproduce the above copyright
20 * notice, this list of conditions and the following disclaimer in
21 * the documentation and/or other materials provided with the
24 * 3. All advertising materials mentioning features or use of this
25 * software must display the following acknowledgment:
26 * "This product includes software developed by the OpenSSL Project
27 * for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
29 * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
30 * endorse or promote products derived from this software without
31 * prior written permission. For written permission, please contact
32 * licensing@OpenSSL.org.
34 * 5. Products derived from this software may not be called "OpenSSL"
35 * nor may "OpenSSL" appear in their names without prior written
36 * permission of the OpenSSL Project.
38 * 6. Redistributions of any form whatsoever must retain the following
40 * "This product includes software developed by the OpenSSL Project
41 * for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
43 * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
44 * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
45 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
46 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
47 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
48 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
49 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
50 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
51 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
52 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
53 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
54 * OF THE POSSIBILITY OF SUCH DAMAGE.
55 * ====================================================================
57 * This product includes cryptographic software written by Eric Young
58 * (eay@cryptsoft.com). This product includes software written by Tim
59 * Hudson (tjh@cryptsoft.com).
63 /* ENGINE general include */
65 #include <openssl/crypto.h>
66 #include <openssl/dso.h>
67 #include <openssl/engine.h>
70 # ifndef OPENSSL_NO_HW_ZENCOD
73 # include "hw_zencod.h"
75 # include "vendor_defns/hw_zencod.h"
78 # define ZENCOD_LIB_NAME "zencod engine"
79 # include "hw_zencod_err.c"
81 # define FAIL_TO_SOFTWARE -15
83 # define ZEN_LIBRARY "zenbridge"
85 # ifdef ZENCOD_TRACING
86 # define PERROR(s) perror(s)
87 # define CHEESE() fputs("## [ZenEngine] ## " __FUNCTION__ "\n", stderr)
95 static inline void esrever(unsigned char *d, int l)
97 for (; --l > 0; --l, d++) {
104 static inline void ypcmem(unsigned char *d, const unsigned char *s, int l)
110 static __inline void esrever(unsigned char *d, int l)
112 for (; --l > 0; --l, d++) {
119 static __inline void ypcmem(unsigned char *d, const unsigned char *s, int l)
126 # define BIGNUM2ZEN(n, bn) (ptr_zencod_init_number((n), \
127 (unsigned long) ((bn)->top * BN_BITS2), \
128 (unsigned char *) ((bn)->d)))
130 # define ZEN_BITS(n, bytes) (ptr_zencod_bytes2bits((unsigned char *) (n), (unsigned long) (bytes)))
131 # define ZEN_BYTES(bits) (ptr_zencod_bits2bytes((unsigned long) (bits)))
133 /* Function for ENGINE detection and control */
134 static int zencod_destroy(ENGINE *e);
135 static int zencod_init(ENGINE *e);
136 static int zencod_finish(ENGINE *e);
137 static int zencod_ctrl(ENGINE *e, int cmd, long i, void *p, void (*f) ());
140 static int zencod_bn_mod_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
141 const BIGNUM *m, BN_CTX *ctx);
144 # ifndef OPENSSL_NO_RSA
145 static int RSA_zencod_rsa_mod_exp(BIGNUM *r0, const BIGNUM *I, RSA *rsa);
146 static int RSA_zencod_bn_mod_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
147 const BIGNUM *m, BN_CTX *ctx,
152 # ifndef OPENSSL_NO_DSA
153 static int DSA_zencod_bn_mod_exp(DSA *dsa, BIGNUM *r, BIGNUM *a,
154 const BIGNUM *p, const BIGNUM *m,
155 BN_CTX *ctx, BN_MONT_CTX *m_ctx);
157 static DSA_SIG *DSA_zencod_do_sign(const unsigned char *dgst, int dlen,
159 static int DSA_zencod_do_verify(const unsigned char *dgst, int dgst_len,
160 DSA_SIG *sig, DSA *dsa);
164 # ifndef OPENSSL_NO_DH
165 static int DH_zencod_bn_mod_exp(const DH *dh, BIGNUM *r, const BIGNUM *a,
166 const BIGNUM *p, const BIGNUM *m, BN_CTX *ctx,
168 static int DH_zencod_generate_key(DH *dh);
169 static int DH_zencod_compute_key(unsigned char *key, const BIGNUM *pub_key,
174 static void RAND_zencod_seed(const void *buf, int num);
175 static int RAND_zencod_rand_bytes(unsigned char *buf, int num);
176 static int RAND_zencod_rand_status(void);
179 static int engine_digests(ENGINE *e, const EVP_MD **digest, const int **nids,
183 static int engine_ciphers(ENGINE *e, const EVP_CIPHER **cipher,
184 const int **nids, int nid);
186 # define ZENCOD_CMD_SO_PATH ENGINE_CMD_BASE
187 static const ENGINE_CMD_DEFN zencod_cmd_defns[] = {
190 "Specifies the path to the 'zenbridge' shared library",
191 ENGINE_CMD_FLAG_STRING},
195 # ifndef OPENSSL_NO_RSA
197 * Our internal RSA_METHOD specific to zencod ENGINE providing pointers to
200 static RSA_METHOD zencod_rsa = {
206 RSA_zencod_rsa_mod_exp,
207 RSA_zencod_bn_mod_exp,
217 # ifndef OPENSSL_NO_DSA
219 * Our internal DSA_METHOD specific to zencod ENGINE providing pointers to
222 static DSA_METHOD zencod_dsa = {
226 DSA_zencod_do_verify,
228 DSA_zencod_bn_mod_exp,
236 # ifndef OPENSSL_NO_DH
238 * Our internal DH_METHOD specific to zencod ENGINE providing pointers to our
241 static DH_METHOD zencod_dh = {
243 DH_zencod_generate_key,
244 DH_zencod_compute_key,
245 DH_zencod_bn_mod_exp,
254 * Our internal RAND_meth specific to zencod ZNGINE providing pointers to our
257 static RAND_METHOD zencod_rand = {
259 RAND_zencod_rand_bytes,
262 RAND_zencod_rand_bytes,
263 RAND_zencod_rand_status
266 /* Constants used when creating the ENGINE */
267 static const char *engine_zencod_id = "zencod";
268 static const char *engine_zencod_name = "ZENCOD hardware engine support";
271 * This internal function is used by ENGINE_zencod () and possibly by the
272 * "dynamic" ENGINE support too ;-)
274 static int bind_helper(ENGINE *e)
277 # ifndef OPENSSL_NO_RSA
278 const RSA_METHOD *meth_rsa;
280 # ifndef OPENSSL_NO_DSA
281 const DSA_METHOD *meth_dsa;
283 # ifndef OPENSSL_NO_DH
284 const DH_METHOD *meth_dh;
287 const RAND_METHOD *meth_rand;
289 if (!ENGINE_set_id(e, engine_zencod_id) ||
290 !ENGINE_set_name(e, engine_zencod_name) ||
291 # ifndef OPENSSL_NO_RSA
292 !ENGINE_set_RSA(e, &zencod_rsa) ||
294 # ifndef OPENSSL_NO_DSA
295 !ENGINE_set_DSA(e, &zencod_dsa) ||
297 # ifndef OPENSSL_NO_DH
298 !ENGINE_set_DH(e, &zencod_dh) ||
300 !ENGINE_set_RAND(e, &zencod_rand) ||
301 !ENGINE_set_destroy_function(e, zencod_destroy) ||
302 !ENGINE_set_init_function(e, zencod_init) ||
303 !ENGINE_set_finish_function(e, zencod_finish) ||
304 !ENGINE_set_ctrl_function(e, zencod_ctrl) ||
305 !ENGINE_set_cmd_defns(e, zencod_cmd_defns) ||
306 !ENGINE_set_digests(e, engine_digests) ||
307 !ENGINE_set_ciphers(e, engine_ciphers)) {
310 # ifndef OPENSSL_NO_RSA
312 * We know that the "PKCS1_OpenSSL()" functions hook properly to the
313 * Zencod-specific mod_exp and mod_exp_crt so we use those functions. NB:
314 * We don't use ENGINE_openssl() or anything "more generic" because
315 * something like the RSAref code may not hook properly, and if you own
316 * one of these cards then you have the right to do RSA operations on it
319 meth_rsa = RSA_PKCS1_OpenSSL();
321 zencod_rsa.rsa_pub_enc = meth_rsa->rsa_pub_enc;
322 zencod_rsa.rsa_pub_dec = meth_rsa->rsa_pub_dec;
323 zencod_rsa.rsa_priv_enc = meth_rsa->rsa_priv_enc;
324 zencod_rsa.rsa_priv_dec = meth_rsa->rsa_priv_dec;
325 /* meth_rsa->rsa_mod_exp */
326 /* meth_rsa->bn_mod_exp */
327 zencod_rsa.init = meth_rsa->init;
328 zencod_rsa.finish = meth_rsa->finish;
331 # ifndef OPENSSL_NO_DSA
333 * We use OpenSSL meth to supply what we don't provide ;-*)
335 meth_dsa = DSA_OpenSSL();
337 /* meth_dsa->dsa_do_sign */
338 zencod_dsa.dsa_sign_setup = meth_dsa->dsa_sign_setup;
339 /* meth_dsa->dsa_do_verify */
340 zencod_dsa.dsa_mod_exp = meth_dsa->dsa_mod_exp;
341 /* zencod_dsa.bn_mod_exp = meth_dsa->bn_mod_exp ; */
342 zencod_dsa.init = meth_dsa->init;
343 zencod_dsa.finish = meth_dsa->finish;
346 # ifndef OPENSSL_NO_DH
348 * We use OpenSSL meth to supply what we don't provide ;-*)
350 meth_dh = DH_OpenSSL();
352 /* zencod_dh.generate_key = meth_dh->generate_key ; */
353 /* zencod_dh.compute_key = meth_dh->compute_key ; */
354 /* zencod_dh.bn_mod_exp = meth_dh->bn_mod_exp ; */
355 zencod_dh.init = meth_dh->init;
356 zencod_dh.finish = meth_dh->finish;
361 * We use OpenSSL meth to supply what we don't provide ;-*)
363 meth_rand = RAND_OpenSSL();
365 /* meth_rand->seed ; */
366 /* zencod_rand.seed = meth_rand->seed ; */
367 /* meth_rand->bytes ; */
368 /* zencod_rand.bytes = meth_rand->bytes ; */
369 zencod_rand.cleanup = meth_rand->cleanup;
370 zencod_rand.add = meth_rand->add;
371 /* meth_rand->pseudorand ; */
372 /* zencod_rand.pseudorand = meth_rand->pseudorand ; */
373 /* zencod_rand.status = meth_rand->status ; */
374 /* meth_rand->status ; */
376 /* Ensure the zencod error handling is set up */
377 ERR_load_ZENCOD_strings();
382 * As this is only ever called once, there's no need for locking (indeed -
383 * the lock will already be held by our caller!!!)
385 static ENGINE *ENGINE_zencod(void)
388 ENGINE *eng = ENGINE_new();
393 if (!bind_helper(eng)) {
401 # ifdef ENGINE_DYNAMIC_SUPPORT
404 void ENGINE_load_zencod(void)
406 /* Copied from eng_[openssl|dyn].c */
407 ENGINE *toadd = ENGINE_zencod();
416 * This is a process-global DSO handle used for loading and unloading the
417 * ZENBRIDGE library. NB: This is only set (or unset) during an * init () or
418 * finish () call (reference counts permitting) and they're * operating with
419 * global locks, so this should be thread-safe * implicitly.
421 static DSO *zencod_dso = NULL;
423 static t_zencod_test *ptr_zencod_test = NULL;
424 static t_zencod_bytes2bits *ptr_zencod_bytes2bits = NULL;
425 static t_zencod_bits2bytes *ptr_zencod_bits2bytes = NULL;
426 static t_zencod_new_number *ptr_zencod_new_number = NULL;
427 static t_zencod_init_number *ptr_zencod_init_number = NULL;
429 static t_zencod_rsa_mod_exp *ptr_zencod_rsa_mod_exp = NULL;
430 static t_zencod_rsa_mod_exp_crt *ptr_zencod_rsa_mod_exp_crt = NULL;
431 static t_zencod_dsa_do_sign *ptr_zencod_dsa_do_sign = NULL;
432 static t_zencod_dsa_do_verify *ptr_zencod_dsa_do_verify = NULL;
433 static t_zencod_dh_generate_key *ptr_zencod_dh_generate_key = NULL;
434 static t_zencod_dh_compute_key *ptr_zencod_dh_compute_key = NULL;
435 static t_zencod_rand_bytes *ptr_zencod_rand_bytes = NULL;
436 static t_zencod_math_mod_exp *ptr_zencod_math_mod_exp = NULL;
438 static t_zencod_md5_init *ptr_zencod_md5_init = NULL;
439 static t_zencod_md5_update *ptr_zencod_md5_update = NULL;
440 static t_zencod_md5_do_final *ptr_zencod_md5_do_final = NULL;
441 static t_zencod_sha1_init *ptr_zencod_sha1_init = NULL;
442 static t_zencod_sha1_update *ptr_zencod_sha1_update = NULL;
443 static t_zencod_sha1_do_final *ptr_zencod_sha1_do_final = NULL;
445 static t_zencod_xdes_cipher *ptr_zencod_xdes_cipher = NULL;
446 static t_zencod_rc4_cipher *ptr_zencod_rc4_cipher = NULL;
449 * These are the static string constants for the DSO file name and the
450 * function symbol names to bind to.
452 static const char *ZENCOD_LIBNAME = ZEN_LIBRARY;
454 static const char *ZENCOD_Fct_0 = "test_device";
455 static const char *ZENCOD_Fct_1 = "zenbridge_bytes2bits";
456 static const char *ZENCOD_Fct_2 = "zenbridge_bits2bytes";
457 static const char *ZENCOD_Fct_3 = "zenbridge_new_number";
458 static const char *ZENCOD_Fct_4 = "zenbridge_init_number";
460 static const char *ZENCOD_Fct_exp_1 = "zenbridge_rsa_mod_exp";
461 static const char *ZENCOD_Fct_exp_2 = "zenbridge_rsa_mod_exp_crt";
462 static const char *ZENCOD_Fct_dsa_1 = "zenbridge_dsa_do_sign";
463 static const char *ZENCOD_Fct_dsa_2 = "zenbridge_dsa_do_verify";
464 static const char *ZENCOD_Fct_dh_1 = "zenbridge_dh_generate_key";
465 static const char *ZENCOD_Fct_dh_2 = "zenbridge_dh_compute_key";
466 static const char *ZENCOD_Fct_rand_1 = "zenbridge_rand_bytes";
467 static const char *ZENCOD_Fct_math_1 = "zenbridge_math_mod_exp";
469 static const char *ZENCOD_Fct_md5_1 = "zenbridge_md5_init";
470 static const char *ZENCOD_Fct_md5_2 = "zenbridge_md5_update";
471 static const char *ZENCOD_Fct_md5_3 = "zenbridge_md5_do_final";
472 static const char *ZENCOD_Fct_sha1_1 = "zenbridge_sha1_init";
473 static const char *ZENCOD_Fct_sha1_2 = "zenbridge_sha1_update";
474 static const char *ZENCOD_Fct_sha1_3 = "zenbridge_sha1_do_final";
476 static const char *ZENCOD_Fct_xdes_1 = "zenbridge_xdes_cipher";
477 static const char *ZENCOD_Fct_rc4_1 = "zenbridge_rc4_cipher";
480 * Destructor (complements the "ENGINE_zencod ()" constructor)
482 static int zencod_destroy(ENGINE *e)
485 ERR_unload_ZENCOD_strings();
491 * (de)initialisation functions. Control Function
493 static int zencod_init(ENGINE *e)
496 t_zencod_test *ptr_0;
497 t_zencod_bytes2bits *ptr_1;
498 t_zencod_bits2bytes *ptr_2;
499 t_zencod_new_number *ptr_3;
500 t_zencod_init_number *ptr_4;
501 t_zencod_rsa_mod_exp *ptr_exp_1;
502 t_zencod_rsa_mod_exp_crt *ptr_exp_2;
503 t_zencod_dsa_do_sign *ptr_dsa_1;
504 t_zencod_dsa_do_verify *ptr_dsa_2;
505 t_zencod_dh_generate_key *ptr_dh_1;
506 t_zencod_dh_compute_key *ptr_dh_2;
507 t_zencod_rand_bytes *ptr_rand_1;
508 t_zencod_math_mod_exp *ptr_math_1;
509 t_zencod_md5_init *ptr_md5_1;
510 t_zencod_md5_update *ptr_md5_2;
511 t_zencod_md5_do_final *ptr_md5_3;
512 t_zencod_sha1_init *ptr_sha1_1;
513 t_zencod_sha1_update *ptr_sha1_2;
514 t_zencod_sha1_do_final *ptr_sha1_3;
515 t_zencod_xdes_cipher *ptr_xdes_1;
516 t_zencod_rc4_cipher *ptr_rc4_1;
521 * We Should add some tests for non NULL parameters or bad value !!
522 * Stuff to be done ...
525 if (zencod_dso != NULL) {
526 ZENCODerr(ZENCOD_F_ZENCOD_INIT, ZENCOD_R_ALREADY_LOADED);
530 * Trying to load the Library "cryptozen"
532 zencod_dso = DSO_load(NULL, ZENCOD_LIBNAME, NULL, 0);
533 if (zencod_dso == NULL) {
534 ZENCODerr(ZENCOD_F_ZENCOD_INIT, ZENCOD_R_DSO_FAILURE);
539 * Trying to load Function from the Library
541 #define BINDIT(t, name) (t*)DSO_bindfunc(zencod_dso, name)
542 if ((ptr_1 = BINDIT(t_zencod_bytes2bits ZENCOD_Fct_1)) == NULL
543 || (ptr_2 = BINDIT(t_zencod_bits2bytes ZENCOD_Fct_2)) == NULL
544 || (ptr_3 = BINDIT(t_zencod_new_number ZENCOD_Fct_3)) == NULL
545 || (ptr_4 = BINDIT(t_zencod_init_number ZENCOD_Fct_4)) == NULL
546 || (ptr_exp_1 = BINDIT(t_zencod_rsa_mod_exp, ZENCOD_Fct_exp_1)) == NULL
547 || (ptr_exp_2 = BINDIT(t_zencod_rsa_mod_exp_crt, ZENCOD_Fct_exp_2)) == NULL
548 || (ptr_dsa_1 = BINDIT(t_zencod_dsa_do_sign, ZENCOD_Fct_dsa_1)) == NULL
549 || (ptr_dsa_2 = BINDIT(t_zencod_dsa_do_verify, ZENCOD_Fct_dsa_2)) == NULL
550 || (ptr_dh_1 = BINDIT(t_zencod_dh_generate_key, ZENCOD_Fct_dh_1)) == NULL
551 || (ptr_dh_2 = BINDIT(t_zencod_dh_compute_key, ZENCOD_Fct_dh_2)) == NULL
552 || (ptr_rand_1 = BINDIT(t_zencod_rand_bytes, ZENCOD_Fct_rand_1)) == NULL
553 || (ptr_math_1 = BINDIT(t_zencod_math_mod_exp, ZENCOD_Fct_math_1)) == NULL
554 || (ptr_0 = BINDIT(t_zencod_test, ZENCOD_Fct_0)) == NULL
555 || (ptr_md5_1 = BINDIT(t_zencod_md5_init, ZENCOD_Fct_md5_1)) == NULL
556 || (ptr_md5_2 = BINDIT(t_zencod_md5_update, ZENCOD_Fct_md5_2)) == NULL
557 || (ptr_md5_3 = BINDIT(t_zencod_md5_do_final, ZENCOD_Fct_md5_3)) == NULL
558 || (ptr_sha1_1 = BINDIT(t_zencod_sha1_init, ZENCOD_Fct_sha1_1)) == NULL
559 || (ptr_sha1_2 = BINDIT(t_zencod_sha1_update, ZENCOD_Fct_sha1_2)) == NULL
560 || (ptr_sha1_3 = BINDIT(t_zencod_sha1_do_final, ZENCOD_Fct_sha1_3)) == NULL
561 || (ptr_xdes_1 = BINDIT(t_zencod_xdes_cipher, ZENCOD_Fct_xdes_1)) == NULL
562 || (ptr_rc4_1 = BINDIT(t_zencod_rc4_cipher, ZENCOD_Fct_rc4_1)) == NULL) {
563 ZENCODerr(ZENCOD_F_ZENCOD_INIT, ZENCOD_R_DSO_FAILURE);
568 * The function from "cryptozen" Library have been correctly loaded so
571 ptr_zencod_test = ptr_0;
572 ptr_zencod_bytes2bits = ptr_1;
573 ptr_zencod_bits2bytes = ptr_2;
574 ptr_zencod_new_number = ptr_3;
575 ptr_zencod_init_number = ptr_4;
576 ptr_zencod_rsa_mod_exp = ptr_exp_1;
577 ptr_zencod_rsa_mod_exp_crt = ptr_exp_2;
578 ptr_zencod_dsa_do_sign = ptr_dsa_1;
579 ptr_zencod_dsa_do_verify = ptr_dsa_2;
580 ptr_zencod_dh_generate_key = ptr_dh_1;
581 ptr_zencod_dh_compute_key = ptr_dh_2;
582 ptr_zencod_rand_bytes = ptr_rand_1;
583 ptr_zencod_math_mod_exp = ptr_math_1;
584 ptr_zencod_test = ptr_0;
585 ptr_zencod_md5_init = ptr_md5_1;
586 ptr_zencod_md5_update = ptr_md5_2;
587 ptr_zencod_md5_do_final = ptr_md5_3;
588 ptr_zencod_sha1_init = ptr_sha1_1;
589 ptr_zencod_sha1_update = ptr_sha1_2;
590 ptr_zencod_sha1_do_final = ptr_sha1_3;
591 ptr_zencod_xdes_cipher = ptr_xdes_1;
592 ptr_zencod_rc4_cipher = ptr_rc4_1;
595 * We should perform a test to see if there is actually any unit runnig on
596 * the system ... Even if the cryptozen library is loaded the module coul
597 * not be loaded on the system ... For now we may just open and close the
601 if (ptr_zencod_test() != 0) {
602 ZENCODerr(ZENCOD_F_ZENCOD_INIT, ZENCOD_R_UNIT_FAILURE);
608 DSO_free(zencod_dso);
610 ptr_zencod_bytes2bits = NULL;
611 ptr_zencod_bits2bytes = NULL;
612 ptr_zencod_new_number = NULL;
613 ptr_zencod_init_number = NULL;
614 ptr_zencod_rsa_mod_exp = NULL;
615 ptr_zencod_rsa_mod_exp_crt = NULL;
616 ptr_zencod_dsa_do_sign = NULL;
617 ptr_zencod_dsa_do_verify = NULL;
618 ptr_zencod_dh_generate_key = NULL;
619 ptr_zencod_dh_compute_key = NULL;
620 ptr_zencod_rand_bytes = NULL;
621 ptr_zencod_math_mod_exp = NULL;
622 ptr_zencod_test = NULL;
623 ptr_zencod_md5_init = NULL;
624 ptr_zencod_md5_update = NULL;
625 ptr_zencod_md5_do_final = NULL;
626 ptr_zencod_sha1_init = NULL;
627 ptr_zencod_sha1_update = NULL;
628 ptr_zencod_sha1_do_final = NULL;
629 ptr_zencod_xdes_cipher = NULL;
630 ptr_zencod_rc4_cipher = NULL;
635 static int zencod_finish(ENGINE *e)
641 * We Should add some tests for non NULL parameters or bad value !!
642 * Stuff to be done ...
644 if (zencod_dso == NULL) {
645 ZENCODerr(ZENCOD_F_ZENCOD_FINISH, ZENCOD_R_NOT_LOADED);
648 if (!DSO_free(zencod_dso)) {
649 ZENCODerr(ZENCOD_F_ZENCOD_FINISH, ZENCOD_R_DSO_FAILURE);
655 ptr_zencod_bytes2bits = NULL;
656 ptr_zencod_bits2bytes = NULL;
657 ptr_zencod_new_number = NULL;
658 ptr_zencod_init_number = NULL;
659 ptr_zencod_rsa_mod_exp = NULL;
660 ptr_zencod_rsa_mod_exp_crt = NULL;
661 ptr_zencod_dsa_do_sign = NULL;
662 ptr_zencod_dsa_do_verify = NULL;
663 ptr_zencod_dh_generate_key = NULL;
664 ptr_zencod_dh_compute_key = NULL;
665 ptr_zencod_rand_bytes = NULL;
666 ptr_zencod_math_mod_exp = NULL;
667 ptr_zencod_test = NULL;
668 ptr_zencod_md5_init = NULL;
669 ptr_zencod_md5_update = NULL;
670 ptr_zencod_md5_do_final = NULL;
671 ptr_zencod_sha1_init = NULL;
672 ptr_zencod_sha1_update = NULL;
673 ptr_zencod_sha1_do_final = NULL;
674 ptr_zencod_xdes_cipher = NULL;
675 ptr_zencod_rc4_cipher = NULL;
680 static int zencod_ctrl(ENGINE *e, int cmd, long i, void *p, void (*f) ())
683 int initialised = ((zencod_dso == NULL) ? 0 : 1);
688 * We Should add some tests for non NULL parameters or bad value !!
689 * Stuff to be done ...
692 case ZENCOD_CMD_SO_PATH:
694 ZENCODerr(ZENCOD_F_ZENCOD_CTRL, ERR_R_PASSED_NULL_PARAMETER);
698 ZENCODerr(ZENCOD_F_ZENCOD_CTRL, ZENCOD_R_ALREADY_LOADED);
701 ZENCOD_LIBNAME = (const char *)p;
707 ZENCODerr(ZENCOD_F_ZENCOD_CTRL, ZENCOD_R_CTRL_COMMAND_NOT_IMPLEMENTED);
713 * BIGNUM stuff Functions
715 static int zencod_bn_mod_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
716 const BIGNUM *m, BN_CTX *ctx)
724 ENGINEerr(ZENCOD_F_ZENCOD_BN_MOD_EXP, ZENCOD_R_NOT_LOADED);
728 if (!bn_wexpand(r, m->top + 1)) {
729 ENGINEerr(ZENCOD_F_ZENCOD_BN_MOD_EXP, ZENCOD_R_BN_EXPAND_FAIL);
733 memset(r->d, 0, BN_num_bytes(m));
735 ptr_zencod_init_number(&y, (r->dmax - 1) * sizeof(BN_ULONG) * 8,
736 (unsigned char *)r->d);
741 /* Must invert x and e parameter due to BN mod exp prototype ... */
742 ret = ptr_zencod_math_mod_exp(&y, &e, &x, &n);
745 PERROR("zenbridge_math_mod_exp");
746 ENGINEerr(ZENCOD_F_ZENCOD_BN_MOD_EXP, ZENCOD_R_REQUEST_FAILED);
750 r->top = (BN_num_bits(m) + BN_BITS2 - 1) / BN_BITS2;
756 * RSA stuff Functions
758 # ifndef OPENSSL_NO_RSA
759 static int RSA_zencod_rsa_mod_exp(BIGNUM *r0, const BIGNUM *i, RSA *rsa)
765 ENGINEerr(ZENCOD_F_ZENCOD_RSA_MOD_EXP_CRT, ZENCOD_R_NOT_LOADED);
769 if (!rsa->p || !rsa->q || !rsa->dmp1 || !rsa->dmq1 || !rsa->iqmp) {
770 ENGINEerr(ZENCOD_F_ZENCOD_RSA_MOD_EXP_CRT,
771 ZENCOD_R_BAD_KEY_COMPONENTS);
775 /* Do in software if argument is too large for hardware */
776 if (RSA_size(rsa) * 8 > ZENBRIDGE_MAX_KEYSIZE_RSA_CRT) {
777 const RSA_METHOD *meth;
779 meth = RSA_PKCS1_OpenSSL();
780 return meth->rsa_mod_exp(r0, i, rsa);
782 zen_nb_t y, x, p, q, dmp1, dmq1, iqmp;
784 if (!bn_expand(r0, RSA_size(rsa) * 8)) {
785 ENGINEerr(ZENCOD_F_ZENCOD_RSA_MOD_EXP_CRT,
786 ZENCOD_R_BN_EXPAND_FAIL);
789 r0->top = (RSA_size(rsa) * 8 + BN_BITS2 - 1) / BN_BITS2;
793 BIGNUM2ZEN(&p, rsa->p);
794 BIGNUM2ZEN(&q, rsa->q);
795 BIGNUM2ZEN(&dmp1, rsa->dmp1);
796 BIGNUM2ZEN(&dmq1, rsa->dmq1);
797 BIGNUM2ZEN(&iqmp, rsa->iqmp);
799 if (ptr_zencod_rsa_mod_exp_crt(&y, &x, &p, &q, &dmp1, &dmq1, &iqmp) <
801 PERROR("zenbridge_rsa_mod_exp_crt");
802 ENGINEerr(ZENCOD_F_ZENCOD_RSA_MOD_EXP_CRT,
803 ZENCOD_R_REQUEST_FAILED);
812 * This function is aliased to RSA_mod_exp (with the mont stuff dropped).
814 static int RSA_zencod_bn_mod_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
815 const BIGNUM *m, BN_CTX *ctx,
822 ENGINEerr(ZENCOD_F_ZENCOD_RSA_MOD_EXP, ZENCOD_R_NOT_LOADED);
826 /* Do in software if argument is too large for hardware */
827 if (BN_num_bits(m) > ZENBRIDGE_MAX_KEYSIZE_RSA) {
828 const RSA_METHOD *meth;
830 meth = RSA_PKCS1_OpenSSL();
831 return meth->bn_mod_exp(r, a, p, m, ctx, m_ctx);
835 if (!bn_expand(r, BN_num_bits(m))) {
836 ENGINEerr(ZENCOD_F_ZENCOD_RSA_MOD_EXP, ZENCOD_R_BN_EXPAND_FAIL);
839 r->top = (BN_num_bits(m) + BN_BITS2 - 1) / BN_BITS2;
846 if (ptr_zencod_rsa_mod_exp(&y, &x, &n, &e) < 0) {
847 PERROR("zenbridge_rsa_mod_exp");
848 ENGINEerr(ZENCOD_F_ZENCOD_RSA_MOD_EXP, ZENCOD_R_REQUEST_FAILED);
855 # endif /* !OPENSSL_NO_RSA */
857 # ifndef OPENSSL_NO_DSA
859 * DSA stuff Functions
861 static DSA_SIG *DSA_zencod_do_sign(const unsigned char *dgst, int dlen,
864 zen_nb_t p, q, g, x, y, r, s, data;
873 ENGINEerr(ZENCOD_F_ZENCOD_DSA_DO_SIGN, ZENCOD_R_NOT_LOADED);
878 ENGINEerr(ZENCOD_F_ZENCOD_DSA_DO_SIGN, ZENCOD_R_REQUEST_FAILED);
882 /* Do in software if argument is too large for hardware */
883 if (BN_num_bits(dsa->p) > ZENBRIDGE_MAX_KEYSIZE_DSA_SIGN ||
884 BN_num_bits(dsa->g) > ZENBRIDGE_MAX_KEYSIZE_DSA_SIGN) {
885 const DSA_METHOD *meth;
886 ENGINEerr(ZENCOD_F_ZENCOD_DSA_DO_SIGN, ZENCOD_R_BAD_KEY_COMPONENTS);
887 meth = DSA_OpenSSL();
888 return meth->dsa_do_sign(dgst, dlen, dsa);
891 if ((bn_s = BN_new()) == NULL || (bn_r = BN_new()) == NULL) {
892 ENGINEerr(ZENCOD_F_ZENCOD_DSA_DO_SIGN, ZENCOD_R_BAD_KEY_COMPONENTS);
896 if (!bn_expand(bn_r, 160) || !bn_expand(bn_s, 160)) {
897 ENGINEerr(ZENCOD_F_ZENCOD_DSA_DO_SIGN, ZENCOD_R_BN_EXPAND_FAIL);
901 bn_r->top = bn_s->top = (160 + BN_BITS2 - 1) / BN_BITS2;
902 BIGNUM2ZEN(&p, dsa->p);
903 BIGNUM2ZEN(&q, dsa->q);
904 BIGNUM2ZEN(&g, dsa->g);
905 BIGNUM2ZEN(&x, dsa->priv_key);
906 BIGNUM2ZEN(&y, dsa->pub_key);
907 BIGNUM2ZEN(&r, bn_r);
908 BIGNUM2ZEN(&s, bn_s);
911 ypcmem(msg, dgst, 20);
912 ptr_zencod_init_number(&data, 160, msg);
914 if (ptr_zencod_dsa_do_sign(0, &data, &y, &p, &q, &g, &x, &r, &s) < 0) {
915 PERROR("zenbridge_dsa_do_sign");
916 ENGINEerr(ZENCOD_F_ZENCOD_DSA_DO_SIGN, ZENCOD_R_REQUEST_FAILED);
920 if ((sig = DSA_SIG_new()) == NULL) {
921 ENGINEerr(ZENCOD_F_ZENCOD_DSA_DO_SIGN, ZENCOD_R_REQUEST_FAILED);
934 static int DSA_zencod_do_verify(const unsigned char *dgst, int dlen,
935 DSA_SIG *sig, DSA *dsa)
937 zen_nb_t data, p, q, g, y, r, s, v;
945 ENGINEerr(ZENCOD_F_ZENCOD_DSA_DO_VERIFY, ZENCOD_R_NOT_LOADED);
950 ENGINEerr(ZENCOD_F_ZENCOD_DSA_DO_SIGN, ZENCOD_R_REQUEST_FAILED);
954 /* Do in software if argument is too large for hardware */
955 if (BN_num_bits(dsa->p) > ZENBRIDGE_MAX_KEYSIZE_DSA_SIGN ||
956 BN_num_bits(dsa->g) > ZENBRIDGE_MAX_KEYSIZE_DSA_SIGN) {
957 const DSA_METHOD *meth;
958 ENGINEerr(ZENCOD_F_ZENCOD_DSA_DO_SIGN, ZENCOD_R_BAD_KEY_COMPONENTS);
959 meth = DSA_OpenSSL();
960 return meth->dsa_do_verify(dgst, dlen, sig, dsa);
963 BIGNUM2ZEN(&p, dsa->p);
964 BIGNUM2ZEN(&q, dsa->q);
965 BIGNUM2ZEN(&g, dsa->g);
966 BIGNUM2ZEN(&y, dsa->pub_key);
967 BIGNUM2ZEN(&r, sig->r);
968 BIGNUM2ZEN(&s, sig->s);
969 ptr_zencod_init_number(&v, 160, v_data);
970 ypcmem(msg, dgst, 20);
971 ptr_zencod_init_number(&data, 160, msg);
974 ptr_zencod_dsa_do_verify(0, &data, &p, &q, &g, &y, &r, &s,
976 PERROR("zenbridge_dsa_do_verify");
977 ENGINEerr(ZENCOD_F_ZENCOD_DSA_DO_VERIFY, ZENCOD_R_REQUEST_FAILED);
981 return ((ret == 0) ? 1 : ret);
984 static int DSA_zencod_bn_mod_exp(DSA *dsa, BIGNUM *r, BIGNUM *a,
985 const BIGNUM *p, const BIGNUM *m,
986 BN_CTX *ctx, BN_MONT_CTX *m_ctx)
990 return zencod_bn_mod_exp(r, a, p, m, ctx);
992 # endif /* !OPENSSL_NO_DSA */
994 # ifndef OPENSSl_NO_DH
998 static int DH_zencod_generate_key(DH *dh)
1000 BIGNUM *bn_prv = NULL;
1001 BIGNUM *bn_pub = NULL;
1002 zen_nb_t y, x, g, p;
1008 ENGINEerr(ZENCOD_F_ZENCOD_DH_GENERATE, ZENCOD_R_NOT_LOADED);
1014 bn_prv = dh->priv_key;
1017 if ((bn_prv = BN_new()) == NULL) {
1018 ENGINEerr(ZENCOD_F_ZENCOD_DH_GENERATE, ZENCOD_R_BN_EXPAND_FAIL);
1026 bn_pub = dh->pub_key;
1027 else if ((bn_pub = BN_new()) == NULL) {
1028 ENGINEerr(ZENCOD_F_ZENCOD_DH_GENERATE, ZENCOD_R_BN_EXPAND_FAIL);
1033 if (!bn_wexpand(bn_prv, dh->p->dmax) || !bn_wexpand(bn_pub, dh->p->dmax)) {
1034 ENGINEerr(ZENCOD_F_ZENCOD_DH_GENERATE, ZENCOD_R_BN_EXPAND_FAIL);
1037 bn_prv->top = dh->p->top;
1038 bn_pub->top = dh->p->top;
1040 /* Convert all keys */
1041 BIGNUM2ZEN(&p, dh->p);
1042 BIGNUM2ZEN(&g, dh->g);
1043 BIGNUM2ZEN(&y, bn_pub);
1044 BIGNUM2ZEN(&x, bn_prv);
1045 x.len = DH_size(dh) * 8;
1047 /* Adjust the lengths of P and G */
1048 p.len = ptr_zencod_bytes2bits(p.data, ZEN_BYTES(p.len));
1049 g.len = ptr_zencod_bytes2bits(g.data, ZEN_BYTES(g.len));
1051 /* Send the request to the driver */
1052 if (ptr_zencod_dh_generate_key(&y, &x, &g, &p, generate_x) < 0) {
1053 perror("zenbridge_dh_generate_key");
1054 ENGINEerr(ZENCOD_F_ZENCOD_DH_GENERATE, ZENCOD_R_REQUEST_FAILED);
1058 dh->priv_key = bn_prv;
1059 dh->pub_key = bn_pub;
1072 static int DH_zencod_compute_key(unsigned char *key, const BIGNUM *pub_key,
1075 zen_nb_t y, x, p, k;
1080 ENGINEerr(ZENCOD_F_ZENCOD_DH_COMPUTE, ZENCOD_R_NOT_LOADED);
1084 if (!dh->priv_key) {
1085 ENGINEerr(ZENCOD_F_ZENCOD_DH_COMPUTE, ZENCOD_R_BAD_KEY_COMPONENTS);
1089 /* Convert all keys */
1090 BIGNUM2ZEN(&y, pub_key);
1091 BIGNUM2ZEN(&x, dh->priv_key);
1092 BIGNUM2ZEN(&p, dh->p);
1093 ptr_zencod_init_number(&k, p.len, key);
1095 /* Adjust the lengths */
1096 p.len = ptr_zencod_bytes2bits(p.data, ZEN_BYTES(p.len));
1097 y.len = ptr_zencod_bytes2bits(y.data, ZEN_BYTES(y.len));
1098 x.len = ptr_zencod_bytes2bits(x.data, ZEN_BYTES(x.len));
1100 /* Call the hardware */
1101 if (ptr_zencod_dh_compute_key(&k, &y, &x, &p) < 0) {
1102 ENGINEerr(ZENCOD_F_ZENCOD_DH_COMPUTE, ZENCOD_R_REQUEST_FAILED);
1106 /* The key must be written MSB -> LSB */
1107 k.len = ptr_zencod_bytes2bits(k.data, ZEN_BYTES(k.len));
1108 esrever(key, ZEN_BYTES(k.len));
1110 return ZEN_BYTES(k.len);
1113 static int DH_zencod_bn_mod_exp(const DH *dh, BIGNUM *r, const BIGNUM *a,
1114 const BIGNUM *p, const BIGNUM *m, BN_CTX *ctx,
1119 return zencod_bn_mod_exp(r, a, p, m, ctx);
1121 # endif /* !OPENSSL_NO_DH */
1124 * RAND stuff Functions
1126 static void RAND_zencod_seed(const void *buf, int num)
1129 * Nothing to do cause our crypto accelerator provide a true random
1134 static int RAND_zencod_rand_bytes(unsigned char *buf, int num)
1141 ENGINEerr(ZENCOD_F_ZENCOD_RAND, ZENCOD_R_NOT_LOADED);
1145 ptr_zencod_init_number(&r, num * 8, buf);
1147 if (ptr_zencod_rand_bytes(&r, ZENBRIDGE_RNG_DIRECT) < 0) {
1148 PERROR("zenbridge_rand_bytes");
1149 ENGINEerr(ZENCOD_F_ZENCOD_RAND, ZENCOD_R_REQUEST_FAILED);
1156 static int RAND_zencod_rand_status(void)
1164 * This stuff is needed if this ENGINE is being compiled into a
1165 * self-contained shared-library.
1167 # ifdef ENGINE_DYNAMIC_SUPPORT
1168 static int bind_fn(ENGINE *e, const char *id)
1171 if (id && (strcmp(id, engine_zencod_id) != 0)) {
1174 if (!bind_helper(e)) {
1181 IMPLEMENT_DYNAMIC_CHECK_FN()
1182 IMPLEMENT_DYNAMIC_BIND_FN(bind_fn)
1183 # endif /* ENGINE_DYNAMIC_SUPPORT */
1185 * Adding "Digest" and "Cipher" tools ...
1186 * This is in development ... ;-)
1187 * In orfer to code this, i refer to hw_openbsd_dev_crypto and openssl engine made by Geoff Thorpe (if i'm rigth),
1188 * and evp, sha md5 definitions etc ...
1190 /* First add some include ... */
1191 # include <openssl/evp.h>
1192 # include <openssl/sha.h>
1193 # include <openssl/md5.h>
1194 # include <openssl/rc4.h>
1195 # include <openssl/des.h>
1196 /* Some variables declaration ... */
1198 * DONS: Disable symetric computation except DES and 3DES, but let part
1201 /* static int engine_digest_nids [ ] = { NID_sha1, NID_md5 } ; */
1202 static int engine_digest_nids[] = { };
1204 static int engine_digest_nids_num = 0;
1206 * static int engine_cipher_nids [ ] = { NID_rc4, NID_rc4_40, NID_des_cbc,
1207 * NID_des_ede3_cbc } ;
1209 static int engine_cipher_nids[] = { NID_des_cbc, NID_des_ede3_cbc };
1211 static int engine_cipher_nids_num = 2;
1213 /* Function prototype ... */
1215 static int engine_sha1_init(EVP_MD_CTX *ctx);
1216 static int engine_sha1_update(EVP_MD_CTX *ctx, const void *data,
1217 unsigned long count);
1218 static int engine_sha1_final(EVP_MD_CTX *ctx, unsigned char *md);
1221 static int engine_md5_init(EVP_MD_CTX *ctx);
1222 static int engine_md5_update(EVP_MD_CTX *ctx, const void *data,
1223 unsigned long count);
1224 static int engine_md5_final(EVP_MD_CTX *ctx, unsigned char *md);
1226 static int engine_md_cleanup(EVP_MD_CTX *ctx);
1227 static int engine_md_copy(EVP_MD_CTX *to, const EVP_MD_CTX *from);
1230 static int engine_rc4_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
1231 const unsigned char *iv, int enc);
1232 static int engine_rc4_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
1233 const unsigned char *in, unsigned int inl);
1236 static int engine_des_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
1237 const unsigned char *iv, int enc);
1238 static int engine_des_cbc_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
1239 const unsigned char *in, unsigned int inl);
1242 static int engine_des_ede3_init_key(EVP_CIPHER_CTX *ctx,
1243 const unsigned char *key,
1244 const unsigned char *iv, int enc);
1245 static int engine_des_ede3_cbc_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
1246 const unsigned char *in,
1249 static int engine_cipher_cleanup(EVP_CIPHER_CTX *ctx); /* cleanup ctx */
1251 /* The one for SHA ... */
1252 static const EVP_MD engine_sha1_md = {
1254 NID_sha1WithRSAEncryption,
1256 EVP_MD_FLAG_ONESHOT,
1260 * EVP_MD_FLAG_ONESHOT = x0001 digest can only handle a single block *
1261 * XXX: set according to device info ...
1266 engine_md_copy, /* dev_crypto_sha_copy */
1267 engine_md_cleanup, /* dev_crypto_sha_cleanup */
1268 EVP_PKEY_RSA_method,
1270 /* sizeof ( EVP_MD * ) + sizeof ( SHA_CTX ) */
1273 * sizeof ( MD_CTX_DATA ) The message digest data structure ...
1277 /* The one for MD5 ... */
1278 static const EVP_MD engine_md5_md = {
1280 NID_md5WithRSAEncryption,
1282 EVP_MD_FLAG_ONESHOT,
1286 * EVP_MD_FLAG_ONESHOT = x0001 digest can only handle a single block *
1287 * XXX: set according to device info ...
1292 engine_md_copy, /* dev_crypto_md5_copy */
1293 engine_md_cleanup, /* dev_crypto_md5_cleanup */
1294 EVP_PKEY_RSA_method,
1296 /* sizeof ( EVP_MD * ) + sizeof ( MD5_CTX ) */
1299 * sizeof ( MD_CTX_DATA ) The message digest data structure ...
1303 /* The one for RC4 ... */
1304 # define EVP_RC4_KEY_SIZE 16
1306 /* Try something static ... */
1310 unsigned char rc4_state[260];
1313 # define rc4_data(ctx) ( (EVP_RC4_KEY *) ( ctx )->cipher_data )
1315 static const EVP_CIPHER engine_rc4 = {
1318 16, /* EVP_RC4_KEY_SIZE should be 128 bits */
1319 0, /* FIXME: key should be up to 256 bytes */
1320 EVP_CIPH_VARIABLE_LENGTH,
1321 engine_rc4_init_key,
1323 engine_cipher_cleanup,
1324 sizeof(NEW_ZEN_RC4_KEY),
1330 /* The one for RC4_40 ... */
1331 static const EVP_CIPHER engine_rc4_40 = {
1336 EVP_CIPH_VARIABLE_LENGTH,
1337 engine_rc4_init_key,
1339 engine_cipher_cleanup,
1340 sizeof(NEW_ZEN_RC4_KEY),
1346 /* The one for DES ... */
1348 /* Try something static ... */
1350 unsigned char des_key[24];
1351 unsigned char des_iv[8];
1354 static const EVP_CIPHER engine_des_cbc = {
1357 0 | EVP_CIPH_CBC_MODE,
1358 engine_des_init_key,
1359 engine_des_cbc_cipher,
1360 engine_cipher_cleanup,
1361 sizeof(ZEN_DES_KEY),
1362 EVP_CIPHER_set_asn1_iv,
1363 EVP_CIPHER_get_asn1_iv,
1368 /* The one for 3DES ... */
1370 /* Try something static ... */
1372 unsigned char des3_key[24];
1373 unsigned char des3_iv[8];
1376 # define des_data(ctx) ( (DES_EDE_KEY *) ( ctx )->cipher_data )
1378 static const EVP_CIPHER engine_des_ede3_cbc = {
1381 0 | EVP_CIPH_CBC_MODE,
1382 engine_des_ede3_init_key,
1383 engine_des_ede3_cbc_cipher,
1384 engine_cipher_cleanup,
1385 sizeof(ZEN_3DES_KEY),
1386 EVP_CIPHER_set_asn1_iv,
1387 EVP_CIPHER_get_asn1_iv,
1392 /* General function cloned on hw_openbsd_dev_crypto one ... */
1393 static int engine_digests(ENGINE *e, const EVP_MD **digest, const int **nids,
1397 # ifdef DEBUG_ZENCOD_MD
1398 fprintf(stderr, "\t=>Function : static int engine_digests () called !\n");
1402 /* We are returning a list of supported nids */
1403 *nids = engine_digest_nids;
1404 return engine_digest_nids_num;
1406 /* We are being asked for a specific digest */
1407 if (nid == NID_md5) {
1408 *digest = &engine_md5_md;
1409 } else if (nid == NID_sha1) {
1410 *digest = &engine_sha1_md;
1419 * SHA stuff Functions
1421 static int engine_sha1_init(EVP_MD_CTX *ctx)
1426 /* Test with zenbridge library ... */
1427 to_return = ptr_zencod_sha1_init((ZEN_MD_DATA *)ctx->md_data);
1428 to_return = !to_return;
1433 static int engine_sha1_update(EVP_MD_CTX *ctx, const void *data,
1434 unsigned long count)
1440 /* Convert parameters ... */
1442 input.data = (unsigned char *)data;
1444 /* Test with zenbridge library ... */
1446 ptr_zencod_sha1_update((ZEN_MD_DATA *)ctx->md_data,
1447 (const zen_nb_t *)&input);
1448 to_return = !to_return;
1453 static int engine_sha1_final(EVP_MD_CTX *ctx, unsigned char *md)
1459 /* Convert parameters ... */
1460 output.len = SHA_DIGEST_LENGTH;
1463 /* Test with zenbridge library ... */
1465 ptr_zencod_sha1_do_final((ZEN_MD_DATA *)ctx->md_data,
1466 (zen_nb_t *) & output);
1467 to_return = !to_return;
1473 * MD5 stuff Functions
1475 static int engine_md5_init(EVP_MD_CTX *ctx)
1480 /* Test with zenbridge library ... */
1481 to_return = ptr_zencod_md5_init((ZEN_MD_DATA *)ctx->md_data);
1482 to_return = !to_return;
1487 static int engine_md5_update(EVP_MD_CTX *ctx, const void *data,
1488 unsigned long count)
1494 /* Convert parameters ... */
1496 input.data = (unsigned char *)data;
1498 /* Test with zenbridge library ... */
1500 ptr_zencod_md5_update((ZEN_MD_DATA *)ctx->md_data,
1501 (const zen_nb_t *)&input);
1502 to_return = !to_return;
1507 static int engine_md5_final(EVP_MD_CTX *ctx, unsigned char *md)
1513 /* Convert parameters ... */
1514 output.len = MD5_DIGEST_LENGTH;
1517 /* Test with zenbridge library ... */
1519 ptr_zencod_md5_do_final((ZEN_MD_DATA *)ctx->md_data,
1520 (zen_nb_t *) & output);
1521 to_return = !to_return;
1526 static int engine_md_cleanup(EVP_MD_CTX *ctx)
1529 ZEN_MD_DATA *zen_md_data = (ZEN_MD_DATA *)ctx->md_data;
1531 OPENSSL_free(zen_md_data->HashBuffer);
1532 zen_md_data->HashBufferSize = 0;
1533 ctx->md_data = NULL;
1537 static int engine_md_copy(EVP_MD_CTX *to, const EVP_MD_CTX *from)
1539 const ZEN_MD_DATA *from_md = (ZEN_MD_DATA *)from->md_data;
1540 ZEN_MD_DATA *to_md = (ZEN_MD_DATA *)to->md_data;
1542 to_md->HashBuffer = OPENSSL_malloc(from_md->HashBufferSize);
1543 if (to_md->HashBuffer == NULL)
1545 memcpy(to_md->HashBuffer, from_md->HashBuffer, from_md->HashBufferSize);
1550 /* General function cloned on hw_openbsd_dev_crypto one ... */
1551 static int engine_ciphers(ENGINE *e, const EVP_CIPHER **cipher,
1552 const int **nids, int nid)
1556 /* We are returning a list of supported nids */
1557 *nids = engine_cipher_nids;
1558 return engine_cipher_nids_num;
1560 /* We are being asked for a specific cipher */
1561 if (nid == NID_rc4) {
1562 *cipher = &engine_rc4;
1563 } else if (nid == NID_rc4_40) {
1564 *cipher = &engine_rc4_40;
1565 } else if (nid == NID_des_cbc) {
1566 *cipher = &engine_des_cbc;
1567 } else if (nid == NID_des_ede3_cbc) {
1568 *cipher = &engine_des_ede3_cbc;
1577 static int engine_rc4_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
1578 const unsigned char *iv, int enc)
1583 NEW_ZEN_RC4_KEY *tmp_rc4_key = NULL;
1585 tmp_rc4_key = (NEW_ZEN_RC4_KEY *) (ctx->cipher_data);
1586 tmp_rc4_key->first = 0;
1587 tmp_rc4_key->len = ctx->key_len;
1588 tmp_rc4_key->rc4_state[0] = 0x00;
1589 tmp_rc4_key->rc4_state[2] = 0x00;
1590 nb = 256 / ctx->key_len;
1591 for (i = 0; i < nb; i++) {
1592 memcpy(&(tmp_rc4_key->rc4_state[4 + i * ctx->key_len]), key,
1601 static int engine_rc4_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
1602 const unsigned char *in, unsigned int in_len)
1605 zen_nb_t output, input;
1608 NEW_ZEN_RC4_KEY *tmp_rc4_key = NULL;
1610 /* Convert parameters ... */
1612 input.data = (unsigned char *)in;
1613 output.len = in_len;
1614 output.data = (unsigned char *)out;
1616 tmp_rc4_key = ((NEW_ZEN_RC4_KEY *) (ctx->cipher_data));
1618 rc4key.data = &(tmp_rc4_key->rc4_state[0]);
1620 /* Test with zenbridge library ... */
1622 ptr_zencod_rc4_cipher(&output, &input, (const zen_nb_t *)&rc4key,
1623 &(tmp_rc4_key->rc4_state[0]),
1624 &(tmp_rc4_key->rc4_state[3]),
1625 !tmp_rc4_key->first);
1626 to_return = !to_return;
1628 /* Update encryption state ... */
1629 tmp_rc4_key->first = 1;
1635 static int engine_des_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
1636 const unsigned char *iv, int enc)
1639 ZEN_DES_KEY *tmp_des_key = NULL;
1642 tmp_des_key = (ZEN_DES_KEY *) (ctx->cipher_data);
1643 memcpy(&(tmp_des_key->des_key[0]), key, 8);
1644 memcpy(&(tmp_des_key->des_key[8]), key, 8);
1645 memcpy(&(tmp_des_key->des_key[16]), key, 8);
1646 memcpy(&(tmp_des_key->des_iv[0]), iv, 8);
1653 static int engine_des_cbc_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
1654 const unsigned char *in, unsigned int inl)
1657 zen_nb_t output, input;
1658 zen_nb_t deskey_1, deskey_2, deskey_3, iv;
1661 /* Convert parameters ... */
1663 input.data = (unsigned char *)in;
1667 /* Set key parameters ... */
1672 (unsigned char *)((ZEN_DES_KEY *) (ctx->cipher_data))->des_key;
1674 (unsigned char *)&((ZEN_DES_KEY *) (ctx->cipher_data))->des_key[8];
1676 (unsigned char *)&((ZEN_DES_KEY *) (ctx->cipher_data))->des_key[16];
1678 /* Key correct iv ... */
1679 memcpy(((ZEN_DES_KEY *) (ctx->cipher_data))->des_iv, ctx->iv, 8);
1681 iv.data = (unsigned char *)((ZEN_DES_KEY *) (ctx->cipher_data))->des_iv;
1683 if (ctx->encrypt == 0) {
1684 memcpy(ctx->iv, &(input.data[input.len - 8]), 8);
1687 /* Test with zenbridge library ... */
1688 to_return = ptr_zencod_xdes_cipher(&output, &input,
1689 (zen_nb_t *) & deskey_1,
1690 (zen_nb_t *) & deskey_2,
1691 (zen_nb_t *) & deskey_3, &iv,
1693 to_return = !to_return;
1696 * But we need to set up the rigth iv ... Test ENCRYPT or DECRYPT mode to
1699 if (ctx->encrypt == 1) {
1700 memcpy(ctx->iv, &(output.data[output.len - 8]), 8);
1706 static int engine_des_ede3_init_key(EVP_CIPHER_CTX *ctx,
1707 const unsigned char *key,
1708 const unsigned char *iv, int enc)
1711 ZEN_3DES_KEY *tmp_3des_key = NULL;
1714 tmp_3des_key = (ZEN_3DES_KEY *) (ctx->cipher_data);
1715 memcpy(&(tmp_3des_key->des3_key[0]), key, 24);
1716 memcpy(&(tmp_3des_key->des3_iv[0]), iv, 8);
1723 static int engine_des_ede3_cbc_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
1724 const unsigned char *in,
1725 unsigned int in_len)
1728 zen_nb_t output, input;
1729 zen_nb_t deskey_1, deskey_2, deskey_3, iv;
1732 /* Convert parameters ... */
1734 input.data = (unsigned char *)in;
1735 output.len = in_len;
1743 (unsigned char *)((ZEN_3DES_KEY *) (ctx->cipher_data))->des3_key;
1745 (unsigned char *)&((ZEN_3DES_KEY *) (ctx->cipher_data))->des3_key[8];
1747 (unsigned char *)&((ZEN_3DES_KEY *) (ctx->cipher_data))->des3_key[16];
1749 /* Key correct iv ... */
1750 memcpy(((ZEN_3DES_KEY *) (ctx->cipher_data))->des3_iv, ctx->iv, 8);
1752 iv.data = (unsigned char *)((ZEN_3DES_KEY *) (ctx->cipher_data))->des3_iv;
1754 if (ctx->encrypt == 0) {
1755 memcpy(ctx->iv, &(input.data[input.len - 8]), 8);
1758 /* Test with zenbridge library ... */
1759 to_return = ptr_zencod_xdes_cipher(&output, &input,
1760 (zen_nb_t *) & deskey_1,
1761 (zen_nb_t *) & deskey_2,
1762 (zen_nb_t *) & deskey_3, &iv,
1764 to_return = !to_return;
1766 if (ctx->encrypt == 1) {
1767 memcpy(ctx->iv, &(output.data[output.len - 8]), 8);
1773 static int engine_cipher_cleanup(EVP_CIPHER_CTX *ctx)
1776 /* Set the key pointer ... */
1777 if (ctx->cipher->nid == NID_rc4 || ctx->cipher->nid == NID_rc4_40) {
1778 } else if (ctx->cipher->nid == NID_des_cbc) {
1779 } else if (ctx->cipher->nid == NID_des_ede3_cbc) {
1785 # endif /* !OPENSSL_NO_HW_ZENCOD */
1786 #endif /* !OPENSSL_NO_HW */