crypto/rsa/rsa_eay.c

   1 /* crypto/rsa/rsa_eay.c */
   2 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
   3  * All rights reserved.
   4  *
   5  * This package is an SSL implementation written
   6  * by Eric Young (eay@cryptsoft.com).
   7  * The implementation was written so as to conform with Netscapes SSL.
   8  *
   9  * This library is free for commercial and non-commercial use as long as
  10  * the following conditions are aheared to.  The following conditions
  11  * apply to all code found in this distribution, be it the RC4, RSA,
  12  * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
  13  * included with this distribution is covered by the same copyright terms
  14  * except that the holder is Tim Hudson (tjh@cryptsoft.com).
  15  *
  16  * Copyright remains Eric Young's, and as such any Copyright notices in
  17  * the code are not to be removed.
  18  * If this package is used in a product, Eric Young should be given attribution
  19  * as the author of the parts of the library used.
  20  * This can be in the form of a textual message at program startup or
  21  * in documentation (online or textual) provided with the package.
  22  *
  23  * Redistribution and use in source and binary forms, with or without
  24  * modification, are permitted provided that the following conditions
  25  * are met:
  26  * 1. Redistributions of source code must retain the copyright
  27  *    notice, this list of conditions and the following disclaimer.
  28  * 2. Redistributions in binary form must reproduce the above copyright
  29  *    notice, this list of conditions and the following disclaimer in the
  30  *    documentation and/or other materials provided with the distribution.
  31  * 3. All advertising materials mentioning features or use of this software
  32  *    must display the following acknowledgement:
  33  *    "This product includes cryptographic software written by
  34  *     Eric Young (eay@cryptsoft.com)"
  35  *    The word 'cryptographic' can be left out if the rouines from the library
  36  *    being used are not cryptographic related :-).
  37  * 4. If you include any Windows specific code (or a derivative thereof) from
  38  *    the apps directory (application code) you must include an acknowledgement:
  39  *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
  40  *
  41  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
  42  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  43  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  44  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  45  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  46  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  47  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  48  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  49  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  50  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  51  * SUCH DAMAGE.
  52  *
  53  * The licence and distribution terms for any publically available version or
  54  * derivative of this code cannot be changed.  i.e. this code cannot simply be
  55  * copied and put under another distribution licence
  56  * [including the GNU Public Licence.]
  57  */
  58
  59 #include <stdio.h>
  60 #include "cryptlib.h"
  61 #include "bn.h"
  62 #include "rsa.h"
  63 #include "rand.h"
  64
  65 #ifndef NOPROTO
  66 static int RSA_eay_public_encrypt(int flen, unsigned char *from,
  67                 unsigned char *to, RSA *rsa,int padding);
  68 static int RSA_eay_private_encrypt(int flen, unsigned char *from,
  69                 unsigned char *to, RSA *rsa,int padding);
  70 static int RSA_eay_public_decrypt(int flen, unsigned char *from,
  71                 unsigned char *to, RSA *rsa,int padding);
  72 static int RSA_eay_private_decrypt(int flen, unsigned char *from,
  73                 unsigned char *to, RSA *rsa,int padding);
  74 static int RSA_eay_mod_exp(BIGNUM *r0, BIGNUM *i, RSA *rsa);
  75 static int RSA_eay_init(RSA *rsa);
  76 static int RSA_eay_finish(RSA *rsa);
  77 #else
  78 static int RSA_eay_public_encrypt();
  79 static int RSA_eay_private_encrypt();
  80 static int RSA_eay_public_decrypt();
  81 static int RSA_eay_private_decrypt();
  82 static int RSA_eay_mod_exp();
  83 static int RSA_eay_init();
  84 static int RSA_eay_finish();
  85 #endif
  86
  87 static RSA_METHOD rsa_pkcs1_eay_meth={
  88         "Eric Young's PKCS#1 RSA",
  89         RSA_eay_public_encrypt,
  90         RSA_eay_public_decrypt,
  91         RSA_eay_private_encrypt,
  92         RSA_eay_private_decrypt,
  93         RSA_eay_mod_exp,
  94         BN_mod_exp_mont,
  95         RSA_eay_init,
  96         RSA_eay_finish,
  97         0,
  98         NULL,
  99         };
 100
 101 RSA_METHOD *RSA_PKCS1_SSLeay()
 102         {
 103         return(&rsa_pkcs1_eay_meth);
 104         }
 105
 106 static int RSA_eay_public_encrypt(flen, from, to, rsa, padding)
 107 int flen;
 108 unsigned char *from;
 109 unsigned char *to;
 110 RSA *rsa;
 111 int padding;
 112         {
 113         BIGNUM f,ret;
 114         int i,j,k,num=0,r= -1;
 115         unsigned char *buf=NULL;
 116         BN_CTX *ctx=NULL;
 117
 118         BN_init(&f);
 119         BN_init(&ret);
 120         if ((ctx=BN_CTX_new()) == NULL) goto err;
 121         num=BN_num_bytes(rsa->n);
 122         if ((buf=(unsigned char *)Malloc(num)) == NULL)
 123                 {
 124                 RSAerr(RSA_F_RSA_EAY_PUBLIC_ENCRYPT,ERR_R_MALLOC_FAILURE);
 125                 goto err;
 126                 }
 127
 128         switch (padding)
 129                 {
 130         case RSA_PKCS1_PADDING:
 131                 i=RSA_padding_add_PKCS1_type_2(buf,num,from,flen);
 132                 break;
 133         case RSA_PKCS1_OAEP_PADDING:
 134                 i=RSA_padding_add_PKCS1_OAEP(buf,num,from,flen,NULL,0);
 135                 break;
 136         case RSA_SSLV23_PADDING:
 137                 i=RSA_padding_add_SSLv23(buf,num,from,flen);
 138                 break;
 139         case RSA_NO_PADDING:
 140                 i=RSA_padding_add_none(buf,num,from,flen);
 141                 break;
 142         default:
 143                 RSAerr(RSA_F_RSA_EAY_PUBLIC_ENCRYPT,RSA_R_UNKNOWN_PADDING_TYPE);
 144                 goto err;
 145                 }
 146         if (i <= 0) goto err;
 147
 148         if (BN_bin2bn(buf,num,&f) == NULL) goto err;
 149
 150         if ((rsa->_method_mod_n == NULL) && (rsa->flags & RSA_FLAG_CACHE_PUBLIC))
 151                 {
 152                 if ((rsa->_method_mod_n=BN_MONT_CTX_new()) != NULL)
 153                         if (!BN_MONT_CTX_set(rsa->_method_mod_n,rsa->n,ctx))
 154                             goto err;
 155                 }
 156
 157         if (!rsa->meth->bn_mod_exp(&ret,&f,rsa->e,rsa->n,ctx,
 158                 rsa->_method_mod_n)) goto err;
 159
 160         /* put in leading 0 bytes if the number is less than the
 161          * length of the modulus */
 162         j=BN_num_bytes(&ret);
 163         i=BN_bn2bin(&ret,&(to[num-j]));
 164         for (k=0; k<(num-i); k++)
 165                 to[k]=0;
 166
 167         r=num;
 168 err:
 169         if (ctx != NULL) BN_CTX_free(ctx);
 170         BN_clear_free(&f);
 171         BN_clear_free(&ret);
 172         if (buf != NULL)
 173                 {
 174                 memset(buf,0,num);
 175                 Free(buf);
 176                 }
 177         return(r);
 178         }
 179
 180 static int RSA_eay_private_encrypt(flen, from, to, rsa, padding)
 181 int flen;
 182 unsigned char *from;
 183 unsigned char *to;
 184 RSA *rsa;
 185 int padding;
 186         {
 187         BIGNUM f,ret;
 188         int i,j,k,num=0,r= -1;
 189         unsigned char *buf=NULL;
 190         BN_CTX *ctx=NULL;
 191
 192         BN_init(&f);
 193         BN_init(&ret);
 194
 195         if ((ctx=BN_CTX_new()) == NULL) goto err;
 196         num=BN_num_bytes(rsa->n);
 197         if ((buf=(unsigned char *)Malloc(num)) == NULL)
 198                 {
 199                 RSAerr(RSA_F_RSA_EAY_PRIVATE_ENCRYPT,ERR_R_MALLOC_FAILURE);
 200                 goto err;
 201                 }
 202
 203         switch (padding)
 204                 {
 205         case RSA_PKCS1_PADDING:
 206                 i=RSA_padding_add_PKCS1_type_1(buf,num,from,flen);
 207                 break;
 208         case RSA_NO_PADDING:
 209                 i=RSA_padding_add_none(buf,num,from,flen);
 210                 break;
 211         case RSA_SSLV23_PADDING:
 212         default:
 213                 RSAerr(RSA_F_RSA_EAY_PRIVATE_ENCRYPT,RSA_R_UNKNOWN_PADDING_TYPE);
 214                 goto err;
 215                 }
 216         if (i <= 0) goto err;
 217
 218         if (BN_bin2bn(buf,num,&f) == NULL) goto err;
 219
 220         if ((rsa->flags & RSA_FLAG_BLINDING) && (rsa->blinding == NULL))
 221                 RSA_blinding_on(rsa,ctx);
 222         if (rsa->flags & RSA_FLAG_BLINDING)
 223                 if (!BN_BLINDING_convert(&f,rsa->blinding,ctx)) goto err;
 224
 225         if (    (rsa->p != NULL) &&
 226                 (rsa->q != NULL) &&
 227                 (rsa->dmp1 != NULL) &&
 228                 (rsa->dmq1 != NULL) &&
 229                 (rsa->iqmp != NULL))
 230                 { if (!rsa->meth->rsa_mod_exp(&ret,&f,rsa)) goto err; }
 231         else
 232                 {
 233                 if (!rsa->meth->bn_mod_exp(&ret,&f,rsa->d,rsa->n,ctx,NULL)) goto err;
 234                 }
 235
 236         if (rsa->flags & RSA_FLAG_BLINDING)
 237                 if (!BN_BLINDING_invert(&ret,rsa->blinding,ctx)) goto err;
 238
 239         /* put in leading 0 bytes if the number is less than the
 240          * length of the modulus */
 241         j=BN_num_bytes(&ret);
 242         i=BN_bn2bin(&ret,&(to[num-j]));
 243         for (k=0; k<(num-i); k++)
 244                 to[k]=0;
 245
 246         r=num;
 247 err:
 248         if (ctx != NULL) BN_CTX_free(ctx);
 249         BN_clear_free(&ret);
 250         BN_clear_free(&f);
 251         if (buf != NULL)
 252                 {
 253                 memset(buf,0,num);
 254                 Free(buf);
 255                 }
 256         return(r);
 257         }
 258
 259 static int RSA_eay_private_decrypt(flen, from, to, rsa,padding)
 260 int flen;
 261 unsigned char *from;
 262 unsigned char *to;
 263 RSA *rsa;
 264 int padding;
 265         {
 266         BIGNUM f,ret;
 267         int j,num=0,r= -1;
 268         unsigned char *p;
 269         unsigned char *buf=NULL;
 270         BN_CTX *ctx=NULL;
 271
 272         BN_init(&f);
 273         BN_init(&ret);
 274         ctx=BN_CTX_new();
 275         if (ctx == NULL) goto err;
 276
 277         num=BN_num_bytes(rsa->n);
 278
 279         if ((buf=(unsigned char *)Malloc(num)) == NULL)
 280                 {
 281                 RSAerr(RSA_F_RSA_EAY_PRIVATE_DECRYPT,ERR_R_MALLOC_FAILURE);
 282                 goto err;
 283                 }
 284
 285         /* This check was for equallity but PGP does evil things
 286          * and chops off the top '0' bytes */
 287         if (flen > num)
 288                 {
 289                 RSAerr(RSA_F_RSA_EAY_PRIVATE_DECRYPT,RSA_R_DATA_GREATER_THAN_MOD_LEN);
 290                 goto err;
 291                 }
 292
 293         /* make data into a big number */
 294         if (BN_bin2bn(from,(int)flen,&f) == NULL) goto err;
 295
 296         if ((rsa->flags & RSA_FLAG_BLINDING) && (rsa->blinding == NULL))
 297                 RSA_blinding_on(rsa,ctx);
 298         if (rsa->flags & RSA_FLAG_BLINDING)
 299                 if (!BN_BLINDING_convert(&f,rsa->blinding,ctx)) goto err;
 300
 301         /* do the decrypt */
 302         if (    (rsa->p != NULL) &&
 303                 (rsa->q != NULL) &&
 304                 (rsa->dmp1 != NULL) &&
 305                 (rsa->dmq1 != NULL) &&
 306                 (rsa->iqmp != NULL))
 307                 { if (!rsa->meth->rsa_mod_exp(&ret,&f,rsa)) goto err; }
 308         else
 309                 {
 310                 if (!rsa->meth->bn_mod_exp(&ret,&f,rsa->d,rsa->n,ctx,NULL))
 311                         goto err;
 312                 }
 313
 314         if (rsa->flags & RSA_FLAG_BLINDING)
 315                 if (!BN_BLINDING_invert(&ret,rsa->blinding,ctx)) goto err;
 316
 317         p=buf;
 318         j=BN_bn2bin(&ret,p); /* j is only used with no-padding mode */
 319
 320         switch (padding)
 321                 {
 322         case RSA_PKCS1_PADDING:
 323                 r=RSA_padding_check_PKCS1_type_2(to,num,buf,j,num);
 324                 break;
 325         case RSA_PKCS1_OAEP_PADDING:
 326                 r=RSA_padding_check_PKCS1_OAEP(to,num,buf,j,num,NULL,0);
 327                 break;
 328         case RSA_SSLV23_PADDING:
 329                 r=RSA_padding_check_SSLv23(to,num,buf,j,num);
 330                 break;
 331         case RSA_NO_PADDING:
 332                 r=RSA_padding_check_none(to,num,buf,j,num);
 333                 break;
 334         default:
 335                 RSAerr(RSA_F_RSA_EAY_PRIVATE_DECRYPT,RSA_R_UNKNOWN_PADDING_TYPE);
 336                 goto err;
 337                 }
 338         if (r < 0)
 339                 RSAerr(RSA_F_RSA_EAY_PRIVATE_DECRYPT,RSA_R_PADDING_CHECK_FAILED);
 340
 341 err:
 342         if (ctx != NULL) BN_CTX_free(ctx);
 343         BN_clear_free(&f);
 344         BN_clear_free(&ret);
 345         if (buf != NULL)
 346                 {
 347                 memset(buf,0,num);
 348                 Free(buf);
 349                 }
 350         return(r);
 351         }
 352
 353 static int RSA_eay_public_decrypt(flen, from, to, rsa, padding)
 354 int flen;
 355 unsigned char *from;
 356 unsigned char *to;
 357 RSA *rsa;
 358 int padding;
 359         {
 360         BIGNUM f,ret;
 361         int i,num=0,r= -1;
 362         unsigned char *p;
 363         unsigned char *buf=NULL;
 364         BN_CTX *ctx=NULL;
 365
 366         BN_init(&f);
 367         BN_init(&ret);
 368         ctx=BN_CTX_new();
 369         if (ctx == NULL) goto err;
 370
 371         num=BN_num_bytes(rsa->n);
 372         buf=(unsigned char *)Malloc(num);
 373         if (buf == NULL)
 374                 {
 375                 RSAerr(RSA_F_RSA_EAY_PUBLIC_DECRYPT,ERR_R_MALLOC_FAILURE);
 376                 goto err;
 377                 }
 378
 379         /* This check was for equallity but PGP does evil things
 380          * and chops off the top '0' bytes */
 381         if (flen > num)
 382                 {
 383                 RSAerr(RSA_F_RSA_EAY_PUBLIC_DECRYPT,RSA_R_DATA_GREATER_THAN_MOD_LEN);
 384                 goto err;
 385                 }
 386
 387         if (BN_bin2bn(from,flen,&f) == NULL) goto err;
 388         /* do the decrypt */
 389         if ((rsa->_method_mod_n == NULL) && (rsa->flags & RSA_FLAG_CACHE_PUBLIC))
 390                 {
 391                 if ((rsa->_method_mod_n=BN_MONT_CTX_new()) != NULL)
 392                         if (!BN_MONT_CTX_set(rsa->_method_mod_n,rsa->n,ctx))
 393                             goto err;
 394                 }
 395
 396         if (!rsa->meth->bn_mod_exp(&ret,&f,rsa->e,rsa->n,ctx,
 397                 rsa->_method_mod_n)) goto err;
 398
 399         p=buf;
 400         i=BN_bn2bin(&ret,p);
 401
 402         switch (padding)
 403                 {
 404         case RSA_PKCS1_PADDING:
 405                 r=RSA_padding_check_PKCS1_type_1(to,num,buf,i,num);
 406                 break;
 407         case RSA_NO_PADDING:
 408                 r=RSA_padding_check_none(to,num,buf,i,num);
 409                 break;
 410         default:
 411                 RSAerr(RSA_F_RSA_EAY_PUBLIC_DECRYPT,RSA_R_UNKNOWN_PADDING_TYPE);
 412                 goto err;
 413                 }
 414         if (r < 0)
 415                 RSAerr(RSA_F_RSA_EAY_PUBLIC_DECRYPT,RSA_R_PADDING_CHECK_FAILED);
 416
 417 err:
 418         if (ctx != NULL) BN_CTX_free(ctx);
 419         BN_clear_free(&f);
 420         BN_clear_free(&ret);
 421         if (buf != NULL)
 422                 {
 423                 memset(buf,0,num);
 424                 Free(buf);
 425                 }
 426         return(r);
 427         }
 428
 429 static int RSA_eay_mod_exp(r0, I, rsa)
 430 BIGNUM *r0;
 431 BIGNUM *I;
 432 RSA *rsa;
 433         {
 434         BIGNUM r1,m1;
 435         int ret=0;
 436         BN_CTX *ctx;
 437
 438         if ((ctx=BN_CTX_new()) == NULL) goto err;
 439         BN_init(&m1);
 440         BN_init(&r1);
 441
 442         if (rsa->flags & RSA_FLAG_CACHE_PRIVATE)
 443                 {
 444                 if (rsa->_method_mod_p == NULL)
 445                         {
 446                         if ((rsa->_method_mod_p=BN_MONT_CTX_new()) != NULL)
 447                                 if (!BN_MONT_CTX_set(rsa->_method_mod_p,rsa->p,
 448                                                      ctx))
 449                                         goto err;
 450                         }
 451                 if (rsa->_method_mod_q == NULL)
 452                         {
 453                         if ((rsa->_method_mod_q=BN_MONT_CTX_new()) != NULL)
 454                                 if (!BN_MONT_CTX_set(rsa->_method_mod_q,rsa->q,
 455                                                      ctx))
 456                                         goto err;
 457                         }
 458                 }
 459
 460         if (!BN_mod(&r1,I,rsa->q,ctx)) goto err;
 461         if (!rsa->meth->bn_mod_exp(&m1,&r1,rsa->dmq1,rsa->q,ctx,
 462                 rsa->_method_mod_q)) goto err;
 463
 464         if (!BN_mod(&r1,I,rsa->p,ctx)) goto err;
 465         if (!rsa->meth->bn_mod_exp(r0,&r1,rsa->dmp1,rsa->p,ctx,
 466                 rsa->_method_mod_p)) goto err;
 467
 468         if (!BN_sub(r0,r0,&m1)) goto err;
 469         /* This will help stop the size of r0 increasing, which does
 470          * affect the multiply if it optimised for a power of 2 size */
 471         if (r0->neg)
 472                 if (!BN_add(r0,r0,rsa->p)) goto err;
 473
 474         if (!BN_mul(&r1,r0,rsa->iqmp,ctx)) goto err;
 475         if (!BN_mod(r0,&r1,rsa->p,ctx)) goto err;
 476         /* If p < q it is occasionally possible for the correction of
 477          * adding 'p' if r0 is negative above to leave the result still
 478          * negative. This can break the private key operations: the following
 479          * second correction should *always* correct this rare occurrence.
 480          * This will *never* happen with OpenSSL generated keys because
 481          * they ensure p > q [steve]
 482          */
 483         if (r0->neg)
 484                 if (!BN_add(r0,r0,rsa->p)) goto err;
 485         if (!BN_mul(&r1,r0,rsa->q,ctx)) goto err;
 486         if (!BN_add(r0,&r1,&m1)) goto err;
 487
 488         ret=1;
 489 err:
 490         BN_clear_free(&m1);
 491         BN_clear_free(&r1);
 492         BN_CTX_free(ctx);
 493         return(ret);
 494         }
 495
 496 static int RSA_eay_init(rsa)
 497 RSA *rsa;
 498         {
 499         rsa->flags|=RSA_FLAG_CACHE_PUBLIC|RSA_FLAG_CACHE_PRIVATE;
 500         return(1);
 501         }
 502
 503 static int RSA_eay_finish(rsa)
 504 RSA *rsa;
 505         {
 506         if (rsa->_method_mod_n != NULL)
 507                 BN_MONT_CTX_free(rsa->_method_mod_n);
 508         if (rsa->_method_mod_p != NULL)
 509                 BN_MONT_CTX_free(rsa->_method_mod_p);
 510         if (rsa->_method_mod_q != NULL)
 511                 BN_MONT_CTX_free(rsa->_method_mod_q);
 512         return(1);
 513         }
 514
 515