/* crypto/x509/x509.h */ /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) * All rights reserved. * * This package is an SSL implementation written * by Eric Young (eay@cryptsoft.com). * The implementation was written so as to conform with Netscapes SSL. * * This library is free for commercial and non-commercial use as long as * the following conditions are aheared to. The following conditions * apply to all code found in this distribution, be it the RC4, RSA, * lhash, DES, etc., code; not just the SSL code. The SSL documentation * included with this distribution is covered by the same copyright terms * except that the holder is Tim Hudson (tjh@cryptsoft.com). * * Copyright remains Eric Young's, and as such any Copyright notices in * the code are not to be removed. * If this package is used in a product, Eric Young should be given attribution * as the author of the parts of the library used. * This can be in the form of a textual message at program startup or * in documentation (online or textual) provided with the package. * * 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 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 acknowledgement: * "This product includes cryptographic software written by * Eric Young (eay@cryptsoft.com)" * The word 'cryptographic' can be left out if the rouines from the library * being used are not cryptographic related :-). * 4. If you include any Windows specific code (or a derivative thereof) from * the apps directory (application code) you must include an acknowledgement: * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" * * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND * ANY EXPRESS 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 AUTHOR OR 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. * * The licence and distribution terms for any publically available version or * derivative of this code cannot be changed. i.e. this code cannot simply be * copied and put under another distribution licence * [including the GNU Public Licence.] */ /* ==================================================================== * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED. * ECDH support in OpenSSL originally developed by * SUN MICROSYSTEMS, INC., and contributed to the OpenSSL project. */ module deimos.openssl.x509; import deimos.openssl._d_util; import core.stdc.time; import deimos.openssl.x509v3; // Needed for GENERAL_NAME. public import deimos.openssl.e_os2; public import deimos.openssl.symhacks; version(OPENSSL_NO_BUFFER) {} else { public import deimos.openssl.buffer; } version(OPENSSL_NO_EVP) {} else { public import deimos.openssl.evp; } version(OPENSSL_NO_BIO) {} else { public import deimos.openssl.bio; } public import deimos.openssl.stack; public import deimos.openssl.asn1; public import deimos.openssl.safestack; version(OPENSSL_NO_EC) {} else { public import deimos.openssl.ec; } version(OPENSSL_NO_ECDSA) {} else { public import deimos.openssl.ecdsa; } version(OPENSSL_NO_ECDH) {} else { public import deimos.openssl.ecdh; } version(OPENSSL_NO_DEPRECATED) {} else { version(OPENSSL_NO_RSA) {} else { public import deimos.openssl.rsa; } version(OPENSSL_NO_DSA) {} else { public import deimos.openssl.dsa; } version(OPENSSL_NO_DH) {} else { public import deimos.openssl.dh; } } version(OPENSSL_NO_SHA) {} else { public import deimos.openssl.sha; } public import deimos.openssl.ossl_typ; extern (C): nothrow: //#ifdef OPENSSL_SYS_WIN32 ///* Under Win32 these are defined in wincrypt.h */ //#undef X509_NAME //#undef X509_CERT_PAIR //#undef X509_EXTENSIONS //#endif enum X509_FILETYPE_PEM = 1; enum X509_FILETYPE_ASN1 = 2; enum X509_FILETYPE_DEFAULT = 3; enum X509v3_KU_DIGITAL_SIGNATURE = 0x0080; enum X509v3_KU_NON_REPUDIATION = 0x0040; enum X509v3_KU_KEY_ENCIPHERMENT = 0x0020; enum X509v3_KU_DATA_ENCIPHERMENT = 0x0010; enum X509v3_KU_KEY_AGREEMENT = 0x0008; enum X509v3_KU_KEY_CERT_SIGN = 0x0004; enum X509v3_KU_CRL_SIGN = 0x0002; enum X509v3_KU_ENCIPHER_ONLY = 0x0001; enum X509v3_KU_DECIPHER_ONLY = 0x8000; enum X509v3_KU_UNDEF = 0xffff; struct X509_objects_st { int nid; ExternC!(int function()) a2i; ExternC!(int function()) i2a; } alias X509_objects_st X509_OBJECTS; struct X509_algor_st { ASN1_OBJECT* algorithm; ASN1_TYPE* parameter; } /* X509_ALGOR */; mixin DECLARE_ASN1_SET_OF!(X509_ALGOR); alias STACK_OF!(X509_ALGOR) X509_ALGORS; struct X509_val_st { ASN1_TIME* notBefore; ASN1_TIME* notAfter; } alias X509_val_st X509_VAL; struct X509_pubkey_st { X509_ALGOR* algor; ASN1_BIT_STRING* public_key; EVP_PKEY* pkey; }; struct X509_sig_st { X509_ALGOR* algor; ASN1_OCTET_STRING* digest; } alias X509_sig_st X509_SIG; struct X509_name_entry_st { ASN1_OBJECT* object; ASN1_STRING* value; int set; int size; /* temp variable */ } alias X509_name_entry_st X509_NAME_ENTRY; /+mixin DECLARE_STACK_OF!(X509_NAME_ENTRY);+/ mixin DECLARE_ASN1_SET_OF!(X509_NAME_ENTRY); /* we always keep X509_NAMEs in 2 forms. */ struct X509_name_st { STACK_OF!(X509_NAME_ENTRY) *entries; int modified; /* true if 'bytes' needs to be built */ version(OPENSSL_NO_BUFFER) { char* bytes; } else { BUF_MEM* bytes; } /* c_ulong hash; Keep the hash around for lookups */ ubyte* canon_enc; int canon_enclen; } /* X509_NAME */; /+mixin DECLARE_STACK_OF!(X509_NAME);+/ enum X509_EX_V_NETSCAPE_HACK = 0x8000; enum X509_EX_V_INIT = 0x0001; struct X509_extension_st { ASN1_OBJECT* object; ASN1_BOOLEAN critical; ASN1_OCTET_STRING* value; } alias X509_extension_st X509_EXTENSION; alias STACK_OF!(X509_EXTENSION) X509_EXTENSIONS; /+mixin DECLARE_STACK_OF!(X509_EXTENSION);+/ mixin DECLARE_ASN1_SET_OF!(X509_EXTENSION); /* a sequence of these are used */ struct x509_attributes_st { ASN1_OBJECT* object; int single; /* 0 for a set, 1 for a single item (which is wrong) */ union value_ { char* ptr; /* 0 */ STACK_OF!(ASN1_TYPE) *set; /* 1 */ ASN1_TYPE* single; } value_ value; } alias x509_attributes_st X509_ATTRIBUTE; /+mixin DECLARE_STACK_OF!(X509_ATTRIBUTE);+/ mixin DECLARE_ASN1_SET_OF!(X509_ATTRIBUTE); struct X509_req_info_st { ASN1_ENCODING enc; ASN1_INTEGER* version_; X509_NAME* subject; X509_PUBKEY* pubkey; /* d=2 hl=2 l= 0 cons: cont: 00 */ STACK_OF!(X509_ATTRIBUTE) *attributes; /* [ 0 ] */ } alias X509_req_info_st X509_REQ_INFO; struct X509_req_st { X509_REQ_INFO* req_info; X509_ALGOR* sig_alg; ASN1_BIT_STRING* signature; int references; } alias X509_req_st X509_REQ; struct x509_cinf_st { ASN1_INTEGER* version_; /* [ 0 ] default of v1 */ ASN1_INTEGER* serialNumber; X509_ALGOR* signature; X509_NAME* issuer; X509_VAL* validity; X509_NAME* subject; X509_PUBKEY* key; ASN1_BIT_STRING* issuerUID; /* [ 1 ] optional in v2 */ ASN1_BIT_STRING* subjectUID; /* [ 2 ] optional in v2 */ STACK_OF!(X509_EXTENSION) *extensions; /* [ 3 ] optional in v3 */ ASN1_ENCODING enc; } alias x509_cinf_st X509_CINF; /* This stuff is certificate "auxiliary info" * it contains details which are useful in certificate * stores and databases. When used this is tagged onto * the end of the certificate itself */ struct x509_cert_aux_st { STACK_OF!(ASN1_OBJECT) *trust; /* trusted uses */ STACK_OF!(ASN1_OBJECT) *reject; /* rejected uses */ ASN1_UTF8STRING* alias_; /* "friendly name" */ ASN1_OCTET_STRING* keyid; /* key id of private key */ STACK_OF!(X509_ALGOR) *other; /* other unspecified info */ } alias x509_cert_aux_st X509_CERT_AUX; struct x509_st { X509_CINF* cert_info; X509_ALGOR* sig_alg; ASN1_BIT_STRING* signature; int valid; int references; char* name; CRYPTO_EX_DATA ex_data; /* These contain copies of various extension values */ c_long ex_pathlen; c_long ex_pcpathlen; c_ulong ex_flags; c_ulong ex_kusage; c_ulong ex_xkusage; c_ulong ex_nscert; ASN1_OCTET_STRING* skid; AUTHORITY_KEYID* akid; X509_POLICY_CACHE* policy_cache; STACK_OF!(DIST_POINT) *crldp; STACK_OF!(GENERAL_NAME) *altname; NAME_CONSTRAINTS* nc; version(OPENSSL_NO_RFC3779) {} else { STACK_OF!(IPAddressFamily) *rfc3779_addr; ASIdentifiers_st* rfc3779_asid; } version(OPENSSL_NO_SHA) {} else { ubyte[SHA_DIGEST_LENGTH] sha1_hash; } X509_CERT_AUX* aux; } /* X509 */; /+mixin DECLARE_STACK_OF!(X509);+/ mixin DECLARE_ASN1_SET_OF!(X509); /* This is used for a table of trust checking functions */ struct x509_trust_st { int trust; int flags; ExternC!(int function(x509_trust_st*, X509*, int)) check_trust; char* name; int arg1; void* arg2; } alias x509_trust_st X509_TRUST; /+mixin DECLARE_STACK_OF!(X509_TRUST);+/ struct x509_cert_pair_st { X509* forward; X509* reverse; } alias x509_cert_pair_st X509_CERT_PAIR; /* standard trust ids */ enum X509_TRUST_DEFAULT = -1; /* Only valid in purpose settings */ enum X509_TRUST_COMPAT = 1; enum X509_TRUST_SSL_CLIENT = 2; enum X509_TRUST_SSL_SERVER = 3; enum X509_TRUST_EMAIL = 4; enum X509_TRUST_OBJECT_SIGN = 5; enum X509_TRUST_OCSP_SIGN = 6; enum X509_TRUST_OCSP_REQUEST = 7; enum X509_TRUST_TSA = 8; /* Keep these up to date! */ enum X509_TRUST_MIN = 1; enum X509_TRUST_MAX = 8; /* trust_flags values */ enum X509_TRUST_DYNAMIC = 1; enum X509_TRUST_DYNAMIC_NAME = 2; /* check_trust return codes */ enum X509_TRUST_TRUSTED = 1; enum X509_TRUST_REJECTED = 2; enum X509_TRUST_UNTRUSTED = 3; /* Flags for X509_print_ex() */ enum X509_FLAG_COMPAT = 0; enum X509_FLAG_NO_HEADER = 1; enum X509_FLAG_NO_VERSION = (1L << 1); enum X509_FLAG_NO_SERIAL = (1L << 2); enum X509_FLAG_NO_SIGNAME = (1L << 3); enum X509_FLAG_NO_ISSUER = (1L << 4); enum X509_FLAG_NO_VALIDITY = (1L << 5); enum X509_FLAG_NO_SUBJECT = (1L << 6); enum X509_FLAG_NO_PUBKEY = (1L << 7); enum X509_FLAG_NO_EXTENSIONS = (1L << 8); enum X509_FLAG_NO_SIGDUMP = (1L << 9); enum X509_FLAG_NO_AUX = (1L << 10); enum X509_FLAG_NO_ATTRIBUTES = (1L << 11); /* Flags specific to X509_NAME_print_ex() */ /* The field separator information */ enum XN_FLAG_SEP_MASK = (0xf << 16); enum XN_FLAG_COMPAT = 0; /* Traditional SSLeay: use old X509_NAME_print */ enum XN_FLAG_SEP_COMMA_PLUS = (1 << 16); /* RFC2253 ,+ */ enum XN_FLAG_SEP_CPLUS_SPC = (2 << 16); /*,+ spaced: more readable */ enum XN_FLAG_SEP_SPLUS_SPC = (3 << 16); /* ;+ spaced */ enum XN_FLAG_SEP_MULTILINE = (4 << 16); /* One line per field */ enum XN_FLAG_DN_REV = (1 << 20); /* Reverse DN order */ /* How the field name is shown */ enum XN_FLAG_FN_MASK = (0x3 << 21); enum XN_FLAG_FN_SN = 0; /* Object short name */ enum XN_FLAG_FN_LN = (1 << 21); /* Object long name */ enum XN_FLAG_FN_OID = (2 << 21); /* Always use OIDs */ enum XN_FLAG_FN_NONE = (3 << 21); /* No field names */ enum XN_FLAG_SPC_EQ = (1 << 23); /* Put spaces round '=' */ /* This determines if we dump fields we don't recognise: * RFC2253 requires this. */ enum XN_FLAG_DUMP_UNKNOWN_FIELDS = (1 << 24); enum XN_FLAG_FN_ALIGN = (1 << 25); /* Align field names to 20 characters */ /* Complete set of RFC2253 flags */ enum XN_FLAG_RFC2253 = (ASN1_STRFLGS_RFC2253 | XN_FLAG_SEP_COMMA_PLUS | XN_FLAG_DN_REV | XN_FLAG_FN_SN | XN_FLAG_DUMP_UNKNOWN_FIELDS); /* readable oneline form */ enum XN_FLAG_ONELINE = (ASN1_STRFLGS_RFC2253 | ASN1_STRFLGS_ESC_QUOTE | XN_FLAG_SEP_CPLUS_SPC | XN_FLAG_SPC_EQ | XN_FLAG_FN_SN); /* readable multiline form */ enum XN_FLAG_MULTILINE = (ASN1_STRFLGS_ESC_CTRL | ASN1_STRFLGS_ESC_MSB | XN_FLAG_SEP_MULTILINE | XN_FLAG_SPC_EQ | XN_FLAG_FN_LN | XN_FLAG_FN_ALIGN); struct x509_revoked_st { ASN1_INTEGER* serialNumber; ASN1_TIME* revocationDate; STACK_OF!(X509_EXTENSION) /* optional */ *extensions; /* Set up if indirect CRL */ STACK_OF!(GENERAL_NAME) *issuer; /* Revocation reason */ int reason; int sequence; /* load sequence */ }; /+mixin DECLARE_STACK_OF!(X509_REVOKED);+/ mixin DECLARE_ASN1_SET_OF!(X509_REVOKED); struct X509_crl_info_st { ASN1_INTEGER* version_; X509_ALGOR* sig_alg; X509_NAME* issuer; ASN1_TIME* lastUpdate; ASN1_TIME* nextUpdate; STACK_OF!(X509_REVOKED) *revoked; STACK_OF!(X509_EXTENSION) /* [0] */ *extensions; ASN1_ENCODING enc; } alias X509_crl_info_st X509_CRL_INFO; struct X509_crl_st { /* actual signature */ X509_CRL_INFO* crl; X509_ALGOR* sig_alg; ASN1_BIT_STRING* signature; int references; int flags; /* Copies of various extensions */ AUTHORITY_KEYID* akid; ISSUING_DIST_POINT* idp; /* Convenient breakdown of IDP */ int idp_flags; int idp_reasons; /* CRL and base CRL numbers for delta processing */ ASN1_INTEGER* crl_number; ASN1_INTEGER* base_crl_number; version(OPENSSL_NO_SHA) {} else { ubyte[SHA_DIGEST_LENGTH] sha1_hash; } STACK_OF!(GENERAL_NAMES) *issuers; const(X509_CRL_METHOD)* meth; void* meth_data; } /* X509_CRL */; /+mixin DECLARE_STACK_OF!(X509_CRL);+/ mixin DECLARE_ASN1_SET_OF!(X509_CRL); struct private_key_st { int version_; /* The PKCS#8 data types */ X509_ALGOR* enc_algor; ASN1_OCTET_STRING* enc_pkey; /* encrypted pub key */ /* When decrypted, the following will not be NULL */ EVP_PKEY* dec_pkey; /* used to encrypt and decrypt */ int key_length; char* key_data; int key_free; /* true if we should auto free key_data */ /* expanded version of 'enc_algor' */ EVP_CIPHER_INFO cipher; int references; } alias private_key_st X509_PKEY; version(OPENSSL_NO_EVP) {} else { struct X509_info_st { X509* x509; X509_CRL* crl; X509_PKEY* x_pkey; EVP_CIPHER_INFO enc_cipher; int enc_len; char* enc_data; int references; } alias X509_info_st X509_INFO; /+mixin DECLARE_STACK_OF!(X509_INFO);+/ } /* The next 2 structures and their 8 routines were sent to me by * Pat Richard and are used to manipulate * Netscapes spki structures - useful if you are writing a CA web page */ struct Netscape_spkac_st { X509_PUBKEY* pubkey; ASN1_IA5STRING* challenge; /* challenge sent in atlas >= PR2 */ } alias Netscape_spkac_st NETSCAPE_SPKAC; struct Netscape_spki_st { NETSCAPE_SPKAC* spkac; /* signed public key and challenge */ X509_ALGOR* sig_algor; ASN1_BIT_STRING* signature; } alias Netscape_spki_st NETSCAPE_SPKI; /* Netscape certificate sequence structure */ struct Netscape_certificate_sequence { ASN1_OBJECT* type; STACK_OF!(X509) *certs; } alias Netscape_certificate_sequence NETSCAPE_CERT_SEQUENCE; /* Unused (and iv length is wrong) struct CBCParameter_st { ubyte[8] iv; } alias CBCParameter_st CBC_PARAM; */ /* Password based encryption structure */ struct PBEPARAM_st { ASN1_OCTET_STRING* salt; ASN1_INTEGER* iter; } alias PBEPARAM_st PBEPARAM; /* Password based encryption V2 structures */ struct PBE2PARAM_st { X509_ALGOR* keyfunc; X509_ALGOR* encryption; } alias PBE2PARAM_st PBE2PARAM; struct PBKDF2PARAM_st { ASN1_TYPE* salt; /* Usually OCTET STRING but could be anything */ ASN1_INTEGER* iter; ASN1_INTEGER* keylength; X509_ALGOR* prf; } alias PBKDF2PARAM_st PBKDF2PARAM; /* PKCS#8 private key info structure */ struct pkcs8_priv_key_info_st { int broken; /* Flag for various broken formats */ enum PKCS8_OK = 0; enum PKCS8_NO_OCTET = 1; enum PKCS8_EMBEDDED_PARAM = 2; enum PKCS8_NS_DB = 3; enum PKCS8_NEG_PRIVKEY = 4; ASN1_INTEGER* version_; X509_ALGOR* pkeyalg; ASN1_TYPE* pkey; /* Should be OCTET STRING but some are broken */ STACK_OF!(X509_ATTRIBUTE) *attributes; }; public import deimos.openssl.x509_vfy; public import deimos.openssl.pkcs7; extern (C): nothrow: enum X509_EXT_PACK_UNKNOWN = 1; enum X509_EXT_PACK_STRING = 2; auto X509_get_version()(x509_st* x) { return ASN1_INTEGER_get(x.cert_info.version_); } /* auto X509_get_serialNumber()(x509_st* x) { return (x.cert_info.serialNumber); } */ auto X509_get_notBefore()(x509_st* x) { return (x.cert_info.validity.notBefore); } auto X509_get_notAfter()(x509_st* x) { return (x.cert_info.validity.notAfter); } alias X509_get_pubkey X509_extract_key; auto X509_REQ_get_version()(x509_st* x) { return ASN1_INTEGER_get(x.req_info.version_); } auto X509_REQ_get_subject_name()(x509_st* x) { return (x.req_info.subject); } alias X509_REQ_get_pubkey X509_REQ_extract_key; alias X509_NAME_cmp X509_name_cmp; auto X509_get_signature_type()(x509_st* x) { return EVP_PKEY_type(OBJ_obj2nid(x.sig_alg.algorithm)); } auto X509_CRL_get_version()(x509_st* x) { return ASN1_INTEGER_get(x.crl.version_); } auto X509_CRL_get_lastUpdate()(x509_st* x) { return (x.crl.lastUpdate); } auto X509_CRL_get_nextUpdate()(x509_st* x) { return (x.crl.nextUpdate); } auto X509_CRL_get_issuer()(x509_st* x) { return (x.crl.issuer); } auto X509_CRL_get_REVOKED()(x509_st* x) { return (x.crl.revoked); } void X509_CRL_set_default_method(const(X509_CRL_METHOD)* meth); X509_CRL_METHOD* X509_CRL_METHOD_new( ExternC!(int function(X509_CRL* crl)) crl_init, ExternC!(int function(X509_CRL* crl)) crl_free, ExternC!(int function(X509_CRL* crl, X509_REVOKED** ret, ASN1_INTEGER* ser, X509_NAME* issuer)) crl_lookup, ExternC!(int function(X509_CRL* crl, EVP_PKEY* pk)) crl_verify); void X509_CRL_METHOD_free(X509_CRL_METHOD* m); void X509_CRL_set_meth_data(X509_CRL* crl, void* dat); void* X509_CRL_get_meth_data(X509_CRL* crl); /* This one is only used so that a binary form can output, as in * i2d_X509_NAME(X509_get_X509_PUBKEY(x),&buf) */ auto X509_get_X509_PUBKEY()(x509_st* x) { return x.cert_info.key; } const(char)* X509_verify_cert_error_string(c_long n); version(OPENSSL_NO_EVP) {} else { int X509_verify(X509* a, EVP_PKEY* r); int X509_REQ_verify(X509_REQ* a, EVP_PKEY* r); int X509_CRL_verify(X509_CRL* a, EVP_PKEY* r); int NETSCAPE_SPKI_verify(NETSCAPE_SPKI* a, EVP_PKEY* r); NETSCAPE_SPKI* NETSCAPE_SPKI_b64_decode(const(char)* str, int len); char* NETSCAPE_SPKI_b64_encode(NETSCAPE_SPKI* x); EVP_PKEY* NETSCAPE_SPKI_get_pubkey(NETSCAPE_SPKI* x); int NETSCAPE_SPKI_set_pubkey(NETSCAPE_SPKI* x, EVP_PKEY* pkey); int NETSCAPE_SPKI_print(BIO* out_, NETSCAPE_SPKI* spki); int X509_signature_dump(BIO *bp,const ASN1_STRING *sig, int indent); int X509_signature_print(BIO* bp,X509_ALGOR* alg, ASN1_STRING* sig); int X509_sign(X509* x, EVP_PKEY* pkey, const(EVP_MD)* md); int X509_sign_ctx(X509 *x, EVP_MD_CTX *ctx); int X509_REQ_sign(X509_REQ* x, EVP_PKEY* pkey, const(EVP_MD)* md); int X509_REQ_sign_ctx(X509_REQ *x, EVP_MD_CTX *ctx); int X509_CRL_sign(X509_CRL* x, EVP_PKEY* pkey, const(EVP_MD)* md); int X509_CRL_sign_ctx(X509_CRL *x, EVP_MD_CTX *ctx); int NETSCAPE_SPKI_sign(NETSCAPE_SPKI* x, EVP_PKEY* pkey, const(EVP_MD)* md); int X509_pubkey_digest(const(X509)* data,const(EVP_MD)* type, ubyte* md, uint* len); int X509_digest(const(X509)* data,const(EVP_MD)* type, ubyte* md, uint* len); int X509_CRL_digest(const(X509_CRL)* data,const(EVP_MD)* type, ubyte* md, uint* len); int X509_REQ_digest(const(X509_REQ)* data,const(EVP_MD)* type, ubyte* md, uint* len); int X509_NAME_digest(const(X509_NAME)* data,const(EVP_MD)* type, ubyte* md, uint* len); } version(OPENSSL_NO_FP_API) {} else { X509* d2i_X509_fp(FILE* fp, X509** x509); int i2d_X509_fp(FILE* fp,X509* x509); X509_CRL* d2i_X509_CRL_fp(FILE* fp,X509_CRL** crl); int i2d_X509_CRL_fp(FILE* fp,X509_CRL* crl); X509_REQ* d2i_X509_REQ_fp(FILE* fp,X509_REQ** req); int i2d_X509_REQ_fp(FILE* fp,X509_REQ* req); version(OPENSSL_NO_RSA) {} else { RSA* d2i_RSAPrivateKey_fp(FILE* fp,RSA** rsa); int i2d_RSAPrivateKey_fp(FILE* fp,RSA* rsa); RSA* d2i_RSAPublicKey_fp(FILE* fp,RSA** rsa); int i2d_RSAPublicKey_fp(FILE* fp,RSA* rsa); RSA* d2i_RSA_PUBKEY_fp(FILE* fp,RSA** rsa); int i2d_RSA_PUBKEY_fp(FILE* fp,RSA* rsa); } version(OPENSSL_NO_DSA) {} else { DSA* d2i_DSA_PUBKEY_fp(FILE* fp, DSA** dsa); int i2d_DSA_PUBKEY_fp(FILE* fp, DSA* dsa); DSA* d2i_DSAPrivateKey_fp(FILE* fp, DSA** dsa); int i2d_DSAPrivateKey_fp(FILE* fp, DSA* dsa); } version(OPENSSL_NO_EC) {} else { EC_KEY* d2i_EC_PUBKEY_fp(FILE* fp, EC_KEY** eckey); int i2d_EC_PUBKEY_fp(FILE* fp, EC_KEY* eckey); EC_KEY* d2i_ECPrivateKey_fp(FILE* fp, EC_KEY** eckey); int i2d_ECPrivateKey_fp(FILE* fp, EC_KEY* eckey); } X509_SIG* d2i_PKCS8_fp(FILE* fp,X509_SIG** p8); int i2d_PKCS8_fp(FILE* fp,X509_SIG* p8); PKCS8_PRIV_KEY_INFO* d2i_PKCS8_PRIV_KEY_INFO_fp(FILE* fp, PKCS8_PRIV_KEY_INFO** p8inf); int i2d_PKCS8_PRIV_KEY_INFO_fp(FILE* fp,PKCS8_PRIV_KEY_INFO* p8inf); int i2d_PKCS8PrivateKeyInfo_fp(FILE* fp, EVP_PKEY* key); int i2d_PrivateKey_fp(FILE* fp, EVP_PKEY* pkey); EVP_PKEY* d2i_PrivateKey_fp(FILE* fp, EVP_PKEY** a); int i2d_PUBKEY_fp(FILE* fp, EVP_PKEY* pkey); EVP_PKEY* d2i_PUBKEY_fp(FILE* fp, EVP_PKEY** a); } version(OPENSSL_NO_BIO) {} else { X509* d2i_X509_bio(BIO* bp,X509** x509); int i2d_X509_bio(BIO* bp,X509* x509); X509_CRL* d2i_X509_CRL_bio(BIO* bp,X509_CRL** crl); int i2d_X509_CRL_bio(BIO* bp,X509_CRL* crl); X509_REQ* d2i_X509_REQ_bio(BIO* bp,X509_REQ** req); int i2d_X509_REQ_bio(BIO* bp,X509_REQ* req); version(OPENSSL_NO_RSA) {} else { RSA* d2i_RSAPrivateKey_bio(BIO* bp,RSA** rsa); int i2d_RSAPrivateKey_bio(BIO* bp,RSA* rsa); RSA* d2i_RSAPublicKey_bio(BIO* bp,RSA** rsa); int i2d_RSAPublicKey_bio(BIO* bp,RSA* rsa); RSA* d2i_RSA_PUBKEY_bio(BIO* bp,RSA** rsa); int i2d_RSA_PUBKEY_bio(BIO* bp,RSA* rsa); } version(OPENSSL_NO_DSA) {} else { DSA* d2i_DSA_PUBKEY_bio(BIO* bp, DSA** dsa); int i2d_DSA_PUBKEY_bio(BIO* bp, DSA* dsa); DSA* d2i_DSAPrivateKey_bio(BIO* bp, DSA** dsa); int i2d_DSAPrivateKey_bio(BIO* bp, DSA* dsa); } version(OPENSSL_NO_EC) {} else { EC_KEY* d2i_EC_PUBKEY_bio(BIO* bp, EC_KEY** eckey); int i2d_EC_PUBKEY_bio(BIO* bp, EC_KEY* eckey); EC_KEY* d2i_ECPrivateKey_bio(BIO* bp, EC_KEY** eckey); int i2d_ECPrivateKey_bio(BIO* bp, EC_KEY* eckey); } X509_SIG* d2i_PKCS8_bio(BIO* bp,X509_SIG** p8); int i2d_PKCS8_bio(BIO* bp,X509_SIG* p8); PKCS8_PRIV_KEY_INFO* d2i_PKCS8_PRIV_KEY_INFO_bio(BIO* bp, PKCS8_PRIV_KEY_INFO** p8inf); int i2d_PKCS8_PRIV_KEY_INFO_bio(BIO* bp,PKCS8_PRIV_KEY_INFO* p8inf); int i2d_PKCS8PrivateKeyInfo_bio(BIO* bp, EVP_PKEY* key); int i2d_PrivateKey_bio(BIO* bp, EVP_PKEY* pkey); EVP_PKEY* d2i_PrivateKey_bio(BIO* bp, EVP_PKEY** a); int i2d_PUBKEY_bio(BIO* bp, EVP_PKEY* pkey); EVP_PKEY* d2i_PUBKEY_bio(BIO* bp, EVP_PKEY** a); } X509* X509_dup(X509* x509); X509_ATTRIBUTE* X509_ATTRIBUTE_dup(X509_ATTRIBUTE* xa); X509_EXTENSION* X509_EXTENSION_dup(X509_EXTENSION* ex); X509_CRL* X509_CRL_dup(X509_CRL* crl); X509_REQ* X509_REQ_dup(X509_REQ* req); X509_ALGOR* X509_ALGOR_dup(X509_ALGOR* xn); int X509_ALGOR_set0(X509_ALGOR* alg, ASN1_OBJECT* aobj, int ptype, void* pval); void X509_ALGOR_get0(ASN1_OBJECT** paobj, int* pptype, void** ppval, X509_ALGOR* algor); void X509_ALGOR_set_md(X509_ALGOR *alg, const EVP_MD *md); X509_NAME* X509_NAME_dup(X509_NAME* xn); X509_NAME_ENTRY* X509_NAME_ENTRY_dup(X509_NAME_ENTRY* ne); int X509_cmp_time(const(ASN1_TIME)* s, time_t* t); int X509_cmp_current_time(const(ASN1_TIME)* s); ASN1_TIME* X509_time_adj(ASN1_TIME* s, c_long adj, time_t* t); ASN1_TIME* X509_time_adj_ex(ASN1_TIME* s, int offset_day, c_long offset_sec, time_t* t); ASN1_TIME* X509_gmtime_adj(ASN1_TIME* s, c_long adj); const(char)* X509_get_default_cert_area(); const(char)* X509_get_default_cert_dir(); const(char)* X509_get_default_cert_file(); const(char)* X509_get_default_cert_dir_env(); const(char)* X509_get_default_cert_file_env(); const(char)* X509_get_default_private_dir(); X509_REQ* X509_to_X509_REQ(X509* x, EVP_PKEY* pkey, const(EVP_MD)* md); X509* X509_REQ_to_X509(X509_REQ* r, int days,EVP_PKEY* pkey); mixin(DECLARE_ASN1_FUNCTIONS!"X509_ALGOR"); mixin(DECLARE_ASN1_ENCODE_FUNCTIONS!("X509_ALGORS", "X509_ALGORS", "X509_ALGORS")); mixin(DECLARE_ASN1_FUNCTIONS!"X509_VAL"); mixin(DECLARE_ASN1_FUNCTIONS!"X509_PUBKEY"); int X509_PUBKEY_set(X509_PUBKEY** x, EVP_PKEY* pkey); EVP_PKEY* X509_PUBKEY_get(X509_PUBKEY* key); int X509_get_pubkey_parameters(EVP_PKEY* pkey, STACK_OF!(X509) *chain); int i2d_PUBKEY(EVP_PKEY* a,ubyte** pp); EVP_PKEY* d2i_PUBKEY(EVP_PKEY** a,const(ubyte)** pp, c_long length); version(OPENSSL_NO_RSA) {} else { int i2d_RSA_PUBKEY(RSA* a,ubyte** pp); RSA* d2i_RSA_PUBKEY(RSA** a,const(ubyte)** pp, c_long length); } version(OPENSSL_NO_DSA) {} else { int i2d_DSA_PUBKEY(DSA* a,ubyte** pp); DSA* d2i_DSA_PUBKEY(DSA** a,const(ubyte)** pp, c_long length); } version(OPENSSL_NO_EC) {} else { int i2d_EC_PUBKEY(EC_KEY* a, ubyte** pp); EC_KEY* d2i_EC_PUBKEY(EC_KEY** a, const(ubyte)** pp, c_long length); } mixin(DECLARE_ASN1_FUNCTIONS!"X509_SIG"); mixin(DECLARE_ASN1_FUNCTIONS!"X509_REQ_INFO"); mixin(DECLARE_ASN1_FUNCTIONS!"X509_REQ"); mixin(DECLARE_ASN1_FUNCTIONS!"X509_ATTRIBUTE"); X509_ATTRIBUTE* X509_ATTRIBUTE_create(int nid, int atrtype, void* value); mixin(DECLARE_ASN1_FUNCTIONS!"X509_EXTENSION"); mixin(DECLARE_ASN1_ENCODE_FUNCTIONS!("X509_EXTENSIONS", "X509_EXTENSIONS", "X509_EXTENSIONS")); mixin(DECLARE_ASN1_FUNCTIONS!"X509_NAME_ENTRY"); mixin(DECLARE_ASN1_FUNCTIONS!"X509_NAME"); int X509_NAME_set(X509_NAME** xn, X509_NAME* name); mixin(DECLARE_ASN1_FUNCTIONS!"X509_CINF"); mixin(DECLARE_ASN1_FUNCTIONS!"X509"); mixin(DECLARE_ASN1_FUNCTIONS!"X509_CERT_AUX"); mixin(DECLARE_ASN1_FUNCTIONS!"X509_CERT_PAIR"); int X509_get_ex_new_index(c_long argl, void* argp, CRYPTO_EX_new* new_func, CRYPTO_EX_dup* dup_func, CRYPTO_EX_free* free_func); int X509_set_ex_data(X509* r, int idx, void* arg); void* X509_get_ex_data(X509* r, int idx); int i2d_X509_AUX(X509* a,ubyte** pp); X509* d2i_X509_AUX(X509** a,const(ubyte)** pp,c_long length); int X509_alias_set1(X509* x, ubyte* name, int len); int X509_keyid_set1(X509* x, ubyte* id, int len); ubyte* X509_alias_get0(X509* x, int* len); ubyte* X509_keyid_get0(X509* x, int* len); int function(int, X509*, int) X509_TRUST_set_default(ExternC!(int function(int , X509*, int)) trust); int X509_TRUST_set(int* t, int trust); int X509_add1_trust_object(X509* x, ASN1_OBJECT* obj); int X509_add1_reject_object(X509* x, ASN1_OBJECT* obj); void X509_trust_clear(X509* x); void X509_reject_clear(X509* x); mixin(DECLARE_ASN1_FUNCTIONS!"X509_REVOKED"); mixin(DECLARE_ASN1_FUNCTIONS!"X509_CRL_INFO"); mixin(DECLARE_ASN1_FUNCTIONS!"X509_CRL"); int X509_CRL_add0_revoked(X509_CRL* crl, X509_REVOKED* rev); int X509_CRL_get0_by_serial(X509_CRL* crl, X509_REVOKED** ret, ASN1_INTEGER* serial); int X509_CRL_get0_by_cert(X509_CRL* crl, X509_REVOKED** ret, X509* x); X509_PKEY* X509_PKEY_new(); void X509_PKEY_free(X509_PKEY* a); int i2d_X509_PKEY(X509_PKEY* a,ubyte** pp); X509_PKEY* d2i_X509_PKEY(X509_PKEY** a,const(ubyte)** pp,c_long length); mixin(DECLARE_ASN1_FUNCTIONS!"NETSCAPE_SPKI"); mixin(DECLARE_ASN1_FUNCTIONS!"NETSCAPE_SPKAC"); mixin(DECLARE_ASN1_FUNCTIONS!"NETSCAPE_CERT_SEQUENCE"); version(OPENSSL_NO_EVP) {} else { X509_INFO* X509_INFO_new(); void X509_INFO_free(X509_INFO* a); char* X509_NAME_oneline(X509_NAME* a,char* buf,int size); int ASN1_verify(i2d_of_void* i2d, X509_ALGOR* algor1, ASN1_BIT_STRING* signature,char* data,EVP_PKEY* pkey); int ASN1_digest(i2d_of_void* i2d,const(EVP_MD)* type,char* data, ubyte* md,uint* len); int ASN1_sign(i2d_of_void* i2d, X509_ALGOR* algor1, X509_ALGOR* algor2, ASN1_BIT_STRING* signature, char* data,EVP_PKEY* pkey, const(EVP_MD)* type); int ASN1_item_digest(const(ASN1_ITEM)* it,const(EVP_MD)* type,void* data, ubyte* md,uint* len); int ASN1_item_verify(const(ASN1_ITEM)* it, X509_ALGOR* algor1, ASN1_BIT_STRING* signature,void* data,EVP_PKEY* pkey); int ASN1_item_sign(const(ASN1_ITEM)* it, X509_ALGOR* algor1, X509_ALGOR* algor2, ASN1_BIT_STRING* signature, void* data, EVP_PKEY* pkey, const(EVP_MD)* type); int ASN1_item_sign_ctx(const ASN1_ITEM *it, X509_ALGOR *algor1, X509_ALGOR *algor2, ASN1_BIT_STRING *signature, void *asn, EVP_MD_CTX *ctx); } int X509_set_version(X509* x,c_long version_); int X509_set_serialNumber(X509* x, ASN1_INTEGER* serial); ASN1_INTEGER* X509_get_serialNumber(X509* x); int X509_set_issuer_name(X509* x, X509_NAME* name); X509_NAME* X509_get_issuer_name(X509* a); int X509_set_subject_name(X509* x, X509_NAME* name); X509_NAME* X509_get_subject_name(X509* a); int X509_set_notBefore(X509* x, const(ASN1_TIME)* tm); int X509_set_notAfter(X509* x, const(ASN1_TIME)* tm); int X509_set_pubkey(X509* x, EVP_PKEY* pkey); EVP_PKEY* X509_get_pubkey(X509* x); ASN1_BIT_STRING* X509_get0_pubkey_bitstr(const(X509)* x); int X509_certificate_type(X509* x,EVP_PKEY* pubkey /* optional */); int X509_REQ_set_version(X509_REQ* x,c_long version_); int X509_REQ_set_subject_name(X509_REQ* req,X509_NAME* name); int X509_REQ_set_pubkey(X509_REQ* x, EVP_PKEY* pkey); EVP_PKEY* X509_REQ_get_pubkey(X509_REQ* req); int X509_REQ_extension_nid(int nid); int* X509_REQ_get_extension_nids(); void X509_REQ_set_extension_nids(int* nids); STACK_OF!(X509_EXTENSION) *X509_REQ_get_extensions(X509_REQ* req); int X509_REQ_add_extensions_nid(X509_REQ* req, STACK_OF!(X509_EXTENSION) *exts, int nid); int X509_REQ_add_extensions(X509_REQ* req, STACK_OF!(X509_EXTENSION) *exts); int X509_REQ_get_attr_count(const(X509_REQ)* req); int X509_REQ_get_attr_by_NID(const(X509_REQ)* req, int nid, int lastpos); int X509_REQ_get_attr_by_OBJ(const(X509_REQ)* req, ASN1_OBJECT* obj, int lastpos); X509_ATTRIBUTE* X509_REQ_get_attr(const(X509_REQ)* req, int loc); X509_ATTRIBUTE* X509_REQ_delete_attr(X509_REQ* req, int loc); int X509_REQ_add1_attr(X509_REQ* req, X509_ATTRIBUTE* attr); int X509_REQ_add1_attr_by_OBJ(X509_REQ* req, const(ASN1_OBJECT)* obj, int type, const(ubyte)* bytes, int len); int X509_REQ_add1_attr_by_NID(X509_REQ* req, int nid, int type, const(ubyte)* bytes, int len); int X509_REQ_add1_attr_by_txt(X509_REQ* req, const(char)* attrname, int type, const(ubyte)* bytes, int len); int X509_CRL_set_version(X509_CRL* x, c_long version_); int X509_CRL_set_issuer_name(X509_CRL* x, X509_NAME* name); int X509_CRL_set_lastUpdate(X509_CRL* x, const(ASN1_TIME)* tm); int X509_CRL_set_nextUpdate(X509_CRL* x, const(ASN1_TIME)* tm); int X509_CRL_sort(X509_CRL* crl); int X509_REVOKED_set_serialNumber(X509_REVOKED* x, ASN1_INTEGER* serial); int X509_REVOKED_set_revocationDate(X509_REVOKED* r, ASN1_TIME* tm); int X509_REQ_check_private_key(X509_REQ* x509,EVP_PKEY* pkey); int X509_check_private_key(X509* x509,EVP_PKEY* pkey); int X509_issuer_and_serial_cmp(const(X509)* a, const(X509)* b); c_ulong X509_issuer_and_serial_hash(X509* a); int X509_issuer_name_cmp(const(X509)* a, const(X509)* b); c_ulong X509_issuer_name_hash(X509* a); int X509_subject_name_cmp(const(X509)* a, const(X509)* b); c_ulong X509_subject_name_hash(X509* x); version(OPENSSL_NO_MD5) {} else { c_ulong X509_issuer_name_hash_old(X509* a); c_ulong X509_subject_name_hash_old(X509* x); } int X509_cmp(const(X509)* a, const(X509)* b); int X509_NAME_cmp(const(X509_NAME)* a, const(X509_NAME)* b); c_ulong X509_NAME_hash(X509_NAME* x); c_ulong X509_NAME_hash_old(X509_NAME* x); int X509_CRL_cmp(const(X509_CRL)* a, const(X509_CRL)* b); int X509_CRL_match(const(X509_CRL)* a, const(X509_CRL)* b); version(OPENSSL_NO_FP_API) {} else { int X509_print_ex_fp(FILE* bp,X509* x, c_ulong nmflag, c_ulong cflag); int X509_print_fp(FILE* bp,X509* x); int X509_CRL_print_fp(FILE* bp,X509_CRL* x); int X509_REQ_print_fp(FILE* bp,X509_REQ* req); int X509_NAME_print_ex_fp(FILE* fp, X509_NAME* nm, int indent, c_ulong flags); } version(OPENSSL_NO_BIO) {} else { int X509_NAME_print(BIO* bp, X509_NAME* name, int obase); int X509_NAME_print_ex(BIO* out_, X509_NAME* nm, int indent, c_ulong flags); int X509_print_ex(BIO* bp,X509* x, c_ulong nmflag, c_ulong cflag); int X509_print(BIO* bp,X509* x); int X509_ocspid_print(BIO* bp,X509* x); int X509_CERT_AUX_print(BIO* bp,X509_CERT_AUX* x, int indent); int X509_CRL_print(BIO* bp,X509_CRL* x); int X509_REQ_print_ex(BIO* bp, X509_REQ* x, c_ulong nmflag, c_ulong cflag); int X509_REQ_print(BIO* bp,X509_REQ* req); } int X509_NAME_entry_count(X509_NAME* name); int X509_NAME_get_text_by_NID(X509_NAME* name, int nid, char* buf,int len); int X509_NAME_get_text_by_OBJ(X509_NAME* name, ASN1_OBJECT* obj, char* buf,int len); /* NOTE: you should be passsing -1, not 0 as lastpos. The functions that use * lastpos, search after that position on. */ int X509_NAME_get_index_by_NID(X509_NAME* name,int nid,int lastpos); int X509_NAME_get_index_by_OBJ(X509_NAME* name,ASN1_OBJECT* obj, int lastpos); X509_NAME_ENTRY* X509_NAME_get_entry(X509_NAME* name, int loc); X509_NAME_ENTRY* X509_NAME_delete_entry(X509_NAME* name, int loc); int X509_NAME_add_entry(X509_NAME* name,X509_NAME_ENTRY* ne, int loc, int set); int X509_NAME_add_entry_by_OBJ(X509_NAME* name, ASN1_OBJECT* obj, int type, ubyte* bytes, int len, int loc, int set); int X509_NAME_add_entry_by_NID(X509_NAME* name, int nid, int type, ubyte* bytes, int len, int loc, int set); X509_NAME_ENTRY* X509_NAME_ENTRY_create_by_txt(X509_NAME_ENTRY** ne, const(char)* field, int type, const(ubyte)* bytes, int len); X509_NAME_ENTRY* X509_NAME_ENTRY_create_by_NID(X509_NAME_ENTRY** ne, int nid, int type,ubyte* bytes, int len); int X509_NAME_add_entry_by_txt(X509_NAME* name, const(char)* field, int type, const(ubyte)* bytes, int len, int loc, int set); X509_NAME_ENTRY* X509_NAME_ENTRY_create_by_OBJ(X509_NAME_ENTRY** ne, ASN1_OBJECT* obj, int type,const(ubyte)* bytes, int len); int X509_NAME_ENTRY_set_object(X509_NAME_ENTRY* ne, ASN1_OBJECT* obj); int X509_NAME_ENTRY_set_data(X509_NAME_ENTRY* ne, int type, const(ubyte)* bytes, int len); ASN1_OBJECT* X509_NAME_ENTRY_get_object(X509_NAME_ENTRY* ne); ASN1_STRING* X509_NAME_ENTRY_get_data(X509_NAME_ENTRY* ne); int X509v3_get_ext_count(const STACK_OF!(X509_EXTENSION) *x); int X509v3_get_ext_by_NID(const STACK_OF!(X509_EXTENSION) *x, int nid, int lastpos); int X509v3_get_ext_by_OBJ(const STACK_OF!(X509_EXTENSION) *x, ASN1_OBJECT* obj,int lastpos); int X509v3_get_ext_by_critical(const STACK_OF!(X509_EXTENSION) *x, int crit, int lastpos); X509_EXTENSION* X509v3_get_ext(const STACK_OF!(X509_EXTENSION) *x, int loc); X509_EXTENSION* X509v3_delete_ext(STACK_OF!(X509_EXTENSION) *x, int loc); STACK_OF!(X509_EXTENSION) *X509v3_add_ext(STACK_OF!(X509_EXTENSION) **x, X509_EXTENSION* ex, int loc); int X509_get_ext_count(X509* x); int X509_get_ext_by_NID(X509* x, int nid, int lastpos); int X509_get_ext_by_OBJ(X509* x,ASN1_OBJECT* obj,int lastpos); int X509_get_ext_by_critical(X509* x, int crit, int lastpos); X509_EXTENSION* X509_get_ext(X509* x, int loc); X509_EXTENSION* X509_delete_ext(X509* x, int loc); int X509_add_ext(X509* x, X509_EXTENSION* ex, int loc); void* X509_get_ext_d2i(X509* x, int nid, int* crit, int* idx); int X509_add1_ext_i2d(X509* x, int nid, void* value, int crit, c_ulong flags); int X509_CRL_get_ext_count(X509_CRL* x); int X509_CRL_get_ext_by_NID(X509_CRL* x, int nid, int lastpos); int X509_CRL_get_ext_by_OBJ(X509_CRL* x,ASN1_OBJECT* obj,int lastpos); int X509_CRL_get_ext_by_critical(X509_CRL* x, int crit, int lastpos); X509_EXTENSION* X509_CRL_get_ext(X509_CRL* x, int loc); X509_EXTENSION* X509_CRL_delete_ext(X509_CRL* x, int loc); int X509_CRL_add_ext(X509_CRL* x, X509_EXTENSION* ex, int loc); void* X509_CRL_get_ext_d2i(X509_CRL* x, int nid, int* crit, int* idx); int X509_CRL_add1_ext_i2d(X509_CRL* x, int nid, void* value, int crit, c_ulong flags); int X509_REVOKED_get_ext_count(X509_REVOKED* x); int X509_REVOKED_get_ext_by_NID(X509_REVOKED* x, int nid, int lastpos); int X509_REVOKED_get_ext_by_OBJ(X509_REVOKED* x,ASN1_OBJECT* obj,int lastpos); int X509_REVOKED_get_ext_by_critical(X509_REVOKED* x, int crit, int lastpos); X509_EXTENSION* X509_REVOKED_get_ext(X509_REVOKED* x, int loc); X509_EXTENSION* X509_REVOKED_delete_ext(X509_REVOKED* x, int loc); int X509_REVOKED_add_ext(X509_REVOKED* x, X509_EXTENSION* ex, int loc); void* X509_REVOKED_get_ext_d2i(X509_REVOKED* x, int nid, int* crit, int* idx); int X509_REVOKED_add1_ext_i2d(X509_REVOKED* x, int nid, void* value, int crit, c_ulong flags); X509_EXTENSION* X509_EXTENSION_create_by_NID(X509_EXTENSION** ex, int nid, int crit, ASN1_OCTET_STRING* data); X509_EXTENSION* X509_EXTENSION_create_by_OBJ(X509_EXTENSION** ex, ASN1_OBJECT* obj,int crit,ASN1_OCTET_STRING* data); int X509_EXTENSION_set_object(X509_EXTENSION* ex,ASN1_OBJECT* obj); int X509_EXTENSION_set_critical(X509_EXTENSION* ex, int crit); int X509_EXTENSION_set_data(X509_EXTENSION* ex, ASN1_OCTET_STRING* data); ASN1_OBJECT* X509_EXTENSION_get_object(X509_EXTENSION* ex); ASN1_OCTET_STRING* X509_EXTENSION_get_data(X509_EXTENSION* ne); int X509_EXTENSION_get_critical(X509_EXTENSION* ex); int X509at_get_attr_count(const STACK_OF!(X509_ATTRIBUTE) *x); int X509at_get_attr_by_NID(const STACK_OF!(X509_ATTRIBUTE) *x, int nid, int lastpos); int X509at_get_attr_by_OBJ(const STACK_OF!(X509_ATTRIBUTE) *sk, ASN1_OBJECT* obj, int lastpos); X509_ATTRIBUTE* X509at_get_attr(const STACK_OF!(X509_ATTRIBUTE) *x, int loc); X509_ATTRIBUTE* X509at_delete_attr(STACK_OF!(X509_ATTRIBUTE) *x, int loc); STACK_OF!(X509_ATTRIBUTE) *X509at_add1_attr(STACK_OF!(X509_ATTRIBUTE) **x, X509_ATTRIBUTE* attr); STACK_OF!(X509_ATTRIBUTE) *X509at_add1_attr_by_OBJ(STACK_OF!(X509_ATTRIBUTE) **x, const(ASN1_OBJECT)* obj, int type, const(ubyte)* bytes, int len); STACK_OF!(X509_ATTRIBUTE) *X509at_add1_attr_by_NID(STACK_OF!(X509_ATTRIBUTE) **x, int nid, int type, const(ubyte)* bytes, int len); STACK_OF!(X509_ATTRIBUTE) *X509at_add1_attr_by_txt(STACK_OF!(X509_ATTRIBUTE) **x, const(char)* attrname, int type, const(ubyte)* bytes, int len); void* X509at_get0_data_by_OBJ(STACK_OF!(X509_ATTRIBUTE) *x, ASN1_OBJECT* obj, int lastpos, int type); X509_ATTRIBUTE* X509_ATTRIBUTE_create_by_NID(X509_ATTRIBUTE** attr, int nid, int atrtype, const(void)* data, int len); X509_ATTRIBUTE* X509_ATTRIBUTE_create_by_OBJ(X509_ATTRIBUTE** attr, const(ASN1_OBJECT)* obj, int atrtype, const(void)* data, int len); X509_ATTRIBUTE* X509_ATTRIBUTE_create_by_txt(X509_ATTRIBUTE** attr, const(char)* atrname, int type, const(ubyte)* bytes, int len); int X509_ATTRIBUTE_set1_object(X509_ATTRIBUTE* attr, const(ASN1_OBJECT)* obj); int X509_ATTRIBUTE_set1_data(X509_ATTRIBUTE* attr, int attrtype, const(void)* data, int len); void* X509_ATTRIBUTE_get0_data(X509_ATTRIBUTE* attr, int idx, int atrtype, void* data); int X509_ATTRIBUTE_count(X509_ATTRIBUTE* attr); ASN1_OBJECT* X509_ATTRIBUTE_get0_object(X509_ATTRIBUTE* attr); ASN1_TYPE* X509_ATTRIBUTE_get0_type(X509_ATTRIBUTE* attr, int idx); int EVP_PKEY_get_attr_count(const(EVP_PKEY)* key); int EVP_PKEY_get_attr_by_NID(const(EVP_PKEY)* key, int nid, int lastpos); int EVP_PKEY_get_attr_by_OBJ(const(EVP_PKEY)* key, ASN1_OBJECT* obj, int lastpos); X509_ATTRIBUTE* EVP_PKEY_get_attr(const(EVP_PKEY)* key, int loc); X509_ATTRIBUTE* EVP_PKEY_delete_attr(EVP_PKEY* key, int loc); int EVP_PKEY_add1_attr(EVP_PKEY* key, X509_ATTRIBUTE* attr); int EVP_PKEY_add1_attr_by_OBJ(EVP_PKEY* key, const(ASN1_OBJECT)* obj, int type, const(ubyte)* bytes, int len); int EVP_PKEY_add1_attr_by_NID(EVP_PKEY* key, int nid, int type, const(ubyte)* bytes, int len); int EVP_PKEY_add1_attr_by_txt(EVP_PKEY* key, const(char)* attrname, int type, const(ubyte)* bytes, int len); int X509_verify_cert(X509_STORE_CTX* ctx); /* lookup a cert from a X509 STACK */ X509* X509_find_by_issuer_and_serial(STACK_OF!(X509) *sk,X509_NAME* name, ASN1_INTEGER* serial); X509* X509_find_by_subject(STACK_OF!(X509) *sk,X509_NAME* name); mixin(DECLARE_ASN1_FUNCTIONS!"PBEPARAM"); mixin(DECLARE_ASN1_FUNCTIONS!"PBE2PARAM"); mixin(DECLARE_ASN1_FUNCTIONS!"PBKDF2PARAM"); int PKCS5_pbe_set0_algor(X509_ALGOR* algor, int alg, int iter, const(ubyte)* salt, int saltlen); X509_ALGOR* PKCS5_pbe_set(int alg, int iter, const(ubyte)* salt, int saltlen); X509_ALGOR* PKCS5_pbe2_set(const(EVP_CIPHER)* cipher, int iter, ubyte* salt, int saltlen); X509_ALGOR* PKCS5_pbe2_set_iv(const(EVP_CIPHER)* cipher, int iter, ubyte* salt, int saltlen, ubyte* aiv, int prf_nid); X509_ALGOR *PKCS5_pbkdf2_set(int iter, ubyte* salt, int saltlen, int prf_nid, int keylen); /* PKCS#8 utilities */ mixin(DECLARE_ASN1_FUNCTIONS!"PKCS8_PRIV_KEY_INFO"); EVP_PKEY* EVP_PKCS82PKEY(PKCS8_PRIV_KEY_INFO* p8); PKCS8_PRIV_KEY_INFO* EVP_PKEY2PKCS8(EVP_PKEY* pkey); PKCS8_PRIV_KEY_INFO* EVP_PKEY2PKCS8_broken(EVP_PKEY* pkey, int broken); PKCS8_PRIV_KEY_INFO* PKCS8_set_broken(PKCS8_PRIV_KEY_INFO* p8, int broken); int PKCS8_pkey_set0(PKCS8_PRIV_KEY_INFO* priv, ASN1_OBJECT* aobj, int version_, int ptype, void* pval, ubyte* penc, int penclen); int PKCS8_pkey_get0(ASN1_OBJECT** ppkalg, const(ubyte)** pk, int* ppklen, X509_ALGOR** pa, PKCS8_PRIV_KEY_INFO* p8); int X509_PUBKEY_set0_param(X509_PUBKEY* pub, ASN1_OBJECT* aobj, int ptype, void* pval, ubyte* penc, int penclen); int X509_PUBKEY_get0_param(ASN1_OBJECT** ppkalg, const(ubyte)** pk, int* ppklen, X509_ALGOR** pa, X509_PUBKEY* pub); int X509_check_trust(X509* x, int id, int flags); int X509_TRUST_get_count(); X509_TRUST* X509_TRUST_get0(int idx); int X509_TRUST_get_by_id(int id); int X509_TRUST_add(int id, int flags, ExternC!(int function(X509_TRUST*, X509*, int)) ck, char* name, int arg1, void* arg2); void X509_TRUST_cleanup(); int X509_TRUST_get_flags(X509_TRUST* xp); char* X509_TRUST_get0_name(X509_TRUST* xp); int X509_TRUST_get_trust(X509_TRUST* xp); /* 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_X509_strings(); /* Error codes for the X509 functions. */ /* Function codes. */ enum X509_F_ADD_CERT_DIR = 100; enum X509_F_BY_FILE_CTRL = 101; enum X509_F_CHECK_POLICY = 145; enum X509_F_DIR_CTRL = 102; enum X509_F_GET_CERT_BY_SUBJECT = 103; enum X509_F_NETSCAPE_SPKI_B64_DECODE = 129; enum X509_F_NETSCAPE_SPKI_B64_ENCODE = 130; enum X509_F_X509AT_ADD1_ATTR = 135; enum X509_F_X509V3_ADD_EXT = 104; enum X509_F_X509_ATTRIBUTE_CREATE_BY_NID = 136; enum X509_F_X509_ATTRIBUTE_CREATE_BY_OBJ = 137; enum X509_F_X509_ATTRIBUTE_CREATE_BY_TXT = 140; enum X509_F_X509_ATTRIBUTE_GET0_DATA = 139; enum X509_F_X509_ATTRIBUTE_SET1_DATA = 138; enum X509_F_X509_CHECK_PRIVATE_KEY = 128; enum X509_F_X509_CRL_PRINT_FP = 147; enum X509_F_X509_EXTENSION_CREATE_BY_NID = 108; enum X509_F_X509_EXTENSION_CREATE_BY_OBJ = 109; enum X509_F_X509_GET_PUBKEY_PARAMETERS = 110; enum X509_F_X509_LOAD_CERT_CRL_FILE = 132; enum X509_F_X509_LOAD_CERT_FILE = 111; enum X509_F_X509_LOAD_CRL_FILE = 112; enum X509_F_X509_NAME_ADD_ENTRY = 113; enum X509_F_X509_NAME_ENTRY_CREATE_BY_NID = 114; enum X509_F_X509_NAME_ENTRY_CREATE_BY_TXT = 131; enum X509_F_X509_NAME_ENTRY_SET_OBJECT = 115; enum X509_F_X509_NAME_ONELINE = 116; enum X509_F_X509_NAME_PRINT = 117; enum X509_F_X509_PRINT_EX_FP = 118; enum X509_F_X509_PUBKEY_GET = 119; enum X509_F_X509_PUBKEY_SET = 120; enum X509_F_X509_REQ_CHECK_PRIVATE_KEY = 144; enum X509_F_X509_REQ_PRINT_EX = 121; enum X509_F_X509_REQ_PRINT_FP = 122; enum X509_F_X509_REQ_TO_X509 = 123; enum X509_F_X509_STORE_ADD_CERT = 124; enum X509_F_X509_STORE_ADD_CRL = 125; enum X509_F_X509_STORE_CTX_GET1_ISSUER = 146; enum X509_F_X509_STORE_CTX_INIT = 143; enum X509_F_X509_STORE_CTX_NEW = 142; enum X509_F_X509_STORE_CTX_PURPOSE_INHERIT = 134; enum X509_F_X509_TO_X509_REQ = 126; enum X509_F_X509_TRUST_ADD = 133; enum X509_F_X509_TRUST_SET = 141; enum X509_F_X509_VERIFY_CERT = 127; /* Reason codes. */ enum X509_R_BAD_X509_FILETYPE = 100; enum X509_R_BASE64_DECODE_ERROR = 118; enum X509_R_CANT_CHECK_DH_KEY = 114; enum X509_R_CERT_ALREADY_IN_HASH_TABLE = 101; enum X509_R_ERR_ASN1_LIB = 102; enum X509_R_INVALID_DIRECTORY = 113; enum X509_R_INVALID_FIELD_NAME = 119; enum X509_R_INVALID_TRUST = 123; enum X509_R_KEY_TYPE_MISMATCH = 115; enum X509_R_KEY_VALUES_MISMATCH = 116; enum X509_R_LOADING_CERT_DIR = 103; enum X509_R_LOADING_DEFAULTS = 104; enum X509_R_METHOD_NOT_SUPPORTED = 124; enum X509_R_NO_CERT_SET_FOR_US_TO_VERIFY = 105; enum X509_R_PUBLIC_KEY_DECODE_ERROR = 125; enum X509_R_PUBLIC_KEY_ENCODE_ERROR = 126; enum X509_R_SHOULD_RETRY = 106; enum X509_R_UNABLE_TO_FIND_PARAMETERS_IN_CHAIN = 107; enum X509_R_UNABLE_TO_GET_CERTS_PUBLIC_KEY = 108; enum X509_R_UNKNOWN_KEY_TYPE = 117; enum X509_R_UNKNOWN_NID = 109; enum X509_R_UNKNOWN_PURPOSE_ID = 121; enum X509_R_UNKNOWN_TRUST_ID = 120; enum X509_R_UNSUPPORTED_ALGORITHM = 111; enum X509_R_WRONG_LOOKUP_TYPE = 112; enum X509_R_WRONG_TYPE = 122;