s4-s3-upgrade Fix group member addition
[amitay/samba.git] / source4 / scripting / python / samba / upgrade.py
1 # backend code for upgrading from Samba3
2 # Copyright Jelmer Vernooij 2005-2007
3 #
4 # This program is free software; you can redistribute it and/or modify
5 # it under the terms of the GNU General Public License as published by
6 # the Free Software Foundation; either version 3 of the License, or
7 # (at your option) any later version.
8 #
9 # This program is distributed in the hope that it will be useful,
10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 # GNU General Public License for more details.
13 #
14 # You should have received a copy of the GNU General Public License
15 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
16 #
17
18 """Support code for upgrading from Samba 3 to Samba 4."""
19
20 __docformat__ = "restructuredText"
21
22 import grp
23 import ldb
24 import time
25 import pwd
26
27 from samba import Ldb, registry
28 from samba.param import LoadParm
29 from samba.provision import provision, FILL_FULL, ProvisioningError
30 from samba.samba3 import passdb
31 from samba.samba3 import param as s3param
32 from samba.dcerpc import lsa, samr, security
33 from samba.dcerpc.security import dom_sid
34 from samba import dsdb
35 from samba.ndr import ndr_pack
36
37
38 def import_sam_policy(samdb, policy, logger):
39     """Import a Samba 3 policy.
40
41     :param samdb: Samba4 SAM database
42     :param policy: Samba3 account policy
43     :param logger: Logger object
44     """
45
46     # Following entries are used -
47     #    min password length, password history, minimum password age,
48     #    maximum password age, lockout duration
49     #
50     # Following entries are not used -
51     #    reset count minutes, user must logon to change password,
52     #    bad lockout minutes, disconnect time
53
54     m = ldb.Message()
55     m.dn = samdb.get_default_basedn()
56     m['a01'] = ldb.MessageElement(str(policy['min password length']), ldb.FLAG_MOD_REPLACE,
57                             'minPwdLength')
58     m['a02'] = ldb.MessageElement(str(policy['password history']), ldb.FLAG_MOD_REPLACE,
59                             'pwdHistoryLength')
60     m['a03'] = ldb.MessageElement(str(policy['minimum password age']), ldb.FLAG_MOD_REPLACE,
61                             'minPwdAge')
62     m['a04'] = ldb.MessageElement(str(policy['maximum password age']), ldb.FLAG_MOD_REPLACE,
63                             'maxPwdAge')
64     m['a05'] = ldb.MessageElement(str(policy['lockout duration']), ldb.FLAG_MOD_REPLACE,
65                             'lockoutDuration')
66
67     try:
68         samdb.modify(m)
69     except ldb.LdbError, e:
70         logger.warn("Could not set account policy, (%s)", str(e))
71
72
73 def add_idmap_entry(idmapdb, sid, xid, xid_type, logger):
74     """Create idmap entry
75
76     :param idmapdb: Samba4 IDMAP database
77     :param sid: user/group sid
78     :param xid: user/group id
79     :param xid_type: type of id (UID/GID)
80     :param logger: Logger object
81     """
82
83     # First try to see if we already have this entry
84     found = False
85     msg = idmapdb.search(expression='objectSid=%s' % str(sid))
86     if msg.count == 1:
87         found = True
88
89     if found:
90         try:
91             m = ldb.Message()
92             m.dn = msg[0]['dn']
93             m['xidNumber'] = ldb.MessageElement(str(xid), ldb.FLAG_MOD_REPLACE, 'xidNumber')
94             m['type'] = ldb.MessageElement(xid_type, ldb.FLAG_MOD_REPLACE, 'type')
95             idmapdb.modify(m)
96         except ldb.LdbError, e:
97             logger.warn('Could not modify idmap entry for sid=%s, id=%s, type=%s (%s)',
98                             str(sid), str(xid), xid_type, str(e))
99     else:
100         try:
101             idmapdb.add({"dn": "CN=%s" % str(sid),
102                         "cn": str(sid),
103                         "objectClass": "sidMap",
104                         "objectSid": ndr_pack(sid),
105                         "type": xid_type,
106                         "xidNumber": str(xid)})
107         except ldb.LdbError, e:
108             logger.warn('Could not add idmap entry for sid=%s, id=%s, type=%s (%s)',
109                             str(sid), str(xid), xid_type, str(e))
110
111
112 def import_idmap(idmapdb, samba3, logger):
113     """Import idmap data.
114
115     :param idmapdb: Samba4 IDMAP database
116     :param samba3_idmap: Samba3 IDMAP database to import from
117     :param logger: Logger object
118     """
119
120     try:
121         samba3_idmap = samba3.get_idmap_db()
122     except IOError as (errno, strerror):
123         logger.warn('Cannot open idmap database, Ignoring: ({0}): {1}'.format(errno, strerror))
124         return
125
126     currentxid = max(samba3_idmap.get_user_hwm(), samba3_idmap.get_group_hwm())
127     lowerbound = currentxid
128     # FIXME: upperbound
129
130     m = ldb.Message()
131     m.dn = ldb.Dn(idmapdb, 'CN=CONFIG')
132     m['lowerbound'] = ldb.MessageElement(str(lowerbound), ldb.FLAG_MOD_REPLACE, 'lowerBound')
133     m['xidNumber'] = ldb.MessageElement(str(currentxid), ldb.FLAG_MOD_REPLACE, 'xidNumber')
134     idmapdb.modify(m)
135
136     for id_type, xid in samba3_idmap.ids():
137         if id_type == 'UID':
138             xid_type = 'ID_TYPE_UID'
139         elif id_type == 'GID':
140             xid_type = 'ID_TYPE_GID'
141         else:
142             logger.warn('Wrong type of entry in idmap (%s), Ignoring', id_type)
143             continue
144
145         sid = samba3_idmap.get_sid(xid, id_type)
146         add_idmap_entry(idmapdb, dom_sid(sid), xid, xid_type, logger)
147
148
149 def add_group_from_mapping_entry(samdb, groupmap, logger):
150     """Add or modify group from group mapping entry
151
152     param samdb: Samba4 SAM database
153     param groupmap: Groupmap entry
154     param logger: Logger object
155     """
156
157     # First try to see if we already have this entry
158     try:
159         msg = samdb.search(base='<SID=%s>' % str(groupmap.sid), scope=ldb.SCOPE_BASE)
160         found = True
161     except ldb.LdbError, (ecode, emsg):
162         if ecode == ldb.ERR_NO_SUCH_OBJECT:
163             found = False
164         else:
165             raise ldb.LdbError(ecode, emsg)
166
167     if found:
168         logger.warn('Group already exists sid=%s, groupname=%s existing_groupname=%s, Ignoring.',
169                             str(groupmap.sid), groupmap.nt_name, msg[0]['sAMAccountName'][0])
170     else:
171         if groupmap.sid_name_use == lsa.SID_NAME_WKN_GRP:
172             # In a lot of Samba3 databases, aliases are marked as well known groups
173             (group_dom_sid, rid) = group.sid.split()
174             if (group_dom_sid != security.dom_sid(security.SID_BUILTIN)):
175                 return
176
177         m = ldb.Message()
178         m.dn = ldb.Dn(samdb, "CN=%s,CN=Users,%s" % (groupmap.nt_name, samdb.get_default_basedn()))
179         m['a01'] = ldb.MessageElement(groupmap.nt_name, ldb.FLAG_MOD_ADD, 'cn')
180         m['a02'] = ldb.MessageElement('group', ldb.FLAG_MOD_ADD, 'objectClass')
181         m['a03'] = ldb.MessageElement(ndr_pack(groupmap.sid), ldb.FLAG_MOD_ADD, 'objectSid')
182         m['a04'] = ldb.MessageElement(groupmap.comment, ldb.FLAG_MOD_ADD, 'description')
183         m['a05'] = ldb.MessageElement(groupmap.nt_name, ldb.FLAG_MOD_ADD, 'sAMAccountName')
184
185         # Fix up incorrect 'well known' groups that are actually builtin (per test above) to be aliases
186         if groupmap.sid_name_use == lsa.SID_NAME_ALIAS or groupmap.sid_name_use == lsa.SID_NAME_WKN_GRP:
187             m['a06'] = ldb.MessageElement(str(dsdb.GTYPE_SECURITY_DOMAIN_LOCAL_GROUP), ldb.FLAG_MOD_ADD, 'groupType')
188
189         try:
190             samdb.add(m, controls=["relax:0"])
191         except ldb.LdbError, e:
192             logger.warn('Could not add group name=%s (%s)', groupmap.nt_name, str(e))
193
194
195 def add_users_to_group(samdb, group, members, logger):
196     """Add user/member to group/alias
197
198     param samdb: Samba4 SAM database
199     param group: Groupmap object
200     param members: List of member SIDs
201     param logger: Logger object
202     """
203     for member_sid in members:
204         m = ldb.Message()
205         m.dn = ldb.Dn(samdb, "<SID=%s>" % str(group.sid))
206         m['a01'] = ldb.MessageElement("<SID=%s>" % str(member_sid), ldb.FLAG_MOD_ADD, 'member')
207
208         try:
209             samdb.modify(m)
210         except ldb.LdbError, (ecode, emsg):
211             if ecode == ldb.ERR_NO_SUCH_OBJECT:
212                 logger.warn("Could not add member '%s' to group '%s' as either group or user record doesn't exist: %s", member_sid, group.sid, emsg)
213             else:
214                 logger.warn("Could not add member '%s' to group '%s': %s", member_sid, group.sid, emsg)
215
216
217 def import_wins(samba4_winsdb, samba3_winsdb):
218     """Import settings from a Samba3 WINS database.
219
220     :param samba4_winsdb: WINS database to import to
221     :param samba3_winsdb: WINS database to import from
222     """
223     version_id = 0
224
225     for (name, (ttl, ips, nb_flags)) in samba3_winsdb.items():
226         version_id+=1
227
228         type = int(name.split("#", 1)[1], 16)
229
230         if type == 0x1C:
231             rType = 0x2
232         elif type & 0x80:
233             if len(ips) > 1:
234                 rType = 0x2
235             else:
236                 rType = 0x1
237         else:
238             if len(ips) > 1:
239                 rType = 0x3
240             else:
241                 rType = 0x0
242
243         if ttl > time.time():
244             rState = 0x0 # active
245         else:
246             rState = 0x1 # released
247
248         nType = ((nb_flags & 0x60)>>5)
249
250         samba4_winsdb.add({"dn": "name=%s,type=0x%s" % tuple(name.split("#")),
251                            "type": name.split("#")[1],
252                            "name": name.split("#")[0],
253                            "objectClass": "winsRecord",
254                            "recordType": str(rType),
255                            "recordState": str(rState),
256                            "nodeType": str(nType),
257                            "expireTime": ldb.timestring(ttl),
258                            "isStatic": "0",
259                            "versionID": str(version_id),
260                            "address": ips})
261
262     samba4_winsdb.add({"dn": "cn=VERSION",
263                        "cn": "VERSION",
264                        "objectClass": "winsMaxVersion",
265                        "maxVersion": str(version_id)})
266
267 def enable_samba3sam(samdb, ldapurl):
268     """Enable Samba 3 LDAP URL database.
269
270     :param samdb: SAM Database.
271     :param ldapurl: Samba 3 LDAP URL
272     """
273     samdb.modify_ldif("""
274 dn: @MODULES
275 changetype: modify
276 replace: @LIST
277 @LIST: samldb,operational,objectguid,rdn_name,samba3sam
278 """)
279
280     samdb.add({"dn": "@MAP=samba3sam", "@MAP_URL": ldapurl})
281
282
283 smbconf_keep = [
284     "dos charset",
285     "unix charset",
286     "display charset",
287     "comment",
288     "path",
289     "directory",
290     "workgroup",
291     "realm",
292     "netbios name",
293     "netbios aliases",
294     "netbios scope",
295     "server string",
296     "interfaces",
297     "bind interfaces only",
298     "security",
299     "auth methods",
300     "encrypt passwords",
301     "null passwords",
302     "obey pam restrictions",
303     "password server",
304     "smb passwd file",
305     "private dir",
306     "passwd chat",
307     "password level",
308     "lanman auth",
309     "ntlm auth",
310     "client NTLMv2 auth",
311     "client lanman auth",
312     "client plaintext auth",
313     "read only",
314     "hosts allow",
315     "hosts deny",
316     "log level",
317     "debuglevel",
318     "log file",
319     "smb ports",
320     "large readwrite",
321     "max protocol",
322     "min protocol",
323     "unicode",
324     "read raw",
325     "write raw",
326     "disable netbios",
327     "nt status support",
328     "max mux",
329     "max xmit",
330     "name resolve order",
331     "max wins ttl",
332     "min wins ttl",
333     "time server",
334     "unix extensions",
335     "use spnego",
336     "server signing",
337     "client signing",
338     "max connections",
339     "paranoid server security",
340     "socket options",
341     "strict sync",
342     "max print jobs",
343     "printable",
344     "print ok",
345     "printer name",
346     "printer",
347     "map system",
348     "map hidden",
349     "map archive",
350     "preferred master",
351     "prefered master",
352     "local master",
353     "browseable",
354     "browsable",
355     "wins server",
356     "wins support",
357     "csc policy",
358     "strict locking",
359     "preload",
360     "auto services",
361     "lock dir",
362     "lock directory",
363     "pid directory",
364     "socket address",
365     "copy",
366     "include",
367     "available",
368     "volume",
369     "fstype",
370     "panic action",
371     "msdfs root",
372     "host msdfs",
373     "winbind separator"]
374
375 def upgrade_smbconf(oldconf,mark):
376     """Remove configuration variables not present in Samba4
377
378     :param oldconf: Old configuration structure
379     :param mark: Whether removed configuration variables should be
380         kept in the new configuration as "samba3:<name>"
381     """
382     data = oldconf.data()
383     newconf = LoadParm()
384
385     for s in data:
386         for p in data[s]:
387             keep = False
388             for k in smbconf_keep:
389                 if smbconf_keep[k] == p:
390                     keep = True
391                     break
392
393             if keep:
394                 newconf.set(s, p, oldconf.get(s, p))
395             elif mark:
396                 newconf.set(s, "samba3:"+p, oldconf.get(s,p))
397
398     return newconf
399
400 SAMBA3_PREDEF_NAMES = {
401         'HKLM': registry.HKEY_LOCAL_MACHINE,
402 }
403
404 def import_registry(samba4_registry, samba3_regdb):
405     """Import a Samba 3 registry database into the Samba 4 registry.
406
407     :param samba4_registry: Samba 4 registry handle.
408     :param samba3_regdb: Samba 3 registry database handle.
409     """
410     def ensure_key_exists(keypath):
411         (predef_name, keypath) = keypath.split("/", 1)
412         predef_id = SAMBA3_PREDEF_NAMES[predef_name]
413         keypath = keypath.replace("/", "\\")
414         return samba4_registry.create_key(predef_id, keypath)
415
416     for key in samba3_regdb.keys():
417         key_handle = ensure_key_exists(key)
418         for subkey in samba3_regdb.subkeys(key):
419             ensure_key_exists(subkey)
420         for (value_name, (value_type, value_data)) in samba3_regdb.values(key).items():
421             key_handle.set_value(value_name, value_type, value_data)
422
423
424 def upgrade_from_samba3(samba3, logger, targetdir, session_info=None, useeadb=False):
425     """Upgrade from samba3 database to samba4 AD database
426
427     :param samba3: samba3 object
428     :param logger: Logger object
429     :param targetdir: samba4 database directory
430     :param session_info: Session information
431     """
432
433     if samba3.lp.get("domain logons"):
434         serverrole = "domain controller"
435     else:
436         if samba3.lp.get("security") == "user":
437             serverrole = "standalone"
438         else:
439             serverrole = "member server"
440
441     domainname = samba3.lp.get("workgroup")
442     realm = samba3.lp.get("realm")
443     netbiosname = samba3.lp.get("netbios name")
444
445     # secrets db
446     secrets_db = samba3.get_secrets_db()
447
448     if not domainname:
449         domainname = secrets_db.domains()[0]
450         logger.warning("No workgroup specified in smb.conf file, assuming '%s'",
451                 domainname)
452
453     if not realm:
454         if serverrole == "domain controller":
455             raise ProvisioningError("No realm specified in smb.conf file and being a DC. That upgrade path doesn't work! Please add a 'realm' directive to your old smb.conf to let us know which one you want to use (it is the DNS name of the AD domain you wish to create.")
456         else:
457             realm = domainname.upper()
458             logger.warning("No realm specified in smb.conf file, assuming '%s'",
459                     realm)
460
461     # Find machine account and password
462     machinepass = None
463     machinerid = None
464     machinesid = None
465     next_rid = 1000
466
467     try:
468         machinepass = secrets_db.get_machine_password(netbiosname)
469     except:
470         pass
471
472     # We must close the direct pytdb database before the C code loads it
473     secrets_db.close()
474
475     # Connect to old password backend
476     passdb.set_secrets_dir(samba3.lp.get("private dir"))
477     s3db = samba3.get_sam_db()
478
479     # Get domain sid
480     try:
481         domainsid = passdb.get_global_sam_sid()
482     except passdb.error:
483         raise Exception("Can't find domain sid for '%s', Exiting." % domainname)
484
485     # Get machine account, sid, rid
486     try:
487         machineacct = s3db.getsampwnam('%s$' % netbiosname)
488         machinesid, machinerid = machineacct.user_sid.split()
489     except:
490         pass
491
492     # Export account policy
493     logger.info("Exporting account policy")
494     policy = s3db.get_account_policy()
495
496     # Export groups from old passdb backend
497     logger.info("Exporting groups")
498     grouplist = s3db.enum_group_mapping()
499     groupmembers = {}
500     for group in grouplist:
501         sid, rid = group.sid.split()
502         if sid == domainsid:
503             if rid >= next_rid:
504                next_rid = rid + 1
505
506         # Get members for each group/alias
507         if group.sid_name_use == lsa.SID_NAME_ALIAS:
508             members = s3db.enum_aliasmem(group.sid)
509         elif group.sid_name_use == lsa.SID_NAME_DOM_GRP:
510             try:
511                 members = s3db.enum_group_members(group.sid)
512             except:
513                 continue
514             groupmembers[group.nt_name] = members
515         elif group.sid_name_use == lsa.SID_NAME_WKN_GRP:
516             (group_dom_sid, rid) = group.sid.split()
517             if (group_dom_sid != security.dom_sid(security.SID_BUILTIN)):
518                 logger.warn("Ignoring 'well known' group '%s' (should already be in AD, and have no members)",
519                             group.nt_name)
520                 continue
521             # A number of buggy databases mix up well known groups and aliases.
522             members = s3db.enum_aliasmem(group.sid)
523         else:
524             logger.warn("Ignoring group '%s' with sid_name_use=%d",
525                         group.nt_name, group.sid_name_use)
526             continue
527
528
529     # Export users from old passdb backend
530     logger.info("Exporting users")
531     userlist = s3db.search_users(0)
532     userdata = {}
533     uids = {}
534     admin_user = None
535     for entry in userlist:
536         if machinerid and machinerid == entry['rid']:
537             continue
538         username = entry['account_name']
539         if entry['rid'] < 1000:
540             logger.info("  Skipping wellknown rid=%d (for username=%s)", entry['rid'], username)
541             continue
542         if entry['rid'] >= next_rid:
543             next_rid = entry['rid'] + 1
544
545         user = s3db.getsampwnam(username)
546         acct_type = (user.acct_ctrl & (samr.ACB_NORMAL|samr.ACB_WSTRUST|samr.ACB_SVRTRUST|samr.ACB_DOMTRUST))
547         if (acct_type == samr.ACB_NORMAL or acct_type == samr.ACB_WSTRUST or acct_type == samr.ACB_SVRTRUST):
548             pass
549         elif acct_type == samr.ACB_DOMTRUST:
550             logger.warn("  Skipping inter-domain trust from domain %s, this trust must be re-created as an AD trust" % username[:-1])
551             continue
552         elif acct_type == (samr.ACB_NORMAL|samr.ACB_WSTRUST) and username[-1] == '$':
553             logger.warn("  Fixing account %s which had both ACB_NORMAL (U) and ACB_WSTRUST (W) set.  Account will be marked as ACB_WSTRUST (W), i.e. as a domain member" % username)
554             user.acct_ctrl = (user.acct_ctrl & ~samr.ACB_NORMAL)
555         else:
556             raise ProvisioningError("""Failed to upgrade due to invalid account %s, account control flags 0x%08X must have exactly one of
557 ACB_NORMAL (N, 0x%08X), ACB_WSTRUST (W 0x%08X), ACB_SVRTRUST (S 0x%08X) or ACB_DOMTRUST (D 0x%08X).
558
559 Please fix this account before attempting to upgrade again
560 """
561                                     % (user.acct_flags, username,
562                                        samr.ACB_NORMAL, samr.ACB_WSTRUST, samr.ACB_SVRTRUST, samr.ACB_DOMTRUST))
563         
564         userdata[username] = user
565         try:
566             uids[username] = s3db.sid_to_id(user.user_sid)[0]
567         except:
568             try:
569                 uids[username] = pwd.getpwnam(username).pw_uid
570             except:
571                 pass
572
573         if not admin_user and username.lower() == 'root':
574             admin_user = username
575         if username.lower() == 'administrator':
576             admin_user = username
577
578     logger.info("Next rid = %d", next_rid)
579
580     # Do full provision
581     result = provision(logger, session_info, None,
582                        targetdir=targetdir, realm=realm, domain=domainname,
583                        domainsid=str(domainsid), next_rid=next_rid,
584                        dc_rid=machinerid,
585                        hostname=netbiosname, machinepass=machinepass,
586                        serverrole=serverrole, samdb_fill=FILL_FULL,
587                        useeadb=useeadb)
588
589     # Import WINS database
590     logger.info("Importing WINS database")
591     import_wins(Ldb(result.paths.winsdb), samba3.get_wins_db())
592
593     # Set Account policy
594     logger.info("Importing Account policy")
595     import_sam_policy(result.samdb, policy, logger)
596
597     # Migrate IDMAP database
598     logger.info("Importing idmap database")
599     import_idmap(result.idmap, samba3, logger)
600
601     # Set the s3 context for samba4 configuration
602     new_lp_ctx = s3param.get_context()
603     new_lp_ctx.load(result.lp.configfile)
604     new_lp_ctx.set("private dir", result.lp.get("private dir"))
605     new_lp_ctx.set("state directory", result.lp.get("state directory"))
606     new_lp_ctx.set("lock directory", result.lp.get("lock directory"))
607
608     # Connect to samba4 backend
609     s4_passdb = passdb.PDB(new_lp_ctx.get("passdb backend"))
610
611     # Export groups to samba4 backend
612     logger.info("Importing groups")
613     for g in grouplist:
614         # Ignore uninitialized groups (gid = -1)
615         if g.gid != 0xffffffff:
616             add_idmap_entry(result.idmap, g.sid, g.gid, "GID", logger)
617             add_group_from_mapping_entry(result.samdb, g, logger)
618
619     # Export users to samba4 backend
620     logger.info("Importing users")
621     for username in userdata:
622         if username.lower() == 'administrator' or username.lower() == 'root':
623             continue
624         s4_passdb.add_sam_account(userdata[username])
625         if username in uids:
626             add_idmap_entry(result.idmap, userdata[username].user_sid, uids[username], "UID", logger)
627
628     logger.info("Adding users to groups")
629     for g in grouplist:
630         if g.nt_name in groupmembers:
631             add_users_to_group(result.samdb, g, groupmembers[g.nt_name], logger)
632
633     # Set password for administrator
634     if admin_user:
635         logger.info("Setting password for administrator")
636         admin_userdata = s4_passdb.getsampwnam("administrator")
637         admin_userdata.nt_passwd = userdata[admin_user].nt_passwd
638         if userdata[admin_user].lanman_passwd:
639             admin_userdata.lanman_passwd = userdata[admin_user].lanman_passwd
640         admin_userdata.pass_last_set_time = userdata[admin_user].pass_last_set_time
641         if userdata[admin_user].pw_history:
642             admin_userdata.pw_history = userdata[admin_user].pw_history
643         s4_passdb.update_sam_account(admin_userdata)
644         logger.info("Administrator password has been set to password of user '%s'", admin_user)
645
646     # FIXME: import_registry(registry.Registry(), samba3.get_registry())
647     # FIXME: shares