diff options
Diffstat (limited to 'librpc/idl/security.idl')
| -rw-r--r-- | librpc/idl/security.idl | 972 |
1 files changed, 972 insertions, 0 deletions
diff --git a/librpc/idl/security.idl b/librpc/idl/security.idl new file mode 100644 index 0000000..8783b67 --- /dev/null +++ b/librpc/idl/security.idl @@ -0,0 +1,972 @@ +#include "idl_types.h" + +/* + security IDL structures +*/ + +import "misc.idl"; + +/* + use the same structure for dom_sid2 as dom_sid. A dom_sid2 is really + just a dom sid, but with the sub_auths represented as a conformant + array. As with all in-structure conformant arrays, the array length + is placed before the start of the structure. That's what gives rise + to the extra num_auths element. We don't want the Samba code to + have to bother with such esoteric NDR details, so its easier to just + define it as a dom_sid and use pidl magic to make it all work. It + just means you need to mark a sid as a "dom_sid2" in the IDL when you + know it is of the conformant array variety +*/ +cpp_quote("#define dom_sid2 dom_sid") + +/* same struct as dom_sid but inside a 28 bytes fixed buffer in NDR */ +cpp_quote("#define dom_sid28 dom_sid") + +/* same struct as dom_sid but in a variable byte buffer, which is maybe empty in NDR */ +cpp_quote("#define dom_sid0 dom_sid") + +[ + /* + * cbf7d408-2d6c-11e2-ae5b-0b5692790e18 just to make ndrdump happy + */ + uuid("cbf7d408-2d6c-11e2-ae5b-0b5692790e18"), + version(0.0), + helper("../libcli/security/security.h"), + pyhelper("librpc/ndr/py_security.c"), + pointer_default(unique) +] +interface security +{ + + typedef bitmap lsa_SystemAccessModeFlags lsa_SystemAccessModeFlags; + + typedef [public,gensize,noprint,nosize,nopull,nopush] struct { + uint8 sid_rev_num; /**< SID revision number */ + [range(0,15)] int8 num_auths; /**< Number of sub-authorities */ + uint8 id_auth[6]; /**< Identifier Authority */ + uint32 sub_auths[15]; + } dom_sid; + /* + access masks are divided up like this: + 0xabccdddd + where + a = generic rights bits SEC_GENERIC_ + b = flags SEC_FLAG_ + c = standard rights bits SEC_STD_ + d = object type specific bits SEC_{FILE,DIR,REG,xxx}_ + + common combinations of bits are prefixed with SEC_RIGHTS_ + */ + const int SEC_MASK_GENERIC = 0xF0000000; + const int SEC_MASK_FLAGS = 0x0F000000; + const int SEC_MASK_STANDARD = 0x00FF0000; + const int SEC_MASK_SPECIFIC = 0x0000FFFF; + + /* generic bits */ + const int SEC_GENERIC_ALL = 0x10000000; + const int SEC_GENERIC_EXECUTE = 0x20000000; + const int SEC_GENERIC_WRITE = 0x40000000; + const int SEC_GENERIC_READ = 0x80000000; + + /* flag bits */ + const int SEC_FLAG_SYSTEM_SECURITY = 0x01000000; + const int SEC_FLAG_MAXIMUM_ALLOWED = 0x02000000; + + /* standard bits */ + const int SEC_STD_DELETE = 0x00010000; + const int SEC_STD_READ_CONTROL = 0x00020000; + const int SEC_STD_WRITE_DAC = 0x00040000; + const int SEC_STD_WRITE_OWNER = 0x00080000; + const int SEC_STD_SYNCHRONIZE = 0x00100000; + const int SEC_STD_REQUIRED = 0x000F0000; + const int SEC_STD_ALL = 0x001F0000; + + /* file specific bits */ + const int SEC_FILE_READ_DATA = 0x00000001; + const int SEC_FILE_WRITE_DATA = 0x00000002; + const int SEC_FILE_APPEND_DATA = 0x00000004; + const int SEC_FILE_READ_EA = 0x00000008; + const int SEC_FILE_WRITE_EA = 0x00000010; + const int SEC_FILE_EXECUTE = 0x00000020; + const int SEC_FILE_READ_ATTRIBUTE = 0x00000080; + const int SEC_FILE_WRITE_ATTRIBUTE = 0x00000100; + const int SEC_FILE_ALL = 0x000001ff; + + /* directory specific bits */ + const int SEC_DIR_LIST = 0x00000001; + const int SEC_DIR_ADD_FILE = 0x00000002; + const int SEC_DIR_ADD_SUBDIR = 0x00000004; + const int SEC_DIR_READ_EA = 0x00000008; + const int SEC_DIR_WRITE_EA = 0x00000010; + const int SEC_DIR_TRAVERSE = 0x00000020; + const int SEC_DIR_DELETE_CHILD = 0x00000040; + const int SEC_DIR_READ_ATTRIBUTE = 0x00000080; + const int SEC_DIR_WRITE_ATTRIBUTE = 0x00000100; + + /* registry entry specific bits */ + const int SEC_REG_QUERY_VALUE = 0x00000001; + const int SEC_REG_SET_VALUE = 0x00000002; + const int SEC_REG_CREATE_SUBKEY = 0x00000004; + const int SEC_REG_ENUM_SUBKEYS = 0x00000008; + const int SEC_REG_NOTIFY = 0x00000010; + const int SEC_REG_CREATE_LINK = 0x00000020; + + /* ldap specific access bits */ + const int SEC_ADS_CREATE_CHILD = 0x00000001; + const int SEC_ADS_DELETE_CHILD = 0x00000002; + const int SEC_ADS_LIST = 0x00000004; + const int SEC_ADS_SELF_WRITE = 0x00000008; + const int SEC_ADS_READ_PROP = 0x00000010; + const int SEC_ADS_WRITE_PROP = 0x00000020; + const int SEC_ADS_DELETE_TREE = 0x00000040; + const int SEC_ADS_LIST_OBJECT = 0x00000080; + const int SEC_ADS_CONTROL_ACCESS = 0x00000100; + + /* invalid bits */ + const int SEC_MASK_INVALID = 0x0ce0fe00; + + /* generic->specific mappings for files */ + const int SEC_RIGHTS_FILE_READ = SEC_STD_READ_CONTROL | + SEC_STD_SYNCHRONIZE | + SEC_FILE_READ_DATA | + SEC_FILE_READ_ATTRIBUTE | + SEC_FILE_READ_EA; + + const int SEC_RIGHTS_FILE_WRITE = SEC_STD_READ_CONTROL | + SEC_STD_SYNCHRONIZE | + SEC_FILE_WRITE_DATA | + SEC_FILE_WRITE_ATTRIBUTE | + SEC_FILE_WRITE_EA | + SEC_FILE_APPEND_DATA; + + const int SEC_RIGHTS_FILE_EXECUTE = SEC_STD_SYNCHRONIZE | + SEC_STD_READ_CONTROL | + SEC_FILE_READ_ATTRIBUTE | + SEC_FILE_EXECUTE; + + const int SEC_RIGHTS_FILE_ALL = SEC_STD_ALL | SEC_FILE_ALL; + + /* generic->specific mappings for directories (same as files) */ + const int SEC_RIGHTS_DIR_READ = SEC_RIGHTS_FILE_READ; + const int SEC_RIGHTS_DIR_WRITE = SEC_RIGHTS_FILE_WRITE; + const int SEC_RIGHTS_DIR_EXECUTE = SEC_RIGHTS_FILE_EXECUTE; + const int SEC_RIGHTS_DIR_ALL = SEC_RIGHTS_FILE_ALL; + + /* rights granted by some specific privileges */ + const int SEC_RIGHTS_PRIV_BACKUP = SEC_STD_READ_CONTROL | + SEC_FLAG_SYSTEM_SECURITY | + SEC_RIGHTS_FILE_READ | + SEC_DIR_TRAVERSE; + + const int SEC_RIGHTS_PRIV_RESTORE = SEC_STD_WRITE_DAC | + SEC_STD_WRITE_OWNER | + SEC_FLAG_SYSTEM_SECURITY | + SEC_RIGHTS_FILE_WRITE | + SEC_DIR_ADD_FILE | + SEC_DIR_ADD_SUBDIR | + SEC_STD_DELETE; + + /* combinations of standard masks. */ + const int STANDARD_RIGHTS_ALL_ACCESS = SEC_STD_ALL; /* 0x001f0000 */ + const int STANDARD_RIGHTS_MODIFY_ACCESS = SEC_STD_READ_CONTROL; /* 0x00020000 */ + const int STANDARD_RIGHTS_EXECUTE_ACCESS = SEC_STD_READ_CONTROL; /* 0x00020000 */ + const int STANDARD_RIGHTS_READ_ACCESS = SEC_STD_READ_CONTROL; /* 0x00020000 */ + const int STANDARD_RIGHTS_WRITE_ACCESS = + (SEC_STD_WRITE_OWNER | + SEC_STD_WRITE_DAC | + SEC_STD_DELETE); /* 0x000d0000 */ + const int STANDARD_RIGHTS_REQUIRED_ACCESS = + (SEC_STD_DELETE | + SEC_STD_READ_CONTROL | + SEC_STD_WRITE_DAC | + SEC_STD_WRITE_OWNER); /* 0x000f0000 */ + + /* generic->specific mappings for Directory Service objects */ + /* directory specific part of GENERIC_ALL */ + const int SEC_ADS_GENERIC_ALL_DS = + (SEC_STD_DELETE | + SEC_STD_WRITE_DAC | + SEC_STD_WRITE_OWNER | + SEC_ADS_CREATE_CHILD | + SEC_ADS_DELETE_CHILD | + SEC_ADS_DELETE_TREE | + SEC_ADS_CONTROL_ACCESS); + const int SEC_ADS_GENERIC_EXECUTE = SEC_STD_READ_CONTROL | SEC_ADS_LIST; + const int SEC_ADS_GENERIC_WRITE = + (SEC_STD_READ_CONTROL | + SEC_ADS_SELF_WRITE | + SEC_ADS_WRITE_PROP); + const int SEC_ADS_GENERIC_READ = + (SEC_STD_READ_CONTROL | + SEC_ADS_LIST | + SEC_ADS_READ_PROP | + SEC_ADS_LIST_OBJECT); + const int SEC_ADS_GENERIC_ALL = + (SEC_ADS_GENERIC_EXECUTE | + SEC_ADS_GENERIC_WRITE | + SEC_ADS_GENERIC_READ | + SEC_ADS_GENERIC_ALL_DS); + + /* + * Rights implicitly granted to a user who is an owner of the security + * descriptor being processed. + */ + typedef enum { + IMPLICIT_OWNER_READ_CONTROL_RIGHTS, + IMPLICIT_OWNER_READ_CONTROL_AND_WRITE_DAC_RIGHTS + } implicit_owner_rights; + + /***************************************************************/ + /* WELL KNOWN SIDS */ + + /* a NULL sid */ + const string SID_NULL = "S-1-0-0"; + + /* the world domain */ + const string NAME_WORLD = "WORLD"; + + const string SID_WORLD_DOMAIN = "S-1-1"; + const string SID_WORLD = "S-1-1-0"; + + /* SECURITY_CREATOR_SID_AUTHORITY */ + const string SID_CREATOR_OWNER_DOMAIN = "S-1-3"; + const string SID_CREATOR_OWNER = "S-1-3-0"; + const string SID_CREATOR_GROUP = "S-1-3-1"; + const string SID_OWNER_RIGHTS = "S-1-3-4"; + + /* SECURITY_NT_AUTHORITY */ + const string NAME_NT_AUTHORITY = "NT AUTHORITY"; + + const string SID_NT_AUTHORITY = "S-1-5"; + const string SID_NT_DIALUP = "S-1-5-1"; + const string SID_NT_NETWORK = "S-1-5-2"; + const string SID_NT_BATCH = "S-1-5-3"; + const string SID_NT_INTERACTIVE = "S-1-5-4"; + const string SID_NT_SERVICE = "S-1-5-6"; + const string SID_NT_ANONYMOUS = "S-1-5-7"; + const string SID_NT_PROXY = "S-1-5-8"; + const string SID_NT_ENTERPRISE_DCS = "S-1-5-9"; + const string SID_NT_SELF = "S-1-5-10"; + const string SID_NT_AUTHENTICATED_USERS = "S-1-5-11"; + const string SID_NT_RESTRICTED = "S-1-5-12"; + const string SID_NT_TERMINAL_SERVER_USERS = "S-1-5-13"; + const string SID_NT_REMOTE_INTERACTIVE = "S-1-5-14"; + const string SID_NT_THIS_ORGANISATION = "S-1-5-15"; + const string SID_NT_IUSR = "S-1-5-17"; + const string SID_NT_SYSTEM = "S-1-5-18"; + const string SID_NT_LOCAL_SERVICE = "S-1-5-19"; + const string SID_NT_NETWORK_SERVICE = "S-1-5-20"; + const string SID_NT_DIGEST_AUTHENTICATION = "S-1-5-64-21"; + const string SID_NT_NTLM_AUTHENTICATION = "S-1-5-64-10"; + const string SID_NT_SCHANNEL_AUTHENTICATION = "S-1-5-64-14"; + const string SID_NT_OTHER_ORGANISATION = "S-1-5-1000"; + + /* SECURITY_BUILTIN_DOMAIN_RID */ + const string NAME_BUILTIN = "BUILTIN"; + + const string SID_BUILTIN = "S-1-5-32"; + const string SID_BUILTIN_ADMINISTRATORS = "S-1-5-32-544"; + const string SID_BUILTIN_USERS = "S-1-5-32-545"; + const string SID_BUILTIN_GUESTS = "S-1-5-32-546"; + const string SID_BUILTIN_POWER_USERS = "S-1-5-32-547"; + const string SID_BUILTIN_ACCOUNT_OPERATORS = "S-1-5-32-548"; + const string SID_BUILTIN_SERVER_OPERATORS = "S-1-5-32-549"; + const string SID_BUILTIN_PRINT_OPERATORS = "S-1-5-32-550"; + const string SID_BUILTIN_BACKUP_OPERATORS = "S-1-5-32-551"; + const string SID_BUILTIN_REPLICATOR = "S-1-5-32-552"; + const string SID_BUILTIN_RAS_SERVERS = "S-1-5-32-553"; + const string SID_BUILTIN_PREW2K = "S-1-5-32-554"; + const string SID_BUILTIN_REMOTE_DESKTOP_USERS = "S-1-5-32-555"; + const string SID_BUILTIN_NETWORK_CONF_OPERATORS = "S-1-5-32-556"; + const string SID_BUILTIN_INCOMING_FOREST_TRUST = "S-1-5-32-557"; + const string SID_BUILTIN_PERFMON_USERS = "S-1-5-32-558"; + const string SID_BUILTIN_PERFLOG_USERS = "S-1-5-32-559"; + const string SID_BUILTIN_AUTH_ACCESS = "S-1-5-32-560"; + const string SID_BUILTIN_TS_LICENSE_SERVERS = "S-1-5-32-561"; + const string SID_BUILTIN_DISTRIBUTED_COM_USERS = "S-1-5-32-562"; + const string SID_BUILTIN_IUSERS = "S-1-5-32-568"; + const string SID_BUILTIN_CRYPTO_OPERATORS = "S-1-5-32-569"; + const string SID_BUILTIN_EVENT_LOG_READERS = "S-1-5-32-573"; + const string SID_BUILTIN_CERT_SERV_DCOM_ACCESS = "S-1-5-32-574"; + const string SID_BUILTIN_RDS_REMOTE_ACCESS_SERVERS = "S-1-5-32-575"; + const string SID_BUILTIN_RDS_ENDPOINT_SERVERS = "S-1-5-32-576"; + const string SID_BUILTIN_RDS_MANAGEMENT_SERVERS = "S-1-5-32-577"; + const string SID_BUILTIN_HYPER_V_ADMINS = "S-1-5-32-578"; + const string SID_BUILTIN_ACCESS_CONTROL_ASSISTANCE_OPS = "S-1-5-32-579"; + const string SID_BUILTIN_REMOTE_MANAGEMENT_USERS = "S-1-5-32-580"; + const string SID_BUILTIN_SYSTEM_MANAGED_ACCOUNTS_GRP = "S-1-5-32-581"; + const string SID_BUILTIN_STORAGE_REPLICA_ADMINISTRATORS = "S-1-5-32-582"; + + const string SID_SECURITY_RESTRICTED_CODE = "S-1-5-33"; + + /* UID/GID mapping Samba style */ + const string SID_SAMBA_UNIX_USER_OWNER = "S-1-22-1"; + const string SID_SAMBA_UNIX_GROUP_OWNER = "S-1-22-2"; + + /* SECURITY_NT_SERVICE */ + const string NAME_NT_SERVICE = "NT SERVICE"; + + const string SID_NT_NT_SERVICE = "S-1-5-80"; + const string SID_NT_TRUSTED_INSTALLER = + "S-1-5-80-956008885-3418522649-1831038044-1853292631-2271478464"; + + /* + * This is added during the AS-REQ/AS-REP exchange after + * pre-authentication was successful. + */ + const string SID_AUTHENTICATION_AUTHORITY_ASSERTED_IDENTITY = "S-1-18-1"; + /* + * This is added during S4U2Self PAC creation. + * + * It won't replace a possible + * SID_AUTHENTICATION_AUTHORITY_ASSERTED_IDENTITY + * during S4U2Proxy. + */ + const string SID_SERVICE_ASSERTED_IDENTITY = "S-1-18-2"; + + const string SID_COMPOUNDED_AUTHENTICATION = "S-1-5-21-0-0-0-496"; + const string SID_CLAIMS_VALID = "S-1-5-21-0-0-0-497"; + + const string SID_USER_MODE_DRIVERS = "S-1-5-84-0-0-0-0-0"; + + const string SID_SECURITY_BUILTIN_PACKAGE_ANY_PACKAGE = "S-1-15-2-1"; + + const string SID_SECURITY_MANDATORY_LOW = "S-1-16-4096"; + const string SID_SECURITY_MANDATORY_MEDIUM = "S-1-16-8192"; + const string SID_SECURITY_MANDATORY_MEDIUM_PLUS = "S-1-16-8448"; + const string SID_SECURITY_MANDATORY_HIGH = "S-1-16-12288"; + const string SID_SECURITY_MANDATORY_SYSTEM = "S-1-16-16384"; + + /* + * http://technet.microsoft.com/en-us/library/hh509017(v=ws.10).aspx + */ + const string SID_NT_NFS_SUBSYSTEM = "S-1-5-88"; + const string SID_NT_NFS_USER = "S-1-5-88-1"; + const string SID_NT_NFS_GROUP = "S-1-5-88-2"; + const string SID_NT_NFS_MASK = "S-1-5-88-3"; + const string SID_NT_NFS_OTHERS = "S-1-5-88-4"; + + /* well-known domain RIDs */ + const int DOMAIN_RID_LOGON = 9; + const int DOMAIN_RID_ENTERPRISE_READONLY_DCS = 498; + const int DOMAIN_RID_ADMINISTRATOR = 500; + const int DOMAIN_RID_GUEST = 501; + const int DOMAIN_RID_KRBTGT = 502; + const int DOMAIN_RID_ADMINS = 512; + const int DOMAIN_RID_USERS = 513; + const int DOMAIN_RID_GUESTS = 514; + const int DOMAIN_RID_DOMAIN_MEMBERS = 515; + const int DOMAIN_RID_DCS = 516; + const int DOMAIN_RID_CERT_ADMINS = 517; + const int DOMAIN_RID_SCHEMA_ADMINS = 518; + const int DOMAIN_RID_ENTERPRISE_ADMINS = 519; + const int DOMAIN_RID_POLICY_ADMINS = 520; + const int DOMAIN_RID_READONLY_DCS = 521; + const int DOMAIN_RID_CLONEABLE_CONTROLLERS = 522; + const int DOMAIN_RID_PROTECTED_USERS = 525; + const int DOMAIN_RID_KEY_ADMINS = 526; + const int DOMAIN_RID_ENTERPRISE_KEY_ADMINS = 527; + const int DOMAIN_RID_RAS_SERVERS = 553; + const int DOMAIN_RID_RODC_ALLOW = 571; + const int DOMAIN_RID_RODC_DENY = 572; + + /* well-known builtin RIDs */ + const int BUILTIN_RID_ADMINISTRATORS = 544; + const int BUILTIN_RID_USERS = 545; + const int BUILTIN_RID_GUESTS = 546; + const int BUILTIN_RID_POWER_USERS = 547; + const int BUILTIN_RID_ACCOUNT_OPERATORS = 548; + const int BUILTIN_RID_SERVER_OPERATORS = 549; + const int BUILTIN_RID_PRINT_OPERATORS = 550; + const int BUILTIN_RID_BACKUP_OPERATORS = 551; + const int BUILTIN_RID_REPLICATOR = 552; + const int BUILTIN_RID_RAS_SERVERS = 553; + const int BUILTIN_RID_PRE_2K_ACCESS = 554; + const int BUILTIN_RID_REMOTE_DESKTOP_USERS = 555; + const int BUILTIN_RID_NETWORK_CONF_OPERATORS = 556; + const int BUILTIN_RID_INCOMING_FOREST_TRUST = 557; + const int BUILTIN_RID_PERFMON_USERS = 558; + const int BUILTIN_RID_PERFLOG_USERS = 559; + const int BUILTIN_RID_AUTH_ACCESS = 560; + const int BUILTIN_RID_TS_LICENSE_SERVERS = 561; + const int BUILTIN_RID_DISTRIBUTED_COM_USERS = 562; + const int BUILTIN_RID_IUSERS = 568; + const int BUILTIN_RID_CRYPTO_OPERATORS = 569; + const int BUILTIN_RID_EVENT_LOG_READERS = 573; + const int BUILTIN_RID_CERT_SERV_DCOM_ACCESS = 574; + const int BUILTIN_RID_RDS_REMOTE_ACCESS_SERVERS = 575; + const int BUILTIN_RID_RDS_ENDPOINT_SERVERS = 576; + const int BUILTIN_RID_RDS_MANAGEMENT_SERVERS = 577; + const int BUILTIN_RID_HYPER_V_ADMINS = 578; + const int BUILTIN_RID_ACCESS_CONTROL_ASSISTANCE_OPS = 579; + const int BUILTIN_RID_REMOTE_MANAGEMENT_USERS = 580; + +/******************************************************************** + This is a list of privileges reported by a WIndows 2008 R2 DC + just for reference purposes (and I know the LUID is not guaranteed + across reboots): + +0x00000002 SeCreateTokenPrivilege "Create a token object" +0x00000003 SeAssignPrimaryTokenPrivilege "Replace a process level token" +0x00000004 SeLockMemoryPrivilege "Lock pages in memory" +0x00000005 SeIncreaseQuotaPrivilege "Adjust memory quotas for a process" +0x00000006 SeMachineAccountPrivilege "Add workstations to domain" +0x00000007 SeTcbPrivilege "Act as part of the operating system" +0x00000008 SeSecurityPrivilege "Manage auditing and security log" +0x00000009 SeTakeOwnershipPrivilege "Take ownership of files or other objects" +0x0000000a SeLoadDriverPrivilege "Load and unload device drivers" +0x0000000b SeSystemProfilePrivilege "Profile system performance" +0x0000000c SeSystemtimePrivilege "Change the system time" +0x0000000d SeProfileSingleProcessPrivilege "Profile single process" +0x0000000e SeIncreaseBasePriorityPrivilege "Increase scheduling priority" +0x0000000f SeCreatePagefilePrivilege "Create a pagefile" +0x00000010 SeCreatePermanentPrivilege "Create permanent shared objects" +0x00000011 SeBackupPrivilege "Back up files and directories" +0x00000012 SeRestorePrivilege "Restore files and directories" +0x00000013 SeShutdownPrivilege "Shut down the system" +0x00000014 SeDebugPrivilege "Debug programs" +0x00000015 SeAuditPrivilege "Generate security audits" +0x00000016 SeSystemEnvironmentPrivilege "Modify firmware environment values" +0x00000017 SeChangeNotifyPrivilege "Bypass traverse checking" +0x00000018 SeRemoteShutdownPrivilege "Force shutdown from a remote system" +0x00000019 SeUndockPrivilege "Remove computer from docking station" +0x0000001a SeSyncAgentPrivilege "Synchronize directory service data" +0x0000001b SeEnableDelegationPrivilege "Enable computer and user accounts to be trusted for delegation" +0x0000001c SeManageVolumePrivilege "Perform volume maintenance tasks" +0x0000001d SeImpersonatePrivilege "Impersonate a client after authentication" +0x0000001e SeCreateGlobalPrivilege "Create global objects" +0x0000001f SeTrustedCredManAccessPrivilege "Access Credential Manager as a trusted caller" +0x00000020 SeRelabelPrivilege "Modify an object label" +0x00000021 SeIncreaseWorkingSetPrivilege "Increase a process working set" +0x00000022 SeTimeZonePrivilege "Change the time zone" +0x00000023 SeCreateSymbolicLinkPrivilege "Create symbolic links" + + ********************************************************************/ + + /* LUID values for privileges known about by Samba (bottom 32 bits of enum, top bits are 0) */ + + /* we have to define the LUID here due to a horrible check by printmig.exe + that requires the SeBackupPrivilege match what is in Windows. So match + those that we implement and start Samba privileges at 0x1001 */ + + typedef enum { + SEC_PRIV_INVALID = 0x0, + SEC_PRIV_INCREASE_QUOTA = 0x5, + SEC_PRIV_MACHINE_ACCOUNT = 0x6, + SEC_PRIV_SECURITY = 0x8, + SEC_PRIV_TAKE_OWNERSHIP = 0x09, + SEC_PRIV_LOAD_DRIVER = 0x0a, + SEC_PRIV_SYSTEM_PROFILE = 0x0b, + SEC_PRIV_SYSTEMTIME = 0x0c, + SEC_PRIV_PROFILE_SINGLE_PROCESS = 0x0d, + SEC_PRIV_INCREASE_BASE_PRIORITY = 0x0e, + SEC_PRIV_CREATE_PAGEFILE = 0x0f, + SEC_PRIV_BACKUP = 0x11, + SEC_PRIV_RESTORE = 0x12, + SEC_PRIV_SHUTDOWN = 0x13, + SEC_PRIV_DEBUG = 0x14, + SEC_PRIV_SYSTEM_ENVIRONMENT = 0x16, + SEC_PRIV_CHANGE_NOTIFY = 0x17, + SEC_PRIV_REMOTE_SHUTDOWN = 0x18, + SEC_PRIV_UNDOCK = 0x19, + SEC_PRIV_ENABLE_DELEGATION = 0x1b, + SEC_PRIV_MANAGE_VOLUME = 0x1c, + SEC_PRIV_IMPERSONATE = 0x1d, + SEC_PRIV_CREATE_GLOBAL = 0x1e, + /* Samba-specific privs */ + SEC_PRIV_PRINT_OPERATOR = 0x1001, + SEC_PRIV_ADD_USERS = 0x1002, + SEC_PRIV_DISK_OPERATOR = 0x1003 + } sec_privilege; + + + /* Bitmap of privilege values for internal use only. We need + * our own bitmap here as privileges.tdb records these values + * as a bitmap (privileges.ldb uses the string forms). + */ + typedef [bitmap64bit] bitmap { + SEC_PRIV_MACHINE_ACCOUNT_BIT = 0x00000010, + + /* Samba-specific privs */ + SEC_PRIV_PRINT_OPERATOR_BIT = 0x00000020, + SEC_PRIV_ADD_USERS_BIT = 0x00000040, + SEC_PRIV_DISK_OPERATOR_BIT = 0x00000080, + + SEC_PRIV_REMOTE_SHUTDOWN_BIT = 0x00000100, + SEC_PRIV_BACKUP_BIT = 0x00000200, + SEC_PRIV_RESTORE_BIT = 0x00000400, + SEC_PRIV_TAKE_OWNERSHIP_BIT = 0x00000800, + /* End of privileges implemented before merge to common code */ + + SEC_PRIV_INCREASE_QUOTA_BIT = 0x00001000, + SEC_PRIV_SECURITY_BIT = 0x00002000, + SEC_PRIV_LOAD_DRIVER_BIT = 0x00004000, + SEC_PRIV_SYSTEM_PROFILE_BIT = 0x00008000, + SEC_PRIV_SYSTEMTIME_BIT = 0x00010000, + SEC_PRIV_PROFILE_SINGLE_PROCESS_BIT = 0x00020000, + SEC_PRIV_INCREASE_BASE_PRIORITY_BIT = 0x00040000, + SEC_PRIV_CREATE_PAGEFILE_BIT = 0x00080000, + SEC_PRIV_SHUTDOWN_BIT = 0x00100000, + SEC_PRIV_DEBUG_BIT = 0x00200000, + SEC_PRIV_SYSTEM_ENVIRONMENT_BIT = 0x00400000, + SEC_PRIV_CHANGE_NOTIFY_BIT = 0x00800000, + SEC_PRIV_UNDOCK_BIT = 0x01000000, + SEC_PRIV_ENABLE_DELEGATION_BIT = 0x02000000, + SEC_PRIV_MANAGE_VOLUME_BIT = 0x04000000, + SEC_PRIV_IMPERSONATE_BIT = 0x08000000, + SEC_PRIV_CREATE_GLOBAL_BIT = 0x10000000 + } se_privilege; + + typedef [bitmap32bit] bitmap { + LSA_POLICY_MODE_INTERACTIVE = 0x00000001, + LSA_POLICY_MODE_NETWORK = 0x00000002, + LSA_POLICY_MODE_BATCH = 0x00000004, + LSA_POLICY_MODE_SERVICE = 0x00000010, + LSA_POLICY_MODE_PROXY = 0x00000020, + LSA_POLICY_MODE_DENY_INTERACTIVE = 0x00000040, + LSA_POLICY_MODE_DENY_NETWORK = 0x00000080, + LSA_POLICY_MODE_DENY_BATCH = 0x00000100, + LSA_POLICY_MODE_DENY_SERVICE = 0x00000200, + LSA_POLICY_MODE_REMOTE_INTERACTIVE = 0x00000400, + LSA_POLICY_MODE_DENY_REMOTE_INTERACTIVE = 0x00000800, + LSA_POLICY_MODE_ALL = 0x00000FF7, + LSA_POLICY_MODE_ALL_NT4 = 0x00000037 + } lsa_SystemAccessModeFlags; + + typedef [public,bitmap8bit] bitmap { + SEC_ACE_FLAG_OBJECT_INHERIT = 0x01, + SEC_ACE_FLAG_CONTAINER_INHERIT = 0x02, + SEC_ACE_FLAG_NO_PROPAGATE_INHERIT = 0x04, + SEC_ACE_FLAG_INHERIT_ONLY = 0x08, + SEC_ACE_FLAG_INHERITED_ACE = 0x10, + SEC_ACE_FLAG_VALID_INHERIT = 0x0f, + SEC_ACE_FLAG_SUCCESSFUL_ACCESS = 0x40, + SEC_ACE_FLAG_FAILED_ACCESS = 0x80 + } security_ace_flags; + + typedef [public,enum8bit] enum { + /* + * The following entries tagged *reserved* have been + * named and allocated by Microsoft but apparently not + * implemented (MS-DTYP 2.4.4.1). + * + * The entries marked *unused* are more or less + * completely ignored by Samba. + */ + SEC_ACE_TYPE_ACCESS_ALLOWED = 0, + SEC_ACE_TYPE_ACCESS_DENIED = 1, + SEC_ACE_TYPE_SYSTEM_AUDIT = 2, + SEC_ACE_TYPE_SYSTEM_ALARM = 3, /* reserved */ + SEC_ACE_TYPE_ALLOWED_COMPOUND = 4, /* reserved */ + SEC_ACE_TYPE_ACCESS_ALLOWED_OBJECT = 5, + SEC_ACE_TYPE_ACCESS_DENIED_OBJECT = 6, + SEC_ACE_TYPE_SYSTEM_AUDIT_OBJECT = 7, + SEC_ACE_TYPE_SYSTEM_ALARM_OBJECT = 8, /* reserved */ + SEC_ACE_TYPE_ACCESS_ALLOWED_CALLBACK = 9, + SEC_ACE_TYPE_ACCESS_DENIED_CALLBACK = 10, + SEC_ACE_TYPE_ACCESS_ALLOWED_CALLBACK_OBJECT = 11, + SEC_ACE_TYPE_ACCESS_DENIED_CALLBACK_OBJECT = 12, + SEC_ACE_TYPE_SYSTEM_AUDIT_CALLBACK = 13, + SEC_ACE_TYPE_SYSTEM_ALARM_CALLBACK = 14, /* reserved */ + SEC_ACE_TYPE_SYSTEM_AUDIT_CALLBACK_OBJECT = 15, + SEC_ACE_TYPE_SYSTEM_ALARM_CALLBACK_OBJECT = 16, /* reserved */ + SEC_ACE_TYPE_SYSTEM_MANDATORY_LABEL = 17, /*unused */ + SEC_ACE_TYPE_SYSTEM_RESOURCE_ATTRIBUTE = 18, + SEC_ACE_TYPE_SYSTEM_SCOPED_POLICY_ID = 19 /* unused */ + } security_ace_type; + + typedef [bitmap32bit] bitmap { + SEC_ACE_OBJECT_TYPE_PRESENT = 0x00000001, + SEC_ACE_INHERITED_OBJECT_TYPE_PRESENT = 0x00000002 + } security_ace_object_flags; + + typedef [nodiscriminant] union { + /* this is the 'schemaIDGUID' attribute of the attribute object in the schema naming context */ + [case(SEC_ACE_OBJECT_TYPE_PRESENT)] GUID type; + [default]; + } security_ace_object_type; + + typedef [nodiscriminant] union { + /* this is the 'schemaIDGUID' attribute of the objectclass object in the schema naming context + * (of the parent container) + */ + [case(SEC_ACE_INHERITED_OBJECT_TYPE_PRESENT)] GUID inherited_type; + [default]; + } security_ace_object_inherited_type; + + typedef struct { + security_ace_object_flags flags; + [switch_is(flags & SEC_ACE_OBJECT_TYPE_PRESENT)] security_ace_object_type type; + [switch_is(flags & SEC_ACE_INHERITED_OBJECT_TYPE_PRESENT)] security_ace_object_inherited_type inherited_type; + } security_ace_object; + + + + /* + * flags that might occur in + * CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1.flags. + * + * Not all of them do anything. Conditional ACEs also use some + * of these flags. + */ + typedef [bitmap32bit] bitmap { + CLAIM_SECURITY_ATTRIBUTE_NON_INHERITABLE = 1, + CLAIM_SECURITY_ATTRIBUTE_VALUE_CASE_SENSITIVE = 2, + CLAIM_SECURITY_ATTRIBUTE_USE_FOR_DENY_ONLY = 4, /*reserved*/ + CLAIM_SECURITY_ATTRIBUTE_DISABLED_BY_DEFAULT = 8, + CLAIM_SECURITY_ATTRIBUTE_DISABLED = 0x10, /*reserved*/ + CLAIM_SECURITY_ATTRIBUTE_MANDATORY = 0x20, + + /* + * These next two are curiously defined in [MS-DTYP] 2.4.10.1: + * + * > Flags: The upper two bytes of this DWORD are available for + * > application-specific data. The two lowest-order bits in the + * > lower of these two bytes are reserved. These two bytes + * > MAY contain only one of the following values in those two + * > bits: + * > + * > FCI_CLAIM_SECURITY_ATTRIBUTE_MANUAL 0x0001 + * > FCI_CLAIM_SECURITY_ATTRIBUTE_POLICY_DERIVED 0x0002 + * + * That is saying these mutually exclusive flags have offset + * values that are measured from the middle of flags field. We + * instead measure from the start. + */ + CLAIM_SECURITY_ATTRIBUTE_MANUAL = 1 << 16, + CLAIM_SECURITY_ATTRIBUTE_POLICY_DERIVED = 1 << 17, + + /* + * As the quote from [MS-DTYP] 2.4.10.1 above says, + * the upper 14 bits are for application-specific + * data. In Samba's case, we have one application + * specific flag to help us remember when we have + * sorted a claim and checked that it contains no + * duplicate values. We need to check this, and the + * check can be expensive, so it helps to remember. + * Having the values sorted is useful for comparisons + * in conditional ACEs. + * + * We can't just sort every claim_v1 we see, because + * resource attribute ACEs in SACLs contain them and + * are not meant to be evaluated prematurely (i.e. you + * can parse and reserialise a SACL even if it + * contains an ACE that would cause an error when used + * as a claim). + * + * In the case of string claims, evaluating uniqueness + * depends on the _CASE_SENSITIVE flag. + */ + CLAIM_SECURITY_ATTRIBUTE_UNIQUE_AND_SORTED = 1 << 30, + /* + * Conditional ACEs use some of the above flags in + * combination with an internal one defined in + * conditional_ace.idl. + * This next definition is warning us in case a clash + * develops (which seems very unlikely). + */ + CLAIM_SECURITY_ATTRIBUTE_RESERVED_FOR_SAMBA = 1UL << 31 + } claim_flags; + + /* + * These claim types for v1 claims mirror those of on-the-wire + * PAC claims, but not conditional ace literal token types. + */ + typedef [public] enum { + CLAIM_SECURITY_ATTRIBUTE_TYPE_INT64 = 0x0001, + CLAIM_SECURITY_ATTRIBUTE_TYPE_UINT64 = 0x0002, + CLAIM_SECURITY_ATTRIBUTE_TYPE_STRING = 0x0003, + CLAIM_SECURITY_ATTRIBUTE_TYPE_SID = 0x0005, + CLAIM_SECURITY_ATTRIBUTE_TYPE_BOOLEAN = 0x0006, + CLAIM_SECURITY_ATTRIBUTE_TYPE_OCTET_STRING = 0x0010 + } security_claim_value_type; + + typedef [nodiscriminant,flag(NDR_NOALIGN)] union { + [case(CLAIM_SECURITY_ATTRIBUTE_TYPE_INT64),relative] int64 *int_value; + [case(CLAIM_SECURITY_ATTRIBUTE_TYPE_UINT64),relative] hyper *uint_value; + [case(CLAIM_SECURITY_ATTRIBUTE_TYPE_STRING),relative] nstring *string_value; + [case(CLAIM_SECURITY_ATTRIBUTE_TYPE_SID),relative] DATA_BLOB *sid_value; + [case(CLAIM_SECURITY_ATTRIBUTE_TYPE_OCTET_STRING),relative] DATA_BLOB *octet_value; + [case(CLAIM_SECURITY_ATTRIBUTE_TYPE_BOOLEAN),relative] hyper *uint_value; + } claim_values; + + typedef [public,gensize] struct { + [relative] nstring *name; + uint16 value_type; + uint32 flags; + uint32 value_count; + [switch_is(value_type)] claim_values values[value_count]; + } CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1; + + typedef [public,nodiscriminant] union { + [default] security_ace_object object; + [case(false)]; + } security_ace_object_ctr; + + typedef [public,nodiscriminant,gensize] union { + [case(SEC_ACE_TYPE_ACCESS_ALLOWED_CALLBACK)] [flag(NDR_REMAINING)] DATA_BLOB conditions; + [case(SEC_ACE_TYPE_ACCESS_DENIED_CALLBACK)] [flag(NDR_REMAINING)] DATA_BLOB conditions; + [case(SEC_ACE_TYPE_ACCESS_ALLOWED_CALLBACK_OBJECT)] [flag(NDR_REMAINING)] DATA_BLOB conditions; + [case(SEC_ACE_TYPE_ACCESS_DENIED_CALLBACK_OBJECT)] [flag(NDR_REMAINING)] DATA_BLOB conditions; + [case(SEC_ACE_TYPE_SYSTEM_AUDIT_CALLBACK)] [flag(NDR_REMAINING)] DATA_BLOB conditions; + [case(SEC_ACE_TYPE_SYSTEM_AUDIT_CALLBACK_OBJECT)] [flag(NDR_REMAINING)] DATA_BLOB conditions; + + [case(SEC_ACE_TYPE_SYSTEM_RESOURCE_ATTRIBUTE)] CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1 claim; + [default][flag(NDR_REMAINING)] DATA_BLOB ignored; + } security_ace_coda; + + typedef [public,gensize,nosize,nopush,nopull] struct { + security_ace_type type; /* SEC_ACE_TYPE_* */ + security_ace_flags flags; /* SEC_ACE_FLAG_* */ + [value(ndr_size_security_ace(r,ndr->flags))] uint16 size; + uint32 access_mask; + [switch_is(sec_ace_object(type))] security_ace_object_ctr object; + dom_sid trustee; + [switch_is(type), subcontext(0), subcontext_size(ndr_subcontext_size_of_ace_coda(r, size, ndr->flags))] security_ace_coda coda; + } security_ace; + + typedef enum { + SECURITY_ACL_REVISION_NT4 = 2, + SECURITY_ACL_REVISION_ADS = 4 + } security_acl_revision; + + const uint NT4_ACL_REVISION = SECURITY_ACL_REVISION_NT4; + + typedef [public,gensize,nosize] struct { + security_acl_revision revision; + [value(ndr_size_security_acl(r,ndr->flags))] uint16 size; + [range(0,2000)] uint32 num_aces; + security_ace aces[num_aces]; + } security_acl; + + /* default revision for new ACLs */ + typedef [public,enum8bit] enum { + SECURITY_DESCRIPTOR_REVISION_1 = 1 + } security_descriptor_revision; + + const int SD_REVISION = SECURITY_DESCRIPTOR_REVISION_1; + + /* security_descriptor->type bits */ + typedef [public,bitmap16bit] bitmap { + SEC_DESC_OWNER_DEFAULTED = 0x0001, + SEC_DESC_GROUP_DEFAULTED = 0x0002, + SEC_DESC_DACL_PRESENT = 0x0004, + SEC_DESC_DACL_DEFAULTED = 0x0008, + SEC_DESC_SACL_PRESENT = 0x0010, + SEC_DESC_SACL_DEFAULTED = 0x0020, + SEC_DESC_DACL_TRUSTED = 0x0040, + SEC_DESC_SERVER_SECURITY = 0x0080, + SEC_DESC_DACL_AUTO_INHERIT_REQ = 0x0100, + SEC_DESC_SACL_AUTO_INHERIT_REQ = 0x0200, + SEC_DESC_DACL_AUTO_INHERITED = 0x0400, + SEC_DESC_SACL_AUTO_INHERITED = 0x0800, + SEC_DESC_DACL_PROTECTED = 0x1000, + SEC_DESC_SACL_PROTECTED = 0x2000, + SEC_DESC_RM_CONTROL_VALID = 0x4000, + SEC_DESC_SELF_RELATIVE = 0x8000 + } security_descriptor_type; + + typedef [gensize,nosize,public,flag(NDR_LITTLE_ENDIAN)] struct { + security_descriptor_revision revision; + security_descriptor_type type; /* SEC_DESC_xxxx flags */ + [relative] dom_sid *owner_sid; + [relative] dom_sid *group_sid; + [relative] security_acl *sacl; /* system ACL */ + [relative] security_acl *dacl; /* user (discretionary) ACL */ + } security_descriptor; + + typedef [public] struct { + [range(0,0x40000),value(ndr_size_security_descriptor(sd,ndr->flags))] uint32 sd_size; + [subcontext(4)] security_descriptor *sd; + } sec_desc_buf; + + /* Group attributes, used to be samr_GroupAttrs */ + typedef [public,bitmap32bit] bitmap { + SE_GROUP_MANDATORY = 0x00000001, + SE_GROUP_ENABLED_BY_DEFAULT = 0x00000002, + SE_GROUP_ENABLED = 0x00000004, + SE_GROUP_OWNER = 0x00000008, + SE_GROUP_USE_FOR_DENY_ONLY = 0x00000010, + SE_GROUP_INTEGRITY = 0x00000020, + SE_GROUP_INTEGRITY_ENABLED = 0x00000040, + SE_GROUP_RESOURCE = 0x20000000, + SE_GROUP_LOGON_ID = 0xC0000000 + } security_GroupAttrs; + + const uint32 SE_GROUP_DEFAULT_FLAGS = + SE_GROUP_MANDATORY | + SE_GROUP_ENABLED_BY_DEFAULT | + SE_GROUP_ENABLED; + + /* + * Should claims be evaluated on this token? + * + * 0 is invalid to catch a zeroed token + */ + typedef enum { + CLAIMS_EVALUATION_INVALID_STATE=0, + CLAIMS_EVALUATION_NEVER = 1, + CLAIMS_EVALUATION_ALWAYS = 2 + } claims_evaluation_control; + + /* + * This is linearised to pass authentication over the NP proxy + * from smbd to RPC servers, but is not in public network protocols + */ + typedef [public] struct { + uint32 num_sids; + [size_is(num_sids)] dom_sid sids[*]; + se_privilege privilege_mask; + lsa_SystemAccessModeFlags rights_mask; + uint32 num_local_claims; + uint32 num_user_claims; + uint32 num_device_claims; + uint32 num_device_sids; + [size_is(num_local_claims)] CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1 local_claims[*]; + [size_is(num_user_claims)] CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1 user_claims[*]; + [size_is(num_device_claims)] CLAIM_SECURITY_ATTRIBUTE_RELATIVE_V1 device_claims[*]; + [size_is(num_device_sids)] dom_sid device_sids[*]; + + /* + * This allows us to disable claims evaluation on a + * per-token basis, allowing library code to remain + * distinct from configuration by passing this in as a + * flag here + */ + claims_evaluation_control evaluate_claims; + } security_token; + + typedef [public] struct { + security_token token; + security_descriptor sd; + uint32 access_desired; + } security_token_descriptor_fuzzing_pair; + + /* This is not yet sent over the network, but is simply defined in IDL */ + typedef [public] struct { + uid_t uid; + gid_t gid; + uint32 ngroups; + [size_is(ngroups)] gid_t groups[*]; + } security_unix_token; + + /* bits that determine which parts of a security descriptor + are being queried/set */ + typedef [public,bitmap32bit] bitmap { + SECINFO_OWNER = 0x00000001, + SECINFO_GROUP = 0x00000002, + SECINFO_DACL = 0x00000004, + SECINFO_SACL = 0x00000008, + SECINFO_LABEL = 0x00000010, + SECINFO_ATTRIBUTE = 0x00000020, + SECINFO_SCOPE = 0x00000040, + SECINFO_BACKUP = 0x00010000, + SECINFO_UNPROTECTED_SACL = 0x10000000, + SECINFO_UNPROTECTED_DACL = 0x20000000, + SECINFO_PROTECTED_SACL = 0x40000000, + SECINFO_PROTECTED_DACL = 0x80000000 + } security_secinfo; + + /* + * a SMB server should only support the following flags + * and ignore all others. + * + * See AdditionalInformation in [MS-SMB2] 2.2.37 SMB2 QUERY_INFO Request + * and 2.2.39 SMB2 SET_INFO Request. + */ + const int SMB_SUPPORTED_SECINFO_FLAGS = ( + SECINFO_OWNER | + SECINFO_GROUP | + SECINFO_DACL | + SECINFO_SACL | + SECINFO_LABEL | + SECINFO_ATTRIBUTE | + SECINFO_SCOPE | + SECINFO_BACKUP | + 0); + + /* + * See [MS-KILE] 2.2.5 LSAP_TOKEN_INFO_INTEGRITY + */ + typedef [public,gensize,flag(NDR_PAHEX)] struct { + uint32 Flags; + uint32 TokenIL; + uint8 MachineId[32]; + } LSAP_TOKEN_INFO_INTEGRITY; + + /* + * See [MS-KILE] 2.2.6 Supported Encryption Types Bit Flags + */ + typedef [public,bitmap32bit] bitmap { + KERB_ENCTYPE_DES_CBC_CRC = 0x00000001, + KERB_ENCTYPE_DES_CBC_MD5 = 0x00000002, + KERB_ENCTYPE_RC4_HMAC_MD5 = 0x00000004, + KERB_ENCTYPE_AES128_CTS_HMAC_SHA1_96 = 0x00000008, + KERB_ENCTYPE_AES256_CTS_HMAC_SHA1_96 = 0x00000010, + KERB_ENCTYPE_AES256_CTS_HMAC_SHA1_96_SK = 0x00000020, + KERB_ENCTYPE_FAST_SUPPORTED = 0x00010000, + KERB_ENCTYPE_COMPOUND_IDENTITY_SUPPORTED = 0x00020000, + KERB_ENCTYPE_CLAIMS_SUPPORTED = 0x00040000, + KERB_ENCTYPE_RESOURCE_SID_COMPRESSION_DISABLED = 0x00080000 + } kerb_EncTypes; + + typedef [public,bitmap32bit] bitmap { + SEC_DACL_AUTO_INHERIT = 0x00000001, + SEC_SACL_AUTO_INHERIT = 0x00000002, + SEC_DEFAULT_DESCRIPTOR = 0x00000004, + SEC_OWNER_FROM_PARENT = 0x00000008, + SEC_GROUP_FROM_PARENT = 0x00000010 + } security_autoinherit; + + /***************************************************************/ + /* Extended right guids */ + + const string GUID_DRS_ALLOCATE_RIDS = "1abd7cf8-0a99-11d1-adbb-00c04fd8d5cd"; + const string GUID_DRS_CHANGE_DOMAIN_MASTER = "014bf69c-7b3b-11d1-85f6-08002be74fab"; + const string GUID_DRS_CHANGE_INFR_MASTER = "cc17b1fb-33d9-11d2-97d4-00c04fd8d5cd"; + const string GUID_DRS_CHANGE_PDC = "bae50096-4752-11d1-9052-00c04fc2d4cf"; + const string GUID_DRS_CHANGE_RID_MASTER = "d58d5f36-0a98-11d1-adbb-00c04fd8d5cd"; + const string GUID_DRS_CHANGE_SCHEMA_MASTER = "e12b56b6-0a95-11d1-adbb-00c04fd8d5cd"; + const string GUID_DRS_GET_CHANGES = "1131f6aa-9c07-11d1-f79f-00c04fc2dcd2"; + const string GUID_DRS_REPL_SYNCRONIZE = "1131f6ab-9c07-11d1-f79f-00c04fc2dcd2"; + const string GUID_DRS_MANAGE_TOPOLOGY = "1131f6ac-9c07-11d1-f79f-00c04fc2dcd2"; + const string GUID_DRS_GET_ALL_CHANGES = "1131f6ad-9c07-11d1-f79f-00c04fc2dcd2"; + const string GUID_DRS_RO_REPL_SECRET_SYNC = "1131f6ae-9c07-11d1-f79f-00c04fc2dcd2"; + const string GUID_DRS_GET_FILTERED_ATTRIBUTES = "89e95b76-444d-4c62-991a-0facbeda640c"; + const string GUID_DRS_MONITOR_TOPOLOGY = "f98340fb-7c5b-4cdb-a00b-2ebdfa115a96"; + const string GUID_DRS_USER_CHANGE_PASSWORD = "ab721a53-1e2f-11d0-9819-00aa0040529b"; + const string GUID_DRS_FORCE_CHANGE_PASSWORD = "00299570-246d-11d0-a768-00aa006e0529"; + const string GUID_DRS_UPDATE_PASSWORD_NOT_REQUIRED_BIT + = "280f369c-67c7-438e-ae98-1d46f3c6f541"; + const string GUID_DRS_UNEXPIRE_PASSWORD = "ccc2dc7d-a6ad-4a7a-8846-c04e3cc53501"; + const string GUID_DRS_ENABLE_PER_USER_REVERSIBLY_ENCRYPTED_PASSWORD + = "05c74c5e-4deb-43b4-bd9f-86664c2a7fd5"; + const string GUID_DRS_DS_INSTALL_REPLICA = "9923a32a-3607-11d2-b9be-0000f87a36b2"; + const string GUID_DRS_REANIMATE_TOMBSTONE = "45ec5156-db7e-47bb-b53f-dbeb2d03c40f"; + const string GUID_DRS_ALLOWED_TO_AUTHENTICATE = "68b1d179-0d15-4D4F-ab71-46152e79a7bc"; + + /***************************************************************/ + /* validated writes guids */ + const string GUID_DRS_VALIDATE_SPN = "f3a64788-5306-11d1-a9c5-0000f80367c1"; + const string GUID_DRS_SELF_MEMBERSHIP = "bf9679c0-0de6-11d0-a285-00aa003049e2"; + const string GUID_DRS_DNS_HOST_NAME = "72e39547-7b18-11d1-adef-00c04fd8d5cd"; + const string GUID_DRS_ADD_DNS_HOST_NAME = "80863791-dbe9-4eb8-837e-7f0ab55d9ac7"; + const string GUID_DRS_BEHAVIOR_VERSION = "d31a8757-2447-4545-8081-3bb610cacbf2"; + + /* A type to describe the mapping of generic access rights to object + specific access rights. */ + + typedef struct { + uint32 generic_read; + uint32 generic_write; + uint32 generic_execute; + uint32 generic_all; + } generic_mapping; + + typedef struct { + uint32 std_read; + uint32 std_write; + uint32 std_execute; + uint32 std_all; + } standard_mapping; +} |