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