demos/engines/rsaref/rsaref.c

   1 /* Demo of how to construct your own engine and using it.  The basis of this
   2    engine is RSAref, an old reference of the RSA algorithm which can still
   3    be found a little here and there. */
   4
   5 #include <stdio.h>
   6 #include <string.h>
   7 #include "./source/global.h"
   8 #include "./source/rsaref.h"
   9 #include "./source/rsa.h"
  10 #include "./source/des.h"
  11 #include <openssl/err.h>
  12 #define OPENSSL_NO_MD2
  13 #define OPENSSL_NO_MD5
  14 #include <openssl/evp.h>
  15 #include <openssl/bn.h>
  16 #include <openssl/engine.h>
  17
  18 #define RSAREF_LIB_NAME "rsaref engine"
  19 #include "rsaref_err.c"
  20
  21 /*****************************************************************************
  22  *** Function declarations and global variable definitions                 ***
  23  *****************************************************************************/
  24
  25 /*****************************************************************************
  26  * Constants used when creating the ENGINE
  27  **/
  28 static const char *engine_rsaref_id = "rsaref";
  29 static const char *engine_rsaref_name = "RSAref engine support";
  30
  31 /*****************************************************************************
  32  * Functions to handle the engine
  33  **/
  34 static int rsaref_destroy(ENGINE *e);
  35 static int rsaref_init(ENGINE *e);
  36 static int rsaref_finish(ENGINE *e);
  37 #if 0
  38 static int rsaref_ctrl(ENGINE *e, int cmd, long i, void *p, void (*f)());
  39 #endif
  40
  41 /*****************************************************************************
  42  * Engine commands
  43  **/
  44 static const ENGINE_CMD_DEFN rsaref_cmd_defns[] = {
  45         {0, NULL, NULL, 0}
  46         };
  47
  48 /*****************************************************************************
  49  * RSA functions
  50  **/
  51 static int rsaref_private_decrypt(int len, const unsigned char *from,
  52         unsigned char *to, RSA *rsa, int padding);
  53 static int rsaref_private_encrypt(int len, const unsigned char *from,
  54         unsigned char *to, RSA *rsa, int padding);
  55 static int rsaref_public_encrypt(int len, const unsigned char *from,
  56         unsigned char *to, RSA *rsa, int padding);
  57 static int rsaref_public_decrypt(int len, const unsigned char *from,
  58         unsigned char *to, RSA *rsa, int padding);
  59 static int bnref_mod_exp(BIGNUM *r,const BIGNUM *a,const BIGNUM *p,const BIGNUM *m,
  60                           BN_CTX *ctx, BN_MONT_CTX *m_ctx);
  61 static int rsaref_mod_exp(BIGNUM *r0, const BIGNUM *I, RSA *rsa);
  62
  63 /*****************************************************************************
  64  * Our RSA method
  65  **/
  66 static RSA_METHOD rsaref_rsa =
  67 {
  68   "RSAref PKCS#1 RSA",
  69   rsaref_public_encrypt,
  70   rsaref_public_decrypt,
  71   rsaref_private_encrypt,
  72   rsaref_private_decrypt,
  73   rsaref_mod_exp,
  74   bnref_mod_exp,
  75   NULL,
  76   NULL,
  77   0,
  78   NULL,
  79   NULL,
  80   NULL
  81 };
  82
  83 /*****************************************************************************
  84  * Symetric cipher and digest function registrars
  85  **/
  86 static int rsaref_ciphers(ENGINE *e, const EVP_CIPHER **cipher,
  87         const int **nids, int nid);
  88 static int rsaref_digests(ENGINE *e, const EVP_MD **digest,
  89         const int **nids, int nid);
  90
  91 static int rsaref_cipher_nids[] =
  92         { NID_des_cbc, NID_des_ede3_cbc, NID_desx_cbc, 0 };
  93 static int rsaref_digest_nids[] =
  94         { NID_md2, NID_md5, 0 };
  95
  96 /*****************************************************************************
  97  * DES functions
  98  **/
  99 int cipher_des_cbc_init(EVP_CIPHER_CTX *ctx, const unsigned char *key,
 100         const unsigned char *iv, int enc);
 101 int cipher_des_cbc_code(EVP_CIPHER_CTX *ctx, unsigned char *out,
 102         const unsigned char *in, unsigned int inl);
 103 int cipher_des_cbc_clean(EVP_CIPHER_CTX *);
 104 int cipher_des_ede3_cbc_init(EVP_CIPHER_CTX *ctx, const unsigned char *key,
 105         const unsigned char *iv, int enc);
 106 int cipher_des_ede3_cbc_code(EVP_CIPHER_CTX *ctx, unsigned char *out,
 107         const unsigned char *in, unsigned int inl);
 108 int cipher_des_ede3_cbc_clean(EVP_CIPHER_CTX *);
 109 int cipher_desx_cbc_init(EVP_CIPHER_CTX *ctx, const unsigned char *key,
 110         const unsigned char *iv, int enc);
 111 int cipher_desx_cbc_code(EVP_CIPHER_CTX *ctx, unsigned char *out,
 112         const unsigned char *in, unsigned int inl);
 113 int cipher_desx_cbc_clean(EVP_CIPHER_CTX *);
 114
 115 /*****************************************************************************
 116  * Our DES ciphers
 117  **/
 118 static const EVP_CIPHER cipher_des_cbc =
 119         {
 120         NID_des_cbc,
 121         8, 8, 8,
 122         0 | EVP_CIPH_CBC_MODE,
 123         cipher_des_cbc_init,
 124         cipher_des_cbc_code,
 125         cipher_des_cbc_clean,
 126         sizeof(DES_CBC_CTX),
 127         NULL,
 128         NULL,
 129         NULL,
 130         NULL
 131         };
 132
 133 static const EVP_CIPHER cipher_des_ede3_cbc =
 134         {
 135         NID_des_ede3_cbc,
 136         8, 24, 8,
 137         0 | EVP_CIPH_CBC_MODE,
 138         cipher_des_ede3_cbc_init,
 139         cipher_des_ede3_cbc_code,
 140         cipher_des_ede3_cbc_clean,
 141         sizeof(DES3_CBC_CTX),
 142         NULL,
 143         NULL,
 144         NULL,
 145         NULL
 146         };
 147
 148 static const EVP_CIPHER cipher_desx_cbc =
 149         {
 150         NID_desx_cbc,
 151         8, 24, 8,
 152         0 | EVP_CIPH_CBC_MODE,
 153         cipher_desx_cbc_init,
 154         cipher_desx_cbc_code,
 155         cipher_desx_cbc_clean,
 156         sizeof(DESX_CBC_CTX),
 157         NULL,
 158         NULL,
 159         NULL,
 160         NULL
 161         };
 162
 163 /*****************************************************************************
 164  * MD functions
 165  **/
 166 static int digest_md2_init(EVP_MD_CTX *ctx);
 167 static int digest_md2_update(EVP_MD_CTX *ctx,const void *data,
 168         unsigned long count);
 169 static int digest_md2_final(EVP_MD_CTX *ctx,unsigned char *md);
 170 static int digest_md5_init(EVP_MD_CTX *ctx);
 171 static int digest_md5_update(EVP_MD_CTX *ctx,const void *data,
 172         unsigned long count);
 173 static int digest_md5_final(EVP_MD_CTX *ctx,unsigned char *md);
 174
 175 /*****************************************************************************
 176  * Our MD digests
 177  **/
 178 static const EVP_MD digest_md2 =
 179         {
 180         NID_md2,
 181         NID_md2WithRSAEncryption,
 182         16,
 183         0,
 184         digest_md2_init,
 185         digest_md2_update,
 186         digest_md2_final,
 187         NULL,
 188         NULL,
 189         EVP_PKEY_RSA_method,
 190         16,
 191         sizeof(MD2_CTX)
 192         };
 193
 194 static const EVP_MD digest_md5 =
 195         {
 196         NID_md5,
 197         NID_md5WithRSAEncryption,
 198         16,
 199         0,
 200         digest_md5_init,
 201         digest_md5_update,
 202         digest_md5_final,
 203         NULL,
 204         NULL,
 205         EVP_PKEY_RSA_method,
 206         64,
 207         sizeof(MD5_CTX)
 208         };
 209
 210 /*****************************************************************************
 211  *** Function definitions                                                  ***
 212  *****************************************************************************/
 213
 214 /*****************************************************************************
 215  * Functions to handle the engine
 216  **/
 217
 218 static int bind_rsaref(ENGINE *e)
 219         {
 220         const RSA_METHOD *meth1;
 221         if(!ENGINE_set_id(e, engine_rsaref_id)
 222                 || !ENGINE_set_name(e, engine_rsaref_name)
 223                 || !ENGINE_set_RSA(e, &rsaref_rsa)
 224                 || !ENGINE_set_ciphers(e, rsaref_ciphers)
 225                 || !ENGINE_set_digests(e, rsaref_digests)
 226                 || !ENGINE_set_destroy_function(e, rsaref_destroy)
 227                 || !ENGINE_set_init_function(e, rsaref_init)
 228                 || !ENGINE_set_finish_function(e, rsaref_finish)
 229                 /* || !ENGINE_set_ctrl_function(e, rsaref_ctrl) */
 230                 /* || !ENGINE_set_cmd_defns(e, rsaref_cmd_defns) */)
 231                 return 0;
 232
 233         /* Ensure the rsaref error handling is set up */
 234         ERR_load_RSAREF_strings();
 235         return 1;
 236         }
 237
 238 #ifdef ENGINE_DYNAMIC_SUPPORT
 239 static int bind_helper(ENGINE *e, const char *id)
 240         {
 241         if(id && (strcmp(id, engine_rsaref_id) != 0))
 242                 return 0;
 243         if(!bind_rsaref(e))
 244                 return 0;
 245         return 1;
 246         }
 247 IMPLEMENT_DYNAMIC_CHECK_FN()
 248 IMPLEMENT_DYNAMIC_BIND_FN(bind_helper)
 249 #else
 250 static ENGINE *engine_rsaref(void)
 251         {
 252         ENGINE *ret = ENGINE_new();
 253         if(!ret)
 254                 return NULL;
 255         if(!bind_rsaref(ret))
 256                 {
 257                 ENGINE_free(ret);
 258                 return NULL;
 259                 }
 260         return ret;
 261         }
 262
 263 void ENGINE_load_rsaref(void)
 264         {
 265         /* Copied from eng_[openssl|dyn].c */
 266         ENGINE *toadd = engine_rsaref();
 267         if(!toadd) return;
 268         ENGINE_add(toadd);
 269         ENGINE_free(toadd);
 270         ERR_clear_error();
 271         }
 272 #endif
 273
 274 /* Initiator which is only present to make sure this engine looks available */
 275 static int rsaref_init(ENGINE *e)
 276         {
 277         return 1;
 278         }
 279
 280 /* Finisher which is only present to make sure this engine looks available */
 281 static int rsaref_finish(ENGINE *e)
 282         {
 283         return 1;
 284         }
 285
 286 /* Destructor (complements the "ENGINE_ncipher()" constructor) */
 287 static int rsaref_destroy(ENGINE *e)
 288         {
 289         ERR_unload_RSAREF_strings();
 290         return 1;
 291         }
 292
 293 /*****************************************************************************
 294  * RSA functions
 295  **/
 296
 297 static int rsaref_mod_exp(BIGNUM *r0, const BIGNUM *I, RSA *rsa)
 298         {
 299         RSAREFerr(RSAREF_F_RSAREF_MOD_EXP,ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 300         return(0);
 301         }
 302
 303 static int bnref_mod_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
 304                           const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx)
 305         {
 306         RSAREFerr(RSAREF_F_BNREF_MOD_EXP,ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 307         return(0);
 308         }
 309
 310 /* unsigned char *to:  [max]    */
 311 static int RSAref_bn2bin(BIGNUM *from, unsigned char *to, int max)
 312         {
 313         int i;
 314
 315         i=BN_num_bytes(from);
 316         if (i > max)
 317                 {
 318                 RSAREFerr(RSAREF_F_RSAREF_BN2BIN,RSAREF_R_LEN);
 319                 return(0);
 320                 }
 321
 322         memset(to,0,(unsigned int)max);
 323         if (!BN_bn2bin(from,&(to[max-i])))
 324                 return(0);
 325         return(1);
 326         }
 327
 328 #ifdef undef
 329 /* unsigned char *from:  [max]    */
 330 static BIGNUM *RSAref_bin2bn(unsigned char *from, BIGNUM *to, int max)
 331         {
 332         int i;
 333         BIGNUM *ret;
 334
 335         for (i=0; i<max; i++)
 336                 if (from[i]) break;
 337
 338         ret=BN_bin2bn(&(from[i]),max-i,to);
 339         return(ret);
 340         }
 341
 342 static int RSAref_Public_ref2eay(RSArefPublicKey *from, RSA *to)
 343         {
 344         to->n=RSAref_bin2bn(from->m,NULL,RSAref_MAX_LEN);
 345         to->e=RSAref_bin2bn(from->e,NULL,RSAref_MAX_LEN);
 346         if ((to->n == NULL) || (to->e == NULL)) return(0);
 347         return(1);
 348         }
 349 #endif
 350
 351 static int RSAref_Public_eay2ref(RSA *from, R_RSA_PUBLIC_KEY *to)
 352         {
 353         to->bits=BN_num_bits(from->n);
 354         if (!RSAref_bn2bin(from->n,to->modulus,MAX_RSA_MODULUS_LEN)) return(0);
 355         if (!RSAref_bn2bin(from->e,to->exponent,MAX_RSA_MODULUS_LEN)) return(0);
 356         return(1);
 357         }
 358
 359 #ifdef undef
 360 static int RSAref_Private_ref2eay(RSArefPrivateKey *from, RSA *to)
 361         {
 362         if ((to->n=RSAref_bin2bn(from->m,NULL,RSAref_MAX_LEN)) == NULL)
 363                 return(0);
 364         if ((to->e=RSAref_bin2bn(from->e,NULL,RSAref_MAX_LEN)) == NULL)
 365                 return(0);
 366         if ((to->d=RSAref_bin2bn(from->d,NULL,RSAref_MAX_LEN)) == NULL)
 367                 return(0);
 368         if ((to->p=RSAref_bin2bn(from->prime[0],NULL,RSAref_MAX_PLEN)) == NULL)
 369                 return(0);
 370         if ((to->q=RSAref_bin2bn(from->prime[1],NULL,RSAref_MAX_PLEN)) == NULL)
 371                 return(0);
 372         if ((to->dmp1=RSAref_bin2bn(from->pexp[0],NULL,RSAref_MAX_PLEN))
 373                 == NULL)
 374                 return(0);
 375         if ((to->dmq1=RSAref_bin2bn(from->pexp[1],NULL,RSAref_MAX_PLEN))
 376                 == NULL)
 377                 return(0);
 378         if ((to->iqmp=RSAref_bin2bn(from->coef,NULL,RSAref_MAX_PLEN)) == NULL)
 379                 return(0);
 380         return(1);
 381         }
 382 #endif
 383
 384 static int RSAref_Private_eay2ref(RSA *from, R_RSA_PRIVATE_KEY *to)
 385         {
 386         to->bits=BN_num_bits(from->n);
 387         if (!RSAref_bn2bin(from->n,to->modulus,MAX_RSA_MODULUS_LEN)) return(0);
 388         if (!RSAref_bn2bin(from->e,to->publicExponent,MAX_RSA_MODULUS_LEN)) return(0);
 389         if (!RSAref_bn2bin(from->d,to->exponent,MAX_RSA_MODULUS_LEN)) return(0);
 390         if (!RSAref_bn2bin(from->p,to->prime[0],MAX_RSA_PRIME_LEN)) return(0);
 391         if (!RSAref_bn2bin(from->q,to->prime[1],MAX_RSA_PRIME_LEN)) return(0);
 392         if (!RSAref_bn2bin(from->dmp1,to->primeExponent[0],MAX_RSA_PRIME_LEN)) return(0);
 393         if (!RSAref_bn2bin(from->dmq1,to->primeExponent[1],MAX_RSA_PRIME_LEN)) return(0);
 394         if (!RSAref_bn2bin(from->iqmp,to->coefficient,MAX_RSA_PRIME_LEN)) return(0);
 395         return(1);
 396         }
 397
 398 static int rsaref_private_decrypt(int len, const unsigned char *from, unsigned char *to,
 399              RSA *rsa, int padding)
 400         {
 401         int i,outlen= -1;
 402         R_RSA_PRIVATE_KEY RSAkey;
 403
 404         if (!RSAref_Private_eay2ref(rsa,&RSAkey))
 405                 goto err;
 406         if ((i=RSAPrivateDecrypt(to,&(unsigned int)outlen,(unsigned char *)from,len,&RSAkey)) != 0)
 407                 {
 408                 RSAREFerr(RSAREF_F_RSAREF_PRIVATE_DECRYPT,i);
 409                 outlen= -1;
 410                 }
 411 err:
 412         memset(&RSAkey,0,sizeof(RSAkey));
 413         return(outlen);
 414         }
 415
 416 static int rsaref_private_encrypt(int len, const unsigned char *from, unsigned char *to,
 417              RSA *rsa, int padding)
 418         {
 419         int i,outlen= -1;
 420         R_RSA_PRIVATE_KEY RSAkey;
 421
 422         if (padding != RSA_PKCS1_PADDING)
 423                 {
 424                 RSAREFerr(RSAREF_F_RSAREF_PRIVATE_ENCRYPT, RSA_R_UNKNOWN_PADDING_TYPE);
 425                 goto err;
 426         }
 427         if (!RSAref_Private_eay2ref(rsa,&RSAkey))
 428                 goto err;
 429         if ((i=RSAPrivateEncrypt(to,&(unsigned int)outlen,(unsigned char *)from,len,&RSAkey)) != 0)
 430                 {
 431                 RSAREFerr(RSAREF_F_RSAREF_PRIVATE_ENCRYPT,i);
 432                 outlen= -1;
 433                 }
 434 err:
 435         memset(&RSAkey,0,sizeof(RSAkey));
 436         return(outlen);
 437         }
 438
 439 static int rsaref_public_decrypt(int len, const unsigned char *from, unsigned char *to,
 440              RSA *rsa, int padding)
 441         {
 442         int i,outlen= -1;
 443         R_RSA_PUBLIC_KEY RSAkey;
 444
 445         if (!RSAref_Public_eay2ref(rsa,&RSAkey))
 446                 goto err;
 447         if ((i=RSAPublicDecrypt(to,&(unsigned int)outlen,(unsigned char *)from,len,&RSAkey)) != 0)
 448                 {
 449                 RSAREFerr(RSAREF_F_RSAREF_PUBLIC_DECRYPT,i);
 450                 outlen= -1;
 451                 }
 452 err:
 453         memset(&RSAkey,0,sizeof(RSAkey));
 454         return(outlen);
 455         }
 456
 457 static int rsaref_public_encrypt(int len, const unsigned char *from, unsigned char *to,
 458              RSA *rsa, int padding)
 459         {
 460         int outlen= -1;
 461         int i;
 462         R_RSA_PUBLIC_KEY RSAkey;
 463         R_RANDOM_STRUCT rnd;
 464         unsigned char buf[16];
 465
 466         if (padding != RSA_PKCS1_PADDING && padding != RSA_SSLV23_PADDING)
 467                 {
 468                 RSAREFerr(RSAREF_F_RSAREF_PUBLIC_ENCRYPT, RSA_R_UNKNOWN_PADDING_TYPE);
 469                 goto err;
 470                 }
 471
 472         R_RandomInit(&rnd);
 473         R_GetRandomBytesNeeded((unsigned int *)&i,&rnd);
 474         while (i > 0)
 475                 {
 476                 if (RAND_bytes(buf,16) <= 0)
 477                         goto err;
 478                 R_RandomUpdate(&rnd,buf,(unsigned int)((i>16)?16:i));
 479                 i-=16;
 480                 }
 481
 482         if (!RSAref_Public_eay2ref(rsa,&RSAkey))
 483                 goto err;
 484         if ((i=RSAPublicEncrypt(to,&(unsigned int)outlen,(unsigned char *)from,len,&RSAkey,&rnd)) != 0)
 485                 {
 486                 RSAREFerr(RSAREF_F_RSAREF_PUBLIC_ENCRYPT,i);
 487                 outlen= -1;
 488                 goto err;
 489                 }
 490 err:
 491         memset(&RSAkey,0,sizeof(RSAkey));
 492         R_RandomFinal(&rnd);
 493         memset(&rnd,0,sizeof(rnd));
 494         return(outlen);
 495         }
 496
 497 /*****************************************************************************
 498  * Symetric cipher and digest function registrars
 499  **/
 500 static int rsaref_ciphers(ENGINE *e, const EVP_CIPHER **cipher,
 501         const int **nids, int nid)
 502         {
 503         int ok = 1;
 504         if(!cipher)
 505                 {
 506                 /* We are returning a list of supported nids */
 507                 *nids = rsaref_cipher_nids;
 508                 return (sizeof(rsaref_cipher_nids)-1)/sizeof(rsaref_cipher_nids[0]);
 509                 }
 510         /* We are being asked for a specific cipher */
 511         switch (nid)
 512                 {
 513         case NID_des_cbc:
 514                 *cipher = &cipher_des_cbc; break;
 515         case NID_des_ede3_cbc:
 516                 *cipher = &cipher_des_ede3_cbc; break;
 517         case NID_desx_cbc:
 518                 *cipher = &cipher_desx_cbc; break;
 519         default:
 520                 ok = 0;
 521                 *cipher = NULL;
 522                 break;
 523                 }
 524         return ok;
 525         }
 526 static int rsaref_digests(ENGINE *e, const EVP_MD **digest,
 527         const int **nids, int nid)
 528         {
 529         int ok = 1;
 530         if(!digest)
 531                 {
 532                 /* We are returning a list of supported nids */
 533                 *nids = rsaref_digest_nids;
 534                 return (sizeof(rsaref_digest_nids)-1)/sizeof(rsaref_digest_nids[0]);
 535                 }
 536         /* We are being asked for a specific digest */
 537         switch (nid)
 538                 {
 539         case NID_md2:
 540                 *digest = &digest_md2; break;
 541         case NID_md5:
 542                 *digest = &digest_md5; break;
 543         default:
 544                 ok = 0;
 545                 *digest = NULL;
 546                 break;
 547                 }
 548         return ok;
 549         }
 550
 551 /*****************************************************************************
 552  * DES functions
 553  **/
 554 #undef data
 555 #define data(ctx) ((DES_CBC_CTX *)(ctx)->cipher_data)
 556 int cipher_des_cbc_init(EVP_CIPHER_CTX *ctx, const unsigned char *key,
 557         const unsigned char *iv, int enc)
 558         {
 559         DES_CBCInit(data(ctx), (unsigned char *)key, (unsigned char *)iv, enc);
 560         return 1;
 561         }
 562 int cipher_des_cbc_code(EVP_CIPHER_CTX *ctx, unsigned char *out,
 563         const unsigned char *in, unsigned int inl)
 564         {
 565         int ret = DES_CBCUpdate(data(ctx), out, (unsigned char *)in, inl);
 566         switch (ret)
 567                 {
 568         case RE_LEN:
 569                 RSAREFerr(RSAREF_F_CIPHER_DES_CBC_CODE,RSAREF_R_LENGTH_NOT_BLOCK_ALIGNED);
 570                 break;
 571         case 0:
 572                 break;
 573         default:
 574                 RSAREFerr(RSAREF_F_CIPHER_DES_CBC_CODE,RSAREF_R_UNKNOWN_FAULT);
 575                 }
 576         return !ret;
 577         }
 578 int cipher_des_cbc_clean(EVP_CIPHER_CTX *ctx)
 579         {
 580         memset(data(ctx), 0, ctx->cipher->ctx_size);
 581         return 1;
 582         }
 583
 584 #undef data
 585 #define data(ctx) ((DES3_CBC_CTX *)(ctx)->cipher_data)
 586 int cipher_des_ede3_cbc_init(EVP_CIPHER_CTX *ctx, const unsigned char *key,
 587         const unsigned char *iv, int enc)
 588         {
 589         DES3_CBCInit(data(ctx), (unsigned char *)key, (unsigned char *)iv,
 590                 enc);
 591         return 1;
 592         }
 593 int cipher_des_ede3_cbc_code(EVP_CIPHER_CTX *ctx, unsigned char *out,
 594         const unsigned char *in, unsigned int inl)
 595         {
 596         int ret = DES3_CBCUpdate(data(ctx), out, (unsigned char *)in, inl);
 597         switch (ret)
 598                 {
 599         case RE_LEN:
 600                 RSAREFerr(RSAREF_F_CIPHER_DES_CBC_CODE,RSAREF_R_LENGTH_NOT_BLOCK_ALIGNED);
 601                 break;
 602         case 0:
 603                 break;
 604         default:
 605                 RSAREFerr(RSAREF_F_CIPHER_DES_CBC_CODE,RSAREF_R_UNKNOWN_FAULT);
 606                 }
 607         return !ret;
 608         }
 609 int cipher_des_ede3_cbc_clean(EVP_CIPHER_CTX *ctx)
 610         {
 611         memset(data(ctx), 0, ctx->cipher->ctx_size);
 612         return 1;
 613         }
 614
 615 #undef data
 616 #define data(ctx) ((DESX_CBC_CTX *)(ctx)->cipher_data)
 617 int cipher_desx_cbc_init(EVP_CIPHER_CTX *ctx, const unsigned char *key,
 618         const unsigned char *iv, int enc)
 619         {
 620         DESX_CBCInit(data(ctx), (unsigned char *)key, (unsigned char *)iv,
 621                 enc);
 622         return 1;
 623         }
 624 int cipher_desx_cbc_code(EVP_CIPHER_CTX *ctx, unsigned char *out,
 625         const unsigned char *in, unsigned int inl)
 626         {
 627         int ret = DESX_CBCUpdate(data(ctx), out, (unsigned char *)in, inl);
 628         switch (ret)
 629                 {
 630         case RE_LEN:
 631                 RSAREFerr(RSAREF_F_CIPHER_DES_CBC_CODE,RSAREF_R_LENGTH_NOT_BLOCK_ALIGNED);
 632                 break;
 633         case 0:
 634                 break;
 635         default:
 636                 RSAREFerr(RSAREF_F_CIPHER_DES_CBC_CODE,RSAREF_R_UNKNOWN_FAULT);
 637                 }
 638         return !ret;
 639         }
 640 int cipher_desx_cbc_clean(EVP_CIPHER_CTX *ctx)
 641         {
 642         memset(data(ctx), 0, ctx->cipher->ctx_size);
 643         return 1;
 644         }
 645
 646 /*****************************************************************************
 647  * MD functions
 648  **/
 649 #undef data
 650 #define data(ctx) ((MD2_CTX *)(ctx)->md_data)
 651 static int digest_md2_init(EVP_MD_CTX *ctx)
 652         {
 653         MD2Init(data(ctx));
 654         return 1;
 655         }
 656 static int digest_md2_update(EVP_MD_CTX *ctx,const void *data,
 657         unsigned long count)
 658         {
 659         MD2Update(data(ctx), (unsigned char *)data, (unsigned int)count);
 660         return 1;
 661         }
 662 static int digest_md2_final(EVP_MD_CTX *ctx,unsigned char *md)
 663         {
 664         MD2Final(md, data(ctx));
 665         return 1;
 666         }
 667
 668 #undef data
 669 #define data(ctx) ((MD5_CTX *)(ctx)->md_data)
 670 static int digest_md5_init(EVP_MD_CTX *ctx)
 671         {
 672         MD5Init(data(ctx));
 673         return 1;
 674         }
 675 static int digest_md5_update(EVP_MD_CTX *ctx,const void *data,
 676         unsigned long count)
 677         {
 678         MD5Update(data(ctx), (unsigned char *)data, (unsigned int)count);
 679         return 1;
 680         }
 681 static int digest_md5_final(EVP_MD_CTX *ctx,unsigned char *md)
 682         {
 683         MD5Final(md, data(ctx));
 684         return 1;
 685         }