demos/engines/ibmca/hw_ibmca.c

   1 /* crypto/engine/hw_ibmca.c */
   2 /*
   3  * Written by Geoff Thorpe (geoff@geoffthorpe.net) for the OpenSSL project
   4  * 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 /* (C) COPYRIGHT International Business Machines Corp. 2001 */
  61
  62 #include <stdio.h>
  63 #include <openssl/crypto.h>
  64 #include <openssl/dso.h>
  65 #include <openssl/engine.h>
  66
  67 #ifndef OPENSSL_NO_HW
  68 # ifndef OPENSSL_NO_HW_IBMCA
  69
  70 #  ifdef FLAT_INC
  71 #   include "ica_openssl_api.h"
  72 #  else
  73 #   include "vendor_defns/ica_openssl_api.h"
  74 #  endif
  75
  76 #  define IBMCA_LIB_NAME "ibmca engine"
  77 #  include "hw_ibmca_err.c"
  78
  79 static int ibmca_destroy(ENGINE *e);
  80 static int ibmca_init(ENGINE *e);
  81 static int ibmca_finish(ENGINE *e);
  82 static int ibmca_ctrl(ENGINE *e, int cmd, long i, void *p, void (*f) ());
  83
  84 static const char *IBMCA_F1 = "icaOpenAdapter";
  85 static const char *IBMCA_F2 = "icaCloseAdapter";
  86 static const char *IBMCA_F3 = "icaRsaModExpo";
  87 static const char *IBMCA_F4 = "icaRandomNumberGenerate";
  88 static const char *IBMCA_F5 = "icaRsaCrt";
  89
  90 ICA_ADAPTER_HANDLE handle = 0;
  91
  92 /* BIGNUM stuff */
  93 static int ibmca_mod_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
  94                          const BIGNUM *m, BN_CTX *ctx);
  95
  96 static int ibmca_mod_exp_crt(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
  97                              const BIGNUM *q, const BIGNUM *dmp1,
  98                              const BIGNUM *dmq1, const BIGNUM *iqmp,
  99                              BN_CTX *ctx);
 100
 101 #  ifndef OPENSSL_NO_RSA
 102 /* RSA stuff */
 103 static int ibmca_rsa_mod_exp(BIGNUM *r0, const BIGNUM *I, RSA *rsa);
 104 #  endif
 105
 106 /* This function is aliased to mod_exp (with the mont stuff dropped). */
 107 static int ibmca_mod_exp_mont(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
 108                               const BIGNUM *m, BN_CTX *ctx,
 109                               BN_MONT_CTX *m_ctx);
 110
 111 #  ifndef OPENSSL_NO_DSA
 112 /* DSA stuff */
 113 static int ibmca_dsa_mod_exp(DSA *dsa, BIGNUM *rr, BIGNUM *a1,
 114                              BIGNUM *p1, BIGNUM *a2, BIGNUM *p2, BIGNUM *m,
 115                              BN_CTX *ctx, BN_MONT_CTX *in_mont);
 116 static int ibmca_mod_exp_dsa(DSA *dsa, BIGNUM *r, BIGNUM *a,
 117                              const BIGNUM *p, const BIGNUM *m, BN_CTX *ctx,
 118                              BN_MONT_CTX *m_ctx);
 119 #  endif
 120
 121 #  ifndef OPENSSL_NO_DH
 122 /* DH stuff */
 123 /* This function is alised to mod_exp (with the DH and mont dropped). */
 124 static int ibmca_mod_exp_dh(const DH *dh, BIGNUM *r,
 125                             const BIGNUM *a, const BIGNUM *p,
 126                             const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx);
 127 #  endif
 128
 129 /* RAND stuff */
 130 static int ibmca_rand_bytes(unsigned char *buf, int num);
 131 static int ibmca_rand_status(void);
 132
 133 /* WJH - check for more commands, like in nuron */
 134
 135 /* The definitions for control commands specific to this engine */
 136 #  define IBMCA_CMD_SO_PATH               ENGINE_CMD_BASE
 137 static const ENGINE_CMD_DEFN ibmca_cmd_defns[] = {
 138     {IBMCA_CMD_SO_PATH,
 139      "SO_PATH",
 140      "Specifies the path to the 'atasi' shared library",
 141      ENGINE_CMD_FLAG_STRING},
 142     {0, NULL, NULL, 0}
 143 };
 144
 145 #  ifndef OPENSSL_NO_RSA
 146 /* Our internal RSA_METHOD that we provide pointers to */
 147 static RSA_METHOD ibmca_rsa = {
 148     "Ibmca RSA method",
 149     NULL,
 150     NULL,
 151     NULL,
 152     NULL,
 153     ibmca_rsa_mod_exp,
 154     ibmca_mod_exp_mont,
 155     NULL,
 156     NULL,
 157     0,
 158     NULL,
 159     NULL,
 160     NULL
 161 };
 162 #  endif
 163
 164 #  ifndef OPENSSL_NO_DSA
 165 /* Our internal DSA_METHOD that we provide pointers to */
 166 static DSA_METHOD ibmca_dsa = {
 167     "Ibmca DSA method",
 168     NULL,                       /* dsa_do_sign */
 169     NULL,                       /* dsa_sign_setup */
 170     NULL,                       /* dsa_do_verify */
 171     ibmca_dsa_mod_exp,          /* dsa_mod_exp */
 172     ibmca_mod_exp_dsa,          /* bn_mod_exp */
 173     NULL,                       /* init */
 174     NULL,                       /* finish */
 175     0,                          /* flags */
 176     NULL                        /* app_data */
 177 };
 178 #  endif
 179
 180 #  ifndef OPENSSL_NO_DH
 181 /* Our internal DH_METHOD that we provide pointers to */
 182 static DH_METHOD ibmca_dh = {
 183     "Ibmca DH method",
 184     NULL,
 185     NULL,
 186     ibmca_mod_exp_dh,
 187     NULL,
 188     NULL,
 189     0,
 190     NULL
 191 };
 192 #  endif
 193
 194 static RAND_METHOD ibmca_rand = {
 195     /* "IBMCA RAND method", */
 196     NULL,
 197     ibmca_rand_bytes,
 198     NULL,
 199     NULL,
 200     ibmca_rand_bytes,
 201     ibmca_rand_status,
 202 };
 203
 204 /* Constants used when creating the ENGINE */
 205 static const char *engine_ibmca_id = "ibmca";
 206 static const char *engine_ibmca_name = "Ibmca hardware engine support";
 207
 208 /*
 209  * This internal function is used by ENGINE_ibmca() and possibly by the
 210  * "dynamic" ENGINE support too
 211  */
 212 static int bind_helper(ENGINE *e)
 213 {
 214 #  ifndef OPENSSL_NO_RSA
 215     const RSA_METHOD *meth1;
 216 #  endif
 217 #  ifndef OPENSSL_NO_DSA
 218     const DSA_METHOD *meth2;
 219 #  endif
 220 #  ifndef OPENSSL_NO_DH
 221     const DH_METHOD *meth3;
 222 #  endif
 223     if (!ENGINE_set_id(e, engine_ibmca_id) ||
 224         !ENGINE_set_name(e, engine_ibmca_name) ||
 225 #  ifndef OPENSSL_NO_RSA
 226         !ENGINE_set_RSA(e, &ibmca_rsa) ||
 227 #  endif
 228 #  ifndef OPENSSL_NO_DSA
 229         !ENGINE_set_DSA(e, &ibmca_dsa) ||
 230 #  endif
 231 #  ifndef OPENSSL_NO_DH
 232         !ENGINE_set_DH(e, &ibmca_dh) ||
 233 #  endif
 234         !ENGINE_set_RAND(e, &ibmca_rand) ||
 235         !ENGINE_set_destroy_function(e, ibmca_destroy) ||
 236         !ENGINE_set_init_function(e, ibmca_init) ||
 237         !ENGINE_set_finish_function(e, ibmca_finish) ||
 238         !ENGINE_set_ctrl_function(e, ibmca_ctrl) ||
 239         !ENGINE_set_cmd_defns(e, ibmca_cmd_defns))
 240         return 0;
 241
 242 #  ifndef OPENSSL_NO_RSA
 243     /*
 244      * We know that the "PKCS1_SSLeay()" functions hook properly to the
 245      * ibmca-specific mod_exp and mod_exp_crt so we use those functions. NB:
 246      * We don't use ENGINE_openssl() or anything "more generic" because
 247      * something like the RSAref code may not hook properly, and if you own
 248      * one of these cards then you have the right to do RSA operations on it
 249      * anyway!
 250      */
 251     meth1 = RSA_PKCS1_SSLeay();
 252     ibmca_rsa.rsa_pub_enc = meth1->rsa_pub_enc;
 253     ibmca_rsa.rsa_pub_dec = meth1->rsa_pub_dec;
 254     ibmca_rsa.rsa_priv_enc = meth1->rsa_priv_enc;
 255     ibmca_rsa.rsa_priv_dec = meth1->rsa_priv_dec;
 256 #  endif
 257
 258 #  ifndef OPENSSL_NO_DSA
 259     /*
 260      * Use the DSA_OpenSSL() method and just hook the mod_exp-ish bits.
 261      */
 262     meth2 = DSA_OpenSSL();
 263     ibmca_dsa.dsa_do_sign = meth2->dsa_do_sign;
 264     ibmca_dsa.dsa_sign_setup = meth2->dsa_sign_setup;
 265     ibmca_dsa.dsa_do_verify = meth2->dsa_do_verify;
 266 #  endif
 267
 268 #  ifndef OPENSSL_NO_DH
 269     /* Much the same for Diffie-Hellman */
 270     meth3 = DH_OpenSSL();
 271     ibmca_dh.generate_key = meth3->generate_key;
 272     ibmca_dh.compute_key = meth3->compute_key;
 273 #  endif
 274
 275     /* Ensure the ibmca error handling is set up */
 276     ERR_load_IBMCA_strings();
 277     return 1;
 278 }
 279
 280 static ENGINE *engine_ibmca(void)
 281 {
 282     ENGINE *ret = ENGINE_new();
 283     if (!ret)
 284         return NULL;
 285     if (!bind_helper(ret)) {
 286         ENGINE_free(ret);
 287         return NULL;
 288     }
 289     return ret;
 290 }
 291
 292 #  ifdef ENGINE_DYNAMIC_SUPPORT
 293 static
 294 #  endif
 295 void ENGINE_load_ibmca(void)
 296 {
 297     /* Copied from eng_[openssl|dyn].c */
 298     ENGINE *toadd = engine_ibmca();
 299     if (!toadd)
 300         return;
 301     ENGINE_add(toadd);
 302     ENGINE_free(toadd);
 303     ERR_clear_error();
 304 }
 305
 306 /* Destructor (complements the "ENGINE_ibmca()" constructor) */
 307 static int ibmca_destroy(ENGINE *e)
 308 {
 309     /*
 310      * Unload the ibmca error strings so any error state including our functs
 311      * or reasons won't lead to a segfault (they simply get displayed without
 312      * corresponding string data because none will be found).
 313      */
 314     ERR_unload_IBMCA_strings();
 315     return 1;
 316 }
 317
 318 /*
 319  * This is a process-global DSO handle used for loading and unloading the
 320  * Ibmca library. NB: This is only set (or unset) during an init() or
 321  * finish() call (reference counts permitting) and they're operating with
 322  * global locks, so this should be thread-safe implicitly.
 323  */
 324
 325 static DSO *ibmca_dso = NULL;
 326
 327 /*
 328  * These are the function pointers that are (un)set when the library has
 329  * successfully (un)loaded.
 330  */
 331
 332 static unsigned int (ICA_CALL * p_icaOpenAdapter) ();
 333 static unsigned int (ICA_CALL * p_icaCloseAdapter) ();
 334 static unsigned int (ICA_CALL * p_icaRsaModExpo) ();
 335 static unsigned int (ICA_CALL * p_icaRandomNumberGenerate) ();
 336 static unsigned int (ICA_CALL * p_icaRsaCrt) ();
 337
 338 /* utility function to obtain a context */
 339 static int get_context(ICA_ADAPTER_HANDLE * p_handle)
 340 {
 341     unsigned int status = 0;
 342
 343     status = p_icaOpenAdapter(0, p_handle);
 344     if (status != 0)
 345         return 0;
 346     return 1;
 347 }
 348
 349 /* similarly to release one. */
 350 static void release_context(ICA_ADAPTER_HANDLE handle)
 351 {
 352     p_icaCloseAdapter(handle);
 353 }
 354
 355 /* (de)initialisation functions. */
 356 static int ibmca_init(ENGINE *e)
 357 {
 358
 359     void (*p1) ();
 360     void (*p2) ();
 361     void (*p3) ();
 362     void (*p4) ();
 363     void (*p5) ();
 364
 365     if (ibmca_dso != NULL) {
 366         IBMCAerr(IBMCA_F_IBMCA_INIT, IBMCA_R_ALREADY_LOADED);
 367         goto err;
 368     }
 369     /*
 370      * Attempt to load libatasi.so/atasi.dll/whatever. Needs to be changed
 371      * unfortunately because the Ibmca drivers don't have standard library
 372      * names that can be platform-translated well.
 373      */
 374     /*
 375      * TODO: Work out how to actually map to the names the Ibmca drivers
 376      * really use - for now a symbollic link needs to be created on the host
 377      * system from libatasi.so to atasi.so on unix variants.
 378      */
 379
 380     /* WJH XXX check name translation */
 381
 382     ibmca_dso = DSO_load(NULL, IBMCA_LIBNAME, NULL,
 383                          /*
 384                           * DSO_FLAG_NAME_TRANSLATION
 385                           */ 0);
 386     if (ibmca_dso == NULL) {
 387         IBMCAerr(IBMCA_F_IBMCA_INIT, IBMCA_R_DSO_FAILURE);
 388         goto err;
 389     }
 390
 391     if (!(p1 = DSO_bind_func(ibmca_dso, IBMCA_F1)) ||
 392         !(p2 = DSO_bind_func(ibmca_dso, IBMCA_F2)) ||
 393         !(p3 = DSO_bind_func(ibmca_dso, IBMCA_F3)) ||
 394         !(p4 = DSO_bind_func(ibmca_dso, IBMCA_F4)) ||
 395         !(p5 = DSO_bind_func(ibmca_dso, IBMCA_F5))) {
 396         IBMCAerr(IBMCA_F_IBMCA_INIT, IBMCA_R_DSO_FAILURE);
 397         goto err;
 398     }
 399
 400     /* Copy the pointers */
 401
 402     p_icaOpenAdapter = (unsigned int (ICA_CALL *) ())p1;
 403     p_icaCloseAdapter = (unsigned int (ICA_CALL *) ())p2;
 404     p_icaRsaModExpo = (unsigned int (ICA_CALL *) ())p3;
 405     p_icaRandomNumberGenerate = (unsigned int (ICA_CALL *) ())p4;
 406     p_icaRsaCrt = (unsigned int (ICA_CALL *) ())p5;
 407
 408     if (!get_context(&handle)) {
 409         IBMCAerr(IBMCA_F_IBMCA_INIT, IBMCA_R_UNIT_FAILURE);
 410         goto err;
 411     }
 412
 413     return 1;
 414  err:
 415     DSO_free(ibmca_dso);
 416     p_icaOpenAdapter = NULL;
 417     p_icaCloseAdapter = NULL;
 418     p_icaRsaModExpo = NULL;
 419     p_icaRandomNumberGenerate = NULL;
 420
 421     return 0;
 422 }
 423
 424 static int ibmca_finish(ENGINE *e)
 425 {
 426     if (ibmca_dso == NULL) {
 427         IBMCAerr(IBMCA_F_IBMCA_FINISH, IBMCA_R_NOT_LOADED);
 428         return 0;
 429     }
 430     release_context(handle);
 431     if (!DSO_free(ibmca_dso)) {
 432         IBMCAerr(IBMCA_F_IBMCA_FINISH, IBMCA_R_DSO_FAILURE);
 433         return 0;
 434     }
 435     ibmca_dso = NULL;
 436
 437     return 1;
 438 }
 439
 440 static int ibmca_ctrl(ENGINE *e, int cmd, long i, void *p, void (*f) ())
 441 {
 442     int initialised = ((ibmca_dso == NULL) ? 0 : 1);
 443     switch (cmd) {
 444     case IBMCA_CMD_SO_PATH:
 445         if (p == NULL) {
 446             IBMCAerr(IBMCA_F_IBMCA_CTRL, ERR_R_PASSED_NULL_PARAMETER);
 447             return 0;
 448         }
 449         if (initialised) {
 450             IBMCAerr(IBMCA_F_IBMCA_CTRL, IBMCA_R_ALREADY_LOADED);
 451             return 0;
 452         }
 453         IBMCA_LIBNAME = (const char *)p;
 454         return 1;
 455     default:
 456         break;
 457     }
 458     IBMCAerr(IBMCA_F_IBMCA_CTRL, IBMCA_R_CTRL_COMMAND_NOT_IMPLEMENTED);
 459     return 0;
 460 }
 461
 462 static int ibmca_mod_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
 463                          const BIGNUM *m, BN_CTX *ctx)
 464 {
 465     /*
 466      * I need somewhere to store temporary serialised values for use with the
 467      * Ibmca API calls. A neat cheat - I'll use BIGNUMs from the BN_CTX but
 468      * access their arrays directly as byte arrays <grin>. This way I don't
 469      * have to clean anything up.
 470      */
 471
 472     BIGNUM *argument = NULL;
 473     BIGNUM *result = NULL;
 474     BIGNUM *key = NULL;
 475     int to_return;
 476     int inLen, outLen, tmpLen;
 477
 478     ICA_KEY_RSA_MODEXPO *publKey = NULL;
 479     unsigned int rc;
 480
 481     to_return = 0;              /* expect failure */
 482
 483     if (!ibmca_dso) {
 484         IBMCAerr(IBMCA_F_IBMCA_MOD_EXP, IBMCA_R_NOT_LOADED);
 485         goto err;
 486     }
 487     /* Prepare the params */
 488     BN_CTX_start(ctx);
 489     argument = BN_CTX_get(ctx);
 490     result = BN_CTX_get(ctx);
 491     key = BN_CTX_get(ctx);
 492
 493     if (!argument || !result || !key) {
 494         IBMCAerr(IBMCA_F_IBMCA_MOD_EXP, IBMCA_R_BN_CTX_FULL);
 495         goto err;
 496     }
 497
 498     if (!bn_wexpand(argument, m->top) || !bn_wexpand(result, m->top) ||
 499         !bn_wexpand(key, sizeof(*publKey) / BN_BYTES)) {
 500         IBMCAerr(IBMCA_F_IBMCA_MOD_EXP, IBMCA_R_BN_EXPAND_FAIL);
 501         goto err;
 502     }
 503
 504     publKey = (ICA_KEY_RSA_MODEXPO *)key->d;
 505
 506     if (publKey == NULL) {
 507         goto err;
 508     }
 509     memset(publKey, 0, sizeof(ICA_KEY_RSA_MODEXPO));
 510
 511     publKey->keyType = CORRECT_ENDIANNESS(ME_KEY_TYPE);
 512     publKey->keyLength = CORRECT_ENDIANNESS(sizeof(ICA_KEY_RSA_MODEXPO));
 513     publKey->expOffset = (char *)publKey->keyRecord - (char *)publKey;
 514
 515     /*
 516      * A quirk of the card: the exponent length has to be the same as the
 517      * modulus (key) length
 518      */
 519
 520     outLen = BN_num_bytes(m);
 521
 522 /* check for modulus length SAB*/
 523     if (outLen > 256) {
 524         IBMCAerr(IBMCA_F_IBMCA_MOD_EXP, IBMCA_R_MEXP_LENGTH_TO_LARGE);
 525         goto err;
 526     }
 527 /* check for modulus length SAB*/
 528
 529     publKey->expLength = publKey->nLength = outLen;
 530     /*
 531      * SAB Check for underflow condition the size of the exponent is less
 532      * than the size of the parameter then we have a big problem and will
 533      * underflow the keyRecord buffer.  Bad stuff could happen then
 534      */
 535     if (outLen < BN_num_bytes(p)) {
 536         IBMCAerr(IBMCA_F_IBMCA_MOD_EXP, IBMCA_R_UNDERFLOW_KEYRECORD);
 537         goto err;
 538     }
 539 /* SAB End check for underflow */
 540
 541     BN_bn2bin(p, &publKey->keyRecord[publKey->expLength - BN_num_bytes(p)]);
 542     BN_bn2bin(m, &publKey->keyRecord[publKey->expLength]);
 543
 544     publKey->modulusBitLength = CORRECT_ENDIANNESS(publKey->nLength * 8);
 545     publKey->nOffset = CORRECT_ENDIANNESS(publKey->expOffset +
 546                                           publKey->expLength);
 547
 548     publKey->expOffset = CORRECT_ENDIANNESS((char *)publKey->keyRecord -
 549                                             (char *)publKey);
 550
 551     tmpLen = outLen;
 552     publKey->expLength = publKey->nLength = CORRECT_ENDIANNESS(tmpLen);
 553
 554     /* Prepare the argument */
 555
 556     memset(argument->d, 0, outLen);
 557     BN_bn2bin(a, (unsigned char *)argument->d + outLen - BN_num_bytes(a));
 558
 559     inLen = outLen;
 560
 561     /* Perform the operation */
 562
 563     if ((rc = p_icaRsaModExpo(handle, inLen, (unsigned char *)argument->d,
 564                               publKey, &outLen, (unsigned char *)result->d))
 565         != 0) {
 566         printf("rc = %d\n", rc);
 567         IBMCAerr(IBMCA_F_IBMCA_MOD_EXP, IBMCA_R_REQUEST_FAILED);
 568         goto err;
 569     }
 570
 571     /* Convert the response */
 572     BN_bin2bn((unsigned char *)result->d, outLen, r);
 573     to_return = 1;
 574  err:
 575     BN_CTX_end(ctx);
 576     return to_return;
 577 }
 578
 579 #  ifndef OPENSSL_NO_RSA
 580 static int ibmca_rsa_mod_exp(BIGNUM *r0, const BIGNUM *I, RSA *rsa)
 581 {
 582     BN_CTX *ctx;
 583     int to_return = 0;
 584
 585     if ((ctx = BN_CTX_new()) == NULL)
 586         goto err;
 587     if (!rsa->p || !rsa->q || !rsa->dmp1 || !rsa->dmq1 || !rsa->iqmp) {
 588         if (!rsa->d || !rsa->n) {
 589             IBMCAerr(IBMCA_F_IBMCA_RSA_MOD_EXP,
 590                      IBMCA_R_MISSING_KEY_COMPONENTS);
 591             goto err;
 592         }
 593         to_return = ibmca_mod_exp(r0, I, rsa->d, rsa->n, ctx);
 594     } else {
 595         to_return = ibmca_mod_exp_crt(r0, I, rsa->p, rsa->q, rsa->dmp1,
 596                                       rsa->dmq1, rsa->iqmp, ctx);
 597     }
 598  err:
 599     BN_CTX_free(ctx);
 600     return to_return;
 601 }
 602 #  endif
 603
 604 /* Ein kleines chinesisches "Restessen"  */
 605 static int ibmca_mod_exp_crt(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
 606                              const BIGNUM *q, const BIGNUM *dmp1,
 607                              const BIGNUM *dmq1, const BIGNUM *iqmp,
 608                              BN_CTX *ctx)
 609 {
 610
 611     BIGNUM *argument = NULL;
 612     BIGNUM *result = NULL;
 613     BIGNUM *key = NULL;
 614
 615     int to_return = 0;          /* expect failure */
 616
 617     char *pkey = NULL;
 618     ICA_KEY_RSA_CRT *privKey = NULL;
 619     int inLen, outLen;
 620
 621     int rc;
 622     unsigned int offset, pSize, qSize;
 623 /* SAB New variables */
 624     unsigned int keyRecordSize;
 625     unsigned int pbytes = BN_num_bytes(p);
 626     unsigned int qbytes = BN_num_bytes(q);
 627     unsigned int dmp1bytes = BN_num_bytes(dmp1);
 628     unsigned int dmq1bytes = BN_num_bytes(dmq1);
 629     unsigned int iqmpbytes = BN_num_bytes(iqmp);
 630
 631     /* Prepare the params */
 632
 633     BN_CTX_start(ctx);
 634     argument = BN_CTX_get(ctx);
 635     result = BN_CTX_get(ctx);
 636     key = BN_CTX_get(ctx);
 637
 638     if (!argument || !result || !key) {
 639         IBMCAerr(IBMCA_F_IBMCA_MOD_EXP_CRT, IBMCA_R_BN_CTX_FULL);
 640         goto err;
 641     }
 642
 643     if (!bn_wexpand(argument, p->top + q->top) ||
 644         !bn_wexpand(result, p->top + q->top) ||
 645         !bn_wexpand(key, sizeof(*privKey) / BN_BYTES)) {
 646         IBMCAerr(IBMCA_F_IBMCA_MOD_EXP_CRT, IBMCA_R_BN_EXPAND_FAIL);
 647         goto err;
 648     }
 649
 650     privKey = (ICA_KEY_RSA_CRT *)key->d;
 651     /*
 652      * SAB Add check for total size in bytes of the parms does not exceed the
 653      * buffer space we have do this first
 654      */
 655     keyRecordSize = pbytes + qbytes + dmp1bytes + dmq1bytes + iqmpbytes;
 656     if (keyRecordSize > sizeof(privKey->keyRecord)) {
 657         IBMCAerr(IBMCA_F_IBMCA_MOD_EXP_CRT, IBMCA_R_OPERANDS_TO_LARGE);
 658         goto err;
 659     }
 660
 661     if ((qbytes + dmq1bytes) > 256) {
 662         IBMCAerr(IBMCA_F_IBMCA_MOD_EXP_CRT, IBMCA_R_OPERANDS_TO_LARGE);
 663         goto err;
 664     }
 665
 666     if (pbytes + dmp1bytes > 256) {
 667         IBMCAerr(IBMCA_F_IBMCA_MOD_EXP_CRT, IBMCA_R_OPERANDS_TO_LARGE);
 668         goto err;
 669     }
 670
 671 /* end SAB additions */
 672
 673     memset(privKey, 0, sizeof(ICA_KEY_RSA_CRT));
 674     privKey->keyType = CORRECT_ENDIANNESS(CRT_KEY_TYPE);
 675     privKey->keyLength = CORRECT_ENDIANNESS(sizeof(ICA_KEY_RSA_CRT));
 676     privKey->modulusBitLength = CORRECT_ENDIANNESS(BN_num_bytes(q) * 2 * 8);
 677
 678     /*
 679      * p,dp & qInv are 1 QWORD Larger
 680      */
 681     privKey->pLength = CORRECT_ENDIANNESS(BN_num_bytes(p) + 8);
 682     privKey->qLength = CORRECT_ENDIANNESS(BN_num_bytes(q));
 683     privKey->dpLength = CORRECT_ENDIANNESS(BN_num_bytes(dmp1) + 8);
 684     privKey->dqLength = CORRECT_ENDIANNESS(BN_num_bytes(dmq1));
 685     privKey->qInvLength = CORRECT_ENDIANNESS(BN_num_bytes(iqmp) + 8);
 686
 687     offset = (char *)privKey->keyRecord - (char *)privKey;
 688
 689     qSize = BN_num_bytes(q);
 690     pSize = qSize + 8;          /* 1 QWORD larger */
 691
 692     /*
 693      * SAB probably aittle redundant, but we'll verify that each of the
 694      * components which make up a key record sent ot the card does not exceed
 695      * the space that is allocated for it.  this handles the case where even
 696      * if the total length does not exceed keyrecord zied, if the operands are
 697      * funny sized they could cause potential side affects on either the card
 698      * or the result
 699      */
 700
 701     if ((pbytes > pSize) || (dmp1bytes > pSize) ||
 702         (iqmpbytes > pSize) || (qbytes > qSize) || (dmq1bytes > qSize)) {
 703         IBMCAerr(IBMCA_F_IBMCA_MOD_EXP_CRT, IBMCA_R_OPERANDS_TO_LARGE);
 704         goto err;
 705
 706     }
 707
 708     privKey->dpOffset = CORRECT_ENDIANNESS(offset);
 709
 710     offset += pSize;
 711     privKey->dqOffset = CORRECT_ENDIANNESS(offset);
 712
 713     offset += qSize;
 714     privKey->pOffset = CORRECT_ENDIANNESS(offset);
 715
 716     offset += pSize;
 717     privKey->qOffset = CORRECT_ENDIANNESS(offset);
 718
 719     offset += qSize;
 720     privKey->qInvOffset = CORRECT_ENDIANNESS(offset);
 721
 722     pkey = (char *)privKey->keyRecord;
 723
 724 /* SAB first check that we don;t under flow the buffer */
 725     if (pSize < pbytes) {
 726         IBMCAerr(IBMCA_F_IBMCA_MOD_EXP_CRT, IBMCA_R_UNDERFLOW_CONDITION);
 727         goto err;
 728     }
 729
 730     /* pkey += pSize - BN_num_bytes(p); WROING this should be dmp1) */
 731     pkey += pSize - BN_num_bytes(dmp1);
 732     BN_bn2bin(dmp1, pkey);
 733     pkey += BN_num_bytes(dmp1); /* move the pointer */
 734
 735     BN_bn2bin(dmq1, pkey);      /* Copy over dmq1 */
 736
 737     pkey += qSize;              /* move pointer */
 738     /* set up for zero padding of next field */
 739     pkey += pSize - BN_num_bytes(p);
 740
 741     BN_bn2bin(p, pkey);
 742     /* increment pointer by number of bytes moved  */
 743     pkey += BN_num_bytes(p);
 744
 745     BN_bn2bin(q, pkey);
 746     pkey += qSize;              /* move the pointer */
 747     pkey += pSize - BN_num_bytes(iqmp); /* Adjust for padding */
 748     BN_bn2bin(iqmp, pkey);
 749
 750     /* Prepare the argument and response */
 751
 752     /*
 753      * Correct endianess is used because the fields were converted above
 754      */
 755     outLen = CORRECT_ENDIANNESS(privKey->qLength) * 2;
 756
 757     if (outLen > 256) {
 758         IBMCAerr(IBMCA_F_IBMCA_MOD_EXP_CRT, IBMCA_R_OUTLEN_TO_LARGE);
 759         goto err;
 760     }
 761
 762     /* SAB check for underflow here on the argeument */
 763     if (outLen < BN_num_bytes(a)) {
 764         IBMCAerr(IBMCA_F_IBMCA_MOD_EXP_CRT, IBMCA_R_UNDERFLOW_CONDITION);
 765         goto err;
 766     }
 767
 768     BN_bn2bin(a, (unsigned char *)argument->d + outLen - BN_num_bytes(a));
 769     inLen = outLen;
 770
 771     memset(result->d, 0, outLen);
 772
 773     /* Perform the operation */
 774
 775     if ((rc = p_icaRsaCrt(handle, inLen, (unsigned char *)argument->d,
 776                           privKey, &outLen, (unsigned char *)result->d)) != 0)
 777     {
 778         printf("rc = %d\n", rc);
 779         IBMCAerr(IBMCA_F_IBMCA_MOD_EXP_CRT, IBMCA_R_REQUEST_FAILED);
 780         goto err;
 781     }
 782
 783     /* Convert the response */
 784
 785     BN_bin2bn((unsigned char *)result->d, outLen, r);
 786     to_return = 1;
 787
 788  err:
 789     BN_CTX_end(ctx);
 790     return to_return;
 791
 792 }
 793
 794 #  ifndef OPENSSL_NO_DSA
 795 /*
 796  * This code was liberated and adapted from the commented-out code in
 797  * dsa_ossl.c. Because of the unoptimised form of the Ibmca acceleration (it
 798  * doesn't have a CRT form for RSA), this function means that an Ibmca system
 799  * running with a DSA server certificate can handshake around 5 or 6 times
 800  * faster/more than an equivalent system running with RSA. Just check out the
 801  * "signs" statistics from the RSA and DSA parts of "openssl speed -engine
 802  * ibmca dsa1024 rsa1024".
 803  */
 804 static int ibmca_dsa_mod_exp(DSA *dsa, BIGNUM *rr, BIGNUM *a1,
 805                              BIGNUM *p1, BIGNUM *a2, BIGNUM *p2, BIGNUM *m,
 806                              BN_CTX *ctx, BN_MONT_CTX *in_mont)
 807 {
 808     BIGNUM t;
 809     int to_return = 0;
 810
 811     BN_init(&t);
 812     /* let rr = a1 ^ p1 mod m */
 813     if (!ibmca_mod_exp(rr, a1, p1, m, ctx))
 814         goto end;
 815     /* let t = a2 ^ p2 mod m */
 816     if (!ibmca_mod_exp(&t, a2, p2, m, ctx))
 817         goto end;
 818     /* let rr = rr * t mod m */
 819     if (!BN_mod_mul(rr, rr, &t, m, ctx))
 820         goto end;
 821     to_return = 1;
 822  end:
 823     BN_free(&t);
 824     return to_return;
 825 }
 826
 827 static int ibmca_mod_exp_dsa(DSA *dsa, BIGNUM *r, BIGNUM *a,
 828                              const BIGNUM *p, const BIGNUM *m, BN_CTX *ctx,
 829                              BN_MONT_CTX *m_ctx)
 830 {
 831     return ibmca_mod_exp(r, a, p, m, ctx);
 832 }
 833 #  endif
 834
 835 /* This function is aliased to mod_exp (with the mont stuff dropped). */
 836 static int ibmca_mod_exp_mont(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
 837                               const BIGNUM *m, BN_CTX *ctx,
 838                               BN_MONT_CTX *m_ctx)
 839 {
 840     return ibmca_mod_exp(r, a, p, m, ctx);
 841 }
 842
 843 #  ifndef OPENSSL_NO_DH
 844 /* This function is aliased to mod_exp (with the dh and mont dropped). */
 845 static int ibmca_mod_exp_dh(DH const *dh, BIGNUM *r,
 846                             const BIGNUM *a, const BIGNUM *p,
 847                             const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx)
 848 {
 849     return ibmca_mod_exp(r, a, p, m, ctx);
 850 }
 851 #  endif
 852
 853 /* Random bytes are good */
 854 static int ibmca_rand_bytes(unsigned char *buf, int num)
 855 {
 856     int to_return = 0;          /* assume failure */
 857     unsigned int ret;
 858
 859     if (handle == 0) {
 860         IBMCAerr(IBMCA_F_IBMCA_RAND_BYTES, IBMCA_R_NOT_INITIALISED);
 861         goto err;
 862     }
 863
 864     ret = p_icaRandomNumberGenerate(handle, num, buf);
 865     if (ret < 0) {
 866         IBMCAerr(IBMCA_F_IBMCA_RAND_BYTES, IBMCA_R_REQUEST_FAILED);
 867         goto err;
 868     }
 869     to_return = 1;
 870  err:
 871     return to_return;
 872 }
 873
 874 static int ibmca_rand_status(void)
 875 {
 876     return 1;
 877 }
 878
 879 /*
 880  * This stuff is needed if this ENGINE is being compiled into a
 881  * self-contained shared-library.
 882  */
 883 #  ifdef ENGINE_DYNAMIC_SUPPORT
 884 static int bind_fn(ENGINE *e, const char *id)
 885 {
 886     if (id && (strcmp(id, engine_ibmca_id) != 0)) /* WJH XXX */
 887         return 0;
 888     if (!bind_helper(e))
 889         return 0;
 890     return 1;
 891 }
 892
 893 IMPLEMENT_DYNAMIC_CHECK_FN()
 894     IMPLEMENT_DYNAMIC_BIND_FN(bind_fn)
 895 #  endif                        /* ENGINE_DYNAMIC_SUPPORT */
 896 # endif                         /* !OPENSSL_NO_HW_IBMCA */
 897 #endif                          /* !OPENSSL_NO_HW */