fb5b8dbad842a381984fca5f1c3ebec730eb0d44
[openssl.git] / 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 */