Ensure we test all parameters for BN_FLG_CONSTTIME
[openssl.git] / crypto / bn / bn_blind.c
1 /*
2  * Copyright 1998-2016 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 #include <openssl/opensslconf.h>
11 #include "internal/cryptlib.h"
12 #include "bn_lcl.h"
13
14 #define BN_BLINDING_COUNTER     32
15
16 struct bn_blinding_st {
17     BIGNUM *A;
18     BIGNUM *Ai;
19     BIGNUM *e;
20     BIGNUM *mod;                /* just a reference */
21     CRYPTO_THREAD_ID tid;
22     int counter;
23     unsigned long flags;
24     BN_MONT_CTX *m_ctx;
25     int (*bn_mod_exp) (BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
26                        const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx);
27     CRYPTO_RWLOCK *lock;
28 };
29
30 BN_BLINDING *BN_BLINDING_new(const BIGNUM *A, const BIGNUM *Ai, BIGNUM *mod)
31 {
32     BN_BLINDING *ret = NULL;
33
34     bn_check_top(mod);
35
36     if ((ret = OPENSSL_zalloc(sizeof(*ret))) == NULL) {
37         BNerr(BN_F_BN_BLINDING_NEW, ERR_R_MALLOC_FAILURE);
38         return NULL;
39     }
40
41     ret->lock = CRYPTO_THREAD_lock_new();
42     if (ret->lock == NULL) {
43         BNerr(BN_F_BN_BLINDING_NEW, ERR_R_MALLOC_FAILURE);
44         OPENSSL_free(ret);
45         return NULL;
46     }
47
48     BN_BLINDING_set_current_thread(ret);
49
50     if (A != NULL) {
51         if ((ret->A = BN_dup(A)) == NULL)
52             goto err;
53     }
54
55     if (Ai != NULL) {
56         if ((ret->Ai = BN_dup(Ai)) == NULL)
57             goto err;
58     }
59
60     /* save a copy of mod in the BN_BLINDING structure */
61     if ((ret->mod = BN_dup(mod)) == NULL)
62         goto err;
63
64     if (BN_get_flags(mod, BN_FLG_CONSTTIME) != 0)
65         BN_set_flags(ret->mod, BN_FLG_CONSTTIME);
66
67     /*
68      * Set the counter to the special value -1 to indicate that this is
69      * never-used fresh blinding that does not need updating before first
70      * use.
71      */
72     ret->counter = -1;
73
74     return ret;
75
76  err:
77     BN_BLINDING_free(ret);
78     return NULL;
79 }
80
81 void BN_BLINDING_free(BN_BLINDING *r)
82 {
83     if (r == NULL)
84         return;
85
86     BN_free(r->A);
87     BN_free(r->Ai);
88     BN_free(r->e);
89     BN_free(r->mod);
90     CRYPTO_THREAD_lock_free(r->lock);
91     OPENSSL_free(r);
92 }
93
94 int BN_BLINDING_update(BN_BLINDING *b, BN_CTX *ctx)
95 {
96     int ret = 0;
97
98     if ((b->A == NULL) || (b->Ai == NULL)) {
99         BNerr(BN_F_BN_BLINDING_UPDATE, BN_R_NOT_INITIALIZED);
100         goto err;
101     }
102
103     if (b->counter == -1)
104         b->counter = 0;
105
106     if (++b->counter == BN_BLINDING_COUNTER && b->e != NULL &&
107         !(b->flags & BN_BLINDING_NO_RECREATE)) {
108         /* re-create blinding parameters */
109         if (!BN_BLINDING_create_param(b, NULL, NULL, ctx, NULL, NULL))
110             goto err;
111     } else if (!(b->flags & BN_BLINDING_NO_UPDATE)) {
112         if (!BN_mod_mul(b->A, b->A, b->A, b->mod, ctx))
113             goto err;
114         if (!BN_mod_mul(b->Ai, b->Ai, b->Ai, b->mod, ctx))
115             goto err;
116     }
117
118     ret = 1;
119  err:
120     if (b->counter == BN_BLINDING_COUNTER)
121         b->counter = 0;
122     return (ret);
123 }
124
125 int BN_BLINDING_convert(BIGNUM *n, BN_BLINDING *b, BN_CTX *ctx)
126 {
127     return BN_BLINDING_convert_ex(n, NULL, b, ctx);
128 }
129
130 int BN_BLINDING_convert_ex(BIGNUM *n, BIGNUM *r, BN_BLINDING *b, BN_CTX *ctx)
131 {
132     int ret = 1;
133
134     bn_check_top(n);
135
136     if ((b->A == NULL) || (b->Ai == NULL)) {
137         BNerr(BN_F_BN_BLINDING_CONVERT_EX, BN_R_NOT_INITIALIZED);
138         return (0);
139     }
140
141     if (b->counter == -1)
142         /* Fresh blinding, doesn't need updating. */
143         b->counter = 0;
144     else if (!BN_BLINDING_update(b, ctx))
145         return (0);
146
147     if (r != NULL) {
148         if (!BN_copy(r, b->Ai))
149             ret = 0;
150     }
151
152     if (!BN_mod_mul(n, n, b->A, b->mod, ctx))
153         ret = 0;
154
155     return ret;
156 }
157
158 int BN_BLINDING_invert(BIGNUM *n, BN_BLINDING *b, BN_CTX *ctx)
159 {
160     return BN_BLINDING_invert_ex(n, NULL, b, ctx);
161 }
162
163 int BN_BLINDING_invert_ex(BIGNUM *n, const BIGNUM *r, BN_BLINDING *b,
164                           BN_CTX *ctx)
165 {
166     int ret;
167
168     bn_check_top(n);
169
170     if (r != NULL)
171         ret = BN_mod_mul(n, n, r, b->mod, ctx);
172     else {
173         if (b->Ai == NULL) {
174             BNerr(BN_F_BN_BLINDING_INVERT_EX, BN_R_NOT_INITIALIZED);
175             return (0);
176         }
177         ret = BN_mod_mul(n, n, b->Ai, b->mod, ctx);
178     }
179
180     bn_check_top(n);
181     return (ret);
182 }
183
184 int BN_BLINDING_is_current_thread(BN_BLINDING *b)
185 {
186     return CRYPTO_THREAD_compare_id(CRYPTO_THREAD_get_current_id(), b->tid);
187 }
188
189 void BN_BLINDING_set_current_thread(BN_BLINDING *b)
190 {
191     b->tid = CRYPTO_THREAD_get_current_id();
192 }
193
194 int BN_BLINDING_lock(BN_BLINDING *b)
195 {
196     return CRYPTO_THREAD_write_lock(b->lock);
197 }
198
199 int BN_BLINDING_unlock(BN_BLINDING *b)
200 {
201     return CRYPTO_THREAD_unlock(b->lock);
202 }
203
204 unsigned long BN_BLINDING_get_flags(const BN_BLINDING *b)
205 {
206     return b->flags;
207 }
208
209 void BN_BLINDING_set_flags(BN_BLINDING *b, unsigned long flags)
210 {
211     b->flags = flags;
212 }
213
214 BN_BLINDING *BN_BLINDING_create_param(BN_BLINDING *b,
215                                       const BIGNUM *e, BIGNUM *m, BN_CTX *ctx,
216                                       int (*bn_mod_exp) (BIGNUM *r,
217                                                          const BIGNUM *a,
218                                                          const BIGNUM *p,
219                                                          const BIGNUM *m,
220                                                          BN_CTX *ctx,
221                                                          BN_MONT_CTX *m_ctx),
222                                       BN_MONT_CTX *m_ctx)
223 {
224     int retry_counter = 32;
225     BN_BLINDING *ret = NULL;
226
227     if (b == NULL)
228         ret = BN_BLINDING_new(NULL, NULL, m);
229     else
230         ret = b;
231
232     if (ret == NULL)
233         goto err;
234
235     if (ret->A == NULL && (ret->A = BN_new()) == NULL)
236         goto err;
237     if (ret->Ai == NULL && (ret->Ai = BN_new()) == NULL)
238         goto err;
239
240     if (e != NULL) {
241         BN_free(ret->e);
242         ret->e = BN_dup(e);
243     }
244     if (ret->e == NULL)
245         goto err;
246
247     if (bn_mod_exp != NULL)
248         ret->bn_mod_exp = bn_mod_exp;
249     if (m_ctx != NULL)
250         ret->m_ctx = m_ctx;
251
252     do {
253         int rv;
254         if (!BN_rand_range(ret->A, ret->mod))
255             goto err;
256         if (!int_bn_mod_inverse(ret->Ai, ret->A, ret->mod, ctx, &rv)) {
257             /*
258              * this should almost never happen for good RSA keys
259              */
260             if (rv) {
261                 if (retry_counter-- == 0) {
262                     BNerr(BN_F_BN_BLINDING_CREATE_PARAM,
263                           BN_R_TOO_MANY_ITERATIONS);
264                     goto err;
265                 }
266             } else
267                 goto err;
268         } else
269             break;
270     } while (1);
271
272     if (ret->bn_mod_exp != NULL && ret->m_ctx != NULL) {
273         if (!ret->bn_mod_exp
274             (ret->A, ret->A, ret->e, ret->mod, ctx, ret->m_ctx))
275             goto err;
276     } else {
277         if (!BN_mod_exp(ret->A, ret->A, ret->e, ret->mod, ctx))
278             goto err;
279     }
280
281     return ret;
282  err:
283     if (b == NULL) {
284         BN_BLINDING_free(ret);
285         ret = NULL;
286     }
287
288     return ret;
289 }