477d4a26ba9606c3fba9534608e13c05164ae7d1
[openssl.git] / crypto / ec / ec_key.c
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 #include <internal/cryptlib.h>
65 #include <string.h>
66 #include "ec_lcl.h"
67 #include <openssl/err.h>
68
69 EC_KEY *EC_KEY_new(void)
70 {
71     return EC_KEY_new_method(NULL);
72 }
73
74 EC_KEY *EC_KEY_new_by_curve_name(int nid)
75 {
76     EC_KEY *ret = EC_KEY_new();
77     if (ret == NULL)
78         return NULL;
79     ret->group = EC_GROUP_new_by_curve_name(nid);
80     if (ret->group == NULL) {
81         EC_KEY_free(ret);
82         return NULL;
83     }
84     return ret;
85 }
86
87 void EC_KEY_free(EC_KEY *r)
88 {
89     int i;
90
91     if (r == NULL)
92         return;
93
94     i = CRYPTO_add(&r->references, -1, CRYPTO_LOCK_EC);
95 #ifdef REF_PRINT
96     REF_PRINT("EC_KEY", r);
97 #endif
98     if (i > 0)
99         return;
100 #ifdef REF_CHECK
101     if (i < 0) {
102         fprintf(stderr, "EC_KEY_free, bad reference count\n");
103         abort();
104     }
105 #endif
106
107     EC_GROUP_free(r->group);
108     EC_POINT_free(r->pub_key);
109     BN_clear_free(r->priv_key);
110
111     EC_EX_DATA_free_all_data(&r->method_data);
112
113     OPENSSL_clear_free((void *)r, sizeof(EC_KEY));
114 }
115
116 EC_KEY *EC_KEY_copy(EC_KEY *dest, const EC_KEY *src)
117 {
118     EC_EXTRA_DATA *d;
119
120     if (dest == NULL || src == NULL) {
121         ECerr(EC_F_EC_KEY_COPY, ERR_R_PASSED_NULL_PARAMETER);
122         return NULL;
123     }
124     /* copy the parameters */
125     if (src->group) {
126         const EC_METHOD *meth = EC_GROUP_method_of(src->group);
127         /* clear the old group */
128         EC_GROUP_free(dest->group);
129         dest->group = EC_GROUP_new(meth);
130         if (dest->group == NULL)
131             return NULL;
132         if (!EC_GROUP_copy(dest->group, src->group))
133             return NULL;
134     }
135     /*  copy the public key */
136     if (src->pub_key && src->group) {
137         EC_POINT_free(dest->pub_key);
138         dest->pub_key = EC_POINT_new(src->group);
139         if (dest->pub_key == NULL)
140             return NULL;
141         if (!EC_POINT_copy(dest->pub_key, src->pub_key))
142             return NULL;
143     }
144     /* copy the private key */
145     if (src->priv_key) {
146         if (dest->priv_key == NULL) {
147             dest->priv_key = BN_new();
148             if (dest->priv_key == NULL)
149                 return NULL;
150         }
151         if (!BN_copy(dest->priv_key, src->priv_key))
152             return NULL;
153     }
154     /* copy method/extra data */
155     EC_EX_DATA_free_all_data(&dest->method_data);
156
157     for (d = src->method_data; d != NULL; d = d->next) {
158         void *t = d->dup_func(d->data);
159
160         if (t == NULL)
161             return 0;
162         if (!EC_EX_DATA_set_data
163             (&dest->method_data, t, d->dup_func, d->free_func,
164              d->clear_free_func))
165             return 0;
166     }
167
168     /* copy the rest */
169     dest->enc_flag = src->enc_flag;
170     dest->conv_form = src->conv_form;
171     dest->version = src->version;
172     dest->flags = src->flags;
173
174     return dest;
175 }
176
177 EC_KEY *EC_KEY_dup(const EC_KEY *ec_key)
178 {
179     EC_KEY *ret = EC_KEY_new();
180     if (ret == NULL)
181         return NULL;
182     if (EC_KEY_copy(ret, ec_key) == NULL) {
183         EC_KEY_free(ret);
184         return NULL;
185     }
186     return ret;
187 }
188
189 int EC_KEY_up_ref(EC_KEY *r)
190 {
191     int i = CRYPTO_add(&r->references, 1, CRYPTO_LOCK_EC);
192 #ifdef REF_PRINT
193     REF_PRINT("EC_KEY", r);
194 #endif
195 #ifdef REF_CHECK
196     if (i < 2) {
197         fprintf(stderr, "EC_KEY_up, bad reference count\n");
198         abort();
199     }
200 #endif
201     return ((i > 1) ? 1 : 0);
202 }
203
204 int EC_KEY_generate_key(EC_KEY *eckey)
205 {
206     if (!eckey || !eckey->group) {
207         ECerr(EC_F_EC_KEY_GENERATE_KEY, ERR_R_PASSED_NULL_PARAMETER);
208         return 0;
209     }
210     if (eckey->meth->keygen)
211         return eckey->meth->keygen(eckey);
212     ECerr(EC_F_EC_KEY_GENERATE_KEY, EC_R_OPERATION_NOT_SUPPORTED);
213     return 0;
214 }
215
216 int ossl_ec_key_gen(EC_KEY *eckey)
217 {
218     int ok = 0;
219     BN_CTX *ctx = NULL;
220     BIGNUM *priv_key = NULL, *order = NULL;
221     EC_POINT *pub_key = NULL;
222
223     if ((order = BN_new()) == NULL)
224         goto err;
225     if ((ctx = BN_CTX_new()) == NULL)
226         goto err;
227
228     if (eckey->priv_key == NULL) {
229         priv_key = BN_new();
230         if (priv_key == NULL)
231             goto err;
232     } else
233         priv_key = eckey->priv_key;
234
235     if (!EC_GROUP_get_order(eckey->group, order, ctx))
236         goto err;
237
238     do
239         if (!BN_rand_range(priv_key, order))
240             goto err;
241     while (BN_is_zero(priv_key)) ;
242
243     if (eckey->pub_key == NULL) {
244         pub_key = EC_POINT_new(eckey->group);
245         if (pub_key == NULL)
246             goto err;
247     } else
248         pub_key = eckey->pub_key;
249
250     if (!EC_POINT_mul(eckey->group, pub_key, priv_key, NULL, NULL, ctx))
251         goto err;
252
253     eckey->priv_key = priv_key;
254     eckey->pub_key = pub_key;
255
256     ok = 1;
257
258  err:
259     BN_free(order);
260     if (eckey->pub_key == NULL)
261         EC_POINT_free(pub_key);
262     if (eckey->priv_key != priv_key)
263         BN_free(priv_key);
264     BN_CTX_free(ctx);
265     return (ok);
266 }
267
268 int EC_KEY_check_key(const EC_KEY *eckey)
269 {
270     int ok = 0;
271     BN_CTX *ctx = NULL;
272     const BIGNUM *order = NULL;
273     EC_POINT *point = NULL;
274
275     if (!eckey || !eckey->group || !eckey->pub_key) {
276         ECerr(EC_F_EC_KEY_CHECK_KEY, ERR_R_PASSED_NULL_PARAMETER);
277         return 0;
278     }
279
280     if (EC_POINT_is_at_infinity(eckey->group, eckey->pub_key)) {
281         ECerr(EC_F_EC_KEY_CHECK_KEY, EC_R_POINT_AT_INFINITY);
282         goto err;
283     }
284
285     if ((ctx = BN_CTX_new()) == NULL)
286         goto err;
287     if ((point = EC_POINT_new(eckey->group)) == NULL)
288         goto err;
289
290     /* testing whether the pub_key is on the elliptic curve */
291     if (EC_POINT_is_on_curve(eckey->group, eckey->pub_key, ctx) <= 0) {
292         ECerr(EC_F_EC_KEY_CHECK_KEY, EC_R_POINT_IS_NOT_ON_CURVE);
293         goto err;
294     }
295     /* testing whether pub_key * order is the point at infinity */
296     order = eckey->group->order;
297     if (BN_is_zero(order)) {
298         ECerr(EC_F_EC_KEY_CHECK_KEY, EC_R_INVALID_GROUP_ORDER);
299         goto err;
300     }
301     if (!EC_POINT_mul(eckey->group, point, NULL, eckey->pub_key, order, ctx)) {
302         ECerr(EC_F_EC_KEY_CHECK_KEY, ERR_R_EC_LIB);
303         goto err;
304     }
305     if (!EC_POINT_is_at_infinity(eckey->group, point)) {
306         ECerr(EC_F_EC_KEY_CHECK_KEY, EC_R_WRONG_ORDER);
307         goto err;
308     }
309     /*
310      * in case the priv_key is present : check if generator * priv_key ==
311      * pub_key
312      */
313     if (eckey->priv_key) {
314         if (BN_cmp(eckey->priv_key, order) >= 0) {
315             ECerr(EC_F_EC_KEY_CHECK_KEY, EC_R_WRONG_ORDER);
316             goto err;
317         }
318         if (!EC_POINT_mul(eckey->group, point, eckey->priv_key,
319                           NULL, NULL, ctx)) {
320             ECerr(EC_F_EC_KEY_CHECK_KEY, ERR_R_EC_LIB);
321             goto err;
322         }
323         if (EC_POINT_cmp(eckey->group, point, eckey->pub_key, ctx) != 0) {
324             ECerr(EC_F_EC_KEY_CHECK_KEY, EC_R_INVALID_PRIVATE_KEY);
325             goto err;
326         }
327     }
328     ok = 1;
329  err:
330     BN_CTX_free(ctx);
331     EC_POINT_free(point);
332     return (ok);
333 }
334
335 int EC_KEY_set_public_key_affine_coordinates(EC_KEY *key, BIGNUM *x,
336                                              BIGNUM *y)
337 {
338     BN_CTX *ctx = NULL;
339     BIGNUM *tx, *ty;
340     EC_POINT *point = NULL;
341     int ok = 0;
342 #ifndef OPENSSL_NO_EC2M
343     int tmp_nid, is_char_two = 0;
344 #endif
345
346     if (!key || !key->group || !x || !y) {
347         ECerr(EC_F_EC_KEY_SET_PUBLIC_KEY_AFFINE_COORDINATES,
348               ERR_R_PASSED_NULL_PARAMETER);
349         return 0;
350     }
351     ctx = BN_CTX_new();
352     if (ctx == NULL)
353         goto err;
354
355     point = EC_POINT_new(key->group);
356
357     if (point == NULL)
358         goto err;
359
360     tx = BN_CTX_get(ctx);
361     ty = BN_CTX_get(ctx);
362
363 #ifndef OPENSSL_NO_EC2M
364     tmp_nid = EC_METHOD_get_field_type(EC_GROUP_method_of(key->group));
365
366     if (tmp_nid == NID_X9_62_characteristic_two_field)
367         is_char_two = 1;
368
369     if (is_char_two) {
370         if (!EC_POINT_set_affine_coordinates_GF2m(key->group, point,
371                                                   x, y, ctx))
372             goto err;
373         if (!EC_POINT_get_affine_coordinates_GF2m(key->group, point,
374                                                   tx, ty, ctx))
375             goto err;
376     } else
377 #endif
378     {
379         if (!EC_POINT_set_affine_coordinates_GFp(key->group, point,
380                                                  x, y, ctx))
381             goto err;
382         if (!EC_POINT_get_affine_coordinates_GFp(key->group, point,
383                                                  tx, ty, ctx))
384             goto err;
385     }
386     /*
387      * Check if retrieved coordinates match originals and are less than field
388      * order: if not values are out of range.
389      */
390     if (BN_cmp(x, tx) || BN_cmp(y, ty)
391         || (BN_cmp(x, key->group->field) >= 0)
392         || (BN_cmp(y, key->group->field) >= 0)) {
393         ECerr(EC_F_EC_KEY_SET_PUBLIC_KEY_AFFINE_COORDINATES,
394               EC_R_COORDINATES_OUT_OF_RANGE);
395         goto err;
396     }
397
398     if (!EC_KEY_set_public_key(key, point))
399         goto err;
400
401     if (EC_KEY_check_key(key) == 0)
402         goto err;
403
404     ok = 1;
405
406  err:
407     BN_CTX_free(ctx);
408     EC_POINT_free(point);
409     return ok;
410
411 }
412
413 const EC_GROUP *EC_KEY_get0_group(const EC_KEY *key)
414 {
415     return key->group;
416 }
417
418 int EC_KEY_set_group(EC_KEY *key, const EC_GROUP *group)
419 {
420     EC_GROUP_free(key->group);
421     key->group = EC_GROUP_dup(group);
422     return (key->group == NULL) ? 0 : 1;
423 }
424
425 const BIGNUM *EC_KEY_get0_private_key(const EC_KEY *key)
426 {
427     return key->priv_key;
428 }
429
430 int EC_KEY_set_private_key(EC_KEY *key, const BIGNUM *priv_key)
431 {
432     BN_clear_free(key->priv_key);
433     key->priv_key = BN_dup(priv_key);
434     return (key->priv_key == NULL) ? 0 : 1;
435 }
436
437 const EC_POINT *EC_KEY_get0_public_key(const EC_KEY *key)
438 {
439     return key->pub_key;
440 }
441
442 int EC_KEY_set_public_key(EC_KEY *key, const EC_POINT *pub_key)
443 {
444     EC_POINT_free(key->pub_key);
445     key->pub_key = EC_POINT_dup(pub_key, key->group);
446     return (key->pub_key == NULL) ? 0 : 1;
447 }
448
449 unsigned int EC_KEY_get_enc_flags(const EC_KEY *key)
450 {
451     return key->enc_flag;
452 }
453
454 void EC_KEY_set_enc_flags(EC_KEY *key, unsigned int flags)
455 {
456     key->enc_flag = flags;
457 }
458
459 point_conversion_form_t EC_KEY_get_conv_form(const EC_KEY *key)
460 {
461     return key->conv_form;
462 }
463
464 void EC_KEY_set_conv_form(EC_KEY *key, point_conversion_form_t cform)
465 {
466     key->conv_form = cform;
467     if (key->group != NULL)
468         EC_GROUP_set_point_conversion_form(key->group, cform);
469 }
470
471 void *EC_KEY_get_key_method_data(EC_KEY *key,
472                                  void *(*dup_func) (void *),
473                                  void (*free_func) (void *),
474                                  void (*clear_free_func) (void *))
475 {
476     void *ret;
477
478     CRYPTO_r_lock(CRYPTO_LOCK_EC);
479     ret =
480         EC_EX_DATA_get_data(key->method_data, dup_func, free_func,
481                             clear_free_func);
482     CRYPTO_r_unlock(CRYPTO_LOCK_EC);
483
484     return ret;
485 }
486
487 void *EC_KEY_insert_key_method_data(EC_KEY *key, void *data,
488                                     void *(*dup_func) (void *),
489                                     void (*free_func) (void *),
490                                     void (*clear_free_func) (void *))
491 {
492     EC_EXTRA_DATA *ex_data;
493
494     CRYPTO_w_lock(CRYPTO_LOCK_EC);
495     ex_data =
496         EC_EX_DATA_get_data(key->method_data, dup_func, free_func,
497                             clear_free_func);
498     if (ex_data == NULL)
499         EC_EX_DATA_set_data(&key->method_data, data, dup_func, free_func,
500                             clear_free_func);
501     CRYPTO_w_unlock(CRYPTO_LOCK_EC);
502
503     return ex_data;
504 }
505
506 void EC_KEY_set_asn1_flag(EC_KEY *key, int flag)
507 {
508     if (key->group != NULL)
509         EC_GROUP_set_asn1_flag(key->group, flag);
510 }
511
512 int EC_KEY_precompute_mult(EC_KEY *key, BN_CTX *ctx)
513 {
514     if (key->group == NULL)
515         return 0;
516     return EC_GROUP_precompute_mult(key->group, ctx);
517 }
518
519 int EC_KEY_get_flags(const EC_KEY *key)
520 {
521     return key->flags;
522 }
523
524 void EC_KEY_set_flags(EC_KEY *key, int flags)
525 {
526     key->flags |= flags;
527 }
528
529 void EC_KEY_clear_flags(EC_KEY *key, int flags)
530 {
531     key->flags &= ~flags;
532 }