Change #include filenames from <foo.h> to <openssl.h>.
[openssl.git] / 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