rsaref/rsaref.c

   1 /* rsaref/rsaref.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 <openssl/bn.h>
  62 #include <openssl/rsa.h>
  63 #include <openssl/rsaref.h>
  64 #include <openssl/rand.h>
  65
  66 /*
  67  * RSAREFerr(RSAREF_F_RSA_REF_BN2BIN,RSAREF_R_CONTENT_ENCODING);
  68  * RSAREFerr(RSAREF_F_RSA_REF_PRIVATE_DECRYPT,RSAREF_R_DATA);
  69  * RSAREFerr(RSAREF_F_RSA_REF_PRIVATE_ENCRYPT,RSAREF_R_DIGEST_ALGORITHM);
  70  * RSAREFerr(RSAREF_F_RSA_REF_PUBLIC_DECRYPT,RSAREF_R_ENCODING);
  71  * RSAREFerr(RSAREF_F_RSA_REF_PUBLIC_ENCRYPT,RSAREF_R_KEY);
  72  * RSAREFerr(RSAREF_F_RSA_REF_PUBLIC_ENCRYPT,RSAREF_R_KEY_ENCODING);
  73  * RSAREFerr(RSAREF_F_RSA_REF_PUBLIC_ENCRYPT,RSAREF_R_LEN);
  74  * RSAREFerr(RSAREF_F_RSA_REF_PUBLIC_ENCRYPT,RSAREF_R_MODULUS_LEN);
  75  * RSAREFerr(RSAREF_F_RSA_REF_PUBLIC_ENCRYPT,RSAREF_R_NEED_RANDOM);
  76  * RSAREFerr(RSAREF_F_RSA_REF_PUBLIC_ENCRYPT,RSAREF_R_PRIVATE_KEY);
  77  * RSAREFerr(RSAREF_F_RSA_REF_PUBLIC_ENCRYPT,RSAREF_R_PUBLIC_KEY);
  78  * RSAREFerr(RSAREF_F_RSA_REF_PUBLIC_ENCRYPT,RSAREF_R_SIGNATURE);
  79  * RSAREFerr(RSAREF_F_RSA_REF_PUBLIC_ENCRYPT,RSAREF_R_SIGNATURE_ENCODING);
  80  * RSAREFerr(RSAREF_F_RSA_REF_PUBLIC_ENCRYPT,RSAREF_R_ENCRYPTION_ALGORITHM);
  81  * RSAREFerr(RSAREF_F_RSAREF_BN2BIN,ERR_R_BN_LIB);
  82  */
  83
  84 #ifndef NOPROTO
  85 static int RSAref_bn2bin(BIGNUM * from, unsigned char* to, int max);
  86 #ifdef undef
  87 static BIGNUM* RSAref_bin2bn(unsigned char* from, BIGNUM * to, int max);
  88 #endif
  89 static int RSAref_Public_eay2ref(RSA * from, RSArefPublicKey * to);
  90 static int RSAref_Private_eay2ref(RSA * from, RSArefPrivateKey * to);
  91 int RSA_ref_private_decrypt(int len, unsigned char *from,
  92         unsigned char *to, RSA *rsa, int padding);
  93 int RSA_ref_private_encrypt(int len, unsigned char *from,
  94         unsigned char *to, RSA *rsa, int padding);
  95 int RSA_ref_public_encrypt(int len, unsigned char *from,
  96         unsigned char *to, RSA *rsa, int padding);
  97 int RSA_ref_public_decrypt(int len, unsigned char *from,
  98         unsigned char *to, RSA *rsa, int padding);
  99 static int BN_ref_mod_exp(BIGNUM *r,BIGNUM *a,BIGNUM *p,BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx);
 100 static int RSA_ref_mod_exp(BIGNUM *r0, BIGNUM *I, RSA *rsa);
 101 #else
 102
 103 static int RSAref_bn2bin();
 104 #ifdef undef
 105 static BIGNUM* RSAref_bin2bn();
 106 #endif
 107 static int RSAref_Public_eay2ref();
 108 static int RSAref_Private_eay2ref();
 109 static int BN_ref_mod_exp();
 110 static int RSA_ref_mod_exp();
 111 int RSA_ref_private_decrypt();
 112 int RSA_ref_private_encrypt();
 113 int RSA_ref_public_encrypt();
 114 int RSA_ref_public_decrypt();
 115 static int BN_ref_mod_exp();
 116 static int RSA_ref_mod_exp();
 117 #endif
 118
 119 static RSA_METHOD rsa_pkcs1_ref_meth={
 120         "RSAref PKCS#1 RSA",
 121         RSA_ref_public_encrypt,
 122         RSA_ref_public_decrypt,
 123         RSA_ref_private_encrypt,
 124         RSA_ref_private_decrypt,
 125         RSA_ref_mod_exp,
 126         BN_ref_mod_exp,
 127         NULL,
 128         NULL,
 129         0,
 130         NULL,
 131         };
 132
 133 RSA_METHOD *RSA_PKCS1_RSAref(void)
 134         {
 135         return(&rsa_pkcs1_ref_meth);
 136         }
 137
 138 static int RSA_ref_mod_exp(BIGNUM *r0, BIGNUM *I, RSA *rsa)
 139         {
 140         RSAREFerr(RSAREF_F_RSA_REF_MOD_EXP,ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 141         return(0);
 142         }
 143
 144 static int BN_ref_mod_exp(BIGNUM *r, BIGNUM *a, BIGNUM *p, BIGNUM *m,
 145              BN_CTX *ctx, BN_MONT_CTX *m_ctx)
 146         {
 147         RSAREFerr(RSAREF_F_BN_REF_MOD_EXP,ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 148         return(0);
 149         }
 150
 151 /* unsigned char *to:  [max]    */
 152 static int RSAref_bn2bin(BIGNUM *from, unsigned char *to, int max)
 153         {
 154         int i;
 155
 156         i=BN_num_bytes(from);
 157         if (i > max)
 158                 {
 159                 RSAREFerr(RSAREF_F_RSAREF_BN2BIN,RSAREF_R_LEN);
 160                 return(0);
 161                 }
 162
 163         memset(to,0,(unsigned int)max);
 164         if (!BN_bn2bin(from,&(to[max-i])))
 165                 return(0);
 166         return(1);
 167         }
 168
 169 #ifdef undef
 170 /* unsigned char *from:  [max]    */
 171 static BIGNUM *RSAref_bin2bn(unsigned char *from, BIGNUM *to, int max)
 172         {
 173         int i;
 174         BIGNUM *ret;
 175
 176         for (i=0; i<max; i++)
 177                 if (from[i]) break;
 178
 179         ret=BN_bin2bn(&(from[i]),max-i,to);
 180         return(ret);
 181         }
 182
 183 static int RSAref_Public_ref2eay(RSArefPublicKey *from, RSA *to)
 184         {
 185         to->n=RSAref_bin2bn(from->m,NULL,RSAref_MAX_LEN);
 186         to->e=RSAref_bin2bn(from->e,NULL,RSAref_MAX_LEN);
 187         if ((to->n == NULL) || (to->e == NULL)) return(0);
 188         return(1);
 189         }
 190 #endif
 191
 192 static int RSAref_Public_eay2ref(RSA *from, RSArefPublicKey *to)
 193         {
 194         to->bits=BN_num_bits(from->n);
 195         if (!RSAref_bn2bin(from->n,to->m,RSAref_MAX_LEN)) return(0);
 196         if (!RSAref_bn2bin(from->e,to->e,RSAref_MAX_LEN)) return(0);
 197         return(1);
 198         }
 199
 200 #ifdef undef
 201 static int RSAref_Private_ref2eay(RSArefPrivateKey *from, RSA *to)
 202         {
 203         if ((to->n=RSAref_bin2bn(from->m,NULL,RSAref_MAX_LEN)) == NULL)
 204                 return(0);
 205         if ((to->e=RSAref_bin2bn(from->e,NULL,RSAref_MAX_LEN)) == NULL)
 206                 return(0);
 207         if ((to->d=RSAref_bin2bn(from->d,NULL,RSAref_MAX_LEN)) == NULL)
 208                 return(0);
 209         if ((to->p=RSAref_bin2bn(from->prime[0],NULL,RSAref_MAX_PLEN)) == NULL)
 210                 return(0);
 211         if ((to->q=RSAref_bin2bn(from->prime[1],NULL,RSAref_MAX_PLEN)) == NULL)
 212                 return(0);
 213         if ((to->dmp1=RSAref_bin2bn(from->pexp[0],NULL,RSAref_MAX_PLEN))
 214                 == NULL)
 215                 return(0);
 216         if ((to->dmq1=RSAref_bin2bn(from->pexp[1],NULL,RSAref_MAX_PLEN))
 217                 == NULL)
 218                 return(0);
 219         if ((to->iqmp=RSAref_bin2bn(from->coef,NULL,RSAref_MAX_PLEN)) == NULL)
 220                 return(0);
 221         return(1);
 222         }
 223 #endif
 224
 225 static int RSAref_Private_eay2ref(RSA *from, RSArefPrivateKey *to)
 226         {
 227         to->bits=BN_num_bits(from->n);
 228         if (!RSAref_bn2bin(from->n,to->m,RSAref_MAX_LEN)) return(0);
 229         if (!RSAref_bn2bin(from->e,to->e,RSAref_MAX_LEN)) return(0);
 230         if (!RSAref_bn2bin(from->d,to->d,RSAref_MAX_LEN)) return(0);
 231         if (!RSAref_bn2bin(from->p,to->prime[0],RSAref_MAX_PLEN)) return(0);
 232         if (!RSAref_bn2bin(from->q,to->prime[1],RSAref_MAX_PLEN)) return(0);
 233         if (!RSAref_bn2bin(from->dmp1,to->pexp[0],RSAref_MAX_PLEN)) return(0);
 234         if (!RSAref_bn2bin(from->dmq1,to->pexp[1],RSAref_MAX_PLEN)) return(0);
 235         if (!RSAref_bn2bin(from->iqmp,to->coef,RSAref_MAX_PLEN)) return(0);
 236         return(1);
 237         }
 238
 239 int RSA_ref_private_decrypt(int len, unsigned char *from, unsigned char *to,
 240              RSA *rsa, int padding)
 241         {
 242         int i,outlen= -1;
 243         RSArefPrivateKey RSAkey;
 244
 245         if (!RSAref_Private_eay2ref(rsa,&RSAkey))
 246                 goto err;
 247         if ((i=RSAPrivateDecrypt(to,&outlen,from,len,&RSAkey)) != 0)
 248                 {
 249                 RSAREFerr(RSAREF_F_RSA_REF_PRIVATE_DECRYPT,i);
 250                 outlen= -1;
 251                 }
 252 err:
 253         memset(&RSAkey,0,sizeof(RSAkey));
 254         return(outlen);
 255         }
 256
 257 int RSA_ref_private_encrypt(int len, unsigned char *from, unsigned char *to,
 258              RSA *rsa, int padding)
 259         {
 260         int i,outlen= -1;
 261         RSArefPrivateKey RSAkey;
 262
 263         if (padding != RSA_PKCS1_PADDING)
 264                 {
 265                 RSAREFerr(RSAREF_F_RSA_REF_PRIVATE_ENCRYPT, RSA_R_UNKNOWN_PADDING_TYPE);
 266                 goto err;
 267         }
 268         if (!RSAref_Private_eay2ref(rsa,&RSAkey))
 269                 goto err;
 270         if ((i=RSAPrivateEncrypt(to,&outlen,from,len,&RSAkey)) != 0)
 271                 {
 272                 RSAREFerr(RSAREF_F_RSA_REF_PRIVATE_ENCRYPT,i);
 273                 outlen= -1;
 274                 }
 275 err:
 276         memset(&RSAkey,0,sizeof(RSAkey));
 277         return(outlen);
 278         }
 279
 280 int RSA_ref_public_decrypt(int len, unsigned char *from, unsigned char *to,
 281              RSA *rsa, int padding)
 282         {
 283         int i,outlen= -1;
 284         RSArefPublicKey RSAkey;
 285
 286         if (!RSAref_Public_eay2ref(rsa,&RSAkey))
 287                 goto err;
 288         if ((i=RSAPublicDecrypt(to,&outlen,from,len,&RSAkey)) != 0)
 289                 {
 290                 RSAREFerr(RSAREF_F_RSA_REF_PUBLIC_DECRYPT,i);
 291                 outlen= -1;
 292                 }
 293 err:
 294         memset(&RSAkey,0,sizeof(RSAkey));
 295         return(outlen);
 296         }
 297
 298 int RSA_ref_public_encrypt(int len, unsigned char *from, unsigned char *to,
 299              RSA *rsa, int padding)
 300         {
 301         int outlen= -1;
 302         int i;
 303         RSArefPublicKey RSAkey;
 304         RSARandomState rnd;
 305         unsigned char buf[16];
 306
 307         if (padding != RSA_PKCS1_PADDING && padding != RSA_SSLV23_PADDING)
 308                 {
 309                 RSAREFerr(RSAREF_F_RSA_REF_PUBLIC_ENCRYPT, RSA_R_UNKNOWN_PADDING_TYPE);
 310                 goto err;
 311                 }
 312
 313         R_RandomInit(&rnd);
 314         R_GetRandomBytesNeeded((unsigned int *)&i,&rnd);
 315         while (i > 0)
 316                 {
 317                 RAND_bytes(buf,16);
 318                 R_RandomUpdate(&rnd,buf,(unsigned int)((i>16)?16:i));
 319                 i-=16;
 320                 }
 321
 322         if (!RSAref_Public_eay2ref(rsa,&RSAkey))
 323                 goto err;
 324         if ((i=RSAPublicEncrypt(to,&outlen,from,len,&RSAkey,&rnd)) != 0)
 325                 {
 326                 RSAREFerr(RSAREF_F_RSA_REF_PUBLIC_ENCRYPT,i);
 327                 outlen= -1;
 328                 goto err;
 329                 }
 330 err:
 331         memset(&RSAkey,0,sizeof(RSAkey));
 332         R_RandomFinal(&rnd);
 333         memset(&rnd,0,sizeof(rnd));
 334         return(outlen);
 335         }
 336