Branch data Line data Source code
1 : : /* crypto/ec/ec_key.c */
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 : : #define OPENSSL_FIPSAPI
65 : :
66 : : #include <string.h>
67 : : #include "ec_lcl.h"
68 : : #include <openssl/err.h>
69 : : #include <string.h>
70 : :
71 : 4398 : EC_KEY *EC_KEY_new(void)
72 : : {
73 : : EC_KEY *ret;
74 : :
75 : 4398 : ret=(EC_KEY *)OPENSSL_malloc(sizeof(EC_KEY));
76 [ - + ]: 4398 : if (ret == NULL)
77 : : {
78 : 0 : ECerr(EC_F_EC_KEY_NEW, ERR_R_MALLOC_FAILURE);
79 : 0 : return(NULL);
80 : : }
81 : :
82 : 4398 : ret->version = 1;
83 : 4398 : ret->flags = 0;
84 : 4398 : ret->group = NULL;
85 : 4398 : ret->pub_key = NULL;
86 : 4398 : ret->priv_key= NULL;
87 : 4398 : ret->enc_flag= 0;
88 : 4398 : ret->conv_form = POINT_CONVERSION_UNCOMPRESSED;
89 : 4398 : ret->references= 1;
90 : 4398 : ret->method_data = NULL;
91 : 4398 : return(ret);
92 : : }
93 : :
94 : 911 : EC_KEY *EC_KEY_new_by_curve_name(int nid)
95 : : {
96 : 911 : EC_KEY *ret = EC_KEY_new();
97 [ + - ]: 911 : if (ret == NULL)
98 : : return NULL;
99 : 911 : ret->group = EC_GROUP_new_by_curve_name(nid);
100 [ - + ]: 911 : if (ret->group == NULL)
101 : : {
102 : 0 : EC_KEY_free(ret);
103 : 0 : return NULL;
104 : : }
105 : : return ret;
106 : : }
107 : :
108 : 4401 : void EC_KEY_free(EC_KEY *r)
109 : : {
110 : : int i;
111 : :
112 [ + - ]: 4401 : if (r == NULL) return;
113 : :
114 : 4401 : i=CRYPTO_add(&r->references,-1,CRYPTO_LOCK_EC);
115 : : #ifdef REF_PRINT
116 : : REF_PRINT("EC_KEY",r);
117 : : #endif
118 [ + + ]: 4401 : if (i > 0) return;
119 : : #ifdef REF_CHECK
120 : : if (i < 0)
121 : : {
122 : : fprintf(stderr,"EC_KEY_free, bad reference count\n");
123 : : abort();
124 : : }
125 : : #endif
126 : :
127 [ + - ]: 4398 : if (r->group != NULL)
128 : 4398 : EC_GROUP_free(r->group);
129 [ + + ]: 4398 : if (r->pub_key != NULL)
130 : 3052 : EC_POINT_free(r->pub_key);
131 [ + + ]: 4398 : if (r->priv_key != NULL)
132 : 3046 : BN_clear_free(r->priv_key);
133 : :
134 : 4398 : EC_EX_DATA_free_all_data(&r->method_data);
135 : :
136 : 4398 : OPENSSL_cleanse((void *)r, sizeof(EC_KEY));
137 : :
138 : 4398 : OPENSSL_free(r);
139 : : }
140 : :
141 : 1942 : EC_KEY *EC_KEY_copy(EC_KEY *dest, const EC_KEY *src)
142 : : {
143 : : EC_EXTRA_DATA *d;
144 : :
145 [ - + ]: 1942 : if (dest == NULL || src == NULL)
146 : : {
147 : 0 : ECerr(EC_F_EC_KEY_COPY, ERR_R_PASSED_NULL_PARAMETER);
148 : 0 : return NULL;
149 : : }
150 : : /* copy the parameters */
151 [ + - ]: 1942 : if (src->group)
152 : : {
153 : 1942 : const EC_METHOD *meth = EC_GROUP_method_of(src->group);
154 : : /* clear the old group */
155 [ - + ]: 1942 : if (dest->group)
156 : 0 : EC_GROUP_free(dest->group);
157 : 1942 : dest->group = EC_GROUP_new(meth);
158 [ + - ]: 1942 : if (dest->group == NULL)
159 : : return NULL;
160 [ + - ]: 1942 : if (!EC_GROUP_copy(dest->group, src->group))
161 : : return NULL;
162 : : }
163 : : /* copy the public key */
164 [ + + ][ + - ]: 1942 : if (src->pub_key && src->group)
165 : : {
166 [ - + ]: 1203 : if (dest->pub_key)
167 : 0 : EC_POINT_free(dest->pub_key);
168 : 1203 : dest->pub_key = EC_POINT_new(src->group);
169 [ + - ]: 1203 : if (dest->pub_key == NULL)
170 : : return NULL;
171 [ + - ]: 1203 : if (!EC_POINT_copy(dest->pub_key, src->pub_key))
172 : : return NULL;
173 : : }
174 : : /* copy the private key */
175 [ + + ]: 1942 : if (src->priv_key)
176 : : {
177 [ + - ]: 1203 : if (dest->priv_key == NULL)
178 : : {
179 : 1203 : dest->priv_key = BN_new();
180 [ + - ]: 1203 : if (dest->priv_key == NULL)
181 : : return NULL;
182 : : }
183 [ + - ]: 1203 : if (!BN_copy(dest->priv_key, src->priv_key))
184 : : return NULL;
185 : : }
186 : : /* copy method/extra data */
187 : 1942 : EC_EX_DATA_free_all_data(&dest->method_data);
188 : :
189 [ - + ]: 1942 : for (d = src->method_data; d != NULL; d = d->next)
190 : : {
191 : 0 : void *t = d->dup_func(d->data);
192 : :
193 [ # # ]: 0 : if (t == NULL)
194 : : return 0;
195 [ # # ]: 0 : if (!EC_EX_DATA_set_data(&dest->method_data, t, d->dup_func, d->free_func, d->clear_free_func))
196 : : return 0;
197 : : }
198 : :
199 : : /* copy the rest */
200 : 1942 : dest->enc_flag = src->enc_flag;
201 : 1942 : dest->conv_form = src->conv_form;
202 : 1942 : dest->version = src->version;
203 : 1942 : dest->flags = src->flags;
204 : :
205 : 1942 : return dest;
206 : : }
207 : :
208 : 1942 : EC_KEY *EC_KEY_dup(const EC_KEY *ec_key)
209 : : {
210 : 1942 : EC_KEY *ret = EC_KEY_new();
211 [ + - ]: 1942 : if (ret == NULL)
212 : : return NULL;
213 [ - + ]: 1942 : if (EC_KEY_copy(ret, ec_key) == NULL)
214 : : {
215 : 0 : EC_KEY_free(ret);
216 : 0 : return NULL;
217 : : }
218 : : return ret;
219 : : }
220 : :
221 : 3 : int EC_KEY_up_ref(EC_KEY *r)
222 : : {
223 : 3 : int i = CRYPTO_add(&r->references, 1, CRYPTO_LOCK_EC);
224 : : #ifdef REF_PRINT
225 : : REF_PRINT("EC_KEY",r);
226 : : #endif
227 : : #ifdef REF_CHECK
228 : : if (i < 2)
229 : : {
230 : : fprintf(stderr, "EC_KEY_up, bad reference count\n");
231 : : abort();
232 : : }
233 : : #endif
234 : 3 : return ((i > 1) ? 1 : 0);
235 : : }
236 : :
237 : : #ifdef OPENSSL_FIPS
238 : :
239 : : #include <openssl/evp.h>
240 : : #include <openssl/fips.h>
241 : : #include <openssl/fips_rand.h>
242 : :
243 : : static int fips_check_ec(EC_KEY *key)
244 : : {
245 : : EVP_PKEY pk;
246 : : unsigned char tbs[] = "ECDSA Pairwise Check Data";
247 : : pk.type = EVP_PKEY_EC;
248 : : pk.pkey.ec = key;
249 : :
250 : : if (!fips_pkey_signature_test(FIPS_TEST_PAIRWISE,
251 : : &pk, tbs, 0, NULL, 0, NULL, 0, NULL))
252 : : {
253 : : FIPSerr(FIPS_F_FIPS_CHECK_EC,FIPS_R_PAIRWISE_TEST_FAILED);
254 : : fips_set_selftest_fail();
255 : : return 0;
256 : : }
257 : : return 1;
258 : : }
259 : :
260 : : int fips_check_ec_prng(EC_KEY *ec)
261 : : {
262 : : int bits, strength;
263 : : if (!FIPS_module_mode())
264 : : return 1;
265 : :
266 : : if (ec->flags & (EC_FLAG_NON_FIPS_ALLOW|EC_FLAG_FIPS_CHECKED))
267 : : return 1;
268 : :
269 : : if (!ec->group)
270 : : return 1;
271 : :
272 : : bits = BN_num_bits(&ec->group->order);
273 : :
274 : : if (bits < 160)
275 : : {
276 : : FIPSerr(FIPS_F_FIPS_CHECK_EC_PRNG,FIPS_R_KEY_TOO_SHORT);
277 : : return 0;
278 : : }
279 : : /* Comparable algorithm strengths: from SP800-57 table 2 */
280 : : if (bits >= 512)
281 : : strength = 256;
282 : : else if (bits >= 384)
283 : : strength = 192;
284 : : else if (bits >= 256)
285 : : strength = 128;
286 : : else if (bits >= 224)
287 : : strength = 112;
288 : : else
289 : : strength = 80;
290 : :
291 : :
292 : : if (FIPS_rand_strength() >= strength)
293 : : return 1;
294 : :
295 : : FIPSerr(FIPS_F_FIPS_CHECK_EC_PRNG,FIPS_R_PRNG_STRENGTH_TOO_LOW);
296 : : return 0;
297 : :
298 : : }
299 : :
300 : : #endif
301 : :
302 : 1834 : int EC_KEY_generate_key(EC_KEY *eckey)
303 : : {
304 : 1834 : int ok = 0;
305 : 1834 : BN_CTX *ctx = NULL;
306 : 1834 : BIGNUM *priv_key = NULL, *order = NULL;
307 : 1834 : EC_POINT *pub_key = NULL;
308 : :
309 : : #ifdef OPENSSL_FIPS
310 : : if(FIPS_selftest_failed())
311 : : {
312 : : FIPSerr(FIPS_F_EC_KEY_GENERATE_KEY,FIPS_R_FIPS_SELFTEST_FAILED);
313 : : return 0;
314 : : }
315 : : #endif
316 : :
317 [ + - ][ - + ]: 1834 : if (!eckey || !eckey->group)
318 : : {
319 : 0 : ECerr(EC_F_EC_KEY_GENERATE_KEY, ERR_R_PASSED_NULL_PARAMETER);
320 : 0 : return 0;
321 : : }
322 : :
323 [ + - ]: 1834 : if ((order = BN_new()) == NULL) goto err;
324 [ + - ]: 1834 : if ((ctx = BN_CTX_new()) == NULL) goto err;
325 : :
326 [ + + ]: 1834 : if (eckey->priv_key == NULL)
327 : : {
328 : 1372 : priv_key = BN_new();
329 [ + - ]: 1372 : if (priv_key == NULL)
330 : : goto err;
331 : : }
332 : : else
333 : : priv_key = eckey->priv_key;
334 : :
335 [ + - ]: 1834 : if (!EC_GROUP_get_order(eckey->group, order, ctx))
336 : : goto err;
337 : :
338 : : #ifdef OPENSSL_FIPS
339 : : if (!fips_check_ec_prng(eckey))
340 : : goto err;
341 : : #endif
342 : :
343 : : do
344 [ + - ]: 1834 : if (!BN_rand_range(priv_key, order))
345 : : goto err;
346 [ - + ]: 1834 : while (BN_is_zero(priv_key));
347 : :
348 [ + + ]: 1834 : if (eckey->pub_key == NULL)
349 : : {
350 : 1372 : pub_key = EC_POINT_new(eckey->group);
351 [ + - ]: 1372 : if (pub_key == NULL)
352 : : goto err;
353 : : }
354 : : else
355 : : pub_key = eckey->pub_key;
356 : :
357 [ + - ]: 1834 : if (!EC_POINT_mul(eckey->group, pub_key, priv_key, NULL, NULL, ctx))
358 : : goto err;
359 : :
360 : 1834 : eckey->priv_key = priv_key;
361 : 1834 : eckey->pub_key = pub_key;
362 : :
363 : : #ifdef OPENSSL_FIPS
364 : : if(!fips_check_ec(eckey))
365 : : {
366 : : eckey->priv_key = NULL;
367 : : eckey->pub_key = NULL;
368 : : goto err;
369 : : }
370 : : #endif
371 : :
372 : 1834 : ok=1;
373 : :
374 : : err:
375 [ + - ]: 1834 : if (order)
376 : 1834 : BN_free(order);
377 [ + - ][ - + ]: 1834 : if (pub_key != NULL && eckey->pub_key == NULL)
378 : 0 : EC_POINT_free(pub_key);
379 [ + - ][ - + ]: 1834 : if (priv_key != NULL && eckey->priv_key == NULL)
380 : 0 : BN_free(priv_key);
381 [ + - ]: 1834 : if (ctx != NULL)
382 : 1834 : BN_CTX_free(ctx);
383 : 1834 : return(ok);
384 : : }
385 : :
386 : 67 : int EC_KEY_check_key(const EC_KEY *eckey)
387 : : {
388 : 67 : int ok = 0;
389 : 67 : BN_CTX *ctx = NULL;
390 : 67 : const BIGNUM *order = NULL;
391 : 67 : EC_POINT *point = NULL;
392 : :
393 [ + - ][ + - ]: 67 : if (!eckey || !eckey->group || !eckey->pub_key)
[ - + ]
394 : : {
395 : 0 : ECerr(EC_F_EC_KEY_CHECK_KEY, ERR_R_PASSED_NULL_PARAMETER);
396 : 0 : return 0;
397 : : }
398 : :
399 [ - + ]: 67 : if (EC_POINT_is_at_infinity(eckey->group, eckey->pub_key))
400 : : {
401 : 0 : ECerr(EC_F_EC_KEY_CHECK_KEY, EC_R_POINT_AT_INFINITY);
402 : 0 : goto err;
403 : : }
404 : :
405 [ + - ]: 67 : if ((ctx = BN_CTX_new()) == NULL)
406 : : goto err;
407 [ + - ]: 67 : if ((point = EC_POINT_new(eckey->group)) == NULL)
408 : : goto err;
409 : :
410 : : /* testing whether the pub_key is on the elliptic curve */
411 [ - + ]: 67 : if (!EC_POINT_is_on_curve(eckey->group, eckey->pub_key, ctx))
412 : : {
413 : 0 : ECerr(EC_F_EC_KEY_CHECK_KEY, EC_R_POINT_IS_NOT_ON_CURVE);
414 : 0 : goto err;
415 : : }
416 : : /* testing whether pub_key * order is the point at infinity */
417 : 67 : order = &eckey->group->order;
418 [ - + ]: 67 : if (BN_is_zero(order))
419 : : {
420 : 0 : ECerr(EC_F_EC_KEY_CHECK_KEY, EC_R_INVALID_GROUP_ORDER);
421 : 0 : goto err;
422 : : }
423 [ - + ]: 67 : if (!EC_POINT_mul(eckey->group, point, NULL, eckey->pub_key, order, ctx))
424 : : {
425 : 0 : ECerr(EC_F_EC_KEY_CHECK_KEY, ERR_R_EC_LIB);
426 : 0 : goto err;
427 : : }
428 [ - + ]: 67 : if (!EC_POINT_is_at_infinity(eckey->group, point))
429 : : {
430 : 0 : ECerr(EC_F_EC_KEY_CHECK_KEY, EC_R_WRONG_ORDER);
431 : 0 : goto err;
432 : : }
433 : : /* in case the priv_key is present :
434 : : * check if generator * priv_key == pub_key
435 : : */
436 [ + - ]: 67 : if (eckey->priv_key)
437 : : {
438 [ - + ]: 67 : if (BN_cmp(eckey->priv_key, order) >= 0)
439 : : {
440 : 0 : ECerr(EC_F_EC_KEY_CHECK_KEY, EC_R_WRONG_ORDER);
441 : 0 : goto err;
442 : : }
443 [ - + ]: 67 : if (!EC_POINT_mul(eckey->group, point, eckey->priv_key,
444 : : NULL, NULL, ctx))
445 : : {
446 : 0 : ECerr(EC_F_EC_KEY_CHECK_KEY, ERR_R_EC_LIB);
447 : 0 : goto err;
448 : : }
449 [ - + ]: 67 : if (EC_POINT_cmp(eckey->group, point, eckey->pub_key,
450 : : ctx) != 0)
451 : : {
452 : 0 : ECerr(EC_F_EC_KEY_CHECK_KEY, EC_R_INVALID_PRIVATE_KEY);
453 : 0 : goto err;
454 : : }
455 : : }
456 : : ok = 1;
457 : : err:
458 [ + - ]: 67 : if (ctx != NULL)
459 : 67 : BN_CTX_free(ctx);
460 [ + - ]: 67 : if (point != NULL)
461 : 67 : EC_POINT_free(point);
462 : 67 : return(ok);
463 : : }
464 : :
465 : 0 : int EC_KEY_set_public_key_affine_coordinates(EC_KEY *key, BIGNUM *x, BIGNUM *y)
466 : : {
467 : 0 : BN_CTX *ctx = NULL;
468 : : BIGNUM *tx, *ty;
469 : 0 : EC_POINT *point = NULL;
470 : 0 : int ok = 0, tmp_nid, is_char_two = 0;
471 : :
472 [ # # ][ # # ]: 0 : if (!key || !key->group || !x || !y)
[ # # ]
473 : : {
474 : 0 : ECerr(EC_F_EC_KEY_SET_PUBLIC_KEY_AFFINE_COORDINATES,
475 : : ERR_R_PASSED_NULL_PARAMETER);
476 : 0 : return 0;
477 : : }
478 : 0 : ctx = BN_CTX_new();
479 [ # # ]: 0 : if (!ctx)
480 : : goto err;
481 : :
482 : 0 : point = EC_POINT_new(key->group);
483 : :
484 [ # # ]: 0 : if (!point)
485 : : goto err;
486 : :
487 : 0 : tmp_nid = EC_METHOD_get_field_type(EC_GROUP_method_of(key->group));
488 : :
489 [ # # ]: 0 : if (tmp_nid == NID_X9_62_characteristic_two_field)
490 : 0 : is_char_two = 1;
491 : :
492 : 0 : tx = BN_CTX_get(ctx);
493 : 0 : ty = BN_CTX_get(ctx);
494 : : #ifndef OPENSSL_NO_EC2M
495 [ # # ]: 0 : if (is_char_two)
496 : : {
497 [ # # ]: 0 : if (!EC_POINT_set_affine_coordinates_GF2m(key->group, point,
498 : : x, y, ctx))
499 : : goto err;
500 [ # # ]: 0 : if (!EC_POINT_get_affine_coordinates_GF2m(key->group, point,
501 : : tx, ty, ctx))
502 : : goto err;
503 : : }
504 : : else
505 : : #endif
506 : : {
507 [ # # ]: 0 : if (!EC_POINT_set_affine_coordinates_GFp(key->group, point,
508 : : x, y, ctx))
509 : : goto err;
510 [ # # ]: 0 : if (!EC_POINT_get_affine_coordinates_GFp(key->group, point,
511 : : tx, ty, ctx))
512 : : goto err;
513 : : }
514 : : /* Check if retrieved coordinates match originals and are less than
515 : : * field order: if not values are out of range.
516 : : */
517 [ # # ][ # # ]: 0 : if (BN_cmp(x, tx) || BN_cmp(y, ty)
518 [ # # ]: 0 : || (BN_cmp(x, &key->group->field) >= 0)
519 [ # # ]: 0 : || (BN_cmp(y, &key->group->field) >= 0))
520 : : {
521 : 0 : ECerr(EC_F_EC_KEY_SET_PUBLIC_KEY_AFFINE_COORDINATES,
522 : : EC_R_COORDINATES_OUT_OF_RANGE);
523 : 0 : goto err;
524 : : }
525 : :
526 [ # # ]: 0 : if (!EC_KEY_set_public_key(key, point))
527 : : goto err;
528 : :
529 [ # # ]: 0 : if (EC_KEY_check_key(key) == 0)
530 : : goto err;
531 : :
532 : 0 : ok = 1;
533 : :
534 : : err:
535 [ # # ]: 0 : if (ctx)
536 : 0 : BN_CTX_free(ctx);
537 [ # # ]: 0 : if (point)
538 : 0 : EC_POINT_free(point);
539 : 0 : return ok;
540 : :
541 : : }
542 : :
543 : 4049 : const EC_GROUP *EC_KEY_get0_group(const EC_KEY *key)
544 : : {
545 : 4049 : return key->group;
546 : : }
547 : :
548 : 1545 : int EC_KEY_set_group(EC_KEY *key, const EC_GROUP *group)
549 : : {
550 [ - + ]: 1545 : if (key->group != NULL)
551 : 0 : EC_GROUP_free(key->group);
552 : 1545 : key->group = EC_GROUP_dup(group);
553 : 1545 : return (key->group == NULL) ? 0 : 1;
554 : : }
555 : :
556 : 2490 : const BIGNUM *EC_KEY_get0_private_key(const EC_KEY *key)
557 : : {
558 : 2490 : return key->priv_key;
559 : : }
560 : :
561 : 468 : int EC_KEY_set_private_key(EC_KEY *key, const BIGNUM *priv_key)
562 : : {
563 [ - + ]: 468 : if (key->priv_key)
564 : 0 : BN_clear_free(key->priv_key);
565 : 468 : key->priv_key = BN_dup(priv_key);
566 : 468 : return (key->priv_key == NULL) ? 0 : 1;
567 : : }
568 : :
569 : 3648 : const EC_POINT *EC_KEY_get0_public_key(const EC_KEY *key)
570 : : {
571 : 3648 : return key->pub_key;
572 : : }
573 : :
574 : 468 : int EC_KEY_set_public_key(EC_KEY *key, const EC_POINT *pub_key)
575 : : {
576 [ - + ]: 468 : if (key->pub_key != NULL)
577 : 0 : EC_POINT_free(key->pub_key);
578 : 468 : key->pub_key = EC_POINT_dup(pub_key, key->group);
579 : 468 : return (key->pub_key == NULL) ? 0 : 1;
580 : : }
581 : :
582 : 0 : unsigned int EC_KEY_get_enc_flags(const EC_KEY *key)
583 : : {
584 : 0 : return key->enc_flag;
585 : : }
586 : :
587 : 0 : void EC_KEY_set_enc_flags(EC_KEY *key, unsigned int flags)
588 : : {
589 : 0 : key->enc_flag = flags;
590 : 0 : }
591 : :
592 : 0 : point_conversion_form_t EC_KEY_get_conv_form(const EC_KEY *key)
593 : : {
594 : 0 : return key->conv_form;
595 : : }
596 : :
597 : 0 : void EC_KEY_set_conv_form(EC_KEY *key, point_conversion_form_t cform)
598 : : {
599 : 0 : key->conv_form = cform;
600 [ # # ]: 0 : if (key->group != NULL)
601 : 0 : EC_GROUP_set_point_conversion_form(key->group, cform);
602 : 0 : }
603 : :
604 : 1451 : void *EC_KEY_get_key_method_data(EC_KEY *key,
605 : : void *(*dup_func)(void *), void (*free_func)(void *), void (*clear_free_func)(void *))
606 : : {
607 : : void *ret;
608 : :
609 : 1451 : CRYPTO_r_lock(CRYPTO_LOCK_EC);
610 : 1451 : ret = EC_EX_DATA_get_data(key->method_data, dup_func, free_func, clear_free_func);
611 : 1451 : CRYPTO_r_unlock(CRYPTO_LOCK_EC);
612 : :
613 : 1451 : return ret;
614 : : }
615 : :
616 : 1104 : void *EC_KEY_insert_key_method_data(EC_KEY *key, void *data,
617 : : void *(*dup_func)(void *), void (*free_func)(void *), void (*clear_free_func)(void *))
618 : : {
619 : : EC_EXTRA_DATA *ex_data;
620 : :
621 : 1104 : CRYPTO_w_lock(CRYPTO_LOCK_EC);
622 : 1104 : ex_data = EC_EX_DATA_get_data(key->method_data, dup_func, free_func, clear_free_func);
623 [ + - ]: 1104 : if (ex_data == NULL)
624 : 1104 : EC_EX_DATA_set_data(&key->method_data, data, dup_func, free_func, clear_free_func);
625 : 1104 : CRYPTO_w_unlock(CRYPTO_LOCK_EC);
626 : :
627 : 1104 : return ex_data;
628 : : }
629 : :
630 : 0 : void EC_KEY_set_asn1_flag(EC_KEY *key, int flag)
631 : : {
632 [ # # ]: 0 : if (key->group != NULL)
633 : 0 : EC_GROUP_set_asn1_flag(key->group, flag);
634 : 0 : }
635 : :
636 : 0 : int EC_KEY_precompute_mult(EC_KEY *key, BN_CTX *ctx)
637 : : {
638 [ # # ]: 0 : if (key->group == NULL)
639 : : return 0;
640 : 0 : return EC_GROUP_precompute_mult(key->group, ctx);
641 : : }
642 : :
643 : 968 : int EC_KEY_get_flags(const EC_KEY *key)
644 : : {
645 : 968 : return key->flags;
646 : : }
647 : :
648 : 2 : void EC_KEY_set_flags(EC_KEY *key, int flags)
649 : : {
650 : 2 : key->flags |= flags;
651 : 2 : }
652 : :
653 : 0 : void EC_KEY_clear_flags(EC_KEY *key, int flags)
654 : : {
655 : 0 : key->flags &= ~flags;
656 : 0 : }
|
