864dadeba9a668e42069cc96e2b1717dcb03c8f7
[openssl.git] / crypto / cms / cms_lcl.h
1 /* crypto/cms/cms_lcl.h */
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 #ifndef HEADER_CMS_LCL_H
55 #define HEADER_CMS_LCL_H
56
57 #ifdef __cplusplus
58 extern "C" {
59 #endif
60
61 #include <openssl/x509.h>
62
63 /* Cryptographic message syntax (CMS) structures: taken
64  * from RFC3852
65  */
66
67 /* Forward references */
68
69 typedef struct CMS_IssuerAndSerialNumber_st CMS_IssuerAndSerialNumber;
70 typedef struct CMS_EncapsulatedContentInfo_st CMS_EncapsulatedContentInfo;
71 typedef struct CMS_SignerIdentifier_st CMS_SignerIdentifier;
72 typedef struct CMS_SignedData_st CMS_SignedData;
73 typedef struct CMS_OtherRevocationInfoFormat_st CMS_OtherRevocationInfoFormat;
74 typedef struct CMS_OriginatorInfo_st CMS_OriginatorInfo;
75 typedef struct CMS_EncryptedContentInfo_st CMS_EncryptedContentInfo;
76 typedef struct CMS_EnvelopedData_st CMS_EnvelopedData;
77 typedef struct CMS_DigestedData_st CMS_DigestedData;
78 typedef struct CMS_EncryptedData_st CMS_EncryptedData;
79 typedef struct CMS_AuthenticatedData_st CMS_AuthenticatedData;
80 typedef struct CMS_CompressedData_st CMS_CompressedData;
81 typedef struct CMS_OtherCertificateFormat_st CMS_OtherCertificateFormat;
82 typedef struct CMS_KeyTransRecipientInfo_st CMS_KeyTransRecipientInfo;
83 typedef struct CMS_OriginatorPublicKey_st CMS_OriginatorPublicKey;
84 typedef struct CMS_OriginatorIdentifierOrKey_st CMS_OriginatorIdentifierOrKey;
85 typedef struct CMS_KeyAgreeRecipientInfo_st CMS_KeyAgreeRecipientInfo;
86 typedef struct CMS_OtherKeyAttribute_st CMS_OtherKeyAttribute;
87 typedef struct CMS_RecipientKeyIdentifier_st CMS_RecipientKeyIdentifier;
88 typedef struct CMS_KeyAgreeRecipientIdentifier_st CMS_KeyAgreeRecipientIdentifier;
89 typedef struct CMS_RecipientEncryptedKey_st CMS_RecipientEncryptedKey;
90 typedef struct CMS_KEKIdentifier_st CMS_KEKIdentifier;
91 typedef struct CMS_KEKRecipientInfo_st CMS_KEKRecipientInfo;
92 typedef struct CMS_PasswordRecipientInfo_st CMS_PasswordRecipientInfo;
93 typedef struct CMS_OtherRecipientInfo_st CMS_OtherRecipientInfo;
94 typedef struct CMS_RecipientInfo_st CMS_RecipientInfo;
95
96 struct CMS_ContentInfo_st
97         {
98         ASN1_OBJECT *contentType;
99         union   {
100                 ASN1_OCTET_STRING *data;
101                 CMS_SignedData *signedData;
102                 CMS_EnvelopedData *envelopedData;
103                 CMS_DigestedData *digestedData;
104                 CMS_EncryptedData *encryptedData;
105                 CMS_AuthenticatedData *authenticatedData;
106                 CMS_CompressedData *compressedData;
107                 ASN1_TYPE *other;
108                 /* Other types ... */
109                 void *otherData;
110                 } d;
111         };
112
113 struct CMS_SignedData_st
114         {
115         long version;
116         STACK_OF(X509_ALGOR) *digestAlgorithms;
117         CMS_EncapsulatedContentInfo *encapContentInfo;
118         STACK_OF(CMS_CertificateChoices) *certificates;
119         STACK_OF(CMS_RevocationInfoChoice) *crls;
120         STACK_OF(CMS_SignerInfo) *signerInfos;
121         };
122  
123 struct CMS_EncapsulatedContentInfo_st
124         {
125         ASN1_OBJECT *eContentType;
126         ASN1_OCTET_STRING *eContent;
127         };
128
129 struct CMS_SignerInfo_st
130         {
131         long version;
132         CMS_SignerIdentifier *sid;
133         X509_ALGOR *digestAlgorithm;
134         STACK_OF(X509_ATTRIBUTE) *signedAttrs;
135         X509_ALGOR *signatureAlgorithm;
136         ASN1_OCTET_STRING *signature;
137         STACK_OF(X509_ATTRIBUTE) *unsignedAttrs;
138         /* Signing certificate and key */
139         X509 *signer;
140         EVP_PKEY *pkey;
141         };
142
143 struct CMS_SignerIdentifier_st
144         {
145         int type;
146         union   {
147                 CMS_IssuerAndSerialNumber *issuerAndSerialNumber;
148                 ASN1_OCTET_STRING *subjectKeyIdentifier;
149                 } d;
150         };
151
152 struct CMS_EnvelopedData_st
153         {
154         long version;
155         CMS_OriginatorInfo *originatorInfo;
156         STACK_OF(CMS_RecipientInfo) *recipientInfos;
157         CMS_EncryptedContentInfo *encryptedContentInfo;
158         STACK_OF(X509_ATTRIBUTE) *unprotectedAttrs;
159         };
160
161 struct CMS_OriginatorInfo_st
162         {
163         STACK_OF(CMS_CertificateChoices) *certificates;
164         STACK_OF(CMS_RevocationInfoChoice) *crls;
165         };
166
167 struct CMS_EncryptedContentInfo_st
168         {
169         ASN1_OBJECT *contentType;
170         X509_ALGOR *contentEncryptionAlgorithm;
171         ASN1_OCTET_STRING *encryptedContent;
172         };
173
174 struct CMS_RecipientInfo_st
175         {
176         int type;
177         union   {
178                 CMS_KeyTransRecipientInfo *ktri;
179                 CMS_KeyAgreeRecipientInfo *kari;
180                 CMS_KEKRecipientInfo *kekri;
181                 CMS_PasswordRecipientInfo *pwri;
182                 CMS_OtherRecipientInfo *ori;
183                 } d;
184         };
185
186 #define CMS_RECIPINFO_TRANS             0
187 #define CMS_RECIPINFO_AGREE             1
188 #define CMS_RECIPINFO_KEK               2
189 #define CMS_RECIPINFO_PASS              3
190 #define CMS_RECIPINFO_OTHER             4
191
192 typedef CMS_SignerIdentifier CMS_RecipientIdentifier;
193
194 struct CMS_KeyTransRecipientInfo_st
195         {
196         long version;
197         CMS_RecipientIdentifier *rid;
198         X509_ALGOR *keyEncryptionAlgorithm;
199         ASN1_OCTET_STRING *encryptedKey;
200         /* Recipient Key and cert */
201         X509 *recip;
202         EVP_PKEY *pkey;
203         };
204
205 struct CMS_KeyAgreeRecipientInfo_st
206         {
207         long version;
208         CMS_OriginatorIdentifierOrKey *originator;
209         ASN1_OCTET_STRING *ukm;
210         X509_ALGOR *keyEncryptionAlgorithm;
211         STACK_OF(CMS_RecipientEncryptedKey) *recipientEncryptedKeys;
212         };
213
214 struct CMS_OriginatorIdentifierOrKey_st
215         {
216         int type;
217         union   {
218                 CMS_IssuerAndSerialNumber *issuerAndSerialNumber;
219                 ASN1_OCTET_STRING *subjectKeyIdentifier;
220                 CMS_OriginatorPublicKey *originatorKey;
221                 } d;
222         };
223
224 struct CMS_OriginatorPublicKey_st
225         {
226         X509_ALGOR *algorithm;
227         ASN1_BIT_STRING *publicKey;
228         };
229
230 struct CMS_RecipientEncryptedKey_st
231         {
232         CMS_KeyAgreeRecipientIdentifier *rid;
233         ASN1_OCTET_STRING *encryptedKey;
234         };
235
236 struct CMS_KeyAgreeRecipientIdentifier_st
237         {
238         int type;
239         union   {
240                 CMS_IssuerAndSerialNumber *issuerAndSerialNumber;
241                 CMS_RecipientKeyIdentifier *rKeyId;
242                 } d;
243         };
244
245 struct CMS_RecipientKeyIdentifier_st
246         {
247         ASN1_OCTET_STRING *subjectKeyIdentifier;
248         ASN1_GENERALIZEDTIME *date;
249         CMS_OtherKeyAttribute *other;
250         };
251
252 struct CMS_KEKRecipientInfo_st
253         {
254         long version;
255         CMS_KEKIdentifier *kekid;
256         X509_ALGOR *keyEncryptionAlgorithm;
257         ASN1_OCTET_STRING *encryptedKey;
258         };
259
260 struct CMS_KEKIdentifier_st
261         {
262         ASN1_OCTET_STRING *keyIdentifier;
263         ASN1_GENERALIZEDTIME *date;
264         CMS_OtherKeyAttribute *other;
265         };
266
267 struct CMS_PasswordRecipientInfo_st
268         {
269         long version;
270         X509_ALGOR *keyDerivationAlgorithm;
271         X509_ALGOR *keyEncryptionAlgorithm;
272         ASN1_OCTET_STRING *encryptedKey;
273         };
274
275 struct CMS_OtherRecipientInfo_st
276         {
277         ASN1_OBJECT *oriType;
278         ASN1_TYPE *oriValue;
279         };
280
281 struct CMS_DigestedData_st
282         {
283         long version;
284         X509_ALGOR *digestAlgorithm;
285         CMS_EncapsulatedContentInfo *encapContentInfo;
286         ASN1_OCTET_STRING *digest;
287         };
288
289 struct CMS_EncryptedData_st
290         {
291         long version;
292         CMS_EncryptedContentInfo *encryptedContentInfo;
293         STACK_OF(X509_ATTRIBUTE) *unprotectedAttrs;
294         };
295
296 struct CMS_AuthenticatedData_st
297         {
298         long version;
299         CMS_OriginatorInfo *originatorInfo;
300         STACK_OF(CMS_RecipientInfo) *recipientInfos;
301         X509_ALGOR *macAlgorithm;
302         X509_ALGOR *digestAlgorithm;
303         CMS_EncapsulatedContentInfo *encapContentInfo;
304         STACK_OF(X509_ATTRIBUTE) *authAttrs;
305         ASN1_OCTET_STRING *mac;
306         STACK_OF(X509_ATTRIBUTE) *unauthAttrs;
307         };
308
309 struct CMS_CompressedData_st
310         {
311         long version;
312         X509_ALGOR *compressionAlgorithm;
313         STACK_OF(CMS_RecipientInfo) *recipientInfos;
314         CMS_EncapsulatedContentInfo *encapContentInfo;
315         };
316
317 struct CMS_RevocationInfoChoice_st
318         {
319         int type;
320         union   {
321                 X509_CRL *crl;
322                 CMS_OtherRevocationInfoFormat *other;
323                 } d;
324         };
325
326 #define CMS_REVCHOICE_CRL               0
327 #define CMS_REVCHOICE_OTHER             1
328
329 struct CMS_OtherRevocationInfoFormat_st
330         {
331         ASN1_OBJECT *otherRevInfoFormat;
332         ASN1_TYPE *otherRevInfo;
333         };
334
335 struct CMS_CertificateChoices
336         {
337         int type;
338                 union {
339                 X509 *certificate;
340                 ASN1_STRING *extendedCertificate;       /* Obsolete */
341                 ASN1_STRING *v1AttrCert;        /* Left encoded for now */
342                 ASN1_STRING *v2AttrCert;        /* Left encoded for now */
343                 CMS_OtherCertificateFormat *other;
344                 } d;
345         };
346
347 #define CMS_CERTCHOICE_CERT             0
348 #define CMS_CERTCHOICE_EXCERT           1
349 #define CMS_CERTCHOICE_V1ACERT          2
350 #define CMS_CERTCHOICE_V2ACERT          3
351 #define CMS_CERTCHOICE_OTHER            4
352
353 struct CMS_OtherCertificateFormat_st
354         {
355         ASN1_OBJECT *otherCertFormat;
356         ASN1_TYPE *otherCert;
357         };
358
359 /* This is also defined in pkcs7.h but we duplicate it
360  * to allow the CMS code to be independent of PKCS#7
361  */
362
363 struct CMS_IssuerAndSerialNumber_st
364         {
365         X509_NAME *issuer;
366         ASN1_INTEGER *serialNumber;
367         };
368
369 struct CMS_OtherKeyAttribute_st
370         {
371         ASN1_OBJECT *keyAttrId;
372         ASN1_TYPE *keyAttr;
373         };
374
375 DECLARE_ASN1_FUNCTIONS(CMS_ContentInfo)
376 DECLARE_ASN1_ITEM(CMS_SignerInfo)
377 DECLARE_ASN1_ITEM(CMS_IssuerAndSerialNumber)
378 DECLARE_ASN1_ITEM(CMS_Attributes_Sign)
379 DECLARE_ASN1_ITEM(CMS_Attributes_Verify)
380 DECLARE_ASN1_ALLOC_FUNCTIONS(CMS_IssuerAndSerialNumber)
381
382 #define CMS_SIGNERINFO_ISSUER_SERIAL    0
383 #define CMS_SIGNERINFO_KEYIDENTIFIER    1
384
385 #define CMS_RECIPINFO_ISSUER_SERIAL     0
386 #define CMS_RECIPINFO_KEYIDENTIFIER     1
387
388 BIO *cms_content_bio(CMS_ContentInfo *cms);
389
390 CMS_ContentInfo *cms_Data_create(void);
391
392 CMS_ContentInfo *cms_DigestedData_create(const EVP_MD *md);
393 BIO *cms_DigestedData_init_bio(CMS_ContentInfo *cms);
394 int cms_DigestedData_do_final(CMS_ContentInfo *cms, BIO *chain, int verify);
395
396 BIO *cms_SignedData_init_bio(CMS_ContentInfo *cms);
397 int cms_SignedData_final(CMS_ContentInfo *cms, BIO *chain);
398 int cms_set1_SignerIdentifier(CMS_SignerIdentifier *sid, X509 *cert, int type);
399 int cms_SignerIdentifier_get0_signer_id(CMS_SignerIdentifier *sid,
400                                         ASN1_OCTET_STRING **keyid,
401                                         X509_NAME **issuer, ASN1_INTEGER **sno);
402 int cms_SignerIdentifier_cert_cmp(CMS_SignerIdentifier *sid, X509 *cert);
403
404 CMS_ContentInfo *cms_CompressedData_create(int comp_nid);
405 BIO *cms_CompressedData_init_bio(CMS_ContentInfo *cms);
406
407 void cms_DigestAlgorithm_set(X509_ALGOR *alg, const EVP_MD *md);
408 BIO *cms_DigestAlgorithm_init_bio(X509_ALGOR *digestAlgorithm);
409 int cms_DigestAlgorithm_find_ctx(EVP_MD_CTX *mctx, BIO *chain,
410                                         X509_ALGOR *mdalg);
411         
412 #ifdef  __cplusplus
413 }
414 #endif
415 #endif