Branch data Line data Source code
1 : : /* crypto/cms/cms_asn1.c */
2 : : /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
3 : : * project.
4 : : */
5 : : /* ====================================================================
6 : : * Copyright (c) 2008 The OpenSSL Project. All rights reserved.
7 : : *
8 : : * Redistribution and use in source and binary forms, with or without
9 : : * modification, are permitted provided that the following conditions
10 : : * are met:
11 : : *
12 : : * 1. Redistributions of source code must retain the above copyright
13 : : * notice, this list of conditions and the following disclaimer.
14 : : *
15 : : * 2. Redistributions in binary form must reproduce the above copyright
16 : : * notice, this list of conditions and the following disclaimer in
17 : : * the documentation and/or other materials provided with the
18 : : * distribution.
19 : : *
20 : : * 3. All advertising materials mentioning features or use of this
21 : : * software must display the following acknowledgment:
22 : : * "This product includes software developed by the OpenSSL Project
23 : : * for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
24 : : *
25 : : * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
26 : : * endorse or promote products derived from this software without
27 : : * prior written permission. For written permission, please contact
28 : : * licensing@OpenSSL.org.
29 : : *
30 : : * 5. Products derived from this software may not be called "OpenSSL"
31 : : * nor may "OpenSSL" appear in their names without prior written
32 : : * permission of the OpenSSL Project.
33 : : *
34 : : * 6. Redistributions of any form whatsoever must retain the following
35 : : * acknowledgment:
36 : : * "This product includes software developed by the OpenSSL Project
37 : : * for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
38 : : *
39 : : * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
40 : : * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
41 : : * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
42 : : * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
43 : : * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
44 : : * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
45 : : * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
46 : : * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
47 : : * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
48 : : * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
49 : : * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
50 : : * OF THE POSSIBILITY OF SUCH DAMAGE.
51 : : * ====================================================================
52 : : */
53 : :
54 : : #include <openssl/asn1t.h>
55 : : #include <openssl/pem.h>
56 : : #include <openssl/x509v3.h>
57 : : #include "cms.h"
58 : : #include "cms_lcl.h"
59 : :
60 : :
61 : : ASN1_SEQUENCE(CMS_IssuerAndSerialNumber) = {
62 : : ASN1_SIMPLE(CMS_IssuerAndSerialNumber, issuer, X509_NAME),
63 : : ASN1_SIMPLE(CMS_IssuerAndSerialNumber, serialNumber, ASN1_INTEGER)
64 : : } ASN1_SEQUENCE_END(CMS_IssuerAndSerialNumber)
65 : :
66 : : ASN1_SEQUENCE(CMS_OtherCertificateFormat) = {
67 : : ASN1_SIMPLE(CMS_OtherCertificateFormat, otherCertFormat, ASN1_OBJECT),
68 : : ASN1_OPT(CMS_OtherCertificateFormat, otherCert, ASN1_ANY)
69 : : } ASN1_SEQUENCE_END(CMS_OtherCertificateFormat)
70 : :
71 : : ASN1_CHOICE(CMS_CertificateChoices) = {
72 : : ASN1_SIMPLE(CMS_CertificateChoices, d.certificate, X509),
73 : : ASN1_IMP(CMS_CertificateChoices, d.extendedCertificate, ASN1_SEQUENCE, 0),
74 : : ASN1_IMP(CMS_CertificateChoices, d.v1AttrCert, ASN1_SEQUENCE, 1),
75 : : ASN1_IMP(CMS_CertificateChoices, d.v2AttrCert, ASN1_SEQUENCE, 2),
76 : : ASN1_IMP(CMS_CertificateChoices, d.other, CMS_OtherCertificateFormat, 3)
77 : : } ASN1_CHOICE_END(CMS_CertificateChoices)
78 : :
79 : : ASN1_CHOICE(CMS_SignerIdentifier) = {
80 : : ASN1_SIMPLE(CMS_SignerIdentifier, d.issuerAndSerialNumber, CMS_IssuerAndSerialNumber),
81 : : ASN1_IMP(CMS_SignerIdentifier, d.subjectKeyIdentifier, ASN1_OCTET_STRING, 0)
82 : : } ASN1_CHOICE_END(CMS_SignerIdentifier)
83 : :
84 : : ASN1_NDEF_SEQUENCE(CMS_EncapsulatedContentInfo) = {
85 : : ASN1_SIMPLE(CMS_EncapsulatedContentInfo, eContentType, ASN1_OBJECT),
86 : : ASN1_NDEF_EXP_OPT(CMS_EncapsulatedContentInfo, eContent, ASN1_OCTET_STRING_NDEF, 0)
87 : : } ASN1_NDEF_SEQUENCE_END(CMS_EncapsulatedContentInfo)
88 : :
89 : : /* Minor tweak to operation: free up signer key, cert */
90 : 1305 : static int cms_si_cb(int operation, ASN1_VALUE **pval, const ASN1_ITEM *it,
91 : : void *exarg)
92 : : {
93 [ + + ]: 1305 : if(operation == ASN1_OP_FREE_POST)
94 : : {
95 : 124 : CMS_SignerInfo *si = (CMS_SignerInfo *)*pval;
96 [ + + ]: 124 : if (si->pkey)
97 : 120 : EVP_PKEY_free(si->pkey);
98 [ + + ]: 124 : if (si->signer)
99 : 120 : X509_free(si->signer);
100 [ + + ]: 124 : if (si->pctx)
101 : 64 : EVP_MD_CTX_cleanup(&si->mctx);
102 : : }
103 : 1305 : return 1;
104 : : }
105 : :
106 : : ASN1_SEQUENCE_cb(CMS_SignerInfo, cms_si_cb) = {
107 : : ASN1_SIMPLE(CMS_SignerInfo, version, LONG),
108 : : ASN1_SIMPLE(CMS_SignerInfo, sid, CMS_SignerIdentifier),
109 : : ASN1_SIMPLE(CMS_SignerInfo, digestAlgorithm, X509_ALGOR),
110 : : ASN1_IMP_SET_OF_OPT(CMS_SignerInfo, signedAttrs, X509_ATTRIBUTE, 0),
111 : : ASN1_SIMPLE(CMS_SignerInfo, signatureAlgorithm, X509_ALGOR),
112 : : ASN1_SIMPLE(CMS_SignerInfo, signature, ASN1_OCTET_STRING),
113 : : ASN1_IMP_SET_OF_OPT(CMS_SignerInfo, unsignedAttrs, X509_ATTRIBUTE, 1)
114 : : } ASN1_SEQUENCE_END_cb(CMS_SignerInfo, CMS_SignerInfo)
115 : :
116 : : ASN1_SEQUENCE(CMS_OtherRevocationInfoFormat) = {
117 : : ASN1_SIMPLE(CMS_OtherRevocationInfoFormat, otherRevInfoFormat, ASN1_OBJECT),
118 : : ASN1_OPT(CMS_OtherRevocationInfoFormat, otherRevInfo, ASN1_ANY)
119 : : } ASN1_SEQUENCE_END(CMS_OtherRevocationInfoFormat)
120 : :
121 : : ASN1_CHOICE(CMS_RevocationInfoChoice) = {
122 : : ASN1_SIMPLE(CMS_RevocationInfoChoice, d.crl, X509_CRL),
123 : : ASN1_IMP(CMS_RevocationInfoChoice, d.other, CMS_OtherRevocationInfoFormat, 1)
124 : : } ASN1_CHOICE_END(CMS_RevocationInfoChoice)
125 : :
126 : : ASN1_NDEF_SEQUENCE(CMS_SignedData) = {
127 : : ASN1_SIMPLE(CMS_SignedData, version, LONG),
128 : : ASN1_SET_OF(CMS_SignedData, digestAlgorithms, X509_ALGOR),
129 : : ASN1_SIMPLE(CMS_SignedData, encapContentInfo, CMS_EncapsulatedContentInfo),
130 : : ASN1_IMP_SET_OF_OPT(CMS_SignedData, certificates, CMS_CertificateChoices, 0),
131 : : ASN1_IMP_SET_OF_OPT(CMS_SignedData, crls, CMS_RevocationInfoChoice, 1),
132 : : ASN1_SET_OF(CMS_SignedData, signerInfos, CMS_SignerInfo)
133 : : } ASN1_NDEF_SEQUENCE_END(CMS_SignedData)
134 : :
135 : : ASN1_SEQUENCE(CMS_OriginatorInfo) = {
136 : : ASN1_IMP_SET_OF_OPT(CMS_OriginatorInfo, certificates, CMS_CertificateChoices, 0),
137 : : ASN1_IMP_SET_OF_OPT(CMS_OriginatorInfo, crls, CMS_RevocationInfoChoice, 1)
138 : : } ASN1_SEQUENCE_END(CMS_OriginatorInfo)
139 : :
140 : : ASN1_NDEF_SEQUENCE(CMS_EncryptedContentInfo) = {
141 : : ASN1_SIMPLE(CMS_EncryptedContentInfo, contentType, ASN1_OBJECT),
142 : : ASN1_SIMPLE(CMS_EncryptedContentInfo, contentEncryptionAlgorithm, X509_ALGOR),
143 : : ASN1_IMP_OPT(CMS_EncryptedContentInfo, encryptedContent, ASN1_OCTET_STRING_NDEF, 0)
144 : : } ASN1_NDEF_SEQUENCE_END(CMS_EncryptedContentInfo)
145 : :
146 : : ASN1_SEQUENCE(CMS_KeyTransRecipientInfo) = {
147 : : ASN1_SIMPLE(CMS_KeyTransRecipientInfo, version, LONG),
148 : : ASN1_SIMPLE(CMS_KeyTransRecipientInfo, rid, CMS_SignerIdentifier),
149 : : ASN1_SIMPLE(CMS_KeyTransRecipientInfo, keyEncryptionAlgorithm, X509_ALGOR),
150 : : ASN1_SIMPLE(CMS_KeyTransRecipientInfo, encryptedKey, ASN1_OCTET_STRING)
151 : : } ASN1_SEQUENCE_END(CMS_KeyTransRecipientInfo)
152 : :
153 : : ASN1_SEQUENCE(CMS_OtherKeyAttribute) = {
154 : : ASN1_SIMPLE(CMS_OtherKeyAttribute, keyAttrId, ASN1_OBJECT),
155 : : ASN1_OPT(CMS_OtherKeyAttribute, keyAttr, ASN1_ANY)
156 : : } ASN1_SEQUENCE_END(CMS_OtherKeyAttribute)
157 : :
158 : : ASN1_SEQUENCE(CMS_RecipientKeyIdentifier) = {
159 : : ASN1_SIMPLE(CMS_RecipientKeyIdentifier, subjectKeyIdentifier, ASN1_OCTET_STRING),
160 : : ASN1_OPT(CMS_RecipientKeyIdentifier, date, ASN1_GENERALIZEDTIME),
161 : : ASN1_OPT(CMS_RecipientKeyIdentifier, other, CMS_OtherKeyAttribute)
162 : : } ASN1_SEQUENCE_END(CMS_RecipientKeyIdentifier)
163 : :
164 : : ASN1_CHOICE(CMS_KeyAgreeRecipientIdentifier) = {
165 : : ASN1_SIMPLE(CMS_KeyAgreeRecipientIdentifier, d.issuerAndSerialNumber, CMS_IssuerAndSerialNumber),
166 : : ASN1_IMP(CMS_KeyAgreeRecipientIdentifier, d.rKeyId, CMS_RecipientKeyIdentifier, 0)
167 : : } ASN1_CHOICE_END(CMS_KeyAgreeRecipientIdentifier)
168 : :
169 : 112 : static int cms_rek_cb(int operation, ASN1_VALUE **pval, const ASN1_ITEM *it,
170 : : void *exarg)
171 : : {
172 : 112 : CMS_RecipientEncryptedKey *rek = (CMS_RecipientEncryptedKey *)*pval;
173 [ + + ]: 112 : if(operation == ASN1_OP_FREE_POST)
174 : : {
175 [ + + ]: 8 : if (rek->pkey)
176 : 4 : EVP_PKEY_free(rek->pkey);
177 : : }
178 : 112 : return 1;
179 : : }
180 : :
181 : : ASN1_SEQUENCE_cb(CMS_RecipientEncryptedKey, cms_rek_cb) = {
182 : : ASN1_SIMPLE(CMS_RecipientEncryptedKey, rid, CMS_KeyAgreeRecipientIdentifier),
183 : : ASN1_SIMPLE(CMS_RecipientEncryptedKey, encryptedKey, ASN1_OCTET_STRING)
184 : : } ASN1_SEQUENCE_END_cb(CMS_RecipientEncryptedKey, CMS_RecipientEncryptedKey)
185 : :
186 : : ASN1_SEQUENCE(CMS_OriginatorPublicKey) = {
187 : : ASN1_SIMPLE(CMS_OriginatorPublicKey, algorithm, X509_ALGOR),
188 : : ASN1_SIMPLE(CMS_OriginatorPublicKey, publicKey, ASN1_BIT_STRING)
189 : : } ASN1_SEQUENCE_END(CMS_OriginatorPublicKey)
190 : :
191 : : ASN1_CHOICE(CMS_OriginatorIdentifierOrKey) = {
192 : : ASN1_SIMPLE(CMS_OriginatorIdentifierOrKey, d.issuerAndSerialNumber, CMS_IssuerAndSerialNumber),
193 : : ASN1_IMP(CMS_OriginatorIdentifierOrKey, d.subjectKeyIdentifier, ASN1_OCTET_STRING, 0),
194 : : ASN1_IMP(CMS_OriginatorIdentifierOrKey, d.originatorKey, CMS_OriginatorPublicKey, 1)
195 : : } ASN1_CHOICE_END(CMS_OriginatorIdentifierOrKey)
196 : :
197 : 96 : static int cms_kari_cb(int operation, ASN1_VALUE **pval, const ASN1_ITEM *it,
198 : : void *exarg)
199 : : {
200 : 96 : CMS_KeyAgreeRecipientInfo *kari = (CMS_KeyAgreeRecipientInfo *)*pval;
201 [ + + ]: 96 : if(operation == ASN1_OP_NEW_POST)
202 : : {
203 : 8 : EVP_CIPHER_CTX_init(&kari->ctx);
204 : 8 : EVP_CIPHER_CTX_set_flags(&kari->ctx,
205 : : EVP_CIPHER_CTX_FLAG_WRAP_ALLOW);
206 : 8 : kari->pctx = NULL;
207 : : }
208 [ + + ]: 88 : else if(operation == ASN1_OP_FREE_POST)
209 : : {
210 [ - + ]: 8 : if (kari->pctx)
211 : 0 : EVP_PKEY_CTX_free(kari->pctx);
212 : 8 : EVP_CIPHER_CTX_cleanup(&kari->ctx);
213 : : }
214 : 96 : return 1;
215 : : }
216 : :
217 : : ASN1_SEQUENCE_cb(CMS_KeyAgreeRecipientInfo, cms_kari_cb) = {
218 : : ASN1_SIMPLE(CMS_KeyAgreeRecipientInfo, version, LONG),
219 : : ASN1_EXP(CMS_KeyAgreeRecipientInfo, originator, CMS_OriginatorIdentifierOrKey, 0),
220 : : ASN1_EXP_OPT(CMS_KeyAgreeRecipientInfo, ukm, ASN1_OCTET_STRING, 1),
221 : : ASN1_SIMPLE(CMS_KeyAgreeRecipientInfo, keyEncryptionAlgorithm, X509_ALGOR),
222 : : ASN1_SEQUENCE_OF(CMS_KeyAgreeRecipientInfo, recipientEncryptedKeys, CMS_RecipientEncryptedKey)
223 : : } ASN1_SEQUENCE_END_cb(CMS_KeyAgreeRecipientInfo, CMS_KeyAgreeRecipientInfo)
224 : :
225 : : ASN1_SEQUENCE(CMS_KEKIdentifier) = {
226 : : ASN1_SIMPLE(CMS_KEKIdentifier, keyIdentifier, ASN1_OCTET_STRING),
227 : : ASN1_OPT(CMS_KEKIdentifier, date, ASN1_GENERALIZEDTIME),
228 : : ASN1_OPT(CMS_KEKIdentifier, other, CMS_OtherKeyAttribute)
229 : : } ASN1_SEQUENCE_END(CMS_KEKIdentifier)
230 : :
231 : : ASN1_SEQUENCE(CMS_KEKRecipientInfo) = {
232 : : ASN1_SIMPLE(CMS_KEKRecipientInfo, version, LONG),
233 : : ASN1_SIMPLE(CMS_KEKRecipientInfo, kekid, CMS_KEKIdentifier),
234 : : ASN1_SIMPLE(CMS_KEKRecipientInfo, keyEncryptionAlgorithm, X509_ALGOR),
235 : : ASN1_SIMPLE(CMS_KEKRecipientInfo, encryptedKey, ASN1_OCTET_STRING)
236 : : } ASN1_SEQUENCE_END(CMS_KEKRecipientInfo)
237 : :
238 : : ASN1_SEQUENCE(CMS_PasswordRecipientInfo) = {
239 : : ASN1_SIMPLE(CMS_PasswordRecipientInfo, version, LONG),
240 : : ASN1_IMP_OPT(CMS_PasswordRecipientInfo, keyDerivationAlgorithm, X509_ALGOR, 0),
241 : : ASN1_SIMPLE(CMS_PasswordRecipientInfo, keyEncryptionAlgorithm, X509_ALGOR),
242 : : ASN1_SIMPLE(CMS_PasswordRecipientInfo, encryptedKey, ASN1_OCTET_STRING)
243 : : } ASN1_SEQUENCE_END(CMS_PasswordRecipientInfo)
244 : :
245 : : ASN1_SEQUENCE(CMS_OtherRecipientInfo) = {
246 : : ASN1_SIMPLE(CMS_OtherRecipientInfo, oriType, ASN1_OBJECT),
247 : : ASN1_OPT(CMS_OtherRecipientInfo, oriValue, ASN1_ANY)
248 : : } ASN1_SEQUENCE_END(CMS_OtherRecipientInfo)
249 : :
250 : : /* Free up RecipientInfo additional data */
251 : 770 : static int cms_ri_cb(int operation, ASN1_VALUE **pval, const ASN1_ITEM *it,
252 : : void *exarg)
253 : : {
254 [ + + ]: 770 : if(operation == ASN1_OP_FREE_PRE)
255 : : {
256 : 70 : CMS_RecipientInfo *ri = (CMS_RecipientInfo *)*pval;
257 [ + + ]: 70 : if (ri->type == CMS_RECIPINFO_TRANS)
258 : : {
259 : 58 : CMS_KeyTransRecipientInfo *ktri = ri->d.ktri;
260 [ + + ]: 58 : if (ktri->pkey)
261 : 29 : EVP_PKEY_free(ktri->pkey);
262 [ + + ]: 58 : if (ktri->recip)
263 : 29 : X509_free(ktri->recip);
264 [ - + ]: 58 : if (ktri->pctx)
265 : 0 : EVP_PKEY_CTX_free(ktri->pctx);
266 : : }
267 [ + + ]: 12 : else if (ri->type == CMS_RECIPINFO_KEK)
268 : : {
269 : 4 : CMS_KEKRecipientInfo *kekri = ri->d.kekri;
270 [ + + ]: 4 : if (kekri->key)
271 : : {
272 : 2 : OPENSSL_cleanse(kekri->key, kekri->keylen);
273 : 2 : OPENSSL_free(kekri->key);
274 : : }
275 : : }
276 [ - + ]: 8 : else if (ri->type == CMS_RECIPINFO_PASS)
277 : : {
278 : 0 : CMS_PasswordRecipientInfo *pwri = ri->d.pwri;
279 [ # # ]: 0 : if (pwri->pass)
280 : : {
281 : 0 : OPENSSL_cleanse(pwri->pass, pwri->passlen);
282 : 0 : OPENSSL_free(pwri->pass);
283 : : }
284 : : }
285 : : }
286 : 770 : return 1;
287 : : }
288 : :
289 : : ASN1_CHOICE_cb(CMS_RecipientInfo, cms_ri_cb) = {
290 : : ASN1_SIMPLE(CMS_RecipientInfo, d.ktri, CMS_KeyTransRecipientInfo),
291 : : ASN1_IMP(CMS_RecipientInfo, d.kari, CMS_KeyAgreeRecipientInfo, 1),
292 : : ASN1_IMP(CMS_RecipientInfo, d.kekri, CMS_KEKRecipientInfo, 2),
293 : : ASN1_IMP(CMS_RecipientInfo, d.pwri, CMS_PasswordRecipientInfo, 3),
294 : : ASN1_IMP(CMS_RecipientInfo, d.ori, CMS_OtherRecipientInfo, 4)
295 : : } ASN1_CHOICE_END_cb(CMS_RecipientInfo, CMS_RecipientInfo, type)
296 : :
297 : : ASN1_NDEF_SEQUENCE(CMS_EnvelopedData) = {
298 : : ASN1_SIMPLE(CMS_EnvelopedData, version, LONG),
299 : : ASN1_IMP_OPT(CMS_EnvelopedData, originatorInfo, CMS_OriginatorInfo, 0),
300 : : ASN1_SET_OF(CMS_EnvelopedData, recipientInfos, CMS_RecipientInfo),
301 : : ASN1_SIMPLE(CMS_EnvelopedData, encryptedContentInfo, CMS_EncryptedContentInfo),
302 : : ASN1_IMP_SET_OF_OPT(CMS_EnvelopedData, unprotectedAttrs, X509_ATTRIBUTE, 1)
303 : : } ASN1_NDEF_SEQUENCE_END(CMS_EnvelopedData)
304 : :
305 : : ASN1_NDEF_SEQUENCE(CMS_DigestedData) = {
306 : : ASN1_SIMPLE(CMS_DigestedData, version, LONG),
307 : : ASN1_SIMPLE(CMS_DigestedData, digestAlgorithm, X509_ALGOR),
308 : : ASN1_SIMPLE(CMS_DigestedData, encapContentInfo, CMS_EncapsulatedContentInfo),
309 : : ASN1_SIMPLE(CMS_DigestedData, digest, ASN1_OCTET_STRING)
310 : : } ASN1_NDEF_SEQUENCE_END(CMS_DigestedData)
311 : :
312 : : ASN1_NDEF_SEQUENCE(CMS_EncryptedData) = {
313 : : ASN1_SIMPLE(CMS_EncryptedData, version, LONG),
314 : : ASN1_SIMPLE(CMS_EncryptedData, encryptedContentInfo, CMS_EncryptedContentInfo),
315 : : ASN1_IMP_SET_OF_OPT(CMS_EncryptedData, unprotectedAttrs, X509_ATTRIBUTE, 1)
316 : : } ASN1_NDEF_SEQUENCE_END(CMS_EncryptedData)
317 : :
318 : : ASN1_NDEF_SEQUENCE(CMS_AuthenticatedData) = {
319 : : ASN1_SIMPLE(CMS_AuthenticatedData, version, LONG),
320 : : ASN1_IMP_OPT(CMS_AuthenticatedData, originatorInfo, CMS_OriginatorInfo, 0),
321 : : ASN1_SET_OF(CMS_AuthenticatedData, recipientInfos, CMS_RecipientInfo),
322 : : ASN1_SIMPLE(CMS_AuthenticatedData, macAlgorithm, X509_ALGOR),
323 : : ASN1_IMP(CMS_AuthenticatedData, digestAlgorithm, X509_ALGOR, 1),
324 : : ASN1_SIMPLE(CMS_AuthenticatedData, encapContentInfo, CMS_EncapsulatedContentInfo),
325 : : ASN1_IMP_SET_OF_OPT(CMS_AuthenticatedData, authAttrs, X509_ALGOR, 2),
326 : : ASN1_SIMPLE(CMS_AuthenticatedData, mac, ASN1_OCTET_STRING),
327 : : ASN1_IMP_SET_OF_OPT(CMS_AuthenticatedData, unauthAttrs, X509_ALGOR, 3)
328 : : } ASN1_NDEF_SEQUENCE_END(CMS_AuthenticatedData)
329 : :
330 : : ASN1_NDEF_SEQUENCE(CMS_CompressedData) = {
331 : : ASN1_SIMPLE(CMS_CompressedData, version, LONG),
332 : : ASN1_SIMPLE(CMS_CompressedData, compressionAlgorithm, X509_ALGOR),
333 : : ASN1_SIMPLE(CMS_CompressedData, encapContentInfo, CMS_EncapsulatedContentInfo),
334 : : } ASN1_NDEF_SEQUENCE_END(CMS_CompressedData)
335 : :
336 : : /* This is the ANY DEFINED BY table for the top level ContentInfo structure */
337 : :
338 : : ASN1_ADB_TEMPLATE(cms_default) = ASN1_EXP(CMS_ContentInfo, d.other, ASN1_ANY, 0);
339 : :
340 : : ASN1_ADB(CMS_ContentInfo) = {
341 : : ADB_ENTRY(NID_pkcs7_data, ASN1_NDEF_EXP(CMS_ContentInfo, d.data, ASN1_OCTET_STRING_NDEF, 0)),
342 : : ADB_ENTRY(NID_pkcs7_signed, ASN1_NDEF_EXP(CMS_ContentInfo, d.signedData, CMS_SignedData, 0)),
343 : : ADB_ENTRY(NID_pkcs7_enveloped, ASN1_NDEF_EXP(CMS_ContentInfo, d.envelopedData, CMS_EnvelopedData, 0)),
344 : : ADB_ENTRY(NID_pkcs7_digest, ASN1_NDEF_EXP(CMS_ContentInfo, d.digestedData, CMS_DigestedData, 0)),
345 : : ADB_ENTRY(NID_pkcs7_encrypted, ASN1_NDEF_EXP(CMS_ContentInfo, d.encryptedData, CMS_EncryptedData, 0)),
346 : : ADB_ENTRY(NID_id_smime_ct_authData, ASN1_NDEF_EXP(CMS_ContentInfo, d.authenticatedData, CMS_AuthenticatedData, 0)),
347 : : ADB_ENTRY(NID_id_smime_ct_compressedData, ASN1_NDEF_EXP(CMS_ContentInfo, d.compressedData, CMS_CompressedData, 0)),
348 : : } ASN1_ADB_END(CMS_ContentInfo, 0, contentType, 0, &cms_default_tt, NULL);
349 : :
350 : : /* CMS streaming support */
351 : 853 : static int cms_cb(int operation, ASN1_VALUE **pval, const ASN1_ITEM *it,
352 : : void *exarg)
353 : : {
354 : 853 : ASN1_STREAM_ARG *sarg = exarg;
355 : 853 : CMS_ContentInfo *cms = NULL;
356 [ + - ]: 853 : if (pval)
357 : 853 : cms = (CMS_ContentInfo *)*pval;
358 : : else
359 : : return 1;
360 [ + + + + ]: 853 : switch(operation)
361 : : {
362 : :
363 : : case ASN1_OP_STREAM_PRE:
364 [ + - ]: 34 : if (CMS_stream(&sarg->boundary, cms) <= 0)
365 : : return 0;
366 : : case ASN1_OP_DETACHED_PRE:
367 : 36 : sarg->ndef_bio = CMS_dataInit(cms, sarg->out);
368 [ + - ]: 36 : if (!sarg->ndef_bio)
369 : : return 0;
370 : : break;
371 : :
372 : : case ASN1_OP_STREAM_POST:
373 : : case ASN1_OP_DETACHED_POST:
374 [ + - ]: 72 : if (CMS_dataFinal(cms, sarg->ndef_bio) <= 0)
375 : : return 0;
376 : : break;
377 : :
378 : : }
379 : : return 1;
380 : : }
381 : :
382 : : ASN1_NDEF_SEQUENCE_cb(CMS_ContentInfo, cms_cb) = {
383 : : ASN1_SIMPLE(CMS_ContentInfo, contentType, ASN1_OBJECT),
384 : : ASN1_ADB_OBJECT(CMS_ContentInfo)
385 : : } ASN1_NDEF_SEQUENCE_END_cb(CMS_ContentInfo, CMS_ContentInfo)
386 : :
387 : : /* Specials for signed attributes */
388 : :
389 : : /* When signing attributes we want to reorder them to match the sorted
390 : : * encoding.
391 : : */
392 : :
393 : : ASN1_ITEM_TEMPLATE(CMS_Attributes_Sign) =
394 : : ASN1_EX_TEMPLATE_TYPE(ASN1_TFLG_SET_ORDER, 0, CMS_ATTRIBUTES, X509_ATTRIBUTE)
395 : : ASN1_ITEM_TEMPLATE_END(CMS_Attributes_Sign)
396 : :
397 : : /* When verifying attributes we need to use the received order. So
398 : : * we use SEQUENCE OF and tag it to SET OF
399 : : */
400 : :
401 : : ASN1_ITEM_TEMPLATE(CMS_Attributes_Verify) =
402 : : ASN1_EX_TEMPLATE_TYPE(ASN1_TFLG_SEQUENCE_OF | ASN1_TFLG_IMPTAG | ASN1_TFLG_UNIVERSAL,
403 : : V_ASN1_SET, CMS_ATTRIBUTES, X509_ATTRIBUTE)
404 : : ASN1_ITEM_TEMPLATE_END(CMS_Attributes_Verify)
405 : :
406 : :
407 : :
408 : : ASN1_CHOICE(CMS_ReceiptsFrom) = {
409 : : ASN1_IMP(CMS_ReceiptsFrom, d.allOrFirstTier, LONG, 0),
410 : : ASN1_IMP_SEQUENCE_OF(CMS_ReceiptsFrom, d.receiptList, GENERAL_NAMES, 1)
411 : : } ASN1_CHOICE_END(CMS_ReceiptsFrom)
412 : :
413 : : ASN1_SEQUENCE(CMS_ReceiptRequest) = {
414 : : ASN1_SIMPLE(CMS_ReceiptRequest, signedContentIdentifier, ASN1_OCTET_STRING),
415 : : ASN1_SIMPLE(CMS_ReceiptRequest, receiptsFrom, CMS_ReceiptsFrom),
416 : : ASN1_SEQUENCE_OF(CMS_ReceiptRequest, receiptsTo, GENERAL_NAMES)
417 : : } ASN1_SEQUENCE_END(CMS_ReceiptRequest)
418 : :
419 : : ASN1_SEQUENCE(CMS_Receipt) = {
420 : : ASN1_SIMPLE(CMS_Receipt, version, LONG),
421 : : ASN1_SIMPLE(CMS_Receipt, contentType, ASN1_OBJECT),
422 : : ASN1_SIMPLE(CMS_Receipt, signedContentIdentifier, ASN1_OCTET_STRING),
423 : : ASN1_SIMPLE(CMS_Receipt, originatorSignatureValue, ASN1_OCTET_STRING)
424 : : } ASN1_SEQUENCE_END(CMS_Receipt)
425 : :
426 : : /* Utilities to encode the CMS_SharedInfo structure used during key
427 : : * derivation.
428 : : */
429 : :
430 : : typedef struct {
431 : : X509_ALGOR *keyInfo;
432 : : ASN1_OCTET_STRING *entityUInfo;
433 : : ASN1_OCTET_STRING *suppPubInfo;
434 : : } CMS_SharedInfo;
435 : :
436 : : ASN1_SEQUENCE(CMS_SharedInfo) = {
437 : : ASN1_SIMPLE(CMS_SharedInfo, keyInfo, X509_ALGOR),
438 : : ASN1_EXP_OPT(CMS_SharedInfo, entityUInfo, ASN1_OCTET_STRING, 0),
439 : : ASN1_EXP_OPT(CMS_SharedInfo, suppPubInfo, ASN1_OCTET_STRING, 2),
440 : : } ASN1_SEQUENCE_END(CMS_SharedInfo)
441 : :
442 : 8 : int CMS_SharedInfo_encode(unsigned char **pder, X509_ALGOR *kekalg,
443 : : ASN1_OCTET_STRING *ukm, int keylen)
444 : : {
445 : : union {
446 : : CMS_SharedInfo *pecsi;
447 : : ASN1_VALUE *a;
448 : 8 : } intsi = {NULL};
449 : :
450 : : ASN1_OCTET_STRING oklen;
451 : : unsigned char kl[4];
452 : : CMS_SharedInfo ecsi;
453 : :
454 : 8 : keylen <<= 3;
455 : 8 : kl[0] = (keylen >> 24) & 0xff;
456 : 8 : kl[1] = (keylen >> 16) & 0xff;
457 : 8 : kl[2] = (keylen >> 8) & 0xff;
458 : 8 : kl[3] = keylen & 0xff;
459 : 8 : oklen.length = 4;
460 : 8 : oklen.data = kl;
461 : 8 : oklen.type = V_ASN1_OCTET_STRING;
462 : 8 : oklen.flags = 0;
463 : 8 : ecsi.keyInfo = kekalg;
464 : 8 : ecsi.entityUInfo = ukm;
465 : 8 : ecsi.suppPubInfo = &oklen;
466 : 8 : intsi.pecsi = &ecsi;
467 : 8 : return ASN1_item_i2d(intsi.a, pder, ASN1_ITEM_rptr(CMS_SharedInfo));
468 : : }
|
