OpenSSL  1.0.1c
 All Classes Files Functions Variables Typedefs Enumerations Enumerator Macros
hw_cluster_labs.c
Go to the documentation of this file.
1 /* crypto/engine/hw_cluster_labs.c */
2 /* Written by Jan Tschirschwitz ([email protected]
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  * [email protected].
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  * ([email protected]). This product includes software written by Tim
55  * Hudson ([email protected]).
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 static 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 #ifdef ENGINE_DYNAMIC_SUPPORT
249 static
250 #endif
251 void ENGINE_load_cluster_labs(void)
252  {
253 
254  ENGINE *cluster_labs = engine_cluster_labs();
255 
256  if(!cluster_labs) return;
257  ENGINE_add(cluster_labs);
258  ENGINE_free(cluster_labs);
259  ERR_clear_error();
260  }
261 #endif /* !ENGINE_DYNAMIC_SUPPORT */
262 
263 static int cluster_labs_destroy(ENGINE *e)
264  {
265 
266  ERR_unload_CL_strings();
267  return 1;
268  }
269 
270 
271 
272 /* This is a process-global DSO handle used for loading and unloading
273  * the Cluster Labs library. NB: This is only set (or unset) during an
274  * init() or finish() call (reference counts permitting) and they're
275  * operating with global locks, so this should be thread-safe
276  * implicitly. */
277 static DSO *cluster_labs_dso = NULL;
278 
279 /* These are the function pointers that are (un)set when the library has
280  * successfully (un)loaded. */
281 static cl_engine_init *p_cl_engine_init = NULL;
282 static cl_mod_exp *p_cl_mod_exp = NULL;
283 static cl_mod_exp_crt *p_cl_mod_exp_crt = NULL;
284 static cl_rsa_mod_exp *p_cl_rsa_mod_exp = NULL;
285 static cl_rsa_priv_enc *p_cl_rsa_priv_enc = NULL;
286 static cl_rsa_priv_dec *p_cl_rsa_priv_dec = NULL;
287 static cl_rsa_pub_enc *p_cl_rsa_pub_enc = NULL;
288 static cl_rsa_pub_dec *p_cl_rsa_pub_dec = NULL;
289 static cl_rand_bytes *p_cl_rand_bytes = NULL;
290 static cl_dsa_sign *p_cl_dsa_sign = NULL;
291 static cl_dsa_verify *p_cl_dsa_verify = NULL;
292 
293 
294 int cluster_labs_init(ENGINE *e)
295  {
296 
297  cl_engine_init *p1;
298  cl_mod_exp *p2;
299  cl_mod_exp_crt *p3;
300  cl_rsa_mod_exp *p4;
301  cl_rsa_priv_enc *p5;
302  cl_rsa_priv_dec *p6;
303  cl_rsa_pub_enc *p7;
304  cl_rsa_pub_dec *p8;
305  cl_rand_bytes *p20;
306  cl_dsa_sign *p30;
307  cl_dsa_verify *p31;
308 
309  /* engine already loaded */
310  if(cluster_labs_dso != NULL)
311  {
312  CLerr(CL_F_CLUSTER_LABS_INIT,CL_R_ALREADY_LOADED);
313  goto err;
314  }
315  /* try to load engine */
316  cluster_labs_dso = DSO_load(NULL, CLUSTER_LABS_LIB_NAME, NULL,0);
317  if(cluster_labs_dso == NULL)
318  {
319  CLerr(CL_F_CLUSTER_LABS_INIT,CL_R_DSO_FAILURE);
320  goto err;
321  }
322  /* bind functions */
323  if( !(p1 = (cl_engine_init *)DSO_bind_func(
324  cluster_labs_dso, CLUSTER_LABS_F1)) ||
325  !(p2 = (cl_mod_exp *)DSO_bind_func(
326  cluster_labs_dso, CLUSTER_LABS_F2)) ||
327  !(p3 = (cl_mod_exp_crt *)DSO_bind_func(
328  cluster_labs_dso, CLUSTER_LABS_F3)) ||
329  !(p4 = (cl_rsa_mod_exp *)DSO_bind_func(
330  cluster_labs_dso, CLUSTER_LABS_F4)) ||
331  !(p5 = (cl_rsa_priv_enc *)DSO_bind_func(
332  cluster_labs_dso, CLUSTER_LABS_F5)) ||
333  !(p6 = (cl_rsa_priv_dec *)DSO_bind_func(
334  cluster_labs_dso, CLUSTER_LABS_F6)) ||
335  !(p7 = (cl_rsa_pub_enc *)DSO_bind_func(
336  cluster_labs_dso, CLUSTER_LABS_F7)) ||
337  !(p8 = (cl_rsa_pub_dec *)DSO_bind_func(
338  cluster_labs_dso, CLUSTER_LABS_F8)) ||
339  !(p20= (cl_rand_bytes *)DSO_bind_func(
340  cluster_labs_dso, CLUSTER_LABS_F20)) ||
341  !(p30= (cl_dsa_sign *)DSO_bind_func(
342  cluster_labs_dso, CLUSTER_LABS_F30)) ||
343  !(p31= (cl_dsa_verify *)DSO_bind_func(
344  cluster_labs_dso, CLUSTER_LABS_F31)))
345  {
346  CLerr(CL_F_CLUSTER_LABS_INIT,CL_R_DSO_FAILURE);
347  goto err;
348  }
349 
350  /* copy function pointers */
351  p_cl_engine_init = p1;
352  p_cl_mod_exp = p2;
353  p_cl_mod_exp_crt = p3;
354  p_cl_rsa_mod_exp = p4;
355  p_cl_rsa_priv_enc = p5;
356  p_cl_rsa_priv_dec = p6;
357  p_cl_rsa_pub_enc = p7;
358  p_cl_rsa_pub_dec = p8;
359  p_cl_rand_bytes = p20;
360  p_cl_dsa_sign = p30;
361  p_cl_dsa_verify = p31;
362 
363 
364 
365  /* cluster labs engine init */
366  if(p_cl_engine_init()== 0){
367  CLerr(CL_F_CLUSTER_LABS_INIT,CL_R_INIT_FAILED);
368  goto err;
369  }
370 
371  return(1);
372 
373 err:
374  /* reset all pointers */
375  if(cluster_labs_dso)
376  DSO_free(cluster_labs_dso);
377 
378  cluster_labs_dso = NULL;
379  p_cl_engine_init = NULL;
380  p_cl_mod_exp = NULL;
381  p_cl_mod_exp_crt = NULL;
382  p_cl_rsa_mod_exp = NULL;
383  p_cl_rsa_priv_enc = NULL;
384  p_cl_rsa_priv_dec = NULL;
385  p_cl_rsa_pub_enc = NULL;
386  p_cl_rsa_pub_dec = NULL;
387  p_cl_rand_bytes = NULL;
388  p_cl_dsa_sign = NULL;
389  p_cl_dsa_verify = NULL;
390 
391  return(0);
392  }
393 
394 
395 static int cluster_labs_finish(ENGINE *e)
396  {
397 
398  if(cluster_labs_dso == NULL)
399  {
400  CLerr(CL_F_CLUSTER_LABS_FINISH,CL_R_NOT_LOADED);
401  return 0;
402  }
403  if(!DSO_free(cluster_labs_dso))
404  {
405  CLerr(CL_F_CLUSTER_LABS_FINISH,CL_R_DSO_FAILURE);
406  return 0;
407  }
408 
409  cluster_labs_dso = NULL;
410  p_cl_engine_init = NULL;
411  p_cl_mod_exp = NULL;
412  p_cl_rsa_mod_exp = NULL;
413  p_cl_mod_exp_crt = NULL;
414  p_cl_rsa_priv_enc = NULL;
415  p_cl_rsa_priv_dec = NULL;
416  p_cl_rsa_pub_enc = NULL;
417  p_cl_rsa_pub_dec = NULL;
418  p_cl_rand_bytes = NULL;
419  p_cl_dsa_sign = NULL;
420  p_cl_dsa_verify = NULL;
421 
422  return(1);
423 
424  }
425 
426 static int cluster_labs_ctrl(ENGINE *e, int cmd, long i, void *p, void (*f)())
427  {
428  int initialised = ((cluster_labs_dso == NULL) ? 0 : 1);
429 
430  switch(cmd)
431  {
432  case CLUSTER_LABS_CMD_SO_PATH:
433  if(p == NULL)
434  {
435  CLerr(CL_F_CLUSTER_LABS_CTRL,ERR_R_PASSED_NULL_PARAMETER);
436  return 0;
437  }
438  if(initialised)
439  {
440  CLerr(CL_F_CLUSTER_LABS_CTRL,CL_R_ALREADY_LOADED);
441  return 0;
442  }
443  CLUSTER_LABS_LIB_NAME = (const char *)p;
444  return 1;
445  default:
446  break;
447  }
448  CLerr(CL_F_CLUSTER_LABS_CTRL,CL_R_COMMAND_NOT_IMPLEMENTED);
449  return 0;
450  }
451 
452 
453 static int cluster_labs_mod_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
454  const BIGNUM *m, BN_CTX *ctx)
455  {
456 
457  if(cluster_labs_dso == NULL)
458  {
459  CLerr(CL_F_CLUSTER_LABS_MOD_EXP,CL_R_NOT_LOADED);
460  return 0;
461  }
462  if(p_cl_mod_exp == NULL)
463  {
464  CLerr(CL_F_CLUSTER_LABS_MOD_EXP,CL_R_FUNCTION_NOT_BINDED);
465  return 0;
466  }
467 
468  return p_cl_mod_exp(r, a, p, m, ctx);
469 
470  }
471 
472 static int cluster_labs_mod_exp_crt(BIGNUM *r, BIGNUM *a, const BIGNUM *p,
473  const BIGNUM *q, const BIGNUM *dmp1, const BIGNUM *dmq1,
474  const BIGNUM *iqmp, BN_CTX *ctx)
475  {
476 
477  if(cluster_labs_dso == NULL)
478  {
479  CLerr(CL_F_CLUSTER_LABS_MOD_EXP_CRT,CL_R_NOT_LOADED);
480  return 0;
481  }
482  if(p_cl_mod_exp_crt == NULL)
483  {
484  CLerr(CL_F_CLUSTER_LABS_MOD_EXP_CRT,CL_R_FUNCTION_NOT_BINDED);
485  return 0;
486  }
487 
488  return p_cl_mod_exp_crt(r, a, p, q,dmp1, dmq1, iqmp, ctx);
489 
490  }
491 
492 static int cluster_labs_rsa_mod_exp(BIGNUM *r0, const BIGNUM *I, RSA *rsa)
493  {
494 
495  if(cluster_labs_dso == NULL)
496  {
497  CLerr(CL_F_CLUSTER_LABS_RSA_MOD_EXP,CL_R_NOT_LOADED);
498  return 0;
499  }
500  if(p_cl_rsa_mod_exp == NULL)
501  {
502  CLerr(CL_F_CLUSTER_LABS_RSA_MOD_EXP,CL_R_FUNCTION_NOT_BINDED);
503  return 0;
504  }
505 
506  return p_cl_rsa_mod_exp(r0, I, rsa);
507 
508  }
509 
510 static DSA_SIG *cluster_labs_dsa_sign(const unsigned char *dgst, int dlen, DSA *dsa)
511  {
512 
513  if(cluster_labs_dso == NULL)
514  {
515  CLerr(CL_F_CLUSTER_LABS_DSA_SIGN,CL_R_NOT_LOADED);
516  return 0;
517  }
518  if(p_cl_dsa_sign == NULL)
519  {
520  CLerr(CL_F_CLUSTER_LABS_DSA_SIGN,CL_R_FUNCTION_NOT_BINDED);
521  return 0;
522  }
523 
524  return p_cl_dsa_sign(dgst, dlen, dsa);
525 
526  }
527 
528 static int cluster_labs_dsa_verify(const unsigned char *dgst, int dgst_len,
529  DSA_SIG *sig, DSA *dsa)
530  {
531 
532  if(cluster_labs_dso == NULL)
533  {
534  CLerr(CL_F_CLUSTER_LABS_DSA_VERIFY,CL_R_NOT_LOADED);
535  return 0;
536  }
537 
538  if(p_cl_dsa_verify == NULL)
539  {
540  CLerr(CL_F_CLUSTER_LABS_DSA_VERIFY,CL_R_FUNCTION_NOT_BINDED);
541  return 0;
542  }
543 
544  return p_cl_dsa_verify(dgst, dgst_len, sig, dsa);
545 
546  }
547 
548 static int cluster_labs_dsa_mod_exp(DSA *dsa, BIGNUM *rr, BIGNUM *a1,
549  BIGNUM *p1, BIGNUM *a2, BIGNUM *p2, BIGNUM *m,
550  BN_CTX *ctx, BN_MONT_CTX *in_mont)
551  {
552  BIGNUM t;
553  int status = 0;
554 
555  BN_init(&t);
556  /* let rr = a1 ^ p1 mod m */
557  if (!cluster_labs_mod_exp(rr,a1,p1,m,ctx)) goto end;
558  /* let t = a2 ^ p2 mod m */
559  if (!cluster_labs_mod_exp(&t,a2,p2,m,ctx)) goto end;
560  /* let rr = rr * t mod m */
561  if (!BN_mod_mul(rr,rr,&t,m,ctx)) goto end;
562  status = 1;
563 end:
564  BN_free(&t);
565 
566  return(1);
567 
568  }
569 
570 static int cluster_labs_mod_exp_dsa(DSA *dsa, BIGNUM *r, BIGNUM *a,
571  const BIGNUM *p, const BIGNUM *m, BN_CTX *ctx,
572  BN_MONT_CTX *m_ctx)
573  {
574  return cluster_labs_mod_exp(r, a, p, m, ctx);
575  }
576 
577 /* This function is aliased to mod_exp (with the mont stuff dropped). */
578 static int cluster_labs_mod_exp_mont(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
579  const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx)
580  {
581  return cluster_labs_mod_exp(r, a, p, m, ctx);
582  }
583 
584 
585 /* This function is aliased to mod_exp (with the dh and mont dropped). */
586 static int cluster_labs_mod_exp_dh(const DH *dh, BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
587  const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx)
588  {
589  return cluster_labs_mod_exp(r, a, p, m, ctx);
590  }
591 
592 
593 static int cluster_labs_rsa_pub_enc(int flen, const unsigned char *from,
594  unsigned char *to, RSA *rsa, int padding)
595  {
596 
597  if(cluster_labs_dso == NULL)
598  {
599  CLerr(CL_F_CLUSTER_LABS_RSA_PUB_ENC,CL_R_NOT_LOADED);
600  return 0;
601  }
602  if(p_cl_rsa_priv_enc == NULL)
603  {
604  CLerr(CL_F_CLUSTER_LABS_RSA_PUB_ENC,CL_R_FUNCTION_NOT_BINDED);
605  return 0;
606  }
607 
608  return p_cl_rsa_pub_enc(flen, from, to, rsa, padding);
609 
610  }
611 
612 static int cluster_labs_rsa_pub_dec(int flen, const unsigned char *from,
613  unsigned char *to, RSA *rsa, int padding)
614  {
615 
616  if(cluster_labs_dso == NULL)
617  {
618  CLerr(CL_F_CLUSTER_LABS_RSA_PUB_DEC,CL_R_NOT_LOADED);
619  return 0;
620  }
621  if(p_cl_rsa_priv_enc == NULL)
622  {
623  CLerr(CL_F_CLUSTER_LABS_RSA_PUB_DEC,CL_R_FUNCTION_NOT_BINDED);
624  return 0;
625  }
626 
627  return p_cl_rsa_pub_dec(flen, from, to, rsa, padding);
628 
629  }
630 
631 
632 static int cluster_labs_rsa_priv_enc(int flen, const unsigned char *from,
633  unsigned char *to, RSA *rsa, int padding)
634  {
635 
636  if(cluster_labs_dso == NULL)
637  {
638  CLerr(CL_F_CLUSTER_LABS_RSA_PRIV_ENC,CL_R_NOT_LOADED);
639  return 0;
640  }
641 
642  if(p_cl_rsa_priv_enc == NULL)
643  {
644  CLerr(CL_F_CLUSTER_LABS_RSA_PRIV_ENC,CL_R_FUNCTION_NOT_BINDED);
645  return 0;
646  }
647 
648  return p_cl_rsa_priv_enc(flen, from, to, rsa, padding);
649 
650  }
651 
652 static int cluster_labs_rsa_priv_dec(int flen, const unsigned char *from,
653  unsigned char *to, RSA *rsa, int padding)
654  {
655 
656  if(cluster_labs_dso == NULL)
657  {
658  CLerr(CL_F_CLUSTER_LABS_RSA_PRIV_DEC,CL_R_NOT_LOADED);
659  return 0;
660  }
661  if(p_cl_rsa_priv_dec == NULL)
662  {
663  CLerr(CL_F_CLUSTER_LABS_RSA_PRIV_DEC,CL_R_FUNCTION_NOT_BINDED);
664  return 0;
665  }
666 
667  return p_cl_rsa_priv_dec(flen, from, to, rsa, padding);
668 
669  }
670 
671 /************************************************************************************
672 * Symmetric algorithms
673 ************************************************************************************/
674 /* this will be come soon! */
675 
676 /************************************************************************************
677 * Random generator
678 ************************************************************************************/
679 
680 static int cluster_labs_rand_bytes(unsigned char *buf, int num){
681 
682  if(cluster_labs_dso == NULL)
683  {
684  CLerr(CL_F_CLUSTER_LABS_RAND_BYTES,CL_R_NOT_LOADED);
685  return 0;
686  }
687  if(p_cl_mod_exp_crt == NULL)
688  {
689  CLerr(CL_F_CLUSTER_LABS_RAND_BYTES,CL_R_FUNCTION_NOT_BINDED);
690  return 0;
691  }
692 
693  return p_cl_rand_bytes(buf, num);
694 
695 }
696 
697 
698 /* This stuff is needed if this ENGINE is being compiled into a self-contained
699  * shared-library. */
700 #ifdef ENGINE_DYNAMIC_SUPPORT
701 static int bind_fn(ENGINE *e, const char *id)
702  {
703  fprintf(stderr, "bind_fn CLUSTER_LABS\n");
704  if(id && (strcmp(id, engine_cluster_labs_id) != 0)) {
705  fprintf(stderr, "bind_fn return(0) first\n");
706  return 0;
707  }
708  if(!bind_helper(e)) {
709  fprintf(stderr, "bind_fn return(1) first\n");
710  return 0;
711  }
712  fprintf(stderr, "bind_fn return(1)\n");
713  return 1;
714  }
715 IMPLEMENT_DYNAMIC_CHECK_FN()
716 IMPLEMENT_DYNAMIC_BIND_FN(bind_fn)
717 #endif /* ENGINE_DYNAMIC_SUPPORT */
718 
719 #endif /* !NO_HW_CLUSTER_LABS */
720 #endif /* !NO_HW */
721 
Generated on Thu Jan 10 2013 09:53:41 for OpenSSL by   doxygen 1.8.2