rsa_ameth.c

Last change on this file was 109052, checked in by vboxsync, 4 weeks ago
openssl-3.4.1: Applied our changes, regenerated files, added missing files and functions. This time with a three way merge. bugref:10890
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 29.5 KB

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

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/libs/openssl-3.4.1/crypto/rsa/rsa_ameth.c

Download in other formats: