New functions to allow RSA_METHODs to be changed without poking round in
[openssl.git] / crypto / rsa / rsa_lib.c
1 /* crypto/rsa/rsa_lib.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 <openssl/crypto.h>
61 #include "cryptlib.h"
62 #include <openssl/lhash.h>
63 #include <openssl/bn.h>
64 #include <openssl/rsa.h>
65
66 const char *RSA_version="RSA" OPENSSL_VERSION_PTEXT;
67
68 static RSA_METHOD *default_RSA_meth=NULL;
69 static int rsa_meth_num=0;
70 static STACK *rsa_meth=NULL;
71
72 RSA *RSA_new(void)
73         {
74         return(RSA_new_method(NULL));
75         }
76
77 void RSA_set_default_method(RSA_METHOD *meth)
78         {
79         default_RSA_meth=meth;
80         }
81
82 RSA_METHOD *RSA_get_default_method(void)
83 {
84         return default_RSA_meth;
85 }
86
87 RSA_METHOD *RSA_get_method(RSA *rsa)
88 {
89         return rsa->meth;
90 }
91
92 RSA_METHOD *RSA_set_method(RSA *rsa, RSA_METHOD *meth)
93 {
94         RSA_METHOD *mtmp;
95         mtmp = rsa->meth;
96         if (mtmp->finish) mtmp->finish(rsa);
97         rsa->meth = meth;
98         if (meth->init) meth->init(rsa);
99         return mtmp;
100 }
101
102 RSA *RSA_new_method(RSA_METHOD *meth)
103         {
104         RSA *ret;
105
106         if (default_RSA_meth == NULL)
107                 {
108 #ifdef RSAref
109                 default_RSA_meth=RSA_PKCS1_RSAref();
110 #else
111                 default_RSA_meth=RSA_PKCS1_SSLeay();
112 #endif
113                 }
114         ret=(RSA *)Malloc(sizeof(RSA));
115         if (ret == NULL)
116                 {
117                 RSAerr(RSA_F_RSA_NEW_METHOD,ERR_R_MALLOC_FAILURE);
118                 return(NULL);
119                 }
120
121         if (meth == NULL)
122                 ret->meth=default_RSA_meth;
123         else
124                 ret->meth=meth;
125
126         ret->pad=0;
127         ret->version=0;
128         ret->n=NULL;
129         ret->e=NULL;
130         ret->d=NULL;
131         ret->p=NULL;
132         ret->q=NULL;
133         ret->dmp1=NULL;
134         ret->dmq1=NULL;
135         ret->iqmp=NULL;
136         ret->references=1;
137         ret->_method_mod_n=NULL;
138         ret->_method_mod_p=NULL;
139         ret->_method_mod_q=NULL;
140         ret->blinding=NULL;
141         ret->bignum_data=NULL;
142         ret->flags=ret->meth->flags;
143         if ((ret->meth->init != NULL) && !ret->meth->init(ret))
144                 {
145                 Free(ret);
146                 ret=NULL;
147                 }
148         else
149                 CRYPTO_new_ex_data(rsa_meth,(char *)ret,&ret->ex_data);
150         return(ret);
151         }
152
153 void RSA_free(RSA *r)
154         {
155         int i;
156
157         if (r == NULL) return;
158
159         i=CRYPTO_add(&r->references,-1,CRYPTO_LOCK_RSA);
160 #ifdef REF_PRINT
161         REF_PRINT("RSA",r);
162 #endif
163         if (i > 0) return;
164 #ifdef REF_CHECK
165         if (i < 0)
166                 {
167                 fprintf(stderr,"RSA_free, bad reference count\n");
168                 abort();
169                 }
170 #endif
171
172         CRYPTO_free_ex_data(rsa_meth,(char *)r,&r->ex_data);
173
174         if (r->meth->finish != NULL)
175                 r->meth->finish(r);
176
177         if (r->n != NULL) BN_clear_free(r->n);
178         if (r->e != NULL) BN_clear_free(r->e);
179         if (r->d != NULL) BN_clear_free(r->d);
180         if (r->p != NULL) BN_clear_free(r->p);
181         if (r->q != NULL) BN_clear_free(r->q);
182         if (r->dmp1 != NULL) BN_clear_free(r->dmp1);
183         if (r->dmq1 != NULL) BN_clear_free(r->dmq1);
184         if (r->iqmp != NULL) BN_clear_free(r->iqmp);
185         if (r->blinding != NULL) BN_BLINDING_free(r->blinding);
186         if (r->bignum_data != NULL) Free_locked(r->bignum_data);
187         Free(r);
188         }
189
190 int RSA_get_ex_new_index(long argl, char *argp, int (*new_func)(),
191              int (*dup_func)(), void (*free_func)())
192         {
193         rsa_meth_num++;
194         return(CRYPTO_get_ex_new_index(rsa_meth_num-1,
195                 &rsa_meth,argl,argp,new_func,dup_func,free_func));
196         }
197
198 int RSA_set_ex_data(RSA *r, int idx, char *arg)
199         {
200         return(CRYPTO_set_ex_data(&r->ex_data,idx,arg));
201         }
202
203 char *RSA_get_ex_data(RSA *r, int idx)
204         {
205         return(CRYPTO_get_ex_data(&r->ex_data,idx));
206         }
207
208 int RSA_size(RSA *r)
209         {
210         return(BN_num_bytes(r->n));
211         }
212
213 int RSA_public_encrypt(int flen, unsigned char *from, unsigned char *to,
214              RSA *rsa, int padding)
215         {
216         return(rsa->meth->rsa_pub_enc(flen, from, to, rsa, padding));
217         }
218
219 int RSA_private_encrypt(int flen, unsigned char *from, unsigned char *to,
220              RSA *rsa, int padding)
221         {
222         return(rsa->meth->rsa_priv_enc(flen, from, to, rsa, padding));
223         }
224
225 int RSA_private_decrypt(int flen, unsigned char *from, unsigned char *to,
226              RSA *rsa, int padding)
227         {
228         return(rsa->meth->rsa_priv_dec(flen, from, to, rsa, padding));
229         }
230
231 int RSA_public_decrypt(int flen, unsigned char *from, unsigned char *to,
232              RSA *rsa, int padding)
233         {
234         return(rsa->meth->rsa_pub_dec(flen, from, to, rsa, padding));
235         }
236
237 int RSA_flags(RSA *r)
238         {
239         return((r == NULL)?0:r->meth->flags);
240         }
241
242 void RSA_blinding_off(RSA *rsa)
243         {
244         if (rsa->blinding != NULL)
245                 {
246                 BN_BLINDING_free(rsa->blinding);
247                 rsa->blinding=NULL;
248                 }
249         rsa->flags&= ~RSA_FLAG_BLINDING;
250         }
251
252 int RSA_blinding_on(RSA *rsa, BN_CTX *p_ctx)
253         {
254         BIGNUM *A,*Ai;
255         BN_CTX *ctx;
256         int ret=0;
257
258         if (p_ctx == NULL)
259                 {
260                 if ((ctx=BN_CTX_new()) == NULL) goto err;
261                 }
262         else
263                 ctx=p_ctx;
264
265         if (rsa->blinding != NULL)
266                 BN_BLINDING_free(rsa->blinding);
267
268         A= &(ctx->bn[0]);
269         ctx->tos++;
270         if (!BN_rand(A,BN_num_bits(rsa->n)-1,1,0)) goto err;
271         if ((Ai=BN_mod_inverse(NULL,A,rsa->n,ctx)) == NULL) goto err;
272
273         if (!rsa->meth->bn_mod_exp(A,A,rsa->e,rsa->n,ctx,rsa->_method_mod_n))
274             goto err;
275         rsa->blinding=BN_BLINDING_new(A,Ai,rsa->n);
276         ctx->tos--;
277         rsa->flags|=RSA_FLAG_BLINDING;
278         BN_free(Ai);
279         ret=1;
280 err:
281         if (ctx != p_ctx) BN_CTX_free(ctx);
282         return(ret);
283         }
284
285 int RSA_memory_lock(RSA *r)
286         {
287         int i,j,k,off;
288         char *p;
289         BIGNUM *bn,**t[6],*b;
290         BN_ULONG *ul;
291
292         if (r->d == NULL) return(1);
293         t[0]= &r->d;
294         t[1]= &r->p;
295         t[2]= &r->q;
296         t[3]= &r->dmp1;
297         t[4]= &r->dmq1;
298         t[5]= &r->iqmp;
299         k=sizeof(BIGNUM)*6;
300         off=k/sizeof(BN_ULONG)+1;
301         j=1;
302         for (i=0; i<6; i++)
303                 j+= (*t[i])->top;
304         if ((p=Malloc_locked((off+j)*sizeof(BN_ULONG))) == NULL)
305                 {
306                 RSAerr(RSA_F_MEMORY_LOCK,ERR_R_MALLOC_FAILURE);
307                 return(0);
308                 }
309         bn=(BIGNUM *)p;
310         ul=(BN_ULONG *)&(p[off]);
311         for (i=0; i<6; i++)
312                 {
313                 b= *(t[i]);
314                 *(t[i])= &(bn[i]);
315                 memcpy((char *)&(bn[i]),(char *)b,sizeof(BIGNUM));
316                 bn[i].flags=BN_FLG_STATIC_DATA;
317                 bn[i].d=ul;
318                 memcpy((char *)ul,b->d,sizeof(BN_ULONG)*b->top);
319                 ul+=b->top;
320                 BN_clear_free(b);
321                 }
322         
323         /* I should fix this so it can still be done */
324         r->flags&= ~(RSA_FLAG_CACHE_PRIVATE|RSA_FLAG_CACHE_PUBLIC);
325
326         r->bignum_data=p;
327         return(1);
328         }
329