rsa/rsa_lib.c: make RSA_security_bits multi-prime aware.
[openssl.git] / crypto / rsa / rsa_gen.c
1 /*
2  * Copyright 1995-2017 The OpenSSL Project Authors. All Rights Reserved.
3  *
4  * Licensed under the OpenSSL license (the "License").  You may not use
5  * this file except in compliance with the License.  You can obtain a copy
6  * in the file LICENSE in the source distribution or at
7  * https://www.openssl.org/source/license.html
8  */
9
10 /*
11  * NB: these functions have been "upgraded", the deprecated versions (which
12  * are compatibility wrappers using these functions) are in rsa_depr.c. -
13  * Geoff
14  */
15
16 #include <stdio.h>
17 #include <time.h>
18 #include "internal/cryptlib.h"
19 #include <openssl/bn.h>
20 #include "rsa_locl.h"
21
22 static int rsa_builtin_keygen(RSA *rsa, int bits, int primes, BIGNUM *e_value,
23                               BN_GENCB *cb);
24
25 /*
26  * NB: this wrapper would normally be placed in rsa_lib.c and the static
27  * implementation would probably be in rsa_eay.c. Nonetheless, is kept here
28  * so that we don't introduce a new linker dependency. Eg. any application
29  * that wasn't previously linking object code related to key-generation won't
30  * have to now just because key-generation is part of RSA_METHOD.
31  */
32 int RSA_generate_key_ex(RSA *rsa, int bits, BIGNUM *e_value, BN_GENCB *cb)
33 {
34     if (rsa->meth->rsa_keygen != NULL)
35         return rsa->meth->rsa_keygen(rsa, bits, e_value, cb);
36
37     return RSA_generate_multi_prime_key(rsa, bits, RSA_DEFAULT_PRIME_NUM,
38                                         e_value, cb);
39 }
40
41 int RSA_generate_multi_prime_key(RSA *rsa, int bits, int primes,
42                                  BIGNUM *e_value, BN_GENCB *cb)
43 {
44     /* multi-prime is only supported with the builtin key generation */
45     if (rsa->meth->rsa_multi_prime_keygen != NULL) {
46         return rsa->meth->rsa_multi_prime_keygen(rsa, bits, primes,
47                                                  e_value, cb);
48     } else if (rsa->meth->rsa_keygen != NULL) {
49         /*
50          * However, if rsa->meth implements only rsa_keygen, then we
51          * have to honour it in 2-prime case and assume that it wouldn't
52          * know what to do with multi-prime key generated by builtin
53          * subroutine...
54          */
55         if (primes == 2)
56             return rsa->meth->rsa_keygen(rsa, bits, e_value, cb);
57         else
58             return 0;
59     }
60
61     return rsa_builtin_keygen(rsa, bits, primes, e_value, cb);
62 }
63
64 static int rsa_builtin_keygen(RSA *rsa, int bits, int primes, BIGNUM *e_value,
65                               BN_GENCB *cb)
66 {
67     BIGNUM *r0 = NULL, *r1 = NULL, *r2 = NULL, *tmp, *prime;
68     int ok = -1, n = 0, bitsr[RSA_MAX_PRIME_NUM], bitse = 0;
69     int i = 0, quo = 0, rmd = 0, adj = 0, retries = 0;
70     RSA_PRIME_INFO *pinfo = NULL;
71     STACK_OF(RSA_PRIME_INFO) *prime_infos = NULL;
72     BN_CTX *ctx = NULL;
73     BN_ULONG bitst = 0;
74
75     /*
76      * From Github pull request #4241:
77      *
78      * We are in disagreement on how to handle security trade-off, in other
79      * words:
80      *
81      * mechanical-check-for-maximum-of-16-prime-factors vs.
82      * limiting-number-depending-on-length-less-factors-for-shorter-keys.
83      */
84
85     /*
86      * When generating ridiculously small keys, we can get stuck
87      * continually regenerating the same prime values.
88      */
89     if (bits < 16) {
90         ok = 0;             /* we set our own err */
91         RSAerr(RSA_F_RSA_BUILTIN_KEYGEN, RSA_R_KEY_SIZE_TOO_SMALL);
92         goto err;
93     }
94
95     if (primes < RSA_DEFAULT_PRIME_NUM
96         || primes > RSA_MAX_PRIME_NUM || bits <= primes) {
97         RSAerr(RSA_F_RSA_BUILTIN_KEYGEN, RSA_R_KEY_PRIME_NUM_INVALID);
98         goto err;
99     }
100
101     ctx = BN_CTX_new();
102     if (ctx == NULL)
103         goto err;
104     BN_CTX_start(ctx);
105     r0 = BN_CTX_get(ctx);
106     r1 = BN_CTX_get(ctx);
107     r2 = BN_CTX_get(ctx);
108     if (r2 == NULL)
109         goto err;
110
111     /* divide bits into 'primes' pieces evenly */
112     quo = bits / primes;
113     rmd = bits % primes;
114
115     if (primes > RSA_DEFAULT_PRIME_NUM && quo < RSA_MIN_PRIME_SIZE) {
116         /*
117          * this means primes are too many for the key bits.
118          *
119          * This only affects multi-prime keys. For normal RSA,
120          * it's limited above (bits >= 16, hence each prime >= 8).
121          *
122          * This is done in this way because the original normal
123          * RSA's behavior should not alter at least in OpenSSL 1.1.1.
124          */
125         RSAerr(RSA_F_RSA_BUILTIN_KEYGEN, RSA_R_KEY_PRIME_NUM_INVALID);
126         goto err;
127     }
128
129     for (i = 0; i < primes; i++)
130         bitsr[i] = (i < rmd) ? quo + 1 : quo;
131
132     /* We need the RSA components non-NULL */
133     if (!rsa->n && ((rsa->n = BN_new()) == NULL))
134         goto err;
135     if (!rsa->d && ((rsa->d = BN_secure_new()) == NULL))
136         goto err;
137     if (!rsa->e && ((rsa->e = BN_new()) == NULL))
138         goto err;
139     if (!rsa->p && ((rsa->p = BN_secure_new()) == NULL))
140         goto err;
141     if (!rsa->q && ((rsa->q = BN_secure_new()) == NULL))
142         goto err;
143     if (!rsa->dmp1 && ((rsa->dmp1 = BN_secure_new()) == NULL))
144         goto err;
145     if (!rsa->dmq1 && ((rsa->dmq1 = BN_secure_new()) == NULL))
146         goto err;
147     if (!rsa->iqmp && ((rsa->iqmp = BN_secure_new()) == NULL))
148         goto err;
149
150     /* initialize multi-prime components */
151     if (primes > RSA_DEFAULT_PRIME_NUM) {
152         rsa->version = RSA_ASN1_VERSION_MULTI;
153         prime_infos = sk_RSA_PRIME_INFO_new_reserve(NULL, primes - 2);
154         if (prime_infos == NULL)
155             goto err;
156         if (rsa->prime_infos != NULL) {
157             /* could this happen? */
158             sk_RSA_PRIME_INFO_pop_free(rsa->prime_infos, rsa_multip_info_free);
159         }
160         rsa->prime_infos = prime_infos;
161
162         /* prime_info from 2 to |primes| -1 */
163         for (i = 2; i < primes; i++) {
164             pinfo = rsa_multip_info_new();
165             if (pinfo == NULL)
166                 goto err;
167             (void)sk_RSA_PRIME_INFO_push(prime_infos, pinfo);
168         }
169     }
170
171     if (BN_copy(rsa->e, e_value) == NULL)
172         goto err;
173
174     /* generate p, q and other primes (if any) */
175     for (i = 0; i < primes; i++) {
176         adj = 0;
177         retries = 0;
178
179         if (i == 0) {
180             prime = rsa->p;
181         } else if (i == 1) {
182             prime = rsa->q;
183         } else {
184             pinfo = sk_RSA_PRIME_INFO_value(prime_infos, i - 2);
185             prime = pinfo->r;
186         }
187
188         for (;;) {
189  redo:
190             if (!BN_generate_prime_ex(prime, bitsr[i] + adj, 0, NULL, NULL, cb))
191                 goto err;
192             /*
193              * prime should not be equal to p, q, r_3...
194              * (those primes prior to this one)
195              */
196             {
197                 int j;
198
199                 for (j = 0; j < i; j++) {
200                     BIGNUM *prev_prime;
201
202                     if (j == 0)
203                         prev_prime = rsa->p;
204                     else if (j == 1)
205                         prev_prime = rsa->q;
206                     else
207                         prev_prime = sk_RSA_PRIME_INFO_value(prime_infos,
208                                                              j - 2)->r;
209
210                     if (!BN_cmp(prime, prev_prime)) {
211                         goto redo;
212                     }
213                 }
214             }
215             if (!BN_sub(r2, prime, BN_value_one()))
216                 goto err;
217             if (!BN_gcd(r1, r2, rsa->e, ctx))
218                 goto err;
219             if (BN_is_one(r1))
220                 break;
221             if (!BN_GENCB_call(cb, 2, n++))
222                 goto err;
223         }
224
225         bitse += bitsr[i];
226
227         /* calculate n immediately to see if it's sufficient */
228         if (i == 1) {
229             /* we get at least 2 primes */
230             if (!BN_mul(r1, rsa->p, rsa->q, ctx))
231                 goto err;
232         } else if (i != 0) {
233             /* modulus n = p * q * r_3 * r_4 ... */
234             if (!BN_mul(r1, rsa->n, prime, ctx))
235                 goto err;
236         } else {
237             /* i == 0, do nothing */
238             if (!BN_GENCB_call(cb, 3, i))
239                 goto err;
240             continue;
241         }
242         /*
243          * if |r1|, product of factors so far, is not as long as expected
244          * (by checking the first 4 bits are less than 0x9 or greater than
245          * 0xF). If so, re-generate the last prime.
246          *
247          * NOTE: This actually can't happen in two-prime case, because of
248          * the way factors are generated.
249          *
250          * Besides, another consideration is, for multi-prime case, even the
251          * length modulus is as long as expected, the modulus could start at
252          * 0x8, which could be utilized to distinguish a multi-prime private
253          * key by using the modulus in a certificate. This is also covered
254          * by checking the length should not be less than 0x9.
255          */
256         if (!BN_rshift(r2, r1, bitse - 4))
257             goto err;
258         bitst = BN_get_word(r2);
259
260         if (bitst < 0x9 || bitst > 0xF) {
261             /*
262              * For keys with more than 4 primes, we attempt longer factor to
263              * meet length requirement.
264              *
265              * Otherwise, we just re-generate the prime with the same length.
266              *
267              * This strategy has the following goals:
268              *
269              * 1. 1024-bit factors are effcient when using 3072 and 4096-bit key
270              * 2. stay the same logic with normal 2-prime key
271              */
272             bitse -= bitsr[i];
273             if (!BN_GENCB_call(cb, 2, n++))
274                 goto err;
275             if (primes > 4) {
276                 if (bitst < 0x9)
277                     adj++;
278                 else
279                     adj--;
280             } else if (retries == 4) {
281                 /*
282                  * re-generate all primes from scratch, mainly used
283                  * in 4 prime case to avoid long loop. Max retry times
284                  * is set to 4.
285                  */
286                 i = -1;
287                 bitse = 0;
288                 continue;
289             }
290             retries++;
291             goto redo;
292         }
293         /* save product of primes for further use, for multi-prime only */
294         if (i > 1 && BN_copy(pinfo->pp, rsa->n) == NULL)
295             goto err;
296         if (BN_copy(rsa->n, r1) == NULL)
297             goto err;
298         if (!BN_GENCB_call(cb, 3, i))
299             goto err;
300     }
301
302     if (BN_cmp(rsa->p, rsa->q) < 0) {
303         tmp = rsa->p;
304         rsa->p = rsa->q;
305         rsa->q = tmp;
306     }
307
308     /* calculate d */
309
310     /* p - 1 */
311     if (!BN_sub(r1, rsa->p, BN_value_one()))
312         goto err;
313     /* q - 1 */
314     if (!BN_sub(r2, rsa->q, BN_value_one()))
315         goto err;
316     /* (p - 1)(q - 1) */
317     if (!BN_mul(r0, r1, r2, ctx))
318         goto err;
319     /* multi-prime */
320     for (i = 2; i < primes; i++) {
321         pinfo = sk_RSA_PRIME_INFO_value(prime_infos, i - 2);
322         /* save r_i - 1 to pinfo->d temporarily */
323         if (!BN_sub(pinfo->d, pinfo->r, BN_value_one()))
324             goto err;
325         if (!BN_mul(r0, r0, pinfo->d, ctx))
326             goto err;
327     }
328
329     {
330         BIGNUM *pr0 = BN_new();
331
332         if (pr0 == NULL)
333             goto err;
334
335         BN_with_flags(pr0, r0, BN_FLG_CONSTTIME);
336         if (!BN_mod_inverse(rsa->d, rsa->e, pr0, ctx)) {
337             BN_free(pr0);
338             goto err;               /* d */
339         }
340         /* We MUST free pr0 before any further use of r0 */
341         BN_free(pr0);
342     }
343
344     {
345         BIGNUM *d = BN_new();
346
347         if (d == NULL)
348             goto err;
349
350         BN_with_flags(d, rsa->d, BN_FLG_CONSTTIME);
351
352         /* calculate d mod (p-1) and d mod (q - 1) */
353         if (!BN_mod(rsa->dmp1, d, r1, ctx)
354             || !BN_mod(rsa->dmq1, d, r2, ctx)) {
355             BN_free(d);
356             goto err;
357         }
358
359         /* calculate CRT exponents */
360         for (i = 2; i < primes; i++) {
361             pinfo = sk_RSA_PRIME_INFO_value(prime_infos, i - 2);
362             /* pinfo->d == r_i - 1 */
363             if (!BN_mod(pinfo->d, d, pinfo->d, ctx)) {
364                 BN_free(d);
365                 goto err;
366             }
367         }
368
369         /* We MUST free d before any further use of rsa->d */
370         BN_free(d);
371     }
372
373     {
374         BIGNUM *p = BN_new();
375
376         if (p == NULL)
377             goto err;
378         BN_with_flags(p, rsa->p, BN_FLG_CONSTTIME);
379
380         /* calculate inverse of q mod p */
381         if (!BN_mod_inverse(rsa->iqmp, rsa->q, p, ctx)) {
382             BN_free(p);
383             goto err;
384         }
385
386         /* calculate CRT coefficient for other primes */
387         for (i = 2; i < primes; i++) {
388             pinfo = sk_RSA_PRIME_INFO_value(prime_infos, i - 2);
389             BN_with_flags(p, pinfo->r, BN_FLG_CONSTTIME);
390             if (!BN_mod_inverse(pinfo->t, pinfo->pp, p, ctx)) {
391                 BN_free(p);
392                 goto err;
393             }
394         }
395
396         /* We MUST free p before any further use of rsa->p */
397         BN_free(p);
398     }
399
400     ok = 1;
401  err:
402     if (ok == -1) {
403         RSAerr(RSA_F_RSA_BUILTIN_KEYGEN, ERR_LIB_BN);
404         ok = 0;
405     }
406     if (ctx != NULL)
407         BN_CTX_end(ctx);
408     BN_CTX_free(ctx);
409     return ok;
410 }