extern crate libloading;
pub struct SSP {
__library: ::libloading::Library,
pub GetLastError: unsafe extern "C" fn() -> DWORD,
pub CertOpenStore: unsafe extern "C" fn(
lpszStoreProvider: LPCSTR,
dwEncodingType: DWORD,
hCryptProv: HCRYPTPROV,
dwFlags: DWORD,
pvPara: *const ::std::os::raw::c_void,
) -> HCERTSTORE,
pub CertCloseStore: unsafe extern "C" fn(hCertStore: HCERTSTORE, dwFlags: DWORD) -> BOOL,
pub CertEnumCertificatesInStore: unsafe extern "C" fn(
hCertStore: HCERTSTORE,
pPrevCertContext: PCCERT_CONTEXT,
) -> PCCERT_CONTEXT,
pub CertFindCertificateInStore: unsafe extern "C" fn(
hCertStore: HCERTSTORE,
dwCertEncodingType: DWORD,
dwFindFlags: DWORD,
dwFindType: DWORD,
pvFindPara: *const ::std::os::raw::c_void,
pPrevCertContext: PCCERT_CONTEXT,
) -> PCCERT_CONTEXT,
pub CertFreeCertificateContext: unsafe extern "C" fn(pCertContext: PCCERT_CONTEXT) -> BOOL,
pub CertGetCertificateContextProperty: unsafe extern "C" fn(
pCertContext: PCCERT_CONTEXT,
dwPropId: DWORD,
pvData: *mut ::std::os::raw::c_void,
pcbData: *mut DWORD,
) -> BOOL,
pub CertEnumCertificateContextProperties:
unsafe extern "C" fn(pCertContext: PCCERT_CONTEXT, dwPropId: DWORD) -> DWORD,
pub CryptAcquireContextW: unsafe extern "C" fn(
phProv: *mut HCRYPTPROV,
pszContainer: LPCWSTR,
pszProvider: LPCWSTR,
dwProvType: DWORD,
dwFlags: DWORD,
) -> BOOL,
pub CryptReleaseContext: unsafe extern "C" fn(hProv: HCRYPTPROV, dwFlags: DWORD) -> BOOL,
pub CryptGenKey: unsafe extern "C" fn(
hProv: HCRYPTPROV,
Algid: ALG_ID,
dwFlags: DWORD,
phKey: *mut HCRYPTKEY,
) -> BOOL,
pub CryptDeriveKey: unsafe extern "C" fn(
hProv: HCRYPTPROV,
Algid: ALG_ID,
hBaseData: HCRYPTHASH,
dwFlags: DWORD,
phKey: *mut HCRYPTKEY,
) -> BOOL,
pub CryptDestroyKey: unsafe extern "C" fn(hKey: HCRYPTKEY) -> BOOL,
pub CryptSetKeyParam: unsafe extern "C" fn(
hKey: HCRYPTKEY,
dwParam: DWORD,
pbData: *const BYTE,
dwFlags: DWORD,
) -> BOOL,
pub CryptGetKeyParam: unsafe extern "C" fn(
hKey: HCRYPTKEY,
dwParam: DWORD,
pbData: *mut BYTE,
pdwDataLen: *mut DWORD,
dwFlags: DWORD,
) -> BOOL,
pub CryptSetHashParam: unsafe extern "C" fn(
hHash: HCRYPTHASH,
dwParam: DWORD,
pbData: *const BYTE,
dwFlags: DWORD,
) -> BOOL,
pub CryptGetHashParam: unsafe extern "C" fn(
hHash: HCRYPTHASH,
dwParam: DWORD,
pbData: *mut BYTE,
pdwDataLen: *mut DWORD,
dwFlags: DWORD,
) -> BOOL,
pub CryptSetProvParam: unsafe extern "C" fn(
hProv: HCRYPTPROV,
dwParam: DWORD,
pbData: *const BYTE,
dwFlags: DWORD,
) -> BOOL,
pub CryptGetProvParam: unsafe extern "C" fn(
hProv: HCRYPTPROV,
dwParam: DWORD,
pbData: *mut BYTE,
pdwDataLen: *mut DWORD,
dwFlags: DWORD,
) -> BOOL,
pub CryptGenRandom:
unsafe extern "C" fn(hProv: HCRYPTPROV, dwLen: DWORD, pbBuffer: *mut BYTE) -> BOOL,
pub CryptGetUserKey: unsafe extern "C" fn(
hProv: HCRYPTPROV,
dwKeySpec: DWORD,
phUserKey: *mut HCRYPTKEY,
) -> BOOL,
pub CryptExportKey: unsafe extern "C" fn(
hKey: HCRYPTKEY,
hExpKey: HCRYPTKEY,
dwBlobType: DWORD,
dwFlags: DWORD,
pbData: *mut BYTE,
pdwDataLen: *mut DWORD,
) -> BOOL,
pub CryptImportKey: unsafe extern "C" fn(
hProv: HCRYPTPROV,
pbData: *const BYTE,
dwDataLen: DWORD,
hPubKey: HCRYPTKEY,
dwFlags: DWORD,
phKey: *mut HCRYPTKEY,
) -> BOOL,
pub CryptEncrypt: unsafe extern "C" fn(
hKey: HCRYPTKEY,
hHash: HCRYPTHASH,
Final: BOOL,
dwFlags: DWORD,
pbData: *mut BYTE,
pdwDataLen: *mut DWORD,
dwBufLen: DWORD,
) -> BOOL,
pub CryptDecrypt: unsafe extern "C" fn(
hKey: HCRYPTKEY,
hHash: HCRYPTHASH,
Final: BOOL,
dwFlags: DWORD,
pbData: *mut BYTE,
pdwDataLen: *mut DWORD,
) -> BOOL,
pub CryptCreateHash: unsafe extern "C" fn(
hProv: HCRYPTPROV,
Algid: ALG_ID,
hKey: HCRYPTKEY,
dwFlags: DWORD,
phHash: *mut HCRYPTHASH,
) -> BOOL,
pub CryptHashData: unsafe extern "C" fn(
hHash: HCRYPTHASH,
pbData: *const BYTE,
dwDataLen: DWORD,
dwFlags: DWORD,
) -> BOOL,
pub CryptHashSessionKey:
unsafe extern "C" fn(hHash: HCRYPTHASH, hKey: HCRYPTKEY, dwFlags: DWORD) -> BOOL,
pub CryptDestroyHash: unsafe extern "C" fn(hHash: HCRYPTHASH) -> BOOL,
pub CryptSignHashA: unsafe extern "C" fn(
hHash: HCRYPTHASH,
dwKeySpec: DWORD,
szDescription: LPCSTR,
dwFlags: DWORD,
pbSignature: *mut BYTE,
pdwSigLen: *mut DWORD,
) -> BOOL,
pub CryptVerifySignatureA: unsafe extern "C" fn(
hHash: HCRYPTHASH,
pbSignature: *const BYTE,
dwSigLen: DWORD,
hPubKey: HCRYPTKEY,
szDescription: LPCSTR,
dwFlags: DWORD,
) -> BOOL,
pub CryptDuplicateKey: unsafe extern "C" fn(
hKey: HCRYPTKEY,
pdwReserved: *mut DWORD,
dwFlags: DWORD,
phKey: *mut HCRYPTKEY,
) -> BOOL,
pub CryptDuplicateHash: unsafe extern "C" fn(
hHash: HCRYPTHASH,
pdwReserved: *mut DWORD,
dwFlags: DWORD,
phHash: *mut HCRYPTHASH,
) -> BOOL,
pub CryptEnumProvidersA: unsafe extern "C" fn(
dwIndex: DWORD,
pdwReserved: *mut DWORD,
dwFlags: DWORD,
pdwProvType: *mut DWORD,
szProvName: LPSTR,
pcbProvName: *mut DWORD,
) -> BOOL,
}
impl SSP {
pub unsafe fn new<P>(path: P) -> Result<Self, ::libloading::Error>
where
P: AsRef<::std::ffi::OsStr>,
{
let library = ::libloading::Library::new(path)?;
Self::from_library(library)
}
pub unsafe fn from_library<L>(library: L) -> Result<Self, ::libloading::Error>
where
L: Into<::libloading::Library>,
{
let __library = library.into();
let GetLastError = __library.get(b"GetLastError\0").map(|sym| *sym)?;
let CertOpenStore = __library.get(b"CertOpenStore\0").map(|sym| *sym)?;
let CertCloseStore = __library.get(b"CertCloseStore\0").map(|sym| *sym)?;
let CertEnumCertificatesInStore = __library
.get(b"CertEnumCertificatesInStore\0")
.map(|sym| *sym)?;
let CertFindCertificateInStore = __library
.get(b"CertFindCertificateInStore\0")
.map(|sym| *sym)?;
let CertFreeCertificateContext = __library
.get(b"CertFreeCertificateContext\0")
.map(|sym| *sym)?;
let CertGetCertificateContextProperty = __library
.get(b"CertGetCertificateContextProperty\0")
.map(|sym| *sym)?;
let CertEnumCertificateContextProperties = __library
.get(b"CertEnumCertificateContextProperties\0")
.map(|sym| *sym)?;
let CryptAcquireContextW = __library.get(b"CryptAcquireContextW\0").map(|sym| *sym)?;
let CryptReleaseContext = __library.get(b"CryptReleaseContext\0").map(|sym| *sym)?;
let CryptGenKey = __library.get(b"CryptGenKey\0").map(|sym| *sym)?;
let CryptDeriveKey = __library.get(b"CryptDeriveKey\0").map(|sym| *sym)?;
let CryptDestroyKey = __library.get(b"CryptDestroyKey\0").map(|sym| *sym)?;
let CryptSetKeyParam = __library.get(b"CryptSetKeyParam\0").map(|sym| *sym)?;
let CryptGetKeyParam = __library.get(b"CryptGetKeyParam\0").map(|sym| *sym)?;
let CryptSetHashParam = __library.get(b"CryptSetHashParam\0").map(|sym| *sym)?;
let CryptGetHashParam = __library.get(b"CryptGetHashParam\0").map(|sym| *sym)?;
let CryptSetProvParam = __library.get(b"CryptSetProvParam\0").map(|sym| *sym)?;
let CryptGetProvParam = __library.get(b"CryptGetProvParam\0").map(|sym| *sym)?;
let CryptGenRandom = __library.get(b"CryptGenRandom\0").map(|sym| *sym)?;
let CryptGetUserKey = __library.get(b"CryptGetUserKey\0").map(|sym| *sym)?;
let CryptExportKey = __library.get(b"CryptExportKey\0").map(|sym| *sym)?;
let CryptImportKey = __library.get(b"CryptImportKey\0").map(|sym| *sym)?;
let CryptEncrypt = __library.get(b"CryptEncrypt\0").map(|sym| *sym)?;
let CryptDecrypt = __library.get(b"CryptDecrypt\0").map(|sym| *sym)?;
let CryptCreateHash = __library.get(b"CryptCreateHash\0").map(|sym| *sym)?;
let CryptHashData = __library.get(b"CryptHashData\0").map(|sym| *sym)?;
let CryptHashSessionKey = __library.get(b"CryptHashSessionKey\0").map(|sym| *sym)?;
let CryptDestroyHash = __library.get(b"CryptDestroyHash\0").map(|sym| *sym)?;
let CryptSignHashA = __library.get(b"CryptSignHashA\0").map(|sym| *sym)?;
let CryptVerifySignatureA = __library.get(b"CryptVerifySignatureA\0").map(|sym| *sym)?;
let CryptDuplicateKey = __library.get(b"CryptDuplicateKey\0").map(|sym| *sym)?;
let CryptDuplicateHash = __library.get(b"CryptDuplicateHash\0").map(|sym| *sym)?;
let CryptEnumProvidersA = __library.get(b"CryptEnumProvidersA\0").map(|sym| *sym)?;
Ok(SSP {
__library,
GetLastError,
CertOpenStore,
CertCloseStore,
CertEnumCertificatesInStore,
CertFindCertificateInStore,
CertFreeCertificateContext,
CertGetCertificateContextProperty,
CertEnumCertificateContextProperties,
CryptAcquireContextW,
CryptReleaseContext,
CryptGenKey,
CryptDeriveKey,
CryptDestroyKey,
CryptSetKeyParam,
CryptGetKeyParam,
CryptSetHashParam,
CryptGetHashParam,
CryptSetProvParam,
CryptGetProvParam,
CryptGenRandom,
CryptGetUserKey,
CryptExportKey,
CryptImportKey,
CryptEncrypt,
CryptDecrypt,
CryptCreateHash,
CryptHashData,
CryptHashSessionKey,
CryptDestroyHash,
CryptSignHashA,
CryptVerifySignatureA,
CryptDuplicateKey,
CryptDuplicateHash,
CryptEnumProvidersA,
})
}
pub unsafe fn GetLastError(&self) -> DWORD {
(self.GetLastError)()
}
pub unsafe fn CertOpenStore(
&self,
lpszStoreProvider: LPCSTR,
dwEncodingType: DWORD,
hCryptProv: HCRYPTPROV,
dwFlags: DWORD,
pvPara: *const ::std::os::raw::c_void,
) -> HCERTSTORE {
(self.CertOpenStore)(
lpszStoreProvider,
dwEncodingType,
hCryptProv,
dwFlags,
pvPara,
)
}
pub unsafe fn CertCloseStore(&self, hCertStore: HCERTSTORE, dwFlags: DWORD) -> BOOL {
(self.CertCloseStore)(hCertStore, dwFlags)
}
pub unsafe fn CertEnumCertificatesInStore(
&self,
hCertStore: HCERTSTORE,
pPrevCertContext: PCCERT_CONTEXT,
) -> PCCERT_CONTEXT {
(self.CertEnumCertificatesInStore)(hCertStore, pPrevCertContext)
}
pub unsafe fn CertFindCertificateInStore(
&self,
hCertStore: HCERTSTORE,
dwCertEncodingType: DWORD,
dwFindFlags: DWORD,
dwFindType: DWORD,
pvFindPara: *const ::std::os::raw::c_void,
pPrevCertContext: PCCERT_CONTEXT,
) -> PCCERT_CONTEXT {
(self.CertFindCertificateInStore)(
hCertStore,
dwCertEncodingType,
dwFindFlags,
dwFindType,
pvFindPara,
pPrevCertContext,
)
}
pub unsafe fn CertFreeCertificateContext(&self, pCertContext: PCCERT_CONTEXT) -> BOOL {
(self.CertFreeCertificateContext)(pCertContext)
}
pub unsafe fn CertGetCertificateContextProperty(
&self,
pCertContext: PCCERT_CONTEXT,
dwPropId: DWORD,
pvData: *mut ::std::os::raw::c_void,
pcbData: *mut DWORD,
) -> BOOL {
(self.CertGetCertificateContextProperty)(pCertContext, dwPropId, pvData, pcbData)
}
pub unsafe fn CertEnumCertificateContextProperties(
&self,
pCertContext: PCCERT_CONTEXT,
dwPropId: DWORD,
) -> DWORD {
(self.CertEnumCertificateContextProperties)(pCertContext, dwPropId)
}
pub unsafe fn CryptAcquireContextW(
&self,
phProv: *mut HCRYPTPROV,
pszContainer: LPCWSTR,
pszProvider: LPCWSTR,
dwProvType: DWORD,
dwFlags: DWORD,
) -> BOOL {
(self.CryptAcquireContextW)(phProv, pszContainer, pszProvider, dwProvType, dwFlags)
}
pub unsafe fn CryptReleaseContext(&self, hProv: HCRYPTPROV, dwFlags: DWORD) -> BOOL {
(self.CryptReleaseContext)(hProv, dwFlags)
}
pub unsafe fn CryptGenKey(
&self,
hProv: HCRYPTPROV,
Algid: ALG_ID,
dwFlags: DWORD,
phKey: *mut HCRYPTKEY,
) -> BOOL {
(self.CryptGenKey)(hProv, Algid, dwFlags, phKey)
}
pub unsafe fn CryptDeriveKey(
&self,
hProv: HCRYPTPROV,
Algid: ALG_ID,
hBaseData: HCRYPTHASH,
dwFlags: DWORD,
phKey: *mut HCRYPTKEY,
) -> BOOL {
(self.CryptDeriveKey)(hProv, Algid, hBaseData, dwFlags, phKey)
}
pub unsafe fn CryptDestroyKey(&self, hKey: HCRYPTKEY) -> BOOL {
(self.CryptDestroyKey)(hKey)
}
pub unsafe fn CryptSetKeyParam(
&self,
hKey: HCRYPTKEY,
dwParam: DWORD,
pbData: *const BYTE,
dwFlags: DWORD,
) -> BOOL {
(self.CryptSetKeyParam)(hKey, dwParam, pbData, dwFlags)
}
pub unsafe fn CryptGetKeyParam(
&self,
hKey: HCRYPTKEY,
dwParam: DWORD,
pbData: *mut BYTE,
pdwDataLen: *mut DWORD,
dwFlags: DWORD,
) -> BOOL {
(self.CryptGetKeyParam)(hKey, dwParam, pbData, pdwDataLen, dwFlags)
}
pub unsafe fn CryptSetHashParam(
&self,
hHash: HCRYPTHASH,
dwParam: DWORD,
pbData: *const BYTE,
dwFlags: DWORD,
) -> BOOL {
(self.CryptSetHashParam)(hHash, dwParam, pbData, dwFlags)
}
pub unsafe fn CryptGetHashParam(
&self,
hHash: HCRYPTHASH,
dwParam: DWORD,
pbData: *mut BYTE,
pdwDataLen: *mut DWORD,
dwFlags: DWORD,
) -> BOOL {
(self.CryptGetHashParam)(hHash, dwParam, pbData, pdwDataLen, dwFlags)
}
pub unsafe fn CryptSetProvParam(
&self,
hProv: HCRYPTPROV,
dwParam: DWORD,
pbData: *const BYTE,
dwFlags: DWORD,
) -> BOOL {
(self.CryptSetProvParam)(hProv, dwParam, pbData, dwFlags)
}
pub unsafe fn CryptGetProvParam(
&self,
hProv: HCRYPTPROV,
dwParam: DWORD,
pbData: *mut BYTE,
pdwDataLen: *mut DWORD,
dwFlags: DWORD,
) -> BOOL {
(self.CryptGetProvParam)(hProv, dwParam, pbData, pdwDataLen, dwFlags)
}
pub unsafe fn CryptGenRandom(
&self,
hProv: HCRYPTPROV,
dwLen: DWORD,
pbBuffer: *mut BYTE,
) -> BOOL {
(self.CryptGenRandom)(hProv, dwLen, pbBuffer)
}
pub unsafe fn CryptGetUserKey(
&self,
hProv: HCRYPTPROV,
dwKeySpec: DWORD,
phUserKey: *mut HCRYPTKEY,
) -> BOOL {
(self.CryptGetUserKey)(hProv, dwKeySpec, phUserKey)
}
pub unsafe fn CryptExportKey(
&self,
hKey: HCRYPTKEY,
hExpKey: HCRYPTKEY,
dwBlobType: DWORD,
dwFlags: DWORD,
pbData: *mut BYTE,
pdwDataLen: *mut DWORD,
) -> BOOL {
(self.CryptExportKey)(hKey, hExpKey, dwBlobType, dwFlags, pbData, pdwDataLen)
}
pub unsafe fn CryptImportKey(
&self,
hProv: HCRYPTPROV,
pbData: *const BYTE,
dwDataLen: DWORD,
hPubKey: HCRYPTKEY,
dwFlags: DWORD,
phKey: *mut HCRYPTKEY,
) -> BOOL {
(self.CryptImportKey)(hProv, pbData, dwDataLen, hPubKey, dwFlags, phKey)
}
pub unsafe fn CryptEncrypt(
&self,
hKey: HCRYPTKEY,
hHash: HCRYPTHASH,
Final: BOOL,
dwFlags: DWORD,
pbData: *mut BYTE,
pdwDataLen: *mut DWORD,
dwBufLen: DWORD,
) -> BOOL {
(self.CryptEncrypt)(hKey, hHash, Final, dwFlags, pbData, pdwDataLen, dwBufLen)
}
pub unsafe fn CryptDecrypt(
&self,
hKey: HCRYPTKEY,
hHash: HCRYPTHASH,
Final: BOOL,
dwFlags: DWORD,
pbData: *mut BYTE,
pdwDataLen: *mut DWORD,
) -> BOOL {
(self.CryptDecrypt)(hKey, hHash, Final, dwFlags, pbData, pdwDataLen)
}
pub unsafe fn CryptCreateHash(
&self,
hProv: HCRYPTPROV,
Algid: ALG_ID,
hKey: HCRYPTKEY,
dwFlags: DWORD,
phHash: *mut HCRYPTHASH,
) -> BOOL {
(self.CryptCreateHash)(hProv, Algid, hKey, dwFlags, phHash)
}
pub unsafe fn CryptHashData(
&self,
hHash: HCRYPTHASH,
pbData: *const BYTE,
dwDataLen: DWORD,
dwFlags: DWORD,
) -> BOOL {
(self.CryptHashData)(hHash, pbData, dwDataLen, dwFlags)
}
pub unsafe fn CryptHashSessionKey(
&self,
hHash: HCRYPTHASH,
hKey: HCRYPTKEY,
dwFlags: DWORD,
) -> BOOL {
(self.CryptHashSessionKey)(hHash, hKey, dwFlags)
}
pub unsafe fn CryptDestroyHash(&self, hHash: HCRYPTHASH) -> BOOL {
(self.CryptDestroyHash)(hHash)
}
pub unsafe fn CryptSignHashA(
&self,
hHash: HCRYPTHASH,
dwKeySpec: DWORD,
szDescription: LPCSTR,
dwFlags: DWORD,
pbSignature: *mut BYTE,
pdwSigLen: *mut DWORD,
) -> BOOL {
(self.CryptSignHashA)(
hHash,
dwKeySpec,
szDescription,
dwFlags,
pbSignature,
pdwSigLen,
)
}
pub unsafe fn CryptVerifySignatureA(
&self,
hHash: HCRYPTHASH,
pbSignature: *const BYTE,
dwSigLen: DWORD,
hPubKey: HCRYPTKEY,
szDescription: LPCSTR,
dwFlags: DWORD,
) -> BOOL {
(self.CryptVerifySignatureA)(
hHash,
pbSignature,
dwSigLen,
hPubKey,
szDescription,
dwFlags,
)
}
pub unsafe fn CryptDuplicateKey(
&self,
hKey: HCRYPTKEY,
pdwReserved: *mut DWORD,
dwFlags: DWORD,
phKey: *mut HCRYPTKEY,
) -> BOOL {
(self.CryptDuplicateKey)(hKey, pdwReserved, dwFlags, phKey)
}
pub unsafe fn CryptDuplicateHash(
&self,
hHash: HCRYPTHASH,
pdwReserved: *mut DWORD,
dwFlags: DWORD,
phHash: *mut HCRYPTHASH,
) -> BOOL {
(self.CryptDuplicateHash)(hHash, pdwReserved, dwFlags, phHash)
}
pub unsafe fn CryptEnumProvidersA(
&self,
dwIndex: DWORD,
pdwReserved: *mut DWORD,
dwFlags: DWORD,
pdwProvType: *mut DWORD,
szProvName: LPSTR,
pcbProvName: *mut DWORD,
) -> BOOL {
(self.CryptEnumProvidersA)(
dwIndex,
pdwReserved,
dwFlags,
pdwProvType,
szProvName,
pcbProvName,
)
}
}