ntlsa.rs - mozsearch

// 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, ULONG_PTR};

use shared::guiddef::GUID;

use shared::minwindef::{PUCHAR, PULONG, UCHAR, ULONG, USHORT};

use shared::ntdef::{NTSTATUS, PNTSTATUS};

use um::lsalookup::{

    LSA_TRUST_INFORMATION, LSA_UNICODE_STRING, PLSA_OBJECT_ATTRIBUTES,

    PLSA_REFERENCED_DOMAIN_LIST, PLSA_STRING, PLSA_TRANSLATED_NAME, PLSA_TRANSLATED_SID2,

    PLSA_TRUST_INFORMATION, PLSA_UNICODE_STRING,

};

use um::ntsecapi::PLSA_HANDLE;

use um::subauth::{PUNICODE_STRING, UNICODE_STRING};

use um::winnt::{

    ACCESS_MASK, ANYSIZE_ARRAY, BOOLEAN, HANDLE, LARGE_INTEGER, LONG, LUID, PBOOLEAN,

    PCLAIMS_BLOB, PHANDLE, PLARGE_INTEGER, PLUID, PPRIVILEGE_SET, PQUOTA_LIMITS,

    PSECURITY_DESCRIPTOR, PSHORT, PSID, PTOKEN_GROUPS, PTOKEN_PRIVILEGES, PTOKEN_SOURCE, PVOID,

    PWSTR, QUOTA_LIMITS, SECURITY_INFORMATION, SID_NAME_USE, STANDARD_RIGHTS_EXECUTE,

    STANDARD_RIGHTS_READ, STANDARD_RIGHTS_REQUIRED, STANDARD_RIGHTS_WRITE, TOKEN_DEFAULT_DACL,

    TOKEN_DEVICE_CLAIMS, TOKEN_OWNER, TOKEN_PRIMARY_GROUP, TOKEN_USER, TOKEN_USER_CLAIMS,

};

pub type LSA_OPERATIONAL_MODE = ULONG;

pub type PLSA_OPERATIONAL_MODE = *mut LSA_OPERATIONAL_MODE;

pub const LSA_MODE_PASSWORD_PROTECTED: ULONG = 0x00000001;

pub const LSA_MODE_INDIVIDUAL_ACCOUNTS: ULONG = 0x00000002;

pub const LSA_MODE_MANDATORY_ACCESS: ULONG = 0x00000004;

pub const LSA_MODE_LOG_FULL: ULONG = 0x00000008;

pub const LSA_MAXIMUM_SID_COUNT: SIZE_T = 0x00000100;

pub const LSA_MAXIMUM_ENUMERATION_LENGTH: SIZE_T = 32000;

pub const LSA_CALL_LICENSE_SERVER: ULONG = 0x80000000;

ENUM!{enum SECURITY_LOGON_TYPE {

    UndefinedLogonType = 0,

    Interactive = 2,

    Network,

    Batch,

    Service,

    Proxy,

    Unlock,

    NetworkCleartext,

    NewCredentials,

    RemoteInteractive,

    CachedInteractive,

    CachedRemoteInteractive,

    CachedUnlock,

}}

pub type PSECURITY_LOGON_TYPE = *mut SECURITY_LOGON_TYPE;

pub const SECURITY_ACCESS_INTERACTIVE_LOGON: ULONG = 0x00000001;

pub const SECURITY_ACCESS_NETWORK_LOGON: ULONG = 0x00000002;

pub const SECURITY_ACCESS_BATCH_LOGON: ULONG = 0x00000004;

pub const SECURITY_ACCESS_SERVICE_LOGON: ULONG = 0x00000010;

pub const SECURITY_ACCESS_PROXY_LOGON: ULONG = 0x00000020;

pub const SECURITY_ACCESS_DENY_INTERACTIVE_LOGON: ULONG = 0x00000040;

pub const SECURITY_ACCESS_DENY_NETWORK_LOGON: ULONG = 0x00000080;

pub const SECURITY_ACCESS_DENY_BATCH_LOGON: ULONG = 0x00000100;

pub const SECURITY_ACCESS_DENY_SERVICE_LOGON: ULONG = 0x00000200;

pub const SECURITY_ACCESS_REMOTE_INTERACTIVE_LOGON: ULONG = 0x00000400;

pub const SECURITY_ACCESS_DENY_REMOTE_INTERACTIVE_LOGON: ULONG = 0x00000800;

ENUM!{enum SE_ADT_PARAMETER_TYPE {

    SeAdtParmTypeNone = 0,

    SeAdtParmTypeString,

    SeAdtParmTypeFileSpec,

    SeAdtParmTypeUlong,

    SeAdtParmTypeSid,

    SeAdtParmTypeLogonId,

    SeAdtParmTypeNoLogonId,

    SeAdtParmTypeAccessMask,

    SeAdtParmTypePrivs,

    SeAdtParmTypeObjectTypes,

    SeAdtParmTypeHexUlong,

    SeAdtParmTypePtr,

    SeAdtParmTypeTime,

    SeAdtParmTypeGuid,

    SeAdtParmTypeLuid,

    SeAdtParmTypeHexInt64,

    SeAdtParmTypeStringList,

    SeAdtParmTypeSidList,

    SeAdtParmTypeDuration,

    SeAdtParmTypeUserAccountControl,

    SeAdtParmTypeNoUac,

    SeAdtParmTypeMessage,

    SeAdtParmTypeDateTime,

    SeAdtParmTypeSockAddr,

    SeAdtParmTypeSD,

    SeAdtParmTypeLogonHours,

    SeAdtParmTypeLogonIdNoSid,

    SeAdtParmTypeUlongNoConv,

    SeAdtParmTypeSockAddrNoPort,

    SeAdtParmTypeAccessReason,

    SeAdtParmTypeStagingReason,

    SeAdtParmTypeResourceAttribute,

    SeAdtParmTypeClaims,

    SeAdtParmTypeLogonIdAsSid,

    SeAdtParmTypeMultiSzString,

    SeAdtParmTypeLogonIdEx,

}}

pub type PSE_ADT_PARAMETER_TYPE = *mut SE_ADT_PARAMETER_TYPE;

pub const SE_ADT_OBJECT_ONLY: USHORT = 0x1;

STRUCT!{struct SE_ADT_OBJECT_TYPE {

    ObjectType: GUID,

    Flags: USHORT,

    Level: USHORT,

    AccessMask: ACCESS_MASK,

}}

pub type PSE_ADT_OBJECT_TYPE = *mut SE_ADT_OBJECT_TYPE;

STRUCT!{struct SE_ADT_PARAMETER_ARRAY_ENTRY {

    Type: SE_ADT_PARAMETER_TYPE,

    Length: ULONG,

    Data: [ULONG_PTR; 2],

    Address: PVOID,

}}

pub type PSE_ADT_PARAMETER_ARRAY_ENTRY = *mut SE_ADT_PARAMETER_ARRAY_ENTRY;

STRUCT!{struct SE_ADT_ACCESS_REASON {

    AccessMask: ACCESS_MASK,

    AccessReasons: [ULONG; 32],

    ObjectTypeIndex: ULONG,

    AccessGranted: ULONG,

    SecurityDescriptor: PSECURITY_DESCRIPTOR,

}}

pub type PSE_ADT_ACCESS_REASON = *mut SE_ADT_ACCESS_REASON;

STRUCT!{struct SE_ADT_CLAIMS {

    Length: ULONG,

    Claims: PCLAIMS_BLOB,

}}

pub type PSE_ADT_CLAIMS = *mut SE_ADT_CLAIMS;

pub const SE_MAX_AUDIT_PARAMETERS: SIZE_T = 32;

pub const SE_MAX_GENERIC_AUDIT_PARAMETERS: SIZE_T = 28;

STRUCT!{struct SE_ADT_PARAMETER_ARRAY {

    CategoryId: ULONG,

    AuditId: ULONG,

    ParameterCount: ULONG,

    Length: ULONG,

    FlatSubCategoryId: USHORT,

    Type: USHORT,

    Flags: ULONG,

    Parameters: [SE_ADT_PARAMETER_ARRAY_ENTRY; SE_MAX_AUDIT_PARAMETERS],

}}

pub type PSE_ADT_PARAMETER_ARRAY = *mut SE_ADT_PARAMETER_ARRAY;

STRUCT!{struct SE_ADT_PARAMETER_ARRAY_EX {

    CategoryId: ULONG,

    AuditId: ULONG,

    Version: ULONG,

    ParameterCount: ULONG,

    Length: ULONG,

    FlatSubCategoryId: USHORT,

    Type: USHORT,

    Flags: ULONG,

    Parameters: [SE_ADT_PARAMETER_ARRAY_ENTRY; SE_MAX_AUDIT_PARAMETERS],

}}

pub type PSE_ADT_PARAMETER_ARRAY_EX = *mut SE_ADT_PARAMETER_ARRAY_EX;

pub const SE_ADT_PARAMETERS_SELF_RELATIVE: ULONG = 0x00000001;

pub const SE_ADT_PARAMETERS_SEND_TO_LSA: ULONG = 0x00000002;

pub const SE_ADT_PARAMETER_EXTENSIBLE_AUDIT: ULONG = 0x00000004;

pub const SE_ADT_PARAMETER_GENERIC_AUDIT: ULONG = 0x00000008;

pub const SE_ADT_PARAMETER_WRITE_SYNCHRONOUS: ULONG = 0x00000010;

#[cfg(target_pointer_width = "32")]

#[inline]

pub fn LSAP_SE_ADT_PARAMETER_ARRAY_TRUE_SIZE(

    AuditParameters: SE_ADT_PARAMETER_ARRAY,

) -> SIZE_T {

    664  // FIXME: sizeof::<SE_ADT_PARAMETER_ARRAY>()

        - (20 // FIXME: sizeof::<SE_ADT_PARAMETER_ARRAY_ENTRY>()

        * (SE_MAX_AUDIT_PARAMETERS - AuditParameters.ParameterCount as SIZE_T))

#[cfg(target_pointer_width = "64")]

#[inline]

pub fn LSAP_SE_ADT_PARAMETER_ARRAY_TRUE_SIZE(

    AuditParameters: SE_ADT_PARAMETER_ARRAY,

) -> SIZE_T {

    1048  // FIXME: sizeof::<SE_ADT_PARAMETER_ARRAY>()

        - (32 // FIXME: sizeof::<SE_ADT_PARAMETER_ARRAY_ENTRY>()

        * (SE_MAX_AUDIT_PARAMETERS - AuditParameters.ParameterCount as SIZE_T))

STRUCT!{struct LSA_ADT_STRING_LIST_ENTRY {

    Flags: ULONG,

    String: UNICODE_STRING,

}}

pub type PLSA_ADT_STRING_LIST_ENTRY = *mut LSA_ADT_STRING_LIST_ENTRY;

STRUCT!{struct LSA_ADT_STRING_LIST {

    cStrings: ULONG,

    String: PLSA_ADT_STRING_LIST_ENTRY,

}}

pub type PLSA_ADT_STRING_LIST = *mut LSA_ADT_STRING_LIST;

STRUCT!{struct LSA_ADT_SID_LIST_ENTRY {

    Flags: ULONG,

    Sid: PSID,

}}

pub type PLSA_ADT_SID_LIST_ENTRY = *mut LSA_ADT_SID_LIST_ENTRY;

STRUCT!{struct LSA_ADT_SID_LIST {

    cSids: ULONG,

    Sid: PLSA_ADT_SID_LIST_ENTRY,

}}

pub type PLSA_ADT_SID_LIST = *mut LSA_ADT_SID_LIST;

pub const LSA_ADT_SECURITY_SOURCE_NAME: &'static str = "Microsoft-Windows-Security-Auditing";

pub const LSA_ADT_LEGACY_SECURITY_SOURCE_NAME: &'static str = "Security";

pub const SE_ADT_POLICY_AUDIT_EVENT_TYPE_EX_BEGIN: ULONG = 100;

ENUM!{enum POLICY_AUDIT_EVENT_TYPE_EX {

    iSystem_SecurityStateChange = SE_ADT_POLICY_AUDIT_EVENT_TYPE_EX_BEGIN,

    iSystem_SecuritySubsystemExtension,

    iSystem_Integrity,

    iSystem_IPSecDriverEvents,

    iSystem_Others,

    iLogon_Logon,

    iLogon_Logoff,

    iLogon_AccountLockout,

    iLogon_IPSecMainMode,

    iLogon_SpecialLogon,

    iLogon_IPSecQuickMode,

    iLogon_IPSecUsermode,

    iLogon_Others,

    iLogon_NPS,

    iLogon_Claims,

    iLogon_Groups,

    iObjectAccess_FileSystem,

    iObjectAccess_Registry,

    iObjectAccess_Kernel,

    iObjectAccess_Sam,

    iObjectAccess_Other,

    iObjectAccess_CertificationAuthority,

    iObjectAccess_ApplicationGenerated,

    iObjectAccess_HandleBasedAudits,

    iObjectAccess_Share,

    iObjectAccess_FirewallPacketDrops,

    iObjectAccess_FirewallConnection,

    iObjectAccess_DetailedFileShare,

    iObjectAccess_RemovableStorage,

    iObjectAccess_CbacStaging,

    iPrivilegeUse_Sensitive,

    iPrivilegeUse_NonSensitive,

    iPrivilegeUse_Others,

    iDetailedTracking_ProcessCreation,

    iDetailedTracking_ProcessTermination,

    iDetailedTracking_DpapiActivity,

    iDetailedTracking_RpcCall,

    iDetailedTracking_PnpActivity,

    iDetailedTracking_TokenRightAdjusted,

    iPolicyChange_AuditPolicy,

    iPolicyChange_AuthenticationPolicy,

    iPolicyChange_AuthorizationPolicy,

    iPolicyChange_MpsscvRulePolicy,

    iPolicyChange_WfpIPSecPolicy,

    iPolicyChange_Others,

    iAccountManagement_UserAccount,

    iAccountManagement_ComputerAccount,

    iAccountManagement_SecurityGroup,

    iAccountManagement_DistributionGroup,

    iAccountManagement_ApplicationGroup,

    iAccountManagement_Others,

    iDSAccess_DSAccess,

    iDSAccess_AdAuditChanges,

    iDS_Replication,

    iDS_DetailedReplication,

    iAccountLogon_CredentialValidation,

    iAccountLogon_Kerberos,

    iAccountLogon_Others,

    iAccountLogon_KerbCredentialValidation,

    iUnknownSubCategory = 999,

}}

pub type PPOLICY_AUDIT_EVENT_TYPE_EX = *mut POLICY_AUDIT_EVENT_TYPE_EX;

ENUM!{enum POLICY_AUDIT_EVENT_TYPE {

    AuditCategorySystem = 0,

    AuditCategoryLogon,

    AuditCategoryObjectAccess,

    AuditCategoryPrivilegeUse,

    AuditCategoryDetailedTracking,

    AuditCategoryPolicyChange,

    AuditCategoryAccountManagement,

    AuditCategoryDirectoryServiceAccess,

    AuditCategoryAccountLogon,

}}

pub type PPOLICY_AUDIT_EVENT_TYPE = *mut POLICY_AUDIT_EVENT_TYPE;

pub const POLICY_AUDIT_EVENT_UNCHANGED: ULONG = 0x00000000;

pub const POLICY_AUDIT_EVENT_SUCCESS: ULONG = 0x00000001;

pub const POLICY_AUDIT_EVENT_FAILURE: ULONG = 0x00000002;

pub const POLICY_AUDIT_EVENT_NONE: ULONG = 0x00000004;

pub const POLICY_AUDIT_EVENT_MASK: ULONG = POLICY_AUDIT_EVENT_SUCCESS | POLICY_AUDIT_EVENT_FAILURE

    | POLICY_AUDIT_EVENT_UNCHANGED | POLICY_AUDIT_EVENT_NONE;

#[inline]

pub fn LSA_SUCCESS(Error: NTSTATUS) -> bool {

    (Error as LONG) >= 0

extern "system" {

    pub fn LsaRegisterLogonProcess(

        LogonProcessName: PLSA_STRING,

        LsaHandle: PHANDLE,

        SecurityMode: PLSA_OPERATIONAL_MODE,

    ) -> NTSTATUS;

    pub fn LsaLogonUser(

        LsaHandle: HANDLE,

        OriginName: PLSA_STRING,

        LogonType: SECURITY_LOGON_TYPE,

        AuthenticationPackage: ULONG,

        AuthenticationInformation: PVOID,

        AuthenticationInformationLength: ULONG,

        LocalGroups: PTOKEN_GROUPS,

        SourceContext: PTOKEN_SOURCE,

        ProfileBuffer: *mut PVOID,

        ProfileBufferLength: PULONG,

        LogonId: PLUID,

        Token: PHANDLE,

        Quotas: PQUOTA_LIMITS,

        SubStatus: PNTSTATUS,

    ) -> NTSTATUS;

    pub fn LsaLookupAuthenticationPackage(

        LsaHandle: HANDLE,

        PackageName: PLSA_STRING,

        AuthenticationPackage: PULONG,

    ) -> NTSTATUS;

    pub fn LsaFreeReturnBuffer(

        Buffer: PVOID,

    ) -> NTSTATUS;

    pub fn LsaCallAuthenticationPackage(

        LsaHandle: HANDLE,

        AuthenticationPackage: ULONG,

        ProtocolSubmitBuffer: PVOID,

        SubmitBufferLength: ULONG,

        ProtocolReturnBuffer: *mut PVOID,

        ReturnBufferLength: PULONG,

        ProtocolStatus: PNTSTATUS,

    ) -> NTSTATUS;

    pub fn LsaDeregisterLogonProcess(

        LsaHandle: HANDLE,

    ) -> NTSTATUS;

    pub fn LsaConnectUntrusted(

        LsaHandle: PHANDLE,

    ) -> NTSTATUS;

extern "C" {

    pub fn LsaInsertProtectedProcessAddress(

        BufferAddress: PVOID,

        BufferSize: ULONG,

    ) -> NTSTATUS;

    pub fn LsaRemoveProtectedProcessAddress(

        BufferAddress: PVOID,

        BufferSize: ULONG,

    ) -> NTSTATUS;

FN!{stdcall PFN_LSA_CALL_AUTH_PKG(

    LsaHandle: HANDLE,

    AuthenticationPackage: ULONG,

    ProtocolSubmitBuffer: PVOID,

    SubmitBufferLength: ULONG,

    ProtocolReturnBuffer: *mut PVOID,

    ReturnBufferLength: PULONG,

    ProtocolStatus: PNTSTATUS,

) -> NTSTATUS}

FN!{stdcall PFN_LSA_DEREGISTER_PROC(

    LsaHandle: HANDLE,

) -> NTSTATUS}

FN!{stdcall PFN_LSA_FREE_BUFFER(

    Buffer: PVOID,

) -> NTSTATUS}

FN!{stdcall PFN_LSA_LOGON_USER(

    LsaHandle: HANDLE,

    OriginName: PLSA_STRING,

    LogonType: SECURITY_LOGON_TYPE,

    AuthenticationPackage: ULONG,

    AuthenticationInformation: PVOID,

    AuthenticationInformationLength: ULONG,

    LocalGroups: PTOKEN_GROUPS,

    SourceContext: PTOKEN_SOURCE,

    ProfileBuffer: *mut PVOID,

    ProfileBufferLength: PULONG,

    LogonId: PLUID,

    Token: PHANDLE,

    Quotas: PQUOTA_LIMITS,

    SubStatus: PNTSTATUS,

) -> NTSTATUS}

FN!{stdcall PFN_LOOKUP_AUTH_PKG(

    LsaHandle: HANDLE,

    PackageName: PLSA_STRING,

    AuthenticationPackage: PULONG,

) -> NTSTATUS}

FN!{stdcall PFN_LSA_REGISTER_PROC(

    LogonProcessName: PLSA_STRING,

    LsaHandle: PHANDLE,

    SecurityMode: PLSA_OPERATIONAL_MODE,

) -> NTSTATUS}

STRUCT!{struct LSA_AUTH_CALLBACKS {

    LsaCallAuthPkgFn: PFN_LSA_CALL_AUTH_PKG,

    LsaDeregisterProcFn: PFN_LSA_DEREGISTER_PROC,

    LsaFreeReturnBufferFn: PFN_LSA_FREE_BUFFER,

    LsaLogonUserFn: PFN_LSA_LOGON_USER,

    LsaLookupAuthPkgFn: PFN_LOOKUP_AUTH_PKG,

    LsaRegisterProcFn: PFN_LSA_REGISTER_PROC,

}}

pub type PLSA_AUTH_CALLBACKS = *mut LSA_AUTH_CALLBACKS;

pub type PCLSA_AUTH_CALLBACKS = *const LSA_AUTH_CALLBACKS;

pub type PLSA_CLIENT_REQUEST = *mut PVOID;

ENUM!{enum LSA_TOKEN_INFORMATION_TYPE {

    LsaTokenInformationNull,

    LsaTokenInformationV1,

    LsaTokenInformationV2,

    LsaTokenInformationV3,

}}

pub type PLSA_TOKEN_INFORMATION_TYPE = *mut LSA_TOKEN_INFORMATION_TYPE;

STRUCT!{struct LSA_TOKEN_INFORMATION_NULL {

    ExpirationTime: LARGE_INTEGER,

    Groups: PTOKEN_GROUPS,

}}

pub type PLSA_TOKEN_INFORMATION_NULL = *mut LSA_TOKEN_INFORMATION_NULL;

STRUCT!{struct LSA_TOKEN_INFORMATION_V1 {

    ExpirationTime: LARGE_INTEGER,

    User: TOKEN_USER,

    Groups: PTOKEN_GROUPS,

    PrimaryGroup: TOKEN_PRIMARY_GROUP,

    Privileges: PTOKEN_PRIVILEGES,

    Owner: TOKEN_OWNER,

    DefaultDacl: TOKEN_DEFAULT_DACL,

}}

pub type PLSA_TOKEN_INFORMATION_V1 = *mut LSA_TOKEN_INFORMATION_V1;

pub type LSA_TOKEN_INFORMATION_V2 = LSA_TOKEN_INFORMATION_V1;

pub type PLSA_TOKEN_INFORMATION_V2 = *mut LSA_TOKEN_INFORMATION_V2;

STRUCT!{struct LSA_TOKEN_INFORMATION_V3 {

    ExpirationTime: LARGE_INTEGER,

    User: TOKEN_USER,

    Groups: PTOKEN_GROUPS,

    PrimaryGroup: TOKEN_PRIMARY_GROUP,

    Privileges: PTOKEN_PRIVILEGES,

    Owner: TOKEN_OWNER,

    DefaultDacl: TOKEN_DEFAULT_DACL,

    UserClaims: TOKEN_USER_CLAIMS,

    DeviceClaims: TOKEN_DEVICE_CLAIMS,

    DeviceGroups: PTOKEN_GROUPS,

}}

pub type PLSA_TOKEN_INFORMATION_V3 = *mut LSA_TOKEN_INFORMATION_V3;

FN!{stdcall PLSA_CREATE_LOGON_SESSION(

    LogonId: PLUID,

) -> NTSTATUS}

FN!{stdcall PLSA_DELETE_LOGON_SESSION(

    LogonId: PLUID,

) -> NTSTATUS}

FN!{stdcall PLSA_ADD_CREDENTIAL(

    LogonId: PLUID,

    AuthenticationPackage: ULONG,

    PrimaryKeyValue: PLSA_STRING,

    Credentials: PLSA_STRING,

) -> NTSTATUS}

FN!{stdcall PLSA_GET_CREDENTIALS(

    LogonId: PLUID,

    AuthenticationPackage: ULONG,

    QueryContext: PULONG,

    RetrieveAllCredentials: BOOLEAN,

    PrimaryKeyValue: PLSA_STRING,

    PrimaryKeyLength: PULONG,

    Credentials: PLSA_STRING,

) -> NTSTATUS}

FN!{stdcall PLSA_DELETE_CREDENTIAL(

    LogonId: PLUID,

    AuthenticationPackage: ULONG,

    PrimaryKeyValue: PLSA_STRING,

) -> NTSTATUS}

FN!{stdcall PLSA_ALLOCATE_LSA_HEAP(

    Length: ULONG,

) -> PVOID}

FN!{stdcall PLSA_FREE_LSA_HEAP(

    Base: PVOID,

) -> ()}

FN!{stdcall PLSA_ALLOCATE_PRIVATE_HEAP(

    Length: SIZE_T,

) -> PVOID}

FN!{stdcall PLSA_FREE_PRIVATE_HEAP(

    Base: PVOID,

) -> ()}

FN!{stdcall PLSA_ALLOCATE_CLIENT_BUFFER(

    ClientRequest: PLSA_CLIENT_REQUEST,

    LengthRequired: ULONG,

    ClientBaseAddress: *mut PVOID,

) -> NTSTATUS}

FN!{stdcall PLSA_FREE_CLIENT_BUFFER(

    ClientRequest: PLSA_CLIENT_REQUEST,

    ClientBaseAddress: PVOID,

) -> NTSTATUS}

FN!{stdcall PLSA_COPY_TO_CLIENT_BUFFER(

    ClientRequest: PLSA_CLIENT_REQUEST,

    Length: ULONG,

    ClientBaseAddress: PVOID,

    BufferToCopy: PVOID,

) -> NTSTATUS}

FN!{stdcall PLSA_COPY_FROM_CLIENT_BUFFER(

    ClientRequest: PLSA_CLIENT_REQUEST,

    Length: ULONG,

    BufferToCopy: PVOID,

    ClientBaseAddress: PVOID,

) -> NTSTATUS}

STRUCT!{struct LSA_DISPATCH_TABLE {

    CreateLogonSession: PLSA_CREATE_LOGON_SESSION,

    DeleteLogonSession: PLSA_DELETE_LOGON_SESSION,

    AddCredential: PLSA_ADD_CREDENTIAL,

    GetCredentials: PLSA_GET_CREDENTIALS,

    DeleteCredential: PLSA_DELETE_CREDENTIAL,

    AllocateLsaHeap: PLSA_ALLOCATE_LSA_HEAP,

    FreeLsaHeap: PLSA_FREE_LSA_HEAP,

    AllocateClientBuffer: PLSA_ALLOCATE_CLIENT_BUFFER,

    FreeClientBuffer: PLSA_FREE_CLIENT_BUFFER,

    CopyToClientBuffer: PLSA_COPY_TO_CLIENT_BUFFER,

    CopyFromClientBuffer: PLSA_COPY_FROM_CLIENT_BUFFER,

}}

pub type PLSA_DISPATCH_TABLE = *mut LSA_DISPATCH_TABLE;

pub const LSA_AP_NAME_INITIALIZE_PACKAGE: &'static str = "LsaApInitializePackage";

pub const LSA_AP_NAME_LOGON_USER: &'static str = "LsaApLogonUser";

pub const LSA_AP_NAME_LOGON_USER_EX: &'static str = "LsaApLogonUserEx";

pub const LSA_AP_NAME_CALL_PACKAGE: &'static str = "LsaApCallPackage";

pub const LSA_AP_NAME_LOGON_TERMINATED: &'static str = "LsaApLogonTerminated";

pub const LSA_AP_NAME_CALL_PACKAGE_UNTRUSTED: &'static str = "LsaApCallPackageUntrusted";

pub const LSA_AP_NAME_CALL_PACKAGE_PASSTHROUGH: &'static str = "LsaApCallPackagePassthrough";

FN!{stdcall PLSA_AP_INITIALIZE_PACKAGE(

    AuthenticationPackageId: ULONG,

    LsaDispatchTable: PLSA_DISPATCH_TABLE,

    Database: PLSA_STRING,

    Confidentiality: PLSA_STRING,

    AuthenticationPackageName: *mut PLSA_STRING,

) -> NTSTATUS}

FN!{stdcall PLSA_AP_LOGON_USER(

    ClientRequest: PLSA_CLIENT_REQUEST,

    LogonType: SECURITY_LOGON_TYPE,

    AuthenticationInformation: PVOID,

    ClientAuthentication: PVOID,

    AuthenticationInformationLength: ULONG,

    ProfileBuffer: *mut PVOID,

    ProfileBufferLength: PULONG,

    LogonId: PLUID,

    SubStatus: PNTSTATUS,

    TokenInformationType: PLSA_TOKEN_INFORMATION_TYPE,

    TokenInformation: *mut PVOID,

    AccountName: *mut PLSA_UNICODE_STRING,

    AuthenticatingAutority: *mut PLSA_UNICODE_STRING,

) -> NTSTATUS}

FN!{stdcall PLSA_AP_LOGON_USER_EX(

    ClientRequest: PLSA_CLIENT_REQUEST,

    LogonType: SECURITY_LOGON_TYPE,

    AuthenticationInformation: PVOID,

    ClientAuthentication: PVOID,

    AuthenticationInformationLength: ULONG,

    ProfileBuffer: *mut PVOID,

    ProfileBufferLength: PULONG,

    LogonId: PLUID,

    SubStatus: PNTSTATUS,

    TokenInformationType: PLSA_TOKEN_INFORMATION_TYPE,

    TokenInformation: *mut PVOID,

    AccountName: *mut PLSA_UNICODE_STRING,

    AuthenticatingAutority: *mut PLSA_UNICODE_STRING,

    MachineName: *mut PUNICODE_STRING,

) -> NTSTATUS}

FN!{stdcall PLSA_AP_CALL_PACKAGE(

    ClientRequest: PLSA_CLIENT_REQUEST,

    ProtocolSubmitBuffer: PVOID,

    ClientBufferBase: PVOID,

    SubmitBufferLength: ULONG,

    ProtocolReturnBuffer: *mut PVOID,

    ReturnBufferLength: PULONG,

    ProtocolStatus: PNTSTATUS,

) -> NTSTATUS}

FN!{stdcall PLSA_AP_CALL_PACKAGE_PASSTHROUGH(

    ClientRequest: PLSA_CLIENT_REQUEST,

    ProtocolSubmitBuffer: PVOID,

    ClientBufferBase: PVOID,

    SubmitBufferLength: ULONG,

    ProtocolReturnBuffer: *mut PVOID,

    ReturnBufferLength: PULONG,

    ProtocolStatus: PNTSTATUS,

) -> NTSTATUS}

FN!{stdcall PLSA_AP_LOGON_TERMINATED(

    LogonId: PLUID,

) -> ()}

pub const POLICY_VIEW_LOCAL_INFORMATION: ULONG = 0x00000001;

pub const POLICY_VIEW_AUDIT_INFORMATION: ULONG = 0x00000002;

pub const POLICY_GET_PRIVATE_INFORMATION: ULONG = 0x00000004;

pub const POLICY_TRUST_ADMIN: ULONG = 0x00000008;

pub const POLICY_CREATE_ACCOUNT: ULONG = 0x00000010;

pub const POLICY_CREATE_SECRET: ULONG = 0x00000020;

pub const POLICY_CREATE_PRIVILEGE: ULONG = 0x00000040;

pub const POLICY_SET_DEFAULT_QUOTA_LIMITS: ULONG = 0x00000080;

pub const POLICY_SET_AUDIT_REQUIREMENTS: ULONG = 0x00000100;

pub const POLICY_AUDIT_LOG_ADMIN: ULONG = 0x00000200;

pub const POLICY_SERVER_ADMIN: ULONG = 0x00000400;

pub const POLICY_LOOKUP_NAMES: ULONG = 0x00000800;

pub const POLICY_NOTIFICATION: ULONG = 0x00001000;

pub const POLICY_ALL_ACCESS: ULONG = STANDARD_RIGHTS_REQUIRED | POLICY_VIEW_LOCAL_INFORMATION

    | POLICY_VIEW_AUDIT_INFORMATION | POLICY_GET_PRIVATE_INFORMATION | POLICY_TRUST_ADMIN

    | POLICY_CREATE_ACCOUNT | POLICY_CREATE_SECRET | POLICY_CREATE_PRIVILEGE

    | POLICY_SET_DEFAULT_QUOTA_LIMITS | POLICY_SET_AUDIT_REQUIREMENTS | POLICY_AUDIT_LOG_ADMIN

    | POLICY_SERVER_ADMIN | POLICY_LOOKUP_NAMES;

pub const POLICY_READ: ULONG = STANDARD_RIGHTS_READ | POLICY_VIEW_AUDIT_INFORMATION

    | POLICY_GET_PRIVATE_INFORMATION;

pub const POLICY_WRITE: ULONG = STANDARD_RIGHTS_WRITE | POLICY_TRUST_ADMIN | POLICY_CREATE_ACCOUNT

    | POLICY_CREATE_SECRET | POLICY_CREATE_PRIVILEGE | POLICY_SET_DEFAULT_QUOTA_LIMITS

    | POLICY_SET_AUDIT_REQUIREMENTS | POLICY_AUDIT_LOG_ADMIN | POLICY_SERVER_ADMIN;

pub const POLICY_EXECUTE: ULONG = STANDARD_RIGHTS_EXECUTE | POLICY_VIEW_LOCAL_INFORMATION

    | POLICY_LOOKUP_NAMES;

STRUCT!{struct LSA_TRANSLATED_SID {

    Use: SID_NAME_USE,

    RelativeId: ULONG,

    DomainIndex: LONG,

}}

pub type PLSA_TRANSLATED_SID = *mut LSA_TRANSLATED_SID;

pub type POLICY_SYSTEM_ACCESS_MODE = ULONG;

pub type PPOLICY_SYSTEM_ACCESS_MODE = *mut POLICY_SYSTEM_ACCESS_MODE;

pub const POLICY_MODE_INTERACTIVE: ULONG = SECURITY_ACCESS_INTERACTIVE_LOGON;

pub const POLICY_MODE_NETWORK: ULONG = SECURITY_ACCESS_NETWORK_LOGON;

pub const POLICY_MODE_BATCH: ULONG = SECURITY_ACCESS_BATCH_LOGON;

pub const POLICY_MODE_SERVICE: ULONG = SECURITY_ACCESS_SERVICE_LOGON;

pub const POLICY_MODE_PROXY: ULONG = SECURITY_ACCESS_PROXY_LOGON;

pub const POLICY_MODE_DENY_INTERACTIVE: ULONG = SECURITY_ACCESS_DENY_INTERACTIVE_LOGON;

pub const POLICY_MODE_DENY_NETWORK: ULONG = SECURITY_ACCESS_DENY_NETWORK_LOGON;

pub const POLICY_MODE_DENY_BATCH: ULONG = SECURITY_ACCESS_DENY_BATCH_LOGON;

pub const POLICY_MODE_DENY_SERVICE: ULONG = SECURITY_ACCESS_DENY_SERVICE_LOGON;

pub const POLICY_MODE_REMOTE_INTERACTIVE: ULONG = SECURITY_ACCESS_REMOTE_INTERACTIVE_LOGON;

pub const POLICY_MODE_DENY_REMOTE_INTERACTIVE: ULONG =

    SECURITY_ACCESS_DENY_REMOTE_INTERACTIVE_LOGON;

pub const POLICY_MODE_ALL: ULONG = POLICY_MODE_INTERACTIVE | POLICY_MODE_NETWORK

    | POLICY_MODE_BATCH | POLICY_MODE_SERVICE | POLICY_MODE_PROXY | POLICY_MODE_DENY_INTERACTIVE

    | POLICY_MODE_DENY_NETWORK | SECURITY_ACCESS_DENY_BATCH_LOGON

    | SECURITY_ACCESS_DENY_SERVICE_LOGON | POLICY_MODE_REMOTE_INTERACTIVE

    | POLICY_MODE_DENY_REMOTE_INTERACTIVE ;

pub const POLICY_MODE_ALL_NT4: ULONG = POLICY_MODE_INTERACTIVE | POLICY_MODE_NETWORK

    | POLICY_MODE_BATCH | POLICY_MODE_SERVICE;

ENUM!{enum POLICY_LSA_SERVER_ROLE {

    PolicyServerRoleBackup = 2,

    PolicyServerRolePrimary,

}}

pub type PPOLICY_LSA_SERVER_ROLE = *mut POLICY_LSA_SERVER_ROLE;

ENUM!{enum POLICY_SERVER_ENABLE_STATE {

    PolicyServerEnabled = 2,

    PolicyServerDisabled,

}}

pub type PPOLICY_SERVER_ENABLE_STATE = *mut POLICY_SERVER_ENABLE_STATE;

pub type POLICY_AUDIT_EVENT_OPTIONS = ULONG;

pub type PPOLICY_AUDIT_EVENT_OPTIONS = *mut POLICY_AUDIT_EVENT_OPTIONS;

STRUCT!{struct POLICY_PRIVILEGE_DEFINITION {

    Name: LSA_UNICODE_STRING,

    LocalValue: LUID,

}}

pub type PPOLICY_PRIVILEGE_DEFINITION = *mut POLICY_PRIVILEGE_DEFINITION;

pub const LSA_LOOKUP_ISOLATED_AS_LOCAL: ULONG = 0x80000000;

pub const LSA_LOOKUP_DISALLOW_CONNECTED_ACCOUNT_INTERNET_SID: ULONG = 0x80000000;

pub const LSA_LOOKUP_PREFER_INTERNET_NAMES: ULONG = 0x40000000;

ENUM!{enum POLICY_INFORMATION_CLASS {

    PolicyAuditLogInformation = 1,

    PolicyAuditEventsInformation,

    PolicyPrimaryDomainInformation,

    PolicyPdAccountInformation,

    PolicyAccountDomainInformation,

    PolicyLsaServerRoleInformation,

    PolicyReplicaSourceInformation,

    PolicyDefaultQuotaInformation,

    PolicyModificationInformation,

    PolicyAuditFullSetInformation,

    PolicyAuditFullQueryInformation,

    PolicyDnsDomainInformation,

    PolicyDnsDomainInformationInt,

    PolicyLocalAccountDomainInformation,

    PolicyLastEntry,

}}

pub type PPOLICY_INFORMATION_CLASS = *mut POLICY_INFORMATION_CLASS;

STRUCT!{struct POLICY_AUDIT_LOG_INFO {

    AuditLogPercentFull: ULONG,

    MaximumLogSize: ULONG,

    AuditRetentionPeriod: LARGE_INTEGER,

    AuditLogFullShutdownInProgress: BOOLEAN,

    TimeToShutdown: LARGE_INTEGER,

    NextAuditRecordId: ULONG,

}}

pub type PPOLICY_AUDIT_LOG_INFO = *mut POLICY_AUDIT_LOG_INFO;

STRUCT!{struct POLICY_AUDIT_EVENTS_INFO {

    AuditingMode: BOOLEAN,

    EventAuditingOptions: PPOLICY_AUDIT_EVENT_OPTIONS,

    MaximumAuditEventCount: ULONG,

}}

pub type PPOLICY_AUDIT_EVENTS_INFO = *mut POLICY_AUDIT_EVENTS_INFO;

STRUCT!{struct POLICY_AUDIT_SUBCATEGORIES_INFO {

    MaximumSubCategoryCount: ULONG,

    EventAuditingOptions: PPOLICY_AUDIT_EVENT_OPTIONS,

}}

pub type PPOLICY_AUDIT_SUBCATEGORIES_INFO = *mut POLICY_AUDIT_SUBCATEGORIES_INFO;

STRUCT!{struct POLICY_AUDIT_CATEGORIES_INFO {

    MaximumCategoryCount: ULONG,

    SubCategoriesInfo: PPOLICY_AUDIT_SUBCATEGORIES_INFO,

}}

pub type PPOLICY_AUDIT_CATEGORIES_INFO = *mut POLICY_AUDIT_CATEGORIES_INFO;

pub const PER_USER_POLICY_UNCHANGED: UCHAR = 0x00;

pub const PER_USER_AUDIT_SUCCESS_INCLUDE: UCHAR = 0x01;

pub const PER_USER_AUDIT_SUCCESS_EXCLUDE: UCHAR = 0x02;

pub const PER_USER_AUDIT_FAILURE_INCLUDE: UCHAR = 0x04;

pub const PER_USER_AUDIT_FAILURE_EXCLUDE: UCHAR = 0x08;

pub const PER_USER_AUDIT_NONE: UCHAR = 0x10;

pub const VALID_PER_USER_AUDIT_POLICY_FLAG: UCHAR = PER_USER_AUDIT_SUCCESS_INCLUDE

    | PER_USER_AUDIT_SUCCESS_EXCLUDE | PER_USER_AUDIT_FAILURE_INCLUDE

    | PER_USER_AUDIT_FAILURE_EXCLUDE | PER_USER_AUDIT_NONE;

STRUCT!{struct POLICY_PRIMARY_DOMAIN_INFO {

    Name: LSA_UNICODE_STRING,

    Sid: PSID,

}}

pub type PPOLICY_PRIMARY_DOMAIN_INFO = *mut POLICY_PRIMARY_DOMAIN_INFO;

STRUCT!{struct POLICY_PD_ACCOUNT_INFO {

    Name: LSA_UNICODE_STRING,

}}

pub type PPOLICY_PD_ACCOUNT_INFO = *mut POLICY_PD_ACCOUNT_INFO;

STRUCT!{struct POLICY_LSA_SERVER_ROLE_INFO {

    LsaServerRole: POLICY_LSA_SERVER_ROLE,

}}

pub type PPOLICY_LSA_SERVER_ROLE_INFO = *mut POLICY_LSA_SERVER_ROLE_INFO;

STRUCT!{struct POLICY_REPLICA_SOURCE_INFO {

    ReplicaSource: LSA_UNICODE_STRING,

    ReplicaAccountName: LSA_UNICODE_STRING,

}}

pub type PPOLICY_REPLICA_SOURCE_INFO = *mut POLICY_REPLICA_SOURCE_INFO;

STRUCT!{struct POLICY_DEFAULT_QUOTA_INFO {

    QuotaLimits: QUOTA_LIMITS,

}}

pub type PPOLICY_DEFAULT_QUOTA_INFO = *mut POLICY_DEFAULT_QUOTA_INFO;

STRUCT!{struct POLICY_MODIFICATION_INFO {

    ModifiedId: LARGE_INTEGER,

    DatabaseCreationTime: LARGE_INTEGER,

}}

pub type PPOLICY_MODIFICATION_INFO = *mut POLICY_MODIFICATION_INFO;

STRUCT!{struct POLICY_AUDIT_FULL_SET_INFO {

    ShutDownOnFull: BOOLEAN,

}}

pub type PPOLICY_AUDIT_FULL_SET_INFO = *mut POLICY_AUDIT_FULL_SET_INFO;

STRUCT!{struct POLICY_AUDIT_FULL_QUERY_INFO {

    ShutDownOnFull: BOOLEAN,

    LogIsFull: BOOLEAN,

}}

pub type PPOLICY_AUDIT_FULL_QUERY_INFO = *mut POLICY_AUDIT_FULL_QUERY_INFO;

ENUM!{enum POLICY_DOMAIN_INFORMATION_CLASS {

    PolicyDomainEfsInformation = 2,

    PolicyDomainKerberosTicketInformation,

}}

pub type PPOLICY_DOMAIN_INFORMATION_CLASS = *mut POLICY_DOMAIN_INFORMATION_CLASS;

pub const POLICY_QOS_SCHANNEL_REQUIRED: ULONG = 0x00000001;

pub const POLICY_QOS_OUTBOUND_INTEGRITY: ULONG = 0x00000002;

pub const POLICY_QOS_OUTBOUND_CONFIDENTIALITY: ULONG = 0x00000004;

pub const POLICY_QOS_INBOUND_INTEGRITY: ULONG = 0x00000008;

pub const POLICY_QOS_INBOUND_CONFIDENTIALITY: ULONG = 0x00000010;

pub const POLICY_QOS_ALLOW_LOCAL_ROOT_CERT_STORE: ULONG = 0x00000020;

pub const POLICY_QOS_RAS_SERVER_ALLOWED: ULONG = 0x00000040;

pub const POLICY_QOS_DHCP_SERVER_ALLOWED: ULONG = 0x00000080;

STRUCT!{struct POLICY_DOMAIN_EFS_INFO {

    InfoLength: ULONG,

    EfsBlob: PUCHAR,

}}

pub type PPOLICY_DOMAIN_EFS_INFO = *mut POLICY_DOMAIN_EFS_INFO;

pub const POLICY_KERBEROS_VALIDATE_CLIENT: ULONG = 0x00000080;

STRUCT!{struct POLICY_DOMAIN_KERBEROS_TICKET_INFO {

    AuthenticationOptions: ULONG,

    MaxServiceTicketAge: LARGE_INTEGER,

    MaxTicketAge: LARGE_INTEGER,

    MaxRenewAge: LARGE_INTEGER,

    MaxClockSkew: LARGE_INTEGER,

    Reserved: LARGE_INTEGER,

}}

pub type PPOLICY_DOMAIN_KERBEROS_TICKET_INFO = *mut POLICY_DOMAIN_KERBEROS_TICKET_INFO;

ENUM!{enum POLICY_NOTIFICATION_INFORMATION_CLASS {

    PolicyNotifyAuditEventsInformation = 1,

    PolicyNotifyAccountDomainInformation,

    PolicyNotifyServerRoleInformation,

    PolicyNotifyDnsDomainInformation,

    PolicyNotifyDomainEfsInformation,

    PolicyNotifyDomainKerberosTicketInformation,

    PolicyNotifyMachineAccountPasswordInformation,

    PolicyNotifyGlobalSaclInformation,

    PolicyNotifyMax,

}}

pub type PPOLICY_NOTIFICATION_INFORMATION_CLASS = *mut POLICY_NOTIFICATION_INFORMATION_CLASS;

pub const ACCOUNT_VIEW: ULONG = 0x00000001;

pub const ACCOUNT_ADJUST_PRIVILEGES: ULONG = 0x00000002;

pub const ACCOUNT_ADJUST_QUOTAS: ULONG = 0x00000004;

pub const ACCOUNT_ADJUST_SYSTEM_ACCESS: ULONG = 0x00000008;

pub const ACCOUNT_ALL_ACCESS: ULONG = STANDARD_RIGHTS_REQUIRED | ACCOUNT_VIEW

    | ACCOUNT_ADJUST_PRIVILEGES | ACCOUNT_ADJUST_QUOTAS | ACCOUNT_ADJUST_SYSTEM_ACCESS;

pub const ACCOUNT_READ: ULONG = STANDARD_RIGHTS_READ | ACCOUNT_VIEW;

pub const ACCOUNT_WRITE: ULONG = STANDARD_RIGHTS_WRITE | ACCOUNT_ADJUST_PRIVILEGES

    | ACCOUNT_ADJUST_QUOTAS | ACCOUNT_ADJUST_SYSTEM_ACCESS;

pub const ACCOUNT_EXECUTE: ULONG = STANDARD_RIGHTS_EXECUTE;

DECLARE_HANDLE!{LSA_HANDLE, __LSA_HANDLE}

pub const TRUSTED_QUERY_DOMAIN_NAME: ULONG = 0x00000001;

pub const TRUSTED_QUERY_CONTROLLERS: ULONG = 0x00000002;

pub const TRUSTED_SET_CONTROLLERS: ULONG = 0x00000004;

pub const TRUSTED_QUERY_POSIX: ULONG = 0x00000008;

pub const TRUSTED_SET_POSIX: ULONG = 0x00000010;

pub const TRUSTED_SET_AUTH: ULONG = 0x00000020;

pub const TRUSTED_QUERY_AUTH: ULONG = 0x00000040;

pub const TRUSTED_ALL_ACCESS: ULONG = STANDARD_RIGHTS_REQUIRED | TRUSTED_QUERY_DOMAIN_NAME

    | TRUSTED_QUERY_CONTROLLERS | TRUSTED_SET_CONTROLLERS | TRUSTED_QUERY_POSIX | TRUSTED_SET_POSIX

    | TRUSTED_SET_AUTH | TRUSTED_QUERY_AUTH;

pub const TRUSTED_READ: ULONG = STANDARD_RIGHTS_READ | TRUSTED_QUERY_DOMAIN_NAME;

pub const TRUSTED_WRITE: ULONG = STANDARD_RIGHTS_WRITE | TRUSTED_SET_CONTROLLERS

    | TRUSTED_SET_POSIX | TRUSTED_SET_AUTH;

pub const TRUSTED_EXECUTE: ULONG = STANDARD_RIGHTS_EXECUTE | TRUSTED_QUERY_CONTROLLERS

    | TRUSTED_QUERY_POSIX;

ENUM!{enum TRUSTED_INFORMATION_CLASS {

    TrustedDomainNameInformation = 1,

    TrustedControllersInformation,

    TrustedPosixOffsetInformation,

    TrustedPasswordInformation,

    TrustedDomainInformationBasic,

    TrustedDomainInformationEx,

    TrustedDomainAuthInformation,

    TrustedDomainFullInformation,

    TrustedDomainAuthInformationInternal,

    TrustedDomainFullInformationInternal,

    TrustedDomainInformationEx2Internal,

    TrustedDomainFullInformation2Internal,

    TrustedDomainSupportedEncryptionTypes,

}}

pub type PTRUSTED_INFORMATION_CLASS = *mut TRUSTED_INFORMATION_CLASS;

STRUCT!{struct TRUSTED_DOMAIN_NAME_INFO {

    Name: LSA_UNICODE_STRING,

}}

pub type PTRUSTED_DOMAIN_NAME_INFO = *mut TRUSTED_DOMAIN_NAME_INFO;

STRUCT!{struct TRUSTED_CONTROLLERS_INFO {

    Entries: ULONG,

    Names: PLSA_UNICODE_STRING,

}}

pub type PTRUSTED_CONTROLLERS_INFO = *mut TRUSTED_CONTROLLERS_INFO;

STRUCT!{struct TRUSTED_POSIX_OFFSET_INFO {

    Offset: ULONG,

}}

pub type PTRUSTED_POSIX_OFFSET_INFO = *mut TRUSTED_POSIX_OFFSET_INFO;

STRUCT!{struct TRUSTED_PASSWORD_INFO {

    Password: LSA_UNICODE_STRING,

    OldPassword: LSA_UNICODE_STRING,

}}

pub type PTRUSTED_PASSWORD_INFO = *mut TRUSTED_PASSWORD_INFO;

pub type TRUSTED_DOMAIN_INFORMATION_BASIC = LSA_TRUST_INFORMATION;

pub type PTRUSTED_DOMAIN_INFORMATION_BASIC = PLSA_TRUST_INFORMATION;

// NOTE: Ignoring Win XP constants

pub const TRUST_DIRECTION_DISABLED: ULONG = 0x00000000;

pub const TRUST_DIRECTION_INBOUND: ULONG = 0x00000001;

pub const TRUST_DIRECTION_OUTBOUND: ULONG = 0x00000002;

pub const TRUST_DIRECTION_BIDIRECTIONAL: ULONG = TRUST_DIRECTION_INBOUND

    | TRUST_DIRECTION_OUTBOUND;

pub const TRUST_TYPE_DOWNLEVEL: ULONG = 0x00000001;

pub const TRUST_TYPE_UPLEVEL: ULONG = 0x00000002;

pub const TRUST_TYPE_MIT: ULONG = 0x00000003;

pub const TRUST_ATTRIBUTE_NON_TRANSITIVE: ULONG = 0x00000001;

pub const TRUST_ATTRIBUTE_UPLEVEL_ONLY: ULONG = 0x00000002;

pub const TRUST_ATTRIBUTE_QUARANTINED_DOMAIN: ULONG = 0x00000004;

pub const TRUST_ATTRIBUTE_FOREST_TRANSITIVE: ULONG = 0x00000008;

pub const TRUST_ATTRIBUTE_CROSS_ORGANIZATION: ULONG = 0x00000010;

pub const TRUST_ATTRIBUTE_WITHIN_FOREST: ULONG = 0x00000020;

pub const TRUST_ATTRIBUTE_TREAT_AS_EXTERNAL: ULONG = 0x00000040;

pub const TRUST_ATTRIBUTE_TRUST_USES_RC4_ENCRYPTION: ULONG = 0x00000080;

pub const TRUST_ATTRIBUTE_TRUST_USES_AES_KEYS: ULONG = 0x00000100;

pub const TRUST_ATTRIBUTE_CROSS_ORGANIZATION_NO_TGT_DELEGATION: ULONG = 0x00000200;

pub const TRUST_ATTRIBUTE_PIM_TRUST: ULONG = 0x00000400;

pub const TRUST_ATTRIBUTES_VALID: ULONG = 0xFF03FFFF;

pub const TRUST_ATTRIBUTES_USER: ULONG = 0xFF000000;

STRUCT!{struct TRUSTED_DOMAIN_INFORMATION_EX {

    Name: LSA_UNICODE_STRING,

    FlatName: LSA_UNICODE_STRING,

    Sid: PSID,

    TrustDirection: ULONG,

    TrustType: ULONG,

    TrustAttributes: ULONG,

}}

pub type PTRUSTED_DOMAIN_INFORMATION_EX = *mut TRUSTED_DOMAIN_INFORMATION_EX;

STRUCT!{struct TRUSTED_DOMAIN_INFORMATION_EX2 {

    Name: LSA_UNICODE_STRING,

    FlatName: LSA_UNICODE_STRING,

    Sid: PSID,

    TrustDirection: ULONG,

    TrustType: ULONG,

    TrustAttributes: ULONG,

    ForestTrustLength: ULONG,

    ForestTrustInfo: PUCHAR,

}}

pub type PTRUSTED_DOMAIN_INFORMATION_EX2 = *mut TRUSTED_DOMAIN_INFORMATION_EX2;

pub const TRUST_AUTH_TYPE_NONE: ULONG = 0;

pub const TRUST_AUTH_TYPE_NT4OWF: ULONG = 1;

pub const TRUST_AUTH_TYPE_CLEAR: ULONG = 2;

pub const TRUST_AUTH_TYPE_VERSION: ULONG = 3;

STRUCT!{struct LSA_AUTH_INFORMATION {

    LastUpdateTime: LARGE_INTEGER,

    AuthType: ULONG,

    AuthInfoLength: ULONG,

    AuthInfo: PUCHAR,

}}

pub type PLSA_AUTH_INFORMATION = *mut LSA_AUTH_INFORMATION;

STRUCT!{struct TRUSTED_DOMAIN_AUTH_INFORMATION {

    IncomingAuthInfos: ULONG,

    IncomingAuthenticationInformation: PLSA_AUTH_INFORMATION,

    IncomingPreviousAuthenticationInformation: PLSA_AUTH_INFORMATION,

    OutgoingAuthInfos: ULONG,

    OutgoingAuthenticationInformation: PLSA_AUTH_INFORMATION,

    OutgoingPreviousAuthenticationInformation: PLSA_AUTH_INFORMATION,

}}

pub type PTRUSTED_DOMAIN_AUTH_INFORMATION = *mut TRUSTED_DOMAIN_AUTH_INFORMATION;

STRUCT!{struct TRUSTED_DOMAIN_FULL_INFORMATION {

    Information: TRUSTED_DOMAIN_INFORMATION_EX,

    PosixOffset: TRUSTED_POSIX_OFFSET_INFO,

    AuthInformation: TRUSTED_DOMAIN_AUTH_INFORMATION,

}}

pub type PTRUSTED_DOMAIN_FULL_INFORMATION = *mut TRUSTED_DOMAIN_FULL_INFORMATION;

STRUCT!{struct TRUSTED_DOMAIN_FULL_INFORMATION2 {

    Information: TRUSTED_DOMAIN_INFORMATION_EX2,

    PosixOffset: TRUSTED_POSIX_OFFSET_INFO,

    AuthInformation: TRUSTED_DOMAIN_AUTH_INFORMATION,

}}

pub type PTRUSTED_DOMAIN_FULL_INFORMATION2 = *mut TRUSTED_DOMAIN_FULL_INFORMATION2;

STRUCT!{struct TRUSTED_DOMAIN_SUPPORTED_ENCRYPTION_TYPES {

    SupportedEncryptionTypes: ULONG,

}}

pub type PTRUSTED_DOMAIN_SUPPORTED_ENCRYPTION_TYPES =

    *mut TRUSTED_DOMAIN_SUPPORTED_ENCRYPTION_TYPES;

ENUM!{enum LSA_FOREST_TRUST_RECORD_TYPE {

    ForestTrustTopLevelName,

    ForestTrustTopLevelNameEx,

    ForestTrustDomainInfo,

    ForestTrustRecordTypeLast = ForestTrustDomainInfo,

}}

pub const LSA_FTRECORD_DISABLED_REASONS: ULONG = 0x0000FFFF;

pub const LSA_TLN_DISABLED_NEW: ULONG = 0x00000001;

pub const LSA_TLN_DISABLED_ADMIN: ULONG = 0x00000002;

pub const LSA_TLN_DISABLED_CONFLICT: ULONG = 0x00000004;

pub const LSA_SID_DISABLED_ADMIN: ULONG = 0x00000001;

pub const LSA_SID_DISABLED_CONFLICT: ULONG = 0x00000002;

pub const LSA_NB_DISABLED_ADMIN: ULONG = 0x00000004;

pub const LSA_NB_DISABLED_CONFLICT: ULONG = 0x00000008;

STRUCT!{struct LSA_FOREST_TRUST_DOMAIN_INFO {

    Sid: PSID,

    DnsName: LSA_UNICODE_STRING,

    NetbiosName: LSA_UNICODE_STRING,

}}

pub type PLSA_FOREST_TRUST_DOMAIN_INFO = *mut LSA_FOREST_TRUST_DOMAIN_INFO;

pub const MAX_FOREST_TRUST_BINARY_DATA_SIZE: SIZE_T = 128 * 1024;

STRUCT!{struct LSA_FOREST_TRUST_BINARY_DATA {

    Length: ULONG,

    Buffer: PUCHAR,

}}

pub type PLSA_FOREST_TRUST_BINARY_DATA = *mut LSA_FOREST_TRUST_BINARY_DATA;

UNION!{union LSA_FOREST_TRUST_RECORD_FORESTTRUSTDATA {

    [u32; 5] [u64; 5],

    TopLevelName TopLevelName_mut: LSA_UNICODE_STRING,

    DomainInfo DomainInfo_mut: LSA_FOREST_TRUST_DOMAIN_INFO,

    Data Data_mut: LSA_FOREST_TRUST_BINARY_DATA,

}}

STRUCT!{struct LSA_FOREST_TRUST_RECORD {

    Flags: ULONG,

    ForestTrustType: LSA_FOREST_TRUST_RECORD_TYPE,

    Time: LARGE_INTEGER,

    ForestTrustData: LSA_FOREST_TRUST_RECORD_FORESTTRUSTDATA,

}}

pub type PLSA_FOREST_TRUST_RECORD = *mut LSA_FOREST_TRUST_RECORD;

pub const MAX_RECORDS_IN_FOREST_TRUST_INFO: SIZE_T = 4000;

STRUCT!{struct LSA_FOREST_TRUST_INFORMATION {

    RecordCount: ULONG,

    Entries: *mut PLSA_FOREST_TRUST_RECORD,

}}

pub type PLSA_FOREST_TRUST_INFORMATION = LSA_FOREST_TRUST_INFORMATION;

ENUM!{enum LSA_FOREST_TRUST_COLLISION_RECORD_TYPE {

    CollisionTdo,

    CollisionXref,

    CollisionOther,

}}

STRUCT!{struct LSA_FOREST_TRUST_COLLISION_RECORD {

    Index: ULONG,

    Type: LSA_FOREST_TRUST_COLLISION_RECORD_TYPE,

    Flags: ULONG,

    Name: LSA_UNICODE_STRING,

}}

pub type PLSA_FOREST_TRUST_COLLISION_RECORD = *mut LSA_FOREST_TRUST_COLLISION_RECORD;

STRUCT!{struct LSA_FOREST_TRUST_COLLISION_INFORMATION {

    RecordCount: ULONG,

    Entries: *mut PLSA_FOREST_TRUST_COLLISION_RECORD,

}}

pub type PLSA_FOREST_TRUST_COLLISION_INFORMATION = *mut LSA_FOREST_TRUST_COLLISION_INFORMATION;

pub const SECRET_SET_VALUE: ULONG = 0x00000001;

pub const SECRET_QUERY_VALUE: ULONG = 0x00000002;

pub const SECRET_ALL_ACCESS: ULONG = STANDARD_RIGHTS_REQUIRED | SECRET_SET_VALUE

    | SECRET_QUERY_VALUE;

pub const SECRET_READ: ULONG = STANDARD_RIGHTS_READ | SECRET_QUERY_VALUE;

pub const SECRET_WRITE: ULONG = STANDARD_RIGHTS_WRITE | SECRET_SET_VALUE;

pub const SECRET_EXECUTE: ULONG = STANDARD_RIGHTS_EXECUTE;

pub const LSA_GLOBAL_SECRET_PREFIX: &'static str = "G$";

pub const LSA_GLOBAL_SECRET_PREFIX_LENGTH: SIZE_T = 2;

pub const LSA_LOCAL_SECRET_PREFIX: &'static str = "L$";

pub const LSA_LOCAL_SECRET_PREFIX_LENGTH: SIZE_T = 2;

pub const LSA_MACHINE_SECRET_PREFIX: &'static str = "M$";

pub const LSA_MACHINE_SECRET_PREFIX_LENGTH: SIZE_T = 2;

pub const LSA_SECRET_MAXIMUM_COUNT: SIZE_T = 0x00001000;

pub const LSA_SECRET_MAXIMUM_LENGTH: SIZE_T = 0x00000200;

DECLARE_HANDLE!{LSA_ENUMERATION_HANDLE, __LSA_ENUMERATION_HANDLE}

pub type PLSA_ENUMERATION_HANDLE = *mut LSA_ENUMERATION_HANDLE;

STRUCT!{struct LSA_ENUMERATION_INFORMATION {

    Sid: PSID,

}}

pub type PLSA_ENUMERATION_INFORMATION = *mut LSA_ENUMERATION_INFORMATION;

extern "system" {

    pub fn LsaFreeMemory(

        Buffer: PVOID,

    ) -> NTSTATUS;

    pub fn LsaClose(

        ObjectHandle: LSA_HANDLE,

    ) -> NTSTATUS;

    pub fn LsaDelete(

        ObjectHandle: LSA_HANDLE,

    ) -> NTSTATUS;

    pub fn LsaQuerySecurityObject(

        ObjectHandle: LSA_HANDLE,

        SecurityInformation: SECURITY_INFORMATION,

        SecurityDescriptor: *mut PSECURITY_DESCRIPTOR,

    ) -> NTSTATUS;

    pub fn LsaSetSecurityObject(

        ObjectHandle: LSA_HANDLE,

        SecurityInformation: SECURITY_INFORMATION,

        SecurityDescriptor: PSECURITY_DESCRIPTOR,

    ) -> NTSTATUS;

    pub fn LsaChangePassword(

        ServerName: PLSA_UNICODE_STRING,

        DomainName: PLSA_UNICODE_STRING,

        AccountName: PLSA_UNICODE_STRING,

        OldPassword: PLSA_UNICODE_STRING,

        NewPassword: PLSA_UNICODE_STRING,

    ) -> NTSTATUS;

STRUCT!{struct LSA_LAST_INTER_LOGON_INFO {

    LastSuccessfulLogon: LARGE_INTEGER,

    LastFailedLogon: LARGE_INTEGER,

    FailedAttemptCountSinceLastSuccessfulLogon: ULONG,

}}

pub type PLSA_LAST_INTER_LOGON_INFO = *mut LSA_LAST_INTER_LOGON_INFO;

STRUCT!{struct SECURITY_LOGON_SESSION_DATA {

    Size: ULONG,

    LogonId: LUID,

    UserName: LSA_UNICODE_STRING,

    LogonDomain: LSA_UNICODE_STRING,

    AuthenticationPackage: LSA_UNICODE_STRING,

    LogonType: ULONG,

    Session: ULONG,

    Sid: PSID,

    LogonTime: LARGE_INTEGER,

    LogonServer: LSA_UNICODE_STRING,

    DnsDomainName: LSA_UNICODE_STRING,

    Upn: LSA_UNICODE_STRING,

    UserFlags: ULONG,

    LastLogonInfo: LSA_LAST_INTER_LOGON_INFO,

    LogonScript: LSA_UNICODE_STRING,

    ProfilePath: LSA_UNICODE_STRING,

    HomeDirectory: LSA_UNICODE_STRING,

    HomeDirectoryDrive: LSA_UNICODE_STRING,

    LogoffTime: LARGE_INTEGER,

    KickOffTime: LARGE_INTEGER,

    PasswordLastSet: LARGE_INTEGER,

    PasswordCanChange: LARGE_INTEGER,

    PasswordMustChange: LARGE_INTEGER,

}}

pub type PSECURITY_LOGON_SESSION_DATA = *mut SECURITY_LOGON_SESSION_DATA;

extern "system" {

    pub fn LsaEnumerateLogonSessions(

        LogonSessionCount: PULONG,

        LogonSessionList: *mut PLUID,

    ) -> NTSTATUS;

    pub fn LsaGetLogonSessionData(

        LogonId: PLUID,

        ppLogonSessionData: *mut PSECURITY_LOGON_SESSION_DATA,

    ) -> NTSTATUS;

    pub fn LsaOpenPolicy(

        SystemName: PLSA_UNICODE_STRING,

        ObjectAttributes: PLSA_OBJECT_ATTRIBUTES,

        DesiredAccess: ACCESS_MASK,

        PolicyHandle: PLSA_HANDLE,

    ) -> NTSTATUS;

    pub fn LsaOpenPolicySce(

        SystemName: PLSA_UNICODE_STRING,

        ObjectAttributes: PLSA_OBJECT_ATTRIBUTES,

        DesiredAccess: ACCESS_MASK,

        PolicyHandle: PLSA_HANDLE,

    ) -> NTSTATUS;

pub const MAXIMUM_CAPES_PER_CAP: SIZE_T = 0x7F;

pub const CENTRAL_ACCESS_POLICY_OWNER_RIGHTS_PRESENT_FLAG: ULONG = 0x00000001;

pub const CENTRAL_ACCESS_POLICY_STAGED_OWNER_RIGHTS_PRESENT_FLAG: ULONG = 0x00000100;

#[inline]

pub fn STAGING_FLAG(Effective: ULONG) -> ULONG {

    (Effective & 0xF) << 8

pub const CENTRAL_ACCESS_POLICY_STAGED_FLAG: ULONG = 0x00010000;

pub const CENTRAL_ACCESS_POLICY_VALID_FLAG_MASK: ULONG =

    CENTRAL_ACCESS_POLICY_OWNER_RIGHTS_PRESENT_FLAG

    | CENTRAL_ACCESS_POLICY_STAGED_OWNER_RIGHTS_PRESENT_FLAG | CENTRAL_ACCESS_POLICY_STAGED_FLAG;

pub const LSASETCAPS_RELOAD_FLAG: ULONG = 0x00000001;

pub const LSASETCAPS_VALID_FLAG_MASK: ULONG = LSASETCAPS_RELOAD_FLAG;

STRUCT!{struct CENTRAL_ACCESS_POLICY_ENTRY {

    Name: LSA_UNICODE_STRING,

    Description: LSA_UNICODE_STRING,

    ChangeId: LSA_UNICODE_STRING,

    LengthAppliesTo: ULONG,

    AppliesTo: PUCHAR,

    LengthSD: ULONG,

    SD: PSECURITY_DESCRIPTOR,

    LengthStagedSD: ULONG,

    StagedSD: PSECURITY_DESCRIPTOR,

    Flags: ULONG,

}}

pub type PCENTRAL_ACCESS_POLICY_ENTRY = *mut CENTRAL_ACCESS_POLICY_ENTRY;

pub type PCCENTRAL_ACCESS_POLICY_ENTRY = *const CENTRAL_ACCESS_POLICY_ENTRY;

STRUCT!{struct CENTRAL_ACCESS_POLICY {

    CAPID: PSID,

    Name: LSA_UNICODE_STRING,

    Description: LSA_UNICODE_STRING,

    ChangeId: LSA_UNICODE_STRING,

    Flags: ULONG,

    CAPECount: ULONG,

    CAPEs: *mut PCENTRAL_ACCESS_POLICY_ENTRY,

}}

pub type PCENTRAL_ACCESS_POLICY = *mut CENTRAL_ACCESS_POLICY;

pub type PCCENTRAL_ACCESS_POLICY = *const CENTRAL_ACCESS_POLICY;

extern "system" {

    pub fn LsaSetCAPs(

        CAPDNs: PLSA_UNICODE_STRING,

        CAPDNCount: ULONG,

        Flags: ULONG,

    ) -> NTSTATUS;

    pub fn LsaGetAppliedCAPIDs(

        SystemName: PLSA_UNICODE_STRING,

        CAPIDs: *mut *mut PSID,

        CAPIDCount: PULONG,

    ) -> NTSTATUS;

    pub fn LsaQueryCAPs(

        CAPIDs: *mut PSID,

        CAPIDCount: ULONG,

        CAPs: *mut PCENTRAL_ACCESS_POLICY,

        CAPCount: PULONG,

    ) -> NTSTATUS;

    pub fn LsaQueryInformationPolicy(

        PolicyHandle: LSA_HANDLE,

        InformationClass: POLICY_INFORMATION_CLASS,

        Buffer: *mut PVOID,

    ) -> NTSTATUS;

    pub fn LsaSetInformationPolicy(

        PolicyHandle: LSA_HANDLE,

        InformationClass: POLICY_INFORMATION_CLASS,

        Buffer: PVOID,

    ) -> NTSTATUS;

    pub fn LsaQueryDomainInformationPolicy(

        PolicyHandle: LSA_HANDLE,

        InformationClass: POLICY_DOMAIN_INFORMATION_CLASS,

        Buffer: *mut PVOID,

    ) -> NTSTATUS;

    pub fn LsaSetDomainInformationPolicy(

        PolicyHandle: LSA_HANDLE,

        InformationClass: POLICY_DOMAIN_INFORMATION_CLASS,

        Buffer: PVOID,

    ) -> NTSTATUS;

    pub fn LsaRegisterPolicyChangeNotification(

        InformationClass: POLICY_NOTIFICATION_INFORMATION_CLASS,

        NotifcationEventHandle: HANDLE,

    ) -> NTSTATUS;

    pub fn LsaUnregisterPolicyChangeNotification(

        InformationClass: POLICY_NOTIFICATION_INFORMATION_CLASS,

        NotifcationEventHandle: HANDLE,

    ) -> NTSTATUS;

    pub fn LsaClearAuditLog(

        PolicyHandle: LSA_HANDLE,

    ) -> NTSTATUS;

    pub fn LsaCreateAccount(

        PolicyHandle: LSA_HANDLE,

        AccountSid: PSID,

        DesiredAccess: ACCESS_MASK,

        AccountHandle: PLSA_HANDLE,

    ) -> NTSTATUS;

    pub fn LsaEnumerateAccounts(

        PolicyHandle: LSA_HANDLE,

        EnumerationContext: PLSA_ENUMERATION_HANDLE,

        Buffer: *mut PVOID,

        PreferredMaximumLength: ULONG,

        CountReturned: PULONG,

    ) -> NTSTATUS;

    pub fn LsaCreateTrustedDomain(

        PolicyHandle: LSA_HANDLE,

        TrustedDomainInformation: PLSA_TRUST_INFORMATION,

        DesiredAccess: ACCESS_MASK,

        TrustedDomainHandle: PLSA_HANDLE,

    ) -> NTSTATUS;

    pub fn LsaEnumerateTrustedDomains(

        PolicyHandle: LSA_HANDLE,

        EnumerationContext: PLSA_ENUMERATION_HANDLE,

        Buffer: *mut PVOID,

        PreferredMaximumLength: ULONG,

        CountReturned: PULONG,

    ) -> NTSTATUS;

    pub fn LsaEnumeratePrivileges(

        PolicyHandle: LSA_HANDLE,

        EnumerationContext: PLSA_ENUMERATION_HANDLE,

        Buffer: *mut PVOID,

        PreferredMaximumLength: ULONG,

        CountReturned: PULONG,

    ) -> NTSTATUS;

    pub fn LsaLookupNames(

        PolicyHandle: LSA_HANDLE,

        Count: ULONG,

        Names: PLSA_UNICODE_STRING,

        ReferencedDomains: *mut PLSA_REFERENCED_DOMAIN_LIST,

        Sids: *mut PLSA_TRANSLATED_SID,

    ) -> NTSTATUS;

    pub fn LsaLookupNames2(

        PolicyHandle: LSA_HANDLE,

        Flags: ULONG,

        Count: ULONG,

        Names: PLSA_UNICODE_STRING,

        ReferencedDomains: *mut PLSA_REFERENCED_DOMAIN_LIST,

        Sids: *mut PLSA_TRANSLATED_SID2,

    ) -> NTSTATUS;

    pub fn LsaLookupSids(

        PolicyHandle: LSA_HANDLE,

        Count: ULONG,

        Sids: *mut PSID,

        ReferencedDomains: *mut PLSA_REFERENCED_DOMAIN_LIST,

        Names: *mut PLSA_TRANSLATED_NAME,

    ) -> NTSTATUS;

    pub fn LsaLookupSids2(

        PolicyHandle: LSA_HANDLE,

        LookupOptions: ULONG,

        Count: ULONG,

        Sids: *mut PSID,

        ReferencedDomains: *mut PLSA_REFERENCED_DOMAIN_LIST,

        Names: *mut PLSA_TRANSLATED_NAME,

    ) -> NTSTATUS;

    pub fn LsaCreateSecret(

        PolicyHandle: LSA_HANDLE,

        SecretName: PLSA_UNICODE_STRING,

        DesiredAccess: ACCESS_MASK,

        SecretHandle: PLSA_HANDLE,

    ) -> NTSTATUS;

    pub fn LsaOpenAccount(

        PolicyHandle: LSA_HANDLE,

        AccountSid: PSID,

        DesiredAccess: ACCESS_MASK,

        AccountHandle: PLSA_HANDLE,

    ) -> NTSTATUS;

    pub fn LsaEnumeratePrivilegesOfAccount(

        AccountHandle: LSA_HANDLE,

        Privileges: *mut PPRIVILEGE_SET,

    ) -> NTSTATUS;

    pub fn LsaAddPrivilegesToAccount(

        AccountHandle: LSA_HANDLE,

        Privileges: PPRIVILEGE_SET,

    ) -> NTSTATUS;

    pub fn LsaRemovePrivilegesFromAccount(

        AccountHandle: LSA_HANDLE,

        AllPrivileges: BOOLEAN,

        Privileges: PPRIVILEGE_SET,

    ) -> NTSTATUS;

    pub fn LsaGetQuotasForAccount(

        AccountHandle: LSA_HANDLE,

        QuotaLimits: PQUOTA_LIMITS,

    ) -> NTSTATUS;

    pub fn LsaSetQuotasForAccount(

        AccountHandle: LSA_HANDLE,

        QuotaLimits: PQUOTA_LIMITS,

    ) -> NTSTATUS;

    pub fn LsaGetSystemAccessAccount(

        AccountHandle: LSA_HANDLE,

        SystemAccess: PULONG,

    ) -> NTSTATUS;

    pub fn LsaSetSystemAccessAccount(

        AccountHandle: LSA_HANDLE,

        SystemAccess: ULONG,

    ) -> NTSTATUS;

    pub fn LsaOpenTrustedDomain(

        PolicyHandle: LSA_HANDLE,

        TrustedDomainSid: PSID,

        DesiredAccess: ACCESS_MASK,

        TrustedDomainHandle: PLSA_HANDLE,

    ) -> NTSTATUS;

    pub fn LsaQueryInfoTrustedDomain(

        TrustedDomainHandle: LSA_HANDLE,

        InformationClass: TRUSTED_INFORMATION_CLASS,

        Buffer: *mut PVOID,

    ) -> NTSTATUS;

    pub fn LsaSetInformationTrustedDomain(

        TrustedDomainHandle: LSA_HANDLE,

        InformationClass: TRUSTED_INFORMATION_CLASS,

        Buffer: PVOID,

    ) -> NTSTATUS;

    pub fn LsaOpenSecret(

        PolicyHandle: LSA_HANDLE,

        SecretName: PLSA_UNICODE_STRING,

        DesiredAccess: ACCESS_MASK,

        SecretHandle: PLSA_HANDLE,

    ) -> NTSTATUS;

    pub fn LsaSetSecret(

        SecretHandle: LSA_HANDLE,

        CurrentValue: PLSA_UNICODE_STRING,

        OldValue: PLSA_UNICODE_STRING,

    ) -> NTSTATUS;

    pub fn LsaQuerySecret(

        SecretHandle: LSA_HANDLE,

        CurrentValue: *mut PLSA_UNICODE_STRING,

        CurrentValueSetTime: PLARGE_INTEGER,

        OldValue: *mut PLSA_UNICODE_STRING,

        OldValueSetTime: PLARGE_INTEGER,

    ) -> NTSTATUS;

    pub fn LsaLookupPrivilegeValue(

        PolicyHandle: LSA_HANDLE,

        Name: PLSA_UNICODE_STRING,

        Value: PLUID,

    ) -> NTSTATUS;

    pub fn LsaLookupPrivilegeName(

        PolicyHandle: LSA_HANDLE,

        Value: PLUID,

        Name: *mut PLSA_UNICODE_STRING,

    ) -> NTSTATUS;

    pub fn LsaLookupPrivilegeDisplayName(

        PolicyHandle: LSA_HANDLE,

        Name: PLSA_UNICODE_STRING,

        DisplayName: *mut PLSA_UNICODE_STRING,

        LanguageReturned: PSHORT,

    ) -> NTSTATUS;

extern "C" {

    pub fn LsaGetUserName(

        UserName: *mut PLSA_UNICODE_STRING,

        DomainName: *mut PLSA_UNICODE_STRING,

    ) -> NTSTATUS;

    pub fn LsaGetRemoteUserName(

        SystemName: PLSA_UNICODE_STRING,

        UserName: *mut PLSA_UNICODE_STRING,

        DomainName: *mut PLSA_UNICODE_STRING,

    ) -> NTSTATUS;

pub const SE_INTERACTIVE_LOGON_NAME: &'static str = "SeInteractiveLogonRight";

pub const SE_NETWORK_LOGON_NAME: &'static str = "SeNetworkLogonRight";

pub const SE_BATCH_LOGON_NAME: &'static str = "SeBatchLogonRight";

pub const SE_SERVICE_LOGON_NAME: &'static str = "SeServiceLogonRight";

pub const SE_DENY_INTERACTIVE_LOGON_NAME: &'static str = "SeDenyInteractiveLogonRight";

pub const SE_DENY_NETWORK_LOGON_NAME: &'static str = "SeDenyNetworkLogonRight";

pub const SE_DENY_BATCH_LOGON_NAME: &'static str = "SeDenyBatchLogonRight";

pub const SE_DENY_SERVICE_LOGON_NAME: &'static str = "SeDenyServiceLogonRight";

pub const SE_REMOTE_INTERACTIVE_LOGON_NAME: &'static str = "SeRemoteInteractiveLogonRight";

pub const SE_DENY_REMOTE_INTERACTIVE_LOGON_NAME: &'static str =

    "SeDenyRemoteInteractiveLogonRight";

extern "system" {

    pub fn LsaEnumerateAccountsWithUserRight(

        PolictHandle: LSA_HANDLE,

        UserRights: PLSA_UNICODE_STRING,

        EnumerationBuffer: *mut PVOID,

        CountReturned: PULONG,

    ) -> NTSTATUS;

    pub fn LsaEnumerateAccountRights(

        PolicyHandle: LSA_HANDLE,

        AccountSid: PSID,

        UserRights: *mut PLSA_UNICODE_STRING,

        CountOfRights: PULONG,

    ) -> NTSTATUS;

    pub fn LsaAddAccountRights(

        PolicyHandle: LSA_HANDLE,

        AccountSid: PSID,

        UserRights: PLSA_UNICODE_STRING,

        CountOfRights: ULONG,

    ) -> NTSTATUS;

    pub fn LsaRemoveAccountRights(

        PolicyHandle: LSA_HANDLE,

        AccountSid: PSID,

        AllRights: BOOLEAN,

        UserRights: PLSA_UNICODE_STRING,

        CountOfRights: ULONG,

    ) -> NTSTATUS;

    pub fn LsaOpenTrustedDomainByName(

        PolicyHandle: LSA_HANDLE,

        TrustedDomainName: PLSA_UNICODE_STRING,

        DesiredAccess: ACCESS_MASK,

        TrustedDomainHandle: PLSA_HANDLE,

    ) -> NTSTATUS;

    pub fn LsaQueryTrustedDomainInfo(

        PolicyHandle: LSA_HANDLE,

        TrustedDomainSid: PSID,

        InformationClass: TRUSTED_INFORMATION_CLASS,

        Buffer: *mut PVOID,

    ) -> NTSTATUS;

    pub fn LsaSetTrustedDomainInformation(

        PolicyHandle: LSA_HANDLE,

        TrustedDomainSid: PSID,

        InformationClass: TRUSTED_INFORMATION_CLASS,

        Buffer: PVOID,

    ) -> NTSTATUS;

    pub fn LsaDeleteTrustedDomain(

        PolicyHandle: LSA_HANDLE,

        TrustedDomainSid: PSID,

    ) -> NTSTATUS;

    pub fn LsaQueryTrustedDomainInfoByName(

        PolicyHandle: LSA_HANDLE,

        TrustedDomainName: PLSA_UNICODE_STRING,

        InformationClass: TRUSTED_INFORMATION_CLASS,

        Buffer: *mut PVOID,

    ) -> NTSTATUS;

    pub fn LsaSetTrustedDomainInfoByName(

        PolicyHandle: LSA_HANDLE,

        TrustedDomainName: PLSA_UNICODE_STRING,

        InformationClass: TRUSTED_INFORMATION_CLASS,

        Buffer: PVOID,

    ) -> NTSTATUS;

    pub fn LsaEnumerateTrustedDomainsEx(

        PolicyHandle: LSA_HANDLE,

        EnumerationContext: PLSA_ENUMERATION_HANDLE,

        Buffer: *mut PVOID,

        PreferredMaximumLength: ULONG,

        CountReturned: PULONG,

    ) -> NTSTATUS;

    pub fn LsaCreateTrustedDomainEx(

        PolicyHandle: LSA_HANDLE,

        TrustedDomainInformation: PTRUSTED_DOMAIN_INFORMATION_EX,

        AuthenticationInformation: PTRUSTED_DOMAIN_AUTH_INFORMATION,

        DesiredAccess: ACCESS_MASK,

        TrustedDomainHandle: PLSA_HANDLE,

    ) -> NTSTATUS;

    pub fn LsaQueryForestTrustInformation(

        PolicyHandle: LSA_HANDLE,

        TrustedDomainName: PLSA_UNICODE_STRING,

        ForestTrustInfo: *mut PLSA_FOREST_TRUST_INFORMATION,

    ) -> NTSTATUS;

    pub fn LsaSetForestTrustInformation(

        PolicyHandle: LSA_HANDLE,

        TrustedDomainName: PLSA_UNICODE_STRING,

        ForestTrustInfo: PLSA_FOREST_TRUST_INFORMATION,

        CheckOnly: BOOLEAN,

        CollisionInfo: *mut PLSA_FOREST_TRUST_COLLISION_INFORMATION,

    ) -> NTSTATUS;

    pub fn LsaForestTrustFindMatch(

        PolicyHandle: LSA_HANDLE,

        Type: ULONG,

        Name: PLSA_UNICODE_STRING,

        Match: *mut PLSA_UNICODE_STRING,

    ) -> NTSTATUS;

    pub fn LsaStorePrivateData(

        PolicyHandle: LSA_HANDLE,

        KeyName: PLSA_UNICODE_STRING,

        PrivateData: PLSA_UNICODE_STRING,

    ) -> NTSTATUS;

    pub fn LsaRetrievePrivateData(

        PolicyHandle: LSA_HANDLE,

        KeyName: PLSA_UNICODE_STRING,

        PrivateData: *mut PLSA_UNICODE_STRING,

    ) -> NTSTATUS;

    pub fn LsaNtStatusToWinError(

        Status: NTSTATUS,

    ) -> ULONG;

ENUM!{enum NEGOTIATE_MESSAGES {

    NegEnumPackagePrefixes = 0,

    NegGetCallerName = 1,

    NegTransferCredentials = 2,

    NegEnumPackageNames = 3,

    NegCallPackageMax,

}}

pub const NEGOTIATE_MAX_PREFIX: SIZE_T = 32;

STRUCT!{struct NEGOTIATE_PACKAGE_PREFIX {

    PackageId: ULONG_PTR,

    PackageDataA: PVOID,

    PackageDataW: PVOID,

    PrefixLen: ULONG_PTR,

    Prefix: [UCHAR; NEGOTIATE_MAX_PREFIX],

}}

pub type PNEGOTIATE_PACKAGE_PREFIX = *mut NEGOTIATE_PACKAGE_PREFIX;

STRUCT!{struct NEGOTIATE_PACKAGE_PREFIXES {

    MessageType: ULONG,

    PrefixCount: ULONG,

    Offset: ULONG,

    Pad: ULONG,

}}

pub type PNEGOTIATE_PACKAGE_PREFIXES = *mut NEGOTIATE_PACKAGE_PREFIXES;

STRUCT!{struct NEGOTIATE_CALLER_NAME_REQUEST {

    MessageType: ULONG,

    LogonId: LUID,

}}

pub type PNEGOTIATE_CALLER_NAME_REQUEST = *mut NEGOTIATE_CALLER_NAME_REQUEST;

STRUCT!{struct NEGOTIATE_CALLER_NAME_RESPONSE {

    Messagetype: ULONG,

    CallerName: PWSTR,

}}

pub type PNEGOTIATE_CALLER_NAME_RESPONSE = *mut NEGOTIATE_CALLER_NAME_RESPONSE;

STRUCT!{struct NEGOTIATE_PACKAGE_NAMES {

    NamesCount: ULONG,

    Names: [UNICODE_STRING; ANYSIZE_ARRAY],

}}

pub type PNEGOTIATE_PACKAGE_NAMES = *mut NEGOTIATE_PACKAGE_NAMES;

pub const NEGOTIATE_ALLOW_NTLM: ULONG = 0x10000000;

pub const NEGOTIATE_NEG_NTLM: ULONG = 0x20000000;

STRUCT!{struct NEGOTIATE_PACKAGE_PREFIX_WOW {

    PackageId: ULONG,

    PackageDataA: ULONG,

    PackageDataW: ULONG,

    PrefixLen: ULONG,

    Prefix: [UCHAR; NEGOTIATE_MAX_PREFIX],

}}

pub type PNEGOTIATE_PACKAGE_PREFIX_WOW = *mut NEGOTIATE_PACKAGE_PREFIX_WOW;

STRUCT!{struct NEGOTIATE_CALLER_NAME_RESPONSE_WOW {

    MessageType: ULONG,

    CallerName: ULONG,

}}

pub type PNEGOTIATE_CALLER_NAME_RESPONSE_WOW = *mut NEGOTIATE_CALLER_NAME_RESPONSE_WOW;

extern "system" {

    pub fn LsaSetPolicyReplicationHandle(

        PolicyHandle: PLSA_HANDLE,

    ) -> NTSTATUS;

pub const MAX_USER_RECORDS: SIZE_T = 1000;

STRUCT!{struct LSA_USER_REGISTRATION_INFO {

    Sid: LSA_UNICODE_STRING,

    DeviceId: LSA_UNICODE_STRING,

    Username: LSA_UNICODE_STRING,

    Thumbprint: LSA_UNICODE_STRING,

    RegistrationTime: LARGE_INTEGER,

}}

pub type PLSA_USER_REGISTRATION_INFO = *mut LSA_USER_REGISTRATION_INFO;

STRUCT!{struct LSA_REGISTRATION_INFO {

    RegisteredCount: ULONG,

    UserRegistrationInfo: *mut PLSA_USER_REGISTRATION_INFO,

}}

pub type PLSA_REGISTRATION_INFO = *mut LSA_REGISTRATION_INFO;

extern "system" {

    pub fn LsaGetDeviceRegistrationInfo(

        RegistrationInfo: *mut PLSA_REGISTRATION_INFO,

    ) -> NTSTATUS;

ENUM!{enum LSA_CREDENTIAL_KEY_SOURCE_TYPE {

    eFromPrecomputed = 1,

    eFromClearPassword,

    eFromNtOwf,

}}

pub type PLSA_CREDENTIAL_KEY_SOURCE_TYPE = *mut LSA_CREDENTIAL_KEY_SOURCE_TYPE;

extern "C" {

    pub fn SeciIsProtectedUser(

        ProtectedUser: PBOOLEAN,

    ) -> NTSTATUS;

Source code

Revision control

Copy as Markdown

Other Tools