Add Windows BCrypt bindings (#20740)

* Update sdkddkver/w32api bindings

* Add BCrypt bindings

---------

Co-authored-by: IchorDev <ichordev@noreply.git.sleeping.town>
This commit is contained in:
IchorDev 2025-01-26 01:33:27 +10:00 committed by GitHub
parent 128d56dd04
commit 32883d3994
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
4 changed files with 1012 additions and 34 deletions

View file

@ -0,0 +1,5 @@
Add Windows BCrypt bindings under `core.sys.windows.bcrypt`
Adds full [BCrypt API](https://learn.microsoft.com/en-us/windows/win32/api/bcrypt/) bindings to the Windows-specific system bindings.
The Windows-specific bindings under `core.sys.windows.sdkddkver` and `core.sys.windows.w32api` have also been updated in order to facilitate the creation of the BCrypt bindings.

View file

@ -0,0 +1,900 @@
/**
* Cryptographic primitives
*
* Translated from MinGW-w64 Windows headers
*
* License: $(LINK2 http://www.boost.org/LICENSE_1_0.txt, Boost License 1.0)
* Authors: Aya Partridge
* Source: $(DRUNTIMESRC core/sys/windows/_bcrypt.d)
*/
module core.sys.windows.bcrypt;
version (Windows):
pragma(lib, "bcrypt");
import core.sys.windows.ntdef, core.sys.windows.sdkddkver, core.sys.windows.winbase, core.sys.windows.windef, core.sys.windows.winnt;
pragma(inline, true)
bool BCRYPT_SUCCESS(NTSTATUS Status) @nogc nothrow pure @safe => Status >= 0;
enum BCRYPT_OBJECT_ALIGNMENT = 16;
enum {
BCRYPT_KDF_HASH = "HASH"w,
BCRYPT_KDF_HMAC = "HMAC"w,
BCRYPT_KDF_TLS_PRF = "TLS_PRF"w,
BCRYPT_KDF_SP80056A_CONCAT = "SP800_56A_CONCAT"w,
}
static if (NTDDI_VERSION >= NTDDI_WINBLUE)
enum {
BCRYPT_KDF_RAW_SECRET = "TRUNCATE"w,
}
static if (NTDDI_VERSION >= NTDDI_WIN10_RS4)
enum {
BCRYPT_KDF_HKDF = "HKDF"w,
}
enum {
KDF_HASH_ALGORITHM = 0x0,
KDF_SECRET_PREPEND = 0x1,
KDF_SECRET_APPEND = 0x2,
KDF_HMAC_KEY = 0x3,
KDF_TLS_PRF_LABEL = 0x4,
KDF_TLS_PRF_SEED = 0x5,
KDF_SECRET_HANDLE = 0x6,
}
static if (NTDDI_VERSION >= NTDDI_WIN7)
enum {
KDF_TLS_PRF_PROTOCOL = 0x7,
KDF_ALGORITHMID = 0x8,
KDF_PARTYUINFO = 0x9,
KDF_PARTYVINFO = 0xA,
KDF_SUPPPUBINFO = 0xB,
KDF_SUPPPRIVINFO = 0xC,
}
static if (NTDDI_VERSION >= NTDDI_WIN8)
enum {
KDF_LABEL = 0xD,
KDF_CONTEXT = 0xE,
KDF_SALT = 0xF,
KDF_ITERATION_COUNT = 0x10,
KDF_GENERIC_PARAMETER = 0x11,
KDF_KEYBITLENGTH = 0x12,
}
static if (NTDDI_VERSION >= NTDDI_WIN10_RS4)
enum {
KDF_HKDF_SALT = 0x13,
KDF_HKDF_INFO = 0x14,
}
enum KDF_USE_SECRET_AS_HMAC_KEY_FLAG = 1;
enum BCRYPT_AUTHENTICATED_CIPHER_MODE_INFO_VERSION = 1;
enum {
BCRYPT_AUTH_MODE_CHAIN_CALLS_FLAG = 0x00000001,
BCRYPT_AUTH_MODE_IN_PROGRESS_FLAG = 0x00000002,
}
pragma(inline, true)
void BCRYPT_INIT_AUTH_MODE_INFO(ref BCRYPT_AUTHENTICATED_CIPHER_MODE_INFO _AUTH_INFO_STRUCT_) @nogc nothrow pure @safe {
RtlZeroMemory(&_AUTH_INFO_STRUCT_, _AUTH_INFO_STRUCT_.sizeof);
_AUTH_INFO_STRUCT_.cbSize = _AUTH_INFO_STRUCT_.sizeof;
_AUTH_INFO_STRUCT_.dwInfoVersion = BCRYPT_AUTHENTICATED_CIPHER_MODE_INFO_VERSION;
}
enum {
BCRYPT_OPAQUE_KEY_BLOB = "OpaqueKeyBlob"w,
BCRYPT_KEY_DATA_BLOB = "KeyDataBlob"w,
}
static if (NTDDI_VERSION >= NTDDI_WIN7)
enum {
BCRYPT_AES_WRAP_KEY_BLOB = "Rfc3565KeyWrapBlob"w,
}
enum {
BCRYPT_ALGORITHM_NAME = "AlgorithmName"w,
BCRYPT_AUTH_TAG_LENGTH = "AuthTagLength"w,
BCRYPT_BLOCK_LENGTH = "BlockLength"w,
BCRYPT_BLOCK_SIZE_LIST = "BlockSizeList"w,
BCRYPT_CHAINING_MODE = "ChainingMode"w,
BCRYPT_CHAIN_MODE_CBC = "ChainingModeCBC"w,
BCRYPT_CHAIN_MODE_CCM = "ChainingModeCCM"w,
BCRYPT_CHAIN_MODE_CFB = "ChainingModeCFB"w,
BCRYPT_CHAIN_MODE_ECB = "ChainingModeECB"w,
BCRYPT_CHAIN_MODE_GCM = "ChainingModeGCM"w,
BCRYPT_CHAIN_MODE_NA = "ChainingModeN/A"w,
BCRYPT_EFFECTIVE_KEY_LENGTH = "EffectiveKeyLength"w,
BCRYPT_HASH_BLOCK_LENGTH = "HashBlockLength"w,
BCRYPT_HASH_LENGTH = "HashDigestLength"w,
BCRYPT_HASH_OID_LIST = "HashOIDList"w,
BCRYPT_INITIALIZATION_VECTOR = "IV"w,
BCRYPT_IS_KEYED_HASH = "IsKeyedHash"w,
BCRYPT_IS_REUSABLE_HASH = "IsReusableHash"w,
BCRYPT_KEY_LENGTH = "KeyLength"w,
BCRYPT_KEY_LENGTHS = "KeyLengths"w,
BCRYPT_KEY_OBJECT_LENGTH = "KeyObjectLength"w,
BCRYPT_KEY_STRENGTH = "KeyStrength"w,
BCRYPT_MESSAGE_BLOCK_LENGTH = "MessageBlockLength"w,
BCRYPT_OBJECT_LENGTH = "ObjectLength"w,
BCRYPT_PADDING_SCHEMES = "PaddingSchemes"w,
BCRYPT_PCP_PLATFORM_TYPE_PROPERTY = "PCP_PLATFORM_TYPE"w,
BCRYPT_PCP_PROVIDER_VERSION_PROPERTY = "PCP_PROVIDER_VERSION"w,
BCRYPT_PRIMITIVE_TYPE = "PrimitiveType"w,
BCRYPT_PROVIDER_HANDLE = "ProviderHandle"w,
BCRYPT_PUBLIC_KEY_LENGTH = "PublicKeyLength"w,
BCRYPT_SIGNATURE_LENGTH = "SignatureLength"w,
}
static if (NTDDI_VERSION >= NTDDI_WINBLUE)
enum {
BCRYPT_MULTI_OBJECT_LENGTH = "MultiObjectLength"w,
}
static if (NTDDI_VERSION >= NTDDI_WIN10_RS4)
enum {
BCRYPT_IS_IFX_TPM_WEAK_KEY = "IsIfxTpmWeakKey"w,
BCRYPT_HKDF_HASH_ALGORITHM = "HkdfHashAlgorithm"w,
BCRYPT_HKDF_SALT_AND_FINALIZE = "HkdfSaltAndFinalize"w,
BCRYPT_HKDF_PRK_AND_FINALIZE = "HkdfPrkAndFinalize"w,
}
static if (NTDDI_VERSION >= NTDDI_WIN11_ZN)
enum {
BCRYPT_FUNCTION_NAME_STRING = "FunctionNameString"w,
BCRYPT_CUSTOMIZATION_STRING = "CustomizationString"w,
}
static if (NTDDI_VERSION >= NTDDI_WIN11_GA)
enum {
BCRYPT_CHAIN_MODE_KWP = "ChainingModeKWP"w,
}
enum {
BCRYPT_SUPPORTED_PAD_ROUTER = 0x00000001,
BCRYPT_SUPPORTED_PAD_PKCS1_ENC = 0x00000002,
BCRYPT_SUPPORTED_PAD_PKCS1_SIG = 0x00000004,
BCRYPT_SUPPORTED_PAD_OAEP = 0x00000008,
BCRYPT_SUPPORTED_PAD_PSS = 0x00000010,
}
enum BCRYPT_PROV_DISPATCH = 0x00000001;
enum BCRYPT_BLOCK_PADDING = 0x00000001;
static if (NTDDI_VERSION >= NTDDI_WIN10_CO)
enum BCRYPT_GENERATE_IV = 0x00000020;
enum {
BCRYPT_PAD_NONE = 0x00000001,
BCRYPT_PAD_PKCS1 = 0x00000002,
BCRYPT_PAD_OAEP = 0x00000004,
BCRYPT_PAD_PSS = 0x00000008,
}
static if (NTDDI_VERSION >= NTDDI_WINBLUE)
enum {
BCRYPT_PAD_PKCS1_OPTIONAL_HASH_OID = 0x00000010,
}
enum BCRYPTBUFFER_VERSION = 0;
struct BCRYPT_KEY_LENGTHS_STRUCT {
ULONG dwMinLength;
ULONG dwMaxLength;
ULONG dwIncrement;
}
alias BCRYPT_AUTH_TAG_LENGTHS_STRUCT = BCRYPT_KEY_LENGTHS_STRUCT;
struct BCRYPT_OID {
ULONG cbOID;
PUCHAR pbOID;
}
struct BCRYPT_OID_LIST {
ULONG dwOIDCount;
BCRYPT_OID* pOIDs;
}
struct BCRYPT_PKCS1_PADDING_INFO {
LPCWSTR pszAlgId;
}
struct BCRYPT_PSS_PADDING_INFO {
LPCWSTR pszAlgId;
ULONG cbSalt;
}
struct BCRYPT_OAEP_PADDING_INFO {
LPCWSTR pszAlgId;
PUCHAR pbLabel;
ULONG cbLabel;
}
struct BCRYPT_AUTHENTICATED_CIPHER_MODE_INFO {
ULONG cbSize;
ULONG dwInfoVersion;
PUCHAR pbNonce;
ULONG cbNonce;
PUCHAR pbAuthData;
ULONG cbAuthData;
PUCHAR pbTag;
ULONG cbTag;
PUCHAR pbMacContext;
ULONG cbMacContext;
ULONG cbAAD;
ULONGLONG cbData;
ULONG dwFlags;
}
alias PBCRYPT_AUTHENTICATED_CIPHER_MODE_INFO = BCRYPT_AUTHENTICATED_CIPHER_MODE_INFO*;
struct BCryptBuffer {
ULONG cbBuffer;
ULONG BufferType;
PVOID pvBuffer;
}
alias PBCryptBuffer = BCryptBuffer*;
struct BCryptBufferDesc {
ULONG ulVersion;
ULONG cBuffers;
PBCryptBuffer pBuffers;
}
alias PBCryptBufferDesc = BCryptBufferDesc*;
enum {
BCRYPT_PUBLIC_KEY_BLOB = "PUBLICBLOB"w,
BCRYPT_PRIVATE_KEY_BLOB = "PRIVATEBLOB"w,
}
enum {
BCRYPT_RSAPUBLIC_BLOB = "RSAPUBLICBLOB"w,
BCRYPT_RSAPRIVATE_BLOB = "RSAPRIVATEBLOB"w,
LEGACY_RSAPUBLIC_BLOB = "CAPIPUBLICBLOB"w,
LEGACY_RSAPRIVATE_BLOB = "CAPIPRIVATEBLOB"w,
}
enum {
BCRYPT_RSAPUBLIC_MAGIC = 0x31415352,
BCRYPT_RSAPRIVATE_MAGIC = 0x32415352,
}
enum BCRYPT_RSAFULLPRIVATE_BLOB = "RSAFULLPRIVATEBLOB"w;
enum BCRYPT_RSAFULLPRIVATE_MAGIC = 0x33415352;
static if (NTDDI_VERSION >= NTDDI_WIN8) {
enum BCRYPT_GLOBAL_PARAMETERS = "SecretAgreementParam"w;
enum BCRYPT_PRIVATE_KEY = "PrivKeyVal"w;
}
enum {
BCRYPT_ECCPUBLIC_BLOB = "ECCPUBLICBLOB"w,
BCRYPT_ECCPRIVATE_BLOB = "ECCPRIVATEBLOB"w,
}
static if (NTDDI_VERSION >= NTDDI_WINTHRESHOLD)
enum {
BCRYPT_ECCFULLPUBLIC_BLOB = "ECCFULLPUBLICBLOB"w,
BCRYPT_ECCFULLPRIVATE_BLOB = "ECCFULLPRIVATEBLOB"w,
}
static if (NTDDI_VERSION >= NTDDI_WINTHRESHOLD)
enum SSL_ECCPUBLIC_BLOB = "SSLECCPUBLICBLOB"w;
enum TLS_13_PRE_SHARED_KEY = "TLS13PRESHAREDKEY"w;
enum {
BCRYPT_ECDH_PUBLIC_P256_MAGIC = 0x314B4345,
BCRYPT_ECDH_PRIVATE_P256_MAGIC = 0x324B4345,
BCRYPT_ECDH_PUBLIC_P384_MAGIC = 0x334B4345,
BCRYPT_ECDH_PRIVATE_P384_MAGIC = 0x344B4345,
BCRYPT_ECDH_PUBLIC_P521_MAGIC = 0x354B4345,
BCRYPT_ECDH_PRIVATE_P521_MAGIC = 0x364B4345,
}
static if (NTDDI_VERSION >= NTDDI_WINTHRESHOLD)
enum {
BCRYPT_ECDH_PUBLIC_GENERIC_MAGIC = 0x504B4345,
BCRYPT_ECDH_PRIVATE_GENERIC_MAGIC = 0x564B4345,
}
enum {
BCRYPT_ECDSA_PUBLIC_P256_MAGIC = 0x31534345,
BCRYPT_ECDSA_PRIVATE_P256_MAGIC = 0x32534345,
BCRYPT_ECDSA_PUBLIC_P384_MAGIC = 0x33534345,
BCRYPT_ECDSA_PRIVATE_P384_MAGIC = 0x34534345,
BCRYPT_ECDSA_PUBLIC_P521_MAGIC = 0x35534345,
BCRYPT_ECDSA_PRIVATE_P521_MAGIC = 0x36534345,
}
static if (NTDDI_VERSION >= NTDDI_WINTHRESHOLD)
enum {
BCRYPT_ECDSA_PUBLIC_GENERIC_MAGIC = 0x50444345,
BCRYPT_ECDSA_PRIVATE_GENERIC_MAGIC = 0x56444345,
}
enum {
BCRYPT_DH_PUBLIC_BLOB = "DHPUBLICBLOB"w,
BCRYPT_DH_PRIVATE_BLOB = "DHPRIVATEBLOB"w,
LEGACY_DH_PUBLIC_BLOB = "CAPIDHPUBLICBLOB"w,
LEGACY_DH_PRIVATE_BLOB = "CAPIDHPRIVATEBLOB"w,
}
enum {
BCRYPT_DH_PUBLIC_MAGIC = 0x42504844,
BCRYPT_DH_PRIVATE_MAGIC = 0x56504844,
}
enum {
BCRYPT_DH_PARAMETERS = "DHParameters"w,
BCRYPT_DH_PARAMETERS_MAGIC = 0x4D504844,
}
enum {
BCRYPT_DSA_PUBLIC_BLOB = "DSAPUBLICBLOB"w,
BCRYPT_DSA_PRIVATE_BLOB = "DSAPRIVATEBLOB"w,
LEGACY_DSA_PUBLIC_BLOB = "CAPIDSAPUBLICBLOB"w,
LEGACY_DSA_PRIVATE_BLOB = "CAPIDSAPRIVATEBLOB"w,
LEGACY_DSA_V2_PUBLIC_BLOB = "V2CAPIDSAPUBLICBLOB"w,
LEGACY_DSA_V2_PRIVATE_BLOB = "V2CAPIDSAPRIVATEBLOB"w,
}
enum {
BCRYPT_DSA_PUBLIC_MAGIC = 0x42505344,
BCRYPT_DSA_PRIVATE_MAGIC = 0x56505344,
BCRYPT_DSA_PUBLIC_MAGIC_V2 = 0x32425044,
BCRYPT_DSA_PRIVATE_MAGIC_V2 = 0x32565044,
}
enum {
BCRYPT_KEY_DATA_BLOB_MAGIC = 0x4D42444B,
BCRYPT_KEY_DATA_BLOB_VERSION1 = 0x1,
}
enum {
BCRYPT_DSA_PARAMETERS = "DSAParameters"w,
BCRYPT_DSA_PARAMETERS_MAGIC = 0x4D505344,
BCRYPT_DSA_PARAMETERS_MAGIC_V2 = 0x324D5044,
}
enum {
MS_PRIMITIVE_PROVIDER = "Microsoft Primitive Provider"w,
MS_PLATFORM_CRYPTO_PROVIDER = "Microsoft Platform Crypto Provider"w,
}
enum {
BCRYPT_RSA_ALGORITHM = "RSA"w,
BCRYPT_RSA_SIGN_ALGORITHM = "RSA_SIGN"w,
BCRYPT_DH_ALGORITHM = "DH"w,
BCRYPT_DSA_ALGORITHM = "DSA"w,
BCRYPT_RC2_ALGORITHM = "RC2"w,
BCRYPT_RC4_ALGORITHM = "RC4"w,
BCRYPT_AES_ALGORITHM = "AES"w,
BCRYPT_DES_ALGORITHM = "DES"w,
BCRYPT_DESX_ALGORITHM = "DESX"w,
BCRYPT_3DES_ALGORITHM = "3DES"w,
BCRYPT_3DES_112_ALGORITHM = "3DES_112"w,
BCRYPT_MD2_ALGORITHM = "MD2"w,
BCRYPT_MD4_ALGORITHM = "MD4"w,
BCRYPT_MD5_ALGORITHM = "MD5"w,
BCRYPT_SHA1_ALGORITHM = "SHA1"w,
BCRYPT_SHA256_ALGORITHM = "SHA256"w,
BCRYPT_SHA384_ALGORITHM = "SHA384"w,
BCRYPT_SHA512_ALGORITHM = "SHA512"w,
BCRYPT_AES_GMAC_ALGORITHM = "AES-GMAC"w,
BCRYPT_AES_CMAC_ALGORITHM = "AES-CMAC"w,
BCRYPT_ECDSA_P256_ALGORITHM = "ECDSA_P256"w,
BCRYPT_ECDSA_P384_ALGORITHM = "ECDSA_P384"w,
BCRYPT_ECDSA_P521_ALGORITHM = "ECDSA_P521"w,
BCRYPT_ECDH_P256_ALGORITHM = "ECDH_P256"w,
BCRYPT_ECDH_P384_ALGORITHM = "ECDH_P384"w,
BCRYPT_ECDH_P521_ALGORITHM = "ECDH_P521"w,
BCRYPT_RNG_ALGORITHM = "RNG"w,
BCRYPT_RNG_FIPS186_DSA_ALGORITHM = "FIPS186DSARNG"w,
BCRYPT_RNG_DUAL_EC_ALGORITHM = "DUALECRNG"w,
BCRYPT_SP800108_CTR_HMAC_ALGORITHM = "SP800_108_CTR_HMAC"w,
BCRYPT_SP80056A_CONCAT_ALGORITHM = "SP800_56A_CONCAT"w,
BCRYPT_PBKDF2_ALGORITHM = "PBKDF2"w,
BCRYPT_CAPI_KDF_ALGORITHM = "CAPI_KDF"w,
}
enum {
BCRYPT_CIPHER_INTERFACE = 0x00000001,
BCRYPT_HASH_INTERFACE = 0x00000002,
BCRYPT_ASYMMETRIC_ENCRYPTION_INTERFACE = 0x00000003,
BCRYPT_SECRET_AGREEMENT_INTERFACE = 0x00000004,
BCRYPT_SIGNATURE_INTERFACE = 0x00000005,
BCRYPT_RNG_INTERFACE = 0x00000006,
BCRYPT_KEY_DERIVATION_INTERFACE = 0x00000007,
}
static if (NTDDI_VERSION >= NTDDI_WINTHRESHOLD)
enum : BCRYPT_ALG_HANDLE {
BCRYPT_MD2_ALG_HANDLE = cast(BCRYPT_ALG_HANDLE) 0x00000001,
BCRYPT_MD4_ALG_HANDLE = cast(BCRYPT_ALG_HANDLE) 0x00000011,
BCRYPT_MD5_ALG_HANDLE = cast(BCRYPT_ALG_HANDLE) 0x00000021,
BCRYPT_SHA1_ALG_HANDLE = cast(BCRYPT_ALG_HANDLE) 0x00000031,
BCRYPT_SHA256_ALG_HANDLE = cast(BCRYPT_ALG_HANDLE) 0x00000041,
BCRYPT_SHA384_ALG_HANDLE = cast(BCRYPT_ALG_HANDLE) 0x00000051,
BCRYPT_SHA512_ALG_HANDLE = cast(BCRYPT_ALG_HANDLE) 0x00000061,
BCRYPT_RC4_ALG_HANDLE = cast(BCRYPT_ALG_HANDLE) 0x00000071,
BCRYPT_RNG_ALG_HANDLE = cast(BCRYPT_ALG_HANDLE) 0x00000081,
BCRYPT_HMAC_MD5_ALG_HANDLE = cast(BCRYPT_ALG_HANDLE) 0x00000091,
BCRYPT_HMAC_SHA1_ALG_HANDLE = cast(BCRYPT_ALG_HANDLE) 0x000000A1,
BCRYPT_HMAC_SHA256_ALG_HANDLE = cast(BCRYPT_ALG_HANDLE) 0x000000B1,
BCRYPT_HMAC_SHA384_ALG_HANDLE = cast(BCRYPT_ALG_HANDLE) 0x000000C1,
BCRYPT_HMAC_SHA512_ALG_HANDLE = cast(BCRYPT_ALG_HANDLE) 0x000000D1,
BCRYPT_RSA_ALG_HANDLE = cast(BCRYPT_ALG_HANDLE) 0x000000E1,
BCRYPT_ECDSA_ALG_HANDLE = cast(BCRYPT_ALG_HANDLE) 0x000000F1,
BCRYPT_AES_CMAC_ALG_HANDLE = cast(BCRYPT_ALG_HANDLE) 0x00000101,
BCRYPT_AES_GMAC_ALG_HANDLE = cast(BCRYPT_ALG_HANDLE) 0x00000111,
BCRYPT_HMAC_MD2_ALG_HANDLE = cast(BCRYPT_ALG_HANDLE) 0x00000121,
BCRYPT_HMAC_MD4_ALG_HANDLE = cast(BCRYPT_ALG_HANDLE) 0x00000131,
BCRYPT_3DES_CBC_ALG_HANDLE = cast(BCRYPT_ALG_HANDLE) 0x00000141,
BCRYPT_3DES_ECB_ALG_HANDLE = cast(BCRYPT_ALG_HANDLE) 0x00000151,
BCRYPT_3DES_CFB_ALG_HANDLE = cast(BCRYPT_ALG_HANDLE) 0x00000161,
BCRYPT_3DES_112_CBC_ALG_HANDLE = cast(BCRYPT_ALG_HANDLE) 0x00000171,
BCRYPT_3DES_112_ECB_ALG_HANDLE = cast(BCRYPT_ALG_HANDLE) 0x00000181,
BCRYPT_3DES_112_CFB_ALG_HANDLE = cast(BCRYPT_ALG_HANDLE) 0x00000191,
BCRYPT_AES_CBC_ALG_HANDLE = cast(BCRYPT_ALG_HANDLE) 0x000001A1,
BCRYPT_AES_ECB_ALG_HANDLE = cast(BCRYPT_ALG_HANDLE) 0x000001B1,
BCRYPT_AES_CFB_ALG_HANDLE = cast(BCRYPT_ALG_HANDLE) 0x000001C1,
BCRYPT_AES_CCM_ALG_HANDLE = cast(BCRYPT_ALG_HANDLE) 0x000001D1,
BCRYPT_AES_GCM_ALG_HANDLE = cast(BCRYPT_ALG_HANDLE) 0x000001E1,
BCRYPT_DES_CBC_ALG_HANDLE = cast(BCRYPT_ALG_HANDLE) 0x000001F1,
BCRYPT_DES_ECB_ALG_HANDLE = cast(BCRYPT_ALG_HANDLE) 0x00000201,
BCRYPT_DES_CFB_ALG_HANDLE = cast(BCRYPT_ALG_HANDLE) 0x00000211,
BCRYPT_DESX_CBC_ALG_HANDLE = cast(BCRYPT_ALG_HANDLE) 0x00000221,
BCRYPT_DESX_ECB_ALG_HANDLE = cast(BCRYPT_ALG_HANDLE) 0x00000231,
BCRYPT_DESX_CFB_ALG_HANDLE = cast(BCRYPT_ALG_HANDLE) 0x00000241,
BCRYPT_RC2_CBC_ALG_HANDLE = cast(BCRYPT_ALG_HANDLE) 0x00000251,
BCRYPT_RC2_ECB_ALG_HANDLE = cast(BCRYPT_ALG_HANDLE) 0x00000261,
BCRYPT_RC2_CFB_ALG_HANDLE = cast(BCRYPT_ALG_HANDLE) 0x00000271,
BCRYPT_DH_ALG_HANDLE = cast(BCRYPT_ALG_HANDLE) 0x00000281,
BCRYPT_ECDH_ALG_HANDLE = cast(BCRYPT_ALG_HANDLE) 0x00000291,
BCRYPT_ECDH_P256_ALG_HANDLE = cast(BCRYPT_ALG_HANDLE) 0x000002A1,
BCRYPT_ECDH_P384_ALG_HANDLE = cast(BCRYPT_ALG_HANDLE) 0x000002B1,
BCRYPT_ECDH_P521_ALG_HANDLE = cast(BCRYPT_ALG_HANDLE) 0x000002C1,
BCRYPT_DSA_ALG_HANDLE = cast(BCRYPT_ALG_HANDLE) 0x000002D1,
BCRYPT_ECDSA_P256_ALG_HANDLE = cast(BCRYPT_ALG_HANDLE) 0x000002E1,
BCRYPT_ECDSA_P384_ALG_HANDLE = cast(BCRYPT_ALG_HANDLE) 0x000002F1,
BCRYPT_ECDSA_P521_ALG_HANDLE = cast(BCRYPT_ALG_HANDLE) 0x00000301,
BCRYPT_RSA_SIGN_ALG_HANDLE = cast(BCRYPT_ALG_HANDLE) 0x00000311,
BCRYPT_CAPI_KDF_ALG_HANDLE = cast(BCRYPT_ALG_HANDLE) 0x00000321,
BCRYPT_PBKDF2_ALG_HANDLE = cast(BCRYPT_ALG_HANDLE) 0x00000331,
BCRYPT_SP800108_CTR_HMAC_ALG_HANDLE = cast(BCRYPT_ALG_HANDLE) 0x00000341,
BCRYPT_SP80056A_CONCAT_ALG_HANDLE = cast(BCRYPT_ALG_HANDLE) 0x00000351,
BCRYPT_TLS1_1_KDF_ALG_HANDLE = cast(BCRYPT_ALG_HANDLE) 0x00000361,
BCRYPT_TLS1_2_KDF_ALG_HANDLE = cast(BCRYPT_ALG_HANDLE) 0x00000371,
BCRYPT_XTS_AES_ALG_HANDLE = cast(BCRYPT_ALG_HANDLE) 0x00000381,
BCRYPT_HKDF_ALG_HANDLE = cast(BCRYPT_ALG_HANDLE) 0x00000391,
}
static if (NTDDI_VERSION >= NTDDI_WIN10_FE)
enum {
BCRYPT_CHACHA20_POLY1305_ALG_HANDLE = cast(BCRYPT_ALG_HANDLE) 0x000003A1,
}
static if (NTDDI_VERSION >= NTDDI_WIN11_ZN)
enum {
BCRYPT_SHA3_256_ALG_HANDLE = cast(BCRYPT_ALG_HANDLE) 0x000003B1,
BCRYPT_SHA3_384_ALG_HANDLE = cast(BCRYPT_ALG_HANDLE) 0x000003C1,
BCRYPT_SHA3_512_ALG_HANDLE = cast(BCRYPT_ALG_HANDLE) 0x000003D1,
BCRYPT_HMAC_SHA3_256_ALG_HANDLE = cast(BCRYPT_ALG_HANDLE) 0x000003E1,
BCRYPT_HMAC_SHA3_384_ALG_HANDLE = cast(BCRYPT_ALG_HANDLE) 0x000003F1,
BCRYPT_HMAC_SHA3_512_ALG_HANDLE = cast(BCRYPT_ALG_HANDLE) 0x00000401,
BCRYPT_CSHAKE128_ALG_HANDLE = cast(BCRYPT_ALG_HANDLE) 0x00000411,
BCRYPT_CSHAKE256_ALG_HANDLE = cast(BCRYPT_ALG_HANDLE) 0x00000421,
BCRYPT_KMAC128_ALG_HANDLE = cast(BCRYPT_ALG_HANDLE) 0x00000431,
BCRYPT_KMAC256_ALG_HANDLE = cast(BCRYPT_ALG_HANDLE) 0x00000441,
}
static if (NTDDI_VERSION >= NTDDI_WIN11_GA)
enum {
BCRYPT_AES_KWP_ALG_HANDLE = cast(BCRYPT_ALG_HANDLE) 0x00000451,
}
enum {
BCRYPT_ALG_HANDLE_HMAC_FLAG = 0x00000008,
BCRYPT_CAPI_AES_FLAG = 0x00000010,
BCRYPT_HASH_REUSABLE_FLAG = 0x00000020,
BCRYPT_BUFFERS_LOCKED_FLAG = 0x00000040,
}
enum {
BCRYPT_CIPHER_OPERATION = 0x00000001,
BCRYPT_HASH_OPERATION = 0x00000002,
BCRYPT_ASYMMETRIC_ENCRYPTION_OPERATION = 0x00000004,
BCRYPT_SECRET_AGREEMENT_OPERATION = 0x00000008,
BCRYPT_SIGNATURE_OPERATION = 0x00000010,
BCRYPT_RNG_OPERATION = 0x00000020,
BCRYPT_KEY_DERIVATION_OPERATION = 0x00000040,
}
enum {
BCRYPT_PUBLIC_KEY_FLAG = 0x00000001,
BCRYPT_PRIVATE_KEY_FLAG = 0x00000002,
}
enum BCRYPT_NO_KEY_VALIDATION = 0x00000008;
enum {
BCRYPT_RNG_USE_ENTROPY_IN_BUFFER = 0x00000001,
BCRYPT_USE_SYSTEM_PREFERRED_RNG = 0x00000002,
}
pragma(inline, true) @nogc nothrow pure @safe {
BCRYPT_INTERFACE_VERSION BCRYPT_MAKE_INTERFACE_VERSION(int major, int minor) =>
BCRYPT_INTERFACE_VERSION(MajorVersion: cast(USHORT)major, MinorVersion: cast(USHORT)minor);
bool BCRYPT_IS_INTERFACE_VERSION_COMPATIBLE(BCRYPT_INTERFACE_VERSION loader, BCRYPT_INTERFACE_VERSION provider) =>
loader.MajorVersion <= provider.MajorVersion;
}
enum {
BCRYPT_CIPHER_INTERFACE_VERSION_1 = BCRYPT_MAKE_INTERFACE_VERSION(1, 0),
BCRYPT_HASH_INTERFACE_VERSION_1 = BCRYPT_MAKE_INTERFACE_VERSION(1, 0),
BCRYPT_ASYMMETRIC_ENCRYPTION_INTERFACE_VERSION_1 = BCRYPT_MAKE_INTERFACE_VERSION(1, 0),
BCRYPT_SECRET_AGREEMENT_INTERFACE_VERSION_1 = BCRYPT_MAKE_INTERFACE_VERSION(1, 0),
BCRYPT_SIGNATURE_INTERFACE_VERSION_1 = BCRYPT_MAKE_INTERFACE_VERSION(1, 0),
BCRYPT_RNG_INTERFACE_VERSION_1 = BCRYPT_MAKE_INTERFACE_VERSION(1, 0),
}
enum {
CRYPT_MIN_DEPENDENCIES = 0x00000001,
CRYPT_PROCESS_ISOLATE = 0x00010000,
}
enum {
CRYPT_UM = 0x00000001,
CRYPT_KM = 0x00000002,
CRYPT_MM = 0x00000003,
CRYPT_ANY = 0x00000004,
}
enum CRYPT_OVERWRITE = 0x00000001;
enum {
CRYPT_LOCAL = 0x00000001,
CRYPT_DOMAIN = 0x00000002,
}
enum {
CRYPT_EXCLUSIVE = 0x00000001,
CRYPT_OVERRIDE = 0x00010000,
}
enum {
CRYPT_ALL_FUNCTIONS = 0x00000001,
CRYPT_ALL_PROVIDERS = 0x00000002,
}
enum {
CRYPT_PRIORITY_TOP = 0x00000000,
CRYPT_PRIORITY_BOTTOM = 0xFFFFFFFF,
}
enum CRYPT_DEFAULT_CONTEXT = "Default"w;
alias BCRYPT_HANDLE = PVOID;
alias BCRYPT_ALG_HANDLE = PVOID;
alias BCRYPT_KEY_HANDLE = PVOID;
alias BCRYPT_HASH_HANDLE = PVOID;
alias BCRYPT_SECRET_HANDLE = PVOID;
struct BCRYPT_KEY_BLOB {
ULONG Magic;
}
struct BCRYPT_RSAKEY_BLOB {
ULONG Magic;
ULONG BitLength;
ULONG cbPublicExp;
ULONG cbModulus;
ULONG cbPrime1;
ULONG cbPrime2;
}
struct BCRYPT_ECCKEY_BLOB {
ULONG dwMagic;
ULONG cbKey;
}
alias PBCRYPT_ECCKEY_BLOB = BCRYPT_ECCKEY_BLOB*;
static if (NTDDI_VERSION >= NTDDI_WINTHRESHOLD) {
struct SSL_ECCKEY_BLOB {
ULONG dwCurveType;
ULONG cbKey;
}
alias PSSL_ECCKEY_BLOB = SSL_ECCKEY_BLOB*;
enum BCRYPT_ECC_FULLKEY_BLOB_V1 = 0x1;
alias ECC_CURVE_TYPE_ENUM = int;
enum : ECC_CURVE_TYPE_ENUM {
BCRYPT_ECC_PRIME_SHORT_WEIERSTRASS_CURVE = 0x1,
BCRYPT_ECC_PRIME_TWISTED_EDWARDS_CURVE = 0x2,
BCRYPT_ECC_PRIME_MONTGOMERY_CURVE = 0x3
}
alias ECC_CURVE_ALG_ID_ENUM = int;
enum : ECC_CURVE_ALG_ID_ENUM {
BCRYPT_NO_CURVE_GENERATION_ALG_ID = 0x0,
}
struct BCRYPT_ECCFULLKEY_BLOB {
ULONG dwMagic;
ULONG dwVersion;
ECC_CURVE_TYPE_ENUM dwCurveType;
ECC_CURVE_ALG_ID_ENUM dwCurveGenerationAlgId;
ULONG cbFieldLength;
ULONG cbSubgroupOrder;
ULONG cbCofactor;
ULONG cbSeed;
}
alias PBCRYPT_ECCFULLKEY_BLOB = BCRYPT_ECCFULLKEY_BLOB*;
}
struct BCRYPT_DH_KEY_BLOB {
ULONG dwMagic;
ULONG cbKey;
}
alias PBCRYPT_DH_KEY_BLOB = BCRYPT_DH_KEY_BLOB*;
struct BCRYPT_DH_PARAMETER_HEADER {
ULONG cbLength;
ULONG dwMagic;
ULONG cbKeyLength;
}
struct BCRYPT_DSA_KEY_BLOB {
ULONG dwMagic;
ULONG cbKey;
UCHAR[4] Count;
UCHAR[20] Seed;
UCHAR[20] q;
}
alias PBCRYPT_DSA_KEY_BLOB = BCRYPT_DSA_KEY_BLOB*;
alias HASHALGORITHM_ENUM = int;
enum : HASHALGORITHM_ENUM {
DSA_HASH_ALGORITHM_SHA1,
DSA_HASH_ALGORITHM_SHA256,
DSA_HASH_ALGORITHM_SHA512,
}
alias DSAFIPSVERSION_ENUM = int;
enum : DSAFIPSVERSION_ENUM {
DSA_FIPS186_2,
DSA_FIPS186_3,
}
struct BCRYPT_DSA_KEY_BLOB_V2 {
ULONG dwMagic;
ULONG cbKey;
HASHALGORITHM_ENUM hashAlgorithm;
DSAFIPSVERSION_ENUM standardVersion;
ULONG cbSeedLength;
ULONG cbGroupSize;
UCHAR[4] Count;
}
alias PBCRYPT_DSA_KEY_BLOB_V2 = BCRYPT_DSA_KEY_BLOB_V2*;
struct BCRYPT_KEY_DATA_BLOB_HEADER {
ULONG dwMagic;
ULONG dwVersion;
ULONG cbKeyData;
}
alias PBCRYPT_KEY_DATA_BLOB_HEADER = BCRYPT_KEY_DATA_BLOB_HEADER*;
struct BCRYPT_DSA_PARAMETER_HEADER {
ULONG cbLength;
ULONG dwMagic;
ULONG cbKeyLength;
UCHAR[4] Count;
UCHAR[20] Seed;
UCHAR[20] q;
}
struct BCRYPT_DSA_PARAMETER_HEADER_V2 {
ULONG cbLength;
ULONG dwMagic;
ULONG cbKeyLength;
HASHALGORITHM_ENUM hashAlgorithm;
DSAFIPSVERSION_ENUM standardVersion;
ULONG cbSeedLength;
ULONG cbGroupSize;
UCHAR[4] Count;
}
struct BCRYPT_ECC_CURVE_NAMES {
ULONG dwEccCurveNames;
LPWSTR* pEccCurveNames;
}
alias BCRYPT_HASH_OPERATION_TYPE = int;
enum : BCRYPT_HASH_OPERATION_TYPE {
BCRYPT_HASH_OPERATION_HASH_DATA = 1,
BCRYPT_HASH_OPERATION_FINISH_HASH = 2,
}
struct BCRYPT_MULTI_HASH_OPERATION {
ULONG iHash;
BCRYPT_HASH_OPERATION_TYPE hashOperation;
PUCHAR pbBuffer;
ULONG cbBuffer;
}
alias BCRYPT_MULTI_OPERATION_TYPE = int;
enum : BCRYPT_MULTI_OPERATION_TYPE {
BCRYPT_OPERATION_TYPE_HASH = 1,
}
struct BCRYPT_MULTI_OBJECT_LENGTH_STRUCT {
ULONG cbPerObject;
ULONG cbPerElement;
}
struct BCRYPT_ALGORITHM_IDENTIFIER {
LPWSTR pszName;
ULONG dwClass;
ULONG dwFlags;
}
struct BCRYPT_PROVIDER_NAME {
LPWSTR pszProviderName;
}
struct BCRYPT_INTERFACE_VERSION {
USHORT MajorVersion;
USHORT MinorVersion;
}
alias PBCRYPT_INTERFACE_VERSION = BCRYPT_INTERFACE_VERSION*;
struct CRYPT_INTERFACE_REG {
ULONG dwInterface;
ULONG dwFlags;
ULONG cFunctions;
PWSTR* rgpszFunctions;
}
alias PCRYPT_INTERFACE_REG = CRYPT_INTERFACE_REG*;
struct CRYPT_IMAGE_REG {
PWSTR pszImage;
ULONG cInterfaces;
PCRYPT_INTERFACE_REG* rgpInterfaces;
}
alias PCRYPT_IMAGE_REG = CRYPT_IMAGE_REG*;
struct CRYPT_PROVIDER_REG {
ULONG cAliases;
PWSTR* rgpszAliases;
PCRYPT_IMAGE_REG pUM;
PCRYPT_IMAGE_REG pKM;
}
alias PCRYPT_PROVIDER_REG = CRYPT_PROVIDER_REG*;
struct CRYPT_PROVIDERS {
ULONG cProviders;
PWSTR* rgpszProviders;
}
alias PCRYPT_PROVIDERS = CRYPT_PROVIDERS*;
struct CRYPT_CONTEXT_CONFIG {
ULONG dwFlags;
ULONG dwReserved;
}
alias PCRYPT_CONTEXT_CONFIG = CRYPT_CONTEXT_CONFIG*;
struct CRYPT_CONTEXT_FUNCTION_CONFIG {
ULONG dwFlags;
ULONG dwReserved;
}
alias PCRYPT_CONTEXT_FUNCTION_CONFIG = CRYPT_CONTEXT_FUNCTION_CONFIG*;
struct CRYPT_CONTEXTS {
ULONG cContexts;
PWSTR* rgpszContexts;
}
alias PCRYPT_CONTEXTS = CRYPT_CONTEXTS*;
struct CRYPT_CONTEXT_FUNCTIONS {
ULONG cFunctions;
PWSTR* rgpszFunctions;
}
alias PCRYPT_CONTEXT_FUNCTIONS = CRYPT_CONTEXT_FUNCTIONS*;
struct CRYPT_CONTEXT_FUNCTION_PROVIDERS {
ULONG cProviders;
PWSTR* rgpszProviders;
}
alias PCRYPT_CONTEXT_FUNCTION_PROVIDERS = CRYPT_CONTEXT_FUNCTION_PROVIDERS*;
struct CRYPT_PROPERTY_REF {
PWSTR pszProperty;
ULONG cbValue;
PUCHAR pbValue;
}
alias PCRYPT_PROPERTY_REF = CRYPT_PROPERTY_REF*;
struct CRYPT_IMAGE_REF {
PWSTR pszImage;
ULONG dwFlags;
}
alias PCRYPT_IMAGE_REF = CRYPT_IMAGE_REF*;
struct CRYPT_PROVIDER_REF {
ULONG dwInterface;
PWSTR pszFunction;
PWSTR pszProvider;
ULONG cProperties;
PCRYPT_PROPERTY_REF* rgpProperties;
PCRYPT_IMAGE_REF pUM;
PCRYPT_IMAGE_REF pKM;
}
alias PCRYPT_PROVIDER_REF = CRYPT_PROVIDER_REF*;
struct CRYPT_PROVIDER_REFS {
ULONG cProviders;
PCRYPT_PROVIDER_REF* rgpProviders;
}
alias PCRYPT_PROVIDER_REFS = CRYPT_PROVIDER_REFS*;
extern(Windows) @nogc nothrow {
NTSTATUS BCryptOpenAlgorithmProvider(scope BCRYPT_ALG_HANDLE* phAlgorithm, scope LPCWSTR pszAlgId, scope LPCWSTR pszImplementation, ULONG dwFlags);
NTSTATUS BCryptEnumAlgorithms(ULONG dwAlgOperations, scope ULONG* pAlgCount, scope BCRYPT_ALGORITHM_IDENTIFIER** ppAlgList, ULONG dwFlags);
NTSTATUS BCryptEnumProviders(scope LPCWSTR pszAlgId, scope ULONG* pImplCount, scope BCRYPT_PROVIDER_NAME** ppImplList, ULONG dwFlags);
NTSTATUS BCryptGetProperty(BCRYPT_HANDLE hObject, scope LPCWSTR pszProperty, scope PUCHAR pbOutput, ULONG cbOutput, scope ULONG* pcbResult, ULONG dwFlags);
NTSTATUS BCryptSetProperty(BCRYPT_HANDLE hObject, scope LPCWSTR pszProperty, scope PUCHAR pbInput, ULONG cbInput, ULONG dwFlags);
NTSTATUS BCryptCloseAlgorithmProvider(BCRYPT_ALG_HANDLE hAlgorithm, ULONG dwFlags);
VOID BCryptFreeBuffer(PVOID pvBuffer);
NTSTATUS BCryptGenerateSymmetricKey(BCRYPT_ALG_HANDLE hAlgorithm, scope BCRYPT_KEY_HANDLE* phKey, scope PUCHAR pbKeyObject, ULONG cbKeyObject, scope PUCHAR pbSecret, ULONG cbSecret, ULONG dwFlags);
NTSTATUS BCryptGenerateKeyPair(BCRYPT_ALG_HANDLE hAlgorithm, scope BCRYPT_KEY_HANDLE* phKey, ULONG dwLength, ULONG dwFlags);
NTSTATUS BCryptEncrypt(BCRYPT_KEY_HANDLE hKey, scope PUCHAR pbInput, ULONG cbInput, scope VOID* pPaddingInfo, scope PUCHAR pbIV, ULONG cbIV, scope PUCHAR pbOutput, ULONG cbOutput, scope ULONG* pcbResult, ULONG dwFlags);
NTSTATUS BCryptDecrypt(BCRYPT_KEY_HANDLE hKey, scope PUCHAR pbInput, ULONG cbInput, scope VOID* pPaddingInfo, scope PUCHAR pbIV, ULONG cbIV, scope PUCHAR pbOutput, ULONG cbOutput, scope ULONG* pcbResult, ULONG dwFlags);
NTSTATUS BCryptExportKey(BCRYPT_KEY_HANDLE hKey, BCRYPT_KEY_HANDLE hExportKey, scope LPCWSTR pszBlobType, scope PUCHAR pbOutput, ULONG cbOutput, scope ULONG* pcbResult, ULONG dwFlags);
NTSTATUS BCryptImportKey(BCRYPT_ALG_HANDLE hAlgorithm, BCRYPT_KEY_HANDLE hImportKey, scope LPCWSTR pszBlobType, scope BCRYPT_KEY_HANDLE* phKey, scope PUCHAR pbKeyObject, ULONG cbKeyObject, scope PUCHAR pbInput, ULONG cbInput, ULONG dwFlags);
NTSTATUS BCryptImportKeyPair(BCRYPT_ALG_HANDLE hAlgorithm, BCRYPT_KEY_HANDLE hImportKey, scope LPCWSTR pszBlobType, scope BCRYPT_KEY_HANDLE* phKey, scope PUCHAR pbInput, ULONG cbInput, ULONG dwFlags);
NTSTATUS BCryptDuplicateKey(BCRYPT_KEY_HANDLE hKey, scope BCRYPT_KEY_HANDLE* phNewKey, scope PUCHAR pbKeyObject, ULONG cbKeyObject, ULONG dwFlags);
NTSTATUS BCryptFinalizeKeyPair(BCRYPT_KEY_HANDLE hKey, ULONG dwFlags);
NTSTATUS BCryptDestroyKey(BCRYPT_KEY_HANDLE hKey);
NTSTATUS BCryptDestroySecret(BCRYPT_SECRET_HANDLE hSecret);
NTSTATUS BCryptSignHash(BCRYPT_KEY_HANDLE hKey, scope VOID* pPaddingInfo, scope PUCHAR pbInput, ULONG cbInput, scope PUCHAR pbOutput, ULONG cbOutput, scope ULONG* pcbResult, ULONG dwFlags);
NTSTATUS BCryptVerifySignature(BCRYPT_KEY_HANDLE hKey, scope VOID* pPaddingInfo, scope PUCHAR pbHash, ULONG cbHash, scope PUCHAR pbSignature, ULONG cbSignature, ULONG dwFlags);
NTSTATUS BCryptSecretAgreement(BCRYPT_KEY_HANDLE hPrivKey, BCRYPT_KEY_HANDLE hPubKey, scope BCRYPT_SECRET_HANDLE* phAgreedSecret, ULONG dwFlags);
NTSTATUS BCryptDeriveKey(BCRYPT_SECRET_HANDLE hSharedSecret, LPCWSTR pwszKDF, scope BCryptBufferDesc* pParameterList, scope PUCHAR pbDerivedKey, ULONG cbDerivedKey, scope ULONG* pcbResult, ULONG dwFlags);
NTSTATUS BCryptKeyDerivation(BCRYPT_KEY_HANDLE hKey, scope BCryptBufferDesc* pParameterList, scope PUCHAR pbDerivedKey, ULONG cbDerivedKey, scope ULONG* pcbResult, ULONG dwFlags);
NTSTATUS BCryptCreateHash(BCRYPT_ALG_HANDLE hAlgorithm, scope BCRYPT_HASH_HANDLE* phHash, scope PUCHAR pbHashObject, ULONG cbHashObject, scope PUCHAR pbSecret, ULONG cbSecret, ULONG dwFlags);
NTSTATUS BCryptHashData(BCRYPT_HASH_HANDLE hHash, scope PUCHAR pbInput, ULONG cbInput, ULONG dwFlags);
NTSTATUS BCryptFinishHash(BCRYPT_HASH_HANDLE hHash, scope PUCHAR pbOutput, ULONG cbOutput, ULONG dwFlags);
static if (NTDDI_VERSION >= NTDDI_WINBLUE) {
NTSTATUS BCryptCreateMultiHash(BCRYPT_ALG_HANDLE hAlgorithm, scope BCRYPT_HASH_HANDLE* phHash, ULONG nHashes, scope PUCHAR pbHashObject, ULONG cbHashObject, scope PUCHAR pbSecret, ULONG cbSecret, ULONG dwFlags);
NTSTATUS BCryptProcessMultiOperations(BCRYPT_HANDLE hObject, BCRYPT_MULTI_OPERATION_TYPE operationType, scope PVOID pOperations, ULONG cbOperations, ULONG dwFlags);
}
NTSTATUS BCryptDuplicateHash(BCRYPT_HASH_HANDLE hHash, scope BCRYPT_HASH_HANDLE* phNewHash, scope PUCHAR pbHashObject, ULONG cbHashObject, ULONG dwFlags);
NTSTATUS BCryptDestroyHash(BCRYPT_HASH_HANDLE hHash);
static if (NTDDI_VERSION >= NTDDI_WINTHRESHOLD) {
NTSTATUS BCryptHash(BCRYPT_ALG_HANDLE hAlgorithm, scope PUCHAR pbSecret, ULONG cbSecret, scope PUCHAR pbInput, ULONG cbInput, scope PUCHAR pbOutput, ULONG cbOutput);
}
NTSTATUS BCryptGenRandom(BCRYPT_ALG_HANDLE hAlgorithm, scope PUCHAR pbBuffer, ULONG cbBuffer, ULONG dwFlags);
NTSTATUS BCryptDeriveKeyCapi(BCRYPT_HASH_HANDLE hHash, BCRYPT_ALG_HANDLE hTargetAlg, scope PUCHAR pbDerivedKey, ULONG cbDerivedKey, ULONG dwFlags);
NTSTATUS BCryptDeriveKeyPBKDF2(BCRYPT_ALG_HANDLE hPrf, scope PUCHAR pbPassword, ULONG cbPassword, scope PUCHAR pbSalt, ULONG cbSalt, ULONGLONG cIterations, scope PUCHAR pbDerivedKey, ULONG cbDerivedKey, ULONG dwFlags);
NTSTATUS BCryptResolveProviders(scope LPCWSTR pszContext, ULONG dwInterface, scope LPCWSTR pszFunction, scope LPCWSTR pszProvider, ULONG dwMode, ULONG dwFlags, scope ULONG* pcbBuffer, scope PCRYPT_PROVIDER_REFS* ppBuffer);
NTSTATUS BCryptGetFipsAlgorithmMode(scope BOOLEAN* pfEnabled);
NTSTATUS BCryptQueryProviderRegistration(scope LPCWSTR pszProvider, ULONG dwMode, ULONG dwInterface, scope ULONG* pcbBuffer, scope PCRYPT_PROVIDER_REG* ppBuffer);
NTSTATUS BCryptEnumRegisteredProviders(scope ULONG* pcbBuffer, scope PCRYPT_PROVIDERS* ppBuffer);
NTSTATUS BCryptCreateContext(ULONG dwTable, scope LPCWSTR pszContext, PCRYPT_CONTEXT_CONFIG pConfig);
NTSTATUS BCryptDeleteContext(ULONG dwTable, scope LPCWSTR pszContext);
NTSTATUS BCryptEnumContexts(ULONG dwTable, scope ULONG* pcbBuffer, scope PCRYPT_CONTEXTS* ppBuffer);
NTSTATUS BCryptConfigureContext(ULONG dwTable, scope LPCWSTR pszContext, PCRYPT_CONTEXT_CONFIG pConfig);
NTSTATUS BCryptQueryContextConfiguration(ULONG dwTable, scope LPCWSTR pszContext, scope ULONG* pcbBuffer, scope PCRYPT_CONTEXT_CONFIG* ppBuffer);
NTSTATUS BCryptAddContextFunction(ULONG dwTable, scope LPCWSTR pszContext, ULONG dwInterface, scope LPCWSTR pszFunction, ULONG dwPosition);
NTSTATUS BCryptRemoveContextFunction(ULONG dwTable, scope LPCWSTR pszContext, ULONG dwInterface, scope LPCWSTR pszFunction);
NTSTATUS BCryptEnumContextFunctions(ULONG dwTable, scope LPCWSTR pszContext, ULONG dwInterface, scope ULONG* pcbBuffer, scope PCRYPT_CONTEXT_FUNCTIONS* ppBuffer);
NTSTATUS BCryptConfigureContextFunction(ULONG dwTable, scope LPCWSTR pszContext, ULONG dwInterface, scope LPCWSTR pszFunction, PCRYPT_CONTEXT_FUNCTION_CONFIG pConfig);
NTSTATUS BCryptQueryContextFunctionConfiguration(ULONG dwTable, scope LPCWSTR pszContext, ULONG dwInterface, scope LPCWSTR pszFunction, scope ULONG* pcbBuffer, scope PCRYPT_CONTEXT_FUNCTION_CONFIG* ppBuffer);
NTSTATUS BCryptEnumContextFunctionProviders(ULONG dwTable, scope LPCWSTR pszContext, ULONG dwInterface, scope LPCWSTR pszFunction, scope ULONG* pcbBuffer, scope PCRYPT_CONTEXT_FUNCTION_PROVIDERS* ppBuffer);
NTSTATUS BCryptSetContextFunctionProperty(ULONG dwTable, scope LPCWSTR pszContext, ULONG dwInterface, scope LPCWSTR pszFunction, LPCWSTR pszProperty, ULONG cbValue, scope PUCHAR pbValue);
NTSTATUS BCryptQueryContextFunctionProperty(ULONG dwTable, scope LPCWSTR pszContext, ULONG dwInterface, scope LPCWSTR pszFunction, LPCWSTR pszProperty, ULONG* pcbValue, scope PUCHAR* ppbValue);
deprecated NTSTATUS BCryptRegisterConfigChangeNotify(scope HANDLE* phEvent);
NTSTATUS BCryptUnregisterConfigChangeNotify(HANDLE hEvent);
}

View file

@ -7,9 +7,10 @@
* Source: $(DRUNTIMESRC core/sys/windows/sdkddkver.d) * Source: $(DRUNTIMESRC core/sys/windows/sdkddkver.d)
*/ */
module core.sys.windows.sdkddkver; module core.sys.windows.sdkddkver;
version (Windows): version (Windows):
import core.sys.windows.w32api;
enum _WIN32_WINNT_NT4 = 0x0400; enum _WIN32_WINNT_NT4 = 0x0400;
enum _WIN32_WINNT_WIN2K = 0x0500; enum _WIN32_WINNT_WIN2K = 0x0500;
enum _WIN32_WINNT_WINXP = 0x0501; enum _WIN32_WINNT_WINXP = 0x0501;
@ -21,6 +22,7 @@ enum _WIN32_WINNT_LONGHORN = 0x0600;
enum _WIN32_WINNT_WIN7 = 0x0601; enum _WIN32_WINNT_WIN7 = 0x0601;
enum _WIN32_WINNT_WIN8 = 0x0602; enum _WIN32_WINNT_WIN8 = 0x0602;
enum _WIN32_WINNT_WINBLUE = 0x0603; enum _WIN32_WINNT_WINBLUE = 0x0603;
enum _WIN32_WINNT_WINTHRESHOLD = 0x0A00;
enum _WIN32_WINNT_WIN10 = 0x0A00; enum _WIN32_WINNT_WIN10 = 0x0A00;
enum _WIN32_IE_IE20 = 0x0200; enum _WIN32_IE_IE20 = 0x0200;
@ -38,6 +40,7 @@ enum _WIN32_IE_IE70 = 0x0700;
enum _WIN32_IE_IE80 = 0x0800; enum _WIN32_IE_IE80 = 0x0800;
enum _WIN32_IE_IE90 = 0x0900; enum _WIN32_IE_IE90 = 0x0900;
enum _WIN32_IE_IE100 = 0x0A00; enum _WIN32_IE_IE100 = 0x0A00;
enum _WIN32_IE_IE110 = 0x0A00;
enum _WIN32_IE_NT4 = _WIN32_IE_IE20; enum _WIN32_IE_NT4 = _WIN32_IE_IE20;
enum _WIN32_IE_NT4SP1 = _WIN32_IE_IE20; enum _WIN32_IE_NT4SP1 = _WIN32_IE_IE20;
@ -64,6 +67,8 @@ enum _WIN32_IE_LONGHORN = _WIN32_IE_IE70;
enum _WIN32_IE_WIN7 = _WIN32_IE_IE80; enum _WIN32_IE_WIN7 = _WIN32_IE_IE80;
enum _WIN32_IE_WIN8 = _WIN32_IE_IE100; enum _WIN32_IE_WIN8 = _WIN32_IE_IE100;
enum _WIN32_IE_WINBLUE = _WIN32_IE_IE100; enum _WIN32_IE_WINBLUE = _WIN32_IE_IE100;
enum _WIN32_IE_WINTHRESHOLD = _WIN32_IE_IE110;
enum _WIN32_IE_WIN10 = _WIN32_IE_IE110;
enum NTDDI_WIN2K = 0x05000000; enum NTDDI_WIN2K = 0x05000000;
@ -106,12 +111,45 @@ enum NTDDI_WS08SP4 = NTDDI_WIN6SP4;
enum NTDDI_WIN7 = 0x06010000; enum NTDDI_WIN7 = 0x06010000;
enum NTDDI_WIN8 = 0x06020000; enum NTDDI_WIN8 = 0x06020000;
enum NTDDI_WINBLUE = 0x06030000; enum NTDDI_WINBLUE = 0x06030000;
enum NTDDI_WINTHRESHOLD = 0x0A000000;
enum NTDDI_WIN10 = 0x0A000000;
enum NTDDI_WIN10_TH2 = 0x0A000001;
enum NTDDI_WIN10_RS1 = 0x0A000002;
enum NTDDI_WIN10_RS2 = 0x0A000003;
enum NTDDI_WIN10_RS3 = 0x0A000004;
enum NTDDI_WIN10_RS4 = 0x0A000005;
enum NTDDI_WIN10_RS5 = 0x0A000006;
enum NTDDI_WIN10_19H1 = 0x0A000007;
enum NTDDI_WIN10_VB = 0x0A000008;
enum NTDDI_WIN10_MN = 0x0A000009;
enum NTDDI_WIN10_FE = 0x0A00000A;
enum NTDDI_WIN10_CO = 0x0A00000B;
enum NTDDI_WIN10_NI = 0x0A00000C;
enum NTDDI_WIN10_CU = 0x0A00000D;
enum NTDDI_WIN11_ZN = 0x0A00000E;
enum NTDDI_WIN11_GA = 0x0A00000F;
enum NTDDI_WIN11_GE = 0x0A000010;
enum OSVERSION_MASK = 0xFFFF0000; enum WDK_NTDDI_VERSION = NTDDI_WIN11_GE;
enum OSVERSION_MASK = 0xFFFF0000U;
enum SPVERSION_MASK = 0x0000FF00; enum SPVERSION_MASK = 0x0000FF00;
enum SUBVERSION_MASK = 0x000000FF; enum SUBVERSION_MASK = 0x000000FF;
enum _WIN32_WINNT = 0x0603; pragma(inline, true) @nogc nothrow pure @safe {
uint OSVER(uint Version) => Version & OSVERSION_MASK;
uint SPVER(uint Version) => (Version & SPVERSION_MASK) >> 8;
uint SUBVER(uint Version) => Version & SUBVERSION_MASK;
enum NTDDI_VERSION = 0x06030000; uint NTDDI_VERSION_FROM_WIN32_WINNT2(uint Version) => Version * 0x10000;
enum WINVER = _WIN32_WINNT; alias NTDDI_VERSION_FROM_WIN32_WINNT = NTDDI_VERSION_FROM_WIN32_WINNT2;
}
static if (_WIN32_WINNT < _WIN32_WINNT_WIN10) {
enum NTDDI_VERSION = NTDDI_VERSION_FROM_WIN32_WINNT(_WIN32_WINNT);
} else {
enum NTDDI_VERSION = WDK_NTDDI_VERSION;
}
enum WINVER = _WIN32_WINNT;

View file

@ -10,12 +10,45 @@
module core.sys.windows.w32api; module core.sys.windows.w32api;
version (Windows): version (Windows):
import core.sys.windows.sdkddkver;
version (ANSI) {} else version = Unicode; version (ANSI) {} else version = Unicode;
enum __W32API_VERSION = 3.17; enum __W32API_VERSION = 3.17;
enum __W32API_MAJOR_VERSION = 3; enum __W32API_MAJOR_VERSION = 3;
enum __W32API_MINOR_VERSION = 17; enum __W32API_MINOR_VERSION = 17;
enum Windows95 = 0x0400;
enum Windows98 = 0x0410;
enum WindowsME = 0x0500;
enum WindowsNT4 = 0x0400;
enum Windows2000 = 0x0500;
enum WindowsXP = 0x0501;
enum Windows2003 = 0x0502;
enum WindowsVista = 0x0600;
enum Windows7 = 0x0601;
enum Windows8 = 0x0602;
enum IE3 = 0x0300;
enum IE301 = 0x0300;
enum IE302 = 0x0300;
enum IE4 = 0x0400;
enum IE401 = 0x0401;
enum IE5 = 0x0500;
enum IE5a = 0x0500;
enum IE5b = 0x0500;
enum IE501 = 0x0501;
enum IE55 = 0x0501;
enum IE56 = 0x0560;
enum IE6 = 0x0600;
enum IE601 = 0x0601;
enum IE602 = 0x0603;
enum IE7 = 0x0700;
enum IE8 = 0x0800;
enum IE9 = 0x0900;
enum IE10 = 0x0A00;
/* These version identifiers are used to specify the minimum version of Windows that an /* These version identifiers are used to specify the minimum version of Windows that an
* application will support. * application will support.
* *
@ -23,62 +56,64 @@ enum __W32API_MINOR_VERSION = 17;
* Windows 9x is no longer supported, either by Microsoft or by DMD, this distinction has been * Windows 9x is no longer supported, either by Microsoft or by DMD, this distinction has been
* removed in order to simplify the bindings. * removed in order to simplify the bindings.
*/ */
version (Windows10) { version (Windows11) {
enum uint _WIN32_WINNT = 0xA00; enum uint _WIN32_WINNT = _WIN32_WINNT_WIN10;
} else version (Windows10) {
enum uint _WIN32_WINNT = _WIN32_WINNT_WIN10;
} else version (Windows8_1) { // also Windows2012R2 } else version (Windows8_1) { // also Windows2012R2
enum uint _WIN32_WINNT = 0x603; enum uint _WIN32_WINNT = _WIN32_WINNT_WINBLUE;
} else version (Windows8) { // also Windows2012 } else version (Windows8) { // also Windows2012
enum uint _WIN32_WINNT = 0x602; enum uint _WIN32_WINNT = _WIN32_WINNT_WIN8;
} else version (Windows7) { // also Windows2008R2 } else version (Windows7) { // also Windows2008R2
enum uint _WIN32_WINNT = 0x601; enum uint _WIN32_WINNT = _WIN32_WINNT_WIN7;
} else version (WindowsVista) { // also Windows2008 } else version (WindowsVista) { // also Windows2008
enum uint _WIN32_WINNT = 0x600; enum uint _WIN32_WINNT = _WIN32_WINNT_VISTA;
} else version (Windows2003) { // also WindowsHomeServer, WindowsXP64 } else version (Windows2003) { // also WindowsHomeServer, WindowsXP64
enum uint _WIN32_WINNT = 0x502; enum uint _WIN32_WINNT = _WIN32_WINNT_WS03;
} else version (WindowsXP) { } else version (WindowsXP) {
enum uint _WIN32_WINNT = 0x501; enum uint _WIN32_WINNT = _WIN32_WINNT_WINXP;
} else version (Windows2000) { } else version (Windows2000) {
// Current DMD doesn't support any version of Windows older than XP, // Current DMD doesn't support any version of Windows older than XP,
// but third-party compilers could use this // but third-party compilers could use this
enum uint _WIN32_WINNT = 0x500; enum uint _WIN32_WINNT = _WIN32_WINNT_WIN2K;
} else { } else {
enum uint _WIN32_WINNT = 0x601; enum uint _WIN32_WINNT = _WIN32_WINNT_WIN7;
} }
version (IE11) { version (IE11) {
enum uint _WIN32_IE = 0xA00; enum uint _WIN32_IE = _WIN32_IE_IE110;
} else version (IE10) { } else version (IE10) {
enum uint _WIN32_IE = 0xA00; enum uint _WIN32_IE = _WIN32_IE_IE100;
} else version (IE9) { } else version (IE9) {
enum uint _WIN32_IE = 0x900; enum uint _WIN32_IE = _WIN32_IE_IE90;
} else version (IE8) { } else version (IE8) {
enum uint _WIN32_IE = 0x800; enum uint _WIN32_IE = _WIN32_IE_IE80;
} else version (IE7) { } else version (IE7) {
enum uint _WIN32_IE = 0x700; enum uint _WIN32_IE = _WIN32_IE_IE70;
} else version (IE602) { } else version (IE602) {
enum uint _WIN32_IE = 0x603; enum uint _WIN32_IE = _WIN32_IE_IE60SP2;
} else version (IE601) { } else version (IE601) {
enum uint _WIN32_IE = 0x601; enum uint _WIN32_IE = _WIN32_IE_IE60SP1;
} else version (IE6) { } else version (IE6) {
enum uint _WIN32_IE = 0x600; enum uint _WIN32_IE = _WIN32_IE_IE60;
} else version (IE56) { } else version (IE56) {
enum uint _WIN32_IE = 0x560; enum uint _WIN32_IE = _WIN32_IE_IE60;
} else version (IE55) { } else version (IE55) {
enum uint _WIN32_IE = 0x550; enum uint _WIN32_IE = _WIN32_IE_IE55;
} else version (IE501) { } else version (IE501) {
enum uint _WIN32_IE = 0x501; enum uint _WIN32_IE = _WIN32_IE_IE501;
} else version (IE5) { } else version (IE5) {
enum uint _WIN32_IE = 0x500; enum uint _WIN32_IE = _WIN32_IE_IE50;
} else version (IE401) { } else version (IE401) {
enum uint _WIN32_IE = 0x401; enum uint _WIN32_IE = _WIN32_IE_IE401;
} else version (IE4) { } else version (IE4) {
enum uint _WIN32_IE = 0x400; enum uint _WIN32_IE = _WIN32_IE_IE40;
} else version (IE3) { } else version (IE3) {
enum uint _WIN32_IE = 0x300; enum uint _WIN32_IE = _WIN32_IE_IE30;
} else static if (_WIN32_WINNT >= 0x500) { } else static if (_WIN32_WINNT >= _WIN32_WINNT_WIN2K) {
enum uint _WIN32_IE = 0x600; enum uint _WIN32_IE = _WIN32_IE_IE60;
} else static if (_WIN32_WINNT >= 0x410) { } else static if (_WIN32_WINNT >= Windows98) { //NOTE: _WIN32_WINNT will never be set this low
enum uint _WIN32_IE = 0x400; enum uint _WIN32_IE = _WIN32_IE_IE40;
} else { } else {
enum uint _WIN32_IE = 0; enum uint _WIN32_IE = 0;
} }