cms_sd.c@ 107835

Last change on this file since 107835 was 104078, checked in by vboxsync, 11 months ago
openssl-3.1.5: Applied and adjusted our OpenSSL changes to 3.1.4. bugref:10638
File size: 33.2 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
389	if (EVP_PKEY_get_default_digest_nid(pk, &def_nid) <= 0) {
390	ERR_raise_data(ERR_LIB_CMS, CMS_R_NO_DEFAULT_DIGEST,
391	"pkey nid=%d", EVP_PKEY_get_id(pk));
392	goto err;
393	}
394	md = EVP_get_digestbynid(def_nid);
395	if (md == NULL) {
396	ERR_raise_data(ERR_LIB_CMS, CMS_R_NO_DEFAULT_DIGEST,
397	"default md nid=%d", def_nid);
398	goto err;
399	}
400	}
401
402	if (!md) {
403	ERR_raise(ERR_LIB_CMS, CMS_R_NO_DIGEST_SET);
404	goto err;
405	}
406
407	if (md == NULL) {
408	ERR_raise(ERR_LIB_CMS, CMS_R_NO_DIGEST_SET);
409	goto err;
410	}
411
412	X509_ALGOR_set_md(si->digestAlgorithm, md);
413
414	/* See if digest is present in digestAlgorithms */
415	for (i = 0; i < sk_X509_ALGOR_num(sd->digestAlgorithms); i++) {
416	const ASN1_OBJECT *aoid;
417	char name[OSSL_MAX_NAME_SIZE];
418
419	alg = sk_X509_ALGOR_value(sd->digestAlgorithms, i);
420	X509_ALGOR_get0(&aoid, NULL, NULL, alg);
421	OBJ_obj2txt(name, sizeof(name), aoid, 0);
422	if (EVP_MD_is_a(md, name))
423	break;
424	}
425
426	if (i == sk_X509_ALGOR_num(sd->digestAlgorithms)) {
427	alg = X509_ALGOR_new();
428	if (alg == NULL)
429	goto merr;
430	X509_ALGOR_set_md(alg, md);
431	if (!sk_X509_ALGOR_push(sd->digestAlgorithms, alg)) {
432	X509_ALGOR_free(alg);
433	goto merr;
434	}
435	}
436
437	if (!(flags & CMS_KEY_PARAM) && !cms_sd_asn1_ctrl(si, 0)) {
438	ERR_raise_data(ERR_LIB_CMS, CMS_R_UNSUPPORTED_SIGNATURE_ALGORITHM,
439	"pkey nid=%d", EVP_PKEY_get_id(pk));
440	goto err;
441	}
442	if (!(flags & CMS_NOATTR)) {
443	/*
444	* Initialize signed attributes structure so other attributes
445	* such as signing time etc are added later even if we add none here.
446	*/
447	if (!si->signedAttrs) {
448	si->signedAttrs = sk_X509_ATTRIBUTE_new_null();
449	if (!si->signedAttrs)
450	goto merr;
451	}
452
453	if (!(flags & CMS_NOSMIMECAP)) {
454	STACK_OF(X509_ALGOR) *smcap = NULL;
455	i = CMS_add_standard_smimecap(&smcap);
456	if (i)
457	i = CMS_add_smimecap(si, smcap);
458	sk_X509_ALGOR_pop_free(smcap, X509_ALGOR_free);
459	if (!i)
460	goto merr;
461	}
462	if (flags & CMS_CADES) {
463	ESS_SIGNING_CERT *sc = NULL;
464	ESS_SIGNING_CERT_V2 *sc2 = NULL;
465	int add_sc;
466
467	if (md == NULL \|\| EVP_MD_is_a(md, SN_sha1)) {
468	if ((sc = OSSL_ESS_signing_cert_new_init(signer,
469	NULL, 1)) == NULL)
470	goto err;
471	add_sc = ossl_cms_add1_signing_cert(si, sc);
472	ESS_SIGNING_CERT_free(sc);
473	} else {
474	if ((sc2 = OSSL_ESS_signing_cert_v2_new_init(md, signer,
475	NULL, 1)) == NULL)
476	goto err;
477	add_sc = ossl_cms_add1_signing_cert_v2(si, sc2);
478	ESS_SIGNING_CERT_V2_free(sc2);
479	}
480	if (!add_sc)
481	goto err;
482	}
483	if (flags & CMS_REUSE_DIGEST) {
484	if (!cms_copy_messageDigest(cms, si))
485	goto err;
486	if (!cms_set_si_contentType_attr(cms, si))
487	goto err;
488	if (!(flags & (CMS_PARTIAL \| CMS_KEY_PARAM)) &&
489	!CMS_SignerInfo_sign(si))
490	goto err;
491	}
492	}
493
494	if (!(flags & CMS_NOCERTS)) {
495	/* NB ignore -1 return for duplicate cert */
496	if (!CMS_add1_cert(cms, signer))
497	goto merr;
498	}
499
500	if (flags & CMS_KEY_PARAM) {
501	if (flags & CMS_NOATTR) {
502	si->pctx = EVP_PKEY_CTX_new_from_pkey(ossl_cms_ctx_get0_libctx(ctx),
503	si->pkey,
504	ossl_cms_ctx_get0_propq(ctx));
505	if (si->pctx == NULL)
506	goto err;
507	if (EVP_PKEY_sign_init(si->pctx) <= 0)
508	goto err;
509	if (EVP_PKEY_CTX_set_signature_md(si->pctx, md) <= 0)
510	goto err;
511	} else if (EVP_DigestSignInit_ex(si->mctx, &si->pctx,
512	EVP_MD_get0_name(md),
513	ossl_cms_ctx_get0_libctx(ctx),
514	ossl_cms_ctx_get0_propq(ctx),
515	pk, NULL) <= 0) {
516	goto err;
517	}
518	}
519
520	if (!sd->signerInfos)
521	sd->signerInfos = sk_CMS_SignerInfo_new_null();
522	if (!sd->signerInfos \|\| !sk_CMS_SignerInfo_push(sd->signerInfos, si))
523	goto merr;
524
525	return si;
526
527	merr:
528	ERR_raise(ERR_LIB_CMS, ERR_R_MALLOC_FAILURE);
529	err:
530	M_ASN1_free_of(si, CMS_SignerInfo);
531	return NULL;
532
533	}
534
535	void ossl_cms_SignerInfos_set_cmsctx(CMS_ContentInfo *cms)
536	{
537	int i;
538	CMS_SignerInfo *si;
539	STACK_OF(CMS_SignerInfo) *sinfos;
540	const CMS_CTX *ctx = ossl_cms_get0_cmsctx(cms);
541
542	ERR_set_mark();
543	sinfos = CMS_get0_SignerInfos(cms);
544	ERR_pop_to_mark(); /* removes error in case sinfos == NULL */
545
546	for (i = 0; i < sk_CMS_SignerInfo_num(sinfos); i++) {
547	si = sk_CMS_SignerInfo_value(sinfos, i);
548	if (si != NULL)
549	si->cms_ctx = ctx;
550	}
551	}
552
553	static int cms_add1_signingTime(CMS_SignerInfo si, ASN1_TIME t)
554	{
555	ASN1_TIME *tt;
556	int r = 0;
557
558	if (t != NULL)
559	tt = t;
560	else
561	tt = X509_gmtime_adj(NULL, 0);
562
563	if (tt == NULL)
564	goto merr;
565
566	if (CMS_signed_add1_attr_by_NID(si, NID_pkcs9_signingTime,
567	tt->type, tt, -1) <= 0)
568	goto merr;
569
570	r = 1;
571	merr:
572	if (t == NULL)
573	ASN1_TIME_free(tt);
574
575	if (!r)
576	ERR_raise(ERR_LIB_CMS, ERR_R_MALLOC_FAILURE);
577
578	return r;
579
580	}
581
582	EVP_PKEY_CTX CMS_SignerInfo_get0_pkey_ctx(CMS_SignerInfo si)
583	{
584	return si->pctx;
585	}
586
587	EVP_MD_CTX CMS_SignerInfo_get0_md_ctx(CMS_SignerInfo si)
588	{
589	return si->mctx;
590	}
591
592	STACK_OF(CMS_SignerInfo) CMS_get0_SignerInfos(CMS_ContentInfo cms)
593	{
594	CMS_SignedData *sd = cms_get0_signed(cms);
595
596	return sd != NULL ? sd->signerInfos : NULL;
597	}
598
599	STACK_OF(X509) CMS_get0_signers(CMS_ContentInfo cms)
600	{
601	STACK_OF(X509) *signers = NULL;
602	STACK_OF(CMS_SignerInfo) *sinfos;
603	CMS_SignerInfo *si;
604	int i;
605
606	sinfos = CMS_get0_SignerInfos(cms);
607	for (i = 0; i < sk_CMS_SignerInfo_num(sinfos); i++) {
608	si = sk_CMS_SignerInfo_value(sinfos, i);
609	if (si->signer != NULL) {
610	if (!ossl_x509_add_cert_new(&signers, si->signer,
611	X509_ADD_FLAG_DEFAULT)) {
612	sk_X509_free(signers);
613	return NULL;
614	}
615	}
616	}
617	return signers;
618	}
619
620	void CMS_SignerInfo_set1_signer_cert(CMS_SignerInfo si, X509 signer)
621	{
622	if (signer != NULL) {
623	X509_up_ref(signer);
624	EVP_PKEY_free(si->pkey);
625	si->pkey = X509_get_pubkey(signer);
626	}
627	X509_free(si->signer);
628	si->signer = signer;
629	}
630
631	int CMS_SignerInfo_get0_signer_id(CMS_SignerInfo *si,
632	ASN1_OCTET_STRING **keyid,
633	X509_NAME issuer, ASN1_INTEGER sno)
634	{
635	return ossl_cms_SignerIdentifier_get0_signer_id(si->sid, keyid, issuer, sno);
636	}
637
638	int CMS_SignerInfo_cert_cmp(CMS_SignerInfo si, X509 cert)
639	{
640	return ossl_cms_SignerIdentifier_cert_cmp(si->sid, cert);
641	}
642
643	int CMS_set1_signers_certs(CMS_ContentInfo cms, STACK_OF(X509) scerts,
644	unsigned int flags)
645	{
646	CMS_SignedData *sd;
647	CMS_SignerInfo *si;
648	CMS_CertificateChoices *cch;
649	STACK_OF(CMS_CertificateChoices) *certs;
650	X509 *x;
651	int i, j;
652	int ret = 0;
653
654	sd = cms_get0_signed(cms);
655	if (sd == NULL)
656	return -1;
657	certs = sd->certificates;
658	for (i = 0; i < sk_CMS_SignerInfo_num(sd->signerInfos); i++) {
659	si = sk_CMS_SignerInfo_value(sd->signerInfos, i);
660	if (si->signer != NULL)
661	continue;
662
663	for (j = 0; j < sk_X509_num(scerts); j++) {
664	x = sk_X509_value(scerts, j);
665	if (CMS_SignerInfo_cert_cmp(si, x) == 0) {
666	CMS_SignerInfo_set1_signer_cert(si, x);
667	ret++;
668	break;
669	}
670	}
671
672	if (si->signer != NULL \|\| (flags & CMS_NOINTERN))
673	continue;
674
675	for (j = 0; j < sk_CMS_CertificateChoices_num(certs); j++) {
676	cch = sk_CMS_CertificateChoices_value(certs, j);
677	if (cch->type != 0)
678	continue;
679	x = cch->d.certificate;
680	if (CMS_SignerInfo_cert_cmp(si, x) == 0) {
681	CMS_SignerInfo_set1_signer_cert(si, x);
682	ret++;
683	break;
684	}
685	}
686	}
687	return ret;
688	}
689
690	void CMS_SignerInfo_get0_algs(CMS_SignerInfo si, EVP_PKEY *pk,
691	X509 signer, X509_ALGOR pdig,
692	X509_ALGOR **psig)
693	{
694	if (pk != NULL)
695	*pk = si->pkey;
696	if (signer != NULL)
697	*signer = si->signer;
698	if (pdig != NULL)
699	*pdig = si->digestAlgorithm;
700	if (psig != NULL)
701	*psig = si->signatureAlgorithm;
702	}
703
704	ASN1_OCTET_STRING CMS_SignerInfo_get0_signature(CMS_SignerInfo si)
705	{
706	return si->signature;
707	}
708
709	static int cms_SignerInfo_content_sign(CMS_ContentInfo *cms,
710	CMS_SignerInfo si, BIO chain)
711	{
712	EVP_MD_CTX *mctx = EVP_MD_CTX_new();
713	int r = 0;
714	EVP_PKEY_CTX *pctx = NULL;
715	const CMS_CTX *ctx = ossl_cms_get0_cmsctx(cms);
716
717	if (mctx == NULL) {
718	ERR_raise(ERR_LIB_CMS, ERR_R_MALLOC_FAILURE);
719	return 0;
720	}
721
722	if (si->pkey == NULL) {
723	ERR_raise(ERR_LIB_CMS, CMS_R_NO_PRIVATE_KEY);
724	goto err;
725	}
726
727	if (!ossl_cms_DigestAlgorithm_find_ctx(mctx, chain, si->digestAlgorithm))
728	goto err;
729	/* Set SignerInfo algorithm details if we used custom parameter */
730	if (si->pctx && !cms_sd_asn1_ctrl(si, 0))
731	goto err;
732
733	/*
734	* If any signed attributes calculate and add messageDigest attribute
735	*/
736
737	if (CMS_signed_get_attr_count(si) >= 0) {
738	unsigned char md[EVP_MAX_MD_SIZE];
739	unsigned int mdlen;
740
741	if (!EVP_DigestFinal_ex(mctx, md, &mdlen))
742	goto err;
743	if (!CMS_signed_add1_attr_by_NID(si, NID_pkcs9_messageDigest,
744	V_ASN1_OCTET_STRING, md, mdlen))
745	goto err;
746	/* Copy content type across */
747	if (!cms_set_si_contentType_attr(cms, si))
748	goto err;
749
750	if (!CMS_SignerInfo_sign(si))
751	goto err;
752	} else if (si->pctx) {
753	unsigned char *sig;
754	size_t siglen;
755	unsigned char md[EVP_MAX_MD_SIZE];
756	unsigned int mdlen;
757
758	pctx = si->pctx;
759	if (!EVP_DigestFinal_ex(mctx, md, &mdlen))
760	goto err;
761	siglen = EVP_PKEY_get_size(si->pkey);
762	sig = OPENSSL_malloc(siglen);
763	if (sig == NULL) {
764	ERR_raise(ERR_LIB_CMS, ERR_R_MALLOC_FAILURE);
765	goto err;
766	}
767	if (EVP_PKEY_sign(pctx, sig, &siglen, md, mdlen) <= 0) {
768	OPENSSL_free(sig);
769	goto err;
770	}
771	ASN1_STRING_set0(si->signature, sig, siglen);
772	} else {
773	unsigned char *sig;
774	unsigned int siglen;
775
776	sig = OPENSSL_malloc(EVP_PKEY_get_size(si->pkey));
777	if (sig == NULL) {
778	ERR_raise(ERR_LIB_CMS, ERR_R_MALLOC_FAILURE);
779	goto err;
780	}
781	if (!EVP_SignFinal_ex(mctx, sig, &siglen, si->pkey,
782	ossl_cms_ctx_get0_libctx(ctx),
783	ossl_cms_ctx_get0_propq(ctx))) {
784	ERR_raise(ERR_LIB_CMS, CMS_R_SIGNFINAL_ERROR);
785	OPENSSL_free(sig);
786	goto err;
787	}
788	ASN1_STRING_set0(si->signature, sig, siglen);
789	}
790
791	r = 1;
792
793	err:
794	EVP_MD_CTX_free(mctx);
795	EVP_PKEY_CTX_free(pctx);
796	return r;
797
798	}
799
800	int ossl_cms_SignedData_final(CMS_ContentInfo cms, BIO chain)
801	{
802	STACK_OF(CMS_SignerInfo) *sinfos;
803	CMS_SignerInfo *si;
804	int i;
805
806	sinfos = CMS_get0_SignerInfos(cms);
807	for (i = 0; i < sk_CMS_SignerInfo_num(sinfos); i++) {
808	si = sk_CMS_SignerInfo_value(sinfos, i);
809	if (!cms_SignerInfo_content_sign(cms, si, chain))
810	return 0;
811	}
812	cms->d.signedData->encapContentInfo->partial = 0;
813	return 1;
814	}
815
816	int CMS_SignerInfo_sign(CMS_SignerInfo *si)
817	{
818	EVP_MD_CTX *mctx = si->mctx;
819	EVP_PKEY_CTX *pctx = NULL;
820	unsigned char *abuf = NULL;
821	int alen;
822	size_t siglen;
823	const CMS_CTX *ctx = si->cms_ctx;
824	char md_name[OSSL_MAX_NAME_SIZE];
825
826	if (OBJ_obj2txt(md_name, sizeof(md_name),
827	si->digestAlgorithm->algorithm, 0) <= 0)
828	return 0;
829
830	if (CMS_signed_get_attr_by_NID(si, NID_pkcs9_signingTime, -1) < 0) {
831	if (!cms_add1_signingTime(si, NULL))
832	goto err;
833	}
834
835	if (!ossl_cms_si_check_attributes(si))
836	goto err;
837
838	if (si->pctx)
839	pctx = si->pctx;
840	else {
841	EVP_MD_CTX_reset(mctx);
842	if (EVP_DigestSignInit_ex(mctx, &pctx, md_name,
843	ossl_cms_ctx_get0_libctx(ctx),
844	ossl_cms_ctx_get0_propq(ctx), si->pkey,
845	NULL) <= 0)
846	goto err;
847	si->pctx = pctx;
848	}
849
850	alen = ASN1_item_i2d((ASN1_VALUE *)si->signedAttrs, &abuf,
851	ASN1_ITEM_rptr(CMS_Attributes_Sign));
852	if (!abuf)
853	goto err;
854	if (EVP_DigestSignUpdate(mctx, abuf, alen) <= 0)
855	goto err;
856	if (EVP_DigestSignFinal(mctx, NULL, &siglen) <= 0)
857	goto err;
858	OPENSSL_free(abuf);
859	abuf = OPENSSL_malloc(siglen);
860	if (abuf == NULL)
861	goto err;
862	if (EVP_DigestSignFinal(mctx, abuf, &siglen) <= 0)
863	goto err;
864
865	EVP_MD_CTX_reset(mctx);
866
867	ASN1_STRING_set0(si->signature, abuf, siglen);
868
869	return 1;
870
871	err:
872	OPENSSL_free(abuf);
873	EVP_MD_CTX_reset(mctx);
874	return 0;
875	}
876
877	int CMS_SignerInfo_verify(CMS_SignerInfo *si)
878	{
879	EVP_MD_CTX *mctx = NULL;
880	unsigned char *abuf = NULL;
881	int alen, r = -1;
882	char name[OSSL_MAX_NAME_SIZE];
883	const EVP_MD *md;
884	EVP_MD *fetched_md = NULL;
885	const CMS_CTX *ctx = si->cms_ctx;
886	OSSL_LIB_CTX *libctx = ossl_cms_ctx_get0_libctx(ctx);
887	const char *propq = ossl_cms_ctx_get0_propq(ctx);
888
889	if (si->pkey == NULL) {
890	ERR_raise(ERR_LIB_CMS, CMS_R_NO_PUBLIC_KEY);
891	return -1;
892	}
893
894	if (!ossl_cms_si_check_attributes(si))
895	return -1;
896
897	OBJ_obj2txt(name, sizeof(name), si->digestAlgorithm->algorithm, 0);
898
899	(void)ERR_set_mark();
900	fetched_md = EVP_MD_fetch(libctx, name, propq);
901
902	if (fetched_md != NULL)
903	md = fetched_md;
904	else
905	md = EVP_get_digestbyobj(si->digestAlgorithm->algorithm);
906	if (md == NULL) {
907	(void)ERR_clear_last_mark();
908	ERR_raise(ERR_LIB_CMS, CMS_R_UNKNOWN_DIGEST_ALGORITHM);
909	return -1;
910	}
911	(void)ERR_pop_to_mark();
912
913	if (si->mctx == NULL && (si->mctx = EVP_MD_CTX_new()) == NULL) {
914	ERR_raise(ERR_LIB_CMS, ERR_R_MALLOC_FAILURE);
915	goto err;
916	}
917	mctx = si->mctx;
918	if (EVP_DigestVerifyInit_ex(mctx, &si->pctx, EVP_MD_get0_name(md), libctx,
919	propq, si->pkey, NULL) <= 0)
920	goto err;
921
922	if (!cms_sd_asn1_ctrl(si, 1))
923	goto err;
924
925	alen = ASN1_item_i2d((ASN1_VALUE *)si->signedAttrs, &abuf,
926	ASN1_ITEM_rptr(CMS_Attributes_Verify));
927	if (abuf == NULL \|\| alen < 0)
928	goto err;
929	r = EVP_DigestVerifyUpdate(mctx, abuf, alen);
930	OPENSSL_free(abuf);
931	if (r <= 0) {
932	r = -1;
933	goto err;
934	}
935	r = EVP_DigestVerifyFinal(mctx,
936	si->signature->data, si->signature->length);
937	if (r <= 0)
938	ERR_raise(ERR_LIB_CMS, CMS_R_VERIFICATION_FAILURE);
939	err:
940	EVP_MD_free(fetched_md);
941	EVP_MD_CTX_reset(mctx);
942	return r;
943	}
944
945	/* Create a chain of digest BIOs from a CMS ContentInfo */
946
947	BIO ossl_cms_SignedData_init_bio(CMS_ContentInfo cms)
948	{
949	int i;
950	CMS_SignedData *sd;
951	BIO *chain = NULL;
952
953	sd = cms_get0_signed(cms);
954	if (sd == NULL)
955	return NULL;
956	if (cms->d.signedData->encapContentInfo->partial)
957	cms_sd_set_version(sd);
958	for (i = 0; i < sk_X509_ALGOR_num(sd->digestAlgorithms); i++) {
959	X509_ALGOR *digestAlgorithm;
960	BIO *mdbio;
961
962	digestAlgorithm = sk_X509_ALGOR_value(sd->digestAlgorithms, i);
963	mdbio = ossl_cms_DigestAlgorithm_init_bio(digestAlgorithm,
964	ossl_cms_get0_cmsctx(cms));
965	if (mdbio == NULL)
966	goto err;
967	if (chain != NULL)
968	BIO_push(chain, mdbio);
969	else
970	chain = mdbio;
971	}
972	return chain;
973	err:
974	BIO_free_all(chain);
975	return NULL;
976	}
977
978	int CMS_SignerInfo_verify_content(CMS_SignerInfo si, BIO chain)
979	{
980	ASN1_OCTET_STRING *os = NULL;
981	EVP_MD_CTX *mctx = EVP_MD_CTX_new();
982	EVP_PKEY_CTX *pkctx = NULL;
983	int r = -1;
984	unsigned char mval[EVP_MAX_MD_SIZE];
985	unsigned int mlen;
986
987	if (mctx == NULL) {
988	ERR_raise(ERR_LIB_CMS, ERR_R_MALLOC_FAILURE);
989	goto err;
990	}
991	/* If we have any signed attributes look for messageDigest value */
992	if (CMS_signed_get_attr_count(si) >= 0) {
993	os = CMS_signed_get0_data_by_OBJ(si,
994	OBJ_nid2obj(NID_pkcs9_messageDigest),
995	-3, V_ASN1_OCTET_STRING);
996	if (os == NULL) {
997	ERR_raise(ERR_LIB_CMS, CMS_R_ERROR_READING_MESSAGEDIGEST_ATTRIBUTE);
998	goto err;
999	}
1000	}
1001
1002	if (!ossl_cms_DigestAlgorithm_find_ctx(mctx, chain, si->digestAlgorithm))
1003	goto err;
1004
1005	if (EVP_DigestFinal_ex(mctx, mval, &mlen) <= 0) {
1006	ERR_raise(ERR_LIB_CMS, CMS_R_UNABLE_TO_FINALIZE_CONTEXT);
1007	goto err;
1008	}
1009
1010	/* If messageDigest found compare it */
1011
1012	if (os != NULL) {
1013	if (mlen != (unsigned int)os->length) {
1014	ERR_raise(ERR_LIB_CMS, CMS_R_MESSAGEDIGEST_ATTRIBUTE_WRONG_LENGTH);
1015	goto err;
1016	}
1017
1018	if (memcmp(mval, os->data, mlen)) {
1019	ERR_raise(ERR_LIB_CMS, CMS_R_VERIFICATION_FAILURE);
1020	r = 0;
1021	} else
1022	r = 1;
1023	} else {
1024	const EVP_MD *md = EVP_MD_CTX_get0_md(mctx);
1025	const CMS_CTX *ctx = si->cms_ctx;
1026
1027	pkctx = EVP_PKEY_CTX_new_from_pkey(ossl_cms_ctx_get0_libctx(ctx),
1028	si->pkey,
1029	ossl_cms_ctx_get0_propq(ctx));
1030	if (pkctx == NULL)
1031	goto err;
1032	if (EVP_PKEY_verify_init(pkctx) <= 0)
1033	goto err;
1034	if (EVP_PKEY_CTX_set_signature_md(pkctx, md) <= 0)
1035	goto err;
1036	si->pctx = pkctx;
1037	if (!cms_sd_asn1_ctrl(si, 1))
1038	goto err;
1039	r = EVP_PKEY_verify(pkctx, si->signature->data,
1040	si->signature->length, mval, mlen);
1041	if (r <= 0) {
1042	ERR_raise(ERR_LIB_CMS, CMS_R_VERIFICATION_FAILURE);
1043	r = 0;
1044	}
1045	}
1046
1047	err:
1048	EVP_PKEY_CTX_free(pkctx);
1049	EVP_MD_CTX_free(mctx);
1050	return r;
1051
1052	}
1053
1054	int CMS_add_smimecap(CMS_SignerInfo si, STACK_OF(X509_ALGOR) algs)
1055	{
1056	unsigned char *smder = NULL;
1057	int smderlen, r;
1058
1059	smderlen = i2d_X509_ALGORS(algs, &smder);
1060	if (smderlen <= 0)
1061	return 0;
1062	r = CMS_signed_add1_attr_by_NID(si, NID_SMIMECapabilities,
1063	V_ASN1_SEQUENCE, smder, smderlen);
1064	OPENSSL_free(smder);
1065	return r;
1066	}
1067
1068	int CMS_add_simple_smimecap(STACK_OF(X509_ALGOR) **algs,
1069	int algnid, int keysize)
1070	{
1071	X509_ALGOR *alg = NULL;
1072	ASN1_INTEGER *key = NULL;
1073
1074	if (keysize > 0) {
1075	key = ASN1_INTEGER_new();
1076	if (key == NULL \|\| !ASN1_INTEGER_set(key, keysize))
1077	goto err;
1078	}
1079	alg = X509_ALGOR_new();
1080	if (alg == NULL)
1081	goto err;
1082
1083	if (!X509_ALGOR_set0(alg, OBJ_nid2obj(algnid),
1084	key ? V_ASN1_INTEGER : V_ASN1_UNDEF, key))
1085	goto err;
1086	key = NULL;
1087	if (*algs == NULL)
1088	*algs = sk_X509_ALGOR_new_null();
1089	if (algs == NULL \|\| !sk_X509_ALGOR_push(algs, alg))
1090	goto err;
1091	return 1;
1092
1093	err:
1094	ASN1_INTEGER_free(key);
1095	X509_ALGOR_free(alg);
1096	return 0;
1097	}
1098
1099	/* Check to see if a cipher exists and if so add S/MIME capabilities */
1100
1101	static int cms_add_cipher_smcap(STACK_OF(X509_ALGOR) **sk, int nid, int arg)
1102	{
1103	if (EVP_get_cipherbynid(nid))
1104	return CMS_add_simple_smimecap(sk, nid, arg);
1105	return 1;
1106	}
1107
1108	static int cms_add_digest_smcap(STACK_OF(X509_ALGOR) **sk, int nid, int arg)
1109	{
1110	if (EVP_get_digestbynid(nid))
1111	return CMS_add_simple_smimecap(sk, nid, arg);
1112	return 1;
1113	}
1114
1115	int CMS_add_standard_smimecap(STACK_OF(X509_ALGOR) **smcap)
1116	{
1117	if (!cms_add_cipher_smcap(smcap, NID_aes_256_cbc, -1)
1118	\|\| !cms_add_digest_smcap(smcap, NID_id_GostR3411_2012_256, -1)
1119	\|\| !cms_add_digest_smcap(smcap, NID_id_GostR3411_2012_512, -1)
1120	\|\| !cms_add_digest_smcap(smcap, NID_id_GostR3411_94, -1)
1121	\|\| !cms_add_cipher_smcap(smcap, NID_id_Gost28147_89, -1)
1122	\|\| !cms_add_cipher_smcap(smcap, NID_aes_192_cbc, -1)
1123	\|\| !cms_add_cipher_smcap(smcap, NID_aes_128_cbc, -1)
1124	\|\| !cms_add_cipher_smcap(smcap, NID_des_ede3_cbc, -1)
1125	\|\| !cms_add_cipher_smcap(smcap, NID_rc2_cbc, 128)
1126	\|\| !cms_add_cipher_smcap(smcap, NID_rc2_cbc, 64)
1127	\|\| !cms_add_cipher_smcap(smcap, NID_des_cbc, -1)
1128	\|\| !cms_add_cipher_smcap(smcap, NID_rc2_cbc, 40))
1129	return 0;
1130	return 1;
1131	}

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

source: vbox/trunk/src/libs/openssl-3.1.7/crypto/cms/cms_sd.c@ 107835

Download in other formats: