source4/lib/ldb/tests/python/sec_descriptor.py

   1 #!/usr/bin/python
   2 # -*- coding: utf-8 -*-
   3
   4 import getopt
   5 import optparse
   6 import sys
   7 import os
   8 import base64
   9 import re
  10 import random
  11
  12 sys.path.append("bin/python")
  13 sys.path.append("../lib/subunit/python")
  14
  15 import samba.getopt as options
  16
  17 # Some error messages that are being tested
  18 from ldb import SCOPE_SUBTREE, SCOPE_ONELEVEL, SCOPE_BASE, LdbError
  19 from ldb import ERR_NO_SUCH_OBJECT, ERR_INVALID_DN_SYNTAX, ERR_UNWILLING_TO_PERFORM
  20 from ldb import ERR_INSUFFICIENT_ACCESS_RIGHTS
  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.auth import system_session
  27 from samba import Ldb, DS_BEHAVIOR_WIN2008
  28 from subunit import SubunitTestRunner
  29 import unittest
  30
  31 parser = optparse.OptionParser("ldap [options] <host>")
  32 sambaopts = options.SambaOptions(parser)
  33 parser.add_option_group(sambaopts)
  34 parser.add_option_group(options.VersionOptions(parser))
  35
  36 # use command line creds if available
  37 credopts = options.CredentialsOptions(parser)
  38 parser.add_option_group(credopts)
  39 opts, args = parser.parse_args()
  40
  41 if len(args) < 1:
  42     parser.print_usage()
  43     sys.exit(1)
  44
  45 host = args[0]
  46
  47 lp = sambaopts.get_loadparm()
  48 creds = credopts.get_credentials(lp)
  49
  50 #
  51 # Tests start here
  52 #
  53
  54 class DescriptorTests(unittest.TestCase):
  55
  56     def delete_force(self, ldb, dn):
  57         try:
  58             ldb.delete(dn)
  59         except LdbError, (num, _):
  60             self.assertEquals(num, ERR_NO_SUCH_OBJECT)
  61
  62     def find_basedn(self, ldb):
  63         res = ldb.search(base="", expression="", scope=SCOPE_BASE,
  64                          attrs=["defaultNamingContext"])
  65         self.assertEquals(len(res), 1)
  66         return res[0]["defaultNamingContext"][0]
  67
  68     def find_configurationdn(self, ldb):
  69         res = ldb.search(base="", expression="", scope=SCOPE_BASE, attrs=["configurationNamingContext"])
  70         self.assertEquals(len(res), 1)
  71         return res[0]["configurationNamingContext"][0]
  72
  73     def find_schemadn(self, ldb):
  74         res = ldb.search(base="", expression="", scope=SCOPE_BASE, attrs=["schemaNamingContext"])
  75         self.assertEquals(len(res), 1)
  76         return res[0]["schemaNamingContext"][0]
  77
  78     def find_domain_sid(self, ldb):
  79         res = ldb.search(base=self.base_dn, expression="(objectClass=*)", scope=SCOPE_BASE)
  80         return ndr_unpack( security.dom_sid,res[0]["objectSid"][0])
  81
  82     def get_users_domain_dn(self, name):
  83         return "CN=%s,CN=Users,%s" % (name, self.base_dn)
  84
  85     def modify_desc(self, object_dn, desc):
  86         assert(isinstance(desc, str) or isinstance(desc, security.descriptor))
  87         mod = """
  88 dn: """ + object_dn + """
  89 changetype: modify
  90 replace: nTSecurityDescriptor
  91 """
  92         if isinstance(desc, str):
  93             mod += "nTSecurityDescriptor: %s" % desc
  94         elif isinstance(desc, security.descriptor):
  95             mod += "nTSecurityDescriptor:: %s" % base64.b64encode(ndr_pack(desc))
  96         self.ldb_admin.modify_ldif(mod)
  97
  98     def create_domain_ou(self, _ldb, ou_dn, desc=None):
  99         ldif = """
 100 dn: """ + ou_dn + """
 101 ou: """ + ou_dn.split(",")[0][3:] + """
 102 objectClass: organizationalUnit
 103 url: www.example.com
 104 """
 105         if desc:
 106             assert(isinstance(desc, str) or isinstance(desc, security.descriptor))
 107             if isinstance(desc, str):
 108                 ldif += "nTSecurityDescriptor: %s" % desc
 109             elif isinstance(desc, security.descriptor):
 110                 ldif += "nTSecurityDescriptor:: %s" % base64.b64encode(ndr_pack(desc))
 111         _ldb.add_ldif(ldif)
 112
 113     def create_domain_user(self, _ldb, user_dn, desc=None):
 114         ldif = """
 115 dn: """ + user_dn + """
 116 sAMAccountName: """ + user_dn.split(",")[0][3:] + """
 117 objectClass: user
 118 userPassword: samba123@
 119 url: www.example.com
 120 """
 121         if desc:
 122             assert(isinstance(desc, str) or isinstance(desc, security.descriptor))
 123             if isinstance(desc, str):
 124                 ldif += "nTSecurityDescriptor: %s" % desc
 125             elif isinstance(desc, security.descriptor):
 126                 ldif += "nTSecurityDescriptor:: %s" % base64.b64encode(ndr_pack(desc))
 127         _ldb.add_ldif(ldif)
 128
 129     def create_domain_group(self, _ldb, group_dn, desc=None):
 130         ldif = """
 131 dn: """ + group_dn + """
 132 objectClass: group
 133 sAMAccountName: """ + group_dn.split(",")[0][3:] + """
 134 groupType: 4
 135 url: www.example.com
 136 """
 137         if desc:
 138             assert(isinstance(desc, str) or isinstance(desc, security.descriptor))
 139             if isinstance(desc, str):
 140                 ldif += "nTSecurityDescriptor: %s" % desc
 141             elif isinstance(desc, security.descriptor):
 142                 ldif += "nTSecurityDescriptor:: %s" % base64.b64encode(ndr_pack(desc))
 143         _ldb.add_ldif(ldif)
 144
 145     def get_unique_schema_class_name(self):
 146         while True:
 147             class_name = "test-class%s" % random.randint(1,100000)
 148             class_dn = "CN=%s,%s" % (class_name, self.schema_dn)
 149             try:
 150                 self.ldb_admin.search(base=class_dn, attrs=["*"])
 151             except LdbError, (num, _):
 152                 self.assertEquals(num, ERR_NO_SUCH_OBJECT)
 153                 return class_name
 154
 155     def create_schema_class(self, _ldb, object_dn, desc=None):
 156         ldif = """
 157 dn: """ + object_dn + """
 158 objectClass: classSchema
 159 objectCategory: CN=Class-Schema,""" + self.schema_dn + """
 160 defaultObjectCategory: """ + object_dn + """
 161 distinguishedName: """ + object_dn + """
 162 governsID: 1.2.840.""" + str(random.randint(1,100000)) + """.1.5.9939
 163 instanceType: 4
 164 objectClassCategory: 1
 165 subClassOf: organizationalPerson
 166 systemFlags: 16
 167 rDNAttID: cn
 168 systemMustContain: cn
 169 systemOnly: FALSE
 170 """
 171         if desc:
 172             assert(isinstance(desc, str) or isinstance(desc, security.descriptor))
 173             if isinstance(desc, str):
 174                 ldif += "nTSecurityDescriptor: %s" % desc
 175             elif isinstance(desc, security.descriptor):
 176                 ldif += "nTSecurityDescriptor:: %s" % base64.b64encode(ndr_pack(desc))
 177         _ldb.add_ldif(ldif)
 178
 179     def create_configuration_container(self, _ldb, object_dn, desc=None):
 180         ldif = """
 181 dn: """ + object_dn + """
 182 objectClass: container
 183 objectCategory: CN=Container,""" + self.schema_dn + """
 184 showInAdvancedViewOnly: TRUE
 185 instanceType: 4
 186 """
 187         if desc:
 188             assert(isinstance(desc, str) or isinstance(desc, security.descriptor))
 189             if isinstance(desc, str):
 190                 ldif += "nTSecurityDescriptor: %s" % desc
 191             elif isinstance(desc, security.descriptor):
 192                 ldif += "nTSecurityDescriptor:: %s" % base64.b64encode(ndr_pack(desc))
 193         _ldb.add_ldif(ldif)
 194
 195     def create_configuration_specifier(self, _ldb, object_dn, desc=None):
 196         ldif = """
 197 dn: """ + object_dn + """
 198 objectClass: displaySpecifier
 199 showInAdvancedViewOnly: TRUE
 200 """
 201         if desc:
 202             assert(isinstance(desc, str) or isinstance(desc, security.descriptor))
 203             if isinstance(desc, str):
 204                 ldif += "nTSecurityDescriptor: %s" % desc
 205             elif isinstance(desc, security.descriptor):
 206                 ldif += "nTSecurityDescriptor:: %s" % base64.b64encode(ndr_pack(desc))
 207         _ldb.add_ldif(ldif)
 208
 209     def read_desc(self, object_dn):
 210         res = self.ldb_admin.search(base=object_dn, attrs=["nTSecurityDescriptor"])
 211         desc = res[0]["nTSecurityDescriptor"][0]
 212         return ndr_unpack( security.descriptor, desc )
 213
 214     def enable_account(self,  user_dn):
 215         """Enable an account.
 216         :param user_dn: Dn of the account to enable.
 217         """
 218         res = self.ldb_admin.search(user_dn, SCOPE_BASE, None, ["userAccountControl"])
 219         assert len(res) == 1
 220         userAccountControl = res[0]["userAccountControl"][0]
 221         userAccountControl = int(userAccountControl)
 222         if (userAccountControl & 0x2):
 223             userAccountControl = userAccountControl & ~0x2 # remove disabled bit
 224         if (userAccountControl & 0x20):
 225             userAccountControl = userAccountControl & ~0x20 # remove 'no password required' bit
 226         mod = """
 227 dn: """ + user_dn + """
 228 changetype: modify
 229 replace: userAccountControl
 230 userAccountControl: %s""" % userAccountControl
 231         if self.WIN2003:
 232             mod = re.sub("userAccountControl: \d.*", "userAccountControl: 544", mod)
 233         self.ldb_admin.modify_ldif(mod)
 234
 235     def get_ldb_connection(self, target_username, target_password):
 236         username_save = creds.get_username(); password_save = creds.get_password()
 237         creds.set_username(target_username)
 238         creds.set_password(target_password)
 239         ldb_target = Ldb(host, credentials=creds, session_info=system_session(), lp=lp)
 240         creds.set_username(username_save); creds.set_password(password_save)
 241         return ldb_target
 242
 243     def get_object_sid(self, object_dn):
 244         res = self.ldb_admin.search(object_dn)
 245         return ndr_unpack( security.dom_sid, res[0]["objectSid"][0] )
 246
 247     def dacl_add_ace(self, object_dn, ace):
 248         desc = self.read_desc( object_dn )
 249         desc_sddl = desc.as_sddl( self.domain_sid )
 250         if ace in desc_sddl:
 251             return
 252         desc_sddl = desc_sddl[0:desc_sddl.index("(")] + ace + desc_sddl[desc_sddl.index("("):]
 253         self.modify_desc(object_dn, desc_sddl)
 254
 255     def get_desc_sddl(self, object_dn):
 256         """ Return object nTSecutiryDescriptor in SDDL format
 257         """
 258         desc = self.read_desc(object_dn)
 259         return desc.as_sddl(self.domain_sid)
 260
 261     def setUp(self):
 262         self.ldb_admin = ldb
 263         self.base_dn = self.find_basedn(self.ldb_admin)
 264         self.configuration_dn = self.find_configurationdn(self.ldb_admin)
 265         self.schema_dn = self.find_schemadn(self.ldb_admin)
 266         self.domain_sid = self.find_domain_sid(self.ldb_admin)
 267         print "baseDN: %s" % self.base_dn
 268         self.SAMBA = False; self.WIN2003 = False
 269         res = self.ldb_admin.search(base="", expression="", scope=SCOPE_BASE, attrs=["vendorName"])
 270         if "vendorName" in res[0].keys() and "Samba Team" in res[0]["vendorName"][0]:
 271             self.SAMBA = True
 272         else:
 273             self.WIN2003 = True
 274         #print "self.SAMBA:", self.SAMBA
 275         #print "self.WIN2003:", self.WIN2003
 276
 277     ################################################################################################
 278
 279     ## Tests for DOMAIN
 280
 281     # Default descriptor tests #####################################################################
 282
 283 class OwnerGroupDescriptorTests(DescriptorTests):
 284
 285     def setUp(self):
 286         DescriptorTests.setUp(self)
 287         if self.SAMBA:
 288             ### Create users
 289             # User 1
 290             user_dn = self.get_users_domain_dn("testuser1")
 291             self.create_domain_user(self.ldb_admin, user_dn)
 292             self.enable_account(user_dn)
 293             ldif = """
 294 dn: CN=Enterprise Admins,CN=Users,""" + self.base_dn + """
 295 changetype: add
 296 member: """ + user_dn
 297             self.ldb_admin.modify_ldif(ldif)
 298             # User 2
 299             user_dn = self.get_users_domain_dn("testuser2")
 300             self.create_domain_user(self.ldb_admin, user_dn)
 301             self.enable_account(user_dn)
 302             ldif = """
 303 dn: CN=Domain Admins,CN=Users,""" + self.base_dn + """
 304 changetype: add
 305 member: """ + user_dn
 306             self.ldb_admin.modify_ldif(ldif)
 307             # User 3
 308             user_dn = self.get_users_domain_dn("testuser3")
 309             self.create_domain_user(self.ldb_admin, user_dn)
 310             self.enable_account(user_dn)
 311             ldif = """
 312 dn: CN=Schema Admins,CN=Users,""" + self.base_dn + """
 313 changetype: add
 314 member: """ + user_dn
 315             self.ldb_admin.modify_ldif(ldif)
 316             # User 4
 317             user_dn = self.get_users_domain_dn("testuser4")
 318             self.create_domain_user(self.ldb_admin, user_dn)
 319             self.enable_account(user_dn)
 320             # User 5
 321             user_dn = self.get_users_domain_dn("testuser5")
 322             self.create_domain_user(self.ldb_admin, user_dn)
 323             self.enable_account(user_dn)
 324             ldif = """
 325 dn: CN=Enterprise Admins,CN=Users,""" + self.base_dn + """
 326 changetype: add
 327 member: """ + user_dn + """
 328
 329 dn: CN=Domain Admins,CN=Users,""" + self.base_dn + """
 330 changetype: add
 331 member: """ + user_dn
 332             self.ldb_admin.modify_ldif(ldif)
 333             # User 6
 334             user_dn = self.get_users_domain_dn("testuser6")
 335             self.create_domain_user(self.ldb_admin, user_dn)
 336             self.enable_account(user_dn)
 337             ldif = """
 338 dn: CN=Enterprise Admins,CN=Users,""" + self.base_dn + """
 339 changetype: add
 340 member: """ + user_dn + """
 341
 342 dn: CN=Domain Admins,CN=Users,""" + self.base_dn + """
 343 changetype: add
 344 member: """ + user_dn + """
 345
 346 dn: CN=Schema Admins,CN=Users,""" + self.base_dn + """
 347 changetype: add
 348 member: """ + user_dn
 349             self.ldb_admin.modify_ldif(ldif)
 350             # User 7
 351             user_dn = self.get_users_domain_dn("testuser7")
 352             self.create_domain_user(self.ldb_admin, user_dn)
 353             self.enable_account(user_dn)
 354             ldif = """
 355 dn: CN=Domain Admins,CN=Users,""" + self.base_dn + """
 356 changetype: add
 357 member: """ + user_dn + """
 358
 359 dn: CN=Schema Admins,CN=Users,""" + self.base_dn + """
 360 changetype: add
 361 member: """ + user_dn
 362             self.ldb_admin.modify_ldif(ldif)
 363             # User 8
 364             user_dn = self.get_users_domain_dn("testuser8")
 365             self.create_domain_user(self.ldb_admin, user_dn)
 366             self.enable_account(user_dn)
 367             ldif = """
 368 dn: CN=Enterprise Admins,CN=Users,""" + self.base_dn + """
 369 changetype: add
 370 member: """ + user_dn + """
 371
 372 dn: CN=Schema Admins,CN=Users,""" + self.base_dn + """
 373 changetype: add
 374 member: """ + user_dn
 375             self.ldb_admin.modify_ldif(ldif)
 376         self.results = {
 377             # msDS-Behavior-Version < DS_BEHAVIOR_WIN2008
 378             "ds_behavior_win2003" : {
 379                 "100" : "O:EAG:DU",
 380                 "101" : "O:DAG:DU",
 381                 "102" : "O:%sG:DU",
 382                 "103" : "O:%sG:DU",
 383                 "104" : "O:DAG:DU",
 384                 "105" : "O:DAG:DU",
 385                 "106" : "O:DAG:DU",
 386                 "107" : "O:EAG:DU",
 387                 "108" : "O:DAG:DA",
 388                 "109" : "O:DAG:DA",
 389                 "110" : "O:%sG:DA",
 390                 "111" : "O:%sG:DA",
 391                 "112" : "O:DAG:DA",
 392                 "113" : "O:DAG:DA",
 393                 "114" : "O:DAG:DA",
 394                 "115" : "O:DAG:DA",
 395                 "130" : "O:EAG:DU",
 396                 "131" : "O:DAG:DU",
 397                 "132" : "O:SAG:DU",
 398                 "133" : "O:%sG:DU",
 399                 "134" : "O:EAG:DU",
 400                 "135" : "O:SAG:DU",
 401                 "136" : "O:SAG:DU",
 402                 "137" : "O:SAG:DU",
 403                 "138" : "O:DAG:DA",
 404                 "139" : "O:DAG:DA",
 405                 "140" : "O:%sG:DA",
 406                 "141" : "O:%sG:DA",
 407                 "142" : "O:DAG:DA",
 408                 "143" : "O:DAG:DA",
 409                 "144" : "O:DAG:DA",
 410                 "145" : "O:DAG:DA",
 411                 "160" : "O:EAG:DU",
 412                 "161" : "O:DAG:DU",
 413                 "162" : "O:%sG:DU",
 414                 "163" : "O:%sG:DU",
 415                 "164" : "O:EAG:DU",
 416                 "165" : "O:EAG:DU",
 417                 "166" : "O:DAG:DU",
 418                 "167" : "O:EAG:DU",
 419                 "168" : "O:DAG:DA",
 420                 "169" : "O:DAG:DA",
 421                 "170" : "O:%sG:DA",
 422                 "171" : "O:%sG:DA",
 423                 "172" : "O:DAG:DA",
 424                 "173" : "O:DAG:DA",
 425                 "174" : "O:DAG:DA",
 426                 "175" : "O:DAG:DA",
 427             },
 428             # msDS-Behavior-Version >= 3
 429             "ds_behavior_win2008" : {
 430                 "100" : "O:EAG:EA",
 431                 "101" : "O:DAG:DA",
 432                 "102" : "O:%sG:DU",
 433                 "103" : "O:%sG:DU",
 434                 "104" : "O:DAG:DA",
 435                 "105" : "O:DAG:DA",
 436                 "106" : "O:DAG:DA",
 437                 "107" : "O:EAG:EA",
 438                 "108" : "O:DAG:DA",
 439                 "109" : "O:DAG:DA",
 440                 "110" : "O:%sG:DA",
 441                 "111" : "O:%sG:DA",
 442                 "112" : "O:DAG:DA",
 443                 "113" : "O:DAG:DA",
 444                 "114" : "O:DAG:DA",
 445                 "115" : "O:DAG:DA",
 446                 "130" : "",
 447                 "131" : "",
 448                 "132" : "",
 449                 "133" : "%s",
 450                 "134" : "",
 451                 "135" : "",
 452                 "136" : "",
 453                 "137" : "",
 454                 "138" : "",
 455                 "139" : "",
 456                 "140" : "%s",
 457                 "141" : "%s",
 458                 "142" : "",
 459                 "143" : "",
 460                 "144" : "",
 461                 "145" : "",
 462                 "160" : "O:EAG:EA",
 463                 "161" : "O:DAG:DA",
 464                 "162" : "O:%sG:DU",
 465                 "163" : "O:%sG:DU",
 466                 "164" : "O:EAG:EA",
 467                 "165" : "O:EAG:EA",
 468                 "166" : "O:DAG:DA",
 469                 "167" : "O:EAG:EA",
 470                 "168" : "O:DAG:DA",
 471                 "169" : "O:DAG:DA",
 472                 "170" : "O:%sG:DA",
 473                 "171" : "O:%sG:DA",
 474                 "172" : "O:DAG:DA",
 475                 "173" : "O:DAG:DA",
 476                 "174" : "O:DAG:DA",
 477                 "175" : "O:DAG:DA",
 478             },
 479         }
 480         # Discover 'msDS-Behavior-Version'
 481         res = self.ldb_admin.search(base=self.base_dn, expression="distinguishedName=%s" % self.base_dn, \
 482                 attrs=['msDS-Behavior-Version'])
 483         res = int(res[0]['msDS-Behavior-Version'][0])
 484         if res < DS_BEHAVIOR_WIN2008:
 485             self.DS_BEHAVIOR = "ds_behavior_win2003"
 486         else:
 487             self.DS_BEHAVIOR = "ds_behavior_win2008"
 488
 489     def tearDown(self):
 490         if self.SAMBA:
 491             self.delete_force(self.ldb_admin, self.get_users_domain_dn("testuser1"))
 492             self.delete_force(self.ldb_admin, self.get_users_domain_dn("testuser2"))
 493             self.delete_force(self.ldb_admin, self.get_users_domain_dn("testuser3"))
 494             self.delete_force(self.ldb_admin, self.get_users_domain_dn("testuser4"))
 495             self.delete_force(self.ldb_admin, self.get_users_domain_dn("testuser5"))
 496             self.delete_force(self.ldb_admin, self.get_users_domain_dn("testuser6"))
 497             self.delete_force(self.ldb_admin, self.get_users_domain_dn("testuser7"))
 498             self.delete_force(self.ldb_admin, self.get_users_domain_dn("testuser8"))
 499         # DOMAIN
 500         self.delete_force(self.ldb_admin, self.get_users_domain_dn("test_domain_group1"))
 501         self.delete_force(self.ldb_admin, "CN=test_domain_user1,OU=test_domain_ou1," + self.base_dn)
 502         self.delete_force(self.ldb_admin, "OU=test_domain_ou2,OU=test_domain_ou1," + self.base_dn)
 503         self.delete_force(self.ldb_admin, "OU=test_domain_ou1," + self.base_dn)
 504         # SCHEMA
 505         # CONFIGURATION
 506         self.delete_force(self.ldb_admin, "CN=test-specifier1,CN=test-container1,CN=DisplaySpecifiers," \
 507                 + self.configuration_dn)
 508         self.delete_force(self.ldb_admin, "CN=test-container1,CN=DisplaySpecifiers," + self.configuration_dn)
 509
 510     def check_user_belongs(self, user_dn, groups=[]):
 511         """ Test wether user is member of the expected group(s) """
 512         if groups != []:
 513             # User is member of at least one additional group
 514             res = self.ldb_admin.search(user_dn, attrs=["memberOf"])
 515             res = [x.upper() for x in sorted(list(res[0]["memberOf"]))]
 516             expected = []
 517             for x in groups:
 518                 expected.append(self.get_users_domain_dn(x))
 519             expected = [x.upper() for x in sorted(expected)]
 520             self.assertEqual(expected, res)
 521         else:
 522             # User is not a member of any additional groups but default
 523             res = self.ldb_admin.search(user_dn, attrs=["*"])
 524             res = [x.upper() for x in res[0].keys()]
 525             self.assertFalse( "MEMBEROF" in res)
 526
 527     def test_100(self):
 528         """ Enterprise admin group member creates object (default nTSecurityDescriptor) in DOMAIN
 529         """
 530         user_name = "testuser1"
 531         self.check_user_belongs(self.get_users_domain_dn(user_name), ["Enterprise Admins"])
 532         # Open Ldb connection with the tested user
 533         _ldb = self.get_ldb_connection("testuser1", "samba123@")
 534         group_dn = "CN=test_domain_group1,CN=Users," + self.base_dn
 535         self.delete_force(self.ldb_admin, group_dn)
 536         self.create_domain_group(_ldb, group_dn)
 537         desc_sddl = self.get_desc_sddl(group_dn)
 538         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
 539         self.assertEqual(self.results[self.DS_BEHAVIOR]["100"], res)
 540
 541     def test_101(self):
 542         """ Dmain admin group member creates object (default nTSecurityDescriptor) in DOMAIN
 543         """
 544         user_name = "testuser2"
 545         self.check_user_belongs(self.get_users_domain_dn(user_name), ["Domain Admins"])
 546         # Open Ldb connection with the tested user
 547         _ldb = self.get_ldb_connection(user_name, "samba123@")
 548         group_dn = "CN=test_domain_group1,CN=Users," + self.base_dn
 549         self.delete_force(self.ldb_admin, group_dn)
 550         self.create_domain_group(_ldb, group_dn)
 551         desc_sddl = self.get_desc_sddl(group_dn)
 552         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
 553         self.assertEqual(self.results[self.DS_BEHAVIOR]["101"], res)
 554
 555     def test_102(self):
 556         """ Schema admin group member with CC right creates object (default nTSecurityDescriptor) in DOMAIN
 557         """
 558         user_name = "testuser3"
 559         self.check_user_belongs(self.get_users_domain_dn(user_name), ["Schema Admins"])
 560         # Open Ldb connection with the tested user
 561         _ldb = self.get_ldb_connection(user_name, "samba123@")
 562         object_dn = "OU=test_domain_ou1," + self.base_dn
 563         self.delete_force(self.ldb_admin, object_dn)
 564         self.create_domain_ou(self.ldb_admin, object_dn)
 565         user_sid = self.get_object_sid( self.get_users_domain_dn(user_name) )
 566         mod = "(A;;CC;;;%s)" % str(user_sid)
 567         self.dacl_add_ace(object_dn, mod)
 568         # Create additional object into the first one
 569         object_dn = "CN=test_domain_user1," + object_dn
 570         self.delete_force(self.ldb_admin, object_dn)
 571         self.create_domain_user(_ldb, object_dn)
 572         desc_sddl = self.get_desc_sddl(object_dn)
 573         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
 574         self.assertEqual(self.results[self.DS_BEHAVIOR]["102"] % str(user_sid), res)
 575
 576     def test_103(self):
 577         """ Regular user with CC right creates object (default nTSecurityDescriptor) in DOMAIN
 578         """
 579         user_name = "testuser4"
 580         self.check_user_belongs(self.get_users_domain_dn(user_name), [])
 581         # Open Ldb connection with the tested user
 582         _ldb = self.get_ldb_connection(user_name, "samba123@")
 583         object_dn = "OU=test_domain_ou1," + self.base_dn
 584         self.delete_force(self.ldb_admin, object_dn)
 585         self.create_domain_ou(self.ldb_admin, object_dn)
 586         user_sid = self.get_object_sid( self.get_users_domain_dn(user_name) )
 587         mod = "(A;;CC;;;%s)" % str(user_sid)
 588         self.dacl_add_ace(object_dn, mod)
 589         # Create additional object into the first one
 590         object_dn = "CN=test_domain_user1," + object_dn
 591         self.delete_force(self.ldb_admin, object_dn)
 592         self.create_domain_user(_ldb, object_dn)
 593         desc_sddl = self.get_desc_sddl(object_dn)
 594         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
 595         self.assertEqual(self.results[self.DS_BEHAVIOR]["103"] % str(user_sid), res)
 596
 597     def test_104(self):
 598         """ Enterprise & Domain admin group member creates object (default nTSecurityDescriptor) in DOMAIN
 599         """
 600         user_name = "testuser5"
 601         self.check_user_belongs(self.get_users_domain_dn(user_name), ["Enterprise Admins", "Domain Admins"])
 602         # Open Ldb connection with the tested user
 603         _ldb = self.get_ldb_connection(user_name, "samba123@")
 604         group_dn = "CN=test_domain_group1,CN=Users," + self.base_dn
 605         self.delete_force(self.ldb_admin, group_dn)
 606         self.create_domain_group(_ldb, group_dn)
 607         desc_sddl = self.get_desc_sddl(group_dn)
 608         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
 609         self.assertEqual(self.results[self.DS_BEHAVIOR]["104"], res)
 610
 611     def test_105(self):
 612         """ Enterprise & Domain & Schema admin group member creates object (default nTSecurityDescriptor) in DOMAIN
 613         """
 614         user_name = "testuser6"
 615         self.check_user_belongs(self.get_users_domain_dn(user_name), ["Enterprise Admins", "Domain Admins", "Schema Admins"])
 616         # Open Ldb connection with the tested user
 617         _ldb = self.get_ldb_connection(user_name, "samba123@")
 618         group_dn = "CN=test_domain_group1,CN=Users," + self.base_dn
 619         self.delete_force(self.ldb_admin, group_dn)
 620         self.create_domain_group(_ldb, group_dn)
 621         desc_sddl = self.get_desc_sddl(group_dn)
 622         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
 623         self.assertEqual(self.results[self.DS_BEHAVIOR]["105"], res)
 624
 625     def test_106(self):
 626         """ Domain & Schema admin group member creates object (default nTSecurityDescriptor) in DOMAIN
 627         """
 628         user_name = "testuser7"
 629         self.check_user_belongs(self.get_users_domain_dn(user_name), ["Domain Admins", "Schema Admins"])
 630         # Open Ldb connection with the tested user
 631         _ldb = self.get_ldb_connection(user_name, "samba123@")
 632         group_dn = "CN=test_domain_group1,CN=Users," + self.base_dn
 633         self.delete_force(self.ldb_admin, group_dn)
 634         self.create_domain_group(_ldb, group_dn)
 635         desc_sddl = self.get_desc_sddl(group_dn)
 636         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
 637         self.assertEqual(self.results[self.DS_BEHAVIOR]["106"], res)
 638
 639     def test_107(self):
 640         """ Enterprise & Schema admin group member creates object (default nTSecurityDescriptor) in DOMAIN
 641         """
 642         user_name = "testuser8"
 643         self.check_user_belongs(self.get_users_domain_dn(user_name), ["Enterprise Admins", "Schema Admins"])
 644         # Open Ldb connection with the tested user
 645         _ldb = self.get_ldb_connection(user_name, "samba123@")
 646         group_dn = "CN=test_domain_group1,CN=Users," + self.base_dn
 647         self.delete_force(self.ldb_admin, group_dn)
 648         self.create_domain_group(_ldb, group_dn)
 649         desc_sddl = self.get_desc_sddl(group_dn)
 650         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
 651         self.assertEqual(self.results[self.DS_BEHAVIOR]["107"], res)
 652
 653     # Control descriptor tests #####################################################################
 654
 655     def test_108(self):
 656         """ Enterprise admin group member creates object (custom descriptor) in DOMAIN
 657         """
 658         user_name = "testuser1"
 659         self.check_user_belongs(self.get_users_domain_dn(user_name), ["Enterprise Admins"])
 660         # Open Ldb connection with the tested user
 661         _ldb = self.get_ldb_connection(user_name, "samba123@")
 662         group_dn = "CN=test_domain_group1,CN=Users," + self.base_dn
 663         self.delete_force(self.ldb_admin, group_dn)
 664         # Create a custom security descriptor
 665         desc_sddl = "O:DAG:DAD:(A;;RP;;;DU)"
 666         self.create_domain_group(_ldb, group_dn, desc_sddl)
 667         desc_sddl = self.get_desc_sddl(group_dn)
 668         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
 669         self.assertEqual(self.results[self.DS_BEHAVIOR]["108"], res)
 670
 671     def test_109(self):
 672         """ Domain admin group member creates object (custom descriptor) in DOMAIN
 673         """
 674         user_name = "testuser2"
 675         self.check_user_belongs(self.get_users_domain_dn(user_name), ["Domain Admins"])
 676         # Open Ldb connection with the tested user
 677         _ldb = self.get_ldb_connection(user_name, "samba123@")
 678         group_dn = "CN=test_domain_group1,CN=Users," + self.base_dn
 679         self.delete_force(self.ldb_admin, group_dn)
 680         # Create a custom security descriptor
 681         desc_sddl = "O:DAG:DAD:(A;;RP;;;DU)"
 682         self.create_domain_group(_ldb, group_dn, desc_sddl)
 683         desc_sddl = self.get_desc_sddl(group_dn)
 684         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
 685         self.assertEqual(self.results[self.DS_BEHAVIOR]["109"], res)
 686
 687     def test_110(self):
 688         """ Schema admin group member with CC right creates object (custom descriptor) in DOMAIN
 689         """
 690         user_name = "testuser3"
 691         self.check_user_belongs(self.get_users_domain_dn(user_name), ["Schema Admins"])
 692         # Open Ldb connection with the tested user
 693         _ldb = self.get_ldb_connection(user_name, "samba123@")
 694         object_dn = "OU=test_domain_ou1," + self.base_dn
 695         self.delete_force(self.ldb_admin, object_dn)
 696         self.create_domain_ou(self.ldb_admin, object_dn)
 697         user_sid = self.get_object_sid( self.get_users_domain_dn(user_name) )
 698         mod = "(A;;CC;;;%s)" % str(user_sid)
 699         self.dacl_add_ace(object_dn, mod)
 700         # Create a custom security descriptor
 701         # NB! Problematic owner part won't accept DA only <User Sid> !!!
 702         desc_sddl = "O:%sG:DAD:(A;;RP;;;DU)" % str(user_sid)
 703         # Create additional object into the first one
 704         object_dn = "CN=test_domain_user1," + object_dn
 705         self.delete_force(self.ldb_admin, object_dn)
 706         self.create_domain_user(_ldb, object_dn, desc_sddl)
 707         desc = self.read_desc(object_dn)
 708         desc_sddl = self.get_desc_sddl(object_dn)
 709         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
 710         self.assertEqual(self.results[self.DS_BEHAVIOR]["110"] % str(user_sid), res)
 711
 712     def test_111(self):
 713         """ Regular user with CC right creates object (custom descriptor) in DOMAIN
 714         """
 715         user_name = "testuser4"
 716         self.check_user_belongs(self.get_users_domain_dn(user_name), [])
 717         # Open Ldb connection with the tested user
 718         _ldb = self.get_ldb_connection(user_name, "samba123@")
 719         object_dn = "OU=test_domain_ou1," + self.base_dn
 720         self.delete_force(self.ldb_admin, object_dn)
 721         self.create_domain_ou(self.ldb_admin, object_dn)
 722         user_sid = self.get_object_sid( self.get_users_domain_dn(user_name) )
 723         mod = "(A;;CC;;;%s)" % str(user_sid)
 724         self.dacl_add_ace(object_dn, mod)
 725         # Create a custom security descriptor
 726         # NB! Problematic owner part won't accept DA only <User Sid> !!!
 727         desc_sddl = "O:%sG:DAD:(A;;RP;;;DU)" % str(user_sid)
 728         # Create additional object into the first one
 729         object_dn = "CN=test_domain_user1," + object_dn
 730         self.delete_force(self.ldb_admin, object_dn)
 731         self.create_domain_user(_ldb, object_dn, desc_sddl)
 732         desc = self.read_desc(object_dn)
 733         desc_sddl = self.get_desc_sddl(object_dn)
 734         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
 735         self.assertEqual(self.results[self.DS_BEHAVIOR]["111"] % str(user_sid), res)
 736
 737     def test_112(self):
 738         """ Domain & Enterprise admin group member creates object (custom descriptor) in DOMAIN
 739         """
 740         user_name = "testuser5"
 741         self.check_user_belongs(self.get_users_domain_dn(user_name), ["Enterprise Admins", "Domain Admins"])
 742         # Open Ldb connection with the tested user
 743         _ldb = self.get_ldb_connection(user_name, "samba123@")
 744         group_dn = "CN=test_domain_group1,CN=Users," + self.base_dn
 745         self.delete_force(self.ldb_admin, group_dn)
 746         # Create a custom security descriptor
 747         desc_sddl = "O:DAG:DAD:(A;;RP;;;DU)"
 748         self.create_domain_group(_ldb, group_dn, desc_sddl)
 749         desc_sddl = self.get_desc_sddl(group_dn)
 750         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
 751         self.assertEqual(self.results[self.DS_BEHAVIOR]["112"], res)
 752
 753     def test_113(self):
 754         """ Domain & Enterprise & Schema admin group  member creates object (custom descriptor) in DOMAIN
 755         """
 756         user_name = "testuser6"
 757         self.check_user_belongs(self.get_users_domain_dn(user_name), ["Enterprise Admins", "Domain Admins", "Schema Admins"])
 758         # Open Ldb connection with the tested user
 759         _ldb = self.get_ldb_connection(user_name, "samba123@")
 760         group_dn = "CN=test_domain_group1,CN=Users," + self.base_dn
 761         self.delete_force(self.ldb_admin, group_dn)
 762         # Create a custom security descriptor
 763         desc_sddl = "O:DAG:DAD:(A;;RP;;;DU)"
 764         self.create_domain_group(_ldb, group_dn, desc_sddl)
 765         desc_sddl = self.get_desc_sddl(group_dn)
 766         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
 767         self.assertEqual(self.results[self.DS_BEHAVIOR]["113"], res)
 768
 769     def test_114(self):
 770         """ Domain & Schema admin group  member creates object (custom descriptor) in DOMAIN
 771         """
 772         user_name = "testuser7"
 773         self.check_user_belongs(self.get_users_domain_dn(user_name), ["Domain Admins", "Schema Admins"])
 774         # Open Ldb connection with the tested user
 775         _ldb = self.get_ldb_connection(user_name, "samba123@")
 776         group_dn = "CN=test_domain_group1,CN=Users," + self.base_dn
 777         self.delete_force(self.ldb_admin, group_dn)
 778         # Create a custom security descriptor
 779         desc_sddl = "O:DAG:DAD:(A;;RP;;;DU)"
 780         self.create_domain_group(_ldb, group_dn, desc_sddl)
 781         desc_sddl = self.get_desc_sddl(group_dn)
 782         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
 783         self.assertEqual(self.results[self.DS_BEHAVIOR]["114"], res)
 784
 785     def test_115(self):
 786         """ Enterprise & Schema admin group  member creates object (custom descriptor) in DOMAIN
 787         """
 788         user_name = "testuser8"
 789         self.check_user_belongs(self.get_users_domain_dn(user_name), ["Enterprise Admins", "Schema Admins"])
 790         # Open Ldb connection with the tested user
 791         _ldb = self.get_ldb_connection(user_name, "samba123@")
 792         group_dn = "CN=test_domain_group1,CN=Users," + self.base_dn
 793         self.delete_force(self.ldb_admin, group_dn)
 794         # Create a custom security descriptor
 795         desc_sddl = "O:DAG:DAD:(A;;RP;;;DU)"
 796         self.create_domain_group(_ldb, group_dn, desc_sddl)
 797         desc_sddl = self.get_desc_sddl(group_dn)
 798         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
 799         self.assertEqual(self.results[self.DS_BEHAVIOR]["115"], res)
 800
 801
 802     def test_999(self):
 803         user_name = "Administrator"
 804         object_dn = "OU=test_domain_ou1," + self.base_dn
 805         self.delete_force(self.ldb_admin, object_dn)
 806         self.create_domain_ou(self.ldb_admin, object_dn)
 807         user_sid = self.get_object_sid( self.get_users_domain_dn(user_name) )
 808         mod = "(D;CI;WP;;;S-1-3-0)"
 809         #mod = ""
 810         self.dacl_add_ace(object_dn, mod)
 811         desc_sddl = self.get_desc_sddl(object_dn)
 812         #print desc_sddl
 813         # Create additional object into the first one
 814         object_dn = "OU=test_domain_ou2," + object_dn
 815         self.delete_force(self.ldb_admin, object_dn)
 816         self.create_domain_ou(self.ldb_admin, object_dn)
 817         desc_sddl = self.get_desc_sddl(object_dn)
 818         #print desc_sddl
 819
 820     ## Tests for SCHEMA
 821
 822     # Defalt descriptor tests ##################################################################
 823
 824     def test_130(self):
 825         user_name = "testuser1"
 826         self.check_user_belongs(self.get_users_domain_dn(user_name), ["Enterprise Admins"])
 827         # Open Ldb connection with the tested user
 828         _ldb = self.get_ldb_connection(user_name, "samba123@")
 829         # Change Schema partition descriptor
 830         user_sid = self.get_object_sid( self.get_users_domain_dn(user_name) )
 831         mod = "(A;;CC;;;AU)"
 832         self.dacl_add_ace(self.schema_dn, mod)
 833         # Create example Schema class
 834         class_name = self.get_unique_schema_class_name()
 835         class_dn = "CN=%s,%s" % (class_name, self.schema_dn)
 836         self.create_schema_class(_ldb, class_dn)
 837         desc_sddl = self.get_desc_sddl(class_dn)
 838         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
 839         self.assertEqual(self.results[self.DS_BEHAVIOR]["130"], res)
 840
 841     def test_131(self):
 842         user_name = "testuser2"
 843         self.check_user_belongs(self.get_users_domain_dn(user_name), ["Domain Admins"])
 844         # Open Ldb connection with the tested user
 845         _ldb = self.get_ldb_connection(user_name, "samba123@")
 846         # Change Schema partition descriptor
 847         mod = "(A;;CC;;;AU)"
 848         self.dacl_add_ace(self.schema_dn, mod)
 849         # Create example Schema class
 850         class_name = self.get_unique_schema_class_name()
 851         class_dn = "CN=%s,%s" % (class_name, self.schema_dn)
 852         self.create_schema_class(_ldb, class_dn)
 853         desc_sddl = self.get_desc_sddl(class_dn)
 854         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
 855         self.assertEqual(self.results[self.DS_BEHAVIOR]["131"], res)
 856
 857     def test_132(self):
 858         user_name = "testuser3"
 859         self.check_user_belongs(self.get_users_domain_dn(user_name), ["Schema Admins"])
 860         # Open Ldb connection with the tested user
 861         _ldb = self.get_ldb_connection(user_name, "samba123@")
 862         # Change Schema partition descriptor
 863         mod = "(A;;CC;;;AU)"
 864         self.dacl_add_ace(self.schema_dn, mod)
 865         # Create example Schema class
 866         class_name = self.get_unique_schema_class_name()
 867         class_dn = "CN=%s,%s" % (class_name, self.schema_dn)
 868         self.create_schema_class(_ldb, class_dn)
 869         desc_sddl = self.get_desc_sddl(class_dn)
 870         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
 871         self.assertEqual(self.results[self.DS_BEHAVIOR]["132"], res)
 872
 873     def test_133(self):
 874         user_name = "testuser4"
 875         self.check_user_belongs(self.get_users_domain_dn(user_name), [])
 876         # Open Ldb connection with the tested user
 877         _ldb = self.get_ldb_connection(user_name, "samba123@")
 878         #Change Schema partition descriptor
 879         user_sid = self.get_object_sid( self.get_users_domain_dn(user_name) )
 880         mod = "(A;;CC;;;AU)"
 881         self.dacl_add_ace(self.schema_dn, mod)
 882         # Create example Schema class
 883         class_name = self.get_unique_schema_class_name()
 884         class_dn = "CN=%s,%s" % (class_name, self.schema_dn)
 885         self.create_schema_class(_ldb, class_dn)
 886         desc_sddl = self.get_desc_sddl(class_dn)
 887         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
 888         self.assertEqual(self.results[self.DS_BEHAVIOR]["133"] % str(user_sid), res)
 889
 890     def test_134(self):
 891         user_name = "testuser5"
 892         self.check_user_belongs(self.get_users_domain_dn(user_name), ["Enterprise Admins", "Domain 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.dacl_add_ace(self.schema_dn, mod)
 898         # Create example Schema class
 899         class_name = self.get_unique_schema_class_name()
 900         class_dn = "CN=%s,%s" % (class_name, self.schema_dn)
 901         self.create_schema_class(_ldb, class_dn)
 902         desc_sddl = self.get_desc_sddl(class_dn)
 903         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
 904         self.assertEqual(self.results[self.DS_BEHAVIOR]["134"], res)
 905
 906     def test_135(self):
 907         user_name = "testuser6"
 908         self.check_user_belongs(self.get_users_domain_dn(user_name), ["Enterprise Admins", "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.dacl_add_ace(self.schema_dn, mod)
 914         # Create example Schema class
 915         class_name = self.get_unique_schema_class_name()
 916         class_dn = "CN=%s,%s" % (class_name, self.schema_dn)
 917         self.create_schema_class(_ldb, class_dn)
 918         desc_sddl = self.get_desc_sddl(class_dn)
 919         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
 920         self.assertEqual(self.results[self.DS_BEHAVIOR]["135"], res)
 921
 922     def test_136(self):
 923         user_name = "testuser7"
 924         self.check_user_belongs(self.get_users_domain_dn(user_name), ["Domain 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.dacl_add_ace(self.schema_dn, mod)
 930         # Create example Schema class
 931         class_name = self.get_unique_schema_class_name()
 932         class_dn = "CN=%s,%s" % (class_name, self.schema_dn)
 933         self.create_schema_class(_ldb, class_dn)
 934         desc_sddl = self.get_desc_sddl(class_dn)
 935         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
 936         self.assertEqual(self.results[self.DS_BEHAVIOR]["136"], res)
 937
 938     def test_137(self):
 939         user_name = "testuser8"
 940         self.check_user_belongs(self.get_users_domain_dn(user_name), ["Enterprise Admins", "Schema Admins"])
 941         # Open Ldb connection with the tested user
 942         _ldb = self.get_ldb_connection(user_name, "samba123@")
 943         # Change Schema partition descriptor
 944         mod = "(A;;CC;;;AU)"
 945         self.dacl_add_ace(self.schema_dn, mod)
 946         # Create example Schema class
 947         class_name = self.get_unique_schema_class_name()
 948         class_dn = "CN=%s,%s" % (class_name, self.schema_dn)
 949         self.create_schema_class(_ldb, class_dn)
 950         desc_sddl = self.get_desc_sddl(class_dn)
 951         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
 952         self.assertEqual(self.results[self.DS_BEHAVIOR]["137"], res)
 953
 954     # Custom descriptor tests ##################################################################
 955
 956     def test_138(self):
 957         user_name = "testuser1"
 958         self.check_user_belongs(self.get_users_domain_dn(user_name), ["Enterprise Admins"])
 959         # Open Ldb connection with the tested user
 960         _ldb = self.get_ldb_connection(user_name, "samba123@")
 961         # Change Schema partition descriptor
 962         mod = "(A;;CC;;;AU)"
 963         self.dacl_add_ace(self.schema_dn, mod)
 964         # Create a custom security descriptor
 965         desc_sddl = "O:DAG:DAD:(A;;RP;;;DU)"
 966         # Create example Schema class
 967         class_name = self.get_unique_schema_class_name()
 968         class_dn = "CN=%s,%s" % (class_name, self.schema_dn)
 969         self.create_schema_class(_ldb, class_dn, desc_sddl)
 970         desc_sddl = self.get_desc_sddl(class_dn)
 971         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
 972         self.assertEqual("O:DAG:DA", res)
 973
 974     def test_139(self):
 975         user_name = "testuser2"
 976         self.check_user_belongs(self.get_users_domain_dn(user_name), ["Domain Admins"])
 977         # Open Ldb connection with the tested user
 978         _ldb = self.get_ldb_connection(user_name, "samba123@")
 979         # Change Schema partition descriptor
 980         mod = "(A;;CC;;;AU)"
 981         self.dacl_add_ace(self.schema_dn, mod)
 982         # Create a custom security descriptor
 983         desc_sddl = "O:DAG:DAD:(A;;RP;;;DU)"
 984         # Create example Schema class
 985         class_name = self.get_unique_schema_class_name()
 986         class_dn = "CN=%s,%s" % (class_name, self.schema_dn)
 987         self.create_schema_class(_ldb, class_dn, desc_sddl)
 988         desc_sddl = self.get_desc_sddl(class_dn)
 989         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
 990         self.assertEqual("O:DAG:DA", res)
 991
 992     def test_140(self):
 993         user_name = "testuser3"
 994         self.check_user_belongs(self.get_users_domain_dn(user_name), ["Schema Admins"])
 995         # Open Ldb connection with the tested user
 996         _ldb = self.get_ldb_connection(user_name, "samba123@")
 997         # Create a custom security descriptor
 998         # NB! Problematic owner part won't accept DA only <User Sid> !!!
 999         user_sid = self.get_object_sid( self.get_users_domain_dn(user_name) )
1000         desc_sddl = "O:%sG:DAD:(A;;RP;;;DU)" % str(user_sid)
1001         # Create example Schema class
1002         class_name = self.get_unique_schema_class_name()
1003         class_dn = "CN=%s,%s" % (class_name, self.schema_dn)
1004         self.create_schema_class(_ldb, class_dn, desc_sddl)
1005         desc_sddl = self.get_desc_sddl(class_dn)
1006         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
1007         self.assertEqual(self.results[self.DS_BEHAVIOR]["140"] % str(user_sid), res)
1008
1009     def test_141(self):
1010         user_name = "testuser4"
1011         self.check_user_belongs(self.get_users_domain_dn(user_name), [])
1012         # Open Ldb connection with the tested user
1013         _ldb = self.get_ldb_connection(user_name, "samba123@")
1014         # Create a custom security descriptor
1015         # NB! Problematic owner part won't accept DA only <User Sid> !!!
1016         user_sid = self.get_object_sid( self.get_users_domain_dn(user_name) )
1017         desc_sddl = "O:%sG:DAD:(A;;RP;;;DU)" % str(user_sid)
1018         # Create example Schema class
1019         class_name = self.get_unique_schema_class_name()
1020         class_dn = "CN=%s,%s" % (class_name, self.schema_dn)
1021         self.create_schema_class(_ldb, class_dn, desc_sddl)
1022         desc_sddl = self.get_desc_sddl(class_dn)
1023         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
1024         self.assertEqual(self.results[self.DS_BEHAVIOR]["141"] % str(user_sid), res)
1025
1026     def test_142(self):
1027         user_name = "testuser5"
1028         self.check_user_belongs(self.get_users_domain_dn(user_name), ["Enterprise Admins", "Domain Admins"])
1029         # Open Ldb connection with the tested user
1030         _ldb = self.get_ldb_connection(user_name, "samba123@")
1031         # Change Schema partition descriptor
1032         mod = "(A;;CC;;;AU)"
1033         self.dacl_add_ace(self.schema_dn, mod)
1034         # Create a custom security descriptor
1035         desc_sddl = "O:DAG:DAD:(A;;RP;;;DU)"
1036         # Create example Schema class
1037         class_name = self.get_unique_schema_class_name()
1038         class_dn = "CN=%s,%s" % (class_name, self.schema_dn)
1039         self.create_schema_class(_ldb, class_dn, desc_sddl)
1040         desc_sddl = self.get_desc_sddl(class_dn)
1041         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
1042         self.assertEqual("O:DAG:DA", res)
1043
1044     def test_143(self):
1045         user_name = "testuser6"
1046         self.check_user_belongs(self.get_users_domain_dn(user_name), ["Enterprise Admins", "Domain Admins", "Schema Admins"])
1047         # Open Ldb connection with the tested user
1048         _ldb = self.get_ldb_connection(user_name, "samba123@")
1049         # Change Schema partition descriptor
1050         mod = "(A;;CC;;;AU)"
1051         self.dacl_add_ace(self.schema_dn, mod)
1052         # Create a custom security descriptor
1053         desc_sddl = "O:DAG:DAD:(A;;RP;;;DU)"
1054         # Create example Schema class
1055         class_name = self.get_unique_schema_class_name()
1056         class_dn = "CN=%s,%s" % (class_name, self.schema_dn)
1057         self.create_schema_class(_ldb, class_dn, desc_sddl)
1058         desc_sddl = self.get_desc_sddl(class_dn)
1059         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
1060         self.assertEqual("O:DAG:DA", res)
1061
1062     def test_144(self):
1063         user_name = "testuser7"
1064         self.check_user_belongs(self.get_users_domain_dn(user_name), ["Domain Admins", "Schema Admins"])
1065         # Open Ldb connection with the tested user
1066         _ldb = self.get_ldb_connection(user_name, "samba123@")
1067         # Change Schema partition descriptor
1068         mod = "(A;;CC;;;AU)"
1069         self.dacl_add_ace(self.schema_dn, mod)
1070         # Create a custom security descriptor
1071         desc_sddl = "O:DAG:DAD:(A;;RP;;;DU)"
1072         # Create example Schema class
1073         class_name = self.get_unique_schema_class_name()
1074         class_dn = "CN=%s,%s" % (class_name, self.schema_dn)
1075         self.create_schema_class(_ldb, class_dn, desc_sddl)
1076         desc_sddl = self.get_desc_sddl(class_dn)
1077         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
1078         self.assertEqual("O:DAG:DA", res)
1079
1080     def test_145(self):
1081         user_name = "testuser8"
1082         self.check_user_belongs(self.get_users_domain_dn(user_name), ["Enterprise Admins", "Schema Admins"])
1083         # Open Ldb connection with the tested user
1084         _ldb = self.get_ldb_connection(user_name, "samba123@")
1085         # Change Schema partition descriptor
1086         mod = "(A;;CC;;;AU)"
1087         self.dacl_add_ace(self.schema_dn, mod)
1088         # Create a custom security descriptor
1089         desc_sddl = "O:DAG:DAD:(A;;RP;;;DU)"
1090         # Create example Schema class
1091         class_name = self.get_unique_schema_class_name()
1092         class_dn = "CN=%s,%s" % (class_name, self.schema_dn)
1093         self.create_schema_class(_ldb, class_dn, desc_sddl)
1094         desc_sddl = self.get_desc_sddl(class_dn)
1095         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
1096         self.assertEqual("O:DAG:DA", res)
1097
1098     ## Tests for CONFIGURATION
1099
1100     # Defalt descriptor tests ##################################################################
1101
1102     def test_160(self):
1103         user_name = "testuser1"
1104         self.check_user_belongs(self.get_users_domain_dn(user_name), ["Enterprise Admins"])
1105         # Open Ldb connection with the tested user
1106         _ldb = self.get_ldb_connection(user_name, "samba123@")
1107         # Create example Configuration container
1108         container_name = "test-container1"
1109         object_dn = "CN=%s,CN=DisplaySpecifiers,%s" % (container_name, self.configuration_dn)
1110         self.delete_force(self.ldb_admin, object_dn)
1111         self.create_configuration_container(_ldb, object_dn, )
1112         desc_sddl = self.get_desc_sddl(object_dn)
1113         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
1114         self.assertEqual(self.results[self.DS_BEHAVIOR]["160"], res)
1115
1116     def test_161(self):
1117         user_name = "testuser2"
1118         self.check_user_belongs(self.get_users_domain_dn(user_name), ["Domain Admins"])
1119         # Open Ldb connection with the tested user
1120         _ldb = self.get_ldb_connection(user_name, "samba123@")
1121         # Create example Configuration container
1122         container_name = "test-container1"
1123         object_dn = "CN=%s,CN=DisplaySpecifiers,%s" % (container_name, self.configuration_dn)
1124         self.delete_force(self.ldb_admin, object_dn)
1125         self.create_configuration_container(_ldb, object_dn, )
1126         desc_sddl = self.get_desc_sddl(object_dn)
1127         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
1128         self.assertEqual(self.results[self.DS_BEHAVIOR]["161"], res)
1129
1130     def test_162(self):
1131         user_name = "testuser3"
1132         self.check_user_belongs(self.get_users_domain_dn(user_name), ["Schema Admins"])
1133         # Open Ldb connection with the tested user
1134         _ldb = self.get_ldb_connection(user_name, "samba123@")
1135         # Create example Configuration container
1136         object_dn = "CN=test-container1,CN=DisplaySpecifiers," + self.configuration_dn
1137         self.delete_force(self.ldb_admin, object_dn)
1138         self.create_configuration_container(self.ldb_admin, object_dn, )
1139         user_sid = self.get_object_sid( self.get_users_domain_dn(user_name) )
1140         mod = "(A;;CC;;;AU)"
1141         self.dacl_add_ace(object_dn, mod)
1142         # Create child object with user's credentials
1143         object_dn = "CN=test-specifier1," + object_dn
1144         self.delete_force(self.ldb_admin, object_dn)
1145         self.create_configuration_specifier(_ldb, object_dn)
1146         desc_sddl = self.get_desc_sddl(object_dn)
1147         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
1148         self.assertEqual(self.results[self.DS_BEHAVIOR]["162"] % str(user_sid), res)
1149
1150     def test_163(self):
1151         user_name = "testuser4"
1152         self.check_user_belongs(self.get_users_domain_dn(user_name), [])
1153         # Open Ldb connection with the tested user
1154         _ldb = self.get_ldb_connection(user_name, "samba123@")
1155         # Create example Configuration container
1156         object_dn = "CN=test-container1,CN=DisplaySpecifiers," + self.configuration_dn
1157         self.delete_force(self.ldb_admin, object_dn)
1158         self.create_configuration_container(self.ldb_admin, object_dn, )
1159         user_sid = self.get_object_sid( self.get_users_domain_dn(user_name) )
1160         mod = "(A;;CC;;;AU)"
1161         self.dacl_add_ace(object_dn, mod)
1162         # Create child object with user's credentials
1163         object_dn = "CN=test-specifier1," + object_dn
1164         self.delete_force(self.ldb_admin, object_dn)
1165         self.create_configuration_specifier(_ldb, object_dn)
1166         desc_sddl = self.get_desc_sddl(object_dn)
1167         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
1168         self.assertEqual(self.results[self.DS_BEHAVIOR]["163"] % str(user_sid), res)
1169
1170     def test_164(self):
1171         user_name = "testuser5"
1172         self.check_user_belongs(self.get_users_domain_dn(user_name), ["Enterprise Admins", "Domain 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         self.delete_force(self.ldb_admin, object_dn)
1179         self.create_configuration_container(_ldb, object_dn, )
1180         desc_sddl = self.get_desc_sddl(object_dn)
1181         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
1182         self.assertEqual(self.results[self.DS_BEHAVIOR]["164"], res)
1183
1184     def test_165(self):
1185         user_name = "testuser6"
1186         self.check_user_belongs(self.get_users_domain_dn(user_name), ["Enterprise Admins", "Domain Admins", "Schema Admins"])
1187         # Open Ldb connection with the tested user
1188         _ldb = self.get_ldb_connection(user_name, "samba123@")
1189         # Create example Configuration container
1190         container_name = "test-container1"
1191         object_dn = "CN=%s,CN=DisplaySpecifiers,%s" % (container_name, self.configuration_dn)
1192         self.delete_force(self.ldb_admin, object_dn)
1193         self.create_configuration_container(_ldb, object_dn, )
1194         desc_sddl = self.get_desc_sddl(object_dn)
1195         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
1196         self.assertEqual(self.results[self.DS_BEHAVIOR]["165"], res)
1197
1198     def test_166(self):
1199         user_name = "testuser7"
1200         self.check_user_belongs(self.get_users_domain_dn(user_name), ["Domain Admins", "Schema Admins"])
1201         # Open Ldb connection with the tested user
1202         _ldb = self.get_ldb_connection(user_name, "samba123@")
1203         # Create example Configuration container
1204         container_name = "test-container1"
1205         object_dn = "CN=%s,CN=DisplaySpecifiers,%s" % (container_name, self.configuration_dn)
1206         self.delete_force(self.ldb_admin, object_dn)
1207         self.create_configuration_container(_ldb, object_dn, )
1208         desc_sddl = self.get_desc_sddl(object_dn)
1209         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
1210         self.assertEqual(self.results[self.DS_BEHAVIOR]["166"], res)
1211
1212     def test_167(self):
1213         user_name = "testuser8"
1214         self.check_user_belongs(self.get_users_domain_dn(user_name), ["Enterprise Admins", "Schema Admins"])
1215         # Open Ldb connection with the tested user
1216         _ldb = self.get_ldb_connection(user_name, "samba123@")
1217         # Create example Configuration container
1218         container_name = "test-container1"
1219         object_dn = "CN=%s,CN=DisplaySpecifiers,%s" % (container_name, self.configuration_dn)
1220         self.delete_force(self.ldb_admin, object_dn)
1221         self.create_configuration_container(_ldb, object_dn, )
1222         desc_sddl = self.get_desc_sddl(object_dn)
1223         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
1224         self.assertEqual(self.results[self.DS_BEHAVIOR]["167"], res)
1225
1226     # Custom descriptor tests ##################################################################
1227
1228     def test_168(self):
1229         user_name = "testuser1"
1230         self.check_user_belongs(self.get_users_domain_dn(user_name), ["Enterprise Admins"])
1231         # Open Ldb connection with the tested user
1232         _ldb = self.get_ldb_connection(user_name, "samba123@")
1233         # Create example Configuration container
1234         container_name = "test-container1"
1235         object_dn = "CN=%s,CN=DisplaySpecifiers,%s" % (container_name, self.configuration_dn)
1236         self.delete_force(self.ldb_admin, object_dn)
1237         # Create a custom security descriptor
1238         desc_sddl = "O:DAG:DAD:(A;;RP;;;DU)"
1239         self.create_configuration_container(_ldb, object_dn, desc_sddl)
1240         desc_sddl = self.get_desc_sddl(object_dn)
1241         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
1242         self.assertEqual("O:DAG:DA", res)
1243
1244     def test_169(self):
1245         user_name = "testuser2"
1246         self.check_user_belongs(self.get_users_domain_dn(user_name), ["Domain Admins"])
1247         # Open Ldb connection with the tested user
1248         _ldb = self.get_ldb_connection(user_name, "samba123@")
1249         # Create example Configuration container
1250         container_name = "test-container1"
1251         object_dn = "CN=%s,CN=DisplaySpecifiers,%s" % (container_name, self.configuration_dn)
1252         self.delete_force(self.ldb_admin, object_dn)
1253         # Create a custom security descriptor
1254         desc_sddl = "O:DAG:DAD:(A;;RP;;;DU)"
1255         self.create_configuration_container(_ldb, object_dn, desc_sddl)
1256         desc_sddl = self.get_desc_sddl(object_dn)
1257         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
1258         self.assertEqual("O:DAG:DA", res)
1259
1260     def test_170(self):
1261         user_name = "testuser3"
1262         self.check_user_belongs(self.get_users_domain_dn(user_name), ["Schema Admins"])
1263         # Open Ldb connection with the tested user
1264         _ldb = self.get_ldb_connection(user_name, "samba123@")
1265         # Create example Configuration container
1266         object_dn = "CN=test-container1,CN=DisplaySpecifiers," + self.configuration_dn
1267         self.delete_force(self.ldb_admin, object_dn)
1268         self.create_configuration_container(self.ldb_admin, object_dn, )
1269         user_sid = self.get_object_sid( self.get_users_domain_dn(user_name) )
1270         mod = "(A;;CC;;;AU)"
1271         self.dacl_add_ace(object_dn, mod)
1272         # Create child object with user's credentials
1273         object_dn = "CN=test-specifier1," + object_dn
1274         self.delete_force(self.ldb_admin, object_dn)
1275         # Create a custom security descriptor
1276         # NB! Problematic owner part won't accept DA only <User Sid> !!!
1277         desc_sddl = "O:%sG:DAD:(A;;RP;;;DU)" % str(user_sid)
1278         self.create_configuration_specifier(_ldb, object_dn, desc_sddl)
1279         desc_sddl = self.get_desc_sddl(object_dn)
1280         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
1281         self.assertEqual(self.results[self.DS_BEHAVIOR]["170"] % str(user_sid), res)
1282
1283     def test_171(self):
1284         user_name = "testuser4"
1285         self.check_user_belongs(self.get_users_domain_dn(user_name), [])
1286         # Open Ldb connection with the tested user
1287         _ldb = self.get_ldb_connection(user_name, "samba123@")
1288         # Create example Configuration container
1289         object_dn = "CN=test-container1,CN=DisplaySpecifiers," + self.configuration_dn
1290         self.delete_force(self.ldb_admin, object_dn)
1291         self.create_configuration_container(self.ldb_admin, object_dn, )
1292         user_sid = self.get_object_sid( self.get_users_domain_dn(user_name) )
1293         mod = "(A;;CC;;;AU)"
1294         self.dacl_add_ace(object_dn, mod)
1295         # Create child object with user's credentials
1296         object_dn = "CN=test-specifier1," + object_dn
1297         self.delete_force(self.ldb_admin, object_dn)
1298         # Create a custom security descriptor
1299         # NB! Problematic owner part won't accept DA only <User Sid> !!!
1300         desc_sddl = "O:%sG:DAD:(A;;RP;;;DU)" % str(user_sid)
1301         self.create_configuration_specifier(_ldb, object_dn, desc_sddl)
1302         desc_sddl = self.get_desc_sddl(object_dn)
1303         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
1304         self.assertEqual(self.results[self.DS_BEHAVIOR]["171"] % str(user_sid), res)
1305
1306     def test_172(self):
1307         user_name = "testuser5"
1308         self.check_user_belongs(self.get_users_domain_dn(user_name), ["Enterprise Admins", "Domain Admins"])
1309         # Open Ldb connection with the tested user
1310         _ldb = self.get_ldb_connection(user_name, "samba123@")
1311         # Create example Configuration container
1312         container_name = "test-container1"
1313         object_dn = "CN=%s,CN=DisplaySpecifiers,%s" % (container_name, self.configuration_dn)
1314         self.delete_force(self.ldb_admin, object_dn)
1315         # Create a custom security descriptor
1316         desc_sddl = "O:DAG:DAD:(A;;RP;;;DU)"
1317         self.create_configuration_container(_ldb, object_dn, desc_sddl)
1318         desc_sddl = self.get_desc_sddl(object_dn)
1319         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
1320         self.assertEqual("O:DAG:DA", res)
1321
1322     def test_173(self):
1323         user_name = "testuser6"
1324         self.check_user_belongs(self.get_users_domain_dn(user_name), ["Enterprise Admins", "Domain Admins", "Schema Admins"])
1325         # Open Ldb connection with the tested user
1326         _ldb = self.get_ldb_connection(user_name, "samba123@")
1327         # Create example Configuration container
1328         container_name = "test-container1"
1329         object_dn = "CN=%s,CN=DisplaySpecifiers,%s" % (container_name, self.configuration_dn)
1330         self.delete_force(self.ldb_admin, object_dn)
1331         # Create a custom security descriptor
1332         desc_sddl = "O:DAG:DAD:(A;;RP;;;DU)"
1333         self.create_configuration_container(_ldb, object_dn, desc_sddl)
1334         desc_sddl = self.get_desc_sddl(object_dn)
1335         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
1336         self.assertEqual("O:DAG:DA", res)
1337
1338     def test_174(self):
1339         user_name = "testuser7"
1340         self.check_user_belongs(self.get_users_domain_dn(user_name), ["Domain Admins", "Schema Admins"])
1341         # Open Ldb connection with the tested user
1342         _ldb = self.get_ldb_connection(user_name, "samba123@")
1343         # Create example Configuration container
1344         container_name = "test-container1"
1345         object_dn = "CN=%s,CN=DisplaySpecifiers,%s" % (container_name, self.configuration_dn)
1346         self.delete_force(self.ldb_admin, object_dn)
1347         # Create a custom security descriptor
1348         desc_sddl = "O:DAG:DAD:(A;;RP;;;DU)"
1349         self.create_configuration_container(_ldb, object_dn, desc_sddl)
1350         desc_sddl = self.get_desc_sddl(object_dn)
1351         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
1352         self.assertEqual("O:DAG:DA", res)
1353
1354     def test_175(self):
1355         user_name = "testuser8"
1356         self.check_user_belongs(self.get_users_domain_dn(user_name), ["Enterprise Admins", "Schema Admins"])
1357         # Open Ldb connection with the tested user
1358         _ldb = self.get_ldb_connection(user_name, "samba123@")
1359         # Create example Configuration container
1360         container_name = "test-container1"
1361         object_dn = "CN=%s,CN=DisplaySpecifiers,%s" % (container_name, self.configuration_dn)
1362         self.delete_force(self.ldb_admin, object_dn)
1363         # Create a custom security descriptor
1364         desc_sddl = "O:DAG:DAD:(A;;RP;;;DU)"
1365         self.create_configuration_container(_ldb, object_dn, desc_sddl)
1366         desc_sddl = self.get_desc_sddl(object_dn)
1367         res = re.search("(O:.*G:.*?)D:", desc_sddl).group(1)
1368         self.assertEqual("O:DAG:DA", res)
1369
1370     ########################################################################################
1371     # Inharitance tests for DACL
1372
1373 class DaclDescriptorTests(DescriptorTests):
1374
1375     def setUp(self):
1376         DescriptorTests.setUp(self)
1377
1378     def tearDown(self):
1379         self.delete_force(self.ldb_admin, "CN=test_inherit_group,OU=test_inherit_ou," + self.base_dn)
1380         self.delete_force(self.ldb_admin, "OU=test_inherit_ou," + self.base_dn)
1381
1382     def create_clean_ou(self, object_dn):
1383         """ Base repeating setup for unittests to follow """
1384         res = self.ldb_admin.search(base=self.base_dn, scope=SCOPE_SUBTREE, \
1385                 expression="distinguishedName=%s" % object_dn)
1386         # Make sure top testing OU has been deleted before starting the test
1387         self.assertEqual(res, [])
1388         self.create_domain_ou(self.ldb_admin, object_dn)
1389         desc_sddl = self.get_desc_sddl(object_dn)
1390         # Make sutre there are inheritable ACEs initially
1391         self.assertTrue("CI" in desc_sddl or "OI" in desc_sddl)
1392         # Find and remove all inherit ACEs
1393         res = re.findall("\(.*?\)", desc_sddl)
1394         res = [x for x in res if ("CI" in x) or ("OI" in x)]
1395         for x in res:
1396             desc_sddl = desc_sddl.replace(x, "")
1397         # Add flag 'protected' in both DACL and SACL so no inherit ACEs
1398         # can propagate from above
1399         desc_sddl = desc_sddl.replace(":AI", ":AIP")
1400         self.modify_desc(object_dn, desc_sddl)
1401         # Verify all inheritable ACEs are gone
1402         desc_sddl = self.get_desc_sddl(object_dn)
1403         self.assertFalse("CI" in desc_sddl)
1404         self.assertFalse("OI" in desc_sddl)
1405
1406     def test_200(self):
1407         """ OU with protected flag and child group. See if the group has inherit ACEs.
1408         """
1409         ou_dn = "OU=test_inherit_ou," + self.base_dn
1410         group_dn = "CN=test_inherit_group," + ou_dn
1411         # Create inheritable-free OU
1412         self.create_clean_ou(ou_dn)
1413         # Create group child object
1414         self.create_domain_group(self.ldb_admin, group_dn)
1415         # Make sure created group object contains NO inherit ACEs
1416         desc_sddl = self.get_desc_sddl(group_dn)
1417         self.assertFalse("ID" in desc_sddl)
1418
1419     def test_201(self):
1420         """ OU with protected flag and no inherit ACEs, child group with custom descriptor.
1421             Verify group has custom and default ACEs only.
1422         """
1423         ou_dn = "OU=test_inherit_ou," + self.base_dn
1424         group_dn = "CN=test_inherit_group," + ou_dn
1425         # Create inheritable-free OU
1426         self.create_clean_ou(ou_dn)
1427         # Create group child object using custom security descriptor
1428         sddl = "O:AUG:AUD:AI(D;;WP;;;DU)"
1429         self.create_domain_group(self.ldb_admin, group_dn, sddl)
1430         # Make sure created group descriptor has NO additional ACEs
1431         desc_sddl = self.get_desc_sddl(group_dn)
1432         self.assertEqual(desc_sddl, sddl)
1433
1434     def test_202(self):
1435         """ OU with protected flag and add couple non-inheritable ACEs, child group.
1436             See if the group has any of the added ACEs.
1437         """
1438         ou_dn = "OU=test_inherit_ou," + self.base_dn
1439         group_dn = "CN=test_inherit_group," + ou_dn
1440         # Create inheritable-free OU
1441         self.create_clean_ou(ou_dn)
1442         # Add some custom non-inheritable ACEs
1443         mod = "(D;;WP;;;DU)(A;;RP;;;DU)"
1444         self.dacl_add_ace(ou_dn, mod)
1445         # Verify all inheritable ACEs are gone
1446         desc_sddl = self.get_desc_sddl(ou_dn)
1447         # Create group child object
1448         self.create_domain_group(self.ldb_admin, group_dn)
1449         # Make sure created group object contains NO inherit ACEs
1450         # also make sure the added above non-inheritable ACEs are absant too
1451         desc_sddl = self.get_desc_sddl(group_dn)
1452         self.assertFalse("ID" in desc_sddl)
1453         for x in re.findall("\(.*?\)", mod):
1454             self.assertFalse(x in desc_sddl)
1455
1456     def test_203(self):
1457         """ OU with protected flag and add 'CI' ACE, child group.
1458             See if the group has the added inherited ACE.
1459         """
1460         ou_dn = "OU=test_inherit_ou," + self.base_dn
1461         group_dn = "CN=test_inherit_group," + ou_dn
1462         # Create inheritable-free OU
1463         self.create_clean_ou(ou_dn)
1464         # Add some custom 'CI' ACE
1465         mod = "(D;CI;WP;;;DU)"
1466         self.dacl_add_ace(ou_dn, mod)
1467         desc_sddl = self.get_desc_sddl(ou_dn)
1468         # Create group child object
1469         self.create_domain_group(self.ldb_admin, group_dn, "O:AUG:AUD:AI(A;;CC;;;AU)")
1470         # Make sure created group object contains only the above inherited ACE
1471         # that we've added manually
1472         desc_sddl = self.get_desc_sddl(group_dn)
1473         mod = mod.replace(";CI;", ";CIID;")
1474         self.assertTrue(mod in desc_sddl)
1475
1476     def test_204(self):
1477         """ OU with protected flag and add 'OI' ACE, child group.
1478             See if the group has the added inherited ACE.
1479         """
1480         ou_dn = "OU=test_inherit_ou," + self.base_dn
1481         group_dn = "CN=test_inherit_group," + ou_dn
1482         # Create inheritable-free OU
1483         self.create_clean_ou(ou_dn)
1484         # Add some custom 'CI' ACE
1485         mod = "(D;OI;WP;;;DU)"
1486         self.dacl_add_ace(ou_dn, mod)
1487         desc_sddl = self.get_desc_sddl(ou_dn)
1488         # Create group child object
1489         self.create_domain_group(self.ldb_admin, group_dn, "O:AUG:AUD:AI(A;;CC;;;AU)")
1490         # Make sure created group object contains only the above inherited ACE
1491         # that we've added manually
1492         desc_sddl = self.get_desc_sddl(group_dn)
1493         mod = mod.replace(";OI;", ";OIIOID;") # change it how it's gonna look like
1494         self.assertTrue(mod in desc_sddl)
1495
1496     def test_205(self):
1497         """ OU with protected flag and add 'OA' for GUID & 'CI' ACE, child group.
1498             See if the group has the added inherited ACE.
1499         """
1500         ou_dn = "OU=test_inherit_ou," + self.base_dn
1501         group_dn = "CN=test_inherit_group," + ou_dn
1502         # Create inheritable-free OU
1503         self.create_clean_ou(ou_dn)
1504         # Add some custom 'OA' for 'name' attribute & 'CI' ACE
1505         mod = "(OA;CI;WP;bf967a0e-0de6-11d0-a285-00aa003049e2;;DU)"
1506         self.dacl_add_ace(ou_dn, mod)
1507         desc_sddl = self.get_desc_sddl(ou_dn)
1508         # Create group child object
1509         self.create_domain_group(self.ldb_admin, group_dn, "O:AUG:AUD:AI(A;;CC;;;AU)")
1510         # Make sure created group object contains only the above inherited ACE
1511         # that we've added manually
1512         desc_sddl = self.get_desc_sddl(group_dn)
1513         mod = mod.replace(";CI;", ";CIID;") # change it how it's gonna look like
1514         self.assertTrue(mod in desc_sddl)
1515
1516     def test_206(self):
1517         """ OU with protected flag and add 'OA' for GUID & 'OI' ACE, child group.
1518             See if the group has the added inherited ACE.
1519         """
1520         ou_dn = "OU=test_inherit_ou," + self.base_dn
1521         group_dn = "CN=test_inherit_group," + ou_dn
1522         # Create inheritable-free OU
1523         self.create_clean_ou(ou_dn)
1524         # Add some custom 'OA' for 'name' attribute & 'OI' ACE
1525         mod = "(OA;OI;WP;bf967a0e-0de6-11d0-a285-00aa003049e2;;DU)"
1526         self.dacl_add_ace(ou_dn, mod)
1527         desc_sddl = self.get_desc_sddl(ou_dn)
1528         # Create group child object
1529         self.create_domain_group(self.ldb_admin, group_dn, "O:AUG:AUD:AI(A;;CC;;;AU)")
1530         # Make sure created group object contains only the above inherited ACE
1531         # that we've added manually
1532         desc_sddl = self.get_desc_sddl(group_dn)
1533         mod = mod.replace(";OI;", ";OIIOID;") # change it how it's gonna look like
1534         self.assertTrue(mod in desc_sddl)
1535
1536     def test_207(self):
1537         """ OU with protected flag and add 'OA' for OU specific GUID & 'CI' ACE, child group.
1538             See if the group has the added inherited ACE.
1539         """
1540         ou_dn = "OU=test_inherit_ou," + self.base_dn
1541         group_dn = "CN=test_inherit_group," + ou_dn
1542         # Create inheritable-free OU
1543         self.create_clean_ou(ou_dn)
1544         # Add some custom 'OA' for 'st' attribute (OU specific) & 'CI' ACE
1545         mod = "(OA;CI;WP;bf967a39-0de6-11d0-a285-00aa003049e2;;DU)"
1546         self.dacl_add_ace(ou_dn, mod)
1547         desc_sddl = self.get_desc_sddl(ou_dn)
1548         # Create group child object
1549         self.create_domain_group(self.ldb_admin, group_dn, "O:AUG:AUD:AI(A;;CC;;;AU)")
1550         # Make sure created group object contains only the above inherited ACE
1551         # that we've added manually
1552         desc_sddl = self.get_desc_sddl(group_dn)
1553         mod = mod.replace(";CI;", ";CIID;") # change it how it's gonna look like
1554         self.assertTrue(mod in desc_sddl)
1555
1556     def test_208(self):
1557         """ OU with protected flag and add 'OA' for OU specific GUID & 'OI' ACE, child group.
1558             See if the group has the added inherited ACE.
1559         """
1560         ou_dn = "OU=test_inherit_ou," + self.base_dn
1561         group_dn = "CN=test_inherit_group," + ou_dn
1562         # Create inheritable-free OU
1563         self.create_clean_ou(ou_dn)
1564         # Add some custom 'OA' for 'st' attribute (OU specific) & 'OI' ACE
1565         mod = "(OA;OI;WP;bf967a39-0de6-11d0-a285-00aa003049e2;;DU)"
1566         self.dacl_add_ace(ou_dn, mod)
1567         desc_sddl = self.get_desc_sddl(ou_dn)
1568         # Create group child object
1569         self.create_domain_group(self.ldb_admin, group_dn, "O:AUG:AUD:AI(A;;CC;;;AU)")
1570         # Make sure created group object contains only the above inherited ACE
1571         # that we've added manually
1572         desc_sddl = self.get_desc_sddl(group_dn)
1573         mod = mod.replace(";OI;", ";OIIOID;") # change it how it's gonna look like
1574         self.assertTrue(mod in desc_sddl)
1575
1576     def test_209(self):
1577         """ OU with protected flag and add 'CI' ACE with 'CO' SID, child group.
1578             See if the group has the added inherited ACE.
1579         """
1580         ou_dn = "OU=test_inherit_ou," + self.base_dn
1581         group_dn = "CN=test_inherit_group," + ou_dn
1582         # Create inheritable-free OU
1583         self.create_clean_ou(ou_dn)
1584         # Add some custom 'CI' ACE
1585         mod = "(D;CI;WP;;;CO)"
1586         self.dacl_add_ace(ou_dn, mod)
1587         desc_sddl = self.get_desc_sddl(ou_dn)
1588         # Create group child object
1589         self.create_domain_group(self.ldb_admin, group_dn, "O:AUG:AUD:AI(A;;CC;;;AU)")
1590         # Make sure created group object contains only the above inherited ACE(s)
1591         # that we've added manually
1592         desc_sddl = self.get_desc_sddl(group_dn)
1593         #print desc_sddl
1594         self.assertTrue("(D;ID;WP;;;AU)" in desc_sddl)
1595         self.assertTrue("(D;CIIOID;WP;;;CO)" in desc_sddl)
1596
1597     ########################################################################################
1598
1599 if not "://" in host:
1600     host = "ldap://%s" % host
1601 ldb = Ldb(host, credentials=creds, session_info=system_session(), lp=lp, options=["modules:paged_searches"])
1602
1603 runner = SubunitTestRunner()
1604 rc = 0
1605 if not runner.run(unittest.makeSuite(OwnerGroupDescriptorTests)).wasSuccessful():
1606     rc = 1
1607 if not runner.run(unittest.makeSuite(DaclDescriptorTests)).wasSuccessful():
1608     rc = 1
1609
1610 sys.exit(rc)