/** * Windows API header module * * Translated from MinGW Windows headers * * Authors: Stewart Gordon * License: $(LINK2 http://www.boost.org/LICENSE_1_0.txt, Boost License 1.0) * Source: $(DRUNTIMESRC core/sys/windows/_wincrypt.d) */ module core.sys.windows.wincrypt; version (Windows): @system: pragma(lib, "advapi32"); version (ANSI) {} else version = Unicode; import core.sys.windows.w32api, core.sys.windows.winbase, core.sys.windows.windef; /* FIXME: * Types of some constants * Types of macros * Inits of various "size" and "version" members * Why are some #ifdefs commented out? */ const TCHAR[] MS_DEF_PROV = "Microsoft Base Cryptographic Provider v1.0", MS_ENHANCED_PROV = "Microsoft Enhanced Cryptographic Provider v1.0", MS_STRONG_PROV = "Microsoft Strong Cryptographic Provider", MS_DEF_RSA_SIG_PROV = "Microsoft RSA Signature Cryptographic Provider", MS_DEF_RSA_SCHANNEL_PROV = "Microsoft RSA SChannel Cryptographic Provider", MS_DEF_DSS_PROV = "Microsoft Base DSS Cryptographic Provider", MS_DEF_DSS_DH_PROV = "Microsoft Base DSS and Diffie-Hellman Cryptographic Provider", MS_ENH_DSS_DH_PROV = "Microsoft Enhanced DSS and Diffie-Hellman Cryptographic Provider", MS_DEF_DH_SCHANNEL_PROV = "Microsoft DH SChannel Cryptographic Provider", MS_SCARD_PROV = "Microsoft Base Smart Card Crypto Provider"; static if (_WIN32_WINNT > 0x501) { const TCHAR[] MS_ENH_RSA_AES_PROV = "Microsoft Enhanced RSA and AES Cryptographic Provider"; } else static if (_WIN32_WINNT == 0x501) { const TCHAR[] MS_ENH_RSA_AES_PROV = "Microsoft Enhanced RSA and AES Cryptographic Provider (Prototype)"; } ALG_ID GET_ALG_CLASS(ALG_ID x) { return x & 0xE000; } ALG_ID GET_ALG_TYPE (ALG_ID x) { return x & 0x1E00; } ALG_ID GET_ALG_SID (ALG_ID x) { return x & 0x01FF; } enum : ALG_ID { ALG_CLASS_ANY = 0, ALG_CLASS_SIGNATURE = 0x2000, ALG_CLASS_MSG_ENCRYPT = 0x4000, ALG_CLASS_DATA_ENCRYPT = 0x6000, ALG_CLASS_HASH = 0x8000, ALG_CLASS_KEY_EXCHANGE = 0xA000, ALG_CLASS_ALL = 0xE000 } enum : ALG_ID { ALG_TYPE_ANY = 0, ALG_TYPE_DSS = 0x0200, ALG_TYPE_RSA = 0x0400, ALG_TYPE_BLOCK = 0x0600, ALG_TYPE_STREAM = 0x0800, ALG_TYPE_DH = 0x0A00, ALG_TYPE_SECURECHANNEL = 0x0C00 } enum : ALG_ID { ALG_SID_ANY = 0, ALG_SID_RSA_ANY = 0, ALG_SID_RSA_PKCS, ALG_SID_RSA_MSATWORK, ALG_SID_RSA_ENTRUST, ALG_SID_RSA_PGP, // = 4 ALG_SID_DSS_ANY = 0, ALG_SID_DSS_PKCS, ALG_SID_DSS_DMS, // = 2 ALG_SID_DES = 1, ALG_SID_3DES = 3, ALG_SID_DESX, ALG_SID_IDEA, ALG_SID_CAST, ALG_SID_SAFERSK64, ALG_SID_SAFERSK128, ALG_SID_3DES_112, ALG_SID_SKIPJACK, ALG_SID_TEK, ALG_SID_CYLINK_MEK, ALG_SID_RC5, // = 13 ALG_SID_RC2 = 2, ALG_SID_RC4 = 1, ALG_SID_SEAL = 2, ALG_SID_MD2 = 1, ALG_SID_MD4, ALG_SID_MD5, ALG_SID_SHA, ALG_SID_MAC, ALG_SID_RIPEMD, ALG_SID_RIPEMD160, ALG_SID_SSL3SHAMD5, ALG_SID_HMAC, ALG_SID_TLS1PRF, // = 10 ALG_SID_AES_128 = 14, ALG_SID_AES_192, ALG_SID_AES_256, ALG_SID_AES, // = 17 ALG_SID_EXAMPLE = 80 } enum : ALG_ID { CALG_MD2 = ALG_CLASS_HASH | ALG_TYPE_ANY | ALG_SID_MD2, CALG_MD4 = ALG_CLASS_HASH | ALG_TYPE_ANY | ALG_SID_MD4, CALG_MD5 = ALG_CLASS_HASH | ALG_TYPE_ANY | ALG_SID_MD5, CALG_SHA = ALG_CLASS_HASH | ALG_TYPE_ANY | ALG_SID_SHA, CALG_SHA1 = CALG_SHA, CALG_MAC = ALG_CLASS_HASH | ALG_TYPE_ANY | ALG_SID_MAC, CALG_3DES = ALG_CLASS_DATA_ENCRYPT | ALG_TYPE_BLOCK | 3, CALG_CYLINK_MEK = ALG_CLASS_DATA_ENCRYPT | ALG_TYPE_BLOCK | 12, CALG_SKIPJACK = ALG_CLASS_DATA_ENCRYPT | ALG_TYPE_BLOCK | 10, CALG_KEA_KEYX = ALG_CLASS_KEY_EXCHANGE | ALG_TYPE_STREAM | ALG_TYPE_DSS | 4, CALG_RSA_SIGN = ALG_CLASS_SIGNATURE | ALG_TYPE_RSA | ALG_SID_RSA_ANY, CALG_DSS_SIGN = ALG_CLASS_SIGNATURE | ALG_TYPE_DSS | ALG_SID_DSS_ANY, CALG_RSA_KEYX = ALG_CLASS_KEY_EXCHANGE | ALG_TYPE_RSA | ALG_SID_RSA_ANY, CALG_DES = ALG_CLASS_DATA_ENCRYPT | ALG_TYPE_BLOCK | ALG_SID_DES, CALG_RC2 = ALG_CLASS_DATA_ENCRYPT | ALG_TYPE_BLOCK | ALG_SID_RC2, CALG_RC4 = ALG_CLASS_DATA_ENCRYPT | ALG_TYPE_STREAM | ALG_SID_RC4, CALG_SEAL = ALG_CLASS_DATA_ENCRYPT | ALG_TYPE_STREAM | ALG_SID_SEAL, CALG_DH_EPHEM = ALG_CLASS_KEY_EXCHANGE | ALG_TYPE_STREAM | ALG_TYPE_DSS | ALG_SID_DSS_DMS, CALG_DESX = ALG_CLASS_DATA_ENCRYPT | ALG_TYPE_BLOCK | ALG_SID_DESX, // is undefined ALG_CLASS_DHASH in MinGW - presuming typo CALG_TLS1PRF = ALG_CLASS_HASH | ALG_TYPE_ANY | ALG_SID_TLS1PRF, CALG_AES_128 = ALG_CLASS_DATA_ENCRYPT | ALG_TYPE_BLOCK | ALG_SID_AES_128, CALG_AES_192 = ALG_CLASS_DATA_ENCRYPT | ALG_TYPE_BLOCK | ALG_SID_AES_192, CALG_AES_256 = ALG_CLASS_DATA_ENCRYPT | ALG_TYPE_BLOCK | ALG_SID_AES_256, CALG_AES = ALG_CLASS_DATA_ENCRYPT | ALG_TYPE_BLOCK | ALG_SID_AES, } enum { CRYPT_VERIFYCONTEXT = 0xF0000000, } enum { CRYPT_NEWKEYSET = 8, CRYPT_DELETEKEYSET = 16, CRYPT_MACHINE_KEYSET = 32, CRYPT_SILENT = 64, } enum { CRYPT_EXPORTABLE = 1, CRYPT_USER_PROTECTED = 2, CRYPT_CREATE_SALT = 4, CRYPT_UPDATE_KEY = 8, } enum { SIMPLEBLOB = 1, PUBLICKEYBLOB = 6, PRIVATEKEYBLOB = 7, PLAINTEXTKEYBLOB = 8, OPAQUEKEYBLOB = 9, PUBLICKEYBLOBEX = 10, SYMMETRICWRAPKEYBLOB = 11, } enum { AT_KEYEXCHANGE = 1, AT_SIGNATURE = 2, } enum { CRYPT_USERDATA = 1, } enum { PKCS5_PADDING = 1, } enum { CRYPT_MODE_CBC = 1, CRYPT_MODE_ECB = 2, CRYPT_MODE_OFB = 3, CRYPT_MODE_CFB = 4, CRYPT_MODE_CTS = 5, CRYPT_MODE_CBCI = 6, CRYPT_MODE_CFBP = 7, CRYPT_MODE_OFBP = 8, CRYPT_MODE_CBCOFM = 9, CRYPT_MODE_CBCOFMI = 10, } enum { CRYPT_ENCRYPT = 1, CRYPT_DECRYPT = 2, CRYPT_EXPORT = 4, CRYPT_READ = 8, CRYPT_WRITE = 16, CRYPT_MAC = 32, } enum { HP_ALGID = 1, HP_HASHVAL = 2, HP_HASHSIZE = 4, HP_HMAC_INFO = 5, } enum { CRYPT_FAILED = FALSE, CRYPT_SUCCEED = TRUE, } bool RCRYPT_SUCCEEDED(BOOL r) { return r==CRYPT_SUCCEED; } bool RCRYPT_FAILED(BOOL r) { return r==CRYPT_FAILED; } enum { PP_ENUMALGS = 1, PP_ENUMCONTAINERS = 2, PP_IMPTYPE = 3, PP_NAME = 4, PP_VERSION = 5, PP_CONTAINER = 6, PP_CHANGE_PASSWORD = 7, PP_KEYSET_SEC_DESCR = 8, PP_CERTCHAIN = 9, PP_KEY_TYPE_SUBTYPE = 10, PP_PROVTYPE = 16, PP_KEYSTORAGE = 17, PP_APPLI_CERT = 18, PP_SYM_KEYSIZE = 19, PP_SESSION_KEYSIZE = 20, PP_UI_PROMPT = 21, PP_ENUMALGS_EX = 22, PP_ENUMMANDROOTS = 25, PP_ENUMELECTROOTS = 26, PP_KEYSET_TYPE = 27, PP_ADMIN_PIN = 31, PP_KEYEXCHANGE_PIN = 32, PP_SIGNATURE_PIN = 33, PP_SIG_KEYSIZE_INC = 34, PP_KEYX_KEYSIZE_INC = 35, PP_UNIQUE_CONTAINER = 36, PP_SGC_INFO = 37, PP_USE_HARDWARE_RNG = 38, PP_KEYSPEC = 39, PP_ENUMEX_SIGNING_PROT = 40, } enum { CRYPT_FIRST = 1, CRYPT_NEXT = 2, } enum { CRYPT_IMPL_HARDWARE = 1, CRYPT_IMPL_SOFTWARE = 2, CRYPT_IMPL_MIXED = 3, CRYPT_IMPL_UNKNOWN = 4, } enum { PROV_RSA_FULL = 1, PROV_RSA_SIG = 2, PROV_DSS = 3, PROV_FORTEZZA = 4, PROV_MS_MAIL = 5, PROV_SSL = 6, PROV_STT_MER = 7, PROV_STT_ACQ = 8, PROV_STT_BRND = 9, PROV_STT_ROOT = 10, PROV_STT_ISS = 11, PROV_RSA_SCHANNEL = 12, PROV_DSS_DH = 13, PROV_EC_ECDSA_SIG = 14, PROV_EC_ECNRA_SIG = 15, PROV_EC_ECDSA_FULL = 16, PROV_EC_ECNRA_FULL = 17, PROV_DH_SCHANNEL = 18, PROV_SPYRUS_LYNKS = 20, PROV_RNG = 21, PROV_INTEL_SEC = 22, PROV_RSA_AES = 24, MAXUIDLEN = 64, } enum { CUR_BLOB_VERSION = 2, } enum { X509_ASN_ENCODING = 1, PKCS_7_ASN_ENCODING = 65536, } enum { CERT_V1 = 0, CERT_V2 = 1, CERT_V3 = 2, } enum { CERT_E_CHAINING = (-2146762486), CERT_E_CN_NO_MATCH = (-2146762481), CERT_E_EXPIRED = (-2146762495), CERT_E_PURPOSE = (-2146762490), CERT_E_REVOCATION_FAILURE = (-2146762482), CERT_E_REVOKED = (-2146762484), CERT_E_ROLE = (-2146762493), CERT_E_UNTRUSTEDROOT = (-2146762487), CERT_E_UNTRUSTEDTESTROOT = (-2146762483), CERT_E_VALIDITYPERIODNESTING = (-2146762494), CERT_E_WRONG_USAGE = (-2146762480), CERT_E_PATHLENCONST = (-2146762492), CERT_E_CRITICAL = (-2146762491), CERT_E_ISSUERCHAINING = (-2146762489), CERT_E_MALFORMED = (-2146762488), CRYPT_E_REVOCATION_OFFLINE = (-2146885613), CRYPT_E_REVOKED = (-2146885616), TRUST_E_BASIC_CONSTRAINTS = (-2146869223), TRUST_E_CERT_SIGNATURE = (-2146869244), TRUST_E_FAIL = (-2146762485), } enum { CERT_TRUST_NO_ERROR = 0, CERT_TRUST_IS_NOT_TIME_VALID = 1, CERT_TRUST_IS_NOT_TIME_NESTED = 2, CERT_TRUST_IS_REVOKED = 4, CERT_TRUST_IS_NOT_SIGNATURE_VALID = 8, CERT_TRUST_IS_NOT_VALID_FOR_USAGE = 16, CERT_TRUST_IS_UNTRUSTED_ROOT = 32, CERT_TRUST_REVOCATION_STATUS_UNKNOWN = 64, CERT_TRUST_IS_CYCLIC = 128, CERT_TRUST_IS_PARTIAL_CHAIN = 65536, CERT_TRUST_CTL_IS_NOT_TIME_VALID = 131072, CERT_TRUST_CTL_IS_NOT_SIGNATURE_VALID = 262144, CERT_TRUST_CTL_IS_NOT_VALID_FOR_USAGE = 524288, } enum { CERT_TRUST_HAS_EXACT_MATCH_ISSUER = 1, CERT_TRUST_HAS_KEY_MATCH_ISSUER = 2, CERT_TRUST_HAS_NAME_MATCH_ISSUER = 4, CERT_TRUST_IS_SELF_SIGNED = 8, CERT_TRUST_IS_COMPLEX_CHAIN = 65536, } enum { CERT_CHAIN_POLICY_BASE = cast(LPCSTR) 1, CERT_CHAIN_POLICY_AUTHENTICODE = cast(LPCSTR) 2, CERT_CHAIN_POLICY_AUTHENTICODE_TS = cast(LPCSTR) 3, CERT_CHAIN_POLICY_SSL = cast(LPCSTR) 4, CERT_CHAIN_POLICY_BASIC_CONSTRAINTS = cast(LPCSTR) 5, CERT_CHAIN_POLICY_NT_AUTH = cast(LPCSTR) 6, } enum { USAGE_MATCH_TYPE_AND = 0, USAGE_MATCH_TYPE_OR = 1, } enum { CERT_SIMPLE_NAME_STR = 1, CERT_OID_NAME_STR = 2, CERT_X500_NAME_STR = 3, } enum { CERT_NAME_STR_SEMICOLON_FLAG = 1073741824, CERT_NAME_STR_CRLF_FLAG = 134217728, CERT_NAME_STR_NO_PLUS_FLAG = 536870912, CERT_NAME_STR_NO_QUOTING_FLAG = 268435456, CERT_NAME_STR_REVERSE_FLAG = 33554432, CERT_NAME_STR_ENABLE_T61_UNICODE_FLAG = 131072, } enum { CERT_FIND_ANY = 0, CERT_FIND_CERT_ID = 1048576, CERT_FIND_CTL_USAGE = 655360, CERT_FIND_ENHKEY_USAGE = 655360, CERT_FIND_EXISTING = 851968, CERT_FIND_HASH = 65536, CERT_FIND_ISSUER_ATTR = 196612, CERT_FIND_ISSUER_NAME = 131076, CERT_FIND_ISSUER_OF = 786432, CERT_FIND_KEY_IDENTIFIER = 983040, CERT_FIND_KEY_SPEC = 589824, CERT_FIND_MD5_HASH = 262144, CERT_FIND_PROPERTY = 327680, CERT_FIND_PUBLIC_KEY = 393216, CERT_FIND_SHA1_HASH = 65536, CERT_FIND_SIGNATURE_HASH = 917504, CERT_FIND_SUBJECT_ATTR = 196615, CERT_FIND_SUBJECT_CERT = 720896, CERT_FIND_SUBJECT_NAME = 131079, CERT_FIND_SUBJECT_STR_A = 458759, CERT_FIND_SUBJECT_STR_W = 524295, CERT_FIND_ISSUER_STR_A = 458756, CERT_FIND_ISSUER_STR_W = 524292, } enum { CERT_FIND_OR_ENHKEY_USAGE_FLAG = 16, CERT_FIND_OPTIONAL_ENHKEY_USAGE_FLAG = 1, CERT_FIND_NO_ENHKEY_USAGE_FLAG = 8, CERT_FIND_VALID_ENHKEY_USAGE_FLAG = 32, CERT_FIND_EXT_ONLY_ENHKEY_USAGE_FLAG = 2, } enum { CERT_CASE_INSENSITIVE_IS_RDN_ATTRS_FLAG = 2, CERT_UNICODE_IS_RDN_ATTRS_FLAG = 1, CERT_CHAIN_FIND_BY_ISSUER = 1, } enum { CERT_CHAIN_FIND_BY_ISSUER_COMPARE_KEY_FLAG = 1, CERT_CHAIN_FIND_BY_ISSUER_COMPLEX_CHAIN_FLAG = 2, CERT_CHAIN_FIND_BY_ISSUER_CACHE_ONLY_URL_FLAG = 4, CERT_CHAIN_FIND_BY_ISSUER_LOCAL_MACHINE_FLAG = 8, CERT_CHAIN_FIND_BY_ISSUER_NO_KEY_FLAG = 16384, CERT_CHAIN_FIND_BY_ISSUER_CACHE_ONLY_FLAG = 32768, } enum { CERT_STORE_PROV_SYSTEM = 10, CERT_SYSTEM_STORE_LOCAL_MACHINE = 131072, } enum { szOID_PKIX_KP_SERVER_AUTH = "4235600", szOID_SERVER_GATED_CRYPTO = "4235658", szOID_SGC_NETSCAPE = "2.16.840.1.113730.4.1", szOID_PKIX_KP_CLIENT_AUTH = "1.3.6.1.5.5.7.3.2", } enum { CRYPT_NOHASHOID = 0x00000001, CRYPT_NO_SALT = 0x10, CRYPT_PREGEN = 0x40, } enum { CRYPT_RECIPIENT = 0x10, CRYPT_INITIATOR = 0x40, CRYPT_ONLINE = 0x80, CRYPT_SF = 0x100, CRYPT_CREATE_IV = 0x200, CRYPT_KEK = 0x400, CRYPT_DATA_KEY = 0x800, CRYPT_VOLATILE = 0x1000, CRYPT_SGCKEY = 0x2000, } enum { KP_IV = 0x00000001, KP_SALT = 0x00000002, KP_PADDING = 0x00000003, KP_MODE = 0x00000004, KP_MODE_BITS = 0x00000005, KP_PERMISSIONS = 0x00000006, KP_ALGID = 0x00000007, KP_BLOCKLEN = 0x00000008, KP_KEYLEN = 0x00000009, KP_SALT_EX = 0x0000000a, KP_P = 0x0000000b, KP_G = 0x0000000c, KP_Q = 0x0000000d, KP_X = 0x0000000e, KP_Y = 0x0000000f, KP_RA = 0x00000010, KP_RB = 0x00000011, KP_INFO = 0x00000012, KP_EFFECTIVE_KEYLEN = 0x00000013, KP_SCHANNEL_ALG = 0x00000014, KP_PUB_PARAMS = 0x00000027, } enum { CRYPT_FLAG_PCT1 = 0x0001, CRYPT_FLAG_SSL2 = 0x0002, CRYPT_FLAG_SSL3 = 0x0004, CRYPT_FLAG_TLS1 = 0x0008, CRYPT_FLAG_IPSEC = 0x0010, CRYPT_FLAG_SIGNING = 0x0020, } enum { SCHANNEL_MAC_KEY = 0x00000000, SCHANNEL_ENC_KEY = 0x00000001, } enum { INTERNATIONAL_USAGE = 0x00000001, } alias UINT ALG_ID; alias ULONG_PTR HCRYPTPROV, HCRYPTKEY, HCRYPTHASH; alias PVOID HCERTSTORE, HCRYPTMSG, HCERTCHAINENGINE; struct VTableProvStruc { FARPROC FuncVerifyImage; } alias VTableProvStruc* PVTableProvStruc; struct _CRYPTOAPI_BLOB { DWORD cbData; BYTE* pbData; } alias _CRYPTOAPI_BLOB CRYPT_INTEGER_BLOB, CRYPT_UINT_BLOB, CRYPT_OBJID_BLOB, CERT_NAME_BLOB, CERT_RDN_VALUE_BLOB, CERT_BLOB, CRL_BLOB, DATA_BLOB, CRYPT_DATA_BLOB, CRYPT_HASH_BLOB, CRYPT_DIGEST_BLOB, CRYPT_DER_BLOB, CRYPT_ATTR_BLOB; alias _CRYPTOAPI_BLOB* PCRYPT_INTEGER_BLOB, PCRYPT_UINT_BLOB, PCRYPT_OBJID_BLOB, PCERT_NAME_BLOB, PCERT_RDN_VALUE_BLOB, PCERT_BLOB, PCRL_BLOB, PDATA_BLOB, PCRYPT_DATA_BLOB, PCRYPT_HASH_BLOB, PCRYPT_DIGEST_BLOB, PCRYPT_DER_BLOB, PCRYPT_ATTR_BLOB; // not described in SDK; has the same layout as HTTPSPolicyCallbackData struct SSL_EXTRA_CERT_CHAIN_POLICY_PARA { DWORD cbStruct; DWORD dwAuthType; DWORD fdwChecks; LPWSTR pwszServerName; } alias SSL_EXTRA_CERT_CHAIN_POLICY_PARA HTTPSPolicyCallbackData; alias SSL_EXTRA_CERT_CHAIN_POLICY_PARA* PSSL_EXTRA_CERT_CHAIN_POLICY_PARA, PHTTPSPolicyCallbackData; /* #if (_WIN32_WINNT>=0x500) */ struct CERT_CHAIN_POLICY_PARA { DWORD cbSize = CERT_CHAIN_POLICY_PARA.sizeof; DWORD dwFlags; void* pvExtraPolicyPara; } alias CERT_CHAIN_POLICY_PARA* PCERT_CHAIN_POLICY_PARA; struct CERT_CHAIN_POLICY_STATUS { DWORD cbSize = CERT_CHAIN_POLICY_STATUS.sizeof; DWORD dwError; LONG lChainIndex; LONG lElementIndex; void* pvExtraPolicyStatus; } alias CERT_CHAIN_POLICY_STATUS* PCERT_CHAIN_POLICY_STATUS; /* #endif */ struct CRYPT_ALGORITHM_IDENTIFIER { LPSTR pszObjId; CRYPT_OBJID_BLOB Parameters; } alias CRYPT_ALGORITHM_IDENTIFIER* PCRYPT_ALGORITHM_IDENTIFIER; struct CRYPT_BIT_BLOB { DWORD cbData; BYTE* pbData; DWORD cUnusedBits; } alias CRYPT_BIT_BLOB* PCRYPT_BIT_BLOB; struct CERT_PUBLIC_KEY_INFO { CRYPT_ALGORITHM_IDENTIFIER Algorithm; CRYPT_BIT_BLOB PublicKey; } alias CERT_PUBLIC_KEY_INFO* PCERT_PUBLIC_KEY_INFO; struct CERT_EXTENSION { LPSTR pszObjId; BOOL fCritical; CRYPT_OBJID_BLOB Value; } alias CERT_EXTENSION* PCERT_EXTENSION; struct CERT_INFO { DWORD dwVersion; CRYPT_INTEGER_BLOB SerialNumber; CRYPT_ALGORITHM_IDENTIFIER SignatureAlgorithm; CERT_NAME_BLOB Issuer; FILETIME NotBefore; FILETIME NotAfter; CERT_NAME_BLOB Subject; CERT_PUBLIC_KEY_INFO SubjectPublicKeyInfo; CRYPT_BIT_BLOB IssuerUniqueId; CRYPT_BIT_BLOB SubjectUniqueId; DWORD cExtension; PCERT_EXTENSION rgExtension; } alias CERT_INFO* PCERT_INFO; struct CERT_CONTEXT { DWORD dwCertEncodingType; BYTE* pbCertEncoded; DWORD cbCertEncoded; PCERT_INFO pCertInfo; HCERTSTORE hCertStore; } alias CERT_CONTEXT* PCERT_CONTEXT; alias const(CERT_CONTEXT)* PCCERT_CONTEXT; struct CTL_USAGE { DWORD cUsageIdentifier; LPSTR* rgpszUsageIdentifier; } alias CTL_USAGE CERT_ENHKEY_USAGE; alias CTL_USAGE* PCTRL_USAGE, PCERT_ENHKEY_USAGE; struct CERT_USAGE_MATCH { DWORD dwType; CERT_ENHKEY_USAGE Usage; } alias CERT_USAGE_MATCH* PCERT_USAGE_MATCH; /* #if (_WIN32_WINNT>=0x500) */ struct CERT_CHAIN_PARA { DWORD cbSize = CERT_CHAIN_PARA.sizeof; CERT_USAGE_MATCH RequestedUsage; //#if CERT_CHAIN_PARA_HAS_EXTRA_FIELDS CERT_USAGE_MATCH RequestedIssuancePolicy; DWORD dwUrlRetrievalTimeout; BOOL fCheckRevocationFreshnessTime; DWORD dwRevocationFreshnessTime; //#endif } alias CERT_CHAIN_PARA* PCERT_CHAIN_PARA; extern (Windows) alias BOOL function(PCCERT_CONTEXT, void*) PFN_CERT_CHAIN_FIND_BY_ISSUER_CALLBACK; struct CERT_CHAIN_FIND_BY_ISSUER_PARA { DWORD cbSize = CERT_CHAIN_FIND_BY_ISSUER_PARA.sizeof; LPCSTR pszUsageIdentifier; DWORD dwKeySpec; DWORD dwAcquirePrivateKeyFlags; DWORD cIssuer; CERT_NAME_BLOB* rgIssuer; PFN_CERT_CHAIN_FIND_BY_ISSUER_CALLBACK pfnFIndCallback; void* pvFindArg; DWORD* pdwIssuerChainIndex; DWORD* pdwIssuerElementIndex; } alias CERT_CHAIN_FIND_BY_ISSUER_PARA* PCERT_CHAIN_FIND_BY_ISSUER_PARA; /* #endif */ struct CERT_TRUST_STATUS { DWORD dwErrorStatus; DWORD dwInfoStatus; } alias CERT_TRUST_STATUS* PCERT_TRUST_STATUS; struct CRL_ENTRY { CRYPT_INTEGER_BLOB SerialNumber; FILETIME RevocationDate; DWORD cExtension; PCERT_EXTENSION rgExtension; } alias CRL_ENTRY* PCRL_ENTRY; struct CRL_INFO { DWORD dwVersion; CRYPT_ALGORITHM_IDENTIFIER SignatureAlgorithm; CERT_NAME_BLOB Issuer; FILETIME ThisUpdate; FILETIME NextUpdate; DWORD cCRLEntry; PCRL_ENTRY rgCRLEntry; DWORD cExtension; PCERT_EXTENSION rgExtension; } alias CRL_INFO* PCRL_INFO; struct CRL_CONTEXT { DWORD dwCertEncodingType; BYTE* pbCrlEncoded; DWORD cbCrlEncoded; PCRL_INFO pCrlInfo; HCERTSTORE hCertStore; } alias CRL_CONTEXT* PCRL_CONTEXT; alias const(CRL_CONTEXT)* PCCRL_CONTEXT; struct CERT_REVOCATION_CRL_INFO { DWORD cbSize = CERT_REVOCATION_CRL_INFO.sizeof; PCCRL_CONTEXT pBaseCRLContext; PCCRL_CONTEXT pDeltaCRLContext; PCRL_ENTRY pCrlEntry; BOOL fDeltaCrlEntry; } alias CERT_REVOCATION_CRL_INFO* PCERT_REVOCATION_CRL_INFO; struct CERT_REVOCATION_INFO { DWORD cbSize = CERT_REVOCATION_INFO.sizeof; DWORD dwRevocationResult; LPCSTR pszRevocationOid; LPVOID pvOidSpecificInfo; BOOL fHasFreshnessTime; DWORD dwFreshnessTime; PCERT_REVOCATION_CRL_INFO pCrlInfo; } alias CERT_REVOCATION_INFO* PCERT_REVOCATION_INFO; /* #if (_WIN32_WINNT>=0x500) */ struct CERT_CHAIN_ELEMENT { DWORD cbSize = CERT_CHAIN_ELEMENT.sizeof; PCCERT_CONTEXT pCertContext; CERT_TRUST_STATUS TrustStatus; PCERT_REVOCATION_INFO pRevocationInfo; PCERT_ENHKEY_USAGE pIssuanceUsage; PCERT_ENHKEY_USAGE pApplicationUsage; } alias CERT_CHAIN_ELEMENT* PCERT_CHAIN_ELEMENT; /* #endif */ struct CRYPT_ATTRIBUTE { LPSTR pszObjId; DWORD cValue; PCRYPT_ATTR_BLOB rgValue; } alias CRYPT_ATTRIBUTE* PCRYPT_ATTRIBUTE; struct CTL_ENTRY { CRYPT_DATA_BLOB SubjectIdentifier; DWORD cAttribute; PCRYPT_ATTRIBUTE rgAttribute; } alias CTL_ENTRY* PCTL_ENTRY; struct CTL_INFO { DWORD dwVersion; CTL_USAGE SubjectUsage; CRYPT_DATA_BLOB ListIdentifier; CRYPT_INTEGER_BLOB SequenceNumber; FILETIME ThisUpdate; FILETIME NextUpdate; CRYPT_ALGORITHM_IDENTIFIER SubjectAlgorithm; DWORD cCTLEntry; PCTL_ENTRY rgCTLEntry; DWORD cExtension; PCERT_EXTENSION rgExtension; } alias CTL_INFO* PCTL_INFO; struct CTL_CONTEXT { DWORD dwMsgAndCertEncodingType; BYTE* pbCtlEncoded; DWORD cbCtlEncoded; PCTL_INFO pCtlInfo; HCERTSTORE hCertStore; HCRYPTMSG hCryptMsg; BYTE* pbCtlContent; DWORD cbCtlContent; } alias CTL_CONTEXT* PCTL_CONTEXT; alias const(CTL_CONTEXT)* PCCTL_CONTEXT; struct CERT_TRUST_LIST_INFO { DWORD cbSize = CERT_TRUST_LIST_INFO.sizeof; PCTL_ENTRY pCtlEntry; PCCTL_CONTEXT pCtlContext; } alias CERT_TRUST_LIST_INFO* PCERT_TRUST_LIST_INFO; struct CERT_SIMPLE_CHAIN { DWORD cbSize = CERT_SIMPLE_CHAIN.sizeof; CERT_TRUST_STATUS TrustStatus; DWORD cElement; PCERT_CHAIN_ELEMENT* rgpElement; PCERT_TRUST_LIST_INFO pTrustListInfo; BOOL fHasRevocationFreshnessTime; DWORD dwRevocationFreshnessTime; } alias CERT_SIMPLE_CHAIN* PCERT_SIMPLE_CHAIN; /* #if (_WIN32_WINNT>=0x500) */ alias const(CERT_CHAIN_CONTEXT)* PCCERT_CHAIN_CONTEXT; struct CERT_CHAIN_CONTEXT { DWORD cbSize = CERT_CHAIN_CONTEXT.sizeof; CERT_TRUST_STATUS TrustStatus; DWORD cChain; PCERT_SIMPLE_CHAIN* rgpChain; DWORD cLowerQualityChainContext; PCCERT_CHAIN_CONTEXT* rgpLowerQualityChainContext; BOOL fHasRevocationFreshnessTime; DWORD dwRevocationFreshnessTime; } alias CERT_CHAIN_CONTEXT* PCERT_CHAIN_CONTEXT; /* #endif */ struct PROV_ENUMALGS { ALG_ID aiAlgid; DWORD dwBitLen; DWORD dwNameLen; CHAR[20] szName = 0; } struct PUBLICKEYSTRUC { BYTE bType; BYTE bVersion; WORD reserved; ALG_ID aiKeyAlg; } alias PUBLICKEYSTRUC BLOBHEADER; struct RSAPUBKEY { DWORD magic; DWORD bitlen; DWORD pubexp; } struct HMAC_INFO { ALG_ID HashAlgid; BYTE* pbInnerString; DWORD cbInnerString; BYTE* pbOuterString; DWORD cbOuterString; } alias HMAC_INFO* PHMAC_INFO; extern (Windows) @nogc nothrow { BOOL CertCloseStore(HCERTSTORE, DWORD); BOOL CertGetCertificateChain(HCERTCHAINENGINE, PCCERT_CONTEXT, LPFILETIME, HCERTSTORE, PCERT_CHAIN_PARA, DWORD, LPVOID, PCCERT_CHAIN_CONTEXT*); BOOL CertVerifyCertificateChainPolicy(LPCSTR, PCCERT_CHAIN_CONTEXT, PCERT_CHAIN_POLICY_PARA, PCERT_CHAIN_POLICY_STATUS); void CertFreeCertificateChain(PCCERT_CHAIN_CONTEXT); DWORD CertNameToStrA(DWORD, PCERT_NAME_BLOB, DWORD, LPSTR, DWORD); DWORD CertNameToStrW(DWORD, PCERT_NAME_BLOB, DWORD, LPWSTR, DWORD); HCERTSTORE CertOpenSystemStoreA(HCRYPTPROV, LPCSTR); HCERTSTORE CertOpenSystemStoreW(HCRYPTPROV, LPCWSTR); HCERTSTORE CertOpenStore(LPCSTR, DWORD, HCRYPTPROV, DWORD, const(void)*); PCCERT_CONTEXT CertFindCertificateInStore(HCERTSTORE, DWORD, DWORD, DWORD, const(void)*, PCCERT_CONTEXT); BOOL CertFreeCertificateContext(PCCERT_CONTEXT); PCCERT_CONTEXT CertGetIssuerCertificateFromStore(HCERTSTORE, PCCERT_CONTEXT, PCCERT_CONTEXT, DWORD*); PCCERT_CHAIN_CONTEXT CertFindChainInStore(HCERTSTORE, DWORD, DWORD, DWORD, const(void)*, PCCERT_CHAIN_CONTEXT); BOOL CryptAcquireContextA(HCRYPTPROV*, LPCSTR, LPCSTR, DWORD, DWORD); BOOL CryptAcquireContextW(HCRYPTPROV*, LPCWSTR, LPCWSTR, DWORD, DWORD); BOOL CryptContextAddRef(HCRYPTPROV, DWORD*, DWORD); BOOL CryptReleaseContext(HCRYPTPROV, ULONG_PTR); BOOL CryptGenKey(HCRYPTPROV, ALG_ID, DWORD, HCRYPTKEY*); BOOL CryptDeriveKey(HCRYPTPROV, ALG_ID, HCRYPTHASH, DWORD, HCRYPTKEY*); BOOL CryptDestroyKey(HCRYPTKEY); static if (_WIN32_WINNT >= 0x500) { BOOL CryptDuplicateHash(HCRYPTHASH, DWORD*, DWORD, HCRYPTHASH*); BOOL CryptDuplicateKey(HCRYPTKEY, DWORD*, DWORD, HCRYPTKEY*); } BOOL CryptSetKeyParam(HCRYPTKEY, DWORD, PBYTE, DWORD); BOOL CryptGetKeyParam(HCRYPTKEY, DWORD, PBYTE, PDWORD, DWORD); BOOL CryptSetHashParam(HCRYPTHASH, DWORD, PBYTE, DWORD); BOOL CryptGetHashParam(HCRYPTHASH, DWORD, PBYTE, PDWORD, DWORD); BOOL CryptSetProvParam(HCRYPTPROV, DWORD, PBYTE, DWORD); BOOL CryptGetProvParam(HCRYPTPROV, DWORD, PBYTE, PDWORD, DWORD); BOOL CryptGenRandom(HCRYPTPROV, DWORD, PBYTE); BOOL CryptGetUserKey(HCRYPTPROV, DWORD, HCRYPTKEY*); BOOL CryptExportKey(HCRYPTKEY, HCRYPTKEY, DWORD, DWORD, PBYTE, PDWORD); BOOL CryptImportKey(HCRYPTPROV, PBYTE, DWORD, HCRYPTKEY, DWORD, HCRYPTKEY*); BOOL CryptEncrypt(HCRYPTKEY, HCRYPTHASH, BOOL, DWORD, PBYTE, PDWORD, DWORD); BOOL CryptDecrypt(HCRYPTKEY, HCRYPTHASH, BOOL, DWORD, PBYTE, PDWORD); BOOL CryptCreateHash(HCRYPTPROV, ALG_ID, HCRYPTKEY, DWORD, HCRYPTHASH*); BOOL CryptHashData(HCRYPTHASH, PBYTE, DWORD, DWORD); BOOL CryptHashSessionKey(HCRYPTHASH, HCRYPTKEY, DWORD); BOOL CryptGetHashValue(HCRYPTHASH, DWORD, PBYTE, PDWORD); BOOL CryptDestroyHash(HCRYPTHASH); BOOL CryptSignHashA(HCRYPTHASH, DWORD, LPCSTR, DWORD, PBYTE, PDWORD); BOOL CryptSignHashW(HCRYPTHASH, DWORD, LPCWSTR, DWORD, PBYTE, PDWORD); BOOL CryptVerifySignatureA(HCRYPTHASH, PBYTE, DWORD, HCRYPTKEY, LPCSTR, DWORD); BOOL CryptVerifySignatureW(HCRYPTHASH, PBYTE, DWORD, HCRYPTKEY, LPCWSTR, DWORD); BOOL CryptSetProviderA(LPCSTR, DWORD); BOOL CryptSetProviderW(LPCWSTR, DWORD); } version (Unicode) { alias CertNameToStrW CertNameToStr; alias CryptAcquireContextW CryptAcquireContext; alias CryptSignHashW CryptSignHash; alias CryptVerifySignatureW CryptVerifySignature; alias CryptSetProviderW CryptSetProvider; alias CertOpenSystemStoreW CertOpenSystemStore; /+alias CERT_FIND_SUBJECT_STR_W CERT_FIND_SUBJECT_STR; alias CERT_FIND_ISSUER_STR_W CERT_FIND_ISSUER_STR;+/ } else { alias CertNameToStrA CertNameToStr; alias CryptAcquireContextA CryptAcquireContext; alias CryptSignHashA CryptSignHash; alias CryptVerifySignatureA CryptVerifySignature; alias CryptSetProviderA CryptSetProvider; alias CertOpenSystemStoreA CertOpenSystemStore; /+alias CERT_FIND_SUBJECT_STR_A CERT_FIND_SUBJECT_STR; alias CERT_FIND_ISSUER_STR_A CERT_FIND_ISSUER_STR;+/ }