81907476d93e0eb5f42892e73fe61870c1792be0
[openssl.git] / providers / implementations / keymgmt / ec_kmgmt.c
1 /*
2  * Copyright 2019 The OpenSSL Project Authors. All Rights Reserved.
3  *
4  * Licensed under the Apache License 2.0 (the "License").  You may not use
5  * this file except in compliance with the License.  You can obtain a copy
6  * in the file LICENSE in the source distribution or at
7  * https://www.openssl.org/source/license.html
8  */
9
10 /*
11  * ECDH/ECDSA low level APIs are deprecated for public use, but still ok for
12  * internal use.
13  */
14 #include "internal/deprecated.h"
15
16 #include <openssl/core_numbers.h>
17 #include <openssl/core_names.h>
18 #include <openssl/bn.h>
19 #include <openssl/ec.h>
20 #include <openssl/objects.h>
21 #include <openssl/params.h>
22 #include "internal/param_build.h"
23 #include "prov/implementations.h"
24 #include "prov/providercommon.h"
25
26 static OSSL_OP_keymgmt_new_fn ec_newdata;
27 static OSSL_OP_keymgmt_free_fn ec_freedata;
28 static OSSL_OP_keymgmt_get_params_fn ec_get_params;
29 static OSSL_OP_keymgmt_gettable_params_fn ec_gettable_params;
30 static OSSL_OP_keymgmt_set_params_fn ec_set_params;
31 static OSSL_OP_keymgmt_settable_params_fn ec_settable_params;
32 static OSSL_OP_keymgmt_has_fn ec_has;
33 static OSSL_OP_keymgmt_import_fn ec_import;
34 static OSSL_OP_keymgmt_import_types_fn ec_import_types;
35 static OSSL_OP_keymgmt_export_fn ec_export;
36 static OSSL_OP_keymgmt_export_types_fn ec_export_types;
37 static OSSL_OP_keymgmt_query_operation_name_fn ec_query_operation_name;
38
39 #define EC_POSSIBLE_SELECTIONS                 \
40     (OSSL_KEYMGMT_SELECT_KEYPAIR | OSSL_KEYMGMT_SELECT_ALL_PARAMETERS )
41
42 static
43 const char *ec_query_operation_name(int operation_id)
44 {
45     switch (operation_id) {
46     case OSSL_OP_KEYEXCH:
47         return "ECDH";
48 #if 0
49     case OSSL_OP_SIGNATURE:
50         return deflt_signature;
51 #endif
52     }
53     return NULL;
54 }
55
56 static ossl_inline
57 int params_to_domparams(EC_KEY *ec, const OSSL_PARAM params[])
58 {
59     const OSSL_PARAM *param_ec_name;
60     EC_GROUP *ecg = NULL;
61     char *curve_name = NULL;
62     int ok = 0;
63
64     if (ec == NULL)
65         return 0;
66
67     param_ec_name = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_EC_NAME);
68     if (param_ec_name == NULL) {
69         /* explicit parameters */
70
71         /*
72          * TODO(3.0): should we support explicit parameters curves?
73          */
74         return 0;
75     } else {
76         /* named curve */
77         int curve_nid;
78
79         if (!OSSL_PARAM_get_utf8_string(param_ec_name, &curve_name, 0)
80                 || curve_name == NULL
81                 || (curve_nid = OBJ_sn2nid(curve_name)) == NID_undef)
82             goto err;
83
84         if ((ecg = EC_GROUP_new_by_curve_name(curve_nid)) == NULL)
85             goto err;
86     }
87
88     if (!EC_KEY_set_group(ec, ecg))
89         goto err;
90
91     /*
92      * TODO(3.0): if the group has changed, should we invalidate the private and
93      * public key?
94      */
95
96     ok = 1;
97
98  err:
99     OPENSSL_free(curve_name);
100     EC_GROUP_free(ecg);
101     return ok;
102 }
103
104 static ossl_inline
105 int domparams_to_params(const EC_KEY *ec, OSSL_PARAM_BLD *tmpl)
106 {
107     const EC_GROUP *ecg;
108     int curve_nid;
109
110     if (ec == NULL)
111         return 0;
112
113     ecg = EC_KEY_get0_group(ec);
114     if (ecg == NULL)
115         return 0;
116
117     curve_nid = EC_GROUP_get_curve_name(ecg);
118
119     if (curve_nid == NID_undef) {
120         /* explicit parameters */
121
122         /*
123          * TODO(3.0): should we support explicit parameters curves?
124          */
125         return 0;
126     } else {
127         /* named curve */
128         const char *curve_name = NULL;
129
130         if ((curve_name = OBJ_nid2sn(curve_nid)) == NULL)
131             return 0;
132
133         if (!ossl_param_bld_push_utf8_string(tmpl, OSSL_PKEY_PARAM_EC_NAME, curve_name, 0))
134             return 0;
135     }
136
137     return 1;
138 }
139
140 /*
141  * Callers of params_to_key MUST make sure that params_to_domparams has been
142  * called before!
143  *
144  * This function only imports the bare keypair, domain parameters and other
145  * parameters are imported separately, and domain parameters are required to
146  * define a keypair.
147  */
148 static ossl_inline
149 int params_to_key(EC_KEY *ec, const OSSL_PARAM params[], int include_private)
150 {
151     const OSSL_PARAM *param_priv_key, *param_pub_key;
152     BIGNUM *priv_key = NULL;
153     unsigned char *pub_key = NULL;
154     size_t pub_key_len;
155     const EC_GROUP *ecg = NULL;
156     EC_POINT *pub_point = NULL;
157     int ok = 0;
158
159     ecg = EC_KEY_get0_group(ec);
160     if (ecg == NULL)
161         return 0;
162
163     param_priv_key =
164         OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_PRIV_KEY);
165     param_pub_key =
166         OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_PUB_KEY);
167
168     /*
169      * We want to have at least a public key either way, so we end up
170      * requiring it unconditionally.
171      */
172     if (param_pub_key == NULL
173             || !OSSL_PARAM_get_octet_string(param_pub_key,
174                                             (void **)&pub_key, 0, &pub_key_len)
175             || (pub_point = EC_POINT_new(ecg)) == NULL
176             || !EC_POINT_oct2point(ecg, pub_point,
177                                    pub_key, pub_key_len, NULL))
178         goto err;
179
180     if (param_priv_key != NULL && include_private
181             && !OSSL_PARAM_get_BN(param_priv_key, &priv_key))
182         goto err;
183
184     if (priv_key != NULL
185             && !EC_KEY_set_private_key(ec, priv_key))
186         goto err;
187
188     if (!EC_KEY_set_public_key(ec, pub_point))
189         goto err;
190
191     ok = 1;
192
193  err:
194     BN_clear_free(priv_key);
195     OPENSSL_free(pub_key);
196     EC_POINT_free(pub_point);
197     return ok;
198 }
199
200 /*
201  * Callers of key_to_params MUST make sure that domparams_to_params is also
202  * called!
203  *
204  * This function only exports the bare keypair, domain parameters and other
205  * parameters are exported separately.
206  */
207 static ossl_inline
208 int key_to_params(const EC_KEY *eckey, OSSL_PARAM_BLD *tmpl, int include_private)
209 {
210     const BIGNUM *priv_key = NULL;
211     const EC_POINT *pub_point = NULL;
212     const EC_GROUP *ecg = NULL;
213     unsigned char *pub_key = NULL;
214     size_t pub_key_len = 0;
215     int ret = 0;
216
217     if (eckey == NULL)
218         return 0;
219
220     ecg = EC_KEY_get0_group(eckey);
221     priv_key = EC_KEY_get0_private_key(eckey);
222     pub_point = EC_KEY_get0_public_key(eckey);
223
224     /* group and public_key must be present, priv_key is optional */
225     if (ecg == NULL || pub_point == NULL)
226         return 0;
227     if ((pub_key_len = EC_POINT_point2buf(ecg, pub_point,
228                                           POINT_CONVERSION_COMPRESSED,
229                                           &pub_key, NULL)) == 0)
230         return 0;
231
232     if (!ossl_param_bld_push_octet_string(tmpl,
233                                           OSSL_PKEY_PARAM_PUB_KEY,
234                                           pub_key, pub_key_len))
235         goto err;
236
237     if (priv_key != NULL && include_private
238             && !ossl_param_bld_push_BN(tmpl,
239                                        OSSL_PKEY_PARAM_PRIV_KEY,
240                                        priv_key))
241         goto err;
242
243     ret = 1;
244
245  err:
246     OPENSSL_free(pub_key);
247     return ret;
248 }
249
250 static ossl_inline
251 int ec_set_param_ecdh_cofactor_mode(EC_KEY *ec, const OSSL_PARAM *p)
252 {
253     const EC_GROUP *ecg = EC_KEY_get0_group(ec);
254     const BIGNUM *cofactor;
255     int mode;
256
257     if (!OSSL_PARAM_get_int(p, &mode))
258         return 0;
259
260     /*
261      * mode can be only 0 for disable, or 1 for enable here.
262      *
263      * This is in contrast with the same parameter on an ECDH EVP_PKEY_CTX that
264      * also supports mode == -1 with the meaning of "reset to the default for
265      * the associated key".
266      */
267     if (mode < 0 || mode > 1)
268         return 0;
269
270     if ((cofactor = EC_GROUP_get0_cofactor(ecg)) == NULL )
271         return 0;
272
273     /* ECDH cofactor mode has no effect if cofactor is 1 */
274     if (BN_is_one(cofactor))
275         return 1;
276
277     if (mode == 1)
278         EC_KEY_set_flags(ec, EC_FLAG_COFACTOR_ECDH);
279     else if (mode == 0)
280         EC_KEY_clear_flags(ec, EC_FLAG_COFACTOR_ECDH);
281
282     return 1;
283 }
284
285 static ossl_inline
286 int params_to_otherparams(EC_KEY *ec, const OSSL_PARAM params[])
287 {
288     const OSSL_PARAM *p;
289
290     if (ec == NULL)
291         return 0;
292
293     p = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_USE_COFACTOR_ECDH);
294     if (p != NULL && !ec_set_param_ecdh_cofactor_mode(ec, p))
295         return 0;
296
297     return 1;
298 }
299
300 static ossl_inline
301 int otherparams_to_params(const EC_KEY *ec, OSSL_PARAM_BLD *tmpl)
302 {
303     int ecdh_cofactor_mode = 0;
304
305     if (ec == NULL)
306         return 0;
307
308     ecdh_cofactor_mode =
309         (EC_KEY_get_flags(ec) & EC_FLAG_COFACTOR_ECDH) ? 1 : 0;
310     if (!ossl_param_bld_push_int(tmpl,
311                 OSSL_PKEY_PARAM_USE_COFACTOR_ECDH,
312                 ecdh_cofactor_mode))
313         return 0;
314
315     return 1;
316 }
317
318 static
319 void *ec_newdata(void *provctx)
320 {
321     return EC_KEY_new();
322 }
323
324 static
325 void ec_freedata(void *keydata)
326 {
327     EC_KEY_free(keydata);
328 }
329
330 static
331 int ec_has(void *keydata, int selection)
332 {
333     EC_KEY *ec = keydata;
334     int ok = 0;
335
336     if ((selection & EC_POSSIBLE_SELECTIONS) != 0)
337         ok = 1;
338
339     if ((selection & OSSL_KEYMGMT_SELECT_PUBLIC_KEY) != 0)
340         ok = ok && (EC_KEY_get0_public_key(ec) != NULL);
341     if ((selection & OSSL_KEYMGMT_SELECT_PRIVATE_KEY) != 0)
342         ok = ok && (EC_KEY_get0_private_key(ec) != NULL);
343     if ((selection & OSSL_KEYMGMT_SELECT_DOMAIN_PARAMETERS) != 0)
344         ok = ok && (EC_KEY_get0_group(ec) != NULL);
345     /*
346      * We consider OSSL_KEYMGMT_SELECT_OTHER_PARAMETERS to always be available,
347      * so no extra check is needed other than the previous one against
348      * EC_POSSIBLE_SELECTIONS.
349      */
350
351     return ok;
352 }
353
354 static
355 int ec_import(void *keydata, int selection, const OSSL_PARAM params[])
356 {
357     EC_KEY *ec = keydata;
358     int ok = 0;
359
360     if (ec == NULL)
361         return 0;
362
363     /*
364      * In this implementation, we can export/import only keydata in the
365      * following combinations:
366      *   - domain parameters only
367      *   - public key with associated domain parameters (+optional other params)
368      *   - private key with associated public key and domain parameters
369      *         (+optional other params)
370      *
371      * This means:
372      *   - domain parameters must always be requested
373      *   - private key must be requested alongside public key
374      *   - other parameters must be requested only alongside a key
375      */
376     if ((selection & OSSL_KEYMGMT_SELECT_DOMAIN_PARAMETERS) == 0)
377         return 0;
378     if ((selection & OSSL_KEYMGMT_SELECT_PRIVATE_KEY) != 0
379             && (selection & OSSL_KEYMGMT_SELECT_PUBLIC_KEY) == 0)
380         return 0;
381     if ((selection & OSSL_KEYMGMT_SELECT_OTHER_PARAMETERS) != 0
382             && (selection & OSSL_KEYMGMT_SELECT_KEYPAIR) == 0)
383         return 0;
384
385     if ((selection & OSSL_KEYMGMT_SELECT_DOMAIN_PARAMETERS) != 0)
386         ok = ok && params_to_domparams(ec, params);
387     if ((selection & OSSL_KEYMGMT_SELECT_KEYPAIR) != 0) {
388         int include_private =
389             selection & OSSL_KEYMGMT_SELECT_PRIVATE_KEY ? 1 : 0;
390
391         ok = ok && params_to_key(ec, params, include_private);
392     }
393     if ((selection & OSSL_KEYMGMT_SELECT_OTHER_PARAMETERS) != 0)
394         ok = ok && params_to_otherparams(ec, params);
395
396     return ok;
397 }
398
399 static
400 int ec_export(void *keydata, int selection, OSSL_CALLBACK *param_cb,
401               void *cbarg)
402 {
403     EC_KEY *ec = keydata;
404     OSSL_PARAM_BLD tmpl;
405     OSSL_PARAM *params = NULL;
406     int ok = 1;
407
408     if (ec == NULL)
409         return 0;
410
411     /*
412      * In this implementation, we can export/import only keydata in the
413      * following combinations:
414      *   - domain parameters only
415      *   - public key with associated domain parameters (+optional other params)
416      *   - private key with associated public key and domain parameters
417      *         (+optional other params)
418      *
419      * This means:
420      *   - domain parameters must always be requested
421      *   - private key must be requested alongside public key
422      *   - other parameters must be requested only alongside a key
423      */
424     if ((selection & OSSL_KEYMGMT_SELECT_DOMAIN_PARAMETERS) == 0)
425         return 0;
426     if ((selection & OSSL_KEYMGMT_SELECT_PRIVATE_KEY) != 0
427             && (selection & OSSL_KEYMGMT_SELECT_PUBLIC_KEY) == 0)
428         return 0;
429     if ((selection & OSSL_KEYMGMT_SELECT_OTHER_PARAMETERS) != 0
430             && (selection & OSSL_KEYMGMT_SELECT_KEYPAIR) == 0)
431         return 0;
432
433     ossl_param_bld_init(&tmpl);
434
435     if ((selection & OSSL_KEYMGMT_SELECT_DOMAIN_PARAMETERS) != 0)
436         ok = ok && domparams_to_params(ec, &tmpl);
437     if ((selection & OSSL_KEYMGMT_SELECT_KEYPAIR) != 0) {
438         int include_private =
439             selection & OSSL_KEYMGMT_SELECT_PRIVATE_KEY ? 1 : 0;
440
441         ok = ok && key_to_params(ec, &tmpl, include_private);
442     }
443     if ((selection & OSSL_KEYMGMT_SELECT_OTHER_PARAMETERS) != 0)
444         ok = ok && otherparams_to_params(ec, &tmpl);
445
446     if (!ok
447         || (params = ossl_param_bld_to_param(&tmpl)) == NULL)
448         return 0;
449
450     ok = param_cb(params, cbarg);
451     ossl_param_bld_free(params);
452     return ok;
453 }
454
455 /* IMEXPORT = IMPORT + EXPORT */
456
457 # define EC_IMEXPORTABLE_DOM_PARAMETERS                          \
458     OSSL_PARAM_utf8_string(OSSL_PKEY_PARAM_EC_NAME, NULL, 0)
459 # define EC_IMEXPORTABLE_PUBLIC_KEY                              \
460     OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PUB_KEY, NULL, 0)
461 # define EC_IMEXPORTABLE_PRIVATE_KEY                             \
462     OSSL_PARAM_BN(OSSL_PKEY_PARAM_PRIV_KEY, NULL, 0)
463 # define EC_IMEXPORTABLE_OTHER_PARAMETERS                        \
464     OSSL_PARAM_int(OSSL_PKEY_PARAM_USE_COFACTOR_ECDH, NULL)
465
466 /*
467  * Include all the possible combinations of OSSL_PARAM arrays for
468  * ec_imexport_types().
469  *
470  * They are in a separate file as it is ~100 lines of unreadable and
471  * uninteresting machine generated stuff.
472  *
473  * TODO(3.0): the generated list looks quite ugly, as to cover all possible
474  * combinations of the bits in `selection`, it also includes combinations that
475  * are not really useful: we might want to consider alternatives to this
476  * solution.
477  */
478 #include "ec_kmgmt_imexport.inc"
479
480 static ossl_inline
481 const OSSL_PARAM *ec_imexport_types(int selection)
482 {
483     int type_select = 0;
484
485     if ((selection & OSSL_KEYMGMT_SELECT_PRIVATE_KEY) != 0)
486         type_select += 1;
487     if ((selection & OSSL_KEYMGMT_SELECT_PUBLIC_KEY) != 0)
488         type_select += 2;
489     if ((selection & OSSL_KEYMGMT_SELECT_DOMAIN_PARAMETERS) != 0)
490         type_select += 4;
491     if ((selection & OSSL_KEYMGMT_SELECT_OTHER_PARAMETERS) != 0)
492         type_select += 8;
493     return ec_types[type_select];
494 }
495
496 static
497 const OSSL_PARAM *ec_import_types(int selection)
498 {
499     return ec_imexport_types(selection);
500 }
501
502 static
503 const OSSL_PARAM *ec_export_types(int selection)
504 {
505     return ec_imexport_types(selection);
506 }
507
508 static
509 int ec_get_params(void *key, OSSL_PARAM params[])
510 {
511     EC_KEY *eck = key;
512     const EC_GROUP *ecg = NULL;
513     OSSL_PARAM *p;
514
515     ecg = EC_KEY_get0_group(eck);
516     if (ecg == NULL)
517         return 0;
518
519     if ((p = OSSL_PARAM_locate(params, OSSL_PKEY_PARAM_MAX_SIZE)) != NULL
520         && !OSSL_PARAM_set_int(p, ECDSA_size(eck)))
521         return 0;
522     if ((p = OSSL_PARAM_locate(params, OSSL_PKEY_PARAM_BITS)) != NULL
523         && !OSSL_PARAM_set_int(p, EC_GROUP_order_bits(ecg)))
524         return 0;
525     if ((p = OSSL_PARAM_locate(params, OSSL_PKEY_PARAM_SECURITY_BITS)) != NULL) {
526         int ecbits, sec_bits;
527
528         ecbits = EC_GROUP_order_bits(ecg);
529
530         /*
531          * The following estimates are based on the values published
532          * in Table 2 of "NIST Special Publication 800-57 Part 1 Revision 4"
533          * at http://dx.doi.org/10.6028/NIST.SP.800-57pt1r4 .
534          *
535          * Note that the above reference explicitly categorizes algorithms in a
536          * discrete set of values {80, 112, 128, 192, 256}, and that it is
537          * relevant only for NIST approved Elliptic Curves, while OpenSSL
538          * applies the same logic also to other curves.
539          *
540          * Classifications produced by other standardazing bodies might differ,
541          * so the results provided for "bits of security" by this provider are
542          * to be considered merely indicative, and it is the users'
543          * responsibility to compare these values against the normative
544          * references that may be relevant for their intent and purposes.
545          */
546         if (ecbits >= 512)
547             sec_bits = 256;
548         else if (ecbits >= 384)
549             sec_bits = 192;
550         else if (ecbits >= 256)
551             sec_bits = 128;
552         else if (ecbits >= 224)
553             sec_bits = 112;
554         else if (ecbits >= 160)
555             sec_bits = 80;
556         else
557             sec_bits = ecbits / 2;
558
559         if (!OSSL_PARAM_set_int(p, sec_bits))
560             return 0;
561     }
562
563     p = OSSL_PARAM_locate(params, OSSL_PKEY_PARAM_USE_COFACTOR_ECDH);
564     if (p != NULL) {
565         int ecdh_cofactor_mode = 0;
566
567         ecdh_cofactor_mode =
568             (EC_KEY_get_flags(eck) & EC_FLAG_COFACTOR_ECDH) ? 1 : 0;
569
570         if (!OSSL_PARAM_set_int(p, ecdh_cofactor_mode))
571             return 0;
572     }
573
574     return 1;
575 }
576
577 static const OSSL_PARAM ec_known_gettable_params[] = {
578     OSSL_PARAM_int(OSSL_PKEY_PARAM_BITS, NULL),
579     OSSL_PARAM_int(OSSL_PKEY_PARAM_SECURITY_BITS, NULL),
580     OSSL_PARAM_int(OSSL_PKEY_PARAM_MAX_SIZE, NULL),
581     OSSL_PARAM_int(OSSL_PKEY_PARAM_USE_COFACTOR_ECDH, NULL),
582     OSSL_PARAM_END
583 };
584
585 static
586 const OSSL_PARAM *ec_gettable_params(void)
587 {
588     return ec_known_gettable_params;
589 }
590
591 static const OSSL_PARAM ec_known_settable_params[] = {
592     OSSL_PARAM_int(OSSL_PKEY_PARAM_USE_COFACTOR_ECDH, NULL),
593     OSSL_PARAM_END
594 };
595
596 static
597 const OSSL_PARAM *ec_settable_params(void)
598 {
599     return ec_known_settable_params;
600 }
601
602 static
603 int ec_set_params(void *key, const OSSL_PARAM params[])
604 {
605     EC_KEY *eck = key;
606     const OSSL_PARAM *p;
607
608     p = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_USE_COFACTOR_ECDH);
609     if (p != NULL && !ec_set_param_ecdh_cofactor_mode(eck, p))
610         return 0;
611
612     return 1;
613 }
614
615 const OSSL_DISPATCH ec_keymgmt_functions[] = {
616     { OSSL_FUNC_KEYMGMT_NEW, (void (*)(void))ec_newdata },
617     { OSSL_FUNC_KEYMGMT_FREE, (void (*)(void))ec_freedata },
618     { OSSL_FUNC_KEYMGMT_GET_PARAMS, (void (*) (void))ec_get_params },
619     { OSSL_FUNC_KEYMGMT_GETTABLE_PARAMS, (void (*) (void))ec_gettable_params },
620     { OSSL_FUNC_KEYMGMT_SET_PARAMS, (void (*) (void))ec_set_params },
621     { OSSL_FUNC_KEYMGMT_SETTABLE_PARAMS, (void (*) (void))ec_settable_params },
622     { OSSL_FUNC_KEYMGMT_HAS, (void (*)(void))ec_has },
623     { OSSL_FUNC_KEYMGMT_IMPORT, (void (*)(void))ec_import },
624     { OSSL_FUNC_KEYMGMT_IMPORT_TYPES, (void (*)(void))ec_import_types },
625     { OSSL_FUNC_KEYMGMT_EXPORT, (void (*)(void))ec_export },
626     { OSSL_FUNC_KEYMGMT_EXPORT_TYPES, (void (*)(void))ec_export_types },
627     { OSSL_FUNC_KEYMGMT_QUERY_OPERATION_NAME,
628         (void (*)(void))ec_query_operation_name },
629     { 0, NULL }
630 };