Typo
[openssl.git] / engines / e_ncipher.c
1 /* crypto/engine/hw_ncipher.c -*- mode: C; c-file-style: "eay" -*- */
2 /* Written by Richard Levitte (richard@levitte.org), Geoff Thorpe
3  * (geoff@geoffthorpe.net) and Dr Stephen N Henson (shenson@bigfoot.com)
4  * for the OpenSSL project 2000.
5  */
6 /* ====================================================================
7  * Copyright (c) 1999-2001 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 #include <stdio.h>
61 #include <string.h>
62 #include <openssl/crypto.h>
63 #include <openssl/pem.h>
64 #include <openssl/dso.h>
65 #include <openssl/engine.h>
66 #include <openssl/ui.h>
67
68 #ifndef OPENSSL_NO_HW
69 #ifndef OPENSSL_NO_HW_NCIPHER
70
71 /* Attribution notice: nCipher have said several times that it's OK for
72  * us to implement a general interface to their boxes, and recently declared
73  * their HWCryptoHook to be public, and therefore available for us to use.
74  * Thanks, nCipher.
75  *
76  * The hwcryptohook.h included here is from May 2000.
77  * [Richard Levitte]
78  */
79 #ifdef FLAT_INC
80 #include "hwcryptohook.h"
81 #else
82 #include "vendor_defns/hwcryptohook.h"
83 #endif
84
85 #define HWCRHK_LIB_NAME "hwcrhk engine"
86 #include "e_ncipher_err.c"
87
88 static int hwcrhk_destroy(ENGINE *e);
89 static int hwcrhk_init(ENGINE *e);
90 static int hwcrhk_finish(ENGINE *e);
91 static int hwcrhk_ctrl(ENGINE *e, int cmd, long i, void *p, void (*f)()); 
92
93 /* Functions to handle mutexes */
94 static int hwcrhk_mutex_init(HWCryptoHook_Mutex*, HWCryptoHook_CallerContext*);
95 static int hwcrhk_mutex_lock(HWCryptoHook_Mutex*);
96 static void hwcrhk_mutex_unlock(HWCryptoHook_Mutex*);
97 static void hwcrhk_mutex_destroy(HWCryptoHook_Mutex*);
98
99 /* BIGNUM stuff */
100 static int hwcrhk_mod_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
101                 const BIGNUM *m, BN_CTX *ctx);
102
103 #ifndef OPENSSL_NO_RSA
104 /* RSA stuff */
105 static int hwcrhk_rsa_mod_exp(BIGNUM *r, const BIGNUM *I, RSA *rsa);
106 #endif
107 /* This function is aliased to mod_exp (with the mont stuff dropped). */
108 static int hwcrhk_mod_exp_mont(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
109                 const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx);
110
111 #ifndef OPENSSL_NO_DH
112 /* DH stuff */
113 /* This function is alised to mod_exp (with the DH and mont dropped). */
114 static int hwcrhk_mod_exp_dh(const DH *dh, BIGNUM *r,
115         const BIGNUM *a, const BIGNUM *p,
116         const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx);
117 #endif
118
119 /* RAND stuff */
120 static int hwcrhk_rand_bytes(unsigned char *buf, int num);
121 static int hwcrhk_rand_status(void);
122
123 /* KM stuff */
124 static EVP_PKEY *hwcrhk_load_privkey(ENGINE *eng, const char *key_id,
125         UI_METHOD *ui_method, void *callback_data);
126 static EVP_PKEY *hwcrhk_load_pubkey(ENGINE *eng, const char *key_id,
127         UI_METHOD *ui_method, void *callback_data);
128 static void hwcrhk_ex_free(void *obj, void *item, CRYPTO_EX_DATA *ad,
129         int ind,long argl, void *argp);
130
131 /* Interaction stuff */
132 static int hwcrhk_insert_card(const char *prompt_info,
133         const char *wrong_info,
134         HWCryptoHook_PassphraseContext *ppctx,
135         HWCryptoHook_CallerContext *cactx);
136 static int hwcrhk_get_pass(const char *prompt_info,
137         int *len_io, char *buf,
138         HWCryptoHook_PassphraseContext *ppctx,
139         HWCryptoHook_CallerContext *cactx);
140 static void hwcrhk_log_message(void *logstr, const char *message);
141
142 /* The definitions for control commands specific to this engine */
143 #define HWCRHK_CMD_SO_PATH              ENGINE_CMD_BASE
144 #define HWCRHK_CMD_FORK_CHECK           (ENGINE_CMD_BASE + 1)
145 #define HWCRHK_CMD_THREAD_LOCKING       (ENGINE_CMD_BASE + 2)
146 #define HWCRHK_CMD_SET_USER_INTERFACE   (ENGINE_CMD_BASE + 3)
147 #define HWCRHK_CMD_SET_CALLBACK_DATA    (ENGINE_CMD_BASE + 4)
148 static const ENGINE_CMD_DEFN hwcrhk_cmd_defns[] = {
149         {HWCRHK_CMD_SO_PATH,
150                 "SO_PATH",
151                 "Specifies the path to the 'hwcrhk' shared library",
152                 ENGINE_CMD_FLAG_STRING},
153         {HWCRHK_CMD_FORK_CHECK,
154                 "FORK_CHECK",
155                 "Turns fork() checking on or off (boolean)",
156                 ENGINE_CMD_FLAG_NUMERIC},
157         {HWCRHK_CMD_THREAD_LOCKING,
158                 "THREAD_LOCKING",
159                 "Turns thread-safe locking on or off (boolean)",
160                 ENGINE_CMD_FLAG_NUMERIC},
161         {HWCRHK_CMD_SET_USER_INTERFACE,
162                 "SET_USER_INTERFACE",
163                 "Set the global user interface (internal)",
164                 ENGINE_CMD_FLAG_INTERNAL},
165         {HWCRHK_CMD_SET_CALLBACK_DATA,
166                 "SET_CALLBACK_DATA",
167                 "Set the global user interface extra data (internal)",
168                 ENGINE_CMD_FLAG_INTERNAL},
169         {0, NULL, NULL, 0}
170         };
171
172 #ifndef OPENSSL_NO_RSA
173 /* Our internal RSA_METHOD that we provide pointers to */
174 static RSA_METHOD hwcrhk_rsa =
175         {
176         "nCipher RSA method",
177         NULL,
178         NULL,
179         NULL,
180         NULL,
181         hwcrhk_rsa_mod_exp,
182         hwcrhk_mod_exp_mont,
183         NULL,
184         NULL,
185         0,
186         NULL,
187         NULL,
188         NULL
189         };
190 #endif
191
192 #ifndef OPENSSL_NO_DH
193 /* Our internal DH_METHOD that we provide pointers to */
194 static DH_METHOD hwcrhk_dh =
195         {
196         "nCipher DH method",
197         NULL,
198         NULL,
199         hwcrhk_mod_exp_dh,
200         NULL,
201         NULL,
202         0,
203         NULL
204         };
205 #endif
206
207 static RAND_METHOD hwcrhk_rand =
208         {
209         /* "nCipher RAND method", */
210         NULL,
211         hwcrhk_rand_bytes,
212         NULL,
213         NULL,
214         hwcrhk_rand_bytes,
215         hwcrhk_rand_status,
216         };
217
218 /* Constants used when creating the ENGINE */
219 static const char *engine_hwcrhk_id = "chil";
220 static const char *engine_hwcrhk_name = "nCipher hardware engine support";
221
222 /* Internal stuff for HWCryptoHook */
223
224 /* Some structures needed for proper use of thread locks */
225 /* hwcryptohook.h has some typedefs that turn struct HWCryptoHook_MutexValue
226    into HWCryptoHook_Mutex */
227 struct HWCryptoHook_MutexValue
228         {
229         int lockid;
230         };
231
232 /* hwcryptohook.h has some typedefs that turn
233    struct HWCryptoHook_PassphraseContextValue
234    into HWCryptoHook_PassphraseContext */
235 struct HWCryptoHook_PassphraseContextValue
236         {
237         UI_METHOD *ui_method;
238         void *callback_data;
239         };
240
241 /* hwcryptohook.h has some typedefs that turn
242    struct HWCryptoHook_CallerContextValue
243    into HWCryptoHook_CallerContext */
244 struct HWCryptoHook_CallerContextValue
245         {
246         pem_password_cb *password_callback; /* Deprecated!  Only present for
247                                                backward compatibility! */
248         UI_METHOD *ui_method;
249         void *callback_data;
250         };
251
252 /* The MPI structure in HWCryptoHook is pretty compatible with OpenSSL
253    BIGNUM's, so lets define a couple of conversion macros */
254 #define BN2MPI(mp, bn) \
255     {mp.size = bn->top * sizeof(BN_ULONG); mp.buf = (unsigned char *)bn->d;}
256 #define MPI2BN(bn, mp) \
257     {mp.size = bn->dmax * sizeof(BN_ULONG); mp.buf = (unsigned char *)bn->d;}
258
259 static BIO *logstream = NULL;
260 static int disable_mutex_callbacks = 0;
261
262 /* One might wonder why these are needed, since one can pass down at least
263    a UI_METHOD and a pointer to callback data to the key-loading functions.
264    The thing is that the ModExp and RSAImmed functions can load keys as well,
265    if the data they get is in a special, nCipher-defined format (hint: if you
266    look at the private exponent of the RSA data as a string, you'll see this
267    string: "nCipher KM tool key id", followed by some bytes, followed a key
268    identity string, followed by more bytes.  This happens when you use "embed"
269    keys instead of "hwcrhk" keys).  Unfortunately, those functions do not take
270    any passphrase or caller context, and our functions can't really take any
271    callback data either.  Still, the "insert_card" and "get_passphrase"
272    callbacks may be called down the line, and will need to know what user
273    interface callbacks to call, and having callback data from the application
274    may be a nice thing as well, so we need to keep track of that globally. */
275 static HWCryptoHook_CallerContext password_context = { NULL, NULL, NULL };
276
277 /* Stuff to pass to the HWCryptoHook library */
278 static HWCryptoHook_InitInfo hwcrhk_globals = {
279         HWCryptoHook_InitFlags_SimpleForkCheck, /* Flags */
280         &logstream,             /* logstream */
281         sizeof(BN_ULONG),       /* limbsize */
282         0,                      /* mslimb first: false for BNs */
283         -1,                     /* msbyte first: use native */
284         0,                      /* Max mutexes, 0 = no small limit */
285         0,                      /* Max simultaneous, 0 = default */
286
287         /* The next few are mutex stuff: we write wrapper functions
288            around the OS mutex functions.  We initialise them to 0
289            here, and change that to actual function pointers in hwcrhk_init()
290            if dynamic locks are supported (that is, if the application
291            programmer has made sure of setting up callbacks bafore starting
292            this engine) *and* if disable_mutex_callbacks hasn't been set by
293            a call to ENGINE_ctrl(ENGINE_CTRL_CHIL_NO_LOCKING). */
294         sizeof(HWCryptoHook_Mutex),
295         0,
296         0,
297         0,
298         0,
299
300         /* The next few are condvar stuff: we write wrapper functions
301            round the OS functions.  Currently not implemented and not
302            and absolute necessity even in threaded programs, therefore
303            0'ed.  Will hopefully be implemented some day, since it
304            enhances the efficiency of HWCryptoHook.  */
305         0, /* sizeof(HWCryptoHook_CondVar), */
306         0, /* hwcrhk_cv_init, */
307         0, /* hwcrhk_cv_wait, */
308         0, /* hwcrhk_cv_signal, */
309         0, /* hwcrhk_cv_broadcast, */
310         0, /* hwcrhk_cv_destroy, */
311
312         hwcrhk_get_pass,        /* pass phrase */
313         hwcrhk_insert_card,     /* insert a card */
314         hwcrhk_log_message      /* Log message */
315 };
316
317
318 /* Now, to our own code */
319
320 /* This internal function is used by ENGINE_ncipher() and possibly by the
321  * "dynamic" ENGINE support too */
322 static int bind_helper(ENGINE *e)
323         {
324 #ifndef OPENSSL_NO_RSA
325         const RSA_METHOD *meth1;
326 #endif
327 #ifndef OPENSSL_NO_DH
328         const DH_METHOD *meth2;
329 #endif
330         if(!ENGINE_set_id(e, engine_hwcrhk_id) ||
331                         !ENGINE_set_name(e, engine_hwcrhk_name) ||
332 #ifndef OPENSSL_NO_RSA
333                         !ENGINE_set_RSA(e, &hwcrhk_rsa) ||
334 #endif
335 #ifndef OPENSSL_NO_DH
336                         !ENGINE_set_DH(e, &hwcrhk_dh) ||
337 #endif
338                         !ENGINE_set_RAND(e, &hwcrhk_rand) ||
339                         !ENGINE_set_destroy_function(e, hwcrhk_destroy) ||
340                         !ENGINE_set_init_function(e, hwcrhk_init) ||
341                         !ENGINE_set_finish_function(e, hwcrhk_finish) ||
342                         !ENGINE_set_ctrl_function(e, hwcrhk_ctrl) ||
343                         !ENGINE_set_load_privkey_function(e, hwcrhk_load_privkey) ||
344                         !ENGINE_set_load_pubkey_function(e, hwcrhk_load_pubkey) ||
345                         !ENGINE_set_cmd_defns(e, hwcrhk_cmd_defns))
346                 return 0;
347
348 #ifndef OPENSSL_NO_RSA
349         /* We know that the "PKCS1_SSLeay()" functions hook properly
350          * to the cswift-specific mod_exp and mod_exp_crt so we use
351          * those functions. NB: We don't use ENGINE_openssl() or
352          * anything "more generic" because something like the RSAref
353          * code may not hook properly, and if you own one of these
354          * cards then you have the right to do RSA operations on it
355          * anyway! */ 
356         meth1 = RSA_PKCS1_SSLeay();
357         hwcrhk_rsa.rsa_pub_enc = meth1->rsa_pub_enc;
358         hwcrhk_rsa.rsa_pub_dec = meth1->rsa_pub_dec;
359         hwcrhk_rsa.rsa_priv_enc = meth1->rsa_priv_enc;
360         hwcrhk_rsa.rsa_priv_dec = meth1->rsa_priv_dec;
361 #endif
362
363 #ifndef OPENSSL_NO_DH
364         /* Much the same for Diffie-Hellman */
365         meth2 = DH_OpenSSL();
366         hwcrhk_dh.generate_key = meth2->generate_key;
367         hwcrhk_dh.compute_key = meth2->compute_key;
368 #endif
369
370         /* Ensure the hwcrhk error handling is set up */
371         ERR_load_HWCRHK_strings();
372         return 1;
373         }
374
375 static ENGINE *engine_ncipher(void)
376         {
377         ENGINE *ret = ENGINE_new();
378         if(!ret)
379                 return NULL;
380         if(!bind_helper(ret))
381                 {
382                 ENGINE_free(ret);
383                 return NULL;
384                 }
385         return ret;
386         }
387
388 void ENGINE_load_chil(void)
389         {
390         /* Copied from eng_[openssl|dyn].c */
391         ENGINE *toadd = engine_ncipher();
392         if(!toadd) return;
393         ENGINE_add(toadd);
394         ENGINE_free(toadd);
395         ERR_clear_error();
396         }
397
398 /* This is a process-global DSO handle used for loading and unloading
399  * the HWCryptoHook library. NB: This is only set (or unset) during an
400  * init() or finish() call (reference counts permitting) and they're
401  * operating with global locks, so this should be thread-safe
402  * implicitly. */
403 static DSO *hwcrhk_dso = NULL;
404 static HWCryptoHook_ContextHandle hwcrhk_context = 0;
405 #ifndef OPENSSL_NO_RSA
406 static int hndidx_rsa = -1;    /* Index for KM handle.  Not really used yet. */
407 #endif
408
409 /* These are the function pointers that are (un)set when the library has
410  * successfully (un)loaded. */
411 static HWCryptoHook_Init_t *p_hwcrhk_Init = NULL;
412 static HWCryptoHook_Finish_t *p_hwcrhk_Finish = NULL;
413 static HWCryptoHook_ModExp_t *p_hwcrhk_ModExp = NULL;
414 #ifndef OPENSSL_NO_RSA
415 static HWCryptoHook_RSA_t *p_hwcrhk_RSA = NULL;
416 #endif
417 static HWCryptoHook_RandomBytes_t *p_hwcrhk_RandomBytes = NULL;
418 #ifndef OPENSSL_NO_RSA
419 static HWCryptoHook_RSALoadKey_t *p_hwcrhk_RSALoadKey = NULL;
420 static HWCryptoHook_RSAGetPublicKey_t *p_hwcrhk_RSAGetPublicKey = NULL;
421 static HWCryptoHook_RSAUnloadKey_t *p_hwcrhk_RSAUnloadKey = NULL;
422 #endif
423 static HWCryptoHook_ModExpCRT_t *p_hwcrhk_ModExpCRT = NULL;
424
425 /* Used in the DSO operations. */
426 static const char *HWCRHK_LIBNAME = NULL;
427 static void free_HWCRHK_LIBNAME(void)
428         {
429         if(HWCRHK_LIBNAME)
430                 OPENSSL_free((void*)HWCRHK_LIBNAME);
431         HWCRHK_LIBNAME = NULL;
432         }
433 static const char *get_HWCRHK_LIBNAME(void)
434         {
435         if(HWCRHK_LIBNAME)
436                 return HWCRHK_LIBNAME;
437         return "nfhwcrhk";
438         }
439 static long set_HWCRHK_LIBNAME(const char *name)
440         {
441         free_HWCRHK_LIBNAME();
442         return (((HWCRHK_LIBNAME = BUF_strdup(name)) != NULL) ? 1 : 0);
443         }
444 static const char *n_hwcrhk_Init = "HWCryptoHook_Init";
445 static const char *n_hwcrhk_Finish = "HWCryptoHook_Finish";
446 static const char *n_hwcrhk_ModExp = "HWCryptoHook_ModExp";
447 #ifndef OPENSSL_NO_RSA
448 static const char *n_hwcrhk_RSA = "HWCryptoHook_RSA";
449 #endif
450 static const char *n_hwcrhk_RandomBytes = "HWCryptoHook_RandomBytes";
451 #ifndef OPENSSL_NO_RSA
452 static const char *n_hwcrhk_RSALoadKey = "HWCryptoHook_RSALoadKey";
453 static const char *n_hwcrhk_RSAGetPublicKey = "HWCryptoHook_RSAGetPublicKey";
454 static const char *n_hwcrhk_RSAUnloadKey = "HWCryptoHook_RSAUnloadKey";
455 #endif
456 static const char *n_hwcrhk_ModExpCRT = "HWCryptoHook_ModExpCRT";
457
458 /* HWCryptoHook library functions and mechanics - these are used by the
459  * higher-level functions further down. NB: As and where there's no
460  * error checking, take a look lower down where these functions are
461  * called, the checking and error handling is probably down there. */
462
463 /* utility function to obtain a context */
464 static int get_context(HWCryptoHook_ContextHandle *hac,
465         HWCryptoHook_CallerContext *cac)
466         {
467         char tempbuf[1024];
468         HWCryptoHook_ErrMsgBuf rmsg;
469
470         rmsg.buf = tempbuf;
471         rmsg.size = sizeof(tempbuf);
472
473         *hac = p_hwcrhk_Init(&hwcrhk_globals, sizeof(hwcrhk_globals), &rmsg,
474                 cac);
475         if (!*hac)
476                 return 0;
477         return 1;
478         }
479  
480 /* similarly to release one. */
481 static void release_context(HWCryptoHook_ContextHandle hac)
482         {
483         p_hwcrhk_Finish(hac);
484         }
485
486 /* Destructor (complements the "ENGINE_ncipher()" constructor) */
487 static int hwcrhk_destroy(ENGINE *e)
488         {
489         free_HWCRHK_LIBNAME();
490         ERR_unload_HWCRHK_strings();
491         return 1;
492         }
493
494 /* (de)initialisation functions. */
495 static int hwcrhk_init(ENGINE *e)
496         {
497         HWCryptoHook_Init_t *p1;
498         HWCryptoHook_Finish_t *p2;
499         HWCryptoHook_ModExp_t *p3;
500 #ifndef OPENSSL_NO_RSA
501         HWCryptoHook_RSA_t *p4;
502         HWCryptoHook_RSALoadKey_t *p5;
503         HWCryptoHook_RSAGetPublicKey_t *p6;
504         HWCryptoHook_RSAUnloadKey_t *p7;
505 #endif
506         HWCryptoHook_RandomBytes_t *p8;
507         HWCryptoHook_ModExpCRT_t *p9;
508
509         if(hwcrhk_dso != NULL)
510                 {
511                 HWCRHKerr(HWCRHK_F_HWCRHK_INIT,HWCRHK_R_ALREADY_LOADED);
512                 goto err;
513                 }
514         /* Attempt to load libnfhwcrhk.so/nfhwcrhk.dll/whatever. */
515         hwcrhk_dso = DSO_load(NULL, get_HWCRHK_LIBNAME(), NULL, 0);
516         if(hwcrhk_dso == NULL)
517                 {
518                 HWCRHKerr(HWCRHK_F_HWCRHK_INIT,HWCRHK_R_DSO_FAILURE);
519                 goto err;
520                 }
521         if(!(p1 = (HWCryptoHook_Init_t *)
522                         DSO_bind_func(hwcrhk_dso, n_hwcrhk_Init)) ||
523                 !(p2 = (HWCryptoHook_Finish_t *)
524                         DSO_bind_func(hwcrhk_dso, n_hwcrhk_Finish)) ||
525                 !(p3 = (HWCryptoHook_ModExp_t *)
526                         DSO_bind_func(hwcrhk_dso, n_hwcrhk_ModExp)) ||
527 #ifndef OPENSSL_NO_RSA
528                 !(p4 = (HWCryptoHook_RSA_t *)
529                         DSO_bind_func(hwcrhk_dso, n_hwcrhk_RSA)) ||
530                 !(p5 = (HWCryptoHook_RSALoadKey_t *)
531                         DSO_bind_func(hwcrhk_dso, n_hwcrhk_RSALoadKey)) ||
532                 !(p6 = (HWCryptoHook_RSAGetPublicKey_t *)
533                         DSO_bind_func(hwcrhk_dso, n_hwcrhk_RSAGetPublicKey)) ||
534                 !(p7 = (HWCryptoHook_RSAUnloadKey_t *)
535                         DSO_bind_func(hwcrhk_dso, n_hwcrhk_RSAUnloadKey)) ||
536 #endif
537                 !(p8 = (HWCryptoHook_RandomBytes_t *)
538                         DSO_bind_func(hwcrhk_dso, n_hwcrhk_RandomBytes)) ||
539                 !(p9 = (HWCryptoHook_ModExpCRT_t *)
540                         DSO_bind_func(hwcrhk_dso, n_hwcrhk_ModExpCRT)))
541                 {
542                 HWCRHKerr(HWCRHK_F_HWCRHK_INIT,HWCRHK_R_DSO_FAILURE);
543                 goto err;
544                 }
545         /* Copy the pointers */
546         p_hwcrhk_Init = p1;
547         p_hwcrhk_Finish = p2;
548         p_hwcrhk_ModExp = p3;
549 #ifndef OPENSSL_NO_RSA
550         p_hwcrhk_RSA = p4;
551         p_hwcrhk_RSALoadKey = p5;
552         p_hwcrhk_RSAGetPublicKey = p6;
553         p_hwcrhk_RSAUnloadKey = p7;
554 #endif
555         p_hwcrhk_RandomBytes = p8;
556         p_hwcrhk_ModExpCRT = p9;
557
558         /* Check if the application decided to support dynamic locks,
559            and if it does, use them. */
560         if (disable_mutex_callbacks == 0 &&
561                 CRYPTO_get_dynlock_create_callback() != NULL &&
562                 CRYPTO_get_dynlock_lock_callback() != NULL &&
563                 CRYPTO_get_dynlock_destroy_callback() != NULL)
564                 {
565                 hwcrhk_globals.mutex_init = hwcrhk_mutex_init;
566                 hwcrhk_globals.mutex_acquire = hwcrhk_mutex_lock;
567                 hwcrhk_globals.mutex_release = hwcrhk_mutex_unlock;
568                 hwcrhk_globals.mutex_destroy = hwcrhk_mutex_destroy;
569                 }
570
571         /* Try and get a context - if not, we may have a DSO but no
572          * accelerator! */
573         if(!get_context(&hwcrhk_context, &password_context))
574                 {
575                 HWCRHKerr(HWCRHK_F_HWCRHK_INIT,HWCRHK_R_UNIT_FAILURE);
576                 goto err;
577                 }
578         /* Everything's fine. */
579 #ifndef OPENSSL_NO_RSA
580         if (hndidx_rsa == -1)
581                 hndidx_rsa = RSA_get_ex_new_index(0,
582                         "nFast HWCryptoHook RSA key handle",
583                         NULL, NULL, hwcrhk_ex_free);
584 #endif
585         return 1;
586 err:
587         if(hwcrhk_dso)
588                 DSO_free(hwcrhk_dso);
589         hwcrhk_dso = NULL;
590         p_hwcrhk_Init = NULL;
591         p_hwcrhk_Finish = NULL;
592         p_hwcrhk_ModExp = NULL;
593 #ifndef OPENSSL_NO_RSA
594         p_hwcrhk_RSA = NULL;
595         p_hwcrhk_RSALoadKey = NULL;
596         p_hwcrhk_RSAGetPublicKey = NULL;
597         p_hwcrhk_RSAUnloadKey = NULL;
598 #endif
599         p_hwcrhk_ModExpCRT = NULL;
600         p_hwcrhk_RandomBytes = NULL;
601         return 0;
602         }
603
604 static int hwcrhk_finish(ENGINE *e)
605         {
606         int to_return = 1;
607         free_HWCRHK_LIBNAME();
608         if(hwcrhk_dso == NULL)
609                 {
610                 HWCRHKerr(HWCRHK_F_HWCRHK_FINISH,HWCRHK_R_NOT_LOADED);
611                 to_return = 0;
612                 goto err;
613                 }
614         release_context(hwcrhk_context);
615         if(!DSO_free(hwcrhk_dso))
616                 {
617                 HWCRHKerr(HWCRHK_F_HWCRHK_FINISH,HWCRHK_R_DSO_FAILURE);
618                 to_return = 0;
619                 goto err;
620                 }
621  err:
622         if (logstream)
623                 BIO_free(logstream);
624         hwcrhk_dso = NULL;
625         p_hwcrhk_Init = NULL;
626         p_hwcrhk_Finish = NULL;
627         p_hwcrhk_ModExp = NULL;
628 #ifndef OPENSSL_NO_RSA
629         p_hwcrhk_RSA = NULL;
630         p_hwcrhk_RSALoadKey = NULL;
631         p_hwcrhk_RSAGetPublicKey = NULL;
632         p_hwcrhk_RSAUnloadKey = NULL;
633 #endif
634         p_hwcrhk_ModExpCRT = NULL;
635         p_hwcrhk_RandomBytes = NULL;
636         return to_return;
637         }
638
639 static int hwcrhk_ctrl(ENGINE *e, int cmd, long i, void *p, void (*f)())
640         {
641         int to_return = 1;
642
643         switch(cmd)
644                 {
645         case HWCRHK_CMD_SO_PATH:
646                 if(hwcrhk_dso)
647                         {
648                         HWCRHKerr(HWCRHK_F_HWCRHK_CTRL,HWCRHK_R_ALREADY_LOADED);
649                         return 0;
650                         }
651                 if(p == NULL)
652                         {
653                         HWCRHKerr(HWCRHK_F_HWCRHK_CTRL,ERR_R_PASSED_NULL_PARAMETER);
654                         return 0;
655                         }
656                 return set_HWCRHK_LIBNAME((const char *)p);
657         case ENGINE_CTRL_SET_LOGSTREAM:
658                 {
659                 BIO *bio = (BIO *)p;
660
661                 CRYPTO_w_lock(CRYPTO_LOCK_ENGINE);
662                 if (logstream)
663                         {
664                         BIO_free(logstream);
665                         logstream = NULL;
666                         }
667                 if (CRYPTO_add(&bio->references,1,CRYPTO_LOCK_BIO) > 1)
668                         logstream = bio;
669                 else
670                         HWCRHKerr(HWCRHK_F_HWCRHK_CTRL,HWCRHK_R_BIO_WAS_FREED);
671                 }
672                 CRYPTO_w_unlock(CRYPTO_LOCK_ENGINE);
673                 break;
674         case ENGINE_CTRL_SET_PASSWORD_CALLBACK:
675                 CRYPTO_w_lock(CRYPTO_LOCK_ENGINE);
676                 password_context.password_callback = (pem_password_cb *)f;
677                 CRYPTO_w_unlock(CRYPTO_LOCK_ENGINE);
678                 break;
679         case ENGINE_CTRL_SET_USER_INTERFACE:
680         case HWCRHK_CMD_SET_USER_INTERFACE:
681                 CRYPTO_w_lock(CRYPTO_LOCK_ENGINE);
682                 password_context.ui_method = (UI_METHOD *)p;
683                 CRYPTO_w_unlock(CRYPTO_LOCK_ENGINE);
684                 break;
685         case ENGINE_CTRL_SET_CALLBACK_DATA:
686         case HWCRHK_CMD_SET_CALLBACK_DATA:
687                 CRYPTO_w_lock(CRYPTO_LOCK_ENGINE);
688                 password_context.callback_data = p;
689                 CRYPTO_w_unlock(CRYPTO_LOCK_ENGINE);
690                 break;
691         /* this enables or disables the "SimpleForkCheck" flag used in the
692          * initialisation structure. */
693         case ENGINE_CTRL_CHIL_SET_FORKCHECK:
694         case HWCRHK_CMD_FORK_CHECK:
695                 CRYPTO_w_lock(CRYPTO_LOCK_ENGINE);
696                 if(i)
697                         hwcrhk_globals.flags |=
698                                 HWCryptoHook_InitFlags_SimpleForkCheck;
699                 else
700                         hwcrhk_globals.flags &=
701                                 ~HWCryptoHook_InitFlags_SimpleForkCheck;
702                 CRYPTO_w_unlock(CRYPTO_LOCK_ENGINE);
703                 break;
704         /* This will prevent the initialisation function from "installing"
705          * the mutex-handling callbacks, even if they are available from
706          * within the library (or were provided to the library from the
707          * calling application). This is to remove any baggage for
708          * applications not using multithreading. */
709         case ENGINE_CTRL_CHIL_NO_LOCKING:
710                 CRYPTO_w_lock(CRYPTO_LOCK_ENGINE);
711                 disable_mutex_callbacks = 1;
712                 CRYPTO_w_unlock(CRYPTO_LOCK_ENGINE);
713                 break;
714         case HWCRHK_CMD_THREAD_LOCKING:
715                 CRYPTO_w_lock(CRYPTO_LOCK_ENGINE);
716                 disable_mutex_callbacks = ((i == 0) ? 0 : 1);
717                 CRYPTO_w_unlock(CRYPTO_LOCK_ENGINE);
718                 break;
719
720         /* The command isn't understood by this engine */
721         default:
722                 HWCRHKerr(HWCRHK_F_HWCRHK_CTRL,
723                         HWCRHK_R_CTRL_COMMAND_NOT_IMPLEMENTED);
724                 to_return = 0;
725                 break;
726                 }
727
728         return to_return;
729         }
730
731 static EVP_PKEY *hwcrhk_load_privkey(ENGINE *eng, const char *key_id,
732         UI_METHOD *ui_method, void *callback_data)
733         {
734 #ifndef OPENSSL_NO_RSA
735         RSA *rtmp = NULL;
736 #endif
737         EVP_PKEY *res = NULL;
738 #ifndef OPENSSL_NO_RSA
739         HWCryptoHook_MPI e, n;
740         HWCryptoHook_RSAKeyHandle *hptr;
741 #endif
742 #if !defined(OPENSSL_NO_RSA)
743         char tempbuf[1024];
744         HWCryptoHook_ErrMsgBuf rmsg;
745 #endif
746         HWCryptoHook_PassphraseContext ppctx;
747
748 #if !defined(OPENSSL_NO_RSA)
749         rmsg.buf = tempbuf;
750         rmsg.size = sizeof(tempbuf);
751 #endif
752
753         if(!hwcrhk_context)
754                 {
755                 HWCRHKerr(HWCRHK_F_HWCRHK_LOAD_PRIVKEY,
756                         HWCRHK_R_NOT_INITIALISED);
757                 goto err;
758                 }
759 #ifndef OPENSSL_NO_RSA
760         hptr = OPENSSL_malloc(sizeof(HWCryptoHook_RSAKeyHandle));
761         if (!hptr)
762                 {
763                 HWCRHKerr(HWCRHK_F_HWCRHK_LOAD_PRIVKEY,
764                         ERR_R_MALLOC_FAILURE);
765                 goto err;
766                 }
767         ppctx.ui_method = ui_method;
768         ppctx.callback_data = callback_data;
769         if (p_hwcrhk_RSALoadKey(hwcrhk_context, key_id, hptr,
770                 &rmsg, &ppctx))
771                 {
772                 HWCRHKerr(HWCRHK_F_HWCRHK_LOAD_PRIVKEY,
773                         HWCRHK_R_CHIL_ERROR);
774                 ERR_add_error_data(1,rmsg.buf);
775                 goto err;
776                 }
777         if (!*hptr)
778                 {
779                 HWCRHKerr(HWCRHK_F_HWCRHK_LOAD_PRIVKEY,
780                         HWCRHK_R_NO_KEY);
781                 goto err;
782                 }
783 #endif
784 #ifndef OPENSSL_NO_RSA
785         rtmp = RSA_new_method(eng);
786         RSA_set_ex_data(rtmp, hndidx_rsa, (char *)hptr);
787         rtmp->e = BN_new();
788         rtmp->n = BN_new();
789         rtmp->flags |= RSA_FLAG_EXT_PKEY;
790         MPI2BN(rtmp->e, e);
791         MPI2BN(rtmp->n, n);
792         if (p_hwcrhk_RSAGetPublicKey(*hptr, &n, &e, &rmsg)
793                 != HWCRYPTOHOOK_ERROR_MPISIZE)
794                 {
795                 HWCRHKerr(HWCRHK_F_HWCRHK_LOAD_PUBKEY,HWCRHK_R_CHIL_ERROR);
796                 ERR_add_error_data(1,rmsg.buf);
797                 goto err;
798                 }
799
800         bn_expand2(rtmp->e, e.size/sizeof(BN_ULONG));
801         bn_expand2(rtmp->n, n.size/sizeof(BN_ULONG));
802         MPI2BN(rtmp->e, e);
803         MPI2BN(rtmp->n, n);
804
805         if (p_hwcrhk_RSAGetPublicKey(*hptr, &n, &e, &rmsg))
806                 {
807                 HWCRHKerr(HWCRHK_F_HWCRHK_LOAD_PUBKEY,
808                         HWCRHK_R_CHIL_ERROR);
809                 ERR_add_error_data(1,rmsg.buf);
810                 goto err;
811                 }
812         rtmp->e->top = e.size / sizeof(BN_ULONG);
813         bn_fix_top(rtmp->e);
814         rtmp->n->top = n.size / sizeof(BN_ULONG);
815         bn_fix_top(rtmp->n);
816
817         res = EVP_PKEY_new();
818         EVP_PKEY_assign_RSA(res, rtmp);
819 #endif
820
821         if (!res)
822                 HWCRHKerr(HWCRHK_F_HWCRHK_LOAD_PUBKEY,
823                         HWCRHK_R_PRIVATE_KEY_ALGORITHMS_DISABLED);
824
825         return res;
826  err:
827         if (res)
828                 EVP_PKEY_free(res);
829 #ifndef OPENSSL_NO_RSA
830         if (rtmp)
831                 RSA_free(rtmp);
832 #endif
833         return NULL;
834         }
835
836 static EVP_PKEY *hwcrhk_load_pubkey(ENGINE *eng, const char *key_id,
837         UI_METHOD *ui_method, void *callback_data)
838         {
839         EVP_PKEY *res = NULL;
840
841 #ifndef OPENSSL_NO_RSA
842         res = hwcrhk_load_privkey(eng, key_id,
843                 ui_method, callback_data);
844 #endif
845
846         if (res)
847                 switch(res->type)
848                         {
849 #ifndef OPENSSL_NO_RSA
850                 case EVP_PKEY_RSA:
851                         {
852                         RSA *rsa = NULL;
853
854                         CRYPTO_w_lock(CRYPTO_LOCK_EVP_PKEY);
855                         rsa = res->pkey.rsa;
856                         res->pkey.rsa = RSA_new();
857                         res->pkey.rsa->n = rsa->n;
858                         res->pkey.rsa->e = rsa->e;
859                         rsa->n = NULL;
860                         rsa->e = NULL;
861                         CRYPTO_w_unlock(CRYPTO_LOCK_EVP_PKEY);
862                         RSA_free(rsa);
863                         }
864                         break;
865 #endif
866                 default:
867                         HWCRHKerr(HWCRHK_F_HWCRHK_LOAD_PUBKEY,
868                                 HWCRHK_R_CTRL_COMMAND_NOT_IMPLEMENTED);
869                         goto err;
870                         }
871
872         return res;
873  err:
874         if (res)
875                 EVP_PKEY_free(res);
876         return NULL;
877         }
878
879 /* A little mod_exp */
880 static int hwcrhk_mod_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
881                         const BIGNUM *m, BN_CTX *ctx)
882         {
883         char tempbuf[1024];
884         HWCryptoHook_ErrMsgBuf rmsg;
885         /* Since HWCryptoHook_MPI is pretty compatible with BIGNUM's,
886            we use them directly, plus a little macro magic.  We only
887            thing we need to make sure of is that enough space is allocated. */
888         HWCryptoHook_MPI m_a, m_p, m_n, m_r;
889         int to_return, ret;
890  
891         to_return = 0; /* expect failure */
892         rmsg.buf = tempbuf;
893         rmsg.size = sizeof(tempbuf);
894
895         if(!hwcrhk_context)
896                 {
897                 HWCRHKerr(HWCRHK_F_HWCRHK_MOD_EXP,HWCRHK_R_NOT_INITIALISED);
898                 goto err;
899                 }
900         /* Prepare the params */
901         bn_expand2(r, m->top);  /* Check for error !! */
902         BN2MPI(m_a, a);
903         BN2MPI(m_p, p);
904         BN2MPI(m_n, m);
905         MPI2BN(r, m_r);
906
907         /* Perform the operation */
908         ret = p_hwcrhk_ModExp(hwcrhk_context, m_a, m_p, m_n, &m_r, &rmsg);
909
910         /* Convert the response */
911         r->top = m_r.size / sizeof(BN_ULONG);
912         bn_fix_top(r);
913
914         if (ret < 0)
915                 {
916                 /* FIXME: When this error is returned, HWCryptoHook is
917                    telling us that falling back to software computation
918                    might be a good thing. */
919                 if(ret == HWCRYPTOHOOK_ERROR_FALLBACK)
920                         {
921                         HWCRHKerr(HWCRHK_F_HWCRHK_MOD_EXP,HWCRHK_R_REQUEST_FALLBACK);
922                         }
923                 else
924                         {
925                         HWCRHKerr(HWCRHK_F_HWCRHK_MOD_EXP,HWCRHK_R_REQUEST_FAILED);
926                         }
927                 ERR_add_error_data(1,rmsg.buf);
928                 goto err;
929                 }
930
931         to_return = 1;
932 err:
933         return to_return;
934         }
935
936 #ifndef OPENSSL_NO_RSA 
937 static int hwcrhk_rsa_mod_exp(BIGNUM *r, const BIGNUM *I, RSA *rsa)
938         {
939         char tempbuf[1024];
940         HWCryptoHook_ErrMsgBuf rmsg;
941         HWCryptoHook_RSAKeyHandle *hptr;
942         int to_return = 0, ret;
943
944         rmsg.buf = tempbuf;
945         rmsg.size = sizeof(tempbuf);
946
947         if(!hwcrhk_context)
948                 {
949                 HWCRHKerr(HWCRHK_F_HWCRHK_MOD_EXP,HWCRHK_R_NOT_INITIALISED);
950                 goto err;
951                 }
952
953         /* This provides support for nForce keys.  Since that's opaque data
954            all we do is provide a handle to the proper key and let HWCryptoHook
955            take care of the rest. */
956         if ((hptr = (HWCryptoHook_RSAKeyHandle *) RSA_get_ex_data(rsa, hndidx_rsa))
957                 != NULL)
958                 {
959                 HWCryptoHook_MPI m_a, m_r;
960
961                 if(!rsa->n)
962                         {
963                         HWCRHKerr(HWCRHK_F_HWCRHK_RSA_MOD_EXP,
964                                 HWCRHK_R_MISSING_KEY_COMPONENTS);
965                         goto err;
966                         }
967
968                 /* Prepare the params */
969                 bn_expand2(r, rsa->n->top); /* Check for error !! */
970                 BN2MPI(m_a, I);
971                 MPI2BN(r, m_r);
972
973                 /* Perform the operation */
974                 ret = p_hwcrhk_RSA(m_a, *hptr, &m_r, &rmsg);
975
976                 /* Convert the response */
977                 r->top = m_r.size / sizeof(BN_ULONG);
978                 bn_fix_top(r);
979
980                 if (ret < 0)
981                         {
982                         /* FIXME: When this error is returned, HWCryptoHook is
983                            telling us that falling back to software computation
984                            might be a good thing. */
985                         if(ret == HWCRYPTOHOOK_ERROR_FALLBACK)
986                                 {
987                                 HWCRHKerr(HWCRHK_F_HWCRHK_RSA_MOD_EXP,
988                                         HWCRHK_R_REQUEST_FALLBACK);
989                                 }
990                         else
991                                 {
992                                 HWCRHKerr(HWCRHK_F_HWCRHK_RSA_MOD_EXP,
993                                         HWCRHK_R_REQUEST_FAILED);
994                                 }
995                         ERR_add_error_data(1,rmsg.buf);
996                         goto err;
997                         }
998                 }
999         else
1000                 {
1001                 HWCryptoHook_MPI m_a, m_p, m_q, m_dmp1, m_dmq1, m_iqmp, m_r;
1002
1003                 if(!rsa->p || !rsa->q || !rsa->dmp1 || !rsa->dmq1 || !rsa->iqmp)
1004                         {
1005                         HWCRHKerr(HWCRHK_F_HWCRHK_RSA_MOD_EXP,
1006                                 HWCRHK_R_MISSING_KEY_COMPONENTS);
1007                         goto err;
1008                         }
1009
1010                 /* Prepare the params */
1011                 bn_expand2(r, rsa->n->top); /* Check for error !! */
1012                 BN2MPI(m_a, I);
1013                 BN2MPI(m_p, rsa->p);
1014                 BN2MPI(m_q, rsa->q);
1015                 BN2MPI(m_dmp1, rsa->dmp1);
1016                 BN2MPI(m_dmq1, rsa->dmq1);
1017                 BN2MPI(m_iqmp, rsa->iqmp);
1018                 MPI2BN(r, m_r);
1019
1020                 /* Perform the operation */
1021                 ret = p_hwcrhk_ModExpCRT(hwcrhk_context, m_a, m_p, m_q,
1022                         m_dmp1, m_dmq1, m_iqmp, &m_r, NULL);
1023
1024                 /* Convert the response */
1025                 r->top = m_r.size / sizeof(BN_ULONG);
1026                 bn_fix_top(r);
1027
1028                 if (ret < 0)
1029                         {
1030                         /* FIXME: When this error is returned, HWCryptoHook is
1031                            telling us that falling back to software computation
1032                            might be a good thing. */
1033                         if(ret == HWCRYPTOHOOK_ERROR_FALLBACK)
1034                                 {
1035                                 HWCRHKerr(HWCRHK_F_HWCRHK_RSA_MOD_EXP,
1036                                         HWCRHK_R_REQUEST_FALLBACK);
1037                                 }
1038                         else
1039                                 {
1040                                 HWCRHKerr(HWCRHK_F_HWCRHK_RSA_MOD_EXP,
1041                                         HWCRHK_R_REQUEST_FAILED);
1042                                 }
1043                         ERR_add_error_data(1,rmsg.buf);
1044                         goto err;
1045                         }
1046                 }
1047         /* If we're here, we must be here with some semblance of success :-) */
1048         to_return = 1;
1049 err:
1050         return to_return;
1051         }
1052 #endif
1053
1054 /* This function is aliased to mod_exp (with the mont stuff dropped). */
1055 static int hwcrhk_mod_exp_mont(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
1056                 const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx)
1057         {
1058         return hwcrhk_mod_exp(r, a, p, m, ctx);
1059         }
1060
1061 #ifndef OPENSSL_NO_DH
1062 /* This function is aliased to mod_exp (with the dh and mont dropped). */
1063 static int hwcrhk_mod_exp_dh(const DH *dh, BIGNUM *r,
1064                 const BIGNUM *a, const BIGNUM *p,
1065                 const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx)
1066         {
1067         return hwcrhk_mod_exp(r, a, p, m, ctx);
1068         }
1069 #endif
1070
1071 /* Random bytes are good */
1072 static int hwcrhk_rand_bytes(unsigned char *buf, int num)
1073         {
1074         char tempbuf[1024];
1075         HWCryptoHook_ErrMsgBuf rmsg;
1076         int to_return = 0; /* assume failure */
1077         int ret;
1078
1079         rmsg.buf = tempbuf;
1080         rmsg.size = sizeof(tempbuf);
1081
1082         if(!hwcrhk_context)
1083                 {
1084                 HWCRHKerr(HWCRHK_F_HWCRHK_RAND_BYTES,HWCRHK_R_NOT_INITIALISED);
1085                 goto err;
1086                 }
1087
1088         ret = p_hwcrhk_RandomBytes(hwcrhk_context, buf, num, &rmsg);
1089         if (ret < 0)
1090                 {
1091                 /* FIXME: When this error is returned, HWCryptoHook is
1092                    telling us that falling back to software computation
1093                    might be a good thing. */
1094                 if(ret == HWCRYPTOHOOK_ERROR_FALLBACK)
1095                         {
1096                         HWCRHKerr(HWCRHK_F_HWCRHK_RAND_BYTES,
1097                                 HWCRHK_R_REQUEST_FALLBACK);
1098                         }
1099                 else
1100                         {
1101                         HWCRHKerr(HWCRHK_F_HWCRHK_RAND_BYTES,
1102                                 HWCRHK_R_REQUEST_FAILED);
1103                         }
1104                 ERR_add_error_data(1,rmsg.buf);
1105                 goto err;
1106                 }
1107         to_return = 1;
1108  err:
1109         return to_return;
1110         }
1111
1112 static int hwcrhk_rand_status(void)
1113         {
1114         return 1;
1115         }
1116
1117 /* This cleans up an RSA KM key, called when ex_data is freed */
1118
1119 static void hwcrhk_ex_free(void *obj, void *item, CRYPTO_EX_DATA *ad,
1120         int ind,long argl, void *argp)
1121 {
1122         char tempbuf[1024];
1123         HWCryptoHook_ErrMsgBuf rmsg;
1124 #ifndef OPENSSL_NO_RSA
1125         HWCryptoHook_RSAKeyHandle *hptr;
1126 #endif
1127 #if !defined(OPENSSL_NO_RSA)
1128         int ret;
1129 #endif
1130
1131         rmsg.buf = tempbuf;
1132         rmsg.size = sizeof(tempbuf);
1133
1134 #ifndef OPENSSL_NO_RSA
1135         hptr = (HWCryptoHook_RSAKeyHandle *) item;
1136         if(hptr)
1137                 {
1138                 ret = p_hwcrhk_RSAUnloadKey(*hptr, NULL);
1139                 OPENSSL_free(hptr);
1140                 }
1141 #endif
1142 }
1143
1144 /* Mutex calls: since the HWCryptoHook model closely follows the POSIX model
1145  * these just wrap the POSIX functions and add some logging.
1146  */
1147
1148 static int hwcrhk_mutex_init(HWCryptoHook_Mutex* mt,
1149         HWCryptoHook_CallerContext *cactx)
1150         {
1151         mt->lockid = CRYPTO_get_new_dynlockid();
1152         if (mt->lockid == 0)
1153                 return 1; /* failure */
1154         return 0; /* success */
1155         }
1156
1157 static int hwcrhk_mutex_lock(HWCryptoHook_Mutex *mt)
1158         {
1159         CRYPTO_w_lock(mt->lockid);
1160         return 0;
1161         }
1162
1163 static void hwcrhk_mutex_unlock(HWCryptoHook_Mutex * mt)
1164         {
1165         CRYPTO_w_unlock(mt->lockid);
1166         }
1167
1168 static void hwcrhk_mutex_destroy(HWCryptoHook_Mutex *mt)
1169         {
1170         CRYPTO_destroy_dynlockid(mt->lockid);
1171         }
1172
1173 static int hwcrhk_get_pass(const char *prompt_info,
1174         int *len_io, char *buf,
1175         HWCryptoHook_PassphraseContext *ppctx,
1176         HWCryptoHook_CallerContext *cactx)
1177         {
1178         pem_password_cb *callback = NULL;
1179         void *callback_data = NULL;
1180         UI_METHOD *ui_method = NULL;
1181
1182         if (cactx)
1183                 {
1184                 if (cactx->ui_method)
1185                         ui_method = cactx->ui_method;
1186                 if (cactx->password_callback)
1187                         callback = cactx->password_callback;
1188                 if (cactx->callback_data)
1189                         callback_data = cactx->callback_data;
1190                 }
1191         if (ppctx)
1192                 {
1193                 if (ppctx->ui_method)
1194                         {
1195                         ui_method = ppctx->ui_method;
1196                         callback = NULL;
1197                         }
1198                 if (ppctx->callback_data)
1199                         callback_data = ppctx->callback_data;
1200                 }
1201         if (callback == NULL && ui_method == NULL)
1202                 {
1203                 HWCRHKerr(HWCRHK_F_HWCRHK_GET_PASS,HWCRHK_R_NO_CALLBACK);
1204                 return -1;
1205                 }
1206
1207         if (ui_method)
1208                 {
1209                 UI *ui = UI_new_method(ui_method);
1210                 if (ui)
1211                         {
1212                         int ok;
1213                         char *prompt = UI_construct_prompt(ui,
1214                                 "pass phrase", prompt_info);
1215
1216                         ok = UI_add_input_string(ui,prompt,
1217                                 UI_INPUT_FLAG_DEFAULT_PWD,
1218                                 buf,0,(*len_io) - 1);
1219                         UI_add_user_data(ui, callback_data);
1220                         UI_ctrl(ui, UI_CTRL_PRINT_ERRORS, 1, 0, 0);
1221
1222                         if (ok >= 0)
1223                                 do
1224                                         {
1225                                         ok=UI_process(ui);
1226                                         }
1227                                 while (ok < 0 && UI_ctrl(ui, UI_CTRL_IS_REDOABLE, 0, 0, 0));
1228
1229                         if (ok >= 0)
1230                                 *len_io = strlen(buf);
1231
1232                         UI_free(ui);
1233                         OPENSSL_free(prompt);
1234                         }
1235                 }
1236         else
1237                 {
1238                 *len_io = callback(buf, *len_io, 0, callback_data);
1239                 }
1240         if(!*len_io)
1241                 return -1;
1242         return 0;
1243         }
1244
1245 static int hwcrhk_insert_card(const char *prompt_info,
1246                       const char *wrong_info,
1247                       HWCryptoHook_PassphraseContext *ppctx,
1248                       HWCryptoHook_CallerContext *cactx)
1249         {
1250         int ok = -1;
1251         UI *ui;
1252         void *callback_data = NULL;
1253         UI_METHOD *ui_method = NULL;
1254
1255         if (cactx)
1256                 {
1257                 if (cactx->ui_method)
1258                         ui_method = cactx->ui_method;
1259                 if (cactx->callback_data)
1260                         callback_data = cactx->callback_data;
1261                 }
1262         if (ppctx)
1263                 {
1264                 if (ppctx->ui_method)
1265                         ui_method = ppctx->ui_method;
1266                 if (ppctx->callback_data)
1267                         callback_data = ppctx->callback_data;
1268                 }
1269         if (ui_method == NULL)
1270                 {
1271                 HWCRHKerr(HWCRHK_F_HWCRHK_INSERT_CARD,
1272                         HWCRHK_R_NO_CALLBACK);
1273                 return -1;
1274                 }
1275
1276         ui = UI_new_method(ui_method);
1277
1278         if (ui)
1279                 {
1280                 char answer;
1281                 char buf[BUFSIZ];
1282
1283                 if (wrong_info)
1284                         BIO_snprintf(buf, sizeof(buf)-1,
1285                                 "Current card: \"%s\"\n", wrong_info);
1286                 ok = UI_dup_info_string(ui, buf);
1287                 if (ok >= 0 && prompt_info)
1288                         {
1289                         BIO_snprintf(buf, sizeof(buf)-1,
1290                                 "Insert card \"%s\"", prompt_info);
1291                         ok = UI_dup_input_boolean(ui, buf,
1292                                 "\n then hit <enter> or C<enter> to cancel\n",
1293                                 "\r\n", "Cc", UI_INPUT_FLAG_ECHO, &answer);
1294                         }
1295                 UI_add_user_data(ui, callback_data);
1296
1297                 if (ok >= 0)
1298                         ok = UI_process(ui);
1299                 UI_free(ui);
1300
1301                 if (ok == -2 || (ok >= 0 && answer == 'C'))
1302                         ok = 1;
1303                 else if (ok < 0)
1304                         ok = -1;
1305                 else
1306                         ok = 0;
1307                 }
1308         return ok;
1309         }
1310
1311 static void hwcrhk_log_message(void *logstr, const char *message)
1312         {
1313         BIO *lstream = NULL;
1314
1315         CRYPTO_w_lock(CRYPTO_LOCK_BIO);
1316         if (logstr)
1317                 lstream=*(BIO **)logstr;
1318         if (lstream)
1319                 {
1320                 BIO_write(lstream, message, strlen(message));
1321                 }
1322         CRYPTO_w_unlock(CRYPTO_LOCK_BIO);
1323         }
1324
1325 /* This stuff is needed if this ENGINE is being compiled into a self-contained
1326  * shared-library. */      
1327 #ifndef OPENSSL_NO_DYNAMIC_ENGINE
1328 static int bind_fn(ENGINE *e, const char *id)
1329         {
1330         if(id && (strcmp(id, engine_hwcrhk_id) != 0))
1331                 return 0;
1332         if(!bind_helper(e))
1333                 return 0;
1334         return 1;
1335         }       
1336 IMPLEMENT_DYNAMIC_CHECK_FN()
1337 IMPLEMENT_DYNAMIC_BIND_FN(bind_fn)
1338 #endif /* OPENSSL_NO_DYNAMIC_ENGINE */
1339
1340 #endif /* !OPENSSL_NO_HW_NCIPHER */
1341 #endif /* !OPENSSL_NO_HW */