rsa_ameth.c@ 99507

最後變更在這個檔案從99507是 99366,由 vboxsync 提交於 2 年前
openssl-3.1.0: Applied and adjusted our OpenSSL changes to 3.0.7. bugref:10418
檔案大小: 28.3 KB

行
1	/*
2	* Copyright 2006-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	* RSA low level APIs are deprecated for public use, but still ok for
12	* internal use.
13	*/
14	#include "internal/deprecated.h"
15
16	#include <stdio.h>
17	#include "internal/cryptlib.h"
18	#include <openssl/asn1t.h>
19	#include <openssl/x509.h>
20	#include <openssl/bn.h>
21	#include <openssl/core_names.h>
22	#include <openssl/param_build.h>
23	#include "crypto/asn1.h"
24	#include "crypto/evp.h"
25	#include "crypto/rsa.h"
26	#include "rsa_local.h"
27
28	/* Set any parameters associated with pkey */
29	static int rsa_param_encode(const EVP_PKEY *pkey,
30	ASN1_STRING *pstr, int pstrtype)
31	{
32	const RSA *rsa = pkey->pkey.rsa;
33
34	*pstr = NULL;
35	/* If RSA it's just NULL type */
36	if (RSA_test_flags(rsa, RSA_FLAG_TYPE_MASK) != RSA_FLAG_TYPE_RSASSAPSS) {
37	*pstrtype = V_ASN1_NULL;
38	return 1;
39	}
40	/* If no PSS parameters we omit parameters entirely */
41	if (rsa->pss == NULL) {
42	*pstrtype = V_ASN1_UNDEF;
43	return 1;
44	}
45	/* Encode PSS parameters */
46	if (ASN1_item_pack(rsa->pss, ASN1_ITEM_rptr(RSA_PSS_PARAMS), pstr) == NULL)
47	return 0;
48
49	*pstrtype = V_ASN1_SEQUENCE;
50	return 1;
51	}
52	/* Decode any parameters and set them in RSA structure */
53	static int rsa_pub_encode(X509_PUBKEY pk, const EVP_PKEY pkey)
54	{
55	unsigned char *penc = NULL;
56	int penclen;
57	ASN1_STRING *str;
58	int strtype;
59
60	if (!rsa_param_encode(pkey, &str, &strtype))
61	return 0;
62	penclen = i2d_RSAPublicKey(pkey->pkey.rsa, &penc);
63	if (penclen <= 0)
64	return 0;
65	if (X509_PUBKEY_set0_param(pk, OBJ_nid2obj(pkey->ameth->pkey_id),
66	strtype, str, penc, penclen))
67	return 1;
68
69	OPENSSL_free(penc);
70	return 0;
71	}
72
73	static int rsa_pub_decode(EVP_PKEY pkey, const X509_PUBKEY pubkey)
74	{
75	const unsigned char *p;
76	int pklen;
77	X509_ALGOR *alg;
78	RSA *rsa = NULL;
79
80	if (!X509_PUBKEY_get0_param(NULL, &p, &pklen, &alg, pubkey))
81	return 0;
82	if ((rsa = d2i_RSAPublicKey(NULL, &p, pklen)) == NULL)
83	return 0;
84	if (!ossl_rsa_param_decode(rsa, alg)) {
85	RSA_free(rsa);
86	return 0;
87	}
88
89	RSA_clear_flags(rsa, RSA_FLAG_TYPE_MASK);
90	switch (pkey->ameth->pkey_id) {
91	case EVP_PKEY_RSA:
92	RSA_set_flags(rsa, RSA_FLAG_TYPE_RSA);
93	break;
94	case EVP_PKEY_RSA_PSS:
95	RSA_set_flags(rsa, RSA_FLAG_TYPE_RSASSAPSS);
96	break;
97	default:
98	/* Leave the type bits zero */
99	break;
100	}
101
102	if (!EVP_PKEY_assign(pkey, pkey->ameth->pkey_id, rsa)) {
103	RSA_free(rsa);
104	return 0;
105	}
106	return 1;
107	}
108
109	static int rsa_pub_cmp(const EVP_PKEY a, const EVP_PKEY b)
110	{
111	/*
112	* Don't check the public/private key, this is mostly for smart
113	* cards.
114	*/
115	if (((RSA_flags(a->pkey.rsa) & RSA_METHOD_FLAG_NO_CHECK))
116	\|\| (RSA_flags(b->pkey.rsa) & RSA_METHOD_FLAG_NO_CHECK)) {
117	return 1;
118	}
119
120	if (BN_cmp(b->pkey.rsa->n, a->pkey.rsa->n) != 0
121	\|\| BN_cmp(b->pkey.rsa->e, a->pkey.rsa->e) != 0)
122	return 0;
123	return 1;
124	}
125
126	static int old_rsa_priv_decode(EVP_PKEY *pkey,
127	const unsigned char **pder, int derlen)
128	{
129	RSA *rsa;
130
131	if ((rsa = d2i_RSAPrivateKey(NULL, pder, derlen)) == NULL)
132	return 0;
133	EVP_PKEY_assign(pkey, pkey->ameth->pkey_id, rsa);
134	return 1;
135	}
136
137	static int old_rsa_priv_encode(const EVP_PKEY pkey, unsigned char *pder)
138	{
139	return i2d_RSAPrivateKey(pkey->pkey.rsa, pder);
140	}
141
142	static int rsa_priv_encode(PKCS8_PRIV_KEY_INFO p8, const EVP_PKEY pkey)
143	{
144	unsigned char *rk = NULL;
145	int rklen;
146	ASN1_STRING *str;
147	int strtype;
148
149	if (!rsa_param_encode(pkey, &str, &strtype))
150	return 0;
151	rklen = i2d_RSAPrivateKey(pkey->pkey.rsa, &rk);
152
153	if (rklen <= 0) {
154	ERR_raise(ERR_LIB_RSA, ERR_R_MALLOC_FAILURE);
155	ASN1_STRING_free(str);
156	return 0;
157	}
158
159	if (!PKCS8_pkey_set0(p8, OBJ_nid2obj(pkey->ameth->pkey_id), 0,
160	strtype, str, rk, rklen)) {
161	ERR_raise(ERR_LIB_RSA, ERR_R_MALLOC_FAILURE);
162	ASN1_STRING_free(str);
163	OPENSSL_clear_free(rk, rklen);
164	return 0;
165	}
166
167	return 1;
168	}
169
170	static int rsa_priv_decode(EVP_PKEY pkey, const PKCS8_PRIV_KEY_INFO p8)
171	{
172	int ret = 0;
173	RSA *rsa = ossl_rsa_key_from_pkcs8(p8, NULL, NULL);
174
175	if (rsa != NULL) {
176	ret = 1;
177	EVP_PKEY_assign(pkey, pkey->ameth->pkey_id, rsa);
178	}
179	return ret;
180	}
181
182	static int int_rsa_size(const EVP_PKEY *pkey)
183	{
184	return RSA_size(pkey->pkey.rsa);
185	}
186
187	static int rsa_bits(const EVP_PKEY *pkey)
188	{
189	return BN_num_bits(pkey->pkey.rsa->n);
190	}
191
192	static int rsa_security_bits(const EVP_PKEY *pkey)
193	{
194	return RSA_security_bits(pkey->pkey.rsa);
195	}
196
197	static void int_rsa_free(EVP_PKEY *pkey)
198	{
199	RSA_free(pkey->pkey.rsa);
200	}
201
202	static int rsa_pss_param_print(BIO bp, int pss_key, RSA_PSS_PARAMS pss,
203	int indent)
204	{
205	int rv = 0;
206	X509_ALGOR *maskHash = NULL;
207
208	if (!BIO_indent(bp, indent, 128))
209	goto err;
210	if (pss_key) {
211	if (pss == NULL) {
212	if (BIO_puts(bp, "No PSS parameter restrictions\n") <= 0)
213	return 0;
214	return 1;
215	} else {
216	if (BIO_puts(bp, "PSS parameter restrictions:") <= 0)
217	return 0;
218	}
219	} else if (pss == NULL) {
220	if (BIO_puts(bp,"(INVALID PSS PARAMETERS)\n") <= 0)
221	return 0;
222	return 1;
223	}
224	if (BIO_puts(bp, "\n") <= 0)
225	goto err;
226	if (pss_key)
227	indent += 2;
228	if (!BIO_indent(bp, indent, 128))
229	goto err;
230	if (BIO_puts(bp, "Hash Algorithm: ") <= 0)
231	goto err;
232
233	if (pss->hashAlgorithm) {
234	if (i2a_ASN1_OBJECT(bp, pss->hashAlgorithm->algorithm) <= 0)
235	goto err;
236	} else if (BIO_puts(bp, "sha1 (default)") <= 0) {
237	goto err;
238	}
239
240	if (BIO_puts(bp, "\n") <= 0)
241	goto err;
242
243	if (!BIO_indent(bp, indent, 128))
244	goto err;
245
246	if (BIO_puts(bp, "Mask Algorithm: ") <= 0)
247	goto err;
248	if (pss->maskGenAlgorithm) {
249	if (i2a_ASN1_OBJECT(bp, pss->maskGenAlgorithm->algorithm) <= 0)
250	goto err;
251	if (BIO_puts(bp, " with ") <= 0)
252	goto err;
253	maskHash = ossl_x509_algor_mgf1_decode(pss->maskGenAlgorithm);
254	if (maskHash != NULL) {
255	if (i2a_ASN1_OBJECT(bp, maskHash->algorithm) <= 0)
256	goto err;
257	} else if (BIO_puts(bp, "INVALID") <= 0) {
258	goto err;
259	}
260	} else if (BIO_puts(bp, "mgf1 with sha1 (default)") <= 0) {
261	goto err;
262	}
263	BIO_puts(bp, "\n");
264
265	if (!BIO_indent(bp, indent, 128))
266	goto err;
267	if (BIO_printf(bp, "%s Salt Length: 0x", pss_key ? "Minimum" : "") <= 0)
268	goto err;
269	if (pss->saltLength) {
270	if (i2a_ASN1_INTEGER(bp, pss->saltLength) <= 0)
271	goto err;
272	} else if (BIO_puts(bp, "14 (default)") <= 0) {
273	goto err;
274	}
275	BIO_puts(bp, "\n");
276
277	if (!BIO_indent(bp, indent, 128))
278	goto err;
279	if (BIO_puts(bp, "Trailer Field: 0x") <= 0)
280	goto err;
281	if (pss->trailerField) {
282	if (i2a_ASN1_INTEGER(bp, pss->trailerField) <= 0)
283	goto err;
284	} else if (BIO_puts(bp, "01 (default)") <= 0) {
285	goto err;
286	}
287	BIO_puts(bp, "\n");
288
289	rv = 1;
290
291	err:
292	X509_ALGOR_free(maskHash);
293	return rv;
294
295	}
296
297	static int pkey_rsa_print(BIO bp, const EVP_PKEY pkey, int off, int priv)
298	{
299	const RSA *x = pkey->pkey.rsa;
300	char *str;
301	const char *s;
302	int ret = 0, mod_len = 0, ex_primes;
303
304	if (x->n != NULL)
305	mod_len = BN_num_bits(x->n);
306	ex_primes = sk_RSA_PRIME_INFO_num(x->prime_infos);
307
308	if (!BIO_indent(bp, off, 128))
309	goto err;
310
311	if (BIO_printf(bp, "%s ", pkey_is_pss(pkey) ? "RSA-PSS" : "RSA") <= 0)
312	goto err;
313
314	if (priv && x->d) {
315	if (BIO_printf(bp, "Private-Key: (%d bit, %d primes)\n",
316	mod_len, ex_primes <= 0 ? 2 : ex_primes + 2) <= 0)
317	goto err;
318	str = "modulus:";
319	s = "publicExponent:";
320	} else {
321	if (BIO_printf(bp, "Public-Key: (%d bit)\n", mod_len) <= 0)
322	goto err;
323	str = "Modulus:";
324	s = "Exponent:";
325	}
326	if (!ASN1_bn_print(bp, str, x->n, NULL, off))
327	goto err;
328	if (!ASN1_bn_print(bp, s, x->e, NULL, off))
329	goto err;
330	if (priv) {
331	int i;
332
333	if (!ASN1_bn_print(bp, "privateExponent:", x->d, NULL, off))
334	goto err;
335	if (!ASN1_bn_print(bp, "prime1:", x->p, NULL, off))
336	goto err;
337	if (!ASN1_bn_print(bp, "prime2:", x->q, NULL, off))
338	goto err;
339	if (!ASN1_bn_print(bp, "exponent1:", x->dmp1, NULL, off))
340	goto err;
341	if (!ASN1_bn_print(bp, "exponent2:", x->dmq1, NULL, off))
342	goto err;
343	if (!ASN1_bn_print(bp, "coefficient:", x->iqmp, NULL, off))
344	goto err;
345	for (i = 0; i < sk_RSA_PRIME_INFO_num(x->prime_infos); i++) {
346	/* print multi-prime info */
347	BIGNUM *bn = NULL;
348	RSA_PRIME_INFO *pinfo;
349	int j;
350
351	pinfo = sk_RSA_PRIME_INFO_value(x->prime_infos, i);
352	for (j = 0; j < 3; j++) {
353	if (!BIO_indent(bp, off, 128))
354	goto err;
355	switch (j) {
356	case 0:
357	if (BIO_printf(bp, "prime%d:", i + 3) <= 0)
358	goto err;
359	bn = pinfo->r;
360	break;
361	case 1:
362	if (BIO_printf(bp, "exponent%d:", i + 3) <= 0)
363	goto err;
364	bn = pinfo->d;
365	break;
366	case 2:
367	if (BIO_printf(bp, "coefficient%d:", i + 3) <= 0)
368	goto err;
369	bn = pinfo->t;
370	break;
371	default:
372	break;
373	}
374	if (!ASN1_bn_print(bp, "", bn, NULL, off))
375	goto err;
376	}
377	}
378	}
379	if (pkey_is_pss(pkey) && !rsa_pss_param_print(bp, 1, x->pss, off))
380	goto err;
381	ret = 1;
382	err:
383	return ret;
384	}
385
386	static int rsa_pub_print(BIO bp, const EVP_PKEY pkey, int indent,
387	ASN1_PCTX *ctx)
388	{
389	return pkey_rsa_print(bp, pkey, indent, 0);
390	}
391
392	static int rsa_priv_print(BIO bp, const EVP_PKEY pkey, int indent,
393	ASN1_PCTX *ctx)
394	{
395	return pkey_rsa_print(bp, pkey, indent, 1);
396	}
397
398	static int rsa_sig_print(BIO bp, const X509_ALGOR sigalg,
399	const ASN1_STRING sig, int indent, ASN1_PCTX pctx)
400	{
401	if (OBJ_obj2nid(sigalg->algorithm) == EVP_PKEY_RSA_PSS) {
402	int rv;
403	RSA_PSS_PARAMS *pss = ossl_rsa_pss_decode(sigalg);
404
405	rv = rsa_pss_param_print(bp, 0, pss, indent);
406	RSA_PSS_PARAMS_free(pss);
407	if (!rv)
408	return 0;
409	} else if (BIO_puts(bp, "\n") <= 0) {
410	return 0;
411	}
412	if (sig)
413	return X509_signature_dump(bp, sig, indent);
414	return 1;
415	}
416
417	static int rsa_pkey_ctrl(EVP_PKEY pkey, int op, long arg1, void arg2)
418	{
419	const EVP_MD *md;
420	const EVP_MD *mgf1md;
421	int min_saltlen;
422
423	switch (op) {
424	case ASN1_PKEY_CTRL_DEFAULT_MD_NID:
425	if (pkey->pkey.rsa->pss != NULL) {
426	if (!ossl_rsa_pss_get_param(pkey->pkey.rsa->pss, &md, &mgf1md,
427	&min_saltlen)) {
428	ERR_raise(ERR_LIB_RSA, ERR_R_INTERNAL_ERROR);
429	return 0;
430	}
431	(int )arg2 = EVP_MD_get_type(md);
432	/* Return of 2 indicates this MD is mandatory */
433	return 2;
434	}
435	(int )arg2 = NID_sha256;
436	return 1;
437
438	default:
439	return -2;
440	}
441	}
442
443	/*
444	* Convert EVP_PKEY_CTX in PSS mode into corresponding algorithm parameter,
445	* suitable for setting an AlgorithmIdentifier.
446	*/
447
448	static RSA_PSS_PARAMS rsa_ctx_to_pss(EVP_PKEY_CTX pkctx)
449	{
450	const EVP_MD sigmd, mgf1md;
451	EVP_PKEY *pk = EVP_PKEY_CTX_get0_pkey(pkctx);
452	int saltlen;
453	int saltlenMax = -1;
454
455	if (EVP_PKEY_CTX_get_signature_md(pkctx, &sigmd) <= 0)
456	return NULL;
457	if (EVP_PKEY_CTX_get_rsa_mgf1_md(pkctx, &mgf1md) <= 0)
458	return NULL;
459	if (EVP_PKEY_CTX_get_rsa_pss_saltlen(pkctx, &saltlen) <= 0)
460	return NULL;
461	if (saltlen == RSA_PSS_SALTLEN_DIGEST) {
462	saltlen = EVP_MD_get_size(sigmd);
463	} else if (saltlen == RSA_PSS_SALTLEN_AUTO_DIGEST_MAX) {
464	/* FIPS 186-4 section 5 "The RSA Digital Signature Algorithm",
465	* subsection 5.5 "PKCS #1" says: "For RSASSA-PSS […] the length (in
466	* bytes) of the salt (sLen) shall satisfy 0 <= sLen <= hLen, where
467	* hLen is the length of the hash function output block (in bytes)."
468	*
469	* Provide a way to use at most the digest length, so that the default
470	* does not violate FIPS 186-4. */
471	saltlen = RSA_PSS_SALTLEN_MAX;
472	saltlenMax = EVP_MD_get_size(sigmd);
473	}
474	if (saltlen == RSA_PSS_SALTLEN_MAX \|\| saltlen == RSA_PSS_SALTLEN_AUTO) {
475	saltlen = EVP_PKEY_get_size(pk) - EVP_MD_get_size(sigmd) - 2;
476	if ((EVP_PKEY_get_bits(pk) & 0x7) == 1)
477	saltlen--;
478	if (saltlen < 0)
479	return NULL;
480	if (saltlenMax >= 0 && saltlen > saltlenMax)
481	saltlen = saltlenMax;
482	}
483
484	return ossl_rsa_pss_params_create(sigmd, mgf1md, saltlen);
485	}
486
487	RSA_PSS_PARAMS ossl_rsa_pss_params_create(const EVP_MD sigmd,
488	const EVP_MD *mgf1md, int saltlen)
489	{
490	RSA_PSS_PARAMS *pss = RSA_PSS_PARAMS_new();
491
492	if (pss == NULL)
493	goto err;
494	if (saltlen != 20) {
495	pss->saltLength = ASN1_INTEGER_new();
496	if (pss->saltLength == NULL)
497	goto err;
498	if (!ASN1_INTEGER_set(pss->saltLength, saltlen))
499	goto err;
500	}
501	if (!ossl_x509_algor_new_from_md(&pss->hashAlgorithm, sigmd))
502	goto err;
503	if (mgf1md == NULL)
504	mgf1md = sigmd;
505	if (!ossl_x509_algor_md_to_mgf1(&pss->maskGenAlgorithm, mgf1md))
506	goto err;
507	if (!ossl_x509_algor_new_from_md(&pss->maskHash, mgf1md))
508	goto err;
509	return pss;
510	err:
511	RSA_PSS_PARAMS_free(pss);
512	return NULL;
513	}
514
515	ASN1_STRING ossl_rsa_ctx_to_pss_string(EVP_PKEY_CTX pkctx)
516	{
517	RSA_PSS_PARAMS *pss = rsa_ctx_to_pss(pkctx);
518	ASN1_STRING *os;
519
520	if (pss == NULL)
521	return NULL;
522
523	os = ASN1_item_pack(pss, ASN1_ITEM_rptr(RSA_PSS_PARAMS), NULL);
524	RSA_PSS_PARAMS_free(pss);
525	return os;
526	}
527
528	/*
529	* From PSS AlgorithmIdentifier set public key parameters. If pkey isn't NULL
530	* then the EVP_MD_CTX is setup and initialised. If it is NULL parameters are
531	* passed to pkctx instead.
532	*/
533
534	int ossl_rsa_pss_to_ctx(EVP_MD_CTX ctx, EVP_PKEY_CTX pkctx,
535	const X509_ALGOR sigalg, EVP_PKEY pkey)
536	{
537	int rv = -1;
538	int saltlen;
539	const EVP_MD mgf1md = NULL, md = NULL;
540	RSA_PSS_PARAMS *pss;
541
542	/* Sanity check: make sure it is PSS */
543	if (OBJ_obj2nid(sigalg->algorithm) != EVP_PKEY_RSA_PSS) {
544	ERR_raise(ERR_LIB_RSA, RSA_R_UNSUPPORTED_SIGNATURE_TYPE);
545	return -1;
546	}
547	/* Decode PSS parameters */
548	pss = ossl_rsa_pss_decode(sigalg);
549
550	if (!ossl_rsa_pss_get_param(pss, &md, &mgf1md, &saltlen)) {
551	ERR_raise(ERR_LIB_RSA, RSA_R_INVALID_PSS_PARAMETERS);
552	goto err;
553	}
554
555	/* We have all parameters now set up context */
556	if (pkey) {
557	if (!EVP_DigestVerifyInit(ctx, &pkctx, md, NULL, pkey))
558	goto err;
559	} else {
560	const EVP_MD *checkmd;
561	if (EVP_PKEY_CTX_get_signature_md(pkctx, &checkmd) <= 0)
562	goto err;
563	if (EVP_MD_get_type(md) != EVP_MD_get_type(checkmd)) {
564	ERR_raise(ERR_LIB_RSA, RSA_R_DIGEST_DOES_NOT_MATCH);
565	goto err;
566	}
567	}
568
569	if (EVP_PKEY_CTX_set_rsa_padding(pkctx, RSA_PKCS1_PSS_PADDING) <= 0)
570	goto err;
571
572	if (EVP_PKEY_CTX_set_rsa_pss_saltlen(pkctx, saltlen) <= 0)
573	goto err;
574
575	if (EVP_PKEY_CTX_set_rsa_mgf1_md(pkctx, mgf1md) <= 0)
576	goto err;
577	/* Carry on */
578	rv = 1;
579
580	err:
581	RSA_PSS_PARAMS_free(pss);
582	return rv;
583	}
584
585	static int rsa_pss_verify_param(const EVP_MD pmd, const EVP_MD pmgf1md,
586	int psaltlen, int ptrailerField)
587	{
588	if (psaltlen != NULL && *psaltlen < 0) {
589	ERR_raise(ERR_LIB_RSA, RSA_R_INVALID_SALT_LENGTH);
590	return 0;
591	}
592	/*
593	* low-level routines support only trailer field 0xbc (value 1) and
594	* PKCS#1 says we should reject any other value anyway.
595	*/
596	if (ptrailerField != NULL && *ptrailerField != 1) {
597	ERR_raise(ERR_LIB_RSA, RSA_R_INVALID_TRAILER);
598	return 0;
599	}
600	return 1;
601	}
602
603	int ossl_rsa_pss_get_param(const RSA_PSS_PARAMS pss, const EVP_MD *pmd,
604	const EVP_MD *pmgf1md, int psaltlen)
605	{
606	/*
607	* Callers do not care about the trailer field, and yet, we must
608	* pass it from get_param to verify_param, since the latter checks
609	* its value.
610	*
611	* When callers start caring, it's a simple thing to add another
612	* argument to this function.
613	*/
614	int trailerField = 0;
615
616	return ossl_rsa_pss_get_param_unverified(pss, pmd, pmgf1md, psaltlen,
617	&trailerField)
618	&& rsa_pss_verify_param(pmd, pmgf1md, psaltlen, &trailerField);
619	}
620
621	/*
622	* Customised RSA item verification routine. This is called when a signature
623	* is encountered requiring special handling. We currently only handle PSS.
624	*/
625
626	static int rsa_item_verify(EVP_MD_CTX ctx, const ASN1_ITEM it,
627	const void asn, const X509_ALGOR sigalg,
628	const ASN1_BIT_STRING sig, EVP_PKEY pkey)
629	{
630	/* Sanity check: make sure it is PSS */
631	if (OBJ_obj2nid(sigalg->algorithm) != EVP_PKEY_RSA_PSS) {
632	ERR_raise(ERR_LIB_RSA, RSA_R_UNSUPPORTED_SIGNATURE_TYPE);
633	return -1;
634	}
635	if (ossl_rsa_pss_to_ctx(ctx, NULL, sigalg, pkey) > 0) {
636	/* Carry on */
637	return 2;
638	}
639	return -1;
640	}
641
642	static int rsa_item_sign(EVP_MD_CTX ctx, const ASN1_ITEM it, const void *asn,
643	X509_ALGOR alg1, X509_ALGOR alg2,
644	ASN1_BIT_STRING *sig)
645	{
646	int pad_mode;
647	EVP_PKEY_CTX *pkctx = EVP_MD_CTX_get_pkey_ctx(ctx);
648
649	if (EVP_PKEY_CTX_get_rsa_padding(pkctx, &pad_mode) <= 0)
650	return 0;
651	if (pad_mode == RSA_PKCS1_PADDING)
652	return 2;
653	if (pad_mode == RSA_PKCS1_PSS_PADDING) {
654	unsigned char aid[128];
655	size_t aid_len = 0;
656	OSSL_PARAM params[2];
657
658	params[0] = OSSL_PARAM_construct_octet_string(
659	OSSL_SIGNATURE_PARAM_ALGORITHM_ID, aid, sizeof(aid));
660	params[1] = OSSL_PARAM_construct_end();
661
662	if (EVP_PKEY_CTX_get_params(pkctx, params) <= 0)
663	return 0;
664	if ((aid_len = params[0].return_size) == 0)
665	return 0;
666
667	if (alg1 != NULL) {
668	const unsigned char *pp = aid;
669	if (d2i_X509_ALGOR(&alg1, &pp, aid_len) == NULL)
670	return 0;
671	}
672	if (alg2 != NULL) {
673	const unsigned char *pp = aid;
674	if (d2i_X509_ALGOR(&alg2, &pp, aid_len) == NULL)
675	return 0;
676	}
677
678	return 3;
679	}
680	return 2;
681	}
682
683	static int rsa_sig_info_set(X509_SIG_INFO siginf, const X509_ALGOR sigalg,
684	const ASN1_STRING *sig)
685	{
686	int rv = 0;
687	int mdnid, saltlen;
688	uint32_t flags;
689	const EVP_MD mgf1md = NULL, md = NULL;
690	RSA_PSS_PARAMS *pss;
691	int secbits;
692
693	/* Sanity check: make sure it is PSS */
694	if (OBJ_obj2nid(sigalg->algorithm) != EVP_PKEY_RSA_PSS)
695	return 0;
696	/* Decode PSS parameters */
697	pss = ossl_rsa_pss_decode(sigalg);
698	if (!ossl_rsa_pss_get_param(pss, &md, &mgf1md, &saltlen))
699	goto err;
700	mdnid = EVP_MD_get_type(md);
701	/*
702	* For TLS need SHA256, SHA384 or SHA512, digest and MGF1 digest must
703	* match and salt length must equal digest size
704	*/
705	if ((mdnid == NID_sha256 \|\| mdnid == NID_sha384 \|\| mdnid == NID_sha512)
706	&& mdnid == EVP_MD_get_type(mgf1md)
707	&& saltlen == EVP_MD_get_size(md))
708	flags = X509_SIG_INFO_TLS;
709	else
710	flags = 0;
711	/* Note: security bits half number of digest bits */
712	secbits = EVP_MD_get_size(md) * 4;
713	/*
714	* SHA1 and MD5 are known to be broken. Reduce security bits so that
715	* they're no longer accepted at security level 1. The real values don't
716	* really matter as long as they're lower than 80, which is our security
717	* level 1.
718	* https://eprint.iacr.org/2020/014 puts a chosen-prefix attack for SHA1 at
719	* 2^63.4
720	* https://documents.epfl.ch/users/l/le/lenstra/public/papers/lat.pdf
721	* puts a chosen-prefix attack for MD5 at 2^39.
722	*/
723	if (mdnid == NID_sha1)
724	secbits = 64;
725	else if (mdnid == NID_md5_sha1)
726	secbits = 68;
727	else if (mdnid == NID_md5)
728	secbits = 39;
729	X509_SIG_INFO_set(siginf, mdnid, EVP_PKEY_RSA_PSS, secbits,
730	flags);
731	rv = 1;
732	err:
733	RSA_PSS_PARAMS_free(pss);
734	return rv;
735	}
736
737	static int rsa_pkey_check(const EVP_PKEY *pkey)
738	{
739	return RSA_check_key_ex(pkey->pkey.rsa, NULL);
740	}
741
742	static size_t rsa_pkey_dirty_cnt(const EVP_PKEY *pkey)
743	{
744	return pkey->pkey.rsa->dirty_cnt;
745	}
746
747	/*
748	* There is no need to do RSA_test_flags(rsa, RSA_FLAG_TYPE_RSASSAPSS)
749	* checks in this method since the caller tests EVP_KEYMGMT_is_a() first.
750	*/
751	static int rsa_int_export_to(const EVP_PKEY *from, int rsa_type,
752	void *to_keydata,
753	OSSL_FUNC_keymgmt_import_fn *importer,
754	OSSL_LIB_CTX libctx, const char propq)
755	{
756	RSA *rsa = from->pkey.rsa;
757	OSSL_PARAM_BLD *tmpl = OSSL_PARAM_BLD_new();
758	OSSL_PARAM *params = NULL;
759	int selection = 0;
760	int rv = 0;
761
762	if (tmpl == NULL)
763	return 0;
764	/* Public parameters must always be present */
765	if (RSA_get0_n(rsa) == NULL \|\| RSA_get0_e(rsa) == NULL)
766	goto err;
767
768	if (!ossl_rsa_todata(rsa, tmpl, NULL, 1))
769	goto err;
770
771	selection \|= OSSL_KEYMGMT_SELECT_PUBLIC_KEY;
772	if (RSA_get0_d(rsa) != NULL)
773	selection \|= OSSL_KEYMGMT_SELECT_PRIVATE_KEY;
774
775	if (rsa->pss != NULL) {
776	const EVP_MD md = NULL, mgf1md = NULL;
777	int md_nid, mgf1md_nid, saltlen, trailerfield;
778	RSA_PSS_PARAMS_30 pss_params;
779
780	if (!ossl_rsa_pss_get_param_unverified(rsa->pss, &md, &mgf1md,
781	&saltlen, &trailerfield))
782	goto err;
783	md_nid = EVP_MD_get_type(md);
784	mgf1md_nid = EVP_MD_get_type(mgf1md);
785	if (!ossl_rsa_pss_params_30_set_defaults(&pss_params)
786	\|\| !ossl_rsa_pss_params_30_set_hashalg(&pss_params, md_nid)
787	\|\| !ossl_rsa_pss_params_30_set_maskgenhashalg(&pss_params,
788	mgf1md_nid)
789	\|\| !ossl_rsa_pss_params_30_set_saltlen(&pss_params, saltlen)
790	\|\| !ossl_rsa_pss_params_30_todata(&pss_params, tmpl, NULL))
791	goto err;
792	selection \|= OSSL_KEYMGMT_SELECT_OTHER_PARAMETERS;
793	}
794
795	if ((params = OSSL_PARAM_BLD_to_param(tmpl)) == NULL)
796	goto err;
797
798	/* We export, the provider imports */
799	rv = importer(to_keydata, selection, params);
800
801	err:
802	OSSL_PARAM_free(params);
803	OSSL_PARAM_BLD_free(tmpl);
804	return rv;
805	}
806
807	static int rsa_int_import_from(const OSSL_PARAM params[], void *vpctx,
808	int rsa_type)
809	{
810	EVP_PKEY_CTX *pctx = vpctx;
811	EVP_PKEY *pkey = EVP_PKEY_CTX_get0_pkey(pctx);
812	RSA *rsa = ossl_rsa_new_with_ctx(pctx->libctx);
813	RSA_PSS_PARAMS_30 rsa_pss_params = { 0, };
814	int pss_defaults_set = 0;
815	int ok = 0;
816
817	if (rsa == NULL) {
818	ERR_raise(ERR_LIB_DH, ERR_R_MALLOC_FAILURE);
819	return 0;
820	}
821
822	RSA_clear_flags(rsa, RSA_FLAG_TYPE_MASK);
823	RSA_set_flags(rsa, rsa_type);
824
825	if (!ossl_rsa_pss_params_30_fromdata(&rsa_pss_params, &pss_defaults_set,
826	params, pctx->libctx))
827	goto err;
828
829	switch (rsa_type) {
830	case RSA_FLAG_TYPE_RSA:
831	/*
832	* Were PSS parameters filled in?
833	* In that case, something's wrong
834	*/
835	if (!ossl_rsa_pss_params_30_is_unrestricted(&rsa_pss_params))
836	goto err;
837	break;
838	case RSA_FLAG_TYPE_RSASSAPSS:
839	/*
840	* Were PSS parameters filled in? In that case, create the old
841	* RSA_PSS_PARAMS structure. Otherwise, this is an unrestricted key.
842	*/
843	if (!ossl_rsa_pss_params_30_is_unrestricted(&rsa_pss_params)) {
844	/* Create the older RSA_PSS_PARAMS from RSA_PSS_PARAMS_30 data */
845	int mdnid = ossl_rsa_pss_params_30_hashalg(&rsa_pss_params);
846	int mgf1mdnid = ossl_rsa_pss_params_30_maskgenhashalg(&rsa_pss_params);
847	int saltlen = ossl_rsa_pss_params_30_saltlen(&rsa_pss_params);
848	const EVP_MD *md = EVP_get_digestbynid(mdnid);
849	const EVP_MD *mgf1md = EVP_get_digestbynid(mgf1mdnid);
850
851	if ((rsa->pss = ossl_rsa_pss_params_create(md, mgf1md,
852	saltlen)) == NULL)
853	goto err;
854	}
855	break;
856	default:
857	/* RSA key sub-types we don't know how to handle yet */
858	goto err;
859	}
860
861	if (!ossl_rsa_fromdata(rsa, params, 1))
862	goto err;
863
864	switch (rsa_type) {
865	case RSA_FLAG_TYPE_RSA:
866	ok = EVP_PKEY_assign_RSA(pkey, rsa);
867	break;
868	case RSA_FLAG_TYPE_RSASSAPSS:
869	ok = EVP_PKEY_assign(pkey, EVP_PKEY_RSA_PSS, rsa);
870	break;
871	}
872
873	err:
874	if (!ok)
875	RSA_free(rsa);
876	return ok;
877	}
878
879	static int rsa_pkey_export_to(const EVP_PKEY from, void to_keydata,
880	OSSL_FUNC_keymgmt_import_fn *importer,
881	OSSL_LIB_CTX libctx, const char propq)
882	{
883	return rsa_int_export_to(from, RSA_FLAG_TYPE_RSA, to_keydata,
884	importer, libctx, propq);
885	}
886
887	static int rsa_pss_pkey_export_to(const EVP_PKEY from, void to_keydata,
888	OSSL_FUNC_keymgmt_import_fn *importer,
889	OSSL_LIB_CTX libctx, const char propq)
890	{
891	return rsa_int_export_to(from, RSA_FLAG_TYPE_RSASSAPSS, to_keydata,
892	importer, libctx, propq);
893	}
894
895	static int rsa_pkey_import_from(const OSSL_PARAM params[], void *vpctx)
896	{
897	return rsa_int_import_from(params, vpctx, RSA_FLAG_TYPE_RSA);
898	}
899
900	static int rsa_pss_pkey_import_from(const OSSL_PARAM params[], void *vpctx)
901	{
902	return rsa_int_import_from(params, vpctx, RSA_FLAG_TYPE_RSASSAPSS);
903	}
904
905	static int rsa_pkey_copy(EVP_PKEY to, EVP_PKEY from)
906	{
907	RSA *rsa = from->pkey.rsa;
908	RSA *dupkey = NULL;
909	int ret;
910
911	if (rsa != NULL) {
912	dupkey = ossl_rsa_dup(rsa, OSSL_KEYMGMT_SELECT_ALL);
913	if (dupkey == NULL)
914	return 0;
915	}
916
917	ret = EVP_PKEY_assign(to, from->type, dupkey);
918	if (!ret)
919	RSA_free(dupkey);
920	return ret;
921	}
922
923	const EVP_PKEY_ASN1_METHOD ossl_rsa_asn1_meths[2] = {
924	{
925	EVP_PKEY_RSA,
926	EVP_PKEY_RSA,
927	ASN1_PKEY_SIGPARAM_NULL,
928
929	"RSA",
930	"OpenSSL RSA method",
931
932	rsa_pub_decode,
933	rsa_pub_encode,
934	rsa_pub_cmp,
935	rsa_pub_print,
936
937	rsa_priv_decode,
938	rsa_priv_encode,
939	rsa_priv_print,
940
941	int_rsa_size,
942	rsa_bits,
943	rsa_security_bits,
944
945	0, 0, 0, 0, 0, 0,
946
947	rsa_sig_print,
948	int_rsa_free,
949	rsa_pkey_ctrl,
950	old_rsa_priv_decode,
951	old_rsa_priv_encode,
952	rsa_item_verify,
953	rsa_item_sign,
954	rsa_sig_info_set,
955	rsa_pkey_check,
956
957	0, 0,
958	0, 0, 0, 0,
959
960	rsa_pkey_dirty_cnt,
961	rsa_pkey_export_to,
962	rsa_pkey_import_from,
963	rsa_pkey_copy
964	},
965
966	{
967	EVP_PKEY_RSA2,
968	EVP_PKEY_RSA,
969	ASN1_PKEY_ALIAS}
970	};
971
972	const EVP_PKEY_ASN1_METHOD ossl_rsa_pss_asn1_meth = {
973	EVP_PKEY_RSA_PSS,
974	EVP_PKEY_RSA_PSS,
975	ASN1_PKEY_SIGPARAM_NULL,
976
977	"RSA-PSS",
978	"OpenSSL RSA-PSS method",
979
980	rsa_pub_decode,
981	rsa_pub_encode,
982	rsa_pub_cmp,
983	rsa_pub_print,
984
985	rsa_priv_decode,
986	rsa_priv_encode,
987	rsa_priv_print,
988
989	int_rsa_size,
990	rsa_bits,
991	rsa_security_bits,
992
993	0, 0, 0, 0, 0, 0,
994
995	rsa_sig_print,
996	int_rsa_free,
997	rsa_pkey_ctrl,
998	0, 0,
999	rsa_item_verify,
1000	rsa_item_sign,
1001	rsa_sig_info_set,
1002	rsa_pkey_check,
1003
1004	0, 0,
1005	0, 0, 0, 0,
1006
1007	rsa_pkey_dirty_cnt,
1008	rsa_pss_pkey_export_to,
1009	rsa_pss_pkey_import_from,
1010	rsa_pkey_copy
1011	};

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

source: vbox/trunk/src/libs/openssl-3.1.0/crypto/rsa/rsa_ameth.c@ 99507

以其他格式下載: