python/samba/upgradehelpers.py

   1 # Helpers for provision stuff
   2 # Copyright (C) Matthieu Patou <mat@matws.net> 2009-2012
   3 #
   4 # Based on provision a Samba4 server by
   5 # Copyright (C) Jelmer Vernooij <jelmer@samba.org> 2007-2008
   6 # Copyright (C) Andrew Bartlett <abartlet@samba.org> 2008
   7 #
   8 #
   9 # This program is free software; you can redistribute it and/or modify
  10 # it under the terms of the GNU General Public License as published by
  11 # the Free Software Foundation; either version 3 of the License, or
  12 # (at your option) any later version.
  13 #
  14 # This program is distributed in the hope that it will be useful,
  15 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 # GNU General Public License for more details.
  18 #
  19 # You should have received a copy of the GNU General Public License
  20 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
  21
  22 from __future__ import print_function
  23 from __future__ import division
  24 """Helpers used for upgrading between different database formats."""
  25
  26 import os
  27 import re
  28 import shutil
  29 import samba
  30
  31 from samba.compat import cmp_fn
  32 from samba import Ldb, version, ntacls
  33 from ldb import SCOPE_SUBTREE, SCOPE_ONELEVEL, SCOPE_BASE
  34 import ldb
  35 from samba.provision import (provision_paths_from_lp,
  36                              getpolicypath, set_gpos_acl, create_gpo_struct,
  37                              provision, ProvisioningError,
  38                              setsysvolacl, secretsdb_self_join)
  39 from samba.provision.common import FILL_FULL
  40 from samba.dcerpc import xattr, drsblobs, security
  41 from samba.dcerpc.misc import SEC_CHAN_BDC
  42 from samba.ndr import ndr_unpack
  43 from samba.samdb import SamDB
  44 from samba import _glue
  45 import tempfile
  46
  47 # All the ldb related to registry are commented because the path for them is
  48 # relative in the provisionPath object
  49 # And so opening them create a file in the current directory which is not what
  50 # we want
  51 # I still keep them commented because I plan soon to make more cleaner
  52 ERROR = -1
  53 SIMPLE = 0x00
  54 CHANGE = 0x01
  55 CHANGESD = 0x02
  56 GUESS = 0x04
  57 PROVISION = 0x08
  58 CHANGEALL = 0xff
  59
  60 hashAttrNotCopied = set(["dn", "whenCreated", "whenChanged", "objectGUID",
  61                          "uSNCreated", "replPropertyMetaData", "uSNChanged", "parentGUID",
  62                          "objectCategory", "distinguishedName", "nTMixedDomain",
  63                          "showInAdvancedViewOnly", "instanceType", "msDS-Behavior-Version",
  64                          "nextRid", "cn", "versionNumber", "lmPwdHistory", "pwdLastSet",
  65                          "ntPwdHistory", "unicodePwd", "dBCSPwd", "supplementalCredentials",
  66                          "gPCUserExtensionNames", "gPCMachineExtensionNames", "maxPwdAge", "secret",
  67                          "possibleInferiors", "privilege", "sAMAccountType"])
  68
  69
  70 class ProvisionLDB(object):
  71
  72     def __init__(self):
  73         self.sam = None
  74         self.secrets = None
  75         self.idmap = None
  76         self.privilege = None
  77         self.hkcr = None
  78         self.hkcu = None
  79         self.hku = None
  80         self.hklm = None
  81
  82     def dbs(self):
  83         return (self.sam, self.secrets, self.idmap, self.privilege)
  84
  85     def startTransactions(self):
  86         for db in self.dbs():
  87             db.transaction_start()
  88 # TO BE DONE
  89 #        self.hkcr.transaction_start()
  90 #        self.hkcu.transaction_start()
  91 #        self.hku.transaction_start()
  92 #        self.hklm.transaction_start()
  93
  94     def groupedRollback(self):
  95         ok = True
  96         for db in self.dbs():
  97             try:
  98                 db.transaction_cancel()
  99             except Exception:
 100                 ok = False
 101         return ok
 102 # TO BE DONE
 103 #        self.hkcr.transaction_cancel()
 104 #        self.hkcu.transaction_cancel()
 105 #        self.hku.transaction_cancel()
 106 #        self.hklm.transaction_cancel()
 107
 108     def groupedCommit(self):
 109         try:
 110             for db in self.dbs():
 111                 db.transaction_prepare_commit()
 112         except Exception:
 113             return self.groupedRollback()
 114 # TO BE DONE
 115 #        self.hkcr.transaction_prepare_commit()
 116 #        self.hkcu.transaction_prepare_commit()
 117 #        self.hku.transaction_prepare_commit()
 118 #        self.hklm.transaction_prepare_commit()
 119         try:
 120             for db in self.dbs():
 121                 db.transaction_commit()
 122         except Exception:
 123             return self.groupedRollback()
 124
 125 # TO BE DONE
 126 #        self.hkcr.transaction_commit()
 127 #        self.hkcu.transaction_commit()
 128 #        self.hku.transaction_commit()
 129 #        self.hklm.transaction_commit()
 130         return True
 131
 132
 133 def get_ldbs(paths, creds, session, lp):
 134     """Return LDB object mapped on most important databases
 135
 136     :param paths: An object holding the different importants paths for provision object
 137     :param creds: Credential used for openning LDB files
 138     :param session: Session to use for openning LDB files
 139     :param lp: A loadparam object
 140     :return: A ProvisionLDB object that contains LDB object for the different LDB files of the provision"""
 141
 142     ldbs = ProvisionLDB()
 143
 144     ldbs.sam = SamDB(paths.samdb,
 145                      session_info=session,
 146                      credentials=creds,
 147                      lp=lp,
 148                      options=["modules:samba_dsdb"],
 149                      flags=0)
 150     ldbs.secrets = Ldb(paths.secrets, session_info=session, credentials=creds, lp=lp)
 151     ldbs.idmap = Ldb(paths.idmapdb, session_info=session, credentials=creds, lp=lp)
 152     ldbs.privilege = Ldb(paths.privilege, session_info=session, credentials=creds, lp=lp)
 153 #    ldbs.hkcr = Ldb(paths.hkcr, session_info=session, credentials=creds, lp=lp)
 154 #    ldbs.hkcu = Ldb(paths.hkcu, session_info=session, credentials=creds, lp=lp)
 155 #    ldbs.hku = Ldb(paths.hku, session_info=session, credentials=creds, lp=lp)
 156 #    ldbs.hklm = Ldb(paths.hklm, session_info=session, credentials=creds, lp=lp)
 157
 158     return ldbs
 159
 160
 161 def usn_in_range(usn, range):
 162     """Check if the usn is in one of the range provided.
 163     To do so, the value is checked to be between the lower bound and
 164     higher bound of a range
 165
 166     :param usn: A integer value corresponding to the usn that we want to update
 167     :param range: A list of integer representing ranges, lower bounds are in
 168                   the even indices, higher in odd indices
 169     :return: True if the usn is in one of the range, False otherwise
 170     """
 171
 172     idx = 0
 173     cont = True
 174     ok = False
 175     while cont:
 176         if idx == len(range):
 177             cont = False
 178             continue
 179         if usn < int(range[idx]):
 180             if idx % 2 == 1:
 181                 ok = True
 182             cont = False
 183         if usn == int(range[idx]):
 184             cont = False
 185             ok = True
 186         idx = idx + 1
 187     return ok
 188
 189
 190 def get_paths(param, targetdir=None, smbconf=None):
 191     """Get paths to important provision objects (smb.conf, ldb files, ...)
 192
 193     :param param: Param object
 194     :param targetdir: Directory where the provision is (or will be) stored
 195     :param smbconf: Path to the smb.conf file
 196     :return: A list with the path of important provision objects"""
 197     if targetdir is not None:
 198         if not os.path.exists(targetdir):
 199             os.mkdir(targetdir)
 200         etcdir = os.path.join(targetdir, "etc")
 201         if not os.path.exists(etcdir):
 202             os.makedirs(etcdir)
 203         smbconf = os.path.join(etcdir, "smb.conf")
 204     if smbconf is None:
 205         smbconf = param.default_path()
 206
 207     if not os.path.exists(smbconf):
 208         raise ProvisioningError("Unable to find smb.conf at %s" % smbconf)
 209
 210     lp = param.LoadParm()
 211     lp.load(smbconf)
 212     paths = provision_paths_from_lp(lp, lp.get("realm"))
 213     return paths
 214
 215
 216 def update_policyids(names, samdb):
 217     """Update policy ids that could have changed after sam update
 218
 219     :param names: List of key provision parameters
 220     :param samdb: An Ldb object conntected with the sam DB
 221     """
 222     # policy guid
 223     res = samdb.search(expression="(displayName=Default Domain Policy)",
 224                        base="CN=Policies,CN=System," + str(names.rootdn),
 225                        scope=SCOPE_ONELEVEL, attrs=["cn", "displayName"])
 226     names.policyid = str(res[0]["cn"]).replace("{", "").replace("}", "")
 227     # dc policy guid
 228     res2 = samdb.search(expression="(displayName=Default Domain Controllers"
 229                                    " Policy)",
 230                         base="CN=Policies,CN=System," + str(names.rootdn),
 231                         scope=SCOPE_ONELEVEL, attrs=["cn", "displayName"])
 232     if len(res2) == 1:
 233         names.policyid_dc = str(res2[0]["cn"]).replace("{", "").replace("}", "")
 234     else:
 235         names.policyid_dc = None
 236
 237
 238 def newprovision(names, session, smbconf, provdir, logger, base_schema=None):
 239     """Create a new provision.
 240
 241     This provision will be the reference for knowing what has changed in the
 242     since the latest upgrade in the current provision
 243
 244     :param names: List of provision parameters
 245     :param creds: Credentials for the authentification
 246     :param session: Session object
 247     :param smbconf: Path to the smb.conf file
 248     :param provdir: Directory where the provision will be stored
 249     :param logger: A Logger
 250     """
 251     if os.path.isdir(provdir):
 252         shutil.rmtree(provdir)
 253     os.mkdir(provdir)
 254     logger.info("Provision stored in %s", provdir)
 255     return provision(logger, session, smbconf=smbconf,
 256                      targetdir=provdir, samdb_fill=FILL_FULL, realm=names.realm,
 257                      domain=names.domain, domainguid=names.domainguid,
 258                      domainsid=names.domainsid, ntdsguid=names.ntdsguid,
 259                      policyguid=names.policyid, policyguid_dc=names.policyid_dc,
 260                      hostname=names.netbiosname.lower(), hostip=None, hostip6=None,
 261                      invocationid=names.invocation, adminpass=names.adminpass,
 262                      krbtgtpass=None, machinepass=None, dnspass=None, root=None,
 263                      nobody=None, users=None,
 264                      serverrole="domain controller",
 265                      backend_type=None, ldapadminpass=None, ol_mmr_urls=None,
 266                      slapd_path=None,
 267                      dom_for_fun_level=names.domainlevel, dns_backend=names.dns_backend,
 268                      useeadb=True, use_ntvfs=True, base_schema=base_schema)
 269
 270
 271 def dn_sort(x, y):
 272     """Sorts two DNs in the lexicographical order it and put higher level DN
 273     before.
 274
 275     So given the dns cn=bar,cn=foo and cn=foo the later will be return as
 276     smaller
 277
 278     :param x: First object to compare
 279     :param y: Second object to compare
 280     """
 281     p = re.compile(r'(?<!\\), ?')
 282     tab1 = p.split(str(x))
 283     tab2 = p.split(str(y))
 284     minimum = min(len(tab1), len(tab2))
 285     len1 = len(tab1) -1
 286     len2 = len(tab2) -1
 287     # Note: python range go up to upper limit but do not include it
 288     for i in range(0, minimum):
 289         ret = cmp_fn(tab1[len1 - i], tab2[len2 - i])
 290         if ret != 0:
 291             return ret
 292         else:
 293             if i == minimum - 1:
 294                 assert len1 != len2, "PB PB PB" + " ".join(tab1) + " / " + " ".join(tab2)
 295                 if len1 > len2:
 296                     return 1
 297                 else:
 298                     return -1
 299     return ret
 300
 301
 302 def identic_rename(ldbobj, dn):
 303     """Perform a back and forth rename to trigger renaming on attribute that
 304     can't be directly modified.
 305
 306     :param lbdobj: An Ldb Object
 307     :param dn: DN of the object to manipulate
 308     """
 309     (before, after) = str(dn).split('=', 1)
 310     # we need to use relax to avoid the subtree_rename constraints
 311     ldbobj.rename(dn, ldb.Dn(ldbobj, "%s=foo%s" % (before, after)), ["relax:0"])
 312     ldbobj.rename(ldb.Dn(ldbobj, "%s=foo%s" % (before, after)), dn, ["relax:0"])
 313
 314
 315 def update_secrets(newsecrets_ldb, secrets_ldb, messagefunc):
 316     """Update secrets.ldb
 317
 318     :param newsecrets_ldb: An LDB object that is connected to the secrets.ldb
 319         of the reference provision
 320     :param secrets_ldb: An LDB object that is connected to the secrets.ldb
 321         of the updated provision
 322     """
 323
 324     messagefunc(SIMPLE, "Update of secrets.ldb")
 325     reference = newsecrets_ldb.search(base="@MODULES", scope=SCOPE_BASE)
 326     current = secrets_ldb.search(base="@MODULES", scope=SCOPE_BASE)
 327     assert reference, "Reference modules list can not be empty"
 328     if len(current) == 0:
 329         # No modules present
 330         delta = secrets_ldb.msg_diff(ldb.Message(), reference[0])
 331         delta.dn = reference[0].dn
 332         secrets_ldb.add(reference[0])
 333     else:
 334         delta = secrets_ldb.msg_diff(current[0], reference[0])
 335         delta.dn = current[0].dn
 336         secrets_ldb.modify(delta)
 337
 338     reference = newsecrets_ldb.search(expression="objectClass=top", base="",
 339                                       scope=SCOPE_SUBTREE, attrs=["dn"])
 340     current = secrets_ldb.search(expression="objectClass=top", base="",
 341                                  scope=SCOPE_SUBTREE, attrs=["dn"])
 342     hash_new = {}
 343     hash = {}
 344     listMissing = []
 345     listPresent = []
 346
 347     empty = ldb.Message()
 348     for i in range(0, len(reference)):
 349         hash_new[str(reference[i]["dn"]).lower()] = reference[i]["dn"]
 350
 351     # Create a hash for speeding the search of existing object in the
 352     # current provision
 353     for i in range(0, len(current)):
 354         hash[str(current[i]["dn"]).lower()] = current[i]["dn"]
 355
 356     for k in hash_new.keys():
 357         if k not in hash:
 358             listMissing.append(hash_new[k])
 359         else:
 360             listPresent.append(hash_new[k])
 361
 362     for entry in listMissing:
 363         reference = newsecrets_ldb.search(expression="distinguishedName=%s" % entry,
 364                                           base="", scope=SCOPE_SUBTREE)
 365         current = secrets_ldb.search(expression="distinguishedName=%s" % entry,
 366                                      base="", scope=SCOPE_SUBTREE)
 367         delta = secrets_ldb.msg_diff(empty, reference[0])
 368         for att in hashAttrNotCopied:
 369             delta.remove(att)
 370         messagefunc(CHANGE, "Entry %s is missing from secrets.ldb" %
 371                     reference[0].dn)
 372         for att in delta:
 373             messagefunc(CHANGE, " Adding attribute %s" % att)
 374         delta.dn = reference[0].dn
 375         secrets_ldb.add(delta)
 376
 377     for entry in listPresent:
 378         reference = newsecrets_ldb.search(expression="distinguishedName=%s" % entry,
 379                                           base="", scope=SCOPE_SUBTREE)
 380         current = secrets_ldb.search(expression="distinguishedName=%s" % entry, base="",
 381                                      scope=SCOPE_SUBTREE)
 382         delta = secrets_ldb.msg_diff(current[0], reference[0])
 383         for att in hashAttrNotCopied:
 384             delta.remove(att)
 385         for att in delta:
 386             if att == "name":
 387                 messagefunc(CHANGE, "Found attribute name on  %s,"
 388                                     " must rename the DN" % (current[0].dn))
 389                 identic_rename(secrets_ldb, reference[0].dn)
 390             else:
 391                 delta.remove(att)
 392
 393     for entry in listPresent:
 394         reference = newsecrets_ldb.search(expression="distinguishedName=%s" % entry, base="",
 395                                           scope=SCOPE_SUBTREE)
 396         current = secrets_ldb.search(expression="distinguishedName=%s" % entry, base="",
 397                                      scope=SCOPE_SUBTREE)
 398         delta = secrets_ldb.msg_diff(current[0], reference[0])
 399         for att in hashAttrNotCopied:
 400             delta.remove(att)
 401         for att in delta:
 402             if att == "msDS-KeyVersionNumber":
 403                 delta.remove(att)
 404             if att != "dn":
 405                 messagefunc(CHANGE,
 406                             "Adding/Changing attribute %s to %s" %
 407                             (att, current[0].dn))
 408
 409         delta.dn = current[0].dn
 410         secrets_ldb.modify(delta)
 411
 412     res2 = secrets_ldb.search(expression="(samaccountname=dns)",
 413                               scope=SCOPE_SUBTREE, attrs=["dn"])
 414
 415     if len(res2) == 1:
 416             messagefunc(SIMPLE, "Remove old dns account")
 417             secrets_ldb.delete(res2[0]["dn"])
 418
 419
 420 def getOEMInfo(samdb, rootdn):
 421     """Return OEM Information on the top level Samba4 use to store version
 422     info in this field
 423
 424     :param samdb: An LDB object connect to sam.ldb
 425     :param rootdn: Root DN of the domain
 426     :return: The content of the field oEMInformation (if any)
 427     """
 428     res = samdb.search(expression="(objectClass=*)", base=str(rootdn),
 429                        scope=SCOPE_BASE, attrs=["dn", "oEMInformation"])
 430     if len(res) > 0 and res[0].get("oEMInformation"):
 431         info = res[0]["oEMInformation"]
 432         return info
 433     else:
 434         return ""
 435
 436
 437 def updateOEMInfo(samdb, rootdn):
 438     """Update the OEMinfo field to add information about upgrade
 439
 440     :param samdb: an LDB object connected to the sam DB
 441     :param rootdn: The string representation of the root DN of
 442         the provision (ie. DC=...,DC=...)
 443     """
 444     res = samdb.search(expression="(objectClass=*)", base=rootdn,
 445                        scope=SCOPE_BASE, attrs=["dn", "oEMInformation"])
 446     if len(res) > 0:
 447         if res[0].get("oEMInformation"):
 448             info = str(res[0]["oEMInformation"])
 449         else:
 450             info = ""
 451         info = "%s, upgrade to %s" % (info, version)
 452         delta = ldb.Message()
 453         delta.dn = ldb.Dn(samdb, str(res[0]["dn"]))
 454         delta["oEMInformation"] = ldb.MessageElement(info, ldb.FLAG_MOD_REPLACE,
 455                                                      "oEMInformation")
 456         samdb.modify(delta)
 457
 458
 459 def update_gpo(paths, samdb, names, lp, message):
 460     """Create missing GPO file object if needed
 461     """
 462     dir = getpolicypath(paths.sysvol, names.dnsdomain, names.policyid)
 463     if not os.path.isdir(dir):
 464         create_gpo_struct(dir)
 465
 466     if names.policyid_dc is None:
 467         raise ProvisioningError("Policy ID for Domain controller is missing")
 468     dir = getpolicypath(paths.sysvol, names.dnsdomain, names.policyid_dc)
 469     if not os.path.isdir(dir):
 470         create_gpo_struct(dir)
 471
 472
 473 def increment_calculated_keyversion_number(samdb, rootdn, hashDns):
 474     """For a given hash associating dn and a number, this function will
 475     update the replPropertyMetaData of each dn in the hash, so that the
 476     calculated value of the msDs-KeyVersionNumber is equal or superior to the
 477     one associated to the given dn.
 478
 479     :param samdb: An SamDB object pointing to the sam
 480     :param rootdn: The base DN where we want to start
 481     :param hashDns: A hash with dn as key and number representing the
 482                  minimum value of msDs-KeyVersionNumber that we want to
 483                  have
 484     """
 485     entry = samdb.search(expression='(objectClass=user)',
 486                          base=ldb.Dn(samdb, str(rootdn)),
 487                          scope=SCOPE_SUBTREE, attrs=["msDs-KeyVersionNumber"],
 488                          controls=["search_options:1:2"])
 489     done = 0
 490     hashDone = {}
 491     if len(entry) == 0:
 492         raise ProvisioningError("Unable to find msDs-KeyVersionNumber")
 493     else:
 494         for e in entry:
 495             if str(e.dn).lower() in hashDns:
 496                 val = e.get("msDs-KeyVersionNumber")
 497                 if not val:
 498                     val = "0"
 499                 version = int(str(hashDns[str(e.dn).lower()]))
 500                 if int(str(val)) < version:
 501                     done = done + 1
 502                     samdb.set_attribute_replmetadata_version(str(e.dn),
 503                                                              "unicodePwd",
 504                                                              version, True)
 505
 506
 507 def delta_update_basesamdb(refsampath, sampath, creds, session, lp, message):
 508     """Update the provision container db: sam.ldb
 509     This function is aimed for alpha9 and newer;
 510
 511     :param refsampath: Path to the samdb in the reference provision
 512     :param sampath: Path to the samdb in the upgraded provision
 513     :param creds: Credential used for openning LDB files
 514     :param session: Session to use for openning LDB files
 515     :param lp: A loadparam object
 516     :return: A msg_diff object with the difference between the @ATTRIBUTES
 517              of the current provision and the reference provision
 518     """
 519
 520     message(SIMPLE,
 521             "Update base samdb by searching difference with reference one")
 522     refsam = Ldb(refsampath, session_info=session, credentials=creds,
 523                  lp=lp, options=["modules:"])
 524     sam = Ldb(sampath, session_info=session, credentials=creds, lp=lp,
 525               options=["modules:"])
 526
 527     empty = ldb.Message()
 528     deltaattr = None
 529     reference = refsam.search(expression="")
 530
 531     for refentry in reference:
 532         entry = sam.search(expression="distinguishedName=%s" % refentry["dn"],
 533                            scope=SCOPE_SUBTREE)
 534         if not len(entry):
 535             delta = sam.msg_diff(empty, refentry)
 536             message(CHANGE, "Adding %s to sam db" % str(refentry.dn))
 537             if str(refentry.dn) == "@PROVISION" and\
 538                     delta.get(samba.provision.LAST_PROVISION_USN_ATTRIBUTE):
 539                 delta.remove(samba.provision.LAST_PROVISION_USN_ATTRIBUTE)
 540             delta.dn = refentry.dn
 541             sam.add(delta)
 542         else:
 543             delta = sam.msg_diff(entry[0], refentry)
 544             if str(refentry.dn) == "@ATTRIBUTES":
 545                 deltaattr = sam.msg_diff(refentry, entry[0])
 546             if str(refentry.dn) == "@PROVISION" and\
 547                     delta.get(samba.provision.LAST_PROVISION_USN_ATTRIBUTE):
 548                 delta.remove(samba.provision.LAST_PROVISION_USN_ATTRIBUTE)
 549             if len(delta.items()) > 1:
 550                 delta.dn = refentry.dn
 551                 sam.modify(delta)
 552
 553     return deltaattr
 554
 555
 556 def construct_existor_expr(attrs):
 557     """Construct a exists or LDAP search expression.
 558
 559     :param attrs: List of attribute on which we want to create the search
 560         expression.
 561     :return: A string representing the expression, if attrs is empty an
 562         empty string is returned
 563     """
 564     expr = ""
 565     if len(attrs) > 0:
 566         expr = "(|"
 567         for att in attrs:
 568             expr = "%s(%s=*)" %(expr, att)
 569         expr = "%s)" %expr
 570     return expr
 571
 572
 573 def update_machine_account_password(samdb, secrets_ldb, names):
 574     """Update (change) the password of the current DC both in the SAM db and in
 575        secret one
 576
 577     :param samdb: An LDB object related to the sam.ldb file of a given provision
 578     :param secrets_ldb: An LDB object related to the secrets.ldb file of a given
 579                         provision
 580     :param names: List of key provision parameters"""
 581
 582     expression = "samAccountName=%s$" % names.netbiosname
 583     secrets_msg = secrets_ldb.search(expression=expression,
 584                                      attrs=["secureChannelType"])
 585     if int(secrets_msg[0]["secureChannelType"][0]) == SEC_CHAN_BDC:
 586         res = samdb.search(expression=expression, attrs=[])
 587         assert(len(res) == 1)
 588
 589         msg = ldb.Message(res[0].dn)
 590         machinepass = samba.generate_random_machine_password(128, 255)
 591         mputf16 = machinepass.encode('utf-16-le')
 592         msg["clearTextPassword"] = ldb.MessageElement(mputf16,
 593                                                       ldb.FLAG_MOD_REPLACE,
 594                                                       "clearTextPassword")
 595         samdb.modify(msg)
 596
 597         res = samdb.search(expression=("samAccountName=%s$" % names.netbiosname),
 598                            attrs=["msDs-keyVersionNumber"])
 599         assert(len(res) == 1)
 600         kvno = int(str(res[0]["msDs-keyVersionNumber"]))
 601         secChanType = int(secrets_msg[0]["secureChannelType"][0])
 602
 603         secretsdb_self_join(secrets_ldb, domain=names.domain,
 604                             realm=names.realm,
 605                             domainsid=names.domainsid,
 606                             dnsdomain=names.dnsdomain,
 607                             netbiosname=names.netbiosname,
 608                             machinepass=machinepass,
 609                             key_version_number=kvno,
 610                             secure_channel_type=secChanType)
 611     else:
 612         raise ProvisioningError("Unable to find a Secure Channel"
 613                                 "of type SEC_CHAN_BDC")
 614
 615
 616 def update_dns_account_password(samdb, secrets_ldb, names):
 617     """Update (change) the password of the dns both in the SAM db and in
 618        secret one
 619
 620     :param samdb: An LDB object related to the sam.ldb file of a given provision
 621     :param secrets_ldb: An LDB object related to the secrets.ldb file of a given
 622                         provision
 623     :param names: List of key provision parameters"""
 624
 625     expression = "samAccountName=dns-%s" % names.netbiosname
 626     secrets_msg = secrets_ldb.search(expression=expression)
 627     if len(secrets_msg) == 1:
 628         res = samdb.search(expression=expression, attrs=[])
 629         assert(len(res) == 1)
 630
 631         msg = ldb.Message(res[0].dn)
 632         machinepass = samba.generate_random_password(128, 255)
 633         mputf16 = machinepass.encode('utf-16-le')
 634         msg["clearTextPassword"] = ldb.MessageElement(mputf16,
 635                                                       ldb.FLAG_MOD_REPLACE,
 636                                                       "clearTextPassword")
 637
 638         samdb.modify(msg)
 639
 640         res = samdb.search(expression=expression,
 641                            attrs=["msDs-keyVersionNumber"])
 642         assert(len(res) == 1)
 643         kvno = str(res[0]["msDs-keyVersionNumber"])
 644
 645         msg = ldb.Message(secrets_msg[0].dn)
 646         msg["secret"] = ldb.MessageElement(machinepass,
 647                                            ldb.FLAG_MOD_REPLACE,
 648                                            "secret")
 649         msg["msDS-KeyVersionNumber"] = ldb.MessageElement(kvno,
 650                                                           ldb.FLAG_MOD_REPLACE,
 651                                                           "msDS-KeyVersionNumber")
 652
 653         secrets_ldb.modify(msg)
 654
 655
 656 def update_krbtgt_account_password(samdb):
 657     """Update (change) the password of the krbtgt account
 658
 659     :param samdb: An LDB object related to the sam.ldb file of a given provision"""
 660
 661     expression = "samAccountName=krbtgt"
 662     res = samdb.search(expression=expression, attrs=[])
 663     assert(len(res) == 1)
 664
 665     msg = ldb.Message(res[0].dn)
 666     machinepass = samba.generate_random_machine_password(128, 255)
 667     mputf16 = machinepass.encode('utf-16-le')
 668     msg["clearTextPassword"] = ldb.MessageElement(mputf16,
 669                                                   ldb.FLAG_MOD_REPLACE,
 670                                                   "clearTextPassword")
 671
 672     samdb.modify(msg)
 673
 674
 675 def search_constructed_attrs_stored(samdb, rootdn, attrs):
 676     """Search a given sam DB for calculated attributes that are
 677     still stored in the db.
 678
 679     :param samdb: An LDB object pointing to the sam
 680     :param rootdn: The base DN where the search should start
 681     :param attrs: A list of attributes to be searched
 682     :return: A hash with attributes as key and an array of
 683              array. Each array contains the dn and the associated
 684              values for this attribute as they are stored in the
 685              sam."""
 686
 687     hashAtt = {}
 688     expr = construct_existor_expr(attrs)
 689     if expr == "":
 690         return hashAtt
 691     entry = samdb.search(expression=expr, base=ldb.Dn(samdb, str(rootdn)),
 692                          scope=SCOPE_SUBTREE, attrs=attrs,
 693                          controls=["search_options:1:2", "bypassoperational:0"])
 694     if len(entry) == 0:
 695         # Nothing anymore
 696         return hashAtt
 697
 698     for ent in entry:
 699         for att in attrs:
 700             if ent.get(att):
 701                 if att in hashAtt:
 702                     hashAtt[att][str(ent.dn).lower()] = str(ent[att])
 703                 else:
 704                     hashAtt[att] = {}
 705                     hashAtt[att][str(ent.dn).lower()] = str(ent[att])
 706
 707     return hashAtt
 708
 709
 710 def findprovisionrange(samdb, basedn):
 711     """ Find ranges of usn grouped by invocation id and then by timestamp
 712         rouned at 1 minute
 713
 714         :param samdb: An LDB object pointing to the samdb
 715         :param basedn: The DN of the forest
 716
 717         :return: A two level dictionary with invoication id as the
 718                 first level, timestamp as the second one and then
 719                 max, min, and number as subkeys, representing respectivily
 720                 the maximum usn for the range, the minimum usn and the number
 721                 of object with usn in this range.
 722     """
 723     nb_obj = 0
 724     hash_id = {}
 725
 726     res = samdb.search(base=basedn, expression="objectClass=*",
 727                        scope=ldb.SCOPE_SUBTREE,
 728                        attrs=["replPropertyMetaData"],
 729                        controls=["search_options:1:2"])
 730
 731     for e in res:
 732         nb_obj = nb_obj + 1
 733         obj = ndr_unpack(drsblobs.replPropertyMetaDataBlob,
 734                          str(e["replPropertyMetaData"])).ctr
 735
 736         for o in obj.array:
 737             # like a timestamp but with the resolution of 1 minute
 738             minutestamp = _glue.nttime2unix(o.originating_change_time) // 60
 739             hash_ts = hash_id.get(str(o.originating_invocation_id))
 740
 741             if hash_ts is None:
 742                 ob = {}
 743                 ob["min"] = o.originating_usn
 744                 ob["max"] = o.originating_usn
 745                 ob["num"] = 1
 746                 ob["list"] = [str(e.dn)]
 747                 hash_ts = {}
 748             else:
 749                 ob = hash_ts.get(minutestamp)
 750                 if ob is None:
 751                     ob = {}
 752                     ob["min"] = o.originating_usn
 753                     ob["max"] = o.originating_usn
 754                     ob["num"] = 1
 755                     ob["list"] = [str(e.dn)]
 756                 else:
 757                     if ob["min"] > o.originating_usn:
 758                         ob["min"] = o.originating_usn
 759                     if ob["max"] < o.originating_usn:
 760                         ob["max"] = o.originating_usn
 761                     if not (str(e.dn) in ob["list"]):
 762                         ob["num"] = ob["num"] + 1
 763                         ob["list"].append(str(e.dn))
 764             hash_ts[minutestamp] = ob
 765             hash_id[str(o.originating_invocation_id)] = hash_ts
 766
 767     return (hash_id, nb_obj)
 768
 769
 770 def print_provision_ranges(dic, limit_print, dest, samdb_path, invocationid):
 771     """ print the differents ranges passed as parameter
 772
 773         :param dic: A dictionnary as returned by findprovisionrange
 774         :param limit_print: minimum number of object in a range in order to print it
 775         :param dest: Destination directory
 776         :param samdb_path: Path to the sam.ldb file
 777         :param invoicationid: Invocation ID for the current provision
 778     """
 779     ldif = ""
 780
 781     for id in dic:
 782         hash_ts = dic[id]
 783         sorted_keys = []
 784         sorted_keys.extend(hash_ts.keys())
 785         sorted_keys.sort()
 786
 787         kept_record = []
 788         for k in sorted_keys:
 789             obj = hash_ts[k]
 790             if obj["num"] > limit_print:
 791                 dt = _glue.nttime2string(_glue.unix2nttime(k * 60))
 792                 print("%s # of modification: %d  \tmin: %d max: %d" % (dt, obj["num"],
 793                                                                        obj["min"],
 794                                                                        obj["max"]))
 795             if hash_ts[k]["num"] > 600:
 796                 kept_record.append(k)
 797
 798         # Let's try to concatenate consecutive block if they are in the almost same minutestamp
 799         for i in range(0, len(kept_record)):
 800             if i != 0:
 801                 key1 = kept_record[i]
 802                 key2 = kept_record[i - 1]
 803                 if key1 - key2 == 1:
 804                     # previous record is just 1 minute away from current
 805                     if int(hash_ts[key1]["min"]) == int(hash_ts[key2]["max"]) + 1:
 806                         # Copy the highest USN in the previous record
 807                         # and mark the current as skipped
 808                         hash_ts[key2]["max"] = hash_ts[key1]["max"]
 809                         hash_ts[key1]["skipped"] = True
 810
 811         for k in kept_record:
 812                 obj = hash_ts[k]
 813                 if obj.get("skipped") is None:
 814                     ldif = "%slastProvisionUSN: %d-%d;%s\n" % (ldif, obj["min"],
 815                                                                obj["max"], id)
 816
 817     if ldif != "":
 818         file = tempfile.mktemp(dir=dest, prefix="usnprov", suffix=".ldif")
 819         print()
 820         print("To track the USNs modified/created by provision and upgrade proivsion,")
 821         print(" the following ranges are proposed to be added to your provision sam.ldb: \n%s" % ldif)
 822         print("We recommend to review them, and if it's correct to integrate the following ldif: %s in your sam.ldb" % file)
 823         print("You can load this file like this: ldbadd -H %s %s\n" %(str(samdb_path), file))
 824         ldif = "dn: @PROVISION\nprovisionnerID: %s\n%s" % (invocationid, ldif)
 825         open(file, 'w').write(ldif)
 826
 827
 828 def int64range2str(value):
 829     """Display the int64 range stored in value as xxx-yyy
 830
 831     :param value: The int64 range
 832     :return: A string of the representation of the range
 833     """
 834
 835     lvalue = long(value)
 836     str = "%d-%d" % (lvalue &0xFFFFFFFF, lvalue >>32)
 837     return str