clcryptapi.pas

Clever_Internet_Suite_6.2的代码 Clever_Internet_Suite_6.2的代码 Clever_Internet_Suite_6.2的代码

                           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;

type
  TclCryptGetProvParam = function (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;

type
  TclCryptGetUserKey = function (hProv     :HCRYPTPROV;
                         dwKeySpec :DWORD;
                         phUserKey :PHCRYPTKEY) :BOOL;stdcall;

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


type
  TclCryptExportKey = function (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;

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

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

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

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

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

function CryptCreateHash(hProv   :HCRYPTPROV;
                         Algid   :ALG_ID;
                         hKey    :HCRYPTKEY;
                         dwFlags :DWORD;
                         phHash  :PHCRYPTHASH) :BOOL; stdcall;
type
  TclCryptCreateHash = function (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;
type
  TclCryptHashData = function (hHash       :HCRYPTHASH;
                 const pbData      :PBYTE;
                       dwDataLen   :DWORD;
                       dwFlags     :DWORD) :BOOL;stdcall;

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

type
  TclCryptDestroyHash = function (hHash :HCRYPTHASH) :BOOL;stdcall;

(*
function CryptHashSessionKey(hHash   :HCRYPTHASH;
                             hKey    :HCRYPTKEY;
                             dwFlags :DWORD) :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;

type
  TclCryptSignHash = function (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;

type
  TclCryptVerifySignature = function (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;

type
  TclCryptGetDefaultProvider = function (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;

type
  TclCryptEnumProviderTypes = function (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;

type
  TclCryptEnumProviders = function (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