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