#![cfg(windows)]
extern crate winapi;
use winapi::*;
extern "system" {
pub fn CertAddCRLContextToStore(
hCertStore: HCERTSTORE, pCrlContext: PCCRL_CONTEXT, dwAddDisposition: DWORD,
ppStoreContext: *mut PCCRL_CONTEXT,
) -> BOOL;
pub fn CertAddCRLLinkToStore(
hCertStore: HCERTSTORE, pCrlContext: PCCRL_CONTEXT, dwAddDisposition: DWORD,
ppStoreContext: *mut PCCRL_CONTEXT,
) -> BOOL;
pub fn CertAddCTLContextToStore(
hCertStore: HCERTSTORE, pCtlContext: PCCTL_CONTEXT, dwAddDisposition: DWORD,
ppStoreContext: *mut PCCTL_CONTEXT,
) -> BOOL;
pub fn CertAddCTLLinkToStore(
hCertStore: HCERTSTORE, pCtlContext: PCCTL_CONTEXT, dwAddDisposition: DWORD,
ppStoreContext: *mut PCCTL_CONTEXT,
) -> BOOL;
pub fn CertAddCertificateContextToStore(
hCertStore: HCERTSTORE, pCertContext: PCCERT_CONTEXT, dwAddDisposition: DWORD,
ppStoreContext: *mut PCCERT_CONTEXT,
) -> BOOL;
pub fn CertAddCertificateLinkToStore(
hCertStore: HCERTSTORE, pCertContext: PCCERT_CONTEXT, dwAddDisposition: DWORD,
ppStoreContext: *mut PCCERT_CONTEXT,
) -> BOOL;
pub fn CertAddEncodedCRLToStore(
hCertStore: HCERTSTORE, dwCertEncodingType: DWORD, pbCrlEncoded: *const BYTE,
cbCrlEncoded: DWORD, dwAddDisposition: DWORD, ppCrlContext: *mut PCCRL_CONTEXT,
) -> BOOL;
pub fn CertAddEncodedCTLToStore(
hCertStore: HCERTSTORE, dwMsgAndCertEncodingType: DWORD, pbCtlEncoded: *const BYTE,
cbCtlEncoded: DWORD, dwAddDisposition: DWORD, ppCtlContext: *mut PCCTL_CONTEXT,
) -> BOOL;
pub fn CertAddEncodedCertificateToStore(
hCertStore: HCERTSTORE, dwCertEncodingType: DWORD, pbCertEncoded: *const BYTE,
cbCertEncoded: DWORD, dwAddDisposition: DWORD, ppCertContext: *mut PCCERT_CONTEXT,
) -> BOOL;
pub fn CertAddEncodedCertificateToSystemStoreA(
szCertStoreName: LPCSTR, pbCertEncoded: *const BYTE, cbCertEncoded: DWORD,
) -> BOOL;
pub fn CertAddEncodedCertificateToSystemStoreW(
szCertStoreName: LPCWSTR, pbCertEncoded: *const BYTE, cbCertEncoded: DWORD,
) -> BOOL;
pub fn CertAddEnhancedKeyUsageIdentifier(
pCertContext: PCCERT_CONTEXT, pszUsageIdentifier: LPCSTR,
) -> BOOL;
pub fn CertAddRefServerOcspResponse(hServerOcspResponse: HCERT_SERVER_OCSP_RESPONSE);
pub fn CertAddRefServerOcspResponseContext(
pServerOcspResponseContext: PCCERT_SERVER_OCSP_RESPONSE_CONTEXT,
);
pub fn CertAddSerializedElementToStore(
hCertStore: HCERTSTORE, pbElement: *const BYTE, cbElement: DWORD, dwAddDisposition: DWORD,
dwFlags: DWORD, dwContextTypeFlags: DWORD, pdwContextType: *mut DWORD,
ppvContext: *mut *const c_void,
) -> BOOL;
pub fn CertAddStoreToCollection(
hCollectionStore: HCERTSTORE, hSiblingStore: HCERTSTORE, dwUpdateFlags: DWORD,
dwPriority: DWORD,
) -> BOOL;
pub fn CertAlgIdToOID(dwAlgId: DWORD) -> LPCSTR;
pub fn CertCloseServerOcspResponse(
hServerOcspResponse: HCERT_SERVER_OCSP_RESPONSE, dwFlags: DWORD,
);
pub fn CertCloseStore(hCertStore: HCERTSTORE, dwFlags: DWORD) -> BOOL;
pub fn CertCompareCertificate(
dwCertEncodingType: DWORD, pCertId1: PCERT_INFO, pCertId2: PCERT_INFO,
) -> BOOL;
pub fn CertCompareCertificateName(
dwCertEncodingType: DWORD, pCertName1: PCERT_NAME_BLOB, pCertName2: PCERT_NAME_BLOB,
) -> BOOL;
pub fn CertCompareIntegerBlob(pInt1: PCRYPT_INTEGER_BLOB, pInt2: PCRYPT_INTEGER_BLOB) -> BOOL;
pub fn CertComparePublicKeyInfo(
dwCertEncodingType: DWORD, pPublicKey1: PCERT_PUBLIC_KEY_INFO,
pPublicKey2: PCERT_PUBLIC_KEY_INFO,
) -> BOOL;
pub fn CertControlStore(
hCertStore: HCERTSTORE, dwFlags: DWORD, dwCtrlType: DWORD, pvCtrlPara: *const c_void,
) -> BOOL;
pub fn CertCreateCRLContext(
dwCertEncodingType: DWORD, pbCrlEncoded: *const BYTE, cbCrlEncoded: DWORD,
) -> PCCRL_CONTEXT;
pub fn CertCreateCTLContext(
dwMsgAndCertEncodingType: DWORD, pbCtlEncoded: *const BYTE, cbCtlEncoded: DWORD,
) -> PCCTL_CONTEXT;
pub fn CertCreateCTLEntryFromCertificateContextProperties(
pCertContext: PCCERT_CONTEXT, cOptAttr: DWORD, rgOptAttr: PCRYPT_ATTRIBUTE, dwFlags: DWORD,
pvReserved: *mut c_void, pCtlEntry: PCTL_ENTRY, pcbCtlEntry: *mut DWORD,
) -> BOOL;
pub fn CertCreateCertificateChainEngine(
pConfig: PCERT_CHAIN_ENGINE_CONFIG, phChainEngine: *mut HCERTCHAINENGINE,
) -> BOOL;
pub fn CertCreateCertificateContext(
dwCertEncodingType: DWORD, pbCertEncoded: *const BYTE, cbCertEncoded: DWORD,
) -> PCCERT_CONTEXT;
pub fn CertCreateContext(
dwContextType: DWORD, dwEncodingType: DWORD, pbEncoded: *const BYTE, cbEncoded: DWORD,
dwFlags: DWORD, pCreatePara: PCERT_CREATE_CONTEXT_PARA,
) -> *const c_void;
pub fn CertCreateSelfSignCertificate(
hCryptProvOrNCryptKey: HCRYPTPROV_OR_NCRYPT_KEY_HANDLE, pSubjectIssuerBlob: PCERT_NAME_BLOB,
dwFlags: DWORD, pKeyProvInfo: PCRYPT_KEY_PROV_INFO,
pSignatureAlgorithm: PCRYPT_ALGORITHM_IDENTIFIER, pStartTime: PSYSTEMTIME,
pEndTime: PSYSTEMTIME, pExtensions: PCERT_EXTENSIONS,
) -> PCCERT_CONTEXT;
pub fn CertDeleteCRLFromStore(pCrlContext: PCCRL_CONTEXT) -> BOOL;
pub fn CertDeleteCTLFromStore(pCtlContext: PCCTL_CONTEXT) -> BOOL;
pub fn CertDeleteCertificateFromStore(pCertContext: PCCERT_CONTEXT) -> BOOL;
pub fn CertDuplicateCRLContext(pCrlContext: PCCRL_CONTEXT) -> PCCRL_CONTEXT;
pub fn CertDuplicateCTLContext(pCtlContext: PCCTL_CONTEXT) -> PCCTL_CONTEXT;
pub fn CertDuplicateCertificateChain(
pChainContext: PCCERT_CHAIN_CONTEXT,
) -> PCCERT_CHAIN_CONTEXT;
pub fn CertDuplicateCertificateContext(pCertContext: PCCERT_CONTEXT) -> PCCERT_CONTEXT;
pub fn CertDuplicateStore(hCertStore: HCERTSTORE) -> HCERTSTORE;
pub fn CertEnumCRLContextProperties(pCrlContext: PCCRL_CONTEXT, dwPropId: DWORD) -> DWORD;
pub fn CertEnumCRLsInStore(
hCertStore: HCERTSTORE, pPrevCrlContext: PCCRL_CONTEXT,
) -> PCCRL_CONTEXT;
pub fn CertEnumCTLContextProperties(pCtlContext: PCCTL_CONTEXT, dwPropId: DWORD) -> DWORD;
pub fn CertEnumCTLsInStore(
hCertStore: HCERTSTORE, pPrevCtlContext: PCCTL_CONTEXT,
) -> PCCTL_CONTEXT;
pub fn CertEnumCertificateContextProperties(
pCertContext: PCCERT_CONTEXT, dwPropId: DWORD,
) -> DWORD;
pub fn CertEnumCertificatesInStore(
hCertStore: HCERTSTORE, pPrevCertContext: PCCERT_CONTEXT,
) -> PCCERT_CONTEXT;
pub fn CertEnumPhysicalStore(
pvSystemStore: *const c_void, dwFlags: DWORD, pvArg: *mut c_void,
pfnEnum: PFN_CERT_ENUM_PHYSICAL_STORE,
) -> BOOL;
pub fn CertEnumSubjectInSortedCTL(
pCtlContext: PCCTL_CONTEXT, ppvNextSubject: *mut *mut c_void,
pSubjectIdentifier: PCRYPT_DER_BLOB, pEncodedAttributes: PCRYPT_DER_BLOB,
) -> BOOL;
pub fn CertEnumSystemStore(
dwFlags: DWORD, pvSystemStoreLocationPara: *mut c_void, pvArg: *mut c_void,
pfnEnum: PFN_CERT_ENUM_SYSTEM_STORE,
) -> BOOL;
pub fn CertEnumSystemStoreLocation(
dwFlags: DWORD, pvArg: *mut c_void, pfnEnum: PFN_CERT_ENUM_SYSTEM_STORE_LOCATION,
) -> BOOL;
pub fn CertFindAttribute(
pszObjId: LPCSTR, cAttr: DWORD, rgAttr: *mut CRYPT_ATTRIBUTE,
) -> PCRYPT_ATTRIBUTE;
pub fn CertFindCRLInStore(
hCertStore: HCERTSTORE, dwCertEncodingType: DWORD, dwFindFlags: DWORD, dwFindType: DWORD,
pvFindPara: *const c_void, pPrevCrlContext: PCCRL_CONTEXT,
) -> PCCRL_CONTEXT;
pub fn CertFindCTLInStore(
hCertStore: HCERTSTORE, dwMsgAndCertEncodingType: DWORD, dwFindFlags: DWORD,
dwFindType: DWORD, pvFindPara: *const c_void, pPrevCtlContext: PCCTL_CONTEXT,
) -> PCCTL_CONTEXT;
pub fn CertFindCertificateInCRL(
pCert: PCCERT_CONTEXT, pCrlContext: PCCRL_CONTEXT, dwFlags: DWORD, pvReserved: *mut c_void,
ppCrlEntry: *mut PCRL_ENTRY,
) -> BOOL;
pub fn CertFindCertificateInStore(
hCertStore: HCERTSTORE, dwCertEncodingType: DWORD, dwFindFlags: DWORD, dwFindType: DWORD,
pvFindPara: *const c_void, pPrevCertContext: PCCERT_CONTEXT,
) -> PCCERT_CONTEXT;
pub fn CertFindChainInStore(
hCertStore: HCERTSTORE, dwCertEncodingType: DWORD, dwFindFlags: DWORD, dwFindType: DWORD,
pvFindPara: *const c_void, pPrevChainContext: PCCERT_CHAIN_CONTEXT,
) -> PCCERT_CHAIN_CONTEXT;
pub fn CertFindExtension(
pszObjId: LPCSTR, cExtensions: DWORD, rgExtensions: *mut CERT_EXTENSION,
) -> PCERT_EXTENSION;
pub fn CertFindRDNAttr(pszObjId: LPCSTR, pName: PCERT_NAME_INFO) -> PCERT_RDN_ATTR;
pub fn CertFindSubjectInCTL(
dwEncodingType: DWORD, dwSubjectType: DWORD, pvSubject: *mut c_void,
pCtlContext: PCCTL_CONTEXT, dwFlags: DWORD,
) -> PCTL_ENTRY;
pub fn CertFindSubjectInSortedCTL(
pSubjectIdentifier: PCRYPT_DATA_BLOB, pCtlContext: PCCTL_CONTEXT, dwFlags: DWORD,
pvReserved: *mut c_void, pEncodedAttributes: PCRYPT_DER_BLOB,
) -> BOOL;
pub fn CertFreeCRLContext(pCrlContext: PCCRL_CONTEXT) -> BOOL;
pub fn CertFreeCTLContext(pCtlContext: PCCTL_CONTEXT) -> BOOL;
pub fn CertFreeCertificateChain(pChainContext: PCCERT_CHAIN_CONTEXT);
pub fn CertFreeCertificateChainEngine(hChainEngine: HCERTCHAINENGINE);
pub fn CertFreeCertificateChainList(prgpSelection: *mut PCCERT_CHAIN_CONTEXT);
pub fn CertFreeCertificateContext(pCertContext: PCCERT_CONTEXT) -> BOOL;
pub fn CertFreeServerOcspResponseContext(
pServerOcspResponseContext: PCCERT_SERVER_OCSP_RESPONSE_CONTEXT,
);
pub fn CertGetCRLContextProperty(
pCrlContext: PCCRL_CONTEXT, dwPropId: DWORD, pvData: *mut c_void, pcbData: *mut DWORD,
) -> BOOL;
pub fn CertGetCRLFromStore(
hCertStore: HCERTSTORE, pIssuerContext: PCCERT_CONTEXT, pPrevCrlContext: PCCRL_CONTEXT,
pdwFlags: *mut DWORD,
) -> PCCRL_CONTEXT;
pub fn CertGetCTLContextProperty(
pCtlContext: PCCTL_CONTEXT, dwPropId: DWORD, pvData: *mut c_void, pcbData: *mut DWORD,
) -> BOOL;
pub fn CertGetCertificateChain(
hChainEngine: HCERTCHAINENGINE, pCertContext: PCCERT_CONTEXT, pTime: LPFILETIME,
hAdditionalStore: HCERTSTORE, pChainPara: PCERT_CHAIN_PARA, dwFlags: DWORD,
pvReserved: LPVOID, ppChainContext: *mut PCCERT_CHAIN_CONTEXT,
) -> BOOL;
pub fn CertGetCertificateContextProperty(
pCertContext: PCCERT_CONTEXT, dwPropId: DWORD, pvData: *mut c_void, pcbData: *mut DWORD,
) -> BOOL;
pub fn CertGetEnhancedKeyUsage(
pCertContext: PCCERT_CONTEXT, dwFlags: DWORD, pUsage: PCERT_ENHKEY_USAGE,
pcbUsage: *mut DWORD,
) -> BOOL;
pub fn CertGetIntendedKeyUsage(
dwCertEncodingType: DWORD, pCertInfo: PCERT_INFO, pbKeyUsage: *mut BYTE, cbKeyUsage: DWORD,
) -> BOOL;
pub fn CertGetIssuerCertificateFromStore(
hCertStore: HCERTSTORE, pSubjectContext: PCCERT_CONTEXT, pPrevIssuerContext: PCCERT_CONTEXT,
pdwFlags: *mut DWORD,
) -> PCCERT_CONTEXT;
pub fn CertGetNameStringA(
pCertContext: PCCERT_CONTEXT, dwType: DWORD, dwFlags: DWORD, pvTypePara: *mut c_void,
pszNameString: LPSTR, cchNameString: DWORD,
) -> DWORD;
pub fn CertGetNameStringW(
pCertContext: PCCERT_CONTEXT, dwType: DWORD, dwFlags: DWORD, pvTypePara: *mut c_void,
pszNameString: LPWSTR, cchNameString: DWORD,
) -> DWORD;
pub fn CertGetPublicKeyLength(
dwCertEncodingType: DWORD, pPublicKey: PCERT_PUBLIC_KEY_INFO,
) -> DWORD;
pub fn CertGetServerOcspResponseContext(
hServerOcspResponse: HCERT_SERVER_OCSP_RESPONSE, dwFlags: DWORD, pvReserved: LPVOID,
) -> PCCERT_SERVER_OCSP_RESPONSE_CONTEXT;
pub fn CertGetStoreProperty(
hCertStore: HCERTSTORE, dwPropId: DWORD, pvData: *mut c_void, pcbData: *mut DWORD,
) -> BOOL;
pub fn CertGetSubjectCertificateFromStore(
hCertStore: HCERTSTORE, dwCertEncodingType: DWORD, pCertId: PCERT_INFO,
) -> PCCERT_CONTEXT;
pub fn CertGetValidUsages(
cCerts: DWORD, rghCerts: *mut PCCERT_CONTEXT, cNumOIDs: *mut c_int, rghOIDs: *mut LPSTR,
pcbOIDs: *mut DWORD,
) -> BOOL;
pub fn CertIsRDNAttrsInCertificateName(
dwCertEncodingType: DWORD, dwFlags: DWORD, pCertName: PCERT_NAME_BLOB, pRDN: PCERT_RDN,
) -> BOOL;
pub fn CertIsStrongHashToSign(
pStrongSignPara: PCCERT_STRONG_SIGN_PARA, pwszCNGHashAlgid: LPCWSTR,
pSigningCert: PCCERT_CONTEXT,
) -> BOOL;
pub fn CertIsValidCRLForCertificate(
pCert: PCCERT_CONTEXT, pCrl: PCCRL_CONTEXT, dwFlags: DWORD, pvReserved: *mut c_void,
) -> BOOL;
pub fn CertNameToStrA(
dwCertEncodingType: DWORD, pName: PCERT_NAME_BLOB, dwStrType: DWORD, psz: LPSTR, csz: DWORD,
) -> DWORD;
pub fn CertNameToStrW(
dwCertEncodingType: DWORD, pName: PCERT_NAME_BLOB, dwStrType: DWORD, psz: LPWSTR,
csz: DWORD,
) -> DWORD;
pub fn CertOIDToAlgId(pszObjId: LPCSTR) -> DWORD;
pub fn CertOpenServerOcspResponse(
pChainContext: PCCERT_CHAIN_CONTEXT, dwFlags: DWORD, pvReserved: LPVOID,
) -> HCERT_SERVER_OCSP_RESPONSE;
pub fn CertOpenStore(
lpszStoreProvider: LPCSTR, dwEncodingType: DWORD, hCryptProv: HCRYPTPROV_LEGACY,
dwFlags: DWORD, pvPara: *const c_void,
) -> HCERTSTORE;
pub fn CertOpenSystemStoreA(
hProv: HCRYPTPROV_LEGACY, szSubsystemProtocol: LPCSTR,
) -> HCERTSTORE;
pub fn CertOpenSystemStoreW(
hProv: HCRYPTPROV_LEGACY, szSubsystemProtocol: LPCWSTR,
) -> HCERTSTORE;
pub fn CertRDNValueToStrA(
dwValueType: DWORD, pValue: PCERT_RDN_VALUE_BLOB, psz: LPSTR, csz: DWORD,
) -> DWORD;
pub fn CertRDNValueToStrW(
dwValueType: DWORD, pValue: PCERT_RDN_VALUE_BLOB, psz: LPWSTR, csz: DWORD,
) -> DWORD;
pub fn CertRegisterPhysicalStore(
pvSystemStore: *const c_void, dwFlags: DWORD, pwszStoreName: LPCWSTR,
pStoreInfo: PCERT_PHYSICAL_STORE_INFO, pvReserved: *mut c_void,
) -> BOOL;
pub fn CertRegisterSystemStore(
pvSystemStore: *const c_void, dwFlags: DWORD, pStoreInfo: PCERT_SYSTEM_STORE_INFO,
pvReserved: *mut c_void,
) -> BOOL;
pub fn CertRemoveEnhancedKeyUsageIdentifier(
pCertContext: PCCERT_CONTEXT, pszUsageIdentifier: LPCSTR,
) -> BOOL;
pub fn CertRemoveStoreFromCollection(hCollectionStore: HCERTSTORE, hSiblingStore: HCERTSTORE);
pub fn CertResyncCertificateChainEngine(hChainEngine: HCERTCHAINENGINE) -> BOOL;
pub fn CertRetrieveLogoOrBiometricInfo(
pCertContext: PCCERT_CONTEXT, lpszLogoOrBiometricType: LPCSTR, dwRetrievalFlags: DWORD,
dwTimeout: DWORD, dwFlags: DWORD, pvReserved: *mut c_void, ppbData: *mut *mut BYTE,
pcbData: *mut DWORD, ppwszMimeType: *mut LPWSTR,
) -> BOOL;
pub fn CertSaveStore(
hCertStore: HCERTSTORE, dwEncodingType: DWORD, dwSaveAs: DWORD, dwSaveTo: DWORD,
pvSaveToPara: *mut c_void, dwFlags: DWORD,
) -> BOOL;
pub fn CertSelectCertificateChains(
pSelectionContext: LPCGUID, dwFlags: DWORD, pChainParameters: PCCERT_SELECT_CHAIN_PARA,
cCriteria: DWORD, rgpCriteria: PCCERT_SELECT_CRITERIA, hStore: HCERTSTORE,
pcSelection: PDWORD, pprgpSelection: *mut *mut PCCERT_CHAIN_CONTEXT,
) -> BOOL;
pub fn CertSerializeCRLStoreElement(
pCrlContext: PCCRL_CONTEXT, dwFlags: DWORD, pbElement: *mut BYTE, pcbElement: *mut DWORD,
) -> BOOL;
pub fn CertSerializeCTLStoreElement(
pCtlContext: PCCTL_CONTEXT, dwFlags: DWORD, pbElement: *mut BYTE, pcbElement: *mut DWORD,
) -> BOOL;
pub fn CertSerializeCertificateStoreElement(
pCertContext: PCCERT_CONTEXT, dwFlags: DWORD, pbElement: *mut BYTE, pcbElement: *mut DWORD,
) -> BOOL;
pub fn CertSetCRLContextProperty(
pCrlContext: PCCRL_CONTEXT, dwPropId: DWORD, dwFlags: DWORD, pvData: *const c_void,
) -> BOOL;
pub fn CertSetCTLContextProperty(
pCtlContext: PCCTL_CONTEXT, dwPropId: DWORD, dwFlags: DWORD, pvData: *const c_void,
) -> BOOL;
pub fn CertSetCertificateContextPropertiesFromCTLEntry(
pCertContext: PCCERT_CONTEXT, pCtlEntry: PCTL_ENTRY, dwFlags: DWORD,
) -> BOOL;
pub fn CertSetCertificateContextProperty(
pCertContext: PCCERT_CONTEXT, dwPropId: DWORD, dwFlags: DWORD, pvData: *const c_void,
) -> BOOL;
pub fn CertSetEnhancedKeyUsage(
pCertContext: PCCERT_CONTEXT, pUsage: PCERT_ENHKEY_USAGE,
) -> BOOL;
pub fn CertSetStoreProperty(
hCertStore: HCERTSTORE, dwPropId: DWORD, dwFlags: DWORD, pvData: *const c_void,
) -> BOOL;
pub fn CertStrToNameA(
dwCertEncodingType: DWORD, pszX500: LPCSTR, dwStrType: DWORD, pvReserved: *mut c_void,
pbEncoded: *mut BYTE, pcbEncoded: *mut DWORD, ppszError: *mut LPCSTR,
) -> BOOL;
pub fn CertStrToNameW(
dwCertEncodingType: DWORD, pszX500: LPCWSTR, dwStrType: DWORD, pvReserved: *mut c_void,
pbEncoded: *mut BYTE, pcbEncoded: *mut DWORD, ppszError: *mut LPCWSTR,
) -> BOOL;
pub fn CertUnregisterPhysicalStore(
pvSystemStore: *const c_void, dwFlags: DWORD, pwszStoreName: LPCWSTR,
) -> BOOL;
pub fn CertUnregisterSystemStore(pvSystemStore: *const c_void, dwFlags: DWORD) -> BOOL;
pub fn CertVerifyCRLRevocation(
dwCertEncodingType: DWORD, pCertId: PCERT_INFO, cCrlInfo: DWORD, rgpCrlInfo: *mut PCRL_INFO,
) -> BOOL;
pub fn CertVerifyCRLTimeValidity(pTimeToVerify: LPFILETIME, pCrlInfo: PCRL_INFO) -> LONG;
pub fn CertVerifyCTLUsage(
dwEncodingType: DWORD, dwSubjectType: DWORD, pvSubject: *mut c_void,
pSubjectUsage: PCTL_USAGE, dwFlags: DWORD, pVerifyUsagePara: PCTL_VERIFY_USAGE_PARA,
pVerifyUsageStatus: PCTL_VERIFY_USAGE_STATUS,
) -> BOOL;
pub fn CertVerifyCertificateChainPolicy(
pszPolicyOID: LPCSTR, pChainContext: PCCERT_CHAIN_CONTEXT,
pPolicyPara: PCERT_CHAIN_POLICY_PARA, pPolicyStatus: PCERT_CHAIN_POLICY_STATUS,
) -> BOOL;
pub fn CertVerifyRevocation(
dwEncodingType: DWORD, dwRevType: DWORD, cContext: DWORD, rgpvContext: *mut PVOID,
dwFlags: DWORD, pRevPara: PCERT_REVOCATION_PARA, pRevStatus: PCERT_REVOCATION_STATUS,
) -> BOOL;
pub fn CertVerifySubjectCertificateContext(
pSubject: PCCERT_CONTEXT, pIssuer: PCCERT_CONTEXT, pdwFlags: *mut DWORD,
) -> BOOL;
pub fn CertVerifyTimeValidity(pTimeToVerify: LPFILETIME, pCertInfo: PCERT_INFO) -> LONG;
pub fn CertVerifyValidityNesting(pSubjectInfo: PCERT_INFO, pIssuerInfo: PCERT_INFO) -> BOOL;
pub fn CryptAcquireCertificatePrivateKey(
pCert: PCCERT_CONTEXT, dwFlags: DWORD, pvParameters: *mut c_void,
phCryptProvOrNCryptKey: *mut HCRYPTPROV_OR_NCRYPT_KEY_HANDLE, pdwKeySpec: *mut DWORD,
pfCallerFreeProvOrNCryptKey: *mut BOOL,
) -> BOOL;
pub fn CryptBinaryToStringA(
pbBinary: *const BYTE, cbBinary: DWORD, dwFlags: DWORD, pszString: LPSTR,
pcchString: *mut DWORD,
) -> BOOL;
pub fn CryptBinaryToStringW(
pbBinary: *const BYTE, cbBinary: DWORD, dwFlags: DWORD, pszString: LPWSTR,
pcchString: *mut DWORD,
) -> BOOL;
pub fn CryptCloseAsyncHandle(hAsync: HCRYPTASYNC) -> BOOL;
pub fn CryptCreateAsyncHandle(dwFlags: DWORD, phAsync: PHCRYPTASYNC) -> BOOL;
pub fn CryptCreateKeyIdentifierFromCSP(
dwCertEncodingType: DWORD, pszPubKeyOID: LPCSTR, pPubKeyStruc: *const PUBLICKEYSTRUC,
cbPubKeyStruc: DWORD, dwFlags: DWORD, pvReserved: *mut c_void, pbHash: *mut BYTE,
pcbHash: *mut DWORD,
) -> BOOL;
pub fn CryptDecodeMessage(
dwMsgTypeFlags: DWORD, pDecryptPara: PCRYPT_DECRYPT_MESSAGE_PARA,
pVerifyPara: PCRYPT_VERIFY_MESSAGE_PARA, dwSignerIndex: DWORD, pbEncodedBlob: *const BYTE,
cbEncodedBlob: DWORD, dwPrevInnerContentType: DWORD, pdwMsgType: *mut DWORD,
pdwInnerContentType: *mut DWORD, pbDecoded: *mut BYTE, pcbDecoded: *mut DWORD,
ppXchgCert: *mut PCCERT_CONTEXT, ppSignerCert: *mut PCCERT_CONTEXT,
) -> BOOL;
pub fn CryptDecodeObject(
dwCertEncodingType: DWORD, lpszStructType: LPCSTR, pbEncoded: *const BYTE,
cbEncoded: DWORD, dwFlags: DWORD, pvStructInfo: *mut c_void, pcbStructInfo: *mut DWORD,
) -> BOOL;
pub fn CryptDecodeObjectEx(
dwCertEncodingType: DWORD, lpszStructType: LPCSTR, pbEncoded: *const BYTE,
cbEncoded: DWORD, dwFlags: DWORD, pDecodePara: PCRYPT_DECODE_PARA,
pvStructInfo: *mut c_void, pcbStructInfo: *mut DWORD,
) -> BOOL;
pub fn CryptDecryptAndVerifyMessageSignature(
pDecryptPara: PCRYPT_DECRYPT_MESSAGE_PARA, pVerifyPara: PCRYPT_VERIFY_MESSAGE_PARA,
dwSignerIndex: DWORD, pbEncryptedBlob: *const BYTE, cbEncryptedBlob: DWORD,
pbDecrypted: *mut BYTE, pcbDecrypted: *mut DWORD, ppXchgCert: *mut PCCERT_CONTEXT,
ppSignerCert: *mut PCCERT_CONTEXT,
) -> BOOL;
pub fn CryptDecryptMessage(
pDecryptPara: PCRYPT_DECRYPT_MESSAGE_PARA, pbEncryptedBlob: *const BYTE,
cbEncryptedBlob: DWORD, pbDecrypted: *mut BYTE, pcbDecrypted: *mut DWORD,
ppXchgCert: *mut PCCERT_CONTEXT,
) -> BOOL;
pub fn CryptEncodeObject(
dwCertEncodingType: DWORD, lpszStructType: LPCSTR, pvStructInfo: *const c_void,
pbEncoded: *mut BYTE, pcbEncoded: *mut DWORD,
) -> BOOL;
pub fn CryptEncodeObjectEx(
dwCertEncodingType: DWORD, lpszStructType: LPCSTR, pvStructInfo: *const c_void,
dwFlags: DWORD, pEncodePara: PCRYPT_ENCODE_PARA, pvEncoded: *mut c_void,
pcbEncoded: *mut DWORD,
) -> BOOL;
pub fn CryptEncryptMessage(
pEncryptPara: PCRYPT_ENCRYPT_MESSAGE_PARA, cRecipientCert: DWORD,
rgpRecipientCert: *mut PCCERT_CONTEXT, pbToBeEncrypted: *const BYTE,
cbToBeEncrypted: DWORD, pbEncryptedBlob: *mut BYTE, pcbEncryptedBlob: *mut DWORD,
) -> BOOL;
pub fn CryptEnumKeyIdentifierProperties(
pKeyIdentifier: *const CRYPT_HASH_BLOB, dwPropId: DWORD, dwFlags: DWORD,
pwszComputerName: LPCWSTR, pvReserved: *mut c_void, pvArg: *mut c_void,
pfnEnum: PFN_CRYPT_ENUM_KEYID_PROP,
) -> BOOL;
pub fn CryptEnumOIDFunction(
dwEncodingType: DWORD, pszFuncName: LPCSTR, pszOID: LPCSTR, dwFlags: DWORD,
pvArg: *mut c_void, pfnEnumOIDFunc: PFN_CRYPT_ENUM_OID_FUNC,
) -> BOOL;
pub fn CryptEnumOIDInfo(
dwGroupId: DWORD, dwFlags: DWORD, pvArg: *mut c_void,
pfnEnumOIDInfo: PFN_CRYPT_ENUM_OID_INFO,
) -> BOOL;
pub fn CryptExportPKCS8(
hCryptProv: HCRYPTPROV, dwKeySpec: DWORD, pszPrivateKeyObjId: LPSTR, dwFlags: DWORD,
pvAuxInfo: *mut c_void, pbPrivateKeyBlob: *mut BYTE, pcbPrivateKeyBlob: *mut DWORD,
) -> BOOL;
pub fn CryptExportPublicKeyInfo(
hCryptProvOrNCryptKey: HCRYPTPROV_OR_NCRYPT_KEY_HANDLE, dwKeySpec: DWORD,
dwCertEncodingType: DWORD, pInfo: PCERT_PUBLIC_KEY_INFO, pcbInfo: *mut DWORD,
) -> BOOL;
pub fn CryptExportPublicKeyInfoEx(
hCryptProvOrNCryptKey: HCRYPTPROV_OR_NCRYPT_KEY_HANDLE, dwKeySpec: DWORD,
dwCertEncodingType: DWORD, pszPublicKeyObjId: LPSTR, dwFlags: DWORD,
pvAuxInfo: *mut c_void, pInfo: PCERT_PUBLIC_KEY_INFO, pcbInfo: *mut DWORD,
) -> BOOL;
pub fn CryptExportPublicKeyInfoFromBCryptKeyHandle(
hBCryptKey: BCRYPT_KEY_HANDLE, dwCertEncodingType: DWORD, pszPublicKeyObjId: LPSTR,
dwFlags: DWORD, pvAuxInfo: *mut c_void, pInfo: PCERT_PUBLIC_KEY_INFO, pcbInfo: *mut DWORD,
) -> BOOL;
pub fn CryptFindCertificateKeyProvInfo(
pCert: PCCERT_CONTEXT, dwFlags: DWORD, pvReserved: *mut c_void,
) -> BOOL;
pub fn CryptFindLocalizedName(pwszCryptName: LPCWSTR) -> LPCWSTR;
pub fn CryptFindOIDInfo(
dwKeyType: DWORD, pvKey: *mut c_void, dwGroupId: DWORD,
) -> PCCRYPT_OID_INFO;
pub fn CryptFormatObject(
dwCertEncodingType: DWORD, dwFormatType: DWORD, dwFormatStrType: DWORD,
pFormatStruct: *mut c_void, lpszStructType: LPCSTR, pbEncoded: *const BYTE,
cbEncoded: DWORD, pbFormat: *mut c_void, pcbFormat: *mut DWORD,
) -> BOOL;
pub fn CryptFreeOIDFunctionAddress(hFuncAddr: HCRYPTOIDFUNCADDR, dwFlags: DWORD) -> BOOL;
pub fn CryptGetAsyncParam(
hAsync: HCRYPTASYNC, pszParamOid: LPSTR, ppvParam: *mut LPVOID,
ppfnFree: *mut PFN_CRYPT_ASYNC_PARAM_FREE_FUNC,
) -> BOOL;
pub fn CryptGetDefaultOIDDllList(
hFuncSet: HCRYPTOIDFUNCSET, dwEncodingType: DWORD, pwszDllList: *mut WCHAR,
pcchDllList: *mut DWORD,
) -> BOOL;
pub fn CryptGetDefaultOIDFunctionAddress(
hFuncSet: HCRYPTOIDFUNCSET, dwEncodingType: DWORD, pwszDll: LPCWSTR, dwFlags: DWORD,
ppvFuncAddr: *mut *mut c_void, phFuncAddr: *mut HCRYPTOIDFUNCADDR,
) -> BOOL;
pub fn CryptGetKeyIdentifierProperty(
pKeyIdentifier: *const CRYPT_HASH_BLOB, dwPropId: DWORD, dwFlags: DWORD,
pwszComputerName: LPCWSTR, pvReserved: *mut c_void, pvData: *mut c_void,
pcbData: *mut DWORD,
) -> BOOL;
pub fn CryptGetMessageCertificates(
dwMsgAndCertEncodingType: DWORD, hCryptProv: HCRYPTPROV_LEGACY, dwFlags: DWORD,
pbSignedBlob: *const BYTE, cbSignedBlob: DWORD,
) -> HCERTSTORE;
pub fn CryptGetMessageSignerCount(
dwMsgEncodingType: DWORD, pbSignedBlob: *const BYTE, cbSignedBlob: DWORD,
) -> LONG;
pub fn CryptGetOIDFunctionAddress(
hFuncSet: HCRYPTOIDFUNCSET, dwEncodingType: DWORD, pszOID: LPCSTR, dwFlags: DWORD,
ppvFuncAddr: *mut *mut c_void, phFuncAddr: *mut HCRYPTOIDFUNCADDR,
) -> BOOL;
pub fn CryptGetOIDFunctionValue(
dwEncodingType: DWORD, pszFuncName: LPCSTR, pszOID: LPCSTR, pwszValueName: LPCWSTR,
pdwValueType: *mut DWORD, pbValueData: *mut BYTE, pcbValueData: *mut DWORD,
) -> BOOL;
pub fn CryptHashCertificate(
hCryptProv: HCRYPTPROV_LEGACY, Algid: ALG_ID, dwFlags: DWORD, pbEncoded: *const BYTE,
cbEncoded: DWORD, pbComputedHash: *mut BYTE, pcbComputedHash: *mut DWORD,
) -> BOOL;
pub fn CryptHashCertificate2(
pwszCNGHashAlgid: LPCWSTR, dwFlags: DWORD, pvReserved: *mut c_void, pbEncoded: *const BYTE,
cbEncoded: DWORD, pbComputedHash: *mut BYTE, pcbComputedHash: *mut DWORD,
) -> BOOL;
pub fn CryptHashMessage(
pHashPara: PCRYPT_HASH_MESSAGE_PARA, fDetachedHash: BOOL, cToBeHashed: DWORD,
rgpbToBeHashed: *mut *const BYTE, rgcbToBeHashed: *mut DWORD, pbHashedBlob: *mut BYTE,
pcbHashedBlob: *mut DWORD, pbComputedHash: *mut BYTE, pcbComputedHash: *mut DWORD,
) -> BOOL;
pub fn CryptHashPublicKeyInfo(
hCryptProv: HCRYPTPROV_LEGACY, Algid: ALG_ID, dwFlags: DWORD, dwCertEncodingType: DWORD,
pInfo: PCERT_PUBLIC_KEY_INFO, pbComputedHash: *mut BYTE, pcbComputedHash: *mut DWORD,
) -> BOOL;
pub fn CryptHashToBeSigned(
hCryptProv: HCRYPTPROV_LEGACY, dwCertEncodingType: DWORD, pbEncoded: *const BYTE,
cbEncoded: DWORD, pbComputedHash: *mut BYTE, pcbComputedHash: *mut DWORD,
) -> BOOL;
pub fn CryptImportPKCS8(
sPrivateKeyAndParams: CRYPT_PKCS8_IMPORT_PARAMS, dwFlags: DWORD,
phCryptProv: *mut HCRYPTPROV, pvAuxInfo: *mut c_void,
) -> BOOL;
pub fn CryptImportPublicKeyInfo(
hCryptProv: HCRYPTPROV, dwCertEncodingType: DWORD, pInfo: PCERT_PUBLIC_KEY_INFO,
phKey: *mut HCRYPTKEY,
) -> BOOL;
pub fn CryptImportPublicKeyInfoEx(
hCryptProv: HCRYPTPROV, dwCertEncodingType: DWORD, pInfo: PCERT_PUBLIC_KEY_INFO,
aiKeyAlg: ALG_ID, dwFlags: DWORD, pvAuxInfo: *mut c_void, phKey: *mut HCRYPTKEY,
) -> BOOL;
pub fn CryptImportPublicKeyInfoEx2(
dwCertEncodingType: DWORD, pInfo: PCERT_PUBLIC_KEY_INFO, dwFlags: DWORD,
pvAuxInfo: *mut c_void, phKey: *mut BCRYPT_KEY_HANDLE,
) -> BOOL;
pub fn CryptInitOIDFunctionSet(pszFuncName: LPCSTR, dwFlags: DWORD) -> HCRYPTOIDFUNCSET;
pub fn CryptInstallDefaultContext(
hCryptProv: HCRYPTPROV, dwDefaultType: DWORD, pvDefaultPara: *const c_void, dwFlags: DWORD,
pvReserved: *mut c_void, phDefaultContext: *mut HCRYPTDEFAULTCONTEXT,
) -> BOOL;
pub fn CryptInstallOIDFunctionAddress(
hModule: HMODULE, dwEncodingType: DWORD, pszFuncName: LPCSTR, cFuncEntry: DWORD,
rgFuncEntry: *const CRYPT_OID_FUNC_ENTRY, dwFlags: DWORD,
) -> BOOL;
pub fn CryptMemAlloc(cbSize: ULONG) -> LPVOID;
pub fn CryptMemFree(pv: LPVOID);
pub fn CryptMemRealloc(pv: LPVOID, cbSize: ULONG) -> LPVOID;
pub fn CryptMsgCalculateEncodedLength(
dwMsgEncodingType: DWORD, dwFlags: DWORD, dwMsgType: DWORD, pvMsgEncodeInfo: *const c_void,
pszInnerContentObjID: LPSTR, cbData: DWORD,
) -> DWORD;
pub fn CryptMsgClose(hCryptMsg: HCRYPTMSG) -> BOOL;
pub fn CryptMsgControl(
hCryptMsg: HCRYPTMSG, dwFlags: DWORD, dwCtrlType: DWORD, pvCtrlPara: *const c_void,
) -> BOOL;
pub fn CryptMsgCountersign(
hCryptMsg: HCRYPTMSG, dwIndex: DWORD, cCountersigners: DWORD,
rgCountersigners: PCMSG_SIGNER_ENCODE_INFO,
) -> BOOL;
pub fn CryptMsgCountersignEncoded(
dwEncodingType: DWORD, pbSignerInfo: PBYTE, cbSignerInfo: DWORD, cCountersigners: DWORD,
rgCountersigners: PCMSG_SIGNER_ENCODE_INFO, pbCountersignature: PBYTE,
pcbCountersignature: PDWORD,
) -> BOOL;
pub fn CryptMsgDuplicate(hCryptMsg: HCRYPTMSG) -> HCRYPTMSG;
pub fn CryptMsgEncodeAndSignCTL(
dwMsgEncodingType: DWORD, pCtlInfo: PCTL_INFO, pSignInfo: PCMSG_SIGNED_ENCODE_INFO,
dwFlags: DWORD, pbEncoded: *mut BYTE, pcbEncoded: *mut DWORD,
) -> BOOL;
pub fn CryptMsgGetAndVerifySigner(
hCryptMsg: HCRYPTMSG, cSignerStore: DWORD, rghSignerStore: *mut HCERTSTORE, dwFlags: DWORD,
ppSigner: *mut PCCERT_CONTEXT, pdwSignerIndex: *mut DWORD,
) -> BOOL;
pub fn CryptMsgGetParam(
hCryptMsg: HCRYPTMSG, dwParamType: DWORD, dwIndex: DWORD, pvData: *mut c_void,
pcbData: *mut DWORD,
) -> BOOL;
pub fn CryptMsgOpenToDecode(
dwMsgEncodingType: DWORD, dwFlags: DWORD, dwMsgType: DWORD, hCryptProv: HCRYPTPROV_LEGACY,
pRecipientInfo: PCERT_INFO, pStreamInfo: PCMSG_STREAM_INFO,
) -> HCRYPTMSG;
pub fn CryptMsgOpenToEncode(
dwMsgEncodingType: DWORD, dwFlags: DWORD, dwMsgType: DWORD, pvMsgEncodeInfo: *mut c_void,
pszInnerContentObjID: LPSTR, pStreamInfo: PCMSG_STREAM_INFO,
) -> HCRYPTMSG;
pub fn CryptMsgSignCTL(
dwMsgEncodingType: DWORD, pbCtlContent: *mut BYTE, cbCtlContent: DWORD,
pSignInfo: PCMSG_SIGNED_ENCODE_INFO, dwFlags: DWORD, pbEncoded: *mut BYTE,
pcbEncoded: *mut DWORD,
) -> BOOL;
pub fn CryptMsgUpdate(
hCryptMsg: HCRYPTMSG, pbData: *const BYTE, cbData: DWORD, fFinal: BOOL,
) -> BOOL;
pub fn CryptMsgVerifyCountersignatureEncoded(
hCryptProv: HCRYPTPROV_LEGACY, dwEncodingType: DWORD, pbSignerInfo: PBYTE,
cbSignerInfo: DWORD, pbSignerInfoCountersignature: PBYTE,
cbSignerInfoCountersignature: DWORD, pciCountersigner: PCERT_INFO,
) -> BOOL;
pub fn CryptMsgVerifyCountersignatureEncodedEx(
hCryptProv: HCRYPTPROV_LEGACY, dwEncodingType: DWORD, pbSignerInfo: PBYTE,
cbSignerInfo: DWORD, pbSignerInfoCountersignature: PBYTE,
cbSignerInfoCountersignature: DWORD, dwSignerType: DWORD, pvSigner: *mut c_void,
dwFlags: DWORD, pvExtra: *mut c_void,
) -> BOOL;
pub fn CryptProtectData(
pDataIn: *mut DATA_BLOB, szDataDescr: LPCWSTR, pOptionalEntropy: *mut DATA_BLOB,
pvReserved: PVOID, pPromptStruct: *mut CRYPTPROTECT_PROMPTSTRUCT, dwFlags: DWORD,
pDataOut: *mut DATA_BLOB,
) -> BOOL;
pub fn CryptProtectMemory(pDataIn: LPVOID, cbDataIn: DWORD, dwFlags: DWORD) -> BOOL;
pub fn CryptQueryObject(
dwObjectType: DWORD, pvObject: *const c_void, dwExpectedContentTypeFlags: DWORD,
dwExpectedFormatTypeFlags: DWORD, dwFlags: DWORD, pdwMsgAndCertEncodingType: *mut DWORD,
pdwContentType: *mut DWORD, pdwFormatType: *mut DWORD, phCertStore: *mut HCERTSTORE,
phMsg: *mut HCRYPTMSG, ppvContext: *mut *const c_void,
) -> BOOL;
pub fn CryptRegisterDefaultOIDFunction(
dwEncodingType: DWORD, pszFuncName: LPCSTR, dwIndex: DWORD, pwszDll: LPCWSTR,
) -> BOOL;
pub fn CryptRegisterOIDFunction(
dwEncodingType: DWORD, pszFuncName: LPCSTR, pszOID: LPCSTR, pwszDll: LPCWSTR,
pszOverrideFuncName: LPCSTR,
) -> BOOL;
pub fn CryptRegisterOIDInfo(pInfo: PCCRYPT_OID_INFO, dwFlags: DWORD) -> BOOL;
pub fn CryptRetrieveTimeStamp(
wszUrl: LPCWSTR, dwRetrievalFlags: DWORD, dwTimeout: DWORD, pszHashId: LPCSTR,
pPara: *const CRYPT_TIMESTAMP_PARA, pbData: *const BYTE, cbData: DWORD,
ppTsContext: *mut PCRYPT_TIMESTAMP_CONTEXT, ppTsSigner: *mut PCCERT_CONTEXT,
phStore: *mut HCERTSTORE,
) -> BOOL;
pub fn CryptSIPAddProvider(psNewProv: *mut SIP_ADD_NEWPROVIDER) -> BOOL;
pub fn CryptSIPCreateIndirectData(
pSubjectInfo: *mut SIP_SUBJECTINFO, pcbIndirectData: *mut DWORD,
pIndirectData: *mut SIP_INDIRECT_DATA,
) -> BOOL;
pub fn CryptSIPGetCaps(pSubjInfo: *mut SIP_SUBJECTINFO, pCaps: *mut SIP_CAP_SET) -> BOOL;
pub fn CryptSIPGetSealedDigest(
pSubjectInfo: *mut SIP_SUBJECTINFO, pSig: *const BYTE, dwSig: DWORD, pbDigest: *mut BYTE,
pcbDigest: *mut DWORD,
) -> BOOL;
pub fn CryptSIPGetSignedDataMsg(
pSubjectInfo: *mut SIP_SUBJECTINFO, pdwEncodingType: *mut DWORD, dwIndex: DWORD,
pcbSignedDataMsg: *mut DWORD, pbSignedDataMsg: *mut BYTE,
) -> BOOL;
pub fn CryptSIPLoad(
pgSubject: *const GUID, dwFlags: DWORD, pSipDispatch: *mut SIP_DISPATCH_INFO,
) -> BOOL;
pub fn CryptSIPPutSignedDataMsg(
pSubjectInfo: *mut SIP_SUBJECTINFO, dwEncodingType: DWORD, pdwIndex: *mut DWORD,
cbSignedDataMsg: DWORD, pbSignedDataMsg: *mut BYTE,
) -> BOOL;
pub fn CryptSIPRemoveProvider(pgProv: *mut GUID) -> BOOL;
pub fn CryptSIPRemoveSignedDataMsg(pSubjectInfo: *mut SIP_SUBJECTINFO, dwIndex: DWORD) -> BOOL;
pub fn CryptSIPRetrieveSubjectGuid(
FileName: LPCWSTR, hFileIn: HANDLE, pgSubject: *mut GUID,
) -> BOOL;
pub fn CryptSIPRetrieveSubjectGuidForCatalogFile(
FileName: LPCWSTR, hFileIn: HANDLE, pgSubject: *mut GUID,
) -> BOOL;
pub fn CryptSIPVerifyIndirectData(
pSubjectInfo: *mut SIP_SUBJECTINFO, pIndirectData: *mut SIP_INDIRECT_DATA,
) -> BOOL;
pub fn CryptSetAsyncParam(
hAsync: HCRYPTASYNC, pszParamOid: LPSTR, pvParam: LPVOID,
pfnFree: PFN_CRYPT_ASYNC_PARAM_FREE_FUNC,
) -> BOOL;
pub fn CryptSetKeyIdentifierProperty(
pKeyIdentifier: *const CRYPT_HASH_BLOB, dwPropId: DWORD, dwFlags: DWORD,
pwszComputerName: LPCWSTR, pvReserved: *mut c_void, pvData: *const c_void,
) -> BOOL;
pub fn CryptSetOIDFunctionValue(
dwEncodingType: DWORD, pszFuncName: LPCSTR, pszOID: LPCSTR, pwszValueName: LPCWSTR,
dwValueType: DWORD, pbValueData: *const BYTE, cbValueData: DWORD,
) -> BOOL;
pub fn CryptSignAndEncodeCertificate(
hCryptProvOrNCryptKey: HCRYPTPROV_OR_NCRYPT_KEY_HANDLE, dwKeySpec: DWORD,
dwCertEncodingType: DWORD, lpszStructType: LPCSTR, pvStructInfo: *const c_void,
pSignatureAlgorithm: PCRYPT_ALGORITHM_IDENTIFIER, pvHashAuxInfo: *const c_void,
pbEncoded: *mut BYTE, pcbEncoded: *mut DWORD,
) -> BOOL;
pub fn CryptSignAndEncryptMessage(
pSignPara: PCRYPT_SIGN_MESSAGE_PARA, pEncryptPara: PCRYPT_ENCRYPT_MESSAGE_PARA,
cRecipientCert: DWORD, rgpRecipientCert: *mut PCCERT_CONTEXT,
pbToBeSignedAndEncrypted: *const BYTE, cbToBeSignedAndEncrypted: DWORD,
pbSignedAndEncryptedBlob: *mut BYTE, pcbSignedAndEncryptedBlob: *mut DWORD,
) -> BOOL;
pub fn CryptSignCertificate(
hCryptProvOrNCryptKey: HCRYPTPROV_OR_NCRYPT_KEY_HANDLE, dwKeySpec: DWORD,
dwCertEncodingType: DWORD, pbEncodedToBeSigned: *const BYTE, cbEncodedToBeSigned: DWORD,
pSignatureAlgorithm: PCRYPT_ALGORITHM_IDENTIFIER, pvHashAuxInfo: *const c_void,
pbSignature: *mut BYTE, pcbSignature: *mut DWORD,
) -> BOOL;
pub fn CryptSignMessage(
pSignPara: PCRYPT_SIGN_MESSAGE_PARA, fDetachedSignature: BOOL, cToBeSigned: DWORD,
rgpbToBeSigned: *mut *const BYTE, rgcbToBeSigned: *mut DWORD, pbSignedBlob: *mut BYTE,
pcbSignedBlob: *mut DWORD,
) -> BOOL;
pub fn CryptSignMessageWithKey(
pSignPara: PCRYPT_KEY_SIGN_MESSAGE_PARA, pbToBeSigned: *const BYTE, cbToBeSigned: DWORD,
pbSignedBlob: *mut BYTE, pcbSignedBlob: *mut DWORD,
) -> BOOL;
pub fn CryptStringToBinaryA(
pszString: LPCSTR, cchString: DWORD, dwFlags: DWORD, pbBinary: *mut BYTE,
pcbBinary: *mut DWORD, pdwSkip: *mut DWORD, pdwFlags: *mut DWORD,
) -> BOOL;
pub fn CryptStringToBinaryW(
pszString: LPCWSTR, cchString: DWORD, dwFlags: DWORD, pbBinary: *mut BYTE,
pcbBinary: *mut DWORD, pdwSkip: *mut DWORD, pdwFlags: *mut DWORD,
) -> BOOL;
pub fn CryptUninstallDefaultContext(
hDefaultContext: HCRYPTDEFAULTCONTEXT, dwFlags: DWORD, pvReserved: *mut c_void,
) -> BOOL;
pub fn CryptUnprotectData(
pDataIn: *mut DATA_BLOB, ppszDataDescr: *mut LPWSTR, pOptionalEntropy: *mut DATA_BLOB,
pvReserved: PVOID, pPromptStruct: *mut CRYPTPROTECT_PROMPTSTRUCT, dwFlags: DWORD,
pDataOut: *mut DATA_BLOB,
) -> BOOL;
pub fn CryptUnprotectMemory(pDataIn: LPVOID, cbDataIn: DWORD, dwFlags: DWORD) -> BOOL;
pub fn CryptUnregisterDefaultOIDFunction(
dwEncodingType: DWORD, pszFuncName: LPCSTR, pwszDll: LPCWSTR,
) -> BOOL;
pub fn CryptUnregisterOIDFunction(
dwEncodingType: DWORD, pszFuncName: LPCSTR, pszOID: LPCSTR,
) -> BOOL;
pub fn CryptUnregisterOIDInfo(pInfo: PCCRYPT_OID_INFO) -> BOOL;
pub fn CryptUpdateProtectedState(
pOldSid: PSID, pwszOldPassword: LPCWSTR, dwFlags: DWORD, pdwSuccessCount: *mut DWORD,
pdwFailureCount: *mut DWORD,
) -> BOOL;
pub fn CryptVerifyCertificateSignature(
hCryptProv: HCRYPTPROV_LEGACY, dwCertEncodingType: DWORD, pbEncoded: *const BYTE,
cbEncoded: DWORD, pPublicKey: PCERT_PUBLIC_KEY_INFO,
) -> BOOL;
pub fn CryptVerifyCertificateSignatureEx(
hCryptProv: HCRYPTPROV_LEGACY, dwCertEncodingType: DWORD, dwSubjectType: DWORD,
pvSubject: *mut c_void, dwIssuerType: DWORD, pvIssuer: *mut c_void, dwFlags: DWORD,
pvExtra: *mut c_void,
) -> BOOL;
pub fn CryptVerifyDetachedMessageHash(
pHashPara: PCRYPT_HASH_MESSAGE_PARA, pbDetachedHashBlob: *mut BYTE,
cbDetachedHashBlob: DWORD, cToBeHashed: DWORD, rgpbToBeHashed: *mut *const BYTE,
rgcbToBeHashed: *mut DWORD, pbComputedHash: *mut BYTE, pcbComputedHash: *mut DWORD,
) -> BOOL;
pub fn CryptVerifyDetachedMessageSignature(
pVerifyPara: PCRYPT_VERIFY_MESSAGE_PARA, dwSignerIndex: DWORD,
pbDetachedSignBlob: *const BYTE, cbDetachedSignBlob: DWORD, cToBeSigned: DWORD,
rgpbToBeSigned: *mut *const BYTE, rgcbToBeSigned: *mut DWORD,
ppSignerCert: *mut PCCERT_CONTEXT,
) -> BOOL;
pub fn CryptVerifyMessageHash(
pHashPara: PCRYPT_HASH_MESSAGE_PARA, pbHashedBlob: *mut BYTE, cbHashedBlob: DWORD,
pbToBeHashed: *mut BYTE, pcbToBeHashed: *mut DWORD, pbComputedHash: *mut BYTE,
pcbComputedHash: *mut DWORD,
) -> BOOL;
pub fn CryptVerifyMessageSignature(
pVerifyPara: PCRYPT_VERIFY_MESSAGE_PARA, dwSignerIndex: DWORD, pbSignedBlob: *const BYTE,
cbSignedBlob: DWORD, pbDecoded: *mut BYTE, pcbDecoded: *mut DWORD,
ppSignerCert: *mut PCCERT_CONTEXT,
) -> BOOL;
pub fn CryptVerifyMessageSignatureWithKey(
pVerifyPara: PCRYPT_KEY_VERIFY_MESSAGE_PARA, pPublicKeyInfo: PCERT_PUBLIC_KEY_INFO,
pbSignedBlob: *const BYTE, cbSignedBlob: DWORD, pbDecoded: *mut BYTE,
pcbDecoded: *mut DWORD,
) -> BOOL;
pub fn CryptVerifyTimeStampSignature(
pbTSContentInfo: *const BYTE, cbTSContentInfo: DWORD, pbData: *const BYTE, cbData: DWORD,
hAdditionalStore: HCERTSTORE, ppTsContext: *mut PCRYPT_TIMESTAMP_CONTEXT,
ppTsSigner: *mut PCCERT_CONTEXT, phStore: *mut HCERTSTORE,
) -> BOOL;
pub fn PFXExportCertStore(
hStore: HCERTSTORE, pPFX: *mut CRYPT_DATA_BLOB, szPassword: LPCWSTR, dwFlags: DWORD,
) -> BOOL;
pub fn PFXExportCertStoreEx(
hStore: HCERTSTORE, pPFX: *mut CRYPT_DATA_BLOB, szPassword: LPCWSTR, pvPara: *mut c_void,
dwFlags: DWORD,
) -> BOOL;
pub fn PFXImportCertStore(
pPFX: *mut CRYPT_DATA_BLOB, szPassword: LPCWSTR, dwFlags: DWORD,
) -> HCERTSTORE;
pub fn PFXIsPFXBlob(pPFX: *mut CRYPT_DATA_BLOB) -> BOOL;
pub fn PFXVerifyPassword(
pPFX: *mut CRYPT_DATA_BLOB, szPassword: LPCWSTR, dwFlags: DWORD,
) -> BOOL;
}