1/*
2 * Copyright (c) 2000-2001 Apple Computer, Inc. All Rights Reserved.
3 *
4 * The contents of this file constitute Original Code as defined in and are
5 * subject to the Apple Public Source License Version 1.2 (the 'License').
6 * You may not use this file except in compliance with the License. Please obtain
7 * a copy of the License at http://www.apple.com/publicsource and read it before
8 * using this file.
9 *
10 * This Original Code and all software distributed under the License are
11 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS
12 * OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, INCLUDING WITHOUT
13 * LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
14 * PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. Please see the License for the
15 * specific language governing rights and limitations under the License.
16 */
17
18
19/* crypto/rsa/rsa_lib.c */
20/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
21 * All rights reserved.
22 *
23 * This package is an SSL implementation written
24 * by Eric Young (eay@cryptsoft.com).
25 * The implementation was written so as to conform with Netscapes SSL.
26 *
27 * This library is free for commercial and non-commercial use as long as
28 * the following conditions are aheared to.  The following conditions
29 * apply to all code found in this distribution, be it the RC4, RSA,
30 * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
31 * included with this distribution is covered by the same copyright terms
32 * except that the holder is Tim Hudson (tjh@cryptsoft.com).
33 *
34 * Copyright remains Eric Young's, and as such any Copyright notices in
35 * the code are not to be removed.
36 * If this package is used in a product, Eric Young should be given attribution
37 * as the author of the parts of the library used.
38 * This can be in the form of a textual message at program startup or
39 * in documentation (online or textual) provided with the package.
40 *
41 * Redistribution and use in source and binary forms, with or without
42 * modification, are permitted provided that the following conditions
43 * are met:
44 * 1. Redistributions of source code must retain the copyright
45 *    notice, this list of conditions and the following disclaimer.
46 * 2. Redistributions in binary form must reproduce the above copyright
47 *    notice, this list of conditions and the following disclaimer in the
48 *    documentation and/or other materials provided with the distribution.
49 * 3. All advertising materials mentioning features or use of this software
50 *    must display the following acknowledgement:
51 *    "This product includes cryptographic software written by
52 *     Eric Young (eay@cryptsoft.com)"
53 *    The word 'cryptographic' can be left out if the rouines from the library
54 *    being used are not cryptographic related :-).
55 * 4. If you include any Windows specific code (or a derivative thereof) from
56 *    the apps directory (application code) you must include an acknowledgement:
57 *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
58 *
59 * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
60 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
61 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
62 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
63 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
64 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
65 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
66 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
67 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
68 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
69 * SUCH DAMAGE.
70 *
71 * The licence and distribution terms for any publically available version or
72 * derivative of this code cannot be changed.  i.e. this code cannot simply be
73 * copied and put under another distribution licence
74 * [including the GNU Public Licence.]
75 */
76
77#include <stdio.h>
78#include <openssl/crypto.h>
79#include "cryptlib.h"
80#include <openssl/lhash.h>
81#include <openssl/bn.h>
82#include <openssl/rsa.h>
83#include <pthread.h>
84
85const char *RSA_version="RSA" OPENSSL_VERSION_PTEXT;
86
87static const RSA_METHOD *default_RSA_meth=NULL;
88static int rsa_meth_num=0;
89static STACK_OF(CRYPTO_EX_DATA_FUNCS) *rsa_meth=NULL;
90
91RSA *RSA_new(void)
92	{
93	return(RSA_new_method(NULL));
94	}
95
96void RSA_set_default_method(const RSA_METHOD *meth)
97	{
98	default_RSA_meth=meth;
99	}
100
101const RSA_METHOD *RSA_get_default_method(void)
102{
103	return default_RSA_meth;
104}
105
106const RSA_METHOD *RSA_get_method(RSA *rsa)
107{
108	return rsa->meth;
109}
110
111const RSA_METHOD *RSA_set_method(RSA *rsa, const RSA_METHOD *meth)
112{
113	const RSA_METHOD *mtmp;
114	mtmp = rsa->meth;
115	if (mtmp->finish) mtmp->finish(rsa);
116	rsa->meth = meth;
117	if (meth->init) meth->init(rsa);
118	return mtmp;
119}
120
121RSA *RSA_new_method(const RSA_METHOD *meth)
122	{
123	RSA *ret;
124
125	if (default_RSA_meth == NULL)
126		{
127#ifdef RSA_NULL
128		default_RSA_meth=RSA_null_method();
129#else
130#ifdef RSAref
131		default_RSA_meth=RSA_PKCS1_RSAref();
132#else
133		default_RSA_meth=RSA_PKCS1_SSLeay();
134#endif
135#endif
136		}
137	ret=(RSA *)Malloc(sizeof(RSA));
138	if (ret == NULL)
139		{
140		RSAerr(RSA_F_RSA_NEW_METHOD,ERR_R_MALLOC_FAILURE);
141		return(NULL);
142		}
143
144	if (meth == NULL)
145		ret->meth=default_RSA_meth;
146	else
147		ret->meth=meth;
148
149	ret->pad=0;
150	ret->version=0;
151	ret->n=NULL;
152	ret->e=NULL;
153	ret->d=NULL;
154	ret->p=NULL;
155	ret->q=NULL;
156	ret->dmp1=NULL;
157	ret->dmq1=NULL;
158	ret->iqmp=NULL;
159	ret->references=1;
160	ret->_method_mod_n=NULL;
161	ret->_method_mod_p=NULL;
162	ret->_method_mod_q=NULL;
163
164	// make blinding per thread
165	ret->num_blinding_threads = 0;
166	pthread_mutex_init(&ret->blinding_mutex, NULL);
167	ret->blinding_array = NULL;
168
169	ret->bignum_data=NULL;
170	ret->flags=ret->meth->flags;
171	if ((ret->meth->init != NULL) && !ret->meth->init(ret))
172		{
173		Free(ret);
174		ret=NULL;
175		}
176	else
177		CRYPTO_new_ex_data(rsa_meth,ret,&ret->ex_data);
178	return(ret);
179	}
180
181void RSA_free(RSA *r)
182	{
183	int i;
184
185	if (r == NULL) return;
186
187	i=CRYPTO_add(&r->references,-1,CRYPTO_LOCK_RSA);
188#ifdef REF_PRINT
189	REF_PRINT("RSA",r);
190#endif
191	if (i > 0) return;
192#ifdef REF_CHECK
193	if (i < 0)
194		{
195		fprintf(stderr,"RSA_free, bad reference count\n");
196		abort();
197		}
198#endif
199
200	CRYPTO_free_ex_data(rsa_meth,r,&r->ex_data);
201
202	if (r->meth->finish != NULL)
203		r->meth->finish(r);
204
205	if (r->n != NULL) BN_clear_free(r->n);
206	if (r->e != NULL) BN_clear_free(r->e);
207	if (r->d != NULL) BN_clear_free(r->d);
208	if (r->p != NULL) BN_clear_free(r->p);
209	if (r->q != NULL) BN_clear_free(r->q);
210	if (r->dmp1 != NULL) BN_clear_free(r->dmp1);
211	if (r->dmq1 != NULL) BN_clear_free(r->dmq1);
212	if (r->iqmp != NULL) BN_clear_free(r->iqmp);
213	RSA_free_thread_blinding_ptr(r);
214	if (r->bignum_data != NULL) Free_locked(r->bignum_data);
215	Free(r);
216	}
217
218int RSA_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func,
219	     CRYPTO_EX_dup *dup_func, CRYPTO_EX_free *free_func)
220        {
221	rsa_meth_num++;
222	return(CRYPTO_get_ex_new_index(rsa_meth_num-1,
223		&rsa_meth,argl,argp,new_func,dup_func,free_func));
224        }
225
226int RSA_set_ex_data(RSA *r, int idx, void *arg)
227	{
228	return(CRYPTO_set_ex_data(&r->ex_data,idx,arg));
229	}
230
231void *RSA_get_ex_data(RSA *r, int idx)
232	{
233	return(CRYPTO_get_ex_data(&r->ex_data,idx));
234	}
235
236int RSA_size(RSA *r)
237	{
238	return(BN_num_bytes(r->n));
239	}
240
241int RSA_public_encrypt(int flen, unsigned char *from, unsigned char *to,
242	     RSA *rsa, int padding)
243	{
244	return(rsa->meth->rsa_pub_enc(flen, from, to, rsa, padding));
245	}
246
247int RSA_private_encrypt(int flen, unsigned char *from, unsigned char *to,
248	     RSA *rsa, int padding)
249	{
250	return(rsa->meth->rsa_priv_enc(flen, from, to, rsa, padding));
251	}
252
253int RSA_private_decrypt(int flen, unsigned char *from, unsigned char *to,
254	     RSA *rsa, int padding)
255	{
256	return(rsa->meth->rsa_priv_dec(flen, from, to, rsa, padding));
257	}
258
259int RSA_public_decrypt(int flen, unsigned char *from, unsigned char *to,
260	     RSA *rsa, int padding)
261	{
262	return(rsa->meth->rsa_pub_dec(flen, from, to, rsa, padding));
263	}
264
265int RSA_flags(RSA *r)
266	{
267	return((r == NULL)?0:r->meth->flags);
268	}
269
270void RSA_blinding_off(RSA *rsa)
271	{
272	RSA_free_thread_blinding_ptr(rsa);
273	rsa->flags&= ~RSA_FLAG_BLINDING;
274	}
275
276int RSA_blinding_on(RSA *rsa, BN_CTX *p_ctx)
277	{
278	BIGNUM *A,*Ai;
279	BN_CTX *ctx;
280	int ret=0;
281
282	if (p_ctx == NULL)
283		{
284		if ((ctx=BN_CTX_new()) == NULL) goto err;
285		}
286	else
287		ctx=p_ctx;
288
289	RSA_free_thread_blinding_ptr(rsa);
290
291	BN_CTX_start(ctx);
292	A = BN_CTX_get(ctx);
293	if (!BN_rand(A,BN_num_bits(rsa->n)-1,1,0)) goto err;
294	if ((Ai=BN_mod_inverse(NULL,A,rsa->n,ctx)) == NULL) goto err;
295
296	if (!rsa->meth->bn_mod_exp(A,A,rsa->e,rsa->n,ctx,rsa->_method_mod_n))
297	    goto err;
298	RSA_set_thread_blinding_ptr(rsa, BN_BLINDING_new(A,Ai,rsa->n));
299	rsa->flags|=RSA_FLAG_BLINDING;
300	BN_free(Ai);
301	ret=1;
302err:
303	BN_CTX_end(ctx);
304	if (ctx != p_ctx) BN_CTX_free(ctx);
305	return(ret);
306	}
307
308int RSA_memory_lock(RSA *r)
309	{
310	int i,j,k,off;
311	char *p;
312	BIGNUM *bn,**t[6],*b;
313	BN_ULONG *ul;
314
315	if (r->d == NULL) return(1);
316	t[0]= &r->d;
317	t[1]= &r->p;
318	t[2]= &r->q;
319	t[3]= &r->dmp1;
320	t[4]= &r->dmq1;
321	t[5]= &r->iqmp;
322	k=sizeof(BIGNUM)*6;
323	off=k/sizeof(BN_ULONG)+1;
324	j=1;
325	for (i=0; i<6; i++)
326		j+= (*t[i])->top;
327	if ((p=Malloc_locked((off+j)*sizeof(BN_ULONG))) == NULL)
328		{
329		RSAerr(RSA_F_MEMORY_LOCK,ERR_R_MALLOC_FAILURE);
330		return(0);
331		}
332	bn=(BIGNUM *)p;
333	ul=(BN_ULONG *)&(p[off]);
334	for (i=0; i<6; i++)
335		{
336		b= *(t[i]);
337		*(t[i])= &(bn[i]);
338		memcpy((char *)&(bn[i]),(char *)b,sizeof(BIGNUM));
339		bn[i].flags=BN_FLG_STATIC_DATA;
340		bn[i].d=ul;
341		memcpy((char *)ul,b->d,sizeof(BN_ULONG)*b->top);
342		ul+=b->top;
343		BN_clear_free(b);
344		}
345
346	/* I should fix this so it can still be done */
347	r->flags&= ~(RSA_FLAG_CACHE_PRIVATE|RSA_FLAG_CACHE_PUBLIC);
348
349	r->bignum_data=p;
350	return(1);
351	}
352
353struct BN_BLINDING_STRUCT
354{
355	pthread_t thread_ID;
356	BN_BLINDING* blinding;
357};
358
359
360
361static struct BN_BLINDING_STRUCT* RSA_get_blinding_struct(RSA *r)
362{
363	// look for storage for the current thread
364	pthread_t current = pthread_self();
365
366	int i;
367	for (i = 0; i < r->num_blinding_threads; ++i)
368	{
369		if (pthread_equal(current, r->blinding_array[i].thread_ID)) // do we have storage for this thread?
370		{
371			return &(r->blinding_array[i]);
372			break;
373		}
374	}
375
376	return NULL;
377}
378
379typedef struct BN_BLINDING_STRUCT BN_BLINDING_STRUCT;
380
381
382BN_BLINDING* RSA_get_thread_blinding_ptr(RSA *r)
383{
384	// lock down the structure
385	pthread_mutex_lock(&r->blinding_mutex);
386
387	BN_BLINDING* result = NULL;
388	BN_BLINDING_STRUCT *st = RSA_get_blinding_struct(r);
389	if (st != NULL)
390	{
391		result = st->blinding;
392	}
393
394	pthread_mutex_unlock(&r->blinding_mutex);
395
396	return result;
397}
398
399
400
401void RSA_set_thread_blinding_ptr(RSA *r, BN_BLINDING* bnb)
402{
403	// lock down the structure
404	pthread_mutex_lock(&r->blinding_mutex);
405
406	// see if there is an existing record for this thread
407	BN_BLINDING_STRUCT *st = RSA_get_blinding_struct(r);
408	if (st == NULL)
409	{
410		// add a new blinding struct
411		int last_member = r->num_blinding_threads;
412		r->num_blinding_threads += 1;
413		r->blinding_array = (BN_BLINDING_STRUCT*) realloc(r->blinding_array, sizeof(BN_BLINDING_STRUCT) * r->num_blinding_threads);
414		st = &r->blinding_array[last_member];
415	}
416
417	st->thread_ID = pthread_self();
418	st->blinding = bnb;
419
420	pthread_mutex_unlock(&r->blinding_mutex);
421}
422
423
424
425void RSA_free_thread_blinding_ptr(RSA *r)
426{
427	// look for storage for the current thread
428	pthread_t current = pthread_self();
429
430	int i;
431	for (i = 0; i < r->num_blinding_threads; ++i)
432	{
433		if (pthread_equal(current, r->blinding_array[i].thread_ID)) // do we have storage for this thread?
434		{
435			BN_BLINDING_free(r->blinding_array[i].blinding);
436
437			int new_count = r->num_blinding_threads - 1;
438			if (new_count == 0)
439			{
440				// no more thread storage, just blow our array away
441				free(r->blinding_array);
442				r->blinding_array = NULL;
443				r->num_blinding_threads = 0;
444			}
445			else
446			{
447				r->blinding_array[i] = r->blinding_array[new_count];
448				r->num_blinding_threads = new_count;
449			}
450			break;
451		}
452	}
453}
454