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