Debian Codegraph @

external/boringssl/crypto/ecdsa/ecdsa.c

raw
1 /* ====================================================================
2 * Copyright (c) 1998-2005 The OpenSSL Project. All rights reserved.
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
6 * are met:
7 *
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 *
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in
13 * the documentation and/or other materials provided with the
14 * distribution.
15 *
16 * 3. All advertising materials mentioning features or use of this
17 * software must display the following acknowledgment:
18 * "This product includes software developed by the OpenSSL Project
19 * for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
20 *
21 * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
22 * endorse or promote products derived from this software without
23 * prior written permission. For written permission, please contact
24 * [email protected].
25 *
26 * 5. Products derived from this software may not be called "OpenSSL"
27 * nor may "OpenSSL" appear in their names without prior written
28 * permission of the OpenSSL Project.
29 *
30 * 6. Redistributions of any form whatsoever must retain the following
31 * acknowledgment:
32 * "This product includes software developed by the OpenSSL Project
33 * for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
34 *
35 * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
36 * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
37 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
38 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
39 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
40 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
41 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
42 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
43 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
44 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
45 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
46 * OF THE POSSIBILITY OF SUCH DAMAGE.
47 * ====================================================================
48 *
49 * This product includes cryptographic software written by Eric Young
50 * ([email protected]). This product includes software written by Tim
51 * Hudson ([email protected]). */
52
53 #include <openssl/ecdsa.h>
54
55 #include <assert.h>
56 #include <string.h>
57
58 #include <openssl/bn.h>
59 #include <openssl/bytestring.h>
60 #include <openssl/err.h>
61 #include <openssl/mem.h>
62
63 #include "../ec/internal.h"
64
65
66 int ECDSA_sign(int type, const uint8_t *digest, size_t digest_len, uint8_t *sig,
67 unsigned int *sig_len, EC_KEY *eckey) {
68 if (eckey->ecdsa_meth && eckey->ecdsa_meth->sign) {
69 return eckey->ecdsa_meth->sign(digest, digest_len, sig, sig_len, eckey);
70 }
71
72 return ECDSA_sign_ex(type, digest, digest_len, sig, sig_len, NULL, NULL,
73 eckey);
74 }
75
76 int ECDSA_verify(int type, const uint8_t *digest, size_t digest_len,
77 const uint8_t *sig, size_t sig_len, EC_KEY *eckey) {
78 ECDSA_SIG *s;
79 int ret = 0;
80 uint8_t *der = NULL;
81
82 /* Decode the ECDSA signature. */
83 s = ECDSA_SIG_from_bytes(sig, sig_len);
84 if (s == NULL) {
85 goto err;
86 }
87
88 /* Defend against potential laxness in the DER parser. */
89 size_t der_len;
90 if (!ECDSA_SIG_to_bytes(&der, &der_len, s) ||
91 der_len != sig_len || memcmp(sig, der, sig_len) != 0) {
92 /* This should never happen. crypto/bytestring is strictly DER. */
93 OPENSSL_PUT_ERROR(ECDSA, ERR_R_INTERNAL_ERROR);
94 goto err;
95 }
96
97 ret = ECDSA_do_verify(digest, digest_len, s, eckey);
98
99 err:
100 OPENSSL_free(der);
101 ECDSA_SIG_free(s);
102 return ret;
103 }
104
105 /* digest_to_bn interprets |digest_len| bytes from |digest| as a big-endian
106 * number and sets |out| to that value. It then truncates |out| so that it's,
107 * at most, as long as |order|. It returns one on success and zero otherwise. */
108 static int digest_to_bn(BIGNUM *out, const uint8_t *digest, size_t digest_len,
109 const BIGNUM *order) {
110 size_t num_bits;
111
112 num_bits = BN_num_bits(order);
113 /* Need to truncate digest if it is too long: first truncate whole
114 * bytes. */
115 if (8 * digest_len > num_bits) {
116 digest_len = (num_bits + 7) / 8;
117 }
118 if (!BN_bin2bn(digest, digest_len, out)) {
119 OPENSSL_PUT_ERROR(ECDSA, ERR_R_BN_LIB);
120 return 0;
121 }
122
123 /* If still too long truncate remaining bits with a shift */
124 if ((8 * digest_len > num_bits) &&
125 !BN_rshift(out, out, 8 - (num_bits & 0x7))) {
126 OPENSSL_PUT_ERROR(ECDSA, ERR_R_BN_LIB);
127 return 0;
128 }
129
130 return 1;
131 }
132
133 ECDSA_SIG *ECDSA_do_sign(const uint8_t *digest, size_t digest_len,
134 EC_KEY *key) {
135 return ECDSA_do_sign_ex(digest, digest_len, NULL, NULL, key);
136 }
137
138 int ECDSA_do_verify(const uint8_t *digest, size_t digest_len,
139 const ECDSA_SIG *sig, EC_KEY *eckey) {
140 int ret = 0;
141 BN_CTX *ctx;
142 BIGNUM *u1, *u2, *m, *X;
143 EC_POINT *point = NULL;
144 const EC_GROUP *group;
145 const EC_POINT *pub_key;
146
147 /* check input values */
148 if ((group = EC_KEY_get0_group(eckey)) == NULL ||
149 (pub_key = EC_KEY_get0_public_key(eckey)) == NULL ||
150 sig == NULL) {
151 OPENSSL_PUT_ERROR(ECDSA, ECDSA_R_MISSING_PARAMETERS);
152 return 0;
153 }
154
155 ctx = BN_CTX_new();
156 if (!ctx) {
157 OPENSSL_PUT_ERROR(ECDSA, ERR_R_MALLOC_FAILURE);
158 return 0;
159 }
160 BN_CTX_start(ctx);
161 u1 = BN_CTX_get(ctx);
162 u2 = BN_CTX_get(ctx);
163 m = BN_CTX_get(ctx);
164 X = BN_CTX_get(ctx);
165 if (u1 == NULL || u2 == NULL || m == NULL || X == NULL) {
166 OPENSSL_PUT_ERROR(ECDSA, ERR_R_BN_LIB);
167 goto err;
168 }
169
170 const BIGNUM *order = EC_GROUP_get0_order(group);
171 if (BN_is_zero(sig->r) || BN_is_negative(sig->r) ||
172 BN_ucmp(sig->r, order) >= 0 || BN_is_zero(sig->s) ||
173 BN_is_negative(sig->s) || BN_ucmp(sig->s, order) >= 0) {
174 OPENSSL_PUT_ERROR(ECDSA, ECDSA_R_BAD_SIGNATURE);
175 ret = 0; /* signature is invalid */
176 goto err;
177 }
178 /* calculate tmp1 = inv(S) mod order */
179 if (!BN_mod_inverse(u2, sig->s, order, ctx)) {
180 OPENSSL_PUT_ERROR(ECDSA, ERR_R_BN_LIB);
181 goto err;
182 }
183 if (!digest_to_bn(m, digest, digest_len, order)) {
184 goto err;
185 }
186 /* u1 = m * tmp mod order */
187 if (!BN_mod_mul(u1, m, u2, order, ctx)) {
188 OPENSSL_PUT_ERROR(ECDSA, ERR_R_BN_LIB);
189 goto err;
190 }
191 /* u2 = r * w mod q */
192 if (!BN_mod_mul(u2, sig->r, u2, order, ctx)) {
193 OPENSSL_PUT_ERROR(ECDSA, ERR_R_BN_LIB);
194 goto err;
195 }
196
197 point = EC_POINT_new(group);
198 if (point == NULL) {
199 OPENSSL_PUT_ERROR(ECDSA, ERR_R_MALLOC_FAILURE);
200 goto err;
201 }
202 if (!EC_POINT_mul(group, point, u1, pub_key, u2, ctx)) {
203 OPENSSL_PUT_ERROR(ECDSA, ERR_R_EC_LIB);
204 goto err;
205 }
206 if (!EC_POINT_get_affine_coordinates_GFp(group, point, X, NULL, ctx)) {
207 OPENSSL_PUT_ERROR(ECDSA, ERR_R_EC_LIB);
208 goto err;
209 }
210 if (!BN_nnmod(u1, X, order, ctx)) {
211 OPENSSL_PUT_ERROR(ECDSA, ERR_R_BN_LIB);
212 goto err;
213 }
214 /* if the signature is correct u1 is equal to sig->r */
215 ret = (BN_ucmp(u1, sig->r) == 0);
216
217 err:
218 BN_CTX_end(ctx);
219 BN_CTX_free(ctx);
220 EC_POINT_free(point);
221 return ret;
222 }
223
224 static int ecdsa_sign_setup(EC_KEY *eckey, BN_CTX *ctx_in, BIGNUM **kinvp,
225 BIGNUM **rp, const uint8_t *digest,
226 size_t digest_len) {
227 BN_CTX *ctx = NULL;
228 BIGNUM *k = NULL, *r = NULL, *X = NULL;
229 EC_POINT *tmp_point = NULL;
230 const EC_GROUP *group;
231 int ret = 0;
232
233 if (eckey == NULL || (group = EC_KEY_get0_group(eckey)) == NULL) {
234 OPENSSL_PUT_ERROR(ECDSA, ERR_R_PASSED_NULL_PARAMETER);
235 return 0;
236 }
237
238 if (ctx_in == NULL) {
239 if ((ctx = BN_CTX_new()) == NULL) {
240 OPENSSL_PUT_ERROR(ECDSA, ERR_R_MALLOC_FAILURE);
241 return 0;
242 }
243 } else {
244 ctx = ctx_in;
245 }
246
247 k = BN_new(); /* this value is later returned in *kinvp */
248 r = BN_new(); /* this value is later returned in *rp */
249 X = BN_new();
250 if (k == NULL || r == NULL || X == NULL) {
251 OPENSSL_PUT_ERROR(ECDSA, ERR_R_MALLOC_FAILURE);
252 goto err;
253 }
254 tmp_point = EC_POINT_new(group);
255 if (tmp_point == NULL) {
256 OPENSSL_PUT_ERROR(ECDSA, ERR_R_EC_LIB);
257 goto err;
258 }
259
260 const BIGNUM *order = EC_GROUP_get0_order(group);
261
262 do {
263 /* If possible, we'll include the private key and message digest in the k
264 * generation. The |digest| argument is only empty if |ECDSA_sign_setup| is
265 * being used. */
266 do {
267 int ok;
268
269 if (digest_len > 0) {
270 ok = BN_generate_dsa_nonce(k, order, EC_KEY_get0_private_key(eckey),
271 digest, digest_len, ctx);
272 } else {
273 ok = BN_rand_range(k, order);
274 }
275 if (!ok) {
276 OPENSSL_PUT_ERROR(ECDSA, ECDSA_R_RANDOM_NUMBER_GENERATION_FAILED);
277 goto err;
278 }
279 } while (BN_is_zero(k));
280
281 /* We do not want timing information to leak the length of k,
282 * so we compute G*k using an equivalent scalar of fixed
283 * bit-length. */
284
285 if (!BN_add(k, k, order)) {
286 goto err;
287 }
288 if (BN_num_bits(k) <= BN_num_bits(order)) {
289 if (!BN_add(k, k, order)) {
290 goto err;
291 }
292 }
293
294 /* compute r the x-coordinate of generator * k */
295 if (!EC_POINT_mul(group, tmp_point, k, NULL, NULL, ctx)) {
296 OPENSSL_PUT_ERROR(ECDSA, ERR_R_EC_LIB);
297 goto err;
298 }
299 if (!EC_POINT_get_affine_coordinates_GFp(group, tmp_point, X, NULL, ctx)) {
300 OPENSSL_PUT_ERROR(ECDSA, ERR_R_EC_LIB);
301 goto err;
302 }
303
304 if (!BN_nnmod(r, X, order, ctx)) {
305 OPENSSL_PUT_ERROR(ECDSA, ERR_R_BN_LIB);
306 goto err;
307 }
308 } while (BN_is_zero(r));
309
310 /* compute the inverse of k */
311 if (ec_group_get_mont_data(group) != NULL) {
312 /* We want inverse in constant time, therefore we use that the order must
313 * be prime and thus we can use Fermat's Little Theorem. */
314 if (!BN_set_word(X, 2) ||
315 !BN_sub(X, order, X)) {
316 OPENSSL_PUT_ERROR(ECDSA, ERR_R_BN_LIB);
317 goto err;
318 }
319 BN_set_flags(X, BN_FLG_CONSTTIME);
320 if (!BN_mod_exp_mont_consttime(k, k, X, order, ctx,
321 ec_group_get_mont_data(group))) {
322 OPENSSL_PUT_ERROR(ECDSA, ERR_R_BN_LIB);
323 goto err;
324 }
325 } else if (!BN_mod_inverse(k, k, order, ctx)) {
326 OPENSSL_PUT_ERROR(ECDSA, ERR_R_BN_LIB);
327 goto err;
328 }
329 /* clear old values if necessary */
330 BN_clear_free(*rp);
331 BN_clear_free(*kinvp);
332
333 /* save the pre-computed values */
334 *rp = r;
335 *kinvp = k;
336 ret = 1;
337
338 err:
339 if (!ret) {
340 BN_clear_free(k);
341 BN_clear_free(r);
342 }
343 if (ctx_in == NULL) {
344 BN_CTX_free(ctx);
345 }
346 EC_POINT_free(tmp_point);
347 BN_clear_free(X);
348 return ret;
349 }
350
351 int ECDSA_sign_setup(EC_KEY *eckey, BN_CTX *ctx, BIGNUM **kinv, BIGNUM **rp) {
352 return ecdsa_sign_setup(eckey, ctx, kinv, rp, NULL, 0);
353 }
354
355 ECDSA_SIG *ECDSA_do_sign_ex(const uint8_t *digest, size_t digest_len,
356 const BIGNUM *in_kinv, const BIGNUM *in_r,
357 EC_KEY *eckey) {
358 int ok = 0;
359 BIGNUM *kinv = NULL, *s, *m = NULL, *tmp = NULL;
360 const BIGNUM *ckinv;
361 BN_CTX *ctx = NULL;
362 const EC_GROUP *group;
363 ECDSA_SIG *ret;
364 const BIGNUM *priv_key;
365
366 if (eckey->ecdsa_meth && eckey->ecdsa_meth->sign) {
367 OPENSSL_PUT_ERROR(ECDSA, ECDSA_R_NOT_IMPLEMENTED);
368 return NULL;
369 }
370
371 group = EC_KEY_get0_group(eckey);
372 priv_key = EC_KEY_get0_private_key(eckey);
373
374 if (group == NULL || priv_key == NULL) {
375 OPENSSL_PUT_ERROR(ECDSA, ERR_R_PASSED_NULL_PARAMETER);
376 return NULL;
377 }
378
379 ret = ECDSA_SIG_new();
380 if (!ret) {
381 OPENSSL_PUT_ERROR(ECDSA, ERR_R_MALLOC_FAILURE);
382 return NULL;
383 }
384 s = ret->s;
385
386 if ((ctx = BN_CTX_new()) == NULL ||
387 (tmp = BN_new()) == NULL ||
388 (m = BN_new()) == NULL) {
389 OPENSSL_PUT_ERROR(ECDSA, ERR_R_MALLOC_FAILURE);
390 goto err;
391 }
392
393 const BIGNUM *order = EC_GROUP_get0_order(group);
394
395 if (!digest_to_bn(m, digest, digest_len, order)) {
396 goto err;
397 }
398 for (;;) {
399 if (in_kinv == NULL || in_r == NULL) {
400 if (!ecdsa_sign_setup(eckey, ctx, &kinv, &ret->r, digest, digest_len)) {
401 OPENSSL_PUT_ERROR(ECDSA, ERR_R_ECDSA_LIB);
402 goto err;
403 }
404 ckinv = kinv;
405 } else {
406 ckinv = in_kinv;
407 if (BN_copy(ret->r, in_r) == NULL) {
408 OPENSSL_PUT_ERROR(ECDSA, ERR_R_MALLOC_FAILURE);
409 goto err;
410 }
411 }
412
413 if (!BN_mod_mul(tmp, priv_key, ret->r, order, ctx)) {
414 OPENSSL_PUT_ERROR(ECDSA, ERR_R_BN_LIB);
415 goto err;
416 }
417 if (!BN_mod_add_quick(s, tmp, m, order)) {
418 OPENSSL_PUT_ERROR(ECDSA, ERR_R_BN_LIB);
419 goto err;
420 }
421 if (!BN_mod_mul(s, s, ckinv, order, ctx)) {
422 OPENSSL_PUT_ERROR(ECDSA, ERR_R_BN_LIB);
423 goto err;
424 }
425 if (BN_is_zero(s)) {
426 /* if kinv and r have been supplied by the caller
427 * don't to generate new kinv and r values */
428 if (in_kinv != NULL && in_r != NULL) {
429 OPENSSL_PUT_ERROR(ECDSA, ECDSA_R_NEED_NEW_SETUP_VALUES);
430 goto err;
431 }
432 } else {
433 /* s != 0 => we have a valid signature */
434 break;
435 }
436 }
437
438 ok = 1;
439
440 err:
441 if (!ok) {
442 ECDSA_SIG_free(ret);
443 ret = NULL;
444 }
445 BN_CTX_free(ctx);
446 BN_clear_free(m);
447 BN_clear_free(tmp);
448 BN_clear_free(kinv);
449 return ret;
450 }
451
452 int ECDSA_sign_ex(int type, const uint8_t *digest, size_t digest_len,
453 uint8_t *sig, unsigned int *sig_len, const BIGNUM *kinv,
454 const BIGNUM *r, EC_KEY *eckey) {
455 int ret = 0;
456 ECDSA_SIG *s = NULL;
457
458 if (eckey->ecdsa_meth && eckey->ecdsa_meth->sign) {
459 OPENSSL_PUT_ERROR(ECDSA, ECDSA_R_NOT_IMPLEMENTED);
460 *sig_len = 0;
461 goto err;
462 }
463
464 s = ECDSA_do_sign_ex(digest, digest_len, kinv, r, eckey);
465 if (s == NULL) {
466 *sig_len = 0;
467 goto err;
468 }
469
470 CBB cbb;
471 CBB_zero(&cbb);
472 size_t len;
473 if (!CBB_init_fixed(&cbb, sig, ECDSA_size(eckey)) ||
474 !ECDSA_SIG_marshal(&cbb, s) ||
475 !CBB_finish(&cbb, NULL, &len)) {
476 OPENSSL_PUT_ERROR(ECDSA, ECDSA_R_ENCODE_ERROR);
477 CBB_cleanup(&cbb);
478 *sig_len = 0;
479 goto err;
480 }
481 *sig_len = (unsigned)len;
482 ret = 1;
483
484 err:
485 ECDSA_SIG_free(s);
486 return ret;
487 }