507 lines
19 KiB
D
507 lines
19 KiB
D
/* crypto/cms/cms.h */
|
|
/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
|
|
* project.
|
|
*/
|
|
/* ====================================================================
|
|
* Copyright (c) 2008 The OpenSSL Project. All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
*
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
*
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in
|
|
* the documentation and/or other materials provided with the
|
|
* distribution.
|
|
*
|
|
* 3. All advertising materials mentioning features or use of this
|
|
* software must display the following acknowledgment:
|
|
* "This product includes software developed by the OpenSSL Project
|
|
* for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
|
|
*
|
|
* 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
|
|
* endorse or promote products derived from this software without
|
|
* prior written permission. For written permission, please contact
|
|
* licensing@OpenSSL.org.
|
|
*
|
|
* 5. Products derived from this software may not be called "OpenSSL"
|
|
* nor may "OpenSSL" appear in their names without prior written
|
|
* permission of the OpenSSL Project.
|
|
*
|
|
* 6. Redistributions of any form whatsoever must retain the following
|
|
* acknowledgment:
|
|
* "This product includes software developed by the OpenSSL Project
|
|
* for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
|
|
* EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
|
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
|
|
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
|
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
|
|
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
|
|
* OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
* ====================================================================
|
|
*/
|
|
|
|
|
|
module deimos.openssl.cms;
|
|
|
|
import deimos.openssl._d_util;
|
|
|
|
import deimos.openssl.asn1; // Needed for DECLARE_ASN1_*.
|
|
import deimos.openssl.x509v3; // Needed for GENERAL_NAMES.
|
|
|
|
public import deimos.openssl.x509;
|
|
|
|
version (OPENSSL_NO_CMS) {
|
|
static assert(false, "CMS is disabled.");
|
|
}
|
|
|
|
extern (C):
|
|
nothrow:
|
|
|
|
|
|
struct CMS_ContentInfo_st;
|
|
alias CMS_ContentInfo_st CMS_ContentInfo;
|
|
struct CMS_SignerInfo_st;
|
|
alias CMS_SignerInfo_st CMS_SignerInfo;
|
|
// BUG/oversight in the original headers: _st suffix missing.
|
|
struct CMS_CertificateChoices;
|
|
struct CMS_RevocationInfoChoice_st;
|
|
alias CMS_RevocationInfoChoice_st CMS_RevocationInfoChoice;
|
|
struct CMS_RecipientInfo_st;
|
|
alias CMS_RecipientInfo_st CMS_RecipientInfo;
|
|
struct CMS_ReceiptRequest_st;
|
|
alias CMS_ReceiptRequest_st CMS_ReceiptRequest;
|
|
struct CMS_Receipt_st;
|
|
alias CMS_Receipt_st CMS_Receipt;
|
|
|
|
/+mixin DECLARE_STACK_OF!(CMS_SignerInfo);+/
|
|
/+mixin DECLARE_STACK_OF!(GENERAL_NAMES);+/
|
|
mixin(DECLARE_ASN1_FUNCTIONS!"CMS_ContentInfo");
|
|
mixin(DECLARE_ASN1_FUNCTIONS!"CMS_ReceiptRequest");
|
|
mixin(DECLARE_ASN1_PRINT_FUNCTION!"CMS_ContentInfo");
|
|
|
|
enum CMS_SIGNERINFO_ISSUER_SERIAL = 0;
|
|
enum CMS_SIGNERINFO_KEYIDENTIFIER = 1;
|
|
|
|
enum CMS_RECIPINFO_TRANS = 0;
|
|
enum CMS_RECIPINFO_AGREE = 1;
|
|
enum CMS_RECIPINFO_KEK = 2;
|
|
enum CMS_RECIPINFO_PASS = 3;
|
|
enum CMS_RECIPINFO_OTHER = 4;
|
|
|
|
/* S/MIME related flags */
|
|
|
|
enum CMS_TEXT = 0x1;
|
|
enum CMS_NOCERTS = 0x2;
|
|
enum CMS_NO_CONTENT_VERIFY = 0x4;
|
|
enum CMS_NO_ATTR_VERIFY = 0x8;
|
|
enum CMS_NOSIGS = (CMS_NO_CONTENT_VERIFY|CMS_NO_ATTR_VERIFY);
|
|
enum CMS_NOINTERN = 0x10;
|
|
enum CMS_NO_SIGNER_CERT_VERIFY = 0x20;
|
|
enum CMS_NOVERIFY = 0x20;
|
|
enum CMS_DETACHED = 0x40;
|
|
enum CMS_BINARY = 0x80;
|
|
enum CMS_NOATTR = 0x100;
|
|
enum CMS_NOSMIMECAP = 0x200;
|
|
enum CMS_NOOLDMIMETYPE = 0x400;
|
|
enum CMS_CRLFEOL = 0x800;
|
|
enum CMS_STREAM = 0x1000;
|
|
enum CMS_NOCRL = 0x2000;
|
|
enum CMS_PARTIAL = 0x4000;
|
|
enum CMS_REUSE_DIGEST = 0x8000;
|
|
enum CMS_USE_KEYID = 0x10000;
|
|
enum CMS_DEBUG_DECRYPT = 0x20000;
|
|
|
|
const(ASN1_OBJECT)* CMS_get0_type(CMS_ContentInfo* cms);
|
|
|
|
BIO* CMS_dataInit(CMS_ContentInfo* cms, BIO* icont);
|
|
int CMS_dataFinal(CMS_ContentInfo* cms, BIO* bio);
|
|
|
|
ASN1_OCTET_STRING** CMS_get0_content(CMS_ContentInfo* cms);
|
|
int CMS_is_detached(CMS_ContentInfo* cms);
|
|
int CMS_set_detached(CMS_ContentInfo* cms, int detached);
|
|
|
|
// #ifdef HEADER_PEM_H
|
|
import deimos.openssl.pem;
|
|
mixin(DECLARE_PEM_rw_const!("CMS", "CMS_ContentInfo")());
|
|
// #endif
|
|
|
|
int CMS_stream(ubyte*** boundary, CMS_ContentInfo* cms);
|
|
CMS_ContentInfo* d2i_CMS_bio(BIO* bp, CMS_ContentInfo** cms);
|
|
int i2d_CMS_bio(BIO* bp, CMS_ContentInfo* cms);
|
|
|
|
BIO* BIO_new_CMS(BIO* out_, CMS_ContentInfo* cms);
|
|
int i2d_CMS_bio_stream(BIO* out_, CMS_ContentInfo* cms, BIO* in_, int flags);
|
|
int PEM_write_bio_CMS_stream(BIO* out_, CMS_ContentInfo* cms, BIO* in_, int flags);
|
|
CMS_ContentInfo* SMIME_read_CMS(BIO* bio, BIO** bcont);
|
|
int SMIME_write_CMS(BIO* bio, CMS_ContentInfo* cms, BIO* data, int flags);
|
|
|
|
int CMS_final(CMS_ContentInfo* cms, BIO* data, BIO* dcont, uint flags);
|
|
|
|
CMS_ContentInfo* CMS_sign(X509* signcert, EVP_PKEY* pkey, STACK_OF!(X509) *certs,
|
|
BIO* data, uint flags);
|
|
|
|
CMS_ContentInfo* CMS_sign_receipt(CMS_SignerInfo* si,
|
|
X509* signcert, EVP_PKEY* pkey,
|
|
STACK_OF!(X509) *certs,
|
|
uint flags);
|
|
|
|
int CMS_data(CMS_ContentInfo* cms, BIO* out_, uint flags);
|
|
CMS_ContentInfo* CMS_data_create(BIO* in_, uint flags);
|
|
|
|
int CMS_digest_verify(CMS_ContentInfo* cms, BIO* dcont, BIO* out_,
|
|
uint flags);
|
|
CMS_ContentInfo* CMS_digest_create(BIO* in_, const(EVP_MD)* md,
|
|
uint flags);
|
|
|
|
int CMS_EncryptedData_decrypt(CMS_ContentInfo* cms,
|
|
const(ubyte)* key, size_t keylen,
|
|
BIO* dcont, BIO* out_, uint flags);
|
|
|
|
CMS_ContentInfo* CMS_EncryptedData_encrypt(BIO* in_, const(EVP_CIPHER)* cipher,
|
|
const(ubyte)* key, size_t keylen,
|
|
uint flags);
|
|
|
|
int CMS_EncryptedData_set1_key(CMS_ContentInfo* cms, const(EVP_CIPHER)* ciph,
|
|
const(ubyte)* key, size_t keylen);
|
|
|
|
int CMS_verify(CMS_ContentInfo* cms, STACK_OF!(X509) *certs,
|
|
X509_STORE* store, BIO* dcont, BIO* out_, uint flags);
|
|
|
|
int CMS_verify_receipt(CMS_ContentInfo* rcms, CMS_ContentInfo* ocms,
|
|
STACK_OF!(X509) *certs,
|
|
X509_STORE* store, uint flags);
|
|
|
|
STACK_OF!(X509) *CMS_get0_signers(CMS_ContentInfo* cms);
|
|
|
|
CMS_ContentInfo* CMS_encrypt(STACK_OF!(X509) *certs, BIO* in_,
|
|
const(EVP_CIPHER)* cipher, uint flags);
|
|
|
|
int CMS_decrypt(CMS_ContentInfo* cms, EVP_PKEY* pkey, X509* cert,
|
|
BIO* dcont, BIO* out_,
|
|
uint flags);
|
|
|
|
int CMS_decrypt_set1_pkey(CMS_ContentInfo* cms, EVP_PKEY* pk, X509* cert);
|
|
int CMS_decrypt_set1_key(CMS_ContentInfo* cms,
|
|
ubyte* key, size_t keylen,
|
|
ubyte* id, size_t idlen);
|
|
int CMS_decrypt_set1_password(CMS_ContentInfo *cms,
|
|
ubyte *pass, ossl_ssize_t passlen);
|
|
|
|
STACK_OF!(CMS_RecipientInfo) *CMS_get0_RecipientInfos(CMS_ContentInfo* cms);
|
|
int CMS_RecipientInfo_type(CMS_RecipientInfo* ri);
|
|
CMS_ContentInfo* CMS_EnvelopedData_create(const(EVP_CIPHER)* cipher);
|
|
CMS_RecipientInfo* CMS_add1_recipient_cert(CMS_ContentInfo* cms,
|
|
X509* recip, uint flags);
|
|
int CMS_RecipientInfo_set0_pkey(CMS_RecipientInfo* ri, EVP_PKEY* pkey);
|
|
int CMS_RecipientInfo_ktri_cert_cmp(CMS_RecipientInfo* ri, X509* cert);
|
|
int CMS_RecipientInfo_ktri_get0_algs(CMS_RecipientInfo* ri,
|
|
EVP_PKEY** pk, X509** recip,
|
|
X509_ALGOR** palg);
|
|
int CMS_RecipientInfo_ktri_get0_signer_id(CMS_RecipientInfo* ri,
|
|
ASN1_OCTET_STRING** keyid,
|
|
X509_NAME** issuer, ASN1_INTEGER** sno);
|
|
|
|
CMS_RecipientInfo* CMS_add0_recipient_key(CMS_ContentInfo* cms, int nid,
|
|
ubyte* key, size_t keylen,
|
|
ubyte* id, size_t idlen,
|
|
ASN1_GENERALIZEDTIME* date,
|
|
ASN1_OBJECT* otherTypeId,
|
|
ASN1_TYPE* otherType);
|
|
|
|
int CMS_RecipientInfo_kekri_get0_id(CMS_RecipientInfo* ri,
|
|
X509_ALGOR** palg,
|
|
ASN1_OCTET_STRING** pid,
|
|
ASN1_GENERALIZEDTIME** pdate,
|
|
ASN1_OBJECT** potherid,
|
|
ASN1_TYPE** pothertype);
|
|
|
|
int CMS_RecipientInfo_set0_key(CMS_RecipientInfo* ri,
|
|
ubyte* key, size_t keylen);
|
|
|
|
int CMS_RecipientInfo_kekri_id_cmp(CMS_RecipientInfo* ri,
|
|
const(ubyte)* id, size_t idlen);
|
|
|
|
int CMS_RecipientInfo_set0_password(CMS_RecipientInfo *ri,
|
|
ubyte* pass,
|
|
ossl_ssize_t passlen);
|
|
|
|
CMS_RecipientInfo *CMS_add0_recipient_password(CMS_ContentInfo *cms,
|
|
int iter, int wrap_nid, int pbe_nid,
|
|
ubyte* pass,
|
|
ossl_ssize_t passlen,
|
|
const(EVP_CIPHER)* kekciph);
|
|
|
|
int CMS_RecipientInfo_decrypt(CMS_ContentInfo* cms, CMS_RecipientInfo* ri);
|
|
|
|
int CMS_uncompress(CMS_ContentInfo* cms, BIO* dcont, BIO* out_,
|
|
uint flags);
|
|
CMS_ContentInfo* CMS_compress(BIO* in_, int comp_nid, uint flags);
|
|
|
|
int CMS_set1_eContentType(CMS_ContentInfo* cms, const(ASN1_OBJECT)* oid);
|
|
const(ASN1_OBJECT)* CMS_get0_eContentType(CMS_ContentInfo* cms);
|
|
|
|
CMS_CertificateChoices* CMS_add0_CertificateChoices(CMS_ContentInfo* cms);
|
|
int CMS_add0_cert(CMS_ContentInfo* cms, X509* cert);
|
|
int CMS_add1_cert(CMS_ContentInfo* cms, X509* cert);
|
|
STACK_OF!(X509) *CMS_get1_certs(CMS_ContentInfo* cms);
|
|
|
|
CMS_RevocationInfoChoice* CMS_add0_RevocationInfoChoice(CMS_ContentInfo* cms);
|
|
int CMS_add0_crl(CMS_ContentInfo* cms, X509_CRL* crl);
|
|
int CMS_add1_crl(CMS_ContentInfo* cms, X509_CRL* crl);
|
|
STACK_OF!(X509_CRL) *CMS_get1_crls(CMS_ContentInfo* cms);
|
|
|
|
int CMS_SignedData_init(CMS_ContentInfo* cms);
|
|
CMS_SignerInfo* CMS_add1_signer(CMS_ContentInfo* cms,
|
|
X509* signer, EVP_PKEY* pk, const(EVP_MD)* md,
|
|
uint flags);
|
|
STACK_OF!(CMS_SignerInfo) *CMS_get0_SignerInfos(CMS_ContentInfo* cms);
|
|
|
|
void CMS_SignerInfo_set1_signer_cert(CMS_SignerInfo* si, X509* signer);
|
|
int CMS_SignerInfo_get0_signer_id(CMS_SignerInfo* si,
|
|
ASN1_OCTET_STRING** keyid,
|
|
X509_NAME** issuer, ASN1_INTEGER** sno);
|
|
int CMS_SignerInfo_cert_cmp(CMS_SignerInfo* si, X509* cert);
|
|
int CMS_set1_signers_certs(CMS_ContentInfo* cms, STACK_OF!(X509) *certs,
|
|
uint flags);
|
|
void CMS_SignerInfo_get0_algs(CMS_SignerInfo* si, EVP_PKEY** pk, X509** signer,
|
|
X509_ALGOR** pdig, X509_ALGOR** psig);
|
|
int CMS_SignerInfo_sign(CMS_SignerInfo* si);
|
|
int CMS_SignerInfo_verify(CMS_SignerInfo* si);
|
|
int CMS_SignerInfo_verify_content(CMS_SignerInfo* si, BIO* chain);
|
|
|
|
int CMS_add_smimecap(CMS_SignerInfo* si, STACK_OF!(X509_ALGOR) *algs);
|
|
int CMS_add_simple_smimecap(STACK_OF!(X509_ALGOR) **algs,
|
|
int algnid, int keysize);
|
|
int CMS_add_standard_smimecap(STACK_OF!(X509_ALGOR) **smcap);
|
|
|
|
int CMS_signed_get_attr_count(const(CMS_SignerInfo)* si);
|
|
int CMS_signed_get_attr_by_NID(const(CMS_SignerInfo)* si, int nid,
|
|
int lastpos);
|
|
int CMS_signed_get_attr_by_OBJ(const(CMS_SignerInfo)* si, ASN1_OBJECT* obj,
|
|
int lastpos);
|
|
X509_ATTRIBUTE* CMS_signed_get_attr(const(CMS_SignerInfo)* si, int loc);
|
|
X509_ATTRIBUTE* CMS_signed_delete_attr(CMS_SignerInfo* si, int loc);
|
|
int CMS_signed_add1_attr(CMS_SignerInfo* si, X509_ATTRIBUTE* attr);
|
|
int CMS_signed_add1_attr_by_OBJ(CMS_SignerInfo* si,
|
|
const(ASN1_OBJECT)* obj, int type,
|
|
const(void)* bytes, int len);
|
|
int CMS_signed_add1_attr_by_NID(CMS_SignerInfo* si,
|
|
int nid, int type,
|
|
const(void)* bytes, int len);
|
|
int CMS_signed_add1_attr_by_txt(CMS_SignerInfo* si,
|
|
const(char)* attrname, int type,
|
|
const(void)* bytes, int len);
|
|
void* CMS_signed_get0_data_by_OBJ(CMS_SignerInfo* si, ASN1_OBJECT* oid,
|
|
int lastpos, int type);
|
|
|
|
int CMS_unsigned_get_attr_count(const(CMS_SignerInfo)* si);
|
|
int CMS_unsigned_get_attr_by_NID(const(CMS_SignerInfo)* si, int nid,
|
|
int lastpos);
|
|
int CMS_unsigned_get_attr_by_OBJ(const(CMS_SignerInfo)* si, ASN1_OBJECT* obj,
|
|
int lastpos);
|
|
X509_ATTRIBUTE* CMS_unsigned_get_attr(const(CMS_SignerInfo)* si, int loc);
|
|
X509_ATTRIBUTE* CMS_unsigned_delete_attr(CMS_SignerInfo* si, int loc);
|
|
int CMS_unsigned_add1_attr(CMS_SignerInfo* si, X509_ATTRIBUTE* attr);
|
|
int CMS_unsigned_add1_attr_by_OBJ(CMS_SignerInfo* si,
|
|
const(ASN1_OBJECT)* obj, int type,
|
|
const(void)* bytes, int len);
|
|
int CMS_unsigned_add1_attr_by_NID(CMS_SignerInfo* si,
|
|
int nid, int type,
|
|
const(void)* bytes, int len);
|
|
int CMS_unsigned_add1_attr_by_txt(CMS_SignerInfo* si,
|
|
const(char)* attrname, int type,
|
|
const(void)* bytes, int len);
|
|
void* CMS_unsigned_get0_data_by_OBJ(CMS_SignerInfo* si, ASN1_OBJECT* oid,
|
|
int lastpos, int type);
|
|
|
|
// #ifdef HEADER_X509V3_H
|
|
|
|
int CMS_get1_ReceiptRequest(CMS_SignerInfo* si, CMS_ReceiptRequest** prr);
|
|
CMS_ReceiptRequest* CMS_ReceiptRequest_create0(ubyte* id, int idlen,
|
|
int allorfirst,
|
|
STACK_OF!(GENERAL_NAMES) *receiptList,
|
|
STACK_OF!(GENERAL_NAMES) *receiptsTo);
|
|
int CMS_add1_ReceiptRequest(CMS_SignerInfo* si, CMS_ReceiptRequest* rr);
|
|
void CMS_ReceiptRequest_get0_values(CMS_ReceiptRequest* rr,
|
|
ASN1_STRING** pcid,
|
|
int* pallorfirst,
|
|
STACK_OF!(GENERAL_NAMES) **plist,
|
|
STACK_OF!(GENERAL_NAMES) **prto);
|
|
|
|
// #endif
|
|
|
|
/* BEGIN ERROR CODES */
|
|
/* The following lines are auto generated by the script mkerr.pl. Any changes
|
|
* made after this point may be overwritten when the script is next run.
|
|
*/
|
|
void ERR_load_CMS_strings();
|
|
|
|
/* Error codes for the CMS functions. */
|
|
|
|
/* Function codes. */
|
|
enum CMS_F_CHECK_CONTENT = 99;
|
|
enum CMS_F_CMS_ADD0_CERT = 164;
|
|
enum CMS_F_CMS_ADD0_RECIPIENT_KEY = 100;
|
|
enum CMS_F_CMS_ADD0_RECIPIENT_PASSWORD = 165;
|
|
enum CMS_F_CMS_ADD1_RECEIPTREQUEST = 158;
|
|
enum CMS_F_CMS_ADD1_RECIPIENT_CERT = 101;
|
|
enum CMS_F_CMS_ADD1_SIGNER = 102;
|
|
enum CMS_F_CMS_ADD1_SIGNINGTIME = 103;
|
|
enum CMS_F_CMS_COMPRESS = 104;
|
|
enum CMS_F_CMS_COMPRESSEDDATA_CREATE = 105;
|
|
enum CMS_F_CMS_COMPRESSEDDATA_INIT_BIO = 106;
|
|
enum CMS_F_CMS_COPY_CONTENT = 107;
|
|
enum CMS_F_CMS_COPY_MESSAGEDIGEST = 108;
|
|
enum CMS_F_CMS_DATA = 109;
|
|
enum CMS_F_CMS_DATAFINAL = 110;
|
|
enum CMS_F_CMS_DATAINIT = 111;
|
|
enum CMS_F_CMS_DECRYPT = 112;
|
|
enum CMS_F_CMS_DECRYPT_SET1_KEY = 113;
|
|
enum CMS_F_CMS_DECRYPT_SET1_PASSWORD = 166;
|
|
enum CMS_F_CMS_DECRYPT_SET1_PKEY = 114;
|
|
enum CMS_F_CMS_DIGESTALGORITHM_FIND_CTX = 115;
|
|
enum CMS_F_CMS_DIGESTALGORITHM_INIT_BIO = 116;
|
|
enum CMS_F_CMS_DIGESTEDDATA_DO_FINAL = 117;
|
|
enum CMS_F_CMS_DIGEST_VERIFY = 118;
|
|
enum CMS_F_CMS_ENCODE_RECEIPT = 161;
|
|
enum CMS_F_CMS_ENCRYPT = 119;
|
|
enum CMS_F_CMS_ENCRYPTEDCONTENT_INIT_BIO = 120;
|
|
enum CMS_F_CMS_ENCRYPTEDDATA_DECRYPT = 121;
|
|
enum CMS_F_CMS_ENCRYPTEDDATA_ENCRYPT = 122;
|
|
enum CMS_F_CMS_ENCRYPTEDDATA_SET1_KEY = 123;
|
|
enum CMS_F_CMS_ENVELOPEDDATA_CREATE = 124;
|
|
enum CMS_F_CMS_ENVELOPEDDATA_INIT_BIO = 125;
|
|
enum CMS_F_CMS_ENVELOPED_DATA_INIT = 126;
|
|
enum CMS_F_CMS_FINAL = 127;
|
|
enum CMS_F_CMS_GET0_CERTIFICATE_CHOICES = 128;
|
|
enum CMS_F_CMS_GET0_CONTENT = 129;
|
|
enum CMS_F_CMS_GET0_ECONTENT_TYPE = 130;
|
|
enum CMS_F_CMS_GET0_ENVELOPED = 131;
|
|
enum CMS_F_CMS_GET0_REVOCATION_CHOICES = 132;
|
|
enum CMS_F_CMS_GET0_SIGNED = 133;
|
|
enum CMS_F_CMS_MSGSIGDIGEST_ADD1 = 162;
|
|
enum CMS_F_CMS_RECEIPTREQUEST_CREATE0 = 159;
|
|
enum CMS_F_CMS_RECEIPT_VERIFY = 160;
|
|
enum CMS_F_CMS_RECIPIENTINFO_DECRYPT = 134;
|
|
enum CMS_F_CMS_RECIPIENTINFO_KEKRI_DECRYPT = 135;
|
|
enum CMS_F_CMS_RECIPIENTINFO_KEKRI_ENCRYPT = 136;
|
|
enum CMS_F_CMS_RECIPIENTINFO_KEKRI_GET0_ID = 137;
|
|
enum CMS_F_CMS_RECIPIENTINFO_KEKRI_ID_CMP = 138;
|
|
enum CMS_F_CMS_RECIPIENTINFO_KTRI_CERT_CMP = 139;
|
|
enum CMS_F_CMS_RECIPIENTINFO_KTRI_DECRYPT = 140;
|
|
enum CMS_F_CMS_RECIPIENTINFO_KTRI_ENCRYPT = 141;
|
|
enum CMS_F_CMS_RECIPIENTINFO_KTRI_GET0_ALGS = 142;
|
|
enum CMS_F_CMS_RECIPIENTINFO_KTRI_GET0_SIGNER_ID = 143;
|
|
enum CMS_F_CMS_RECIPIENTINFO_PWRI_CRYPT = 167;
|
|
enum CMS_F_CMS_RECIPIENTINFO_SET0_KEY = 144;
|
|
enum CMS_F_CMS_RECIPIENTINFO_SET0_PASSWORD = 168;
|
|
enum CMS_F_CMS_RECIPIENTINFO_SET0_PKEY = 145;
|
|
enum CMS_F_CMS_SET1_SIGNERIDENTIFIER = 146;
|
|
enum CMS_F_CMS_SET_DETACHED = 147;
|
|
enum CMS_F_CMS_SIGN = 148;
|
|
enum CMS_F_CMS_SIGNED_DATA_INIT = 149;
|
|
enum CMS_F_CMS_SIGNERINFO_CONTENT_SIGN = 150;
|
|
enum CMS_F_CMS_SIGNERINFO_SIGN = 151;
|
|
enum CMS_F_CMS_SIGNERINFO_VERIFY = 152;
|
|
enum CMS_F_CMS_SIGNERINFO_VERIFY_CERT = 153;
|
|
enum CMS_F_CMS_SIGNERINFO_VERIFY_CONTENT = 154;
|
|
enum CMS_F_CMS_SIGN_RECEIPT = 163;
|
|
enum CMS_F_CMS_STREAM = 155;
|
|
enum CMS_F_CMS_UNCOMPRESS = 156;
|
|
enum CMS_F_CMS_VERIFY = 157;
|
|
|
|
/* Reason codes. */
|
|
enum CMS_R_ADD_SIGNER_ERROR = 99;
|
|
enum CMS_R_CERTIFICATE_ALREADY_PRESENT = 175;
|
|
enum CMS_R_CERTIFICATE_HAS_NO_KEYID = 160;
|
|
enum CMS_R_CERTIFICATE_VERIFY_ERROR = 100;
|
|
enum CMS_R_CIPHER_INITIALISATION_ERROR = 101;
|
|
enum CMS_R_CIPHER_PARAMETER_INITIALISATION_ERROR = 102;
|
|
enum CMS_R_CMS_DATAFINAL_ERROR = 103;
|
|
enum CMS_R_CMS_LIB = 104;
|
|
enum CMS_R_CONTENTIDENTIFIER_MISMATCH = 170;
|
|
enum CMS_R_CONTENT_NOT_FOUND = 105;
|
|
enum CMS_R_CONTENT_TYPE_MISMATCH = 171;
|
|
enum CMS_R_CONTENT_TYPE_NOT_COMPRESSED_DATA = 106;
|
|
enum CMS_R_CONTENT_TYPE_NOT_ENVELOPED_DATA = 107;
|
|
enum CMS_R_CONTENT_TYPE_NOT_SIGNED_DATA = 108;
|
|
enum CMS_R_CONTENT_VERIFY_ERROR = 109;
|
|
enum CMS_R_CTRL_ERROR = 110;
|
|
enum CMS_R_CTRL_FAILURE = 111;
|
|
enum CMS_R_DECRYPT_ERROR = 112;
|
|
enum CMS_R_DIGEST_ERROR = 161;
|
|
enum CMS_R_ERROR_GETTING_PUBLIC_KEY = 113;
|
|
enum CMS_R_ERROR_READING_MESSAGEDIGEST_ATTRIBUTE = 114;
|
|
enum CMS_R_ERROR_SETTING_KEY = 115;
|
|
enum CMS_R_ERROR_SETTING_RECIPIENTINFO = 116;
|
|
enum CMS_R_INVALID_ENCRYPTED_KEY_LENGTH = 117;
|
|
enum CMS_R_INVALID_KEY_ENCRYPTION_PARAMETER = 176;
|
|
enum CMS_R_INVALID_KEY_LENGTH = 118;
|
|
enum CMS_R_MD_BIO_INIT_ERROR = 119;
|
|
enum CMS_R_MESSAGEDIGEST_ATTRIBUTE_WRONG_LENGTH = 120;
|
|
enum CMS_R_MESSAGEDIGEST_WRONG_LENGTH = 121;
|
|
enum CMS_R_MSGSIGDIGEST_ERROR = 172;
|
|
enum CMS_R_MSGSIGDIGEST_VERIFICATION_FAILURE = 162;
|
|
enum CMS_R_MSGSIGDIGEST_WRONG_LENGTH = 163;
|
|
enum CMS_R_NEED_ONE_SIGNER = 164;
|
|
enum CMS_R_NOT_A_SIGNED_RECEIPT = 165;
|
|
enum CMS_R_NOT_ENCRYPTED_DATA = 122;
|
|
enum CMS_R_NOT_KEK = 123;
|
|
enum CMS_R_NOT_KEY_TRANSPORT = 124;
|
|
enum CMS_R_NOT_PWRI = 177;
|
|
enum CMS_R_NOT_SUPPORTED_FOR_THIS_KEY_TYPE = 125;
|
|
enum CMS_R_NO_CIPHER = 126;
|
|
enum CMS_R_NO_CONTENT = 127;
|
|
enum CMS_R_NO_CONTENT_TYPE = 173;
|
|
enum CMS_R_NO_DEFAULT_DIGEST = 128;
|
|
enum CMS_R_NO_DIGEST_SET = 129;
|
|
enum CMS_R_NO_KEY = 130;
|
|
enum CMS_R_NO_KEY_OR_CERT = 174;
|
|
enum CMS_R_NO_MATCHING_DIGEST = 131;
|
|
enum CMS_R_NO_MATCHING_RECIPIENT = 132;
|
|
enum CMS_R_NO_MATCHING_SIGNATURE = 166;
|
|
enum CMS_R_NO_MSGSIGDIGEST = 167;
|
|
enum CMS_R_NO_PASSWORD = 178;
|
|
enum CMS_R_NO_PRIVATE_KEY = 133;
|
|
enum CMS_R_NO_PUBLIC_KEY = 134;
|
|
enum CMS_R_NO_RECEIPT_REQUEST = 168;
|
|
enum CMS_R_NO_SIGNERS = 135;
|
|
enum CMS_R_PRIVATE_KEY_DOES_NOT_MATCH_CERTIFICATE = 136;
|
|
enum CMS_R_RECEIPT_DECODE_ERROR = 169;
|
|
enum CMS_R_RECIPIENT_ERROR = 137;
|
|
enum CMS_R_SIGNER_CERTIFICATE_NOT_FOUND = 138;
|
|
enum CMS_R_SIGNFINAL_ERROR = 139;
|
|
enum CMS_R_SMIME_TEXT_ERROR = 140;
|
|
enum CMS_R_STORE_INIT_ERROR = 141;
|
|
enum CMS_R_TYPE_NOT_COMPRESSED_DATA = 142;
|
|
enum CMS_R_TYPE_NOT_DATA = 143;
|
|
enum CMS_R_TYPE_NOT_DIGESTED_DATA = 144;
|
|
enum CMS_R_TYPE_NOT_ENCRYPTED_DATA = 145;
|
|
enum CMS_R_TYPE_NOT_ENVELOPED_DATA = 146;
|
|
enum CMS_R_UNABLE_TO_FINALIZE_CONTEXT = 147;
|
|
enum CMS_R_UNKNOWN_CIPHER = 148;
|
|
enum CMS_R_UNKNOWN_DIGEST_ALGORIHM = 149;
|
|
enum CMS_R_UNKNOWN_ID = 150;
|
|
enum CMS_R_UNSUPPORTED_COMPRESSION_ALGORITHM = 151;
|
|
enum CMS_R_UNSUPPORTED_CONTENT_TYPE = 152;
|
|
enum CMS_R_UNSUPPORTED_KEK_ALGORITHM = 153;
|
|
enum CMS_R_UNSUPPORTED_KEY_ENCRYPTION_ALGORITHM = 179;
|
|
enum CMS_R_UNSUPPORTED_RECIPIENT_TYPE = 154;
|
|
enum CMS_R_UNSUPPORTED_RECPIENTINFO_TYPE = 155;
|
|
enum CMS_R_UNSUPPORTED_TYPE = 156;
|
|
enum CMS_R_UNWRAP_ERROR = 157;
|
|
enum CMS_R_UNWRAP_FAILURE = 180;
|
|
enum CMS_R_VERIFICATION_FAILURE = 158;
|
|
enum CMS_R_WRAP_ERROR = 159;
|