]>
Commit | Line | Data |
---|---|---|
0abae163 | 1 | /* |
4333b89f | 2 | * Copyright 2020-2021 The OpenSSL Project Authors. All Rights Reserved. |
0abae163 RL |
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 | ||
5b5eea4b SL |
10 | /* |
11 | * Low level APIs related to EC_KEY are deprecated for public use, | |
12 | * but still ok for internal use. | |
13 | */ | |
14 | #include "internal/deprecated.h" | |
15 | ||
0abae163 RL |
16 | #include <openssl/core_names.h> |
17 | #include <openssl/objects.h> | |
18 | #include <openssl/params.h> | |
c0f39ded | 19 | #include <openssl/err.h> |
3f773c91 TM |
20 | #ifndef FIPS_MODULE |
21 | # include <openssl/engine.h> | |
22 | # include <openssl/x509.h> | |
23 | #endif | |
0abae163 RL |
24 | #include "crypto/bn.h" |
25 | #include "crypto/ec.h" | |
c0f39ded | 26 | #include "ec_local.h" |
d5f9166b | 27 | #include "internal/e_os.h" |
c0f39ded SL |
28 | #include "internal/param_build_set.h" |
29 | ||
30 | /* Mapping between a flag and a name */ | |
31 | static const OSSL_ITEM encoding_nameid_map[] = { | |
32 | { OPENSSL_EC_EXPLICIT_CURVE, OSSL_PKEY_EC_ENCODING_EXPLICIT }, | |
33 | { OPENSSL_EC_NAMED_CURVE, OSSL_PKEY_EC_ENCODING_GROUP }, | |
34 | }; | |
35 | ||
5b5eea4b SL |
36 | static const OSSL_ITEM check_group_type_nameid_map[] = { |
37 | { 0, OSSL_PKEY_EC_GROUP_CHECK_DEFAULT }, | |
38 | { EC_FLAG_CHECK_NAMED_GROUP, OSSL_PKEY_EC_GROUP_CHECK_NAMED }, | |
39 | { EC_FLAG_CHECK_NAMED_GROUP_NIST, OSSL_PKEY_EC_GROUP_CHECK_NAMED_NIST }, | |
40 | }; | |
41 | ||
42 | static const OSSL_ITEM format_nameid_map[] = { | |
43 | { (int)POINT_CONVERSION_UNCOMPRESSED, OSSL_PKEY_EC_POINT_CONVERSION_FORMAT_UNCOMPRESSED }, | |
44 | { (int)POINT_CONVERSION_COMPRESSED, OSSL_PKEY_EC_POINT_CONVERSION_FORMAT_COMPRESSED }, | |
45 | { (int)POINT_CONVERSION_HYBRID, OSSL_PKEY_EC_POINT_CONVERSION_FORMAT_HYBRID }, | |
46 | }; | |
47 | ||
32ab57cb | 48 | int ossl_ec_encoding_name2id(const char *name) |
c0f39ded SL |
49 | { |
50 | size_t i, sz; | |
51 | ||
52 | /* Return the default value if there is no name */ | |
53 | if (name == NULL) | |
54 | return OPENSSL_EC_NAMED_CURVE; | |
55 | ||
56 | for (i = 0, sz = OSSL_NELEM(encoding_nameid_map); i < sz; i++) { | |
57 | if (strcasecmp(name, encoding_nameid_map[i].ptr) == 0) | |
58 | return encoding_nameid_map[i].id; | |
59 | } | |
60 | return -1; | |
61 | } | |
62 | ||
63 | static char *ec_param_encoding_id2name(int id) | |
64 | { | |
65 | size_t i, sz; | |
66 | ||
67 | for (i = 0, sz = OSSL_NELEM(encoding_nameid_map); i < sz; i++) { | |
68 | if (id == (int)encoding_nameid_map[i].id) | |
69 | return encoding_nameid_map[i].ptr; | |
70 | } | |
71 | return NULL; | |
72 | } | |
73 | ||
32ab57cb | 74 | char *ossl_ec_check_group_type_id2name(int id) |
5b5eea4b SL |
75 | { |
76 | size_t i, sz; | |
77 | ||
78 | for (i = 0, sz = OSSL_NELEM(check_group_type_nameid_map); i < sz; i++) { | |
79 | if (id == (int)check_group_type_nameid_map[i].id) | |
80 | return check_group_type_nameid_map[i].ptr; | |
81 | } | |
82 | return NULL; | |
83 | } | |
84 | ||
85 | static int ec_check_group_type_name2id(const char *name) | |
86 | { | |
87 | size_t i, sz; | |
88 | ||
89 | /* Return the default value if there is no name */ | |
90 | if (name == NULL) | |
91 | return 0; | |
92 | ||
93 | for (i = 0, sz = OSSL_NELEM(check_group_type_nameid_map); i < sz; i++) { | |
94 | if (strcasecmp(name, check_group_type_nameid_map[i].ptr) == 0) | |
95 | return check_group_type_nameid_map[i].id; | |
96 | } | |
97 | return -1; | |
98 | } | |
99 | ||
32ab57cb | 100 | int ossl_ec_set_check_group_type_from_name(EC_KEY *ec, const char *name) |
5b5eea4b SL |
101 | { |
102 | int flags = ec_check_group_type_name2id(name); | |
103 | ||
104 | if (flags == -1) | |
105 | return 0; | |
106 | EC_KEY_clear_flags(ec, EC_FLAG_CHECK_NAMED_GROUP_MASK); | |
107 | EC_KEY_set_flags(ec, flags); | |
108 | return 1; | |
109 | } | |
110 | ||
111 | static int ec_set_check_group_type_from_param(EC_KEY *ec, const OSSL_PARAM *p) | |
112 | { | |
113 | const char *name = NULL; | |
114 | int status = 0; | |
115 | ||
116 | switch (p->data_type) { | |
117 | case OSSL_PARAM_UTF8_STRING: | |
118 | name = p->data; | |
119 | status = (name != NULL); | |
120 | break; | |
121 | case OSSL_PARAM_UTF8_PTR: | |
122 | status = OSSL_PARAM_get_utf8_ptr(p, &name); | |
123 | break; | |
124 | } | |
125 | if (status) | |
32ab57cb | 126 | return ossl_ec_set_check_group_type_from_name(ec, name); |
5b5eea4b SL |
127 | return 0; |
128 | } | |
129 | ||
32ab57cb | 130 | int ossl_ec_pt_format_name2id(const char *name) |
5b5eea4b SL |
131 | { |
132 | size_t i, sz; | |
133 | ||
134 | /* Return the default value if there is no name */ | |
135 | if (name == NULL) | |
136 | return (int)POINT_CONVERSION_UNCOMPRESSED; | |
137 | ||
138 | for (i = 0, sz = OSSL_NELEM(format_nameid_map); i < sz; i++) { | |
139 | if (strcasecmp(name, format_nameid_map[i].ptr) == 0) | |
140 | return format_nameid_map[i].id; | |
141 | } | |
142 | return -1; | |
143 | } | |
144 | ||
32ab57cb | 145 | char *ossl_ec_pt_format_id2name(int id) |
5b5eea4b SL |
146 | { |
147 | size_t i, sz; | |
148 | ||
149 | for (i = 0, sz = OSSL_NELEM(format_nameid_map); i < sz; i++) { | |
150 | if (id == (int)format_nameid_map[i].id) | |
151 | return format_nameid_map[i].ptr; | |
152 | } | |
153 | return NULL; | |
154 | } | |
155 | ||
f71a7453 JS |
156 | static int ec_group_explicit_todata(const EC_GROUP *group, OSSL_PARAM_BLD *tmpl, |
157 | OSSL_PARAM params[], BN_CTX *bnctx, | |
158 | unsigned char **genbuf) | |
c0f39ded | 159 | { |
f71a7453 JS |
160 | int ret = 0, fid; |
161 | const char *field_type; | |
162 | const OSSL_PARAM *param = NULL; | |
163 | const OSSL_PARAM *param_p = NULL; | |
164 | const OSSL_PARAM *param_a = NULL; | |
165 | const OSSL_PARAM *param_b = NULL; | |
166 | ||
167 | fid = EC_GROUP_get_field_type(group); | |
168 | ||
169 | if (fid == NID_X9_62_prime_field) { | |
170 | field_type = SN_X9_62_prime_field; | |
171 | } else if (fid == NID_X9_62_characteristic_two_field) { | |
172 | #ifdef OPENSSL_NO_EC2M | |
173 | ERR_raise(ERR_LIB_EC, EC_R_GF2M_NOT_SUPPORTED); | |
174 | goto err; | |
175 | #else | |
176 | field_type = SN_X9_62_characteristic_two_field; | |
177 | #endif | |
178 | } else { | |
179 | ERR_raise(ERR_LIB_EC, EC_R_INVALID_FIELD); | |
c0f39ded SL |
180 | return 0; |
181 | } | |
182 | ||
f71a7453 JS |
183 | param_p = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_EC_P); |
184 | param_a = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_EC_A); | |
185 | param_b = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_EC_B); | |
186 | if (tmpl != NULL || param_p != NULL || param_a != NULL || param_b != NULL) | |
187 | { | |
188 | BIGNUM *p = BN_CTX_get(bnctx); | |
189 | BIGNUM *a = BN_CTX_get(bnctx); | |
190 | BIGNUM *b = BN_CTX_get(bnctx); | |
c0f39ded | 191 | |
c0f39ded | 192 | if (b == NULL) { |
9311d0c4 | 193 | ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE); |
c0f39ded SL |
194 | goto err; |
195 | } | |
196 | ||
197 | if (!EC_GROUP_get_curve(group, p, a, b, bnctx)) { | |
9311d0c4 | 198 | ERR_raise(ERR_LIB_EC, EC_R_INVALID_CURVE); |
c0f39ded SL |
199 | goto err; |
200 | } | |
f71a7453 JS |
201 | if (!ossl_param_build_set_bn(tmpl, params, OSSL_PKEY_PARAM_EC_P, p) |
202 | || !ossl_param_build_set_bn(tmpl, params, OSSL_PKEY_PARAM_EC_A, a) | |
203 | || !ossl_param_build_set_bn(tmpl, params, OSSL_PKEY_PARAM_EC_B, b)) { | |
204 | ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE); | |
205 | goto err; | |
206 | } | |
207 | } | |
208 | ||
209 | param = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_EC_ORDER); | |
210 | if (tmpl != NULL || param != NULL) { | |
211 | const BIGNUM *order = EC_GROUP_get0_order(group); | |
c0f39ded | 212 | |
c0f39ded | 213 | if (order == NULL) { |
9311d0c4 | 214 | ERR_raise(ERR_LIB_EC, EC_R_INVALID_GROUP_ORDER); |
c0f39ded SL |
215 | goto err; |
216 | } | |
f71a7453 JS |
217 | if (!ossl_param_build_set_bn(tmpl, params, OSSL_PKEY_PARAM_EC_ORDER, |
218 | order)) { | |
219 | ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE); | |
220 | goto err; | |
221 | } | |
222 | } | |
223 | ||
224 | param = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_EC_FIELD_TYPE); | |
225 | if (tmpl != NULL || param != NULL) { | |
226 | if (!ossl_param_build_set_utf8_string(tmpl, params, | |
227 | OSSL_PKEY_PARAM_EC_FIELD_TYPE, | |
228 | field_type)) { | |
229 | ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE); | |
230 | goto err; | |
231 | } | |
232 | } | |
233 | ||
234 | param = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_EC_GENERATOR); | |
235 | if (tmpl != NULL || param != NULL) { | |
236 | size_t genbuf_len; | |
237 | const EC_POINT *genpt = EC_GROUP_get0_generator(group); | |
238 | point_conversion_form_t genform = EC_GROUP_get_point_conversion_form(group); | |
239 | ||
c0f39ded | 240 | if (genpt == NULL) { |
9311d0c4 | 241 | ERR_raise(ERR_LIB_EC, EC_R_INVALID_GENERATOR); |
c0f39ded SL |
242 | goto err; |
243 | } | |
c0f39ded SL |
244 | genbuf_len = EC_POINT_point2buf(group, genpt, genform, genbuf, bnctx); |
245 | if (genbuf_len == 0) { | |
9311d0c4 | 246 | ERR_raise(ERR_LIB_EC, EC_R_INVALID_GENERATOR); |
c0f39ded SL |
247 | goto err; |
248 | } | |
f71a7453 JS |
249 | if (!ossl_param_build_set_octet_string(tmpl, params, |
250 | OSSL_PKEY_PARAM_EC_GENERATOR, | |
251 | *genbuf, genbuf_len)) { | |
9311d0c4 | 252 | ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE); |
c0f39ded SL |
253 | goto err; |
254 | } | |
f71a7453 JS |
255 | } |
256 | ||
257 | param = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_EC_COFACTOR); | |
258 | if (tmpl != NULL || param != NULL) { | |
259 | const BIGNUM *cofactor = EC_GROUP_get0_cofactor(group); | |
c0f39ded | 260 | |
c0f39ded SL |
261 | if (cofactor != NULL |
262 | && !ossl_param_build_set_bn(tmpl, params, | |
263 | OSSL_PKEY_PARAM_EC_COFACTOR, cofactor)) { | |
9311d0c4 | 264 | ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE); |
c0f39ded SL |
265 | goto err; |
266 | } | |
f71a7453 JS |
267 | } |
268 | ||
269 | param = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_EC_SEED); | |
270 | if (tmpl != NULL || param != NULL) { | |
271 | unsigned char *seed = EC_GROUP_get0_seed(group); | |
272 | size_t seed_len = EC_GROUP_get_seed_len(group); | |
c0f39ded | 273 | |
c0f39ded SL |
274 | if (seed != NULL |
275 | && seed_len > 0 | |
276 | && !ossl_param_build_set_octet_string(tmpl, params, | |
277 | OSSL_PKEY_PARAM_EC_SEED, | |
278 | seed, seed_len)) { | |
9311d0c4 | 279 | ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE); |
c0f39ded SL |
280 | goto err; |
281 | } | |
f71a7453 JS |
282 | } |
283 | ret = 1; | |
284 | err: | |
285 | return ret; | |
286 | } | |
287 | ||
288 | int ossl_ec_group_todata(const EC_GROUP *group, OSSL_PARAM_BLD *tmpl, | |
289 | OSSL_PARAM params[], OSSL_LIB_CTX *libctx, | |
290 | const char *propq, | |
291 | BN_CTX *bnctx, unsigned char **genbuf) | |
292 | { | |
293 | int ret = 0, curve_nid, encoding_flag; | |
294 | const char *encoding_name, *pt_form_name; | |
295 | point_conversion_form_t genform; | |
296 | ||
297 | if (group == NULL) { | |
1287dabd | 298 | ERR_raise(ERR_LIB_EC, EC_R_PASSED_NULL_PARAMETER); |
f71a7453 JS |
299 | return 0; |
300 | } | |
301 | ||
302 | genform = EC_GROUP_get_point_conversion_form(group); | |
303 | pt_form_name = ossl_ec_pt_format_id2name(genform); | |
304 | if (pt_form_name == NULL | |
305 | || !ossl_param_build_set_utf8_string( | |
306 | tmpl, params, | |
307 | OSSL_PKEY_PARAM_EC_POINT_CONVERSION_FORMAT, pt_form_name)) { | |
308 | ERR_raise(ERR_LIB_EC, EC_R_INVALID_FORM); | |
309 | return 0; | |
310 | } | |
311 | encoding_flag = EC_GROUP_get_asn1_flag(group) & OPENSSL_EC_NAMED_CURVE; | |
312 | encoding_name = ec_param_encoding_id2name(encoding_flag); | |
313 | if (encoding_name == NULL | |
314 | || !ossl_param_build_set_utf8_string(tmpl, params, | |
315 | OSSL_PKEY_PARAM_EC_ENCODING, | |
316 | encoding_name)) { | |
317 | ERR_raise(ERR_LIB_EC, EC_R_INVALID_ENCODING); | |
318 | return 0; | |
319 | } | |
320 | ||
321 | curve_nid = EC_GROUP_get_curve_name(group); | |
322 | ||
323 | /* | |
324 | * Get the explicit parameters in these two cases: | |
325 | * - We do not have a template, i.e. specific parameters are requested | |
326 | * - The curve is not a named curve | |
327 | */ | |
328 | if (tmpl == NULL || curve_nid == NID_undef) | |
329 | if (!ec_group_explicit_todata(group, tmpl, params, bnctx, genbuf)) | |
c0f39ded | 330 | goto err; |
f71a7453 JS |
331 | |
332 | if (curve_nid != NID_undef) { | |
333 | /* Named curve */ | |
f9253152 | 334 | const char *curve_name = OSSL_EC_curve_nid2name(curve_nid); |
c0f39ded SL |
335 | |
336 | if (curve_name == NULL | |
337 | || !ossl_param_build_set_utf8_string(tmpl, params, | |
338 | OSSL_PKEY_PARAM_GROUP_NAME, | |
339 | curve_name)) { | |
9311d0c4 | 340 | ERR_raise(ERR_LIB_EC, EC_R_INVALID_CURVE); |
c0f39ded SL |
341 | goto err; |
342 | } | |
343 | } | |
344 | ret = 1; | |
345 | err: | |
346 | return ret; | |
347 | } | |
0abae163 RL |
348 | |
349 | /* | |
350 | * The intention with the "backend" source file is to offer backend support | |
351 | * for legacy backends (EVP_PKEY_ASN1_METHOD and EVP_PKEY_METHOD) and provider | |
352 | * implementations alike. | |
353 | */ | |
32ab57cb | 354 | int ossl_ec_set_ecdh_cofactor_mode(EC_KEY *ec, int mode) |
0abae163 RL |
355 | { |
356 | const EC_GROUP *ecg = EC_KEY_get0_group(ec); | |
357 | const BIGNUM *cofactor; | |
0abae163 RL |
358 | /* |
359 | * mode can be only 0 for disable, or 1 for enable here. | |
360 | * | |
361 | * This is in contrast with the same parameter on an ECDH EVP_PKEY_CTX that | |
362 | * also supports mode == -1 with the meaning of "reset to the default for | |
363 | * the associated key". | |
364 | */ | |
365 | if (mode < 0 || mode > 1) | |
366 | return 0; | |
367 | ||
368 | if ((cofactor = EC_GROUP_get0_cofactor(ecg)) == NULL ) | |
369 | return 0; | |
370 | ||
371 | /* ECDH cofactor mode has no effect if cofactor is 1 */ | |
372 | if (BN_is_one(cofactor)) | |
373 | return 1; | |
374 | ||
375 | if (mode == 1) | |
376 | EC_KEY_set_flags(ec, EC_FLAG_COFACTOR_ECDH); | |
377 | else if (mode == 0) | |
378 | EC_KEY_clear_flags(ec, EC_FLAG_COFACTOR_ECDH); | |
379 | ||
380 | return 1; | |
381 | } | |
382 | ||
383 | /* | |
32ab57cb | 384 | * Callers of ossl_ec_key_fromdata MUST make sure that ec_key_params_fromdata has |
0abae163 RL |
385 | * been called before! |
386 | * | |
387 | * This function only gets the bare keypair, domain parameters and other | |
388 | * parameters are treated separately, and domain parameters are required to | |
389 | * define a keypair. | |
390 | */ | |
32ab57cb | 391 | int ossl_ec_key_fromdata(EC_KEY *ec, const OSSL_PARAM params[], int include_private) |
0abae163 | 392 | { |
9e2c0358 | 393 | const OSSL_PARAM *param_priv_key = NULL, *param_pub_key = NULL; |
0abae163 RL |
394 | BN_CTX *ctx = NULL; |
395 | BIGNUM *priv_key = NULL; | |
396 | unsigned char *pub_key = NULL; | |
397 | size_t pub_key_len; | |
398 | const EC_GROUP *ecg = NULL; | |
399 | EC_POINT *pub_point = NULL; | |
400 | int ok = 0; | |
401 | ||
402 | ecg = EC_KEY_get0_group(ec); | |
403 | if (ecg == NULL) | |
404 | return 0; | |
405 | ||
0abae163 RL |
406 | param_pub_key = |
407 | OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_PUB_KEY); | |
9e2c0358 RL |
408 | if (include_private) |
409 | param_priv_key = | |
410 | OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_PRIV_KEY); | |
0abae163 | 411 | |
32ab57cb | 412 | ctx = BN_CTX_new_ex(ossl_ec_key_get_libctx(ec)); |
0abae163 RL |
413 | if (ctx == NULL) |
414 | goto err; | |
9e2c0358 | 415 | |
9e2c0358 RL |
416 | if (param_pub_key != NULL) |
417 | if (!OSSL_PARAM_get_octet_string(param_pub_key, | |
418 | (void **)&pub_key, 0, &pub_key_len) | |
0abae163 | 419 | || (pub_point = EC_POINT_new(ecg)) == NULL |
9e2c0358 | 420 | || !EC_POINT_oct2point(ecg, pub_point, pub_key, pub_key_len, ctx)) |
0abae163 RL |
421 | goto err; |
422 | ||
423 | if (param_priv_key != NULL && include_private) { | |
424 | int fixed_words; | |
425 | const BIGNUM *order; | |
426 | ||
427 | /* | |
428 | * Key import/export should never leak the bit length of the secret | |
429 | * scalar in the key. | |
430 | * | |
431 | * For this reason, on export we use padded BIGNUMs with fixed length. | |
432 | * | |
433 | * When importing we also should make sure that, even if short lived, | |
434 | * the newly created BIGNUM is marked with the BN_FLG_CONSTTIME flag as | |
435 | * soon as possible, so that any processing of this BIGNUM might opt for | |
436 | * constant time implementations in the backend. | |
437 | * | |
438 | * Setting the BN_FLG_CONSTTIME flag alone is never enough, we also have | |
439 | * to preallocate the BIGNUM internal buffer to a fixed public size big | |
440 | * enough that operations performed during the processing never trigger | |
441 | * a realloc which would leak the size of the scalar through memory | |
442 | * accesses. | |
443 | * | |
444 | * Fixed Length | |
445 | * ------------ | |
446 | * | |
447 | * The order of the large prime subgroup of the curve is our choice for | |
448 | * a fixed public size, as that is generally the upper bound for | |
449 | * generating a private key in EC cryptosystems and should fit all valid | |
450 | * secret scalars. | |
451 | * | |
452 | * For padding on export we just use the bit length of the order | |
453 | * converted to bytes (rounding up). | |
454 | * | |
455 | * For preallocating the BIGNUM storage we look at the number of "words" | |
456 | * required for the internal representation of the order, and we | |
457 | * preallocate 2 extra "words" in case any of the subsequent processing | |
458 | * might temporarily overflow the order length. | |
459 | */ | |
460 | order = EC_GROUP_get0_order(ecg); | |
461 | if (order == NULL || BN_is_zero(order)) | |
462 | goto err; | |
463 | ||
464 | fixed_words = bn_get_top(order) + 2; | |
465 | ||
466 | if ((priv_key = BN_secure_new()) == NULL) | |
467 | goto err; | |
468 | if (bn_wexpand(priv_key, fixed_words) == NULL) | |
469 | goto err; | |
470 | BN_set_flags(priv_key, BN_FLG_CONSTTIME); | |
471 | ||
472 | if (!OSSL_PARAM_get_BN(param_priv_key, &priv_key)) | |
473 | goto err; | |
474 | } | |
475 | ||
476 | if (priv_key != NULL | |
9e2c0358 | 477 | && !EC_KEY_set_private_key(ec, priv_key)) |
0abae163 RL |
478 | goto err; |
479 | ||
9e2c0358 RL |
480 | if (pub_point != NULL |
481 | && !EC_KEY_set_public_key(ec, pub_point)) | |
0abae163 RL |
482 | goto err; |
483 | ||
484 | ok = 1; | |
485 | ||
486 | err: | |
487 | BN_CTX_free(ctx); | |
488 | BN_clear_free(priv_key); | |
489 | OPENSSL_free(pub_key); | |
490 | EC_POINT_free(pub_point); | |
491 | return ok; | |
492 | } | |
493 | ||
32ab57cb | 494 | int ossl_ec_group_fromdata(EC_KEY *ec, const OSSL_PARAM params[]) |
0abae163 | 495 | { |
0abae163 | 496 | int ok = 0; |
c0f39ded | 497 | EC_GROUP *group = NULL; |
0abae163 RL |
498 | |
499 | if (ec == NULL) | |
500 | return 0; | |
501 | ||
32ab57cb SL |
502 | group = EC_GROUP_new_from_params(params, ossl_ec_key_get_libctx(ec), |
503 | ossl_ec_key_get0_propq(ec)); | |
0abae163 | 504 | |
c0f39ded | 505 | if (!EC_KEY_set_group(ec, group)) |
0abae163 | 506 | goto err; |
0abae163 | 507 | ok = 1; |
c0f39ded SL |
508 | err: |
509 | EC_GROUP_free(group); | |
0abae163 RL |
510 | return ok; |
511 | } | |
512 | ||
5b5eea4b SL |
513 | static int ec_key_point_format_fromdata(EC_KEY *ec, const OSSL_PARAM params[]) |
514 | { | |
515 | const OSSL_PARAM *p; | |
516 | int format = -1; | |
517 | ||
518 | p = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_EC_POINT_CONVERSION_FORMAT); | |
519 | if (p != NULL) { | |
32ab57cb | 520 | if (!ossl_ec_pt_format_param2id(p, &format)) { |
5b5eea4b SL |
521 | ECerr(0, EC_R_INVALID_FORM); |
522 | return 0; | |
523 | } | |
524 | EC_KEY_set_conv_form(ec, format); | |
525 | } | |
526 | return 1; | |
527 | } | |
528 | ||
529 | static int ec_key_group_check_fromdata(EC_KEY *ec, const OSSL_PARAM params[]) | |
530 | { | |
531 | const OSSL_PARAM *p; | |
532 | ||
533 | p = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_EC_GROUP_CHECK_TYPE); | |
534 | if (p != NULL) | |
535 | return ec_set_check_group_type_from_param(ec, p); | |
536 | return 1; | |
537 | } | |
538 | ||
539 | static int ec_set_include_public(EC_KEY *ec, int include) | |
540 | { | |
541 | int flags = EC_KEY_get_enc_flags(ec); | |
542 | ||
543 | if (!include) | |
544 | flags |= EC_PKEY_NO_PUBKEY; | |
545 | else | |
546 | flags &= ~EC_PKEY_NO_PUBKEY; | |
547 | EC_KEY_set_enc_flags(ec, flags); | |
548 | return 1; | |
549 | } | |
550 | ||
32ab57cb | 551 | int ossl_ec_key_otherparams_fromdata(EC_KEY *ec, const OSSL_PARAM params[]) |
0abae163 RL |
552 | { |
553 | const OSSL_PARAM *p; | |
554 | ||
555 | if (ec == NULL) | |
556 | return 0; | |
557 | ||
558 | p = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_USE_COFACTOR_ECDH); | |
b8086652 SL |
559 | if (p != NULL) { |
560 | int mode; | |
0abae163 | 561 | |
b8086652 | 562 | if (!OSSL_PARAM_get_int(p, &mode) |
32ab57cb | 563 | || !ossl_ec_set_ecdh_cofactor_mode(ec, mode)) |
b8086652 SL |
564 | return 0; |
565 | } | |
c0f39ded | 566 | |
5b5eea4b SL |
567 | p = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_EC_INCLUDE_PUBLIC); |
568 | if (p != NULL) { | |
569 | int include = 1; | |
570 | ||
571 | if (!OSSL_PARAM_get_int(p, &include) | |
572 | || !ec_set_include_public(ec, include)) | |
573 | return 0; | |
574 | } | |
575 | if (!ec_key_point_format_fromdata(ec, params)) | |
576 | return 0; | |
577 | if (!ec_key_group_check_fromdata(ec, params)) | |
578 | return 0; | |
0abae163 RL |
579 | return 1; |
580 | } | |
5b5eea4b | 581 | |
b247113c TM |
582 | int ossl_ec_key_is_foreign(const EC_KEY *ec) |
583 | { | |
584 | #ifndef FIPS_MODULE | |
585 | if (ec->engine != NULL || EC_KEY_get_method(ec) != EC_KEY_OpenSSL()) | |
586 | return 1; | |
587 | #endif | |
588 | return 0; | |
589 | ||
590 | } | |
591 | ||
b4f447c0 TM |
592 | EC_KEY *ossl_ec_key_dup(const EC_KEY *src, int selection) |
593 | { | |
db6b1266 | 594 | EC_KEY *ret; |
b4f447c0 TM |
595 | |
596 | if (src == NULL) { | |
597 | ERR_raise(ERR_LIB_EC, ERR_R_PASSED_NULL_PARAMETER); | |
db6b1266 | 598 | return NULL; |
b4f447c0 TM |
599 | } |
600 | ||
db6b1266 TM |
601 | if ((ret = ossl_ec_key_new_method_int(src->libctx, src->propq, |
602 | src->engine)) == NULL) | |
603 | return NULL; | |
604 | ||
b4f447c0 TM |
605 | /* copy the parameters */ |
606 | if (src->group != NULL | |
607 | && (selection & OSSL_KEYMGMT_SELECT_DOMAIN_PARAMETERS) != 0) { | |
608 | ret->group = ossl_ec_group_new_ex(src->libctx, src->propq, | |
609 | src->group->meth); | |
610 | if (ret->group == NULL | |
611 | || !EC_GROUP_copy(ret->group, src->group)) | |
612 | goto err; | |
613 | ||
614 | if (src->meth != NULL) { | |
615 | #if !defined(OPENSSL_NO_ENGINE) && !defined(FIPS_MODULE) | |
616 | if (src->engine != NULL && ENGINE_init(src->engine) == 0) | |
617 | goto err; | |
618 | ret->engine = src->engine; | |
619 | #endif | |
620 | ret->meth = src->meth; | |
621 | } | |
622 | } | |
623 | ||
624 | /* copy the public key */ | |
625 | if (src->pub_key != NULL | |
626 | && (selection & OSSL_KEYMGMT_SELECT_PUBLIC_KEY) != 0) { | |
627 | if (ret->group == NULL) | |
628 | /* no parameter-less keys allowed */ | |
629 | goto err; | |
630 | ret->pub_key = EC_POINT_new(ret->group); | |
631 | if (ret->pub_key == NULL | |
632 | || !EC_POINT_copy(ret->pub_key, src->pub_key)) | |
633 | goto err; | |
634 | } | |
635 | ||
636 | /* copy the private key */ | |
637 | if (src->priv_key != NULL | |
638 | && (selection & OSSL_KEYMGMT_SELECT_PRIVATE_KEY) != 0) { | |
639 | if (ret->group == NULL) | |
640 | /* no parameter-less keys allowed */ | |
641 | goto err; | |
642 | ret->priv_key = BN_new(); | |
643 | if (ret->priv_key == NULL || !BN_copy(ret->priv_key, src->priv_key)) | |
644 | goto err; | |
645 | if (ret->group->meth->keycopy | |
646 | && ret->group->meth->keycopy(ret, src) == 0) | |
647 | goto err; | |
648 | } | |
649 | ||
650 | /* copy the rest */ | |
651 | if ((selection & OSSL_KEYMGMT_SELECT_OTHER_PARAMETERS) != 0) { | |
652 | ret->enc_flag = src->enc_flag; | |
653 | ret->conv_form = src->conv_form; | |
654 | } | |
655 | ||
656 | ret->version = src->version; | |
657 | ret->flags = src->flags; | |
658 | ||
659 | #ifndef FIPS_MODULE | |
660 | if (!CRYPTO_dup_ex_data(CRYPTO_EX_INDEX_EC_KEY, | |
661 | &ret->ex_data, &src->ex_data)) | |
662 | goto err; | |
663 | #endif | |
664 | ||
665 | if (ret->meth != NULL && ret->meth->copy != NULL) { | |
666 | if ((selection | |
667 | & OSSL_KEYMGMT_SELECT_KEYPAIR) != OSSL_KEYMGMT_SELECT_KEYPAIR) | |
668 | goto err; | |
669 | if (ret->meth->copy(ret, src) == 0) | |
670 | goto err; | |
671 | } | |
672 | ||
673 | return ret; | |
674 | err: | |
675 | EC_KEY_free(ret); | |
676 | return NULL; | |
677 | } | |
678 | ||
32ab57cb | 679 | int ossl_ec_encoding_param2id(const OSSL_PARAM *p, int *id) |
5b5eea4b SL |
680 | { |
681 | const char *name = NULL; | |
682 | int status = 0; | |
683 | ||
684 | switch (p->data_type) { | |
685 | case OSSL_PARAM_UTF8_STRING: | |
686 | /* The OSSL_PARAM functions have no support for this */ | |
687 | name = p->data; | |
688 | status = (name != NULL); | |
689 | break; | |
690 | case OSSL_PARAM_UTF8_PTR: | |
691 | status = OSSL_PARAM_get_utf8_ptr(p, &name); | |
692 | break; | |
693 | } | |
694 | if (status) { | |
32ab57cb | 695 | int i = ossl_ec_encoding_name2id(name); |
5b5eea4b SL |
696 | |
697 | if (i >= 0) { | |
698 | *id = i; | |
699 | return 1; | |
700 | } | |
701 | } | |
702 | return 0; | |
703 | } | |
704 | ||
32ab57cb | 705 | int ossl_ec_pt_format_param2id(const OSSL_PARAM *p, int *id) |
5b5eea4b SL |
706 | { |
707 | const char *name = NULL; | |
708 | int status = 0; | |
709 | ||
710 | switch (p->data_type) { | |
711 | case OSSL_PARAM_UTF8_STRING: | |
712 | /* The OSSL_PARAM functions have no support for this */ | |
713 | name = p->data; | |
714 | status = (name != NULL); | |
715 | break; | |
716 | case OSSL_PARAM_UTF8_PTR: | |
717 | status = OSSL_PARAM_get_utf8_ptr(p, &name); | |
718 | break; | |
719 | } | |
720 | if (status) { | |
32ab57cb | 721 | int i = ossl_ec_pt_format_name2id(name); |
5b5eea4b SL |
722 | |
723 | if (i >= 0) { | |
724 | *id = i; | |
725 | return 1; | |
726 | } | |
727 | } | |
728 | return 0; | |
729 | } | |
cf333799 RL |
730 | |
731 | #ifndef FIPS_MODULE | |
8c7c1c84 MC |
732 | int ossl_x509_algor_is_sm2(const X509_ALGOR *palg) |
733 | { | |
734 | int ptype = 0; | |
735 | const void *pval = NULL; | |
736 | ||
737 | X509_ALGOR_get0(NULL, &ptype, &pval, palg); | |
738 | ||
739 | if (ptype == V_ASN1_OBJECT) | |
740 | return OBJ_obj2nid((ASN1_OBJECT *)pval) == NID_sm2; | |
741 | ||
742 | if (ptype == V_ASN1_SEQUENCE) { | |
743 | const ASN1_STRING *str = pval; | |
744 | const unsigned char *der = str->data; | |
745 | int derlen = str->length; | |
746 | EC_GROUP *group; | |
747 | int ret; | |
748 | ||
749 | if ((group = d2i_ECPKParameters(NULL, &der, derlen)) == NULL) | |
750 | ret = 0; | |
751 | else | |
752 | ret = (EC_GROUP_get_curve_name(group) == NID_sm2); | |
753 | ||
754 | EC_GROUP_free(group); | |
755 | return ret; | |
756 | } | |
757 | ||
758 | return 0; | |
759 | } | |
760 | ||
cf333799 RL |
761 | EC_KEY *ossl_ec_key_param_from_x509_algor(const X509_ALGOR *palg, |
762 | OSSL_LIB_CTX *libctx, const char *propq) | |
763 | { | |
764 | int ptype = 0; | |
765 | const void *pval = NULL; | |
766 | EC_KEY *eckey = NULL; | |
767 | EC_GROUP *group = NULL; | |
768 | ||
769 | X509_ALGOR_get0(NULL, &ptype, &pval, palg); | |
770 | if ((eckey = EC_KEY_new_ex(libctx, propq)) == NULL) { | |
771 | ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE); | |
772 | goto ecerr; | |
773 | } | |
774 | ||
775 | if (ptype == V_ASN1_SEQUENCE) { | |
776 | const ASN1_STRING *pstr = pval; | |
777 | const unsigned char *pm = pstr->data; | |
778 | int pmlen = pstr->length; | |
779 | ||
780 | ||
781 | if (d2i_ECParameters(&eckey, &pm, pmlen) == NULL) { | |
782 | ERR_raise(ERR_LIB_EC, EC_R_DECODE_ERROR); | |
783 | goto ecerr; | |
784 | } | |
785 | } else if (ptype == V_ASN1_OBJECT) { | |
786 | const ASN1_OBJECT *poid = pval; | |
787 | ||
788 | /* | |
789 | * type == V_ASN1_OBJECT => the parameters are given by an asn1 OID | |
790 | */ | |
791 | ||
792 | group = EC_GROUP_new_by_curve_name_ex(libctx, propq, OBJ_obj2nid(poid)); | |
793 | if (group == NULL) | |
794 | goto ecerr; | |
795 | EC_GROUP_set_asn1_flag(group, OPENSSL_EC_NAMED_CURVE); | |
796 | if (EC_KEY_set_group(eckey, group) == 0) | |
797 | goto ecerr; | |
798 | EC_GROUP_free(group); | |
799 | } else { | |
800 | ERR_raise(ERR_LIB_EC, EC_R_DECODE_ERROR); | |
801 | goto ecerr; | |
802 | } | |
803 | ||
804 | return eckey; | |
805 | ||
806 | ecerr: | |
807 | EC_KEY_free(eckey); | |
808 | EC_GROUP_free(group); | |
809 | return NULL; | |
810 | } | |
811 | ||
812 | EC_KEY *ossl_ec_key_from_pkcs8(const PKCS8_PRIV_KEY_INFO *p8inf, | |
813 | OSSL_LIB_CTX *libctx, const char *propq) | |
814 | { | |
815 | const unsigned char *p = NULL; | |
816 | int pklen; | |
817 | EC_KEY *eckey = NULL; | |
818 | const X509_ALGOR *palg; | |
819 | ||
820 | if (!PKCS8_pkey_get0(NULL, &p, &pklen, &palg, p8inf)) | |
821 | return 0; | |
822 | eckey = ossl_ec_key_param_from_x509_algor(palg, libctx, propq); | |
823 | if (eckey == NULL) | |
824 | goto err; | |
825 | ||
826 | /* We have parameters now set private key */ | |
827 | if (!d2i_ECPrivateKey(&eckey, &p, pklen)) { | |
828 | ERR_raise(ERR_LIB_EC, EC_R_DECODE_ERROR); | |
829 | goto err; | |
830 | } | |
831 | ||
832 | return eckey; | |
833 | err: | |
834 | EC_KEY_free(eckey); | |
835 | return NULL; | |
836 | } | |
837 | #endif |