engines/e_4758_cca.c

   1 /* Author: Maurice Gittens <maurice@gittens.nl>                       */
   2 /* ====================================================================
   3  * Copyright (c) 1999 The OpenSSL Project.  All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  *
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  *
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in
  14  *    the documentation and/or other materials provided with the
  15  *    distribution.
  16  *
  17  * 3. All advertising materials mentioning features or use of this
  18  *    software must display the following acknowledgment:
  19  *    "This product includes software developed by the OpenSSL Project
  20  *    for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
  21  *
  22  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
  23  *    endorse or promote products derived from this software without
  24  *    prior written permission. For written permission, please contact
  25  *    licensing@OpenSSL.org.
  26  *
  27  * 5. Products derived from this software may not be called "OpenSSL"
  28  *    nor may "OpenSSL" appear in their names without prior written
  29  *    permission of the OpenSSL Project.
  30  *
  31  * 6. Redistributions of any form whatsoever must retain the following
  32  *    acknowledgment:
  33  *    "This product includes software developed by the OpenSSL Project
  34  *    for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
  35  *
  36  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
  37  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  38  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  39  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
  40  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  41  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  42  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  43  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  44  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  45  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  46  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  47  * OF THE POSSIBILITY OF SUCH DAMAGE.
  48  * ====================================================================
  49  *
  50  * This product includes cryptographic software written by Eric Young
  51  * (eay@cryptsoft.com).  This product includes software written by Tim
  52  * Hudson (tjh@cryptsoft.com).
  53  *
  54  */
  55
  56 #include <stdio.h>
  57 #include <openssl/crypto.h>
  58 /* #include <openssl/pem.h> */
  59 #include <openssl/dso.h>
  60 #include <openssl/x509.h>
  61 #include <openssl/objects.h>
  62 #include <openssl/engine.h>
  63
  64 #ifndef OPENSSL_NO_HW
  65 #ifndef OPENSSL_NO_HW_4758_CCA
  66
  67 #ifdef FLAT_INC
  68 #include "hw_4758_cca.h"
  69 #else
  70 #include "vendor_defns/hw_4758_cca.h"
  71 #endif
  72
  73 #include "e_4758_cca_err.c"
  74
  75 static int ibm_4758_cca_destroy(ENGINE *e);
  76 static int ibm_4758_cca_init(ENGINE *e);
  77 static int ibm_4758_cca_finish(ENGINE *e);
  78 static int ibm_4758_cca_ctrl(ENGINE *e, int cmd, long i, void *p, void (*f)());
  79
  80 /* rsa functions */
  81 /*---------------*/
  82 #ifndef OPENSSL_NO_RSA
  83 static int cca_rsa_pub_enc(int flen, const unsigned char *from,
  84                 unsigned char *to, RSA *rsa,int padding);
  85 static int cca_rsa_priv_dec(int flen, const unsigned char *from,
  86                 unsigned char *to, RSA *rsa,int padding);
  87 static int cca_rsa_sign(int type, const unsigned char *m, unsigned int m_len,
  88                 unsigned char *sigret, unsigned int *siglen, const RSA *rsa);
  89 static int cca_rsa_verify(int dtype, const unsigned char *m, unsigned int m_len,
  90                 unsigned char *sigbuf, unsigned int siglen, const RSA *rsa);
  91
  92 /* utility functions */
  93 /*-----------------------*/
  94 static EVP_PKEY *ibm_4758_load_privkey(ENGINE*, const char*,
  95                 UI_METHOD *ui_method, void *callback_data);
  96 static EVP_PKEY *ibm_4758_load_pubkey(ENGINE*, const char*,
  97                 UI_METHOD *ui_method, void *callback_data);
  98
  99 static int getModulusAndExponent(const unsigned char *token, long *exponentLength,
 100                 unsigned char *exponent, long *modulusLength,
 101                 long *modulusFieldLength, unsigned char *modulus);
 102 #endif
 103
 104 /* RAND number functions */
 105 /*-----------------------*/
 106 static int cca_get_random_bytes(unsigned char*, int );
 107 static int cca_random_status(void);
 108
 109 static void cca_ex_free(void *obj, void *item, CRYPTO_EX_DATA *ad,
 110                 int idx,long argl, void *argp);
 111
 112 /* Function pointers for CCA verbs */
 113 /*---------------------------------*/
 114 #ifndef OPENSSL_NO_RSA
 115 static F_KEYRECORDREAD keyRecordRead;
 116 static F_DIGITALSIGNATUREGENERATE digitalSignatureGenerate;
 117 static F_DIGITALSIGNATUREVERIFY digitalSignatureVerify;
 118 static F_PUBLICKEYEXTRACT publicKeyExtract;
 119 static F_PKAENCRYPT pkaEncrypt;
 120 static F_PKADECRYPT pkaDecrypt;
 121 #endif
 122 static F_RANDOMNUMBERGENERATE randomNumberGenerate;
 123
 124 /* static variables */
 125 /*------------------*/
 126 static const char *CCA4758_LIB_NAME = NULL;
 127 static const char *get_CCA4758_LIB_NAME(void)
 128         {
 129         if(CCA4758_LIB_NAME)
 130                 return CCA4758_LIB_NAME;
 131         return CCA_LIB_NAME;
 132         }
 133 static void free_CCA4758_LIB_NAME(void)
 134         {
 135         if(CCA4758_LIB_NAME)
 136                 OPENSSL_free((void*)CCA4758_LIB_NAME);
 137         CCA4758_LIB_NAME = NULL;
 138         }
 139 static long set_CCA4758_LIB_NAME(const char *name)
 140         {
 141         free_CCA4758_LIB_NAME();
 142         return (((CCA4758_LIB_NAME = BUF_strdup(name)) != NULL) ? 1 : 0);
 143         }
 144 #ifndef OPENSSL_NO_RSA
 145 static const char* n_keyRecordRead = CSNDKRR;
 146 static const char* n_digitalSignatureGenerate = CSNDDSG;
 147 static const char* n_digitalSignatureVerify = CSNDDSV;
 148 static const char* n_publicKeyExtract = CSNDPKX;
 149 static const char* n_pkaEncrypt = CSNDPKE;
 150 static const char* n_pkaDecrypt = CSNDPKD;
 151 #endif
 152 static const char* n_randomNumberGenerate = CSNBRNG;
 153
 154 static int hndidx = -1;
 155 static DSO *dso = NULL;
 156
 157 /* openssl engine initialization structures */
 158 /*------------------------------------------*/
 159
 160 #define CCA4758_CMD_SO_PATH             ENGINE_CMD_BASE
 161 static const ENGINE_CMD_DEFN    cca4758_cmd_defns[] = {
 162         {CCA4758_CMD_SO_PATH,
 163                 "SO_PATH",
 164                 "Specifies the path to the '4758cca' shared library",
 165                 ENGINE_CMD_FLAG_STRING},
 166         {0, NULL, NULL, 0}
 167         };
 168
 169 #ifndef OPENSSL_NO_RSA
 170 static RSA_METHOD ibm_4758_cca_rsa =
 171         {
 172         "IBM 4758 CCA RSA method",
 173         cca_rsa_pub_enc,
 174         NULL,
 175         NULL,
 176         cca_rsa_priv_dec,
 177         NULL, /*rsa_mod_exp,*/
 178         NULL, /*mod_exp_mont,*/
 179         NULL, /* init */
 180         NULL, /* finish */
 181         RSA_FLAG_SIGN_VER,        /* flags */
 182         NULL, /* app_data */
 183         cca_rsa_sign, /* rsa_sign */
 184         cca_rsa_verify  /* rsa_verify */
 185         };
 186 #endif
 187
 188 static RAND_METHOD ibm_4758_cca_rand =
 189         {
 190         /* "IBM 4758 RAND method", */
 191         NULL, /* seed */
 192         cca_get_random_bytes, /* get random bytes from the card */
 193         NULL, /* cleanup */
 194         NULL, /* add */
 195         cca_get_random_bytes, /* pseudo rand */
 196         cca_random_status, /* status */
 197         };
 198
 199 static const char *engine_4758_cca_id = "4758cca";
 200 static const char *engine_4758_cca_name = "IBM 4758 CCA hardware engine support";
 201
 202 /* engine implementation */
 203 /*-----------------------*/
 204 static int bind_helper(ENGINE *e)
 205         {
 206         if(!ENGINE_set_id(e, engine_4758_cca_id) ||
 207                         !ENGINE_set_name(e, engine_4758_cca_name) ||
 208 #ifndef OPENSSL_NO_RSA
 209                         !ENGINE_set_RSA(e, &ibm_4758_cca_rsa) ||
 210 #endif
 211                         !ENGINE_set_RAND(e, &ibm_4758_cca_rand) ||
 212                         !ENGINE_set_destroy_function(e, ibm_4758_cca_destroy) ||
 213                         !ENGINE_set_init_function(e, ibm_4758_cca_init) ||
 214                         !ENGINE_set_finish_function(e, ibm_4758_cca_finish) ||
 215                         !ENGINE_set_ctrl_function(e, ibm_4758_cca_ctrl) ||
 216                         !ENGINE_set_load_privkey_function(e, ibm_4758_load_privkey) ||
 217                         !ENGINE_set_load_pubkey_function(e, ibm_4758_load_pubkey) ||
 218                         !ENGINE_set_cmd_defns(e, cca4758_cmd_defns))
 219                 return 0;
 220         /* Ensure the error handling is set up */
 221         ERR_load_CCA4758_strings();
 222         return 1;
 223         }
 224
 225 static ENGINE *engine_4758_cca(void)
 226         {
 227         ENGINE *ret = ENGINE_new();
 228         if(!ret)
 229                 return NULL;
 230         if(!bind_helper(ret))
 231                 {
 232                 ENGINE_free(ret);
 233                 return NULL;
 234                 }
 235         return ret;
 236         }
 237
 238 void ENGINE_load_4758cca(void)
 239         {
 240         ENGINE *e_4758 = engine_4758_cca();
 241         if (!e_4758) return;
 242         ENGINE_add(e_4758);
 243         ENGINE_free(e_4758);
 244         ERR_clear_error();
 245         }
 246
 247 static int ibm_4758_cca_destroy(ENGINE *e)
 248         {
 249         ERR_unload_CCA4758_strings();
 250         free_CCA4758_LIB_NAME();
 251         return 1;
 252         }
 253
 254 static int ibm_4758_cca_init(ENGINE *e)
 255         {
 256         if(dso)
 257                 {
 258                 CCA4758err(CCA4758_F_IBM_4758_CCA_INIT,CCA4758_R_ALREADY_LOADED);
 259                 goto err;
 260                 }
 261
 262         dso = DSO_load(NULL, get_CCA4758_LIB_NAME(), NULL, 0);
 263         if(!dso)
 264                 {
 265                 CCA4758err(CCA4758_F_IBM_4758_CCA_INIT,CCA4758_R_DSO_FAILURE);
 266                 goto err;
 267                 }
 268
 269 #ifndef OPENSSL_NO_RSA
 270         if(!(keyRecordRead = (F_KEYRECORDREAD)
 271                                 DSO_bind_func(dso, n_keyRecordRead)) ||
 272                         !(randomNumberGenerate = (F_RANDOMNUMBERGENERATE)
 273                                 DSO_bind_func(dso, n_randomNumberGenerate)) ||
 274                         !(digitalSignatureGenerate = (F_DIGITALSIGNATUREGENERATE)
 275                                 DSO_bind_func(dso, n_digitalSignatureGenerate)) ||
 276                         !(digitalSignatureVerify = (F_DIGITALSIGNATUREVERIFY)
 277                                 DSO_bind_func(dso, n_digitalSignatureVerify)) ||
 278                         !(publicKeyExtract = (F_PUBLICKEYEXTRACT)
 279                                 DSO_bind_func(dso, n_publicKeyExtract)) ||
 280                         !(pkaEncrypt = (F_PKAENCRYPT)
 281                                 DSO_bind_func(dso, n_pkaEncrypt)) ||
 282                         !(pkaDecrypt = (F_PKADECRYPT)
 283                                 DSO_bind_func(dso, n_pkaDecrypt)))
 284                 {
 285                 CCA4758err(CCA4758_F_IBM_4758_CCA_INIT,CCA4758_R_DSO_FAILURE);
 286                 goto err;
 287                 }
 288 #else
 289         if(!(randomNumberGenerate = (F_RANDOMNUMBERGENERATE)
 290                                 DSO_bind_func(dso, n_randomNumberGenerate)))
 291                 {
 292                 CCA4758err(CCA4758_F_IBM_4758_CCA_INIT,CCA4758_R_DSO_FAILURE);
 293                 goto err;
 294                 }
 295 #endif
 296
 297         hndidx = RSA_get_ex_new_index(0, "IBM 4758 CCA RSA key handle",
 298                 NULL, NULL, cca_ex_free);
 299
 300         return 1;
 301 err:
 302         if(dso)
 303                 DSO_free(dso);
 304         dso = NULL;
 305
 306         keyRecordRead = (F_KEYRECORDREAD)0;
 307         randomNumberGenerate = (F_RANDOMNUMBERGENERATE)0;
 308         digitalSignatureGenerate = (F_DIGITALSIGNATUREGENERATE)0;
 309         digitalSignatureVerify = (F_DIGITALSIGNATUREVERIFY)0;
 310         publicKeyExtract = (F_PUBLICKEYEXTRACT)0;
 311         pkaEncrypt = (F_PKAENCRYPT)0;
 312         pkaDecrypt = (F_PKADECRYPT)0;
 313         return 0;
 314         }
 315
 316 static int ibm_4758_cca_finish(ENGINE *e)
 317         {
 318         free_CCA4758_LIB_NAME();
 319         if(!dso)
 320                 {
 321                 CCA4758err(CCA4758_F_IBM_4758_CCA_FINISH,
 322                                 CCA4758_R_NOT_LOADED);
 323                 return 0;
 324                 }
 325         if(!DSO_free(dso))
 326                 {
 327                 CCA4758err(CCA4758_F_IBM_4758_CCA_FINISH,
 328                                 CCA4758_R_UNIT_FAILURE);
 329                 return 0;
 330                 }
 331         dso = NULL;
 332         keyRecordRead = (F_KEYRECORDREAD)0;
 333         randomNumberGenerate = (F_RANDOMNUMBERGENERATE)0;
 334         digitalSignatureGenerate = (F_DIGITALSIGNATUREGENERATE)0;
 335         digitalSignatureVerify = (F_DIGITALSIGNATUREVERIFY)0;
 336         publicKeyExtract = (F_PUBLICKEYEXTRACT)0;
 337         pkaEncrypt = (F_PKAENCRYPT)0;
 338         pkaDecrypt = (F_PKADECRYPT)0;
 339         return 1;
 340         }
 341
 342 static int ibm_4758_cca_ctrl(ENGINE *e, int cmd, long i, void *p, void (*f)())
 343         {
 344         int initialised = ((dso == NULL) ? 0 : 1);
 345         switch(cmd)
 346                 {
 347         case CCA4758_CMD_SO_PATH:
 348                 if(p == NULL)
 349                         {
 350                         CCA4758err(CCA4758_F_IBM_4758_CCA_CTRL,
 351                                         ERR_R_PASSED_NULL_PARAMETER);
 352                         return 0;
 353                         }
 354                 if(initialised)
 355                         {
 356                         CCA4758err(CCA4758_F_IBM_4758_CCA_CTRL,
 357                                         CCA4758_R_ALREADY_LOADED);
 358                         return 0;
 359                         }
 360                 return set_CCA4758_LIB_NAME((const char *)p);
 361         default:
 362                 break;
 363                 }
 364         CCA4758err(CCA4758_F_IBM_4758_CCA_CTRL,
 365                         CCA4758_R_COMMAND_NOT_IMPLEMENTED);
 366         return 0;
 367         }
 368
 369 #ifndef OPENSSL_NO_RSA
 370
 371 #define MAX_CCA_PKA_TOKEN_SIZE 2500
 372
 373 static EVP_PKEY *ibm_4758_load_privkey(ENGINE* e, const char* key_id,
 374                         UI_METHOD *ui_method, void *callback_data)
 375         {
 376         RSA *rtmp = NULL;
 377         EVP_PKEY *res = NULL;
 378         unsigned char* keyToken = NULL;
 379         unsigned char pubKeyToken[MAX_CCA_PKA_TOKEN_SIZE];
 380         long pubKeyTokenLength = MAX_CCA_PKA_TOKEN_SIZE;
 381         long keyTokenLength = MAX_CCA_PKA_TOKEN_SIZE;
 382         long returnCode;
 383         long reasonCode;
 384         long exitDataLength = 0;
 385         long ruleArrayLength = 0;
 386         unsigned char exitData[8];
 387         unsigned char ruleArray[8];
 388         unsigned char keyLabel[64];
 389         long keyLabelLength = strlen(key_id);
 390         unsigned char modulus[256];
 391         long modulusFieldLength = sizeof(modulus);
 392         long modulusLength = 0;
 393         unsigned char exponent[256];
 394         long exponentLength = sizeof(exponent);
 395
 396         if (keyLabelLength > sizeof(keyLabel))
 397                 {
 398                 CCA4758err(CCA4758_F_IBM_4758_CCA_LOAD_PRIVKEY,
 399                 CCA4758_R_SIZE_TOO_LARGE_OR_TOO_SMALL);
 400                 return NULL;
 401                 }
 402
 403         memset(keyLabel,' ', sizeof(keyLabel));
 404         memcpy(keyLabel, key_id, keyLabelLength);
 405
 406         keyToken = OPENSSL_malloc(MAX_CCA_PKA_TOKEN_SIZE + sizeof(long));
 407         if (!keyToken)
 408                 {
 409                 CCA4758err(CCA4758_F_IBM_4758_CCA_LOAD_PRIVKEY,
 410                                 ERR_R_MALLOC_FAILURE);
 411                 goto err;
 412                 }
 413
 414         keyRecordRead(&returnCode, &reasonCode, &exitDataLength,
 415                 exitData, &ruleArrayLength, ruleArray, keyLabel,
 416                 &keyTokenLength, keyToken+sizeof(long));
 417
 418         if (returnCode)
 419                 {
 420                 CCA4758err(CCA4758_F_IBM_4758_CCA_LOAD_PRIVKEY,
 421                         CCA4758_R_FAILED_LOADING_PRIVATE_KEY);
 422                 goto err;
 423                 }
 424
 425         publicKeyExtract(&returnCode, &reasonCode, &exitDataLength,
 426                 exitData, &ruleArrayLength, ruleArray, &keyTokenLength,
 427                 keyToken+sizeof(long), &pubKeyTokenLength, pubKeyToken);
 428
 429         if (returnCode)
 430                 {
 431                 CCA4758err(CCA4758_F_IBM_4758_CCA_LOAD_PRIVKEY,
 432                         CCA4758_R_FAILED_LOADING_PRIVATE_KEY);
 433                 goto err;
 434                 }
 435
 436         if (!getModulusAndExponent(pubKeyToken, &exponentLength,
 437                         exponent, &modulusLength, &modulusFieldLength,
 438                         modulus))
 439                 {
 440                 CCA4758err(CCA4758_F_IBM_4758_CCA_LOAD_PRIVKEY,
 441                         CCA4758_R_FAILED_LOADING_PRIVATE_KEY);
 442                 goto err;
 443                 }
 444
 445         (*(long*)keyToken) = keyTokenLength;
 446         rtmp = RSA_new_method(e);
 447         RSA_set_ex_data(rtmp, hndidx, (char *)keyToken);
 448
 449         rtmp->e = BN_bin2bn(exponent, exponentLength, NULL);
 450         rtmp->n = BN_bin2bn(modulus, modulusFieldLength, NULL);
 451         rtmp->flags |= RSA_FLAG_EXT_PKEY;
 452
 453         res = EVP_PKEY_new();
 454         EVP_PKEY_assign_RSA(res, rtmp);
 455
 456         return res;
 457 err:
 458         if (keyToken)
 459                 OPENSSL_free(keyToken);
 460         if (res)
 461                 EVP_PKEY_free(res);
 462         if (rtmp)
 463                 RSA_free(rtmp);
 464         return NULL;
 465         }
 466
 467 static EVP_PKEY *ibm_4758_load_pubkey(ENGINE* e, const char* key_id,
 468                         UI_METHOD *ui_method, void *callback_data)
 469         {
 470         RSA *rtmp = NULL;
 471         EVP_PKEY *res = NULL;
 472         unsigned char* keyToken = NULL;
 473         long keyTokenLength = MAX_CCA_PKA_TOKEN_SIZE;
 474         long returnCode;
 475         long reasonCode;
 476         long exitDataLength = 0;
 477         long ruleArrayLength = 0;
 478         unsigned char exitData[8];
 479         unsigned char ruleArray[8];
 480         unsigned char keyLabel[64];
 481         long keyLabelLength = strlen(key_id);
 482         unsigned char modulus[512];
 483         long modulusFieldLength = sizeof(modulus);
 484         long modulusLength = 0;
 485         unsigned char exponent[512];
 486         long exponentLength = sizeof(exponent);
 487
 488         if (keyLabelLength > sizeof(keyLabel))
 489                 {
 490                 CCA4758err(CCA4758_F_IBM_4758_CCA_LOAD_PRIVKEY,
 491                         CCA4758_R_SIZE_TOO_LARGE_OR_TOO_SMALL);
 492                 return NULL;
 493                 }
 494
 495         memset(keyLabel,' ', sizeof(keyLabel));
 496         memcpy(keyLabel, key_id, keyLabelLength);
 497
 498         keyToken = OPENSSL_malloc(MAX_CCA_PKA_TOKEN_SIZE + sizeof(long));
 499         if (!keyToken)
 500                 {
 501                 CCA4758err(CCA4758_F_IBM_4758_CCA_LOAD_PUBKEY,
 502                                 ERR_R_MALLOC_FAILURE);
 503                 goto err;
 504                 }
 505
 506         keyRecordRead(&returnCode, &reasonCode, &exitDataLength, exitData,
 507                 &ruleArrayLength, ruleArray, keyLabel, &keyTokenLength,
 508                 keyToken+sizeof(long));
 509
 510         if (returnCode)
 511                 {
 512                 CCA4758err(CCA4758_F_IBM_4758_CCA_LOAD_PRIVKEY,
 513                                 ERR_R_MALLOC_FAILURE);
 514                 goto err;
 515                 }
 516
 517         if (!getModulusAndExponent(keyToken+sizeof(long), &exponentLength,
 518                         exponent, &modulusLength, &modulusFieldLength, modulus))
 519                 {
 520                 CCA4758err(CCA4758_F_IBM_4758_CCA_LOAD_PRIVKEY,
 521                         CCA4758_R_FAILED_LOADING_PUBLIC_KEY);
 522                 goto err;
 523                 }
 524
 525         (*(long*)keyToken) = keyTokenLength;
 526         rtmp = RSA_new_method(e);
 527         RSA_set_ex_data(rtmp, hndidx, (char *)keyToken);
 528         rtmp->e = BN_bin2bn(exponent, exponentLength, NULL);
 529         rtmp->n = BN_bin2bn(modulus, modulusFieldLength, NULL);
 530         rtmp->flags |= RSA_FLAG_EXT_PKEY;
 531         res = EVP_PKEY_new();
 532         EVP_PKEY_assign_RSA(res, rtmp);
 533
 534         return res;
 535 err:
 536         if (keyToken)
 537                 OPENSSL_free(keyToken);
 538         if (res)
 539                 EVP_PKEY_free(res);
 540         if (rtmp)
 541                 RSA_free(rtmp);
 542         return NULL;
 543         }
 544
 545 static int cca_rsa_pub_enc(int flen, const unsigned char *from,
 546                         unsigned char *to, RSA *rsa,int padding)
 547         {
 548         long returnCode;
 549         long reasonCode;
 550         long lflen = flen;
 551         long exitDataLength = 0;
 552         unsigned char exitData[8];
 553         long ruleArrayLength = 1;
 554         unsigned char ruleArray[8] = "PKCS-1.2";
 555         long dataStructureLength = 0;
 556         unsigned char dataStructure[8];
 557         long outputLength = RSA_size(rsa);
 558         long keyTokenLength;
 559         unsigned char* keyToken = (unsigned char*)RSA_get_ex_data(rsa, hndidx);
 560
 561         keyTokenLength = *(long*)keyToken;
 562         keyToken+=sizeof(long);
 563
 564         pkaEncrypt(&returnCode, &reasonCode, &exitDataLength, exitData,
 565                 &ruleArrayLength, ruleArray, &lflen, (unsigned char*)from,
 566                 &dataStructureLength, dataStructure, &keyTokenLength,
 567                 keyToken, &outputLength, to);
 568
 569         if (returnCode || reasonCode)
 570                 return -(returnCode << 16 | reasonCode);
 571         return outputLength;
 572         }
 573
 574 static int cca_rsa_priv_dec(int flen, const unsigned char *from,
 575                         unsigned char *to, RSA *rsa,int padding)
 576         {
 577         long returnCode;
 578         long reasonCode;
 579         long lflen = flen;
 580         long exitDataLength = 0;
 581         unsigned char exitData[8];
 582         long ruleArrayLength = 1;
 583         unsigned char ruleArray[8] = "PKCS-1.2";
 584         long dataStructureLength = 0;
 585         unsigned char dataStructure[8];
 586         long outputLength = RSA_size(rsa);
 587         long keyTokenLength;
 588         unsigned char* keyToken = (unsigned char*)RSA_get_ex_data(rsa, hndidx);
 589
 590         keyTokenLength = *(long*)keyToken;
 591         keyToken+=sizeof(long);
 592
 593         pkaDecrypt(&returnCode, &reasonCode, &exitDataLength, exitData,
 594                 &ruleArrayLength, ruleArray, &lflen, (unsigned char*)from,
 595                 &dataStructureLength, dataStructure, &keyTokenLength,
 596                 keyToken, &outputLength, to);
 597
 598         return (returnCode | reasonCode) ? 0 : 1;
 599         }
 600
 601 #define SSL_SIG_LEN 36
 602
 603 static int cca_rsa_verify(int type, const unsigned char *m, unsigned int m_len,
 604                 unsigned char *sigbuf, unsigned int siglen, const RSA *rsa)
 605         {
 606         long returnCode;
 607         long reasonCode;
 608         long lsiglen = siglen;
 609         long exitDataLength = 0;
 610         unsigned char exitData[8];
 611         long ruleArrayLength = 1;
 612         unsigned char ruleArray[8] = "PKCS-1.1";
 613         long keyTokenLength;
 614         unsigned char* keyToken = (unsigned char*)RSA_get_ex_data(rsa, hndidx);
 615         long length = SSL_SIG_LEN;
 616         long keyLength ;
 617         unsigned char *hashBuffer = NULL;
 618         X509_SIG sig;
 619         ASN1_TYPE parameter;
 620         X509_ALGOR algorithm;
 621         ASN1_OCTET_STRING digest;
 622
 623         keyTokenLength = *(long*)keyToken;
 624         keyToken+=sizeof(long);
 625
 626         if (type == NID_md5 || type == NID_sha1)
 627                 {
 628                 sig.algor = &algorithm;
 629                 algorithm.algorithm = OBJ_nid2obj(type);
 630
 631                 if (!algorithm.algorithm)
 632                         {
 633                         CCA4758err(CCA4758_F_IBM_4758_CCA_VERIFY,
 634                                 CCA4758_R_UNKNOWN_ALGORITHM_TYPE);
 635                         return 0;
 636                         }
 637
 638                 if (!algorithm.algorithm->length)
 639                         {
 640                         CCA4758err(CCA4758_F_IBM_4758_CCA_VERIFY,
 641                                 CCA4758_R_ASN1_OID_UNKNOWN_FOR_MD);
 642                         return 0;
 643                         }
 644
 645                 parameter.type = V_ASN1_NULL;
 646                 parameter.value.ptr = NULL;
 647                 algorithm.parameter = &parameter;
 648
 649                 sig.digest = &digest;
 650                 sig.digest->data = (unsigned char*)m;
 651                 sig.digest->length = m_len;
 652
 653                 length = i2d_X509_SIG(&sig, NULL);
 654                 }
 655
 656         keyLength = RSA_size(rsa);
 657
 658         if (length - RSA_PKCS1_PADDING > keyLength)
 659                 {
 660                 CCA4758err(CCA4758_F_IBM_4758_CCA_VERIFY,
 661                         CCA4758_R_SIZE_TOO_LARGE_OR_TOO_SMALL);
 662                 return 0;
 663                 }
 664
 665         switch (type)
 666                 {
 667                 case NID_md5_sha1 :
 668                         if (m_len != SSL_SIG_LEN)
 669                                 {
 670                                 CCA4758err(CCA4758_F_IBM_4758_CCA_VERIFY,
 671                                 CCA4758_R_SIZE_TOO_LARGE_OR_TOO_SMALL);
 672                                 return 0;
 673                                 }
 674
 675                         hashBuffer = (unsigned char *)m;
 676                         length = m_len;
 677                         break;
 678                 case NID_md5 :
 679                         {
 680                         unsigned char *ptr;
 681                         ptr = hashBuffer = OPENSSL_malloc(
 682                                         (unsigned int)keyLength+1);
 683                         if (!hashBuffer)
 684                                 {
 685                                 CCA4758err(CCA4758_F_IBM_4758_CCA_VERIFY,
 686                                                 ERR_R_MALLOC_FAILURE);
 687                                 return 0;
 688                                 }
 689
 690                         i2d_X509_SIG(&sig, &ptr);
 691                         }
 692                         break;
 693                 case NID_sha1 :
 694                         {
 695                         unsigned char *ptr;
 696                         ptr = hashBuffer = OPENSSL_malloc(
 697                                         (unsigned int)keyLength+1);
 698                         if (!hashBuffer)
 699                                 {
 700                                 CCA4758err(CCA4758_F_IBM_4758_CCA_VERIFY,
 701                                                 ERR_R_MALLOC_FAILURE);
 702                                 return 0;
 703                                 }
 704                         i2d_X509_SIG(&sig, &ptr);
 705                         }
 706                         break;
 707                 default:
 708                         return 0;
 709                 }
 710
 711         digitalSignatureVerify(&returnCode, &reasonCode, &exitDataLength,
 712                 exitData, &ruleArrayLength, ruleArray, &keyTokenLength,
 713                 keyToken, &length, hashBuffer, &lsiglen, sigbuf);
 714
 715         if (type == NID_sha1 || type == NID_md5)
 716                 {
 717                 memset(hashBuffer, 0, keyLength+1);
 718                 OPENSSL_free(hashBuffer);
 719                 }
 720
 721         return ((returnCode || reasonCode) ? 0 : 1);
 722         }
 723
 724 #define SSL_SIG_LEN 36
 725
 726 static int cca_rsa_sign(int type, const unsigned char *m, unsigned int m_len,
 727                 unsigned char *sigret, unsigned int *siglen, const RSA *rsa)
 728         {
 729         long returnCode;
 730         long reasonCode;
 731         long exitDataLength = 0;
 732         unsigned char exitData[8];
 733         long ruleArrayLength = 1;
 734         unsigned char ruleArray[8] = "PKCS-1.1";
 735         long outputLength=256;
 736         long outputBitLength;
 737         long keyTokenLength;
 738         unsigned char *hashBuffer = NULL;
 739         unsigned char* keyToken = (unsigned char*)RSA_get_ex_data(rsa, hndidx);
 740         long length = SSL_SIG_LEN;
 741         long keyLength ;
 742         X509_SIG sig;
 743         ASN1_TYPE parameter;
 744         X509_ALGOR algorithm;
 745         ASN1_OCTET_STRING digest;
 746
 747         keyTokenLength = *(long*)keyToken;
 748         keyToken+=sizeof(long);
 749
 750         if (type == NID_md5 || type == NID_sha1)
 751                 {
 752                 sig.algor = &algorithm;
 753                 algorithm.algorithm = OBJ_nid2obj(type);
 754
 755                 if (!algorithm.algorithm)
 756                         {
 757                         CCA4758err(CCA4758_F_IBM_4758_CCA_SIGN,
 758                                 CCA4758_R_UNKNOWN_ALGORITHM_TYPE);
 759                         return 0;
 760                         }
 761
 762                 if (!algorithm.algorithm->length)
 763                         {
 764                         CCA4758err(CCA4758_F_IBM_4758_CCA_SIGN,
 765                                 CCA4758_R_ASN1_OID_UNKNOWN_FOR_MD);
 766                         return 0;
 767                         }
 768
 769                 parameter.type = V_ASN1_NULL;
 770                 parameter.value.ptr = NULL;
 771                 algorithm.parameter = &parameter;
 772
 773                 sig.digest = &digest;
 774                 sig.digest->data = (unsigned char*)m;
 775                 sig.digest->length = m_len;
 776
 777                 length = i2d_X509_SIG(&sig, NULL);
 778                 }
 779
 780         keyLength = RSA_size(rsa);
 781
 782         if (length - RSA_PKCS1_PADDING > keyLength)
 783                 {
 784                 CCA4758err(CCA4758_F_IBM_4758_CCA_SIGN,
 785                         CCA4758_R_SIZE_TOO_LARGE_OR_TOO_SMALL);
 786                 return 0;
 787                 }
 788
 789         switch (type)
 790                 {
 791                 case NID_md5_sha1 :
 792                         if (m_len != SSL_SIG_LEN)
 793                                 {
 794                                 CCA4758err(CCA4758_F_IBM_4758_CCA_SIGN,
 795                                 CCA4758_R_SIZE_TOO_LARGE_OR_TOO_SMALL);
 796                                 return 0;
 797                                 }
 798                         hashBuffer = (unsigned char*)m;
 799                         length = m_len;
 800                         break;
 801                 case NID_md5 :
 802                         {
 803                         unsigned char *ptr;
 804                         ptr = hashBuffer = OPENSSL_malloc(
 805                                         (unsigned int)keyLength+1);
 806                         if (!hashBuffer)
 807                                 {
 808                                 CCA4758err(CCA4758_F_IBM_4758_CCA_VERIFY,
 809                                                 ERR_R_MALLOC_FAILURE);
 810                                 return 0;
 811                                 }
 812                         i2d_X509_SIG(&sig, &ptr);
 813                         }
 814                         break;
 815                 case NID_sha1 :
 816                         {
 817                         unsigned char *ptr;
 818                         ptr = hashBuffer = OPENSSL_malloc(
 819                                         (unsigned int)keyLength+1);
 820                         if (!hashBuffer)
 821                                 {
 822                                 CCA4758err(CCA4758_F_IBM_4758_CCA_VERIFY,
 823                                                 ERR_R_MALLOC_FAILURE);
 824                                 return 0;
 825                                 }
 826                         i2d_X509_SIG(&sig, &ptr);
 827                         }
 828                         break;
 829                 default:
 830                         return 0;
 831                 }
 832
 833         digitalSignatureGenerate(&returnCode, &reasonCode, &exitDataLength,
 834                 exitData, &ruleArrayLength, ruleArray, &keyTokenLength,
 835                 keyToken, &length, hashBuffer, &outputLength, &outputBitLength,
 836                 sigret);
 837
 838         if (type == NID_sha1 || type == NID_md5)
 839                 {
 840                 memset(hashBuffer, 0, keyLength+1);
 841                 OPENSSL_free(hashBuffer);
 842                 }
 843
 844         *siglen = outputLength;
 845
 846         return ((returnCode || reasonCode) ? 0 : 1);
 847         }
 848
 849 static int getModulusAndExponent(const unsigned char*token, long *exponentLength,
 850                 unsigned char *exponent, long *modulusLength, long *modulusFieldLength,
 851                 unsigned char *modulus)
 852         {
 853         unsigned long len;
 854
 855         if (*token++ != (char)0x1E) /* internal PKA token? */
 856                 return 0;
 857
 858         if (*token++) /* token version must be zero */
 859                 return 0;
 860
 861         len = *token++;
 862         len = len << 8;
 863         len |= (unsigned char)*token++;
 864
 865         token += 4; /* skip reserved bytes */
 866
 867         if (*token++ == (char)0x04)
 868                 {
 869                 if (*token++) /* token version must be zero */
 870                         return 0;
 871
 872                 len = *token++;
 873                 len = len << 8;
 874                 len |= (unsigned char)*token++;
 875
 876                 token+=2; /* skip reserved section */
 877
 878                 len = *token++;
 879                 len = len << 8;
 880                 len |= (unsigned char)*token++;
 881
 882                 *exponentLength = len;
 883
 884                 len = *token++;
 885                 len = len << 8;
 886                 len |= (unsigned char)*token++;
 887
 888                 *modulusLength = len;
 889
 890                 len = *token++;
 891                 len = len << 8;
 892                 len |= (unsigned char)*token++;
 893
 894                 *modulusFieldLength = len;
 895
 896                 memcpy(exponent, token, *exponentLength);
 897                 token+= *exponentLength;
 898
 899                 memcpy(modulus, token, *modulusFieldLength);
 900                 return 1;
 901                 }
 902         return 0;
 903         }
 904
 905 #endif /* OPENSSL_NO_RSA */
 906
 907 static int cca_random_status(void)
 908         {
 909         return 1;
 910         }
 911
 912 static int cca_get_random_bytes(unsigned char* buf, int num)
 913         {
 914         long ret_code;
 915         long reason_code;
 916         long exit_data_length;
 917         unsigned char exit_data[4];
 918         unsigned char form[] = "RANDOM  ";
 919         unsigned char rand_buf[8];
 920
 921         while(num >= sizeof(rand_buf))
 922                 {
 923                 randomNumberGenerate(&ret_code, &reason_code, &exit_data_length,
 924                         exit_data, form, rand_buf);
 925                 if (ret_code)
 926                         return 0;
 927                 num -= sizeof(rand_buf);
 928                 memcpy(buf, rand_buf, sizeof(rand_buf));
 929                 buf += sizeof(rand_buf);
 930                 }
 931
 932         if (num)
 933                 {
 934                 randomNumberGenerate(&ret_code, &reason_code, NULL, NULL,
 935                         form, rand_buf);
 936                 if (ret_code)
 937                         return 0;
 938                 memcpy(buf, rand_buf, num);
 939                 }
 940
 941         return 1;
 942         }
 943
 944 static void cca_ex_free(void *obj, void *item, CRYPTO_EX_DATA *ad, int idx,
 945                 long argl, void *argp)
 946         {
 947         if (item)
 948                 OPENSSL_free(item);
 949         }
 950
 951 /* Goo to handle building as a dynamic engine */
 952 #ifndef OPENSSL_NO_DYNAMIC_ENGINE
 953 static int bind_fn(ENGINE *e, const char *id)
 954         {
 955         if(id && (strcmp(id, engine_4758_cca_id) != 0))
 956                 return 0;
 957         if(!bind_helper(e))
 958                 return 0;
 959         return 1;
 960         }
 961 IMPLEMENT_DYNAMIC_CHECK_FN()
 962 IMPLEMENT_DYNAMIC_BIND_FN(bind_fn)
 963 #endif /* OPENSSL_NO_DYNAMIC_ENGINE */
 964
 965 #endif /* !OPENSSL_NO_HW_4758_CCA */
 966 #endif /* !OPENSSL_NO_HW */