// Licensed under the Apache License, Version 2.0
// <LICENSE-APACHE or
http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or
http://opensource.org/licenses/MIT>, at your option.
// All files in the project carrying such notice may not be copied, modified, or distributed
// except according to those terms.
use shared::basetsd::SIZE_T;
use shared::minwindef::{BOOL, DWORD, LPVOID, PBYTE, PDWORD, ULONG};
use um::minwinbase::SECURITY_ATTRIBUTES;
use um::wincrypt::ALG_ID;
use um::winnt::{LPCWSTR, LPWSTR, SID};
pub const WINEFS_SETUSERKEY_SET_CAPABILITIES: DWORD = 0x00000001;
STRUCT!{struct EFS_CERTIFICATE_BLOB {
dwCertEncodingType: DWORD,
cbData: DWORD,
pbData: PBYTE,
}}
pub type PEFS_CERTIFICATE_BLOB = *mut EFS_CERTIFICATE_BLOB;
STRUCT!{struct EFS_HASH_BLOB {
cbData: DWORD,
pbData: PBYTE,
}}
pub type PEFS_HASH_BLOB = *mut EFS_HASH_BLOB;
STRUCT!{struct EFS_RPC_BLOB {
cbData: DWORD,
pbData: PBYTE,
}}
pub type PEFS_RPC_BLOB = *mut EFS_RPC_BLOB;
STRUCT!{struct EFS_PIN_BLOB {
cbPadding: DWORD,
cbData: DWORD,
pbData: PBYTE,
}}
pub type PEFS_PIN_BLOB = *mut EFS_PIN_BLOB;
STRUCT!{struct EFS_KEY_INFO {
dwVersion: DWORD,
Entropy: ULONG,
Algorithm: ALG_ID,
KeyLength: ULONG,
}}
pub type PEFS_KEY_INFO = *mut EFS_KEY_INFO;
STRUCT!{struct EFS_COMPATIBILITY_INFO {
EfsVersion: DWORD,
}}
pub type PEFS_COMPATIBILITY_INFO = *mut EFS_COMPATIBILITY_INFO;
pub const EFS_COMPATIBILITY_VERSION_NCRYPT_PROTECTOR: DWORD = 5;
pub const EFS_COMPATIBILITY_VERSION_PFILE_PROTECTOR: DWORD = 6;
#[inline]
pub fn EFS_IS_DESCRIPTOR_VERSION(v: DWORD) -> bool {
v == EFS_COMPATIBILITY_VERSION_NCRYPT_PROTECTOR
|| v == EFS_COMPATIBILITY_VERSION_PFILE_PROTECTOR
}
pub const EFS_SUBVER_UNKNOWN: DWORD = 0;
pub const EFS_EFS_SUBVER_EFS_CERT: DWORD = 1;
pub const EFS_PFILE_SUBVER_RMS: DWORD = 2;
pub const EFS_PFILE_SUBVER_APPX: DWORD = 3;
STRUCT!{struct EFS_VERSION_INFO {
EfsVersion: DWORD,
SubVersion: DWORD,
}}
pub type PEFS_VERSION_INFO = *mut EFS_VERSION_INFO;
#[inline]
pub fn EFS_IS_APPX_VERSION(v: DWORD, subV: DWORD) -> bool {
v == EFS_COMPATIBILITY_VERSION_PFILE_PROTECTOR && subV == EFS_PFILE_SUBVER_APPX
}
STRUCT!{struct EFS_DECRYPTION_STATUS_INFO {
dwDecryptionError: DWORD,
dwHashOffset: DWORD,
cbHash: DWORD,
}}
pub type PEFS_DECRYPTION_STATUS_INFO = *mut EFS_DECRYPTION_STATUS_INFO;
STRUCT!{struct EFS_ENCRYPTION_STATUS_INFO {
bHasCurrentKey: BOOL,
dwEncryptionError: DWORD,
}}
pub type PEFS_ENCRYPTION_STATUS_INFO = *mut EFS_ENCRYPTION_STATUS_INFO;
STRUCT!{struct ENCRYPTION_CERTIFICATE {
cbTotalLength: DWORD,
pUserSid: *mut SID,
pCertBlob: PEFS_CERTIFICATE_BLOB,
}}
pub type PENCRYPTION_CERTIFICATE = *mut ENCRYPTION_CERTIFICATE;
pub const MAX_SID_SIZE: SIZE_T = 256;
STRUCT!{struct ENCRYPTION_CERTIFICATE_HASH {
cbTotalLength: DWORD,
pUserSid: *mut SID,
pHash: PEFS_HASH_BLOB,
lpDisplayInformation: LPWSTR,
}}
pub type PENCRYPTION_CERTIFICATE_HASH = *mut ENCRYPTION_CERTIFICATE_HASH;
STRUCT!{struct ENCRYPTION_CERTIFICATE_HASH_LIST {
nCert_Hash: DWORD,
pUsers: *mut PENCRYPTION_CERTIFICATE_HASH,
}}
pub type PENCRYPTION_CERTIFICATE_HASH_LIST = *mut ENCRYPTION_CERTIFICATE_HASH_LIST;
STRUCT!{struct ENCRYPTION_CERTIFICATE_LIST {
nUsers: DWORD,
pUsers: *mut PENCRYPTION_CERTIFICATE,
}}
pub type PENCRYPTION_CERTIFICATE_LIST = *mut ENCRYPTION_CERTIFICATE_LIST;
pub const EFS_METADATA_ADD_USER: DWORD = 0x00000001;
pub const EFS_METADATA_REMOVE_USER: DWORD = 0x00000002;
pub const EFS_METADATA_REPLACE_USER: DWORD = 0x00000004;
pub const EFS_METADATA_GENERAL_OP: DWORD = 0x00000008;
STRUCT!{struct ENCRYPTED_FILE_METADATA_SIGNATURE {
dwEfsAccessType: DWORD,
pCertificatesAdded: PENCRYPTION_CERTIFICATE_HASH_LIST,
pEncryptionCertificate: PENCRYPTION_CERTIFICATE,
pEfsStreamSignature: PEFS_RPC_BLOB,
}}
pub type PENCRYPTED_FILE_METADATA_SIGNATURE = *mut ENCRYPTED_FILE_METADATA_SIGNATURE;
STRUCT!{struct ENCRYPTION_PROTECTOR {
cbTotalLength: DWORD,
pUserSid: *mut SID,
lpProtectorDescriptor: LPWSTR,
}}
pub type PENCRYPTION_PROTECTOR = *mut ENCRYPTION_PROTECTOR;
STRUCT!{struct ENCRYPTION_PROTECTOR_LIST {
nProtectors: DWORD,
pProtectors: *mut PENCRYPTION_PROTECTOR,
}}
pub type PENCRYPTION_PROTECTOR_LIST = *mut ENCRYPTION_PROTECTOR_LIST;
extern "system" {
pub fn QueryUsersOnEncryptedFile(
lpFileName: LPCWSTR,
pUsers: *mut PENCRYPTION_CERTIFICATE_HASH_LIST,
) -> DWORD;
pub fn QueryRecoveryAgentsOnEncryptedFile(
lpFileName: LPCWSTR,
pRecoveryAgents: *mut PENCRYPTION_CERTIFICATE_HASH_LIST,
) -> DWORD;
pub fn RemoveUsersFromEncryptedFile(
lpFileName: LPCWSTR,
pHashes: PENCRYPTION_CERTIFICATE_HASH_LIST,
) -> DWORD;
pub fn AddUsersToEncryptedFile(
lpFileName: LPCWSTR,
pEncryptionCertificate: PENCRYPTION_CERTIFICATE_LIST,
) -> DWORD;
pub fn SetUserFileEncryptionKey(
pEncryptionCertificate: PENCRYPTION_CERTIFICATE,
) -> DWORD;
pub fn SetUserFileEncryptionKeyEx(
pEncryptionCertificate: PENCRYPTION_CERTIFICATE,
dwCapabilities: DWORD,
dwFlags: DWORD,
pvReserved: LPVOID,
) -> DWORD;
pub fn FreeEncryptionCertificateHashList(
pUsers: PENCRYPTION_CERTIFICATE_HASH_LIST,
);
pub fn EncryptionDisable(
DirPath: LPCWSTR,
Disable: BOOL,
) -> BOOL;
pub fn DuplicateEncryptionInfoFile(
SrcFileName: LPCWSTR,
DstFileName: LPCWSTR,
dwCreationDistribution: DWORD,
dwAttributes: DWORD,
lpSecurityAttributes: *const SECURITY_ATTRIBUTES,
) -> DWORD;
pub fn GetEncryptedFileMetadata(
lpFileName: LPCWSTR,
pcbMetadata: PDWORD,
ppbMetadata: *mut PBYTE,
) -> DWORD;
pub fn SetEncryptedFileMetadata(
lpFileName: LPCWSTR,
pbOldMetadata: PBYTE,
pbNewMetadata: PBYTE,
pOwnerHash: PENCRYPTION_CERTIFICATE_HASH,
dwOperation: DWORD,
pCertificatesAdded: PENCRYPTION_CERTIFICATE_HASH_LIST,
) -> DWORD;
pub fn FreeEncryptedFileMetadata(
pbMetadata: PBYTE,
);
}
