Debian Codegraph @

source4/torture/drs/python/ridalloc_exop.py

raw
1 #!/usr/bin/env python3
2 # -*- coding: utf-8 -*-
3 #
4 # Tests various RID allocation scenarios
5 #
6 # Copyright (C) Kamen Mazdrashki <[email protected]> 2011
7 # Copyright (C) Andrew Bartlett <[email protected]> 2016
8 # Copyright (C) Catalyst IT Ltd. 2016
9 #
10 # This program is free software; you can redistribute it and/or modify
11 # it under the terms of the GNU General Public License as published by
12 # the Free Software Foundation; either version 3 of the License, or
13 # (at your option) any later version.
14 #
15 # This program is distributed in the hope that it will be useful,
16 # but WITHOUT ANY WARRANTY; without even the implied warranty of
17 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 # GNU General Public License for more details.
19 #
20 # You should have received a copy of the GNU General Public License
21 # along with this program. If not, see <http://www.gnu.org/licenses/>.
22 #
23
24 #
25 # Usage:
26 # export DC1=dc1_dns_name
27 # export DC2=dc2_dns_name
28 # export SUBUNITRUN=$samba4srcdir/scripting/bin/subunitrun
29 # PYTHONPATH="$PYTHONPATH:$samba4srcdir/torture/drs/python" $SUBUNITRUN ridalloc_exop -U"$DOMAIN/$DC_USERNAME"%"$DC_PASSWORD"
30 #
31
32 import drs_base
33
34 import ldb
35 from ldb import SCOPE_BASE
36
37 from samba.dcerpc import drsuapi, misc
38 from samba.samdb import SamDB
39
40 import shutil
41 import os
42 from samba.auth import system_session, admin_session
43 from samba.dbchecker import dbcheck
44 from samba.ndr import ndr_pack
45 from samba.dcerpc import security
46 from samba import drs_utils, dsdb
47
48
49 class DrsReplicaSyncTestCase(drs_base.DrsBaseTestCase):
50 """Intended as a semi-black box test case for DsGetNCChanges
51 implementation for extended operations. It should be testing
52 how DsGetNCChanges handles different input params (mostly invalid).
53 Final goal is to make DsGetNCChanges as binary compatible to
54 Windows implementation as possible"""
55
56 def setUp(self):
57 super(DrsReplicaSyncTestCase, self).setUp()
58
59 def tearDown(self):
60 super(DrsReplicaSyncTestCase, self).tearDown()
61
62 def _determine_fSMORoleOwner(self, fsmo_obj_dn):
63 """Returns (owner, not_owner) pair where:
64 owner: dns name for FSMO owner
65 not_owner: dns name for DC not owning the FSMO"""
66 # collect info to return later
67 fsmo_info_1 = {"dns_name": self.dnsname_dc1,
68 "invocation_id": self.ldb_dc1.get_invocation_id(),
69 "ntds_guid": self.ldb_dc1.get_ntds_GUID(),
70 "server_dn": self.ldb_dc1.get_serverName()}
71 fsmo_info_2 = {"dns_name": self.dnsname_dc2,
72 "invocation_id": self.ldb_dc2.get_invocation_id(),
73 "ntds_guid": self.ldb_dc2.get_ntds_GUID(),
74 "server_dn": self.ldb_dc2.get_serverName()}
75
76 msgs = self.ldb_dc1.search(scope=ldb.SCOPE_BASE, base=fsmo_info_1["server_dn"], attrs=["serverReference"])
77 fsmo_info_1["server_acct_dn"] = ldb.Dn(self.ldb_dc1, msgs[0]["serverReference"][0].decode('utf8'))
78 fsmo_info_1["rid_set_dn"] = ldb.Dn(self.ldb_dc1, "CN=RID Set") + fsmo_info_1["server_acct_dn"]
79
80 msgs = self.ldb_dc2.search(scope=ldb.SCOPE_BASE, base=fsmo_info_2["server_dn"], attrs=["serverReference"])
81 fsmo_info_2["server_acct_dn"] = ldb.Dn(self.ldb_dc2, msgs[0]["serverReference"][0].decode('utf8'))
82 fsmo_info_2["rid_set_dn"] = ldb.Dn(self.ldb_dc2, "CN=RID Set") + fsmo_info_2["server_acct_dn"]
83
84 # determine the owner dc
85 res = self.ldb_dc1.search(fsmo_obj_dn,
86 scope=SCOPE_BASE, attrs=["fSMORoleOwner"])
87 assert len(res) == 1, "Only one fSMORoleOwner value expected for %s!" % fsmo_obj_dn
88 fsmo_owner = res[0]["fSMORoleOwner"][0]
89 if fsmo_owner == self.info_dc1["dsServiceName"][0]:
90 return (fsmo_info_1, fsmo_info_2)
91 return (fsmo_info_2, fsmo_info_1)
92
93 def _check_exop_failed(self, ctr6, expected_failure):
94 self.assertEqual(ctr6.extended_ret, expected_failure)
95 #self.assertEqual(ctr6.object_count, 0)
96 #self.assertEqual(ctr6.first_object, None)
97 self.assertEqual(ctr6.more_data, False)
98 self.assertEqual(ctr6.nc_object_count, 0)
99 self.assertEqual(ctr6.nc_linked_attributes_count, 0)
100 self.assertEqual(ctr6.linked_attributes_count, 0)
101 self.assertEqual(ctr6.linked_attributes, [])
102 self.assertEqual(ctr6.drs_error[0], 0)
103
104 def test_InvalidDestDSA_ridalloc(self):
105 """Test RID allocation with invalid destination DSA guid"""
106 fsmo_dn = ldb.Dn(self.ldb_dc1, "CN=RID Manager$,CN=System," + self.ldb_dc1.domain_dn())
107 (fsmo_owner, fsmo_not_owner) = self._determine_fSMORoleOwner(fsmo_dn)
108
109 req8 = self._exop_req8(dest_dsa="9c637462-5b8c-4467-aef2-bdb1f57bc4ef",
110 invocation_id=fsmo_owner["invocation_id"],
111 nc_dn_str=fsmo_dn,
112 exop=drsuapi.DRSUAPI_EXOP_FSMO_RID_ALLOC)
113
114 (drs, drs_handle) = self._ds_bind(fsmo_owner["dns_name"])
115 (level, ctr) = drs.DsGetNCChanges(drs_handle, 8, req8)
116 self.assertEqual(level, 6, "Expected level 6 response!")
117 self._check_exop_failed(ctr, drsuapi.DRSUAPI_EXOP_ERR_UNKNOWN_CALLER)
118 self.assertEqual(ctr.source_dsa_guid, misc.GUID(fsmo_owner["ntds_guid"]))
119 self.assertEqual(ctr.source_dsa_invocation_id, misc.GUID(fsmo_owner["invocation_id"]))
120
121 def test_do_ridalloc(self):
122 """Test doing a RID allocation with a valid destination DSA guid"""
123 fsmo_dn = ldb.Dn(self.ldb_dc1, "CN=RID Manager$,CN=System," + self.ldb_dc1.domain_dn())
124 (fsmo_owner, fsmo_not_owner) = self._determine_fSMORoleOwner(fsmo_dn)
125
126 req8 = self._exop_req8(dest_dsa=fsmo_not_owner["ntds_guid"],
127 invocation_id=fsmo_owner["invocation_id"],
128 nc_dn_str=fsmo_dn,
129 exop=drsuapi.DRSUAPI_EXOP_FSMO_RID_ALLOC)
130
131 (drs, drs_handle) = self._ds_bind(fsmo_owner["dns_name"])
132 (level, ctr) = drs.DsGetNCChanges(drs_handle, 8, req8)
133 self.assertEqual(level, 6, "Expected level 6 response!")
134 self.assertEqual(ctr.source_dsa_guid, misc.GUID(fsmo_owner["ntds_guid"]))
135 self.assertEqual(ctr.source_dsa_invocation_id, misc.GUID(fsmo_owner["invocation_id"]))
136 ctr6 = ctr
137 self.assertEqual(ctr6.extended_ret, drsuapi.DRSUAPI_EXOP_ERR_SUCCESS)
138 self.assertEqual(ctr6.object_count, 3)
139 self.assertNotEqual(ctr6.first_object, None)
140 self.assertEqual(ldb.Dn(self.ldb_dc1, ctr6.first_object.object.identifier.dn), fsmo_dn)
141 self.assertNotEqual(ctr6.first_object.next_object, None)
142 self.assertNotEqual(ctr6.first_object.next_object.next_object, None)
143 second_object = ctr6.first_object.next_object.object
144 self.assertEqual(ldb.Dn(self.ldb_dc1, second_object.identifier.dn), fsmo_not_owner["rid_set_dn"])
145 third_object = ctr6.first_object.next_object.next_object.object
146 self.assertEqual(ldb.Dn(self.ldb_dc1, third_object.identifier.dn), fsmo_not_owner["server_acct_dn"])
147
148 self.assertEqual(ctr6.more_data, False)
149 self.assertEqual(ctr6.nc_object_count, 0)
150 self.assertEqual(ctr6.nc_linked_attributes_count, 0)
151 self.assertEqual(ctr6.drs_error[0], 0)
152 # We don't check the linked_attributes_count as if the domain
153 # has an RODC, it can gain links on the server account object
154
155 def test_do_ridalloc_get_anc(self):
156 """Test doing a RID allocation with a valid destination DSA guid and GET_ANC flag"""
157 fsmo_dn = ldb.Dn(self.ldb_dc1, "CN=RID Manager$,CN=System," + self.ldb_dc1.domain_dn())
158 (fsmo_owner, fsmo_not_owner) = self._determine_fSMORoleOwner(fsmo_dn)
159
160 req8 = self._exop_req8(dest_dsa=fsmo_not_owner["ntds_guid"],
161 invocation_id=fsmo_owner["invocation_id"],
162 nc_dn_str=fsmo_dn,
163 exop=drsuapi.DRSUAPI_EXOP_FSMO_RID_ALLOC,
164 replica_flags=drsuapi.DRSUAPI_DRS_GET_ANC)
165
166 (drs, drs_handle) = self._ds_bind(fsmo_owner["dns_name"])
167 (level, ctr) = drs.DsGetNCChanges(drs_handle, 8, req8)
168 self.assertEqual(level, 6, "Expected level 6 response!")
169 self.assertEqual(ctr.source_dsa_guid, misc.GUID(fsmo_owner["ntds_guid"]))
170 self.assertEqual(ctr.source_dsa_invocation_id, misc.GUID(fsmo_owner["invocation_id"]))
171 ctr6 = ctr
172 self.assertEqual(ctr6.extended_ret, drsuapi.DRSUAPI_EXOP_ERR_SUCCESS)
173 self.assertEqual(ctr6.object_count, 3)
174 self.assertNotEqual(ctr6.first_object, None)
175 self.assertEqual(ldb.Dn(self.ldb_dc1, ctr6.first_object.object.identifier.dn), fsmo_dn)
176 self.assertNotEqual(ctr6.first_object.next_object, None)
177 self.assertNotEqual(ctr6.first_object.next_object.next_object, None)
178 second_object = ctr6.first_object.next_object.object
179 self.assertEqual(ldb.Dn(self.ldb_dc1, second_object.identifier.dn), fsmo_not_owner["rid_set_dn"])
180 third_object = ctr6.first_object.next_object.next_object.object
181 self.assertEqual(ldb.Dn(self.ldb_dc1, third_object.identifier.dn), fsmo_not_owner["server_acct_dn"])
182 self.assertEqual(ctr6.more_data, False)
183 self.assertEqual(ctr6.nc_object_count, 0)
184 self.assertEqual(ctr6.nc_linked_attributes_count, 0)
185 self.assertEqual(ctr6.drs_error[0], 0)
186 # We don't check the linked_attributes_count as if the domain
187 # has an RODC, it can gain links on the server account object
188
189 def test_edit_rid_master(self):
190 """Test doing a RID allocation after changing the RID master from the original one.
191 This should set rIDNextRID to 0 on the new RID master."""
192 # 1. a. Transfer role to non-RID master
193 # b. Check that it succeeds correctly
194 #
195 # 2. a. Call the RID alloc against the former master.
196 # b. Check that it succeeds.
197 fsmo_dn = ldb.Dn(self.ldb_dc1, "CN=RID Manager$,CN=System," + self.ldb_dc1.domain_dn())
198 (fsmo_owner, fsmo_not_owner) = self._determine_fSMORoleOwner(fsmo_dn)
199
200 # 1. Swap RID master role
201 m = ldb.Message()
202 m.dn = ldb.Dn(self.ldb_dc1, "")
203 m["becomeRidMaster"] = ldb.MessageElement("1", ldb.FLAG_MOD_REPLACE,
204 "becomeRidMaster")
205
206 # Make sure that ldb_dc1 == RID Master
207
208 server_dn = str(ldb.Dn(self.ldb_dc1, self.ldb_dc1.get_dsServiceName()).parent())
209
210 # self.ldb_dc1 == LOCALDC
211 if server_dn == fsmo_owner['server_dn']:
212 # ldb_dc1 == VAMPIREDC
213 ldb_dc1, ldb_dc2 = self.ldb_dc2, self.ldb_dc1
214 else:
215 # Otherwise switch the two
216 ldb_dc1, ldb_dc2 = self.ldb_dc1, self.ldb_dc2
217
218 try:
219 # ldb_dc1 is now RID MASTER (as VAMPIREDC)
220 ldb_dc1.modify(m)
221 except ldb.LdbError as e1:
222 (num, msg) = e1.args
223 self.fail("Failed to reassign RID Master " + msg)
224
225 try:
226 # 2. Perform a RID alloc
227 req8 = self._exop_req8(dest_dsa=fsmo_owner["ntds_guid"],
228 invocation_id=fsmo_not_owner["invocation_id"],
229 nc_dn_str=fsmo_dn,
230 exop=drsuapi.DRSUAPI_EXOP_FSMO_RID_ALLOC)
231
232 (drs, drs_handle) = self._ds_bind(fsmo_not_owner["dns_name"])
233 # 3. Make sure the allocation succeeds
234 try:
235 (level, ctr) = drs.DsGetNCChanges(drs_handle, 8, req8)
236 except RuntimeError as e:
237 self.fail("RID allocation failed: " + str(e))
238
239 fsmo_dn = ldb.Dn(self.ldb_dc1, "CN=RID Manager$,CN=System," + self.ldb_dc1.domain_dn())
240
241 self.assertEqual(level, 6, "Expected level 6 response!")
242 self.assertEqual(ctr.source_dsa_guid, misc.GUID(fsmo_not_owner["ntds_guid"]))
243 self.assertEqual(ctr.source_dsa_invocation_id, misc.GUID(fsmo_not_owner["invocation_id"]))
244 ctr6 = ctr
245 self.assertEqual(ctr6.extended_ret, drsuapi.DRSUAPI_EXOP_ERR_SUCCESS)
246 self.assertEqual(ctr6.object_count, 3)
247 self.assertNotEqual(ctr6.first_object, None)
248 self.assertEqual(ldb.Dn(ldb_dc2, ctr6.first_object.object.identifier.dn), fsmo_dn)
249 self.assertNotEqual(ctr6.first_object.next_object, None)
250 self.assertNotEqual(ctr6.first_object.next_object.next_object, None)
251 second_object = ctr6.first_object.next_object.object
252 self.assertEqual(ldb.Dn(self.ldb_dc1, second_object.identifier.dn), fsmo_owner["rid_set_dn"])
253 third_object = ctr6.first_object.next_object.next_object.object
254 self.assertEqual(ldb.Dn(self.ldb_dc1, third_object.identifier.dn), fsmo_owner["server_acct_dn"])
255 finally:
256 # Swap the RID master back for other tests
257 m = ldb.Message()
258 m.dn = ldb.Dn(ldb_dc2, "")
259 m["becomeRidMaster"] = ldb.MessageElement("1", ldb.FLAG_MOD_REPLACE, "becomeRidMaster")
260 try:
261 ldb_dc2.modify(m)
262 except ldb.LdbError as e:
263 (num, msg) = e.args
264 self.fail("Failed to restore RID Master " + msg)
265
266 def test_offline_samba_tool_seized_ridalloc(self):
267 """Perform a join against the non-RID manager and then seize the RID Manager role"""
268
269 fsmo_dn = ldb.Dn(self.ldb_dc1, "CN=RID Manager$,CN=System," + self.ldb_dc1.domain_dn())
270 (fsmo_owner, fsmo_not_owner) = self._determine_fSMORoleOwner(fsmo_dn)
271
272 targetdir = self._test_join(fsmo_not_owner['dns_name'], "RIDALLOCTEST1")
273 try:
274 # Connect to the database
275 ldb_url = "tdb://%s" % os.path.join(targetdir, "private/sam.ldb")
276 smbconf = os.path.join(targetdir, "etc/smb.conf")
277
278 lp = self.get_loadparm()
279 new_ldb = SamDB(ldb_url, credentials=self.get_credentials(),
280 session_info=system_session(lp), lp=lp)
281
282 # 1. Get server name
283 res = new_ldb.search(base=ldb.Dn(new_ldb, new_ldb.get_serverName()),
284 scope=ldb.SCOPE_BASE, attrs=["serverReference"])
285 # 2. Get server reference
286 server_ref_dn = ldb.Dn(new_ldb, res[0]['serverReference'][0].decode('utf8'))
287
288 # Assert that no RID Set has been set
289 res = new_ldb.search(base=server_ref_dn,
290 scope=ldb.SCOPE_BASE, attrs=['rIDSetReferences'])
291
292 self.assertFalse("rIDSetReferences" in res[0])
293
294 (result, out, err) = self.runsubcmd("fsmo", "seize", "--role", "rid", "-H", ldb_url, "--configfile=%s" % (smbconf), "--force")
295 self.assertCmdSuccess(result, out, err)
296 self.assertEqual(err, "", "Shouldn't be any error messages")
297
298 # 3. Assert we get the RID Set
299 res = new_ldb.search(base=server_ref_dn,
300 scope=ldb.SCOPE_BASE, attrs=['rIDSetReferences'])
301
302 self.assertTrue("rIDSetReferences" in res[0])
303 finally:
304 shutil.rmtree(targetdir, ignore_errors=True)
305 self._test_force_demote(fsmo_not_owner['dns_name'], "RIDALLOCTEST1")
306
307 def _test_join(self, server, netbios_name):
308 tmpdir = os.path.join(self.tempdir, "targetdir")
309 creds = self.get_credentials()
310 (result, out, err) = self.runsubcmd("domain", "join",
311 creds.get_realm(),
312 "dc", "-U%s%%%s" % (creds.get_username(),
313 creds.get_password()),
314 '--targetdir=%s' % tmpdir,
315 '--server=%s' % server,
316 "--option=netbios name = %s" % netbios_name)
317 self.assertCmdSuccess(result, out, err)
318 return tmpdir
319
320 def _test_force_demote(self, server, netbios_name):
321 creds = self.get_credentials()
322 (result, out, err) = self.runsubcmd("domain", "demote",
323 "-U%s%%%s" % (creds.get_username(),
324 creds.get_password()),
325 '--server=%s' % server,
326 "--remove-other-dead-server=%s" % netbios_name)
327 self.assertCmdSuccess(result, out, err)
328
329 def test_offline_manual_seized_ridalloc_with_dbcheck(self):
330 """Perform the same actions as test_offline_samba_tool_seized_ridalloc,
331 but do not create the RID set. Confirm that dbcheck correctly creates
332 the RID Set.
333
334 Also check
335 """
336 fsmo_dn = ldb.Dn(self.ldb_dc1, "CN=RID Manager$,CN=System," + self.ldb_dc1.domain_dn())
337 (fsmo_owner, fsmo_not_owner) = self._determine_fSMORoleOwner(fsmo_dn)
338
339 targetdir = self._test_join(fsmo_not_owner['dns_name'], "RIDALLOCTEST2")
340 try:
341 # Connect to the database
342 ldb_url = "tdb://%s" % os.path.join(targetdir, "private/sam.ldb")
343 lp = self.get_loadparm()
344
345 new_ldb = SamDB(ldb_url, credentials=self.get_credentials(),
346 session_info=system_session(lp), lp=lp)
347
348 serviceName = new_ldb.get_dsServiceName()
349 m = ldb.Message()
350 m.dn = fsmo_dn
351 m["fSMORoleOwner"] = ldb.MessageElement(serviceName,
352 ldb.FLAG_MOD_REPLACE,
353 "fSMORoleOwner")
354 new_ldb.modify(m)
355
356 # 1. Get server name
357 res = new_ldb.search(base=ldb.Dn(new_ldb, new_ldb.get_serverName()),
358 scope=ldb.SCOPE_BASE, attrs=["serverReference"])
359 # 2. Get server reference
360 server_ref_dn = ldb.Dn(new_ldb, res[0]['serverReference'][0].decode('utf8'))
361
362 # Assert that no RID Set has been set
363 res = new_ldb.search(base=server_ref_dn,
364 scope=ldb.SCOPE_BASE, attrs=['rIDSetReferences'])
365
366 self.assertFalse("rIDSetReferences" in res[0])
367
368 chk = dbcheck(new_ldb, verbose=False, fix=True, yes=True, quiet=True)
369
370 self.assertEqual(chk.check_database(DN=server_ref_dn, scope=ldb.SCOPE_BASE), 1, "Should have fixed one error (missing RID Set)")
371
372 # 3. Assert we get the RID Set
373 res = new_ldb.search(base=server_ref_dn,
374 scope=ldb.SCOPE_BASE, attrs=['rIDSetReferences'])
375
376 self.assertTrue("rIDSetReferences" in res[0])
377 finally:
378 self._test_force_demote(fsmo_not_owner['dns_name'], "RIDALLOCTEST2")
379 shutil.rmtree(targetdir, ignore_errors=True)
380
381 def test_offline_manual_seized_ridalloc_add_user(self):
382 """Perform the same actions as test_offline_samba_tool_seized_ridalloc,
383 but do not create the RID set. Confirm that user-add correctly creates
384 the RID Set."""
385 fsmo_dn = ldb.Dn(self.ldb_dc1, "CN=RID Manager$,CN=System," + self.ldb_dc1.domain_dn())
386 (fsmo_owner, fsmo_not_owner) = self._determine_fSMORoleOwner(fsmo_dn)
387
388 targetdir = self._test_join(fsmo_not_owner['dns_name'], "RIDALLOCTEST3")
389 try:
390 # Connect to the database
391 ldb_url = "tdb://%s" % os.path.join(targetdir, "private/sam.ldb")
392 lp = self.get_loadparm()
393
394 new_ldb = SamDB(ldb_url, credentials=self.get_credentials(),
395 session_info=system_session(lp), lp=lp)
396
397 serviceName = new_ldb.get_dsServiceName()
398 m = ldb.Message()
399 m.dn = fsmo_dn
400 m["fSMORoleOwner"] = ldb.MessageElement(serviceName,
401 ldb.FLAG_MOD_REPLACE,
402 "fSMORoleOwner")
403 new_ldb.modify(m)
404
405 # 1. Get server name
406 res = new_ldb.search(base=ldb.Dn(new_ldb, new_ldb.get_serverName()),
407 scope=ldb.SCOPE_BASE, attrs=["serverReference"])
408 # 2. Get server reference
409 server_ref_dn = ldb.Dn(new_ldb, res[0]['serverReference'][0].decode('utf8'))
410
411 # Assert that no RID Set has been set
412 res = new_ldb.search(base=server_ref_dn,
413 scope=ldb.SCOPE_BASE, attrs=['rIDSetReferences'])
414
415 self.assertFalse("rIDSetReferences" in res[0])
416
417 new_ldb.newuser("ridalloctestuser", "P@ssword!")
418
419 # 3. Assert we get the RID Set
420 res = new_ldb.search(base=server_ref_dn,
421 scope=ldb.SCOPE_BASE, attrs=['rIDSetReferences'])
422
423 self.assertTrue("rIDSetReferences" in res[0])
424
425 finally:
426 self._test_force_demote(fsmo_not_owner['dns_name'], "RIDALLOCTEST3")
427 shutil.rmtree(targetdir, ignore_errors=True)
428
429 def test_offline_manual_seized_ridalloc_add_user_as_admin(self):
430 """Perform the same actions as test_offline_samba_tool_seized_ridalloc,
431 but do not create the RID set. Confirm that user-add correctly creates
432 the RID Set."""
433 fsmo_dn = ldb.Dn(self.ldb_dc1, "CN=RID Manager$,CN=System," + self.ldb_dc1.domain_dn())
434 (fsmo_owner, fsmo_not_owner) = self._determine_fSMORoleOwner(fsmo_dn)
435
436 targetdir = self._test_join(fsmo_not_owner['dns_name'], "RIDALLOCTEST4")
437 try:
438 # Connect to the database
439 ldb_url = "tdb://%s" % os.path.join(targetdir, "private/sam.ldb")
440 lp = self.get_loadparm()
441
442 new_ldb = SamDB(ldb_url, credentials=self.get_credentials(),
443 session_info=admin_session(lp, self.ldb_dc1.get_domain_sid()), lp=lp)
444
445 serviceName = new_ldb.get_dsServiceName()
446 m = ldb.Message()
447 m.dn = fsmo_dn
448 m["fSMORoleOwner"] = ldb.MessageElement(serviceName,
449 ldb.FLAG_MOD_REPLACE,
450 "fSMORoleOwner")
451 new_ldb.modify(m)
452
453 # 1. Get server name
454 res = new_ldb.search(base=ldb.Dn(new_ldb, new_ldb.get_serverName()),
455 scope=ldb.SCOPE_BASE, attrs=["serverReference"])
456 # 2. Get server reference
457 server_ref_dn = ldb.Dn(new_ldb, res[0]['serverReference'][0].decode('utf8'))
458
459 # Assert that no RID Set has been set
460 res = new_ldb.search(base=server_ref_dn,
461 scope=ldb.SCOPE_BASE, attrs=['rIDSetReferences'])
462
463 self.assertFalse("rIDSetReferences" in res[0])
464
465 # Create a user to allocate a RID Set for itself (the RID master)
466 new_ldb.newuser("ridalloctestuser", "P@ssword!")
467
468 # 3. Assert we get the RID Set
469 res = new_ldb.search(base=server_ref_dn,
470 scope=ldb.SCOPE_BASE, attrs=['rIDSetReferences'])
471
472 self.assertTrue("rIDSetReferences" in res[0])
473
474 finally:
475 self._test_force_demote(fsmo_not_owner['dns_name'], "RIDALLOCTEST4")
476 shutil.rmtree(targetdir, ignore_errors=True)
477
478 def test_join_time_ridalloc(self):
479 """Perform a join against the RID manager and assert we have a RID Set"""
480
481 fsmo_dn = ldb.Dn(self.ldb_dc1, "CN=RID Manager$,CN=System," + self.ldb_dc1.domain_dn())
482 (fsmo_owner, fsmo_not_owner) = self._determine_fSMORoleOwner(fsmo_dn)
483
484 targetdir = self._test_join(fsmo_owner['dns_name'], "RIDALLOCTEST5")
485 try:
486 # Connect to the database
487 ldb_url = "tdb://%s" % os.path.join(targetdir, "private/sam.ldb")
488
489 lp = self.get_loadparm()
490 new_ldb = SamDB(ldb_url, credentials=self.get_credentials(),
491 session_info=system_session(lp), lp=lp)
492
493 # 1. Get server name
494 res = new_ldb.search(base=ldb.Dn(new_ldb, new_ldb.get_serverName()),
495 scope=ldb.SCOPE_BASE, attrs=["serverReference"])
496 # 2. Get server reference
497 server_ref_dn = ldb.Dn(new_ldb, res[0]['serverReference'][0].decode('utf8'))
498
499 # 3. Assert we get the RID Set
500 res = new_ldb.search(base=server_ref_dn,
501 scope=ldb.SCOPE_BASE, attrs=['rIDSetReferences'])
502
503 self.assertTrue("rIDSetReferences" in res[0])
504 finally:
505 self._test_force_demote(fsmo_owner['dns_name'], "RIDALLOCTEST5")
506 shutil.rmtree(targetdir, ignore_errors=True)
507
508 def test_rid_set_dbcheck(self):
509 """Perform a join against the RID manager and assert we have a RID Set.
510 Using dbcheck, we assert that we can detect out of range users."""
511
512 fsmo_dn = ldb.Dn(self.ldb_dc1, "CN=RID Manager$,CN=System," + self.ldb_dc1.domain_dn())
513 (fsmo_owner, fsmo_not_owner) = self._determine_fSMORoleOwner(fsmo_dn)
514
515 targetdir = self._test_join(fsmo_owner['dns_name'], "RIDALLOCTEST6")
516 try:
517 # Connect to the database
518 ldb_url = "tdb://%s" % os.path.join(targetdir, "private/sam.ldb")
519
520 lp = self.get_loadparm()
521 new_ldb = SamDB(ldb_url, credentials=self.get_credentials(),
522 session_info=system_session(lp), lp=lp)
523
524 # 1. Get server name
525 res = new_ldb.search(base=ldb.Dn(new_ldb, new_ldb.get_serverName()),
526 scope=ldb.SCOPE_BASE, attrs=["serverReference"])
527 # 2. Get server reference
528 server_ref_dn = ldb.Dn(new_ldb, res[0]['serverReference'][0].decode('utf8'))
529
530 # 3. Assert we get the RID Set
531 res = new_ldb.search(base=server_ref_dn,
532 scope=ldb.SCOPE_BASE, attrs=['rIDSetReferences'])
533
534 self.assertTrue("rIDSetReferences" in res[0])
535 rid_set_dn = ldb.Dn(new_ldb, res[0]["rIDSetReferences"][0].decode('utf8'))
536
537 # 4. Add a new user (triggers RID set work)
538 new_ldb.newuser("ridalloctestuser", "P@ssword!")
539
540 # 5. Now fetch the RID SET
541 rid_set_res = new_ldb.search(base=rid_set_dn,
542 scope=ldb.SCOPE_BASE, attrs=['rIDNextRid',
543 'rIDAllocationPool'])
544 next_pool = int(rid_set_res[0]["rIDAllocationPool"][0])
545 last_rid = (0xFFFFFFFF00000000 & next_pool) >> 32
546
547 # 6. Add user above the ridNextRid and at mid-range.
548 #
549 # We can do this with safety because this is an offline DB that will be
550 # destroyed.
551 m = ldb.Message()
552 m.dn = ldb.Dn(new_ldb, "CN=ridsettestuser1,CN=Users")
553 m.dn.add_base(new_ldb.get_default_basedn())
554 m['objectClass'] = ldb.MessageElement('user', ldb.FLAG_MOD_ADD, 'objectClass')
555 m['objectSid'] = ldb.MessageElement(ndr_pack(security.dom_sid(str(new_ldb.get_domain_sid()) + "-%d" % (last_rid - 10))),
556 ldb.FLAG_MOD_ADD,
557 'objectSid')
558 new_ldb.add(m, controls=["relax:0"])
559
560 # 7. Check the RID Set
561 chk = dbcheck(new_ldb, verbose=False, fix=True, yes=True, quiet=True)
562
563 # Should have one error (wrong rIDNextRID)
564 self.assertEqual(chk.check_database(DN=rid_set_dn, scope=ldb.SCOPE_BASE), 1)
565
566 # 8. Assert we get didn't show any other errors
567 chk = dbcheck(new_ldb, verbose=False, fix=False, quiet=True)
568
569 rid_set_res = new_ldb.search(base=rid_set_dn,
570 scope=ldb.SCOPE_BASE, attrs=['rIDNextRid',
571 'rIDAllocationPool'])
572 last_allocated_rid = int(rid_set_res[0]["rIDNextRid"][0])
573 self.assertEqual(last_allocated_rid, last_rid - 10)
574
575 # 9. Assert that the range wasn't thrown away
576
577 next_pool = int(rid_set_res[0]["rIDAllocationPool"][0])
578 self.assertEqual(last_rid, (0xFFFFFFFF00000000 & next_pool) >> 32, "rid pool should have changed")
579 finally:
580 self._test_force_demote(fsmo_owner['dns_name'], "RIDALLOCTEST6")
581 shutil.rmtree(targetdir, ignore_errors=True)
582
583 def test_rid_set_dbcheck_after_seize(self):
584 """Perform a join against the RID manager and assert we have a RID Set.
585 We seize the RID master role, then using dbcheck, we assert that we can
586 detect out of range users (and then bump the RID set as required)."""
587
588 fsmo_dn = ldb.Dn(self.ldb_dc1, "CN=RID Manager$,CN=System," + self.ldb_dc1.domain_dn())
589 (fsmo_owner, fsmo_not_owner) = self._determine_fSMORoleOwner(fsmo_dn)
590
591 targetdir = self._test_join(fsmo_owner['dns_name'], "RIDALLOCTEST7")
592 try:
593 # Connect to the database
594 ldb_url = "tdb://%s" % os.path.join(targetdir, "private/sam.ldb")
595 smbconf = os.path.join(targetdir, "etc/smb.conf")
596
597 lp = self.get_loadparm()
598 new_ldb = SamDB(ldb_url, credentials=self.get_credentials(),
599 session_info=system_session(lp), lp=lp)
600
601 # 1. Get server name
602 res = new_ldb.search(base=ldb.Dn(new_ldb, new_ldb.get_serverName()),
603 scope=ldb.SCOPE_BASE, attrs=["serverReference"])
604 # 2. Get server reference
605 server_ref_dn = ldb.Dn(new_ldb, res[0]['serverReference'][0].decode('utf8'))
606
607 # 3. Assert we get the RID Set
608 res = new_ldb.search(base=server_ref_dn,
609 scope=ldb.SCOPE_BASE, attrs=['rIDSetReferences'])
610
611 self.assertTrue("rIDSetReferences" in res[0])
612 rid_set_dn = ldb.Dn(new_ldb, res[0]["rIDSetReferences"][0].decode('utf8'))
613 # 4. Seize the RID Manager role
614 (result, out, err) = self.runsubcmd("fsmo", "seize", "--role", "rid", "-H", ldb_url, "--configfile=%s" % (smbconf), "--force")
615 self.assertCmdSuccess(result, out, err)
616 self.assertEqual(err, "", "Shouldn't be any error messages")
617
618 # 5. Add a new user (triggers RID set work)
619 new_ldb.newuser("ridalloctestuser", "P@ssword!")
620
621 # 6. Now fetch the RID SET
622 rid_set_res = new_ldb.search(base=rid_set_dn,
623 scope=ldb.SCOPE_BASE, attrs=['rIDNextRid',
624 'rIDAllocationPool'])
625 next_pool = int(rid_set_res[0]["rIDAllocationPool"][0])
626 last_rid = (0xFFFFFFFF00000000 & next_pool) >> 32
627
628 # 7. Add user above the ridNextRid and at almost the end of the range.
629 #
630 m = ldb.Message()
631 m.dn = ldb.Dn(new_ldb, "CN=ridsettestuser2,CN=Users")
632 m.dn.add_base(new_ldb.get_default_basedn())
633 m['objectClass'] = ldb.MessageElement('user', ldb.FLAG_MOD_ADD, 'objectClass')
634 m['objectSid'] = ldb.MessageElement(ndr_pack(security.dom_sid(str(new_ldb.get_domain_sid()) + "-%d" % (last_rid - 3))),
635 ldb.FLAG_MOD_ADD,
636 'objectSid')
637 new_ldb.add(m, controls=["relax:0"])
638
639 # 8. Add user above the ridNextRid and at the end of the range
640 m = ldb.Message()
641 m.dn = ldb.Dn(new_ldb, "CN=ridsettestuser3,CN=Users")
642 m.dn.add_base(new_ldb.get_default_basedn())
643 m['objectClass'] = ldb.MessageElement('user', ldb.FLAG_MOD_ADD, 'objectClass')
644 m['objectSid'] = ldb.MessageElement(ndr_pack(security.dom_sid(str(new_ldb.get_domain_sid()) + "-%d" % last_rid)),
645 ldb.FLAG_MOD_ADD,
646 'objectSid')
647 new_ldb.add(m, controls=["relax:0"])
648
649 chk = dbcheck(new_ldb, verbose=False, fix=True, yes=True, quiet=True)
650
651 # Should have fixed two errors (wrong ridNextRid)
652 self.assertEqual(chk.check_database(DN=rid_set_dn, scope=ldb.SCOPE_BASE), 2)
653
654 # 9. Assert we get didn't show any other errors
655 chk = dbcheck(new_ldb, verbose=False, fix=False, quiet=True)
656
657 # 10. Add another user (checks RID rollover)
658 # We have seized the role, so we can do that.
659 new_ldb.newuser("ridalloctestuser3", "P@ssword!")
660
661 rid_set_res = new_ldb.search(base=rid_set_dn,
662 scope=ldb.SCOPE_BASE, attrs=['rIDNextRid',
663 'rIDAllocationPool'])
664 next_pool = int(rid_set_res[0]["rIDAllocationPool"][0])
665 self.assertNotEqual(last_rid, (0xFFFFFFFF00000000 & next_pool) >> 32, "rid pool should have changed")
666 finally:
667 self._test_force_demote(fsmo_owner['dns_name'], "RIDALLOCTEST7")
668 shutil.rmtree(targetdir, ignore_errors=True)
669
670 def test_replicate_against_deleted_objects_transaction(self):
671 """Not related to RID allocation, but uses the infrastructure here.
672 Do a join, create a link between two objects remotely, but
673 remove the target locally. Show that we need to set a magic
674 opaque if there is an outer transaction.
675
676 """
677 fsmo_dn = ldb.Dn(self.ldb_dc1, "CN=RID Manager$,CN=System," + self.ldb_dc1.domain_dn())
678 (fsmo_owner, fsmo_not_owner) = self._determine_fSMORoleOwner(fsmo_dn)
679
680 test_user4 = "ridalloctestuser4"
681 test_group = "ridalloctestgroup1"
682
683 self.ldb_dc1.newuser(test_user4, "P@ssword!")
684
685 self.addCleanup(self.ldb_dc1.deleteuser, test_user4)
686
687 self.ldb_dc1.newgroup(test_group)
688 self.addCleanup(self.ldb_dc1.deletegroup, test_group)
689
690 targetdir = self._test_join(self.dnsname_dc1, "RIDALLOCTEST8")
691 try:
692 # Connect to the database
693 ldb_url = "tdb://%s" % os.path.join(targetdir, "private/sam.ldb")
694 lp = self.get_loadparm()
695
696 new_ldb = SamDB(ldb_url,
697 session_info=system_session(lp), lp=lp)
698
699 destination_dsa_guid = misc.GUID(new_ldb.get_ntds_GUID())
700
701 repl = drs_utils.drs_Replicate(f'ncacn_ip_tcp:{self.dnsname_dc1}[seal]',
702 lp,
703 self.get_credentials(),
704 new_ldb,
705 destination_dsa_guid)
706
707 source_dsa_invocation_id = misc.GUID(self.ldb_dc1.invocation_id)
708
709 # Add the link on the remote DC
710 self.ldb_dc1.add_remove_group_members(test_group, [test_user4])
711
712 # Starting a transaction overrides, currently the logic
713 # inside repl.replicatate to retry with GET_TGT which in
714 # turn tells the repl_meta_data module that the most up to
715 # date info is already available
716 new_ldb.transaction_start()
717 repl.replicate(self.ldb_dc1.domain_dn(),
718 source_dsa_invocation_id,
719 destination_dsa_guid)
720
721 # Delete the user locally, before applying the links.
722 # This simulates getting the delete in the replciation
723 # stream.
724 new_ldb.deleteuser(test_user4)
725
726 # This fails as the user has been deleted locally but a remote link is sent
727 self.assertRaises(ldb.LdbError, new_ldb.transaction_commit)
728
729 new_ldb.transaction_start()
730 repl.replicate(self.ldb_dc1.domain_dn(),
731 source_dsa_invocation_id,
732 destination_dsa_guid)
733
734 # Delete the user locally (the previous transaction
735 # doesn't apply), before applying the links. This
736 # simulates getting the delete in the replciation stream.
737 new_ldb.deleteuser(test_user4)
738
739 new_ldb.set_opaque(dsdb.DSDB_FULL_JOIN_REPLICATION_COMPLETED_OPAQUE_NAME,
740 1)
741
742 # This should now work
743 try:
744 new_ldb.transaction_commit()
745 except ldb.LdbError as e:
746 self.fail(f"Failed to replicate despite setting opaque with {e.args[1]}")
747
748 finally:
749 self._test_force_demote(self.dnsname_dc1, "RIDALLOCTEST8")
750 shutil.rmtree(targetdir, ignore_errors=True)
751
752 def test_replicate_against_deleted_objects_normal(self):
753 """Not related to RID allocation, but uses the infrastructure here.
754 Do a join, create a link between two objects remotely, but
755 remove the target locally. .
756
757 """
758 fsmo_dn = ldb.Dn(self.ldb_dc1, "CN=RID Manager$,CN=System," + self.ldb_dc1.domain_dn())
759 (fsmo_owner, fsmo_not_owner) = self._determine_fSMORoleOwner(fsmo_dn)
760
761 test_user5 = "ridalloctestuser5"
762 test_group2 = "ridalloctestgroup2"
763
764 self.ldb_dc1.newuser(test_user5, "P@ssword!")
765 self.addCleanup(self.ldb_dc1.deleteuser, test_user5)
766
767 self.ldb_dc1.newgroup(test_group2)
768 self.addCleanup(self.ldb_dc1.deletegroup, test_group2)
769
770 targetdir = self._test_join(self.dnsname_dc1, "RIDALLOCTEST9")
771 try:
772 # Connect to the database
773 ldb_url = "tdb://%s" % os.path.join(targetdir, "private/sam.ldb")
774 lp = self.get_loadparm()
775
776 new_ldb = SamDB(ldb_url,
777 session_info=system_session(lp), lp=lp)
778
779 destination_dsa_guid = misc.GUID(new_ldb.get_ntds_GUID())
780
781 repl = drs_utils.drs_Replicate(f'ncacn_ip_tcp:{self.dnsname_dc1}[seal]',
782 lp,
783 self.get_credentials(),
784 new_ldb,
785 destination_dsa_guid)
786
787 source_dsa_invocation_id = misc.GUID(self.ldb_dc1.invocation_id)
788
789 # Add the link on the remote DC
790 self.ldb_dc1.add_remove_group_members(test_group2, [test_user5])
791
792 # Delete the user locally
793 new_ldb.deleteuser(test_user5)
794
795 # Confirm replication copes with a link to a locally deleted user
796 repl.replicate(self.ldb_dc1.domain_dn(),
797 source_dsa_invocation_id,
798 destination_dsa_guid)
799
800 finally:
801 self._test_force_demote(self.dnsname_dc1, "RIDALLOCTEST9")
802 shutil.rmtree(targetdir, ignore_errors=True)