5a25da13e7c40a84dfc1f559ea5de85a28c7e20d
[nivanova/samba-autobuild/.git] / python / samba / netcmd / domain_backup.py
1 # domain_backup
2 #
3 # Copyright Andrew Bartlett <abartlet@samba.org>
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 import datetime
19 import os
20 import sys
21 import tarfile
22 import logging
23 import shutil
24 import tempfile
25 import samba
26 import samba.getopt as options
27 from samba.samdb import SamDB
28 import ldb
29 from samba import smb
30 from samba.ntacls import backup_online, backup_restore
31 from samba.auth import system_session
32 from samba.join import DCJoinContext, join_clone
33 from samba.dcerpc.security import dom_sid
34 from samba.netcmd import Option, CommandError
35 from samba.dcerpc import misc
36 from samba import Ldb
37 from fsmo import cmd_fsmo_seize
38 from samba.provision import make_smbconf
39 from samba.upgradehelpers import update_krbtgt_account_password
40 from samba.remove_dc import remove_dc
41 from samba.provision import secretsdb_self_join
42
43
44
45 # work out a SID (based on a free RID) to use when the domain gets restored.
46 # This ensures that the restored DC's SID won't clash with any other RIDs
47 # already in use in the domain
48 def get_sid_for_restore(samdb):
49     # Find the DN of the RID set of the server
50     res = samdb.search(base=ldb.Dn(samdb, samdb.get_serverName()),
51                        scope=ldb.SCOPE_BASE, attrs=["serverReference"])
52     server_ref_dn = ldb.Dn(samdb, res[0]['serverReference'][0])
53     res = samdb.search(base=server_ref_dn,
54                        scope=ldb.SCOPE_BASE,
55                        attrs=['rIDSetReferences'])
56     rid_set_dn = ldb.Dn(samdb, res[0]['rIDSetReferences'][0])
57
58     # Get the alloc pools and next RID of the RID set
59     res = samdb.search(base=rid_set_dn,
60                        scope=ldb.SCOPE_SUBTREE,
61                        expression="(rIDNextRID=*)",
62                        attrs=['rIDAllocationPool',
63                               'rIDPreviousAllocationPool',
64                               'rIDNextRID'])
65
66     # Decode the bounds of the RID allocation pools
67     rid = int(res[0].get('rIDNextRID')[0])
68
69     def split_val(num):
70         high = (0xFFFFFFFF00000000 & int(num)) >> 32
71         low = 0x00000000FFFFFFFF & int(num)
72         return low, high
73     pool_l, pool_h = split_val(res[0].get('rIDPreviousAllocationPool')[0])
74     npool_l, npool_h = split_val(res[0].get('rIDAllocationPool')[0])
75
76     # Calculate next RID based on pool bounds
77     if rid == npool_h:
78         raise CommandError('Out of RIDs, finished AllocPool')
79     if rid == pool_h:
80         if pool_h == npool_h:
81             raise CommandError('Out of RIDs, finished PrevAllocPool.')
82         rid = npool_l
83     else:
84         rid += 1
85
86     # Construct full SID
87     sid = dom_sid(samdb.get_domain_sid())
88     return str(sid) + '-' + str(rid)
89
90
91 def get_timestamp():
92     return datetime.datetime.now().isoformat().replace(':', '-')
93
94
95 def backup_filepath(targetdir, name, time_str):
96     filename = 'samba-backup-{}-{}.tar.bz2'.format(name, time_str)
97     return os.path.join(targetdir, filename)
98
99
100 def create_backup_tar(logger, tmpdir, backup_filepath):
101     # Adds everything in the tmpdir into a new tar file
102     logger.info("Creating backup file %s..." % backup_filepath)
103     tf = tarfile.open(backup_filepath, 'w:bz2')
104     tf.add(tmpdir, arcname='./')
105     tf.close()
106
107
108 # Add a backup-specific marker to the DB with info that we'll use during
109 # the restore process
110 def add_backup_marker(samdb, marker, value):
111     m = ldb.Message()
112     m.dn = ldb.Dn(samdb, "@SAMBA_DSDB")
113     m[marker] = ldb.MessageElement(value, ldb.FLAG_MOD_ADD, marker)
114     samdb.modify(m)
115
116
117 def check_online_backup_args(logger, credopts, server, targetdir):
118     # Make sure we have all the required args.
119     u_p = {'user': credopts.creds.get_username(),
120            'pass': credopts.creds.get_password()}
121     if None in u_p.values():
122         raise CommandError("Creds required.")
123     if server is None:
124         raise CommandError('Server required')
125     if targetdir is None:
126         raise CommandError('Target directory required')
127
128     if not os.path.exists(targetdir):
129         logger.info('Creating targetdir %s...' % targetdir)
130         os.makedirs(targetdir)
131
132
133 class cmd_domain_backup_online(samba.netcmd.Command):
134     '''Copy a running DC's current DB into a backup tar file.
135
136     Takes a backup copy of the current domain from a running DC. If the domain
137     were to undergo a catastrophic failure, then the backup file can be used to
138     recover the domain. The backup created is similar to the DB that a new DC
139     would receive when it joins the domain.
140
141     Note that:
142     - it's recommended to run 'samba-tool dbcheck' before taking a backup-file
143       and fix any errors it reports.
144     - all the domain's secrets are included in the backup file.
145     - although the DB contents can be untarred and examined manually, you need
146       to run 'samba-tool domain backup restore' before you can start a Samba DC
147       from the backup file.'''
148
149     synopsis = "%prog --server=<DC-to-backup> --targetdir=<output-dir>"
150     takes_optiongroups = {
151         "sambaopts": options.SambaOptions,
152         "credopts": options.CredentialsOptions,
153     }
154
155     takes_options = [
156         Option("--server", help="The DC to backup", type=str),
157         Option("--targetdir", type=str,
158                help="Directory to write the backup file to"),
159        ]
160
161     def run(self, sambaopts=None, credopts=None, server=None, targetdir=None):
162         logger = self.get_logger()
163         logger.setLevel(logging.DEBUG)
164
165         # Make sure we have all the required args.
166         check_online_backup_args(logger, credopts, server, targetdir)
167
168         lp = sambaopts.get_loadparm()
169         creds = credopts.get_credentials(lp)
170
171         if not os.path.exists(targetdir):
172             logger.info('Creating targetdir %s...' % targetdir)
173             os.makedirs(targetdir)
174
175         tmpdir = tempfile.mkdtemp(dir=targetdir)
176
177         # Run a clone join on the remote
178         ctx = join_clone(logger=logger, creds=creds, lp=lp,
179                          include_secrets=True, dns_backend='SAMBA_INTERNAL',
180                          server=server, targetdir=tmpdir)
181
182         # get the paths used for the clone, then drop the old samdb connection
183         paths = ctx.paths
184         del ctx
185
186         # Get a free RID to use as the new DC's SID (when it gets restored)
187         remote_sam = SamDB(url='ldap://' + server, credentials=creds,
188                            session_info=system_session(), lp=lp)
189         new_sid = get_sid_for_restore(remote_sam)
190         realm = remote_sam.domain_dns_name()
191
192         # Grab the remote DC's sysvol files and bundle them into a tar file
193         sysvol_tar = os.path.join(tmpdir, 'sysvol.tar.gz')
194         smb_conn = smb.SMB(server, "sysvol", lp=lp, creds=creds)
195         backup_online(smb_conn, sysvol_tar, remote_sam.get_domain_sid())
196
197         # remove the default sysvol files created by the clone (we want to
198         # make sure we restore the sysvol.tar.gz files instead)
199         shutil.rmtree(paths.sysvol)
200
201         # Edit the downloaded sam.ldb to mark it as a backup
202         samdb = SamDB(url=paths.samdb, session_info=system_session(), lp=lp)
203         time_str = get_timestamp()
204         add_backup_marker(samdb, "backupDate", time_str)
205         add_backup_marker(samdb, "sidForRestore", new_sid)
206
207         # Add everything in the tmpdir to the backup tar file
208         backup_file = backup_filepath(targetdir, realm, time_str)
209         create_backup_tar(logger, tmpdir, backup_file)
210
211         shutil.rmtree(tmpdir)
212
213
214 class cmd_domain_backup_restore(cmd_fsmo_seize):
215     '''Restore the domain's DB from a backup-file.
216
217     This restores a previously backed up copy of the domain's DB on a new DC.
218
219     Note that the restored DB will not contain the original DC that the backup
220     was taken from (or any other DCs in the original domain). Only the new DC
221     (specified by --newservername) will be present in the restored DB.
222
223     Samba can then be started against the restored DB. Any existing DCs for the
224     domain should be shutdown before the new DC is started. Other DCs can then
225     be joined to the new DC to recover the network.
226
227     Note that this command should be run as the root user - it will fail
228     otherwise.'''
229
230     synopsis = ("%prog --backup-file=<tar-file> --targetdir=<output-dir> "
231                 "--newservername=<DC-name>")
232     takes_options = [
233         Option("--backup-file", help="Path to backup file", type=str),
234         Option("--targetdir", help="Path to write to", type=str),
235         Option("--newservername", help="Name for new server", type=str),
236     ]
237
238     takes_optiongroups = {
239         "sambaopts": options.SambaOptions,
240         "credopts": options.CredentialsOptions,
241     }
242
243     def run(self, sambaopts=None, credopts=None, backup_file=None,
244             targetdir=None, newservername=None):
245         if not (backup_file and os.path.exists(backup_file)):
246             raise CommandError('Backup file not found.')
247         if targetdir is None:
248             raise CommandError('Please specify a target directory')
249         if os.path.exists(targetdir) and os.listdir(targetdir):
250             raise CommandError('Target directory is not empty')
251         if not newservername:
252             raise CommandError('Server name required')
253
254         logger = logging.getLogger()
255         logger.setLevel(logging.DEBUG)
256         logger.addHandler(logging.StreamHandler(sys.stdout))
257
258         # ldapcmp prefers the server's netBIOS name in upper-case
259         newservername = newservername.upper()
260
261         # extract the backup .tar to a temp directory
262         targetdir = os.path.abspath(targetdir)
263         tf = tarfile.open(backup_file)
264         tf.extractall(targetdir)
265         tf.close()
266
267         # use the smb.conf that got backed up, by default (save what was
268         # actually backed up, before we mess with it)
269         smbconf = os.path.join(targetdir, 'etc', 'smb.conf')
270         shutil.copyfile(smbconf, smbconf + ".orig")
271
272         # if a smb.conf was specified on the cmd line, then use that instead
273         cli_smbconf = sambaopts.get_loadparm_path()
274         if cli_smbconf:
275             logger.info("Using %s as restored domain's smb.conf" % cli_smbconf)
276             shutil.copyfile(cli_smbconf, smbconf)
277
278         lp = samba.param.LoadParm()
279         lp.load(smbconf)
280
281         # open a DB connection to the restored DB
282         private_dir = os.path.join(targetdir, 'private')
283         samdb_path = os.path.join(private_dir, 'sam.ldb')
284         samdb = SamDB(url=samdb_path, session_info=system_session(), lp=lp)
285
286         # Create account using the join_add_objects function in the join object
287         # We need namingContexts, account control flags, and the sid saved by
288         # the backup process.
289         res = samdb.search(base="", scope=ldb.SCOPE_BASE,
290                            attrs=['namingContexts'])
291         ncs = [str(r) for r in res[0].get('namingContexts')]
292
293         creds = credopts.get_credentials(lp)
294         ctx = DCJoinContext(logger, creds=creds, lp=lp,
295                             forced_local_samdb=samdb,
296                             netbios_name=newservername)
297         ctx.nc_list = ncs
298         ctx.full_nc_list = ncs
299         ctx.userAccountControl = (samba.dsdb.UF_SERVER_TRUST_ACCOUNT |
300                                   samba.dsdb.UF_TRUSTED_FOR_DELEGATION)
301
302         # rewrite the smb.conf to make sure it uses the new targetdir settings.
303         # (This doesn't update all filepaths in a customized config, but it
304         # corrects the same paths that get set by a new provision)
305         logger.info('Updating basic smb.conf settings...')
306         make_smbconf(smbconf, newservername, ctx.domain_name,
307                      ctx.realm, targetdir, lp=lp,
308                      serverrole="active directory domain controller")
309
310         # Get the SID saved by the backup process and create account
311         res = samdb.search(base=ldb.Dn(samdb, "@SAMBA_DSDB"),
312                            scope=ldb.SCOPE_BASE,
313                            attrs=['sidForRestore'])
314         sid = res[0].get('sidForRestore')[0]
315         logger.info('Creating account with SID: ' + str(sid))
316         ctx.join_add_objects(specified_sid=dom_sid(sid))
317
318         m = ldb.Message()
319         m.dn = ldb.Dn(samdb, '@ROOTDSE')
320         ntds_guid = str(ctx.ntds_guid)
321         m["dsServiceName"] = ldb.MessageElement("<GUID=%s>" % ntds_guid,
322                                                 ldb.FLAG_MOD_REPLACE,
323                                                 "dsServiceName")
324         samdb.modify(m)
325
326         secrets_path = os.path.join(private_dir, 'secrets.ldb')
327         secrets_ldb = Ldb(secrets_path, session_info=system_session(), lp=lp)
328         secretsdb_self_join(secrets_ldb, domain=ctx.domain_name,
329                             realm=ctx.realm, dnsdomain=ctx.dnsdomain,
330                             netbiosname=ctx.myname, domainsid=ctx.domsid,
331                             machinepass=ctx.acct_pass,
332                             key_version_number=ctx.key_version_number,
333                             secure_channel_type=misc.SEC_CHAN_BDC)
334
335         # Seize DNS roles
336         domain_dn = samdb.domain_dn()
337         forest_dn = samba.dn_from_dns_name(samdb.forest_dns_name())
338         domaindns_dn = ("CN=Infrastructure,DC=DomainDnsZones,", domain_dn)
339         forestdns_dn = ("CN=Infrastructure,DC=ForestDnsZones,", forest_dn)
340         for dn_prefix, dns_dn in [forestdns_dn, domaindns_dn]:
341             if dns_dn not in ncs:
342                 continue
343             full_dn = dn_prefix + dns_dn
344             m = ldb.Message()
345             m.dn = ldb.Dn(samdb, full_dn)
346             m["fSMORoleOwner"] = ldb.MessageElement(samdb.get_dsServiceName(),
347                                                     ldb.FLAG_MOD_REPLACE,
348                                                     "fSMORoleOwner")
349             samdb.modify(m)
350
351         # Seize other roles
352         for role in ['rid', 'pdc', 'naming', 'infrastructure', 'schema']:
353             self.seize_role(role, samdb, force=True)
354
355         # Get all DCs and remove them (this ensures these DCs cannot
356         # replicate because they will not have a password)
357         search_expr = "(&(objectClass=Server)(serverReference=*))"
358         res = samdb.search(samdb.get_config_basedn(), scope=ldb.SCOPE_SUBTREE,
359                            expression=search_expr)
360         for m in res:
361             cn = m.get('cn')[0]
362             if cn != newservername:
363                 remove_dc(samdb, logger, cn)
364
365         # Remove the repsFrom and repsTo from each NC to ensure we do
366         # not try (and fail) to talk to the old DCs
367         for nc in ncs:
368             msg = ldb.Message()
369             msg.dn = ldb.Dn(samdb, nc)
370
371             msg["repsFrom"] = ldb.MessageElement([],
372                                                  ldb.FLAG_MOD_REPLACE,
373                                                  "repsFrom")
374             msg["repsTo"] = ldb.MessageElement([],
375                                                  ldb.FLAG_MOD_REPLACE,
376                                                  "repsTo")
377             samdb.modify(msg)
378
379         # Update the krbtgt passwords twice, ensuring no tickets from
380         # the old domain are valid
381         update_krbtgt_account_password(samdb)
382         update_krbtgt_account_password(samdb)
383
384         # restore the sysvol directory from the backup tar file, including the
385         # original NTACLs. Note that the backup_restore() will fail if not root
386         sysvol_tar = os.path.join(targetdir, 'sysvol.tar.gz')
387         dest_sysvol_dir = lp.get('path', 'sysvol')
388         if not os.path.exists(dest_sysvol_dir):
389             os.makedirs(dest_sysvol_dir)
390         backup_restore(sysvol_tar, dest_sysvol_dir, samdb, smbconf)
391         os.remove(sysvol_tar)
392
393         # Remove DB markers added by the backup process
394         m = ldb.Message()
395         m.dn = ldb.Dn(samdb, "@SAMBA_DSDB")
396         m["backupDate"] = ldb.MessageElement([], ldb.FLAG_MOD_DELETE,
397                                              "backupDate")
398         m["sidForRestore"] = ldb.MessageElement([], ldb.FLAG_MOD_DELETE,
399                                                 "sidForRestore")
400         samdb.modify(m)
401
402         logger.info("Backup file successfully restored to %s" % targetdir)
403         logger.info("Please check the smb.conf settings are correct before "
404                     "starting samba.")
405
406
407 class cmd_domain_backup(samba.netcmd.SuperCommand):
408     '''Create or restore a backup of the domain.'''
409     subcommands = {'online': cmd_domain_backup_online(),
410                    'restore': cmd_domain_backup_restore()}