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 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 if(!ENGINE_set_id(e, engine_ubsec_id) || 214 !ENGINE_set_name(e, engine_ubsec_name) || 215 #ifndef OPENSSL_NO_RSA 216 !ENGINE_set_RSA(e, &ubsec_rsa) || 217 #endif 218 #ifndef OPENSSL_NO_DSA 219 !ENGINE_set_DSA(e, &ubsec_dsa) || 220 #endif 221 #ifndef OPENSSL_NO_DH 222 !ENGINE_set_DH(e, &ubsec_dh) || 223 #endif 224 !ENGINE_set_destroy_function(e, ubsec_destroy) || 225 !ENGINE_set_init_function(e, ubsec_init) || 226 !ENGINE_set_finish_function(e, ubsec_finish) || 227 !ENGINE_set_ctrl_function(e, ubsec_ctrl) || 228 !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 meth1 = RSA_PKCS1_SSLeay(); 240 ubsec_rsa.rsa_pub_enc = meth1->rsa_pub_enc; 241 ubsec_rsa.rsa_pub_dec = meth1->rsa_pub_dec; 242 ubsec_rsa.rsa_priv_enc = meth1->rsa_priv_enc; 243 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 meth3 = DH_OpenSSL(); 250 ubsec_dh.generate_key = meth3->generate_key; 251 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 ERR_load_UBSEC_strings(); 257 return 1; 258 } 259 260 #ifdef OPENSSL_NO_DYNAMIC_ENGINE 261 static ENGINE *engine_ubsec(void) 262 { 263 ENGINE *ret = ENGINE_new(); 264 if(!ret) 265 return NULL; 266 if(!bind_helper(ret)) 267 { 268 ENGINE_free(ret); 269 return NULL; 270 } 271 return ret; 272 } 273 274 void ENGINE_load_ubsec(void) 275 { 276 /* Copied from eng_[openssl|dyn].c */ 277 ENGINE *toadd = engine_ubsec(); 278 if(!toadd) return; 279 ENGINE_add(toadd); 280 ENGINE_free(toadd); 281 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 static const char *get_UBSEC_LIBNAME(void) 326 { 327 if(UBSEC_LIBNAME) 328 return UBSEC_LIBNAME; 329 return "ubsec"; 330 } 331 static void free_UBSEC_LIBNAME(void) 332 { 333 if(UBSEC_LIBNAME) 334 OPENSSL_free((void*)UBSEC_LIBNAME); 335 UBSEC_LIBNAME = NULL; 336 } 337 static long set_UBSEC_LIBNAME(const char *name) 338 { 339 free_UBSEC_LIBNAME(); 340 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 static int ubsec_destroy(ENGINE *e) 364 { 365 free_UBSEC_LIBNAME(); 366 ERR_unload_UBSEC_strings(); 367 return 1; 368 } 369 370 /* (de)initialisation functions. */ 371 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 int fd = 0; 393 394 if(ubsec_dso != NULL) 395 { 396 UBSECerr(UBSEC_F_UBSEC_INIT, UBSEC_R_ALREADY_LOADED); 397 goto err; 398 } 399 /* 400 * Attempt to load libubsec.so/ubsec.dll/whatever. 401 */ 402 ubsec_dso = DSO_load(NULL, get_UBSEC_LIBNAME(), NULL, 0); 403 if(ubsec_dso == NULL) 404 { 405 UBSECerr(UBSEC_F_UBSEC_INIT, UBSEC_R_DSO_FAILURE); 406 goto err; 407 } 408 409 if ( 410 !(p1 = (t_UBSEC_ubsec_bytes_to_bits *) DSO_bind_func(ubsec_dso, UBSEC_F1)) || 411 !(p2 = (t_UBSEC_ubsec_bits_to_bytes *) DSO_bind_func(ubsec_dso, UBSEC_F2)) || 412 !(p3 = (t_UBSEC_ubsec_open *) DSO_bind_func(ubsec_dso, UBSEC_F3)) || 413 !(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 DSO_bind_func(ubsec_dso, UBSEC_F5)) || 417 !(p6 = (t_UBSEC_diffie_hellman_agree_ioctl *) 418 DSO_bind_func(ubsec_dso, UBSEC_F6)) || 419 #endif 420 /* #ifndef OPENSSL_NO_RSA */ 421 !(p7 = (t_UBSEC_rsa_mod_exp_ioctl *) DSO_bind_func(ubsec_dso, UBSEC_F7)) || 422 !(p8 = (t_UBSEC_rsa_mod_exp_crt_ioctl *) DSO_bind_func(ubsec_dso, UBSEC_F8)) || 423 /* #endif */ 424 #ifndef OPENSSL_NO_DSA 425 !(p9 = (t_UBSEC_dsa_sign_ioctl *) DSO_bind_func(ubsec_dso, UBSEC_F9)) || 426 !(p10 = (t_UBSEC_dsa_verify_ioctl *) DSO_bind_func(ubsec_dso, UBSEC_F10)) || 427 #endif 428 !(p11 = (t_UBSEC_math_accelerate_ioctl *) 429 DSO_bind_func(ubsec_dso, UBSEC_F11)) || 430 !(p12 = (t_UBSEC_rng_ioctl *) DSO_bind_func(ubsec_dso, UBSEC_F12)) || 431 !(p13 = (t_UBSEC_max_key_len_ioctl *) DSO_bind_func(ubsec_dso, UBSEC_F13))) 432 { 433 UBSECerr(UBSEC_F_UBSEC_INIT, UBSEC_R_DSO_FAILURE); 434 goto err; 435 } 436 437 /* Copy the pointers */ 438 p_UBSEC_ubsec_bytes_to_bits = p1; 439 p_UBSEC_ubsec_bits_to_bytes = p2; 440 p_UBSEC_ubsec_open = p3; 441 p_UBSEC_ubsec_close = p4; 442 #ifndef OPENSSL_NO_DH 443 p_UBSEC_diffie_hellman_generate_ioctl = p5; 444 p_UBSEC_diffie_hellman_agree_ioctl = p6; 445 #endif 446 #ifndef OPENSSL_NO_RSA 447 p_UBSEC_rsa_mod_exp_ioctl = p7; 448 p_UBSEC_rsa_mod_exp_crt_ioctl = p8; 449 #endif 450 #ifndef OPENSSL_NO_DSA 451 p_UBSEC_dsa_sign_ioctl = p9; 452 p_UBSEC_dsa_verify_ioctl = p10; 453 #endif 454 p_UBSEC_math_accelerate_ioctl = p11; 455 p_UBSEC_rng_ioctl = p12; 456 p_UBSEC_max_key_len_ioctl = p13; 457 458 /* Perform an open to see if there's actually any unit running. */ 459 if (((fd = p_UBSEC_ubsec_open(UBSEC_KEY_DEVICE_NAME)) > 0) && (p_UBSEC_max_key_len_ioctl(fd, &max_key_len) == 0)) 460 { 461 p_UBSEC_ubsec_close(fd); 462 return 1; 463 } 464 else 465 { 466 UBSECerr(UBSEC_F_UBSEC_INIT, UBSEC_R_UNIT_FAILURE); 467 } 468 469 err: 470 if(ubsec_dso) 471 DSO_free(ubsec_dso); 472 ubsec_dso = NULL; 473 p_UBSEC_ubsec_bytes_to_bits = NULL; 474 p_UBSEC_ubsec_bits_to_bytes = NULL; 475 p_UBSEC_ubsec_open = NULL; 476 p_UBSEC_ubsec_close = NULL; 477 #ifndef OPENSSL_NO_DH 478 p_UBSEC_diffie_hellman_generate_ioctl = NULL; 479 p_UBSEC_diffie_hellman_agree_ioctl = NULL; 480 #endif 481 #ifndef OPENSSL_NO_RSA 482 p_UBSEC_rsa_mod_exp_ioctl = NULL; 483 p_UBSEC_rsa_mod_exp_crt_ioctl = NULL; 484 #endif 485 #ifndef OPENSSL_NO_DSA 486 p_UBSEC_dsa_sign_ioctl = NULL; 487 p_UBSEC_dsa_verify_ioctl = NULL; 488 #endif 489 p_UBSEC_math_accelerate_ioctl = NULL; 490 p_UBSEC_rng_ioctl = NULL; 491 p_UBSEC_max_key_len_ioctl = NULL; 492 493 return 0; 494 } 495 496 static int ubsec_finish(ENGINE *e) 497 { 498 free_UBSEC_LIBNAME(); 499 if(ubsec_dso == NULL) 500 { 501 UBSECerr(UBSEC_F_UBSEC_FINISH, UBSEC_R_NOT_LOADED); 502 return 0; 503 } 504 if(!DSO_free(ubsec_dso)) 505 { 506 UBSECerr(UBSEC_F_UBSEC_FINISH, UBSEC_R_DSO_FAILURE); 507 return 0; 508 } 509 ubsec_dso = NULL; 510 p_UBSEC_ubsec_bytes_to_bits = NULL; 511 p_UBSEC_ubsec_bits_to_bytes = NULL; 512 p_UBSEC_ubsec_open = NULL; 513 p_UBSEC_ubsec_close = NULL; 514 #ifndef OPENSSL_NO_DH 515 p_UBSEC_diffie_hellman_generate_ioctl = NULL; 516 p_UBSEC_diffie_hellman_agree_ioctl = NULL; 517 #endif 518 #ifndef OPENSSL_NO_RSA 519 p_UBSEC_rsa_mod_exp_ioctl = NULL; 520 p_UBSEC_rsa_mod_exp_crt_ioctl = NULL; 521 #endif 522 #ifndef OPENSSL_NO_DSA 523 p_UBSEC_dsa_sign_ioctl = NULL; 524 p_UBSEC_dsa_verify_ioctl = NULL; 525 #endif 526 p_UBSEC_math_accelerate_ioctl = NULL; 527 p_UBSEC_rng_ioctl = NULL; 528 p_UBSEC_max_key_len_ioctl = NULL; 529 return 1; 530 } 531 532 static int ubsec_ctrl(ENGINE *e, int cmd, long i, void *p, void (*f)(void)) 533 { 534 int initialised = ((ubsec_dso == NULL) ? 0 : 1); 535 switch(cmd) 536 { 537 case UBSEC_CMD_SO_PATH: 538 if(p == NULL) 539 { 540 UBSECerr(UBSEC_F_UBSEC_CTRL,ERR_R_PASSED_NULL_PARAMETER); 541 return 0; 542 } 543 if(initialised) 544 { 545 UBSECerr(UBSEC_F_UBSEC_CTRL,UBSEC_R_ALREADY_LOADED); 546 return 0; 547 } 548 return set_UBSEC_LIBNAME((const char *)p); 549 default: 550 break; 551 } 552 UBSECerr(UBSEC_F_UBSEC_CTRL,UBSEC_R_CTRL_COMMAND_NOT_IMPLEMENTED); 553 return 0; 554 } 555 556 static int ubsec_mod_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, 557 const BIGNUM *m, BN_CTX *ctx) 558 { 559 int y_len = 0; 560 int fd; 561 562 if(ubsec_dso == NULL) 563 { 564 UBSECerr(UBSEC_F_UBSEC_MOD_EXP, UBSEC_R_NOT_LOADED); 565 return 0; 566 } 567 568 /* Check if hardware can't handle this argument. */ 569 y_len = BN_num_bits(m); 570 if (y_len > max_key_len) { 571 UBSECerr(UBSEC_F_UBSEC_MOD_EXP, UBSEC_R_SIZE_TOO_LARGE_OR_TOO_SMALL); 572 return BN_mod_exp(r, a, p, m, ctx); 573 } 574 575 if(!bn_wexpand(r, m->top)) 576 { 577 UBSECerr(UBSEC_F_UBSEC_MOD_EXP, UBSEC_R_BN_EXPAND_FAIL); 578 return 0; 579 } 580 581 if ((fd = p_UBSEC_ubsec_open(UBSEC_KEY_DEVICE_NAME)) <= 0) { 582 fd = 0; 583 UBSECerr(UBSEC_F_UBSEC_MOD_EXP, UBSEC_R_UNIT_FAILURE); 584 return BN_mod_exp(r, a, p, m, ctx); 585 } 586 587 if (p_UBSEC_rsa_mod_exp_ioctl(fd, (unsigned char *)a->d, BN_num_bits(a), 588 (unsigned char *)m->d, BN_num_bits(m), (unsigned char *)p->d, 589 BN_num_bits(p), (unsigned char *)r->d, &y_len) != 0) 590 { 591 UBSECerr(UBSEC_F_UBSEC_MOD_EXP, UBSEC_R_REQUEST_FAILED); 592 p_UBSEC_ubsec_close(fd); 593 594 return BN_mod_exp(r, a, p, m, ctx); 595 } 596 597 p_UBSEC_ubsec_close(fd); 598 599 r->top = (BN_num_bits(m)+BN_BITS2-1)/BN_BITS2; 600 return 1; 601 } 602 603 #ifndef OPENSSL_NO_RSA 604 static int ubsec_rsa_mod_exp(BIGNUM *r0, const BIGNUM *I, RSA *rsa, BN_CTX *ctx) 605 { 606 int to_return = 0; 607 608 if(!rsa->p || !rsa->q || !rsa->dmp1 || !rsa->dmq1 || !rsa->iqmp) 609 { 610 UBSECerr(UBSEC_F_UBSEC_RSA_MOD_EXP, UBSEC_R_MISSING_KEY_COMPONENTS); 611 goto err; 612 } 613 614 to_return = ubsec_mod_exp_crt(r0, I, rsa->p, rsa->q, rsa->dmp1, 615 rsa->dmq1, rsa->iqmp, ctx); 616 if (to_return == FAIL_TO_SOFTWARE) 617 { 618 /* 619 * Do in software as hardware failed. 620 */ 621 const RSA_METHOD *meth = RSA_PKCS1_SSLeay(); 622 to_return = (*meth->rsa_mod_exp)(r0, I, rsa, ctx); 623 } 624 err: 625 return to_return; 626 } 627 628 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 y_len = BN_num_bits(p) + BN_num_bits(q); 636 637 /* Check if hardware can't handle this argument. */ 638 if (y_len > max_key_len) { 639 UBSECerr(UBSEC_F_UBSEC_MOD_EXP_CRT, UBSEC_R_SIZE_TOO_LARGE_OR_TOO_SMALL); 640 return FAIL_TO_SOFTWARE; 641 } 642 643 if (!bn_wexpand(r, p->top + q->top + 1)) { 644 UBSECerr(UBSEC_F_UBSEC_MOD_EXP_CRT, UBSEC_R_BN_EXPAND_FAIL); 645 return 0; 646 } 647 648 if ((fd = p_UBSEC_ubsec_open(UBSEC_KEY_DEVICE_NAME)) <= 0) { 649 fd = 0; 650 UBSECerr(UBSEC_F_UBSEC_MOD_EXP_CRT, UBSEC_R_UNIT_FAILURE); 651 return FAIL_TO_SOFTWARE; 652 } 653 654 if (p_UBSEC_rsa_mod_exp_crt_ioctl(fd, 655 (unsigned char *)a->d, BN_num_bits(a), 656 (unsigned char *)qinv->d, BN_num_bits(qinv), 657 (unsigned char *)dp->d, BN_num_bits(dp), 658 (unsigned char *)p->d, BN_num_bits(p), 659 (unsigned char *)dq->d, BN_num_bits(dq), 660 (unsigned char *)q->d, BN_num_bits(q), 661 (unsigned char *)r->d, &y_len) != 0) { 662 UBSECerr(UBSEC_F_UBSEC_MOD_EXP_CRT, UBSEC_R_REQUEST_FAILED); 663 p_UBSEC_ubsec_close(fd); 664 return FAIL_TO_SOFTWARE; 665 } 666 667 p_UBSEC_ubsec_close(fd); 668 669 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 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 int ret = 0; 714 715 /* Do in software if the key is too large for the hardware. */ 716 if (BN_num_bits(m) > max_key_len) 717 { 718 const RSA_METHOD *meth = RSA_PKCS1_SSLeay(); 719 ret = (*meth->bn_mod_exp)(r, a, p, m, ctx, m_ctx); 720 } 721 else 722 { 723 ret = ubsec_mod_exp(r, a, p, m, ctx); 724 } 725 726 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 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 return ubsec_mod_exp(r, a, p, m, ctx); 737 } 738 #endif 739 740 #ifndef OPENSSL_NO_DSA 741 static DSA_SIG *ubsec_dsa_do_sign(const unsigned char *dgst, int dlen, DSA *dsa) 742 { 743 DSA_SIG *to_return = NULL; 744 int s_len = 160, r_len = 160, d_len, fd; 745 BIGNUM m, *r=NULL, *s=NULL; 746 747 BN_init(&m); 748 749 s = BN_new(); 750 r = BN_new(); 751 if ((s == NULL) || (r==NULL)) 752 goto err; 753 754 d_len = p_UBSEC_ubsec_bytes_to_bits((unsigned char *)dgst, dlen); 755 756 if(!bn_wexpand(r, (160+BN_BITS2-1)/BN_BITS2) || 757 (!bn_wexpand(s, (160+BN_BITS2-1)/BN_BITS2))) { 758 UBSECerr(UBSEC_F_UBSEC_DSA_DO_SIGN, UBSEC_R_BN_EXPAND_FAIL); 759 goto err; 760 } 761 762 if (BN_bin2bn(dgst,dlen,&m) == NULL) { 763 UBSECerr(UBSEC_F_UBSEC_DSA_DO_SIGN, UBSEC_R_BN_EXPAND_FAIL); 764 goto err; 765 } 766 767 if ((fd = p_UBSEC_ubsec_open(UBSEC_KEY_DEVICE_NAME)) <= 0) { 768 const DSA_METHOD *meth; 769 fd = 0; 770 UBSECerr(UBSEC_F_UBSEC_DSA_DO_SIGN, UBSEC_R_UNIT_FAILURE); 771 meth = DSA_OpenSSL(); 772 to_return = meth->dsa_do_sign(dgst, dlen, dsa); 773 goto err; 774 } 775 776 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 (unsigned char *)dsa->p->d, BN_num_bits(dsa->p), 780 (unsigned char *)dsa->q->d, BN_num_bits(dsa->q), 781 (unsigned char *)dsa->g->d, BN_num_bits(dsa->g), 782 (unsigned char *)dsa->priv_key->d, BN_num_bits(dsa->priv_key), 783 (unsigned char *)r->d, &r_len, 784 (unsigned char *)s->d, &s_len ) != 0) { 785 const DSA_METHOD *meth; 786 787 UBSECerr(UBSEC_F_UBSEC_DSA_DO_SIGN, UBSEC_R_REQUEST_FAILED); 788 p_UBSEC_ubsec_close(fd); 789 meth = DSA_OpenSSL(); 790 to_return = meth->dsa_do_sign(dgst, dlen, dsa); 791 792 goto err; 793 } 794 795 p_UBSEC_ubsec_close(fd); 796 797 r->top = (160+BN_BITS2-1)/BN_BITS2; 798 s->top = (160+BN_BITS2-1)/BN_BITS2; 799 800 to_return = DSA_SIG_new(); 801 if(to_return == NULL) { 802 UBSECerr(UBSEC_F_UBSEC_DSA_DO_SIGN, UBSEC_R_BN_EXPAND_FAIL); 803 goto err; 804 } 805 806 to_return->r = r; 807 to_return->s = s; 808 809 err: 810 if (!to_return) { 811 if (r) BN_free(r); 812 if (s) BN_free(s); 813 } 814 BN_clear_free(&m); 815 return to_return; 816 } 817 818 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 int to_return = 0; 823 int fd; 824 BIGNUM v, *pv = &v; 825 826 BN_init(&v); 827 828 if(!bn_wexpand(pv, dsa->p->top)) { 829 UBSECerr(UBSEC_F_UBSEC_DSA_VERIFY, UBSEC_R_BN_EXPAND_FAIL); 830 goto err; 831 } 832 833 v_len = BN_num_bits(dsa->p); 834 835 d_len = p_UBSEC_ubsec_bytes_to_bits((unsigned char *)dgst, dgst_len); 836 837 if ((fd = p_UBSEC_ubsec_open(UBSEC_KEY_DEVICE_NAME)) <= 0) { 838 const DSA_METHOD *meth; 839 fd = 0; 840 UBSECerr(UBSEC_F_UBSEC_DSA_VERIFY, UBSEC_R_UNIT_FAILURE); 841 meth = DSA_OpenSSL(); 842 to_return = meth->dsa_do_verify(dgst, dgst_len, sig, dsa); 843 goto err; 844 } 845 846 if (p_UBSEC_dsa_verify_ioctl(fd, 0, /* compute hash before signing */ 847 (unsigned char *)dgst, d_len, 848 (unsigned char *)dsa->p->d, BN_num_bits(dsa->p), 849 (unsigned char *)dsa->q->d, BN_num_bits(dsa->q), 850 (unsigned char *)dsa->g->d, BN_num_bits(dsa->g), 851 (unsigned char *)dsa->pub_key->d, BN_num_bits(dsa->pub_key), 852 (unsigned char *)sig->r->d, BN_num_bits(sig->r), 853 (unsigned char *)sig->s->d, BN_num_bits(sig->s), 854 (unsigned char *)v.d, &v_len) != 0) { 855 const DSA_METHOD *meth; 856 UBSECerr(UBSEC_F_UBSEC_DSA_VERIFY, UBSEC_R_REQUEST_FAILED); 857 p_UBSEC_ubsec_close(fd); 858 859 meth = DSA_OpenSSL(); 860 to_return = meth->dsa_do_verify(dgst, dgst_len, sig, dsa); 861 862 goto err; 863 } 864 865 p_UBSEC_ubsec_close(fd); 866 867 to_return = 1; 868 err: 869 BN_clear_free(&v); 870 return to_return; 871 } 872 #endif 873 874 #ifndef OPENSSL_NO_DH 875 static int ubsec_dh_compute_key(unsigned char *key,const BIGNUM *pub_key,DH *dh) 876 { 877 int ret = -1, 878 k_len, 879 fd; 880 881 k_len = BN_num_bits(dh->p); 882 883 if ((fd = p_UBSEC_ubsec_open(UBSEC_KEY_DEVICE_NAME)) <= 0) 884 { 885 const DH_METHOD *meth; 886 UBSECerr(UBSEC_F_UBSEC_DH_COMPUTE_KEY, UBSEC_R_UNIT_FAILURE); 887 meth = DH_OpenSSL(); 888 ret = meth->compute_key(key, pub_key, dh); 889 goto err; 890 } 891 892 if (p_UBSEC_diffie_hellman_agree_ioctl(fd, 893 (unsigned char *)dh->priv_key->d, BN_num_bits(dh->priv_key), 894 (unsigned char *)pub_key->d, BN_num_bits(pub_key), 895 (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 UBSECerr(UBSEC_F_UBSEC_DH_COMPUTE_KEY, UBSEC_R_REQUEST_FAILED); 901 p_UBSEC_ubsec_close(fd); 902 903 meth = DH_OpenSSL(); 904 ret = meth->compute_key(key, pub_key, dh); 905 906 goto err; 907 } 908 909 p_UBSEC_ubsec_close(fd); 910 911 ret = p_UBSEC_ubsec_bits_to_bytes(k_len); 912 err: 913 return ret; 914 } 915 916 static int ubsec_dh_generate_key(DH *dh) 917 { 918 int ret = 0, 919 random_bits = 0, 920 pub_key_len = 0, 921 priv_key_len = 0, 922 fd; 923 BIGNUM *pub_key = NULL; 924 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 if (dh->priv_key == NULL) 932 { 933 priv_key = BN_new(); 934 if (priv_key == NULL) goto err; 935 priv_key_len = BN_num_bits(dh->p); 936 if(bn_wexpand(priv_key, dh->p->top) == NULL) goto err; 937 do 938 if (!BN_rand_range(priv_key, dh->p)) goto err; 939 while (BN_is_zero(priv_key)); 940 random_bits = BN_num_bits(priv_key); 941 } 942 else 943 { 944 priv_key = dh->priv_key; 945 } 946 947 if (dh->pub_key == NULL) 948 { 949 pub_key = BN_new(); 950 pub_key_len = BN_num_bits(dh->p); 951 if(bn_wexpand(pub_key, dh->p->top) == NULL) goto err; 952 if(pub_key == NULL) goto err; 953 } 954 else 955 { 956 pub_key = dh->pub_key; 957 } 958 959 if ((fd = p_UBSEC_ubsec_open(UBSEC_KEY_DEVICE_NAME)) <= 0) 960 { 961 const DH_METHOD *meth; 962 UBSECerr(UBSEC_F_UBSEC_DH_GENERATE_KEY, UBSEC_R_UNIT_FAILURE); 963 meth = DH_OpenSSL(); 964 ret = meth->generate_key(dh); 965 goto err; 966 } 967 968 if (p_UBSEC_diffie_hellman_generate_ioctl(fd, 969 (unsigned char *)priv_key->d, &priv_key_len, 970 (unsigned char *)pub_key->d, &pub_key_len, 971 (unsigned char *)dh->g->d, BN_num_bits(dh->g), 972 (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 UBSECerr(UBSEC_F_UBSEC_DH_GENERATE_KEY, UBSEC_R_REQUEST_FAILED); 979 p_UBSEC_ubsec_close(fd); 980 981 meth = DH_OpenSSL(); 982 ret = meth->generate_key(dh); 983 984 goto err; 985 } 986 987 p_UBSEC_ubsec_close(fd); 988 989 dh->pub_key = pub_key; 990 dh->pub_key->top = (pub_key_len + BN_BITS2-1) / BN_BITS2; 991 dh->priv_key = priv_key; 992 dh->priv_key->top = (priv_key_len + BN_BITS2-1) / BN_BITS2; 993 994 ret = 1; 995 err: 996 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 */ 1070