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