hw_cluster_labs.c revision 296465
1/* crypto/engine/hw_cluster_labs.c */ 2/* 3 * Written by Jan Tschirschwitz (jan.tschirschwitz@cluster-labs.com for the 4 * OpenSSL project 2000. 5 */ 6/* ==================================================================== 7 * Copyright (c) 1999 The OpenSSL Project. All rights reserved. 8 * 9 * Redistribution and use in source and binary forms, with or without 10 * modification, are permitted provided that the following conditions 11 * are met: 12 * 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 16 * 2. Redistributions in binary form must reproduce the above copyright 17 * notice, this list of conditions and the following disclaimer in 18 * the documentation and/or other materials provided with the 19 * distribution. 20 * 21 * 3. All advertising materials mentioning features or use of this 22 * software must display the following acknowledgment: 23 * "This product includes software developed by the OpenSSL Project 24 * for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)" 25 * 26 * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to 27 * endorse or promote products derived from this software without 28 * prior written permission. For written permission, please contact 29 * licensing@OpenSSL.org. 30 * 31 * 5. Products derived from this software may not be called "OpenSSL" 32 * nor may "OpenSSL" appear in their names without prior written 33 * permission of the OpenSSL Project. 34 * 35 * 6. Redistributions of any form whatsoever must retain the following 36 * acknowledgment: 37 * "This product includes software developed by the OpenSSL Project 38 * for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)" 39 * 40 * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY 41 * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 42 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 43 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR 44 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 45 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 46 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 47 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 48 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 49 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 50 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED 51 * OF THE POSSIBILITY OF SUCH DAMAGE. 52 * ==================================================================== 53 * 54 * This product includes cryptographic software written by Eric Young 55 * (eay@cryptsoft.com). This product includes software written by Tim 56 * Hudson (tjh@cryptsoft.com). 57 * 58 */ 59 60#define MSC_VER /* only used cryptic.h */ 61 62#include <stdio.h> 63#include <openssl/crypto.h> 64#include <openssl/dso.h> 65#include <openssl/des.h> 66#include <openssl/engine.h> 67 68#ifndef NO_HW 69# ifndef NO_HW_CLUSTER_LABS 70 71# ifdef FLAT_INC 72# include "cluster_labs.h" 73# else 74# include "vendor_defns/cluster_labs.h" 75# endif 76 77# define CL_LIB_NAME "cluster_labs engine" 78# include "hw_cluster_labs_err.c" 79 80static int cluster_labs_destroy(ENGINE *e); 81static int cluster_labs_init(ENGINE *e); 82static int cluster_labs_finish(ENGINE *e); 83static int cluster_labs_ctrl(ENGINE *e, int cmd, long i, void *p, 84 void (*f) ()); 85 86/* BIGNUM stuff */ 87/* This function is aliased to mod_exp (with the mont stuff dropped). */ 88static int cluster_labs_mod_exp_mont(BIGNUM *r, const BIGNUM *a, 89 const BIGNUM *p, const BIGNUM *m, 90 BN_CTX *ctx, BN_MONT_CTX *m_ctx); 91 92/* RSA stuff */ 93# ifndef OPENSSL_NO_RSA 94static int cluster_labs_rsa_pub_enc(int flen, const unsigned char *from, 95 unsigned char *to, RSA *rsa, int padding); 96static int cluster_labs_rsa_pub_dec(int flen, const unsigned char *from, 97 unsigned char *to, RSA *rsa, int padding); 98static int cluster_labs_rsa_priv_enc(int flen, const unsigned char *from, 99 unsigned char *to, RSA *rsa, 100 int padding); 101static int cluster_labs_rsa_priv_dec(int flen, const unsigned char *from, 102 unsigned char *to, RSA *rsa, 103 int padding); 104static int cluster_labs_rsa_mod_exp(BIGNUM *r0, const BIGNUM *I, RSA *rsa); 105# endif 106 107/* DSA stuff */ 108# ifndef OPENSSL_NO_DSA 109static DSA_SIG *cluster_labs_dsa_sign(const unsigned char *dgst, int dlen, 110 DSA *dsa); 111static int cluster_labs_dsa_verify(const unsigned char *dgst, int dgst_len, 112 DSA_SIG *sig, DSA *dsa); 113static int cluster_labs_dsa_mod_exp(DSA *dsa, BIGNUM *rr, BIGNUM *a1, 114 BIGNUM *p1, BIGNUM *a2, BIGNUM *p2, 115 BIGNUM *m, BN_CTX *ctx, 116 BN_MONT_CTX *in_mont); 117static int cluster_labs_mod_exp_dsa(DSA *dsa, BIGNUM *r, BIGNUM *a, 118 const BIGNUM *p, const BIGNUM *m, 119 BN_CTX *ctx, BN_MONT_CTX *m_ctx); 120# endif 121 122/* DH stuff */ 123# ifndef OPENSSL_NO_DH 124/* This function is alised to mod_exp (with the DH and mont dropped). */ 125static int cluster_labs_mod_exp_dh(const DH *dh, BIGNUM *r, const BIGNUM *a, 126 const BIGNUM *p, const BIGNUM *m, 127 BN_CTX *ctx, BN_MONT_CTX *m_ctx); 128# endif 129 130/* RANDOM stuff */ 131static int cluster_labs_rand_bytes(unsigned char *buf, int num); 132 133/* The definitions for control commands specific to this engine */ 134# define CLUSTER_LABS_CMD_SO_PATH ENGINE_CMD_BASE 135static const ENGINE_CMD_DEFN cluster_labs_cmd_defns[] = { 136 {CLUSTER_LABS_CMD_SO_PATH, 137 "SO_PATH", 138 "Specifies the path to the 'cluster labs' shared library", 139 ENGINE_CMD_FLAG_STRING}, 140 {0, NULL, NULL, 0} 141}; 142 143/* Our internal RSA_METHOD that we provide pointers to */ 144# ifndef OPENSSL_NO_RSA 145static RSA_METHOD cluster_labs_rsa = { 146 "Cluster Labs RSA method", 147 cluster_labs_rsa_pub_enc, /* rsa_pub_enc */ 148 cluster_labs_rsa_pub_dec, /* rsa_pub_dec */ 149 cluster_labs_rsa_priv_enc, /* rsa_priv_enc */ 150 cluster_labs_rsa_priv_dec, /* rsa_priv_dec */ 151 cluster_labs_rsa_mod_exp, /* rsa_mod_exp */ 152 cluster_labs_mod_exp_mont, /* bn_mod_exp */ 153 NULL, /* init */ 154 NULL, /* finish */ 155 0, /* flags */ 156 NULL, /* apps_data */ 157 NULL, /* rsa_sign */ 158 NULL /* rsa_verify */ 159}; 160# endif 161 162/* Our internal DSA_METHOD that we provide pointers to */ 163# ifndef OPENSSL_NO_DSA 164static DSA_METHOD cluster_labs_dsa = { 165 "Cluster Labs DSA method", 166 cluster_labs_dsa_sign, /* dsa_do_sign */ 167 NULL, /* dsa_sign_setup */ 168 cluster_labs_dsa_verify, /* dsa_do_verify */ 169 cluster_labs_dsa_mod_exp, /* dsa_mod_exp */ 170 cluster_labs_mod_exp_dsa, /* bn_mod_exp */ 171 NULL, /* init */ 172 NULL, /* finish */ 173 0, /* flags */ 174 NULL /* app_data */ 175}; 176# endif 177 178/* Our internal DH_METHOD that we provide pointers to */ 179# ifndef OPENSSL_NO_DH 180static DH_METHOD cluster_labs_dh = { 181 "Cluster Labs DH method", 182 NULL, /* generate key */ 183 NULL, /* compute key */ 184 cluster_labs_mod_exp_dh, /* bn_mod_exp */ 185 NULL, /* init */ 186 NULL, /* finish */ 187 0, /* flags */ 188 NULL /* app_data */ 189}; 190# endif 191 192static RAND_METHOD cluster_labs_rand = { 193 /* "Cluster Labs RAND method", */ 194 NULL, /* seed */ 195 cluster_labs_rand_bytes, /* bytes */ 196 NULL, /* cleanup */ 197 NULL, /* add */ 198 cluster_labs_rand_bytes, /* pseudorand */ 199 NULL, /* status */ 200}; 201 202static const char *engine_cluster_labs_id = "cluster_labs"; 203static const char *engine_cluster_labs_name = 204 "Cluster Labs hardware engine support"; 205 206/* engine implementation */ 207/* ---------------------*/ 208static int bind_helper(ENGINE *e) 209{ 210 211 if (!ENGINE_set_id(e, engine_cluster_labs_id) || 212 !ENGINE_set_name(e, engine_cluster_labs_name) || 213# ifndef OPENSSL_NO_RSA 214 !ENGINE_set_RSA(e, &cluster_labs_rsa) || 215# endif 216# ifndef OPENSSL_NO_DSA 217 !ENGINE_set_DSA(e, &cluster_labs_dsa) || 218# endif 219# ifndef OPENSSL_NO_DH 220 !ENGINE_set_DH(e, &cluster_labs_dh) || 221# endif 222 !ENGINE_set_RAND(e, &cluster_labs_rand) || 223 !ENGINE_set_destroy_function(e, cluster_labs_destroy) || 224 !ENGINE_set_init_function(e, cluster_labs_init) || 225 !ENGINE_set_finish_function(e, cluster_labs_finish) || 226 !ENGINE_set_ctrl_function(e, cluster_labs_ctrl) || 227 !ENGINE_set_cmd_defns(e, cluster_labs_cmd_defns)) 228 return 0; 229 /* Ensure the error handling is set up */ 230 ERR_load_CL_strings(); 231 return 1; 232} 233 234# ifndef ENGINE_DYNAMIC_SUPPORT 235static ENGINE *engine_cluster_labs(void) 236{ 237 ENGINE *ret = ENGINE_new(); 238 239 if (!ret) 240 return NULL; 241 if (!bind_helper(ret)) { 242 ENGINE_free(ret); 243 return NULL; 244 } 245 return ret; 246} 247 248# ifdef ENGINE_DYNAMIC_SUPPORT 249static 250# endif 251void ENGINE_load_cluster_labs(void) 252{ 253 254 ENGINE *cluster_labs = engine_cluster_labs(); 255 256 if (!cluster_labs) 257 return; 258 ENGINE_add(cluster_labs); 259 ENGINE_free(cluster_labs); 260 ERR_clear_error(); 261} 262# endif /* !ENGINE_DYNAMIC_SUPPORT */ 263 264static int cluster_labs_destroy(ENGINE *e) 265{ 266 267 ERR_unload_CL_strings(); 268 return 1; 269} 270 271/* 272 * This is a process-global DSO handle used for loading and unloading the 273 * Cluster Labs library. NB: This is only set (or unset) during an init() or 274 * finish() call (reference counts permitting) and they're operating with 275 * global locks, so this should be thread-safe implicitly. 276 */ 277static DSO *cluster_labs_dso = NULL; 278 279/* 280 * These are the function pointers that are (un)set when the library has 281 * successfully (un)loaded. 282 */ 283static cl_engine_init *p_cl_engine_init = NULL; 284static cl_mod_exp *p_cl_mod_exp = NULL; 285static cl_mod_exp_crt *p_cl_mod_exp_crt = NULL; 286static cl_rsa_mod_exp *p_cl_rsa_mod_exp = NULL; 287static cl_rsa_priv_enc *p_cl_rsa_priv_enc = NULL; 288static cl_rsa_priv_dec *p_cl_rsa_priv_dec = NULL; 289static cl_rsa_pub_enc *p_cl_rsa_pub_enc = NULL; 290static cl_rsa_pub_dec *p_cl_rsa_pub_dec = NULL; 291static cl_rand_bytes *p_cl_rand_bytes = NULL; 292static cl_dsa_sign *p_cl_dsa_sign = NULL; 293static cl_dsa_verify *p_cl_dsa_verify = NULL; 294 295int cluster_labs_init(ENGINE *e) 296{ 297 298 cl_engine_init *p1; 299 cl_mod_exp *p2; 300 cl_mod_exp_crt *p3; 301 cl_rsa_mod_exp *p4; 302 cl_rsa_priv_enc *p5; 303 cl_rsa_priv_dec *p6; 304 cl_rsa_pub_enc *p7; 305 cl_rsa_pub_dec *p8; 306 cl_rand_bytes *p20; 307 cl_dsa_sign *p30; 308 cl_dsa_verify *p31; 309 310 /* engine already loaded */ 311 if (cluster_labs_dso != NULL) { 312 CLerr(CL_F_CLUSTER_LABS_INIT, CL_R_ALREADY_LOADED); 313 goto err; 314 } 315 /* try to load engine */ 316 cluster_labs_dso = DSO_load(NULL, CLUSTER_LABS_LIB_NAME, NULL, 0); 317 if (cluster_labs_dso == NULL) { 318 CLerr(CL_F_CLUSTER_LABS_INIT, CL_R_DSO_FAILURE); 319 goto err; 320 } 321 /* bind functions */ 322 if (! 323 (p1 = 324 (cl_engine_init *) DSO_bind_func(cluster_labs_dso, CLUSTER_LABS_F1)) 325|| !(p2 = (cl_mod_exp *) DSO_bind_func(cluster_labs_dso, CLUSTER_LABS_F2)) 326|| !(p3 = (cl_mod_exp_crt *) DSO_bind_func(cluster_labs_dso, CLUSTER_LABS_F3)) 327|| !(p4 = (cl_rsa_mod_exp *) DSO_bind_func(cluster_labs_dso, CLUSTER_LABS_F4)) 328|| !(p5 = 329 (cl_rsa_priv_enc *) DSO_bind_func(cluster_labs_dso, CLUSTER_LABS_F5)) 330|| !(p6 = 331 (cl_rsa_priv_dec *) DSO_bind_func(cluster_labs_dso, CLUSTER_LABS_F6)) 332|| !(p7 = (cl_rsa_pub_enc *) DSO_bind_func(cluster_labs_dso, CLUSTER_LABS_F7)) 333|| !(p8 = (cl_rsa_pub_dec *) DSO_bind_func(cluster_labs_dso, CLUSTER_LABS_F8)) 334|| !(p20 = 335 (cl_rand_bytes *) DSO_bind_func(cluster_labs_dso, CLUSTER_LABS_F20)) 336|| !(p30 = (cl_dsa_sign *) DSO_bind_func(cluster_labs_dso, CLUSTER_LABS_F30)) 337|| !(p31 = 338 (cl_dsa_verify *) DSO_bind_func(cluster_labs_dso, CLUSTER_LABS_F31))) { 339 CLerr(CL_F_CLUSTER_LABS_INIT, CL_R_DSO_FAILURE); 340 goto err; 341 } 342 343 /* copy function pointers */ 344 p_cl_engine_init = p1; 345 p_cl_mod_exp = p2; 346 p_cl_mod_exp_crt = p3; 347 p_cl_rsa_mod_exp = p4; 348 p_cl_rsa_priv_enc = p5; 349 p_cl_rsa_priv_dec = p6; 350 p_cl_rsa_pub_enc = p7; 351 p_cl_rsa_pub_dec = p8; 352 p_cl_rand_bytes = p20; 353 p_cl_dsa_sign = p30; 354 p_cl_dsa_verify = p31; 355 356 /* cluster labs engine init */ 357 if (p_cl_engine_init() == 0) { 358 CLerr(CL_F_CLUSTER_LABS_INIT, CL_R_INIT_FAILED); 359 goto err; 360 } 361 362 return (1); 363 364 err: 365 /* reset all pointers */ 366 if (cluster_labs_dso) 367 DSO_free(cluster_labs_dso); 368 369 cluster_labs_dso = NULL; 370 p_cl_engine_init = NULL; 371 p_cl_mod_exp = NULL; 372 p_cl_mod_exp_crt = NULL; 373 p_cl_rsa_mod_exp = NULL; 374 p_cl_rsa_priv_enc = NULL; 375 p_cl_rsa_priv_dec = NULL; 376 p_cl_rsa_pub_enc = NULL; 377 p_cl_rsa_pub_dec = NULL; 378 p_cl_rand_bytes = NULL; 379 p_cl_dsa_sign = NULL; 380 p_cl_dsa_verify = NULL; 381 382 return (0); 383} 384 385static int cluster_labs_finish(ENGINE *e) 386{ 387 388 if (cluster_labs_dso == NULL) { 389 CLerr(CL_F_CLUSTER_LABS_FINISH, CL_R_NOT_LOADED); 390 return 0; 391 } 392 if (!DSO_free(cluster_labs_dso)) { 393 CLerr(CL_F_CLUSTER_LABS_FINISH, CL_R_DSO_FAILURE); 394 return 0; 395 } 396 397 cluster_labs_dso = NULL; 398 p_cl_engine_init = NULL; 399 p_cl_mod_exp = NULL; 400 p_cl_rsa_mod_exp = NULL; 401 p_cl_mod_exp_crt = NULL; 402 p_cl_rsa_priv_enc = NULL; 403 p_cl_rsa_priv_dec = NULL; 404 p_cl_rsa_pub_enc = NULL; 405 p_cl_rsa_pub_dec = NULL; 406 p_cl_rand_bytes = NULL; 407 p_cl_dsa_sign = NULL; 408 p_cl_dsa_verify = NULL; 409 410 return (1); 411 412} 413 414static int cluster_labs_ctrl(ENGINE *e, int cmd, long i, void *p, 415 void (*f) ()) 416{ 417 int initialised = ((cluster_labs_dso == NULL) ? 0 : 1); 418 419 switch (cmd) { 420 case CLUSTER_LABS_CMD_SO_PATH: 421 if (p == NULL) { 422 CLerr(CL_F_CLUSTER_LABS_CTRL, ERR_R_PASSED_NULL_PARAMETER); 423 return 0; 424 } 425 if (initialised) { 426 CLerr(CL_F_CLUSTER_LABS_CTRL, CL_R_ALREADY_LOADED); 427 return 0; 428 } 429 CLUSTER_LABS_LIB_NAME = (const char *)p; 430 return 1; 431 default: 432 break; 433 } 434 CLerr(CL_F_CLUSTER_LABS_CTRL, CL_R_COMMAND_NOT_IMPLEMENTED); 435 return 0; 436} 437 438static int cluster_labs_mod_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, 439 const BIGNUM *m, BN_CTX *ctx) 440{ 441 442 if (cluster_labs_dso == NULL) { 443 CLerr(CL_F_CLUSTER_LABS_MOD_EXP, CL_R_NOT_LOADED); 444 return 0; 445 } 446 if (p_cl_mod_exp == NULL) { 447 CLerr(CL_F_CLUSTER_LABS_MOD_EXP, CL_R_FUNCTION_NOT_BINDED); 448 return 0; 449 } 450 451 return p_cl_mod_exp(r, a, p, m, ctx); 452 453} 454 455static int cluster_labs_mod_exp_crt(BIGNUM *r, BIGNUM *a, const BIGNUM *p, 456 const BIGNUM *q, const BIGNUM *dmp1, 457 const BIGNUM *dmq1, const BIGNUM *iqmp, 458 BN_CTX *ctx) 459{ 460 461 if (cluster_labs_dso == NULL) { 462 CLerr(CL_F_CLUSTER_LABS_MOD_EXP_CRT, CL_R_NOT_LOADED); 463 return 0; 464 } 465 if (p_cl_mod_exp_crt == NULL) { 466 CLerr(CL_F_CLUSTER_LABS_MOD_EXP_CRT, CL_R_FUNCTION_NOT_BINDED); 467 return 0; 468 } 469 470 return p_cl_mod_exp_crt(r, a, p, q, dmp1, dmq1, iqmp, ctx); 471 472} 473 474static int cluster_labs_rsa_mod_exp(BIGNUM *r0, const BIGNUM *I, RSA *rsa) 475{ 476 477 if (cluster_labs_dso == NULL) { 478 CLerr(CL_F_CLUSTER_LABS_RSA_MOD_EXP, CL_R_NOT_LOADED); 479 return 0; 480 } 481 if (p_cl_rsa_mod_exp == NULL) { 482 CLerr(CL_F_CLUSTER_LABS_RSA_MOD_EXP, CL_R_FUNCTION_NOT_BINDED); 483 return 0; 484 } 485 486 return p_cl_rsa_mod_exp(r0, I, rsa); 487 488} 489 490static DSA_SIG *cluster_labs_dsa_sign(const unsigned char *dgst, int dlen, 491 DSA *dsa) 492{ 493 494 if (cluster_labs_dso == NULL) { 495 CLerr(CL_F_CLUSTER_LABS_DSA_SIGN, CL_R_NOT_LOADED); 496 return 0; 497 } 498 if (p_cl_dsa_sign == NULL) { 499 CLerr(CL_F_CLUSTER_LABS_DSA_SIGN, CL_R_FUNCTION_NOT_BINDED); 500 return 0; 501 } 502 503 return p_cl_dsa_sign(dgst, dlen, dsa); 504 505} 506 507static int cluster_labs_dsa_verify(const unsigned char *dgst, int dgst_len, 508 DSA_SIG *sig, DSA *dsa) 509{ 510 511 if (cluster_labs_dso == NULL) { 512 CLerr(CL_F_CLUSTER_LABS_DSA_VERIFY, CL_R_NOT_LOADED); 513 return 0; 514 } 515 516 if (p_cl_dsa_verify == NULL) { 517 CLerr(CL_F_CLUSTER_LABS_DSA_VERIFY, CL_R_FUNCTION_NOT_BINDED); 518 return 0; 519 } 520 521 return p_cl_dsa_verify(dgst, dgst_len, sig, dsa); 522 523} 524 525static int cluster_labs_dsa_mod_exp(DSA *dsa, BIGNUM *rr, BIGNUM *a1, 526 BIGNUM *p1, BIGNUM *a2, BIGNUM *p2, 527 BIGNUM *m, BN_CTX *ctx, 528 BN_MONT_CTX *in_mont) 529{ 530 BIGNUM t; 531 int status = 0; 532 533 BN_init(&t); 534 /* let rr = a1 ^ p1 mod m */ 535 if (!cluster_labs_mod_exp(rr, a1, p1, m, ctx)) 536 goto end; 537 /* let t = a2 ^ p2 mod m */ 538 if (!cluster_labs_mod_exp(&t, a2, p2, m, ctx)) 539 goto end; 540 /* let rr = rr * t mod m */ 541 if (!BN_mod_mul(rr, rr, &t, m, ctx)) 542 goto end; 543 status = 1; 544 end: 545 BN_free(&t); 546 547 return (1); 548 549} 550 551static int cluster_labs_mod_exp_dsa(DSA *dsa, BIGNUM *r, BIGNUM *a, 552 const BIGNUM *p, const BIGNUM *m, 553 BN_CTX *ctx, BN_MONT_CTX *m_ctx) 554{ 555 return cluster_labs_mod_exp(r, a, p, m, ctx); 556} 557 558/* This function is aliased to mod_exp (with the mont stuff dropped). */ 559static int cluster_labs_mod_exp_mont(BIGNUM *r, const BIGNUM *a, 560 const BIGNUM *p, const BIGNUM *m, 561 BN_CTX *ctx, BN_MONT_CTX *m_ctx) 562{ 563 return cluster_labs_mod_exp(r, a, p, m, ctx); 564} 565 566/* This function is aliased to mod_exp (with the dh and mont dropped). */ 567static int cluster_labs_mod_exp_dh(const DH *dh, BIGNUM *r, const BIGNUM *a, 568 const BIGNUM *p, const BIGNUM *m, 569 BN_CTX *ctx, BN_MONT_CTX *m_ctx) 570{ 571 return cluster_labs_mod_exp(r, a, p, m, ctx); 572} 573 574static int cluster_labs_rsa_pub_enc(int flen, const unsigned char *from, 575 unsigned char *to, RSA *rsa, int padding) 576{ 577 578 if (cluster_labs_dso == NULL) { 579 CLerr(CL_F_CLUSTER_LABS_RSA_PUB_ENC, CL_R_NOT_LOADED); 580 return 0; 581 } 582 if (p_cl_rsa_priv_enc == NULL) { 583 CLerr(CL_F_CLUSTER_LABS_RSA_PUB_ENC, CL_R_FUNCTION_NOT_BINDED); 584 return 0; 585 } 586 587 return p_cl_rsa_pub_enc(flen, from, to, rsa, padding); 588 589} 590 591static int cluster_labs_rsa_pub_dec(int flen, const unsigned char *from, 592 unsigned char *to, RSA *rsa, int padding) 593{ 594 595 if (cluster_labs_dso == NULL) { 596 CLerr(CL_F_CLUSTER_LABS_RSA_PUB_DEC, CL_R_NOT_LOADED); 597 return 0; 598 } 599 if (p_cl_rsa_priv_enc == NULL) { 600 CLerr(CL_F_CLUSTER_LABS_RSA_PUB_DEC, CL_R_FUNCTION_NOT_BINDED); 601 return 0; 602 } 603 604 return p_cl_rsa_pub_dec(flen, from, to, rsa, padding); 605 606} 607 608static int cluster_labs_rsa_priv_enc(int flen, const unsigned char *from, 609 unsigned char *to, RSA *rsa, int padding) 610{ 611 612 if (cluster_labs_dso == NULL) { 613 CLerr(CL_F_CLUSTER_LABS_RSA_PRIV_ENC, CL_R_NOT_LOADED); 614 return 0; 615 } 616 617 if (p_cl_rsa_priv_enc == NULL) { 618 CLerr(CL_F_CLUSTER_LABS_RSA_PRIV_ENC, CL_R_FUNCTION_NOT_BINDED); 619 return 0; 620 } 621 622 return p_cl_rsa_priv_enc(flen, from, to, rsa, padding); 623 624} 625 626static int cluster_labs_rsa_priv_dec(int flen, const unsigned char *from, 627 unsigned char *to, RSA *rsa, int padding) 628{ 629 630 if (cluster_labs_dso == NULL) { 631 CLerr(CL_F_CLUSTER_LABS_RSA_PRIV_DEC, CL_R_NOT_LOADED); 632 return 0; 633 } 634 if (p_cl_rsa_priv_dec == NULL) { 635 CLerr(CL_F_CLUSTER_LABS_RSA_PRIV_DEC, CL_R_FUNCTION_NOT_BINDED); 636 return 0; 637 } 638 639 return p_cl_rsa_priv_dec(flen, from, to, rsa, padding); 640 641} 642 643/************************************************************************************ 644* Symmetric algorithms 645************************************************************************************/ 646/* this will be come soon! */ 647 648/************************************************************************************ 649* Random generator 650************************************************************************************/ 651 652static int cluster_labs_rand_bytes(unsigned char *buf, int num) 653{ 654 655 if (cluster_labs_dso == NULL) { 656 CLerr(CL_F_CLUSTER_LABS_RAND_BYTES, CL_R_NOT_LOADED); 657 return 0; 658 } 659 if (p_cl_mod_exp_crt == NULL) { 660 CLerr(CL_F_CLUSTER_LABS_RAND_BYTES, CL_R_FUNCTION_NOT_BINDED); 661 return 0; 662 } 663 664 return p_cl_rand_bytes(buf, num); 665 666} 667 668/* 669 * This stuff is needed if this ENGINE is being compiled into a 670 * self-contained shared-library. 671 */ 672# ifdef ENGINE_DYNAMIC_SUPPORT 673static int bind_fn(ENGINE *e, const char *id) 674{ 675 fprintf(stderr, "bind_fn CLUSTER_LABS\n"); 676 if (id && (strcmp(id, engine_cluster_labs_id) != 0)) { 677 fprintf(stderr, "bind_fn return(0) first\n"); 678 return 0; 679 } 680 if (!bind_helper(e)) { 681 fprintf(stderr, "bind_fn return(1) first\n"); 682 return 0; 683 } 684 fprintf(stderr, "bind_fn return(1)\n"); 685 return 1; 686} 687 688IMPLEMENT_DYNAMIC_CHECK_FN() 689 IMPLEMENT_DYNAMIC_BIND_FN(bind_fn) 690# endif /* ENGINE_DYNAMIC_SUPPORT */ 691# endif /* !NO_HW_CLUSTER_LABS */ 692#endif /* !NO_HW */ 693