← Back to branch summary

~ubuntu-branches/ubuntu/lucid/openssl/lucid-proposed

« back to all changes in this revision

Viewing changes to crypto/rsa/rsa_lib.c

  • Committer: Bazaar Package Importer
  • Author(s): Kurt Roeckx
  • Date: 2009-06-13 18:15:46 UTC
  • mto: (11.1.5 squeeze)
  • mto: This revision was merged to the branch mainline in revision 34.
  • Revision ID: james.westby@ubuntu.com-20090613181546-vbfntai3b009dl1u
Tags: upstream-0.9.8k
Import upstream version 0.9.8k

Show diffs side-by-side

added added

removed removed

Lines of Context:
crypto/rsa/rsa_lib.c
67
67
#include <openssl/engine.h>
68
68
#endif
69
69
 
70
 
const char RSA_version[]="RSA" OPENSSL_VERSION_PTEXT;
71
 
 
72
 
static const RSA_METHOD *default_RSA_meth=NULL;
73
 
 
74
 
RSA *RSA_new(void)
75
 
        {
76
 
        RSA *r=RSA_new_method(NULL);
77
 
 
78
 
        return r;
79
 
        }
80
 
 
81
 
void RSA_set_default_method(const RSA_METHOD *meth)
82
 
        {
83
 
        default_RSA_meth = meth;
84
 
        }
85
 
 
86
 
const RSA_METHOD *RSA_get_default_method(void)
87
 
        {
88
 
        if (default_RSA_meth == NULL)
89
 
                {
90
 
#ifdef RSA_NULL
91
 
                default_RSA_meth=RSA_null_method();
92
 
#else
93
 
#if 0 /* was: #ifdef RSAref */
94
 
                default_RSA_meth=RSA_PKCS1_RSAref();
95
 
#else
96
 
                default_RSA_meth=RSA_PKCS1_SSLeay();
97
 
#endif
98
 
#endif
99
 
                }
100
 
 
101
 
        return default_RSA_meth;
102
 
        }
103
 
 
104
 
const RSA_METHOD *RSA_get_method(const RSA *rsa)
105
 
        {
106
 
        return rsa->meth;
107
 
        }
108
 
 
109
 
int RSA_set_method(RSA *rsa, const RSA_METHOD *meth)
110
 
        {
111
 
        /* NB: The caller is specifically setting a method, so it's not up to us
112
 
         * to deal with which ENGINE it comes from. */
113
 
        const RSA_METHOD *mtmp;
114
 
        mtmp = rsa->meth;
115
 
        if (mtmp->finish) mtmp->finish(rsa);
116
 
#ifndef OPENSSL_NO_ENGINE
117
 
        if (rsa->engine)
118
 
                {
119
 
                ENGINE_finish(rsa->engine);
120
 
                rsa->engine = NULL;
121
 
                }
122
 
#endif
123
 
        rsa->meth = meth;
124
 
        if (meth->init) meth->init(rsa);
125
 
        return 1;
126
 
        }
127
 
 
128
 
RSA *RSA_new_method(ENGINE *engine)
129
 
        {
130
 
        RSA *ret;
131
 
 
132
 
        ret=(RSA *)OPENSSL_malloc(sizeof(RSA));
133
 
        if (ret == NULL)
134
 
                {
135
 
                RSAerr(RSA_F_RSA_NEW_METHOD,ERR_R_MALLOC_FAILURE);
136
 
                return NULL;
137
 
                }
138
 
 
139
 
        ret->meth = RSA_get_default_method();
140
 
#ifndef OPENSSL_NO_ENGINE
141
 
        if (engine)
142
 
                {
143
 
                if (!ENGINE_init(engine))
144
 
                        {
145
 
                        RSAerr(RSA_F_RSA_NEW_METHOD, ERR_R_ENGINE_LIB);
146
 
                        OPENSSL_free(ret);
147
 
                        return NULL;
148
 
                        }
149
 
                ret->engine = engine;
150
 
                }
151
 
        else
152
 
                ret->engine = ENGINE_get_default_RSA();
153
 
        if(ret->engine)
154
 
                {
155
 
                ret->meth = ENGINE_get_RSA(ret->engine);
156
 
                if(!ret->meth)
157
 
                        {
158
 
                        RSAerr(RSA_F_RSA_NEW_METHOD,
159
 
                                ERR_R_ENGINE_LIB);
160
 
                        ENGINE_finish(ret->engine);
161
 
                        OPENSSL_free(ret);
162
 
                        return NULL;
163
 
                        }
164
 
                }
165
 
#endif
166
 
 
167
 
        ret->pad=0;
168
 
        ret->version=0;
169
 
        ret->n=NULL;
170
 
        ret->e=NULL;
171
 
        ret->d=NULL;
172
 
        ret->p=NULL;
173
 
        ret->q=NULL;
174
 
        ret->dmp1=NULL;
175
 
        ret->dmq1=NULL;
176
 
        ret->iqmp=NULL;
177
 
        ret->references=1;
178
 
        ret->_method_mod_n=NULL;
179
 
        ret->_method_mod_p=NULL;
180
 
        ret->_method_mod_q=NULL;
181
 
        ret->blinding=NULL;
182
 
        ret->mt_blinding=NULL;
183
 
        ret->bignum_data=NULL;
184
 
        ret->flags=ret->meth->flags;
185
 
        CRYPTO_new_ex_data(CRYPTO_EX_INDEX_RSA, ret, &ret->ex_data);
186
 
        if ((ret->meth->init != NULL) && !ret->meth->init(ret))
187
 
                {
188
 
#ifndef OPENSSL_NO_ENGINE
189
 
                if (ret->engine)
190
 
                        ENGINE_finish(ret->engine);
191
 
#endif
192
 
                CRYPTO_free_ex_data(CRYPTO_EX_INDEX_RSA, ret, &ret->ex_data);
193
 
                OPENSSL_free(ret);
194
 
                ret=NULL;
195
 
                }
196
 
        return(ret);
197
 
        }
198
 
 
199
 
void RSA_free(RSA *r)
200
 
        {
201
 
        int i;
202
 
 
203
 
        if (r == NULL) return;
204
 
 
205
 
        i=CRYPTO_add(&r->references,-1,CRYPTO_LOCK_RSA);
206
 
#ifdef REF_PRINT
207
 
        REF_PRINT("RSA",r);
208
 
#endif
209
 
        if (i > 0) return;
210
 
#ifdef REF_CHECK
211
 
        if (i < 0)
212
 
                {
213
 
                fprintf(stderr,"RSA_free, bad reference count\n");
214
 
                abort();
215
 
                }
216
 
#endif
217
 
 
218
 
        if (r->meth->finish)
219
 
                r->meth->finish(r);
220
 
#ifndef OPENSSL_NO_ENGINE
221
 
        if (r->engine)
222
 
                ENGINE_finish(r->engine);
223
 
#endif
224
 
 
225
 
        CRYPTO_free_ex_data(CRYPTO_EX_INDEX_RSA, r, &r->ex_data);
226
 
 
227
 
        if (r->n != NULL) BN_clear_free(r->n);
228
 
        if (r->e != NULL) BN_clear_free(r->e);
229
 
        if (r->d != NULL) BN_clear_free(r->d);
230
 
        if (r->p != NULL) BN_clear_free(r->p);
231
 
        if (r->q != NULL) BN_clear_free(r->q);
232
 
        if (r->dmp1 != NULL) BN_clear_free(r->dmp1);
233
 
        if (r->dmq1 != NULL) BN_clear_free(r->dmq1);
234
 
        if (r->iqmp != NULL) BN_clear_free(r->iqmp);
235
 
        if (r->blinding != NULL) BN_BLINDING_free(r->blinding);
236
 
        if (r->mt_blinding != NULL) BN_BLINDING_free(r->mt_blinding);
237
 
        if (r->bignum_data != NULL) OPENSSL_free_locked(r->bignum_data);
238
 
        OPENSSL_free(r);
239
 
        }
240
 
 
241
 
int RSA_up_ref(RSA *r)
242
 
        {
243
 
        int i = CRYPTO_add(&r->references, 1, CRYPTO_LOCK_RSA);
244
 
#ifdef REF_PRINT
245
 
        REF_PRINT("RSA",r);
246
 
#endif
247
 
#ifdef REF_CHECK
248
 
        if (i < 2)
249
 
                {
250
 
                fprintf(stderr, "RSA_up_ref, bad reference count\n");
251
 
                abort();
252
 
                }
253
 
#endif
254
 
        return ((i > 1) ? 1 : 0);
255
 
        }
256
 
 
257
 
int RSA_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func,
258
 
             CRYPTO_EX_dup *dup_func, CRYPTO_EX_free *free_func)
259
 
        {
260
 
        return CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_RSA, argl, argp,
261
 
                                new_func, dup_func, free_func);
262
 
        }
263
 
 
264
 
int RSA_set_ex_data(RSA *r, int idx, void *arg)
265
 
        {
266
 
        return(CRYPTO_set_ex_data(&r->ex_data,idx,arg));
267
 
        }
268
 
 
269
 
void *RSA_get_ex_data(const RSA *r, int idx)
270
 
        {
271
 
        return(CRYPTO_get_ex_data(&r->ex_data,idx));
272
 
        }
273
 
 
274
 
int RSA_size(const RSA *r)
275
 
        {
276
 
        return(BN_num_bytes(r->n));
277
 
        }
278
 
 
279
70
int RSA_public_encrypt(int flen, const unsigned char *from, unsigned char *to,
280
71
             RSA *rsa, int padding)
281
72
        {
285
76
int RSA_private_encrypt(int flen, const unsigned char *from, unsigned char *to,
286
77
             RSA *rsa, int padding)
287
78
        {
 
79
#ifdef OPENSSL_FIPS
 
80
        if(FIPS_mode() && !(rsa->flags & RSA_FLAG_NON_FIPS_ALLOW))
 
81
                {
 
82
                RSAerr(RSA_F_RSA_PRIVATE_ENCRYPT, RSA_R_OPERATION_NOT_ALLOWED_IN_FIPS_MODE);
 
83
                return 0;
 
84
                }
 
85
#endif
288
86
        return(rsa->meth->rsa_priv_enc(flen, from, to, rsa, padding));
289
87
        }
290
88
 
297
95
int RSA_public_decrypt(int flen, const unsigned char *from, unsigned char *to,
298
96
             RSA *rsa, int padding)
299
97
        {
 
98
#ifdef OPENSSL_FIPS
 
99
        if(FIPS_mode() && !(rsa->flags & RSA_FLAG_NON_FIPS_ALLOW))
 
100
                {
 
101
                RSAerr(RSA_F_RSA_PUBLIC_DECRYPT, RSA_R_OPERATION_NOT_ALLOWED_IN_FIPS_MODE);
 
102
                return 0;
 
103
                }
 
104
#endif
300
105
        return(rsa->meth->rsa_pub_dec(flen, from, to, rsa, padding));
301
106
        }
302
107
 
303
 
int RSA_flags(const RSA *r)
 
108
int RSA_size(const RSA *r)
304
109
        {
305
 
        return((r == NULL)?0:r->meth->flags);
 
110
        return(BN_num_bytes(r->n));
306
111
        }
307
112
 
308
113
void RSA_blinding_off(RSA *rsa)
427
232
 
428
233
        return ret;
429
234
}
430
 
 
431
 
int RSA_memory_lock(RSA *r)
432
 
        {
433
 
        int i,j,k,off;
434
 
        char *p;
435
 
        BIGNUM *bn,**t[6],*b;
436
 
        BN_ULONG *ul;
437
 
 
438
 
        if (r->d == NULL) return(1);
439
 
        t[0]= &r->d;
440
 
        t[1]= &r->p;
441
 
        t[2]= &r->q;
442
 
        t[3]= &r->dmp1;
443
 
        t[4]= &r->dmq1;
444
 
        t[5]= &r->iqmp;
445
 
        k=sizeof(BIGNUM)*6;
446
 
        off=k/sizeof(BN_ULONG)+1;
447
 
        j=1;
448
 
        for (i=0; i<6; i++)
449
 
                j+= (*t[i])->top;
450
 
        if ((p=OPENSSL_malloc_locked((off+j)*sizeof(BN_ULONG))) == NULL)
451
 
                {
452
 
                RSAerr(RSA_F_RSA_MEMORY_LOCK,ERR_R_MALLOC_FAILURE);
453
 
                return(0);
454
 
                }
455
 
        bn=(BIGNUM *)p;
456
 
        ul=(BN_ULONG *)&(p[off]);
457
 
        for (i=0; i<6; i++)
458
 
                {
459
 
                b= *(t[i]);
460
 
                *(t[i])= &(bn[i]);
461
 
                memcpy((char *)&(bn[i]),(char *)b,sizeof(BIGNUM));
462
 
                bn[i].flags=BN_FLG_STATIC_DATA;
463
 
                bn[i].d=ul;
464
 
                memcpy((char *)ul,b->d,sizeof(BN_ULONG)*b->top);
465
 
                ul+=b->top;
466
 
                BN_clear_free(b);
467
 
                }
468
 
        
469
 
        /* I should fix this so it can still be done */
470
 
        r->flags&= ~(RSA_FLAG_CACHE_PRIVATE|RSA_FLAG_CACHE_PUBLIC);
471
 
 
472
 
        r->bignum_data=p;
473
 
        return(1);
474
 
        }