libphobos/libdruntime/core/sys/windows/ntsecapi.d - gcc - Git at Google


            
            /**

            
             * Windows API header module

            
             *

            
             * Translated from MinGW Windows headers

            
             *

            
             * Authors: Stewart Gordon

            
             * License: $(LINK2 http://www.boost.org/LICENSE_1_0.txt, Boost License 1.0)

            
             * Source: $(DRUNTIMESRC core/sys/windows/_ntsecapi.d)

            
             */

            
            module core.sys.windows.ntsecapi;

            
            version (Windows):

            
            pragma(lib, "advapi32");


            version (ANSI) {} else version = Unicode;


            private import

            
              core.sys.windows.basetyps, core.sys.windows.ntdef, core.sys.windows.windef, core.sys.windows.winnt, core.sys.windows.w32api;


            // FIXME: check types and grouping of constants

            
            // FIXME: check Windows version support


            enum KERB_WRAP_NO_ENCRYPT        = 0x80000001;


            enum LOGON_GUEST                 = 0x00000001;

            
            enum LOGON_NOENCRYPTION          = 0x00000002;

            
            enum LOGON_CACHED_ACCOUNT        = 0x00000004;

            
            enum LOGON_USED_LM_PASSWORD      = 0x00000008;

            
            enum LOGON_EXTRA_SIDS            = 0x00000020;

            
            enum LOGON_SUBAUTH_SESSION_KEY   = 0x00000040;

            
            enum LOGON_SERVER_TRUST_ACCOUNT  = 0x00000080;

            
            enum LOGON_NTLMV2_ENABLED        = 0x00000100;

            
            enum LOGON_RESOURCE_GROUPS       = 0x00000200;

            
            enum LOGON_PROFILE_PATH_RETURNED = 0x00000400;

            
            enum LOGON_GRACE_LOGON           = 0x01000000;


            enum {

            
                LSA_MODE_PASSWORD_PROTECTED = 1,

            
                LSA_MODE_INDIVIDUAL_ACCOUNTS,

            
                LSA_MODE_MANDATORY_ACCESS,

            
                LSA_MODE_LOG_FULL

            
            }


            bool LSA_SUCCESS()(int x) { return x >= 0; }


            /*  TOTHINKABOUT: These constants don't have ANSI/Unicode versioned

            
             *  aliases.  Should we merge them anyway?

            
             */

            
            const char[]  MICROSOFT_KERBEROS_NAME_A = "Kerberos";

            
            const wchar[] MICROSOFT_KERBEROS_NAME_W = "Kerberos";

            
            const char[]  MSV1_0_PACKAGE_NAME  = "MICROSOFT_AUTHENTICATION_PACKAGE_V1_0";

            
            const wchar[] MSV1_0_PACKAGE_NAMEW = "MICROSOFT_AUTHENTICATION_PACKAGE_V1_0";


            enum MSV1_0_ALLOW_SERVER_TRUST_ACCOUNT      =       32;

            
            enum MSV1_0_ALLOW_WORKSTATION_TRUST_ACCOUNT =     2048;

            
            enum MSV1_0_CLEARTEXT_PASSWORD_ALLOWED      =        2;

            
            enum MSV1_0_CRED_LM_PRESENT                 =        1;

            
            enum MSV1_0_CRED_NT_PRESENT                 =        2;

            
            enum MSV1_0_CRED_VERSION                    =        0;

            
            enum MSV1_0_DONT_TRY_GUEST_ACCOUNT          =       16;

            
            enum MSV1_0_MAX_NTLM3_LIFE                  =     1800;

            
            enum MSV1_0_MAX_AVL_SIZE                    =    64000;

            
            enum MSV1_0_MNS_LOGON                       = 16777216;


            enum size_t

            
                MSV1_0_CHALLENGE_LENGTH          = 8,

            
                MSV1_0_LANMAN_SESSION_KEY_LENGTH = 8,

            
                MSV1_0_NTLM3_RESPONSE_LENGTH     = 16,

            
                MSV1_0_NTLM3_OWF_LENGTH          = 16,

            
                MSV1_0_NTLM3_INPUT_LENGTH        = MSV1_0_NTLM3_RESPONSE.sizeof

            
                                                   - MSV1_0_NTLM3_RESPONSE_LENGTH,

            
                MSV1_0_OWF_PASSWORD_LENGTH       = 16,

            
                MSV1_0_PACKAGE_NAMEW_LENGTH      = MSV1_0_PACKAGE_NAMEW.sizeof

            
                                                   - WCHAR.sizeof;


            enum MSV1_0_RETURN_USER_PARAMETERS      =          8;

            
            enum MSV1_0_RETURN_PASSWORD_EXPIRY      =         64;

            
            enum MSV1_0_RETURN_PROFILE_PATH         =        512;

            
            enum MSV1_0_SUBAUTHENTICATION_DLL_EX    =    1048576;

            
            enum MSV1_0_SUBAUTHENTICATION_DLL       = 0xff000000;

            
            enum MSV1_0_SUBAUTHENTICATION_DLL_SHIFT =         24;

            
            enum MSV1_0_SUBAUTHENTICATION_DLL_RAS   =          2;

            
            enum MSV1_0_SUBAUTHENTICATION_DLL_IIS   =        132;

            
            enum MSV1_0_SUBAUTHENTICATION_FLAGS     = 0xff000000;

            
            enum MSV1_0_TRY_GUEST_ACCOUNT_ONLY      =        256;

            
            enum MSV1_0_TRY_SPECIFIED_DOMAIN_ONLY   =       1024;

            
            enum MSV1_0_UPDATE_LOGON_STATISTICS     =          4;

            
            enum MSV1_0_USE_CLIENT_CHALLENGE        =        128;

            
            enum MSV1_0_USER_SESSION_KEY_LENGTH     =         16;


            const char[]

            
                MSV1_0_SUBAUTHENTICATION_KEY

            
                  = `System\CurrentControlSet\Control\Lsa\MSV1_0`,

            
                MSV1_0_SUBAUTHENTICATION_VALUE = "Auth";


            enum ACCESS_MASK

            
                POLICY_VIEW_LOCAL_INFORMATION   = 0x0001,

            
                POLICY_VIEW_AUDIT_INFORMATION   = 0x0002,

            
                POLICY_GET_PRIVATE_INFORMATION  = 0x0004,

            
                POLICY_TRUST_ADMIN              = 0x0008,

            
                POLICY_CREATE_ACCOUNT           = 0x0010,

            
                POLICY_CREATE_SECRET            = 0x0020,

            
                POLICY_CREATE_PRIVILEGE         = 0x0040,

            
                POLICY_SET_DEFAULT_QUOTA_LIMITS = 0x0080,

            
                POLICY_SET_AUDIT_REQUIREMENTS   = 0x0100,

            
                POLICY_AUDIT_LOG_ADMIN          = 0x0200,

            
                POLICY_SERVER_ADMIN             = 0x0400,

            
                POLICY_LOOKUP_NAMES             = 0x0800,


                POLICY_READ                     = STANDARD_RIGHTS_READ     | 0x0006,

            
                POLICY_WRITE                    = STANDARD_RIGHTS_WRITE    | 0x07F8,

            
                POLICY_EXECUTE                  = STANDARD_RIGHTS_EXECUTE  | 0x0801,

            
                POLICY_ALL_ACCESS               = STANDARD_RIGHTS_REQUIRED | 0x0FFF;


            enum POLICY_AUDIT_EVENT_UNCHANGED = 0;

            
            enum POLICY_AUDIT_EVENT_SUCCESS   = 1;

            
            enum POLICY_AUDIT_EVENT_FAILURE   = 2;

            
            enum POLICY_AUDIT_EVENT_NONE      = 4;

            
            enum POLICY_AUDIT_EVENT_MASK      = 7;


            enum {

            
                POLICY_LOCATION_LOCAL = 1,

            
                POLICY_LOCATION_DS

            
            }


            enum : uint {

            
                POLICY_MACHINE_POLICY_LOCAL     =          0,

            
                POLICY_MACHINE_POLICY_DEFAULTED,

            
                POLICY_MACHINE_POLICY_EXPLICIT,

            
                POLICY_MACHINE_POLICY_UNKNOWN   = 0xFFFFFFFF

            
            }


            enum POLICY_QOS_SCHANEL_REQUIRED            = 0x0001;

            
            enum POLICY_QOS_OUTBOUND_INTEGRITY          = 0x0002;

            
            enum POLICY_QOS_OUTBOUND_CONFIDENTIALITY    = 0x0004;

            
            enum POLICY_QOS_INBOUND_INTEGREITY          = 0x0008;

            
            enum POLICY_QOS_INBOUND_CONFIDENTIALITY     = 0x0010;

            
            enum POLICY_QOS_ALLOW_LOCAL_ROOT_CERT_STORE = 0x0020;

            
            enum POLICY_QOS_RAS_SERVER_ALLOWED          = 0x0040;

            
            enum POLICY_QOS_DHCP_SERVER_ALLOWD          = 0x0080;


            enum POLICY_KERBEROS_FORWARDABLE  = 1;

            
            enum POLICY_KERBEROS_PROXYABLE    = 2;

            
            enum POLICY_KERBEROS_RENEWABLE    = 4;

            
            enum POLICY_KERBEROS_POSTDATEABLE = 8;


            const char[]

            
                SAM_PASSWORD_CHANGE_NOTIFY_ROUTINE = "PasswordChangeNotify",

            
                SAM_INIT_NOTIFICATION_ROUTINE      = "InitializeChangeNotify",

            
                SAM_PASSWORD_FILTER_ROUTINE        = "PasswordFilter";


            const TCHAR[]

            
                SE_INTERACTIVE_LOGON_NAME          = "SeInteractiveLogonRight",

            
                SE_NETWORK_LOGON_NAME              = "SeNetworkLogonRight",

            
                SE_BATCH_LOGON_NAME                = "SeBatchLogonRight",

            
                SE_SERVICE_LOGON_NAME              = "SeServiceLogonRight";


            enum {

            
                TRUST_ATTRIBUTE_NON_TRANSITIVE =         1,

            
                TRUST_ATTRIBUTE_UPLEVEL_ONLY   =         2,

            
                TRUST_ATTRIBUTE_TREE_PARENT    =   4194304,

            
                TRUST_ATTRIBUTES_VALID         = -16580609

            
            }


            enum {

            
                TRUST_AUTH_TYPE_NONE,

            
                TRUST_AUTH_TYPE_NT4OWF,

            
                TRUST_AUTH_TYPE_CLEAR

            
            }


            enum {

            
                TRUST_DIRECTION_DISABLED,

            
                TRUST_DIRECTION_INBOUND,

            
                TRUST_DIRECTION_OUTBOUND,

            
                TRUST_DIRECTION_BIDIRECTIONAL

            
            }


            enum {

            
                TRUST_TYPE_DOWNLEVEL = 1,

            
                TRUST_TYPE_UPLEVEL,

            
                TRUST_TYPE_MIT,

            
                TRUST_TYPE_DCE

            
            }


            alias LSA_UNICODE_STRING = UNICODE_STRING;

            
            alias PLSA_UNICODE_STRING = UNICODE_STRING*;

            
            alias LSA_STRING = STRING;

            
            alias PLSA_STRING = STRING*;


            enum MSV1_0_LOGON_SUBMIT_TYPE {

            
                MsV1_0InteractiveLogon       = 2,

            
                MsV1_0Lm20Logon,

            
                MsV1_0NetworkLogon,

            
                MsV1_0SubAuthLogon,

            
                MsV1_0WorkstationUnlockLogon = 7

            
            }

            
            alias PMSV1_0_LOGON_SUBMIT_TYPE = MSV1_0_LOGON_SUBMIT_TYPE*;


            enum MSV1_0_PROFILE_BUFFER_TYPE {

            
                MsV1_0InteractiveProfile = 2,

            
                MsV1_0Lm20LogonProfile,

            
                MsV1_0SmartCardProfile

            
            }

            
            alias PMSV1_0_PROFILE_BUFFER_TYPE = MSV1_0_PROFILE_BUFFER_TYPE*;


            enum MSV1_0_AVID {

            
                MsvAvEOL,

            
                MsvAvNbComputerName,

            
                MsvAvNbDomainName,

            
                MsvAvDnsComputerName,

            
                MsvAvDnsDomainName

            
            }


            enum MSV1_0_PROTOCOL_MESSAGE_TYPE {

            
                MsV1_0Lm20ChallengeRequest = 0,

            
                MsV1_0Lm20GetChallengeResponse,

            
                MsV1_0EnumerateUsers,

            
                MsV1_0GetUserInfo,

            
                MsV1_0ReLogonUsers,

            
                MsV1_0ChangePassword,

            
                MsV1_0ChangeCachedPassword,

            
                MsV1_0GenericPassthrough,

            
                MsV1_0CacheLogon,

            
                MsV1_0SubAuth,

            
                MsV1_0DeriveCredential,

            
                MsV1_0CacheLookup

            
            }

            
            alias PMSV1_0_PROTOCOL_MESSAGE_TYPE = MSV1_0_PROTOCOL_MESSAGE_TYPE*;


            enum POLICY_LSA_SERVER_ROLE {

            
                PolicyServerRoleBackup = 2,

            
                PolicyServerRolePrimary

            
            }

            
            alias PPOLICY_LSA_SERVER_ROLE = POLICY_LSA_SERVER_ROLE*;


            enum POLICY_SERVER_ENABLE_STATE {

            
                PolicyServerEnabled = 2,

            
                PolicyServerDisabled

            
            }

            
            alias PPOLICY_SERVER_ENABLE_STATE = POLICY_SERVER_ENABLE_STATE*;


            enum POLICY_INFORMATION_CLASS {

            
                PolicyAuditLogInformation = 1,

            
                PolicyAuditEventsInformation,

            
                PolicyPrimaryDomainInformation,

            
                PolicyPdAccountInformation,

            
                PolicyAccountDomainInformation,

            
                PolicyLsaServerRoleInformation,

            
                PolicyReplicaSourceInformation,

            
                PolicyDefaultQuotaInformation,

            
                PolicyModificationInformation,

            
                PolicyAuditFullSetInformation,

            
                PolicyAuditFullQueryInformation,

            
                PolicyDnsDomainInformation,

            
                PolicyEfsInformation

            
            }

            
            alias PPOLICY_INFORMATION_CLASS = POLICY_INFORMATION_CLASS*;


            enum POLICY_AUDIT_EVENT_TYPE {

            
                AuditCategorySystem,

            
                AuditCategoryLogon,

            
                AuditCategoryObjectAccess,

            
                AuditCategoryPrivilegeUse,

            
                AuditCategoryDetailedTracking,

            
                AuditCategoryPolicyChange,

            
                AuditCategoryAccountManagement,

            
                AuditCategoryDirectoryServiceAccess,

            
                AuditCategoryAccountLogon

            
            }

            
            alias PPOLICY_AUDIT_EVENT_TYPE = POLICY_AUDIT_EVENT_TYPE*;


            enum POLICY_LOCAL_INFORMATION_CLASS {

            
                PolicyLocalAuditEventsInformation = 1,

            
                PolicyLocalPdAccountInformation,

            
                PolicyLocalAccountDomainInformation,

            
                PolicyLocalLsaServerRoleInformation,

            
                PolicyLocalReplicaSourceInformation,

            
                PolicyLocalModificationInformation,

            
                PolicyLocalAuditFullSetInformation,

            
                PolicyLocalAuditFullQueryInformation,

            
                PolicyLocalDnsDomainInformation,

            
                PolicyLocalIPSecReferenceInformation,

            
                PolicyLocalMachinePasswordInformation,

            
                PolicyLocalQualityOfServiceInformation,

            
                PolicyLocalPolicyLocationInformation

            
            }

            
            alias PPOLICY_LOCAL_INFORMATION_CLASS = POLICY_LOCAL_INFORMATION_CLASS*;


            enum POLICY_DOMAIN_INFORMATION_CLASS {

            
                PolicyDomainIPSecReferenceInformation = 1,

            
                PolicyDomainQualityOfServiceInformation,

            
                PolicyDomainEfsInformation,

            
                PolicyDomainPublicKeyInformation,

            
                PolicyDomainPasswordPolicyInformation,

            
                PolicyDomainLockoutInformation,

            
                PolicyDomainKerberosTicketInformation

            
            }

            
            alias PPOLICY_DOMAIN_INFORMATION_CLASS = POLICY_DOMAIN_INFORMATION_CLASS*;


            enum SECURITY_LOGON_TYPE {

            
                Interactive = 2,

            
                Network,

            
                Batch,

            
                Service,

            
                Proxy,

            
                Unlock

            
            }

            
            alias PSECURITY_LOGON_TYPE = SECURITY_LOGON_TYPE*;


            enum TRUSTED_INFORMATION_CLASS {

            
                TrustedDomainNameInformation = 1,

            
                TrustedControllersInformation,

            
                TrustedPosixOffsetInformation,

            
                TrustedPasswordInformation,

            
                TrustedDomainInformationBasic,

            
                TrustedDomainInformationEx,

            
                TrustedDomainAuthInformation,

            
                TrustedDomainFullInformation

            
            }

            
            alias PTRUSTED_INFORMATION_CLASS = TRUSTED_INFORMATION_CLASS*;


            struct DOMAIN_PASSWORD_INFORMATION {

            
                USHORT        MinPasswordLength;

            
                USHORT        PasswordHistoryLength;

            
                ULONG         PasswordProperties;

            
                LARGE_INTEGER MaxPasswordAge;

            
                LARGE_INTEGER MinPasswordAge;

            
            }

            
            alias PDOMAIN_PASSWORD_INFORMATION = DOMAIN_PASSWORD_INFORMATION*;


            struct LSA_ENUMERATION_INFORMATION {

            
                PSID Sid;

            
            }

            
            alias PLSA_ENUMERATION_INFORMATION = LSA_ENUMERATION_INFORMATION*;


            alias LSA_OBJECT_ATTRIBUTES = OBJECT_ATTRIBUTES;

            
            alias PLSA_OBJECT_ATTRIBUTES = OBJECT_ATTRIBUTES*;


            struct LSA_TRUST_INFORMATION {

            
                LSA_UNICODE_STRING Name;

            
                PSID               Sid;

            
            }

            
            alias TRUSTED_DOMAIN_INFORMATION_BASIC = LSA_TRUST_INFORMATION;

            
            alias PLSA_TRUST_INFORMATION = LSA_TRUST_INFORMATION*;

            
            /*  in MinGW (further down the code):

            
             *      typedef PLSA_TRUST_INFORMATION *PTRUSTED_DOMAIN_INFORMATION_BASIC;

            
             *  but it doesn't look right....

            
             */

            
            alias PTRUSTED_DOMAIN_INFORMATION_BASIC = LSA_TRUST_INFORMATION**;


            struct LSA_REFERENCED_DOMAIN_LIST {

            
                ULONG                  Entries;

            
                PLSA_TRUST_INFORMATION Domains;

            
            }

            
            alias PLSA_REFERENCED_DOMAIN_LIST = LSA_REFERENCED_DOMAIN_LIST*;


            struct LSA_TRANSLATED_SID {

            
                SID_NAME_USE Use;

            
                ULONG        RelativeId;

            
                LONG         DomainIndex;

            
            }

            
            alias PLSA_TRANSLATED_SID = LSA_TRANSLATED_SID*;


            struct LSA_TRANSLATED_NAME {

            
                SID_NAME_USE       Use;

            
                LSA_UNICODE_STRING Name;

            
                LONG               DomainIndex;

            
            }

            
            alias PLSA_TRANSLATED_NAME = LSA_TRANSLATED_NAME*;


            struct MSV1_0_INTERACTIVE_LOGON {

            
                MSV1_0_LOGON_SUBMIT_TYPE MessageType;

            
                UNICODE_STRING           LogonDomainName;

            
                UNICODE_STRING           UserName;

            
                UNICODE_STRING           Password;

            
            }

            
            alias PMSV1_0_INTERACTIVE_LOGON = MSV1_0_INTERACTIVE_LOGON*;


            struct MSV1_0_INTERACTIVE_PROFILE {

            
                MSV1_0_PROFILE_BUFFER_TYPE MessageType;

            
                USHORT                     LogonCount;

            
                USHORT                     BadPasswordCount;

            
                LARGE_INTEGER              LogonTime;

            
                LARGE_INTEGER              LogoffTime;

            
                LARGE_INTEGER              KickOffTime;

            
                LARGE_INTEGER              PasswordLastSet;

            
                LARGE_INTEGER              PasswordCanChange;

            
                LARGE_INTEGER              PasswordMustChange;

            
                UNICODE_STRING             LogonScript;

            
                UNICODE_STRING             HomeDirectory;

            
                UNICODE_STRING             FullName;

            
                UNICODE_STRING             ProfilePath;

            
                UNICODE_STRING             HomeDirectoryDrive;

            
                UNICODE_STRING             LogonServer;

            
                ULONG                      UserFlags;

            
            }

            
            alias PMSV1_0_INTERACTIVE_PROFILE = MSV1_0_INTERACTIVE_PROFILE*;


            struct MSV1_0_LM20_LOGON {

            
                MSV1_0_LOGON_SUBMIT_TYPE       MessageType;

            
                UNICODE_STRING                 LogonDomainName;

            
                UNICODE_STRING                 UserName;

            
                UNICODE_STRING                 Workstation;

            
                UCHAR[MSV1_0_CHALLENGE_LENGTH] ChallengeToClient;

            
                STRING                         CaseSensitiveChallengeResponse;

            
                STRING                         CaseInsensitiveChallengeResponse;

            
                ULONG                          ParameterControl;

            
            }

            
            alias PMSV1_0_LM20_LOGON = MSV1_0_LM20_LOGON*;


            //static if (_WIN32_WINNT >= 0x500) {

            
                struct MSV1_0_SUBAUTH_LOGON {

            
                    MSV1_0_LOGON_SUBMIT_TYPE       MessageType;

            
                    UNICODE_STRING                 LogonDomainName;

            
                    UNICODE_STRING                 UserName;

            
                    UNICODE_STRING                 Workstation;

            
                    UCHAR[MSV1_0_CHALLENGE_LENGTH] ChallengeToClient;

            
                    STRING                         AuthenticationInfo1;

            
                    STRING                         AuthenticationInfo2;

            
                    ULONG                          ParameterControl;

            
                    ULONG                          SubAuthPackageId;

            
                }

            
                alias PMSV1_0_SUBAUTH_LOGON = MSV1_0_SUBAUTH_LOGON*;

            
            //}


            struct MSV1_0_LM20_LOGON_PROFILE {

            
                MSV1_0_PROFILE_BUFFER_TYPE              MessageType;

            
                LARGE_INTEGER                           KickOffTime;

            
                LARGE_INTEGER                           LogoffTime;

            
                ULONG                                   UserFlags;

            
                UCHAR[MSV1_0_USER_SESSION_KEY_LENGTH]   UserSessionKey;

            
                UNICODE_STRING                          LogonDomainName;

            
                UCHAR[MSV1_0_LANMAN_SESSION_KEY_LENGTH] LanmanSessionKey;

            
                UNICODE_STRING                          LogonServer;

            
                UNICODE_STRING                          UserParameters;

            
            }

            
            alias PMSV1_0_LM20_LOGON_PROFILE = MSV1_0_LM20_LOGON_PROFILE*;


            struct MSV1_0_SUPPLEMENTAL_CREDENTIAL {

            
                ULONG Version;

            
                ULONG Flags;

            
                UCHAR[MSV1_0_OWF_PASSWORD_LENGTH] LmPassword;

            
                UCHAR[MSV1_0_OWF_PASSWORD_LENGTH] NtPassword;

            
            }

            
            alias PMSV1_0_SUPPLEMENTAL_CREDENTIAL = MSV1_0_SUPPLEMENTAL_CREDENTIAL*;


            struct MSV1_0_NTLM3_RESPONSE {

            
                UCHAR[MSV1_0_NTLM3_RESPONSE_LENGTH] Response;

            
                UCHAR     RespType;

            
                UCHAR     HiRespType;

            
                USHORT    Flags;

            
                ULONG     MsgWord;

            
                ULONGLONG TimeStamp;

            
                UCHAR[MSV1_0_CHALLENGE_LENGTH]      ChallengeFromClient;

            
                ULONG     AvPairsOff;

            
                UCHAR     _Buffer;

            
                UCHAR*    Buffer() return { return &_Buffer; }

            
            }

            
            alias PMSV1_0_NTLM3_RESPONSE = MSV1_0_NTLM3_RESPONSE*;


            struct  MSV1_0_AV_PAIR {

            
                USHORT AvId;

            
                USHORT AvLen;

            
            }

            
            alias PMSV1_0_AV_PAIR = MSV1_0_AV_PAIR*;


            struct MSV1_0_CHANGEPASSWORD_REQUEST {

            
                MSV1_0_PROTOCOL_MESSAGE_TYPE MessageType;

            
                UNICODE_STRING DomainName;

            
                UNICODE_STRING AccountName;

            
                UNICODE_STRING OldPassword;

            
                UNICODE_STRING NewPassword;

            
                BOOLEAN        Impersonating;

            
            }

            
            alias PMSV1_0_CHANGEPASSWORD_REQUEST = MSV1_0_CHANGEPASSWORD_REQUEST*;


            struct MSV1_0_CHANGEPASSWORD_RESPONSE {

            
                MSV1_0_PROTOCOL_MESSAGE_TYPE MessageType;

            
                BOOLEAN                      PasswordInfoValid;

            
                DOMAIN_PASSWORD_INFORMATION  DomainPasswordInfo;

            
            }

            
            alias PMSV1_0_CHANGEPASSWORD_RESPONSE = MSV1_0_CHANGEPASSWORD_RESPONSE*;


            struct MSV1_0_SUBAUTH_REQUEST {

            
                MSV1_0_PROTOCOL_MESSAGE_TYPE MessageType;

            
                ULONG  SubAuthPackageId;

            
                ULONG  SubAuthInfoLength;

            
                PUCHAR SubAuthSubmitBuffer;

            
            }

            
            alias PMSV1_0_SUBAUTH_REQUEST = MSV1_0_SUBAUTH_REQUEST*;


            struct MSV1_0_SUBAUTH_RESPONSE {

            
                MSV1_0_PROTOCOL_MESSAGE_TYPE MessageType;

            
                ULONG  SubAuthInfoLength;

            
                PUCHAR SubAuthReturnBuffer;

            
            }

            
            alias PMSV1_0_SUBAUTH_RESPONSE = MSV1_0_SUBAUTH_RESPONSE*;


            enum MSV1_0_DERIVECRED_TYPE_SHA1 = 0;


            struct MSV1_0_DERIVECRED_REQUEST {

            
                MSV1_0_PROTOCOL_MESSAGE_TYPE MessageType;

            
                LUID   LogonId;

            
                ULONG  DeriveCredType;

            
                ULONG  DeriveCredInfoLength;

            
                UCHAR  _DeriveCredSubmitBuffer;

            
                UCHAR* DeriveCredSubmitBuffer() return { return &_DeriveCredSubmitBuffer; }

            
            }

            
            alias PMSV1_0_DERIVECRED_REQUEST = MSV1_0_DERIVECRED_REQUEST*;


            struct MSV1_0_DERIVECRED_RESPONSE {

            
                MSV1_0_PROTOCOL_MESSAGE_TYPE MessageType;

            
                ULONG  DeriveCredInfoLength;

            
                UCHAR  _DeriveCredReturnBuffer;

            
                UCHAR* DeriveCredReturnBuffer() return { return &_DeriveCredReturnBuffer; }

            
            }

            
            alias PMSV1_0_DERIVECRED_RESPONSE = MSV1_0_DERIVECRED_RESPONSE*;


            alias LSA_ENUMERATION_HANDLE = uint, LSA_OPERATIONAL_MODE = uint, POLICY_AUDIT_EVENT_OPTIONS = uint;

            
            alias PLSA_ENUMERATION_HANDLE = uint*, PLSA_OPERATIONAL_MODE = uint*, PPOLICY_AUDIT_EVENT_OPTIONS = uint*;


            struct POLICY_PRIVILEGE_DEFINITION {

            
                LSA_UNICODE_STRING Name;

            
                LUID LocalValue;

            
            }

            
            alias PPOLICY_PRIVILEGE_DEFINITION = POLICY_PRIVILEGE_DEFINITION*;


            struct POLICY_AUDIT_LOG_INFO {

            
                ULONG         AuditLogPercentFull;

            
                ULONG         MaximumLogSize;

            
                LARGE_INTEGER AuditRetentionPeriod;

            
                BOOLEAN       AuditLogFullShutdownInProgress;

            
                LARGE_INTEGER TimeToShutdown;

            
                ULONG         NextAuditRecordId;

            
            }

            
            alias PPOLICY_AUDIT_LOG_INFO = POLICY_AUDIT_LOG_INFO*;


            struct POLICY_AUDIT_EVENTS_INFO {

            
                BOOLEAN                     AuditingMode;

            
                PPOLICY_AUDIT_EVENT_OPTIONS EventAuditingOptions;

            
                ULONG                       MaximumAuditEventCount;

            
            }

            
            alias PPOLICY_AUDIT_EVENTS_INFO = POLICY_AUDIT_EVENTS_INFO*;


            struct POLICY_ACCOUNT_DOMAIN_INFO {

            
                LSA_UNICODE_STRING DomainName;

            
                PSID               DomainSid;

            
            }

            
            alias PPOLICY_ACCOUNT_DOMAIN_INFO = POLICY_ACCOUNT_DOMAIN_INFO*;


            struct POLICY_PRIMARY_DOMAIN_INFO {

            
                LSA_UNICODE_STRING Name;

            
                PSID               Sid;

            
            }

            
            alias PPOLICY_PRIMARY_DOMAIN_INFO = POLICY_PRIMARY_DOMAIN_INFO*;


            struct POLICY_DNS_DOMAIN_INFO {

            
                LSA_UNICODE_STRING Name;

            
                LSA_UNICODE_STRING DnsDomainName;

            
                LSA_UNICODE_STRING DnsTreeName;

            
                GUID               DomainGuid;

            
                PSID               Sid;

            
            }

            
            alias PPOLICY_DNS_DOMAIN_INFO = POLICY_DNS_DOMAIN_INFO*;


            struct POLICY_PD_ACCOUNT_INFO {

            
                LSA_UNICODE_STRING Name;

            
            }

            
            alias PPOLICY_PD_ACCOUNT_INFO = POLICY_PD_ACCOUNT_INFO*;


            struct POLICY_LSA_SERVER_ROLE_INFO {

            
                POLICY_LSA_SERVER_ROLE LsaServerRole;

            
            }

            
            alias PPOLICY_LSA_SERVER_ROLE_INFO = POLICY_LSA_SERVER_ROLE_INFO*;


            struct POLICY_REPLICA_SOURCE_INFO {

            
                LSA_UNICODE_STRING ReplicaSource;

            
                LSA_UNICODE_STRING ReplicaAccountName;

            
            }

            
            alias PPOLICY_REPLICA_SOURCE_INFO = POLICY_REPLICA_SOURCE_INFO*;


            struct POLICY_DEFAULT_QUOTA_INFO {

            
                QUOTA_LIMITS QuotaLimits;

            
            }

            
            alias PPOLICY_DEFAULT_QUOTA_INFO = POLICY_DEFAULT_QUOTA_INFO*;


            struct POLICY_MODIFICATION_INFO {

            
                LARGE_INTEGER ModifiedId;

            
                LARGE_INTEGER DatabaseCreationTime;

            
            }

            
            alias PPOLICY_MODIFICATION_INFO = POLICY_MODIFICATION_INFO*;


            struct POLICY_AUDIT_FULL_SET_INFO {

            
                BOOLEAN ShutDownOnFull;

            
            }

            
            alias PPOLICY_AUDIT_FULL_SET_INFO = POLICY_AUDIT_FULL_SET_INFO*;


            struct POLICY_AUDIT_FULL_QUERY_INFO {

            
                BOOLEAN ShutDownOnFull;

            
                BOOLEAN LogIsFull;

            
            }

            
            alias PPOLICY_AUDIT_FULL_QUERY_INFO = POLICY_AUDIT_FULL_QUERY_INFO*;


            struct POLICY_EFS_INFO {

            
                ULONG InfoLength;

            
                PUCHAR EfsBlob;

            
            }

            
            alias PPOLICY_EFS_INFO = POLICY_EFS_INFO*;


            struct POLICY_LOCAL_IPSEC_REFERENCE_INFO {

            
                LSA_UNICODE_STRING ObjectPath;

            
            }

            
            alias PPOLICY_LOCAL_IPSEC_REFERENCE_INFO = POLICY_LOCAL_IPSEC_REFERENCE_INFO*;


            struct POLICY_LOCAL_MACHINE_PASSWORD_INFO {

            
                LARGE_INTEGER PasswordChangeInterval;

            
            }

            
            alias PPOLICY_LOCAL_MACHINE_PASSWORD_INFO = POLICY_LOCAL_MACHINE_PASSWORD_INFO*;


            struct POLICY_LOCAL_POLICY_LOCATION_INFO {

            
                ULONG PolicyLocation;

            
            }

            
            alias PPOLICY_LOCAL_POLICY_LOCATION_INFO = POLICY_LOCAL_POLICY_LOCATION_INFO*;


            struct POLICY_LOCAL_QUALITY_OF_SERVICE_INFO{

            
                ULONG QualityOfService;

            
            }

            
            alias POLICY_DOMAIN_QUALITY_OF_SERVICE_INFO = POLICY_LOCAL_QUALITY_OF_SERVICE_INFO;

            
            alias PPOLICY_LOCAL_QUALITY_OF_SERVICE_INFO = POLICY_LOCAL_QUALITY_OF_SERVICE_INFO*, PPOLICY_DOMAIN_QUALITY_OF_SERVICE_INFO = POLICY_LOCAL_QUALITY_OF_SERVICE_INFO*;


            struct POLICY_DOMAIN_PUBLIC_KEY_INFO {

            
                ULONG  InfoLength;

            
                PUCHAR PublicKeyInfo;

            
            }

            
            alias PPOLICY_DOMAIN_PUBLIC_KEY_INFO = POLICY_DOMAIN_PUBLIC_KEY_INFO*;


            struct POLICY_DOMAIN_LOCKOUT_INFO {

            
                LARGE_INTEGER LockoutDuration;

            
                LARGE_INTEGER LockoutObservationWindow;

            
                USHORT        LockoutThreshold;

            
            }

            
            alias PPOLICY_DOMAIN_LOCKOUT_INFO = POLICY_DOMAIN_LOCKOUT_INFO*;


            struct POLICY_DOMAIN_PASSWORD_INFO {

            
                USHORT        MinPasswordLength;

            
                USHORT        PasswordHistoryLength;

            
                ULONG         PasswordProperties;

            
                LARGE_INTEGER MaxPasswordAge;

            
                LARGE_INTEGER MinPasswordAge;

            
            }

            
            alias PPOLICY_DOMAIN_PASSWORD_INFO = POLICY_DOMAIN_PASSWORD_INFO*;


            struct POLICY_DOMAIN_KERBEROS_TICKET_INFO {

            
                ULONG         AuthenticationOptions;

            
                LARGE_INTEGER MinTicketAge;

            
                LARGE_INTEGER MaxTicketAge;

            
                LARGE_INTEGER MaxRenewAge;

            
                LARGE_INTEGER ProxyLifetime;

            
                LARGE_INTEGER ForceLogoff;

            
            }

            
            alias PPOLICY_DOMAIN_KERBEROS_TICKET_INFO = POLICY_DOMAIN_KERBEROS_TICKET_INFO*;


            alias LSA_HANDLE = HANDLE;

            
            alias PLSA_HANDLE = LSA_HANDLE*;


            struct TRUSTED_DOMAIN_NAME_INFO {

            
                LSA_UNICODE_STRING Name;

            
            }

            
            alias PTRUSTED_DOMAIN_NAME_INFO = TRUSTED_DOMAIN_NAME_INFO*;


            struct TRUSTED_CONTROLLERS_INFO {

            
                ULONG               Entries;

            
                PLSA_UNICODE_STRING Names;

            
            }

            
            alias PTRUSTED_CONTROLLERS_INFO = TRUSTED_CONTROLLERS_INFO*;


            struct TRUSTED_POSIX_OFFSET_INFO {

            
                ULONG Offset;

            
            }

            
            alias PTRUSTED_POSIX_OFFSET_INFO = TRUSTED_POSIX_OFFSET_INFO*;


            struct TRUSTED_PASSWORD_INFO {

            
                LSA_UNICODE_STRING Password;

            
                LSA_UNICODE_STRING OldPassword;

            
            }

            
            alias PTRUSTED_PASSWORD_INFO = TRUSTED_PASSWORD_INFO*;


            struct TRUSTED_DOMAIN_INFORMATION_EX {

            
                LSA_UNICODE_STRING Name;

            
                LSA_UNICODE_STRING FlatName;

            
                PSID               Sid;

            
                ULONG              TrustDirection;

            
                ULONG              TrustType;

            
                ULONG              TrustAttributes;

            
            }

            
            alias PTRUSTED_DOMAIN_INFORMATION_EX = TRUSTED_DOMAIN_INFORMATION_EX*;


            struct LSA_AUTH_INFORMATION {

            
                LARGE_INTEGER LastUpdateTime;

            
                ULONG         AuthType;

            
                ULONG         AuthInfoLength;

            
                PUCHAR        AuthInfo;

            
            }

            
            alias PLSA_AUTH_INFORMATION = LSA_AUTH_INFORMATION*;


            struct TRUSTED_DOMAIN_AUTH_INFORMATION {

            
                ULONG                 IncomingAuthInfos;

            
                PLSA_AUTH_INFORMATION IncomingAuthenticationInformation;

            
                PLSA_AUTH_INFORMATION IncomingPreviousAuthenticationInformation;

            
                ULONG                 OutgoingAuthInfos;

            
                PLSA_AUTH_INFORMATION OutgoingAuthenticationInformation;

            
                PLSA_AUTH_INFORMATION OutgoingPreviousAuthenticationInformation;

            
            }

            
            alias PTRUSTED_DOMAIN_AUTH_INFORMATION = TRUSTED_DOMAIN_AUTH_INFORMATION*;


            struct TRUSTED_DOMAIN_FULL_INFORMATION {

            
                TRUSTED_DOMAIN_INFORMATION_EX   Information;

            
                TRUSTED_POSIX_OFFSET_INFO       PosixOffset;

            
                TRUSTED_DOMAIN_AUTH_INFORMATION AuthInformation;

            
            }

            
            alias PTRUSTED_DOMAIN_FULL_INFORMATION = TRUSTED_DOMAIN_FULL_INFORMATION*;


            extern (Windows) nothrow @nogc {

            
                NTSTATUS LsaAddAccountRights(LSA_HANDLE, PSID, PLSA_UNICODE_STRING,

            
                  ULONG);

            
                NTSTATUS LsaCallAuthenticationPackage(HANDLE, ULONG, PVOID, ULONG,

            
                  PVOID*, PULONG, PNTSTATUS);

            
                NTSTATUS LsaClose(LSA_HANDLE);

            
                NTSTATUS LsaConnectUntrusted(PHANDLE);

            
                NTSTATUS LsaCreateTrustedDomainEx(LSA_HANDLE,

            
                  PTRUSTED_DOMAIN_INFORMATION_EX, PTRUSTED_DOMAIN_AUTH_INFORMATION,

            
                  ACCESS_MASK, PLSA_HANDLE);

            
                NTSTATUS LsaDeleteTrustedDomain(LSA_HANDLE, PSID);

            
                NTSTATUS LsaDeregisterLogonProcess(HANDLE);

            
                NTSTATUS LsaEnumerateAccountRights(LSA_HANDLE, PSID, PLSA_UNICODE_STRING*,

            
                  PULONG);

            
                NTSTATUS LsaEnumerateAccountsWithUserRight(LSA_HANDLE,

            
                  PLSA_UNICODE_STRING, PVOID*, PULONG);

            
                NTSTATUS LsaEnumerateTrustedDomains(LSA_HANDLE, PLSA_ENUMERATION_HANDLE,

            
                  PVOID*, ULONG, PULONG);

            
                NTSTATUS LsaEnumerateTrustedDomainsEx(LSA_HANDLE, PLSA_ENUMERATION_HANDLE,

            
                  TRUSTED_INFORMATION_CLASS, PVOID*, ULONG, PULONG);

            
                NTSTATUS LsaFreeMemory(PVOID);

            
                NTSTATUS LsaFreeReturnBuffer(PVOID);

            
                NTSTATUS LsaLogonUser(HANDLE, PLSA_STRING, SECURITY_LOGON_TYPE, ULONG,

            
                  PVOID, ULONG, PTOKEN_GROUPS, PTOKEN_SOURCE, PVOID*, PULONG, PLUID,

            
                  PHANDLE, PQUOTA_LIMITS, PNTSTATUS);

            
                NTSTATUS LsaLookupAuthenticationPackage(HANDLE, PLSA_STRING, PULONG);

            
                NTSTATUS LsaLookupNames(LSA_HANDLE, ULONG, PLSA_UNICODE_STRING,

            
                  PLSA_REFERENCED_DOMAIN_LIST*, PLSA_TRANSLATED_SID*);

            
                NTSTATUS LsaLookupSids(LSA_HANDLE, ULONG, PSID*,

            
                  PLSA_REFERENCED_DOMAIN_LIST*, PLSA_TRANSLATED_NAME*);

            
                ULONG LsaNtStatusToWinError(NTSTATUS);

            
                NTSTATUS LsaOpenPolicy(PLSA_UNICODE_STRING, PLSA_OBJECT_ATTRIBUTES,

            
                  ACCESS_MASK, PLSA_HANDLE);

            
                NTSTATUS LsaQueryDomainInformationPolicy(LSA_HANDLE,

            
                  POLICY_DOMAIN_INFORMATION_CLASS, PVOID*);

            
                NTSTATUS LsaQueryInformationPolicy(LSA_HANDLE, POLICY_INFORMATION_CLASS,

            
                  PVOID*);

            
                NTSTATUS LsaQueryLocalInformationPolicy(LSA_HANDLE,

            
                  POLICY_LOCAL_INFORMATION_CLASS, PVOID*);

            
                NTSTATUS LsaQueryTrustedDomainInfo(LSA_HANDLE, PSID,

            
                  TRUSTED_INFORMATION_CLASS, PVOID*);

            
                NTSTATUS LsaQueryTrustedDomainInfoByName(LSA_HANDLE, PLSA_UNICODE_STRING,

            
                  TRUSTED_INFORMATION_CLASS, PVOID*);

            
                NTSTATUS LsaRegisterLogonProcess(PLSA_STRING, PHANDLE,

            
                  PLSA_OPERATIONAL_MODE);

            
                NTSTATUS LsaRemoveAccountRights(LSA_HANDLE, PSID, BOOLEAN,

            
                  PLSA_UNICODE_STRING, ULONG);

            
                NTSTATUS LsaRetrievePrivateData(LSA_HANDLE, PLSA_UNICODE_STRING,

            
                  PLSA_UNICODE_STRING*);

            
                NTSTATUS LsaSetDomainInformationPolicy(LSA_HANDLE,

            
                  POLICY_DOMAIN_INFORMATION_CLASS, PVOID);

            
                NTSTATUS LsaSetInformationPolicy(LSA_HANDLE, POLICY_INFORMATION_CLASS,

            
                  PVOID);

            
                NTSTATUS LsaSetLocalInformationPolicy(LSA_HANDLE,

            
                  POLICY_LOCAL_INFORMATION_CLASS, PVOID);

            
                NTSTATUS LsaSetTrustedDomainInformation(LSA_HANDLE, PSID,

            
                  TRUSTED_INFORMATION_CLASS, PVOID);

            
                NTSTATUS LsaSetTrustedDomainInfoByName(LSA_HANDLE, PLSA_UNICODE_STRING,

            
                  TRUSTED_INFORMATION_CLASS, PVOID);

            
                NTSTATUS LsaStorePrivateData(LSA_HANDLE, PLSA_UNICODE_STRING,

            
                  PLSA_UNICODE_STRING);

            
            }


            alias PSAM_PASSWORD_NOTIFICATION_ROUTINE = NTSTATUS function(PUNICODE_STRING, ULONG, PUNICODE_STRING);

            
            alias PSAM_INIT_NOTIFICATION_ROUTINE = BOOLEAN function();

            
            alias PSAM_PASSWORD_FILTER_ROUTINE = BOOLEAN function(PUNICODE_STRING, PUNICODE_STRING,

            
              PUNICODE_STRING, BOOLEAN);