Branch data Line data Source code
1 : : /* crypto/engine/hw_ubsec.c */
2 : : /* Written by Geoff Thorpe (geoff@geoffthorpe.net) for the OpenSSL
3 : : * project 2000.
4 : : *
5 : : * Cloned shamelessly by Joe Tardo.
6 : : */
7 : : /* ====================================================================
8 : : * Copyright (c) 1999-2001 The OpenSSL Project. All rights reserved.
9 : : *
10 : : * Redistribution and use in source and binary forms, with or without
11 : : * modification, are permitted provided that the following conditions
12 : : * are met:
13 : : *
14 : : * 1. Redistributions of source code must retain the above copyright
15 : : * notice, this list of conditions and the following disclaimer.
16 : : *
17 : : * 2. Redistributions in binary form must reproduce the above copyright
18 : : * notice, this list of conditions and the following disclaimer in
19 : : * the documentation and/or other materials provided with the
20 : : * distribution.
21 : : *
22 : : * 3. All advertising materials mentioning features or use of this
23 : : * software must display the following acknowledgment:
24 : : * "This product includes software developed by the OpenSSL Project
25 : : * for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
26 : : *
27 : : * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
28 : : * endorse or promote products derived from this software without
29 : : * prior written permission. For written permission, please contact
30 : : * licensing@OpenSSL.org.
31 : : *
32 : : * 5. Products derived from this software may not be called "OpenSSL"
33 : : * nor may "OpenSSL" appear in their names without prior written
34 : : * permission of the OpenSSL Project.
35 : : *
36 : : * 6. Redistributions of any form whatsoever must retain the following
37 : : * acknowledgment:
38 : : * "This product includes software developed by the OpenSSL Project
39 : : * for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
40 : : *
41 : : * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
42 : : * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
43 : : * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
44 : : * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
45 : : * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
46 : : * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
47 : : * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
48 : : * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
49 : : * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
50 : : * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
51 : : * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
52 : : * OF THE POSSIBILITY OF SUCH DAMAGE.
53 : : * ====================================================================
54 : : *
55 : : * This product includes cryptographic software written by Eric Young
56 : : * (eay@cryptsoft.com). This product includes software written by Tim
57 : : * Hudson (tjh@cryptsoft.com).
58 : : *
59 : : */
60 : :
61 : : #include <stdio.h>
62 : : #include <string.h>
63 : : #include <openssl/crypto.h>
64 : : #include <openssl/buffer.h>
65 : : #include <openssl/dso.h>
66 : : #include <openssl/engine.h>
67 : : #ifndef OPENSSL_NO_RSA
68 : : #include <openssl/rsa.h>
69 : : #endif
70 : : #ifndef OPENSSL_NO_DSA
71 : : #include <openssl/dsa.h>
72 : : #endif
73 : : #ifndef OPENSSL_NO_DH
74 : : #include <openssl/dh.h>
75 : : #endif
76 : : #include <openssl/bn.h>
77 : :
78 : : #ifndef OPENSSL_NO_HW
79 : : #ifndef OPENSSL_NO_HW_UBSEC
80 : :
81 : : #ifdef FLAT_INC
82 : : #include "hw_ubsec.h"
83 : : #else
84 : : #include "vendor_defns/hw_ubsec.h"
85 : : #endif
86 : :
87 : : #define UBSEC_LIB_NAME "ubsec engine"
88 : : #include "e_ubsec_err.c"
89 : :
90 : : #define FAIL_TO_SOFTWARE -15
91 : :
92 : : static int ubsec_destroy(ENGINE *e);
93 : : static int ubsec_init(ENGINE *e);
94 : : static int ubsec_finish(ENGINE *e);
95 : : static int ubsec_ctrl(ENGINE *e, int cmd, long i, void *p, void (*f)(void));
96 : : static int ubsec_mod_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
97 : : const BIGNUM *m, BN_CTX *ctx);
98 : : #ifndef OPENSSL_NO_RSA
99 : : static int ubsec_mod_exp_crt(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
100 : : const BIGNUM *q, const BIGNUM *dp,
101 : : const BIGNUM *dq, const BIGNUM *qinv, BN_CTX *ctx);
102 : : static int ubsec_rsa_mod_exp(BIGNUM *r0, const BIGNUM *I, RSA *rsa, BN_CTX *ctx);
103 : : static int ubsec_mod_exp_mont(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
104 : : const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx);
105 : : #endif
106 : : #ifndef OPENSSL_NO_DSA
107 : : #ifdef NOT_USED
108 : : static int ubsec_dsa_mod_exp(DSA *dsa, BIGNUM *rr, BIGNUM *a1,
109 : : BIGNUM *p1, BIGNUM *a2, BIGNUM *p2, BIGNUM *m,
110 : : BN_CTX *ctx, BN_MONT_CTX *in_mont);
111 : : static int ubsec_mod_exp_dsa(DSA *dsa, BIGNUM *r, BIGNUM *a,
112 : : const BIGNUM *p, const BIGNUM *m, BN_CTX *ctx,
113 : : BN_MONT_CTX *m_ctx);
114 : : #endif
115 : : static DSA_SIG *ubsec_dsa_do_sign(const unsigned char *dgst, int dlen, DSA *dsa);
116 : : static int ubsec_dsa_verify(const unsigned char *dgst, int dgst_len,
117 : : DSA_SIG *sig, DSA *dsa);
118 : : #endif
119 : : #ifndef OPENSSL_NO_DH
120 : : static int ubsec_mod_exp_dh(const DH *dh, BIGNUM *r, const BIGNUM *a,
121 : : const BIGNUM *p, const BIGNUM *m, BN_CTX *ctx,
122 : : BN_MONT_CTX *m_ctx);
123 : : static int ubsec_dh_compute_key(unsigned char *key,const BIGNUM *pub_key,DH *dh);
124 : : static int ubsec_dh_generate_key(DH *dh);
125 : : #endif
126 : :
127 : : #ifdef NOT_USED
128 : : static int ubsec_rand_bytes(unsigned char *buf, int num);
129 : : static int ubsec_rand_status(void);
130 : : #endif
131 : :
132 : : #define UBSEC_CMD_SO_PATH ENGINE_CMD_BASE
133 : : static const ENGINE_CMD_DEFN ubsec_cmd_defns[] = {
134 : : {UBSEC_CMD_SO_PATH,
135 : : "SO_PATH",
136 : : "Specifies the path to the 'ubsec' shared library",
137 : : ENGINE_CMD_FLAG_STRING},
138 : : {0, NULL, NULL, 0}
139 : : };
140 : :
141 : : #ifndef OPENSSL_NO_RSA
142 : : /* Our internal RSA_METHOD that we provide pointers to */
143 : : static RSA_METHOD ubsec_rsa =
144 : : {
145 : : "UBSEC RSA method",
146 : : NULL,
147 : : NULL,
148 : : NULL,
149 : : NULL,
150 : : ubsec_rsa_mod_exp,
151 : : ubsec_mod_exp_mont,
152 : : NULL,
153 : : NULL,
154 : : 0,
155 : : NULL,
156 : : NULL,
157 : : NULL,
158 : : NULL
159 : : };
160 : : #endif
161 : :
162 : : #ifndef OPENSSL_NO_DSA
163 : : /* Our internal DSA_METHOD that we provide pointers to */
164 : : static DSA_METHOD ubsec_dsa =
165 : : {
166 : : "UBSEC DSA method",
167 : : ubsec_dsa_do_sign, /* dsa_do_sign */
168 : : NULL, /* dsa_sign_setup */
169 : : ubsec_dsa_verify, /* dsa_do_verify */
170 : : NULL, /* ubsec_dsa_mod_exp */ /* dsa_mod_exp */
171 : : NULL, /* ubsec_mod_exp_dsa */ /* bn_mod_exp */
172 : : NULL, /* init */
173 : : NULL, /* finish */
174 : : 0, /* flags */
175 : : NULL, /* app_data */
176 : : NULL, /* dsa_paramgen */
177 : : NULL /* dsa_keygen */
178 : : };
179 : : #endif
180 : :
181 : : #ifndef OPENSSL_NO_DH
182 : : /* Our internal DH_METHOD that we provide pointers to */
183 : : static DH_METHOD ubsec_dh =
184 : : {
185 : : "UBSEC DH method",
186 : : ubsec_dh_generate_key,
187 : : ubsec_dh_compute_key,
188 : : ubsec_mod_exp_dh,
189 : : NULL,
190 : : NULL,
191 : : 0,
192 : : NULL,
193 : : NULL
194 : : };
195 : : #endif
196 : :
197 : : /* Constants used when creating the ENGINE */
198 : : static const char *engine_ubsec_id = "ubsec";
199 : : static const char *engine_ubsec_name = "UBSEC hardware engine support";
200 : :
201 : : /* This internal function is used by ENGINE_ubsec() and possibly by the
202 : : * "dynamic" ENGINE support too */
203 : 728 : static int bind_helper(ENGINE *e)
204 : : {
205 : : #ifndef OPENSSL_NO_RSA
206 : : const RSA_METHOD *meth1;
207 : : #endif
208 : : #ifndef OPENSSL_NO_DH
209 : : #ifndef HAVE_UBSEC_DH
210 : : const DH_METHOD *meth3;
211 : : #endif /* HAVE_UBSEC_DH */
212 : : #endif
213 [ + - + - ]: 1456 : if(!ENGINE_set_id(e, engine_ubsec_id) ||
214 [ + - ]: 1456 : !ENGINE_set_name(e, engine_ubsec_name) ||
215 : : #ifndef OPENSSL_NO_RSA
216 [ + - ]: 1456 : !ENGINE_set_RSA(e, &ubsec_rsa) ||
217 : : #endif
218 : : #ifndef OPENSSL_NO_DSA
219 [ + - ]: 1456 : !ENGINE_set_DSA(e, &ubsec_dsa) ||
220 : : #endif
221 : : #ifndef OPENSSL_NO_DH
222 [ + - ]: 1456 : !ENGINE_set_DH(e, &ubsec_dh) ||
223 : : #endif
224 [ + - ]: 1456 : !ENGINE_set_destroy_function(e, ubsec_destroy) ||
225 [ + - ]: 1456 : !ENGINE_set_init_function(e, ubsec_init) ||
226 [ + - ]: 1456 : !ENGINE_set_finish_function(e, ubsec_finish) ||
227 [ + - ]: 1456 : !ENGINE_set_ctrl_function(e, ubsec_ctrl) ||
228 : 728 : !ENGINE_set_cmd_defns(e, ubsec_cmd_defns))
229 : : return 0;
230 : :
231 : : #ifndef OPENSSL_NO_RSA
232 : : /* We know that the "PKCS1_SSLeay()" functions hook properly
233 : : * to the Broadcom-specific mod_exp and mod_exp_crt so we use
234 : : * those functions. NB: We don't use ENGINE_openssl() or
235 : : * anything "more generic" because something like the RSAref
236 : : * code may not hook properly, and if you own one of these
237 : : * cards then you have the right to do RSA operations on it
238 : : * anyway! */
239 : 728 : meth1 = RSA_PKCS1_SSLeay();
240 : 728 : ubsec_rsa.rsa_pub_enc = meth1->rsa_pub_enc;
241 : 728 : ubsec_rsa.rsa_pub_dec = meth1->rsa_pub_dec;
242 : 728 : ubsec_rsa.rsa_priv_enc = meth1->rsa_priv_enc;
243 : 728 : ubsec_rsa.rsa_priv_dec = meth1->rsa_priv_dec;
244 : : #endif
245 : :
246 : : #ifndef OPENSSL_NO_DH
247 : : #ifndef HAVE_UBSEC_DH
248 : : /* Much the same for Diffie-Hellman */
249 : 728 : meth3 = DH_OpenSSL();
250 : 728 : ubsec_dh.generate_key = meth3->generate_key;
251 : 728 : ubsec_dh.compute_key = meth3->compute_key;
252 : : #endif /* HAVE_UBSEC_DH */
253 : : #endif
254 : :
255 : : /* Ensure the ubsec error handling is set up */
256 : 728 : ERR_load_UBSEC_strings();
257 : 728 : return 1;
258 : : }
259 : :
260 : : #ifdef OPENSSL_NO_DYNAMIC_ENGINE
261 : 728 : static ENGINE *engine_ubsec(void)
262 : : {
263 : 728 : ENGINE *ret = ENGINE_new();
264 [ + - ]: 728 : if(!ret)
265 : : return NULL;
266 [ - + ]: 728 : if(!bind_helper(ret))
267 : : {
268 : 0 : ENGINE_free(ret);
269 : 0 : return NULL;
270 : : }
271 : : return ret;
272 : : }
273 : :
274 : 728 : void ENGINE_load_ubsec(void)
275 : : {
276 : : /* Copied from eng_[openssl|dyn].c */
277 : 728 : ENGINE *toadd = engine_ubsec();
278 [ + - ]: 728 : if(!toadd) return;
279 : 728 : ENGINE_add(toadd);
280 : 728 : ENGINE_free(toadd);
281 : 728 : ERR_clear_error();
282 : : }
283 : : #endif
284 : :
285 : : /* This is a process-global DSO handle used for loading and unloading
286 : : * the UBSEC library. NB: This is only set (or unset) during an
287 : : * init() or finish() call (reference counts permitting) and they're
288 : : * operating with global locks, so this should be thread-safe
289 : : * implicitly. */
290 : :
291 : : static DSO *ubsec_dso = NULL;
292 : :
293 : : /* These are the function pointers that are (un)set when the library has
294 : : * successfully (un)loaded. */
295 : :
296 : : static t_UBSEC_ubsec_bytes_to_bits *p_UBSEC_ubsec_bytes_to_bits = NULL;
297 : : static t_UBSEC_ubsec_bits_to_bytes *p_UBSEC_ubsec_bits_to_bytes = NULL;
298 : : static t_UBSEC_ubsec_open *p_UBSEC_ubsec_open = NULL;
299 : : static t_UBSEC_ubsec_close *p_UBSEC_ubsec_close = NULL;
300 : : #ifndef OPENSSL_NO_DH
301 : : static t_UBSEC_diffie_hellman_generate_ioctl
302 : : *p_UBSEC_diffie_hellman_generate_ioctl = NULL;
303 : : static t_UBSEC_diffie_hellman_agree_ioctl *p_UBSEC_diffie_hellman_agree_ioctl = NULL;
304 : : #endif
305 : : #ifndef OPENSSL_NO_RSA
306 : : static t_UBSEC_rsa_mod_exp_ioctl *p_UBSEC_rsa_mod_exp_ioctl = NULL;
307 : : static t_UBSEC_rsa_mod_exp_crt_ioctl *p_UBSEC_rsa_mod_exp_crt_ioctl = NULL;
308 : : #endif
309 : : #ifndef OPENSSL_NO_DSA
310 : : static t_UBSEC_dsa_sign_ioctl *p_UBSEC_dsa_sign_ioctl = NULL;
311 : : static t_UBSEC_dsa_verify_ioctl *p_UBSEC_dsa_verify_ioctl = NULL;
312 : : #endif
313 : : static t_UBSEC_math_accelerate_ioctl *p_UBSEC_math_accelerate_ioctl = NULL;
314 : : static t_UBSEC_rng_ioctl *p_UBSEC_rng_ioctl = NULL;
315 : : static t_UBSEC_max_key_len_ioctl *p_UBSEC_max_key_len_ioctl = NULL;
316 : :
317 : : static int max_key_len = 1024; /* ??? */
318 : :
319 : : /*
320 : : * These are the static string constants for the DSO file name and the function
321 : : * symbol names to bind to.
322 : : */
323 : :
324 : : static const char *UBSEC_LIBNAME = NULL;
325 : 281 : static const char *get_UBSEC_LIBNAME(void)
326 : : {
327 [ - + ]: 281 : if(UBSEC_LIBNAME)
328 : 0 : return UBSEC_LIBNAME;
329 : : return "ubsec";
330 : : }
331 : 727 : static void free_UBSEC_LIBNAME(void)
332 : : {
333 [ - + ]: 727 : if(UBSEC_LIBNAME)
334 : 0 : OPENSSL_free((void*)UBSEC_LIBNAME);
335 : 727 : UBSEC_LIBNAME = NULL;
336 : 727 : }
337 : 0 : static long set_UBSEC_LIBNAME(const char *name)
338 : : {
339 : 0 : free_UBSEC_LIBNAME();
340 : 0 : return (((UBSEC_LIBNAME = BUF_strdup(name)) != NULL) ? 1 : 0);
341 : : }
342 : : static const char *UBSEC_F1 = "ubsec_bytes_to_bits";
343 : : static const char *UBSEC_F2 = "ubsec_bits_to_bytes";
344 : : static const char *UBSEC_F3 = "ubsec_open";
345 : : static const char *UBSEC_F4 = "ubsec_close";
346 : : #ifndef OPENSSL_NO_DH
347 : : static const char *UBSEC_F5 = "diffie_hellman_generate_ioctl";
348 : : static const char *UBSEC_F6 = "diffie_hellman_agree_ioctl";
349 : : #endif
350 : : /* #ifndef OPENSSL_NO_RSA */
351 : : static const char *UBSEC_F7 = "rsa_mod_exp_ioctl";
352 : : static const char *UBSEC_F8 = "rsa_mod_exp_crt_ioctl";
353 : : /* #endif */
354 : : #ifndef OPENSSL_NO_DSA
355 : : static const char *UBSEC_F9 = "dsa_sign_ioctl";
356 : : static const char *UBSEC_F10 = "dsa_verify_ioctl";
357 : : #endif
358 : : static const char *UBSEC_F11 = "math_accelerate_ioctl";
359 : : static const char *UBSEC_F12 = "rng_ioctl";
360 : : static const char *UBSEC_F13 = "ubsec_max_key_len_ioctl";
361 : :
362 : : /* Destructor (complements the "ENGINE_ubsec()" constructor) */
363 : 727 : static int ubsec_destroy(ENGINE *e)
364 : : {
365 : 727 : free_UBSEC_LIBNAME();
366 : 727 : ERR_unload_UBSEC_strings();
367 : 727 : return 1;
368 : : }
369 : :
370 : : /* (de)initialisation functions. */
371 : 281 : static int ubsec_init(ENGINE *e)
372 : : {
373 : : t_UBSEC_ubsec_bytes_to_bits *p1;
374 : : t_UBSEC_ubsec_bits_to_bytes *p2;
375 : : t_UBSEC_ubsec_open *p3;
376 : : t_UBSEC_ubsec_close *p4;
377 : : #ifndef OPENSSL_NO_DH
378 : : t_UBSEC_diffie_hellman_generate_ioctl *p5;
379 : : t_UBSEC_diffie_hellman_agree_ioctl *p6;
380 : : #endif
381 : : /* #ifndef OPENSSL_NO_RSA */
382 : : t_UBSEC_rsa_mod_exp_ioctl *p7;
383 : : t_UBSEC_rsa_mod_exp_crt_ioctl *p8;
384 : : /* #endif */
385 : : #ifndef OPENSSL_NO_DSA
386 : : t_UBSEC_dsa_sign_ioctl *p9;
387 : : t_UBSEC_dsa_verify_ioctl *p10;
388 : : #endif
389 : : t_UBSEC_math_accelerate_ioctl *p11;
390 : : t_UBSEC_rng_ioctl *p12;
391 : : t_UBSEC_max_key_len_ioctl *p13;
392 : 281 : int fd = 0;
393 : :
394 [ - + ]: 281 : if(ubsec_dso != NULL)
395 : : {
396 : 0 : UBSECerr(UBSEC_F_UBSEC_INIT, UBSEC_R_ALREADY_LOADED);
397 : 0 : goto err;
398 : : }
399 : : /*
400 : : * Attempt to load libubsec.so/ubsec.dll/whatever.
401 : : */
402 : 281 : ubsec_dso = DSO_load(NULL, get_UBSEC_LIBNAME(), NULL, 0);
403 [ + - ]: 281 : if(ubsec_dso == NULL)
404 : : {
405 : 281 : UBSECerr(UBSEC_F_UBSEC_INIT, UBSEC_R_DSO_FAILURE);
406 : 281 : goto err;
407 : : }
408 : :
409 [ # # ]: 0 : if (
410 [ # # ]: 0 : !(p1 = (t_UBSEC_ubsec_bytes_to_bits *) DSO_bind_func(ubsec_dso, UBSEC_F1)) ||
411 [ # # ]: 0 : !(p2 = (t_UBSEC_ubsec_bits_to_bytes *) DSO_bind_func(ubsec_dso, UBSEC_F2)) ||
412 [ # # ]: 0 : !(p3 = (t_UBSEC_ubsec_open *) DSO_bind_func(ubsec_dso, UBSEC_F3)) ||
413 [ # # ]: 0 : !(p4 = (t_UBSEC_ubsec_close *) DSO_bind_func(ubsec_dso, UBSEC_F4)) ||
414 : : #ifndef OPENSSL_NO_DH
415 : : !(p5 = (t_UBSEC_diffie_hellman_generate_ioctl *)
416 [ # # ]: 0 : DSO_bind_func(ubsec_dso, UBSEC_F5)) ||
417 : : !(p6 = (t_UBSEC_diffie_hellman_agree_ioctl *)
418 [ # # ]: 0 : DSO_bind_func(ubsec_dso, UBSEC_F6)) ||
419 : : #endif
420 : : /* #ifndef OPENSSL_NO_RSA */
421 [ # # ]: 0 : !(p7 = (t_UBSEC_rsa_mod_exp_ioctl *) DSO_bind_func(ubsec_dso, UBSEC_F7)) ||
422 [ # # ]: 0 : !(p8 = (t_UBSEC_rsa_mod_exp_crt_ioctl *) DSO_bind_func(ubsec_dso, UBSEC_F8)) ||
423 : : /* #endif */
424 : : #ifndef OPENSSL_NO_DSA
425 [ # # ]: 0 : !(p9 = (t_UBSEC_dsa_sign_ioctl *) DSO_bind_func(ubsec_dso, UBSEC_F9)) ||
426 [ # # ]: 0 : !(p10 = (t_UBSEC_dsa_verify_ioctl *) DSO_bind_func(ubsec_dso, UBSEC_F10)) ||
427 : : #endif
428 : : !(p11 = (t_UBSEC_math_accelerate_ioctl *)
429 [ # # ]: 0 : DSO_bind_func(ubsec_dso, UBSEC_F11)) ||
430 [ # # ]: 0 : !(p12 = (t_UBSEC_rng_ioctl *) DSO_bind_func(ubsec_dso, UBSEC_F12)) ||
431 : 0 : !(p13 = (t_UBSEC_max_key_len_ioctl *) DSO_bind_func(ubsec_dso, UBSEC_F13)))
432 : : {
433 : 0 : UBSECerr(UBSEC_F_UBSEC_INIT, UBSEC_R_DSO_FAILURE);
434 : 0 : goto err;
435 : : }
436 : :
437 : : /* Copy the pointers */
438 : 0 : p_UBSEC_ubsec_bytes_to_bits = p1;
439 : 0 : p_UBSEC_ubsec_bits_to_bytes = p2;
440 : 0 : p_UBSEC_ubsec_open = p3;
441 : 0 : p_UBSEC_ubsec_close = p4;
442 : : #ifndef OPENSSL_NO_DH
443 : 0 : p_UBSEC_diffie_hellman_generate_ioctl = p5;
444 : 0 : p_UBSEC_diffie_hellman_agree_ioctl = p6;
445 : : #endif
446 : : #ifndef OPENSSL_NO_RSA
447 : 0 : p_UBSEC_rsa_mod_exp_ioctl = p7;
448 : 0 : p_UBSEC_rsa_mod_exp_crt_ioctl = p8;
449 : : #endif
450 : : #ifndef OPENSSL_NO_DSA
451 : 0 : p_UBSEC_dsa_sign_ioctl = p9;
452 : 0 : p_UBSEC_dsa_verify_ioctl = p10;
453 : : #endif
454 : 0 : p_UBSEC_math_accelerate_ioctl = p11;
455 : 0 : p_UBSEC_rng_ioctl = p12;
456 : 0 : p_UBSEC_max_key_len_ioctl = p13;
457 : :
458 : : /* Perform an open to see if there's actually any unit running. */
459 [ # # ][ # # ]: 0 : if (((fd = p_UBSEC_ubsec_open(UBSEC_KEY_DEVICE_NAME)) > 0) && (p_UBSEC_max_key_len_ioctl(fd, &max_key_len) == 0))
460 : : {
461 : 0 : p_UBSEC_ubsec_close(fd);
462 : 0 : return 1;
463 : : }
464 : : else
465 : : {
466 : 0 : UBSECerr(UBSEC_F_UBSEC_INIT, UBSEC_R_UNIT_FAILURE);
467 : : }
468 : :
469 : : err:
470 [ - + ]: 281 : if(ubsec_dso)
471 : 0 : DSO_free(ubsec_dso);
472 : 281 : ubsec_dso = NULL;
473 : 281 : p_UBSEC_ubsec_bytes_to_bits = NULL;
474 : 281 : p_UBSEC_ubsec_bits_to_bytes = NULL;
475 : 281 : p_UBSEC_ubsec_open = NULL;
476 : 281 : p_UBSEC_ubsec_close = NULL;
477 : : #ifndef OPENSSL_NO_DH
478 : 281 : p_UBSEC_diffie_hellman_generate_ioctl = NULL;
479 : 281 : p_UBSEC_diffie_hellman_agree_ioctl = NULL;
480 : : #endif
481 : : #ifndef OPENSSL_NO_RSA
482 : 281 : p_UBSEC_rsa_mod_exp_ioctl = NULL;
483 : 281 : p_UBSEC_rsa_mod_exp_crt_ioctl = NULL;
484 : : #endif
485 : : #ifndef OPENSSL_NO_DSA
486 : 281 : p_UBSEC_dsa_sign_ioctl = NULL;
487 : 281 : p_UBSEC_dsa_verify_ioctl = NULL;
488 : : #endif
489 : 281 : p_UBSEC_math_accelerate_ioctl = NULL;
490 : 281 : p_UBSEC_rng_ioctl = NULL;
491 : 281 : p_UBSEC_max_key_len_ioctl = NULL;
492 : :
493 : 281 : return 0;
494 : : }
495 : :
496 : 0 : static int ubsec_finish(ENGINE *e)
497 : : {
498 : 0 : free_UBSEC_LIBNAME();
499 [ # # ]: 0 : if(ubsec_dso == NULL)
500 : : {
501 : 0 : UBSECerr(UBSEC_F_UBSEC_FINISH, UBSEC_R_NOT_LOADED);
502 : 0 : return 0;
503 : : }
504 [ # # ]: 0 : if(!DSO_free(ubsec_dso))
505 : : {
506 : 0 : UBSECerr(UBSEC_F_UBSEC_FINISH, UBSEC_R_DSO_FAILURE);
507 : 0 : return 0;
508 : : }
509 : 0 : ubsec_dso = NULL;
510 : 0 : p_UBSEC_ubsec_bytes_to_bits = NULL;
511 : 0 : p_UBSEC_ubsec_bits_to_bytes = NULL;
512 : 0 : p_UBSEC_ubsec_open = NULL;
513 : 0 : p_UBSEC_ubsec_close = NULL;
514 : : #ifndef OPENSSL_NO_DH
515 : 0 : p_UBSEC_diffie_hellman_generate_ioctl = NULL;
516 : 0 : p_UBSEC_diffie_hellman_agree_ioctl = NULL;
517 : : #endif
518 : : #ifndef OPENSSL_NO_RSA
519 : 0 : p_UBSEC_rsa_mod_exp_ioctl = NULL;
520 : 0 : p_UBSEC_rsa_mod_exp_crt_ioctl = NULL;
521 : : #endif
522 : : #ifndef OPENSSL_NO_DSA
523 : 0 : p_UBSEC_dsa_sign_ioctl = NULL;
524 : 0 : p_UBSEC_dsa_verify_ioctl = NULL;
525 : : #endif
526 : 0 : p_UBSEC_math_accelerate_ioctl = NULL;
527 : 0 : p_UBSEC_rng_ioctl = NULL;
528 : 0 : p_UBSEC_max_key_len_ioctl = NULL;
529 : 0 : return 1;
530 : : }
531 : :
532 : 0 : static int ubsec_ctrl(ENGINE *e, int cmd, long i, void *p, void (*f)(void))
533 : : {
534 : 0 : int initialised = ((ubsec_dso == NULL) ? 0 : 1);
535 [ # # ]: 0 : switch(cmd)
536 : : {
537 : : case UBSEC_CMD_SO_PATH:
538 [ # # ]: 0 : if(p == NULL)
539 : : {
540 : 0 : UBSECerr(UBSEC_F_UBSEC_CTRL,ERR_R_PASSED_NULL_PARAMETER);
541 : 0 : return 0;
542 : : }
543 [ # # ]: 0 : if(initialised)
544 : : {
545 : 0 : UBSECerr(UBSEC_F_UBSEC_CTRL,UBSEC_R_ALREADY_LOADED);
546 : 0 : return 0;
547 : : }
548 : 0 : return set_UBSEC_LIBNAME((const char *)p);
549 : : default:
550 : : break;
551 : : }
552 : 0 : UBSECerr(UBSEC_F_UBSEC_CTRL,UBSEC_R_CTRL_COMMAND_NOT_IMPLEMENTED);
553 : 0 : return 0;
554 : : }
555 : :
556 : 0 : static int ubsec_mod_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
557 : : const BIGNUM *m, BN_CTX *ctx)
558 : : {
559 : 0 : int y_len = 0;
560 : : int fd;
561 : :
562 [ # # ]: 0 : if(ubsec_dso == NULL)
563 : : {
564 : 0 : UBSECerr(UBSEC_F_UBSEC_MOD_EXP, UBSEC_R_NOT_LOADED);
565 : 0 : return 0;
566 : : }
567 : :
568 : : /* Check if hardware can't handle this argument. */
569 : 0 : y_len = BN_num_bits(m);
570 [ # # ]: 0 : if (y_len > max_key_len) {
571 : 0 : UBSECerr(UBSEC_F_UBSEC_MOD_EXP, UBSEC_R_SIZE_TOO_LARGE_OR_TOO_SMALL);
572 : 0 : return BN_mod_exp(r, a, p, m, ctx);
573 : : }
574 : :
575 [ # # ][ # # ]: 0 : if(!bn_wexpand(r, m->top))
576 : : {
577 : 0 : UBSECerr(UBSEC_F_UBSEC_MOD_EXP, UBSEC_R_BN_EXPAND_FAIL);
578 : 0 : return 0;
579 : : }
580 : :
581 [ # # ]: 0 : if ((fd = p_UBSEC_ubsec_open(UBSEC_KEY_DEVICE_NAME)) <= 0) {
582 : 0 : fd = 0;
583 : 0 : UBSECerr(UBSEC_F_UBSEC_MOD_EXP, UBSEC_R_UNIT_FAILURE);
584 : 0 : return BN_mod_exp(r, a, p, m, ctx);
585 : : }
586 : :
587 [ # # ]: 0 : if (p_UBSEC_rsa_mod_exp_ioctl(fd, (unsigned char *)a->d, BN_num_bits(a),
588 : 0 : (unsigned char *)m->d, BN_num_bits(m), (unsigned char *)p->d,
589 : 0 : BN_num_bits(p), (unsigned char *)r->d, &y_len) != 0)
590 : : {
591 : 0 : UBSECerr(UBSEC_F_UBSEC_MOD_EXP, UBSEC_R_REQUEST_FAILED);
592 : 0 : p_UBSEC_ubsec_close(fd);
593 : :
594 : 0 : return BN_mod_exp(r, a, p, m, ctx);
595 : : }
596 : :
597 : 0 : p_UBSEC_ubsec_close(fd);
598 : :
599 : 0 : r->top = (BN_num_bits(m)+BN_BITS2-1)/BN_BITS2;
600 : 0 : return 1;
601 : : }
602 : :
603 : : #ifndef OPENSSL_NO_RSA
604 : 0 : static int ubsec_rsa_mod_exp(BIGNUM *r0, const BIGNUM *I, RSA *rsa, BN_CTX *ctx)
605 : : {
606 : 0 : int to_return = 0;
607 : :
608 [ # # ][ # # ]: 0 : if(!rsa->p || !rsa->q || !rsa->dmp1 || !rsa->dmq1 || !rsa->iqmp)
[ # # ][ # # ]
[ # # ]
609 : : {
610 : 0 : UBSECerr(UBSEC_F_UBSEC_RSA_MOD_EXP, UBSEC_R_MISSING_KEY_COMPONENTS);
611 : 0 : goto err;
612 : : }
613 : :
614 : 0 : to_return = ubsec_mod_exp_crt(r0, I, rsa->p, rsa->q, rsa->dmp1,
615 : : rsa->dmq1, rsa->iqmp, ctx);
616 [ # # ]: 0 : if (to_return == FAIL_TO_SOFTWARE)
617 : : {
618 : : /*
619 : : * Do in software as hardware failed.
620 : : */
621 : 0 : const RSA_METHOD *meth = RSA_PKCS1_SSLeay();
622 : 0 : to_return = (*meth->rsa_mod_exp)(r0, I, rsa, ctx);
623 : : }
624 : : err:
625 : 0 : return to_return;
626 : : }
627 : :
628 : 0 : static int ubsec_mod_exp_crt(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
629 : : const BIGNUM *q, const BIGNUM *dp,
630 : : const BIGNUM *dq, const BIGNUM *qinv, BN_CTX *ctx)
631 : : {
632 : : int y_len,
633 : : fd;
634 : :
635 : 0 : y_len = BN_num_bits(p) + BN_num_bits(q);
636 : :
637 : : /* Check if hardware can't handle this argument. */
638 [ # # ]: 0 : if (y_len > max_key_len) {
639 : 0 : UBSECerr(UBSEC_F_UBSEC_MOD_EXP_CRT, UBSEC_R_SIZE_TOO_LARGE_OR_TOO_SMALL);
640 : : return FAIL_TO_SOFTWARE;
641 : : }
642 : :
643 [ # # ][ # # ]: 0 : if (!bn_wexpand(r, p->top + q->top + 1)) {
644 : 0 : UBSECerr(UBSEC_F_UBSEC_MOD_EXP_CRT, UBSEC_R_BN_EXPAND_FAIL);
645 : : return 0;
646 : : }
647 : :
648 [ # # ]: 0 : if ((fd = p_UBSEC_ubsec_open(UBSEC_KEY_DEVICE_NAME)) <= 0) {
649 : 0 : fd = 0;
650 : 0 : UBSECerr(UBSEC_F_UBSEC_MOD_EXP_CRT, UBSEC_R_UNIT_FAILURE);
651 : : return FAIL_TO_SOFTWARE;
652 : : }
653 : :
654 [ # # ]: 0 : if (p_UBSEC_rsa_mod_exp_crt_ioctl(fd,
655 : 0 : (unsigned char *)a->d, BN_num_bits(a),
656 : 0 : (unsigned char *)qinv->d, BN_num_bits(qinv),
657 : 0 : (unsigned char *)dp->d, BN_num_bits(dp),
658 : 0 : (unsigned char *)p->d, BN_num_bits(p),
659 : 0 : (unsigned char *)dq->d, BN_num_bits(dq),
660 : 0 : (unsigned char *)q->d, BN_num_bits(q),
661 : 0 : (unsigned char *)r->d, &y_len) != 0) {
662 : 0 : UBSECerr(UBSEC_F_UBSEC_MOD_EXP_CRT, UBSEC_R_REQUEST_FAILED);
663 : 0 : p_UBSEC_ubsec_close(fd);
664 : : return FAIL_TO_SOFTWARE;
665 : : }
666 : :
667 : 0 : p_UBSEC_ubsec_close(fd);
668 : :
669 : 0 : r->top = (BN_num_bits(p) + BN_num_bits(q) + BN_BITS2 - 1)/BN_BITS2;
670 : : return 1;
671 : : }
672 : : #endif
673 : :
674 : : #ifndef OPENSSL_NO_DSA
675 : : #ifdef NOT_USED
676 : : static int ubsec_dsa_mod_exp(DSA *dsa, BIGNUM *rr, BIGNUM *a1,
677 : : BIGNUM *p1, BIGNUM *a2, BIGNUM *p2, BIGNUM *m,
678 : : BN_CTX *ctx, BN_MONT_CTX *in_mont)
679 : : {
680 : : BIGNUM t;
681 : : int to_return = 0;
682 : :
683 : : BN_init(&t);
684 : : /* let rr = a1 ^ p1 mod m */
685 : : if (!ubsec_mod_exp(rr,a1,p1,m,ctx)) goto end;
686 : : /* let t = a2 ^ p2 mod m */
687 : : if (!ubsec_mod_exp(&t,a2,p2,m,ctx)) goto end;
688 : : /* let rr = rr * t mod m */
689 : : if (!BN_mod_mul(rr,rr,&t,m,ctx)) goto end;
690 : : to_return = 1;
691 : : end:
692 : : BN_free(&t);
693 : : return to_return;
694 : : }
695 : :
696 : : static int ubsec_mod_exp_dsa(DSA *dsa, BIGNUM *r, BIGNUM *a,
697 : : const BIGNUM *p, const BIGNUM *m, BN_CTX *ctx,
698 : : BN_MONT_CTX *m_ctx)
699 : : {
700 : : return ubsec_mod_exp(r, a, p, m, ctx);
701 : : }
702 : : #endif
703 : : #endif
704 : :
705 : : #ifndef OPENSSL_NO_RSA
706 : :
707 : : /*
708 : : * This function is aliased to mod_exp (with the mont stuff dropped).
709 : : */
710 : 0 : static int ubsec_mod_exp_mont(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
711 : : const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx)
712 : : {
713 : 0 : int ret = 0;
714 : :
715 : : /* Do in software if the key is too large for the hardware. */
716 [ # # ]: 0 : if (BN_num_bits(m) > max_key_len)
717 : : {
718 : 0 : const RSA_METHOD *meth = RSA_PKCS1_SSLeay();
719 : 0 : ret = (*meth->bn_mod_exp)(r, a, p, m, ctx, m_ctx);
720 : : }
721 : : else
722 : : {
723 : 0 : ret = ubsec_mod_exp(r, a, p, m, ctx);
724 : : }
725 : :
726 : 0 : return ret;
727 : : }
728 : : #endif
729 : :
730 : : #ifndef OPENSSL_NO_DH
731 : : /* This function is aliased to mod_exp (with the dh and mont dropped). */
732 : 0 : static int ubsec_mod_exp_dh(const DH *dh, BIGNUM *r, const BIGNUM *a,
733 : : const BIGNUM *p, const BIGNUM *m, BN_CTX *ctx,
734 : : BN_MONT_CTX *m_ctx)
735 : : {
736 : 0 : return ubsec_mod_exp(r, a, p, m, ctx);
737 : : }
738 : : #endif
739 : :
740 : : #ifndef OPENSSL_NO_DSA
741 : 0 : static DSA_SIG *ubsec_dsa_do_sign(const unsigned char *dgst, int dlen, DSA *dsa)
742 : : {
743 : 0 : DSA_SIG *to_return = NULL;
744 : 0 : int s_len = 160, r_len = 160, d_len, fd;
745 : 0 : BIGNUM m, *r=NULL, *s=NULL;
746 : :
747 : 0 : BN_init(&m);
748 : :
749 : 0 : s = BN_new();
750 : 0 : r = BN_new();
751 [ # # ]: 0 : if ((s == NULL) || (r==NULL))
752 : : goto err;
753 : :
754 : 0 : d_len = p_UBSEC_ubsec_bytes_to_bits((unsigned char *)dgst, dlen);
755 : :
756 [ # # ][ # # ]: 0 : if(!bn_wexpand(r, (160+BN_BITS2-1)/BN_BITS2) ||
[ # # ][ # # ]
[ # # # # ]
757 : 0 : (!bn_wexpand(s, (160+BN_BITS2-1)/BN_BITS2))) {
758 : 0 : UBSECerr(UBSEC_F_UBSEC_DSA_DO_SIGN, UBSEC_R_BN_EXPAND_FAIL);
759 : 0 : goto err;
760 : : }
761 : :
762 [ # # ]: 0 : if (BN_bin2bn(dgst,dlen,&m) == NULL) {
763 : 0 : UBSECerr(UBSEC_F_UBSEC_DSA_DO_SIGN, UBSEC_R_BN_EXPAND_FAIL);
764 : 0 : goto err;
765 : : }
766 : :
767 [ # # ]: 0 : if ((fd = p_UBSEC_ubsec_open(UBSEC_KEY_DEVICE_NAME)) <= 0) {
768 : : const DSA_METHOD *meth;
769 : 0 : fd = 0;
770 : 0 : UBSECerr(UBSEC_F_UBSEC_DSA_DO_SIGN, UBSEC_R_UNIT_FAILURE);
771 : 0 : meth = DSA_OpenSSL();
772 : 0 : to_return = meth->dsa_do_sign(dgst, dlen, dsa);
773 : 0 : goto err;
774 : : }
775 : :
776 [ # # ]: 0 : if (p_UBSEC_dsa_sign_ioctl(fd, 0, /* compute hash before signing */
777 : : (unsigned char *)dgst, d_len,
778 : : NULL, 0, /* compute random value */
779 : 0 : (unsigned char *)dsa->p->d, BN_num_bits(dsa->p),
780 : 0 : (unsigned char *)dsa->q->d, BN_num_bits(dsa->q),
781 : 0 : (unsigned char *)dsa->g->d, BN_num_bits(dsa->g),
782 : 0 : (unsigned char *)dsa->priv_key->d, BN_num_bits(dsa->priv_key),
783 : 0 : (unsigned char *)r->d, &r_len,
784 : 0 : (unsigned char *)s->d, &s_len ) != 0) {
785 : : const DSA_METHOD *meth;
786 : :
787 : 0 : UBSECerr(UBSEC_F_UBSEC_DSA_DO_SIGN, UBSEC_R_REQUEST_FAILED);
788 : 0 : p_UBSEC_ubsec_close(fd);
789 : 0 : meth = DSA_OpenSSL();
790 : 0 : to_return = meth->dsa_do_sign(dgst, dlen, dsa);
791 : :
792 : 0 : goto err;
793 : : }
794 : :
795 : 0 : p_UBSEC_ubsec_close(fd);
796 : :
797 : 0 : r->top = (160+BN_BITS2-1)/BN_BITS2;
798 : 0 : s->top = (160+BN_BITS2-1)/BN_BITS2;
799 : :
800 : 0 : to_return = DSA_SIG_new();
801 [ # # ]: 0 : if(to_return == NULL) {
802 : 0 : UBSECerr(UBSEC_F_UBSEC_DSA_DO_SIGN, UBSEC_R_BN_EXPAND_FAIL);
803 : 0 : goto err;
804 : : }
805 : :
806 : 0 : to_return->r = r;
807 : 0 : to_return->s = s;
808 : :
809 : : err:
810 [ # # ]: 0 : if (!to_return) {
811 [ # # ]: 0 : if (r) BN_free(r);
812 [ # # ]: 0 : if (s) BN_free(s);
813 : : }
814 : 0 : BN_clear_free(&m);
815 : 0 : return to_return;
816 : : }
817 : :
818 : 0 : static int ubsec_dsa_verify(const unsigned char *dgst, int dgst_len,
819 : : DSA_SIG *sig, DSA *dsa)
820 : : {
821 : : int v_len, d_len;
822 : 0 : int to_return = 0;
823 : : int fd;
824 : 0 : BIGNUM v, *pv = &v;
825 : :
826 : 0 : BN_init(&v);
827 : :
828 [ # # ][ # # ]: 0 : if(!bn_wexpand(pv, dsa->p->top)) {
829 : 0 : UBSECerr(UBSEC_F_UBSEC_DSA_VERIFY, UBSEC_R_BN_EXPAND_FAIL);
830 : 0 : goto err;
831 : : }
832 : :
833 : 0 : v_len = BN_num_bits(dsa->p);
834 : :
835 : 0 : d_len = p_UBSEC_ubsec_bytes_to_bits((unsigned char *)dgst, dgst_len);
836 : :
837 [ # # ]: 0 : if ((fd = p_UBSEC_ubsec_open(UBSEC_KEY_DEVICE_NAME)) <= 0) {
838 : : const DSA_METHOD *meth;
839 : 0 : fd = 0;
840 : 0 : UBSECerr(UBSEC_F_UBSEC_DSA_VERIFY, UBSEC_R_UNIT_FAILURE);
841 : 0 : meth = DSA_OpenSSL();
842 : 0 : to_return = meth->dsa_do_verify(dgst, dgst_len, sig, dsa);
843 : 0 : goto err;
844 : : }
845 : :
846 [ # # ]: 0 : if (p_UBSEC_dsa_verify_ioctl(fd, 0, /* compute hash before signing */
847 : : (unsigned char *)dgst, d_len,
848 : 0 : (unsigned char *)dsa->p->d, BN_num_bits(dsa->p),
849 : 0 : (unsigned char *)dsa->q->d, BN_num_bits(dsa->q),
850 : 0 : (unsigned char *)dsa->g->d, BN_num_bits(dsa->g),
851 : 0 : (unsigned char *)dsa->pub_key->d, BN_num_bits(dsa->pub_key),
852 : 0 : (unsigned char *)sig->r->d, BN_num_bits(sig->r),
853 : 0 : (unsigned char *)sig->s->d, BN_num_bits(sig->s),
854 : 0 : (unsigned char *)v.d, &v_len) != 0) {
855 : : const DSA_METHOD *meth;
856 : 0 : UBSECerr(UBSEC_F_UBSEC_DSA_VERIFY, UBSEC_R_REQUEST_FAILED);
857 : 0 : p_UBSEC_ubsec_close(fd);
858 : :
859 : 0 : meth = DSA_OpenSSL();
860 : 0 : to_return = meth->dsa_do_verify(dgst, dgst_len, sig, dsa);
861 : :
862 : 0 : goto err;
863 : : }
864 : :
865 : 0 : p_UBSEC_ubsec_close(fd);
866 : :
867 : 0 : to_return = 1;
868 : : err:
869 : 0 : BN_clear_free(&v);
870 : 0 : return to_return;
871 : : }
872 : : #endif
873 : :
874 : : #ifndef OPENSSL_NO_DH
875 : 0 : static int ubsec_dh_compute_key(unsigned char *key,const BIGNUM *pub_key,DH *dh)
876 : : {
877 : 0 : int ret = -1,
878 : : k_len,
879 : : fd;
880 : :
881 : 0 : k_len = BN_num_bits(dh->p);
882 : :
883 [ # # ]: 0 : if ((fd = p_UBSEC_ubsec_open(UBSEC_KEY_DEVICE_NAME)) <= 0)
884 : : {
885 : : const DH_METHOD *meth;
886 : 0 : UBSECerr(UBSEC_F_UBSEC_DH_COMPUTE_KEY, UBSEC_R_UNIT_FAILURE);
887 : 0 : meth = DH_OpenSSL();
888 : 0 : ret = meth->compute_key(key, pub_key, dh);
889 : 0 : goto err;
890 : : }
891 : :
892 [ # # ]: 0 : if (p_UBSEC_diffie_hellman_agree_ioctl(fd,
893 : 0 : (unsigned char *)dh->priv_key->d, BN_num_bits(dh->priv_key),
894 : 0 : (unsigned char *)pub_key->d, BN_num_bits(pub_key),
895 : 0 : (unsigned char *)dh->p->d, BN_num_bits(dh->p),
896 : : key, &k_len) != 0)
897 : : {
898 : : /* Hardware's a no go, failover to software */
899 : : const DH_METHOD *meth;
900 : 0 : UBSECerr(UBSEC_F_UBSEC_DH_COMPUTE_KEY, UBSEC_R_REQUEST_FAILED);
901 : 0 : p_UBSEC_ubsec_close(fd);
902 : :
903 : 0 : meth = DH_OpenSSL();
904 : 0 : ret = meth->compute_key(key, pub_key, dh);
905 : :
906 : 0 : goto err;
907 : : }
908 : :
909 : 0 : p_UBSEC_ubsec_close(fd);
910 : :
911 : 0 : ret = p_UBSEC_ubsec_bits_to_bytes(k_len);
912 : : err:
913 : 0 : return ret;
914 : : }
915 : :
916 : 0 : static int ubsec_dh_generate_key(DH *dh)
917 : : {
918 : 0 : int ret = 0,
919 : 0 : random_bits = 0,
920 : 0 : pub_key_len = 0,
921 : 0 : priv_key_len = 0,
922 : : fd;
923 : 0 : BIGNUM *pub_key = NULL;
924 : 0 : BIGNUM *priv_key = NULL;
925 : :
926 : : /*
927 : : * How many bits should Random x be? dh_key.c
928 : : * sets the range from 0 to num_bits(modulus) ???
929 : : */
930 : :
931 [ # # ]: 0 : if (dh->priv_key == NULL)
932 : : {
933 : 0 : priv_key = BN_new();
934 [ # # ]: 0 : if (priv_key == NULL) goto err;
935 : 0 : priv_key_len = BN_num_bits(dh->p);
936 [ # # ][ # # ]: 0 : if(bn_wexpand(priv_key, dh->p->top) == NULL) goto err;
937 : : do
938 [ # # ]: 0 : if (!BN_rand_range(priv_key, dh->p)) goto err;
939 [ # # ]: 0 : while (BN_is_zero(priv_key));
940 : 0 : random_bits = BN_num_bits(priv_key);
941 : : }
942 : : else
943 : : {
944 : : priv_key = dh->priv_key;
945 : : }
946 : :
947 [ # # ]: 0 : if (dh->pub_key == NULL)
948 : : {
949 : 0 : pub_key = BN_new();
950 : 0 : pub_key_len = BN_num_bits(dh->p);
951 [ # # ][ # # ]: 0 : if(bn_wexpand(pub_key, dh->p->top) == NULL) goto err;
952 [ # # ]: 0 : if(pub_key == NULL) goto err;
953 : : }
954 : : else
955 : : {
956 : : pub_key = dh->pub_key;
957 : : }
958 : :
959 [ # # ]: 0 : if ((fd = p_UBSEC_ubsec_open(UBSEC_KEY_DEVICE_NAME)) <= 0)
960 : : {
961 : : const DH_METHOD *meth;
962 : 0 : UBSECerr(UBSEC_F_UBSEC_DH_GENERATE_KEY, UBSEC_R_UNIT_FAILURE);
963 : 0 : meth = DH_OpenSSL();
964 : 0 : ret = meth->generate_key(dh);
965 : 0 : goto err;
966 : : }
967 : :
968 [ # # ]: 0 : if (p_UBSEC_diffie_hellman_generate_ioctl(fd,
969 : 0 : (unsigned char *)priv_key->d, &priv_key_len,
970 : 0 : (unsigned char *)pub_key->d, &pub_key_len,
971 : 0 : (unsigned char *)dh->g->d, BN_num_bits(dh->g),
972 : 0 : (unsigned char *)dh->p->d, BN_num_bits(dh->p),
973 : : 0, 0, random_bits) != 0)
974 : : {
975 : : /* Hardware's a no go, failover to software */
976 : : const DH_METHOD *meth;
977 : :
978 : 0 : UBSECerr(UBSEC_F_UBSEC_DH_GENERATE_KEY, UBSEC_R_REQUEST_FAILED);
979 : 0 : p_UBSEC_ubsec_close(fd);
980 : :
981 : 0 : meth = DH_OpenSSL();
982 : 0 : ret = meth->generate_key(dh);
983 : :
984 : 0 : goto err;
985 : : }
986 : :
987 : 0 : p_UBSEC_ubsec_close(fd);
988 : :
989 : 0 : dh->pub_key = pub_key;
990 : 0 : dh->pub_key->top = (pub_key_len + BN_BITS2-1) / BN_BITS2;
991 : 0 : dh->priv_key = priv_key;
992 : 0 : dh->priv_key->top = (priv_key_len + BN_BITS2-1) / BN_BITS2;
993 : :
994 : 0 : ret = 1;
995 : : err:
996 : 0 : return ret;
997 : : }
998 : : #endif
999 : :
1000 : : #ifdef NOT_USED
1001 : : static int ubsec_rand_bytes(unsigned char * buf,
1002 : : int num)
1003 : : {
1004 : : int ret = 0,
1005 : : fd;
1006 : :
1007 : : if ((fd = p_UBSEC_ubsec_open(UBSEC_KEY_DEVICE_NAME)) <= 0)
1008 : : {
1009 : : const RAND_METHOD *meth;
1010 : : UBSECerr(UBSEC_F_UBSEC_RAND_BYTES, UBSEC_R_UNIT_FAILURE);
1011 : : num = p_UBSEC_ubsec_bits_to_bytes(num);
1012 : : meth = RAND_SSLeay();
1013 : : meth->seed(buf, num);
1014 : : ret = meth->bytes(buf, num);
1015 : : goto err;
1016 : : }
1017 : :
1018 : : num *= 8; /* bytes to bits */
1019 : :
1020 : : if (p_UBSEC_rng_ioctl(fd,
1021 : : UBSEC_RNG_DIRECT,
1022 : : buf,
1023 : : &num) != 0)
1024 : : {
1025 : : /* Hardware's a no go, failover to software */
1026 : : const RAND_METHOD *meth;
1027 : :
1028 : : UBSECerr(UBSEC_F_UBSEC_RAND_BYTES, UBSEC_R_REQUEST_FAILED);
1029 : : p_UBSEC_ubsec_close(fd);
1030 : :
1031 : : num = p_UBSEC_ubsec_bits_to_bytes(num);
1032 : : meth = RAND_SSLeay();
1033 : : meth->seed(buf, num);
1034 : : ret = meth->bytes(buf, num);
1035 : :
1036 : : goto err;
1037 : : }
1038 : :
1039 : : p_UBSEC_ubsec_close(fd);
1040 : :
1041 : : ret = 1;
1042 : : err:
1043 : : return(ret);
1044 : : }
1045 : :
1046 : :
1047 : : static int ubsec_rand_status(void)
1048 : : {
1049 : : return 0;
1050 : : }
1051 : : #endif
1052 : :
1053 : : /* This stuff is needed if this ENGINE is being compiled into a self-contained
1054 : : * shared-library. */
1055 : : #ifndef OPENSSL_NO_DYNAMIC_ENGINE
1056 : : static int bind_fn(ENGINE *e, const char *id)
1057 : : {
1058 : : if(id && (strcmp(id, engine_ubsec_id) != 0))
1059 : : return 0;
1060 : : if(!bind_helper(e))
1061 : : return 0;
1062 : : return 1;
1063 : : }
1064 : : IMPLEMENT_DYNAMIC_CHECK_FN()
1065 : : IMPLEMENT_DYNAMIC_BIND_FN(bind_fn)
1066 : : #endif /* OPENSSL_NO_DYNAMIC_ENGINE */
1067 : :
1068 : : #endif /* !OPENSSL_NO_HW_UBSEC */
1069 : : #endif /* !OPENSSL_NO_HW */
|
