Add aep and sureware implementations and clean up some error reasons
[openssl.git] / crypto / engine / hw_aep.c
1 /* crypto/engine/hw_aep.c */
2 /*
3  */
4 /* ====================================================================
5  * Copyright (c) 1999 The OpenSSL Project.  All rights reserved.
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  *
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer. 
13  *
14  * 2. Redistributions in binary form must reproduce the above copyright
15  *    notice, this list of conditions and the following disclaimer in
16  *    the documentation and/or other materials provided with the
17  *    distribution.
18  *
19  * 3. All advertising materials mentioning features or use of this
20  *    software must display the following acknowledgment:
21  *    "This product includes software developed by the OpenSSL Project
22  *    for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
23  *
24  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
25  *    endorse or promote products derived from this software without
26  *    prior written permission. For written permission, please contact
27  *    licensing@OpenSSL.org.
28  *
29  * 5. Products derived from this software may not be called "OpenSSL"
30  *    nor may "OpenSSL" appear in their names without prior written
31  *    permission of the OpenSSL Project.
32  *
33  * 6. Redistributions of any form whatsoever must retain the following
34  *    acknowledgment:
35  *    "This product includes software developed by the OpenSSL Project
36  *    for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
37  *
38  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
39  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
40  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
41  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
42  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
43  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
44  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
45  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
46  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
47  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
48  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
49  * OF THE POSSIBILITY OF SUCH DAMAGE.
50  * ====================================================================
51  *
52  * This product includes cryptographic software written by Eric Young
53  * (eay@cryptsoft.com).  This product includes software written by Tim
54  * Hudson (tjh@cryptsoft.com).
55  *
56  */
57
58 #include <stdio.h>
59 #include <openssl/bn.h>
60 #include <string.h>
61
62 #include <openssl/e_os2.h>
63 #ifndef OPENSSL_SYS_MSDOS
64 #include <sys/types.h>
65 #include <unistd.h>
66 #else
67 #include <process.h>
68 typedef int pid_t;
69 #endif
70
71 #include <openssl/crypto.h>
72 #include <openssl/dso.h>
73 #include <openssl/engine.h>
74
75 #ifndef OPENSSL_NO_HW
76 #ifndef OPENSSL_NO_HW_AEP
77 #ifdef FLAT_INC
78 #include "aep.h"
79 #else
80 #include "vendor_defns/aep.h"
81 #endif
82
83 #define AEP_LIB_NAME "aep engine"
84 #include "hw_aep_err.c"
85
86 static int aep_init(ENGINE *e);
87 static int aep_finish(ENGINE *e);
88 static int aep_ctrl(ENGINE *e, int cmd, long i, void *p, void (*f)());
89 static int aep_destroy(ENGINE *e);
90
91 static AEP_RV aep_get_connection(AEP_CONNECTION_HNDL_PTR hConnection);
92 static AEP_RV aep_return_connection(AEP_CONNECTION_HNDL hConnection);
93 static AEP_RV aep_close_all_connections(int use_engine_lock, int *in_use);
94
95 /* BIGNUM stuff */
96 static int aep_mod_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
97         const BIGNUM *m, BN_CTX *ctx);
98
99 static AEP_RV aep_mod_exp_crt(BIGNUM *r,const  BIGNUM *a, const BIGNUM *p,
100         const BIGNUM *q, const BIGNUM *dmp1,const BIGNUM *dmq1,
101         const BIGNUM *iqmp, BN_CTX *ctx);
102
103 /* RSA stuff */
104 #ifndef OPENSSL_NO_RSA
105 static int aep_rsa_mod_exp(BIGNUM *r0, const BIGNUM *I, RSA *rsa);
106 #endif
107
108 /* This function is aliased to mod_exp (with the mont stuff dropped). */
109 static int aep_mod_exp_mont(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
110         const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx);
111
112 /* DSA stuff */
113 #ifndef OPENSSL_NO_DSA
114 static int aep_dsa_mod_exp(DSA *dsa, BIGNUM *rr, BIGNUM *a1,
115         BIGNUM *p1, BIGNUM *a2, BIGNUM *p2, BIGNUM *m,
116         BN_CTX *ctx, BN_MONT_CTX *in_mont);
117
118 static int aep_mod_exp_dsa(DSA *dsa, BIGNUM *r, BIGNUM *a,
119         const BIGNUM *p, const BIGNUM *m, BN_CTX *ctx,
120         BN_MONT_CTX *m_ctx);
121 #endif
122
123 /* DH stuff */
124 /* This function is aliased to mod_exp (with the DH and mont dropped). */
125 #ifndef OPENSSL_NO_DH
126 static int aep_mod_exp_dh(const DH *dh, BIGNUM *r, const BIGNUM *a,
127         const BIGNUM *p, const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx);
128 #endif
129
130 /* rand stuff   */
131 #ifdef AEPRAND
132 static int aep_rand(unsigned char *buf, int num);
133 static int aep_rand_status(void);
134 #endif
135
136 /* Bignum conversion stuff */
137 static AEP_RV GetBigNumSize(void* ArbBigNum, AEP_U32* BigNumSize);
138 static AEP_RV MakeAEPBigNum(void* ArbBigNum, AEP_U32 BigNumSize,
139         unsigned char* AEP_BigNum);
140 static AEP_RV ConvertAEPBigNum(void* ArbBigNum, AEP_U32 BigNumSize,
141         unsigned char* AEP_BigNum);
142
143 /* The definitions for control commands specific to this engine */
144 #define AEP_CMD_SO_PATH         ENGINE_CMD_BASE
145 static const ENGINE_CMD_DEFN aep_cmd_defns[] =
146         {
147         { AEP_CMD_SO_PATH,
148           "SO_PATH",
149           "Specifies the path to the 'aep' shared library",
150           ENGINE_CMD_FLAG_STRING
151         },
152         {0, NULL, NULL, 0}
153         };
154
155 #ifndef OPENSSL_NO_RSA
156 /* Our internal RSA_METHOD that we provide pointers to */
157 static RSA_METHOD aep_rsa =
158         {
159         "Aep RSA method",
160         NULL,                /*rsa_pub_encrypt*/
161         NULL,                /*rsa_pub_decrypt*/
162         NULL,                /*rsa_priv_encrypt*/
163         NULL,                /*rsa_priv_encrypt*/
164         aep_rsa_mod_exp,     /*rsa_mod_exp*/
165         aep_mod_exp_mont,    /*bn_mod_exp*/
166         NULL,                /*init*/
167         NULL,                /*finish*/
168         0,                   /*flags*/
169         NULL,                /*app_data*/
170         NULL,                /*rsa_sign*/
171         NULL                 /*rsa_verify*/
172         };
173 #endif
174
175 #ifndef OPENSSL_NO_DSA
176 /* Our internal DSA_METHOD that we provide pointers to */
177 static DSA_METHOD aep_dsa =
178         {
179         "Aep DSA method",
180         NULL,                /* dsa_do_sign */
181         NULL,                /* dsa_sign_setup */
182         NULL,                /* dsa_do_verify */
183         aep_dsa_mod_exp,     /* dsa_mod_exp */
184         aep_mod_exp_dsa,     /* bn_mod_exp */
185         NULL,                /* init */
186         NULL,                /* finish */
187         0,                   /* flags */
188         NULL                 /* app_data */
189         };
190 #endif
191
192 #ifndef OPENSSL_NO_DH
193 /* Our internal DH_METHOD that we provide pointers to */
194 static DH_METHOD aep_dh =
195         {
196         "Aep DH method",
197         NULL,
198         NULL,
199         aep_mod_exp_dh,
200         NULL,
201         NULL,
202         0,
203         NULL
204         };
205 #endif
206
207 #ifdef AEPRAND
208 /* our internal RAND_method that we provide pointers to  */
209 static RAND_METHOD aep_random =
210         {
211         /*"AEP RAND method", */
212         NULL,
213         aep_rand,
214         NULL,
215         NULL,
216         aep_rand,
217         aep_rand_status,
218         };
219 #endif
220
221 /*Define an array of structures to hold connections*/
222 static AEP_CONNECTION_ENTRY aep_app_conn_table[MAX_PROCESS_CONNECTIONS];
223
224 /*Used to determine if this is a new process*/
225 static pid_t    recorded_pid = 0;
226
227 #ifdef AEPRAND
228 static AEP_U8   rand_block[RAND_BLK_SIZE];
229 static AEP_U32  rand_block_bytes = 0;
230 #endif
231
232 /* Constants used when creating the ENGINE */
233 static const char *engine_aep_id = "aep";
234 static const char *engine_aep_name = "Aep hardware engine support";
235
236
237 /* This internal function is used by ENGINE_aep() and possibly by the
238  * "dynamic" ENGINE support too */
239 static int bind_aep(ENGINE *e)
240         {
241 #ifndef OPENSSL_NO_RSA
242         const RSA_METHOD  *meth1;
243 #endif
244 #ifndef OPENSSL_NO_DSA
245         const DSA_METHOD  *meth2;
246 #endif
247 #ifndef OPENSSL_NO_DH
248         const DH_METHOD   *meth3;
249 #endif
250
251         if(!ENGINE_set_id(e, engine_aep_id) ||
252                 !ENGINE_set_name(e, engine_aep_name) ||
253 #ifndef OPENSSL_NO_RSA
254                 !ENGINE_set_RSA(e, &aep_rsa) ||
255 #endif
256 #ifndef OPENSSL_NO_DSA
257                 !ENGINE_set_DSA(e, &aep_dsa) ||
258 #endif
259 #ifndef OPENSSL_NO_DH
260                 !ENGINE_set_DH(e, &aep_dh) ||
261 #endif
262 #ifdef AEPRAND
263                 !ENGINE_set_RAND(e, &aep_random) ||
264 #endif
265                 !ENGINE_set_init_function(e, aep_init) ||
266                 !ENGINE_set_destroy_function(e, aep_destroy) ||
267                 !ENGINE_set_finish_function(e, aep_finish) ||
268                 !ENGINE_set_ctrl_function(e, aep_ctrl) ||
269                 !ENGINE_set_cmd_defns(e, aep_cmd_defns))
270                 return 0;
271
272 #ifndef OPENSSL_NO_RSA
273         /* We know that the "PKCS1_SSLeay()" functions hook properly
274          * to the aep-specific mod_exp and mod_exp_crt so we use
275          * those functions. NB: We don't use ENGINE_openssl() or
276          * anything "more generic" because something like the RSAref
277          * code may not hook properly, and if you own one of these
278          * cards then you have the right to do RSA operations on it
279          * anyway! */
280         meth1 = RSA_PKCS1_SSLeay();
281         aep_rsa.rsa_pub_enc = meth1->rsa_pub_enc;
282         aep_rsa.rsa_pub_dec = meth1->rsa_pub_dec;
283         aep_rsa.rsa_priv_enc = meth1->rsa_priv_enc;
284         aep_rsa.rsa_priv_dec = meth1->rsa_priv_dec;
285 #endif
286
287
288 #ifndef OPENSSL_NO_DSA
289         /* Use the DSA_OpenSSL() method and just hook the mod_exp-ish
290          * bits. */
291         meth2 = DSA_OpenSSL();
292         aep_dsa.dsa_do_sign    = meth2->dsa_do_sign;
293         aep_dsa.dsa_sign_setup = meth2->dsa_sign_setup;
294         aep_dsa.dsa_do_verify  = meth2->dsa_do_verify;
295
296         aep_dsa = *DSA_get_default_method(); 
297         aep_dsa.dsa_mod_exp = aep_dsa_mod_exp; 
298         aep_dsa.bn_mod_exp = aep_mod_exp_dsa;
299 #endif
300
301 #ifndef OPENSSL_NO_DH
302         /* Much the same for Diffie-Hellman */
303         meth3 = DH_OpenSSL();
304         aep_dh.generate_key = meth3->generate_key;
305         aep_dh.compute_key  = meth3->compute_key;
306         aep_dh.bn_mod_exp   = meth3->bn_mod_exp;
307 #endif
308
309         /* Ensure the aep error handling is set up */
310         ERR_load_AEP_strings();
311
312         return 1;
313 }
314
315 #ifdef ENGINE_DYNAMIC_SUPPORT
316 static int bind_helper(ENGINE *e, const char *id)
317         {
318         if(id && (strcmp(id, engine_aep_id) != 0))
319                 return 0;
320         if(!bind_aep(e))
321                 return 0;
322         return 1;
323         }       
324 IMPLEMENT_DYNAMIC_CHECK_FN()
325 IMPLEMENT_DYNAMIC_BIND_FN(bind_helper)
326 #else
327 static ENGINE *engine_aep(void)
328         {
329         ENGINE *ret = ENGINE_new();
330         if(!ret)
331                 return NULL;
332         if(!bind_aep(ret))
333                 {
334                 ENGINE_free(ret);
335                 return NULL;
336                 }
337         return ret;
338         }
339
340 void ENGINE_load_aep(void)
341         {
342         /* Copied from eng_[openssl|dyn].c */
343         ENGINE *toadd = engine_aep();
344         if(!toadd) return;
345         ENGINE_add(toadd);
346         ENGINE_free(toadd);
347         ERR_clear_error();
348         }
349 #endif
350
351 /* This is a process-global DSO handle used for loading and unloading
352  * the Aep library. NB: This is only set (or unset) during an
353  * init() or finish() call (reference counts permitting) and they're
354  * operating with global locks, so this should be thread-safe
355  * implicitly. */
356 static DSO *aep_dso = NULL;
357
358 /* These are the static string constants for the DSO file name and the function
359  * symbol names to bind to. 
360 */
361 static const char *AEP_LIBNAME = "aep";
362
363 static const char *AEP_F1    = "AEP_ModExp";
364 static const char *AEP_F2    = "AEP_ModExpCrt";
365 #ifdef AEPRAND
366 static const char *AEP_F3    = "AEP_GenRandom";
367 #endif
368 static const char *AEP_F4    = "AEP_Finalize";
369 static const char *AEP_F5    = "AEP_Initialize";
370 static const char *AEP_F6    = "AEP_OpenConnection";
371 static const char *AEP_F7    = "AEP_SetBNCallBacks";
372 static const char *AEP_F8    = "AEP_CloseConnection";
373
374 /* These are the function pointers that are (un)set when the library has
375  * successfully (un)loaded. */
376 static t_AEP_OpenConnection    *p_AEP_OpenConnection  = NULL;
377 static t_AEP_CloseConnection   *p_AEP_CloseConnection = NULL;
378 static t_AEP_ModExp            *p_AEP_ModExp          = NULL;
379 static t_AEP_ModExpCrt         *p_AEP_ModExpCrt       = NULL;
380 #ifdef AEPRAND
381 static t_AEP_GenRandom         *p_AEP_GenRandom       = NULL;
382 #endif
383 static t_AEP_Initialize        *p_AEP_Initialize      = NULL;
384 static t_AEP_Finalize          *p_AEP_Finalize        = NULL;
385 static t_AEP_SetBNCallBacks    *p_AEP_SetBNCallBacks  = NULL;
386
387 /* (de)initialisation functions. */
388 static int aep_init(ENGINE *e)
389         {
390         t_AEP_ModExp          *p1;
391         t_AEP_ModExpCrt       *p2;
392 #ifdef AEPRAND
393         t_AEP_GenRandom       *p3;
394 #endif
395         t_AEP_Finalize        *p4;
396         t_AEP_Initialize      *p5;
397         t_AEP_OpenConnection  *p6;
398         t_AEP_SetBNCallBacks  *p7;
399         t_AEP_CloseConnection *p8;
400
401         int to_return = 0;
402  
403         if(aep_dso != NULL)
404                 {
405                 AEPerr(AEP_F_AEP_INIT,AEP_R_ALREADY_LOADED);
406                 goto err;
407                 }
408         /* Attempt to load libaep.so. */
409
410         aep_dso = DSO_load(NULL, AEP_LIBNAME, NULL, 0);
411   
412         if(aep_dso == NULL)
413                 {
414                 AEPerr(AEP_F_AEP_INIT,AEP_R_NOT_LOADED);
415                 goto err;
416                 }
417
418         if(     !(p1 = (t_AEP_ModExp *)     DSO_bind_func( aep_dso,AEP_F1))  ||
419                 !(p2 = (t_AEP_ModExpCrt*)   DSO_bind_func( aep_dso,AEP_F2))  ||
420 #ifdef AEPRAND
421                 !(p3 = (t_AEP_GenRandom*)   DSO_bind_func( aep_dso,AEP_F3))  ||
422 #endif
423                 !(p4 = (t_AEP_Finalize*)    DSO_bind_func( aep_dso,AEP_F4))  ||
424                 !(p5 = (t_AEP_Initialize*)  DSO_bind_func( aep_dso,AEP_F5))  ||
425                 !(p6 = (t_AEP_OpenConnection*) DSO_bind_func( aep_dso,AEP_F6))  ||
426                 !(p7 = (t_AEP_SetBNCallBacks*) DSO_bind_func( aep_dso,AEP_F7))  ||
427                 !(p8 = (t_AEP_CloseConnection*) DSO_bind_func( aep_dso,AEP_F8)))
428                 {
429                 AEPerr(AEP_F_AEP_INIT,AEP_R_NOT_LOADED);
430                 goto err;
431                 }
432
433         /* Copy the pointers */
434   
435         p_AEP_ModExp           = p1;
436         p_AEP_ModExpCrt        = p2;
437 #ifdef AEPRAND
438         p_AEP_GenRandom        = p3;
439 #endif
440         p_AEP_Finalize         = p4;
441         p_AEP_Initialize       = p5;
442         p_AEP_OpenConnection   = p6;
443         p_AEP_SetBNCallBacks   = p7;
444         p_AEP_CloseConnection  = p8;
445  
446         to_return = 1;
447  
448         return to_return;
449
450  err: 
451
452         if(aep_dso)
453                 DSO_free(aep_dso);
454                 
455         p_AEP_OpenConnection    = NULL;
456         p_AEP_ModExp            = NULL;
457         p_AEP_ModExpCrt         = NULL;
458 #ifdef AEPRAND
459         p_AEP_GenRandom         = NULL;
460 #endif
461         p_AEP_Initialize        = NULL;
462         p_AEP_Finalize          = NULL;
463         p_AEP_SetBNCallBacks    = NULL;
464         p_AEP_CloseConnection   = NULL;
465
466         return to_return;
467         }
468
469 /* Destructor (complements the "ENGINE_aep()" constructor) */
470 static int aep_destroy(ENGINE *e)
471         {
472         ERR_unload_AEP_strings();
473         return 1;
474         }
475
476 static int aep_finish(ENGINE *e)
477         {
478         int to_return = 0, in_use;
479         AEP_RV rv;
480
481         if(aep_dso == NULL)
482                 {
483                 AEPerr(AEP_F_AEP_FINISH,AEP_R_NOT_LOADED);
484                 goto err;
485                 }
486
487         rv = aep_close_all_connections(0, &in_use);
488         if (rv != AEP_R_OK)
489                 {
490                 AEPerr(AEP_F_AEP_FINISH,AEP_R_CLOSE_HANDLES_FAILED);
491                 goto err;
492                 }
493         if (in_use)
494                 {
495                 AEPerr(AEP_F_AEP_FINISH,AEP_R_CONNECTIONS_IN_USE);
496                 goto err;
497                 }
498
499         rv = p_AEP_Finalize();
500         if (rv != AEP_R_OK)
501                 {
502                 AEPerr(AEP_F_AEP_FINISH,AEP_R_FINALIZE_FAILED);
503                 goto err;
504                 }
505
506         if(!DSO_free(aep_dso))
507                 {
508                 AEPerr(AEP_F_AEP_FINISH,AEP_R_UNIT_FAILURE);
509                 goto err;
510                 }
511
512         aep_dso = NULL;
513         p_AEP_CloseConnection   = NULL;
514         p_AEP_OpenConnection    = NULL;
515         p_AEP_ModExp            = NULL;
516         p_AEP_ModExpCrt         = NULL;
517 #ifdef AEPRAND
518         p_AEP_GenRandom         = NULL;
519 #endif
520         p_AEP_Initialize        = NULL;
521         p_AEP_Finalize          = NULL;
522         p_AEP_SetBNCallBacks    = NULL;
523
524         to_return = 1;
525  err:
526         return to_return;
527         }
528
529 static int aep_ctrl(ENGINE *e, int cmd, long i, void *p, void (*f)())
530         {
531         int initialised = ((aep_dso == NULL) ? 0 : 1);
532         switch(cmd)
533                 {
534         case AEP_CMD_SO_PATH:
535                 if(p == NULL)
536                         {
537                         AEPerr(AEP_F_AEP_CTRL,
538                                 ERR_R_PASSED_NULL_PARAMETER);
539                         return 0;
540                         }
541                 if(initialised)
542                         {
543                         AEPerr(AEP_F_AEP_CTRL,
544                                 AEP_R_ALREADY_LOADED);
545                         return 0;
546                         }
547                 AEP_LIBNAME = (const char *)p;
548                 return 1;
549         default:
550                 break;
551                 }
552         AEPerr(AEP_F_AEP_CTRL,AEP_R_CTRL_COMMAND_NOT_IMPLEMENTED);
553         return 0;
554         }
555
556 static int aep_mod_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
557         const BIGNUM *m, BN_CTX *ctx)
558         {
559         int to_return = 0;
560         AEP_CONNECTION_HNDL hConnection;
561         AEP_RV rv;
562
563         /*Grab a connection from the pool*/
564         rv = aep_get_connection(&hConnection);
565         if (rv != AEP_R_OK)
566                 {     
567                 AEPerr(AEP_F_AEP_MOD_EXP,AEP_R_GET_HANDLE_FAILED);
568                 goto err;
569                 }
570
571         /*To the card with the mod exp*/
572         rv = p_AEP_ModExp(hConnection,(void*)a, (void*)p,(void*)m, (void*)r,NULL);
573
574         if (rv !=  AEP_R_OK)
575                 {
576                 AEPerr(AEP_F_AEP_MOD_EXP,AEP_R_MOD_EXP_FAILED);
577                 rv = aep_return_connection(hConnection);
578                 goto err;
579                 }
580
581         /*Return the connection to the pool*/
582         rv = aep_return_connection(hConnection);
583         if (rv != AEP_R_OK)
584                 {
585                 AEPerr(AEP_F_AEP_RAND,AEP_R_RETURN_CONNECTION_FAILED); 
586                 goto err;
587                 }
588
589         to_return = 1;
590  err:
591         return to_return;
592         }
593         
594 static AEP_RV aep_mod_exp_crt(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
595         const BIGNUM *q, const BIGNUM *dmp1,
596         const BIGNUM *dmq1,const BIGNUM *iqmp, BN_CTX *ctx)
597         {
598         AEP_RV rv = AEP_R_OK;
599         AEP_CONNECTION_HNDL hConnection;
600
601         /*Grab a connection from the pool*/
602         rv = aep_get_connection(&hConnection);
603         if (rv != AEP_R_OK)
604                 {
605                 AEPerr(AEP_F_AEP_MOD_EXP_CRT,AEP_R_GET_HANDLE_FAILED);
606                 goto err;
607                 }
608
609         /*To the card with the mod exp*/
610         rv = p_AEP_ModExpCrt(hConnection,(void*)a, (void*)p, (void*)q, (void*)dmp1,(void*)dmq1,
611                 (void*)iqmp,(void*)r,NULL);
612         if (rv != AEP_R_OK)
613                 {
614                 AEPerr(AEP_F_AEP_MOD_EXP_CRT,AEP_R_MOD_EXP_CRT_FAILED);
615                 rv = aep_return_connection(hConnection);
616                 goto err;
617                 }
618
619         /*Return the connection to the pool*/
620         rv = aep_return_connection(hConnection);
621         if (rv != AEP_R_OK)
622                 {
623                 AEPerr(AEP_F_AEP_RAND,AEP_R_RETURN_CONNECTION_FAILED); 
624                 goto err;
625                 }
626  
627  err:
628         return rv;
629         }
630         
631
632 #ifdef AEPRAND
633 static int aep_rand(unsigned char *buf,int len )
634         {
635         AEP_RV rv = AEP_R_OK;
636         AEP_CONNECTION_HNDL hConnection;
637
638         int to_return = 0;
639
640   
641         CRYPTO_w_lock(CRYPTO_LOCK_RAND);
642
643         /*Can the request be serviced with what's already in the buffer?*/
644         if (len <= rand_block_bytes)
645                 {
646                 memcpy(buf, &rand_block[RAND_BLK_SIZE - rand_block_bytes], len);
647                 rand_block_bytes -= len;
648                 CRYPTO_w_unlock(CRYPTO_LOCK_RAND);
649                 }
650         else
651                 /*If not the get another block of random bytes*/
652                 {
653                 CRYPTO_w_unlock(CRYPTO_LOCK_RAND);
654
655                 rv = aep_get_connection(&hConnection);
656                 if (rv !=  AEP_R_OK)
657                         { 
658                         AEPerr(AEP_F_AEP_RAND,AEP_R_GET_HANDLE_FAILED);             
659                         goto err_nounlock;
660                         }
661
662                 if (len > RAND_BLK_SIZE)
663                         {
664                         rv = p_AEP_GenRandom(hConnection, len, 2, buf, NULL);
665                         if (rv !=  AEP_R_OK)
666                                 {  
667                                 AEPerr(AEP_F_AEP_RAND,AEP_R_GET_RANDOM_FAILED); 
668                                 goto err_nounlock;
669                                 }
670                         }
671                 else
672                         {
673                         CRYPTO_w_lock(CRYPTO_LOCK_RAND);
674
675                         rv = p_AEP_GenRandom(hConnection, RAND_BLK_SIZE, 2, &rand_block[0], NULL);
676                         if (rv !=  AEP_R_OK)
677                                 {       
678                                 AEPerr(AEP_F_AEP_RAND,AEP_R_GET_RANDOM_FAILED); 
679               
680                                 goto err;
681                                 }
682
683                         rand_block_bytes = RAND_BLK_SIZE;
684
685                         memcpy(buf, &rand_block[RAND_BLK_SIZE - rand_block_bytes], len);
686                         rand_block_bytes -= len;
687
688                         CRYPTO_w_unlock(CRYPTO_LOCK_RAND);
689                         }
690
691                 rv = aep_return_connection(hConnection);
692                 if (rv != AEP_R_OK)
693                         {
694                         AEPerr(AEP_F_AEP_RAND,AEP_R_RETURN_CONNECTION_FAILED); 
695           
696                         goto err_nounlock;
697                         }
698                 }
699   
700         return 1;
701  err:
702         CRYPTO_w_unlock(CRYPTO_LOCK_DYNLOCK);
703  err_nounlock:
704         return 0;
705         }
706         
707 static int aep_rand_status(void)
708 {
709         return 1;
710 }
711 #endif
712
713 #ifndef OPENSSL_NO_RSA
714 static int aep_rsa_mod_exp(BIGNUM *r0, const BIGNUM *I, RSA *rsa)
715         {
716         BN_CTX *ctx = NULL;
717         int to_return = 0;
718         AEP_RV rv = AEP_R_OK;
719
720         if ((ctx = BN_CTX_new()) == NULL)
721                 goto err;
722
723         if (!aep_dso)
724                 {
725                 AEPerr(AEP_F_AEP_RSA_MOD_EXP,AEP_R_NOT_LOADED);
726                 goto err;
727                 }
728
729         /*See if we have all the necessary bits for a crt*/
730         if (rsa->q && rsa->dmp1 && rsa->dmq1 && rsa->iqmp)
731                 {
732                 rv =  aep_mod_exp_crt(r0,I,rsa->p,rsa->q, rsa->dmp1,rsa->dmq1,rsa->iqmp,ctx);
733                 if (rv != AEP_R_OK)
734                         goto err;
735                 }
736         else
737                 {
738                 if (!rsa->d || !rsa->n)
739                         {
740                         AEPerr(AEP_F_AEP_RSA_MOD_EXP,AEP_R_MISSING_KEY_COMPONENTS);
741                         goto err;
742                         }
743  
744                 rv = aep_mod_exp(r0,I,rsa->d,rsa->n,ctx);
745                 if  (rv != AEP_R_OK)
746                         goto err;
747         
748                 }
749
750         to_return = 1;
751
752  err:
753         if(ctx)
754                 BN_CTX_free(ctx);
755         return to_return;
756 }
757 #endif
758
759 #ifndef OPENSSL_NO_DSA
760 static int aep_dsa_mod_exp(DSA *dsa, BIGNUM *rr, BIGNUM *a1,
761         BIGNUM *p1, BIGNUM *a2, BIGNUM *p2, BIGNUM *m,
762         BN_CTX *ctx, BN_MONT_CTX *in_mont)
763         {
764         BIGNUM t;
765         int to_return = 0;
766         BN_init(&t);
767
768         /* let rr = a1 ^ p1 mod m */
769         if (!aep_mod_exp(rr,a1,p1,m,ctx)) goto end;
770         /* let t = a2 ^ p2 mod m */
771         if (!aep_mod_exp(&t,a2,p2,m,ctx)) goto end;
772         /* let rr = rr * t mod m */
773         if (!BN_mod_mul(rr,rr,&t,m,ctx)) goto end;
774         to_return = 1;
775  end: 
776         BN_free(&t);
777         return to_return;
778         }
779
780 static int aep_mod_exp_dsa(DSA *dsa, BIGNUM *r, BIGNUM *a,
781         const BIGNUM *p, const BIGNUM *m, BN_CTX *ctx,
782         BN_MONT_CTX *m_ctx)
783         {  
784         return aep_mod_exp(r, a, p, m, ctx); 
785         }
786 #endif
787
788 /* This function is aliased to mod_exp (with the mont stuff dropped). */
789 static int aep_mod_exp_mont(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
790         const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx)
791         {
792         return aep_mod_exp(r, a, p, m, ctx);
793         }
794
795 #ifndef OPENSSL_NO_DH
796 /* This function is aliased to mod_exp (with the dh and mont dropped). */
797 static int aep_mod_exp_dh(const DH *dh, BIGNUM *r, const BIGNUM *a,
798         const BIGNUM *p, const BIGNUM *m, BN_CTX *ctx,
799         BN_MONT_CTX *m_ctx)
800         {
801         return aep_mod_exp(r, a, p, m, ctx);
802         }
803 #endif
804
805 static AEP_RV aep_get_connection(AEP_CONNECTION_HNDL_PTR phConnection)
806         {
807         int count;
808         AEP_RV rv = AEP_R_OK;
809
810         /*Get the current process id*/
811         pid_t curr_pid;
812
813         CRYPTO_w_lock(CRYPTO_LOCK_ENGINE);
814
815         curr_pid = getpid();
816
817         /*Check if this is the first time this is being called from the current
818           process*/
819         if (recorded_pid != curr_pid)
820                 {
821                 /*Remember our pid so we can check if we're in a new process*/
822                 recorded_pid = curr_pid;
823
824                 /*Call Finalize to make sure we have not inherited some data
825                   from a parent process*/
826                 p_AEP_Finalize();
827      
828                 /*Initialise the AEP API*/
829                 rv = p_AEP_Initialize(NULL);
830
831                 if (rv != AEP_R_OK)
832                         {
833                         AEPerr(AEP_F_AEP_INIT,AEP_R_INIT_FAILURE);
834                         recorded_pid = 0;
835                         goto end;
836                         }
837
838                 /*Set the AEP big num call back functions*/
839                 rv = p_AEP_SetBNCallBacks(&GetBigNumSize, &MakeAEPBigNum,
840                         &ConvertAEPBigNum);
841
842                 if (rv != AEP_R_OK)
843                         {
844                         AEPerr(AEP_F_AEP_INIT,AEP_R_SETBNCALLBACK_FAILURE);
845                         recorded_pid = 0;
846                         goto end;
847                         }
848
849 #ifdef AEPRAND
850                 /*Reset the rand byte count*/
851                 rand_block_bytes = 0;
852 #endif
853
854                 /*Init the structures*/
855                 for (count = 0;count < MAX_PROCESS_CONNECTIONS;count ++)
856                         {
857                         aep_app_conn_table[count].conn_state = NotConnected;
858                         aep_app_conn_table[count].conn_hndl  = 0;
859                         }
860
861                 /*Open a connection*/
862                 rv = p_AEP_OpenConnection(phConnection);
863
864                 if (rv != AEP_R_OK)
865                         {
866                         AEPerr(AEP_F_AEP_INIT,AEP_R_UNIT_FAILURE);
867                         recorded_pid = 0;
868                         goto end;
869                         }
870
871                 aep_app_conn_table[0].conn_state = InUse;
872                 aep_app_conn_table[0].conn_hndl = *phConnection;
873                 goto end;
874                 }
875         /*Check the existing connections to see if we can find a free one*/
876         for (count = 0;count < MAX_PROCESS_CONNECTIONS;count ++)
877                 {
878                 if (aep_app_conn_table[count].conn_state == Connected)
879                         {
880                         aep_app_conn_table[count].conn_state = InUse;
881                         *phConnection = aep_app_conn_table[count].conn_hndl;
882                         goto end;
883                         }
884                 }
885         /*If no connections available, we're going to have to try
886           to open a new one*/
887         for (count = 0;count < MAX_PROCESS_CONNECTIONS;count ++)
888                 {
889                 if (aep_app_conn_table[count].conn_state == NotConnected)
890                         {
891                         /*Open a connection*/
892                         rv = p_AEP_OpenConnection(phConnection);
893
894                         if (rv != AEP_R_OK)
895                                 {             
896                                 AEPerr(AEP_F_AEP_INIT,AEP_R_UNIT_FAILURE);
897                                 goto end;
898                                 }
899
900                         aep_app_conn_table[count].conn_state = InUse;
901                         aep_app_conn_table[count].conn_hndl = *phConnection;
902                         goto end;
903                         }
904                 }
905         rv = AEP_R_GENERAL_ERROR;
906  end:
907         CRYPTO_w_unlock(CRYPTO_LOCK_ENGINE);
908         return rv;
909         }
910
911
912 static AEP_RV aep_return_connection(AEP_CONNECTION_HNDL hConnection)
913         {
914         int count;
915
916         CRYPTO_w_lock(CRYPTO_LOCK_ENGINE);
917
918         /*Find the connection item that matches this connection handle*/
919         for(count = 0;count < MAX_PROCESS_CONNECTIONS;count ++)
920                 {
921                 if (aep_app_conn_table[count].conn_hndl == hConnection)
922                         {
923                         aep_app_conn_table[count].conn_state = Connected;
924                         break;
925                         }
926                 }
927
928         CRYPTO_w_unlock(CRYPTO_LOCK_ENGINE);
929
930         return AEP_R_OK;
931         }
932
933 static AEP_RV aep_close_all_connections(int use_engine_lock, int *in_use)
934         {
935         int count;
936         AEP_RV rv;
937
938         *in_use = 0;
939         if (use_engine_lock) CRYPTO_w_lock(CRYPTO_LOCK_ENGINE);
940         for (count = 0;count < MAX_PROCESS_CONNECTIONS;count ++)
941                 {
942                 switch (aep_app_conn_table[count].conn_state)
943                         {
944                 case Connected:
945                         rv = p_AEP_CloseConnection(aep_app_conn_table[count].conn_hndl);
946                         if (rv != AEP_R_OK)
947                                 return rv;
948                         aep_app_conn_table[count].conn_state = NotConnected;
949                         aep_app_conn_table[count].conn_hndl  = 0;
950                         break;
951                 case InUse:
952                         (*in_use)++;
953                         break;
954                 case NotConnected:
955                         break;
956                         }
957                 }
958         if (use_engine_lock) CRYPTO_w_unlock(CRYPTO_LOCK_ENGINE);
959         return AEP_R_OK;
960         }
961
962 /*BigNum call back functions, used to convert OpenSSL bignums into AEP bignums.
963   Note only 32bit Openssl build support*/
964
965 static AEP_RV GetBigNumSize(void* ArbBigNum, AEP_U32* BigNumSize)
966         {
967         BIGNUM* bn;
968
969         /*Cast the ArbBigNum pointer to our BIGNUM struct*/
970         bn = (BIGNUM*) ArbBigNum;
971
972 #ifdef SIXTY_FOUR_BIT_LONG
973         *BigNumSize = bn->top << 3;
974 #else
975         /*Size of the bignum in bytes is equal to the bn->top (no of 32 bit
976           words) multiplies by 4*/
977         *BigNumSize = bn->top << 2;
978 #endif
979
980         return AEP_R_OK;
981         }
982
983 static AEP_RV MakeAEPBigNum(void* ArbBigNum, AEP_U32 BigNumSize,
984         unsigned char* AEP_BigNum)
985         {
986         BIGNUM* bn;
987
988 #ifndef SIXTY_FOUR_BIT_LONG
989         unsigned char* buf;
990         int i;
991 #endif
992
993         /*Cast the ArbBigNum pointer to our BIGNUM struct*/
994         bn = (BIGNUM*) ArbBigNum;
995
996 #ifdef SIXTY_FOUR_BIT_LONG
997         memcpy(AEP_BigNum, bn->d, BigNumSize);
998 #else
999         /*Must copy data into a (monotone) least significant byte first format
1000           performing endian conversion if necessary*/
1001         for(i=0;i<bn->top;i++)
1002                 {
1003                 buf = (unsigned char*)&bn->d[i];
1004
1005                 *((AEP_U32*)AEP_BigNum) =
1006                         (AEP_U32) ((unsigned) buf[1] << 8 | buf[0]) |
1007                         ((unsigned) buf[3] << 8 | buf[2])  << 16;
1008
1009                 AEP_BigNum += 4;
1010                 }
1011 #endif
1012
1013         return AEP_R_OK;
1014         }
1015
1016 /*Turn an AEP Big Num back to a user big num*/
1017 static AEP_RV ConvertAEPBigNum(void* ArbBigNum, AEP_U32 BigNumSize,
1018         unsigned char* AEP_BigNum)
1019         {
1020         BIGNUM* bn;
1021 #ifndef SIXTY_FOUR_BIT_LONG
1022         int i;
1023 #endif
1024
1025         bn = (BIGNUM*)ArbBigNum;
1026
1027         /*Expand the result bn so that it can hold our big num.
1028           Size is in bits*/
1029         bn_expand(bn, (int)(BigNumSize << 3));
1030
1031 #ifdef SIXTY_FOUR_BIT_LONG
1032         bn->top = BigNumSize >> 3;
1033         
1034         if((BigNumSize & 7) != 0)
1035                 bn->top++;
1036
1037         memset(bn->d, 0, bn->top << 3); 
1038
1039         memcpy(bn->d, AEP_BigNum, BigNumSize);
1040 #else
1041         bn->top = BigNumSize >> 2;
1042  
1043         for(i=0;i<bn->top;i++)
1044                 {
1045                 bn->d[i] = (AEP_U32)
1046                         ((unsigned) AEP_BigNum[3] << 8 | AEP_BigNum[2]) << 16 |
1047                         ((unsigned) AEP_BigNum[1] << 8 | AEP_BigNum[0]);
1048                 AEP_BigNum += 4;
1049                 }
1050 #endif
1051
1052         return AEP_R_OK;
1053 }       
1054         
1055 #endif /* !OPENSSL_NO_HW_AEP */
1056 #endif /* !OPENSSL_NO_HW */