ec_backend.c@ 99507

最後變更在這個檔案從99507是 97372,由 vboxsync 提交於 2 年前
libs: Switch to openssl-3.0.7, bugref:10317
檔案大小: 24.6 KB

行
1	/*
2	* Copyright 2020-2022 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	* 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
16	#include <openssl/core_names.h>
17	#include <openssl/objects.h>
18	#include <openssl/params.h>
19	#include <openssl/err.h>
20	#ifndef FIPS_MODULE
21	# include <openssl/engine.h>
22	# include <openssl/x509.h>
23	#endif
24	#include "crypto/bn.h"
25	#include "crypto/ec.h"
26	#include "ec_local.h"
27	#include "e_os.h"
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
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
48	int ossl_ec_encoding_name2id(const char *name)
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 (OPENSSL_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
74	char *ossl_ec_check_group_type_id2name(int id)
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 (OPENSSL_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
100	int ossl_ec_set_check_group_type_from_name(EC_KEY ec, const char name)
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)
126	return ossl_ec_set_check_group_type_from_name(ec, name);
127	return 0;
128	}
129
130	int ossl_ec_pt_format_name2id(const char *name)
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 (OPENSSL_strcasecmp(name, format_nameid_map[i].ptr) == 0)
140	return format_nameid_map[i].id;
141	}
142	return -1;
143	}
144
145	char *ossl_ec_pt_format_id2name(int id)
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
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)
159	{
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);
180	return 0;
181	}
182
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);
191
192	if (b == NULL) {
193	ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
194	goto err;
195	}
196
197	if (!EC_GROUP_get_curve(group, p, a, b, bnctx)) {
198	ERR_raise(ERR_LIB_EC, EC_R_INVALID_CURVE);
199	goto err;
200	}
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);
212
213	if (order == NULL) {
214	ERR_raise(ERR_LIB_EC, EC_R_INVALID_GROUP_ORDER);
215	goto err;
216	}
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
240	if (genpt == NULL) {
241	ERR_raise(ERR_LIB_EC, EC_R_INVALID_GENERATOR);
242	goto err;
243	}
244	genbuf_len = EC_POINT_point2buf(group, genpt, genform, genbuf, bnctx);
245	if (genbuf_len == 0) {
246	ERR_raise(ERR_LIB_EC, EC_R_INVALID_GENERATOR);
247	goto err;
248	}
249	if (!ossl_param_build_set_octet_string(tmpl, params,
250	OSSL_PKEY_PARAM_EC_GENERATOR,
251	*genbuf, genbuf_len)) {
252	ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
253	goto err;
254	}
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);
260
261	if (cofactor != NULL
262	&& !ossl_param_build_set_bn(tmpl, params,
263	OSSL_PKEY_PARAM_EC_COFACTOR, cofactor)) {
264	ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
265	goto err;
266	}
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);
273
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)) {
279	ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
280	goto err;
281	}
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) {
298	ERR_raise(ERR_LIB_EC,EC_R_PASSED_NULL_PARAMETER);
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	if (!ossl_param_build_set_int(tmpl, params,
322	OSSL_PKEY_PARAM_EC_DECODED_FROM_EXPLICIT_PARAMS,
323	group->decoded_from_explicit_params))
324	return 0;
325
326	curve_nid = EC_GROUP_get_curve_name(group);
327
328	/*
329	* Get the explicit parameters in these two cases:
330	* - We do not have a template, i.e. specific parameters are requested
331	* - The curve is not a named curve
332	*/
333	if (tmpl == NULL \|\| curve_nid == NID_undef)
334	if (!ec_group_explicit_todata(group, tmpl, params, bnctx, genbuf))
335	goto err;
336
337	if (curve_nid != NID_undef) {
338	/* Named curve */
339	const char *curve_name = OSSL_EC_curve_nid2name(curve_nid);
340
341	if (curve_name == NULL
342	\|\| !ossl_param_build_set_utf8_string(tmpl, params,
343	OSSL_PKEY_PARAM_GROUP_NAME,
344	curve_name)) {
345	ERR_raise(ERR_LIB_EC, EC_R_INVALID_CURVE);
346	goto err;
347	}
348	}
349	ret = 1;
350	err:
351	return ret;
352	}
353
354	/*
355	* The intention with the "backend" source file is to offer backend support
356	* for legacy backends (EVP_PKEY_ASN1_METHOD and EVP_PKEY_METHOD) and provider
357	* implementations alike.
358	*/
359	int ossl_ec_set_ecdh_cofactor_mode(EC_KEY *ec, int mode)
360	{
361	const EC_GROUP *ecg = EC_KEY_get0_group(ec);
362	const BIGNUM *cofactor;
363	/*
364	* mode can be only 0 for disable, or 1 for enable here.
365	*
366	* This is in contrast with the same parameter on an ECDH EVP_PKEY_CTX that
367	* also supports mode == -1 with the meaning of "reset to the default for
368	* the associated key".
369	*/
370	if (mode < 0 \|\| mode > 1)
371	return 0;
372
373	if ((cofactor = EC_GROUP_get0_cofactor(ecg)) == NULL )
374	return 0;
375
376	/* ECDH cofactor mode has no effect if cofactor is 1 */
377	if (BN_is_one(cofactor))
378	return 1;
379
380	if (mode == 1)
381	EC_KEY_set_flags(ec, EC_FLAG_COFACTOR_ECDH);
382	else if (mode == 0)
383	EC_KEY_clear_flags(ec, EC_FLAG_COFACTOR_ECDH);
384
385	return 1;
386	}
387
388	/*
389	* Callers of ossl_ec_key_fromdata MUST make sure that ec_key_params_fromdata has
390	* been called before!
391	*
392	* This function only gets the bare keypair, domain parameters and other
393	* parameters are treated separately, and domain parameters are required to
394	* define a keypair.
395	*/
396	int ossl_ec_key_fromdata(EC_KEY *ec, const OSSL_PARAM params[], int include_private)
397	{
398	const OSSL_PARAM param_priv_key = NULL, param_pub_key = NULL;
399	BN_CTX *ctx = NULL;
400	BIGNUM *priv_key = NULL;
401	unsigned char *pub_key = NULL;
402	size_t pub_key_len;
403	const EC_GROUP *ecg = NULL;
404	EC_POINT *pub_point = NULL;
405	int ok = 0;
406
407	ecg = EC_KEY_get0_group(ec);
408	if (ecg == NULL)
409	return 0;
410
411	param_pub_key =
412	OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_PUB_KEY);
413	if (include_private)
414	param_priv_key =
415	OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_PRIV_KEY);
416
417	ctx = BN_CTX_new_ex(ossl_ec_key_get_libctx(ec));
418	if (ctx == NULL)
419	goto err;
420
421	if (param_pub_key != NULL)
422	if (!OSSL_PARAM_get_octet_string(param_pub_key,
423	(void **)&pub_key, 0, &pub_key_len)
424	\|\| (pub_point = EC_POINT_new(ecg)) == NULL
425	\|\| !EC_POINT_oct2point(ecg, pub_point, pub_key, pub_key_len, ctx))
426	goto err;
427
428	if (param_priv_key != NULL && include_private) {
429	int fixed_words;
430	const BIGNUM *order;
431
432	/*
433	* Key import/export should never leak the bit length of the secret
434	* scalar in the key.
435	*
436	* For this reason, on export we use padded BIGNUMs with fixed length.
437	*
438	* When importing we also should make sure that, even if short lived,
439	* the newly created BIGNUM is marked with the BN_FLG_CONSTTIME flag as
440	* soon as possible, so that any processing of this BIGNUM might opt for
441	* constant time implementations in the backend.
442	*
443	* Setting the BN_FLG_CONSTTIME flag alone is never enough, we also have
444	* to preallocate the BIGNUM internal buffer to a fixed public size big
445	* enough that operations performed during the processing never trigger
446	* a realloc which would leak the size of the scalar through memory
447	* accesses.
448	*
449	* Fixed Length
450	* ------------
451	*
452	* The order of the large prime subgroup of the curve is our choice for
453	* a fixed public size, as that is generally the upper bound for
454	* generating a private key in EC cryptosystems and should fit all valid
455	* secret scalars.
456	*
457	* For padding on export we just use the bit length of the order
458	* converted to bytes (rounding up).
459	*
460	* For preallocating the BIGNUM storage we look at the number of "words"
461	* required for the internal representation of the order, and we
462	* preallocate 2 extra "words" in case any of the subsequent processing
463	* might temporarily overflow the order length.
464	*/
465	order = EC_GROUP_get0_order(ecg);
466	if (order == NULL \|\| BN_is_zero(order))
467	goto err;
468
469	fixed_words = bn_get_top(order) + 2;
470
471	if ((priv_key = BN_secure_new()) == NULL)
472	goto err;
473	if (bn_wexpand(priv_key, fixed_words) == NULL)
474	goto err;
475	BN_set_flags(priv_key, BN_FLG_CONSTTIME);
476
477	if (!OSSL_PARAM_get_BN(param_priv_key, &priv_key))
478	goto err;
479	}
480
481	if (priv_key != NULL
482	&& !EC_KEY_set_private_key(ec, priv_key))
483	goto err;
484
485	if (pub_point != NULL
486	&& !EC_KEY_set_public_key(ec, pub_point))
487	goto err;
488
489	ok = 1;
490
491	err:
492	BN_CTX_free(ctx);
493	BN_clear_free(priv_key);
494	OPENSSL_free(pub_key);
495	EC_POINT_free(pub_point);
496	return ok;
497	}
498
499	int ossl_ec_group_fromdata(EC_KEY *ec, const OSSL_PARAM params[])
500	{
501	int ok = 0;
502	EC_GROUP *group = NULL;
503
504	if (ec == NULL)
505	return 0;
506
507	group = EC_GROUP_new_from_params(params, ossl_ec_key_get_libctx(ec),
508	ossl_ec_key_get0_propq(ec));
509
510	if (!EC_KEY_set_group(ec, group))
511	goto err;
512	ok = 1;
513	err:
514	EC_GROUP_free(group);
515	return ok;
516	}
517
518	static int ec_key_point_format_fromdata(EC_KEY *ec, const OSSL_PARAM params[])
519	{
520	const OSSL_PARAM *p;
521	int format = -1;
522
523	p = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_EC_POINT_CONVERSION_FORMAT);
524	if (p != NULL) {
525	if (!ossl_ec_pt_format_param2id(p, &format)) {
526	ECerr(0, EC_R_INVALID_FORM);
527	return 0;
528	}
529	EC_KEY_set_conv_form(ec, format);
530	}
531	return 1;
532	}
533
534	static int ec_key_group_check_fromdata(EC_KEY *ec, const OSSL_PARAM params[])
535	{
536	const OSSL_PARAM *p;
537
538	p = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_EC_GROUP_CHECK_TYPE);
539	if (p != NULL)
540	return ec_set_check_group_type_from_param(ec, p);
541	return 1;
542	}
543
544	static int ec_set_include_public(EC_KEY *ec, int include)
545	{
546	int flags = EC_KEY_get_enc_flags(ec);
547
548	if (!include)
549	flags \|= EC_PKEY_NO_PUBKEY;
550	else
551	flags &= ~EC_PKEY_NO_PUBKEY;
552	EC_KEY_set_enc_flags(ec, flags);
553	return 1;
554	}
555
556	int ossl_ec_key_otherparams_fromdata(EC_KEY *ec, const OSSL_PARAM params[])
557	{
558	const OSSL_PARAM *p;
559
560	if (ec == NULL)
561	return 0;
562
563	p = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_USE_COFACTOR_ECDH);
564	if (p != NULL) {
565	int mode;
566
567	if (!OSSL_PARAM_get_int(p, &mode)
568	\|\| !ossl_ec_set_ecdh_cofactor_mode(ec, mode))
569	return 0;
570	}
571
572	p = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_EC_INCLUDE_PUBLIC);
573	if (p != NULL) {
574	int include = 1;
575
576	if (!OSSL_PARAM_get_int(p, &include)
577	\|\| !ec_set_include_public(ec, include))
578	return 0;
579	}
580	if (!ec_key_point_format_fromdata(ec, params))
581	return 0;
582	if (!ec_key_group_check_fromdata(ec, params))
583	return 0;
584	return 1;
585	}
586
587	int ossl_ec_key_is_foreign(const EC_KEY *ec)
588	{
589	#ifndef FIPS_MODULE
590	if (ec->engine != NULL \|\| EC_KEY_get_method(ec) != EC_KEY_OpenSSL())
591	return 1;
592	#endif
593	return 0;
594
595	}
596
597	EC_KEY ossl_ec_key_dup(const EC_KEY src, int selection)
598	{
599	EC_KEY *ret;
600
601	if (src == NULL) {
602	ERR_raise(ERR_LIB_EC, ERR_R_PASSED_NULL_PARAMETER);
603	return NULL;
604	}
605
606	if ((ret = ossl_ec_key_new_method_int(src->libctx, src->propq,
607	src->engine)) == NULL)
608	return NULL;
609
610	/* copy the parameters */
611	if (src->group != NULL
612	&& (selection & OSSL_KEYMGMT_SELECT_DOMAIN_PARAMETERS) != 0) {
613	ret->group = ossl_ec_group_new_ex(src->libctx, src->propq,
614	src->group->meth);
615	if (ret->group == NULL
616	\|\| !EC_GROUP_copy(ret->group, src->group))
617	goto err;
618
619	if (src->meth != NULL) {
620	#if !defined(OPENSSL_NO_ENGINE) && !defined(FIPS_MODULE)
621	if (src->engine != NULL && ENGINE_init(src->engine) == 0)
622	goto err;
623	ret->engine = src->engine;
624	#endif
625	ret->meth = src->meth;
626	}
627	}
628
629	/* copy the public key */
630	if (src->pub_key != NULL
631	&& (selection & OSSL_KEYMGMT_SELECT_PUBLIC_KEY) != 0) {
632	if (ret->group == NULL)
633	/* no parameter-less keys allowed */
634	goto err;
635	ret->pub_key = EC_POINT_new(ret->group);
636	if (ret->pub_key == NULL
637	\|\| !EC_POINT_copy(ret->pub_key, src->pub_key))
638	goto err;
639	}
640
641	/* copy the private key */
642	if (src->priv_key != NULL
643	&& (selection & OSSL_KEYMGMT_SELECT_PRIVATE_KEY) != 0) {
644	if (ret->group == NULL)
645	/* no parameter-less keys allowed */
646	goto err;
647	ret->priv_key = BN_new();
648	if (ret->priv_key == NULL \|\| !BN_copy(ret->priv_key, src->priv_key))
649	goto err;
650	if (ret->group->meth->keycopy
651	&& ret->group->meth->keycopy(ret, src) == 0)
652	goto err;
653	}
654
655	/* copy the rest */
656	if ((selection & OSSL_KEYMGMT_SELECT_OTHER_PARAMETERS) != 0) {
657	ret->enc_flag = src->enc_flag;
658	ret->conv_form = src->conv_form;
659	}
660
661	ret->version = src->version;
662	ret->flags = src->flags;
663
664	#ifndef FIPS_MODULE
665	if (!CRYPTO_dup_ex_data(CRYPTO_EX_INDEX_EC_KEY,
666	&ret->ex_data, &src->ex_data))
667	goto err;
668	#endif
669
670	if (ret->meth != NULL && ret->meth->copy != NULL) {
671	if ((selection
672	& OSSL_KEYMGMT_SELECT_KEYPAIR) != OSSL_KEYMGMT_SELECT_KEYPAIR)
673	goto err;
674	if (ret->meth->copy(ret, src) == 0)
675	goto err;
676	}
677
678	return ret;
679	err:
680	EC_KEY_free(ret);
681	return NULL;
682	}
683
684	int ossl_ec_encoding_param2id(const OSSL_PARAM p, int id)
685	{
686	const char *name = NULL;
687	int status = 0;
688
689	switch (p->data_type) {
690	case OSSL_PARAM_UTF8_STRING:
691	/* The OSSL_PARAM functions have no support for this */
692	name = p->data;
693	status = (name != NULL);
694	break;
695	case OSSL_PARAM_UTF8_PTR:
696	status = OSSL_PARAM_get_utf8_ptr(p, &name);
697	break;
698	}
699	if (status) {
700	int i = ossl_ec_encoding_name2id(name);
701
702	if (i >= 0) {
703	*id = i;
704	return 1;
705	}
706	}
707	return 0;
708	}
709
710	int ossl_ec_pt_format_param2id(const OSSL_PARAM p, int id)
711	{
712	const char *name = NULL;
713	int status = 0;
714
715	switch (p->data_type) {
716	case OSSL_PARAM_UTF8_STRING:
717	/* The OSSL_PARAM functions have no support for this */
718	name = p->data;
719	status = (name != NULL);
720	break;
721	case OSSL_PARAM_UTF8_PTR:
722	status = OSSL_PARAM_get_utf8_ptr(p, &name);
723	break;
724	}
725	if (status) {
726	int i = ossl_ec_pt_format_name2id(name);
727
728	if (i >= 0) {
729	*id = i;
730	return 1;
731	}
732	}
733	return 0;
734	}
735
736	#ifndef FIPS_MODULE
737	int ossl_x509_algor_is_sm2(const X509_ALGOR *palg)
738	{
739	int ptype = 0;
740	const void *pval = NULL;
741
742	X509_ALGOR_get0(NULL, &ptype, &pval, palg);
743
744	if (ptype == V_ASN1_OBJECT)
745	return OBJ_obj2nid((ASN1_OBJECT *)pval) == NID_sm2;
746
747	if (ptype == V_ASN1_SEQUENCE) {
748	const ASN1_STRING *str = pval;
749	const unsigned char *der = str->data;
750	int derlen = str->length;
751	EC_GROUP *group;
752	int ret;
753
754	if ((group = d2i_ECPKParameters(NULL, &der, derlen)) == NULL)
755	ret = 0;
756	else
757	ret = (EC_GROUP_get_curve_name(group) == NID_sm2);
758
759	EC_GROUP_free(group);
760	return ret;
761	}
762
763	return 0;
764	}
765
766	EC_KEY ossl_ec_key_param_from_x509_algor(const X509_ALGOR palg,
767	OSSL_LIB_CTX libctx, const char propq)
768	{
769	int ptype = 0;
770	const void *pval = NULL;
771	EC_KEY *eckey = NULL;
772	EC_GROUP *group = NULL;
773
774	X509_ALGOR_get0(NULL, &ptype, &pval, palg);
775	if ((eckey = EC_KEY_new_ex(libctx, propq)) == NULL) {
776	ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
777	goto ecerr;
778	}
779
780	if (ptype == V_ASN1_SEQUENCE) {
781	const ASN1_STRING *pstr = pval;
782	const unsigned char *pm = pstr->data;
783	int pmlen = pstr->length;
784
785
786	if (d2i_ECParameters(&eckey, &pm, pmlen) == NULL) {
787	ERR_raise(ERR_LIB_EC, EC_R_DECODE_ERROR);
788	goto ecerr;
789	}
790	} else if (ptype == V_ASN1_OBJECT) {
791	const ASN1_OBJECT *poid = pval;
792
793	/*
794	* type == V_ASN1_OBJECT => the parameters are given by an asn1 OID
795	*/
796
797	group = EC_GROUP_new_by_curve_name_ex(libctx, propq, OBJ_obj2nid(poid));
798	if (group == NULL)
799	goto ecerr;
800	EC_GROUP_set_asn1_flag(group, OPENSSL_EC_NAMED_CURVE);
801	if (EC_KEY_set_group(eckey, group) == 0)
802	goto ecerr;
803	EC_GROUP_free(group);
804	} else {
805	ERR_raise(ERR_LIB_EC, EC_R_DECODE_ERROR);
806	goto ecerr;
807	}
808
809	return eckey;
810
811	ecerr:
812	EC_KEY_free(eckey);
813	EC_GROUP_free(group);
814	return NULL;
815	}
816
817	EC_KEY ossl_ec_key_from_pkcs8(const PKCS8_PRIV_KEY_INFO p8inf,
818	OSSL_LIB_CTX libctx, const char propq)
819	{
820	const unsigned char *p = NULL;
821	int pklen;
822	EC_KEY *eckey = NULL;
823	const X509_ALGOR *palg;
824
825	if (!PKCS8_pkey_get0(NULL, &p, &pklen, &palg, p8inf))
826	return 0;
827	eckey = ossl_ec_key_param_from_x509_algor(palg, libctx, propq);
828	if (eckey == NULL)
829	goto err;
830
831	/* We have parameters now set private key */
832	if (!d2i_ECPrivateKey(&eckey, &p, pklen)) {
833	ERR_raise(ERR_LIB_EC, EC_R_DECODE_ERROR);
834	goto err;
835	}
836
837	return eckey;
838	err:
839	EC_KEY_free(eckey);
840	return NULL;
841	}
842	#endif

注意: 瀏覽 TracBrowser 來幫助您使用儲存庫瀏覽器

source: vbox/trunk/src/libs/openssl-3.0.7/crypto/ec/ec_backend.c@ 99507

以其他格式下載: