PEP8: add spaces after operators
[nivanova/samba-autobuild/.git] / python / samba / domain_update.py
1 # Samba4 Domain update checker
2 #
3 # Copyright (C) Andrew Bartlett <abartlet@samba.org> 2017
4 #
5 # This program is free software; you can redistribute it and/or modify
6 # it under the terms of the GNU General Public License as published by
7 # the Free Software Foundation; either version 3 of the License, or
8 # (at your option) any later version.
9 #
10 # This program is distributed in the hope that it will be useful,
11 # but WITHOUT ANY WARRANTY; without even the implied warranty of
12 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 # GNU General Public License for more details.
14 #
15 # You should have received a copy of the GNU General Public License
16 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
17 #
18
19 import re
20 import ldb
21 import samba
22 import time
23 from base64 import b64encode
24 from samba import dsdb
25 from samba import common
26 from samba import sd_utils
27 from samba.dcerpc import misc
28 from samba.dcerpc import drsuapi
29 from samba.ndr import ndr_unpack, ndr_pack
30 from samba.dcerpc import drsblobs
31 from samba.common import dsdb_Dn
32 from samba.dcerpc import security
33 from samba.dcerpc.security import SECINFO_DACL
34 from samba.descriptor import (
35     get_wellknown_sds,
36     get_diff_sds,
37     get_managed_service_accounts_descriptor,
38 )
39 from samba.auth import system_session, admin_session
40 from samba.netcmd import CommandError
41 from samba.netcmd.fsmo import get_fsmo_roleowner
42 from samba.dsdb import (
43     DS_DOMAIN_FUNCTION_2008,
44     DS_DOMAIN_FUNCTION_2008_R2,
45     DS_DOMAIN_FUNCTION_2012,
46     DS_DOMAIN_FUNCTION_2012_R2,
47     DS_DOMAIN_FUNCTION_2016,
48 )
49
50 MIN_UPDATE = 75
51 MAX_UPDATE = 81
52
53 update_map = {
54     # Missing updates from 2008 R2 - version 5
55     75: "5e1574f6-55df-493e-a671-aaeffca6a100",
56     76: "d262aae8-41f7-48ed-9f35-56bbb677573d",
57     77: "82112ba0-7e4c-4a44-89d9-d46c9612bf91",
58     # Windows Server 2012 - version 9
59     78: "c3c927a6-cc1d-47c0-966b-be8f9b63d991",
60     79: "54afcfb9-637a-4251-9f47-4d50e7021211",
61     80: "f4728883-84dd-483c-9897-274f2ebcf11e",
62     81: "ff4f9d27-7157-4cb0-80a9-5d6f2b14c8ff",
63     # Windows Server 2012 R2 - version 10
64     # No updates
65 }
66
67 functional_level_to_max_update = {
68     DS_DOMAIN_FUNCTION_2008: 74,
69     DS_DOMAIN_FUNCTION_2008_R2: 77,
70     DS_DOMAIN_FUNCTION_2012: 81,
71     DS_DOMAIN_FUNCTION_2012_R2: 81,
72     DS_DOMAIN_FUNCTION_2016: 88,
73 }
74
75 functional_level_to_version = {
76     DS_DOMAIN_FUNCTION_2008: 3,
77     DS_DOMAIN_FUNCTION_2008_R2: 5,
78     DS_DOMAIN_FUNCTION_2012: 9,
79     DS_DOMAIN_FUNCTION_2012_R2: 10,
80     DS_DOMAIN_FUNCTION_2016: 15,
81 }
82
83 # No update numbers have been skipped over
84 missing_updates = []
85
86
87 class DomainUpdateException(Exception):
88     pass
89
90
91 class DomainUpdate(object):
92     """Check and update a SAM database for domain updates"""
93
94     def __init__(self, samdb, fix=False,
95                  add_update_container=True):
96         """
97         :param samdb: LDB database
98         :param fix: Apply the update if the container is missing
99         :param add_update_container: Add the container at the end of the change
100         :raise DomainUpdateException:
101         """
102         self.samdb = samdb
103         self.fix = fix
104         self.add_update_container = add_update_container
105         # TODO: In future we should check for inconsistencies when it claims it has been done
106         self.check_update_applied = False
107
108         self.config_dn = self.samdb.get_config_basedn()
109         self.domain_dn = self.samdb.domain_dn()
110         self.schema_dn = self.samdb.get_schema_basedn()
111
112         self.sd_utils = sd_utils.SDUtils(samdb)
113         self.domain_sid = security.dom_sid(samdb.get_domain_sid())
114
115         self.domainupdate_container = self.samdb.get_root_basedn()
116         if not self.domainupdate_container.add_child("CN=Operations,CN=DomainUpdates,CN=System"):
117             raise DomainUpdateException("Failed to add domain update container child")
118
119         self.revision_object = self.samdb.get_root_basedn()
120         if not self.revision_object.add_child("CN=ActiveDirectoryUpdate,CN=DomainUpdates,CN=System"):
121             raise DomainUpdateException("Failed to add revision object child")
122
123     def check_updates_functional_level(self, functional_level,
124                                        old_functional_level=None,
125                                        update_revision=False):
126         """
127         Apply all updates for a given old and new functional level
128         :param functional_level: constant
129         :param old_functional_level: constant
130         :param update_revision: modify the stored version
131         :raise DomainUpdateException:
132         """
133         res = self.samdb.search(base=self.revision_object,
134                                 attrs=["revision"], scope=ldb.SCOPE_BASE)
135
136         expected_update = functional_level_to_max_update[functional_level]
137
138         if old_functional_level:
139             min_update = functional_level_to_max_update[old_functional_level]
140             min_update += 1
141         else:
142             min_update = MIN_UPDATE
143
144         self.check_updates_range(min_update, expected_update)
145
146         expected_version = functional_level_to_version[functional_level]
147         found_version = int(res[0]['revision'][0])
148         if update_revision and found_version < expected_version:
149             if not self.fix:
150                 raise DomainUpdateException("Revision is not high enough. Fix is set to False."
151                                             "\nExpected: %dGot: %d" % (expected_version,
152                                                                        found_version))
153             self.samdb.modify_ldif("""dn: %s
154 changetype: modify
155 replace: revision
156 revision: %d
157 """ % (str(self.revision_object), expected_version))
158
159     def check_updates_iterator(self, iterator):
160         """
161         Apply a list of updates which must be within the valid range of updates
162         :param iterator: Iterable specifying integer update numbers to apply
163         :raise DomainUpdateException:
164         """
165         for op in iterator:
166             if op < MIN_UPDATE or op > MAX_UPDATE:
167                 raise DomainUpdateException("Update number invalid.")
168
169             # No LDIF file exists for the change
170             getattr(self, "operation_%d" % op)(op)
171
172     def check_updates_range(self, start=0, end=0):
173         """
174         Apply a range of updates which must be within the valid range of updates
175         :param start: integer update to begin
176         :param end: integer update to end (inclusive)
177         :raise DomainUpdateException:
178         """
179         op = start
180         if start < MIN_UPDATE or start > end or end > MAX_UPDATE:
181             raise DomainUpdateException("Update number invalid.")
182         while op <= end:
183             if op not in missing_updates:
184                 # No LDIF file exists for the change
185                 getattr(self, "operation_%d" % op)(op)
186
187             op += 1
188
189     def update_exists(self, op):
190         """
191         :param op: Integer update number
192         :return: True if update exists else False
193         """
194         try:
195             res = self.samdb.search(base=self.domainupdate_container,
196                                     expression="(CN=%s)" % update_map[op])
197         except ldb.LdbError:
198             return False
199
200         return len(res) == 1
201
202     def update_add(self, op):
203         """
204         Add the corresponding container object for the given update
205         :param op: Integer update
206         """
207         self.samdb.add_ldif("""dn: CN=%s,%s
208 objectClass: container
209 """ % (update_map[op], str(self.domainupdate_container)))
210
211     def insert_ace_into_dacl(self, dn, existing_sddl, ace):
212         """
213         Add an ACE to a DACL, checking if it already exists with a simple string search.
214
215         :param dn: DN to modify
216         :param existing_sddl: existing sddl as string
217         :param ace: string ace to insert
218         :return: True if modified else False
219         """
220         index = existing_sddl.rfind("S:")
221         if index != -1:
222             new_sddl = existing_sddl[:index] + ace + existing_sddl[index:]
223         else:
224             # Insert it at the end if no S: section
225             new_sddl = existing_sddl + ace
226
227         if ace in existing_sddl:
228             return False
229
230         self.sd_utils.modify_sd_on_dn(dn, new_sddl,
231                                       controls=["sd_flags:1:%d" % SECINFO_DACL])
232
233         return True
234
235     def insert_ace_into_string(self, dn, ace, attr):
236         """
237         Insert an ACE into a string attribute like defaultSecurityDescriptor.
238         This also checks if it already exists using a simple string search.
239
240         :param dn: DN to modify
241         :param ace: string ace to insert
242         :param attr: attribute to modify
243         :return: True if modified else False
244         """
245         msg = self.samdb.search(base=dn,
246                                 attrs=[attr],
247                                 controls=["search_options:1:2"])
248
249         assert len(msg) == 1
250         existing_sddl = msg[0][attr][0]
251         index = existing_sddl.rfind("S:")
252         if index != -1:
253             new_sddl = existing_sddl[:index] + ace + existing_sddl[index:]
254         else:
255             # Insert it at the end if no S: section
256             new_sddl = existing_sddl + ace
257
258         if ace in existing_sddl:
259             return False
260
261         m = ldb.Message()
262         m.dn = dn
263         m[attr] = ldb.MessageElement(new_sddl, ldb.FLAG_MOD_REPLACE,
264                                      attr)
265
266         self.samdb.modify(m, controls=["relax:0"])
267
268         return True
269
270     def raise_if_not_fix(self, op):
271         """
272         Raises an exception if not set to fix.
273         :param op: Integer operation
274         :raise DomainUpdateException:
275         """
276         if not self.fix:
277             raise DomainUpdateException("Missing operation %d. Fix is currently set to False" % op)
278
279     # Create a new object CN=TPM Devices in the Domain partition.
280     def operation_78(self, op):
281         if self.update_exists(op):
282             return
283         self.raise_if_not_fix(op)
284
285         self.samdb.add_ldif("""dn: CN=TPM Devices,%s
286 objectClass: top
287 objectClass: msTPM-InformationObjectsContainer
288 """ % self.domain_dn,
289                             controls=["relax:0", "provision:0"])
290
291         if self.add_update_container:
292             self.update_add(op)
293
294     # Created an access control entry for the TPM service.
295     def operation_79(self, op):
296         if self.update_exists(op):
297             return
298         self.raise_if_not_fix(op)
299
300         ace = "(OA;CIIO;WP;ea1b7b93-5e48-46d5-bc6c-4df4fda78a35;bf967a86-0de6-11d0-a285-00aa003049e2;PS)"
301
302         res = self.samdb.search(expression="(objectClass=samDomain)",
303                                 attrs=["nTSecurityDescriptor"],
304                                 controls=["search_options:1:2"])
305         for msg in res:
306             existing_sd = ndr_unpack(security.descriptor,
307                                      msg["nTSecurityDescriptor"][0])
308             existing_sddl = existing_sd.as_sddl(self.domain_sid)
309
310             self.insert_ace_into_dacl(msg.dn, existing_sddl, ace)
311
312         res = self.samdb.search(expression="(objectClass=domainDNS)",
313                                 attrs=["nTSecurityDescriptor"],
314                                 controls=["search_options:1:2"])
315         for msg in res:
316             existing_sd = ndr_unpack(security.descriptor,
317                                      msg["nTSecurityDescriptor"][0])
318             existing_sddl = existing_sd.as_sddl(self.domain_sid)
319
320             self.insert_ace_into_dacl(msg.dn, existing_sddl, ace)
321
322         if self.add_update_container:
323             self.update_add(op)
324
325     # Grant "Clone DC" extended right to Cloneable Domain Controllers group
326     def operation_80(self, op):
327         if self.update_exists(op):
328             return
329         self.raise_if_not_fix(op)
330
331         ace = "(OA;;CR;3e0f7e18-2c7a-4c10-ba82-4d926db99a3e;;%s-522)" % str(self.domain_sid)
332
333         res = self.samdb.search(base=self.domain_dn,
334                                 scope=ldb.SCOPE_BASE,
335                                 attrs=["nTSecurityDescriptor"],
336                                 controls=["search_options:1:2",
337                                           "sd_flags:1:%d" % SECINFO_DACL])
338         msg = res[0]
339
340         existing_sd = ndr_unpack(security.descriptor,
341                                  msg["nTSecurityDescriptor"][0])
342         existing_sddl = existing_sd.as_sddl(self.domain_sid)
343
344         self.insert_ace_into_dacl(msg.dn, existing_sddl, ace)
345
346         if self.add_update_container:
347             self.update_add(op)
348
349     # Grant ms-DS-Allowed-To-Act-On-Behalf-Of-Other-Identity to Principal Self
350     # on all objects
351     def operation_81(self, op):
352         if self.update_exists(op):
353             return
354         self.raise_if_not_fix(op)
355
356         ace = "(OA;CIOI;RPWP;3f78c3e5-f79a-46bd-a0b8-9d18116ddc79;;PS)"
357
358         res = self.samdb.search(expression="(objectClass=samDomain)",
359                                 attrs=["nTSecurityDescriptor"],
360                                 controls=["search_options:1:2"])
361         for msg in res:
362             existing_sd = ndr_unpack(security.descriptor,
363                                      msg["nTSecurityDescriptor"][0])
364             existing_sddl = existing_sd.as_sddl(self.domain_sid)
365
366             self.insert_ace_into_dacl(msg.dn, existing_sddl, ace)
367
368         res = self.samdb.search(expression="(objectClass=domainDNS)",
369                                 attrs=["nTSecurityDescriptor"],
370                                 controls=["search_options:1:2"])
371
372         for msg in res:
373             existing_sd = ndr_unpack(security.descriptor,
374                                      msg["nTSecurityDescriptor"][0])
375             existing_sddl = existing_sd.as_sddl(self.domain_sid)
376
377             self.insert_ace_into_dacl(msg.dn, existing_sddl, ace)
378
379         if self.add_update_container:
380             self.update_add(op)
381
382     #
383     # THE FOLLOWING ARE MISSING UPDATES FROM 2008 R2
384     #
385
386     # Add Managed Service Accounts container
387     def operation_75(self, op):
388         if self.update_exists(op):
389             return
390         self.raise_if_not_fix(op)
391
392         descriptor = get_managed_service_accounts_descriptor(self.domain_sid)
393         managedservice_descr = b64encode(descriptor).decode('utf8')
394         managed_service_dn = "CN=Managed Service Accounts,%s" % \
395             str(self.domain_dn)
396
397         self.samdb.modify_ldif("""dn: %s
398 changetype: add
399 objectClass: container
400 description: Default container for managed service accounts
401 showInAdvancedViewOnly: FALSE
402 nTSecurityDescriptor:: %s""" % (managed_service_dn, managedservice_descr),
403                                controls=["relax:0", "provision:0"])
404
405         if self.add_update_container:
406             self.update_add(op)
407
408     # Add the otherWellKnownObjects reference to MSA
409     def operation_76(self, op):
410         if self.update_exists(op):
411             return
412         self.raise_if_not_fix(op)
413
414         managed_service_dn = "CN=Managed Service Accounts,%s" % \
415             str(self.domain_dn)
416
417         self.samdb.modify_ldif("""dn: %s
418 changetype: modify
419 add: otherWellKnownObjects
420 otherWellKnownObjects: B:32:1EB93889E40C45DF9F0C64D23BBB6237:%s
421 """ % (str(self.domain_dn), managed_service_dn), controls=["relax:0",
422                                                            "provision:0"])
423
424         if self.add_update_container:
425             self.update_add(op)
426
427     # Add the PSPs object in the System container
428     def operation_77(self, op):
429         if self.update_exists(op):
430             return
431         self.raise_if_not_fix(op)
432
433         self.samdb.add_ldif("""dn: CN=PSPs,CN=System,%s
434 objectClass: top
435 objectClass: msImaging-PSPs
436 """ % str(self.domain_dn), controls=["relax:0", "provision:0"])
437
438         if self.add_update_container:
439             self.update_add(op)