47feede54bc26ae8b9c1a9d120f803d1cf8344b7
[openssl.git] / crypto / ec / ec_key.c
1 /*
2  * Copyright 2002-2020 The OpenSSL Project Authors. All Rights Reserved.
3  * Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved
4  *
5  * Licensed under the Apache License 2.0 (the "License").  You may not use
6  * this file except in compliance with the License.  You can obtain a copy
7  * in the file LICENSE in the source distribution or at
8  * https://www.openssl.org/source/license.html
9  */
10
11 /*
12  * ECDSA low level APIs are deprecated for public use, but still ok for
13  * internal use.
14  */
15 #include "internal/deprecated.h"
16
17 #include "internal/cryptlib.h"
18 #include <string.h>
19 #include "ec_local.h"
20 #include "internal/refcount.h"
21 #include <openssl/err.h>
22 #include <openssl/engine.h>
23 #include <openssl/self_test.h>
24 #include "crypto/bn.h"
25
26 static int ecdsa_keygen_pairwise_test(EC_KEY *eckey, OSSL_CALLBACK *cb,
27                                       void *cbarg);
28
29 #ifndef FIPS_MODULE
30 EC_KEY *EC_KEY_new(void)
31 {
32     return ec_key_new_method_int(NULL, NULL);
33 }
34 #endif
35
36 EC_KEY *EC_KEY_new_ex(OPENSSL_CTX *ctx)
37 {
38     return ec_key_new_method_int(ctx, NULL);
39 }
40
41 EC_KEY *EC_KEY_new_by_curve_name_ex(OPENSSL_CTX *ctx, int nid)
42 {
43     EC_KEY *ret = EC_KEY_new_ex(ctx);
44     if (ret == NULL)
45         return NULL;
46     ret->group = EC_GROUP_new_by_curve_name_ex(ctx, nid);
47     if (ret->group == NULL) {
48         EC_KEY_free(ret);
49         return NULL;
50     }
51     if (ret->meth->set_group != NULL
52         && ret->meth->set_group(ret, ret->group) == 0) {
53         EC_KEY_free(ret);
54         return NULL;
55     }
56     return ret;
57 }
58
59 #ifndef FIPS_MODULE
60 EC_KEY *EC_KEY_new_by_curve_name(int nid)
61 {
62     return EC_KEY_new_by_curve_name_ex(NULL, nid);
63 }
64 #endif
65
66 void EC_KEY_free(EC_KEY *r)
67 {
68     int i;
69
70     if (r == NULL)
71         return;
72
73     CRYPTO_DOWN_REF(&r->references, &i, r->lock);
74     REF_PRINT_COUNT("EC_KEY", r);
75     if (i > 0)
76         return;
77     REF_ASSERT_ISNT(i < 0);
78
79     if (r->meth != NULL && r->meth->finish != NULL)
80         r->meth->finish(r);
81
82 #if !defined(OPENSSL_NO_ENGINE) && !defined(FIPS_MODULE)
83     ENGINE_finish(r->engine);
84 #endif
85
86     if (r->group && r->group->meth->keyfinish)
87         r->group->meth->keyfinish(r);
88
89 #ifndef FIPS_MODULE
90     CRYPTO_free_ex_data(CRYPTO_EX_INDEX_EC_KEY, r, &r->ex_data);
91 #endif
92     CRYPTO_THREAD_lock_free(r->lock);
93     EC_GROUP_free(r->group);
94     EC_POINT_free(r->pub_key);
95     BN_clear_free(r->priv_key);
96
97     OPENSSL_clear_free((void *)r, sizeof(EC_KEY));
98 }
99
100 EC_KEY *EC_KEY_copy(EC_KEY *dest, const EC_KEY *src)
101 {
102     if (dest == NULL || src == NULL) {
103         ECerr(EC_F_EC_KEY_COPY, ERR_R_PASSED_NULL_PARAMETER);
104         return NULL;
105     }
106     if (src->meth != dest->meth) {
107         if (dest->meth->finish != NULL)
108             dest->meth->finish(dest);
109         if (dest->group && dest->group->meth->keyfinish)
110             dest->group->meth->keyfinish(dest);
111 #if !defined(OPENSSL_NO_ENGINE) && !defined(FIPS_MODULE)
112         if (ENGINE_finish(dest->engine) == 0)
113             return 0;
114         dest->engine = NULL;
115 #endif
116     }
117     dest->libctx = src->libctx;
118     /* copy the parameters */
119     if (src->group != NULL) {
120         /* clear the old group */
121         EC_GROUP_free(dest->group);
122         dest->group = ec_group_new_ex(src->libctx, src->group->meth);
123         if (dest->group == NULL)
124             return NULL;
125         if (!EC_GROUP_copy(dest->group, src->group))
126             return NULL;
127
128         /*  copy the public key */
129         if (src->pub_key != NULL) {
130             EC_POINT_free(dest->pub_key);
131             dest->pub_key = EC_POINT_new(src->group);
132             if (dest->pub_key == NULL)
133                 return NULL;
134             if (!EC_POINT_copy(dest->pub_key, src->pub_key))
135                 return NULL;
136         }
137         /* copy the private key */
138         if (src->priv_key != NULL) {
139             if (dest->priv_key == NULL) {
140                 dest->priv_key = BN_new();
141                 if (dest->priv_key == NULL)
142                     return NULL;
143             }
144             if (!BN_copy(dest->priv_key, src->priv_key))
145                 return NULL;
146             if (src->group->meth->keycopy
147                 && src->group->meth->keycopy(dest, src) == 0)
148                 return NULL;
149         }
150     }
151
152
153     /* copy the rest */
154     dest->enc_flag = src->enc_flag;
155     dest->conv_form = src->conv_form;
156     dest->version = src->version;
157     dest->flags = src->flags;
158 #ifndef FIPS_MODULE
159     if (!CRYPTO_dup_ex_data(CRYPTO_EX_INDEX_EC_KEY,
160                             &dest->ex_data, &src->ex_data))
161         return NULL;
162 #endif
163
164     if (src->meth != dest->meth) {
165 #if !defined(OPENSSL_NO_ENGINE) && !defined(FIPS_MODULE)
166         if (src->engine != NULL && ENGINE_init(src->engine) == 0)
167             return NULL;
168         dest->engine = src->engine;
169 #endif
170         dest->meth = src->meth;
171     }
172
173     if (src->meth->copy != NULL && src->meth->copy(dest, src) == 0)
174         return NULL;
175
176     dest->dirty_cnt++;
177
178     return dest;
179 }
180
181 EC_KEY *EC_KEY_dup(const EC_KEY *ec_key)
182 {
183     EC_KEY *ret = ec_key_new_method_int(ec_key->libctx, ec_key->engine);
184
185     if (ret == NULL)
186         return NULL;
187
188     if (EC_KEY_copy(ret, ec_key) == NULL) {
189         EC_KEY_free(ret);
190         return NULL;
191     }
192     return ret;
193 }
194
195 int EC_KEY_up_ref(EC_KEY *r)
196 {
197     int i;
198
199     if (CRYPTO_UP_REF(&r->references, &i, r->lock) <= 0)
200         return 0;
201
202     REF_PRINT_COUNT("EC_KEY", r);
203     REF_ASSERT_ISNT(i < 2);
204     return ((i > 1) ? 1 : 0);
205 }
206
207 ENGINE *EC_KEY_get0_engine(const EC_KEY *eckey)
208 {
209     return eckey->engine;
210 }
211
212 int EC_KEY_generate_key(EC_KEY *eckey)
213 {
214     if (eckey == NULL || eckey->group == NULL) {
215         ECerr(EC_F_EC_KEY_GENERATE_KEY, ERR_R_PASSED_NULL_PARAMETER);
216         return 0;
217     }
218     if (eckey->meth->keygen != NULL) {
219         int ret;
220
221         ret = eckey->meth->keygen(eckey);
222         if (ret == 1)
223             eckey->dirty_cnt++;
224
225         return ret;
226     }
227     ECerr(EC_F_EC_KEY_GENERATE_KEY, EC_R_OPERATION_NOT_SUPPORTED);
228     return 0;
229 }
230
231 int ossl_ec_key_gen(EC_KEY *eckey)
232 {
233     int ret;
234
235     ret = eckey->group->meth->keygen(eckey);
236
237     if (ret == 1)
238         eckey->dirty_cnt++;
239     return ret;
240 }
241
242 /*
243  * ECC Key generation.
244  * See SP800-56AR3 5.6.1.2.2 "Key Pair Generation by Testing Candidates"
245  *
246  * Params:
247  *     libctx A context containing an optional self test callback.
248  *     eckey An EC key object that contains domain params. The generated keypair
249  *           is stored in this object.
250  *     pairwise_test Set to non zero to perform a pairwise test. If the test
251  *                   fails then the keypair is not generated,
252  * Returns 1 if the keypair was generated or 0 otherwise.
253  */
254 int ec_generate_key(OPENSSL_CTX *libctx, EC_KEY *eckey, int pairwise_test)
255 {
256     int ok = 0;
257     BIGNUM *priv_key = NULL;
258     const BIGNUM *order = NULL;
259     EC_POINT *pub_key = NULL;
260     const EC_GROUP *group = eckey->group;
261     BN_CTX *ctx = BN_CTX_secure_new_ex(eckey->libctx);
262
263     if (ctx == NULL)
264         goto err;
265
266     if (eckey->priv_key == NULL) {
267         priv_key = BN_secure_new();
268         if (priv_key == NULL)
269             goto err;
270     } else
271         priv_key = eckey->priv_key;
272
273     /*
274      * Steps (1-2): Check domain parameters and security strength.
275      * These steps must be done by the user. This would need to be
276      * stated in the security policy.
277      */
278
279     order = EC_GROUP_get0_order(group);
280     if (order == NULL)
281         goto err;
282
283     /*
284      * Steps (3-7): priv_key = DRBG_RAND(order_n_bits) (range [1, n-1]).
285      * Although this is slightly different from the standard, it is effectively
286      * equivalent as it gives an unbiased result ranging from 1..n-1. It is also
287      * faster as the standard needs to retry more often. Also doing
288      * 1 + rand[0..n-2] would effect the way that tests feed dummy entropy into
289      * rand so the simpler backward compatible method has been used here.
290      */
291     do
292         if (!BN_priv_rand_range_ex(priv_key, order, ctx))
293             goto err;
294     while (BN_is_zero(priv_key)) ;
295
296     if (eckey->pub_key == NULL) {
297         pub_key = EC_POINT_new(group);
298         if (pub_key == NULL)
299             goto err;
300     } else
301         pub_key = eckey->pub_key;
302
303     /* Step (8) : pub_key = priv_key * G (where G is a point on the curve) */
304     if (!EC_POINT_mul(group, pub_key, priv_key, NULL, NULL, ctx))
305         goto err;
306
307     eckey->priv_key = priv_key;
308     eckey->pub_key = pub_key;
309     priv_key = NULL;
310     pub_key = NULL;
311
312     eckey->dirty_cnt++;
313
314 #ifdef FIPS_MODULE
315     pairwise_test = 1;
316 #endif /* FIPS_MODULE */
317
318     ok = 1;
319     if (pairwise_test) {
320         OSSL_CALLBACK *cb = NULL;
321         void *cbarg = NULL;
322
323         OSSL_SELF_TEST_get_callback(libctx, &cb, &cbarg);
324         ok = ecdsa_keygen_pairwise_test(eckey, cb, cbarg);
325     }
326 err:
327     /* Step (9): If there is an error return an invalid keypair. */
328     if (!ok) {
329         BN_clear(eckey->priv_key);
330         if (eckey->pub_key != NULL)
331             EC_POINT_set_to_infinity(group, eckey->pub_key);
332     }
333
334     EC_POINT_free(pub_key);
335     BN_clear_free(priv_key);
336     BN_CTX_free(ctx);
337     return ok;
338 }
339
340 int ec_key_simple_generate_key(EC_KEY *eckey)
341 {
342     return ec_generate_key(NULL, eckey, 0);
343 }
344
345 int ec_key_simple_generate_public_key(EC_KEY *eckey)
346 {
347     int ret;
348
349     /*
350      * See SP800-56AR3 5.6.1.2.2: Step (8)
351      * pub_key = priv_key * G (where G is a point on the curve)
352      */
353     ret = EC_POINT_mul(eckey->group, eckey->pub_key, eckey->priv_key, NULL,
354                        NULL, NULL);
355
356     if (ret == 1)
357         eckey->dirty_cnt++;
358
359     return ret;
360 }
361
362 int EC_KEY_check_key(const EC_KEY *eckey)
363 {
364     if (eckey == NULL || eckey->group == NULL || eckey->pub_key == NULL) {
365         ECerr(EC_F_EC_KEY_CHECK_KEY, ERR_R_PASSED_NULL_PARAMETER);
366         return 0;
367     }
368
369     if (eckey->group->meth->keycheck == NULL) {
370         ECerr(EC_F_EC_KEY_CHECK_KEY, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
371         return 0;
372     }
373
374     return eckey->group->meth->keycheck(eckey);
375 }
376
377 /*
378  * Check the range of the EC public key.
379  * See SP800-56A R3 Section 5.6.2.3.3 (Part 2)
380  * i.e.
381  *  - If q = odd prime p: Verify that xQ and yQ are integers in the
382  *    interval[0, p - 1], OR
383  *  - If q = 2m: Verify that xQ and yQ are bit strings of length m bits.
384  * Returns 1 if the public key has a valid range, otherwise it returns 0.
385  */
386 static int ec_key_public_range_check(BN_CTX *ctx, const EC_KEY *key)
387 {
388     int ret = 0;
389     BIGNUM *x, *y;
390
391     BN_CTX_start(ctx);
392     x = BN_CTX_get(ctx);
393     y = BN_CTX_get(ctx);
394     if (y == NULL)
395         goto err;
396
397     if (!EC_POINT_get_affine_coordinates(key->group, key->pub_key, x, y, ctx))
398         goto err;
399
400     if (EC_GROUP_get_field_type(key->group) == NID_X9_62_prime_field) {
401         if (BN_is_negative(x)
402             || BN_cmp(x, key->group->field) >= 0
403             || BN_is_negative(y)
404             || BN_cmp(y, key->group->field) >= 0) {
405             goto err;
406         }
407     } else {
408         int m = EC_GROUP_get_degree(key->group);
409         if (BN_num_bits(x) > m || BN_num_bits(y) > m) {
410             goto err;
411         }
412     }
413     ret = 1;
414 err:
415     BN_CTX_end(ctx);
416     return ret;
417 }
418
419 /*
420  * ECC Key validation as specified in SP800-56A R3.
421  * Section 5.6.2.3.3 ECC Full Public-Key Validation.
422  */
423 int ec_key_public_check(const EC_KEY *eckey, BN_CTX *ctx)
424 {
425     int ret = 0;
426     EC_POINT *point = NULL;
427     const BIGNUM *order = NULL;
428
429     if (eckey == NULL || eckey->group == NULL || eckey->pub_key == NULL) {
430         ECerr(0, ERR_R_PASSED_NULL_PARAMETER);
431         return 0;
432     }
433
434     /* 5.6.2.3.3 (Step 1): Q != infinity */
435     if (EC_POINT_is_at_infinity(eckey->group, eckey->pub_key)) {
436         ECerr(0, EC_R_POINT_AT_INFINITY);
437         return 0;
438     }
439
440     point = EC_POINT_new(eckey->group);
441     if (point == NULL)
442         return 0;
443
444     /* 5.6.2.3.3 (Step 2) Test if the public key is in range */
445     if (!ec_key_public_range_check(ctx, eckey)) {
446         ECerr(0, EC_R_COORDINATES_OUT_OF_RANGE);
447         goto err;
448     }
449
450     /* 5.6.2.3.3 (Step 3) is the pub_key on the elliptic curve */
451     if (EC_POINT_is_on_curve(eckey->group, eckey->pub_key, ctx) <= 0) {
452         ECerr(0, EC_R_POINT_IS_NOT_ON_CURVE);
453         goto err;
454     }
455
456     order = eckey->group->order;
457     if (BN_is_zero(order)) {
458         ECerr(0, EC_R_INVALID_GROUP_ORDER);
459         goto err;
460     }
461     /* 5.6.2.3.3 (Step 4) : pub_key * order is the point at infinity. */
462     if (!EC_POINT_mul(eckey->group, point, NULL, eckey->pub_key, order, ctx)) {
463         ECerr(0, ERR_R_EC_LIB);
464         goto err;
465     }
466     if (!EC_POINT_is_at_infinity(eckey->group, point)) {
467         ECerr(0, EC_R_WRONG_ORDER);
468         goto err;
469     }
470     ret = 1;
471 err:
472     EC_POINT_free(point);
473     return ret;
474 }
475
476 /*
477  * ECC Key validation as specified in SP800-56A R3.
478  * Section 5.6.2.1.2 Owner Assurance of Private-Key Validity
479  * The private key is in the range [1, order-1]
480  */
481 int ec_key_private_check(const EC_KEY *eckey)
482 {
483     if (eckey == NULL || eckey->group == NULL || eckey->priv_key == NULL) {
484         ECerr(0, ERR_R_PASSED_NULL_PARAMETER);
485         return 0;
486     }
487     if (BN_cmp(eckey->priv_key, BN_value_one()) < 0
488         || BN_cmp(eckey->priv_key, eckey->group->order) >= 0) {
489         ECerr(0, EC_R_INVALID_PRIVATE_KEY);
490         return 0;
491     }
492     return 1;
493 }
494
495 /*
496  * ECC Key validation as specified in SP800-56A R3.
497  * Section 5.6.2.1.4 Owner Assurance of Pair-wise Consistency (b)
498  * Check if generator * priv_key = pub_key
499  */
500 int ec_key_pairwise_check(const EC_KEY *eckey, BN_CTX *ctx)
501 {
502     int ret = 0;
503     EC_POINT *point = NULL;
504
505     if (eckey == NULL
506        || eckey->group == NULL
507        || eckey->pub_key == NULL
508        || eckey->priv_key == NULL) {
509         ECerr(0, ERR_R_PASSED_NULL_PARAMETER);
510         return 0;
511     }
512
513     point = EC_POINT_new(eckey->group);
514     if (point == NULL)
515         goto err;
516
517
518     if (!EC_POINT_mul(eckey->group, point, eckey->priv_key, NULL, NULL, ctx)) {
519         ECerr(0, ERR_R_EC_LIB);
520         goto err;
521     }
522     if (EC_POINT_cmp(eckey->group, point, eckey->pub_key, ctx) != 0) {
523         ECerr(0, EC_R_INVALID_PRIVATE_KEY);
524         goto err;
525     }
526     ret = 1;
527 err:
528     EC_POINT_free(point);
529     return ret;
530 }
531
532
533 /*
534  * ECC Key validation as specified in SP800-56A R3.
535  *    Section 5.6.2.3.3 ECC Full Public-Key Validation
536  *    Section 5.6.2.1.2 Owner Assurance of Private-Key Validity
537  *    Section 5.6.2.1.4 Owner Assurance of Pair-wise Consistency
538  * NOTES:
539  *    Before calling this method in fips mode, there should be an assurance that
540  *    an approved elliptic-curve group is used.
541  * Returns 1 if the key is valid, otherwise it returns 0.
542  */
543 int ec_key_simple_check_key(const EC_KEY *eckey)
544 {
545     int ok = 0;
546     BN_CTX *ctx = NULL;
547
548     if (eckey == NULL) {
549         ECerr(0, ERR_R_PASSED_NULL_PARAMETER);
550         return 0;
551     }
552     if ((ctx = BN_CTX_new_ex(eckey->libctx)) == NULL)
553         return 0;
554
555     if (!ec_key_public_check(eckey, ctx))
556         goto err;
557
558     if (eckey->priv_key != NULL) {
559         if (!ec_key_private_check(eckey)
560             || !ec_key_pairwise_check(eckey, ctx))
561             goto err;
562     }
563     ok = 1;
564 err:
565     BN_CTX_free(ctx);
566     return ok;
567 }
568
569 int EC_KEY_set_public_key_affine_coordinates(EC_KEY *key, BIGNUM *x,
570                                              BIGNUM *y)
571 {
572     BN_CTX *ctx = NULL;
573     BIGNUM *tx, *ty;
574     EC_POINT *point = NULL;
575     int ok = 0;
576
577     if (key == NULL || key->group == NULL || x == NULL || y == NULL) {
578         ECerr(EC_F_EC_KEY_SET_PUBLIC_KEY_AFFINE_COORDINATES,
579               ERR_R_PASSED_NULL_PARAMETER);
580         return 0;
581     }
582     ctx = BN_CTX_new_ex(key->libctx);
583     if (ctx == NULL)
584         return 0;
585
586     BN_CTX_start(ctx);
587     point = EC_POINT_new(key->group);
588
589     if (point == NULL)
590         goto err;
591
592     tx = BN_CTX_get(ctx);
593     ty = BN_CTX_get(ctx);
594     if (ty == NULL)
595         goto err;
596
597     if (!EC_POINT_set_affine_coordinates(key->group, point, x, y, ctx))
598         goto err;
599     if (!EC_POINT_get_affine_coordinates(key->group, point, tx, ty, ctx))
600         goto err;
601
602     /*
603      * Check if retrieved coordinates match originals. The range check is done
604      * inside EC_KEY_check_key().
605      */
606     if (BN_cmp(x, tx) || BN_cmp(y, ty)) {
607         ECerr(EC_F_EC_KEY_SET_PUBLIC_KEY_AFFINE_COORDINATES,
608               EC_R_COORDINATES_OUT_OF_RANGE);
609         goto err;
610     }
611
612     /* EC_KEY_set_public_key updates dirty_cnt */
613     if (!EC_KEY_set_public_key(key, point))
614         goto err;
615
616     if (EC_KEY_check_key(key) == 0)
617         goto err;
618
619     ok = 1;
620
621  err:
622     BN_CTX_end(ctx);
623     BN_CTX_free(ctx);
624     EC_POINT_free(point);
625     return ok;
626
627 }
628
629 OPENSSL_CTX *ec_key_get_libctx(const EC_KEY *key)
630 {
631     return key->libctx;
632 }
633
634 const EC_GROUP *EC_KEY_get0_group(const EC_KEY *key)
635 {
636     return key->group;
637 }
638
639 int EC_KEY_set_group(EC_KEY *key, const EC_GROUP *group)
640 {
641     if (key->meth->set_group != NULL && key->meth->set_group(key, group) == 0)
642         return 0;
643     EC_GROUP_free(key->group);
644     key->group = EC_GROUP_dup(group);
645     key->dirty_cnt++;
646     return (key->group == NULL) ? 0 : 1;
647 }
648
649 const BIGNUM *EC_KEY_get0_private_key(const EC_KEY *key)
650 {
651     return key->priv_key;
652 }
653
654 int EC_KEY_set_private_key(EC_KEY *key, const BIGNUM *priv_key)
655 {
656     int fixed_top;
657     const BIGNUM *order = NULL;
658     BIGNUM *tmp_key = NULL;
659
660     if (key->group == NULL || key->group->meth == NULL)
661         return 0;
662
663     /*
664      * Not only should key->group be set, but it should also be in a valid
665      * fully initialized state.
666      *
667      * Specifically, to operate in constant time, we need that the group order
668      * is set, as we use its length as the fixed public size of any scalar used
669      * as an EC private key.
670      */
671     order = EC_GROUP_get0_order(key->group);
672     if (order == NULL || BN_is_zero(order))
673         return 0; /* This should never happen */
674
675     if (key->group->meth->set_private != NULL
676         && key->group->meth->set_private(key, priv_key) == 0)
677         return 0;
678     if (key->meth->set_private != NULL
679         && key->meth->set_private(key, priv_key) == 0)
680         return 0;
681
682     /*
683      * We should never leak the bit length of the secret scalar in the key,
684      * so we always set the `BN_FLG_CONSTTIME` flag on the internal `BIGNUM`
685      * holding the secret scalar.
686      *
687      * This is important also because `BN_dup()` (and `BN_copy()`) do not
688      * propagate the `BN_FLG_CONSTTIME` flag from the source `BIGNUM`, and
689      * this brings an extra risk of inadvertently losing the flag, even when
690      * the caller specifically set it.
691      *
692      * The propagation has been turned on and off a few times in the past
693      * years because in some conditions has shown unintended consequences in
694      * some code paths, so at the moment we can't fix this in the BN layer.
695      *
696      * In `EC_KEY_set_private_key()` we can work around the propagation by
697      * manually setting the flag after `BN_dup()` as we know for sure that
698      * inside the EC module the `BN_FLG_CONSTTIME` is always treated
699      * correctly and should not generate unintended consequences.
700      *
701      * Setting the BN_FLG_CONSTTIME flag alone is never enough, we also have
702      * to preallocate the BIGNUM internal buffer to a fixed public size big
703      * enough that operations performed during the processing never trigger
704      * a realloc which would leak the size of the scalar through memory
705      * accesses.
706      *
707      * Fixed Length
708      * ------------
709      *
710      * The order of the large prime subgroup of the curve is our choice for
711      * a fixed public size, as that is generally the upper bound for
712      * generating a private key in EC cryptosystems and should fit all valid
713      * secret scalars.
714      *
715      * For preallocating the BIGNUM storage we look at the number of "words"
716      * required for the internal representation of the order, and we
717      * preallocate 2 extra "words" in case any of the subsequent processing
718      * might temporarily overflow the order length.
719      */
720     tmp_key = BN_dup(priv_key);
721     if (tmp_key == NULL)
722         return 0;
723
724     BN_set_flags(tmp_key, BN_FLG_CONSTTIME);
725
726     fixed_top = bn_get_top(order) + 2;
727     if (bn_wexpand(tmp_key, fixed_top) == NULL) {
728         BN_clear_free(tmp_key);
729         return 0;
730     }
731
732     BN_clear_free(key->priv_key);
733     key->priv_key = tmp_key;
734     key->dirty_cnt++;
735
736     return 1;
737 }
738
739 const EC_POINT *EC_KEY_get0_public_key(const EC_KEY *key)
740 {
741     return key->pub_key;
742 }
743
744 int EC_KEY_set_public_key(EC_KEY *key, const EC_POINT *pub_key)
745 {
746     if (key->meth->set_public != NULL
747         && key->meth->set_public(key, pub_key) == 0)
748         return 0;
749     EC_POINT_free(key->pub_key);
750     key->pub_key = EC_POINT_dup(pub_key, key->group);
751     key->dirty_cnt++;
752     return (key->pub_key == NULL) ? 0 : 1;
753 }
754
755 unsigned int EC_KEY_get_enc_flags(const EC_KEY *key)
756 {
757     return key->enc_flag;
758 }
759
760 void EC_KEY_set_enc_flags(EC_KEY *key, unsigned int flags)
761 {
762     key->enc_flag = flags;
763 }
764
765 point_conversion_form_t EC_KEY_get_conv_form(const EC_KEY *key)
766 {
767     return key->conv_form;
768 }
769
770 void EC_KEY_set_conv_form(EC_KEY *key, point_conversion_form_t cform)
771 {
772     key->conv_form = cform;
773     if (key->group != NULL)
774         EC_GROUP_set_point_conversion_form(key->group, cform);
775 }
776
777 void EC_KEY_set_asn1_flag(EC_KEY *key, int flag)
778 {
779     if (key->group != NULL)
780         EC_GROUP_set_asn1_flag(key->group, flag);
781 }
782
783 #ifndef OPENSSL_NO_DEPRECATED_3_0
784 int EC_KEY_precompute_mult(EC_KEY *key, BN_CTX *ctx)
785 {
786     if (key->group == NULL)
787         return 0;
788     return EC_GROUP_precompute_mult(key->group, ctx);
789 }
790 #endif
791
792 int EC_KEY_get_flags(const EC_KEY *key)
793 {
794     return key->flags;
795 }
796
797 void EC_KEY_set_flags(EC_KEY *key, int flags)
798 {
799     key->flags |= flags;
800     key->dirty_cnt++;
801 }
802
803 void EC_KEY_clear_flags(EC_KEY *key, int flags)
804 {
805     key->flags &= ~flags;
806     key->dirty_cnt++;
807 }
808
809 size_t EC_KEY_key2buf(const EC_KEY *key, point_conversion_form_t form,
810                         unsigned char **pbuf, BN_CTX *ctx)
811 {
812     if (key == NULL || key->pub_key == NULL || key->group == NULL)
813         return 0;
814     return EC_POINT_point2buf(key->group, key->pub_key, form, pbuf, ctx);
815 }
816
817 int EC_KEY_oct2key(EC_KEY *key, const unsigned char *buf, size_t len,
818                    BN_CTX *ctx)
819 {
820     if (key == NULL || key->group == NULL)
821         return 0;
822     if (key->pub_key == NULL)
823         key->pub_key = EC_POINT_new(key->group);
824     if (key->pub_key == NULL)
825         return 0;
826     if (EC_POINT_oct2point(key->group, key->pub_key, buf, len, ctx) == 0)
827         return 0;
828     key->dirty_cnt++;
829     /*
830      * Save the point conversion form.
831      * For non-custom curves the first octet of the buffer (excluding
832      * the last significant bit) contains the point conversion form.
833      * EC_POINT_oct2point() has already performed sanity checking of
834      * the buffer so we know it is valid.
835      */
836     if ((key->group->meth->flags & EC_FLAGS_CUSTOM_CURVE) == 0)
837         key->conv_form = (point_conversion_form_t)(buf[0] & ~0x01);
838     return 1;
839 }
840
841 size_t EC_KEY_priv2oct(const EC_KEY *eckey,
842                        unsigned char *buf, size_t len)
843 {
844     if (eckey->group == NULL || eckey->group->meth == NULL)
845         return 0;
846     if (eckey->group->meth->priv2oct == NULL) {
847         ECerr(EC_F_EC_KEY_PRIV2OCT, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
848         return 0;
849     }
850
851     return eckey->group->meth->priv2oct(eckey, buf, len);
852 }
853
854 size_t ec_key_simple_priv2oct(const EC_KEY *eckey,
855                               unsigned char *buf, size_t len)
856 {
857     size_t buf_len;
858
859     buf_len = (EC_GROUP_order_bits(eckey->group) + 7) / 8;
860     if (eckey->priv_key == NULL)
861         return 0;
862     if (buf == NULL)
863         return buf_len;
864     else if (len < buf_len)
865         return 0;
866
867     /* Octetstring may need leading zeros if BN is to short */
868
869     if (BN_bn2binpad(eckey->priv_key, buf, buf_len) == -1) {
870         ECerr(EC_F_EC_KEY_SIMPLE_PRIV2OCT, EC_R_BUFFER_TOO_SMALL);
871         return 0;
872     }
873
874     return buf_len;
875 }
876
877 int EC_KEY_oct2priv(EC_KEY *eckey, const unsigned char *buf, size_t len)
878 {
879     int ret;
880
881     if (eckey->group == NULL || eckey->group->meth == NULL)
882         return 0;
883     if (eckey->group->meth->oct2priv == NULL) {
884         ECerr(EC_F_EC_KEY_OCT2PRIV, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
885         return 0;
886     }
887     ret = eckey->group->meth->oct2priv(eckey, buf, len);
888     if (ret == 1)
889         eckey->dirty_cnt++;
890     return ret;
891 }
892
893 int ec_key_simple_oct2priv(EC_KEY *eckey, const unsigned char *buf, size_t len)
894 {
895     if (eckey->priv_key == NULL)
896         eckey->priv_key = BN_secure_new();
897     if (eckey->priv_key == NULL) {
898         ECerr(EC_F_EC_KEY_SIMPLE_OCT2PRIV, ERR_R_MALLOC_FAILURE);
899         return 0;
900     }
901     eckey->priv_key = BN_bin2bn(buf, len, eckey->priv_key);
902     if (eckey->priv_key == NULL) {
903         ECerr(EC_F_EC_KEY_SIMPLE_OCT2PRIV, ERR_R_BN_LIB);
904         return 0;
905     }
906     eckey->dirty_cnt++;
907     return 1;
908 }
909
910 size_t EC_KEY_priv2buf(const EC_KEY *eckey, unsigned char **pbuf)
911 {
912     size_t len;
913     unsigned char *buf;
914
915     len = EC_KEY_priv2oct(eckey, NULL, 0);
916     if (len == 0)
917         return 0;
918     if ((buf = OPENSSL_malloc(len)) == NULL) {
919         ECerr(EC_F_EC_KEY_PRIV2BUF, ERR_R_MALLOC_FAILURE);
920         return 0;
921     }
922     len = EC_KEY_priv2oct(eckey, buf, len);
923     if (len == 0) {
924         OPENSSL_free(buf);
925         return 0;
926     }
927     *pbuf = buf;
928     return len;
929 }
930
931 int EC_KEY_can_sign(const EC_KEY *eckey)
932 {
933     if (eckey->group == NULL || eckey->group->meth == NULL
934         || (eckey->group->meth->flags & EC_FLAGS_NO_SIGN))
935         return 0;
936     return 1;
937 }
938
939 /*
940  * FIPS 140-2 IG 9.9 AS09.33
941  * Perform a sign/verify operation.
942  *
943  * NOTE: When generating keys for key-agreement schemes - FIPS 140-2 IG 9.9
944  * states that no additional pairwise tests are required (apart from the tests
945  * specified in SP800-56A) when generating keys. Hence pairwise ECDH tests are
946  * omitted here.
947  */
948 static int ecdsa_keygen_pairwise_test(EC_KEY *eckey, OSSL_CALLBACK *cb,
949                                       void *cbarg)
950 {
951     int ret = 0;
952     unsigned char dgst[16] = {0};
953     int dgst_len = (int)sizeof(dgst);
954     ECDSA_SIG *sig = NULL;
955     OSSL_SELF_TEST *st = NULL;
956
957     st = OSSL_SELF_TEST_new(cb, cbarg);
958     if (st == NULL)
959         return 0;
960
961     OSSL_SELF_TEST_onbegin(st, OSSL_SELF_TEST_TYPE_PCT,
962                            OSSL_SELF_TEST_DESC_PCT_ECDSA);
963
964     sig = ECDSA_do_sign(dgst, dgst_len, eckey);
965     if (sig == NULL)
966         goto err;
967
968     OSSL_SELF_TEST_oncorrupt_byte(st, dgst);
969
970     if (ECDSA_do_verify(dgst, dgst_len, sig, eckey) != 1)
971         goto err;
972
973     ret = 1;
974 err:
975     OSSL_SELF_TEST_onend(st, ret);
976     OSSL_SELF_TEST_free(st);
977     ECDSA_SIG_free(sig);
978     return ret;
979 }