cms_sd.c@ 101665

Last change on this file since 101665 was 101211, checked in by vboxsync, 14 months ago
openssl-3.1.3: Applied and adjusted our OpenSSL changes to 3.1.2. bugref:10527
File size: 32.9 KB

Line
1	/*
2	* Copyright 2008-2023 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	#include "internal/cryptlib.h"
11	#include <openssl/asn1t.h>
12	#include <openssl/pem.h>
13	#include <openssl/x509.h>
14	#include <openssl/x509v3.h>
15	#include <openssl/err.h>
16	#include <openssl/cms.h>
17	#include <openssl/ess.h>
18	#include "internal/sizes.h"
19	#include "crypto/asn1.h"
20	#include "crypto/evp.h"
21	#include "crypto/ess.h"
22	#include "crypto/x509.h" /* for ossl_x509_add_cert_new() */
23	#include "cms_local.h"
24
25	/* CMS SignedData Utilities */
26
27	static CMS_SignedData cms_get0_signed(CMS_ContentInfo cms)
28	{
29	if (OBJ_obj2nid(cms->contentType) != NID_pkcs7_signed) {
30	ERR_raise(ERR_LIB_CMS, CMS_R_CONTENT_TYPE_NOT_SIGNED_DATA);
31	return NULL;
32	}
33	return cms->d.signedData;
34	}
35
36	static CMS_SignedData cms_signed_data_init(CMS_ContentInfo cms)
37	{
38	if (cms->d.other == NULL) {
39	cms->d.signedData = M_ASN1_new_of(CMS_SignedData);
40	if (!cms->d.signedData) {
41	ERR_raise(ERR_LIB_CMS, ERR_R_MALLOC_FAILURE);
42	return NULL;
43	}
44	cms->d.signedData->version = 1;
45	cms->d.signedData->encapContentInfo->eContentType =
46	OBJ_nid2obj(NID_pkcs7_data);
47	cms->d.signedData->encapContentInfo->partial = 1;
48	ASN1_OBJECT_free(cms->contentType);
49	cms->contentType = OBJ_nid2obj(NID_pkcs7_signed);
50	return cms->d.signedData;
51	}
52	return cms_get0_signed(cms);
53	}
54
55	/* Just initialise SignedData e.g. for certs only structure */
56
57	int CMS_SignedData_init(CMS_ContentInfo *cms)
58	{
59	if (cms_signed_data_init(cms))
60	return 1;
61	else
62	return 0;
63	}
64
65
66	/* Check structures and fixup version numbers (if necessary) */
67
68	static void cms_sd_set_version(CMS_SignedData *sd)
69	{
70	int i;
71	CMS_CertificateChoices *cch;
72	CMS_RevocationInfoChoice *rch;
73	CMS_SignerInfo *si;
74
75	for (i = 0; i < sk_CMS_CertificateChoices_num(sd->certificates); i++) {
76	cch = sk_CMS_CertificateChoices_value(sd->certificates, i);
77	if (cch->type == CMS_CERTCHOICE_OTHER) {
78	if (sd->version < 5)
79	sd->version = 5;
80	} else if (cch->type == CMS_CERTCHOICE_V2ACERT) {
81	if (sd->version < 4)
82	sd->version = 4;
83	} else if (cch->type == CMS_CERTCHOICE_V1ACERT) {
84	if (sd->version < 3)
85	sd->version = 3;
86	}
87	}
88
89	for (i = 0; i < sk_CMS_RevocationInfoChoice_num(sd->crls); i++) {
90	rch = sk_CMS_RevocationInfoChoice_value(sd->crls, i);
91	if (rch->type == CMS_REVCHOICE_OTHER) {
92	if (sd->version < 5)
93	sd->version = 5;
94	}
95	}
96
97	if ((OBJ_obj2nid(sd->encapContentInfo->eContentType) != NID_pkcs7_data)
98	&& (sd->version < 3))
99	sd->version = 3;
100
101	for (i = 0; i < sk_CMS_SignerInfo_num(sd->signerInfos); i++) {
102	si = sk_CMS_SignerInfo_value(sd->signerInfos, i);
103	if (si->sid->type == CMS_SIGNERINFO_KEYIDENTIFIER) {
104	if (si->version < 3)
105	si->version = 3;
106	if (sd->version < 3)
107	sd->version = 3;
108	} else if (si->version < 1)
109	si->version = 1;
110	}
111
112	if (sd->version < 1)
113	sd->version = 1;
114
115	}
116
117	/*
118	* RFC 5652 Section 11.1 Content Type
119	* The content-type attribute within signed-data MUST
120	* 1) be present if there are signed attributes
121	* 2) match the content type in the signed-data,
122	* 3) be a signed attribute.
123	* 4) not have more than one copy of the attribute.
124	*
125	* Note that since the CMS_SignerInfo_sign() always adds the "signing time"
126	* attribute, the content type attribute MUST be added also.
127	* Assumptions: This assumes that the attribute does not already exist.
128	*/
129	static int cms_set_si_contentType_attr(CMS_ContentInfo cms, CMS_SignerInfo si)
130	{
131	ASN1_OBJECT *ctype = cms->d.signedData->encapContentInfo->eContentType;
132
133	/* Add the contentType attribute */
134	return CMS_signed_add1_attr_by_NID(si, NID_pkcs9_contentType,
135	V_ASN1_OBJECT, ctype, -1) > 0;
136	}
137
138	/* Copy an existing messageDigest value */
139
140	static int cms_copy_messageDigest(CMS_ContentInfo cms, CMS_SignerInfo si)
141	{
142	STACK_OF(CMS_SignerInfo) *sinfos;
143	CMS_SignerInfo *sitmp;
144	int i;
145
146	sinfos = CMS_get0_SignerInfos(cms);
147	for (i = 0; i < sk_CMS_SignerInfo_num(sinfos); i++) {
148	ASN1_OCTET_STRING *messageDigest;
149
150	sitmp = sk_CMS_SignerInfo_value(sinfos, i);
151	if (sitmp == si)
152	continue;
153	if (CMS_signed_get_attr_count(sitmp) < 0)
154	continue;
155	if (OBJ_cmp(si->digestAlgorithm->algorithm,
156	sitmp->digestAlgorithm->algorithm))
157	continue;
158	messageDigest = CMS_signed_get0_data_by_OBJ(sitmp,
159	OBJ_nid2obj
160	(NID_pkcs9_messageDigest),
161	-3, V_ASN1_OCTET_STRING);
162	if (!messageDigest) {
163	ERR_raise(ERR_LIB_CMS, CMS_R_ERROR_READING_MESSAGEDIGEST_ATTRIBUTE);
164	return 0;
165	}
166
167	if (CMS_signed_add1_attr_by_NID(si, NID_pkcs9_messageDigest,
168	V_ASN1_OCTET_STRING,
169	messageDigest, -1))
170	return 1;
171	else
172	return 0;
173	}
174	ERR_raise(ERR_LIB_CMS, CMS_R_NO_MATCHING_DIGEST);
175	return 0;
176	}
177
178	int ossl_cms_set1_SignerIdentifier(CMS_SignerIdentifier sid, X509 cert,
179	int type, const CMS_CTX *ctx)
180	{
181	switch (type) {
182	case CMS_SIGNERINFO_ISSUER_SERIAL:
183	if (!ossl_cms_set1_ias(&sid->d.issuerAndSerialNumber, cert))
184	return 0;
185	break;
186
187	case CMS_SIGNERINFO_KEYIDENTIFIER:
188	if (!ossl_cms_set1_keyid(&sid->d.subjectKeyIdentifier, cert))
189	return 0;
190	break;
191
192	default:
193	ERR_raise(ERR_LIB_CMS, CMS_R_UNKNOWN_ID);
194	return 0;
195	}
196
197	sid->type = type;
198
199	return 1;
200	}
201
202	int ossl_cms_SignerIdentifier_get0_signer_id(CMS_SignerIdentifier *sid,
203	ASN1_OCTET_STRING **keyid,
204	X509_NAME **issuer,
205	ASN1_INTEGER **sno)
206	{
207	if (sid->type == CMS_SIGNERINFO_ISSUER_SERIAL) {
208	if (issuer)
209	*issuer = sid->d.issuerAndSerialNumber->issuer;
210	if (sno)
211	*sno = sid->d.issuerAndSerialNumber->serialNumber;
212	} else if (sid->type == CMS_SIGNERINFO_KEYIDENTIFIER) {
213	if (keyid)
214	*keyid = sid->d.subjectKeyIdentifier;
215	} else
216	return 0;
217	return 1;
218	}
219
220	int ossl_cms_SignerIdentifier_cert_cmp(CMS_SignerIdentifier sid, X509 cert)
221	{
222	if (sid->type == CMS_SIGNERINFO_ISSUER_SERIAL)
223	return ossl_cms_ias_cert_cmp(sid->d.issuerAndSerialNumber, cert);
224	else if (sid->type == CMS_SIGNERINFO_KEYIDENTIFIER)
225	return ossl_cms_keyid_cert_cmp(sid->d.subjectKeyIdentifier, cert);
226	else
227	return -1;
228	}
229
230	/* Method to map any, incl. provider-implemented PKEY types to OIDs */
231	/* ECDSA and DSA and all provider-delivered signatures implementation is the same */
232	static int cms_generic_sign(CMS_SignerInfo *si, int verify)
233	{
234	if (!ossl_assert(verify == 0 \|\| verify == 1))
235	return -1;
236
237	if (!verify) {
238	int snid, hnid, pknid;
239	X509_ALGOR alg1, alg2;
240	EVP_PKEY *pkey = si->pkey;
241	pknid = EVP_PKEY_get_id(pkey);
242
243	CMS_SignerInfo_get0_algs(si, NULL, NULL, &alg1, &alg2);
244	if (alg1 == NULL \|\| alg1->algorithm == NULL)
245	return -1;
246	hnid = OBJ_obj2nid(alg1->algorithm);
247	if (hnid == NID_undef)
248	return -1;
249	if (pknid <= 0) { /* check whether a provider registered a NID */
250	const char *typename = EVP_PKEY_get0_type_name(pkey);
251	if (typename != NULL)
252	pknid = OBJ_txt2nid(typename);
253	}
254	if (!OBJ_find_sigid_by_algs(&snid, hnid, pknid))
255	return -1;
256	return X509_ALGOR_set0(alg2, OBJ_nid2obj(snid), V_ASN1_UNDEF, NULL);
257	}
258	return 1;
259	}
260
261	static int cms_sd_asn1_ctrl(CMS_SignerInfo *si, int cmd)
262	{
263	EVP_PKEY *pkey = si->pkey;
264	int i;
265
266	if (EVP_PKEY_is_a(pkey, "DSA") \|\| EVP_PKEY_is_a(pkey, "EC"))
267	return cms_generic_sign(si, cmd) > 0;
268	else if (EVP_PKEY_is_a(pkey, "RSA") \|\| EVP_PKEY_is_a(pkey, "RSA-PSS"))
269	return ossl_cms_rsa_sign(si, cmd) > 0;
270
271	/* Now give engines, providers, etc a chance to handle this */
272	if (pkey->ameth == NULL \|\| pkey->ameth->pkey_ctrl == NULL)
273	return cms_generic_sign(si, cmd) > 0;
274	i = pkey->ameth->pkey_ctrl(pkey, ASN1_PKEY_CTRL_CMS_SIGN, cmd, si);
275	if (i == -2) {
276	ERR_raise(ERR_LIB_CMS, CMS_R_NOT_SUPPORTED_FOR_THIS_KEY_TYPE);
277	return 0;
278	}
279	if (i <= 0) {
280	ERR_raise(ERR_LIB_CMS, CMS_R_CTRL_FAILURE);
281	return 0;
282	}
283	return 1;
284	}
285
286	/* Add SigningCertificate signed attribute to the signer info. */
287	static int ossl_cms_add1_signing_cert(CMS_SignerInfo *si,
288	const ESS_SIGNING_CERT *sc)
289	{
290	ASN1_STRING *seq = NULL;
291	unsigned char p, pp = NULL;
292	int ret, len = i2d_ESS_SIGNING_CERT(sc, NULL);
293
294	if (len <= 0 \|\| (pp = OPENSSL_malloc(len)) == NULL)
295	return 0;
296
297	p = pp;
298	i2d_ESS_SIGNING_CERT(sc, &p);
299	if (!(seq = ASN1_STRING_new()) \|\| !ASN1_STRING_set(seq, pp, len)) {
300	ASN1_STRING_free(seq);
301	OPENSSL_free(pp);
302	return 0;
303	}
304	OPENSSL_free(pp);
305	ret = CMS_signed_add1_attr_by_NID(si, NID_id_smime_aa_signingCertificate,
306	V_ASN1_SEQUENCE, seq, -1);
307	ASN1_STRING_free(seq);
308	return ret;
309	}
310
311	/* Add SigningCertificateV2 signed attribute to the signer info. */
312	static int ossl_cms_add1_signing_cert_v2(CMS_SignerInfo *si,
313	const ESS_SIGNING_CERT_V2 *sc)
314	{
315	ASN1_STRING *seq = NULL;
316	unsigned char p, pp = NULL;
317	int ret, len = i2d_ESS_SIGNING_CERT_V2(sc, NULL);
318
319	if (len <= 0 \|\| (pp = OPENSSL_malloc(len)) == NULL)
320	return 0;
321
322	p = pp;
323	i2d_ESS_SIGNING_CERT_V2(sc, &p);
324	if (!(seq = ASN1_STRING_new()) \|\| !ASN1_STRING_set(seq, pp, len)) {
325	ASN1_STRING_free(seq);
326	OPENSSL_free(pp);
327	return 0;
328	}
329	OPENSSL_free(pp);
330	ret = CMS_signed_add1_attr_by_NID(si, NID_id_smime_aa_signingCertificateV2,
331	V_ASN1_SEQUENCE, seq, -1);
332	ASN1_STRING_free(seq);
333	return ret;
334	}
335
336	CMS_SignerInfo CMS_add1_signer(CMS_ContentInfo cms,
337	X509 signer, EVP_PKEY pk, const EVP_MD *md,
338	unsigned int flags)
339	{
340	CMS_SignedData *sd;
341	CMS_SignerInfo *si = NULL;
342	X509_ALGOR *alg;
343	int i, type;
344	const CMS_CTX *ctx = ossl_cms_get0_cmsctx(cms);
345
346	if (!X509_check_private_key(signer, pk)) {
347	ERR_raise(ERR_LIB_CMS, CMS_R_PRIVATE_KEY_DOES_NOT_MATCH_CERTIFICATE);
348	return NULL;
349	}
350	sd = cms_signed_data_init(cms);
351	if (!sd)
352	goto err;
353	si = M_ASN1_new_of(CMS_SignerInfo);
354	if (!si)
355	goto merr;
356	/* Call for side-effect of computing hash and caching extensions */
357	X509_check_purpose(signer, -1, -1);
358
359	X509_up_ref(signer);
360	EVP_PKEY_up_ref(pk);
361
362	si->cms_ctx = ctx;
363	si->pkey = pk;
364	si->signer = signer;
365	si->mctx = EVP_MD_CTX_new();
366	si->pctx = NULL;
367
368	if (si->mctx == NULL) {
369	ERR_raise(ERR_LIB_CMS, ERR_R_MALLOC_FAILURE);
370	goto err;
371	}
372
373	if (flags & CMS_USE_KEYID) {
374	si->version = 3;
375	if (sd->version < 3)
376	sd->version = 3;
377	type = CMS_SIGNERINFO_KEYIDENTIFIER;
378	} else {
379	type = CMS_SIGNERINFO_ISSUER_SERIAL;
380	si->version = 1;
381	}
382
383	if (!ossl_cms_set1_SignerIdentifier(si->sid, signer, type, ctx))
384	goto err;
385
386	if (md == NULL) {
387	int def_nid;
388	if (EVP_PKEY_get_default_digest_nid(pk, &def_nid) <= 0)
389	goto err;
390	md = EVP_get_digestbynid(def_nid);
391	if (md == NULL) {
392	ERR_raise(ERR_LIB_CMS, CMS_R_NO_DEFAULT_DIGEST);
393	goto err;
394	}
395	}
396
397	if (!md) {
398	ERR_raise(ERR_LIB_CMS, CMS_R_NO_DIGEST_SET);
399	goto err;
400	}
401
402	if (md == NULL) {
403	ERR_raise(ERR_LIB_CMS, CMS_R_NO_DIGEST_SET);
404	goto err;
405	}
406
407	X509_ALGOR_set_md(si->digestAlgorithm, md);
408
409	/* See if digest is present in digestAlgorithms */
410	for (i = 0; i < sk_X509_ALGOR_num(sd->digestAlgorithms); i++) {
411	const ASN1_OBJECT *aoid;
412	char name[OSSL_MAX_NAME_SIZE];
413
414	alg = sk_X509_ALGOR_value(sd->digestAlgorithms, i);
415	X509_ALGOR_get0(&aoid, NULL, NULL, alg);
416	OBJ_obj2txt(name, sizeof(name), aoid, 0);
417	if (EVP_MD_is_a(md, name))
418	break;
419	}
420
421	if (i == sk_X509_ALGOR_num(sd->digestAlgorithms)) {
422	alg = X509_ALGOR_new();
423	if (alg == NULL)
424	goto merr;
425	X509_ALGOR_set_md(alg, md);
426	if (!sk_X509_ALGOR_push(sd->digestAlgorithms, alg)) {
427	X509_ALGOR_free(alg);
428	goto merr;
429	}
430	}
431
432	if (!(flags & CMS_KEY_PARAM) && !cms_sd_asn1_ctrl(si, 0))
433	goto err;
434	if (!(flags & CMS_NOATTR)) {
435	/*
436	* Initialize signed attributes structure so other attributes
437	* such as signing time etc are added later even if we add none here.
438	*/
439	if (!si->signedAttrs) {
440	si->signedAttrs = sk_X509_ATTRIBUTE_new_null();
441	if (!si->signedAttrs)
442	goto merr;
443	}
444
445	if (!(flags & CMS_NOSMIMECAP)) {
446	STACK_OF(X509_ALGOR) *smcap = NULL;
447	i = CMS_add_standard_smimecap(&smcap);
448	if (i)
449	i = CMS_add_smimecap(si, smcap);
450	sk_X509_ALGOR_pop_free(smcap, X509_ALGOR_free);
451	if (!i)
452	goto merr;
453	}
454	if (flags & CMS_CADES) {
455	ESS_SIGNING_CERT *sc = NULL;
456	ESS_SIGNING_CERT_V2 *sc2 = NULL;
457	int add_sc;
458
459	if (md == NULL \|\| EVP_MD_is_a(md, SN_sha1)) {
460	if ((sc = OSSL_ESS_signing_cert_new_init(signer,
461	NULL, 1)) == NULL)
462	goto err;
463	add_sc = ossl_cms_add1_signing_cert(si, sc);
464	ESS_SIGNING_CERT_free(sc);
465	} else {
466	if ((sc2 = OSSL_ESS_signing_cert_v2_new_init(md, signer,
467	NULL, 1)) == NULL)
468	goto err;
469	add_sc = ossl_cms_add1_signing_cert_v2(si, sc2);
470	ESS_SIGNING_CERT_V2_free(sc2);
471	}
472	if (!add_sc)
473	goto err;
474	}
475	if (flags & CMS_REUSE_DIGEST) {
476	if (!cms_copy_messageDigest(cms, si))
477	goto err;
478	if (!cms_set_si_contentType_attr(cms, si))
479	goto err;
480	if (!(flags & (CMS_PARTIAL \| CMS_KEY_PARAM)) &&
481	!CMS_SignerInfo_sign(si))
482	goto err;
483	}
484	}
485
486	if (!(flags & CMS_NOCERTS)) {
487	/* NB ignore -1 return for duplicate cert */
488	if (!CMS_add1_cert(cms, signer))
489	goto merr;
490	}
491
492	if (flags & CMS_KEY_PARAM) {
493	if (flags & CMS_NOATTR) {
494	si->pctx = EVP_PKEY_CTX_new_from_pkey(ossl_cms_ctx_get0_libctx(ctx),
495	si->pkey,
496	ossl_cms_ctx_get0_propq(ctx));
497	if (si->pctx == NULL)
498	goto err;
499	if (EVP_PKEY_sign_init(si->pctx) <= 0)
500	goto err;
501	if (EVP_PKEY_CTX_set_signature_md(si->pctx, md) <= 0)
502	goto err;
503	} else if (EVP_DigestSignInit_ex(si->mctx, &si->pctx,
504	EVP_MD_get0_name(md),
505	ossl_cms_ctx_get0_libctx(ctx),
506	ossl_cms_ctx_get0_propq(ctx),
507	pk, NULL) <= 0) {
508	goto err;
509	}
510	}
511
512	if (!sd->signerInfos)
513	sd->signerInfos = sk_CMS_SignerInfo_new_null();
514	if (!sd->signerInfos \|\| !sk_CMS_SignerInfo_push(sd->signerInfos, si))
515	goto merr;
516
517	return si;
518
519	merr:
520	ERR_raise(ERR_LIB_CMS, ERR_R_MALLOC_FAILURE);
521	err:
522	M_ASN1_free_of(si, CMS_SignerInfo);
523	return NULL;
524
525	}
526
527	void ossl_cms_SignerInfos_set_cmsctx(CMS_ContentInfo *cms)
528	{
529	int i;
530	CMS_SignerInfo *si;
531	STACK_OF(CMS_SignerInfo) *sinfos;
532	const CMS_CTX *ctx = ossl_cms_get0_cmsctx(cms);
533
534	ERR_set_mark();
535	sinfos = CMS_get0_SignerInfos(cms);
536	ERR_pop_to_mark(); /* removes error in case sinfos == NULL */
537
538	for (i = 0; i < sk_CMS_SignerInfo_num(sinfos); i++) {
539	si = sk_CMS_SignerInfo_value(sinfos, i);
540	if (si != NULL)
541	si->cms_ctx = ctx;
542	}
543	}
544
545	static int cms_add1_signingTime(CMS_SignerInfo si, ASN1_TIME t)
546	{
547	ASN1_TIME *tt;
548	int r = 0;
549
550	if (t != NULL)
551	tt = t;
552	else
553	tt = X509_gmtime_adj(NULL, 0);
554
555	if (tt == NULL)
556	goto merr;
557
558	if (CMS_signed_add1_attr_by_NID(si, NID_pkcs9_signingTime,
559	tt->type, tt, -1) <= 0)
560	goto merr;
561
562	r = 1;
563	merr:
564	if (t == NULL)
565	ASN1_TIME_free(tt);
566
567	if (!r)
568	ERR_raise(ERR_LIB_CMS, ERR_R_MALLOC_FAILURE);
569
570	return r;
571
572	}
573
574	EVP_PKEY_CTX CMS_SignerInfo_get0_pkey_ctx(CMS_SignerInfo si)
575	{
576	return si->pctx;
577	}
578
579	EVP_MD_CTX CMS_SignerInfo_get0_md_ctx(CMS_SignerInfo si)
580	{
581	return si->mctx;
582	}
583
584	STACK_OF(CMS_SignerInfo) CMS_get0_SignerInfos(CMS_ContentInfo cms)
585	{
586	CMS_SignedData *sd = cms_get0_signed(cms);
587
588	return sd != NULL ? sd->signerInfos : NULL;
589	}
590
591	STACK_OF(X509) CMS_get0_signers(CMS_ContentInfo cms)
592	{
593	STACK_OF(X509) *signers = NULL;
594	STACK_OF(CMS_SignerInfo) *sinfos;
595	CMS_SignerInfo *si;
596	int i;
597
598	sinfos = CMS_get0_SignerInfos(cms);
599	for (i = 0; i < sk_CMS_SignerInfo_num(sinfos); i++) {
600	si = sk_CMS_SignerInfo_value(sinfos, i);
601	if (si->signer != NULL) {
602	if (!ossl_x509_add_cert_new(&signers, si->signer,
603	X509_ADD_FLAG_DEFAULT)) {
604	sk_X509_free(signers);
605	return NULL;
606	}
607	}
608	}
609	return signers;
610	}
611
612	void CMS_SignerInfo_set1_signer_cert(CMS_SignerInfo si, X509 signer)
613	{
614	if (signer != NULL) {
615	X509_up_ref(signer);
616	EVP_PKEY_free(si->pkey);
617	si->pkey = X509_get_pubkey(signer);
618	}
619	X509_free(si->signer);
620	si->signer = signer;
621	}
622
623	int CMS_SignerInfo_get0_signer_id(CMS_SignerInfo *si,
624	ASN1_OCTET_STRING **keyid,
625	X509_NAME issuer, ASN1_INTEGER sno)
626	{
627	return ossl_cms_SignerIdentifier_get0_signer_id(si->sid, keyid, issuer, sno);
628	}
629
630	int CMS_SignerInfo_cert_cmp(CMS_SignerInfo si, X509 cert)
631	{
632	return ossl_cms_SignerIdentifier_cert_cmp(si->sid, cert);
633	}
634
635	int CMS_set1_signers_certs(CMS_ContentInfo cms, STACK_OF(X509) scerts,
636	unsigned int flags)
637	{
638	CMS_SignedData *sd;
639	CMS_SignerInfo *si;
640	CMS_CertificateChoices *cch;
641	STACK_OF(CMS_CertificateChoices) *certs;
642	X509 *x;
643	int i, j;
644	int ret = 0;
645
646	sd = cms_get0_signed(cms);
647	if (sd == NULL)
648	return -1;
649	certs = sd->certificates;
650	for (i = 0; i < sk_CMS_SignerInfo_num(sd->signerInfos); i++) {
651	si = sk_CMS_SignerInfo_value(sd->signerInfos, i);
652	if (si->signer != NULL)
653	continue;
654
655	for (j = 0; j < sk_X509_num(scerts); j++) {
656	x = sk_X509_value(scerts, j);
657	if (CMS_SignerInfo_cert_cmp(si, x) == 0) {
658	CMS_SignerInfo_set1_signer_cert(si, x);
659	ret++;
660	break;
661	}
662	}
663
664	if (si->signer != NULL \|\| (flags & CMS_NOINTERN))
665	continue;
666
667	for (j = 0; j < sk_CMS_CertificateChoices_num(certs); j++) {
668	cch = sk_CMS_CertificateChoices_value(certs, j);
669	if (cch->type != 0)
670	continue;
671	x = cch->d.certificate;
672	if (CMS_SignerInfo_cert_cmp(si, x) == 0) {
673	CMS_SignerInfo_set1_signer_cert(si, x);
674	ret++;
675	break;
676	}
677	}
678	}
679	return ret;
680	}
681
682	void CMS_SignerInfo_get0_algs(CMS_SignerInfo si, EVP_PKEY *pk,
683	X509 signer, X509_ALGOR pdig,
684	X509_ALGOR **psig)
685	{
686	if (pk != NULL)
687	*pk = si->pkey;
688	if (signer != NULL)
689	*signer = si->signer;
690	if (pdig != NULL)
691	*pdig = si->digestAlgorithm;
692	if (psig != NULL)
693	*psig = si->signatureAlgorithm;
694	}
695
696	ASN1_OCTET_STRING CMS_SignerInfo_get0_signature(CMS_SignerInfo si)
697	{
698	return si->signature;
699	}
700
701	static int cms_SignerInfo_content_sign(CMS_ContentInfo *cms,
702	CMS_SignerInfo si, BIO chain)
703	{
704	EVP_MD_CTX *mctx = EVP_MD_CTX_new();
705	int r = 0;
706	EVP_PKEY_CTX *pctx = NULL;
707	const CMS_CTX *ctx = ossl_cms_get0_cmsctx(cms);
708
709	if (mctx == NULL) {
710	ERR_raise(ERR_LIB_CMS, ERR_R_MALLOC_FAILURE);
711	return 0;
712	}
713
714	if (si->pkey == NULL) {
715	ERR_raise(ERR_LIB_CMS, CMS_R_NO_PRIVATE_KEY);
716	goto err;
717	}
718
719	if (!ossl_cms_DigestAlgorithm_find_ctx(mctx, chain, si->digestAlgorithm))
720	goto err;
721	/* Set SignerInfo algorithm details if we used custom parameter */
722	if (si->pctx && !cms_sd_asn1_ctrl(si, 0))
723	goto err;
724
725	/*
726	* If any signed attributes calculate and add messageDigest attribute
727	*/
728
729	if (CMS_signed_get_attr_count(si) >= 0) {
730	unsigned char md[EVP_MAX_MD_SIZE];
731	unsigned int mdlen;
732
733	if (!EVP_DigestFinal_ex(mctx, md, &mdlen))
734	goto err;
735	if (!CMS_signed_add1_attr_by_NID(si, NID_pkcs9_messageDigest,
736	V_ASN1_OCTET_STRING, md, mdlen))
737	goto err;
738	/* Copy content type across */
739	if (!cms_set_si_contentType_attr(cms, si))
740	goto err;
741
742	if (!CMS_SignerInfo_sign(si))
743	goto err;
744	} else if (si->pctx) {
745	unsigned char *sig;
746	size_t siglen;
747	unsigned char md[EVP_MAX_MD_SIZE];
748	unsigned int mdlen;
749
750	pctx = si->pctx;
751	if (!EVP_DigestFinal_ex(mctx, md, &mdlen))
752	goto err;
753	siglen = EVP_PKEY_get_size(si->pkey);
754	sig = OPENSSL_malloc(siglen);
755	if (sig == NULL) {
756	ERR_raise(ERR_LIB_CMS, ERR_R_MALLOC_FAILURE);
757	goto err;
758	}
759	if (EVP_PKEY_sign(pctx, sig, &siglen, md, mdlen) <= 0) {
760	OPENSSL_free(sig);
761	goto err;
762	}
763	ASN1_STRING_set0(si->signature, sig, siglen);
764	} else {
765	unsigned char *sig;
766	unsigned int siglen;
767
768	sig = OPENSSL_malloc(EVP_PKEY_get_size(si->pkey));
769	if (sig == NULL) {
770	ERR_raise(ERR_LIB_CMS, ERR_R_MALLOC_FAILURE);
771	goto err;
772	}
773	if (!EVP_SignFinal_ex(mctx, sig, &siglen, si->pkey,
774	ossl_cms_ctx_get0_libctx(ctx),
775	ossl_cms_ctx_get0_propq(ctx))) {
776	ERR_raise(ERR_LIB_CMS, CMS_R_SIGNFINAL_ERROR);
777	OPENSSL_free(sig);
778	goto err;
779	}
780	ASN1_STRING_set0(si->signature, sig, siglen);
781	}
782
783	r = 1;
784
785	err:
786	EVP_MD_CTX_free(mctx);
787	EVP_PKEY_CTX_free(pctx);
788	return r;
789
790	}
791
792	int ossl_cms_SignedData_final(CMS_ContentInfo cms, BIO chain)
793	{
794	STACK_OF(CMS_SignerInfo) *sinfos;
795	CMS_SignerInfo *si;
796	int i;
797
798	sinfos = CMS_get0_SignerInfos(cms);
799	for (i = 0; i < sk_CMS_SignerInfo_num(sinfos); i++) {
800	si = sk_CMS_SignerInfo_value(sinfos, i);
801	if (!cms_SignerInfo_content_sign(cms, si, chain))
802	return 0;
803	}
804	cms->d.signedData->encapContentInfo->partial = 0;
805	return 1;
806	}
807
808	int CMS_SignerInfo_sign(CMS_SignerInfo *si)
809	{
810	EVP_MD_CTX *mctx = si->mctx;
811	EVP_PKEY_CTX *pctx = NULL;
812	unsigned char *abuf = NULL;
813	int alen;
814	size_t siglen;
815	const CMS_CTX *ctx = si->cms_ctx;
816	char md_name[OSSL_MAX_NAME_SIZE];
817
818	if (OBJ_obj2txt(md_name, sizeof(md_name),
819	si->digestAlgorithm->algorithm, 0) <= 0)
820	return 0;
821
822	if (CMS_signed_get_attr_by_NID(si, NID_pkcs9_signingTime, -1) < 0) {
823	if (!cms_add1_signingTime(si, NULL))
824	goto err;
825	}
826
827	if (!ossl_cms_si_check_attributes(si))
828	goto err;
829
830	if (si->pctx)
831	pctx = si->pctx;
832	else {
833	EVP_MD_CTX_reset(mctx);
834	if (EVP_DigestSignInit_ex(mctx, &pctx, md_name,
835	ossl_cms_ctx_get0_libctx(ctx),
836	ossl_cms_ctx_get0_propq(ctx), si->pkey,
837	NULL) <= 0)
838	goto err;
839	si->pctx = pctx;
840	}
841
842	alen = ASN1_item_i2d((ASN1_VALUE *)si->signedAttrs, &abuf,
843	ASN1_ITEM_rptr(CMS_Attributes_Sign));
844	if (!abuf)
845	goto err;
846	if (EVP_DigestSignUpdate(mctx, abuf, alen) <= 0)
847	goto err;
848	if (EVP_DigestSignFinal(mctx, NULL, &siglen) <= 0)
849	goto err;
850	OPENSSL_free(abuf);
851	abuf = OPENSSL_malloc(siglen);
852	if (abuf == NULL)
853	goto err;
854	if (EVP_DigestSignFinal(mctx, abuf, &siglen) <= 0)
855	goto err;
856
857	EVP_MD_CTX_reset(mctx);
858
859	ASN1_STRING_set0(si->signature, abuf, siglen);
860
861	return 1;
862
863	err:
864	OPENSSL_free(abuf);
865	EVP_MD_CTX_reset(mctx);
866	return 0;
867	}
868
869	int CMS_SignerInfo_verify(CMS_SignerInfo *si)
870	{
871	EVP_MD_CTX *mctx = NULL;
872	unsigned char *abuf = NULL;
873	int alen, r = -1;
874	char name[OSSL_MAX_NAME_SIZE];
875	const EVP_MD *md;
876	EVP_MD *fetched_md = NULL;
877	const CMS_CTX *ctx = si->cms_ctx;
878	OSSL_LIB_CTX *libctx = ossl_cms_ctx_get0_libctx(ctx);
879	const char *propq = ossl_cms_ctx_get0_propq(ctx);
880
881	if (si->pkey == NULL) {
882	ERR_raise(ERR_LIB_CMS, CMS_R_NO_PUBLIC_KEY);
883	return -1;
884	}
885
886	if (!ossl_cms_si_check_attributes(si))
887	return -1;
888
889	OBJ_obj2txt(name, sizeof(name), si->digestAlgorithm->algorithm, 0);
890
891	(void)ERR_set_mark();
892	fetched_md = EVP_MD_fetch(libctx, name, propq);
893
894	if (fetched_md != NULL)
895	md = fetched_md;
896	else
897	md = EVP_get_digestbyobj(si->digestAlgorithm->algorithm);
898	if (md == NULL) {
899	(void)ERR_clear_last_mark();
900	ERR_raise(ERR_LIB_CMS, CMS_R_UNKNOWN_DIGEST_ALGORITHM);
901	return -1;
902	}
903	(void)ERR_pop_to_mark();
904
905	if (si->mctx == NULL && (si->mctx = EVP_MD_CTX_new()) == NULL) {
906	ERR_raise(ERR_LIB_CMS, ERR_R_MALLOC_FAILURE);
907	goto err;
908	}
909	mctx = si->mctx;
910	if (EVP_DigestVerifyInit_ex(mctx, &si->pctx, EVP_MD_get0_name(md), libctx,
911	propq, si->pkey, NULL) <= 0)
912	goto err;
913
914	if (!cms_sd_asn1_ctrl(si, 1))
915	goto err;
916
917	alen = ASN1_item_i2d((ASN1_VALUE *)si->signedAttrs, &abuf,
918	ASN1_ITEM_rptr(CMS_Attributes_Verify));
919	if (abuf == NULL \|\| alen < 0)
920	goto err;
921	r = EVP_DigestVerifyUpdate(mctx, abuf, alen);
922	OPENSSL_free(abuf);
923	if (r <= 0) {
924	r = -1;
925	goto err;
926	}
927	r = EVP_DigestVerifyFinal(mctx,
928	si->signature->data, si->signature->length);
929	if (r <= 0)
930	ERR_raise(ERR_LIB_CMS, CMS_R_VERIFICATION_FAILURE);
931	err:
932	EVP_MD_free(fetched_md);
933	EVP_MD_CTX_reset(mctx);
934	return r;
935	}
936
937	/* Create a chain of digest BIOs from a CMS ContentInfo */
938
939	BIO ossl_cms_SignedData_init_bio(CMS_ContentInfo cms)
940	{
941	int i;
942	CMS_SignedData *sd;
943	BIO *chain = NULL;
944
945	sd = cms_get0_signed(cms);
946	if (sd == NULL)
947	return NULL;
948	if (cms->d.signedData->encapContentInfo->partial)
949	cms_sd_set_version(sd);
950	for (i = 0; i < sk_X509_ALGOR_num(sd->digestAlgorithms); i++) {
951	X509_ALGOR *digestAlgorithm;
952	BIO *mdbio;
953
954	digestAlgorithm = sk_X509_ALGOR_value(sd->digestAlgorithms, i);
955	mdbio = ossl_cms_DigestAlgorithm_init_bio(digestAlgorithm,
956	ossl_cms_get0_cmsctx(cms));
957	if (mdbio == NULL)
958	goto err;
959	if (chain != NULL)
960	BIO_push(chain, mdbio);
961	else
962	chain = mdbio;
963	}
964	return chain;
965	err:
966	BIO_free_all(chain);
967	return NULL;
968	}
969
970	int CMS_SignerInfo_verify_content(CMS_SignerInfo si, BIO chain)
971	{
972	ASN1_OCTET_STRING *os = NULL;
973	EVP_MD_CTX *mctx = EVP_MD_CTX_new();
974	EVP_PKEY_CTX *pkctx = NULL;
975	int r = -1;
976	unsigned char mval[EVP_MAX_MD_SIZE];
977	unsigned int mlen;
978
979	if (mctx == NULL) {
980	ERR_raise(ERR_LIB_CMS, ERR_R_MALLOC_FAILURE);
981	goto err;
982	}
983	/* If we have any signed attributes look for messageDigest value */
984	if (CMS_signed_get_attr_count(si) >= 0) {
985	os = CMS_signed_get0_data_by_OBJ(si,
986	OBJ_nid2obj(NID_pkcs9_messageDigest),
987	-3, V_ASN1_OCTET_STRING);
988	if (os == NULL) {
989	ERR_raise(ERR_LIB_CMS, CMS_R_ERROR_READING_MESSAGEDIGEST_ATTRIBUTE);
990	goto err;
991	}
992	}
993
994	if (!ossl_cms_DigestAlgorithm_find_ctx(mctx, chain, si->digestAlgorithm))
995	goto err;
996
997	if (EVP_DigestFinal_ex(mctx, mval, &mlen) <= 0) {
998	ERR_raise(ERR_LIB_CMS, CMS_R_UNABLE_TO_FINALIZE_CONTEXT);
999	goto err;
1000	}
1001
1002	/* If messageDigest found compare it */
1003
1004	if (os != NULL) {
1005	if (mlen != (unsigned int)os->length) {
1006	ERR_raise(ERR_LIB_CMS, CMS_R_MESSAGEDIGEST_ATTRIBUTE_WRONG_LENGTH);
1007	goto err;
1008	}
1009
1010	if (memcmp(mval, os->data, mlen)) {
1011	ERR_raise(ERR_LIB_CMS, CMS_R_VERIFICATION_FAILURE);
1012	r = 0;
1013	} else
1014	r = 1;
1015	} else {
1016	const EVP_MD *md = EVP_MD_CTX_get0_md(mctx);
1017	const CMS_CTX *ctx = si->cms_ctx;
1018
1019	pkctx = EVP_PKEY_CTX_new_from_pkey(ossl_cms_ctx_get0_libctx(ctx),
1020	si->pkey,
1021	ossl_cms_ctx_get0_propq(ctx));
1022	if (pkctx == NULL)
1023	goto err;
1024	if (EVP_PKEY_verify_init(pkctx) <= 0)
1025	goto err;
1026	if (EVP_PKEY_CTX_set_signature_md(pkctx, md) <= 0)
1027	goto err;
1028	si->pctx = pkctx;
1029	if (!cms_sd_asn1_ctrl(si, 1))
1030	goto err;
1031	r = EVP_PKEY_verify(pkctx, si->signature->data,
1032	si->signature->length, mval, mlen);
1033	if (r <= 0) {
1034	ERR_raise(ERR_LIB_CMS, CMS_R_VERIFICATION_FAILURE);
1035	r = 0;
1036	}
1037	}
1038
1039	err:
1040	EVP_PKEY_CTX_free(pkctx);
1041	EVP_MD_CTX_free(mctx);
1042	return r;
1043
1044	}
1045
1046	int CMS_add_smimecap(CMS_SignerInfo si, STACK_OF(X509_ALGOR) algs)
1047	{
1048	unsigned char *smder = NULL;
1049	int smderlen, r;
1050
1051	smderlen = i2d_X509_ALGORS(algs, &smder);
1052	if (smderlen <= 0)
1053	return 0;
1054	r = CMS_signed_add1_attr_by_NID(si, NID_SMIMECapabilities,
1055	V_ASN1_SEQUENCE, smder, smderlen);
1056	OPENSSL_free(smder);
1057	return r;
1058	}
1059
1060	int CMS_add_simple_smimecap(STACK_OF(X509_ALGOR) **algs,
1061	int algnid, int keysize)
1062	{
1063	X509_ALGOR *alg;
1064	ASN1_INTEGER *key = NULL;
1065
1066	if (keysize > 0) {
1067	key = ASN1_INTEGER_new();
1068	if (key == NULL \|\| !ASN1_INTEGER_set(key, keysize)) {
1069	ASN1_INTEGER_free(key);
1070	return 0;
1071	}
1072	}
1073	alg = X509_ALGOR_new();
1074	if (alg == NULL) {
1075	ASN1_INTEGER_free(key);
1076	return 0;
1077	}
1078
1079	X509_ALGOR_set0(alg, OBJ_nid2obj(algnid),
1080	key ? V_ASN1_INTEGER : V_ASN1_UNDEF, key);
1081	if (*algs == NULL)
1082	*algs = sk_X509_ALGOR_new_null();
1083	if (algs == NULL \|\| !sk_X509_ALGOR_push(algs, alg)) {
1084	X509_ALGOR_free(alg);
1085	return 0;
1086	}
1087	return 1;
1088	}
1089
1090	/* Check to see if a cipher exists and if so add S/MIME capabilities */
1091
1092	static int cms_add_cipher_smcap(STACK_OF(X509_ALGOR) **sk, int nid, int arg)
1093	{
1094	if (EVP_get_cipherbynid(nid))
1095	return CMS_add_simple_smimecap(sk, nid, arg);
1096	return 1;
1097	}
1098
1099	static int cms_add_digest_smcap(STACK_OF(X509_ALGOR) **sk, int nid, int arg)
1100	{
1101	if (EVP_get_digestbynid(nid))
1102	return CMS_add_simple_smimecap(sk, nid, arg);
1103	return 1;
1104	}
1105
1106	int CMS_add_standard_smimecap(STACK_OF(X509_ALGOR) **smcap)
1107	{
1108	if (!cms_add_cipher_smcap(smcap, NID_aes_256_cbc, -1)
1109	\|\| !cms_add_digest_smcap(smcap, NID_id_GostR3411_2012_256, -1)
1110	\|\| !cms_add_digest_smcap(smcap, NID_id_GostR3411_2012_512, -1)
1111	\|\| !cms_add_digest_smcap(smcap, NID_id_GostR3411_94, -1)
1112	\|\| !cms_add_cipher_smcap(smcap, NID_id_Gost28147_89, -1)
1113	\|\| !cms_add_cipher_smcap(smcap, NID_aes_192_cbc, -1)
1114	\|\| !cms_add_cipher_smcap(smcap, NID_aes_128_cbc, -1)
1115	\|\| !cms_add_cipher_smcap(smcap, NID_des_ede3_cbc, -1)
1116	\|\| !cms_add_cipher_smcap(smcap, NID_rc2_cbc, 128)
1117	\|\| !cms_add_cipher_smcap(smcap, NID_rc2_cbc, 64)
1118	\|\| !cms_add_cipher_smcap(smcap, NID_des_cbc, -1)
1119	\|\| !cms_add_cipher_smcap(smcap, NID_rc2_cbc, 40))
1120	return 0;
1121	return 1;
1122	}

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

source: vbox/trunk/src/libs/openssl-3.1.3/crypto/cms/cms_sd.c@ 101665

Download in other formats: