← Back to branch summary

~sbeattie/ubuntu/oneiric/openssl/lp850608

« back to all changes in this revision

Viewing changes to crypto/rsa/rsa_eng.c

  • Committer: Bazaar Package Importer
  • Author(s): Colin Watson
  • Date: 2011-05-01 23:51:53 UTC
  • mfrom: (11.1.20 sid)
  • Revision ID: james.westby@ubuntu.com-20110501235153-bjcxitndquaezb68
Tags: 1.0.0d-2ubuntu1
https://launchpad.net/bugs/675566
* Resynchronise with Debian (LP: #675566).  Remaining changes:
  - debian/libssl1.0.0.postinst:
    + Display a system restart required notification bubble on libssl1.0.0
      upgrade.
    + Use a different priority for libssl1.0.0/restart-services depending
      on whether a desktop, or server dist-upgrade is being performed.
  - debian/{libssl1.0.0-udeb.dirs, control, rules}: Create
    libssl1.0.0-udeb, for the benefit of wget-udeb (no wget-udeb package
    in Debian).
  - debian/{libcrypto1.0.0-udeb.dirs, libssl1.0.0.dirs, libssl1.0.0.files,
    rules}: Move runtime libraries to /lib, for the benefit of
    wpasupplicant.
  - debian/patches/aesni.patch: Backport Intel AES-NI support, now from
    http://rt.openssl.org/Ticket/Display.html?id=2065 rather than the
    0.9.8 variant.
  - debian/patches/Bsymbolic-functions.patch: Link using
    -Bsymbolic-functions.
  - debian/patches/perlpath-quilt.patch: Don't change perl #! paths under
    .pc.
  - debian/rules:
    + Don't run 'make test' when cross-building.
    + Use host compiler when cross-building.  Patch from Neil Williams.
    + Don't build for processors no longer supported: i486, i586 (on
      i386), v8 (on sparc).
    + Fix Makefile to properly clean up libs/ dirs in clean target.
    + Replace duplicate files in the doc directory with symlinks.
* Update architectures affected by Bsymbolic-functions.patch.
* Drop debian/patches/no-sslv2.patch; Debian now adds the 'no-ssl2'
  configure option, which compiles out SSLv2 support entirely, so this is
  no longer needed.
* Drop openssl-doc in favour of the libssl-doc package introduced by
  Debian.  Add Conflicts/Replaces until the next LTS release.

Show diffs side-by-side

added added

removed removed

Lines of Context:
crypto/rsa/rsa_eng.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
 
#include <openssl/rand.h>
66
 
#ifndef OPENSSL_NO_ENGINE
67
 
#include <openssl/engine.h>
68
 
#endif
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
 
#ifdef OPENSSL_FIPS
84
 
        if (FIPS_mode() && !(meth->flags & RSA_FLAG_FIPS_METHOD))
85
 
                {
86
 
                RSAerr(RSA_F_RSA_SET_DEFAULT_METHOD, RSA_R_NON_FIPS_METHOD);
87
 
                return;
88
 
                }
89
 
#endif
90
 
        default_RSA_meth = meth;
91
 
        }
92
 
 
93
 
const RSA_METHOD *RSA_get_default_method(void)
94
 
        {
95
 
        if (default_RSA_meth == NULL)
96
 
                {
97
 
#ifdef RSA_NULL
98
 
                default_RSA_meth=RSA_null_method();
99
 
#else
100
 
#if 0 /* was: #ifdef RSAref */
101
 
                default_RSA_meth=RSA_PKCS1_RSAref();
102
 
#else
103
 
                default_RSA_meth=RSA_PKCS1_SSLeay();
104
 
#endif
105
 
#endif
106
 
                }
107
 
 
108
 
        return default_RSA_meth;
109
 
        }
110
 
 
111
 
const RSA_METHOD *RSA_get_method(const RSA *rsa)
112
 
        {
113
 
        return rsa->meth;
114
 
        }
115
 
 
116
 
int RSA_set_method(RSA *rsa, const RSA_METHOD *meth)
117
 
        {
118
 
        /* NB: The caller is specifically setting a method, so it's not up to us
119
 
         * to deal with which ENGINE it comes from. */
120
 
        const RSA_METHOD *mtmp;
121
 
#ifdef OPENSSL_FIPS
122
 
        if (FIPS_mode() && !(meth->flags & RSA_FLAG_FIPS_METHOD))
123
 
                {
124
 
                RSAerr(RSA_F_RSA_SET_METHOD, RSA_R_NON_FIPS_METHOD);
125
 
                return 0;
126
 
                }
127
 
#endif
128
 
        mtmp = rsa->meth;
129
 
        if (mtmp->finish) mtmp->finish(rsa);
130
 
#ifndef OPENSSL_NO_ENGINE
131
 
        if (rsa->engine)
132
 
                {
133
 
                ENGINE_finish(rsa->engine);
134
 
                rsa->engine = NULL;
135
 
                }
136
 
#endif
137
 
        rsa->meth = meth;
138
 
        if (meth->init) meth->init(rsa);
139
 
        return 1;
140
 
        }
141
 
 
142
 
RSA *RSA_new_method(ENGINE *engine)
143
 
        {
144
 
        RSA *ret;
145
 
 
146
 
        ret=(RSA *)OPENSSL_malloc(sizeof(RSA));
147
 
        if (ret == NULL)
148
 
                {
149
 
                RSAerr(RSA_F_RSA_NEW_METHOD,ERR_R_MALLOC_FAILURE);
150
 
                return NULL;
151
 
                }
152
 
 
153
 
        ret->meth = RSA_get_default_method();
154
 
#ifndef OPENSSL_NO_ENGINE
155
 
        if (engine)
156
 
                {
157
 
                if (!ENGINE_init(engine))
158
 
                        {
159
 
                        RSAerr(RSA_F_RSA_NEW_METHOD, ERR_R_ENGINE_LIB);
160
 
                        OPENSSL_free(ret);
161
 
                        return NULL;
162
 
                        }
163
 
                ret->engine = engine;
164
 
                }
165
 
        else
166
 
                ret->engine = ENGINE_get_default_RSA();
167
 
        if(ret->engine)
168
 
                {
169
 
                ret->meth = ENGINE_get_RSA(ret->engine);
170
 
                if(!ret->meth)
171
 
                        {
172
 
                        RSAerr(RSA_F_RSA_NEW_METHOD,
173
 
                                ERR_R_ENGINE_LIB);
174
 
                        ENGINE_finish(ret->engine);
175
 
                        OPENSSL_free(ret);
176
 
                        return NULL;
177
 
                        }
178
 
                }
179
 
#endif
180
 
#ifdef OPENSSL_FIPS
181
 
        if (FIPS_mode() && !(ret->meth->flags & RSA_FLAG_FIPS_METHOD))
182
 
                {
183
 
                RSAerr(RSA_F_RSA_NEW_METHOD, RSA_R_NON_FIPS_METHOD);
184
 
#ifndef OPENSSL_NO_ENGINE
185
 
                if (ret->engine)
186
 
                        ENGINE_finish(ret->engine);
187
 
#endif
188
 
                OPENSSL_free(ret);
189
 
                return NULL;
190
 
                }
191
 
#endif
192
 
 
193
 
        ret->pad=0;
194
 
        ret->version=0;
195
 
        ret->n=NULL;
196
 
        ret->e=NULL;
197
 
        ret->d=NULL;
198
 
        ret->p=NULL;
199
 
        ret->q=NULL;
200
 
        ret->dmp1=NULL;
201
 
        ret->dmq1=NULL;
202
 
        ret->iqmp=NULL;
203
 
        ret->references=1;
204
 
        ret->_method_mod_n=NULL;
205
 
        ret->_method_mod_p=NULL;
206
 
        ret->_method_mod_q=NULL;
207
 
        ret->blinding=NULL;
208
 
        ret->mt_blinding=NULL;
209
 
        ret->bignum_data=NULL;
210
 
        ret->flags=ret->meth->flags & ~RSA_FLAG_NON_FIPS_ALLOW;
211
 
        if (!CRYPTO_new_ex_data(CRYPTO_EX_INDEX_RSA, ret, &ret->ex_data))
212
 
                {
213
 
#ifndef OPENSSL_NO_ENGINE
214
 
        if (ret->engine)
215
 
                ENGINE_finish(ret->engine);
216
 
#endif
217
 
                OPENSSL_free(ret);
218
 
                return(NULL);
219
 
                }
220
 
 
221
 
        if ((ret->meth->init != NULL) && !ret->meth->init(ret))
222
 
                {
223
 
#ifndef OPENSSL_NO_ENGINE
224
 
                if (ret->engine)
225
 
                        ENGINE_finish(ret->engine);
226
 
#endif
227
 
                CRYPTO_free_ex_data(CRYPTO_EX_INDEX_RSA, ret, &ret->ex_data);
228
 
                OPENSSL_free(ret);
229
 
                ret=NULL;
230
 
                }
231
 
        return(ret);
232
 
        }
233
 
 
234
 
void RSA_free(RSA *r)
235
 
        {
236
 
        int i;
237
 
 
238
 
        if (r == NULL) return;
239
 
 
240
 
        i=CRYPTO_add(&r->references,-1,CRYPTO_LOCK_RSA);
241
 
#ifdef REF_PRINT
242
 
        REF_PRINT("RSA",r);
243
 
#endif
244
 
        if (i > 0) return;
245
 
#ifdef REF_CHECK
246
 
        if (i < 0)
247
 
                {
248
 
                fprintf(stderr,"RSA_free, bad reference count\n");
249
 
                abort();
250
 
                }
251
 
#endif
252
 
 
253
 
        if (r->meth->finish)
254
 
                r->meth->finish(r);
255
 
#ifndef OPENSSL_NO_ENGINE
256
 
        if (r->engine)
257
 
                ENGINE_finish(r->engine);
258
 
#endif
259
 
 
260
 
        CRYPTO_free_ex_data(CRYPTO_EX_INDEX_RSA, r, &r->ex_data);
261
 
 
262
 
        if (r->n != NULL) BN_clear_free(r->n);
263
 
        if (r->e != NULL) BN_clear_free(r->e);
264
 
        if (r->d != NULL) BN_clear_free(r->d);
265
 
        if (r->p != NULL) BN_clear_free(r->p);
266
 
        if (r->q != NULL) BN_clear_free(r->q);
267
 
        if (r->dmp1 != NULL) BN_clear_free(r->dmp1);
268
 
        if (r->dmq1 != NULL) BN_clear_free(r->dmq1);
269
 
        if (r->iqmp != NULL) BN_clear_free(r->iqmp);
270
 
        if (r->blinding != NULL) BN_BLINDING_free(r->blinding);
271
 
        if (r->mt_blinding != NULL) BN_BLINDING_free(r->mt_blinding);
272
 
        if (r->bignum_data != NULL) OPENSSL_free_locked(r->bignum_data);
273
 
        OPENSSL_free(r);
274
 
        }
275
 
 
276
 
int RSA_up_ref(RSA *r)
277
 
        {
278
 
        int i = CRYPTO_add(&r->references, 1, CRYPTO_LOCK_RSA);
279
 
#ifdef REF_PRINT
280
 
        REF_PRINT("RSA",r);
281
 
#endif
282
 
#ifdef REF_CHECK
283
 
        if (i < 2)
284
 
                {
285
 
                fprintf(stderr, "RSA_up_ref, bad reference count\n");
286
 
                abort();
287
 
                }
288
 
#endif
289
 
        return ((i > 1) ? 1 : 0);
290
 
        }
291
 
 
292
 
int RSA_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func,
293
 
             CRYPTO_EX_dup *dup_func, CRYPTO_EX_free *free_func)
294
 
        {
295
 
        return CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_RSA, argl, argp,
296
 
                                new_func, dup_func, free_func);
297
 
        }
298
 
 
299
 
int RSA_set_ex_data(RSA *r, int idx, void *arg)
300
 
        {
301
 
        return(CRYPTO_set_ex_data(&r->ex_data,idx,arg));
302
 
        }
303
 
 
304
 
void *RSA_get_ex_data(const RSA *r, int idx)
305
 
        {
306
 
        return(CRYPTO_get_ex_data(&r->ex_data,idx));
307
 
        }
308
 
 
309
 
int RSA_flags(const RSA *r)
310
 
        {
311
 
        return((r == NULL)?0:r->meth->flags);
312
 
        }
313
 
 
314
 
int RSA_memory_lock(RSA *r)
315
 
        {
316
 
        int i,j,k,off;
317
 
        char *p;
318
 
        BIGNUM *bn,**t[6],*b;
319
 
        BN_ULONG *ul;
320
 
 
321
 
        if (r->d == NULL) return(1);
322
 
        t[0]= &r->d;
323
 
        t[1]= &r->p;
324
 
        t[2]= &r->q;
325
 
        t[3]= &r->dmp1;
326
 
        t[4]= &r->dmq1;
327
 
        t[5]= &r->iqmp;
328
 
        k=sizeof(BIGNUM)*6;
329
 
        off=k/sizeof(BN_ULONG)+1;
330
 
        j=1;
331
 
        for (i=0; i<6; i++)
332
 
                j+= (*t[i])->top;
333
 
        if ((p=OPENSSL_malloc_locked((off+j)*sizeof(BN_ULONG))) == NULL)
334
 
                {
335
 
                RSAerr(RSA_F_RSA_MEMORY_LOCK,ERR_R_MALLOC_FAILURE);
336
 
                return(0);
337
 
                }
338
 
        bn=(BIGNUM *)p;
339
 
        ul=(BN_ULONG *)&(p[off]);
340
 
        for (i=0; i<6; i++)
341
 
                {
342
 
                b= *(t[i]);
343
 
                *(t[i])= &(bn[i]);
344
 
                memcpy((char *)&(bn[i]),(char *)b,sizeof(BIGNUM));
345
 
                bn[i].flags=BN_FLG_STATIC_DATA;
346
 
                bn[i].d=ul;
347
 
                memcpy((char *)ul,b->d,sizeof(BN_ULONG)*b->top);
348
 
                ul+=b->top;
349
 
                BN_clear_free(b);
350
 
                }
351
 
        
352
 
        /* I should fix this so it can still be done */
353
 
        r->flags&= ~(RSA_FLAG_CACHE_PRIVATE|RSA_FLAG_CACHE_PUBLIC);
354
 
 
355
 
        r->bignum_data=p;
356
 
        return(1);
357
 
        }