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