erabo/spiegel-keyman
1
0
Fork 0
mirror of https://github.com/keymanapp/keyman.git synced 2026-08-07 17:36:00 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 12
spiegel-keyman/common/windows/delphi/ext/jwa/Win32API/JwaBCrypt.pas
Marc Durdin fc7917cdca chore(windows): move JWA to common
2022-06-06 08:13:37 +10:00

1934 lines
60 KiB
ObjectPascal
Raw Blame History

{******************************************************************************}
{ }
{ BCrypt.pas Interface Unit for Object Pascal }
{ }
{ Portions created by Microsoft are Copyright (C) 1995-2005 Microsoft }
{ Corporation. All Rights Reserved. }
{ }
{ The initial developer of the original translation is Rudy Velthuis }
{ }
{ Portions created by Rudy Velthuis are Copyright (C) 2005-2008 }
{ All Rights Reserved. }
{ }
{ Adapted for JEDI API Library by Christian Wimmer }
{ }
{ Obtained through: Joint Endeavour of Delphi Innovators (Project JEDI) }
{ The original code is: bcrypt.h, released 1992-1999. }
{ }
{ You may retrieve the latest version of this file at the Project JEDI }
{ APILIB home page, located at http://jedi-apilib.sourceforge.net }
{ }
{ The contents of this file are used with permission, subject to the Mozilla }
{ Public License Version 1.1 (the "License"); you may not use this file except }
{ in compliance with the License. You may obtain a copy of the License at }
{ http://www.mozilla.org/MPL/MPL-1.1.html }
{ }
{ Software distributed under the License is distributed on an "AS IS" basis, }
{ WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for }
{ the specific language governing rights and limitations under the License. }
{ }
{ Alternatively, the contents of this file may be used under the terms of the }
{ GNU Lesser General Public License (the "LGPL License"), in which case the }
{ provisions of the LGPL License are applicable instead of those above. }
{ If you wish to allow use of your version of this file only under the terms }
{ of the LGPL License and not to allow others to use your version of this file }
{ under the MPL, indicate your decision by deleting the provisions above and }
{ replace them with the notice and other provisions required by the LGPL }
{ License. If you do not delete the provisions above, a recipient may use }
{ your version of this file under either the MPL or the LGPL License. }
{ }
{ For more information about the LGPL: http://www.gnu.org/copyleft/lesser.html }
{ }
{******************************************************************************}
{$IFNDEF JWA_OMIT_SECTIONS}
unit JwaBCrypt;
{$IFDEF DELPHI6_UP}
{$ALIGN 8}
{$ELSE}
{$A+}
//Warning: Record alignment 4
{$ENDIF DELPHI6_UP}
interface
uses
JwaWinType, JwaNtStatus, JwaWinBase, JwaWinCrypt;
{$ENDIF JWA_OMIT_SECTIONS}
{$IFNDEF JWA_IMPLEMENTATIONSECTION}
//
// DeriveKey KDF Types
//
const
{$EXTERNALSYM BCRYPT_KDF_HASH}
BCRYPT_KDF_HASH = 'HASH';
{$EXTERNALSYM BCRYPT_KDF_HMAC}
BCRYPT_KDF_HMAC = 'HMAC';
{$EXTERNALSYM BCRYPT_KDF_TLS_PRF}
BCRYPT_KDF_TLS_PRF = 'TLS_PRF';
//
// DeriveKey KDF BufferTypes
//
// For BCRYPT_KDF_HASH and BCRYPT_KDF_HMAC operations, there may be an arbitrary
// number of KDF_SECRET_PREPEND and KDF_SECRET_APPEND buffertypes in the
// parameter list. The BufferTypes are processed in order of appearence
// within the parameter list.
//
{$EXTERNALSYM KDF_HASH_ALGORITHM}
KDF_HASH_ALGORITHM = $0;
{$EXTERNALSYM KDF_SECRET_PREPEND}
KDF_SECRET_PREPEND = $1;
{$EXTERNALSYM KDF_SECRET_APPEND}
KDF_SECRET_APPEND = $2;
{$EXTERNALSYM KDF_HMAC_KEY}
KDF_HMAC_KEY = $3;
{$EXTERNALSYM KDF_TLS_PRF_LABEL}
KDF_TLS_PRF_LABEL = $4;
{$EXTERNALSYM KDF_TLS_PRF_SEED}
KDF_TLS_PRF_SEED = $5;
{$EXTERNALSYM KDF_SECRET_HANDLE}
KDF_SECRET_HANDLE = $6;
//
// DeriveKey Flags:
//
// KDF_USE_SECRET_AS_HMAC_KEY_FLAG causes the secret agreement to serve also
// as the HMAC key. If this flag is used, the KDF_HMAC_KEY parameter should
// NOT be specified.
//
{$EXTERNALSYM KDF_USE_SECRET_AS_HMAC_KEY_FLAG}
KDF_USE_SECRET_AS_HMAC_KEY_FLAG = $1;
//
// BCrypt structs
//
type
PBCryptKeyLengthsStruct = ^TBCryptKeyLengthsStruct;
{$EXTERNALSYM __BCRYPT_KEY_LENGTHS_STRUCT}
__BCRYPT_KEY_LENGTHS_STRUCT = record
dwMinLength: ULONG;
dwMaxLength: ULONG;
dwIncrement: ULONG;
end;
{$EXTERNALSYM BCRYPT_KEY_LENGTHS_STRUCT}
BCRYPT_KEY_LENGTHS_STRUCT = __BCRYPT_KEY_LENGTHS_STRUCT;
TBCryptKeyLengthsStruct = __BCRYPT_KEY_LENGTHS_STRUCT;
PBCryptOID = ^TBCryptOID;
{$EXTERNALSYM _BCRYPT_OID}
_BCRYPT_OID = packed record
cbOID: ULONG;
pbOID: PUCHAR;
end;
{$EXTERNALSYM BCRYPT_OID}
BCRYPT_OID = _BCRYPT_OID;
TBCryptOID = _BCRYPT_OID;
PBCryptOIDList = ^TBCryptOIDList;
{$EXTERNALSYM _BCRYPT_OID_LIST}
_BCRYPT_OID_LIST = packed record
dwOIDCount: ULONG;
pOIDs: PBCryptOID;
end;
{$EXTERNALSYM BCRYPT_OID_LIST}
BCRYPT_OID_LIST = _BCRYPT_OID_LIST;
TBCryptOIDList = _BCRYPT_OID_LIST;
PBCryptPKCS1PaddingInfo = ^TBCryptPKCS1PaddingInfo;
{$EXTERNALSYM _BCRYPT_PKCS1_PADDING_INFO}
_BCRYPT_PKCS1_PADDING_INFO = record
pszAlgId: LPCWSTR;
end;
{$EXTERNALSYM BCRYPT_PKCS1_PADDING_INFO}
BCRYPT_PKCS1_PADDING_INFO = _BCRYPT_PKCS1_PADDING_INFO;
TBCryptPKCS1PaddingInfo = _BCRYPT_PKCS1_PADDING_INFO;
PBCryptPSSPaddingInfo = ^TBCryptPSSPaddingInfo;
{$EXTERNALSYM _BCRYPT_PSS_PADDING_INFO}
_BCRYPT_PSS_PADDING_INFO = record
pszAlgId: LPCWSTR;
cbSalt: ULONG;
end;
{$EXTERNALSYM BCRYPT_PSS_PADDING_INFO}
BCRYPT_PSS_PADDING_INFO = _BCRYPT_PSS_PADDING_INFO;
TBCryptPSSPaddingInfo = _BCRYPT_PSS_PADDING_INFO;
PBCryptOAEPPaddingInfo = ^TBCryptOAEPPaddingInfo;
{$EXTERNALSYM _BCRYPT_OAEP_PADDING_INFO}
_BCRYPT_OAEP_PADDING_INFO = record
pszAlgId: LPCWSTR;
pbLabel: PUCHAR;
cbLabel: ULONG;
end;
{$EXTERNALSYM BCRYPT_OAEP_PADDING_INFO}
BCRYPT_OAEP_PADDING_INFO = _BCRYPT_OAEP_PADDING_INFO;
TBCryptOAEPPaddingInfo = _BCRYPT_OAEP_PADDING_INFO;
//
// BCrypt String Properties
//
const
// BCrypt(Import/Export)Key BLOB types
{$EXTERNALSYM BCRYPT_OPAQUE_KEY_BLOB}
BCRYPT_OPAQUE_KEY_BLOB = 'OpaqueKeyBlob';
{$EXTERNALSYM BCRYPT_KEY_DATA_BLOB}
BCRYPT_KEY_DATA_BLOB = 'KeyDataBlob';
// BCryptGetProperty strings
{$EXTERNALSYM BCRYPT_OBJECT_LENGTH}
BCRYPT_OBJECT_LENGTH = 'ObjectLength';
{$EXTERNALSYM BCRYPT_ALGORITHM_NAME}
BCRYPT_ALGORITHM_NAME = 'AlgorithmName';
{$EXTERNALSYM BCRYPT_PROVIDER_HANDLE}
BCRYPT_PROVIDER_HANDLE = 'ProviderHandle';
{$EXTERNALSYM BCRYPT_CHAINING_MODE}
BCRYPT_CHAINING_MODE = 'ChainingMode';
{$EXTERNALSYM BCRYPT_BLOCK_LENGTH}
BCRYPT_BLOCK_LENGTH = 'BlockLength';
{$EXTERNALSYM BCRYPT_KEY_LENGTH}
BCRYPT_KEY_LENGTH = 'KeyLength';
{$EXTERNALSYM BCRYPT_KEY_OBJECT_LENGTH}
BCRYPT_KEY_OBJECT_LENGTH = 'KeyObjectLength';
{$EXTERNALSYM BCRYPT_KEY_STRENGTH}
BCRYPT_KEY_STRENGTH = 'KeyStrength';
{$EXTERNALSYM BCRYPT_KEY_LENGTHS}
BCRYPT_KEY_LENGTHS = 'KeyLengths';
{$EXTERNALSYM BCRYPT_BLOCK_SIZE_LIST}
BCRYPT_BLOCK_SIZE_LIST = 'BlockSizeList';
{$EXTERNALSYM BCRYPT_EFFECTIVE_KEY_LENGTH}
BCRYPT_EFFECTIVE_KEY_LENGTH = 'EffectiveKeyLength';
{$EXTERNALSYM BCRYPT_HASH_LENGTH}
BCRYPT_HASH_LENGTH = 'HashDigestLength';
{$EXTERNALSYM BCRYPT_HASH_OID_LIST}
BCRYPT_HASH_OID_LIST = 'HashOIDList';
{$EXTERNALSYM BCRYPT_PADDING_SCHEMES}
BCRYPT_PADDING_SCHEMES = 'PaddingSchemes';
{$EXTERNALSYM BCRYPT_SIGNATURE_LENGTH}
BCRYPT_SIGNATURE_LENGTH = 'SignatureLength';
{$EXTERNALSYM BCRYPT_HASH_BLOCK_LENGTH}
BCRYPT_HASH_BLOCK_LENGTH = 'HashBlockLength';
// BCryptSetProperty strings
{$EXTERNALSYM BCRYPT_INITIALIZATION_VECTOR}
BCRYPT_INITIALIZATION_VECTOR = 'IV';
// Property Strings
{$EXTERNALSYM BCRYPT_CHAIN_MODE_NA}
BCRYPT_CHAIN_MODE_NA = 'ChainingModeN/A';
{$EXTERNALSYM BCRYPT_CHAIN_MODE_CBC}
BCRYPT_CHAIN_MODE_CBC = 'ChainingModeCBC';
{$EXTERNALSYM BCRYPT_CHAIN_MODE_ECB}
BCRYPT_CHAIN_MODE_ECB = 'ChainingModeECB';
{$EXTERNALSYM BCRYPT_CHAIN_MODE_CFB}
BCRYPT_CHAIN_MODE_CFB = 'ChainingModeCFB';
// Supported RSA Padding Types
{$EXTERNALSYM BCRYPT_SUPPORTED_PAD_ROUTER}
BCRYPT_SUPPORTED_PAD_ROUTER = $00000001;
{$EXTERNALSYM BCRYPT_SUPPORTED_PAD_PKCS1_ENC}
BCRYPT_SUPPORTED_PAD_PKCS1_ENC = $00000002;
{$EXTERNALSYM BCRYPT_SUPPORTED_PAD_PKCS1_SIG}
BCRYPT_SUPPORTED_PAD_PKCS1_SIG = $00000004;
{$EXTERNALSYM BCRYPT_SUPPORTED_PAD_OAEP}
BCRYPT_SUPPORTED_PAD_OAEP = $00000008;
{$EXTERNALSYM BCRYPT_SUPPORTED_PAD_PSS}
BCRYPT_SUPPORTED_PAD_PSS = $00000010;
//
// BCrypt Flags
//
{$EXTERNALSYM BCRYPT_PROV_DISPATCH}
BCRYPT_PROV_DISPATCH = $00000001; // BCryptOpenAlgorithmProvider
{$EXTERNALSYM BCRYPT_BLOCK_PADDING}
BCRYPT_BLOCK_PADDING = $00000001; // BCryptEncrypt/Decrypt
// RSA padding schemes
{$EXTERNALSYM BCRYPT_PAD_NONE}
BCRYPT_PAD_NONE = $00000001;
{$EXTERNALSYM BCRYPT_PAD_PKCS1}
BCRYPT_PAD_PKCS1 = $00000002; // BCryptEncrypt/Decrypt BCryptSignHash/VerifySignature
{$EXTERNALSYM BCRYPT_PAD_OAEP}
BCRYPT_PAD_OAEP = $00000004; // BCryptEncrypt/Decrypt
{$EXTERNALSYM BCRYPT_PAD_PSS}
BCRYPT_PAD_PSS = $00000008; // BCryptSignHash/VerifySignature
{$EXTERNALSYM BCRYPTBUFFER_VERSION}
BCRYPTBUFFER_VERSION = 0;
type
{$EXTERNALSYM PBCryptBuffer}
PBCryptBuffer = ^TBCryptBuffer;
{$EXTERNALSYM _BCryptBuffer}
_BCryptBuffer = record
cbBuffer: ULONG; // Length of buffer, in bytes
BufferType: ULONG; // Buffer type
pvBuffer: Pointer; // Pointer to buffer
end;
{$EXTERNALSYM BCryptBuffer}
BCryptBuffer = _BCryptBuffer;
TBCryptBuffer = _BCryptBuffer;
{$EXTERNALSYM PBCryptBufferDesc}
PBCryptBufferDesc = ^TBCryptBufferDesc;
{$EXTERNALSYM _BCryptBufferDesc}
_BCryptBufferDesc = record
ulVersion: ULONG; // Version number
cBuffers: ULONG; // Number of buffers
pBuffers: PBCryptBuffer; // Pointer to array of buffers
end;
{$EXTERNALSYM BCryptBufferDesc}
BCryptBufferDesc = _BCryptBufferDesc;
TBCryptBufferDesc = _BCryptBufferDesc;
//
// Primitive handles
//
{$EXTERNALSYM BCRYPT_HANDLE}
BCRYPT_HANDLE = THandle;
{$EXTERNALSYM BCRYPT_ALG_HANDLE}
BCRYPT_ALG_HANDLE = THandle;
{$EXTERNALSYM BCRYPT_KEY_HANDLE}
BCRYPT_KEY_HANDLE = THandle;
{$EXTERNALSYM BCRYPT_HASH_HANDLE}
BCRYPT_HASH_HANDLE = THandle;
{$EXTERNALSYM BCRYPT_SECRET_HANDLE}
BCRYPT_SECRET_HANDLE = THandle;
//
// Structures used to represent key blobs.
//
const
{$EXTERNALSYM BCRYPT_PUBLIC_KEY_BLOB}
BCRYPT_PUBLIC_KEY_BLOB = 'PUBLICBLOB';
{$EXTERNALSYM BCRYPT_PRIVATE_KEY_BLOB}
BCRYPT_PRIVATE_KEY_BLOB = 'PRIVATEBLOB';
type
PBCryptKeyBlob = ^TBCryptKeyBlob;
{$EXTERNALSYM _BCRYPT_KEY_BLOB}
_BCRYPT_KEY_BLOB = record
Magic: ULONG;
end;
{$EXTERNALSYM BCRYPT_KEY_BLOB}
BCRYPT_KEY_BLOB = _BCRYPT_KEY_BLOB;
TBCryptKeyBlob = _BCRYPT_KEY_BLOB;
// The BCRYPT_RSAPUBLIC_BLOB and BCRYPT_RSAPRIVATE_BLOB blob types are used
// to transport plaintext RSA keys. These blob types will be supported by
// all RSA primitive providers.
// The BCRYPT_RSAPRIVATE_BLOB includes the following values:
// Public Exponent
// Modulus
// Prime1
// Prime2
const
{$EXTERNALSYM BCRYPT_RSAPUBLIC_BLOB}
BCRYPT_RSAPUBLIC_BLOB = 'RSAPUBLICBLOB';
{$EXTERNALSYM BCRYPT_RSAPRIVATE_BLOB}
BCRYPT_RSAPRIVATE_BLOB = 'RSAPRIVATEBLOB';
{$EXTERNALSYM LEGACY_RSAPUBLIC_BLOB}
LEGACY_RSAPUBLIC_BLOB = 'CAPIPUBLICBLOB';
{$EXTERNALSYM LEGACY_RSAPRIVATE_BLOB}
LEGACY_RSAPRIVATE_BLOB = 'CAPIPRIVATEBLOB';
{$EXTERNALSYM BCRYPT_RSAPUBLIC_MAGIC}
BCRYPT_RSAPUBLIC_MAGIC = $31415352; // RSA1
{$EXTERNALSYM BCRYPT_RSAPRIVATE_MAGIC}
BCRYPT_RSAPRIVATE_MAGIC = $32415352; // RSA2
type
PBCryptRSAKeyBlob = ^TBCryptRSAKeyBlob;
{$EXTERNALSYM _BCRYPT_RSAKEY_BLOB}
_BCRYPT_RSAKEY_BLOB = record
Magic: ULONG;
BitLength: ULONG;
cbPublicExp: ULONG;
cbModulus: ULONG;
cbPrime1: ULONG;
cbPrime2: ULONG;
end;
{$EXTERNALSYM BCRYPT_RSAKEY_BLOB}
BCRYPT_RSAKEY_BLOB = _BCRYPT_RSAKEY_BLOB;
TBCryptRSAKeyBlob = _BCRYPT_RSAKEY_BLOB;
const
// The BCRYPT_RSAFULLPRIVATE_BLOB blob type is used to transport
// plaintext private RSA keys. It includes the following values:
// Public Exponent
// Modulus
// Prime1
// Prime2
// Private Exponent mod (Prime1 - 1)
// Private Exponent mod (Prime2 - 1)
// Inverse of Prime2 mod Prime1
// PrivateExponent
{$EXTERNALSYM BCRYPT_RSAFULLPRIVATE_BLOB}
BCRYPT_RSAFULLPRIVATE_BLOB = 'RSAFULLPRIVATEBLOB';
{$EXTERNALSYM BCRYPT_RSAFULLPRIVATE_MAGIC}
BCRYPT_RSAFULLPRIVATE_MAGIC = $33415352; // RSA3
// The BCRYPT_ECCPUBLIC_BLOB and BCRYPT_ECCPRIVATE_BLOB blob types are used
// to transport plaintext ECC keys. These blob types will be supported by
// all ECC primitive providers.
{$EXTERNALSYM BCRYPT_ECCPUBLIC_BLOB}
BCRYPT_ECCPUBLIC_BLOB = 'ECCPUBLICBLOB';
{$EXTERNALSYM BCRYPT_ECCPRIVATE_BLOB}
BCRYPT_ECCPRIVATE_BLOB = 'ECCPRIVATEBLOB';
{$EXTERNALSYM BCRYPT_ECDH_PUBLIC_P256_MAGIC}
BCRYPT_ECDH_PUBLIC_P256_MAGIC = $314B4345; // ECK1
{$EXTERNALSYM BCRYPT_ECDH_PRIVATE_P256_MAGIC}
BCRYPT_ECDH_PRIVATE_P256_MAGIC = $324B4345; // ECK2
{$EXTERNALSYM BCRYPT_ECDH_PUBLIC_P384_MAGIC}
BCRYPT_ECDH_PUBLIC_P384_MAGIC = $334B4345; // ECK3
{$EXTERNALSYM BCRYPT_ECDH_PRIVATE_P384_MAGIC}
BCRYPT_ECDH_PRIVATE_P384_MAGIC = $344B4345; // ECK4
{$EXTERNALSYM BCRYPT_ECDH_PUBLIC_P521_MAGIC}
BCRYPT_ECDH_PUBLIC_P521_MAGIC = $354B4345; // ECK5
{$EXTERNALSYM BCRYPT_ECDH_PRIVATE_P521_MAGIC}
BCRYPT_ECDH_PRIVATE_P521_MAGIC = $364B4345; // ECK6
{$EXTERNALSYM BCRYPT_ECDSA_PUBLIC_P256_MAGIC}
BCRYPT_ECDSA_PUBLIC_P256_MAGIC = $31534345; // ECS1
{$EXTERNALSYM BCRYPT_ECDSA_PRIVATE_P256_MAGIC}
BCRYPT_ECDSA_PRIVATE_P256_MAGIC = $32534345; // ECS2
{$EXTERNALSYM BCRYPT_ECDSA_PUBLIC_P384_MAGIC}
BCRYPT_ECDSA_PUBLIC_P384_MAGIC = $33534345; // ECS3
{$EXTERNALSYM BCRYPT_ECDSA_PRIVATE_P384_MAGIC}
BCRYPT_ECDSA_PRIVATE_P384_MAGIC = $34534345; // ECS4
{$EXTERNALSYM BCRYPT_ECDSA_PUBLIC_P521_MAGIC}
BCRYPT_ECDSA_PUBLIC_P521_MAGIC = $35534345; // ECS5
{$EXTERNALSYM BCRYPT_ECDSA_PRIVATE_P521_MAGIC}
BCRYPT_ECDSA_PRIVATE_P521_MAGIC = $36534345; // ECS6
type
PBCryptECCKeyBlob = ^TBCryptECCKeyBlob;
{$EXTERNALSYM _BCRYPT_ECCKEY_BLOB}
_BCRYPT_ECCKEY_BLOB = record
dwMagic: ULONG;
cbKey: ULONG;
end;
{$EXTERNALSYM BCRYPT_ECCKEY_BLOB}
BCRYPT_ECCKEY_BLOB = _BCRYPT_ECCKEY_BLOB;
TBCryptECCKeyBlob = _BCRYPT_ECCKEY_BLOB;
const
// The BCRYPT_DH_PUBLIC_BLOB and BCRYPT_DH_PRIVATE_BLOB blob types are used
// to transport plaintext DH keys. These blob types will be supported by
// all DH primitive providers.
{$EXTERNALSYM BCRYPT_DH_PUBLIC_BLOB}
BCRYPT_DH_PUBLIC_BLOB = 'DHPUBLICBLOB';
{$EXTERNALSYM BCRYPT_DH_PRIVATE_BLOB}
BCRYPT_DH_PRIVATE_BLOB = 'DHPRIVATEBLOB';
{$EXTERNALSYM LEGACY_DH_PUBLIC_BLOB}
LEGACY_DH_PUBLIC_BLOB = 'CAPIDHPUBLICBLOB';
{$EXTERNALSYM LEGACY_DH_PRIVATE_BLOB}
LEGACY_DH_PRIVATE_BLOB = 'CAPIDHPRIVATEBLOB';
{$EXTERNALSYM BCRYPT_DH_PUBLIC_MAGIC}
BCRYPT_DH_PUBLIC_MAGIC = $42504844; // DHPB
{$EXTERNALSYM BCRYPT_DH_PRIVATE_MAGIC}
BCRYPT_DH_PRIVATE_MAGIC = $56504844; // DHPV
type
PBCryptDHKeyBlob = ^TBCryptDHKeyBlob;
{$EXTERNALSYM _BCRYPT_DH_KEY_BLOB}
_BCRYPT_DH_KEY_BLOB = record
dwMagic: ULONG;
cbKey: ULONG;
end;
{$EXTERNALSYM BCRYPT_DH_KEY_BLOB}
BCRYPT_DH_KEY_BLOB = _BCRYPT_DH_KEY_BLOB;
TBCryptDHKeyBlob = _BCRYPT_DH_KEY_BLOB;
const
// Property Strings for DH
{$EXTERNALSYM BCRYPT_DH_PARAMETERS}
BCRYPT_DH_PARAMETERS = 'DHParameters';
{$EXTERNALSYM BCRYPT_DH_PARAMETERS_MAGIC}
BCRYPT_DH_PARAMETERS_MAGIC = $4d504844; // DHPM
type
PBCryptDHParameterHeader = ^TBCryptDHParameterHeader;
{$EXTERNALSYM _BCRYPT_DH_PARAMETER_HEADER}
_BCRYPT_DH_PARAMETER_HEADER = record
cbLength: ULONG;
dwMagic: ULONG;
cbKeyLength: ULONG;
end;
{$EXTERNALSYM BCRYPT_DH_PARAMETER_HEADER}
BCRYPT_DH_PARAMETER_HEADER = _BCRYPT_DH_PARAMETER_HEADER;
TBCryptDHParameterHeader = _BCRYPT_DH_PARAMETER_HEADER;
const
// The BCRYPT_DSA_PUBLIC_BLOB and BCRYPT_DSA_PRIVATE_BLOB blob types are used
// to transport plaintext DSA keys. These blob types will be supported by
// all DSA primitive providers.
{$EXTERNALSYM BCRYPT_DSA_PUBLIC_BLOB}
BCRYPT_DSA_PUBLIC_BLOB = 'DSAPUBLICBLOB';
{$EXTERNALSYM BCRYPT_DSA_PRIVATE_BLOB}
BCRYPT_DSA_PRIVATE_BLOB = 'DSAPRIVATEBLOB';
{$EXTERNALSYM LEGACY_DSA_PUBLIC_BLOB}
LEGACY_DSA_PUBLIC_BLOB = 'CAPIDSAPUBLICBLOB';
{$EXTERNALSYM LEGACY_DSA_PRIVATE_BLOB}
LEGACY_DSA_PRIVATE_BLOB = 'CAPIDSAPRIVATEBLOB';
{$EXTERNALSYM LEGACY_DSA_V2_PRIVATE_BLOB}
LEGACY_DSA_V2_PRIVATE_BLOB = 'V2CAPIDSAPRIVATEBLOB';
{$EXTERNALSYM BCRYPT_DSA_PUBLIC_MAGIC}
BCRYPT_DSA_PUBLIC_MAGIC = $42505344; // DSPB
{$EXTERNALSYM BCRYPT_DSA_PRIVATE_MAGIC}
BCRYPT_DSA_PRIVATE_MAGIC = $56505344; // DSPV
type
PBCryptDSAKeyBlob = ^TBCryptDSAKeyBlob;
{$EXTERNALSYM _BCRYPT_DSA_KEY_BLOB}
_BCRYPT_DSA_KEY_BLOB = record
dwMagic: ULONG;
cbKey: ULONG;
Count: array[0..3] of UCHAR;
Seed: array[0..19] of UCHAR;
q: array[0..19] of UCHAR;
end;
{$EXTERNALSYM BCRYPT_DSA_KEY_BLOB}
BCRYPT_DSA_KEY_BLOB = _BCRYPT_DSA_KEY_BLOB;
TBCryptDSAKeyBlob = _BCRYPT_DSA_KEY_BLOB;
PBCryptKeyDataBlobHeader = ^TBCryptKeyDataBlobHeader;
{$EXTERNALSYM _BCRYPT_KEY_DATA_BLOB_HEADER}
_BCRYPT_KEY_DATA_BLOB_HEADER = record
dwMagic: ULONG;
dwVersion: ULONG;
cbKeyData: ULONG;
end;
{$EXTERNALSYM BCRYPT_KEY_DATA_BLOB_HEADER}
BCRYPT_KEY_DATA_BLOB_HEADER = _BCRYPT_KEY_DATA_BLOB_HEADER;
TBCryptKeyDataBlobHeader = _BCRYPT_KEY_DATA_BLOB_HEADER;
const
{$EXTERNALSYM BCRYPT_KEY_DATA_BLOB_MAGIC}
BCRYPT_KEY_DATA_BLOB_MAGIC = $4d42444b; //Key Data Blob Magic (KDBM)
{$EXTERNALSYM BCRYPT_KEY_DATA_BLOB_VERSION1}
BCRYPT_KEY_DATA_BLOB_VERSION1 = $1;
// Property Strings for DSA
{$EXTERNALSYM BCRYPT_DSA_PARAMETERS}
BCRYPT_DSA_PARAMETERS = 'DSAParameters';
{$EXTERNALSYM BCRYPT_DSA_PARAMETERS_MAGIC}
BCRYPT_DSA_PARAMETERS_MAGIC = $4d505344; // DSPM
type
PBCryptDSAParameterHeader = ^TBCryptDSAParameterHeader;
{$EXTERNALSYM _BCRYPT_DSA_PARAMETER_HEADER}
_BCRYPT_DSA_PARAMETER_HEADER = record
cbLength: ULONG;
dwMagic: ULONG;
cbKeyLength: ULONG;
Count: array[0..3] of UCHAR;
Seed: array[0..19] of UCHAR;
q: array[0..19] of UCHAR;
end;
{$EXTERNALSYM BCRYPT_DSA_PARAMETER_HEADER}
BCRYPT_DSA_PARAMETER_HEADER = _BCRYPT_DSA_PARAMETER_HEADER;
TBCryptDSAParameterHeader = _BCRYPT_DSA_PARAMETER_HEADER;
const
//
// Microsoft built-in providers.
//
{$EXTERNALSYM MS_PRIMITIVE_PROVIDER}
MS_PRIMITIVE_PROVIDER = 'Microsoft Primitive Provider';
//
// Common algorithm identifiers.
//
{$EXTERNALSYM BCRYPT_RSA_ALGORITHM}
BCRYPT_RSA_ALGORITHM = 'RSA';
{$EXTERNALSYM BCRYPT_RSA_SIGN_ALGORITHM}
BCRYPT_RSA_SIGN_ALGORITHM = 'RSA_SIGN';
{$EXTERNALSYM BCRYPT_DH_ALGORITHM}
BCRYPT_DH_ALGORITHM = 'DH';
{$EXTERNALSYM BCRYPT_DSA_ALGORITHM}
BCRYPT_DSA_ALGORITHM = 'DSA';
{$EXTERNALSYM BCRYPT_RC2_ALGORITHM}
BCRYPT_RC2_ALGORITHM = 'RC2';
{$EXTERNALSYM BCRYPT_RC4_ALGORITHM}
BCRYPT_RC4_ALGORITHM = 'RC4';
{$EXTERNALSYM BCRYPT_AES_ALGORITHM}
BCRYPT_AES_ALGORITHM = 'AES';
{$EXTERNALSYM BCRYPT_DES_ALGORITHM}
BCRYPT_DES_ALGORITHM = 'DES';
{$EXTERNALSYM BCRYPT_DESX_ALGORITHM}
BCRYPT_DESX_ALGORITHM = 'DESX';
{$EXTERNALSYM BCRYPT_3DES_ALGORITHM}
BCRYPT_3DES_ALGORITHM = '3DES';
{$EXTERNALSYM BCRYPT_3DES_112_ALGORITHM}
BCRYPT_3DES_112_ALGORITHM = '3DES_112';
{$EXTERNALSYM BCRYPT_MD2_ALGORITHM}
BCRYPT_MD2_ALGORITHM = 'MD2';
{$EXTERNALSYM BCRYPT_MD4_ALGORITHM}
BCRYPT_MD4_ALGORITHM = 'MD4';
{$EXTERNALSYM BCRYPT_MD5_ALGORITHM}
BCRYPT_MD5_ALGORITHM = 'MD5';
{$EXTERNALSYM BCRYPT_SHA1_ALGORITHM}
BCRYPT_SHA1_ALGORITHM = 'SHA1';
{$EXTERNALSYM BCRYPT_SHA256_ALGORITHM}
BCRYPT_SHA256_ALGORITHM = 'SHA256';
{$EXTERNALSYM BCRYPT_SHA384_ALGORITHM}
BCRYPT_SHA384_ALGORITHM = 'SHA384';
{$EXTERNALSYM BCRYPT_SHA512_ALGORITHM}
BCRYPT_SHA512_ALGORITHM = 'SHA512';
{$EXTERNALSYM BCRYPT_ECDSA_P256_ALGORITHM}
BCRYPT_ECDSA_P256_ALGORITHM = 'ECDSA_P256';
{$EXTERNALSYM BCRYPT_ECDSA_P384_ALGORITHM}
BCRYPT_ECDSA_P384_ALGORITHM = 'ECDSA_P384';
{$EXTERNALSYM BCRYPT_ECDSA_P521_ALGORITHM}
BCRYPT_ECDSA_P521_ALGORITHM = 'ECDSA_P521';
{$EXTERNALSYM BCRYPT_ECDH_P256_ALGORITHM}
BCRYPT_ECDH_P256_ALGORITHM = 'ECDH_P256';
{$EXTERNALSYM BCRYPT_ECDH_P384_ALGORITHM}
BCRYPT_ECDH_P384_ALGORITHM = 'ECDH_P384';
{$EXTERNALSYM BCRYPT_ECDH_P521_ALGORITHM}
BCRYPT_ECDH_P521_ALGORITHM = 'ECDH_P521';
{$EXTERNALSYM BCRYPT_RNG_ALGORITHM}
BCRYPT_RNG_ALGORITHM = 'RNG';
{$EXTERNALSYM BCRYPT_RNG_FIPS186_DSA_ALGORITHM}
BCRYPT_RNG_FIPS186_DSA_ALGORITHM = 'FIPS186DSARNG';
//
// Interfaces
//
{$EXTERNALSYM BCRYPT_CIPHER_INTERFACE}
BCRYPT_CIPHER_INTERFACE = $00000001;
{$EXTERNALSYM BCRYPT_HASH_INTERFACE}
BCRYPT_HASH_INTERFACE = $00000002;
{$EXTERNALSYM BCRYPT_ASYMMETRIC_ENCRYPTION_INTERFACE}
BCRYPT_ASYMMETRIC_ENCRYPTION_INTERFACE = $00000003;
{$EXTERNALSYM BCRYPT_SECRET_AGREEMENT_INTERFACE}
BCRYPT_SECRET_AGREEMENT_INTERFACE = $00000004;
{$EXTERNALSYM BCRYPT_SIGNATURE_INTERFACE}
BCRYPT_SIGNATURE_INTERFACE = $00000005;
{$EXTERNALSYM BCRYPT_RNG_INTERFACE}
BCRYPT_RNG_INTERFACE = $00000006;
//
// Primitive algorithm provider functions.
//
{$EXTERNALSYM BCRYPT_ALG_HANDLE_HMAC_FLAG}
BCRYPT_ALG_HANDLE_HMAC_FLAG = $00000008;
{$EXTERNALSYM BCryptOpenAlgorithmProvider}
function BCryptOpenAlgorithmProvider(out phAlgorithm: BCRYPT_ALG_HANDLE;
pszAlgId, pszImplementation: LPCWSTR; dwFlags: ULONG): TNTStatus; stdcall;
type
{$EXTERNALSYM BCryptOpenAlgorithmProviderFn}
BCryptOpenAlgorithmProviderFn = function(out phAlgorithm: BCRYPT_ALG_HANDLE;
pszAlgId: LPCWSTR; dwFlags: ULONG): TNTStatus stdcall;
const
// AlgOperations flags for use with BCryptEnumAlgorithms()
{$EXTERNALSYM BCRYPT_CIPHER_OPERATION}
BCRYPT_CIPHER_OPERATION = $00000001;
{$EXTERNALSYM BCRYPT_HASH_OPERATION}
BCRYPT_HASH_OPERATION = $00000002;
{$EXTERNALSYM BCRYPT_ASYMMETRIC_ENCRYPTION_OPERATION}
BCRYPT_ASYMMETRIC_ENCRYPTION_OPERATION = $00000004;
{$EXTERNALSYM BCRYPT_SECRET_AGREEMENT_OPERATION}
BCRYPT_SECRET_AGREEMENT_OPERATION = $00000008;
{$EXTERNALSYM BCRYPT_SIGNATURE_OPERATION}
BCRYPT_SIGNATURE_OPERATION = $00000010;
{$EXTERNALSYM BCRYPT_RNG_OPERATION}
BCRYPT_RNG_OPERATION = $00000020;
// USE EXTREME CAUTION: editing comments that contain "certenrolls_*" tokens
// could break building CertEnroll idl files:
// certenrolls_begin -- BCRYPT_ALGORITHM_IDENTIFIER
type
PBCryptAlgorithmIdentifier = ^TBCryptAlgorithmIdentifier;
{$EXTERNALSYM _BCRYPT_ALGORITHM_IDENTIFIER}
_BCRYPT_ALGORITHM_IDENTIFIER = record
pszName: LPWSTR;
dwClass: ULONG;
dwFlags: ULONG;
end;
{$EXTERNALSYM BCRYPT_ALGORITHM_IDENTIFIER}
BCRYPT_ALGORITHM_IDENTIFIER = _BCRYPT_ALGORITHM_IDENTIFIER;
TBCryptAlgorithmIdentifier = _BCRYPT_ALGORITHM_IDENTIFIER;
// certenrolls_end
{$EXTERNALSYM BCryptEnumAlgorithms}
function BCryptEnumAlgorithms(dwAlgOperations: ULONG; out pAlgCount: ULONG;
out ppAlgList: PBCryptAlgorithmIdentifier; dwFlags: ULONG): TNTStatus; stdcall;
type
PBCryptProviderName = ^TBCryptProviderName;
{$EXTERNALSYM _BCRYPT_PROVIDER_NAME}
_BCRYPT_PROVIDER_NAME = record
pszProviderName: LPWSTR;
end;
{$EXTERNALSYM BCRYPT_PROVIDER_NAME}
BCRYPT_PROVIDER_NAME = _BCRYPT_PROVIDER_NAME;
TBCryptProviderName = _BCRYPT_PROVIDER_NAME;
{$EXTERNALSYM BCryptEnumProviders}
function BCryptEnumProviders(pszAlgId: LPCWSTR; out pImplCount: ULONG;
out ppImplList: PBCryptProviderName; dwFlags: ULONG): TNTStatus; stdcall;
const
// Flags for use with BCryptGetProperty and BCryptSetProperty
{$EXTERNALSYM BCRYPT_PUBLIC_KEY_FLAG}
BCRYPT_PUBLIC_KEY_FLAG = $00000001;
{$EXTERNALSYM BCRYPT_PRIVATE_KEY_FLAG}
BCRYPT_PRIVATE_KEY_FLAG = $00000002;
{$EXTERNALSYM BCryptGetProperty}
function BCryptGetProperty(hObject: BCRYPT_HANDLE; pszProperty: LPCWSTR;
pbOutput: PUCHAR; cbOutput: ULONG; out pcbResult: ULONG;
dwFlags: ULONG): TNTStatus; stdcall;
{$EXTERNALSYM BCryptSetProperty}
function BCryptSetProperty(hObject: BCRYPT_HANDLE; pszProperty: LPCWSTR;
pbInput: PUCHAR; cbInput: ULONG; dwFlags: ULONG): TNTStatus; stdcall;
{$EXTERNALSYM BCryptCloseAlgorithmProvider}
function BCryptCloseAlgorithmProvider(hAlgorithm: BCRYPT_ALG_HANDLE;
dwFlags: ULONG): TNTStatus; stdcall;
{$EXTERNALSYM BCryptFreeBuffer}
procedure BCryptFreeBuffer(pvBuffer: Pointer); stdcall;
//
// Primitive encryption functions.
//
{$EXTERNALSYM BCryptGenerateSymmetricKey}
function BCryptGenerateSymmetricKey(hAlgorithm: BCRYPT_ALG_HANDLE;
out phKey: BCRYPT_KEY_HANDLE; pbKeyObject: PUCHAR; cbKeyObject: ULONG;
pbSecret: PUCHAR; cbSecret, dwFlags: ULONG): TNTStatus; stdcall;
{$EXTERNALSYM BCryptGenerateKeyPair}
function BCryptGenerateKeyPair(hAlgorithm: BCRYPT_ALG_HANDLE;
out phKey: BCRYPT_KEY_HANDLE; dwLength, dwFlags: ULONG): TNTStatus; stdcall;
{$EXTERNALSYM BCryptEncrypt}
function BCryptEncrypt(hKey: BCRYPT_KEY_HANDLE; pbInput: PUCHAR;
cbInput: ULONG; pPaddingInfo: Pointer; pbIV: PUCHAR; cbIV: ULONG;
pbOutput: PUCHAR; cbOutput: ULONG; out pcbResult: ULONG;
dwFlags: ULONG): TNTStatus; stdcall;
{$EXTERNALSYM BCryptDecrypt}
function BCryptDecrypt(hKey: BCRYPT_KEY_HANDLE; pbInput: PUCHAR;
cbInput: ULONG; pPaddingInfo: Pointer; pbIV: PUCHAR; cbIV: ULONG;
pbOutput: PUCHAR; cbOutput: ULONG; out pcbResult: ULONG;
dwFlags: ULONG): TNTStatus; stdcall;
{$EXTERNALSYM BCryptExportKey}
function BCryptExportKey(hKey, hExportKey: BCRYPT_KEY_HANDLE;
pszBlobType: LPCWSTR; pbOutput: PUCHAR; cbOutput: ULONG;
out pcbResult: ULONG; dwFlags: ULONG): TNTStatus; stdcall;
{$EXTERNALSYM BCryptImportKey}
function BCryptImportKey(hAlgorithm: BCRYPT_ALG_HANDLE;
hImportKey: BCRYPT_KEY_HANDLE; pszBlobType: LPCWSTR;
out phKey: BCRYPT_KEY_HANDLE; pbKeyObject: PUCHAR; cbKeyObject: ULONG;
pbInput: PUCHAR; cbInput, dwFlags: ULONG): TNTStatus; stdcall;
const
{$EXTERNALSYM BCRYPT_NO_KEY_VALIDATION}
BCRYPT_NO_KEY_VALIDATION = $00000008;
{$EXTERNALSYM BCryptImportKeyPair}
function BCryptImportKeyPair(hAlgorithm: BCRYPT_ALG_HANDLE;
hImportKey: BCRYPT_KEY_HANDLE; pszBlobType: LPCWSTR;
out phKey: BCRYPT_KEY_HANDLE; pbInput: PUCHAR; cbInput: ULONG;
dwFlags: ULONG): TNTStatus; stdcall;
{$EXTERNALSYM BCryptDuplicateKey}
function BCryptDuplicateKey(hKey: BCRYPT_KEY_HANDLE;
out phNewKey: BCRYPT_KEY_HANDLE; pbKeyObject: PUCHAR;
cbKeyObject, dwFlags: ULONG): TNTStatus; stdcall;
{$EXTERNALSYM BCryptFinalizeKeyPair}
function BCryptFinalizeKeyPair(hKey: BCRYPT_KEY_HANDLE;
dwFlags: ULONG): TNTStatus; stdcall;
{$EXTERNALSYM BCryptDestroyKey}
function BCryptDestroyKey(hKey: BCRYPT_KEY_HANDLE): TNTStatus; stdcall;
{$EXTERNALSYM BCryptDestroySecret}
function BCryptDestroySecret(hSecret: BCRYPT_SECRET_HANDLE): TNTStatus; stdcall;
{$EXTERNALSYM BCryptSignHash}
function BCryptSignHash(hKey: BCRYPT_KEY_HANDLE; pPaddingInfo: Pointer;
pbInput: PUCHAR; cbInput: ULONG; pbOutput: PUCHAR; cbOutput: ULONG;
out pcbResult: ULONG; dwFlags: ULONG): TNTStatus; stdcall;
{$EXTERNALSYM BCryptVerifySignature}
function BCryptVerifySignature(hKey: BCRYPT_KEY_HANDLE; pPaddingInfo: Pointer;
pbHash: PUCHAR; cbHash: ULONG; pbSignature: PUCHAR;
cbSignature, dwFlags: ULONG): TNTStatus; stdcall;
{$EXTERNALSYM BCryptSecretAgreement}
function BCryptSecretAgreement(hPrivKey, hPubKey: BCRYPT_KEY_HANDLE;
out phAgreedSecret: BCRYPT_SECRET_HANDLE; dwFlags: ULONG): TNTStatus; stdcall;
{$EXTERNALSYM BCryptDeriveKey}
function BCryptDeriveKey(hSharedSecret: BCRYPT_SECRET_HANDLE; pwszKDF: LPCWSTR;
pParameterList: PBCryptBufferDesc; pbDerivedKey: PUCHAR; cbDerivedKey: ULONG;
out pcbResult: ULONG; dwFlags: ULONG): TNTStatus; stdcall;
//
// Primitive hashing functions.
//
{$EXTERNALSYM BCryptCreateHash}
function BCryptCreateHash(hAlgorithm: BCRYPT_ALG_HANDLE;
out phHash: BCRYPT_HASH_HANDLE; pbHashObject: PUCHAR; cbHashObject: ULONG;
pbSecret: PUCHAR { optional }; cbSecret: ULONG { optional };
dwFlags: ULONG): TNTStatus; stdcall;
{$EXTERNALSYM BCryptHashData}
function BCryptHashData(hHash: BCRYPT_HASH_HANDLE; pbInput: PUCHAR;
cbInput, dwFlags: ULONG): TNTStatus; stdcall;
{$EXTERNALSYM BCryptFinishHash}
function BCryptFinishHash(hHash: BCRYPT_HASH_HANDLE; pbOutput: PUCHAR;
cbOutput, dwFlags: ULONG): TNTStatus; stdcall;
{$EXTERNALSYM BCryptDuplicateHash}
function BCryptDuplicateHash(hHash: BCRYPT_HASH_HANDLE;
out phNewHash: BCRYPT_HASH_HANDLE; pbHashObject: PUCHAR;
cbHashObject, dwFlags: ULONG): TNTStatus; stdcall;
{$EXTERNALSYM BCryptDestroyHash}
function BCryptDestroyHash(hHash: BCRYPT_HASH_HANDLE): TNTStatus; stdcall;
//
// Primitive random number generation.
//
const
// Flags to BCryptGenRandom
BCRYPT_RNG_USE_ENTROPY_IN_BUFFER = $00000001;
{$EXTERNALSYM BCryptGenRandom}
function BCryptGenRandom(hAlgorithm: BCRYPT_ALG_HANDLE; pbBuffer: PUCHAR;
cbBuffer, dwFlags: ULONG): TNTStatus; stdcall;
//
// Interface version control...
//
type
PBCryptInterfaceVersion = ^TBCryptInterfaceVersion;
{$EXTERNALSYM _BCRYPT_INTERFACE_VERSION}
_BCRYPT_INTERFACE_VERSION = record
MajorVersion: Word;
MinorVersion: Word;
end;
{$EXTERNALSYM BCRYPT_INTERFACE_VERSION}
BCRYPT_INTERFACE_VERSION = _BCRYPT_INTERFACE_VERSION;
TBCryptInterfaceVersion = _BCRYPT_INTERFACE_VERSION;
{$EXTERNALSYM BCRYPT_MAKE_INTERFACE_VERSION}
function BCRYPT_MAKE_INTERFACE_VERSION(
major, minor: Word): TBCryptInterfaceVersion;
{$EXTERNALSYM BCRYPT_IS_INTERFACE_VERSION_COMPATIBLE}
function BCRYPT_IS_INTERFACE_VERSION_COMPATIBLE(
const loader, provider: TBCryptInterfaceVersion): Boolean;
//
// Primitive provider interfaces.
//
const
{$EXTERNALSYM BCRYPT_CIPHER_INTERFACE_VERSION_1}
BCRYPT_CIPHER_INTERFACE_VERSION_1: TBCryptInterfaceVersion =
(MajorVersion: 1; MinorVersion: 0);
{$EXTERNALSYM BCRYPT_HASH_INTERFACE_VERSION_1}
BCRYPT_HASH_INTERFACE_VERSION_1: TBCryptInterfaceVersion =
(MajorVersion: 1; MinorVersion: 0);
{$EXTERNALSYM BCRYPT_ASYMMETRIC_ENCRYPTION_INTERFACE_VERSION_1}
BCRYPT_ASYMMETRIC_ENCRYPTION_INTERFACE_VERSION_1: TBCryptInterfaceVersion =
(MajorVersion: 1; MinorVersion: 0);
{$EXTERNALSYM BCRYPT_SECRET_AGREEMENT_INTERFACE_VERSION_1}
BCRYPT_SECRET_AGREEMENT_INTERFACE_VERSION_1: TBCryptInterfaceVersion =
(MajorVersion: 1; MinorVersion: 0);
{$EXTERNALSYM BCRYPT_SIGNATURE_INTERFACE_VERSION_1}
BCRYPT_SIGNATURE_INTERFACE_VERSION_1: TBCryptInterfaceVersion =
(MajorVersion: 1; MinorVersion: 0);
{$EXTERNALSYM BCRYPT_RNG_INTERFACE_VERSION_1}
BCRYPT_RNG_INTERFACE_VERSION_1: TBCryptInterfaceVersion =
(MajorVersion: 1; MinorVersion: 0);
//////////////////////////////////////////////////////////////////////////////
// CryptoConfig Definitions //////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
const
// Interface registration flags
{$EXTERNALSYM CRYPT_MIN_DEPENDENCIES}
CRYPT_MIN_DEPENDENCIES = $00000001;
{$EXTERNALSYM CRYPT_PROCESS_ISOLATE}
CRYPT_PROCESS_ISOLATE = $00010000; // User-mode only
// Processor modes supported by a provider
//
// = Valid for BCryptQueryProviderRegistration and BCryptResolveProviders; :
//
{$EXTERNALSYM CRYPT_UM}
CRYPT_UM = $00000001; // User mode only
{$EXTERNALSYM CRYPT_KM}
CRYPT_KM = $00000002; // Kernel mode only
{$EXTERNALSYM CRYPT_MM}
CRYPT_MM = $00000003; // Multi-mode: Must support BOTH UM and KM
//
// = Valid only for BCryptQueryProviderRegistration; :
//
{$EXTERNALSYM CRYPT_ANY}
CRYPT_ANY = $00000004; // Wildcard: Either UM, or KM, or both
// Write behavior flags
{$EXTERNALSYM CRYPT_OVERWRITE}
CRYPT_OVERWRITE = $00000001;
// Configuration tables
{$EXTERNALSYM CRYPT_LOCAL}
CRYPT_LOCAL = $00000001;
{$EXTERNALSYM CRYPT_DOMAIN}
CRYPT_DOMAIN = $00000002;
// Context configuration flags
{$EXTERNALSYM CRYPT_EXCLUSIVE}
CRYPT_EXCLUSIVE = $00000001;
{$EXTERNALSYM CRYPT_OVERRIDE}
CRYPT_OVERRIDE = $00010000; // Enterprise table only
// Resolution and enumeration flags
{$EXTERNALSYM CRYPT_ALL_FUNCTIONS}
CRYPT_ALL_FUNCTIONS = $00000001;
{$EXTERNALSYM CRYPT_ALL_PROVIDERS}
CRYPT_ALL_PROVIDERS = $00000002;
// Priority list positions
{$EXTERNALSYM CRYPT_PRIORITY_TOP}
CRYPT_PRIORITY_TOP = $00000000;
{$EXTERNALSYM CRYPT_PRIORITY_BOTTOM}
CRYPT_PRIORITY_BOTTOM = $FFFFFFFF;
// Default system-wide context
{$EXTERNALSYM CRYPT_DEFAULT_CONTEXT}
CRYPT_DEFAULT_CONTEXT = 'Default';
//////////////////////////////////////////////////////////////////////////////
// CryptoConfig Structures ///////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
//
// Provider Registration Structures
//
type
PCryptInterfaceReg = ^TCryptInterfaceReg;
{$EXTERNALSYM _CRYPT_INTERFACE_REG}
_CRYPT_INTERFACE_REG = record
dwInterface: ULONG;
dwFlags: ULONG;
cFunctions: ULONG;
rgpszFunctions: ^PWideChar;
end;
{$EXTERNALSYM CRYPT_INTERFACE_REG}
CRYPT_INTERFACE_REG = _CRYPT_INTERFACE_REG;
TCryptInterfaceReg = _CRYPT_INTERFACE_REG;
PCryptImageReg = ^TCryptImageReg;
{$EXTERNALSYM _CRYPT_IMAGE_REG}
_CRYPT_IMAGE_REG = record
pszImage: PWideChar;
cInterfaces: ULONG;
rgpInterfaces: ^PCryptInterfaceReg;
end;
{$EXTERNALSYM CRYPT_IMAGE_REG}
CRYPT_IMAGE_REG = _CRYPT_IMAGE_REG;
TCryptImageReg = _CRYPT_IMAGE_REG;
PCryptProviderReg = ^TCryptProviderReg;
{$EXTERNALSYM _CRYPT_PROVIDER_REG}
_CRYPT_PROVIDER_REG = record
cAliases: ULONG;
rgpszAliases: ^PWideChar;
pUM: PCryptImageReg;
pKM: PCryptImageReg;
end;
{$EXTERNALSYM CRYPT_PROVIDER_REG}
CRYPT_PROVIDER_REG = _CRYPT_PROVIDER_REG;
TCryptProviderReg = _CRYPT_PROVIDER_REG;
PCryptProviders = ^TCryptProviders;
{$EXTERNALSYM _CRYPT_PROVIDERS}
_CRYPT_PROVIDERS = record
cProviders: ULONG;
rgpszProviders: ^PWideChar;
end;
{$EXTERNALSYM CRYPT_PROVIDERS}
CRYPT_PROVIDERS = _CRYPT_PROVIDERS;
TCryptProviders = _CRYPT_PROVIDERS;
//
// Context Configuration Structures
//
PCryptContextConfig = ^TCryptContextConfig;
{$EXTERNALSYM _CRYPT_CONTEXT_CONFIG}
_CRYPT_CONTEXT_CONFIG = record
dwFlags: ULONG;
dwReserved: ULONG;
end;
{$EXTERNALSYM CRYPT_CONTEXT_CONFIG}
CRYPT_CONTEXT_CONFIG = _CRYPT_CONTEXT_CONFIG;
TCryptContextConfig = _CRYPT_CONTEXT_CONFIG;
PCryptContextFunctionConfig = ^TCryptContextFunctionConfig;
{$EXTERNALSYM _CRYPT_CONTEXT_FUNCTION_CONFIG}
_CRYPT_CONTEXT_FUNCTION_CONFIG = record
dwFlags: ULONG;
dwReserved: ULONG;
end;
{$EXTERNALSYM CRYPT_CONTEXT_FUNCTION_CONFIG}
CRYPT_CONTEXT_FUNCTION_CONFIG = _CRYPT_CONTEXT_FUNCTION_CONFIG;
TCryptContextFunctionConfig = _CRYPT_CONTEXT_FUNCTION_CONFIG;
PCryptContexts = ^TCryptContexts;
{$EXTERNALSYM _CRYPT_CONTEXTS}
_CRYPT_CONTEXTS = record
cContexts: ULONG;
rgpszContexts: ^PWideChar;
end;
{$EXTERNALSYM CRYPT_CONTEXTS}
CRYPT_CONTEXTS = _CRYPT_CONTEXTS;
TCryptContexts = _CRYPT_CONTEXTS;
PCryptContextFunctions = ^TCryptContextFunctions;
{$EXTERNALSYM _CRYPT_CONTEXT_FUNCTIONS}
_CRYPT_CONTEXT_FUNCTIONS = record
cFunctions: ULONG;
rgpszFunctions: ^PWideChar;
end;
{$EXTERNALSYM CRYPT_CONTEXT_FUNCTIONS}
CRYPT_CONTEXT_FUNCTIONS = _CRYPT_CONTEXT_FUNCTIONS;
TCryptContextFunctions = _CRYPT_CONTEXT_FUNCTIONS;
PCryptContextFunctionProviders = ^TCryptContextFunctionProviders;
{$EXTERNALSYM _CRYPT_CONTEXT_FUNCTION_PROVIDERS}
_CRYPT_CONTEXT_FUNCTION_PROVIDERS = record
cProviders: ULONG;
rgpszProviders: ^PWideChar;
end;
{$EXTERNALSYM CRYPT_CONTEXT_FUNCTION_PROVIDERS}
CRYPT_CONTEXT_FUNCTION_PROVIDERS = _CRYPT_CONTEXT_FUNCTION_PROVIDERS;
TCryptContextFunctionProviders = _CRYPT_CONTEXT_FUNCTION_PROVIDERS;
//
// Provider Resolution Structures
//
PCryptPropertyRef = ^TCryptPropertyRef;
{$EXTERNALSYM _CRYPT_PROPERTY_REF}
_CRYPT_PROPERTY_REF = record
pszProperty: PWideChar;
cbValue: ULONG;
pbValue: PUCHAR;
end;
{$EXTERNALSYM CRYPT_PROPERTY_REF}
CRYPT_PROPERTY_REF = _CRYPT_PROPERTY_REF;
TCryptPropertyRef = _CRYPT_PROPERTY_REF;
PCryptImageRef = ^TCryptImageRef;
{$EXTERNALSYM _CRYPT_IMAGE_REF}
_CRYPT_IMAGE_REF = record
pszImage: PWideChar;
dwFlags: ULONG;
end;
{$EXTERNALSYM CRYPT_IMAGE_REF}
CRYPT_IMAGE_REF = _CRYPT_IMAGE_REF;
TCryptImageRef = _CRYPT_IMAGE_REF;
PCryptProviderRef = ^TCryptProviderRef;
{$EXTERNALSYM _CRYPT_PROVIDER_REF}
_CRYPT_PROVIDER_REF = record
dwInterface: ULONG;
pszFunction: PWideChar;
pszProvider: PWideChar;
cProperties: ULONG;
rgpProperties: ^PCryptPropertyRef;
pUM: PCryptImageRef;
pKM: PCryptImageRef;
end;
{$EXTERNALSYM CRYPT_PROVIDER_REF}
CRYPT_PROVIDER_REF = _CRYPT_PROVIDER_REF;
TCryptProviderRef = _CRYPT_PROVIDER_REF;
PPCryptProviderRefs = ^PCryptProviderRefs;
PCryptProviderRefs = ^TCryptProviderRefs;
{$EXTERNALSYM _CRYPT_PROVIDER_REFS}
_CRYPT_PROVIDER_REFS = record
cProviders: ULONG;
rgpProviders: ^PCryptProviderRef;
end;
{$EXTERNALSYM CRYPT_PROVIDER_REFS}
CRYPT_PROVIDER_REFS = _CRYPT_PROVIDER_REFS;
TCryptProviderRefs = _CRYPT_PROVIDER_REFS;
//////////////////////////////////////////////////////////////////////////////
// CryptoConfig Functions ////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
{$EXTERNALSYM BCryptQueryProviderRegistration}
function BCryptQueryProviderRegistration(pszProvider: LPCWSTR;
dwMode, dwInterface: ULONG; pcbBuffer: PULONG;
out ppBuffer: PCryptProviderReg): TNTStatus stdcall;
{$EXTERNALSYM BCryptEnumRegisteredProviders}
function BCryptEnumRegisteredProviders(var pcbBuffer: ULONG;
out ppBuffer: PCryptProviders): TNTStatus stdcall;
//
// Context Configuration Functions
//
{$EXTERNALSYM BCryptCreateContext}
function BCryptCreateContext(dwTable: ULONG; pszContext: LPCWSTR;
pConfig: PCryptContextConfig): TNTStatus stdcall; // Optional
{$EXTERNALSYM BCryptDeleteContext}
function BCryptDeleteContext(dwTable: ULONG;
pszContext: LPCWSTR): TNTStatus stdcall;
{$EXTERNALSYM BCryptEnumContexts}
function BCryptEnumContexts(dwTable: ULONG; var pcbBuffer: ULONG;
out ppBuffer: PCryptContexts): TNTStatus stdcall;
{$EXTERNALSYM BCryptConfigureContext}
function BCryptConfigureContext(dwTable: ULONG; pszContext: LPCWSTR;
pConfig: PCryptContextConfig): TNTStatus stdcall;
{$EXTERNALSYM BCryptQueryContextConfiguration}
function BCryptQueryContextConfiguration(dwTable: ULONG; pszContext: LPCWSTR;
var pcbBuffer: ULONG; out ppBuffer: PCryptContextConfig): TNTStatus stdcall;
{$EXTERNALSYM BCryptAddContextFunction}
function BCryptAddContextFunction(dwTable: ULONG; pszContext: LPCWSTR;
dwInterface: ULONG; pszFunction: LPCWSTR;
dwPosition: ULONG): TNTStatus stdcall;
{$EXTERNALSYM BCryptRemoveContextFunction}
function BCryptRemoveContextFunction(dwTable: ULONG; pszContext: LPCWSTR;
dwInterface: ULONG; pszFunction: LPCWSTR): TNTStatus stdcall;
{$EXTERNALSYM BCryptEnumContextFunctions}
function BCryptEnumContextFunctions(dwTable: ULONG; pszContext: LPCWSTR;
dwInterface: ULONG; var pcbBuffer: ULONG;
out ppBuffer: PCryptContextFunctions): TNTStatus stdcall;
{$EXTERNALSYM BCryptConfigureContextFunction}
function BCryptConfigureContextFunction(dwTable: ULONG; pszContext: LPCWSTR;
dwInterface: ULONG; pszFunction: LPCWSTR;
pConfig: PCryptContextFunctionConfig): TNTStatus stdcall;
{$EXTERNALSYM BCryptQueryContextFunctionConfiguration}
function BCryptQueryContextFunctionConfiguration(dwTable: ULONG;
pszContext: LPCWSTR; dwInterface: ULONG; pszFunction: LPCWSTR;
var pcbBuffer: ULONG;
out ppBuffer: PCryptContextFunctionConfig): TNTStatus stdcall;
{$EXTERNALSYM BCryptEnumContextFunctionProviders}
function BCryptEnumContextFunctionProviders(dwTable: ULONG;
pszContext: LPCWSTR; dwInterface: ULONG; pszFunction: LPCWSTR;
var pcbBuffer: ULONG;
out ppBuffer: PCryptContextFunctionProviders): TNTStatus stdcall;
{$EXTERNALSYM BCryptSetContextFunctionProperty}
function BCryptSetContextFunctionProperty(dwTable: ULONG;
pszContext: LPCWSTR; dwInterface: ULONG; pszFunction, pszProperty: LPCWSTR;
cbValue: ULONG; pbValue: PUCHAR): TNTStatus stdcall;
{$EXTERNALSYM BCryptQueryContextFunctionProperty}
function BCryptQueryContextFunctionProperty(dwTable: ULONG;
pszContext: LPCWSTR; dwInterface: ULONG; pszFunction, pszProperty: LPCWSTR;
var pcbValue: ULONG; var ppbValue: PUCHAR): TNTStatus stdcall;
//
// Configuration Change Notification Functions
//
{$EXTERNALSYM BCryptRegisterConfigChangeNotify}
function BCryptRegisterConfigChangeNotify(
out phEvent: THANDLE): TNTStatus; stdcall;
{$EXTERNALSYM BCryptUnregisterConfigChangeNotify}
function BCryptUnregisterConfigChangeNotify(
hEvent: THANDLE): TNTStatus; stdcall;
//
// Provider Resolution Functions
//
{$EXTERNALSYM BCryptResolveProviders}
function BCryptResolveProviders(pszContext: LPCWSTR; dwInterface: ULONG;
pszFunction, pszProvider: LPCWSTR; dwMode, dwFlags: ULONG;
var pcbBuffer: ULONG; ppBuffer: PPCryptProviderRefs): TNTStatus; stdcall;
//
// Miscellaneous queries about the crypto environment
//
{$EXTERNALSYM BCryptGetFipsAlgorithmMode}
function BCryptGetFipsAlgorithmMode(
out pfEnabled: ByteBool): TNTStatus; stdcall;
{$ENDIF JWA_IMPLEMENTATIONSECTION}
{$IFNDEF JWA_OMIT_SECTIONS}
implementation
uses JwaWinDLLNames;
{$ENDIF JWA_OMIT_SECTIONS}
{$IFNDEF JWA_INTERFACESECTION}
{$IFNDEF DYNAMIC_LINK}
function BCryptOpenAlgorithmProvider; external bcryptdll name 'BCryptOpenAlgorithmProvider';
function BCryptEnumAlgorithms; external bcryptdll name 'BCryptEnumAlgorithms';
function BCryptEnumProviders; external bcryptdll name 'BCryptEnumProviders';
function BCryptGetProperty; external bcryptdll name 'BCryptGetProperty';
function BCryptSetProperty; external bcryptdll name 'BCryptSetProperty';
function BCryptCloseAlgorithmProvider; external bcryptdll name 'BCryptCloseAlgorithmProvider';
procedure BCryptFreeBuffer; external bcryptdll name 'BCryptFreeBuffer';
function BCryptGenerateSymmetricKey; external bcryptdll name 'BCryptGenerateSymmetricKey';
function BCryptGenerateKeyPair; external bcryptdll name 'BCryptGenerateKeyPair';
function BCryptEncrypt; external bcryptdll name 'BCryptEncrypt';
function BCryptDecrypt; external bcryptdll name 'BCryptDecrypt';
function BCryptExportKey; external bcryptdll name 'BCryptExportKey';
function BCryptImportKey; external bcryptdll name 'BCryptImportKey';
function BCryptImportKeyPair; external bcryptdll name 'BCryptImportKeyPair';
function BCryptDuplicateKey; external bcryptdll name 'BCryptDuplicateKey';
function BCryptFinalizeKeyPair; external bcryptdll name 'BCryptFinalizeKeyPair';
function BCryptDestroyKey; external bcryptdll name 'BCryptDestroyKey';
function BCryptDestroySecret; external bcryptdll name 'BCryptDestroySecret';
function BCryptSignHash; external bcryptdll name 'BCryptSignHash';
function BCryptVerifySignature; external bcryptdll name 'BCryptVerifySignature';
function BCryptSecretAgreement; external bcryptdll name 'BCryptSecretAgreement';
function BCryptDeriveKey; external bcryptdll name 'BCryptDeriveKey';
function BCryptCreateHash; external bcryptdll name 'BCryptCreateHash';
function BCryptHashData; external bcryptdll name 'BCryptHashData';
function BCryptFinishHash; external bcryptdll name 'BCryptFinishHash';
function BCryptDuplicateHash; external bcryptdll name 'BCryptDuplicateHash';
function BCryptDestroyHash; external bcryptdll name 'BCryptDestroyHash';
function BCryptGenRandom; external bcryptdll name 'BCryptGenRandom';
function BCryptRegisterConfigChangeNotify; external bcryptdll name 'BCryptRegisterConfigChangeNotify';
function BCryptUnregisterConfigChangeNotify; external bcryptdll name 'BCryptUnregisterConfigChangeNotify';
function BCryptResolveProviders; external bcryptdll name 'BCryptResolveProviders';
function BCryptGetFipsAlgorithmMode; external bcryptdll name 'BCryptGetFipsAlgorithmMode';
function BCryptQueryProviderRegistration; external bcryptdll name 'BCryptQueryProviderRegistration';
function BCryptEnumRegisteredProviders; external bcryptdll name 'BCryptEnumRegisteredProviders';
function BCryptCreateContext; external bcryptdll name 'BCryptCreateContext';
function BCryptDeleteContext; external bcryptdll name 'BCryptDeleteContext';
function BCryptEnumContexts; external bcryptdll name 'BCryptEnumContexts';
function BCryptConfigureContext; external bcryptdll name 'BCryptConfigureContext';
function BCryptQueryContextConfiguration; external bcryptdll name 'BCryptQueryContextConfiguration';
function BCryptAddContextFunction; external bcryptdll name 'BCryptAddContextFunction';
function BCryptRemoveContextFunction; external bcryptdll name 'BCryptRemoveContextFunction';
function BCryptEnumContextFunctions; external bcryptdll name 'BCryptEnumContextFunctions';
function BCryptConfigureContextFunction; external bcryptdll name 'BCryptConfigureContextFunction';
function BCryptQueryContextFunctionConfiguration; external bcryptdll name 'BCryptConfigureContextFunction';
function BCryptEnumContextFunctionProviders; external bcryptdll name 'BCryptEnumContextFunctionProviders';
function BCryptSetContextFunctionProperty; external bcryptdll name 'BCryptSetContextFunctionProperty';
function BCryptQueryContextFunctionProperty; external bcryptdll name 'BCryptQueryContextFunctionProperty';
{$ELSE}
var
_BCryptOpenAlgorithmProvider: Pointer;
function BCryptOpenAlgorithmProvider;
begin
GetProcedureAddress(_BCryptOpenAlgorithmProvider, bcryptdll, 'BCryptOpenAlgorithmProvider');
asm
MOV ESP, EBP
POP EBP
JMP [_BCryptOpenAlgorithmProvider]
end;
end;
var
_BCryptEnumAlgorithms: Pointer;
function BCryptEnumAlgorithms;
begin
GetProcedureAddress(_BCryptEnumAlgorithms, bcryptdll, 'BCryptEnumAlgorithms');
asm
MOV ESP, EBP
POP EBP
JMP [_BCryptEnumAlgorithms]
end;
end;
var
_BCryptEnumProviders: Pointer;
function BCryptEnumProviders;
begin
GetProcedureAddress(_BCryptEnumProviders, bcryptdll, 'BCryptEnumProviders');
asm
MOV ESP, EBP
POP EBP
JMP [_BCryptEnumProviders]
end;
end;
var
_BCryptGetProperty: Pointer;
function BCryptGetProperty;
begin
GetProcedureAddress(_BCryptGetProperty, bcryptdll, 'BCryptGetProperty');
asm
MOV ESP, EBP
POP EBP
JMP [_BCryptGetProperty]
end;
end;
var
_BCryptSetProperty: Pointer;
function BCryptSetProperty;
begin
GetProcedureAddress(_BCryptSetProperty, bcryptdll, 'BCryptSetProperty');
asm
MOV ESP, EBP
POP EBP
JMP [_BCryptSetProperty]
end;
end;
var
_BCryptCloseAlgorithmProvider: Pointer;
function BCryptCloseAlgorithmProvider;
begin
GetProcedureAddress(_BCryptCloseAlgorithmProvider, bcryptdll, 'BCryptCloseAlgorithmProvider');
asm
MOV ESP, EBP
POP EBP
JMP [_BCryptCloseAlgorithmProvider]
end;
end;
var
_BCryptFreeBuffer: Pointer;
procedure BCryptFreeBuffer;
begin
GetProcedureAddress(_BCryptFreeBuffer, bcryptdll, 'BCryptFreeBuffer');
asm
MOV ESP, EBP
POP EBP
JMP [_BCryptFreeBuffer]
end;
end;
var
_BCryptGenerateSymmetricKey: Pointer;
function BCryptGenerateSymmetricKey;
begin
GetProcedureAddress(_BCryptGenerateSymmetricKey, bcryptdll, 'BCryptGenerateSymmetricKey');
asm
MOV ESP, EBP
POP EBP
JMP [_BCryptGenerateSymmetricKey]
end;
end;
var
_BCryptGenerateKeyPair: Pointer;
function BCryptGenerateKeyPair;
begin
GetProcedureAddress(_BCryptGenerateKeyPair, bcryptdll, 'BCryptGenerateKeyPair');
asm
MOV ESP, EBP
POP EBP
JMP [_BCryptGenerateKeyPair]
end;
end;
var
_BCryptEncrypt: Pointer;
function BCryptEncrypt;
begin
GetProcedureAddress(_BCryptEncrypt, bcryptdll, 'BCryptEncrypt');
asm
MOV ESP, EBP
POP EBP
JMP [_BCryptEncrypt]
end;
end;
var
_BCryptDecrypt: Pointer;
function BCryptDecrypt;
begin
GetProcedureAddress(_BCryptDecrypt, bcryptdll, 'BCryptDecrypt');
asm
MOV ESP, EBP
POP EBP
JMP [_BCryptDecrypt]
end;
end;
var
_BCryptExportKey: Pointer;
function BCryptExportKey;
begin
GetProcedureAddress(_BCryptExportKey, bcryptdll, 'BCryptExportKey');
asm
MOV ESP, EBP
POP EBP
JMP [_BCryptExportKey]
end;
end;
var
_BCryptImportKey: Pointer;
function BCryptImportKey;
begin
GetProcedureAddress(_BCryptImportKey, bcryptdll, 'BCryptImportKey');
asm
MOV ESP, EBP
POP EBP
JMP [_BCryptImportKey]
end;
end;
var
_BCryptImportKeyPair: Pointer;
function BCryptImportKeyPair;
begin
GetProcedureAddress(_BCryptImportKeyPair, bcryptdll, 'BCryptImportKeyPair');
asm
MOV ESP, EBP
POP EBP
JMP [_BCryptImportKeyPair]
end;
end;
var
_BCryptDuplicateKey: Pointer;
function BCryptDuplicateKey;
begin
GetProcedureAddress(_BCryptDuplicateKey, bcryptdll, 'BCryptDuplicateKey');
asm
MOV ESP, EBP
POP EBP
JMP [_BCryptDuplicateKey]
end;
end;
var
_BCryptFinalizeKeyPair: Pointer;
function BCryptFinalizeKeyPair;
begin
GetProcedureAddress(_BCryptFinalizeKeyPair, bcryptdll, 'BCryptFinalizeKeyPair');
asm
MOV ESP, EBP
POP EBP
JMP [_BCryptFinalizeKeyPair]
end;
end;
var
_BCryptDestroyKey: Pointer;
function BCryptDestroyKey;
begin
GetProcedureAddress(_BCryptDestroyKey, bcryptdll, 'BCryptDestroyKey');
asm
MOV ESP, EBP
POP EBP
JMP [_BCryptDestroyKey]
end;
end;
var
_BCryptDestroySecret: Pointer;
function BCryptDestroySecret;
begin
GetProcedureAddress(_BCryptDestroySecret, bcryptdll, 'BCryptDestroySecret');
asm
MOV ESP, EBP
POP EBP
JMP [_BCryptDestroySecret]
end;
end;
var
_BCryptSignHash: Pointer;
function BCryptSignHash;
begin
GetProcedureAddress(_BCryptSignHash, bcryptdll, 'BCryptSignHash');
asm
MOV ESP, EBP
POP EBP
JMP [_BCryptSignHash]
end;
end;
var
_BCryptVerifySignature: Pointer;
function BCryptVerifySignature;
begin
GetProcedureAddress(_BCryptVerifySignature, bcryptdll, 'BCryptVerifySignature');
asm
MOV ESP, EBP
POP EBP
JMP [_BCryptVerifySignature]
end;
end;
var
_BCryptSecretAgreement: Pointer;
function BCryptSecretAgreement;
begin
GetProcedureAddress(_BCryptSecretAgreement, bcryptdll, 'BCryptSecretAgreement');
asm
MOV ESP, EBP
POP EBP
JMP [_BCryptSecretAgreement]
end;
end;
var
_BCryptDeriveKey: Pointer;
function BCryptDeriveKey;
begin
GetProcedureAddress(_BCryptDeriveKey, bcryptdll, 'BCryptDeriveKey');
asm
MOV ESP, EBP
POP EBP
JMP [_BCryptDeriveKey]
end;
end;
var
_BCryptCreateHash: Pointer;
function BCryptCreateHash;
begin
GetProcedureAddress(_BCryptCreateHash, bcryptdll, 'BCryptCreateHash');
asm
MOV ESP, EBP
POP EBP
JMP [_BCryptCreateHash]
end;
end;
var
_BCryptHashData: Pointer;
function BCryptHashData;
begin
GetProcedureAddress(_BCryptHashData, bcryptdll, 'BCryptHashData');
asm
MOV ESP, EBP
POP EBP
JMP [_BCryptHashData]
end;
end;
var
_BCryptFinishHash: Pointer;
function BCryptFinishHash;
begin
GetProcedureAddress(_BCryptFinishHash, bcryptdll, 'BCryptFinishHash');
asm
MOV ESP, EBP
POP EBP
JMP [_BCryptFinishHash]
end;
end;
var
_BCryptDuplicateHash: Pointer;
function BCryptDuplicateHash;
begin
GetProcedureAddress(_BCryptDuplicateHash, bcryptdll, 'BCryptDuplicateHash');
asm
MOV ESP, EBP
POP EBP
JMP [_BCryptDuplicateHash]
end;
end;
var
_BCryptDestroyHash: Pointer;
function BCryptDestroyHash;
begin
GetProcedureAddress(_BCryptDestroyHash, bcryptdll, 'BCryptDestroyHash');
asm
MOV ESP, EBP
POP EBP
JMP [_BCryptDestroyHash]
end;
end;
var
_BCryptGenRandom: Pointer;
function BCryptGenRandom;
begin
GetProcedureAddress(_BCryptGenRandom, bcryptdll, 'BCryptGenRandom');
asm
MOV ESP, EBP
POP EBP
JMP [_BCryptGenRandom]
end;
end;
var
//_BCryptRegisterConfigChangeNotify: Pointer;
_BCryptRegisterConfigCN: Pointer;
function BCryptRegisterConfigChangeNotify;
begin
GetProcedureAddress(_BCryptRegisterConfigCN, bcryptdll, 'BCryptRegisterConfigChangeNotify');
asm
MOV ESP, EBP
POP EBP
JMP [_BCryptRegisterConfigCN]
end;
end;
var
//_BCryptUnregisterConfigChangeNotify: Pointer;
_BCryptUnregisterConfigCN: Pointer;
function BCryptUnregisterConfigChangeNotify;
begin
GetProcedureAddress(_BCryptUnregisterConfigCN, bcryptdll, 'BCryptUnregisterConfigChangeNotify');
asm
MOV ESP, EBP
POP EBP
JMP [_BCryptUnregisterConfigCN]
end;
end;
var
_BCryptResolveProviders: Pointer;
function BCryptResolveProviders;
begin
GetProcedureAddress(_BCryptResolveProviders, bcryptdll, 'BCryptResolveProviders');
asm
MOV ESP, EBP
POP EBP
JMP [_BCryptResolveProviders]
end;
end;
var
_BCryptGetFipsAlgorithmMode: Pointer;
function BCryptGetFipsAlgorithmMode;
begin
GetProcedureAddress(_BCryptGetFipsAlgorithmMode, bcryptdll, 'BCryptGetFipsAlgorithmMode');
asm
MOV ESP, EBP
POP EBP
JMP [_BCryptGetFipsAlgorithmMode]
end;
end;
var
_BCryptQueryProviderRegistration: Pointer;
function BCryptQueryProviderRegistration;
begin
GetProcedureAddress(_BCryptQueryProviderRegistration, bcryptdll, 'BCryptQueryProviderRegistration');
asm
MOV ESP, EBP
POP EBP
JMP [_BCryptQueryProviderRegistration]
end;
end;
var
_BCryptEnumRegisteredProviders: Pointer;
function BCryptEnumRegisteredProviders;
begin
GetProcedureAddress(_BCryptEnumRegisteredProviders, bcryptdll, 'BCryptEnumRegisteredProviders');
asm
MOV ESP, EBP
POP EBP
JMP [_BCryptEnumRegisteredProviders]
end;
end;
var
_BCryptCreateContext: Pointer;
function BCryptCreateContext;
begin
GetProcedureAddress(_BCryptCreateContext, bcryptdll, 'BCryptCreateContext');
asm
MOV ESP, EBP
POP EBP
JMP [_BCryptCreateContext]
end;
end;
var
_BCryptDeleteContext: Pointer;
function BCryptDeleteContext;
begin
GetProcedureAddress(_BCryptDeleteContext, bcryptdll, 'BCryptDeleteContext');
asm
MOV ESP, EBP
POP EBP
JMP [_BCryptDeleteContext]
end;
end;
var
_BCryptEnumContexts: Pointer;
function BCryptEnumContexts;
begin
GetProcedureAddress(_BCryptEnumContexts, bcryptdll, 'BCryptEnumContexts');
asm
MOV ESP, EBP
POP EBP
JMP [_BCryptEnumContexts]
end;
end;
var
_BCryptConfigureContext: Pointer;
function BCryptConfigureContext;
begin
GetProcedureAddress(_BCryptConfigureContext, bcryptdll, 'BCryptConfigureContext');
asm
MOV ESP, EBP
POP EBP
JMP [_BCryptConfigureContext]
end;
end;
var
_BCryptQueryContextConfiguration: Pointer;
function BCryptQueryContextConfiguration;
begin
GetProcedureAddress(_BCryptQueryContextConfiguration, bcryptdll, 'BCryptQueryContextConfiguration');
asm
MOV ESP, EBP
POP EBP
JMP [_BCryptQueryContextConfiguration]
end;
end;
var
_BCryptAddContextFunction: Pointer;
function BCryptAddContextFunction;
begin
GetProcedureAddress(_BCryptAddContextFunction, bcryptdll, 'BCryptAddContextFunction');
asm
MOV ESP, EBP
POP EBP
JMP [_BCryptAddContextFunction]
end;
end;
var
_BCryptRemoveContextFunction: Pointer;
function BCryptRemoveContextFunction;
begin
GetProcedureAddress(_BCryptRemoveContextFunction, bcryptdll, 'BCryptRemoveContextFunction');
asm
MOV ESP, EBP
POP EBP
JMP [_BCryptRemoveContextFunction]
end;
end;
var
_BCryptEnumContextFunctions: Pointer;
function BCryptEnumContextFunctions;
begin
GetProcedureAddress(_BCryptEnumContextFunctions, bcryptdll, 'BCryptEnumContextFunctions');
asm
MOV ESP, EBP
POP EBP
JMP [_BCryptEnumContextFunctions]
end;
end;
var
_BCryptConfigureContextFunction: Pointer;
function BCryptConfigureContextFunction;
begin
GetProcedureAddress(_BCryptConfigureContextFunction, bcryptdll, 'BCryptConfigureContextFunction');
asm
MOV ESP, EBP
POP EBP
JMP [_BCryptConfigureContextFunction]
end;
end;
var
//_BCryptQueryContextFunctionConfiguration: Pointer;
_BCryptQueryContextFC: Pointer;
function BCryptQueryContextFunctionConfiguration;
begin
GetProcedureAddress(_BCryptQueryContextFC, bcryptdll, 'BCryptQueryContextFunctionConfiguration');
asm
MOV ESP, EBP
POP EBP
JMP [_BCryptQueryContextFC]
end;
end;
var
//_BCryptEnumContextFunctionProviders: Pointer;
_BCryptEnumContextFP: Pointer;
function BCryptEnumContextFunctionProviders;
begin
GetProcedureAddress(_BCryptEnumContextFP, bcryptdll, 'BCryptEnumContextFunctionProviders');
asm
MOV ESP, EBP
POP EBP
JMP [_BCryptEnumContextFP]
end;
end;
var
//_BCryptSetContextFunctionProperty: Pointer;
_BCryptSetContextFP: Pointer;
function BCryptSetContextFunctionProperty;
begin
GetProcedureAddress(_BCryptSetContextFP, bcryptdll, 'BCryptSetContextFunctionProperty');
asm
MOV ESP, EBP
POP EBP
JMP [_BCryptSetContextFP]
end;
end;
var
//_BCryptQueryContextFunctionProperty: Pointer;
_BCryptQueryContextFP: Pointer;
function BCryptQueryContextFunctionProperty;
begin
GetProcedureAddress(_BCryptQueryContextFP, bcryptdll, 'BCryptQueryContextFunctionProperty');
asm
MOV ESP, EBP
POP EBP
JMP [_BCryptQueryContextFP]
end;
end;
{$ENDIF DYNAMIC_LINK}
// Macro translations
function BCRYPT_MAKE_INTERFACE_VERSION(
major, minor: Word): TBCryptInterfaceVersion;
begin
Result.MajorVersion := major;
Result.MinorVersion := minor;
end;
function BCRYPT_IS_INTERFACE_VERSION_COMPATIBLE(
const loader, provider: TBCryptInterfaceVersion): Boolean;
begin
Result := loader.MajorVersion <= provider.MajorVersion;
end;
{$ENDIF JWA_INTERFACESECTION}
{$IFNDEF JWA_OMIT_SECTIONS}
end.
{$ENDIF JWA_OMIT_SECTIONS}
Reference in a new issue View git blame Copy permalink