add test
[openssl.git] / demos / engines / cluster_labs / hw_cluster_labs.c
1 /* crypto/engine/hw_cluster_labs.c */
2 /* Written by Jan Tschirschwitz (jan.tschirschwitz@cluster-labs.com
3  * for the OpenSSL project 2000.
4  */
5 /* ====================================================================
6  * Copyright (c) 1999 The OpenSSL Project.  All rights reserved.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  *
12  * 1. Redistributions of source code must retain the above copyright
13  *    notice, this list of conditions and the following disclaimer. 
14  *
15  * 2. Redistributions in binary form must reproduce the above copyright
16  *    notice, this list of conditions and the following disclaimer in
17  *    the documentation and/or other materials provided with the
18  *    distribution.
19  *
20  * 3. All advertising materials mentioning features or use of this
21  *    software must display the following acknowledgment:
22  *    "This product includes software developed by the OpenSSL Project
23  *    for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
24  *
25  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
26  *    endorse or promote products derived from this software without
27  *    prior written permission. For written permission, please contact
28  *    licensing@OpenSSL.org.
29  *
30  * 5. Products derived from this software may not be called "OpenSSL"
31  *    nor may "OpenSSL" appear in their names without prior written
32  *    permission of the OpenSSL Project.
33  *
34  * 6. Redistributions of any form whatsoever must retain the following
35  *    acknowledgment:
36  *    "This product includes software developed by the OpenSSL Project
37  *    for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
38  *
39  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
40  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
41  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
42  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
43  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
44  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
45  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
46  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
47  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
48  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
49  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
50  * OF THE POSSIBILITY OF SUCH DAMAGE.
51  * ====================================================================
52  *
53  * This product includes cryptographic software written by Eric Young
54  * (eay@cryptsoft.com).  This product includes software written by Tim
55  * Hudson (tjh@cryptsoft.com).
56  *
57  */
58
59 #define MSC_VER   /* only used cryptic.h */
60
61 #include <stdio.h>
62 #include <openssl/crypto.h>
63 #include <openssl/dso.h>
64 #include <openssl/des.h>
65 #include <openssl/engine.h>
66
67 #ifndef NO_HW
68 #ifndef NO_HW_CLUSTER_LABS
69
70 #ifdef FLAT_INC
71 #include "cluster_labs.h"
72 #else
73 #include "vendor_defns/cluster_labs.h"
74 #endif
75
76 #define CL_LIB_NAME "cluster_labs engine"
77 #include "hw_cluster_labs_err.c"
78
79
80 static int cluster_labs_destroy(ENGINE *e);
81 static int cluster_labs_init(ENGINE *e);
82 static int cluster_labs_finish(ENGINE *e);
83 static int cluster_labs_ctrl(ENGINE *e, int cmd, long i, void *p, void (*f)());
84
85
86 /* BIGNUM stuff */
87 /* This function is aliased to mod_exp (with the mont stuff dropped). */
88 static int cluster_labs_mod_exp_mont(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
89                 const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx);
90                 
91 /* RSA stuff */
92 #ifndef OPENSSL_NO_RSA
93 static int cluster_labs_rsa_pub_enc(int flen, const unsigned char *from,
94              unsigned char *to, RSA *rsa, int padding);
95 static int cluster_labs_rsa_pub_dec(int flen, const unsigned char *from,
96              unsigned char *to, RSA *rsa, int padding);
97 static int cluster_labs_rsa_priv_enc(int flen, const unsigned char *from, 
98                 unsigned char *to, RSA *rsa, int padding);
99 static int cluster_labs_rsa_priv_dec(int flen, const unsigned char *from, 
100                 unsigned char *to, RSA *rsa, int padding);
101 static int cluster_labs_rsa_mod_exp(BIGNUM *r0, const BIGNUM *I, RSA *rsa);
102 #endif
103
104 /* DSA stuff */
105 #ifndef OPENSSL_NO_DSA
106 DSA_SIG *cluster_labs_dsa_sign(const unsigned char *dgst, int dlen, DSA *dsa);
107 static int cluster_labs_dsa_verify(const unsigned char *dgst, int dgst_len,
108                                 DSA_SIG *sig, DSA *dsa);
109 static int cluster_labs_dsa_mod_exp(DSA *dsa, BIGNUM *rr, BIGNUM *a1,
110                 BIGNUM *p1, BIGNUM *a2, BIGNUM *p2, BIGNUM *m,
111                 BN_CTX *ctx, BN_MONT_CTX *in_mont);
112 static int cluster_labs_mod_exp_dsa(DSA *dsa, BIGNUM *r, BIGNUM *a,
113                 const BIGNUM *p, const BIGNUM *m, BN_CTX *ctx,
114                 BN_MONT_CTX *m_ctx);
115 #endif
116                                                                 
117 /* DH stuff */
118 #ifndef OPENSSL_NO_DH
119 /* This function is alised to mod_exp (with the DH and mont dropped). */
120 static int cluster_labs_mod_exp_dh(const DH *dh, BIGNUM *r, const BIGNUM *a, const BIGNUM *p, 
121                 const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx);
122 #endif
123                 
124 /* RANDOM stuff */                                              
125 static int cluster_labs_rand_bytes(unsigned char *buf, int num);
126
127 /* The definitions for control commands specific to this engine */
128 #define CLUSTER_LABS_CMD_SO_PATH                ENGINE_CMD_BASE
129 static const ENGINE_CMD_DEFN cluster_labs_cmd_defns[] =
130         {
131         { CLUSTER_LABS_CMD_SO_PATH,
132           "SO_PATH",
133           "Specifies the path to the 'cluster labs' shared library",
134           ENGINE_CMD_FLAG_STRING
135         },
136         {0, NULL, NULL, 0}
137         };
138
139 /* Our internal RSA_METHOD that we provide pointers to */
140 #ifndef OPENSSL_NO_RSA
141 static RSA_METHOD cluster_labs_rsa =
142         {
143         "Cluster Labs RSA method",
144         cluster_labs_rsa_pub_enc,       /* rsa_pub_enc */
145         cluster_labs_rsa_pub_dec,       /* rsa_pub_dec */
146         cluster_labs_rsa_priv_enc,      /* rsa_priv_enc */
147         cluster_labs_rsa_priv_dec,      /* rsa_priv_dec */
148         cluster_labs_rsa_mod_exp,       /* rsa_mod_exp */
149         cluster_labs_mod_exp_mont,      /* bn_mod_exp */
150         NULL,                           /* init */
151         NULL,                           /* finish */
152         0,                              /* flags */
153         NULL,                           /* apps_data */
154         NULL,                           /* rsa_sign */
155         NULL                            /* rsa_verify */
156         };
157 #endif
158
159 /* Our internal DSA_METHOD that we provide pointers to */
160 #ifndef OPENSSL_NO_DSA
161 static DSA_METHOD cluster_labs_dsa =
162         {
163         "Cluster Labs DSA method",
164         cluster_labs_dsa_sign,          /* dsa_do_sign */
165         NULL,                           /* dsa_sign_setup */
166         cluster_labs_dsa_verify,        /* dsa_do_verify */
167         cluster_labs_dsa_mod_exp,       /* dsa_mod_exp */
168         cluster_labs_mod_exp_dsa,       /* bn_mod_exp */
169         NULL,                           /* init */
170         NULL,                           /* finish */
171         0,                              /* flags */
172         NULL                            /* app_data */
173         };
174 #endif  
175
176 /* Our internal DH_METHOD that we provide pointers to */
177 #ifndef OPENSSL_NO_DH
178 static DH_METHOD cluster_labs_dh =
179         {
180         "Cluster Labs DH method",
181         NULL,                           /* generate key */
182         NULL,                           /* compute key */
183         cluster_labs_mod_exp_dh,        /* bn_mod_exp */
184         NULL,                           /* init */
185         NULL,                           /* finish */
186         0,                              /* flags */
187         NULL                            /* app_data */
188         };
189 #endif  
190         
191 static RAND_METHOD cluster_labs_rand =
192         {
193         /* "Cluster Labs RAND method", */
194         NULL,                           /* seed */
195         cluster_labs_rand_bytes,        /* bytes */
196         NULL,                           /* cleanup */
197         NULL,                           /* add */
198         cluster_labs_rand_bytes,        /* pseudorand */
199         NULL,                           /* status */
200         };      
201
202 static const char *engine_cluster_labs_id = "cluster_labs";
203 static const char *engine_cluster_labs_name = "Cluster Labs hardware engine support";
204
205 /* engine implementation */
206 /*-----------------------*/
207 static int bind_helper(ENGINE *e)
208         {
209         
210         if(!ENGINE_set_id(e, engine_cluster_labs_id) ||
211                         !ENGINE_set_name(e, engine_cluster_labs_name) ||
212 #ifndef OPENSSL_NO_RSA
213                         !ENGINE_set_RSA(e, &cluster_labs_rsa) ||
214 #endif
215 #ifndef OPENSSL_NO_DSA
216                         !ENGINE_set_DSA(e, &cluster_labs_dsa) ||
217 #endif
218 #ifndef OPENSSL_NO_DH
219                         !ENGINE_set_DH(e, &cluster_labs_dh) ||
220 #endif
221                         !ENGINE_set_RAND(e, &cluster_labs_rand) ||
222                         !ENGINE_set_destroy_function(e, cluster_labs_destroy) ||
223                         !ENGINE_set_init_function(e, cluster_labs_init) ||
224                         !ENGINE_set_finish_function(e, cluster_labs_finish) ||
225                         !ENGINE_set_ctrl_function(e, cluster_labs_ctrl) ||
226                         !ENGINE_set_cmd_defns(e, cluster_labs_cmd_defns))
227                 return 0;
228         /* Ensure the error handling is set up */
229         ERR_load_CL_strings();
230         return 1;
231         }
232         
233 #ifndef ENGINE_DYNAMIC_SUPPORT
234 static ENGINE *engine_cluster_labs(void)
235         {
236         ENGINE *ret = ENGINE_new();
237
238         if(!ret)
239                 return NULL;
240         if(!bind_helper(ret))
241                 {
242                 ENGINE_free(ret);
243                 return NULL;
244                 }
245         return ret;
246         }
247
248 void ENGINE_load_cluster_labs(void)
249         {
250
251         ENGINE *cluster_labs = engine_cluster_labs();
252         
253         if(!cluster_labs) return;
254         ENGINE_add(cluster_labs);
255         ENGINE_free(cluster_labs);
256         ERR_clear_error();
257         }
258 #endif /* !ENGINE_DYNAMIC_SUPPORT */
259
260 static int cluster_labs_destroy(ENGINE *e)
261         {
262         
263         ERR_unload_CL_strings();
264         return 1;
265         }
266
267
268
269 /* This is a process-global DSO handle used for loading and unloading
270  * the Cluster Labs library. NB: This is only set (or unset) during an
271  * init() or finish() call (reference counts permitting) and they're
272  * operating with global locks, so this should be thread-safe
273  * implicitly. */
274 static DSO *cluster_labs_dso = NULL;
275
276 /* These are the function pointers that are (un)set when the library has
277  * successfully (un)loaded. */
278 static cl_engine_init           *p_cl_engine_init                = NULL;
279 static cl_mod_exp               *p_cl_mod_exp                    = NULL;
280 static cl_mod_exp_crt           *p_cl_mod_exp_crt                = NULL;
281 static cl_rsa_mod_exp           *p_cl_rsa_mod_exp                = NULL;
282 static cl_rsa_priv_enc          *p_cl_rsa_priv_enc               = NULL;
283 static cl_rsa_priv_dec          *p_cl_rsa_priv_dec               = NULL;
284 static cl_rsa_pub_enc           *p_cl_rsa_pub_enc                = NULL;
285 static cl_rsa_pub_dec           *p_cl_rsa_pub_dec                = NULL;
286 static cl_rand_bytes            *p_cl_rand_bytes                 = NULL;
287 static cl_dsa_sign              *p_cl_dsa_sign                   = NULL;
288 static cl_dsa_verify            *p_cl_dsa_verify                 = NULL;
289
290
291 int cluster_labs_init(ENGINE *e)
292         {
293
294         cl_engine_init                  *p1;
295         cl_mod_exp                      *p2;
296         cl_mod_exp_crt                  *p3;
297         cl_rsa_mod_exp                  *p4;
298         cl_rsa_priv_enc                 *p5;
299         cl_rsa_priv_dec                 *p6;    
300         cl_rsa_pub_enc                  *p7;
301         cl_rsa_pub_dec                  *p8;
302         cl_rand_bytes                   *p20;
303         cl_dsa_sign                     *p30;   
304         cl_dsa_verify                   *p31;           
305         
306         /* engine already loaded */
307         if(cluster_labs_dso != NULL)
308                 {
309                 CLerr(CL_F_CLUSTER_LABS_INIT,CL_R_ALREADY_LOADED);
310                 goto err;
311                 }
312         /* try to load engine    */     
313         cluster_labs_dso = DSO_load(NULL, CLUSTER_LABS_LIB_NAME, NULL,0);
314         if(cluster_labs_dso == NULL)
315                 {
316                 CLerr(CL_F_CLUSTER_LABS_INIT,CL_R_DSO_FAILURE);
317                 goto err;
318                 }
319         /* bind functions */
320         if(     !(p1 = (cl_engine_init *)DSO_bind_func(
321                                 cluster_labs_dso, CLUSTER_LABS_F1)) ||
322                 !(p2 = (cl_mod_exp *)DSO_bind_func(
323                                 cluster_labs_dso, CLUSTER_LABS_F2)) ||                  
324                 !(p3 = (cl_mod_exp_crt *)DSO_bind_func(
325                                 cluster_labs_dso, CLUSTER_LABS_F3)) ||                          
326                 !(p4 = (cl_rsa_mod_exp *)DSO_bind_func(
327                                 cluster_labs_dso, CLUSTER_LABS_F4)) ||                          
328                 !(p5 = (cl_rsa_priv_enc *)DSO_bind_func(
329                                 cluster_labs_dso, CLUSTER_LABS_F5)) ||
330                 !(p6 = (cl_rsa_priv_dec *)DSO_bind_func(
331                                 cluster_labs_dso, CLUSTER_LABS_F6)) ||
332                 !(p7 = (cl_rsa_pub_enc *)DSO_bind_func(
333                                 cluster_labs_dso, CLUSTER_LABS_F7)) ||
334                 !(p8 = (cl_rsa_pub_dec *)DSO_bind_func(
335                                 cluster_labs_dso, CLUSTER_LABS_F8)) ||
336                 !(p20= (cl_rand_bytes *)DSO_bind_func(
337                                 cluster_labs_dso, CLUSTER_LABS_F20)) ||
338                 !(p30= (cl_dsa_sign *)DSO_bind_func(
339                                 cluster_labs_dso, CLUSTER_LABS_F30)) ||
340                 !(p31= (cl_dsa_verify *)DSO_bind_func(
341                                 cluster_labs_dso, CLUSTER_LABS_F31)))
342                 {
343                 CLerr(CL_F_CLUSTER_LABS_INIT,CL_R_DSO_FAILURE);
344                 goto err;
345                 }
346                 
347         /* copy function pointers */
348         p_cl_engine_init                = p1;
349         p_cl_mod_exp                    = p2;
350         p_cl_mod_exp_crt                = p3;   
351         p_cl_rsa_mod_exp                = p4;
352         p_cl_rsa_priv_enc               = p5;
353         p_cl_rsa_priv_dec               = p6;
354         p_cl_rsa_pub_enc                = p7;
355         p_cl_rsa_pub_dec                = p8;
356         p_cl_rand_bytes                 = p20;  
357         p_cl_dsa_sign                   = p30;
358         p_cl_dsa_verify                 = p31;  
359         
360         
361         
362         /* cluster labs engine init */
363         if(p_cl_engine_init()== 0){
364                 CLerr(CL_F_CLUSTER_LABS_INIT,CL_R_INIT_FAILED);         
365                 goto err;
366         }
367
368         return(1);
369
370 err:    
371         /* reset all pointers */
372         if(cluster_labs_dso)
373                 DSO_free(cluster_labs_dso);
374
375         cluster_labs_dso                = NULL;
376         p_cl_engine_init                = NULL; 
377         p_cl_mod_exp                    = NULL;
378         p_cl_mod_exp_crt                = NULL;
379         p_cl_rsa_mod_exp                = NULL;
380         p_cl_rsa_priv_enc               = NULL;
381         p_cl_rsa_priv_dec               = NULL; 
382         p_cl_rsa_pub_enc                = NULL;
383         p_cl_rsa_pub_dec                = NULL; 
384         p_cl_rand_bytes                 = NULL; 
385         p_cl_dsa_sign                   = NULL;
386         p_cl_dsa_verify                 = NULL; 
387         
388         return(0);
389         }
390         
391
392 static int cluster_labs_finish(ENGINE *e)
393         {
394
395         if(cluster_labs_dso == NULL)
396                 {
397                 CLerr(CL_F_CLUSTER_LABS_FINISH,CL_R_NOT_LOADED);
398                 return 0;
399                 }
400         if(!DSO_free(cluster_labs_dso))
401                 {
402                 CLerr(CL_F_CLUSTER_LABS_FINISH,CL_R_DSO_FAILURE);
403                 return 0;
404                 }
405                 
406         cluster_labs_dso                = NULL;
407         p_cl_engine_init                = NULL;         
408         p_cl_mod_exp                    = NULL;
409         p_cl_rsa_mod_exp                = NULL; 
410         p_cl_mod_exp_crt                = NULL; 
411         p_cl_rsa_priv_enc               = NULL; 
412         p_cl_rsa_priv_dec               = NULL; 
413         p_cl_rsa_pub_enc                = NULL;
414         p_cl_rsa_pub_dec                = NULL; 
415         p_cl_rand_bytes                 = NULL;         
416         p_cl_dsa_sign                   = NULL;
417         p_cl_dsa_verify                 = NULL; 
418         
419         return(1);      
420         
421         }
422         
423 static int cluster_labs_ctrl(ENGINE *e, int cmd, long i, void *p, void (*f)())
424         {
425         int initialised = ((cluster_labs_dso == NULL) ? 0 : 1);
426
427         switch(cmd)
428                 {
429         case CLUSTER_LABS_CMD_SO_PATH:
430                 if(p == NULL)
431                         {
432                         CLerr(CL_F_CLUSTER_LABS_CTRL,ERR_R_PASSED_NULL_PARAMETER);
433                         return 0;
434                         }
435                 if(initialised)
436                         {
437                         CLerr(CL_F_CLUSTER_LABS_CTRL,CL_R_ALREADY_LOADED);
438                         return 0;
439                         }
440                 CLUSTER_LABS_LIB_NAME = (const char *)p;
441                 return 1;
442         default:
443                 break;
444                 }
445         CLerr(CL_F_CLUSTER_LABS_CTRL,CL_R_COMMAND_NOT_IMPLEMENTED);
446         return 0;
447         }
448         
449
450 static int cluster_labs_mod_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
451                 const BIGNUM *m, BN_CTX *ctx)
452         {
453
454         if(cluster_labs_dso == NULL)
455                 {
456                 CLerr(CL_F_CLUSTER_LABS_MOD_EXP,CL_R_NOT_LOADED);
457                 return 0;
458                 }       
459         if(p_cl_mod_exp == NULL)
460                 {
461                 CLerr(CL_F_CLUSTER_LABS_MOD_EXP,CL_R_FUNCTION_NOT_BINDED);
462                 return 0;
463                 }
464
465         return  p_cl_mod_exp(r, a, p, m, ctx);
466
467         }
468         
469 static int cluster_labs_mod_exp_crt(BIGNUM *r, BIGNUM *a, const BIGNUM *p,
470                 const BIGNUM *q, const BIGNUM *dmp1, const BIGNUM *dmq1,
471                 const BIGNUM *iqmp, BN_CTX *ctx)
472         {
473
474         if(cluster_labs_dso == NULL)
475                 {
476                 CLerr(CL_F_CLUSTER_LABS_MOD_EXP_CRT,CL_R_NOT_LOADED);           
477                 return 0;
478                 }
479         if(p_cl_mod_exp_crt == NULL)
480                 {
481                 CLerr(CL_F_CLUSTER_LABS_MOD_EXP_CRT,CL_R_FUNCTION_NOT_BINDED);          
482                 return 0;
483                 }
484         
485         return  p_cl_mod_exp_crt(r, a, p, q,dmp1, dmq1, iqmp, ctx);
486         
487         }
488         
489 static int cluster_labs_rsa_mod_exp(BIGNUM *r0, const BIGNUM *I, RSA *rsa)
490         {
491
492         if(cluster_labs_dso == NULL)
493                 {
494                 CLerr(CL_F_CLUSTER_LABS_RSA_MOD_EXP,CL_R_NOT_LOADED);           
495                 return 0;
496                 }
497         if(p_cl_rsa_mod_exp == NULL)
498                 {
499                 CLerr(CL_F_CLUSTER_LABS_RSA_MOD_EXP,CL_R_FUNCTION_NOT_BINDED);                          
500                 return 0;
501                 }
502
503         return p_cl_rsa_mod_exp(r0, I, rsa);
504
505         }
506         
507 DSA_SIG *cluster_labs_dsa_sign(const unsigned char *dgst, int dlen, DSA *dsa)
508         {
509
510         if(cluster_labs_dso == NULL)
511                 {
512                 CLerr(CL_F_CLUSTER_LABS_DSA_SIGN,CL_R_NOT_LOADED);              
513                 return 0;
514                 }
515         if(p_cl_dsa_sign == NULL)
516                 {
517                 CLerr(CL_F_CLUSTER_LABS_DSA_SIGN,CL_R_FUNCTION_NOT_BINDED);                             
518                 return 0;
519                 }
520
521         return p_cl_dsa_sign(dgst, dlen, dsa);
522         
523         }
524         
525 static int cluster_labs_dsa_verify(const unsigned char *dgst, int dgst_len,
526                                 DSA_SIG *sig, DSA *dsa)
527         {
528
529         if(cluster_labs_dso == NULL)
530                 {
531                 CLerr(CL_F_CLUSTER_LABS_DSA_VERIFY,CL_R_NOT_LOADED);            
532                 return 0;
533                 }
534         
535         if(p_cl_dsa_verify == NULL)
536                 {
537                 CLerr(CL_F_CLUSTER_LABS_DSA_VERIFY,CL_R_FUNCTION_NOT_BINDED);                           
538                 return 0;
539                 }
540
541         return p_cl_dsa_verify(dgst, dgst_len, sig, dsa);
542         
543         }                       
544
545 static int cluster_labs_dsa_mod_exp(DSA *dsa, BIGNUM *rr, BIGNUM *a1,
546                 BIGNUM *p1, BIGNUM *a2, BIGNUM *p2, BIGNUM *m,
547                 BN_CTX *ctx, BN_MONT_CTX *in_mont)
548         {
549         BIGNUM t;
550         int status = 0;
551                 
552         BN_init(&t);
553         /* let rr = a1 ^ p1 mod m */
554         if (!cluster_labs_mod_exp(rr,a1,p1,m,ctx)) goto end;
555         /* let t = a2 ^ p2 mod m */
556         if (!cluster_labs_mod_exp(&t,a2,p2,m,ctx)) goto end;
557         /* let rr = rr * t mod m */
558         if (!BN_mod_mul(rr,rr,&t,m,ctx)) goto end;
559         status = 1;
560 end:
561         BN_free(&t);
562         
563         return(1);
564
565         }
566
567 static int cluster_labs_mod_exp_dsa(DSA *dsa, BIGNUM *r, BIGNUM *a,
568                 const BIGNUM *p, const BIGNUM *m, BN_CTX *ctx,
569                 BN_MONT_CTX *m_ctx)
570         {
571         return  cluster_labs_mod_exp(r, a, p, m, ctx);
572         }
573         
574 /* This function is aliased to mod_exp (with the mont stuff dropped). */
575 static int cluster_labs_mod_exp_mont(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
576                 const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx)
577         {
578         return  cluster_labs_mod_exp(r, a, p, m, ctx);
579         }
580         
581
582 /* This function is aliased to mod_exp (with the dh and mont dropped). */
583 static int cluster_labs_mod_exp_dh(const DH *dh, BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
584                 const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx)
585         {
586         return  cluster_labs_mod_exp(r, a, p, m, ctx);
587         }
588
589
590 static int cluster_labs_rsa_pub_enc(int flen, const unsigned char *from,
591              unsigned char *to, RSA *rsa, int padding)
592         {
593
594         if(cluster_labs_dso == NULL)
595                 {
596                 CLerr(CL_F_CLUSTER_LABS_RSA_PUB_ENC,CL_R_NOT_LOADED);           
597                 return 0;
598                 }
599         if(p_cl_rsa_priv_enc == NULL)
600                 {
601                 CLerr(CL_F_CLUSTER_LABS_RSA_PUB_ENC,CL_R_FUNCTION_NOT_BINDED);                          
602                 return 0;
603                 }
604                 
605         return  p_cl_rsa_pub_enc(flen, from, to, rsa, padding);
606         
607         }  
608              
609 static int cluster_labs_rsa_pub_dec(int flen, const unsigned char *from,
610              unsigned char *to, RSA *rsa, int padding)
611         {
612
613         if(cluster_labs_dso == NULL)
614                 {
615                 CLerr(CL_F_CLUSTER_LABS_RSA_PUB_DEC,CL_R_NOT_LOADED);           
616                 return 0;
617                 }
618         if(p_cl_rsa_priv_enc == NULL)
619                 {
620                 CLerr(CL_F_CLUSTER_LABS_RSA_PUB_DEC,CL_R_FUNCTION_NOT_BINDED);                          
621                 return 0;
622                 }
623                 
624         return  p_cl_rsa_pub_dec(flen, from, to, rsa, padding);
625         
626         }  
627
628
629 static int cluster_labs_rsa_priv_enc(int flen, const unsigned char *from, 
630                 unsigned char *to, RSA *rsa, int padding)
631         {
632
633         if(cluster_labs_dso == NULL)
634                 {
635                 CLerr(CL_F_CLUSTER_LABS_RSA_PRIV_ENC,CL_R_NOT_LOADED);          
636                 return 0;
637                 }
638
639         if(p_cl_rsa_priv_enc == NULL)
640                 {
641                 CLerr(CL_F_CLUSTER_LABS_RSA_PRIV_ENC,CL_R_FUNCTION_NOT_BINDED);                         
642                 return 0;
643                 }
644                 
645         return  p_cl_rsa_priv_enc(flen, from, to, rsa, padding);
646         
647         }  
648
649 static int cluster_labs_rsa_priv_dec(int flen, const unsigned char *from, 
650                 unsigned char *to, RSA *rsa, int padding)
651         {
652         
653         if(cluster_labs_dso == NULL)
654                 {
655                 CLerr(CL_F_CLUSTER_LABS_RSA_PRIV_DEC,CL_R_NOT_LOADED);          
656                 return 0;
657                 }
658         if(p_cl_rsa_priv_dec == NULL)
659                 {
660                 CLerr(CL_F_CLUSTER_LABS_RSA_PRIV_DEC,CL_R_FUNCTION_NOT_BINDED);                         
661                 return 0;
662                 }
663
664         return  p_cl_rsa_priv_dec(flen, from, to, rsa, padding);
665                 
666         }  
667
668 /************************************************************************************
669 * Symmetric algorithms
670 ************************************************************************************/
671 /* this will be come soon! */
672
673 /************************************************************************************
674 * Random generator
675 ************************************************************************************/
676
677 static int cluster_labs_rand_bytes(unsigned char *buf, int num){
678
679         if(cluster_labs_dso == NULL)
680                 {
681                 CLerr(CL_F_CLUSTER_LABS_RAND_BYTES,CL_R_NOT_LOADED);            
682                 return 0;
683                 }
684         if(p_cl_mod_exp_crt == NULL)
685                 {
686                 CLerr(CL_F_CLUSTER_LABS_RAND_BYTES,CL_R_FUNCTION_NOT_BINDED);                           
687                 return 0;
688                 }
689
690         return  p_cl_rand_bytes(buf, num);
691
692 }
693
694
695 /* This stuff is needed if this ENGINE is being compiled into a self-contained
696  * shared-library. */
697 #ifdef ENGINE_DYNAMIC_SUPPORT
698 static int bind_fn(ENGINE *e, const char *id)
699         {
700         fprintf(stderr, "bind_fn CLUSTER_LABS\n");
701         if(id && (strcmp(id, engine_cluster_labs_id) != 0)) {
702                 fprintf(stderr, "bind_fn return(0) first\n");
703                 return 0;
704                 }
705         if(!bind_helper(e)) {
706                 fprintf(stderr, "bind_fn return(1) first\n");
707                 return 0;
708                 }
709         fprintf(stderr, "bind_fn return(1)\n");         
710         return 1;
711         }
712 IMPLEMENT_DYNAMIC_CHECK_FN()
713 IMPLEMENT_DYNAMIC_BIND_FN(bind_fn)
714 #endif /* ENGINE_DYNAMIC_SUPPORT */
715                                                 
716 #endif /* !NO_HW_CLUSTER_LABS */
717 #endif /* !NO_HW */
718