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

   1 #!/usr/bin/env python
   2 #
   3 # implement samba_tool gpo commands
   4 #
   5 # Copyright Andrew Tridgell 2010
   6 #
   7 # based on C implementation by Guenther Deschner and Wilco Baan Hofman
   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
  23 import samba.getopt as options
  24 import ldb
  25
  26 from samba.auth import system_session
  27 from samba.netcmd import (
  28     Command,
  29     CommandError,
  30     Option,
  31     SuperCommand,
  32     )
  33 from samba.samdb import SamDB
  34 from samba import drs_utils, nttime2string, dsdb
  35 from samba.dcerpc import misc
  36
  37
  38 def samdb_connect(ctx):
  39     '''make a ldap connection to the server'''
  40     try:
  41         ctx.samdb = SamDB(url=ctx.url,
  42                           session_info=system_session(),
  43                           credentials=ctx.creds, lp=ctx.lp)
  44     except Exception, e:
  45         raise CommandError("LDAP connection to %s failed " % ctx.url, e)
  46
  47
  48 def attr_default(msg, attrname, default):
  49     '''get an attribute from a ldap msg with a default'''
  50     if attrname in msg:
  51         return msg[attrname][0]
  52     return default
  53
  54
  55 def flags_string(flags, value):
  56     '''return a set of flags as a string'''
  57     if value == 0:
  58         return 'NONE'
  59     ret = ''
  60     for (str, val) in flags:
  61         if val & value:
  62             ret += str + ' '
  63             value &= ~val
  64     if value != 0:
  65         ret += '0x%08x' % value
  66     return ret.rstrip()
  67
  68
  69 def parse_gplink(gplink):
  70     '''parse a gPLink into an array of dn and options'''
  71     ret = []
  72     a = gplink.split(']')
  73     for g in a:
  74         if not g:
  75             continue
  76         d = g.split(';')
  77         if len(d) != 2 or not d[0].startswith("[LDAP://"):
  78             raise RuntimeError("Badly formed gPLink '%s'" % g)
  79         ret.append({ 'dn' : d[0][8:], 'options' : int(d[1])})
  80     return ret
  81
  82
  83 class cmd_listall(Command):
  84     """list all GPOs"""
  85
  86     synopsis = "%prog gpo listall"
  87
  88     takes_optiongroups = {
  89         "sambaopts": options.SambaOptions,
  90         "versionopts": options.VersionOptions,
  91         "credopts": options.CredentialsOptions,
  92     }
  93
  94     takes_options = [
  95         Option("-H", help="LDB URL for database or target server", type=str)
  96         ]
  97
  98     def run(self, H=None, sambaopts=None,
  99             credopts=None, versionopts=None, server=None):
 100
 101         self.url = H
 102         self.lp = sambaopts.get_loadparm()
 103
 104         self.creds = credopts.get_credentials(self.lp)
 105         if not self.creds.authentication_requested():
 106             self.creds.set_machine_account(self.lp)
 107
 108         samdb_connect(self)
 109
 110         policies_dn = self.samdb.get_default_basedn()
 111         policies_dn.add_child(ldb.Dn(self.samdb, "CN=Policies,CN=System"))
 112
 113         gpo_flags = [
 114             ("GPO_FLAG_USER_DISABLE", dsdb.GPO_FLAG_USER_DISABLE ),
 115             ( "GPO_FLAG_MACHINE_DISABLE", dsdb.GPO_FLAG_MACHINE_DISABLE ) ]
 116
 117         try:
 118             msg = self.samdb.search(base=policies_dn, scope=ldb.SCOPE_ONELEVEL,
 119                                     expression="(objectClass=groupPolicyContainer)",
 120                                     attrs=['nTSecurityDescriptor', 'versionNumber', 'flags', 'name', 'displayName', 'gPCFileSysPath'])
 121         except Exception, e:
 122             raise CommandError("Failed to list policies in %s" % policies_dn, e)
 123         for m in msg:
 124             print("GPO          : %s" % m['name'][0])
 125             print("display name : %s" % m['displayName'][0])
 126             print("path         : %s" % m['gPCFileSysPath'][0])
 127             print("dn           : %s" % m.dn)
 128             print("version      : %s" % attr_default(m, 'version', '0'))
 129             print("flags        : %s" % flags_string(gpo_flags, int(attr_default(m, 'flags', 0))))
 130             print("")
 131
 132
 133 class cmd_list(Command):
 134     """list GPOs for a user"""
 135
 136     synopsis = "%prog gpo list <username>"
 137
 138     takes_optiongroups = {
 139         "sambaopts": options.SambaOptions,
 140         "versionopts": options.VersionOptions,
 141         "credopts": options.CredentialsOptions,
 142     }
 143
 144     takes_args = [ 'username' ]
 145
 146     takes_options = [
 147         Option("-H", help="LDB URL for database or target server", type=str)
 148         ]
 149
 150     def run(self, username, H=None, sambaopts=None,
 151             credopts=None, versionopts=None, server=None):
 152
 153         self.url = H
 154         self.lp = sambaopts.get_loadparm()
 155
 156         self.creds = credopts.get_credentials(self.lp)
 157         if not self.creds.authentication_requested():
 158             self.creds.set_machine_account(self.lp)
 159
 160         samdb_connect(self)
 161
 162         try:
 163             user_dn = self.samdb.search(expression='(&(samAccountName=%s)(objectclass=User))' % username)[0].dn
 164         except Exception, e:
 165             raise CommandError("Failed to find user %s" % username, e)
 166
 167         # check if its a computer account
 168         try:
 169             msg = self.samdb.search(base=user_dn, scope=ldb.SCOPE_BASE, attrs=['objectClass'])[0]
 170             is_computer = 'computer' in msg['objectClass']
 171         except Exception, e:
 172             raise CommandError("Failed to find objectClass for user %s" % username, e)
 173
 174         print("TODO: get user token")
 175         # token = self.samdb.get_user_token(username)
 176
 177         gpos = []
 178
 179         inherit = True
 180         dn = ldb.Dn(self.samdb, str(user_dn)).parent()
 181         while True:
 182             msg = self.samdb.search(base=dn, scope=ldb.SCOPE_BASE, attrs=['gPLink', 'gPOptions'])[0]
 183             if 'gPLink' in msg:
 184                 glist = parse_gplink(msg['gPLink'][0])
 185                 for g in glist:
 186                     if not inherit and not (g['options'] & dsdb.GPLINK_OPT_ENFORCE):
 187                         continue
 188                     if g['options'] & dsdb.GPLINK_OPT_DISABLE:
 189                         continue
 190
 191                     print("TODO: access checking")
 192                     #if not samdb.access_check(secdesc, token, security.SEC_RIGHTS_FILE_READ):
 193                     #    continue
 194
 195                     # check the flags on the GPO
 196                     flags = int(attr_default(self.samdb.search(base=g['dn'], scope=ldb.SCOPE_BASE, attrs=['flags'])[0], 'flags', 0))
 197                     if is_computer and (flags & dsdb.GPO_FLAG_MACHINE_DISABLE):
 198                         continue
 199                     if not is_computer and (flags & dsdb.GPO_FLAG_USER_DISABLE):
 200                         continue
 201                     gpos.append(g)
 202
 203             # check if this blocks inheritance
 204             gpoptions = int(attr_default(msg, 'gPOptions', 0))
 205             if gpoptions & dsdb.GPO_BLOCK_INHERITANCE:
 206                 inherit = False
 207
 208             if dn == self.samdb.get_default_basedn():
 209                 break
 210             dn = dn.parent()
 211
 212         print("GPO's for user %s" % username)
 213         for g in gpos:
 214             print("\t%s" % g['dn'])
 215
 216
 217 class cmd_gpo(SuperCommand):
 218     """GPO commands"""
 219
 220     subcommands = {}
 221     subcommands["listall"] = cmd_listall()
 222     subcommands["list"] = cmd_list()