source4/scripting/python/samba/netcmd/domain.py

   1 #!/usr/bin/env python
   2 #
   3 # domain management
   4 #
   5 # Copyright Matthias Dieter Wallnoefer 2009
   6 # Copyright Andrew Kroeger 2009
   7 # Copyright Jelmer Vernooij 2009
   8 # Copyright Giampaolo Lauria 2011
   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
  26 import samba.getopt as options
  27 import ldb
  28 import os
  29 from samba import Ldb
  30 from samba.net import Net, LIBNET_JOIN_AUTOMATIC
  31 from samba.dcerpc.misc import SEC_CHAN_WKSTA
  32 from samba.join import join_RODC, join_DC
  33 from samba.auth import system_session
  34 from samba.samdb import SamDB
  35 from samba.dcerpc.samr import DOMAIN_PASSWORD_COMPLEX, DOMAIN_PASSWORD_STORE_CLEARTEXT
  36 from samba.netcmd import (
  37     Command,
  38     CommandError,
  39     SuperCommand,
  40     Option
  41     )
  42
  43 from samba.dsdb import (
  44     DS_DOMAIN_FUNCTION_2000,
  45     DS_DOMAIN_FUNCTION_2003,
  46     DS_DOMAIN_FUNCTION_2003_MIXED,
  47     DS_DOMAIN_FUNCTION_2008,
  48     DS_DOMAIN_FUNCTION_2008_R2,
  49     )
  50
  51
  52
  53 class cmd_domain_export_keytab(Command):
  54     """Dumps kerberos keys of the domain into a keytab"""
  55     synopsis = "%prog domain exportkeytab <keytab>"
  56
  57     takes_options = [
  58         ]
  59
  60     takes_args = ["keytab"]
  61
  62     def run(self, keytab, credopts=None, sambaopts=None, versionopts=None):
  63         lp = sambaopts.get_loadparm()
  64         net = Net(None, lp, server=credopts.ipaddress)
  65         net.export_keytab(keytab=keytab)
  66
  67
  68
  69 class cmd_domain_join(Command):
  70     """Joins domain as either member or backup domain controller [server connection needed]"""
  71
  72     synopsis = "%prog domain join <dnsdomain> [DC | RODC | MEMBER] [options]"
  73
  74     takes_options = [
  75         Option("--server", help="DC to join", type=str),
  76         Option("--site", help="site to join", type=str),
  77         Option("--targetdir", help="where to store provision", type=str),
  78         Option("--domain-critical-only",
  79                help="only replicate critical domain objects",
  80                action="store_true"),
  81         ]
  82
  83     takes_args = ["domain", "role?"]
  84
  85     def run(self, domain, role=None, sambaopts=None, credopts=None,
  86             versionopts=None, server=None, site=None, targetdir=None,
  87             domain_critical_only=False):
  88         lp = sambaopts.get_loadparm()
  89         creds = credopts.get_credentials(lp)
  90         net = Net(creds, lp, server=credopts.ipaddress)
  91
  92         if site is None:
  93             site = "Default-First-Site-Name"
  94
  95         netbios_name = lp.get("netbios name")
  96
  97         if not role is None:
  98             role = role.upper()
  99
 100         if role is None or role == "MEMBER":
 101             (join_password, sid, domain_name) = net.join_member(domain,
 102                                                                 netbios_name,
 103                                                                 LIBNET_JOIN_AUTOMATIC)
 104
 105             self.outf.write("Joined domain %s (%s)\n" % (domain_name, sid))
 106             return
 107         elif role == "DC":
 108             join_DC(server=server, creds=creds, lp=lp, domain=domain,
 109                     site=site, netbios_name=netbios_name, targetdir=targetdir,
 110                     domain_critical_only=domain_critical_only)
 111             return
 112         elif role == "RODC":
 113             join_RODC(server=server, creds=creds, lp=lp, domain=domain,
 114                       site=site, netbios_name=netbios_name, targetdir=targetdir,
 115                       domain_critical_only=domain_critical_only)
 116             return
 117         else:
 118             raise CommandError("Invalid role %s (possible values: MEMBER, BDC, RODC)" % role)
 119
 120
 121
 122 class cmd_domain_level(Command):
 123     """Raises domain and forest function levels"""
 124
 125     synopsis = "%prog domain level (show | raise <options>)"
 126
 127     takes_options = [
 128         Option("-H", "--URL", help="LDB URL for database or target server", type=str,
 129                metavar="URL", dest="H"),
 130         Option("--quiet", help="Be quiet", action="store_true"),
 131         Option("--forest", type="choice", choices=["2003", "2008", "2008_R2"],
 132             help="The forest function level (2003 | 2008 | 2008_R2)"),
 133             ]
 134
 135     takes_args = ["subcommand"]
 136
 137     def run(self, subcommand, H=None, forest=None, domain=None, quiet=False,
 138             credopts=None, sambaopts=None, versionopts=None):
 139         lp = sambaopts.get_loadparm()
 140         creds = credopts.get_credentials(lp, fallback_machine=True)
 141
 142         samdb = SamDB(url=H, session_info=system_session(),
 143             credentials=creds, lp=lp)
 144
 145         domain_dn = samdb.domain_dn()
 146
 147         res_forest = samdb.search("CN=Partitions,CN=Configuration," + domain_dn,
 148           scope=ldb.SCOPE_BASE, attrs=["msDS-Behavior-Version"])
 149         assert len(res_forest) == 1
 150
 151         res_domain = samdb.search(domain_dn, scope=ldb.SCOPE_BASE,
 152           attrs=["msDS-Behavior-Version", "nTMixedDomain"])
 153         assert len(res_domain) == 1
 154
 155         res_dc_s = samdb.search("CN=Sites,CN=Configuration," + domain_dn,
 156           scope=ldb.SCOPE_SUBTREE, expression="(objectClass=nTDSDSA)",
 157           attrs=["msDS-Behavior-Version"])
 158         assert len(res_dc_s) >= 1
 159
 160         try:
 161             level_forest = int(res_forest[0]["msDS-Behavior-Version"][0])
 162             level_domain = int(res_domain[0]["msDS-Behavior-Version"][0])
 163             level_domain_mixed = int(res_domain[0]["nTMixedDomain"][0])
 164
 165             min_level_dc = int(res_dc_s[0]["msDS-Behavior-Version"][0]) # Init value
 166             for msg in res_dc_s:
 167                 if int(msg["msDS-Behavior-Version"][0]) < min_level_dc:
 168                     min_level_dc = int(msg["msDS-Behavior-Version"][0])
 169
 170             if level_forest < 0 or level_domain < 0:
 171                 raise CommandError("Domain and/or forest function level(s) is/are invalid. Correct them or reprovision!")
 172             if min_level_dc < 0:
 173                 raise CommandError("Lowest function level of a DC is invalid. Correct this or reprovision!")
 174             if level_forest > level_domain:
 175                 raise CommandError("Forest function level is higher than the domain level(s). Correct this or reprovision!")
 176             if level_domain > min_level_dc:
 177                 raise CommandError("Domain function level is higher than the lowest function level of a DC. Correct this or reprovision!")
 178
 179         except KeyError:
 180             raise CommandError("Could not retrieve the actual domain, forest level and/or lowest DC function level!")
 181
 182         if subcommand == "show":
 183             self.message("Domain and forest function level for domain '%s'" % domain_dn)
 184             if level_forest == DS_DOMAIN_FUNCTION_2000 and level_domain_mixed != 0:
 185                 self.message("\nATTENTION: You run SAMBA 4 on a forest function level lower than Windows 2000 (Native). This isn't supported! Please raise!")
 186             if level_domain == DS_DOMAIN_FUNCTION_2000 and level_domain_mixed != 0:
 187                 self.message("\nATTENTION: You run SAMBA 4 on a domain function level lower than Windows 2000 (Native). This isn't supported! Please raise!")
 188             if min_level_dc == DS_DOMAIN_FUNCTION_2000 and level_domain_mixed != 0:
 189                 self.message("\nATTENTION: You run SAMBA 4 on a lowest function level of a DC lower than Windows 2003. This isn't supported! Please step-up or upgrade the concerning DC(s)!")
 190
 191             self.message("")
 192
 193             if level_forest == DS_DOMAIN_FUNCTION_2000:
 194                 outstr = "2000"
 195             elif level_forest == DS_DOMAIN_FUNCTION_2003_MIXED:
 196                 outstr = "2003 with mixed domains/interim (NT4 DC support)"
 197             elif level_forest == DS_DOMAIN_FUNCTION_2003:
 198                 outstr = "2003"
 199             elif level_forest == DS_DOMAIN_FUNCTION_2008:
 200                 outstr = "2008"
 201             elif level_forest == DS_DOMAIN_FUNCTION_2008_R2:
 202                 outstr = "2008 R2"
 203             else:
 204                 outstr = "higher than 2008 R2"
 205             self.message("Forest function level: (Windows) " + outstr)
 206
 207             if level_domain == DS_DOMAIN_FUNCTION_2000 and level_domain_mixed != 0:
 208                 outstr = "2000 mixed (NT4 DC support)"
 209             elif level_domain == DS_DOMAIN_FUNCTION_2000 and level_domain_mixed == 0:
 210                 outstr = "2000"
 211             elif level_domain == DS_DOMAIN_FUNCTION_2003_MIXED:
 212                 outstr = "2003 with mixed domains/interim (NT4 DC support)"
 213             elif level_domain == DS_DOMAIN_FUNCTION_2003:
 214                 outstr = "2003"
 215             elif level_domain == DS_DOMAIN_FUNCTION_2008:
 216                 outstr = "2008"
 217             elif level_domain == DS_DOMAIN_FUNCTION_2008_R2:
 218                 outstr = "2008 R2"
 219             else:
 220                 outstr = "higher than 2008 R2"
 221             self.message("Lowest function level of a DC: (Windows) " + outstr)
 222
 223         elif subcommand == "raise":
 224             msgs = []
 225
 226             if domain is not None:
 227                 if domain == "2003":
 228                     new_level_domain = DS_DOMAIN_FUNCTION_2003
 229                 elif domain == "2008":
 230                     new_level_domain = DS_DOMAIN_FUNCTION_2008
 231                 elif domain == "2008_R2":
 232                     new_level_domain = DS_DOMAIN_FUNCTION_2008_R2
 233
 234                 if new_level_domain <= level_domain and level_domain_mixed == 0:
 235                     raise CommandError("Domain function level can't be smaller equal to the actual one!")
 236
 237                 if new_level_domain > min_level_dc:
 238                     raise CommandError("Domain function level can't be higher than the lowest function level of a DC!")
 239
 240                 # Deactivate mixed/interim domain support
 241                 if level_domain_mixed != 0:
 242                     # Directly on the base DN
 243                     m = ldb.Message()
 244                     m.dn = ldb.Dn(samdb, domain_dn)
 245                     m["nTMixedDomain"] = ldb.MessageElement("0",
 246                       ldb.FLAG_MOD_REPLACE, "nTMixedDomain")
 247                     samdb.modify(m)
 248                     # Under partitions
 249                     m = ldb.Message()
 250                     m.dn = ldb.Dn(samdb, "CN=" + lp.get("workgroup")
 251                       + ",CN=Partitions,CN=Configuration," + domain_dn)
 252                     m["nTMixedDomain"] = ldb.MessageElement("0",
 253                       ldb.FLAG_MOD_REPLACE, "nTMixedDomain")
 254                     try:
 255                         samdb.modify(m)
 256                     except ldb.LdbError, (enum, emsg):
 257                         if enum != ldb.ERR_UNWILLING_TO_PERFORM:
 258                             raise
 259
 260                 # Directly on the base DN
 261                 m = ldb.Message()
 262                 m.dn = ldb.Dn(samdb, domain_dn)
 263                 m["msDS-Behavior-Version"]= ldb.MessageElement(                                                                                             str(new_level_domain), ldb.FLAG_MOD_REPLACE,
 264                             "msDS-Behavior-Version")
 265                 samdb.modify(m)
 266                 # Under partitions
 267                 m = ldb.Message()
 268                 m.dn = ldb.Dn(samdb, "CN=" + lp.get("workgroup")
 269                   + ",CN=Partitions,CN=Configuration," + domain_dn)
 270                 m["msDS-Behavior-Version"]= ldb.MessageElement(
 271                   str(new_level_domain), ldb.FLAG_MOD_REPLACE,
 272                           "msDS-Behavior-Version")
 273                 try:
 274                     samdb.modify(m)
 275                 except ldb.LdbError, (enum, emsg):
 276                     if enum != ldb.ERR_UNWILLING_TO_PERFORM:
 277                         raise
 278
 279                 level_domain = new_level_domain
 280                 msgs.append("Domain function level changed!")
 281
 282             if forest is not None:
 283                 if forest == "2003":
 284                     new_level_forest = DS_DOMAIN_FUNCTION_2003
 285                 elif forest == "2008":
 286                     new_level_forest = DS_DOMAIN_FUNCTION_2008
 287                 elif forest == "2008_R2":
 288                     new_level_forest = DS_DOMAIN_FUNCTION_2008_R2
 289                 if new_level_forest <= level_forest:
 290                     raise CommandError("Forest function level can't be smaller equal to the actual one!")
 291                 if new_level_forest > level_domain:
 292                     raise CommandError("Forest function level can't be higher than the domain function level(s). Please raise it/them first!")
 293                 m = ldb.Message()
 294                 m.dn = ldb.Dn(samdb, "CN=Partitions,CN=Configuration,"
 295                   + domain_dn)
 296                 m["msDS-Behavior-Version"]= ldb.MessageElement(
 297                   str(new_level_forest), ldb.FLAG_MOD_REPLACE,
 298                           "msDS-Behavior-Version")
 299                 samdb.modify(m)
 300                 msgs.append("Forest function level changed!")
 301             msgs.append("All changes applied successfully!")
 302             self.message("\n".join(msgs))
 303         else:
 304             raise CommandError("Wrong argument '%s'!" % subcommand)
 305
 306
 307
 308 class cmd_domain_machinepassword(Command):
 309     """Gets a machine password out of our SAM"""
 310
 311     synopsis = "%prog domain machinepassword <accountname>"
 312
 313     takes_args = ["secret"]
 314
 315     def run(self, secret, sambaopts=None, credopts=None, versionopts=None):
 316         lp = sambaopts.get_loadparm()
 317         creds = credopts.get_credentials(lp, fallback_machine=True)
 318         name = lp.get("secrets database")
 319         path = lp.get("private dir")
 320         url = os.path.join(path, name)
 321         if not os.path.exists(url):
 322             raise CommandError("secret database not found at %s " % url)
 323         secretsdb = Ldb(url=url, session_info=system_session(),
 324             credentials=creds, lp=lp)
 325         result = secretsdb.search(attrs=["secret"],
 326             expression="(&(objectclass=primaryDomain)(samaccountname=%s))" % ldb.binary_encode(secret))
 327
 328         if len(result) != 1:
 329             raise CommandError("search returned %d records, expected 1" % len(result))
 330
 331         self.outf.write("%s\n" % result[0]["secret"])
 332
 333
 334
 335 class cmd_domain_passwordsettings(Command):
 336     """Sets password settings
 337
 338     Password complexity, history length, minimum password length, the minimum
 339     and maximum password age) on a Samba4 server.
 340     """
 341
 342     synopsis = "%prog domain passwordsettings (show | set <options>)"
 343
 344     takes_options = [
 345         Option("-H", "--URL", help="LDB URL for database or target server", type=str,
 346                metavar="URL", dest="H"),
 347         Option("--quiet", help="Be quiet", action="store_true"),
 348         Option("--complexity", type="choice", choices=["on","off","default"],
 349           help="The password complexity (on | off | default). Default is 'on'"),
 350         Option("--store-plaintext", type="choice", choices=["on","off","default"],
 351           help="Store plaintext passwords where account have 'store passwords with reversible encryption' set (on | off | default). Default is 'off'"),
 352         Option("--history-length",
 353           help="The password history length (<integer> | default).  Default is 24.", type=str),
 354         Option("--min-pwd-length",
 355           help="The minimum password length (<integer> | default).  Default is 7.", type=str),
 356         Option("--min-pwd-age",
 357           help="The minimum password age (<integer in days> | default).  Default is 1.", type=str),
 358         Option("--max-pwd-age",
 359           help="The maximum password age (<integer in days> | default).  Default is 43.", type=str),
 360           ]
 361
 362     takes_args = ["subcommand"]
 363
 364     def run(self, subcommand, H=None, min_pwd_age=None, max_pwd_age=None,
 365             quiet=False, complexity=None, store_plaintext=None, history_length=None,
 366             min_pwd_length=None, credopts=None, sambaopts=None,
 367             versionopts=None):
 368         lp = sambaopts.get_loadparm()
 369         creds = credopts.get_credentials(lp)
 370
 371         samdb = SamDB(url=H, session_info=system_session(),
 372             credentials=creds, lp=lp)
 373
 374         domain_dn = samdb.domain_dn()
 375         res = samdb.search(domain_dn, scope=ldb.SCOPE_BASE,
 376           attrs=["pwdProperties", "pwdHistoryLength", "minPwdLength",
 377                  "minPwdAge", "maxPwdAge"])
 378         assert(len(res) == 1)
 379         try:
 380             pwd_props = int(res[0]["pwdProperties"][0])
 381             pwd_hist_len = int(res[0]["pwdHistoryLength"][0])
 382             cur_min_pwd_len = int(res[0]["minPwdLength"][0])
 383             # ticks -> days
 384             cur_min_pwd_age = int(abs(int(res[0]["minPwdAge"][0])) / (1e7 * 60 * 60 * 24))
 385             cur_max_pwd_age = int(abs(int(res[0]["maxPwdAge"][0])) / (1e7 * 60 * 60 * 24))
 386         except Exception, e:
 387             raise CommandError("Could not retrieve password properties!", e)
 388
 389         if subcommand == "show":
 390             self.message("Password informations for domain '%s'" % domain_dn)
 391             self.message("")
 392             if pwd_props & DOMAIN_PASSWORD_COMPLEX != 0:
 393                 self.message("Password complexity: on")
 394             else:
 395                 self.message("Password complexity: off")
 396             if pwd_props & DOMAIN_PASSWORD_STORE_CLEARTEXT != 0:
 397                 self.message("Store plaintext passwords: on")
 398             else:
 399                 self.message("Store plaintext passwords: off")
 400             self.message("Password history length: %d" % pwd_hist_len)
 401             self.message("Minimum password length: %d" % cur_min_pwd_len)
 402             self.message("Minimum password age (days): %d" % cur_min_pwd_age)
 403             self.message("Maximum password age (days): %d" % cur_max_pwd_age)
 404         elif subcommand == "set":
 405             msgs = []
 406             m = ldb.Message()
 407             m.dn = ldb.Dn(samdb, domain_dn)
 408
 409             if complexity is not None:
 410                 if complexity == "on" or complexity == "default":
 411                     pwd_props = pwd_props | DOMAIN_PASSWORD_COMPLEX
 412                     msgs.append("Password complexity activated!")
 413                 elif complexity == "off":
 414                     pwd_props = pwd_props & (~DOMAIN_PASSWORD_COMPLEX)
 415                     msgs.append("Password complexity deactivated!")
 416
 417             if store_plaintext is not None:
 418                 if store_plaintext == "on" or store_plaintext == "default":
 419                     pwd_props = pwd_props | DOMAIN_PASSWORD_STORE_CLEARTEXT
 420                     msgs.append("Plaintext password storage for changed passwords activated!")
 421                 elif store_plaintext == "off":
 422                     pwd_props = pwd_props & (~DOMAIN_PASSWORD_STORE_CLEARTEXT)
 423                     msgs.append("Plaintext password storage for changed passwords deactivated!")
 424
 425             if complexity is not None or store_plaintext is not None:
 426                 m["pwdProperties"] = ldb.MessageElement(str(pwd_props),
 427                   ldb.FLAG_MOD_REPLACE, "pwdProperties")
 428
 429             if history_length is not None:
 430                 if history_length == "default":
 431                     pwd_hist_len = 24
 432                 else:
 433                     pwd_hist_len = int(history_length)
 434
 435                 if pwd_hist_len < 0 or pwd_hist_len > 24:
 436                     raise CommandError("Password history length must be in the range of 0 to 24!")
 437
 438                 m["pwdHistoryLength"] = ldb.MessageElement(str(pwd_hist_len),
 439                   ldb.FLAG_MOD_REPLACE, "pwdHistoryLength")
 440                 msgs.append("Password history length changed!")
 441
 442             if min_pwd_length is not None:
 443                 if min_pwd_length == "default":
 444                     min_pwd_len = 7
 445                 else:
 446                     min_pwd_len = int(min_pwd_length)
 447
 448                 if min_pwd_len < 0 or min_pwd_len > 14:
 449                     raise CommandError("Minimum password length must be in the range of 0 to 14!")
 450
 451                 m["minPwdLength"] = ldb.MessageElement(str(min_pwd_len),
 452                   ldb.FLAG_MOD_REPLACE, "minPwdLength")
 453                 msgs.append("Minimum password length changed!")
 454
 455             if min_pwd_age is not None:
 456                 if min_pwd_age == "default":
 457                     min_pwd_age = 1
 458                 else:
 459                     min_pwd_age = int(min_pwd_age)
 460
 461                 if min_pwd_age < 0 or min_pwd_age > 998:
 462                     raise CommandError("Minimum password age must be in the range of 0 to 998!")
 463
 464                 # days -> ticks
 465                 min_pwd_age_ticks = -int(min_pwd_age * (24 * 60 * 60 * 1e7))
 466
 467                 m["minPwdAge"] = ldb.MessageElement(str(min_pwd_age_ticks),
 468                   ldb.FLAG_MOD_REPLACE, "minPwdAge")
 469                 msgs.append("Minimum password age changed!")
 470
 471             if max_pwd_age is not None:
 472                 if max_pwd_age == "default":
 473                     max_pwd_age = 43
 474                 else:
 475                     max_pwd_age = int(max_pwd_age)
 476
 477                 if max_pwd_age < 0 or max_pwd_age > 999:
 478                     raise CommandError("Maximum password age must be in the range of 0 to 999!")
 479
 480                 # days -> ticks
 481                 max_pwd_age_ticks = -int(max_pwd_age * (24 * 60 * 60 * 1e7))
 482
 483                 m["maxPwdAge"] = ldb.MessageElement(str(max_pwd_age_ticks),
 484                   ldb.FLAG_MOD_REPLACE, "maxPwdAge")
 485                 msgs.append("Maximum password age changed!")
 486
 487             if max_pwd_age > 0 and min_pwd_age >= max_pwd_age:
 488                 raise CommandError("Maximum password age (%d) must be greater than minimum password age (%d)!" % (max_pwd_age, min_pwd_age))
 489
 490             if len(m) == 0:
 491                 raise CommandError("You must specify at least one option to set. Try --help")
 492             samdb.modify(m)
 493             msgs.append("All changes applied successfully!")
 494             self.message("\n".join(msgs))
 495         else:
 496             raise CommandError("Wrong argument '%s'!" % subcommand)
 497
 498
 499
 500 class cmd_domain(SuperCommand):
 501     """Domain management"""
 502
 503     subcommands = {}
 504     subcommands["exportkeytab"] = cmd_domain_export_keytab()
 505     subcommands["join"] = cmd_domain_join()
 506     subcommands["level"] = cmd_domain_level()
 507     subcommands["machinepassword"] = cmd_domain_machinepassword()
 508     subcommands["passwordsettings"] = cmd_domain_passwordsettings()