]> git.ipfire.org Git - thirdparty/openssl.git/blame - engines/e_sureware.c
projects / thirdparty / openssl.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Fix self signed handling.
[thirdparty/openssl.git] / engines / e_sureware.c
CommitLineData
3a83462d
MC		 1/*-
2* Written by Corinne Dive-Reclus(cdive@baltimore.com)
0f113f3e 3*
5572f482
RL		 4*
5* Redistribution and use in source and binary forms, with or without
6* modification, are permitted provided that the following conditions
7* are met:
8*
9* 1. Redistributions of source code must retain the above copyright
0f113f3e 10* notice, this list of conditions and the following disclaimer.
5572f482
RL		 11*
12* 2. Redistributions in binary form must reproduce the above copyright
13* notice, this list of conditions and the following disclaimer in
14* the documentation and/or other materials provided with the
15* distribution.
16*
17* 3. All advertising materials mentioning features or use of this
18* software must display the following acknowledgment:
19* "This product includes software developed by the OpenSSL Project
20* for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
21*
22* 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
23* endorse or promote products derived from this software without
24* prior written permission. For written permission, please contact
25* licensing@OpenSSL.org.
26*
27* 5. Products derived from this software may not be called "OpenSSL"
28* nor may "OpenSSL" appear in their names without prior written
29* permission of the OpenSSL Project.
30*
31* 6. Redistributions of any form whatsoever must retain the following
32* acknowledgment:
33* "This product includes software developed by the OpenSSL Project
34* for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
35*
36* Written by Corinne Dive-Reclus(cdive@baltimore.com)
37*
38* Copyright@2001 Baltimore Technologies Ltd.
39* All right Reserved.
b853717f
MC		 40* *
41* THIS FILE IS PROVIDED BY BALTIMORE TECHNOLOGIES ``AS IS'' AND *
42* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE *
43* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE *
44* ARE DISCLAIMED. IN NO EVENT SHALL BALTIMORE TECHNOLOGIES BE LIABLE *
45* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL *
46* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS *
47* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) *
48* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT *
49* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY *
50* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF *
51* SUCH DAMAGE. *
5572f482
RL		 52====================================================================*/
53
54#include <stdio.h>
5be1264b 55#include <string.h>
5572f482
RL		 56#include <openssl/crypto.h>
57#include <openssl/pem.h>
58#include <openssl/dso.h>
5572f482 59#include <openssl/engine.h>
3a87a9b9 60#include <openssl/rand.h>
3eeaab4b 61#ifndef OPENSSL_NO_RSA
0f113f3e 62# include <openssl/rsa.h>
3eeaab4b
NL		 63#endif
64#ifndef OPENSSL_NO_DSA
0f113f3e 65# include <openssl/dsa.h>
3eeaab4b
NL		 66#endif
67#ifndef OPENSSL_NO_DH
0f113f3e 68# include <openssl/dh.h>
3eeaab4b 69#endif
f15390bd 70#include <openssl/bn.h>
5572f482
RL		 71
72#ifndef OPENSSL_NO_HW
0f113f3e 73# ifndef OPENSSL_NO_HW_SUREWARE
5572f482 74
0f113f3e
MC		 75# ifdef FLAT_INC
76# include "sureware.h"
77# else
78# include "vendor_defns/sureware.h"
79# endif
5572f482 80
0f113f3e
MC		 81# define SUREWARE_LIB_NAME "sureware engine"
82# include "e_sureware_err.c"
5572f482 83
0f113f3e
MC		 84static int surewarehk_ctrl(ENGINE *e, int cmd, long i, void *p,
85 void (*f) (void));
5572f482
RL		 86static int surewarehk_destroy(ENGINE *e);
87static int surewarehk_init(ENGINE *e);
88static int surewarehk_finish(ENGINE *e);
89static int surewarehk_modexp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
0f113f3e 90 const BIGNUM *m, BN_CTX *ctx);
5572f482
RL		 91
92/* RSA stuff */
0f113f3e
MC		 93# ifndef OPENSSL_NO_RSA
94static int surewarehk_rsa_priv_dec(int flen, const unsigned char *from,
95 unsigned char *to, RSA *rsa, int padding);
96static int surewarehk_rsa_sign(int flen, const unsigned char *from,
97 unsigned char *to, RSA *rsa, int padding);
98# endif
5572f482
RL		 99
100/* RAND stuff */
6343829a 101static int surewarehk_rand_bytes(unsigned char *buf, int num);
a0b3e0de
DSH		 102static int surewarehk_rand_seed(const void *buf, int num);
103static int surewarehk_rand_add(const void *buf, int num, double entropy);
5572f482
RL		 104
105/* KM stuff */
106static EVP_PKEY *surewarehk_load_privkey(ENGINE *e, const char *key_id,
0f113f3e
MC		 107 UI_METHOD *ui_method,
108 void *callback_data);
5572f482 109static EVP_PKEY *surewarehk_load_pubkey(ENGINE *e, const char *key_id,
0f113f3e
MC		 110 UI_METHOD *ui_method,
111 void *callback_data);
5572f482 112static void surewarehk_ex_free(void *obj, void *item, CRYPTO_EX_DATA *ad,
0f113f3e 113 int idx, long argl, void *argp);
5572f482 114
0f113f3e 115# ifndef OPENSSL_NO_RSA
5572f482 116/* This function is aliased to mod_exp (with the mont stuff dropped). */
0f113f3e
MC		 117static int surewarehk_mod_exp_mont(BIGNUM *r, const BIGNUM *a,
118 const BIGNUM *p, const BIGNUM *m,
119 BN_CTX *ctx, BN_MONT_CTX *m_ctx)
5572f482 120{
0f113f3e 121 return surewarehk_modexp(r, a, p, m, ctx);
5572f482
RL		 122}
123
124/* Our internal RSA_METHOD that we provide pointers to */
0f113f3e
MC		 125static RSA_METHOD surewarehk_rsa = {
126 "SureWare RSA method",
127 NULL, /* pub_enc */
128 NULL, /* pub_dec */
129 surewarehk_rsa_sign, /* our rsa_sign is OpenSSL priv_enc */
130 surewarehk_rsa_priv_dec, /* priv_dec */
131 NULL, /* mod_exp */
132 surewarehk_mod_exp_mont, /* mod_exp_mongomery */
133 NULL, /* init */
134 NULL, /* finish */
135 0, /* RSA flag */
136 NULL,
137 NULL, /* OpenSSL sign */
138 NULL, /* OpenSSL verify */
139 NULL /* keygen */
140};
141# endif
5572f482 142
0f113f3e 143# ifndef OPENSSL_NO_DH
5572f482
RL		 144/* Our internal DH_METHOD that we provide pointers to */
145/* This function is aliased to mod_exp (with the dh and mont dropped). */
146static int surewarehk_modexp_dh(const DH *dh, BIGNUM *r, const BIGNUM *a,
0f113f3e
MC		 147 const BIGNUM *p, const BIGNUM *m, BN_CTX *ctx,
148 BN_MONT_CTX *m_ctx)
5572f482 149{
0f113f3e 150 return surewarehk_modexp(r, a, p, m, ctx);
5572f482
RL		 151}
152
0f113f3e
MC		 153static DH_METHOD surewarehk_dh = {
154 "SureWare DH method",
155 NULL, /* gen_key */
156 NULL, /* agree, */
157 surewarehk_modexp_dh, /* dh mod exp */
158 NULL, /* init */
159 NULL, /* finish */
160 0, /* flags */
161 NULL,
162 NULL
163};
164# endif
5572f482 165
0f113f3e
MC		 166static RAND_METHOD surewarehk_rand = {
167 /* "SureWare RAND method", */
168 surewarehk_rand_seed,
169 surewarehk_rand_bytes,
170 NULL, /* cleanup */
171 surewarehk_rand_add,
172 surewarehk_rand_bytes,
173 NULL, /* rand_status */
174};
5572f482 175
0f113f3e 176# ifndef OPENSSL_NO_DSA
5572f482 177/* DSA stuff */
0f113f3e
MC		 178static DSA_SIG *surewarehk_dsa_do_sign(const unsigned char *dgst, int dlen,
179 DSA *dsa);
5572f482 180static int surewarehk_dsa_mod_exp(DSA *dsa, BIGNUM *rr, BIGNUM *a1,
0f113f3e
MC		 181 BIGNUM *p1, BIGNUM *a2, BIGNUM *p2,
182 BIGNUM *m, BN_CTX *ctx,
183 BN_MONT_CTX *in_mont)
5572f482 184{
0f113f3e
MC		 185 BIGNUM t;
186 int to_return = 0;
187 BN_init(&t);
188 /* let rr = a1 ^ p1 mod m */
189 if (!surewarehk_modexp(rr, a1, p1, m, ctx))
190 goto end;
191 /* let t = a2 ^ p2 mod m */
192 if (!surewarehk_modexp(&t, a2, p2, m, ctx))
193 goto end;
194 /* let rr = rr * t mod m */
195 if (!BN_mod_mul(rr, rr, &t, m, ctx))
196 goto end;
197 to_return = 1;
198 end:
199 BN_free(&t);
200 return to_return;
5572f482
RL		 201}
202
0f113f3e
MC		 203static DSA_METHOD surewarehk_dsa = {
204 "SureWare DSA method",
205 surewarehk_dsa_do_sign,
206 NULL, /* sign setup */
207 NULL, /* verify, */
208 surewarehk_dsa_mod_exp, /* mod exp */
209 NULL, /* bn mod exp */
210 NULL, /* init */
211 NULL, /* finish */
212 0,
213 NULL,
214 NULL,
215 NULL
216};
217# endif
5572f482
RL		 218
219static const char *engine_sureware_id = "sureware";
220static const char *engine_sureware_name = "SureWare hardware engine support";
221
222/* Now, to our own code */
223
0f113f3e
MC		 224/*
225 * As this is only ever called once, there's no need for locking (indeed -
226 * the lock will already be held by our caller!!!)
227 */
5572f482
RL		 228static int bind_sureware(ENGINE *e)
229{
0f113f3e
MC		 230# ifndef OPENSSL_NO_RSA
231 const RSA_METHOD *meth1;
232# endif
233# ifndef OPENSSL_NO_DSA
234 const DSA_METHOD *meth2;
235# endif
236# ifndef OPENSSL_NO_DH
237 const DH_METHOD *meth3;
238# endif
5572f482 239
0f113f3e
MC		 240 if (!ENGINE_set_id(e, engine_sureware_id) ||
241 !ENGINE_set_name(e, engine_sureware_name) ||
242# ifndef OPENSSL_NO_RSA
243 !ENGINE_set_RSA(e, &surewarehk_rsa) ||
244# endif
245# ifndef OPENSSL_NO_DSA
246 !ENGINE_set_DSA(e, &surewarehk_dsa) ||
247# endif
248# ifndef OPENSSL_NO_DH
249 !ENGINE_set_DH(e, &surewarehk_dh) ||
250# endif
251 !ENGINE_set_RAND(e, &surewarehk_rand) ||
252 !ENGINE_set_destroy_function(e, surewarehk_destroy) ||
253 !ENGINE_set_init_function(e, surewarehk_init) ||
254 !ENGINE_set_finish_function(e, surewarehk_finish) ||
255 !ENGINE_set_ctrl_function(e, surewarehk_ctrl) ||
256 !ENGINE_set_load_privkey_function(e, surewarehk_load_privkey) ||
257 !ENGINE_set_load_pubkey_function(e, surewarehk_load_pubkey))
258 return 0;
5572f482 259
0f113f3e
MC		 260# ifndef OPENSSL_NO_RSA
261 /*
262 * We know that the "PKCS1_SSLeay()" functions hook properly to the
263 * cswift-specific mod_exp and mod_exp_crt so we use those functions. NB:
264 * We don't use ENGINE_openssl() or anything "more generic" because
265 * something like the RSAref code may not hook properly, and if you own
266 * one of these cards then you have the right to do RSA operations on it
267 * anyway!
268 */
269 meth1 = RSA_PKCS1_SSLeay();
270 if (meth1) {
271 surewarehk_rsa.rsa_pub_enc = meth1->rsa_pub_enc;
272 surewarehk_rsa.rsa_pub_dec = meth1->rsa_pub_dec;
273 }
274# endif
5572f482 275
0f113f3e
MC		 276# ifndef OPENSSL_NO_DSA
277 /*
278 * Use the DSA_OpenSSL() method and just hook the mod_exp-ish bits.
279 */
280 meth2 = DSA_OpenSSL();
281 if (meth2) {
282 surewarehk_dsa.dsa_do_verify = meth2->dsa_do_verify;
283 }
284# endif
5572f482 285
0f113f3e
MC		 286# ifndef OPENSSL_NO_DH
287 /* Much the same for Diffie-Hellman */
288 meth3 = DH_OpenSSL();
289 if (meth3) {
290 surewarehk_dh.generate_key = meth3->generate_key;
291 surewarehk_dh.compute_key = meth3->compute_key;
292 }
293# endif
5572f482 294
0f113f3e
MC		 295 /* Ensure the sureware error handling is set up */
296 ERR_load_SUREWARE_strings();
297 return 1;
5572f482
RL		 298}
299
0f113f3e 300# ifndef OPENSSL_NO_DYNAMIC_ENGINE
5572f482 301static int bind_helper(ENGINE *e, const char *id)
0f113f3e
MC		 302{
303 if (id && (strcmp(id, engine_sureware_id) != 0))
304 return 0;
305 if (!bind_sureware(e))
306 return 0;
307 return 1;
308}
309
5572f482 310IMPLEMENT_DYNAMIC_CHECK_FN()
0f113f3e
MC		 311 IMPLEMENT_DYNAMIC_BIND_FN(bind_helper)
312# else
5572f482 313static ENGINE *engine_sureware(void)
0f113f3e
MC		 314{
315 ENGINE *ret = ENGINE_new();
316 if (!ret)
317 return NULL;
318 if (!bind_sureware(ret)) {
319 ENGINE_free(ret);
320 return NULL;
321 }
322 return ret;
323}
5572f482
RL		 324
325void ENGINE_load_sureware(void)
0f113f3e
MC		 326{
327 /* Copied from eng_[openssl|dyn].c */
328 ENGINE *toadd = engine_sureware();
329 if (!toadd)
330 return;
331 ENGINE_add(toadd);
332 ENGINE_free(toadd);
333 ERR_clear_error();
334}
335# endif
5572f482 336
0f113f3e
MC		 337/*
338 * This is a process-global DSO handle used for loading and unloading the
339 * SureWareHook library. NB: This is only set (or unset) during an init() or
340 * finish() call (reference counts permitting) and they're operating with
341 * global locks, so this should be thread-safe implicitly.
342 */
5572f482 343static DSO *surewarehk_dso = NULL;
0f113f3e 344# ifndef OPENSSL_NO_RSA
68d39f3c
MC		 345/* Index for KM handle. Not really used yet. */
346static int rsaHndidx = -1;
0f113f3e
MC		 347# endif
348# ifndef OPENSSL_NO_DSA
68d39f3c
MC		 349/* Index for KM handle. Not really used yet. */
350static int dsaHndidx = -1;
0f113f3e 351# endif
5572f482 352
0f113f3e
MC		 353/*
354 * These are the function pointers that are (un)set when the library has
355 * successfully (un)loaded.
356 */
5572f482
RL		 357static SureWareHook_Init_t *p_surewarehk_Init = NULL;
358static SureWareHook_Finish_t *p_surewarehk_Finish = NULL;
359static SureWareHook_Rand_Bytes_t *p_surewarehk_Rand_Bytes = NULL;
360static SureWareHook_Rand_Seed_t *p_surewarehk_Rand_Seed = NULL;
361static SureWareHook_Load_Privkey_t *p_surewarehk_Load_Privkey = NULL;
362static SureWareHook_Info_Pubkey_t *p_surewarehk_Info_Pubkey = NULL;
363static SureWareHook_Load_Rsa_Pubkey_t *p_surewarehk_Load_Rsa_Pubkey = NULL;
364static SureWareHook_Load_Dsa_Pubkey_t *p_surewarehk_Load_Dsa_Pubkey = NULL;
0f113f3e
MC		 365static SureWareHook_Free_t *p_surewarehk_Free = NULL;
366static SureWareHook_Rsa_Priv_Dec_t *p_surewarehk_Rsa_Priv_Dec = NULL;
367static SureWareHook_Rsa_Sign_t *p_surewarehk_Rsa_Sign = NULL;
368static SureWareHook_Dsa_Sign_t *p_surewarehk_Dsa_Sign = NULL;
369static SureWareHook_Mod_Exp_t *p_surewarehk_Mod_Exp = NULL;
5572f482
RL		 370
371/* Used in the DSO operations. */
372static const char *surewarehk_LIBNAME = "SureWareHook";
373static const char *n_surewarehk_Init = "SureWareHook_Init";
374static const char *n_surewarehk_Finish = "SureWareHook_Finish";
0f113f3e
MC		 375static const char *n_surewarehk_Rand_Bytes = "SureWareHook_Rand_Bytes";
376static const char *n_surewarehk_Rand_Seed = "SureWareHook_Rand_Seed";
377static const char *n_surewarehk_Load_Privkey = "SureWareHook_Load_Privkey";
378static const char *n_surewarehk_Info_Pubkey = "SureWareHook_Info_Pubkey";
379static const char *n_surewarehk_Load_Rsa_Pubkey =
380 "SureWareHook_Load_Rsa_Pubkey";
381static const char *n_surewarehk_Load_Dsa_Pubkey =
382 "SureWareHook_Load_Dsa_Pubkey";
383static const char *n_surewarehk_Free = "SureWareHook_Free";
384static const char *n_surewarehk_Rsa_Priv_Dec = "SureWareHook_Rsa_Priv_Dec";
385static const char *n_surewarehk_Rsa_Sign = "SureWareHook_Rsa_Sign";
386static const char *n_surewarehk_Dsa_Sign = "SureWareHook_Dsa_Sign";
387static const char *n_surewarehk_Mod_Exp = "SureWareHook_Mod_Exp";
5572f482
RL		 388static BIO *logstream = NULL;
389
0f113f3e
MC		 390/*
391 * SureWareHook library functions and mechanics - these are used by the
392 * higher-level functions further down. NB: As and where there's no error
393 * checking, take a look lower down where these functions are called, the
394 * checking and error handling is probably down there.
395 */
396static int threadsafe = 1;
397static int surewarehk_ctrl(ENGINE *e, int cmd, long i, void *p,
398 void (*f) (void))
5572f482 399{
0f113f3e 400 int to_return = 1;
5572f482 401
0f113f3e
MC		 402 switch (cmd) {
403 case ENGINE_CTRL_SET_LOGSTREAM:
404 {
405 BIO *bio = (BIO *)p;
406 CRYPTO_w_lock(CRYPTO_LOCK_ENGINE);
ca3a82c3
RS		 407 BIO_free(logstream);
408 logstream = NULL;
0f113f3e
MC		 409 if (CRYPTO_add(&bio->references, 1, CRYPTO_LOCK_BIO) > 1)
410 logstream = bio;
411 else
412 SUREWAREerr(SUREWARE_F_SUREWAREHK_CTRL,
413 SUREWARE_R_BIO_WAS_FREED);
414 }
415 CRYPTO_w_unlock(CRYPTO_LOCK_ENGINE);
416 break;
417 /*
418 * This will prevent the initialisation function from "installing"
419 * the mutex-handling callbacks, even if they are available from
420 * within the library (or were provided to the library from the
421 * calling application). This is to remove any baggage for
422 * applications not using multithreading.
423 */
424 case ENGINE_CTRL_CHIL_NO_LOCKING:
425 CRYPTO_w_lock(CRYPTO_LOCK_ENGINE);
426 threadsafe = 0;
427 CRYPTO_w_unlock(CRYPTO_LOCK_ENGINE);
428 break;
5572f482 429
0f113f3e
MC		 430 /* The command isn't understood by this engine */
431 default:
432 SUREWAREerr(SUREWARE_F_SUREWAREHK_CTRL,
433 ENGINE_R_CTRL_COMMAND_NOT_IMPLEMENTED);
434 to_return = 0;
435 break;
436 }
5572f482 437
0f113f3e 438 return to_return;
5572f482
RL		 439}
440
441/* Destructor (complements the "ENGINE_surewarehk()" constructor) */
442static int surewarehk_destroy(ENGINE *e)
443{
0f113f3e
MC		 444 ERR_unload_SUREWARE_strings();
445 return 1;
5572f482
RL		 446}
447
448/* (de)initialisation functions. */
449static int surewarehk_init(ENGINE *e)
450{
0f113f3e
MC		 451 char msg[64] = "ENGINE_init";
452 SureWareHook_Init_t *p1 = NULL;
453 SureWareHook_Finish_t *p2 = NULL;
454 SureWareHook_Rand_Bytes_t *p3 = NULL;
455 SureWareHook_Rand_Seed_t *p4 = NULL;
456 SureWareHook_Load_Privkey_t *p5 = NULL;
457 SureWareHook_Load_Rsa_Pubkey_t *p6 = NULL;
458 SureWareHook_Free_t *p7 = NULL;
459 SureWareHook_Rsa_Priv_Dec_t *p8 = NULL;
460 SureWareHook_Rsa_Sign_t *p9 = NULL;
461 SureWareHook_Dsa_Sign_t *p12 = NULL;
462 SureWareHook_Info_Pubkey_t *p13 = NULL;
463 SureWareHook_Load_Dsa_Pubkey_t *p14 = NULL;
464 SureWareHook_Mod_Exp_t *p15 = NULL;
5572f482 465
0f113f3e
MC		 466 if (surewarehk_dso != NULL) {
467 SUREWAREerr(SUREWARE_F_SUREWAREHK_INIT, ENGINE_R_ALREADY_LOADED);
468 goto err;
469 }
470 /* Attempt to load libsurewarehk.so/surewarehk.dll/whatever. */
471 surewarehk_dso = DSO_load(NULL, surewarehk_LIBNAME, NULL, 0);
472 if (surewarehk_dso == NULL) {
473 SUREWAREerr(SUREWARE_F_SUREWAREHK_INIT, ENGINE_R_DSO_FAILURE);
474 goto err;
475 }
476 if (!
477 (p1 =
478 (SureWareHook_Init_t *) DSO_bind_func(surewarehk_dso,
479 n_surewarehk_Init))
480|| !(p2 =
481 (SureWareHook_Finish_t *) DSO_bind_func(surewarehk_dso,
482 n_surewarehk_Finish))
483|| !(p3 =
484 (SureWareHook_Rand_Bytes_t *) DSO_bind_func(surewarehk_dso,
485 n_surewarehk_Rand_Bytes))
486|| !(p4 =
487 (SureWareHook_Rand_Seed_t *) DSO_bind_func(surewarehk_dso,
488 n_surewarehk_Rand_Seed))
489|| !(p5 =
490 (SureWareHook_Load_Privkey_t *) DSO_bind_func(surewarehk_dso,
491 n_surewarehk_Load_Privkey))
492|| !(p6 =
493 (SureWareHook_Load_Rsa_Pubkey_t *) DSO_bind_func(surewarehk_dso,
494 n_surewarehk_Load_Rsa_Pubkey))
495|| !(p7 =
496 (SureWareHook_Free_t *) DSO_bind_func(surewarehk_dso, n_surewarehk_Free))
497|| !(p8 =
498 (SureWareHook_Rsa_Priv_Dec_t *) DSO_bind_func(surewarehk_dso,
499 n_surewarehk_Rsa_Priv_Dec))
500|| !(p9 =
501 (SureWareHook_Rsa_Sign_t *) DSO_bind_func(surewarehk_dso,
502 n_surewarehk_Rsa_Sign))
503|| !(p12 =
504 (SureWareHook_Dsa_Sign_t *) DSO_bind_func(surewarehk_dso,
505 n_surewarehk_Dsa_Sign))
506|| !(p13 =
507 (SureWareHook_Info_Pubkey_t *) DSO_bind_func(surewarehk_dso,
508 n_surewarehk_Info_Pubkey))
509|| !(p14 =
510 (SureWareHook_Load_Dsa_Pubkey_t *) DSO_bind_func(surewarehk_dso,
511 n_surewarehk_Load_Dsa_Pubkey))
512|| !(p15 =
513 (SureWareHook_Mod_Exp_t *) DSO_bind_func(surewarehk_dso,
514 n_surewarehk_Mod_Exp))) {
515 SUREWAREerr(SUREWARE_F_SUREWAREHK_INIT, ENGINE_R_DSO_FAILURE);
516 goto err;
517 }
518 /* Copy the pointers */
519 p_surewarehk_Init = p1;
520 p_surewarehk_Finish = p2;
521 p_surewarehk_Rand_Bytes = p3;
522 p_surewarehk_Rand_Seed = p4;
523 p_surewarehk_Load_Privkey = p5;
524 p_surewarehk_Load_Rsa_Pubkey = p6;
525 p_surewarehk_Free = p7;
526 p_surewarehk_Rsa_Priv_Dec = p8;
527 p_surewarehk_Rsa_Sign = p9;
528 p_surewarehk_Dsa_Sign = p12;
529 p_surewarehk_Info_Pubkey = p13;
530 p_surewarehk_Load_Dsa_Pubkey = p14;
531 p_surewarehk_Mod_Exp = p15;
532 /* Contact the hardware and initialises it. */
533 if (p_surewarehk_Init(msg, threadsafe) == SUREWAREHOOK_ERROR_UNIT_FAILURE) {
534 SUREWAREerr(SUREWARE_F_SUREWAREHK_INIT, SUREWARE_R_UNIT_FAILURE);
535 goto err;
536 }
537 if (p_surewarehk_Init(msg, threadsafe) == SUREWAREHOOK_ERROR_UNIT_FAILURE) {
538 SUREWAREerr(SUREWARE_F_SUREWAREHK_INIT, SUREWARE_R_UNIT_FAILURE);
539 goto err;
540 }
541 /*
542 * try to load the default private key, if failed does not return a
543 * failure but wait for an explicit ENGINE_load_privakey
544 */
545 surewarehk_load_privkey(e, NULL, NULL, NULL);
5572f482 546
0f113f3e
MC		 547 /* Everything's fine. */
548# ifndef OPENSSL_NO_RSA
549 if (rsaHndidx == -1)
550 rsaHndidx = RSA_get_ex_new_index(0,
551 "SureWareHook RSA key handle",
552 NULL, NULL, surewarehk_ex_free);
553# endif
554# ifndef OPENSSL_NO_DSA
555 if (dsaHndidx == -1)
556 dsaHndidx = DSA_get_ex_new_index(0,
557 "SureWareHook DSA key handle",
558 NULL, NULL, surewarehk_ex_free);
559# endif
5572f482 560
0f113f3e
MC		 561 return 1;
562 err:
efa7dd64 563 DSO_free(surewarehk_dso);
0f113f3e
MC		 564 surewarehk_dso = NULL;
565 p_surewarehk_Init = NULL;
566 p_surewarehk_Finish = NULL;
567 p_surewarehk_Rand_Bytes = NULL;
568 p_surewarehk_Rand_Seed = NULL;
569 p_surewarehk_Load_Privkey = NULL;
570 p_surewarehk_Load_Rsa_Pubkey = NULL;
571 p_surewarehk_Free = NULL;
572 p_surewarehk_Rsa_Priv_Dec = NULL;
573 p_surewarehk_Rsa_Sign = NULL;
574 p_surewarehk_Dsa_Sign = NULL;
575 p_surewarehk_Info_Pubkey = NULL;
576 p_surewarehk_Load_Dsa_Pubkey = NULL;
577 p_surewarehk_Mod_Exp = NULL;
578 return 0;
5572f482
RL		 579}
580
581static int surewarehk_finish(ENGINE *e)
582{
0f113f3e
MC		 583 int to_return = 1;
584 if (surewarehk_dso == NULL) {
585 SUREWAREerr(SUREWARE_F_SUREWAREHK_FINISH, ENGINE_R_NOT_LOADED);
586 to_return = 0;
587 goto err;
588 }
589 p_surewarehk_Finish();
590 if (!DSO_free(surewarehk_dso)) {
591 SUREWAREerr(SUREWARE_F_SUREWAREHK_FINISH, ENGINE_R_DSO_FAILURE);
592 to_return = 0;
593 goto err;
594 }
5572f482 595 err:
ca3a82c3 596 BIO_free(logstream);
0f113f3e
MC		 597 surewarehk_dso = NULL;
598 p_surewarehk_Init = NULL;
599 p_surewarehk_Finish = NULL;
600 p_surewarehk_Rand_Bytes = NULL;
601 p_surewarehk_Rand_Seed = NULL;
602 p_surewarehk_Load_Privkey = NULL;
603 p_surewarehk_Load_Rsa_Pubkey = NULL;
604 p_surewarehk_Free = NULL;
605 p_surewarehk_Rsa_Priv_Dec = NULL;
606 p_surewarehk_Rsa_Sign = NULL;
607 p_surewarehk_Dsa_Sign = NULL;
608 p_surewarehk_Info_Pubkey = NULL;
609 p_surewarehk_Load_Dsa_Pubkey = NULL;
610 p_surewarehk_Mod_Exp = NULL;
611 return to_return;
5572f482
RL		 612}
613
0f113f3e 614static void surewarehk_error_handling(char *const msg, int func, int ret)
5572f482 615{
0f113f3e
MC		 616 switch (ret) {
617 case SUREWAREHOOK_ERROR_UNIT_FAILURE:
618 ENGINEerr(func, SUREWARE_R_UNIT_FAILURE);
619 break;
620 case SUREWAREHOOK_ERROR_FALLBACK:
621 ENGINEerr(func, SUREWARE_R_REQUEST_FALLBACK);
622 break;
623 case SUREWAREHOOK_ERROR_DATA_SIZE:
624 ENGINEerr(func, SUREWARE_R_SIZE_TOO_LARGE_OR_TOO_SMALL);
625 break;
626 case SUREWAREHOOK_ERROR_INVALID_PAD:
627 ENGINEerr(func, SUREWARE_R_PADDING_CHECK_FAILED);
628 break;
629 default:
630 ENGINEerr(func, SUREWARE_R_REQUEST_FAILED);
631 break;
632 case 1: /* nothing */
633 msg[0] = '\0';
634 }
635 if (*msg) {
636 ERR_add_error_data(1, msg);
637 if (logstream) {
638 CRYPTO_w_lock(CRYPTO_LOCK_BIO);
639 BIO_write(logstream, msg, strlen(msg));
640 CRYPTO_w_unlock(CRYPTO_LOCK_BIO);
641 }
642 }
5572f482
RL		 643}
644
6343829a 645static int surewarehk_rand_bytes(unsigned char *buf, int num)
5572f482 646{
0f113f3e
MC		 647 int ret = 0;
648 char msg[64] = "ENGINE_rand_bytes";
649 if (!p_surewarehk_Rand_Bytes) {
650 SUREWAREerr(SUREWARE_F_SUREWAREHK_RAND_BYTES,
651 ENGINE_R_NOT_INITIALISED);
652 } else {
653 ret = p_surewarehk_Rand_Bytes(msg, buf, num);
654 surewarehk_error_handling(msg, SUREWARE_F_SUREWAREHK_RAND_BYTES, ret);
655 }
656 return ret == 1 ? 1 : 0;
5572f482
RL		 657}
658
a0b3e0de 659static int surewarehk_rand_seed(const void *buf, int num)
5572f482 660{
0f113f3e
MC		 661 int ret = 0;
662 char msg[64] = "ENGINE_rand_seed";
663 if (!p_surewarehk_Rand_Seed) {
664 SUREWAREerr(SUREWARE_F_SUREWAREHK_RAND_SEED,
665 ENGINE_R_NOT_INITIALISED);
666 return 0;
667 } else {
668 ret = p_surewarehk_Rand_Seed(msg, buf, num);
669 surewarehk_error_handling(msg, SUREWARE_F_SUREWAREHK_RAND_SEED, ret);
670 if (ret == 1)
671 return 1;
672 else
673 return 0;
674 }
5572f482
RL		 675}
676
a0b3e0de 677static int surewarehk_rand_add(const void *buf, int num, double entropy)
5572f482 678{
0f113f3e 679 return surewarehk_rand_seed(buf, num);
5572f482
RL		 680}
681
0f113f3e
MC		 682static EVP_PKEY *sureware_load_public(ENGINE *e, const char *key_id,
683 char *hptr, unsigned long el,
684 char keytype)
5572f482 685{
0f113f3e
MC		 686 EVP_PKEY *res = NULL;
687# ifndef OPENSSL_NO_RSA
688 RSA *rsatmp = NULL;
689# endif
690# ifndef OPENSSL_NO_DSA
691 DSA *dsatmp = NULL;
692# endif
693 char msg[64] = "sureware_load_public";
694 int ret = 0;
695 if (!p_surewarehk_Load_Rsa_Pubkey || !p_surewarehk_Load_Dsa_Pubkey) {
696 SUREWAREerr(SUREWARE_F_SUREWARE_LOAD_PUBLIC,
697 ENGINE_R_NOT_INITIALISED);
698 goto err;
699 }
700 switch (keytype) {
701# ifndef OPENSSL_NO_RSA
702 case 1:
703 /*RSA*/
704 /* set private external reference */
705 rsatmp = RSA_new_method(e);
706 RSA_set_ex_data(rsatmp, rsaHndidx, hptr);
707 rsatmp->flags |= RSA_FLAG_EXT_PKEY;
5572f482 708
0f113f3e
MC		 709 /* set public big nums */
710 rsatmp->e = BN_new();
711 rsatmp->n = BN_new();
61986d32 712 if (!rsatmp->e || !rsatmp->n)
7b611e5f 713 goto err;
0f113f3e
MC		 714 bn_expand2(rsatmp->e, el / sizeof(BN_ULONG));
715 bn_expand2(rsatmp->n, el / sizeof(BN_ULONG));
7b611e5f
MC		 716 if (rsatmp->e->dmax != (int)(el / sizeof(BN_ULONG)) ||
717 rsatmp->n->dmax != (int)(el / sizeof(BN_ULONG)))
0f113f3e
MC		 718 goto err;
719 ret = p_surewarehk_Load_Rsa_Pubkey(msg, key_id, el,
720 (unsigned long *)rsatmp->n->d,
721 (unsigned long *)rsatmp->e->d);
722 surewarehk_error_handling(msg, SUREWARE_F_SUREWARE_LOAD_PUBLIC, ret);
723 if (ret != 1) {
724 SUREWAREerr(SUREWARE_F_SUREWARE_LOAD_PUBLIC,
725 ENGINE_R_FAILED_LOADING_PUBLIC_KEY);
726 goto err;
727 }
728 /* normalise pub e and pub n */
729 rsatmp->e->top = el / sizeof(BN_ULONG);
730 bn_fix_top(rsatmp->e);
731 rsatmp->n->top = el / sizeof(BN_ULONG);
732 bn_fix_top(rsatmp->n);
733 /* create an EVP object: engine + rsa key */
734 res = EVP_PKEY_new();
735 EVP_PKEY_assign_RSA(res, rsatmp);
736 break;
737# endif
5572f482 738
0f113f3e
MC		 739# ifndef OPENSSL_NO_DSA
740 case 2:
741 /*DSA*/
742 /* set private/public external reference */
743 dsatmp = DSA_new_method(e);
744 DSA_set_ex_data(dsatmp, dsaHndidx, hptr);
745 /*
746 * dsatmp->flags |= DSA_FLAG_EXT_PKEY;
747 */
5572f482 748
0f113f3e
MC		 749 /* set public key */
750 dsatmp->pub_key = BN_new();
751 dsatmp->p = BN_new();
752 dsatmp->q = BN_new();
753 dsatmp->g = BN_new();
61986d32 754 if (!dsatmp->pub_key || !dsatmp->p || !dsatmp->q || !dsatmp->g)
7b611e5f 755 goto err;
0f113f3e
MC		 756 bn_expand2(dsatmp->pub_key, el / sizeof(BN_ULONG));
757 bn_expand2(dsatmp->p, el / sizeof(BN_ULONG));
758 bn_expand2(dsatmp->q, 20 / sizeof(BN_ULONG));
759 bn_expand2(dsatmp->g, el / sizeof(BN_ULONG));
7b611e5f
MC		 760 if (dsatmp->pub_key->dmax != (int)(el / sizeof(BN_ULONG))
761 || dsatmp->p->dmax != (int)(el / sizeof(BN_ULONG))
762 || dsatmp->q->dmax != 20 / sizeof(BN_ULONG)
763 || dsatmp->g->dmax != (int)(el / sizeof(BN_ULONG)))
0f113f3e 764 goto err;
5572f482 765
0f113f3e
MC		 766 ret = p_surewarehk_Load_Dsa_Pubkey(msg, key_id, el,
767 (unsigned long *)dsatmp->
768 pub_key->d,
769 (unsigned long *)dsatmp->p->d,
770 (unsigned long *)dsatmp->q->d,
771 (unsigned long *)dsatmp->g->d);
772 surewarehk_error_handling(msg, SUREWARE_F_SUREWARE_LOAD_PUBLIC, ret);
773 if (ret != 1) {
774 SUREWAREerr(SUREWARE_F_SUREWARE_LOAD_PUBLIC,
775 ENGINE_R_FAILED_LOADING_PUBLIC_KEY);
776 goto err;
777 }
778 /* set parameters */
779 /* normalise pubkey and parameters in case of */
780 dsatmp->pub_key->top = el / sizeof(BN_ULONG);
781 bn_fix_top(dsatmp->pub_key);
782 dsatmp->p->top = el / sizeof(BN_ULONG);
783 bn_fix_top(dsatmp->p);
784 dsatmp->q->top = 20 / sizeof(BN_ULONG);
785 bn_fix_top(dsatmp->q);
786 dsatmp->g->top = el / sizeof(BN_ULONG);
787 bn_fix_top(dsatmp->g);
5572f482 788
0f113f3e
MC		 789 /* create an EVP object: engine + rsa key */
790 res = EVP_PKEY_new();
791 EVP_PKEY_assign_DSA(res, dsatmp);
792 break;
793# endif
5572f482 794
0f113f3e
MC		 795 default:
796 SUREWAREerr(SUREWARE_F_SUREWARE_LOAD_PUBLIC,
797 ENGINE_R_FAILED_LOADING_PRIVATE_KEY);
798 goto err;
799 }
800 return res;
5572f482 801 err:
0f113f3e 802# ifndef OPENSSL_NO_RSA
d6407083 803 RSA_free(rsatmp);
0f113f3e
MC		 804# endif
805# ifndef OPENSSL_NO_DSA
d6407083 806 DSA_free(dsatmp);
0f113f3e
MC		 807# endif
808 return NULL;
5572f482
RL		 809}
810
811static EVP_PKEY *surewarehk_load_privkey(ENGINE *e, const char *key_id,
0f113f3e
MC		 812 UI_METHOD *ui_method,
813 void *callback_data)
5572f482 814{
0f113f3e
MC		 815 EVP_PKEY *res = NULL;
816 int ret = 0;
817 unsigned long el = 0;
818 char *hptr = NULL;
819 char keytype = 0;
820 char msg[64] = "ENGINE_load_privkey";
5572f482 821
0f113f3e
MC		 822 if (!p_surewarehk_Load_Privkey) {
823 SUREWAREerr(SUREWARE_F_SUREWAREHK_LOAD_PRIVKEY,
824 ENGINE_R_NOT_INITIALISED);
825 } else {
826 ret = p_surewarehk_Load_Privkey(msg, key_id, &hptr, &el, &keytype);
827 if (ret != 1) {
828 SUREWAREerr(SUREWARE_F_SUREWAREHK_LOAD_PRIVKEY,
829 ENGINE_R_FAILED_LOADING_PRIVATE_KEY);
830 ERR_add_error_data(1, msg);
831 } else
832 res = sureware_load_public(e, key_id, hptr, el, keytype);
833 }
834 return res;
5572f482
RL		 835}
836
837static EVP_PKEY *surewarehk_load_pubkey(ENGINE *e, const char *key_id,
0f113f3e
MC		 838 UI_METHOD *ui_method,
839 void *callback_data)
5572f482 840{
0f113f3e
MC		 841 EVP_PKEY *res = NULL;
842 int ret = 0;
843 unsigned long el = 0;
844 char *hptr = NULL;
845 char keytype = 0;
846 char msg[64] = "ENGINE_load_pubkey";
5572f482 847
0f113f3e
MC		 848 if (!p_surewarehk_Info_Pubkey) {
849 SUREWAREerr(SUREWARE_F_SUREWAREHK_LOAD_PUBKEY,
850 ENGINE_R_NOT_INITIALISED);
851 } else {
852 /* call once to identify if DSA or RSA */
853 ret = p_surewarehk_Info_Pubkey(msg, key_id, &el, &keytype);
854 if (ret != 1) {
855 SUREWAREerr(SUREWARE_F_SUREWAREHK_LOAD_PUBKEY,
856 ENGINE_R_FAILED_LOADING_PUBLIC_KEY);
857 ERR_add_error_data(1, msg);
858 } else
859 res = sureware_load_public(e, key_id, hptr, el, keytype);
860 }
861 return res;
5572f482
RL		 862}
863
0f113f3e
MC		 864/*
865 * This cleans up an RSA/DSA KM key(do not destroy the key into the hardware)
866 * , called when ex_data is freed
867 */
5572f482 868static void surewarehk_ex_free(void *obj, void *item, CRYPTO_EX_DATA *ad,
0f113f3e 869 int idx, long argl, void *argp)
5572f482 870{
0f113f3e
MC		 871 if (!p_surewarehk_Free) {
872 SUREWAREerr(SUREWARE_F_SUREWAREHK_EX_FREE, ENGINE_R_NOT_INITIALISED);
873 } else
874 p_surewarehk_Free((char *)item, 0);
5572f482
RL		 875}
876
5572f482 877/*
0f113f3e
MC		 878 * return number of decrypted bytes
879 */
880# ifndef OPENSSL_NO_RSA
881static int surewarehk_rsa_priv_dec(int flen, const unsigned char *from,
882 unsigned char *to, RSA *rsa, int padding)
5572f482 883{
0f113f3e
MC		 884 int ret = 0, tlen;
885 char *buf = NULL, *hptr = NULL;
886 char msg[64] = "ENGINE_rsa_priv_dec";
887 if (!p_surewarehk_Rsa_Priv_Dec) {
888 SUREWAREerr(SUREWARE_F_SUREWAREHK_RSA_PRIV_DEC,
889 ENGINE_R_NOT_INITIALISED);
890 }
891 /* extract ref to private key */
75ebbd9a 892 else if ((hptr = RSA_get_ex_data(rsa, rsaHndidx)) == NULL) {
0f113f3e
MC		 893 SUREWAREerr(SUREWARE_F_SUREWAREHK_RSA_PRIV_DEC,
894 SUREWARE_R_MISSING_KEY_COMPONENTS);
895 goto err;
896 }
897 /* analyse what padding we can do into the hardware */
898 if (padding == RSA_PKCS1_PADDING) {
899 /* do it one shot */
900 ret =
901 p_surewarehk_Rsa_Priv_Dec(msg, flen, (unsigned char *)from, &tlen,
902 to, hptr, SUREWARE_PKCS1_PAD);
903 surewarehk_error_handling(msg, SUREWARE_F_SUREWAREHK_RSA_PRIV_DEC,
904 ret);
905 if (ret != 1)
906 goto err;
907 ret = tlen;
908 } else { /* do with no padding into hardware */
909
910 ret =
911 p_surewarehk_Rsa_Priv_Dec(msg, flen, (unsigned char *)from, &tlen,
912 to, hptr, SUREWARE_NO_PAD);
913 surewarehk_error_handling(msg, SUREWARE_F_SUREWAREHK_RSA_PRIV_DEC,
914 ret);
915 if (ret != 1)
916 goto err;
917 /* intermediate buffer for padding */
918 if ((buf = OPENSSL_malloc(tlen)) == NULL) {
919 SUREWAREerr(SUREWARE_F_SUREWAREHK_RSA_PRIV_DEC,
920 ERR_R_MALLOC_FAILURE);
921 goto err;
922 }
923 memcpy(buf, to, tlen); /* transfert to into buf */
924 switch (padding) { /* check padding in software */
0f113f3e
MC		 925 case RSA_PKCS1_OAEP_PADDING:
926 ret =
927 RSA_padding_check_PKCS1_OAEP(to, tlen, (unsigned char *)buf,
928 tlen, tlen, NULL, 0);
929 break;
0f113f3e
MC		 930 case RSA_SSLV23_PADDING:
931 ret =
932 RSA_padding_check_SSLv23(to, tlen, (unsigned char *)buf, flen,
933 tlen);
934 break;
935 case RSA_NO_PADDING:
936 ret =
937 RSA_padding_check_none(to, tlen, (unsigned char *)buf, flen,
938 tlen);
939 break;
940 default:
941 SUREWAREerr(SUREWARE_F_SUREWAREHK_RSA_PRIV_DEC,
942 SUREWARE_R_UNKNOWN_PADDING_TYPE);
943 goto err;
944 }
945 if (ret < 0)
946 SUREWAREerr(SUREWARE_F_SUREWAREHK_RSA_PRIV_DEC,
947 SUREWARE_R_PADDING_CHECK_FAILED);
948 }
949 err:
4b45c6e5 950 OPENSSL_clear_free(buf, tlen);
0f113f3e 951 return ret;
5572f482
RL		 952}
953
954/*
0f113f3e
MC		 955 * Does what OpenSSL rsa_priv_enc does.
956 */
957static int surewarehk_rsa_sign(int flen, const unsigned char *from,
958 unsigned char *to, RSA *rsa, int padding)
5572f482 959{
0f113f3e
MC		 960 int ret = 0, tlen;
961 char *hptr = NULL;
962 char msg[64] = "ENGINE_rsa_sign";
963 if (!p_surewarehk_Rsa_Sign) {
964 SUREWAREerr(SUREWARE_F_SUREWAREHK_RSA_SIGN, ENGINE_R_NOT_INITIALISED);
965 }
966 /* extract ref to private key */
75ebbd9a 967 else if ((hptr = RSA_get_ex_data(rsa, rsaHndidx)) == NULL) {
0f113f3e
MC		 968 SUREWAREerr(SUREWARE_F_SUREWAREHK_RSA_SIGN,
969 SUREWARE_R_MISSING_KEY_COMPONENTS);
970 } else {
971 switch (padding) {
972 case RSA_PKCS1_PADDING: /* do it in one shot */
973 ret =
974 p_surewarehk_Rsa_Sign(msg, flen, (unsigned char *)from, &tlen,
975 to, hptr, SUREWARE_PKCS1_PAD);
976 surewarehk_error_handling(msg, SUREWARE_F_SUREWAREHK_RSA_SIGN,
977 ret);
978 break;
979 case RSA_NO_PADDING:
980 default:
981 SUREWAREerr(SUREWARE_F_SUREWAREHK_RSA_SIGN,
982 SUREWARE_R_UNKNOWN_PADDING_TYPE);
983 }
984 }
985 return ret == 1 ? tlen : ret;
5572f482
RL		 986}
987
0f113f3e 988# endif
5572f482 989
0f113f3e 990# ifndef OPENSSL_NO_DSA
5572f482 991/* DSA sign and verify */
0f113f3e
MC		 992static DSA_SIG *surewarehk_dsa_do_sign(const unsigned char *from, int flen,
993 DSA *dsa)
5572f482 994{
0f113f3e
MC		 995 int ret = 0;
996 char *hptr = NULL;
997 DSA_SIG *psign = NULL;
998 char msg[64] = "ENGINE_dsa_do_sign";
999 if (!p_surewarehk_Dsa_Sign) {
1000 SUREWAREerr(SUREWARE_F_SUREWAREHK_DSA_DO_SIGN,
1001 ENGINE_R_NOT_INITIALISED);
1002 goto err;
1003 }
1004 /* extract ref to private key */
75ebbd9a 1005 else if ((hptr = DSA_get_ex_data(dsa, dsaHndidx)) == NULL) {
0f113f3e
MC		 1006 SUREWAREerr(SUREWARE_F_SUREWAREHK_DSA_DO_SIGN,
1007 SUREWARE_R_MISSING_KEY_COMPONENTS);
1008 goto err;
1009 } else {
1010 if ((psign = DSA_SIG_new()) == NULL) {
1011 SUREWAREerr(SUREWARE_F_SUREWAREHK_DSA_DO_SIGN,
1012 ERR_R_MALLOC_FAILURE);
1013 goto err;
1014 }
1015 psign->r = BN_new();
1016 psign->s = BN_new();
61986d32 1017 if (!psign->r || !psign->s)
7b611e5f 1018 goto err;
0f113f3e
MC		 1019 bn_expand2(psign->r, 20 / sizeof(BN_ULONG));
1020 bn_expand2(psign->s, 20 / sizeof(BN_ULONG));
7b611e5f
MC		 1021 if (psign->r->dmax != 20 / sizeof(BN_ULONG) ||
1022 psign->s->dmax != 20 / sizeof(BN_ULONG))
0f113f3e
MC		 1023 goto err;
1024 ret = p_surewarehk_Dsa_Sign(msg, flen, from,
1025 (unsigned long *)psign->r->d,
1026 (unsigned long *)psign->s->d, hptr);
1027 surewarehk_error_handling(msg, SUREWARE_F_SUREWAREHK_DSA_DO_SIGN,
1028 ret);
1029 }
1030 psign->r->top = 20 / sizeof(BN_ULONG);
1031 bn_fix_top(psign->r);
1032 psign->s->top = 20 / sizeof(BN_ULONG);
1033 bn_fix_top(psign->s);
5572f482 1034
0f113f3e
MC		 1035 err:
1036 if (psign) {
1037 DSA_SIG_free(psign);
1038 psign = NULL;
1039 }
1040 return psign;
5572f482 1041}
0f113f3e 1042# endif
5572f482
RL		 1043
1044static int surewarehk_modexp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
0f113f3e 1045 const BIGNUM *m, BN_CTX *ctx)
5572f482 1046{
0f113f3e
MC		 1047 int ret = 0;
1048 char msg[64] = "ENGINE_modexp";
1049 if (!p_surewarehk_Mod_Exp) {
1050 SUREWAREerr(SUREWARE_F_SUREWAREHK_MODEXP, ENGINE_R_NOT_INITIALISED);
7b611e5f 1051 } else if (r) {
0f113f3e 1052 bn_expand2(r, m->top);
7b611e5f 1053 if (r->dmax == m->top) {
0f113f3e
MC		 1054 /* do it */
1055 ret = p_surewarehk_Mod_Exp(msg,
1056 m->top * sizeof(BN_ULONG),
1057 (unsigned long *)m->d,
1058 p->top * sizeof(BN_ULONG),
1059 (unsigned long *)p->d,
1060 a->top * sizeof(BN_ULONG),
1061 (unsigned long *)a->d,
1062 (unsigned long *)r->d);
1063 surewarehk_error_handling(msg, SUREWARE_F_SUREWAREHK_MODEXP, ret);
1064 if (ret == 1) {
1065 /* normalise result */
1066 r->top = m->top;
1067 bn_fix_top(r);
1068 }
1069 }
1070 }
1071 return ret;
5572f482 1072}
0f113f3e
MC		 1073# endif /* !OPENSSL_NO_HW_SUREWARE */
1074#endif /* !OPENSSL_NO_HW */
A mirror of the official openssl repository