d4708
/
source-engine
mirror of https://github.com/nillerusr/source-engine.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
26 Commits
25 Branches
6 Tags
221 MiB
Tree: 85a22a3a92
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '85a22a3a92'
${ noResults }
source-engine/thirdparty/openssl/demos/engines/zencod/hw_zencod.c

1810 lines
51 KiB
Raw Normal View History Unescape

Add thirdparty libs
4 years ago
/* crypto/engine/hw_zencod.c */
/*
* Written by Fred Donnat (frederic.donnat@zencod.com) for "zencod" * engine
* integration in order to redirect crypto computing on a crypto * hardware
* accelerator zenssl32 ;-) * * Date : 25 jun 2002 * Revision : 17 Ju7 2002
* * Version : zencod_engine-0.9.7
*/
/* ====================================================================
* Copyright (c) 1999-2001 The OpenSSL Project. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* 3. All advertising materials mentioning features or use of this
* software must display the following acknowledgment:
* "This product includes software developed by the OpenSSL Project
* for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
*
* 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
* endorse or promote products derived from this software without
* prior written permission. For written permission, please contact
* licensing@OpenSSL.org.
*
* 5. Products derived from this software may not be called "OpenSSL"
* nor may "OpenSSL" appear in their names without prior written
* permission of the OpenSSL Project.
*
* 6. Redistributions of any form whatsoever must retain the following
* acknowledgment:
* "This product includes software developed by the OpenSSL Project
* for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
*
* THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
* EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE.
* ====================================================================
*
* This product includes cryptographic software written by Eric Young
* (eay@cryptsoft.com). This product includes software written by Tim
* Hudson (tjh@cryptsoft.com).
*
*/
/* ENGINE general include */
#include <stdio.h>
#include <openssl/crypto.h>
#include <openssl/dso.h>
#include <openssl/engine.h>
#ifndef OPENSSL_NO_HW
# ifndef OPENSSL_NO_HW_ZENCOD
# ifdef FLAT_INC
# include "hw_zencod.h"
# else
# include "vendor_defns/hw_zencod.h"
# endif
# define ZENCOD_LIB_NAME "zencod engine"
# include "hw_zencod_err.c"
# define FAIL_TO_SOFTWARE -15
# define ZEN_LIBRARY "zenbridge"
# if 0
# define PERROR(s) perror(s)
# define CHEESE() fputs("## [ZenEngine] ## " __FUNCTION__ "\n", stderr)
# else
# define PERROR(s)
# define CHEESE()
# endif
/* Sorry ;) */
# ifndef WIN32
static inline void esrever(unsigned char *d, int l)
{
for (; --l > 0; --l, d++) {
*d ^= *(d + l);
*(d + l) ^= *d;
*d ^= *(d + l);
}
}
static inline void ypcmem(unsigned char *d, const unsigned char *s, int l)
{
for (d += l; l--;)
*--d = *s++;
}
# else
static __inline void esrever(unsigned char *d, int l)
{
for (; --l > 0; --l, d++) {
*d ^= *(d + l);
*(d + l) ^= *d;
*d ^= *(d + l);
}
}
static __inline void ypcmem(unsigned char *d, const unsigned char *s, int l)
{
for (d += l; l--;)
*--d = *s++;
}
# endif
# define BIGNUM2ZEN(n, bn) (ptr_zencod_init_number((n), \
(unsigned long) ((bn)->top * BN_BITS2), \
(unsigned char *) ((bn)->d)))
# define ZEN_BITS(n, bytes) (ptr_zencod_bytes2bits((unsigned char *) (n), (unsigned long) (bytes)))
# define ZEN_BYTES(bits) (ptr_zencod_bits2bytes((unsigned long) (bits)))
/* Function for ENGINE detection and control */
static int zencod_destroy(ENGINE *e);
static int zencod_init(ENGINE *e);
static int zencod_finish(ENGINE *e);
static int zencod_ctrl(ENGINE *e, int cmd, long i, void *p, void (*f) ());
/* BIGNUM stuff */
static int zencod_bn_mod_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
const BIGNUM *m, BN_CTX *ctx);
/* RSA stuff */
# ifndef OPENSSL_NO_RSA
static int RSA_zencod_rsa_mod_exp(BIGNUM *r0, const BIGNUM *I, RSA *rsa);
static int RSA_zencod_bn_mod_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
const BIGNUM *m, BN_CTX *ctx,
BN_MONT_CTX *m_ctx);
# endif
/* DSA stuff */
# ifndef OPENSSL_NO_DSA
static int DSA_zencod_bn_mod_exp(DSA *dsa, BIGNUM *r, BIGNUM *a,
const BIGNUM *p, const BIGNUM *m,
BN_CTX *ctx, BN_MONT_CTX *m_ctx);
static DSA_SIG *DSA_zencod_do_sign(const unsigned char *dgst, int dlen,
DSA *dsa);
static int DSA_zencod_do_verify(const unsigned char *dgst, int dgst_len,
DSA_SIG *sig, DSA *dsa);
# endif
/* DH stuff */
# ifndef OPENSSL_NO_DH
static int DH_zencod_bn_mod_exp(const DH *dh, BIGNUM *r, const BIGNUM *a,
const BIGNUM *p, const BIGNUM *m, BN_CTX *ctx,
BN_MONT_CTX *m_ctx);
static int DH_zencod_generate_key(DH *dh);
static int DH_zencod_compute_key(unsigned char *key, const BIGNUM *pub_key,
DH *dh);
# endif
/* Rand stuff */
static void RAND_zencod_seed(const void *buf, int num);
static int RAND_zencod_rand_bytes(unsigned char *buf, int num);
static int RAND_zencod_rand_status(void);
/* Digest Stuff */
static int engine_digests(ENGINE *e, const EVP_MD **digest, const int **nids,
int nid);
/* Cipher Stuff */
static int engine_ciphers(ENGINE *e, const EVP_CIPHER **cipher,
const int **nids, int nid);
# define ZENCOD_CMD_SO_PATH ENGINE_CMD_BASE
static const ENGINE_CMD_DEFN zencod_cmd_defns[] = {
{ZENCOD_CMD_SO_PATH,
"SO_PATH",
"Specifies the path to the 'zenbridge' shared library",
ENGINE_CMD_FLAG_STRING},
{0, NULL, NULL, 0}
};
# ifndef OPENSSL_NO_RSA
/*
* Our internal RSA_METHOD specific to zencod ENGINE providing pointers to
* our function
*/
static RSA_METHOD zencod_rsa = {
"ZENCOD RSA method",
NULL,
NULL,
NULL,
NULL,
RSA_zencod_rsa_mod_exp,
RSA_zencod_bn_mod_exp,
NULL,
NULL,
0,
NULL,
NULL,
NULL
};
# endif
# ifndef OPENSSL_NO_DSA
/*
* Our internal DSA_METHOD specific to zencod ENGINE providing pointers to
* our function
*/
static DSA_METHOD zencod_dsa = {
"ZENCOD DSA method",
DSA_zencod_do_sign,
NULL,
DSA_zencod_do_verify,
NULL,
DSA_zencod_bn_mod_exp,
NULL,
NULL,
0,
NULL
};
# endif
# ifndef OPENSSL_NO_DH
/*
* Our internal DH_METHOD specific to zencod ENGINE providing pointers to our
* function
*/
static DH_METHOD zencod_dh = {
"ZENCOD DH method",
DH_zencod_generate_key,
DH_zencod_compute_key,
DH_zencod_bn_mod_exp,
NULL,
NULL,
0,
NULL
};
# endif
/*
* Our internal RAND_meth specific to zencod ZNGINE providing pointers to our
* function
*/
static RAND_METHOD zencod_rand = {
RAND_zencod_seed,
RAND_zencod_rand_bytes,
NULL,
NULL,
RAND_zencod_rand_bytes,
RAND_zencod_rand_status
};
/* Constants used when creating the ENGINE */
static const char *engine_zencod_id = "zencod";
static const char *engine_zencod_name = "ZENCOD hardware engine support";
/*
* This internal function is used by ENGINE_zencod () and possibly by the
* "dynamic" ENGINE support too ;-)
*/
static int bind_helper(ENGINE *e)
{
# ifndef OPENSSL_NO_RSA
const RSA_METHOD *meth_rsa;
# endif
# ifndef OPENSSL_NO_DSA
const DSA_METHOD *meth_dsa;
# endif
# ifndef OPENSSL_NO_DH
const DH_METHOD *meth_dh;
# endif
const RAND_METHOD *meth_rand;
if (!ENGINE_set_id(e, engine_zencod_id) ||
!ENGINE_set_name(e, engine_zencod_name) ||
# ifndef OPENSSL_NO_RSA
!ENGINE_set_RSA(e, &zencod_rsa) ||
# endif
# ifndef OPENSSL_NO_DSA
!ENGINE_set_DSA(e, &zencod_dsa) ||
# endif
# ifndef OPENSSL_NO_DH
!ENGINE_set_DH(e, &zencod_dh) ||
# endif
!ENGINE_set_RAND(e, &zencod_rand) ||
!ENGINE_set_destroy_function(e, zencod_destroy) ||
!ENGINE_set_init_function(e, zencod_init) ||
!ENGINE_set_finish_function(e, zencod_finish) ||
!ENGINE_set_ctrl_function(e, zencod_ctrl) ||
!ENGINE_set_cmd_defns(e, zencod_cmd_defns) ||
!ENGINE_set_digests(e, engine_digests) ||
!ENGINE_set_ciphers(e, engine_ciphers)) {
return 0;
}
# ifndef OPENSSL_NO_RSA
/*
* We know that the "PKCS1_SSLeay()" functions hook properly to the
* Zencod-specific mod_exp and mod_exp_crt so we use those functions. NB:
* We don't use ENGINE_openssl() or anything "more generic" because
* something like the RSAref code may not hook properly, and if you own
* one of these cards then you have the right to do RSA operations on it
* anyway!
*/
meth_rsa = RSA_PKCS1_SSLeay();
zencod_rsa.rsa_pub_enc = meth_rsa->rsa_pub_enc;
zencod_rsa.rsa_pub_dec = meth_rsa->rsa_pub_dec;
zencod_rsa.rsa_priv_enc = meth_rsa->rsa_priv_enc;
zencod_rsa.rsa_priv_dec = meth_rsa->rsa_priv_dec;
/* meth_rsa->rsa_mod_exp */
/* meth_rsa->bn_mod_exp */
zencod_rsa.init = meth_rsa->init;
zencod_rsa.finish = meth_rsa->finish;
# endif
# ifndef OPENSSL_NO_DSA
/*
* We use OpenSSL meth to supply what we don't provide ;-*)
*/
meth_dsa = DSA_OpenSSL();
/* meth_dsa->dsa_do_sign */
zencod_dsa.dsa_sign_setup = meth_dsa->dsa_sign_setup;
/* meth_dsa->dsa_do_verify */
zencod_dsa.dsa_mod_exp = meth_dsa->dsa_mod_exp;
/* zencod_dsa.bn_mod_exp = meth_dsa->bn_mod_exp ; */
zencod_dsa.init = meth_dsa->init;
zencod_dsa.finish = meth_dsa->finish;
# endif
# ifndef OPENSSL_NO_DH
/*
* We use OpenSSL meth to supply what we don't provide ;-*)
*/
meth_dh = DH_OpenSSL();
/* zencod_dh.generate_key = meth_dh->generate_key ; */
/* zencod_dh.compute_key = meth_dh->compute_key ; */
/* zencod_dh.bn_mod_exp = meth_dh->bn_mod_exp ; */
zencod_dh.init = meth_dh->init;
zencod_dh.finish = meth_dh->finish;
# endif
/*
* We use OpenSSL (SSLeay) meth to supply what we don't provide ;-*)
*/
meth_rand = RAND_SSLeay();
/* meth_rand->seed ; */
/* zencod_rand.seed = meth_rand->seed ; */
/* meth_rand->bytes ; */
/* zencod_rand.bytes = meth_rand->bytes ; */
zencod_rand.cleanup = meth_rand->cleanup;
zencod_rand.add = meth_rand->add;
/* meth_rand->pseudorand ; */
/* zencod_rand.pseudorand = meth_rand->pseudorand ; */
/* zencod_rand.status = meth_rand->status ; */
/* meth_rand->status ; */
/* Ensure the zencod error handling is set up */
ERR_load_ZENCOD_strings();
return 1;
}
/*
* As this is only ever called once, there's no need for locking (indeed -
* the lock will already be held by our caller!!!)
*/
static ENGINE *ENGINE_zencod(void)
{
ENGINE *eng = ENGINE_new();
if (!eng) {
return NULL;
}
if (!bind_helper(eng)) {
ENGINE_free(eng);
return NULL;
}
return eng;
}
# ifdef ENGINE_DYNAMIC_SUPPORT
static
# endif
void ENGINE_load_zencod(void)
{
/* Copied from eng_[openssl|dyn].c */
ENGINE *toadd = ENGINE_zencod();
if (!toadd)
return;
ENGINE_add(toadd);
ENGINE_free(toadd);
ERR_clear_error();
}
/*
* This is a process-global DSO handle used for loading and unloading the
* ZENBRIDGE library. NB: This is only set (or unset) during an * init () or
* finish () call (reference counts permitting) and they're * operating with
* global locks, so this should be thread-safe * implicitly.
*/
static DSO *zencod_dso = NULL;
static t_zencod_test *ptr_zencod_test = NULL;
static t_zencod_bytes2bits *ptr_zencod_bytes2bits = NULL;
static t_zencod_bits2bytes *ptr_zencod_bits2bytes = NULL;
static t_zencod_new_number *ptr_zencod_new_number = NULL;
static t_zencod_init_number *ptr_zencod_init_number = NULL;
static t_zencod_rsa_mod_exp *ptr_zencod_rsa_mod_exp = NULL;
static t_zencod_rsa_mod_exp_crt *ptr_zencod_rsa_mod_exp_crt = NULL;
static t_zencod_dsa_do_sign *ptr_zencod_dsa_do_sign = NULL;
static t_zencod_dsa_do_verify *ptr_zencod_dsa_do_verify = NULL;
static t_zencod_dh_generate_key *ptr_zencod_dh_generate_key = NULL;
static t_zencod_dh_compute_key *ptr_zencod_dh_compute_key = NULL;
static t_zencod_rand_bytes *ptr_zencod_rand_bytes = NULL;
static t_zencod_math_mod_exp *ptr_zencod_math_mod_exp = NULL;
static t_zencod_md5_init *ptr_zencod_md5_init = NULL;
static t_zencod_md5_update *ptr_zencod_md5_update = NULL;
static t_zencod_md5_do_final *ptr_zencod_md5_do_final = NULL;
static t_zencod_sha1_init *ptr_zencod_sha1_init = NULL;
static t_zencod_sha1_update *ptr_zencod_sha1_update = NULL;
static t_zencod_sha1_do_final *ptr_zencod_sha1_do_final = NULL;
static t_zencod_xdes_cipher *ptr_zencod_xdes_cipher = NULL;
static t_zencod_rc4_cipher *ptr_zencod_rc4_cipher = NULL;
/*
* These are the static string constants for the DSO file name and the
* function symbol names to bind to.
*/
static const char *ZENCOD_LIBNAME = ZEN_LIBRARY;
static const char *ZENCOD_Fct_0 = "test_device";
static const char *ZENCOD_Fct_1 = "zenbridge_bytes2bits";
static const char *ZENCOD_Fct_2 = "zenbridge_bits2bytes";
static const char *ZENCOD_Fct_3 = "zenbridge_new_number";
static const char *ZENCOD_Fct_4 = "zenbridge_init_number";
static const char *ZENCOD_Fct_exp_1 = "zenbridge_rsa_mod_exp";
static const char *ZENCOD_Fct_exp_2 = "zenbridge_rsa_mod_exp_crt";
static const char *ZENCOD_Fct_dsa_1 = "zenbridge_dsa_do_sign";
static const char *ZENCOD_Fct_dsa_2 = "zenbridge_dsa_do_verify";
static const char *ZENCOD_Fct_dh_1 = "zenbridge_dh_generate_key";
static const char *ZENCOD_Fct_dh_2 = "zenbridge_dh_compute_key";
static const char *ZENCOD_Fct_rand_1 = "zenbridge_rand_bytes";
static const char *ZENCOD_Fct_math_1 = "zenbridge_math_mod_exp";
static const char *ZENCOD_Fct_md5_1 = "zenbridge_md5_init";
static const char *ZENCOD_Fct_md5_2 = "zenbridge_md5_update";
static const char *ZENCOD_Fct_md5_3 = "zenbridge_md5_do_final";
static const char *ZENCOD_Fct_sha1_1 = "zenbridge_sha1_init";
static const char *ZENCOD_Fct_sha1_2 = "zenbridge_sha1_update";
static const char *ZENCOD_Fct_sha1_3 = "zenbridge_sha1_do_final";
static const char *ZENCOD_Fct_xdes_1 = "zenbridge_xdes_cipher";
static const char *ZENCOD_Fct_rc4_1 = "zenbridge_rc4_cipher";
/*
* Destructor (complements the "ENGINE_zencod ()" constructor)
*/
static int zencod_destroy(ENGINE *e)
{
ERR_unload_ZENCOD_strings();
return 1;
}
/*
* (de)initialisation functions. Control Function
*/
static int zencod_init(ENGINE *e)
{
t_zencod_test *ptr_0;
t_zencod_bytes2bits *ptr_1;
t_zencod_bits2bytes *ptr_2;
t_zencod_new_number *ptr_3;
t_zencod_init_number *ptr_4;
t_zencod_rsa_mod_exp *ptr_exp_1;
t_zencod_rsa_mod_exp_crt *ptr_exp_2;
t_zencod_dsa_do_sign *ptr_dsa_1;
t_zencod_dsa_do_verify *ptr_dsa_2;
t_zencod_dh_generate_key *ptr_dh_1;
t_zencod_dh_compute_key *ptr_dh_2;
t_zencod_rand_bytes *ptr_rand_1;
t_zencod_math_mod_exp *ptr_math_1;
t_zencod_md5_init *ptr_md5_1;
t_zencod_md5_update *ptr_md5_2;
t_zencod_md5_do_final *ptr_md5_3;
t_zencod_sha1_init *ptr_sha1_1;
t_zencod_sha1_update *ptr_sha1_2;
t_zencod_sha1_do_final *ptr_sha1_3;
t_zencod_xdes_cipher *ptr_xdes_1;
t_zencod_rc4_cipher *ptr_rc4_1;
CHEESE();
/*
* We Should add some tests for non NULL parameters or bad value !!
* Stuff to be done ...
*/
if (zencod_dso != NULL) {
ZENCODerr(ZENCOD_F_ZENCOD_INIT, ZENCOD_R_ALREADY_LOADED);
goto err;
}
/*
* Trying to load the Library "cryptozen"
*/
zencod_dso = DSO_load(NULL, ZENCOD_LIBNAME, NULL, 0);
if (zencod_dso == NULL) {
ZENCODerr(ZENCOD_F_ZENCOD_INIT, ZENCOD_R_DSO_FAILURE);
goto err;
}
/*
* Trying to load Function from the Library
*/
if (!
(ptr_1 =
(t_zencod_bytes2bits *) DSO_bind_func(zencod_dso, ZENCOD_Fct_1))
|| !(ptr_2 = (t_zencod_bits2bytes *) DSO_bind_func(zencod_dso, ZENCOD_Fct_2))
|| !(ptr_3 = (t_zencod_new_number *) DSO_bind_func(zencod_dso, ZENCOD_Fct_3))
|| !(ptr_4 = (t_zencod_init_number *) DSO_bind_func(zencod_dso, ZENCOD_Fct_4))
|| !(ptr_exp_1 =
(t_zencod_rsa_mod_exp *) DSO_bind_func(zencod_dso, ZENCOD_Fct_exp_1))
|| !(ptr_exp_2 =
(t_zencod_rsa_mod_exp_crt *) DSO_bind_func(zencod_dso, ZENCOD_Fct_exp_2))
|| !(ptr_dsa_1 =
(t_zencod_dsa_do_sign *) DSO_bind_func(zencod_dso, ZENCOD_Fct_dsa_1))
|| !(ptr_dsa_2 =
(t_zencod_dsa_do_verify *) DSO_bind_func(zencod_dso, ZENCOD_Fct_dsa_2))
|| !(ptr_dh_1 =
(t_zencod_dh_generate_key *) DSO_bind_func(zencod_dso, ZENCOD_Fct_dh_1))
|| !(ptr_dh_2 =
(t_zencod_dh_compute_key *) DSO_bind_func(zencod_dso, ZENCOD_Fct_dh_2))
|| !(ptr_rand_1 =
(t_zencod_rand_bytes *) DSO_bind_func(zencod_dso, ZENCOD_Fct_rand_1))
|| !(ptr_math_1 =
(t_zencod_math_mod_exp *) DSO_bind_func(zencod_dso, ZENCOD_Fct_math_1))
|| !(ptr_0 = (t_zencod_test *) DSO_bind_func(zencod_dso, ZENCOD_Fct_0))
|| !(ptr_md5_1 =
(t_zencod_md5_init *) DSO_bind_func(zencod_dso, ZENCOD_Fct_md5_1))
|| !(ptr_md5_2 =
(t_zencod_md5_update *) DSO_bind_func(zencod_dso, ZENCOD_Fct_md5_2))
|| !(ptr_md5_3 =
(t_zencod_md5_do_final *) DSO_bind_func(zencod_dso, ZENCOD_Fct_md5_3))
|| !(ptr_sha1_1 =
(t_zencod_sha1_init *) DSO_bind_func(zencod_dso, ZENCOD_Fct_sha1_1))
|| !(ptr_sha1_2 =
(t_zencod_sha1_update *) DSO_bind_func(zencod_dso, ZENCOD_Fct_sha1_2))
|| !(ptr_sha1_3 =
(t_zencod_sha1_do_final *) DSO_bind_func(zencod_dso, ZENCOD_Fct_sha1_3))
|| !(ptr_xdes_1 =
(t_zencod_xdes_cipher *) DSO_bind_func(zencod_dso, ZENCOD_Fct_xdes_1))
|| !(ptr_rc4_1 =
(t_zencod_rc4_cipher *) DSO_bind_func(zencod_dso, ZENCOD_Fct_rc4_1))) {
ZENCODerr(ZENCOD_F_ZENCOD_INIT, ZENCOD_R_DSO_FAILURE);
goto err;
}
/*
* The function from "cryptozen" Library have been correctly loaded so
* copy them
*/
ptr_zencod_test = ptr_0;
ptr_zencod_bytes2bits = ptr_1;
ptr_zencod_bits2bytes = ptr_2;
ptr_zencod_new_number = ptr_3;
ptr_zencod_init_number = ptr_4;
ptr_zencod_rsa_mod_exp = ptr_exp_1;
ptr_zencod_rsa_mod_exp_crt = ptr_exp_2;
ptr_zencod_dsa_do_sign = ptr_dsa_1;
ptr_zencod_dsa_do_verify = ptr_dsa_2;
ptr_zencod_dh_generate_key = ptr_dh_1;
ptr_zencod_dh_compute_key = ptr_dh_2;
ptr_zencod_rand_bytes = ptr_rand_1;
ptr_zencod_math_mod_exp = ptr_math_1;
ptr_zencod_test = ptr_0;
ptr_zencod_md5_init = ptr_md5_1;
ptr_zencod_md5_update = ptr_md5_2;
ptr_zencod_md5_do_final = ptr_md5_3;
ptr_zencod_sha1_init = ptr_sha1_1;
ptr_zencod_sha1_update = ptr_sha1_2;
ptr_zencod_sha1_do_final = ptr_sha1_3;
ptr_zencod_xdes_cipher = ptr_xdes_1;
ptr_zencod_rc4_cipher = ptr_rc4_1;
/*
* We should perform a test to see if there is actually any unit runnig on
* the system ... Even if the cryptozen library is loaded the module coul
* not be loaded on the system ... For now we may just open and close the
* device !!
*/
if (ptr_zencod_test() != 0) {
ZENCODerr(ZENCOD_F_ZENCOD_INIT, ZENCOD_R_UNIT_FAILURE);
goto err;
}
return 1;
err:
if (zencod_dso) {
DSO_free(zencod_dso);
}
zencod_dso = NULL;
ptr_zencod_bytes2bits = NULL;
ptr_zencod_bits2bytes = NULL;
ptr_zencod_new_number = NULL;
ptr_zencod_init_number = NULL;
ptr_zencod_rsa_mod_exp = NULL;
ptr_zencod_rsa_mod_exp_crt = NULL;
ptr_zencod_dsa_do_sign = NULL;
ptr_zencod_dsa_do_verify = NULL;
ptr_zencod_dh_generate_key = NULL;
ptr_zencod_dh_compute_key = NULL;
ptr_zencod_rand_bytes = NULL;
ptr_zencod_math_mod_exp = NULL;
ptr_zencod_test = NULL;
ptr_zencod_md5_init = NULL;
ptr_zencod_md5_update = NULL;
ptr_zencod_md5_do_final = NULL;
ptr_zencod_sha1_init = NULL;
ptr_zencod_sha1_update = NULL;
ptr_zencod_sha1_do_final = NULL;
ptr_zencod_xdes_cipher = NULL;
ptr_zencod_rc4_cipher = NULL;
return 0;
}
static int zencod_finish(ENGINE *e)
{
CHEESE();
/*
* We Should add some tests for non NULL parameters or bad value !!
* Stuff to be done ...
*/
if (zencod_dso == NULL) {
ZENCODerr(ZENCOD_F_ZENCOD_FINISH, ZENCOD_R_NOT_LOADED);
return 0;
}
if (!DSO_free(zencod_dso)) {
ZENCODerr(ZENCOD_F_ZENCOD_FINISH, ZENCOD_R_DSO_FAILURE);
return 0;
}
zencod_dso = NULL;
ptr_zencod_bytes2bits = NULL;
ptr_zencod_bits2bytes = NULL;
ptr_zencod_new_number = NULL;
ptr_zencod_init_number = NULL;
ptr_zencod_rsa_mod_exp = NULL;
ptr_zencod_rsa_mod_exp_crt = NULL;
ptr_zencod_dsa_do_sign = NULL;
ptr_zencod_dsa_do_verify = NULL;
ptr_zencod_dh_generate_key = NULL;
ptr_zencod_dh_compute_key = NULL;
ptr_zencod_rand_bytes = NULL;
ptr_zencod_math_mod_exp = NULL;
ptr_zencod_test = NULL;
ptr_zencod_md5_init = NULL;
ptr_zencod_md5_update = NULL;
ptr_zencod_md5_do_final = NULL;
ptr_zencod_sha1_init = NULL;
ptr_zencod_sha1_update = NULL;
ptr_zencod_sha1_do_final = NULL;
ptr_zencod_xdes_cipher = NULL;
ptr_zencod_rc4_cipher = NULL;
return 1;
}
static int zencod_ctrl(ENGINE *e, int cmd, long i, void *p, void (*f) ())
{
int initialised = ((zencod_dso == NULL) ? 0 : 1);
CHEESE();
/*
* We Should add some tests for non NULL parameters or bad value !!
* Stuff to be done ...
*/
switch (cmd) {
case ZENCOD_CMD_SO_PATH:
if (p == NULL) {
ZENCODerr(ZENCOD_F_ZENCOD_CTRL, ERR_R_PASSED_NULL_PARAMETER);
return 0;
}
if (initialised) {
ZENCODerr(ZENCOD_F_ZENCOD_CTRL, ZENCOD_R_ALREADY_LOADED);
return 0;
}
ZENCOD_LIBNAME = (const char *)p;
return 1;
default:
break;
}
ZENCODerr(ZENCOD_F_ZENCOD_CTRL, ZENCOD_R_CTRL_COMMAND_NOT_IMPLEMENTED);
return 0;
}
/*
* BIGNUM stuff Functions
*/
static int zencod_bn_mod_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
const BIGNUM *m, BN_CTX *ctx)
{
zen_nb_t y, x, e, n;
int ret;
CHEESE();
if (!zencod_dso) {
ENGINEerr(ZENCOD_F_ZENCOD_BN_MOD_EXP, ZENCOD_R_NOT_LOADED);
return 0;
}
if (!bn_wexpand(r, m->top + 1)) {
ENGINEerr(ZENCOD_F_ZENCOD_BN_MOD_EXP, ZENCOD_R_BN_EXPAND_FAIL);
return 0;
}
memset(r->d, 0, BN_num_bytes(m));
ptr_zencod_init_number(&y, (r->dmax - 1) * sizeof(BN_ULONG) * 8,
(unsigned char *)r->d);
BIGNUM2ZEN(&x, a);
BIGNUM2ZEN(&e, p);
BIGNUM2ZEN(&n, m);
/* Must invert x and e parameter due to BN mod exp prototype ... */
ret = ptr_zencod_math_mod_exp(&y, &e, &x, &n);
if (ret) {
PERROR("zenbridge_math_mod_exp");
ENGINEerr(ZENCOD_F_ZENCOD_BN_MOD_EXP, ZENCOD_R_REQUEST_FAILED);
return 0;
}
r->top = (BN_num_bits(m) + BN_BITS2 - 1) / BN_BITS2;
return 1;
}
/*
* RSA stuff Functions
*/
# ifndef OPENSSL_NO_RSA
static int RSA_zencod_rsa_mod_exp(BIGNUM *r0, const BIGNUM *i, RSA *rsa)
{
CHEESE();
if (!zencod_dso) {
ENGINEerr(ZENCOD_F_ZENCOD_RSA_MOD_EXP_CRT, ZENCOD_R_NOT_LOADED);
return 0;
}
if (!rsa->p || !rsa->q || !rsa->dmp1 || !rsa->dmq1 || !rsa->iqmp) {
ENGINEerr(ZENCOD_F_ZENCOD_RSA_MOD_EXP_CRT,
ZENCOD_R_BAD_KEY_COMPONENTS);
return 0;
}
/* Do in software if argument is too large for hardware */
if (RSA_size(rsa) * 8 > ZENBRIDGE_MAX_KEYSIZE_RSA_CRT) {
const RSA_METHOD *meth;
meth = RSA_PKCS1_SSLeay();
return meth->rsa_mod_exp(r0, i, rsa);
} else {
zen_nb_t y, x, p, q, dmp1, dmq1, iqmp;
if (!bn_expand(r0, RSA_size(rsa) * 8)) {
ENGINEerr(ZENCOD_F_ZENCOD_RSA_MOD_EXP_CRT,
ZENCOD_R_BN_EXPAND_FAIL);
return 0;
}
r0->top = (RSA_size(rsa) * 8 + BN_BITS2 - 1) / BN_BITS2;
BIGNUM2ZEN(&x, i);
BIGNUM2ZEN(&y, r0);
BIGNUM2ZEN(&p, rsa->p);
BIGNUM2ZEN(&q, rsa->q);
BIGNUM2ZEN(&dmp1, rsa->dmp1);
BIGNUM2ZEN(&dmq1, rsa->dmq1);
BIGNUM2ZEN(&iqmp, rsa->iqmp);
if (ptr_zencod_rsa_mod_exp_crt(&y, &x, &p, &q, &dmp1, &dmq1, &iqmp) <
0) {
PERROR("zenbridge_rsa_mod_exp_crt");
ENGINEerr(ZENCOD_F_ZENCOD_RSA_MOD_EXP_CRT,
ZENCOD_R_REQUEST_FAILED);
return 0;
}
return 1;
}
}
/*
* This function is aliased to RSA_mod_exp (with the mont stuff dropped).
*/
static int RSA_zencod_bn_mod_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
const BIGNUM *m, BN_CTX *ctx,
BN_MONT_CTX *m_ctx)
{
CHEESE();
if (!zencod_dso) {
ENGINEerr(ZENCOD_F_ZENCOD_RSA_MOD_EXP, ZENCOD_R_NOT_LOADED);
return 0;
}
/* Do in software if argument is too large for hardware */
if (BN_num_bits(m) > ZENBRIDGE_MAX_KEYSIZE_RSA) {
const RSA_METHOD *meth;
meth = RSA_PKCS1_SSLeay();
return meth->bn_mod_exp(r, a, p, m, ctx, m_ctx);
} else {
zen_nb_t y, x, e, n;
if (!bn_expand(r, BN_num_bits(m))) {
ENGINEerr(ZENCOD_F_ZENCOD_RSA_MOD_EXP, ZENCOD_R_BN_EXPAND_FAIL);
return 0;
}
r->top = (BN_num_bits(m) + BN_BITS2 - 1) / BN_BITS2;
BIGNUM2ZEN(&x, a);
BIGNUM2ZEN(&y, r);
BIGNUM2ZEN(&e, p);
BIGNUM2ZEN(&n, m);
if (ptr_zencod_rsa_mod_exp(&y, &x, &n, &e) < 0) {
PERROR("zenbridge_rsa_mod_exp");
ENGINEerr(ZENCOD_F_ZENCOD_RSA_MOD_EXP, ZENCOD_R_REQUEST_FAILED);
return 0;
}
return 1;
}
}
# endif /* !OPENSSL_NO_RSA */
# ifndef OPENSSL_NO_DSA
/*
* DSA stuff Functions
*/
static DSA_SIG *DSA_zencod_do_sign(const unsigned char *dgst, int dlen,
DSA *dsa)
{
zen_nb_t p, q, g, x, y, r, s, data;
DSA_SIG *sig;
BIGNUM *bn_r = NULL;
BIGNUM *bn_s = NULL;
char msg[20];
CHEESE();
if (!zencod_dso) {
ENGINEerr(ZENCOD_F_ZENCOD_DSA_DO_SIGN, ZENCOD_R_NOT_LOADED);
goto FAILED;
}
if (dlen > 160) {
ENGINEerr(ZENCOD_F_ZENCOD_DSA_DO_SIGN, ZENCOD_R_REQUEST_FAILED);
goto FAILED;
}
/* Do in software if argument is too large for hardware */
if (BN_num_bits(dsa->p) > ZENBRIDGE_MAX_KEYSIZE_DSA_SIGN ||
BN_num_bits(dsa->g) > ZENBRIDGE_MAX_KEYSIZE_DSA_SIGN) {
const DSA_METHOD *meth;
ENGINEerr(ZENCOD_F_ZENCOD_DSA_DO_SIGN, ZENCOD_R_BAD_KEY_COMPONENTS);
meth = DSA_OpenSSL();
return meth->dsa_do_sign(dgst, dlen, dsa);
}
if (!(bn_s = BN_new()) || !(bn_r = BN_new())) {
ENGINEerr(ZENCOD_F_ZENCOD_DSA_DO_SIGN, ZENCOD_R_BAD_KEY_COMPONENTS);
goto FAILED;
}
if (!bn_expand(bn_r, 160) || !bn_expand(bn_s, 160)) {
ENGINEerr(ZENCOD_F_ZENCOD_DSA_DO_SIGN, ZENCOD_R_BN_EXPAND_FAIL);
goto FAILED;
}
bn_r->top = bn_s->top = (160 + BN_BITS2 - 1) / BN_BITS2;
BIGNUM2ZEN(&p, dsa->p);
BIGNUM2ZEN(&q, dsa->q);
BIGNUM2ZEN(&g, dsa->g);
BIGNUM2ZEN(&x, dsa->priv_key);
BIGNUM2ZEN(&y, dsa->pub_key);
BIGNUM2ZEN(&r, bn_r);
BIGNUM2ZEN(&s, bn_s);
q.len = x.len = 160;
ypcmem(msg, dgst, 20);
ptr_zencod_init_number(&data, 160, msg);
if (ptr_zencod_dsa_do_sign(0, &data, &y, &p, &q, &g, &x, &r, &s) < 0) {
PERROR("zenbridge_dsa_do_sign");
ENGINEerr(ZENCOD_F_ZENCOD_DSA_DO_SIGN, ZENCOD_R_REQUEST_FAILED);
goto FAILED;
}
if (!(sig = DSA_SIG_new())) {
ENGINEerr(ZENCOD_F_ZENCOD_DSA_DO_SIGN, ZENCOD_R_REQUEST_FAILED);
goto FAILED;
}
sig->r = bn_r;
sig->s = bn_s;
return sig;
FAILED:
if (bn_r)
BN_free(bn_r);
if (bn_s)
BN_free(bn_s);
return NULL;
}
static int DSA_zencod_do_verify(const unsigned char *dgst, int dlen,
DSA_SIG *sig, DSA *dsa)
{
zen_nb_t data, p, q, g, y, r, s, v;
char msg[20];
char v_data[20];
int ret;
CHEESE();
if (!zencod_dso) {
ENGINEerr(ZENCOD_F_ZENCOD_DSA_DO_VERIFY, ZENCOD_R_NOT_LOADED);
return 0;
}
if (dlen > 160) {
ENGINEerr(ZENCOD_F_ZENCOD_DSA_DO_SIGN, ZENCOD_R_REQUEST_FAILED);
return 0;
}
/* Do in software if argument is too large for hardware */
if (BN_num_bits(dsa->p) > ZENBRIDGE_MAX_KEYSIZE_DSA_SIGN ||
BN_num_bits(dsa->g) > ZENBRIDGE_MAX_KEYSIZE_DSA_SIGN) {
const DSA_METHOD *meth;
ENGINEerr(ZENCOD_F_ZENCOD_DSA_DO_SIGN, ZENCOD_R_BAD_KEY_COMPONENTS);
meth = DSA_OpenSSL();
return meth->dsa_do_verify(dgst, dlen, sig, dsa);
}
BIGNUM2ZEN(&p, dsa->p);
BIGNUM2ZEN(&q, dsa->q);
BIGNUM2ZEN(&g, dsa->g);
BIGNUM2ZEN(&y, dsa->pub_key);
BIGNUM2ZEN(&r, sig->r);
BIGNUM2ZEN(&s, sig->s);
ptr_zencod_init_number(&v, 160, v_data);
ypcmem(msg, dgst, 20);
ptr_zencod_init_number(&data, 160, msg);
if ((ret =
ptr_zencod_dsa_do_verify(0, &data, &p, &q, &g, &y, &r, &s,
&v)) < 0) {
PERROR("zenbridge_dsa_do_verify");
ENGINEerr(ZENCOD_F_ZENCOD_DSA_DO_VERIFY, ZENCOD_R_REQUEST_FAILED);
return 0;
}
return ((ret == 0) ? 1 : ret);
}
static int DSA_zencod_bn_mod_exp(DSA *dsa, BIGNUM *r, BIGNUM *a,
const BIGNUM *p, const BIGNUM *m,
BN_CTX *ctx, BN_MONT_CTX *m_ctx)
{
CHEESE();
return zencod_bn_mod_exp(r, a, p, m, ctx);
}
# endif /* !OPENSSL_NO_DSA */
# ifndef OPENSSl_NO_DH
/*
* DH stuff Functions
*/
static int DH_zencod_generate_key(DH *dh)
{
BIGNUM *bn_prv = NULL;
BIGNUM *bn_pub = NULL;
zen_nb_t y, x, g, p;
int generate_x;
CHEESE();
if (!zencod_dso) {
ENGINEerr(ZENCOD_F_ZENCOD_DH_GENERATE, ZENCOD_R_NOT_LOADED);
return 0;
}
/* Private key */
if (dh->priv_key) {
bn_prv = dh->priv_key;
generate_x = 0;
} else {
if (!(bn_prv = BN_new())) {
ENGINEerr(ZENCOD_F_ZENCOD_DH_GENERATE, ZENCOD_R_BN_EXPAND_FAIL);
goto FAILED;
}
generate_x = 1;
}
/* Public key */
if (dh->pub_key)
bn_pub = dh->pub_key;
else if (!(bn_pub = BN_new())) {
ENGINEerr(ZENCOD_F_ZENCOD_DH_GENERATE, ZENCOD_R_BN_EXPAND_FAIL);
goto FAILED;
}
/* Expand */
if (!bn_wexpand(bn_prv, dh->p->dmax) || !bn_wexpand(bn_pub, dh->p->dmax)) {
ENGINEerr(ZENCOD_F_ZENCOD_DH_GENERATE, ZENCOD_R_BN_EXPAND_FAIL);
goto FAILED;
}
bn_prv->top = dh->p->top;
bn_pub->top = dh->p->top;
/* Convert all keys */
BIGNUM2ZEN(&p, dh->p);
BIGNUM2ZEN(&g, dh->g);
BIGNUM2ZEN(&y, bn_pub);
BIGNUM2ZEN(&x, bn_prv);
x.len = DH_size(dh) * 8;
/* Adjust the lengths of P and G */
p.len = ptr_zencod_bytes2bits(p.data, ZEN_BYTES(p.len));
g.len = ptr_zencod_bytes2bits(g.data, ZEN_BYTES(g.len));
/* Send the request to the driver */
if (ptr_zencod_dh_generate_key(&y, &x, &g, &p, generate_x) < 0) {
perror("zenbridge_dh_generate_key");
ENGINEerr(ZENCOD_F_ZENCOD_DH_GENERATE, ZENCOD_R_REQUEST_FAILED);
goto FAILED;
}
dh->priv_key = bn_prv;
dh->pub_key = bn_pub;
return 1;
FAILED:
if (!dh->priv_key && bn_prv)
BN_free(bn_prv);
if (!dh->pub_key && bn_pub)
BN_free(bn_pub);
return 0;
}
static int DH_zencod_compute_key(unsigned char *key, const BIGNUM *pub_key,
DH *dh)
{
zen_nb_t y, x, p, k;
CHEESE();
if (!zencod_dso) {
ENGINEerr(ZENCOD_F_ZENCOD_DH_COMPUTE, ZENCOD_R_NOT_LOADED);
return 0;
}
if (!dh->priv_key) {
ENGINEerr(ZENCOD_F_ZENCOD_DH_COMPUTE, ZENCOD_R_BAD_KEY_COMPONENTS);
return 0;
}
/* Convert all keys */
BIGNUM2ZEN(&y, pub_key);
BIGNUM2ZEN(&x, dh->priv_key);
BIGNUM2ZEN(&p, dh->p);
ptr_zencod_init_number(&k, p.len, key);
/* Adjust the lengths */
p.len = ptr_zencod_bytes2bits(p.data, ZEN_BYTES(p.len));
y.len = ptr_zencod_bytes2bits(y.data, ZEN_BYTES(y.len));
x.len = ptr_zencod_bytes2bits(x.data, ZEN_BYTES(x.len));
/* Call the hardware */
if (ptr_zencod_dh_compute_key(&k, &y, &x, &p) < 0) {
ENGINEerr(ZENCOD_F_ZENCOD_DH_COMPUTE, ZENCOD_R_REQUEST_FAILED);
return 0;
}
/* The key must be written MSB -> LSB */
k.len = ptr_zencod_bytes2bits(k.data, ZEN_BYTES(k.len));
esrever(key, ZEN_BYTES(k.len));
return ZEN_BYTES(k.len);
}
static int DH_zencod_bn_mod_exp(const DH *dh, BIGNUM *r, const BIGNUM *a,
const BIGNUM *p, const BIGNUM *m, BN_CTX *ctx,
BN_MONT_CTX *m_ctx)
{
CHEESE();
return zencod_bn_mod_exp(r, a, p, m, ctx);
}
# endif /* !OPENSSL_NO_DH */
/*
* RAND stuff Functions
*/
static void RAND_zencod_seed(const void *buf, int num)
{
/*
* Nothing to do cause our crypto accelerator provide a true random
* generator
*/
}
static int RAND_zencod_rand_bytes(unsigned char *buf, int num)
{
zen_nb_t r;
CHEESE();
if (!zencod_dso) {
ENGINEerr(ZENCOD_F_ZENCOD_RAND, ZENCOD_R_NOT_LOADED);
return 0;
}
ptr_zencod_init_number(&r, num * 8, buf);
if (ptr_zencod_rand_bytes(&r, ZENBRIDGE_RNG_DIRECT) < 0) {
PERROR("zenbridge_rand_bytes");
ENGINEerr(ZENCOD_F_ZENCOD_RAND, ZENCOD_R_REQUEST_FAILED);
return 0;
}
return 1;
}
static int RAND_zencod_rand_status(void)
{
CHEESE();
return 1;
}
/*
* This stuff is needed if this ENGINE is being compiled into a
* self-contained shared-library.
*/
# ifdef ENGINE_DYNAMIC_SUPPORT
static int bind_fn(ENGINE *e, const char *id)
{
if (id && (strcmp(id, engine_zencod_id) != 0)) {
return 0;
}
if (!bind_helper(e)) {
return 0;
}
return 1;
}
IMPLEMENT_DYNAMIC_CHECK_FN()
IMPLEMENT_DYNAMIC_BIND_FN(bind_fn)
# endif /* ENGINE_DYNAMIC_SUPPORT */
/*
* Adding "Digest" and "Cipher" tools ...
* This is in development ... ;-)
* In orfer to code this, i refer to hw_openbsd_dev_crypto and openssl engine made by Geoff Thorpe (if i'm rigth),
* and evp, sha md5 definitions etc ...
*/
/* First add some include ... */
# include <openssl/evp.h>
# include <openssl/sha.h>
# include <openssl/md5.h>
# include <openssl/rc4.h>
# include <openssl/des.h>
/* Some variables declaration ... */
/*
* DONS: Disable symetric computation except DES and 3DES, but let part
* of the code
*/
/* static int engine_digest_nids [ ] = { NID_sha1, NID_md5 } ; */
static int engine_digest_nids[] = { };
static int engine_digest_nids_num = 0;
/*
* static int engine_cipher_nids [ ] = { NID_rc4, NID_rc4_40, NID_des_cbc,
* NID_des_ede3_cbc } ;
*/
static int engine_cipher_nids[] = { NID_des_cbc, NID_des_ede3_cbc };
static int engine_cipher_nids_num = 2;
/* Function prototype ... */
/* SHA stuff */
static int engine_sha1_init(EVP_MD_CTX *ctx);
static int engine_sha1_update(EVP_MD_CTX *ctx, const void *data,
unsigned long count);
static int engine_sha1_final(EVP_MD_CTX *ctx, unsigned char *md);
/* MD5 stuff */
static int engine_md5_init(EVP_MD_CTX *ctx);
static int engine_md5_update(EVP_MD_CTX *ctx, const void *data,
unsigned long count);
static int engine_md5_final(EVP_MD_CTX *ctx, unsigned char *md);
static int engine_md_cleanup(EVP_MD_CTX *ctx);
static int engine_md_copy(EVP_MD_CTX *to, const EVP_MD_CTX *from);
/* RC4 Stuff */
static int engine_rc4_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
const unsigned char *iv, int enc);
static int engine_rc4_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
const unsigned char *in, unsigned int inl);
/* DES Stuff */
static int engine_des_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
const unsigned char *iv, int enc);
static int engine_des_cbc_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
const unsigned char *in, unsigned int inl);
/* 3DES Stuff */
static int engine_des_ede3_init_key(EVP_CIPHER_CTX *ctx,
const unsigned char *key,
const unsigned char *iv, int enc);
static int engine_des_ede3_cbc_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
const unsigned char *in,
unsigned int inl);
static int engine_cipher_cleanup(EVP_CIPHER_CTX *ctx); /* cleanup ctx */
/* The one for SHA ... */
static const EVP_MD engine_sha1_md = {
NID_sha1,
NID_sha1WithRSAEncryption,
SHA_DIGEST_LENGTH,
EVP_MD_FLAG_ONESHOT,
/*
* 0,
*//*
* EVP_MD_FLAG_ONESHOT = x0001 digest can only handle a single block *
* XXX: set according to device info ...
*/
engine_sha1_init,
engine_sha1_update,
engine_sha1_final,
engine_md_copy, /* dev_crypto_sha_copy */
engine_md_cleanup, /* dev_crypto_sha_cleanup */
EVP_PKEY_RSA_method,
SHA_CBLOCK,
/* sizeof ( EVP_MD * ) + sizeof ( SHA_CTX ) */
sizeof(ZEN_MD_DATA)
/*
* sizeof ( MD_CTX_DATA ) The message digest data structure ...
*/
};
/* The one for MD5 ... */
static const EVP_MD engine_md5_md = {
NID_md5,
NID_md5WithRSAEncryption,
MD5_DIGEST_LENGTH,
EVP_MD_FLAG_ONESHOT,
/*
* 0,
*//*
* EVP_MD_FLAG_ONESHOT = x0001 digest can only handle a single block *
* XXX: set according to device info ...
*/
engine_md5_init,
engine_md5_update,
engine_md5_final,
engine_md_copy, /* dev_crypto_md5_copy */
engine_md_cleanup, /* dev_crypto_md5_cleanup */
EVP_PKEY_RSA_method,
MD5_CBLOCK,
/* sizeof ( EVP_MD * ) + sizeof ( MD5_CTX ) */
sizeof(ZEN_MD_DATA)
/*
* sizeof ( MD_CTX_DATA ) The message digest data structure ...
*/
};
/* The one for RC4 ... */
# define EVP_RC4_KEY_SIZE 16
/* Try something static ... */
typedef struct {
unsigned int len;
unsigned int first;
unsigned char rc4_state[260];
} NEW_ZEN_RC4_KEY;
# define rc4_data(ctx) ( (EVP_RC4_KEY *) ( ctx )->cipher_data )
static const EVP_CIPHER engine_rc4 = {
NID_rc4,
1,
16, /* EVP_RC4_KEY_SIZE should be 128 bits */
0, /* FIXME: key should be up to 256 bytes */
EVP_CIPH_VARIABLE_LENGTH,
engine_rc4_init_key,
engine_rc4_cipher,
engine_cipher_cleanup,
sizeof(NEW_ZEN_RC4_KEY),
NULL,
NULL,
NULL
};
/* The one for RC4_40 ... */
static const EVP_CIPHER engine_rc4_40 = {
NID_rc4_40,
1,
5, /* 40 bits */
0,
EVP_CIPH_VARIABLE_LENGTH,
engine_rc4_init_key,
engine_rc4_cipher,
engine_cipher_cleanup,
sizeof(NEW_ZEN_RC4_KEY),
NULL,
NULL,
NULL
};
/* The one for DES ... */
/* Try something static ... */
typedef struct {
unsigned char des_key[24];
unsigned char des_iv[8];
} ZEN_DES_KEY;
static const EVP_CIPHER engine_des_cbc = {
NID_des_cbc,
8, 8, 8,
0 | EVP_CIPH_CBC_MODE,
engine_des_init_key,
engine_des_cbc_cipher,
engine_cipher_cleanup,
sizeof(ZEN_DES_KEY),
EVP_CIPHER_set_asn1_iv,
EVP_CIPHER_get_asn1_iv,
NULL,
NULL
};
/* The one for 3DES ... */
/* Try something static ... */
typedef struct {
unsigned char des3_key[24];
unsigned char des3_iv[8];
} ZEN_3DES_KEY;
# define des_data(ctx) ( (DES_EDE_KEY *) ( ctx )->cipher_data )
static const EVP_CIPHER engine_des_ede3_cbc = {
NID_des_ede3_cbc,
8, 8, 8,
0 | EVP_CIPH_CBC_MODE,
engine_des_ede3_init_key,
engine_des_ede3_cbc_cipher,
engine_cipher_cleanup,
sizeof(ZEN_3DES_KEY),
EVP_CIPHER_set_asn1_iv,
EVP_CIPHER_get_asn1_iv,
NULL,
NULL
};
/* General function cloned on hw_openbsd_dev_crypto one ... */
static int engine_digests(ENGINE *e, const EVP_MD **digest, const int **nids,
int nid)
{
# ifdef DEBUG_ZENCOD_MD
fprintf(stderr, "\t=>Function : static int engine_digests () called !\n");
# endif
if (!digest) {
/* We are returning a list of supported nids */
*nids = engine_digest_nids;
return engine_digest_nids_num;
}
/* We are being asked for a specific digest */
if (nid == NID_md5) {
*digest = &engine_md5_md;
} else if (nid == NID_sha1) {
*digest = &engine_sha1_md;
} else {
*digest = NULL;
return 0;
}
return 1;
}
/*
* SHA stuff Functions
*/
static int engine_sha1_init(EVP_MD_CTX *ctx)
{
int to_return = 0;
/* Test with zenbridge library ... */
to_return = ptr_zencod_sha1_init((ZEN_MD_DATA *)ctx->md_data);
to_return = !to_return;
return to_return;
}
static int engine_sha1_update(EVP_MD_CTX *ctx, const void *data,
unsigned long count)
{
zen_nb_t input;
int to_return = 0;
/* Convert parameters ... */
input.len = count;
input.data = (unsigned char *)data;
/* Test with zenbridge library ... */
to_return =
ptr_zencod_sha1_update((ZEN_MD_DATA *)ctx->md_data,
(const zen_nb_t *)&input);
to_return = !to_return;
return to_return;
}
static int engine_sha1_final(EVP_MD_CTX *ctx, unsigned char *md)
{
zen_nb_t output;
int to_return = 0;
/* Convert parameters ... */
output.len = SHA_DIGEST_LENGTH;
output.data = md;
/* Test with zenbridge library ... */
to_return =
ptr_zencod_sha1_do_final((ZEN_MD_DATA *)ctx->md_data,
(zen_nb_t *) & output);
to_return = !to_return;
return to_return;
}
/*
* MD5 stuff Functions
*/
static int engine_md5_init(EVP_MD_CTX *ctx)
{
int to_return = 0;
/* Test with zenbridge library ... */
to_return = ptr_zencod_md5_init((ZEN_MD_DATA *)ctx->md_data);
to_return = !to_return;
return to_return;
}
static int engine_md5_update(EVP_MD_CTX *ctx, const void *data,
unsigned long count)
{
zen_nb_t input;
int to_return = 0;
/* Convert parameters ... */
input.len = count;
input.data = (unsigned char *)data;
/* Test with zenbridge library ... */
to_return =
ptr_zencod_md5_update((ZEN_MD_DATA *)ctx->md_data,
(const zen_nb_t *)&input);
to_return = !to_return;
return to_return;
}
static int engine_md5_final(EVP_MD_CTX *ctx, unsigned char *md)
{
zen_nb_t output;
int to_return = 0;
/* Convert parameters ... */
output.len = MD5_DIGEST_LENGTH;
output.data = md;
/* Test with zenbridge library ... */
to_return =
ptr_zencod_md5_do_final((ZEN_MD_DATA *)ctx->md_data,
(zen_nb_t *) & output);
to_return = !to_return;
return to_return;
}
static int engine_md_cleanup(EVP_MD_CTX *ctx)
{
ZEN_MD_DATA *zen_md_data = (ZEN_MD_DATA *)ctx->md_data;
if (zen_md_data->HashBuffer != NULL) {
OPENSSL_free(zen_md_data->HashBuffer);
zen_md_data->HashBufferSize = 0;
ctx->md_data = NULL;
}
return 1;
}
static int engine_md_copy(EVP_MD_CTX *to, const EVP_MD_CTX *from)
{
const ZEN_MD_DATA *from_md = (ZEN_MD_DATA *)from->md_data;
ZEN_MD_DATA *to_md = (ZEN_MD_DATA *)to->md_data;
to_md->HashBuffer = OPENSSL_malloc(from_md->HashBufferSize);
memcpy(to_md->HashBuffer, from_md->HashBuffer, from_md->HashBufferSize);
return 1;
}
/* General function cloned on hw_openbsd_dev_crypto one ... */
static int engine_ciphers(ENGINE *e, const EVP_CIPHER **cipher,
const int **nids, int nid)
{
if (!cipher) {
/* We are returning a list of supported nids */
*nids = engine_cipher_nids;
return engine_cipher_nids_num;
}
/* We are being asked for a specific cipher */
if (nid == NID_rc4) {
*cipher = &engine_rc4;
} else if (nid == NID_rc4_40) {
*cipher = &engine_rc4_40;
} else if (nid == NID_des_cbc) {
*cipher = &engine_des_cbc;
} else if (nid == NID_des_ede3_cbc) {
*cipher = &engine_des_ede3_cbc;
} else {
*cipher = NULL;
return 0;
}
return 1;
}
static int engine_rc4_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
const unsigned char *iv, int enc)
{
int to_return = 0;
int i = 0;
int nb = 0;
NEW_ZEN_RC4_KEY *tmp_rc4_key = NULL;
tmp_rc4_key = (NEW_ZEN_RC4_KEY *) (ctx->cipher_data);
tmp_rc4_key->first = 0;
tmp_rc4_key->len = ctx->key_len;
tmp_rc4_key->rc4_state[0] = 0x00;
tmp_rc4_key->rc4_state[2] = 0x00;
nb = 256 / ctx->key_len;
for (i = 0; i < nb; i++) {
memcpy(&(tmp_rc4_key->rc4_state[4 + i * ctx->key_len]), key,
ctx->key_len);
}
to_return = 1;
return to_return;
}
static int engine_rc4_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
const unsigned char *in, unsigned int in_len)
{
zen_nb_t output, input;
zen_nb_t rc4key;
int to_return = 0;
NEW_ZEN_RC4_KEY *tmp_rc4_key = NULL;
/* Convert parameters ... */
input.len = in_len;
input.data = (unsigned char *)in;
output.len = in_len;
output.data = (unsigned char *)out;
tmp_rc4_key = ((NEW_ZEN_RC4_KEY *) (ctx->cipher_data));
rc4key.len = 260;
rc4key.data = &(tmp_rc4_key->rc4_state[0]);
/* Test with zenbridge library ... */
to_return =
ptr_zencod_rc4_cipher(&output, &input, (const zen_nb_t *)&rc4key,
&(tmp_rc4_key->rc4_state[0]),
&(tmp_rc4_key->rc4_state[3]),
!tmp_rc4_key->first);
to_return = !to_return;
/* Update encryption state ... */
tmp_rc4_key->first = 1;
tmp_rc4_key = NULL;
return to_return;
}
static int engine_des_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
const unsigned char *iv, int enc)
{
ZEN_DES_KEY *tmp_des_key = NULL;
int to_return = 0;
tmp_des_key = (ZEN_DES_KEY *) (ctx->cipher_data);
memcpy(&(tmp_des_key->des_key[0]), key, 8);
memcpy(&(tmp_des_key->des_key[8]), key, 8);
memcpy(&(tmp_des_key->des_key[16]), key, 8);
memcpy(&(tmp_des_key->des_iv[0]), iv, 8);
to_return = 1;
return to_return;
}
static int engine_des_cbc_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
const unsigned char *in, unsigned int inl)
{
zen_nb_t output, input;
zen_nb_t deskey_1, deskey_2, deskey_3, iv;
int to_return = 0;
/* Convert parameters ... */
input.len = inl;
input.data = (unsigned char *)in;
output.len = inl;
output.data = out;
/* Set key parameters ... */
deskey_1.len = 8;
deskey_2.len = 8;
deskey_3.len = 8;
deskey_1.data =
(unsigned char *)((ZEN_DES_KEY *) (ctx->cipher_data))->des_key;
deskey_2.data =
(unsigned char *)&((ZEN_DES_KEY *) (ctx->cipher_data))->des_key[8];
deskey_3.data =
(unsigned char *)&((ZEN_DES_KEY *) (ctx->cipher_data))->des_key[16];
/* Key correct iv ... */
memcpy(((ZEN_DES_KEY *) (ctx->cipher_data))->des_iv, ctx->iv, 8);
iv.len = 8;
iv.data = (unsigned char *)((ZEN_DES_KEY *) (ctx->cipher_data))->des_iv;
if (ctx->encrypt == 0) {
memcpy(ctx->iv, &(input.data[input.len - 8]), 8);
}
/* Test with zenbridge library ... */
to_return = ptr_zencod_xdes_cipher(&output, &input,
(zen_nb_t *) & deskey_1,
(zen_nb_t *) & deskey_2,
(zen_nb_t *) & deskey_3, &iv,
ctx->encrypt);
to_return = !to_return;
/*
* But we need to set up the rigth iv ... Test ENCRYPT or DECRYPT mode to
* set iv ...
*/
if (ctx->encrypt == 1) {
memcpy(ctx->iv, &(output.data[output.len - 8]), 8);
}
return to_return;
}
static int engine_des_ede3_init_key(EVP_CIPHER_CTX *ctx,
const unsigned char *key,
const unsigned char *iv, int enc)
{
ZEN_3DES_KEY *tmp_3des_key = NULL;
int to_return = 0;
tmp_3des_key = (ZEN_3DES_KEY *) (ctx->cipher_data);
memcpy(&(tmp_3des_key->des3_key[0]), key, 24);
memcpy(&(tmp_3des_key->des3_iv[0]), iv, 8);
to_return = 1;
return to_return;
}
static int engine_des_ede3_cbc_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
const unsigned char *in,
unsigned int in_len)
{
zen_nb_t output, input;
zen_nb_t deskey_1, deskey_2, deskey_3, iv;
int to_return = 0;
/* Convert parameters ... */
input.len = in_len;
input.data = (unsigned char *)in;
output.len = in_len;
output.data = out;
/* Set key ... */
deskey_1.len = 8;
deskey_2.len = 8;
deskey_3.len = 8;
deskey_1.data =
(unsigned char *)((ZEN_3DES_KEY *) (ctx->cipher_data))->des3_key;
deskey_2.data =
(unsigned char *)&((ZEN_3DES_KEY *) (ctx->cipher_data))->des3_key[8];
deskey_3.data =
(unsigned char *)&((ZEN_3DES_KEY *) (ctx->cipher_data))->des3_key[16];
/* Key correct iv ... */
memcpy(((ZEN_3DES_KEY *) (ctx->cipher_data))->des3_iv, ctx->iv, 8);
iv.len = 8;
iv.data = (unsigned char *)((ZEN_3DES_KEY *) (ctx->cipher_data))->des3_iv;
if (ctx->encrypt == 0) {
memcpy(ctx->iv, &(input.data[input.len - 8]), 8);
}
/* Test with zenbridge library ... */
to_return = ptr_zencod_xdes_cipher(&output, &input,
(zen_nb_t *) & deskey_1,
(zen_nb_t *) & deskey_2,
(zen_nb_t *) & deskey_3, &iv,
ctx->encrypt);
to_return = !to_return;
if (ctx->encrypt == 1) {
memcpy(ctx->iv, &(output.data[output.len - 8]), 8);
}
return to_return;
}
static int engine_cipher_cleanup(EVP_CIPHER_CTX *ctx)
{
/* Set the key pointer ... */
if (ctx->cipher->nid == NID_rc4 || ctx->cipher->nid == NID_rc4_40) {
} else if (ctx->cipher->nid == NID_des_cbc) {
} else if (ctx->cipher->nid == NID_des_ede3_cbc) {
}
return 1;
}
# endif /* !OPENSSL_NO_HW_ZENCOD */
#endif /* !OPENSSL_NO_HW */