xref: /openbsd/lib/libcrypto/ec/ec_key.c (revision ff0b5b20)
1 /* $OpenBSD: ec_key.c,v 1.51 2025/01/25 10:34:36 tb Exp $ */
2 /*
3  * Written by Nils Larsch for the OpenSSL project.
4  */
5 /* ====================================================================
6  * Copyright (c) 1998-2005 The OpenSSL Project.  All rights reserved.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  *
12  * 1. Redistributions of source code must retain the above copyright
13  *    notice, this list of conditions and the following disclaimer.
14  *
15  * 2. Redistributions in binary form must reproduce the above copyright
16  *    notice, this list of conditions and the following disclaimer in
17  *    the documentation and/or other materials provided with the
18  *    distribution.
19  *
20  * 3. All advertising materials mentioning features or use of this
21  *    software must display the following acknowledgment:
22  *    "This product includes software developed by the OpenSSL Project
23  *    for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
24  *
25  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
26  *    endorse or promote products derived from this software without
27  *    prior written permission. For written permission, please contact
28  *    openssl-core@openssl.org.
29  *
30  * 5. Products derived from this software may not be called "OpenSSL"
31  *    nor may "OpenSSL" appear in their names without prior written
32  *    permission of the OpenSSL Project.
33  *
34  * 6. Redistributions of any form whatsoever must retain the following
35  *    acknowledgment:
36  *    "This product includes software developed by the OpenSSL Project
37  *    for use in the OpenSSL Toolkit (http://www.openssl.org/)"
38  *
39  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
40  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
41  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
42  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
43  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
44  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
45  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
46  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
47  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
48  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
49  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
50  * OF THE POSSIBILITY OF SUCH DAMAGE.
51  * ====================================================================
52  *
53  * This product includes cryptographic software written by Eric Young
54  * (eay@cryptsoft.com).  This product includes software written by Tim
55  * Hudson (tjh@cryptsoft.com).
56  *
57  */
58 /* ====================================================================
59  * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED.
60  * Portions originally developed by SUN MICROSYSTEMS, INC., and
61  * contributed to the OpenSSL project.
62  */
63 
64 #include <string.h>
65 
66 #include <openssl/opensslconf.h>
67 
68 #include <openssl/ec.h>
69 #include <openssl/err.h>
70 
71 #include "bn_local.h"
72 #include "ec_local.h"
73 #include "ecdsa_local.h"
74 
75 EC_KEY *
EC_KEY_new(void)76 EC_KEY_new(void)
77 {
78 	return EC_KEY_new_method(NULL);
79 }
80 LCRYPTO_ALIAS(EC_KEY_new);
81 
82 EC_KEY *
EC_KEY_new_by_curve_name(int nid)83 EC_KEY_new_by_curve_name(int nid)
84 {
85 	EC_KEY *ec_key;
86 
87 	if ((ec_key = EC_KEY_new()) == NULL)
88 		goto err;
89 
90 	if ((ec_key->group = EC_GROUP_new_by_curve_name(nid)) == NULL)
91 		goto err;
92 
93 	/* XXX - do we want an ec_key_set0_group()? */
94 	if (ec_key->meth->set_group != NULL) {
95 		if (!ec_key->meth->set_group(ec_key, ec_key->group))
96 			goto err;
97 	}
98 
99 	return ec_key;
100 
101  err:
102 	EC_KEY_free(ec_key);
103 
104 	return NULL;
105 }
106 LCRYPTO_ALIAS(EC_KEY_new_by_curve_name);
107 
108 void
EC_KEY_free(EC_KEY * ec_key)109 EC_KEY_free(EC_KEY *ec_key)
110 {
111 	if (ec_key == NULL)
112 		return;
113 
114 	if (CRYPTO_add(&ec_key->references, -1, CRYPTO_LOCK_EC) > 0)
115 		return;
116 
117 	if (ec_key->meth != NULL && ec_key->meth->finish != NULL)
118 		ec_key->meth->finish(ec_key);
119 
120 	CRYPTO_free_ex_data(CRYPTO_EX_INDEX_EC_KEY, ec_key, &ec_key->ex_data);
121 
122 	EC_GROUP_free(ec_key->group);
123 	EC_POINT_free(ec_key->pub_key);
124 	BN_free(ec_key->priv_key);
125 
126 	freezero(ec_key, sizeof(*ec_key));
127 }
128 LCRYPTO_ALIAS(EC_KEY_free);
129 
130 EC_KEY *
EC_KEY_copy(EC_KEY * dest,const EC_KEY * src)131 EC_KEY_copy(EC_KEY *dest, const EC_KEY *src)
132 {
133 	if (dest == NULL || src == NULL) {
134 		ECerror(ERR_R_PASSED_NULL_PARAMETER);
135 		return NULL;
136 	}
137 
138 	if (src->meth != dest->meth) {
139 		if (dest->meth != NULL && dest->meth->finish != NULL)
140 			dest->meth->finish(dest);
141 	}
142 
143 	if (src->group != NULL) {
144 		EC_GROUP_free(dest->group);
145 		if ((dest->group = EC_GROUP_dup(src->group)) == NULL)
146 			return NULL;
147 		if (src->pub_key != NULL) {
148 			EC_POINT_free(dest->pub_key);
149 			if ((dest->pub_key = EC_POINT_dup(src->pub_key,
150 			    src->group)) == NULL)
151 				return NULL;
152 		}
153 	}
154 
155 	BN_free(dest->priv_key);
156 	dest->priv_key = NULL;
157 	if (src->priv_key != NULL) {
158 		if ((dest->priv_key = BN_dup(src->priv_key)) == NULL)
159 			return NULL;
160 	}
161 
162 	dest->enc_flag = src->enc_flag;
163 	dest->conv_form = src->conv_form;
164 	dest->version = src->version;
165 	dest->flags = src->flags;
166 
167 	/*
168 	 * The fun part about being a toolkit implementer is that the rest of
169 	 * the world gets to live with your terrible API design choices for
170 	 * eternity. (To be fair: the signature was changed in OpenSSL 3).
171 	 */
172 	if (!CRYPTO_dup_ex_data(CRYPTO_EX_INDEX_EC_KEY, &dest->ex_data,
173 	    &((EC_KEY *)src)->ex_data))	/* XXX const */
174 		return NULL;
175 
176 	dest->meth = src->meth;
177 
178 	if (src->meth != NULL && src->meth->copy != NULL) {
179 		if (!src->meth->copy(dest, src))
180 			return NULL;
181 	}
182 
183 	return dest;
184 }
185 LCRYPTO_ALIAS(EC_KEY_copy);
186 
187 EC_KEY *
EC_KEY_dup(const EC_KEY * in_ec_key)188 EC_KEY_dup(const EC_KEY *in_ec_key)
189 {
190 	EC_KEY *ec_key;
191 
192 	/* XXX - Pass NULL - so we're perhaps not running the right init()? */
193 	if ((ec_key = EC_KEY_new_method(NULL)) == NULL)
194 		goto err;
195 	if (EC_KEY_copy(ec_key, in_ec_key) == NULL)
196 		goto err;
197 
198 	return ec_key;
199 
200  err:
201 	EC_KEY_free(ec_key);
202 
203 	return NULL;
204 }
205 LCRYPTO_ALIAS(EC_KEY_dup);
206 
207 int
EC_KEY_up_ref(EC_KEY * r)208 EC_KEY_up_ref(EC_KEY *r)
209 {
210 	return CRYPTO_add(&r->references, 1, CRYPTO_LOCK_EC) > 1;
211 }
212 LCRYPTO_ALIAS(EC_KEY_up_ref);
213 
214 int
EC_KEY_set_ex_data(EC_KEY * r,int idx,void * arg)215 EC_KEY_set_ex_data(EC_KEY *r, int idx, void *arg)
216 {
217 	return CRYPTO_set_ex_data(&r->ex_data, idx, arg);
218 }
219 LCRYPTO_ALIAS(EC_KEY_set_ex_data);
220 
221 void *
EC_KEY_get_ex_data(const EC_KEY * r,int idx)222 EC_KEY_get_ex_data(const EC_KEY *r, int idx)
223 {
224 	return CRYPTO_get_ex_data(&r->ex_data, idx);
225 }
226 LCRYPTO_ALIAS(EC_KEY_get_ex_data);
227 
228 int
EC_KEY_generate_key(EC_KEY * eckey)229 EC_KEY_generate_key(EC_KEY *eckey)
230 {
231 	if (eckey->meth->keygen != NULL)
232 		return eckey->meth->keygen(eckey);
233 	ECerror(EC_R_NOT_IMPLEMENTED);
234 	return 0;
235 }
236 LCRYPTO_ALIAS(EC_KEY_generate_key);
237 
238 static int
ec_key_gen(EC_KEY * eckey)239 ec_key_gen(EC_KEY *eckey)
240 {
241 	BIGNUM *priv_key = NULL;
242 	EC_POINT *pub_key = NULL;
243 	const BIGNUM *order;
244 	int ret = 0;
245 
246 	if (eckey == NULL || eckey->group == NULL) {
247 		ECerror(ERR_R_PASSED_NULL_PARAMETER);
248 		goto err;
249 	}
250 
251 	if ((priv_key = BN_new()) == NULL)
252 		goto err;
253 	if ((pub_key = EC_POINT_new(eckey->group)) == NULL)
254 		goto err;
255 
256 	if ((order = EC_GROUP_get0_order(eckey->group)) == NULL)
257 		goto err;
258 	if (!bn_rand_interval(priv_key, 1, order))
259 		goto err;
260 	if (!EC_POINT_mul(eckey->group, pub_key, priv_key, NULL, NULL, NULL))
261 		goto err;
262 
263 	BN_free(eckey->priv_key);
264 	eckey->priv_key = priv_key;
265 	priv_key = NULL;
266 
267 	EC_POINT_free(eckey->pub_key);
268 	eckey->pub_key = pub_key;
269 	pub_key = NULL;
270 
271 	ret = 1;
272 
273  err:
274 	EC_POINT_free(pub_key);
275 	BN_free(priv_key);
276 
277 	return ret;
278 }
279 
280 int
EC_KEY_check_key(const EC_KEY * eckey)281 EC_KEY_check_key(const EC_KEY *eckey)
282 {
283 	BN_CTX *ctx = NULL;
284 	EC_POINT *point = NULL;
285 	const BIGNUM *order;
286 	int ret = 0;
287 
288 	if (eckey == NULL || eckey->group == NULL || eckey->pub_key == NULL) {
289 		ECerror(ERR_R_PASSED_NULL_PARAMETER);
290 		goto err;
291 	}
292 
293 	if (EC_POINT_is_at_infinity(eckey->group, eckey->pub_key)) {
294 		ECerror(EC_R_POINT_AT_INFINITY);
295 		goto err;
296 	}
297 
298 	if ((ctx = BN_CTX_new()) == NULL)
299 		goto err;
300 
301 	if ((point = EC_POINT_new(eckey->group)) == NULL)
302 		goto err;
303 
304 	/* Ensure public key is on the elliptic curve. */
305 	if (EC_POINT_is_on_curve(eckey->group, eckey->pub_key, ctx) <= 0) {
306 		ECerror(EC_R_POINT_IS_NOT_ON_CURVE);
307 		goto err;
308 	}
309 
310 	/* Ensure public key multiplied by the order is the point at infinity. */
311 	if ((order = EC_GROUP_get0_order(eckey->group)) == NULL) {
312 		ECerror(EC_R_INVALID_GROUP_ORDER);
313 		goto err;
314 	}
315 	if (!EC_POINT_mul(eckey->group, point, NULL, eckey->pub_key, order, ctx)) {
316 		ECerror(ERR_R_EC_LIB);
317 		goto err;
318 	}
319 	if (!EC_POINT_is_at_infinity(eckey->group, point)) {
320 		ECerror(EC_R_WRONG_ORDER);
321 		goto err;
322 	}
323 
324 	/*
325 	 * If the private key is present, ensure that the private key multiplied
326 	 * by the generator matches the public key.
327 	 */
328 	if (eckey->priv_key != NULL) {
329 		if (BN_cmp(eckey->priv_key, order) >= 0) {
330 			ECerror(EC_R_WRONG_ORDER);
331 			goto err;
332 		}
333 		if (!EC_POINT_mul(eckey->group, point, eckey->priv_key, NULL,
334 		    NULL, ctx)) {
335 			ECerror(ERR_R_EC_LIB);
336 			goto err;
337 		}
338 		if (EC_POINT_cmp(eckey->group, point, eckey->pub_key,
339 		    ctx) != 0) {
340 			ECerror(EC_R_INVALID_PRIVATE_KEY);
341 			goto err;
342 		}
343 	}
344 
345 	ret = 1;
346 
347  err:
348 	BN_CTX_free(ctx);
349 	EC_POINT_free(point);
350 
351 	return ret;
352 }
353 LCRYPTO_ALIAS(EC_KEY_check_key);
354 
355 int
EC_KEY_set_public_key_affine_coordinates(EC_KEY * key,BIGNUM * x,BIGNUM * y)356 EC_KEY_set_public_key_affine_coordinates(EC_KEY *key, BIGNUM *x, BIGNUM *y)
357 {
358 	BN_CTX *ctx = NULL;
359 	EC_POINT *point = NULL;
360 	BIGNUM *tx, *ty;
361 	int ret = 0;
362 
363 	if (key == NULL || key->group == NULL || x == NULL || y == NULL) {
364 		ECerror(ERR_R_PASSED_NULL_PARAMETER);
365 		goto err;
366 	}
367 
368 	if ((ctx = BN_CTX_new()) == NULL)
369 		goto err;
370 
371 	BN_CTX_start(ctx);
372 
373 	if ((tx = BN_CTX_get(ctx)) == NULL)
374 		goto err;
375 	if ((ty = BN_CTX_get(ctx)) == NULL)
376 		goto err;
377 
378 	if ((point = EC_POINT_new(key->group)) == NULL)
379 		goto err;
380 
381 	if (!EC_POINT_set_affine_coordinates(key->group, point, x, y, ctx))
382 		goto err;
383 	if (!EC_POINT_get_affine_coordinates(key->group, point, tx, ty, ctx))
384 		goto err;
385 
386 	/*
387 	 * Check if retrieved coordinates match originals: if not values are
388 	 * out of range.
389 	 */
390 	if (BN_cmp(x, tx) != 0 || BN_cmp(y, ty) != 0) {
391 		ECerror(EC_R_COORDINATES_OUT_OF_RANGE);
392 		goto err;
393 	}
394 	if (!EC_KEY_set_public_key(key, point))
395 		goto err;
396 	if (EC_KEY_check_key(key) == 0)
397 		goto err;
398 
399 	ret = 1;
400 
401  err:
402 	BN_CTX_end(ctx);
403 	BN_CTX_free(ctx);
404 	EC_POINT_free(point);
405 
406 	return ret;
407 }
408 LCRYPTO_ALIAS(EC_KEY_set_public_key_affine_coordinates);
409 
410 const EC_GROUP *
EC_KEY_get0_group(const EC_KEY * key)411 EC_KEY_get0_group(const EC_KEY *key)
412 {
413 	return key->group;
414 }
415 LCRYPTO_ALIAS(EC_KEY_get0_group);
416 
417 int
EC_KEY_set_group(EC_KEY * key,const EC_GROUP * group)418 EC_KEY_set_group(EC_KEY *key, const EC_GROUP *group)
419 {
420 	if (key->meth->set_group != NULL &&
421 	    key->meth->set_group(key, group) == 0)
422 		return 0;
423 	EC_GROUP_free(key->group);
424 	key->group = EC_GROUP_dup(group);
425 	return (key->group == NULL) ? 0 : 1;
426 }
427 LCRYPTO_ALIAS(EC_KEY_set_group);
428 
429 const BIGNUM *
EC_KEY_get0_private_key(const EC_KEY * key)430 EC_KEY_get0_private_key(const EC_KEY *key)
431 {
432 	return key->priv_key;
433 }
434 LCRYPTO_ALIAS(EC_KEY_get0_private_key);
435 
436 int
EC_KEY_set_private_key(EC_KEY * key,const BIGNUM * priv_key)437 EC_KEY_set_private_key(EC_KEY *key, const BIGNUM *priv_key)
438 {
439 	if (key->meth->set_private != NULL &&
440 	    key->meth->set_private(key, priv_key) == 0)
441 		return 0;
442 
443 	BN_free(key->priv_key);
444 	if ((key->priv_key = BN_dup(priv_key)) == NULL)
445 		return 0;
446 
447 	return 1;
448 }
449 LCRYPTO_ALIAS(EC_KEY_set_private_key);
450 
451 const EC_POINT *
EC_KEY_get0_public_key(const EC_KEY * key)452 EC_KEY_get0_public_key(const EC_KEY *key)
453 {
454 	return key->pub_key;
455 }
456 LCRYPTO_ALIAS(EC_KEY_get0_public_key);
457 
458 int
EC_KEY_set_public_key(EC_KEY * key,const EC_POINT * pub_key)459 EC_KEY_set_public_key(EC_KEY *key, const EC_POINT *pub_key)
460 {
461 	if (key->meth->set_public != NULL &&
462 	    key->meth->set_public(key, pub_key) == 0)
463 		return 0;
464 
465 	EC_POINT_free(key->pub_key);
466 	if ((key->pub_key = EC_POINT_dup(pub_key, key->group)) == NULL)
467 		return 0;
468 
469 	return 1;
470 }
471 LCRYPTO_ALIAS(EC_KEY_set_public_key);
472 
473 unsigned int
EC_KEY_get_enc_flags(const EC_KEY * key)474 EC_KEY_get_enc_flags(const EC_KEY *key)
475 {
476 	return key->enc_flag;
477 }
478 LCRYPTO_ALIAS(EC_KEY_get_enc_flags);
479 
480 void
EC_KEY_set_enc_flags(EC_KEY * key,unsigned int flags)481 EC_KEY_set_enc_flags(EC_KEY *key, unsigned int flags)
482 {
483 	key->enc_flag = flags;
484 }
485 LCRYPTO_ALIAS(EC_KEY_set_enc_flags);
486 
487 point_conversion_form_t
EC_KEY_get_conv_form(const EC_KEY * key)488 EC_KEY_get_conv_form(const EC_KEY *key)
489 {
490 	return key->conv_form;
491 }
492 LCRYPTO_ALIAS(EC_KEY_get_conv_form);
493 
494 void
EC_KEY_set_conv_form(EC_KEY * key,point_conversion_form_t cform)495 EC_KEY_set_conv_form(EC_KEY *key, point_conversion_form_t cform)
496 {
497 	key->conv_form = cform;
498 	if (key->group != NULL)
499 		EC_GROUP_set_point_conversion_form(key->group, cform);
500 }
501 LCRYPTO_ALIAS(EC_KEY_set_conv_form);
502 
503 void
EC_KEY_set_asn1_flag(EC_KEY * key,int flag)504 EC_KEY_set_asn1_flag(EC_KEY *key, int flag)
505 {
506 	if (key->group != NULL)
507 		EC_GROUP_set_asn1_flag(key->group, flag);
508 }
509 LCRYPTO_ALIAS(EC_KEY_set_asn1_flag);
510 
511 int
EC_KEY_precompute_mult(EC_KEY * key,BN_CTX * ctx)512 EC_KEY_precompute_mult(EC_KEY *key, BN_CTX *ctx)
513 {
514 	if (key->group == NULL)
515 		return 0;
516 	return 1;
517 }
518 LCRYPTO_ALIAS(EC_KEY_precompute_mult);
519 
520 int
EC_KEY_get_flags(const EC_KEY * key)521 EC_KEY_get_flags(const EC_KEY *key)
522 {
523 	return key->flags;
524 }
525 LCRYPTO_ALIAS(EC_KEY_get_flags);
526 
527 void
EC_KEY_set_flags(EC_KEY * key,int flags)528 EC_KEY_set_flags(EC_KEY *key, int flags)
529 {
530 	key->flags |= flags;
531 }
532 LCRYPTO_ALIAS(EC_KEY_set_flags);
533 
534 void
EC_KEY_clear_flags(EC_KEY * key,int flags)535 EC_KEY_clear_flags(EC_KEY *key, int flags)
536 {
537 	key->flags &= ~flags;
538 }
539 LCRYPTO_ALIAS(EC_KEY_clear_flags);
540 
541 const EC_KEY_METHOD *
EC_KEY_get_method(const EC_KEY * key)542 EC_KEY_get_method(const EC_KEY *key)
543 {
544 	return key->meth;
545 }
546 LCRYPTO_ALIAS(EC_KEY_get_method);
547 
548 int
EC_KEY_set_method(EC_KEY * key,const EC_KEY_METHOD * meth)549 EC_KEY_set_method(EC_KEY *key, const EC_KEY_METHOD *meth)
550 {
551 	void (*finish)(EC_KEY *key) = key->meth->finish;
552 
553 	if (finish != NULL)
554 		finish(key);
555 
556 	key->meth = meth;
557 	if (meth->init != NULL)
558 		return meth->init(key);
559 	return 1;
560 }
561 LCRYPTO_ALIAS(EC_KEY_set_method);
562 
563 EC_KEY *
EC_KEY_new_method(ENGINE * engine)564 EC_KEY_new_method(ENGINE *engine)
565 {
566 	EC_KEY *ret;
567 
568 	if ((ret = calloc(1, sizeof(EC_KEY))) == NULL) {
569 		ECerror(ERR_R_MALLOC_FAILURE);
570 		return NULL;
571 	}
572 	ret->meth = EC_KEY_get_default_method();
573 	ret->version = 1;
574 	ret->flags = 0;
575 	ret->group = NULL;
576 	ret->pub_key = NULL;
577 	ret->priv_key = NULL;
578 	ret->enc_flag = 0;
579 	ret->conv_form = POINT_CONVERSION_UNCOMPRESSED;
580 	ret->references = 1;
581 
582 	if (!CRYPTO_new_ex_data(CRYPTO_EX_INDEX_EC_KEY, ret, &ret->ex_data))
583 		goto err;
584 	if (ret->meth->init != NULL && ret->meth->init(ret) == 0)
585 		goto err;
586 
587 	return ret;
588 
589  err:
590 	EC_KEY_free(ret);
591 	return NULL;
592 }
593 LCRYPTO_ALIAS(EC_KEY_new_method);
594 
595 #define EC_KEY_METHOD_DYNAMIC   1
596 
597 EC_KEY_METHOD *
EC_KEY_METHOD_new(const EC_KEY_METHOD * meth)598 EC_KEY_METHOD_new(const EC_KEY_METHOD *meth)
599 {
600 	EC_KEY_METHOD *ret;
601 
602 	if ((ret = calloc(1, sizeof(*meth))) == NULL)
603 		return NULL;
604 	if (meth != NULL)
605 		*ret = *meth;
606 	ret->flags |= EC_KEY_METHOD_DYNAMIC;
607 	return ret;
608 }
609 LCRYPTO_ALIAS(EC_KEY_METHOD_new);
610 
611 void
EC_KEY_METHOD_free(EC_KEY_METHOD * meth)612 EC_KEY_METHOD_free(EC_KEY_METHOD *meth)
613 {
614 	if (meth == NULL)
615 		return;
616 	if (meth->flags & EC_KEY_METHOD_DYNAMIC)
617 		free(meth);
618 }
619 LCRYPTO_ALIAS(EC_KEY_METHOD_free);
620 
621 void
EC_KEY_METHOD_set_init(EC_KEY_METHOD * meth,int (* init)(EC_KEY * key),void (* finish)(EC_KEY * key),int (* copy)(EC_KEY * dest,const EC_KEY * src),int (* set_group)(EC_KEY * key,const EC_GROUP * grp),int (* set_private)(EC_KEY * key,const BIGNUM * priv_key),int (* set_public)(EC_KEY * key,const EC_POINT * pub_key))622 EC_KEY_METHOD_set_init(EC_KEY_METHOD *meth,
623     int (*init)(EC_KEY *key),
624     void (*finish)(EC_KEY *key),
625     int (*copy)(EC_KEY *dest, const EC_KEY *src),
626     int (*set_group)(EC_KEY *key, const EC_GROUP *grp),
627     int (*set_private)(EC_KEY *key, const BIGNUM *priv_key),
628     int (*set_public)(EC_KEY *key, const EC_POINT *pub_key))
629 {
630 	meth->init = init;
631 	meth->finish = finish;
632 	meth->copy = copy;
633 	meth->set_group = set_group;
634 	meth->set_private = set_private;
635 	meth->set_public = set_public;
636 }
637 LCRYPTO_ALIAS(EC_KEY_METHOD_set_init);
638 
639 void
EC_KEY_METHOD_set_keygen(EC_KEY_METHOD * meth,int (* keygen)(EC_KEY * key))640 EC_KEY_METHOD_set_keygen(EC_KEY_METHOD *meth, int (*keygen)(EC_KEY *key))
641 {
642 	meth->keygen = keygen;
643 }
644 LCRYPTO_ALIAS(EC_KEY_METHOD_set_keygen);
645 
646 void
EC_KEY_METHOD_set_compute_key(EC_KEY_METHOD * meth,int (* ckey)(unsigned char ** out,size_t * out_len,const EC_POINT * pub_key,const EC_KEY * ecdh))647 EC_KEY_METHOD_set_compute_key(EC_KEY_METHOD *meth,
648     int (*ckey)(unsigned char **out, size_t *out_len, const EC_POINT *pub_key,
649         const EC_KEY *ecdh))
650 {
651 	meth->compute_key = ckey;
652 }
653 LCRYPTO_ALIAS(EC_KEY_METHOD_set_compute_key);
654 
655 void
EC_KEY_METHOD_set_sign(EC_KEY_METHOD * meth,int (* sign)(int type,const unsigned char * dgst,int dlen,unsigned char * sig,unsigned int * siglen,const BIGNUM * kinv,const BIGNUM * r,EC_KEY * eckey),int (* sign_setup)(EC_KEY * eckey,BN_CTX * ctx_in,BIGNUM ** kinvp,BIGNUM ** rp),ECDSA_SIG * (* sign_sig)(const unsigned char * dgst,int dgst_len,const BIGNUM * in_kinv,const BIGNUM * in_r,EC_KEY * eckey))656 EC_KEY_METHOD_set_sign(EC_KEY_METHOD *meth,
657     int (*sign)(int type, const unsigned char *dgst,
658 	int dlen, unsigned char *sig, unsigned int *siglen,
659 	const BIGNUM *kinv, const BIGNUM *r, EC_KEY *eckey),
660     int (*sign_setup)(EC_KEY *eckey, BN_CTX *ctx_in,
661 	BIGNUM **kinvp, BIGNUM **rp),
662     ECDSA_SIG *(*sign_sig)(const unsigned char *dgst,
663 	int dgst_len, const BIGNUM *in_kinv,
664 	const BIGNUM *in_r, EC_KEY *eckey))
665 {
666 	meth->sign = sign;
667 	meth->sign_setup = sign_setup;
668 	meth->sign_sig = sign_sig;
669 }
670 LCRYPTO_ALIAS(EC_KEY_METHOD_set_sign);
671 
672 void
EC_KEY_METHOD_set_verify(EC_KEY_METHOD * meth,int (* verify)(int type,const unsigned char * dgst,int dgst_len,const unsigned char * sigbuf,int sig_len,EC_KEY * eckey),int (* verify_sig)(const unsigned char * dgst,int dgst_len,const ECDSA_SIG * sig,EC_KEY * eckey))673 EC_KEY_METHOD_set_verify(EC_KEY_METHOD *meth,
674     int (*verify)(int type, const unsigned char *dgst, int dgst_len,
675 	const unsigned char *sigbuf, int sig_len, EC_KEY *eckey),
676     int (*verify_sig)(const unsigned char *dgst, int dgst_len,
677 	const ECDSA_SIG *sig, EC_KEY *eckey))
678 {
679 	meth->verify = verify;
680 	meth->verify_sig = verify_sig;
681 }
682 LCRYPTO_ALIAS(EC_KEY_METHOD_set_verify);
683 
684 
685 void
EC_KEY_METHOD_get_init(const EC_KEY_METHOD * meth,int (** pinit)(EC_KEY * key),void (** pfinish)(EC_KEY * key),int (** pcopy)(EC_KEY * dest,const EC_KEY * src),int (** pset_group)(EC_KEY * key,const EC_GROUP * grp),int (** pset_private)(EC_KEY * key,const BIGNUM * priv_key),int (** pset_public)(EC_KEY * key,const EC_POINT * pub_key))686 EC_KEY_METHOD_get_init(const EC_KEY_METHOD *meth,
687     int (**pinit)(EC_KEY *key),
688     void (**pfinish)(EC_KEY *key),
689     int (**pcopy)(EC_KEY *dest, const EC_KEY *src),
690     int (**pset_group)(EC_KEY *key, const EC_GROUP *grp),
691     int (**pset_private)(EC_KEY *key, const BIGNUM *priv_key),
692     int (**pset_public)(EC_KEY *key, const EC_POINT *pub_key))
693 {
694 	if (pinit != NULL)
695 		*pinit = meth->init;
696 	if (pfinish != NULL)
697 		*pfinish = meth->finish;
698 	if (pcopy != NULL)
699 		*pcopy = meth->copy;
700 	if (pset_group != NULL)
701 		*pset_group = meth->set_group;
702 	if (pset_private != NULL)
703 		*pset_private = meth->set_private;
704 	if (pset_public != NULL)
705 		*pset_public = meth->set_public;
706 }
707 LCRYPTO_ALIAS(EC_KEY_METHOD_get_init);
708 
709 void
EC_KEY_METHOD_get_keygen(const EC_KEY_METHOD * meth,int (** pkeygen)(EC_KEY * key))710 EC_KEY_METHOD_get_keygen(const EC_KEY_METHOD *meth,
711     int (**pkeygen)(EC_KEY *key))
712 {
713 	if (pkeygen != NULL)
714 		*pkeygen = meth->keygen;
715 }
716 LCRYPTO_ALIAS(EC_KEY_METHOD_get_keygen);
717 
718 void
EC_KEY_METHOD_get_compute_key(const EC_KEY_METHOD * meth,int (** pck)(unsigned char ** out,size_t * out_len,const EC_POINT * pub_key,const EC_KEY * ecdh))719 EC_KEY_METHOD_get_compute_key(const EC_KEY_METHOD *meth,
720     int (**pck)(unsigned char **out, size_t *out_len, const EC_POINT *pub_key,
721         const EC_KEY *ecdh))
722 {
723 	if (pck != NULL)
724 		*pck = meth->compute_key;
725 }
726 LCRYPTO_ALIAS(EC_KEY_METHOD_get_compute_key);
727 
728 void
EC_KEY_METHOD_get_sign(const EC_KEY_METHOD * meth,int (** psign)(int type,const unsigned char * dgst,int dlen,unsigned char * sig,unsigned int * siglen,const BIGNUM * kinv,const BIGNUM * r,EC_KEY * eckey),int (** psign_setup)(EC_KEY * eckey,BN_CTX * ctx_in,BIGNUM ** kinvp,BIGNUM ** rp),ECDSA_SIG * (** psign_sig)(const unsigned char * dgst,int dgst_len,const BIGNUM * in_kinv,const BIGNUM * in_r,EC_KEY * eckey))729 EC_KEY_METHOD_get_sign(const EC_KEY_METHOD *meth,
730     int (**psign)(int type, const unsigned char *dgst,
731 	int dlen, unsigned char *sig, unsigned int *siglen,
732 	const BIGNUM *kinv, const BIGNUM *r, EC_KEY *eckey),
733     int (**psign_setup)(EC_KEY *eckey, BN_CTX *ctx_in,
734 	BIGNUM **kinvp, BIGNUM **rp),
735     ECDSA_SIG *(**psign_sig)(const unsigned char *dgst,
736 	int dgst_len, const BIGNUM *in_kinv, const BIGNUM *in_r,
737 	EC_KEY *eckey))
738 {
739 	if (psign != NULL)
740 		*psign = meth->sign;
741 	if (psign_setup != NULL)
742 		*psign_setup = meth->sign_setup;
743 	if (psign_sig != NULL)
744 		*psign_sig = meth->sign_sig;
745 }
746 LCRYPTO_ALIAS(EC_KEY_METHOD_get_sign);
747 
748 void
EC_KEY_METHOD_get_verify(const EC_KEY_METHOD * meth,int (** pverify)(int type,const unsigned char * dgst,int dgst_len,const unsigned char * sigbuf,int sig_len,EC_KEY * eckey),int (** pverify_sig)(const unsigned char * dgst,int dgst_len,const ECDSA_SIG * sig,EC_KEY * eckey))749 EC_KEY_METHOD_get_verify(const EC_KEY_METHOD *meth,
750     int (**pverify)(int type, const unsigned char *dgst, int dgst_len,
751 	const unsigned char *sigbuf, int sig_len, EC_KEY *eckey),
752     int (**pverify_sig)(const unsigned char *dgst, int dgst_len,
753 	const ECDSA_SIG *sig, EC_KEY *eckey))
754 {
755 	if (pverify != NULL)
756 		*pverify = meth->verify;
757 	if (pverify_sig != NULL)
758 		*pverify_sig = meth->verify_sig;
759 }
760 LCRYPTO_ALIAS(EC_KEY_METHOD_get_verify);
761 
762 static const EC_KEY_METHOD openssl_ec_key_method = {
763 	.name = "OpenSSL EC_KEY method",
764 	.flags = 0,
765 
766 	.init = NULL,
767 	.finish = NULL,
768 	.copy = NULL,
769 
770 	.set_group = NULL,
771 	.set_private = NULL,
772 	.set_public = NULL,
773 
774 	.keygen = ec_key_gen,
775 	.compute_key = ecdh_compute_key,
776 
777 	.sign = ecdsa_sign,
778 	.sign_setup = ecdsa_sign_setup,
779 	.sign_sig = ecdsa_sign_sig,
780 
781 	.verify = ecdsa_verify,
782 	.verify_sig = ecdsa_verify_sig,
783 };
784 
785 const EC_KEY_METHOD *
EC_KEY_OpenSSL(void)786 EC_KEY_OpenSSL(void)
787 {
788 	return &openssl_ec_key_method;
789 }
790 LCRYPTO_ALIAS(EC_KEY_OpenSSL);
791 
792 const EC_KEY_METHOD *default_ec_key_meth = &openssl_ec_key_method;
793 
794 const EC_KEY_METHOD *
EC_KEY_get_default_method(void)795 EC_KEY_get_default_method(void)
796 {
797 	return default_ec_key_meth;
798 }
799 LCRYPTO_ALIAS(EC_KEY_get_default_method);
800 
801 void
EC_KEY_set_default_method(const EC_KEY_METHOD * meth)802 EC_KEY_set_default_method(const EC_KEY_METHOD *meth)
803 {
804 	if (meth == NULL)
805 		default_ec_key_meth = &openssl_ec_key_method;
806 	else
807 		default_ec_key_meth = meth;
808 }
809 LCRYPTO_ALIAS(EC_KEY_set_default_method);
810