wcrypt2.pas

Delphi LDAP Authentication Component delphi ldap控件

function CryptSetKeyParam(hKey    :HCRYPTKEY;
                          dwParam :DWORD;
                          pbData  :PBYTE;
                          dwFlags :DWORD) :BOOL;stdcall;


function CryptGetKeyParam(hKey       :HCRYPTKEY;
                          dwParam    :DWORD;
                          pbData     :PBYTE;
                          pdwDataLen :PDWORD;
                          dwFlags    :DWORD) :BOOL;stdcall;


function CryptSetHashParam(hHash   :HCRYPTHASH;
                           dwParam :DWORD;
                           pbData  :PBYTE;
                           dwFlags :DWORD) :BOOL;stdcall;


function CryptGetHashParam(hHash      :HCRYPTHASH;
                           dwParam    :DWORD;
                           pbData     :PBYTE;
                           pdwDataLen :PDWORD;
                           dwFlags    :DWORD) :BOOL;stdcall;


function CryptSetProvParam(hProv   :HCRYPTPROV;
                           dwParam :DWORD;
                           pbData  :PBYTE;
                           dwFlags :DWORD) :BOOL;stdcall;


function CryptGetProvParam(hProv      :HCRYPTPROV;
                           dwParam    :DWORD;
                           pbData     :PBYTE;
                           pdwDataLen :PDWORD;
                           dwFlags    :DWORD) :BOOL;stdcall;


function CryptGenRandom(hProv    :HCRYPTPROV;
                        dwLen    :DWORD;
                        pbBuffer :PBYTE) :BOOL;stdcall;


function CryptGetUserKey(hProv     :HCRYPTPROV;
                         dwKeySpec :DWORD;
                         phUserKey :PHCRYPTKEY) :BOOL;stdcall;


function CryptExportKey(hKey       :HCRYPTKEY;
                        hExpKey    :HCRYPTKEY;
                        dwBlobType :DWORD;
                        dwFlags    :DWORD;
                        pbData     :PBYTE;
                        pdwDataLen :PDWORD) :BOOL;stdcall;


function CryptImportKey(hProv     :HCRYPTPROV;
                        pbData    :PBYTE;
                        dwDataLen :DWORD;
                        hPubKey   :HCRYPTKEY;
                        dwFlags   :DWORD;
                        phKey     :PHCRYPTKEY) :BOOL;stdcall;


function CryptEncrypt(hKey       :HCRYPTKEY;
                      hHash      :HCRYPTHASH;
                      Final      :BOOL;
                      dwFlags    :DWORD;
                      pbData     :PBYTE;
                      pdwDataLen :PDWORD;
                      dwBufLen   :DWORD) :BOOL;stdcall;


function CryptDecrypt(hKey       :HCRYPTKEY;
                      hHash      :HCRYPTHASH;
                      Final      :BOOL;
                      dwFlags    :DWORD;
                      pbData     :PBYTE;
                      pdwDataLen :PDWORD) :BOOL;stdcall;


function CryptCreateHash(hProv   :HCRYPTPROV;
                         Algid   :ALG_ID;
                         hKey    :HCRYPTKEY;
                         dwFlags :DWORD;
                         phHash  :PHCRYPTHASH) :BOOL;stdcall;


function CryptHashData(hHash       :HCRYPTHASH;
                 const pbData      :PBYTE;
                       dwDataLen   :DWORD;
                       dwFlags     :DWORD) :BOOL;stdcall;


function CryptHashSessionKey(hHash   :HCRYPTHASH;
                             hKey    :HCRYPTKEY;
                             dwFlags :DWORD) :BOOL;stdcall;


function CryptDestroyHash(hHash :HCRYPTHASH) :BOOL;stdcall;


function CryptSignHashA(hHash        :HCRYPTHASH;
                        dwKeySpec    :DWORD;
                        sDescription :PAnsiChar;
                        dwFlags      :DWORD;
                        pbSignature  :PBYTE;
                        pdwSigLen    :PDWORD) :BOOL;stdcall;


function CryptSignHash(hHash         :HCRYPTHASH;
                        dwKeySpec    :DWORD;
                        sDescription :LPAWSTR;
                        dwFlags      :DWORD;
                        pbSignature  :PBYTE;
                        pdwSigLen    :PDWORD) :BOOL;stdcall;

function CryptSignHashW(hHash        :HCRYPTHASH;
                        dwKeySpec    :DWORD;
                        sDescription :PWideChar;
                        dwFlags      :DWORD;
                        pbSignature  :PBYTE;
                        pdwSigLen    :PDWORD) :BOOL;stdcall;

function CryptSignHashU(hHash        :HCRYPTHASH;
                        dwKeySpec    :DWORD;
                        sDescription :PWideChar;
                        dwFlags      :DWORD;
                        pbSignature  :PBYTE;
                        pdwSigLen    :PDWORD) :BOOL;stdcall;

function CryptVerifySignatureA(hHash        :HCRYPTHASH;
                         const pbSignature  :PBYTE;
                               dwSigLen     :DWORD;
                               hPubKey      :HCRYPTKEY;
                               sDescription :PAnsiChar;
                               dwFlags      :DWORD) :BOOL;stdcall;

function CryptVerifySignature(hHash         :HCRYPTHASH;
                        const pbSignature  :PBYTE;
                              dwSigLen     :DWORD;
                              hPubKey      :HCRYPTKEY;
                              sDescription :LPAWSTR;
                               dwFlags      :DWORD) :BOOL;stdcall;


function CryptVerifySignatureW(hHash        :HCRYPTHASH;
                         const pbSignature  :PBYTE;
                               dwSigLen     :DWORD;
                               hPubKey      :HCRYPTKEY;
                               sDescription :PWideChar;
                               dwFlags      :DWORD) :BOOL;stdcall;


function CryptSetProviderA(pszProvName :PAnsiChar;
                           dwProvType  :DWORD) :BOOL;stdcall;

function CryptSetProvider(pszProvName :LPAWSTR;
                           dwProvType :DWORD) :BOOL;stdcall;

function CryptSetProviderW(pszProvName :PWideChar;
                           dwProvType  :DWORD) :BOOL;stdcall;

function CryptSetProviderU(pszProvName :PWideChar;
                           dwProvType  :DWORD) :BOOL;stdcall;

{$IFDEF NT5}

function CryptSetProviderExA(pszProvName :LPCSTR;
                             dwProvType  :DWORD;
                             pdwReserved :PDWORD;
                             dwFlags     :DWORD):BOOL;stdcall;

function CryptSetProviderExW(pszProvName :LPCWSTR;
                             dwProvType  :DWORD;
                             pdwReserved :PDWORD;
                             dwFlags     :DWORD):BOOL;stdcall;

function CryptSetProviderEx(pszProvName :LPAWSTR;
                            dwProvType  :DWORD;
                            pdwReserved :PDWORD;
                            dwFlags     :DWORD):BOOL;stdcall;


function CryptGetDefaultProviderA(dwProvType  :DWORD;
                                  pdwReserved :DWORD;
                                  dwFlags     :DWORD;
                                  pszProvName :LPSTR;
                                  pcbProvName :PDWORD):BOOL ; stdcall;

function CryptGetDefaultProviderW(dwProvType  :DWORD;
                                  pdwReserved :DWORD;
                                  dwFlags     :DWORD;
                                  pszProvName :LPWSTR;
                                  pcbProvName :PDWORD):BOOL ; stdcall;

function CryptGetDefaultProvider(dwProvType  :DWORD;
                                 pdwReserved :DWORD;
                                 dwFlags     :DWORD;
                                 pszProvName :LPAWSTR;
                                 pcbProvName :PDWORD):BOOL ; stdcall;

function CryptEnumProviderTypesA(dwIndex     :DWORD;
                                 pdwReserved :PDWORD;
                                 dwFlags     :DWORD;
                                 pdwProvType :PDWORD;
                                 pszTypeName :LPSTR;
                                 pcbTypeName :PDWORD):BOOL ; stdcall;

function CryptEnumProviderTypesW(dwIndex     :DWORD;
                                 pdwReserved :PDWORD;
                                 dwFlags     :DWORD;
                                 pdwProvType :PDWORD;
                                 pszTypeName :LPWSTR;
                                 pcbTypeName :PDWORD):BOOL ; stdcall;

function CryptEnumProviderTypes(dwIndex     :DWORD;
                                pdwReserved :PDWORD;
                                dwFlags     :DWORD;
                                pdwProvType :PDWORD;
                                pszTypeName :LPAWSTR;
                                pcbTypeName :PDWORD):BOOL ; stdcall;

function CryptEnumProvidersA(dwIndex     :DWORD;
                             pdwReserved :PDWORD;
                             dwFlags     :DWORD;
                             pdwProvType :PDWORD;
                             pszProvName :LPSTR;
                             pcbProvName :PDWORD):BOOL ; stdcall;

function CryptEnumProvidersW(dwIndex     :DWORD;
                             pdwReserved :PDWORD;
                             dwFlags     :DWORD;
                             pdwProvType :PDWORD;
                             pszProvName :LPWSTR;
                             pcbProvName :PDWORD):BOOL ; stdcall;

function CryptEnumProviders(dwIndex      :DWORD;
                             pdwReserved :PDWORD;
                             dwFlags     :DWORD;
                             pdwProvType :PDWORD;
                             pszProvName :LPAWSTR;
                             pcbProvName :PDWORD):BOOL ; stdcall;

function CryptContextAddRef(hProv       :HCRYPTPROV;
                            pdwReserved :PDWORD;
                            dwFlags     :DWORD):BOOL ; stdcall;

function CryptDuplicateKey(hKey        :HCRYPTKEY;
                           pdwReserved :PDWORD;
                           dwFlags     :DWORD;
                           phKey       :PHCRYPTKEY):BOOL ; stdcall;

function CryptDuplicateHash(hHash       :HCRYPTHASH;
                            pdwReserved :PDWORD;
                            dwFlags     :DWORD;
                            phHash      :PHCRYPTHASH):BOOL ; stdcall;

{$ENDIF NT5}

function CryptEnumProvidersU(dwIndex     :DWORD;
                             pdwReserved :PDWORD;
                             dwFlags     :DWORD;
                             pdwProvType :PDWORD;
                             pszProvName :LPWSTR;
                             pcbProvName :PDWORD):BOOL ; stdcall;

//+-------------------------------------------------------------------------
//  CRYPTOAPI BLOB definitions
//--------------------------------------------------------------------------

type
  PCRYPTOAPI_BLOB = ^CRYPTOAPI_BLOB;
  CRYPTOAPI_BLOB = record
    cbData :DWORD;
    pbData :PBYTE;
  end;

type
  CRYPT_INTEGER_BLOB            = CRYPTOAPI_BLOB;
  PCRYPT_INTEGER_BLOB           = ^CRYPT_INTEGER_BLOB;
  CRYPT_UINT_BLOB               = CRYPTOAPI_BLOB;
  PCRYPT_UINT_BLOB              = ^CRYPT_UINT_BLOB;
  CRYPT_OBJID_BLOB              = CRYPTOAPI_BLOB;
  PCRYPT_OBJID_BLOB             = ^CRYPT_OBJID_BLOB;
  CERT_NAME_BLOB                = CRYPTOAPI_BLOB;
  PCERT_NAME_BLOB               = ^CERT_NAME_BLOB;
  CERT_RDN_VALUE_BLOB           = CRYPTOAPI_BLOB;
  PCERT_RDN_VALUE_BLOB          = ^CERT_RDN_VALUE_BLOB;
  CERT_BLOB                     = CRYPTOAPI_BLOB;
  PCERT_BLOB                    = ^CERT_BLOB;
  CRL_BLOB                      = CRYPTOAPI_BLOB;
  PCRL_BLOB                     = ^CRL_BLOB;
  DATA_BLOB                     = CRYPTOAPI_BLOB;
  PDATA_BLOB                    = ^DATA_BLOB;     // JEFFJEFF temporary (too generic)
  CRYPT_DATA_BLOB               = CRYPTOAPI_BLOB;
  PCRYPT_DATA_BLOB              = ^CRYPT_DATA_BLOB;
  CRYPT_HASH_BLOB               = CRYPTOAPI_BLOB;
  PCRYPT_HASH_BLOB              = ^CRYPT_HASH_BLOB;
  CRYPT_DIGEST_BLOB             = CRYPTOAPI_BLOB;
  PCRYPT_DIGEST_BLOB            = ^CRYPT_DIGEST_BLOB;
  CRYPT_DER_BLOB                = CRYPTOAPI_BLOB;
  PCRYPT_DER_BLOB               = ^CRYPT_DER_BLOB;
  CRYPT_ATTR_BLOB               = CRYPTOAPI_BLOB;
  PCRYPT_ATTR_BLOB              = ^CRYPT_ATTR_BLOB;

//+-------------------------------------------------------------------------
//  In a CRYPT_BIT_BLOB the last byte may contain 0-7 unused bits. Therefore, the
//  overall bit length is cbData * 8 - cUnusedBits.
//--------------------------------------------------------------------------

type
  PCRYPT_BIT_BLOB = ^CRYPT_BIT_BLOB;
  CRYPT_BIT_BLOB = record
    cbData      :DWORD;
    pbData      :PBYTE;
    cUnusedBits :DWORD;
  end;

//+-------------------------------------------------------------------------
//  Type used for any algorithm
//
//  Where the Parameters CRYPT_OBJID_BLOB is in its encoded representation. For most
//  algorithm types, the Parameters CRYPT_OBJID_BLOB is NULL (Parameters.cbData = 0).
//--------------------------------------------------------------------------

type
  PCRYPT_ALGORITHM_IDENTIFIER = ^CRYPT_ALGORITHM_IDENTIFIER;
  CRYPT_ALGORITHM_IDENTIFIER = record
    pszObjId   :LPSTR;
    Parameters :CRYPT_OBJID_BLOB;
  end;

// Following are the definitions of various algorithm object identifiers
// RSA
const 
  szOID_RSA         = '1.2.840.113549';
  szOID_PKCS        = '1.2.840.113549.1';
  szOID_RSA_HASH    = '1.2.840.113549.2';
  szOID_RSA_ENCRYPT = '1.2.840.113549.3';