source4/dsdb/tests/python/sec_descriptor.py

   1 #!/usr/bin/env python
   2 # -*- coding: utf-8 -*-
   3
   4 from __future__ import print_function
   5 import optparse
   6 import sys
   7 import os
   8 import base64
   9 import re
  10 import random
  11
  12 sys.path.insert(0, "bin/python")
  13 import samba
  14
  15 from samba.tests.subunitrun import SubunitOptions, TestProgram
  16
  17 import samba.getopt as options
  18
  19 # Some error messages that are being tested
  20 from ldb import SCOPE_SUBTREE, SCOPE_BASE, LdbError, ERR_NO_SUCH_OBJECT
  21
  22 # For running the test unit
  23 from samba.ndr import ndr_pack, ndr_unpack
  24 from samba.dcerpc import security
  25
  26 from samba import gensec, sd_utils
  27 from samba.samdb import SamDB
  28 from samba.credentials import Credentials, DONT_USE_KERBEROS
  29 from samba.auth import system_session
  30 from samba.dsdb import DS_DOMAIN_FUNCTION_2008
  31 from samba.dcerpc.security import (
  32     SECINFO_OWNER, SECINFO_GROUP, SECINFO_DACL, SECINFO_SACL)
  33 import samba.tests
  34 from samba.tests import delete_force
  35
  36 parser = optparse.OptionParser("sec_descriptor.py [options] <host>")
  37 sambaopts = options.SambaOptions(parser)
  38 parser.add_option_group(sambaopts)
  39 parser.add_option_group(options.VersionOptions(parser))
  40
  41 # use command line creds if available
  42 credopts = options.CredentialsOptions(parser)
  43 parser.add_option_group(credopts)
  44 subunitopts = SubunitOptions(parser)
  45 parser.add_option_group(subunitopts)
  46
  47 opts, args = parser.parse_args()
  48
  49 if len(args) < 1:
  50     parser.print_usage()
  51     sys.exit(1)
  52
  53 host = args[0]
  54
  55 lp = sambaopts.get_loadparm()
  56 creds = credopts.get_credentials(lp)
  57 creds.set_gensec_features(creds.get_gensec_features() | gensec.FEATURE_SEAL)
  58
  59 #
  60 # Tests start here
  61 #
  62
  63 class DescriptorTests(samba.tests.TestCase):
  64
  65     def get_users_domain_dn(self, name):
  66         return "CN=%s,CN=Users,%s" % (name, self.base_dn)
  67
  68     def create_schema_class(self, _ldb, desc=None):
  69         while True:
  70             class_id = random.randint(0,65535)
  71             class_name = "descriptor-test-class%s" % class_id
  72             class_dn = "CN=%s,%s" % (class_name, self.schema_dn)
  73             try:
  74                 self.ldb_admin.search(base=class_dn, attrs=["name"])
  75             except LdbError as e:
  76                 (num, _) = e.args
  77                 self.assertEquals(num, ERR_NO_SUCH_OBJECT)
  78                 break
  79
  80         ldif = """
  81 dn: """ + class_dn + """
  82 objectClass: classSchema
  83 objectCategory: CN=Class-Schema,""" + self.schema_dn + """
  84 defaultObjectCategory: """ + class_dn + """
  85 governsId: 1.3.6.1.4.1.7165.4.6.2.3.""" + str(class_id) + """
  86 instanceType: 4
  87 objectClassCategory: 1
  88 subClassOf: organizationalPerson
  89 systemFlags: 16
  90 rDNAttID: cn
  91 systemMustContain: cn
  92 systemOnly: FALSE
  93 """
  94         if desc:
  95             assert(isinstance(desc, str) or isinstance(desc, security.descriptor))
  96             if isinstance(desc, str):
  97                 ldif += "nTSecurityDescriptor: %s" % desc
  98             elif isinstance(desc, security.descriptor):
  99                 ldif += "nTSecurityDescriptor:: %s" % base64.b64encode(ndr_pack(desc)).decode('utf8')
 100         _ldb.add_ldif(ldif)
 101         return class_dn
 102
 103     def create_configuration_container(self, _ldb, object_dn, desc=None):
 104         ldif = """
 105 dn: """ + object_dn + """
 106 objectClass: container
 107 objectCategory: CN=Container,""" + self.schema_dn + """
 108 showInAdvancedViewOnly: TRUE
 109 instanceType: 4
 110 """
 111         if desc:
 112             assert(isinstance(desc, str) or isinstance(desc, security.descriptor))
 113             if isinstance(desc, str):
 114                 ldif += "nTSecurityDescriptor: %s" % desc
 115             elif isinstance(desc, security.descriptor):
 116                 ldif += "nTSecurityDescriptor:: %s" % base64.b64encode(ndr_pack(desc)).decode('utf8')
 117         _ldb.add_ldif(ldif)
 118
 119     def create_configuration_specifier(self, _ldb, object_dn, desc=None):
 120         ldif = """
 121 dn: """ + object_dn + """
 122 objectClass: displaySpecifier
 123 showInAdvancedViewOnly: TRUE
 124 """
 125         if desc:
 126             assert(isinstance(desc, str) or isinstance(desc, security.descriptor))
 127             if isinstance(desc, str):
 128                 ldif += "nTSecurityDescriptor: %s" % desc
 129             elif isinstance(desc, security.descriptor):
 130                 ldif += "nTSecurityDescriptor:: %s" % base64.b64encode(ndr_pack(desc)).decode('utf8')
 131         _ldb.add_ldif(ldif)
 132
 133     def get_ldb_connection(self, target_username, target_password):
 134         creds_tmp = Credentials()
 135         creds_tmp.set_username(target_username)
 136         creds_tmp.set_password(target_password)
 137         creds_tmp.set_domain(creds.get_domain())
 138         creds_tmp.set_realm(creds.get_realm())
 139         creds_tmp.set_workstation(creds.get_workstation())
 140         creds_tmp.set_gensec_features(creds_tmp.get_gensec_features()
 141                                       | gensec.FEATURE_SEAL)
 142         creds_tmp.set_kerberos_state(DONT_USE_KERBEROS) # kinit is too expensive to use in a tight loop
 143         ldb_target = SamDB(url=host, credentials=creds_tmp, lp=lp)
 144         return ldb_target
 145
 146     def setUp(self):
 147         super(DescriptorTests, self).setUp()
 148         self.ldb_admin = SamDB(host, credentials=creds, session_info=system_session(lp), lp=lp,
 149                                options=ldb_options)
 150         self.base_dn = self.ldb_admin.domain_dn()
 151         self.configuration_dn = self.ldb_admin.get_config_basedn().get_linearized()
 152         self.schema_dn = self.ldb_admin.get_schema_basedn().get_linearized()
 153         self.domain_sid = security.dom_sid(self.ldb_admin.get_domain_sid())
 154         self.sd_utils = sd_utils.SDUtils(self.ldb_admin)
 155         self.addCleanup(self.delete_admin_connection)
 156         print("baseDN: %s" % self.base_dn)
 157
 158     def delete_admin_connection(self):
 159         del self.sd_utils
 160         del self.ldb_admin
 161
 162     ################################################################################################
 163
 164     ## Tests for DOMAIN
 165
 166     # Default descriptor tests #####################################################################
 167
 168 class OwnerGroupDescriptorTests(DescriptorTests):
 169
 170     def deleteAll(self):
 171         delete_force(self.ldb_admin, self.get_users_domain_dn("testuser1"))
 172         delete_force(self.ldb_admin, self.get_users_domain_dn("testuser2"))
 173         delete_force(self.ldb_admin, self.get_users_domain_dn("testuser3"))
 174         delete_force(self.ldb_admin, self.get_users_domain_dn("testuser4"))
 175         delete_force(self.ldb_admin, self.get_users_domain_dn("testuser5"))
 176         delete_force(self.ldb_admin, self.get_users_domain_dn("testuser6"))
 177         delete_force(self.ldb_admin, self.get_users_domain_dn("testuser7"))
 178         delete_force(self.ldb_admin, self.get_users_domain_dn("testuser8"))
 179         # DOMAIN
 180         delete_force(self.ldb_admin, self.get_users_domain_dn("test_domain_group1"))
 181         delete_force(self.ldb_admin, "CN=test_domain_user1,OU=test_domain_ou1," + self.base_dn)
 182         delete_force(self.ldb_admin, "OU=test_domain_ou2,OU=test_domain_ou1," + self.base_dn)
 183         delete_force(self.ldb_admin, "OU=test_domain_ou1," + self.base_dn)
 184         # SCHEMA
 185         # CONFIGURATION
 186         delete_force(self.ldb_admin, "CN=test-specifier1,CN=test-container1,CN=DisplaySpecifiers," \
 187                      + self.configuration_dn)
 188         delete_force(self.ldb_admin, "CN=test-container1,CN=DisplaySpecifiers," + self.configuration_dn)
 189
 190     def setUp(self):
 191         super(OwnerGroupDescriptorTests, self).setUp()
 192         self.deleteAll()
 193         ### Create users
 194         # User 1 - Enterprise Admins
 195         self.ldb_admin.newuser("testuser1", "samba123@")
 196         # User 2 - Domain Admins
 197         self.ldb_admin.newuser("testuser2", "samba123@")
 198         # User 3 - Schema Admins
 199         self.ldb_admin.newuser("testuser3", "samba123@")
 200         # User 4 - regular user
 201         self.ldb_admin.newuser("testuser4", "samba123@")
 202         # User 5 - Enterprise Admins and Domain Admins
 203         self.ldb_admin.newuser("testuser5", "samba123@")
 204         # User 6 - Enterprise Admins, Domain Admins, Schema Admins
 205         self.ldb_admin.newuser("testuser6", "samba123@")
 206         # User 7 - Domain Admins and Schema Admins
 207         self.ldb_admin.newuser("testuser7", "samba123@")
 208         # User 5 - Enterprise Admins and Schema Admins
 209         self.ldb_admin.newuser("testuser8", "samba123@")
 210
 211         self.ldb_admin.add_remove_group_members("Enterprise Admins",
 212                                                 ["testuser1", "testuser5", "testuser6", "testuser8"],
 213                                                 add_members_operation=True)
 214         self.ldb_admin.add_remove_group_members("Domain Admins",
 215                                                 ["testuser2","testuser5","testuser6","testuser7"],
 216                                                 add_members_operation=True)
 217         self.ldb_admin.add_remove_group_members("Schema Admins",
 218                                                 ["testuser3","testuser6","testuser7","testuser8"],
 219                                                 add_members_operation=True)
 220
 221         self.results = {
 222             # msDS-Behavior-Version < DS_DOMAIN_FUNCTION_2008
 223             "ds_behavior_win2003" : {
 224                 "100" : "O:EAG:DU",
 225                 "101" : "O:DAG:DU",
 226                 "102" : "O:%sG:DU",
 227                 "103" : "O:%sG:DU",
 228                 "104" : "O:DAG:DU",
 229                 "105" : "O:DAG:DU",
 230                 "106" : "O:DAG:DU",
 231                 "107" : "O:EAG:DU",
 232                 "108" : "O:DAG:DA",
 233                 "109" : "O:DAG:DA",
 234                 "110" : "O:%sG:DA",
 235                 "111" : "O:%sG:DA",
 236                 "112" : "O:DAG:DA",
 237                 "113" : "O:DAG:DA",
 238                 "114" : "O:DAG:DA",
 239                 "115" : "O:DAG:DA",
 240                 "130" : "O:EAG:DU",
 241                 "131" : "O:DAG:DU",
 242                 "132" : "O:SAG:DU",
 243                 "133" : "O:%sG:DU",
 244                 "134" : "O:EAG:DU",
 245                 "135" : "O:SAG:DU",
 246                 "136" : "O:SAG:DU",
 247                 "137" : "O:SAG:DU",
 248                 "138" : "O:DAG:DA",
 249                 "139" : "O:DAG:DA",
 250                 "140" : "O:%sG:DA",
 251                 "141" : "O:%sG:DA",
 252                 "142" : "O:DAG:DA",
 253                 "143" : "O:DAG:DA",
 254                 "144" : "O:DAG:DA",
 255                 "145" : "O:DAG:DA",
 256                 "160" : "O:EAG:DU",
 257                 "161" : "O:DAG:DU",
 258                 "162" : "O:%sG:DU",
 259                 "163" : "O:%sG:DU",
 260                 "164" : "O:EAG:DU",
 261                 "165" : "O:EAG:DU",
 262                 "166" : "O:DAG:DU",
 263                 "167" : "O:EAG:DU",
 264                 "168" : "O:DAG:DA",
 265                 "169" : "O:DAG:DA",
 266                 "170" : "O:%sG:DA",
 267                 "171" : "O:%sG:DA",
 268                 "172" : "O:DAG:DA",
 269                 "173" : "O:DAG:DA",
 270                 "174" : "O:DAG:DA",
 271                 "175" : "O:DAG:DA",
 272             },
 273             # msDS-Behavior-Version >= DS_DOMAIN_FUNCTION_2008
 274             "ds_behavior_win2008" : {
 275                 "100" : "O:EAG:EA",
 276                 "101" : "O:DAG:DA",
 277                 "102" : "O:%sG:DU",
 278                 "103" : "O:%sG:DU",
 279                 "104" : "O:DAG:DA",
 280                 "105" : "O:DAG:DA",
 281                 "106" : "O:DAG:DA",
 282                 "107" : "O:EAG:EA",
 283                 "108" : "O:DAG:DA",
 284                 "109" : "O:DAG:DA",
 285                 "110" : "O:%sG:DA",
 286                 "111" : "O:%sG:DA",
 287                 "112" : "O:DAG:DA",
 288                 "113" : "O:DAG:DA",
 289                 "114" : "O:DAG:DA",
 290                 "115" : "O:DAG:DA",
 291                 "130" : "O:EAG:EA",
 292                 "131" : "O:DAG:DA",
 293                 "132" : "O:SAG:SA",
 294                 "133" : "O:%sG:DU",
 295                 "134" : "O:EAG:EA",
 296                 "135" : "O:SAG:SA",
 297                 "136" : "O:SAG:SA",
 298                 "137" : "O:SAG:SA",
 299                 "138" : "",
 300                 "139" : "",
 301                 "140" : "O:%sG:DA",
 302                 "141" : "O:%sG:DA",
 303                 "142" : "",
 304                 "143" : "",
 305                 "144" : "",
 306                 "145" : "",
 307                 "160" : "O:EAG:EA",
 308                 "161" : "O:DAG:DA",
 309                 "162" : "O:%sG:DU",
 310                 "163" : "O:%sG:DU",
 311                 "164" : "O:EAG:EA",
 312                 "165" : "O:EAG:EA",
 313                 "166" : "O:DAG:DA",
 314                 "167" : "O:EAG:EA",
 315                 "168" : "O:DAG:DA",
 316                 "169" : "O:DAG:DA",
 317                 "170" : "O:%sG:DA",
 318                 "171" : "O:%sG:DA",
 319                 "172" : "O:DAG:DA",
 320                 "173" : "O:DAG:DA",
 321                 "174" : "O:DAG:DA",
 322                 "175" : "O:DAG:DA",
 323             },
 324         }
 325         # Discover 'domainControllerFunctionality'
 326         res = self.ldb_admin.search(base="", scope=SCOPE_BASE,
 327                                     attrs=['domainControllerFunctionality'])
 328         res = int(res[0]['domainControllerFunctionality'][0])
 329         if res < DS_DOMAIN_FUNCTION_2008:
 330             self.DS_BEHAVIOR = "ds_behavior_win2003"
 331         else:
 332             self.DS_BEHAVIOR = "ds_behavior_win2008"
 333
 334     def tearDown(self):
 335         super(DescriptorTests, self).tearDown()
 336         self.deleteAll()
 337
 338     def check_user_belongs(self, user_dn, groups=[]):
 339         """ Test wether user is member of the expected group(s) """
 340         if groups != []:
 341             # User is member of at least one additional group
 342             res = self.ldb_admin.search(user_dn, attrs=["memberOf"])
 343             res = [x.upper() for x in sorted(list(res[0]["memberOf"]))]
 344             expected = []
 345             for x in groups:
 346                 expected.append(self.get_users_domain_dn(x))
 347             expected = [x.upper() for x in sorted(expected)]
 348             self.assertEqual(expected, res)
 349         else:
 350             # User is not a member of any additional groups but default
 351             res = self.ldb_admin.search(user_dn, attrs=["*"])
 352             res = [x.upper() for x in res[0].keys()]
 353             self.assertFalse( "MEMBEROF" in res)
 354
 355     def check_modify_inheritance(self, _ldb, object_dn, owner_group=""):
 356         # Modify
 357         sd_user_utils = sd_utils.SDUtils(_ldb)
 358         ace = "(D;;CC;;;LG)" # Deny Create Children to Guest account
 359         if owner_group != "":
 360             sd_user_utils.modify_sd_on_dn(object_dn, owner_group + "D:" + ace)
 361         else:
 362             sd_user_utils.modify_sd_on_dn(object_dn, "D:" + ace)
 363         # Make sure the modify operation has been applied
 364         desc_sddl = self.sd_utils.get_sd_as_sddl(object_dn)
 365         self.assertTrue(ace in desc_sddl)
 366         # Make sure we have identical result for both "add" and "modify"
 367         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
 368         print(self._testMethodName)
 369         test_number = self._testMethodName[5:]
 370         self.assertEqual(self.results[self.DS_BEHAVIOR][test_number], res)
 371
 372     def test_100(self):
 373         """ Enterprise admin group member creates object (default nTSecurityDescriptor) in DOMAIN
 374         """
 375         user_name = "testuser1"
 376         self.check_user_belongs(self.get_users_domain_dn(user_name), ["Enterprise Admins"])
 377         # Open Ldb connection with the tested user
 378         _ldb = self.get_ldb_connection(user_name, "samba123@")
 379         object_dn = "CN=test_domain_group1,CN=Users," + self.base_dn
 380         delete_force(self.ldb_admin, object_dn)
 381         _ldb.newgroup("test_domain_group1", grouptype=4)
 382         desc_sddl = self.sd_utils.get_sd_as_sddl(object_dn)
 383         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
 384         self.assertEqual(self.results[self.DS_BEHAVIOR][self._testMethodName[5:]], res)
 385         self.check_modify_inheritance(_ldb, object_dn)
 386
 387     def test_101(self):
 388         """ Domain admin group member creates object (default nTSecurityDescriptor) in DOMAIN
 389         """
 390         user_name = "testuser2"
 391         self.check_user_belongs(self.get_users_domain_dn(user_name), ["Domain Admins"])
 392         # Open Ldb connection with the tested user
 393         _ldb = self.get_ldb_connection(user_name, "samba123@")
 394         object_dn = "CN=test_domain_group1,CN=Users," + self.base_dn
 395         delete_force(self.ldb_admin, object_dn)
 396         _ldb.newgroup("test_domain_group1", grouptype=4)
 397         desc_sddl = self.sd_utils.get_sd_as_sddl(object_dn)
 398         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
 399         self.assertEqual(self.results[self.DS_BEHAVIOR][self._testMethodName[5:]], res)
 400         self.check_modify_inheritance(_ldb, object_dn)
 401
 402     def test_102(self):
 403         """ Schema admin group member with CC right creates object (default nTSecurityDescriptor) in DOMAIN
 404         """
 405         user_name = "testuser3"
 406         self.check_user_belongs(self.get_users_domain_dn(user_name), ["Schema Admins"])
 407         # Open Ldb connection with the tested user
 408         _ldb = self.get_ldb_connection(user_name, "samba123@")
 409         object_dn = "OU=test_domain_ou1," + self.base_dn
 410         delete_force(self.ldb_admin, object_dn)
 411         self.ldb_admin.create_ou(object_dn)
 412         user_sid = self.sd_utils.get_object_sid( self.get_users_domain_dn(user_name) )
 413         mod = "(A;CI;WPWDCC;;;%s)" % str(user_sid)
 414         self.sd_utils.dacl_add_ace(object_dn, mod)
 415         # Create additional object into the first one
 416         object_dn = "CN=test_domain_user1," + object_dn
 417         delete_force(self.ldb_admin, object_dn)
 418         _ldb.newuser("test_domain_user1", "samba123@",
 419                      userou="OU=test_domain_ou1", setpassword=False)
 420         desc_sddl = self.sd_utils.get_sd_as_sddl(object_dn)
 421         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
 422         self.assertEqual(self.results[self.DS_BEHAVIOR][self._testMethodName[5:]] % str(user_sid), res)
 423         # This fails, research why
 424         #self.check_modify_inheritance(_ldb, object_dn)
 425
 426     def test_103(self):
 427         """ Regular user with CC right creates object (default nTSecurityDescriptor) in DOMAIN
 428         """
 429         user_name = "testuser4"
 430         self.check_user_belongs(self.get_users_domain_dn(user_name), [])
 431         # Open Ldb connection with the tested user
 432         _ldb = self.get_ldb_connection(user_name, "samba123@")
 433         object_dn = "OU=test_domain_ou1," + self.base_dn
 434         delete_force(self.ldb_admin, object_dn)
 435         self.ldb_admin.create_ou(object_dn)
 436         user_sid = self.sd_utils.get_object_sid( self.get_users_domain_dn(user_name) )
 437         mod = "(A;CI;WPWDCC;;;%s)" % str(user_sid)
 438         self.sd_utils.dacl_add_ace(object_dn, mod)
 439         # Create additional object into the first one
 440         object_dn = "CN=test_domain_user1," + object_dn
 441         delete_force(self.ldb_admin, object_dn)
 442         _ldb.newuser("test_domain_user1", "samba123@",
 443                      userou="OU=test_domain_ou1", setpassword=False)
 444         desc_sddl = self.sd_utils.get_sd_as_sddl(object_dn)
 445         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
 446         self.assertEqual(self.results[self.DS_BEHAVIOR][self._testMethodName[5:]] % str(user_sid), res)
 447         #this fails, research why
 448         #self.check_modify_inheritance(_ldb, object_dn)
 449
 450     def test_104(self):
 451         """ Enterprise & Domain admin group member creates object (default nTSecurityDescriptor) in DOMAIN
 452         """
 453         user_name = "testuser5"
 454         self.check_user_belongs(self.get_users_domain_dn(user_name), ["Enterprise Admins", "Domain Admins"])
 455         # Open Ldb connection with the tested user
 456         _ldb = self.get_ldb_connection(user_name, "samba123@")
 457         object_dn = "CN=test_domain_group1,CN=Users," + self.base_dn
 458         delete_force(self.ldb_admin, object_dn)
 459         _ldb.newgroup("test_domain_group1", grouptype=4)
 460         desc_sddl = self.sd_utils.get_sd_as_sddl(object_dn)
 461         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
 462         self.assertEqual(self.results[self.DS_BEHAVIOR][self._testMethodName[5:]], res)
 463         self.check_modify_inheritance(_ldb, object_dn)
 464
 465     def test_105(self):
 466         """ Enterprise & Domain & Schema admin group member creates object (default nTSecurityDescriptor) in DOMAIN
 467         """
 468         user_name = "testuser6"
 469         self.check_user_belongs(self.get_users_domain_dn(user_name), ["Enterprise Admins", "Domain Admins", "Schema Admins"])
 470         # Open Ldb connection with the tested user
 471         _ldb = self.get_ldb_connection(user_name, "samba123@")
 472         object_dn = "CN=test_domain_group1,CN=Users," + self.base_dn
 473         delete_force(self.ldb_admin, object_dn)
 474         _ldb.newgroup("test_domain_group1", grouptype=4)
 475         desc_sddl = self.sd_utils.get_sd_as_sddl(object_dn)
 476         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
 477         self.assertEqual(self.results[self.DS_BEHAVIOR][self._testMethodName[5:]], res)
 478         self.check_modify_inheritance(_ldb, object_dn)
 479
 480     def test_106(self):
 481         """ Domain & Schema admin group member creates object (default nTSecurityDescriptor) in DOMAIN
 482         """
 483         user_name = "testuser7"
 484         self.check_user_belongs(self.get_users_domain_dn(user_name), ["Domain Admins", "Schema Admins"])
 485         # Open Ldb connection with the tested user
 486         _ldb = self.get_ldb_connection(user_name, "samba123@")
 487         object_dn = "CN=test_domain_group1,CN=Users," + self.base_dn
 488         delete_force(self.ldb_admin, object_dn)
 489         _ldb.newgroup("test_domain_group1", grouptype=4)
 490         desc_sddl = self.sd_utils.get_sd_as_sddl(object_dn)
 491         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
 492         self.assertEqual(self.results[self.DS_BEHAVIOR][self._testMethodName[5:]], res)
 493         self.check_modify_inheritance(_ldb, object_dn)
 494
 495     def test_107(self):
 496         """ Enterprise & Schema admin group member creates object (default nTSecurityDescriptor) in DOMAIN
 497         """
 498         user_name = "testuser8"
 499         self.check_user_belongs(self.get_users_domain_dn(user_name), ["Enterprise Admins", "Schema Admins"])
 500         # Open Ldb connection with the tested user
 501         _ldb = self.get_ldb_connection(user_name, "samba123@")
 502         object_dn = "CN=test_domain_group1,CN=Users," + self.base_dn
 503         delete_force(self.ldb_admin, object_dn)
 504         _ldb.newgroup("test_domain_group1", grouptype=4)
 505         desc_sddl = self.sd_utils.get_sd_as_sddl(object_dn)
 506         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
 507         self.assertEqual(self.results[self.DS_BEHAVIOR][self._testMethodName[5:]], res)
 508         self.check_modify_inheritance(_ldb, object_dn)
 509
 510     # Control descriptor tests #####################################################################
 511
 512     def test_108(self):
 513         """ Enterprise admin group member creates object (custom descriptor) in DOMAIN
 514         """
 515         user_name = "testuser1"
 516         self.check_user_belongs(self.get_users_domain_dn(user_name), ["Enterprise Admins"])
 517         # Open Ldb connection with the tested user
 518         _ldb = self.get_ldb_connection(user_name, "samba123@")
 519         object_dn = "CN=test_domain_group1,CN=Users," + self.base_dn
 520         delete_force(self.ldb_admin, object_dn)
 521         # Create a custom security descriptor
 522         sddl = "O:DAG:DAD:(A;;RP;;;DU)"
 523         tmp_desc = security.descriptor.from_sddl(sddl, self.domain_sid)
 524         _ldb.newgroup("test_domain_group1", grouptype=4, sd=tmp_desc)
 525         desc_sddl = self.sd_utils.get_sd_as_sddl(object_dn)
 526         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
 527         self.assertEqual(self.results[self.DS_BEHAVIOR][self._testMethodName[5:]], res)
 528
 529     def test_109(self):
 530         """ Domain admin group member creates object (custom descriptor) in DOMAIN
 531         """
 532         user_name = "testuser2"
 533         self.check_user_belongs(self.get_users_domain_dn(user_name), ["Domain Admins"])
 534         # Open Ldb connection with the tested user
 535         _ldb = self.get_ldb_connection(user_name, "samba123@")
 536         object_dn = "CN=test_domain_group1,CN=Users," + self.base_dn
 537         delete_force(self.ldb_admin, object_dn)
 538         # Create a custom security descriptor
 539         sddl = "O:DAG:DAD:(A;;RP;;;DU)"
 540         tmp_desc = security.descriptor.from_sddl(sddl, self.domain_sid)
 541         _ldb.newgroup("test_domain_group1", grouptype=4, sd=tmp_desc)
 542         desc_sddl = self.sd_utils.get_sd_as_sddl(object_dn)
 543         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
 544         self.assertEqual(self.results[self.DS_BEHAVIOR][self._testMethodName[5:]], res)
 545
 546     def test_110(self):
 547         """ Schema admin group member with CC right creates object (custom descriptor) in DOMAIN
 548         """
 549         user_name = "testuser3"
 550         self.check_user_belongs(self.get_users_domain_dn(user_name), ["Schema Admins"])
 551         # Open Ldb connection with the tested user
 552         _ldb = self.get_ldb_connection(user_name, "samba123@")
 553         object_dn = "OU=test_domain_ou1," + self.base_dn
 554         delete_force(self.ldb_admin, object_dn)
 555         self.ldb_admin.create_ou(object_dn)
 556         user_sid = self.sd_utils.get_object_sid( self.get_users_domain_dn(user_name) )
 557         mod = "(A;CI;WOWDCC;;;%s)" % str(user_sid)
 558         self.sd_utils.dacl_add_ace(object_dn, mod)
 559         # Create a custom security descriptor
 560         # NB! Problematic owner part won't accept DA only <User Sid> !!!
 561         sddl = "O:%sG:DAD:(A;;RP;;;DU)" % str(user_sid)
 562         tmp_desc = security.descriptor.from_sddl(sddl, self.domain_sid)
 563         # Create additional object into the first one
 564         object_dn = "CN=test_domain_user1," + object_dn
 565         delete_force(self.ldb_admin, object_dn)
 566         _ldb.newuser("test_domain_user1", "samba123@",
 567                      userou="OU=test_domain_ou1", sd=tmp_desc, setpassword=False)
 568         desc = self.sd_utils.read_sd_on_dn(object_dn)
 569         desc_sddl = self.sd_utils.get_sd_as_sddl(object_dn)
 570         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
 571         self.assertEqual(self.results[self.DS_BEHAVIOR][self._testMethodName[5:]] % str(user_sid), res)
 572
 573     def test_111(self):
 574         """ Regular user with CC right creates object (custom descriptor) in DOMAIN
 575         """
 576         user_name = "testuser4"
 577         self.check_user_belongs(self.get_users_domain_dn(user_name), [])
 578         # Open Ldb connection with the tested user
 579         _ldb = self.get_ldb_connection(user_name, "samba123@")
 580         object_dn = "OU=test_domain_ou1," + self.base_dn
 581         delete_force(self.ldb_admin, object_dn)
 582         self.ldb_admin.create_ou(object_dn)
 583         user_sid = self.sd_utils.get_object_sid( self.get_users_domain_dn(user_name) )
 584         mod = "(A;CI;WOWDCC;;;%s)" % str(user_sid)
 585         self.sd_utils.dacl_add_ace(object_dn, mod)
 586         # Create a custom security descriptor
 587         # NB! Problematic owner part won't accept DA only <User Sid> !!!
 588         sddl = "O:%sG:DAD:(A;;RP;;;DU)" % str(user_sid)
 589         tmp_desc = security.descriptor.from_sddl(sddl, self.domain_sid)
 590         # Create additional object into the first one
 591         object_dn = "CN=test_domain_user1," + object_dn
 592         delete_force(self.ldb_admin, object_dn)
 593         _ldb.newuser("test_domain_user1", "samba123@",
 594                      userou="OU=test_domain_ou1", sd=tmp_desc, setpassword=False)
 595         desc = self.sd_utils.read_sd_on_dn(object_dn)
 596         desc_sddl = self.sd_utils.get_sd_as_sddl(object_dn)
 597         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
 598         self.assertEqual(self.results[self.DS_BEHAVIOR][self._testMethodName[5:]] % str(user_sid), res)
 599
 600     def test_112(self):
 601         """ Domain & Enterprise admin group member creates object (custom descriptor) in DOMAIN
 602         """
 603         user_name = "testuser5"
 604         self.check_user_belongs(self.get_users_domain_dn(user_name), ["Enterprise Admins", "Domain Admins"])
 605         # Open Ldb connection with the tested user
 606         _ldb = self.get_ldb_connection(user_name, "samba123@")
 607         object_dn = "CN=test_domain_group1,CN=Users," + self.base_dn
 608         delete_force(self.ldb_admin, object_dn)
 609         # Create a custom security descriptor
 610         sddl = "O:DAG:DAD:(A;;RP;;;DU)"
 611         tmp_desc = security.descriptor.from_sddl(sddl, self.domain_sid)
 612         _ldb.newgroup("test_domain_group1", grouptype=4, sd=tmp_desc)
 613         desc_sddl = self.sd_utils.get_sd_as_sddl(object_dn)
 614         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
 615         self.assertEqual(self.results[self.DS_BEHAVIOR][self._testMethodName[5:]], res)
 616
 617     def test_113(self):
 618         """ Domain & Enterprise & Schema admin group  member creates object (custom descriptor) in DOMAIN
 619         """
 620         user_name = "testuser6"
 621         self.check_user_belongs(self.get_users_domain_dn(user_name), ["Enterprise Admins", "Domain Admins", "Schema Admins"])
 622         # Open Ldb connection with the tested user
 623         _ldb = self.get_ldb_connection(user_name, "samba123@")
 624         object_dn = "CN=test_domain_group1,CN=Users," + self.base_dn
 625         delete_force(self.ldb_admin, object_dn)
 626         # Create a custom security descriptor
 627         sddl = "O:DAG:DAD:(A;;RP;;;DU)"
 628         tmp_desc = security.descriptor.from_sddl(sddl, self.domain_sid)
 629         _ldb.newgroup("test_domain_group1", grouptype=4, sd=tmp_desc)
 630         desc_sddl = self.sd_utils.get_sd_as_sddl(object_dn)
 631         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
 632         self.assertEqual(self.results[self.DS_BEHAVIOR][self._testMethodName[5:]], res)
 633
 634     def test_114(self):
 635         """ Domain & Schema admin group  member creates object (custom descriptor) in DOMAIN
 636         """
 637         user_name = "testuser7"
 638         self.check_user_belongs(self.get_users_domain_dn(user_name), ["Domain Admins", "Schema Admins"])
 639         # Open Ldb connection with the tested user
 640         _ldb = self.get_ldb_connection(user_name, "samba123@")
 641         object_dn = "CN=test_domain_group1,CN=Users," + self.base_dn
 642         delete_force(self.ldb_admin, object_dn)
 643         # Create a custom security descriptor
 644         sddl = "O:DAG:DAD:(A;;RP;;;DU)"
 645         tmp_desc = security.descriptor.from_sddl(sddl, self.domain_sid)
 646         _ldb.newgroup("test_domain_group1", grouptype=4, sd=tmp_desc)
 647         desc_sddl = self.sd_utils.get_sd_as_sddl(object_dn)
 648         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
 649         self.assertEqual(self.results[self.DS_BEHAVIOR][self._testMethodName[5:]], res)
 650
 651     def test_115(self):
 652         """ Enterprise & Schema admin group  member creates object (custom descriptor) in DOMAIN
 653         """
 654         user_name = "testuser8"
 655         self.check_user_belongs(self.get_users_domain_dn(user_name), ["Enterprise Admins", "Schema Admins"])
 656         # Open Ldb connection with the tested user
 657         _ldb = self.get_ldb_connection(user_name, "samba123@")
 658         object_dn = "CN=test_domain_group1,CN=Users," + self.base_dn
 659         delete_force(self.ldb_admin, object_dn)
 660         # Create a custom security descriptor
 661         sddl = "O:DAG:DAD:(A;;RP;;;DU)"
 662         tmp_desc = security.descriptor.from_sddl(sddl, self.domain_sid)
 663         _ldb.newgroup("test_domain_group1", grouptype=4, sd=tmp_desc)
 664         desc_sddl = self.sd_utils.get_sd_as_sddl(object_dn)
 665         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
 666         self.assertEqual(self.results[self.DS_BEHAVIOR][self._testMethodName[5:]], res)
 667
 668     def test_999(self):
 669         user_name = "Administrator"
 670         object_dn = "OU=test_domain_ou1," + self.base_dn
 671         delete_force(self.ldb_admin, object_dn)
 672         self.ldb_admin.create_ou(object_dn)
 673         user_sid = self.sd_utils.get_object_sid( self.get_users_domain_dn(user_name) )
 674         mod = "(D;CI;WP;;;S-1-3-0)"
 675         #mod = ""
 676         self.sd_utils.dacl_add_ace(object_dn, mod)
 677         desc_sddl = self.sd_utils.get_sd_as_sddl(object_dn)
 678         # Create additional object into the first one
 679         object_dn = "OU=test_domain_ou2," + object_dn
 680         delete_force(self.ldb_admin, object_dn)
 681         self.ldb_admin.create_ou(object_dn)
 682         desc_sddl = self.sd_utils.get_sd_as_sddl(object_dn)
 683
 684     ## Tests for SCHEMA
 685
 686     # Defalt descriptor tests ##################################################################
 687
 688     def test_130(self):
 689         user_name = "testuser1"
 690         self.check_user_belongs(self.get_users_domain_dn(user_name), ["Enterprise Admins"])
 691         # Open Ldb connection with the tested user
 692         _ldb = self.get_ldb_connection(user_name, "samba123@")
 693         # Change Schema partition descriptor
 694         user_sid = self.sd_utils.get_object_sid( self.get_users_domain_dn(user_name) )
 695         mod = "(A;;WDCC;;;AU)"
 696         self.sd_utils.dacl_add_ace(self.schema_dn, mod)
 697         # Create example Schema class
 698         class_dn = self.create_schema_class(_ldb)
 699         desc_sddl = self.sd_utils.get_sd_as_sddl(class_dn)
 700         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
 701         self.assertEqual(self.results[self.DS_BEHAVIOR][self._testMethodName[5:]], res)
 702         self.check_modify_inheritance(_ldb, class_dn)
 703
 704     def test_131(self):
 705         user_name = "testuser2"
 706         self.check_user_belongs(self.get_users_domain_dn(user_name), ["Domain Admins"])
 707         # Open Ldb connection with the tested user
 708         _ldb = self.get_ldb_connection(user_name, "samba123@")
 709         # Change Schema partition descriptor
 710         mod = "(A;CI;WDCC;;;AU)"
 711         self.sd_utils.dacl_add_ace(self.schema_dn, mod)
 712         # Create example Schema class
 713         class_dn = self.create_schema_class(_ldb)
 714         desc_sddl = self.sd_utils.get_sd_as_sddl(class_dn)
 715         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
 716         self.assertEqual(self.results[self.DS_BEHAVIOR][self._testMethodName[5:]], res)
 717         self.check_modify_inheritance(_ldb, class_dn)
 718
 719     def test_132(self):
 720         user_name = "testuser3"
 721         self.check_user_belongs(self.get_users_domain_dn(user_name), ["Schema Admins"])
 722         # Open Ldb connection with the tested user
 723         _ldb = self.get_ldb_connection(user_name, "samba123@")
 724         # Change Schema partition descriptor
 725         mod = "(A;CI;WDCC;;;AU)"
 726         self.sd_utils.dacl_add_ace(self.schema_dn, mod)
 727         # Create example Schema class
 728         class_dn = self.create_schema_class(_ldb)
 729         desc_sddl = self.sd_utils.get_sd_as_sddl(class_dn)
 730         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
 731         self.assertEqual(self.results[self.DS_BEHAVIOR][self._testMethodName[5:]], res)
 732         #self.check_modify_inheritance(_ldb, class_dn)
 733
 734     def test_133(self):
 735         user_name = "testuser4"
 736         self.check_user_belongs(self.get_users_domain_dn(user_name), [])
 737         # Open Ldb connection with the tested user
 738         _ldb = self.get_ldb_connection(user_name, "samba123@")
 739         #Change Schema partition descriptor
 740         user_sid = self.sd_utils.get_object_sid( self.get_users_domain_dn(user_name) )
 741         mod = "(A;CI;WDCC;;;AU)"
 742         self.sd_utils.dacl_add_ace(self.schema_dn, mod)
 743         # Create example Schema class
 744         class_dn = self.create_schema_class(_ldb)
 745         desc_sddl = self.sd_utils.get_sd_as_sddl(class_dn)
 746         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
 747         self.assertEqual(self.results[self.DS_BEHAVIOR][self._testMethodName[5:]] % str(user_sid), res)
 748         #self.check_modify_inheritance(_ldb, class_dn)
 749
 750     def test_134(self):
 751         user_name = "testuser5"
 752         self.check_user_belongs(self.get_users_domain_dn(user_name), ["Enterprise Admins", "Domain Admins"])
 753         # Open Ldb connection with the tested user
 754         _ldb = self.get_ldb_connection(user_name, "samba123@")
 755         #Change Schema partition descriptor
 756         mod = "(A;CI;WDCC;;;AU)"
 757         self.sd_utils.dacl_add_ace(self.schema_dn, mod)
 758         # Create example Schema class
 759         class_dn = self.create_schema_class(_ldb)
 760         desc_sddl = self.sd_utils.get_sd_as_sddl(class_dn)
 761         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
 762         self.assertEqual(self.results[self.DS_BEHAVIOR][self._testMethodName[5:]], res)
 763         self.check_modify_inheritance(_ldb, class_dn)
 764
 765     def test_135(self):
 766         user_name = "testuser6"
 767         self.check_user_belongs(self.get_users_domain_dn(user_name), ["Enterprise Admins", "Domain Admins", "Schema Admins"])
 768         # Open Ldb connection with the tested user
 769         _ldb = self.get_ldb_connection(user_name, "samba123@")
 770         # Change Schema partition descriptor
 771         mod = "(A;CI;WDCC;;;AU)"
 772         self.sd_utils.dacl_add_ace(self.schema_dn, mod)
 773         # Create example Schema class
 774         class_dn = self.create_schema_class(_ldb)
 775         desc_sddl = self.sd_utils.get_sd_as_sddl(class_dn)
 776         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
 777         self.assertEqual(self.results[self.DS_BEHAVIOR][self._testMethodName[5:]], res)
 778         self.check_modify_inheritance(_ldb, class_dn)
 779
 780     def test_136(self):
 781         user_name = "testuser7"
 782         self.check_user_belongs(self.get_users_domain_dn(user_name), ["Domain Admins", "Schema Admins"])
 783         # Open Ldb connection with the tested user
 784         _ldb = self.get_ldb_connection(user_name, "samba123@")
 785         # Change Schema partition descriptor
 786         mod = "(A;CI;WDCC;;;AU)"
 787         self.sd_utils.dacl_add_ace(self.schema_dn, mod)
 788         # Create example Schema class
 789         class_dn = self.create_schema_class(_ldb)
 790         desc_sddl = self.sd_utils.get_sd_as_sddl(class_dn)
 791         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
 792         self.assertEqual(self.results[self.DS_BEHAVIOR][self._testMethodName[5:]], res)
 793         self.check_modify_inheritance(_ldb, class_dn)
 794
 795     def test_137(self):
 796         user_name = "testuser8"
 797         self.check_user_belongs(self.get_users_domain_dn(user_name), ["Enterprise Admins", "Schema Admins"])
 798         # Open Ldb connection with the tested user
 799         _ldb = self.get_ldb_connection(user_name, "samba123@")
 800         # Change Schema partition descriptor
 801         mod = "(A;CI;WDCC;;;AU)"
 802         self.sd_utils.dacl_add_ace(self.schema_dn, mod)
 803         # Create example Schema class
 804         class_dn = self.create_schema_class(_ldb)
 805         desc_sddl = self.sd_utils.get_sd_as_sddl(class_dn)
 806         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
 807         self.assertEqual(self.results[self.DS_BEHAVIOR][self._testMethodName[5:]], res)
 808         self.check_modify_inheritance(_ldb, class_dn)
 809
 810     # Custom descriptor tests ##################################################################
 811
 812     def test_138(self):
 813         user_name = "testuser1"
 814         self.check_user_belongs(self.get_users_domain_dn(user_name), ["Enterprise Admins"])
 815         # Open Ldb connection with the tested user
 816         _ldb = self.get_ldb_connection(user_name, "samba123@")
 817         # Change Schema partition descriptor
 818         mod = "(A;;CC;;;AU)"
 819         self.sd_utils.dacl_add_ace(self.schema_dn, mod)
 820         # Create a custom security descriptor
 821         desc_sddl = "O:DAG:DAD:(A;;RP;;;DU)"
 822         # Create example Schema class
 823         class_dn = self.create_schema_class(_ldb, desc_sddl)
 824         desc_sddl = self.sd_utils.get_sd_as_sddl(class_dn)
 825         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
 826         self.assertEqual("O:DAG:DA", res)
 827
 828     def test_139(self):
 829         user_name = "testuser2"
 830         self.check_user_belongs(self.get_users_domain_dn(user_name), ["Domain Admins"])
 831         # Open Ldb connection with the tested user
 832         _ldb = self.get_ldb_connection(user_name, "samba123@")
 833         # Change Schema partition descriptor
 834         mod = "(A;;CC;;;AU)"
 835         self.sd_utils.dacl_add_ace(self.schema_dn, mod)
 836         # Create a custom security descriptor
 837         desc_sddl = "O:DAG:DAD:(A;;RP;;;DU)"
 838         # Create example Schema class
 839         class_dn = self.create_schema_class(_ldb, desc_sddl)
 840         desc_sddl = self.sd_utils.get_sd_as_sddl(class_dn)
 841         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
 842         self.assertEqual("O:DAG:DA", res)
 843
 844     def test_140(self):
 845         user_name = "testuser3"
 846         self.check_user_belongs(self.get_users_domain_dn(user_name), ["Schema Admins"])
 847         # Open Ldb connection with the tested user
 848         _ldb = self.get_ldb_connection(user_name, "samba123@")
 849         # Create a custom security descriptor
 850         # NB! Problematic owner part won't accept DA only <User Sid> !!!
 851         user_sid = self.sd_utils.get_object_sid( self.get_users_domain_dn(user_name) )
 852         desc_sddl = "O:%sG:DAD:(A;;RP;;;DU)" % str(user_sid)
 853         # Create example Schema class
 854         class_dn = self.create_schema_class(_ldb, desc_sddl)
 855         desc_sddl = self.sd_utils.get_sd_as_sddl(class_dn)
 856         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
 857         self.assertEqual(self.results[self.DS_BEHAVIOR][self._testMethodName[5:]] % str(user_sid), res)
 858
 859     def test_141(self):
 860         user_name = "testuser4"
 861         self.check_user_belongs(self.get_users_domain_dn(user_name), [])
 862         # Open Ldb connection with the tested user
 863         _ldb = self.get_ldb_connection(user_name, "samba123@")
 864         # Create a custom security descriptor
 865         # NB! Problematic owner part won't accept DA only <User Sid> !!!
 866         user_sid = self.sd_utils.get_object_sid( self.get_users_domain_dn(user_name) )
 867         desc_sddl = "O:%sG:DAD:(A;;RP;;;DU)" % str(user_sid)
 868         # Create example Schema class
 869         class_dn = self.create_schema_class(_ldb, desc_sddl)
 870         desc_sddl = self.sd_utils.get_sd_as_sddl(class_dn)
 871         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
 872         self.assertEqual(self.results[self.DS_BEHAVIOR][self._testMethodName[5:]] % str(user_sid), res)
 873
 874     def test_142(self):
 875         user_name = "testuser5"
 876         self.check_user_belongs(self.get_users_domain_dn(user_name), ["Enterprise Admins", "Domain Admins"])
 877         # Open Ldb connection with the tested user
 878         _ldb = self.get_ldb_connection(user_name, "samba123@")
 879         # Change Schema partition descriptor
 880         mod = "(A;;CC;;;AU)"
 881         self.sd_utils.dacl_add_ace(self.schema_dn, mod)
 882         # Create a custom security descriptor
 883         desc_sddl = "O:DAG:DAD:(A;;RP;;;DU)"
 884         # Create example Schema class
 885         class_dn = self.create_schema_class(_ldb, desc_sddl)
 886         desc_sddl = self.sd_utils.get_sd_as_sddl(class_dn)
 887         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
 888         self.assertEqual("O:DAG:DA", res)
 889
 890     def test_143(self):
 891         user_name = "testuser6"
 892         self.check_user_belongs(self.get_users_domain_dn(user_name), ["Enterprise Admins", "Domain Admins", "Schema Admins"])
 893         # Open Ldb connection with the tested user
 894         _ldb = self.get_ldb_connection(user_name, "samba123@")
 895         # Change Schema partition descriptor
 896         mod = "(A;;CC;;;AU)"
 897         self.sd_utils.dacl_add_ace(self.schema_dn, mod)
 898         # Create a custom security descriptor
 899         desc_sddl = "O:DAG:DAD:(A;;RP;;;DU)"
 900         # Create example Schema class
 901         class_dn = self.create_schema_class(_ldb, desc_sddl)
 902         desc_sddl = self.sd_utils.get_sd_as_sddl(class_dn)
 903         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
 904         self.assertEqual("O:DAG:DA", res)
 905
 906     def test_144(self):
 907         user_name = "testuser7"
 908         self.check_user_belongs(self.get_users_domain_dn(user_name), ["Domain Admins", "Schema Admins"])
 909         # Open Ldb connection with the tested user
 910         _ldb = self.get_ldb_connection(user_name, "samba123@")
 911         # Change Schema partition descriptor
 912         mod = "(A;;CC;;;AU)"
 913         self.sd_utils.dacl_add_ace(self.schema_dn, mod)
 914         # Create a custom security descriptor
 915         desc_sddl = "O:DAG:DAD:(A;;RP;;;DU)"
 916         # Create example Schema class
 917         class_dn = self.create_schema_class(_ldb, desc_sddl)
 918         desc_sddl = self.sd_utils.get_sd_as_sddl(class_dn)
 919         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
 920         self.assertEqual("O:DAG:DA", res)
 921
 922     def test_145(self):
 923         user_name = "testuser8"
 924         self.check_user_belongs(self.get_users_domain_dn(user_name), ["Enterprise Admins", "Schema Admins"])
 925         # Open Ldb connection with the tested user
 926         _ldb = self.get_ldb_connection(user_name, "samba123@")
 927         # Change Schema partition descriptor
 928         mod = "(A;;CC;;;AU)"
 929         self.sd_utils.dacl_add_ace(self.schema_dn, mod)
 930         # Create a custom security descriptor
 931         desc_sddl = "O:DAG:DAD:(A;;RP;;;DU)"
 932         # Create example Schema class
 933         class_dn = self.create_schema_class(_ldb, desc_sddl)
 934         desc_sddl = self.sd_utils.get_sd_as_sddl(class_dn)
 935         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
 936         self.assertEqual("O:DAG:DA", res)
 937
 938     ## Tests for CONFIGURATION
 939
 940     # Defalt descriptor tests ##################################################################
 941
 942     def test_160(self):
 943         user_name = "testuser1"
 944         self.check_user_belongs(self.get_users_domain_dn(user_name), ["Enterprise Admins"])
 945         # Open Ldb connection with the tested user
 946         _ldb = self.get_ldb_connection(user_name, "samba123@")
 947         # Create example Configuration container
 948         container_name = "test-container1"
 949         object_dn = "CN=%s,CN=DisplaySpecifiers,%s" % (container_name, self.configuration_dn)
 950         delete_force(self.ldb_admin, object_dn)
 951         self.create_configuration_container(_ldb, object_dn, )
 952         desc_sddl = self.sd_utils.get_sd_as_sddl(object_dn)
 953         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
 954         self.assertEqual(self.results[self.DS_BEHAVIOR][self._testMethodName[5:]], res)
 955         self.check_modify_inheritance(_ldb, object_dn)
 956
 957     def test_161(self):
 958         user_name = "testuser2"
 959         self.check_user_belongs(self.get_users_domain_dn(user_name), ["Domain Admins"])
 960         # Open Ldb connection with the tested user
 961         _ldb = self.get_ldb_connection(user_name, "samba123@")
 962         # Create example Configuration container
 963         container_name = "test-container1"
 964         object_dn = "CN=%s,CN=DisplaySpecifiers,%s" % (container_name, self.configuration_dn)
 965         delete_force(self.ldb_admin, object_dn)
 966         self.create_configuration_container(_ldb, object_dn, )
 967         desc_sddl = self.sd_utils.get_sd_as_sddl(object_dn)
 968         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
 969         self.assertEqual(self.results[self.DS_BEHAVIOR][self._testMethodName[5:]], res)
 970         self.check_modify_inheritance(_ldb, object_dn)
 971
 972     def test_162(self):
 973         user_name = "testuser3"
 974         self.check_user_belongs(self.get_users_domain_dn(user_name), ["Schema Admins"])
 975         # Open Ldb connection with the tested user
 976         _ldb = self.get_ldb_connection(user_name, "samba123@")
 977         # Create example Configuration container
 978         object_dn = "CN=test-container1,CN=DisplaySpecifiers," + self.configuration_dn
 979         delete_force(self.ldb_admin, object_dn)
 980         self.create_configuration_container(self.ldb_admin, object_dn, )
 981         user_sid = self.sd_utils.get_object_sid( self.get_users_domain_dn(user_name) )
 982         mod = "(A;;WDCC;;;AU)"
 983         self.sd_utils.dacl_add_ace(object_dn, mod)
 984         # Create child object with user's credentials
 985         object_dn = "CN=test-specifier1," + object_dn
 986         delete_force(self.ldb_admin, object_dn)
 987         self.create_configuration_specifier(_ldb, object_dn)
 988         desc_sddl = self.sd_utils.get_sd_as_sddl(object_dn)
 989         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
 990         self.assertEqual(self.results[self.DS_BEHAVIOR][self._testMethodName[5:]] % str(user_sid), res)
 991         #self.check_modify_inheritance(_ldb, object_dn)
 992
 993     def test_163(self):
 994         user_name = "testuser4"
 995         self.check_user_belongs(self.get_users_domain_dn(user_name), [])
 996         # Open Ldb connection with the tested user
 997         _ldb = self.get_ldb_connection(user_name, "samba123@")
 998         # Create example Configuration container
 999         object_dn = "CN=test-container1,CN=DisplaySpecifiers," + self.configuration_dn
1000         delete_force(self.ldb_admin, object_dn)
1001         self.create_configuration_container(self.ldb_admin, object_dn, )
1002         user_sid = self.sd_utils.get_object_sid( self.get_users_domain_dn(user_name) )
1003         mod = "(A;CI;WDCC;;;AU)"
1004         self.sd_utils.dacl_add_ace(object_dn, mod)
1005         # Create child object with user's credentials
1006         object_dn = "CN=test-specifier1," + object_dn
1007         delete_force(self.ldb_admin, object_dn)
1008         self.create_configuration_specifier(_ldb, object_dn)
1009         desc_sddl = self.sd_utils.get_sd_as_sddl(object_dn)
1010         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
1011         self.assertEqual(self.results[self.DS_BEHAVIOR][self._testMethodName[5:]] % str(user_sid), res)
1012         #self.check_modify_inheritance(_ldb, object_dn)
1013
1014     def test_164(self):
1015         user_name = "testuser5"
1016         self.check_user_belongs(self.get_users_domain_dn(user_name), ["Enterprise Admins", "Domain Admins"])
1017         # Open Ldb connection with the tested user
1018         _ldb = self.get_ldb_connection(user_name, "samba123@")
1019         # Create example Configuration container
1020         container_name = "test-container1"
1021         object_dn = "CN=%s,CN=DisplaySpecifiers,%s" % (container_name, self.configuration_dn)
1022         delete_force(self.ldb_admin, object_dn)
1023         self.create_configuration_container(_ldb, object_dn, )
1024         desc_sddl = self.sd_utils.get_sd_as_sddl(object_dn)
1025         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
1026         self.assertEqual(self.results[self.DS_BEHAVIOR][self._testMethodName[5:]], res)
1027         self.check_modify_inheritance(_ldb, object_dn)
1028
1029     def test_165(self):
1030         user_name = "testuser6"
1031         self.check_user_belongs(self.get_users_domain_dn(user_name), ["Enterprise Admins", "Domain Admins", "Schema Admins"])
1032         # Open Ldb connection with the tested user
1033         _ldb = self.get_ldb_connection(user_name, "samba123@")
1034         # Create example Configuration container
1035         container_name = "test-container1"
1036         object_dn = "CN=%s,CN=DisplaySpecifiers,%s" % (container_name, self.configuration_dn)
1037         delete_force(self.ldb_admin, object_dn)
1038         self.create_configuration_container(_ldb, object_dn, )
1039         desc_sddl = self.sd_utils.get_sd_as_sddl(object_dn)
1040         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
1041         self.assertEqual(self.results[self.DS_BEHAVIOR][self._testMethodName[5:]], res)
1042         self.check_modify_inheritance(_ldb, object_dn)
1043
1044     def test_166(self):
1045         user_name = "testuser7"
1046         self.check_user_belongs(self.get_users_domain_dn(user_name), ["Domain Admins", "Schema Admins"])
1047         # Open Ldb connection with the tested user
1048         _ldb = self.get_ldb_connection(user_name, "samba123@")
1049         # Create example Configuration container
1050         container_name = "test-container1"
1051         object_dn = "CN=%s,CN=DisplaySpecifiers,%s" % (container_name, self.configuration_dn)
1052         delete_force(self.ldb_admin, object_dn)
1053         self.create_configuration_container(_ldb, object_dn, )
1054         desc_sddl = self.sd_utils.get_sd_as_sddl(object_dn)
1055         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
1056         self.assertEqual(self.results[self.DS_BEHAVIOR][self._testMethodName[5:]], res)
1057         self.check_modify_inheritance(_ldb, object_dn)
1058
1059     def test_167(self):
1060         user_name = "testuser8"
1061         self.check_user_belongs(self.get_users_domain_dn(user_name), ["Enterprise Admins", "Schema Admins"])
1062         # Open Ldb connection with the tested user
1063         _ldb = self.get_ldb_connection(user_name, "samba123@")
1064         # Create example Configuration container
1065         container_name = "test-container1"
1066         object_dn = "CN=%s,CN=DisplaySpecifiers,%s" % (container_name, self.configuration_dn)
1067         delete_force(self.ldb_admin, object_dn)
1068         self.create_configuration_container(_ldb, object_dn, )
1069         desc_sddl = self.sd_utils.get_sd_as_sddl(object_dn)
1070         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
1071         self.assertEqual(self.results[self.DS_BEHAVIOR][self._testMethodName[5:]], res)
1072         self.check_modify_inheritance(_ldb, object_dn)
1073
1074     # Custom descriptor tests ##################################################################
1075
1076     def test_168(self):
1077         user_name = "testuser1"
1078         self.check_user_belongs(self.get_users_domain_dn(user_name), ["Enterprise Admins"])
1079         # Open Ldb connection with the tested user
1080         _ldb = self.get_ldb_connection(user_name, "samba123@")
1081         # Create example Configuration container
1082         container_name = "test-container1"
1083         object_dn = "CN=%s,CN=DisplaySpecifiers,%s" % (container_name, self.configuration_dn)
1084         delete_force(self.ldb_admin, object_dn)
1085         # Create a custom security descriptor
1086         desc_sddl = "O:DAG:DAD:(A;;RP;;;DU)"
1087         self.create_configuration_container(_ldb, object_dn, desc_sddl)
1088         desc_sddl = self.sd_utils.get_sd_as_sddl(object_dn)
1089         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
1090         self.assertEqual("O:DAG:DA", res)
1091
1092     def test_169(self):
1093         user_name = "testuser2"
1094         self.check_user_belongs(self.get_users_domain_dn(user_name), ["Domain Admins"])
1095         # Open Ldb connection with the tested user
1096         _ldb = self.get_ldb_connection(user_name, "samba123@")
1097         # Create example Configuration container
1098         container_name = "test-container1"
1099         object_dn = "CN=%s,CN=DisplaySpecifiers,%s" % (container_name, self.configuration_dn)
1100         delete_force(self.ldb_admin, object_dn)
1101         # Create a custom security descriptor
1102         desc_sddl = "O:DAG:DAD:(A;;RP;;;DU)"
1103         self.create_configuration_container(_ldb, object_dn, desc_sddl)
1104         desc_sddl = self.sd_utils.get_sd_as_sddl(object_dn)
1105         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
1106         self.assertEqual("O:DAG:DA", res)
1107
1108     def test_170(self):
1109         user_name = "testuser3"
1110         self.check_user_belongs(self.get_users_domain_dn(user_name), ["Schema Admins"])
1111         # Open Ldb connection with the tested user
1112         _ldb = self.get_ldb_connection(user_name, "samba123@")
1113         # Create example Configuration container
1114         object_dn = "CN=test-container1,CN=DisplaySpecifiers," + self.configuration_dn
1115         delete_force(self.ldb_admin, object_dn)
1116         self.create_configuration_container(self.ldb_admin, object_dn, )
1117         user_sid = self.sd_utils.get_object_sid( self.get_users_domain_dn(user_name) )
1118         mod = "(A;;CC;;;AU)"
1119         self.sd_utils.dacl_add_ace(object_dn, mod)
1120         # Create child object with user's credentials
1121         object_dn = "CN=test-specifier1," + object_dn
1122         delete_force(self.ldb_admin, object_dn)
1123         # Create a custom security descriptor
1124         # NB! Problematic owner part won't accept DA only <User Sid> !!!
1125         desc_sddl = "O:%sG:DAD:(A;;RP;;;DU)" % str(user_sid)
1126         self.create_configuration_specifier(_ldb, object_dn, desc_sddl)
1127         desc_sddl = self.sd_utils.get_sd_as_sddl(object_dn)
1128         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
1129         self.assertEqual(self.results[self.DS_BEHAVIOR][self._testMethodName[5:]] % str(user_sid), res)
1130
1131     def test_171(self):
1132         user_name = "testuser4"
1133         self.check_user_belongs(self.get_users_domain_dn(user_name), [])
1134         # Open Ldb connection with the tested user
1135         _ldb = self.get_ldb_connection(user_name, "samba123@")
1136         # Create example Configuration container
1137         object_dn = "CN=test-container1,CN=DisplaySpecifiers," + self.configuration_dn
1138         delete_force(self.ldb_admin, object_dn)
1139         self.create_configuration_container(self.ldb_admin, object_dn, )
1140         user_sid = self.sd_utils.get_object_sid( self.get_users_domain_dn(user_name) )
1141         mod = "(A;;CC;;;AU)"
1142         self.sd_utils.dacl_add_ace(object_dn, mod)
1143         # Create child object with user's credentials
1144         object_dn = "CN=test-specifier1," + object_dn
1145         delete_force(self.ldb_admin, object_dn)
1146         # Create a custom security descriptor
1147         # NB! Problematic owner part won't accept DA only <User Sid> !!!
1148         desc_sddl = "O:%sG:DAD:(A;;RP;;;DU)" % str(user_sid)
1149         self.create_configuration_specifier(_ldb, object_dn, desc_sddl)
1150         desc_sddl = self.sd_utils.get_sd_as_sddl(object_dn)
1151         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
1152         self.assertEqual(self.results[self.DS_BEHAVIOR][self._testMethodName[5:]] % str(user_sid), res)
1153
1154     def test_172(self):
1155         user_name = "testuser5"
1156         self.check_user_belongs(self.get_users_domain_dn(user_name), ["Enterprise Admins", "Domain Admins"])
1157         # Open Ldb connection with the tested user
1158         _ldb = self.get_ldb_connection(user_name, "samba123@")
1159         # Create example Configuration container
1160         container_name = "test-container1"
1161         object_dn = "CN=%s,CN=DisplaySpecifiers,%s" % (container_name, self.configuration_dn)
1162         delete_force(self.ldb_admin, object_dn)
1163         # Create a custom security descriptor
1164         desc_sddl = "O:DAG:DAD:(A;;RP;;;DU)"
1165         self.create_configuration_container(_ldb, object_dn, desc_sddl)
1166         desc_sddl = self.sd_utils.get_sd_as_sddl(object_dn)
1167         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
1168         self.assertEqual("O:DAG:DA", res)
1169
1170     def test_173(self):
1171         user_name = "testuser6"
1172         self.check_user_belongs(self.get_users_domain_dn(user_name), ["Enterprise Admins", "Domain Admins", "Schema Admins"])
1173         # Open Ldb connection with the tested user
1174         _ldb = self.get_ldb_connection(user_name, "samba123@")
1175         # Create example Configuration container
1176         container_name = "test-container1"
1177         object_dn = "CN=%s,CN=DisplaySpecifiers,%s" % (container_name, self.configuration_dn)
1178         delete_force(self.ldb_admin, object_dn)
1179         # Create a custom security descriptor
1180         desc_sddl = "O:DAG:DAD:(A;;RP;;;DU)"
1181         self.create_configuration_container(_ldb, object_dn, desc_sddl)
1182         desc_sddl = self.sd_utils.get_sd_as_sddl(object_dn)
1183         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
1184         self.assertEqual("O:DAG:DA", res)
1185
1186     def test_174(self):
1187         user_name = "testuser7"
1188         self.check_user_belongs(self.get_users_domain_dn(user_name), ["Domain Admins", "Schema Admins"])
1189         # Open Ldb connection with the tested user
1190         _ldb = self.get_ldb_connection(user_name, "samba123@")
1191         # Create example Configuration container
1192         container_name = "test-container1"
1193         object_dn = "CN=%s,CN=DisplaySpecifiers,%s" % (container_name, self.configuration_dn)
1194         delete_force(self.ldb_admin, object_dn)
1195         # Create a custom security descriptor
1196         desc_sddl = "O:DAG:DAD:(A;;RP;;;DU)"
1197         self.create_configuration_container(_ldb, object_dn, desc_sddl)
1198         desc_sddl = self.sd_utils.get_sd_as_sddl(object_dn)
1199         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
1200         self.assertEqual("O:DAG:DA", res)
1201
1202     def test_175(self):
1203         user_name = "testuser8"
1204         self.check_user_belongs(self.get_users_domain_dn(user_name), ["Enterprise Admins", "Schema Admins"])
1205         # Open Ldb connection with the tested user
1206         _ldb = self.get_ldb_connection(user_name, "samba123@")
1207         # Create example Configuration container
1208         container_name = "test-container1"
1209         object_dn = "CN=%s,CN=DisplaySpecifiers,%s" % (container_name, self.configuration_dn)
1210         delete_force(self.ldb_admin, object_dn)
1211         # Create a custom security descriptor
1212         desc_sddl = "O:DAG:DAD:(A;;RP;;;DU)"
1213         self.create_configuration_container(_ldb, object_dn, desc_sddl)
1214         desc_sddl = self.sd_utils.get_sd_as_sddl(object_dn)
1215         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
1216         self.assertEqual("O:DAG:DA", res)
1217
1218     ########################################################################################
1219     # Inheritance tests for DACL
1220
1221 class DaclDescriptorTests(DescriptorTests):
1222
1223     def deleteAll(self):
1224         delete_force(self.ldb_admin, "CN=test_inherit_group,OU=test_inherit_ou," + self.base_dn)
1225         delete_force(self.ldb_admin, "OU=test_inherit_ou5,OU=test_inherit_ou1,OU=test_inherit_ou_p," + self.base_dn)
1226         delete_force(self.ldb_admin, "OU=test_inherit_ou6,OU=test_inherit_ou2,OU=test_inherit_ou_p," + self.base_dn)
1227         delete_force(self.ldb_admin, "OU=test_inherit_ou1,OU=test_inherit_ou_p," + self.base_dn)
1228         delete_force(self.ldb_admin, "OU=test_inherit_ou2,OU=test_inherit_ou_p," + self.base_dn)
1229         delete_force(self.ldb_admin, "OU=test_inherit_ou3,OU=test_inherit_ou_p," + self.base_dn)
1230         delete_force(self.ldb_admin, "OU=test_inherit_ou4,OU=test_inherit_ou_p," + self.base_dn)
1231         delete_force(self.ldb_admin, "OU=test_inherit_ou_p," + self.base_dn)
1232         delete_force(self.ldb_admin, "OU=test_inherit_ou," + self.base_dn)
1233
1234     def setUp(self):
1235         super(DaclDescriptorTests, self).setUp()
1236         self.deleteAll()
1237
1238     def create_clean_ou(self, object_dn):
1239         """ Base repeating setup for unittests to follow """
1240         res = self.ldb_admin.search(base=self.base_dn, scope=SCOPE_SUBTREE, \
1241                                     expression="distinguishedName=%s" % object_dn)
1242         # Make sure top testing OU has been deleted before starting the test
1243         self.assertEqual(len(res), 0)
1244         self.ldb_admin.create_ou(object_dn)
1245         desc_sddl = self.sd_utils.get_sd_as_sddl(object_dn)
1246         # Make sure there are inheritable ACEs initially
1247         self.assertTrue("CI" in desc_sddl or "OI" in desc_sddl)
1248         # Find and remove all inherit ACEs
1249         res = re.findall("\(.*?\)", desc_sddl)
1250         res = [x for x in res if ("CI" in x) or ("OI" in x)]
1251         for x in res:
1252             desc_sddl = desc_sddl.replace(x, "")
1253         # Add flag 'protected' in both DACL and SACL so no inherit ACEs
1254         # can propagate from above
1255         # remove SACL, we are not interested
1256         desc_sddl = desc_sddl.replace(":AI", ":AIP")
1257         self.sd_utils.modify_sd_on_dn(object_dn, desc_sddl)
1258         # Verify all inheritable ACEs are gone
1259         desc_sddl = self.sd_utils.get_sd_as_sddl(object_dn)
1260         self.assertFalse("CI" in desc_sddl)
1261         self.assertFalse("OI" in desc_sddl)
1262
1263     def test_200(self):
1264         """ OU with protected flag and child group. See if the group has inherit ACEs.
1265         """
1266         ou_dn = "OU=test_inherit_ou," + self.base_dn
1267         group_dn = "CN=test_inherit_group," + ou_dn
1268         # Create inheritable-free OU
1269         self.create_clean_ou(ou_dn)
1270         # Create group child object
1271         self.ldb_admin.newgroup("test_inherit_group", groupou="OU=test_inherit_ou", grouptype=4)
1272         # Make sure created group object contains NO inherit ACEs
1273         desc_sddl = self.sd_utils.get_sd_as_sddl(group_dn)
1274         self.assertFalse("ID" in desc_sddl)
1275
1276     def test_201(self):
1277         """ OU with protected flag and no inherit ACEs, child group with custom descriptor.
1278             Verify group has custom and default ACEs only.
1279         """
1280         ou_dn = "OU=test_inherit_ou," + self.base_dn
1281         group_dn = "CN=test_inherit_group," + ou_dn
1282         # Create inheritable-free OU
1283         self.create_clean_ou(ou_dn)
1284         # Create group child object using custom security descriptor
1285         sddl = "O:AUG:AUD:AI(D;;WP;;;DU)"
1286         tmp_desc = security.descriptor.from_sddl(sddl, self.domain_sid)
1287         self.ldb_admin.newgroup("test_inherit_group", groupou="OU=test_inherit_ou", grouptype=4, sd=tmp_desc)
1288         # Make sure created group descriptor has NO additional ACEs
1289         desc_sddl = self.sd_utils.get_sd_as_sddl(group_dn)
1290         self.assertEqual(desc_sddl, sddl)
1291         sddl = "O:AUG:AUD:AI(D;;CC;;;LG)"
1292         self.sd_utils.modify_sd_on_dn(group_dn, sddl)
1293         desc_sddl = self.sd_utils.get_sd_as_sddl(group_dn)
1294         self.assertEqual(desc_sddl, sddl)
1295
1296     def test_202(self):
1297         """ OU with protected flag and add couple non-inheritable ACEs, child group.
1298             See if the group has any of the added ACEs.
1299         """
1300         ou_dn = "OU=test_inherit_ou," + self.base_dn
1301         group_dn = "CN=test_inherit_group," + ou_dn
1302         # Create inheritable-free OU
1303         self.create_clean_ou(ou_dn)
1304         # Add some custom non-inheritable ACEs
1305         mod = "(D;;WP;;;DU)(A;;RP;;;DU)"
1306         moded = "(D;;CC;;;LG)"
1307         self.sd_utils.dacl_add_ace(ou_dn, mod)
1308         # Verify all inheritable ACEs are gone
1309         desc_sddl = self.sd_utils.get_sd_as_sddl(ou_dn)
1310         # Create group child object
1311         self.ldb_admin.newgroup("test_inherit_group", groupou="OU=test_inherit_ou", grouptype=4)
1312         # Make sure created group object contains NO inherit ACEs
1313         # also make sure the added above non-inheritable ACEs are absent too
1314         desc_sddl = self.sd_utils.get_sd_as_sddl(group_dn)
1315         self.assertFalse("ID" in desc_sddl)
1316         for x in re.findall("\(.*?\)", mod):
1317             self.assertFalse(x in desc_sddl)
1318         self.sd_utils.modify_sd_on_dn(group_dn, "D:" + moded)
1319         desc_sddl = self.sd_utils.get_sd_as_sddl(group_dn)
1320         self.assertFalse("ID" in desc_sddl)
1321         for x in re.findall("\(.*?\)", mod):
1322             self.assertFalse(x in desc_sddl)
1323
1324     def test_203(self):
1325         """ OU with protected flag and add 'CI' ACE, child group.
1326             See if the group has the added inherited ACE.
1327         """
1328         ou_dn = "OU=test_inherit_ou," + self.base_dn
1329         group_dn = "CN=test_inherit_group," + ou_dn
1330         # Create inheritable-free OU
1331         self.create_clean_ou(ou_dn)
1332         # Add some custom 'CI' ACE
1333         mod = "(D;CI;WP;;;DU)"
1334         moded = "(D;;CC;;;LG)"
1335         self.sd_utils.dacl_add_ace(ou_dn, mod)
1336         desc_sddl = self.sd_utils.get_sd_as_sddl(ou_dn)
1337         # Create group child object
1338         tmp_desc = security.descriptor.from_sddl("O:AUG:AUD:AI(A;;CC;;;AU)", self.domain_sid)
1339         self.ldb_admin.newgroup("test_inherit_group", groupou="OU=test_inherit_ou", grouptype=4, sd=tmp_desc)
1340         # Make sure created group object contains only the above inherited ACE
1341         # that we've added manually
1342         desc_sddl = self.sd_utils.get_sd_as_sddl(group_dn)
1343         mod = mod.replace(";CI;", ";CIID;")
1344         self.assertTrue(mod in desc_sddl)
1345         self.sd_utils.modify_sd_on_dn(group_dn, "D:" + moded)
1346         desc_sddl = self.sd_utils.get_sd_as_sddl(group_dn)
1347         self.assertTrue(moded in desc_sddl)
1348         self.assertTrue(mod in desc_sddl)
1349
1350     def test_204(self):
1351         """ OU with protected flag and add 'OI' ACE, child group.
1352             See if the group has the added inherited ACE.
1353         """
1354         ou_dn = "OU=test_inherit_ou," + self.base_dn
1355         group_dn = "CN=test_inherit_group," + ou_dn
1356         # Create inheritable-free OU
1357         self.create_clean_ou(ou_dn)
1358         # Add some custom 'CI' ACE
1359         mod = "(D;OI;WP;;;DU)"
1360         moded = "(D;;CC;;;LG)"
1361         self.sd_utils.dacl_add_ace(ou_dn, mod)
1362         desc_sddl = self.sd_utils.get_sd_as_sddl(ou_dn)
1363         # Create group child object
1364         tmp_desc = security.descriptor.from_sddl("O:AUG:AUD:AI(A;;CC;;;AU)", self.domain_sid)
1365         self.ldb_admin.newgroup("test_inherit_group", groupou="OU=test_inherit_ou", grouptype=4, sd=tmp_desc)
1366         # Make sure created group object contains only the above inherited ACE
1367         # that we've added manually
1368         desc_sddl = self.sd_utils.get_sd_as_sddl(group_dn)
1369         mod = mod.replace(";OI;", ";OIIOID;") # change it how it's gonna look like
1370         self.assertTrue(mod in desc_sddl)
1371         self.sd_utils.modify_sd_on_dn(group_dn, "D:" +moded)
1372         desc_sddl = self.sd_utils.get_sd_as_sddl(group_dn)
1373         self.assertTrue(moded in desc_sddl)
1374         self.assertTrue(mod in desc_sddl)
1375
1376     def test_205(self):
1377         """ OU with protected flag and add 'OA' for GUID & 'CI' ACE, child group.
1378             See if the group has the added inherited ACE.
1379         """
1380         ou_dn = "OU=test_inherit_ou," + self.base_dn
1381         group_dn = "CN=test_inherit_group," + ou_dn
1382         # Create inheritable-free OU
1383         self.create_clean_ou(ou_dn)
1384         # Add some custom 'OA' for 'name' attribute & 'CI' ACE
1385         mod = "(OA;CI;WP;bf967a0e-0de6-11d0-a285-00aa003049e2;;DU)"
1386         moded = "(D;;CC;;;LG)"
1387         self.sd_utils.dacl_add_ace(ou_dn, mod)
1388         desc_sddl = self.sd_utils.get_sd_as_sddl(ou_dn)
1389         # Create group child object
1390         tmp_desc = security.descriptor.from_sddl("O:AUG:AUD:AI(A;;CC;;;AU)", self.domain_sid)
1391         self.ldb_admin.newgroup("test_inherit_group", groupou="OU=test_inherit_ou", grouptype=4, sd=tmp_desc)
1392         # Make sure created group object contains only the above inherited ACE
1393         # that we've added manually
1394         desc_sddl = self.sd_utils.get_sd_as_sddl(group_dn)
1395         mod = mod.replace(";CI;", ";CIID;") # change it how it's gonna look like
1396         self.assertTrue(mod in desc_sddl)
1397         self.sd_utils.modify_sd_on_dn(group_dn, "D:" + moded)
1398         desc_sddl = self.sd_utils.get_sd_as_sddl(group_dn)
1399         self.assertTrue(moded in desc_sddl)
1400         self.assertTrue(mod in desc_sddl)
1401
1402     def test_206(self):
1403         """ OU with protected flag and add 'OA' for GUID & 'OI' ACE, child group.
1404             See if the group has the added inherited ACE.
1405         """
1406         ou_dn = "OU=test_inherit_ou," + self.base_dn
1407         group_dn = "CN=test_inherit_group," + ou_dn
1408         # Create inheritable-free OU
1409         self.create_clean_ou(ou_dn)
1410         # Add some custom 'OA' for 'name' attribute & 'OI' ACE
1411         mod = "(OA;OI;WP;bf967a0e-0de6-11d0-a285-00aa003049e2;;DU)"
1412         moded = "(D;;CC;;;LG)"
1413         self.sd_utils.dacl_add_ace(ou_dn, mod)
1414         desc_sddl = self.sd_utils.get_sd_as_sddl(ou_dn)
1415         # Create group child object
1416         tmp_desc = security.descriptor.from_sddl("O:AUG:AUD:AI(A;;CC;;;AU)", self.domain_sid)
1417         self.ldb_admin.newgroup("test_inherit_group", groupou="OU=test_inherit_ou", grouptype=4, sd=tmp_desc)
1418         # Make sure created group object contains only the above inherited ACE
1419         # that we've added manually
1420         desc_sddl = self.sd_utils.get_sd_as_sddl(group_dn)
1421         mod = mod.replace(";OI;", ";OIIOID;") # change it how it's gonna look like
1422         self.assertTrue(mod in desc_sddl)
1423         self.sd_utils.modify_sd_on_dn(group_dn, "D:" + moded)
1424         desc_sddl = self.sd_utils.get_sd_as_sddl(group_dn)
1425         self.assertTrue(moded in desc_sddl)
1426         self.assertTrue(mod in desc_sddl)
1427
1428     def test_207(self):
1429         """ OU with protected flag and add 'OA' for OU specific GUID & 'CI' ACE, child group.
1430             See if the group has the added inherited ACE.
1431         """
1432         ou_dn = "OU=test_inherit_ou," + self.base_dn
1433         group_dn = "CN=test_inherit_group," + ou_dn
1434         # Create inheritable-free OU
1435         self.create_clean_ou(ou_dn)
1436         # Add some custom 'OA' for 'st' attribute (OU specific) & 'CI' ACE
1437         mod = "(OA;CI;WP;bf967a39-0de6-11d0-a285-00aa003049e2;;DU)"
1438         moded = "(D;;CC;;;LG)"
1439         self.sd_utils.dacl_add_ace(ou_dn, mod)
1440         desc_sddl = self.sd_utils.get_sd_as_sddl(ou_dn)
1441         # Create group child object
1442         tmp_desc = security.descriptor.from_sddl("O:AUG:AUD:AI(A;;CC;;;AU)", self.domain_sid)
1443         self.ldb_admin.newgroup("test_inherit_group", groupou="OU=test_inherit_ou", grouptype=4, sd=tmp_desc)
1444         # Make sure created group object contains only the above inherited ACE
1445         # that we've added manually
1446         desc_sddl = self.sd_utils.get_sd_as_sddl(group_dn)
1447         mod = mod.replace(";CI;", ";CIID;") # change it how it's gonna look like
1448         self.assertTrue(mod in desc_sddl)
1449         self.sd_utils.modify_sd_on_dn(group_dn, "D:" + moded)
1450         desc_sddl = self.sd_utils.get_sd_as_sddl(group_dn)
1451         self.assertTrue(moded in desc_sddl)
1452         self.assertTrue(mod in desc_sddl)
1453
1454     def test_208(self):
1455         """ OU with protected flag and add 'OA' for OU specific GUID & 'OI' ACE, child group.
1456             See if the group has the added inherited ACE.
1457         """
1458         ou_dn = "OU=test_inherit_ou," + self.base_dn
1459         group_dn = "CN=test_inherit_group," + ou_dn
1460         # Create inheritable-free OU
1461         self.create_clean_ou(ou_dn)
1462         # Add some custom 'OA' for 'st' attribute (OU specific) & 'OI' ACE
1463         mod = "(OA;OI;WP;bf967a39-0de6-11d0-a285-00aa003049e2;;DU)"
1464         moded = "(D;;CC;;;LG)"
1465         self.sd_utils.dacl_add_ace(ou_dn, mod)
1466         desc_sddl = self.sd_utils.get_sd_as_sddl(ou_dn)
1467         # Create group child object
1468         tmp_desc = security.descriptor.from_sddl("O:AUG:AUD:AI(A;;CC;;;AU)", self.domain_sid)
1469         self.ldb_admin.newgroup("test_inherit_group", groupou="OU=test_inherit_ou", grouptype=4, sd=tmp_desc)
1470         # Make sure created group object contains only the above inherited ACE
1471         # that we've added manually
1472         desc_sddl = self.sd_utils.get_sd_as_sddl(group_dn)
1473         mod = mod.replace(";OI;", ";OIIOID;") # change it how it's gonna look like
1474         self.assertTrue(mod in desc_sddl)
1475         self.sd_utils.modify_sd_on_dn(group_dn, "D:(OA;OI;WP;bf967a39-0de6-11d0-a285-00aa003049e2;;DU)" + moded)
1476         desc_sddl = self.sd_utils.get_sd_as_sddl(group_dn)
1477         self.assertTrue(moded in desc_sddl)
1478         self.assertTrue(mod in desc_sddl)
1479
1480     def test_209(self):
1481         """ OU with protected flag and add 'CI' ACE with 'CO' SID, child group.
1482             See if the group has the added inherited ACE.
1483         """
1484         ou_dn = "OU=test_inherit_ou," + self.base_dn
1485         group_dn = "CN=test_inherit_group," + ou_dn
1486         # Create inheritable-free OU
1487         self.create_clean_ou(ou_dn)
1488         # Add some custom 'CI' ACE
1489         mod = "(D;CI;WP;;;CO)"
1490         moded = "(D;;CC;;;LG)"
1491         self.sd_utils.dacl_add_ace(ou_dn, mod)
1492         desc_sddl = self.sd_utils.get_sd_as_sddl(ou_dn)
1493         # Create group child object
1494         tmp_desc = security.descriptor.from_sddl("O:AUG:AUD:AI(A;;CC;;;AU)", self.domain_sid)
1495         self.ldb_admin.newgroup("test_inherit_group", groupou="OU=test_inherit_ou", grouptype=4, sd=tmp_desc)
1496         # Make sure created group object contains only the above inherited ACE(s)
1497         # that we've added manually
1498         desc_sddl = self.sd_utils.get_sd_as_sddl(group_dn)
1499         self.assertTrue("(D;ID;WP;;;AU)" in desc_sddl)
1500         self.assertTrue("(D;CIIOID;WP;;;CO)" in desc_sddl)
1501         self.sd_utils.modify_sd_on_dn(group_dn, "D:" + moded)
1502         desc_sddl = self.sd_utils.get_sd_as_sddl(group_dn)
1503         self.assertTrue(moded in desc_sddl)
1504         self.assertTrue("(D;ID;WP;;;DA)" in desc_sddl)
1505         self.assertTrue("(D;CIIOID;WP;;;CO)" in desc_sddl)
1506
1507     def test_210(self):
1508         """ OU with protected flag, provide ACEs with ID flag raised. Should be ignored.
1509         """
1510         ou_dn = "OU=test_inherit_ou," + self.base_dn
1511         group_dn = "CN=test_inherit_group," + ou_dn
1512         self.create_clean_ou(ou_dn)
1513         # Add some custom  ACE
1514         mod = "D:(D;CIIO;WP;;;CO)(A;ID;WP;;;AU)"
1515         tmp_desc = security.descriptor.from_sddl(mod, self.domain_sid)
1516         self.ldb_admin.newgroup("test_inherit_group", groupou="OU=test_inherit_ou", grouptype=4, sd=tmp_desc)
1517         # Make sure created group object does not contain the ID ace
1518         desc_sddl = self.sd_utils.get_sd_as_sddl(group_dn)
1519         self.assertFalse("(A;ID;WP;;;AU)" in desc_sddl)
1520
1521     def test_211(self):
1522         """ Provide ACE with CO SID, should be expanded and replaced
1523         """
1524         ou_dn = "OU=test_inherit_ou," + self.base_dn
1525         group_dn = "CN=test_inherit_group," + ou_dn
1526         # Create inheritable-free OU
1527         self.create_clean_ou(ou_dn)
1528         # Add some custom 'CI' ACE
1529         mod = "D:(D;CI;WP;;;CO)"
1530         tmp_desc = security.descriptor.from_sddl(mod, self.domain_sid)
1531         self.ldb_admin.newgroup("test_inherit_group", groupou="OU=test_inherit_ou", grouptype=4, sd=tmp_desc)
1532         desc_sddl = self.sd_utils.get_sd_as_sddl(group_dn)
1533         self.assertTrue("(D;;WP;;;DA)" in desc_sddl)
1534         self.assertTrue("(D;CIIO;WP;;;CO)" in desc_sddl)
1535
1536     def test_212(self):
1537         """ Provide ACE with IO flag, should be ignored
1538         """
1539         ou_dn = "OU=test_inherit_ou," + self.base_dn
1540         group_dn = "CN=test_inherit_group," + ou_dn
1541         # Create inheritable-free OU
1542         self.create_clean_ou(ou_dn)
1543         # Add some custom 'CI' ACE
1544         mod = "D:(D;CIIO;WP;;;CO)"
1545         tmp_desc = security.descriptor.from_sddl(mod, self.domain_sid)
1546         self.ldb_admin.newgroup("test_inherit_group", groupou="OU=test_inherit_ou", grouptype=4, sd=tmp_desc)
1547         # Make sure created group object contains only the above inherited ACE(s)
1548         # that we've added manually
1549         desc_sddl = self.sd_utils.get_sd_as_sddl(group_dn)
1550         self.assertTrue("(D;CIIO;WP;;;CO)" in desc_sddl)
1551         self.assertFalse("(D;;WP;;;DA)" in desc_sddl)
1552         self.assertFalse("(D;CIIO;WP;;;CO)(D;CIIO;WP;;;CO)" in desc_sddl)
1553
1554     def test_213(self):
1555         """ Provide ACE with IO flag, should be ignored
1556         """
1557         ou_dn = "OU=test_inherit_ou," + self.base_dn
1558         group_dn = "CN=test_inherit_group," + ou_dn
1559         # Create inheritable-free OU
1560         self.create_clean_ou(ou_dn)
1561         mod = "D:(D;IO;WP;;;DA)"
1562         tmp_desc = security.descriptor.from_sddl(mod, self.domain_sid)
1563         self.ldb_admin.newgroup("test_inherit_group", groupou="OU=test_inherit_ou", grouptype=4, sd=tmp_desc)
1564         # Make sure created group object contains only the above inherited ACE(s)
1565         # that we've added manually
1566         desc_sddl = self.sd_utils.get_sd_as_sddl(group_dn)
1567         self.assertFalse("(D;IO;WP;;;DA)" in desc_sddl)
1568
1569     def test_214(self):
1570         """ Test behavior of ACEs containing generic rights
1571         """
1572         ou_dn = "OU=test_inherit_ou_p," + self.base_dn
1573         ou_dn1 = "OU=test_inherit_ou1," + ou_dn
1574         ou_dn2 = "OU=test_inherit_ou2," + ou_dn
1575         ou_dn3 = "OU=test_inherit_ou3," + ou_dn
1576         ou_dn4 = "OU=test_inherit_ou4," + ou_dn
1577         ou_dn5 = "OU=test_inherit_ou5," + ou_dn1
1578         ou_dn6 = "OU=test_inherit_ou6," + ou_dn2
1579         # Create inheritable-free OU
1580         mod = "D:P(A;CI;WPRPLCCCDCWDRC;;;DA)"
1581         tmp_desc = security.descriptor.from_sddl(mod, self.domain_sid)
1582         self.ldb_admin.create_ou(ou_dn, sd=tmp_desc)
1583         mod = "D:(A;CI;GA;;;DU)"
1584         tmp_desc = security.descriptor.from_sddl(mod, self.domain_sid)
1585         self.ldb_admin.create_ou(ou_dn1, sd=tmp_desc)
1586         mod = "D:(A;CIIO;GA;;;DU)"
1587         tmp_desc = security.descriptor.from_sddl(mod, self.domain_sid)
1588         self.ldb_admin.create_ou(ou_dn2, sd=tmp_desc)
1589         mod = "D:(A;;GA;;;DU)"
1590         tmp_desc = security.descriptor.from_sddl(mod, self.domain_sid)
1591         self.ldb_admin.create_ou(ou_dn3, sd=tmp_desc)
1592         mod = "D:(A;IO;GA;;;DU)"
1593         tmp_desc = security.descriptor.from_sddl(mod, self.domain_sid)
1594         self.ldb_admin.create_ou(ou_dn4, sd=tmp_desc)
1595
1596         self.ldb_admin.create_ou(ou_dn5)
1597         self.ldb_admin.create_ou(ou_dn6)
1598
1599         desc_sddl = self.sd_utils.get_sd_as_sddl(ou_dn1)
1600         self.assertTrue("(A;;RPWPCRCCDCLCLORCWOWDSDDTSW;;;DU)" in desc_sddl)
1601         self.assertTrue("(A;CIIO;GA;;;DU)" in desc_sddl)
1602         desc_sddl = self.sd_utils.get_sd_as_sddl(ou_dn2)
1603         self.assertFalse("(A;;RPWPCRCCDCLCLORCWOWDSDDTSW;;;DU)" in desc_sddl)
1604         self.assertTrue("(A;CIIO;GA;;;DU)" in desc_sddl)
1605         desc_sddl = self.sd_utils.get_sd_as_sddl(ou_dn3)
1606         self.assertTrue("(A;;RPWPCRCCDCLCLORCWOWDSDDTSW;;;DU)" in desc_sddl)
1607         self.assertFalse("(A;CIIO;GA;;;DU)" in desc_sddl)
1608         desc_sddl = self.sd_utils.get_sd_as_sddl(ou_dn4)
1609         self.assertFalse("(A;;RPWPCRCCDCLCLORCWOWDSDDTSW;;;DU)" in desc_sddl)
1610         self.assertFalse("(A;CIIO;GA;;;DU)" in desc_sddl)
1611         desc_sddl = self.sd_utils.get_sd_as_sddl(ou_dn5)
1612         self.assertTrue("(A;ID;RPWPCRCCDCLCLORCWOWDSDDTSW;;;DU)" in desc_sddl)
1613         self.assertTrue("(A;CIIOID;GA;;;DU)" in desc_sddl)
1614         desc_sddl = self.sd_utils.get_sd_as_sddl(ou_dn6)
1615         self.assertTrue("(A;ID;RPWPCRCCDCLCLORCWOWDSDDTSW;;;DU)" in desc_sddl)
1616         self.assertTrue("(A;CIIOID;GA;;;DU)" in desc_sddl)
1617
1618     def test_215(self):
1619         """ Make sure IO flag is removed in child objects
1620         """
1621         ou_dn = "OU=test_inherit_ou_p," + self.base_dn
1622         ou_dn1 = "OU=test_inherit_ou1," + ou_dn
1623         ou_dn5 = "OU=test_inherit_ou5," + ou_dn1
1624         # Create inheritable-free OU
1625         mod = "D:P(A;CI;WPRPLCCCDCWDRC;;;DA)"
1626         tmp_desc = security.descriptor.from_sddl(mod, self.domain_sid)
1627         self.ldb_admin.create_ou(ou_dn, sd=tmp_desc)
1628         mod = "D:(A;CIIO;WP;;;DU)"
1629         tmp_desc = security.descriptor.from_sddl(mod, self.domain_sid)
1630         self.ldb_admin.create_ou(ou_dn1, sd=tmp_desc)
1631         self.ldb_admin.create_ou(ou_dn5)
1632         desc_sddl = self.sd_utils.get_sd_as_sddl(ou_dn5)
1633         self.assertTrue("(A;CIID;WP;;;DU)" in desc_sddl)
1634         self.assertFalse("(A;CIIOID;WP;;;DU)" in desc_sddl)
1635
1636     def test_216(self):
1637         """ Make sure ID ACES provided by user are ignored
1638         """
1639         ou_dn = "OU=test_inherit_ou," + self.base_dn
1640         group_dn = "CN=test_inherit_group," + ou_dn
1641         mod = "D:P(A;;WPRPLCCCDCWDRC;;;DA)"
1642         tmp_desc = security.descriptor.from_sddl(mod, self.domain_sid)
1643         self.ldb_admin.create_ou(ou_dn, sd=tmp_desc)
1644         # Add some custom  ACE
1645         mod = "D:(D;ID;WP;;;AU)"
1646         tmp_desc = security.descriptor.from_sddl(mod, self.domain_sid)
1647         self.ldb_admin.newgroup("test_inherit_group", groupou="OU=test_inherit_ou", grouptype=4, sd=tmp_desc)
1648         # Make sure created group object does not contain the ID ace
1649         desc_sddl = self.sd_utils.get_sd_as_sddl(group_dn)
1650         self.assertFalse("(A;ID;WP;;;AU)" in desc_sddl)
1651         self.assertFalse("(A;;WP;;;AU)" in desc_sddl)
1652
1653     def test_217(self):
1654         """ Make sure ID ACES provided by user are not ignored if P flag is set
1655         """
1656         ou_dn = "OU=test_inherit_ou," + self.base_dn
1657         group_dn = "CN=test_inherit_group," + ou_dn
1658         mod = "D:P(A;;WPRPLCCCDCWDRC;;;DA)"
1659         tmp_desc = security.descriptor.from_sddl(mod, self.domain_sid)
1660         self.ldb_admin.create_ou(ou_dn, sd=tmp_desc)
1661         # Add some custom  ACE
1662         mod = "D:P(A;ID;WP;;;AU)"
1663         tmp_desc = security.descriptor.from_sddl(mod, self.domain_sid)
1664         self.ldb_admin.newgroup("test_inherit_group", groupou="OU=test_inherit_ou", grouptype=4, sd=tmp_desc)
1665         # Make sure created group object does not contain the ID ace
1666         desc_sddl = self.sd_utils.get_sd_as_sddl(group_dn)
1667         self.assertFalse("(A;ID;WP;;;AU)" in desc_sddl)
1668         self.assertTrue("(A;;WP;;;AU)" in desc_sddl)
1669
1670     ########################################################################################
1671
1672
1673 class SdFlagsDescriptorTests(DescriptorTests):
1674     def deleteAll(self):
1675         delete_force(self.ldb_admin, "OU=test_sdflags_ou," + self.base_dn)
1676
1677     def setUp(self):
1678         super(SdFlagsDescriptorTests, self).setUp()
1679         self.test_descr = "O:AUG:AUD:(D;;CC;;;LG)S:(OU;;WP;;;AU)"
1680         self.deleteAll()
1681
1682     def test_301(self):
1683         """ Modify a descriptor with OWNER_SECURITY_INFORMATION set.
1684             See that only the owner has been changed.
1685         """
1686         ou_dn = "OU=test_sdflags_ou," + self.base_dn
1687         self.ldb_admin.create_ou(ou_dn)
1688         self.sd_utils.modify_sd_on_dn(ou_dn, self.test_descr, controls=["sd_flags:1:%d" % (SECINFO_OWNER)])
1689         desc_sddl = self.sd_utils.get_sd_as_sddl(ou_dn)
1690         # make sure we have modified the owner
1691         self.assertTrue("O:AU" in desc_sddl)
1692         # make sure nothing else has been modified
1693         self.assertFalse("G:AU" in desc_sddl)
1694         self.assertFalse("D:(D;;CC;;;LG)" in desc_sddl)
1695         self.assertFalse("(OU;;WP;;;AU)" in desc_sddl)
1696
1697     def test_302(self):
1698         """ Modify a descriptor with GROUP_SECURITY_INFORMATION set.
1699             See that only the owner has been changed.
1700         """
1701         ou_dn = "OU=test_sdflags_ou," + self.base_dn
1702         self.ldb_admin.create_ou(ou_dn)
1703         self.sd_utils.modify_sd_on_dn(ou_dn, self.test_descr, controls=["sd_flags:1:%d" % (SECINFO_GROUP)])
1704         desc_sddl = self.sd_utils.get_sd_as_sddl(ou_dn)
1705         # make sure we have modified the group
1706         self.assertTrue("G:AU" in desc_sddl)
1707         # make sure nothing else has been modified
1708         self.assertFalse("O:AU" in desc_sddl)
1709         self.assertFalse("D:(D;;CC;;;LG)" in desc_sddl)
1710         self.assertFalse("(OU;;WP;;;AU)" in desc_sddl)
1711
1712     def test_303(self):
1713         """ Modify a descriptor with SACL_SECURITY_INFORMATION set.
1714             See that only the owner has been changed.
1715         """
1716         ou_dn = "OU=test_sdflags_ou," + self.base_dn
1717         self.ldb_admin.create_ou(ou_dn)
1718         self.sd_utils.modify_sd_on_dn(ou_dn, self.test_descr, controls=["sd_flags:1:%d" % (SECINFO_DACL)])
1719         desc_sddl = self.sd_utils.get_sd_as_sddl(ou_dn)
1720         # make sure we have modified the DACL
1721         self.assertTrue("(D;;CC;;;LG)" in desc_sddl)
1722         # make sure nothing else has been modified
1723         self.assertFalse("O:AU" in desc_sddl)
1724         self.assertFalse("G:AU" in desc_sddl)
1725         self.assertFalse("(OU;;WP;;;AU)" in desc_sddl)
1726
1727     def test_304(self):
1728         """ Modify a descriptor with SACL_SECURITY_INFORMATION set.
1729             See that only the owner has been changed.
1730         """
1731         ou_dn = "OU=test_sdflags_ou," + self.base_dn
1732         self.ldb_admin.create_ou(ou_dn)
1733         self.sd_utils.modify_sd_on_dn(ou_dn, self.test_descr, controls=["sd_flags:1:%d" % (SECINFO_SACL)])
1734         desc_sddl = self.sd_utils.get_sd_as_sddl(ou_dn)
1735         # make sure we have modified the DACL
1736         self.assertTrue("(OU;;WP;;;AU)" in desc_sddl)
1737         # make sure nothing else has been modified
1738         self.assertFalse("O:AU" in desc_sddl)
1739         self.assertFalse("G:AU" in desc_sddl)
1740         self.assertFalse("(D;;CC;;;LG)" in desc_sddl)
1741
1742     def test_305(self):
1743         """ Modify a descriptor with 0x0 set.
1744             Contrary to logic this is interpreted as no control,
1745             which is the same as 0xF
1746         """
1747         ou_dn = "OU=test_sdflags_ou," + self.base_dn
1748         self.ldb_admin.create_ou(ou_dn)
1749         self.sd_utils.modify_sd_on_dn(ou_dn, self.test_descr, controls=["sd_flags:1:0"])
1750         desc_sddl = self.sd_utils.get_sd_as_sddl(ou_dn)
1751         # make sure we have modified the DACL
1752         self.assertTrue("(OU;;WP;;;AU)" in desc_sddl)
1753         # make sure nothing else has been modified
1754         self.assertTrue("O:AU" in desc_sddl)
1755         self.assertTrue("G:AU" in desc_sddl)
1756         self.assertTrue("(D;;CC;;;LG)" in desc_sddl)
1757
1758     def test_306(self):
1759         """ Modify a descriptor with 0xF set.
1760         """
1761         ou_dn = "OU=test_sdflags_ou," + self.base_dn
1762         self.ldb_admin.create_ou(ou_dn)
1763         self.sd_utils.modify_sd_on_dn(ou_dn, self.test_descr, controls=["sd_flags:1:15"])
1764         desc_sddl = self.sd_utils.get_sd_as_sddl(ou_dn)
1765         # make sure we have modified the DACL
1766         self.assertTrue("(OU;;WP;;;AU)" in desc_sddl)
1767         # make sure nothing else has been modified
1768         self.assertTrue("O:AU" in desc_sddl)
1769         self.assertTrue("G:AU" in desc_sddl)
1770         self.assertTrue("(D;;CC;;;LG)" in desc_sddl)
1771
1772     def test_307(self):
1773         """ Read a descriptor with OWNER_SECURITY_INFORMATION
1774             Only the owner part should be returned.
1775         """
1776         ou_dn = "OU=test_sdflags_ou," + self.base_dn
1777         self.ldb_admin.create_ou(ou_dn)
1778         desc_sddl = self.sd_utils.get_sd_as_sddl(ou_dn, controls=["sd_flags:1:%d" % (SECINFO_OWNER)])
1779         # make sure we have read the owner
1780         self.assertTrue("O:" in desc_sddl)
1781         # make sure we have read nothing else
1782         self.assertFalse("G:" in desc_sddl)
1783         self.assertFalse("D:" in desc_sddl)
1784         self.assertFalse("S:" in desc_sddl)
1785
1786     def test_308(self):
1787         """ Read a descriptor with GROUP_SECURITY_INFORMATION
1788             Only the group part should be returned.
1789         """
1790         ou_dn = "OU=test_sdflags_ou," + self.base_dn
1791         self.ldb_admin.create_ou(ou_dn)
1792         desc_sddl = self.sd_utils.get_sd_as_sddl(ou_dn, controls=["sd_flags:1:%d" % (SECINFO_GROUP)])
1793         # make sure we have read the owner
1794         self.assertTrue("G:" in desc_sddl)
1795         # make sure we have read nothing else
1796         self.assertFalse("O:" in desc_sddl)
1797         self.assertFalse("D:" in desc_sddl)
1798         self.assertFalse("S:" in desc_sddl)
1799
1800     def test_309(self):
1801         """ Read a descriptor with SACL_SECURITY_INFORMATION
1802             Only the sacl part should be returned.
1803         """
1804         ou_dn = "OU=test_sdflags_ou," + self.base_dn
1805         self.ldb_admin.create_ou(ou_dn)
1806         desc_sddl = self.sd_utils.get_sd_as_sddl(ou_dn, controls=["sd_flags:1:%d" % (SECINFO_SACL)])
1807         # make sure we have read the owner
1808         self.assertTrue("S:" in desc_sddl)
1809         # make sure we have read nothing else
1810         self.assertFalse("O:" in desc_sddl)
1811         self.assertFalse("D:" in desc_sddl)
1812         self.assertFalse("G:" in desc_sddl)
1813
1814     def test_310(self):
1815         """ Read a descriptor with DACL_SECURITY_INFORMATION
1816             Only the dacl part should be returned.
1817         """
1818         ou_dn = "OU=test_sdflags_ou," + self.base_dn
1819         self.ldb_admin.create_ou(ou_dn)
1820         desc_sddl = self.sd_utils.get_sd_as_sddl(ou_dn, controls=["sd_flags:1:%d" % (SECINFO_DACL)])
1821         # make sure we have read the owner
1822         self.assertTrue("D:" in desc_sddl)
1823         # make sure we have read nothing else
1824         self.assertFalse("O:" in desc_sddl)
1825         self.assertFalse("S:" in desc_sddl)
1826         self.assertFalse("G:" in desc_sddl)
1827
1828     def test_311(self):
1829         sd_flags = (SECINFO_OWNER |
1830                     SECINFO_GROUP |
1831                     SECINFO_DACL |
1832                     SECINFO_SACL)
1833
1834         res = self.ldb_admin.search(self.base_dn, SCOPE_BASE, None,
1835                                     [], controls=None)
1836         self.assertFalse("nTSecurityDescriptor" in res[0])
1837
1838         res = self.ldb_admin.search(self.base_dn, SCOPE_BASE, None,
1839                                     ["name"], controls=None)
1840         self.assertFalse("nTSecurityDescriptor" in res[0])
1841
1842         res = self.ldb_admin.search(self.base_dn, SCOPE_BASE, None,
1843                                     ["name"], controls=["sd_flags:1:%d" % (sd_flags)])
1844         self.assertFalse("nTSecurityDescriptor" in res[0])
1845
1846         res = self.ldb_admin.search(self.base_dn, SCOPE_BASE, None,
1847                                     [], controls=["sd_flags:1:%d" % (sd_flags)])
1848         self.assertTrue("nTSecurityDescriptor" in res[0])
1849         tmp = res[0]["nTSecurityDescriptor"][0]
1850         sd = ndr_unpack(security.descriptor, tmp)
1851         sddl = sd.as_sddl(self.sd_utils.domain_sid)
1852         self.assertTrue("O:" in sddl)
1853         self.assertTrue("G:" in sddl)
1854         self.assertTrue("D:" in sddl)
1855         self.assertTrue("S:" in sddl)
1856
1857         res = self.ldb_admin.search(self.base_dn, SCOPE_BASE, None,
1858                                     ["*"], controls=["sd_flags:1:%d" % (sd_flags)])
1859         self.assertTrue("nTSecurityDescriptor" in res[0])
1860         tmp = res[0]["nTSecurityDescriptor"][0]
1861         sd = ndr_unpack(security.descriptor, tmp)
1862         sddl = sd.as_sddl(self.sd_utils.domain_sid)
1863         self.assertTrue("O:" in sddl)
1864         self.assertTrue("G:" in sddl)
1865         self.assertTrue("D:" in sddl)
1866         self.assertTrue("S:" in sddl)
1867
1868         res = self.ldb_admin.search(self.base_dn, SCOPE_BASE, None,
1869                                     ["nTSecurityDescriptor", "*"], controls=["sd_flags:1:%d" % (sd_flags)])
1870         self.assertTrue("nTSecurityDescriptor" in res[0])
1871         tmp = res[0]["nTSecurityDescriptor"][0]
1872         sd = ndr_unpack(security.descriptor, tmp)
1873         sddl = sd.as_sddl(self.sd_utils.domain_sid)
1874         self.assertTrue("O:" in sddl)
1875         self.assertTrue("G:" in sddl)
1876         self.assertTrue("D:" in sddl)
1877         self.assertTrue("S:" in sddl)
1878
1879         res = self.ldb_admin.search(self.base_dn, SCOPE_BASE, None,
1880                                     ["*", "nTSecurityDescriptor"], controls=["sd_flags:1:%d" % (sd_flags)])
1881         self.assertTrue("nTSecurityDescriptor" in res[0])
1882         tmp = res[0]["nTSecurityDescriptor"][0]
1883         sd = ndr_unpack(security.descriptor, tmp)
1884         sddl = sd.as_sddl(self.sd_utils.domain_sid)
1885         self.assertTrue("O:" in sddl)
1886         self.assertTrue("G:" in sddl)
1887         self.assertTrue("D:" in sddl)
1888         self.assertTrue("S:" in sddl)
1889
1890         res = self.ldb_admin.search(self.base_dn, SCOPE_BASE, None,
1891                                     ["nTSecurityDescriptor", "name"], controls=["sd_flags:1:%d" % (sd_flags)])
1892         self.assertTrue("nTSecurityDescriptor" in res[0])
1893         tmp = res[0]["nTSecurityDescriptor"][0]
1894         sd = ndr_unpack(security.descriptor, tmp)
1895         sddl = sd.as_sddl(self.sd_utils.domain_sid)
1896         self.assertTrue("O:" in sddl)
1897         self.assertTrue("G:" in sddl)
1898         self.assertTrue("D:" in sddl)
1899         self.assertTrue("S:" in sddl)
1900
1901         res = self.ldb_admin.search(self.base_dn, SCOPE_BASE, None,
1902                                     ["name", "nTSecurityDescriptor"], controls=["sd_flags:1:%d" % (sd_flags)])
1903         self.assertTrue("nTSecurityDescriptor" in res[0])
1904         tmp = res[0]["nTSecurityDescriptor"][0]
1905         sd = ndr_unpack(security.descriptor, tmp)
1906         sddl = sd.as_sddl(self.sd_utils.domain_sid)
1907         self.assertTrue("O:" in sddl)
1908         self.assertTrue("G:" in sddl)
1909         self.assertTrue("D:" in sddl)
1910         self.assertTrue("S:" in sddl)
1911
1912         res = self.ldb_admin.search(self.base_dn, SCOPE_BASE, None,
1913                                     ["nTSecurityDescriptor"], controls=None)
1914         self.assertTrue("nTSecurityDescriptor" in res[0])
1915         tmp = res[0]["nTSecurityDescriptor"][0]
1916         sd = ndr_unpack(security.descriptor, tmp)
1917         sddl = sd.as_sddl(self.sd_utils.domain_sid)
1918         self.assertTrue("O:" in sddl)
1919         self.assertTrue("G:" in sddl)
1920         self.assertTrue("D:" in sddl)
1921         self.assertTrue("S:" in sddl)
1922
1923         res = self.ldb_admin.search(self.base_dn, SCOPE_BASE, None,
1924                                     ["name", "nTSecurityDescriptor"], controls=None)
1925         self.assertTrue("nTSecurityDescriptor" in res[0])
1926         tmp = res[0]["nTSecurityDescriptor"][0]
1927         sd = ndr_unpack(security.descriptor, tmp)
1928         sddl = sd.as_sddl(self.sd_utils.domain_sid)
1929         self.assertTrue("O:" in sddl)
1930         self.assertTrue("G:" in sddl)
1931         self.assertTrue("D:" in sddl)
1932         self.assertTrue("S:" in sddl)
1933
1934         res = self.ldb_admin.search(self.base_dn, SCOPE_BASE, None,
1935                                     ["nTSecurityDescriptor", "name"], controls=None)
1936         self.assertTrue("nTSecurityDescriptor" in res[0])
1937         tmp = res[0]["nTSecurityDescriptor"][0]
1938         sd = ndr_unpack(security.descriptor, tmp)
1939         sddl = sd.as_sddl(self.sd_utils.domain_sid)
1940         self.assertTrue("O:" in sddl)
1941         self.assertTrue("G:" in sddl)
1942         self.assertTrue("D:" in sddl)
1943         self.assertTrue("S:" in sddl)
1944
1945     def test_312(self):
1946         """This search is done by the windows dc join..."""
1947
1948         res = self.ldb_admin.search(self.base_dn, SCOPE_BASE, None, ["1.1"],
1949                                     controls=["extended_dn:1:0", "sd_flags:1:0", "search_options:1:1"])
1950         self.assertFalse("nTSecurityDescriptor" in res[0])
1951
1952 class RightsAttributesTests(DescriptorTests):
1953
1954     def deleteAll(self):
1955         delete_force(self.ldb_admin, self.get_users_domain_dn("testuser_attr"))
1956         delete_force(self.ldb_admin, self.get_users_domain_dn("testuser_attr2"))
1957         delete_force(self.ldb_admin, "OU=test_domain_ou1," + self.base_dn)
1958
1959     def setUp(self):
1960         super(RightsAttributesTests, self).setUp()
1961         self.deleteAll()
1962         ### Create users
1963         # User 1
1964         self.ldb_admin.newuser("testuser_attr", "samba123@")
1965         # User 2, Domain Admins
1966         self.ldb_admin.newuser("testuser_attr2", "samba123@")
1967         self.ldb_admin.add_remove_group_members("Domain Admins",
1968                                                 ["testuser_attr2"],
1969                                                 add_members_operation=True)
1970
1971     def test_sDRightsEffective(self):
1972         object_dn = "OU=test_domain_ou1," + self.base_dn
1973         delete_force(self.ldb_admin, object_dn)
1974         self.ldb_admin.create_ou(object_dn)
1975         print(self.get_users_domain_dn("testuser_attr"))
1976         user_sid = self.sd_utils.get_object_sid(self.get_users_domain_dn("testuser_attr"))
1977         #give testuser1 read access so attributes can be retrieved
1978         mod = "(A;CI;RP;;;%s)" % str(user_sid)
1979         self.sd_utils.dacl_add_ace(object_dn, mod)
1980         _ldb = self.get_ldb_connection("testuser_attr", "samba123@")
1981         res = _ldb.search(base=object_dn, expression="", scope=SCOPE_BASE,
1982                           attrs=["sDRightsEffective"])
1983         #user whould have no rights at all
1984         self.assertEquals(len(res), 1)
1985         self.assertEquals(res[0]["sDRightsEffective"][0], "0")
1986         #give the user Write DACL and see what happens
1987         mod = "(A;CI;WD;;;%s)" % str(user_sid)
1988         self.sd_utils.dacl_add_ace(object_dn, mod)
1989         res = _ldb.search(base=object_dn, expression="", scope=SCOPE_BASE,
1990                           attrs=["sDRightsEffective"])
1991         #user whould have DACL_SECURITY_INFORMATION
1992         self.assertEquals(len(res), 1)
1993         self.assertEquals(res[0]["sDRightsEffective"][0], ("%d") % SECINFO_DACL)
1994         #give the user Write Owners and see what happens
1995         mod = "(A;CI;WO;;;%s)" % str(user_sid)
1996         self.sd_utils.dacl_add_ace(object_dn, mod)
1997         res = _ldb.search(base=object_dn, expression="", scope=SCOPE_BASE,
1998                           attrs=["sDRightsEffective"])
1999         #user whould have DACL_SECURITY_INFORMATION, OWNER_SECURITY_INFORMATION, GROUP_SECURITY_INFORMATION
2000         self.assertEquals(len(res), 1)
2001         self.assertEquals(res[0]["sDRightsEffective"][0], ("%d") % (SECINFO_DACL | SECINFO_GROUP | SECINFO_OWNER))
2002         #no way to grant security privilege bu adding ACE's so we use a memeber of Domain Admins
2003         _ldb = self.get_ldb_connection("testuser_attr2", "samba123@")
2004         res = _ldb.search(base=object_dn, expression="", scope=SCOPE_BASE,
2005                           attrs=["sDRightsEffective"])
2006         #user whould have DACL_SECURITY_INFORMATION, OWNER_SECURITY_INFORMATION, GROUP_SECURITY_INFORMATION
2007         self.assertEquals(len(res), 1)
2008         self.assertEquals(res[0]["sDRightsEffective"][0], \
2009                           ("%d") % (SECINFO_DACL | SECINFO_GROUP | SECINFO_OWNER | SECINFO_SACL))
2010
2011     def test_allowedChildClassesEffective(self):
2012         object_dn = "OU=test_domain_ou1," + self.base_dn
2013         delete_force(self.ldb_admin, object_dn)
2014         self.ldb_admin.create_ou(object_dn)
2015         user_sid = self.sd_utils.get_object_sid(self.get_users_domain_dn("testuser_attr"))
2016         #give testuser1 read access so attributes can be retrieved
2017         mod = "(A;CI;RP;;;%s)" % str(user_sid)
2018         self.sd_utils.dacl_add_ace(object_dn, mod)
2019         _ldb = self.get_ldb_connection("testuser_attr", "samba123@")
2020         res = _ldb.search(base=object_dn, expression="", scope=SCOPE_BASE,
2021                           attrs=["allowedChildClassesEffective"])
2022         #there should be no allowed child classes
2023         self.assertEquals(len(res), 1)
2024         self.assertFalse("allowedChildClassesEffective" in res[0].keys())
2025         #give the user the right to create children of type user
2026         mod = "(OA;CI;CC;bf967aba-0de6-11d0-a285-00aa003049e2;;%s)" % str(user_sid)
2027         self.sd_utils.dacl_add_ace(object_dn, mod)
2028         res = _ldb.search(base=object_dn, expression="", scope=SCOPE_BASE,
2029                           attrs=["allowedChildClassesEffective"])
2030         # allowedChildClassesEffective should only have one value, user
2031         self.assertEquals(len(res), 1)
2032         self.assertEquals(len(res[0]["allowedChildClassesEffective"]), 1)
2033         self.assertEquals(res[0]["allowedChildClassesEffective"][0], "user")
2034
2035     def test_allowedAttributesEffective(self):
2036         object_dn = "OU=test_domain_ou1," + self.base_dn
2037         delete_force(self.ldb_admin, object_dn)
2038         self.ldb_admin.create_ou(object_dn)
2039         user_sid = self.sd_utils.get_object_sid(self.get_users_domain_dn("testuser_attr"))
2040         #give testuser1 read access so attributes can be retrieved
2041         mod = "(A;CI;RP;;;%s)" % str(user_sid)
2042         self.sd_utils.dacl_add_ace(object_dn, mod)
2043         _ldb = self.get_ldb_connection("testuser_attr", "samba123@")
2044         res = _ldb.search(base=object_dn, expression="", scope=SCOPE_BASE,
2045                           attrs=["allowedAttributesEffective"])
2046         #there should be no allowed attributes
2047         self.assertEquals(len(res), 1)
2048         self.assertFalse("allowedAttributesEffective" in res[0].keys())
2049         #give the user the right to write displayName and managedBy
2050         mod2 = "(OA;CI;WP;bf967953-0de6-11d0-a285-00aa003049e2;;%s)" % str(user_sid)
2051         mod = "(OA;CI;WP;0296c120-40da-11d1-a9c0-0000f80367c1;;%s)" % str(user_sid)
2052         # also rights to modify an read only attribute, fromEntry
2053         mod3 = "(OA;CI;WP;9a7ad949-ca53-11d1-bbd0-0080c76670c0;;%s)" % str(user_sid)
2054         self.sd_utils.dacl_add_ace(object_dn, mod + mod2 + mod3)
2055         res = _ldb.search(base=object_dn, expression="", scope=SCOPE_BASE,
2056                           attrs=["allowedAttributesEffective"])
2057         # value should only contain user and managedBy
2058         self.assertEquals(len(res), 1)
2059         self.assertEquals(len(res[0]["allowedAttributesEffective"]), 2)
2060         self.assertTrue("displayName" in res[0]["allowedAttributesEffective"])
2061         self.assertTrue("managedBy" in res[0]["allowedAttributesEffective"])
2062
2063 class SdAutoInheritTests(DescriptorTests):
2064     def deleteAll(self):
2065         delete_force(self.ldb_admin, self.sub_dn)
2066         delete_force(self.ldb_admin, self.ou_dn)
2067
2068     def setUp(self):
2069         super(SdAutoInheritTests, self).setUp()
2070         self.ou_dn = "OU=test_SdAutoInherit_ou," + self.base_dn
2071         self.sub_dn = "OU=test_sub," + self.ou_dn
2072         self.deleteAll()
2073
2074     def test_301(self):
2075         """ Modify a descriptor with OWNER_SECURITY_INFORMATION set.
2076             See that only the owner has been changed.
2077         """
2078         attrs = ["nTSecurityDescriptor", "replPropertyMetaData", "uSNChanged"]
2079         controls=["sd_flags:1:%d" % (SECINFO_DACL)]
2080         ace = "(A;CI;CC;;;NU)"
2081         sub_ace = "(A;CIID;CC;;;NU)"
2082         sd_sddl = "O:BAG:BAD:P(A;CI;0x000f01ff;;;AU)"
2083         sd = security.descriptor.from_sddl(sd_sddl, self.domain_sid)
2084
2085         self.ldb_admin.create_ou(self.ou_dn,sd=sd)
2086         self.ldb_admin.create_ou(self.sub_dn)
2087
2088         ou_res0 = self.sd_utils.ldb.search(self.ou_dn, SCOPE_BASE,
2089                                            None, attrs, controls=controls)
2090         sub_res0 = self.sd_utils.ldb.search(self.sub_dn, SCOPE_BASE,
2091                                             None, attrs, controls=controls)
2092
2093         ou_sd0 = ndr_unpack(security.descriptor, ou_res0[0]["nTSecurityDescriptor"][0])
2094         sub_sd0 = ndr_unpack(security.descriptor, sub_res0[0]["nTSecurityDescriptor"][0])
2095
2096         ou_sddl0 = ou_sd0.as_sddl(self.domain_sid)
2097         sub_sddl0 = sub_sd0.as_sddl(self.domain_sid)
2098
2099         self.assertFalse(ace in ou_sddl0)
2100         self.assertFalse(ace in sub_sddl0)
2101
2102         ou_sddl1 = (ou_sddl0[:ou_sddl0.index("(")] + ace +
2103                     ou_sddl0[ou_sddl0.index("("):])
2104
2105         sub_sddl1 = (sub_sddl0[:sub_sddl0.index("(")] + ace +
2106                      sub_sddl0[sub_sddl0.index("("):])
2107
2108         self.sd_utils.modify_sd_on_dn(self.ou_dn, ou_sddl1, controls=controls)
2109
2110         sub_res2 = self.sd_utils.ldb.search(self.sub_dn, SCOPE_BASE,
2111                                             None, attrs, controls=controls)
2112         ou_res2 = self.sd_utils.ldb.search(self.ou_dn, SCOPE_BASE,
2113                                            None, attrs, controls=controls)
2114
2115         ou_sd2 = ndr_unpack(security.descriptor, ou_res2[0]["nTSecurityDescriptor"][0])
2116         sub_sd2 = ndr_unpack(security.descriptor, sub_res2[0]["nTSecurityDescriptor"][0])
2117
2118         ou_sddl2 = ou_sd2.as_sddl(self.domain_sid)
2119         sub_sddl2 = sub_sd2.as_sddl(self.domain_sid)
2120
2121         self.assertFalse(ou_sddl2 == ou_sddl0)
2122         self.assertFalse(sub_sddl2 == sub_sddl0)
2123
2124         if ace not in ou_sddl2:
2125             print("ou0: %s" % ou_sddl0)
2126             print("ou2: %s" % ou_sddl2)
2127
2128         if sub_ace not in sub_sddl2:
2129             print("sub0: %s" % sub_sddl0)
2130             print("sub2: %s" % sub_sddl2)
2131
2132         self.assertTrue(ace in ou_sddl2)
2133         self.assertTrue(sub_ace in sub_sddl2)
2134
2135         ou_usn0 = int(ou_res0[0]["uSNChanged"][0])
2136         ou_usn2 = int(ou_res2[0]["uSNChanged"][0])
2137         self.assertTrue(ou_usn2 > ou_usn0)
2138
2139         sub_usn0 = int(sub_res0[0]["uSNChanged"][0])
2140         sub_usn2 = int(sub_res2[0]["uSNChanged"][0])
2141         self.assertTrue(sub_usn2 == sub_usn0)
2142
2143 if not "://" in host:
2144     if os.path.isfile(host):
2145         host = "tdb://%s" % host
2146     else:
2147         host = "ldap://%s" % host
2148
2149 # use 'paged_search' module when connecting remotely
2150 if host.lower().startswith("ldap://"):
2151     ldb_options = ["modules:paged_searches"]
2152
2153 TestProgram(module=__name__, opts=subunitopts)