gpo: python chardet is not a dep of samba
[nivanova/samba-autobuild/.git] / python / samba / gpclass.py
1 # Reads important GPO parameters and updates Samba
2 # Copyright (C) Luke Morrison <luc785@.hotmail.com> 2013
3 #
4 # This program is free software; you can redistribute it and/or modify
5 # it under the terms of the GNU General Public License as published by
6 # the Free Software Foundation; either version 3 of the License, or
7 # (at your option) any later version.
8 #
9 # This program is distributed in the hope that it will be useful,
10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 # GNU General Public License for more details.
13 #
14 # You should have received a copy of the GNU General Public License
15 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
16
17
18 import sys
19 import os
20 import tdb
21 sys.path.insert(0, "bin/python")
22 from samba import NTSTATUSError
23 from ConfigParser import ConfigParser
24 from StringIO import StringIO
25 from abc import ABCMeta, abstractmethod
26 import xml.etree.ElementTree as etree
27 import re
28 from samba.net import Net
29 from samba.dcerpc import nbt
30 from samba import smb
31 import samba.gpo as gpo
32
33 try:
34     from enum import Enum
35     GPOSTATE = Enum('GPOSTATE', 'APPLY ENFORCE UNAPPLY')
36 except ImportError:
37     class GPOSTATE:
38         APPLY = 1
39         ENFORCE = 2
40         UNAPPLY = 3
41
42 class gp_log:
43     ''' Log settings overwritten by gpo apply
44     The gp_log is an xml file that stores a history of gpo changes (and the
45     original setting value).
46
47     The log is organized like so:
48
49 <gp>
50     <user name="KDC-1$">
51         <applylog>
52             <guid count="0" value="{31B2F340-016D-11D2-945F-00C04FB984F9}" />
53         </applylog>
54         <guid value="{31B2F340-016D-11D2-945F-00C04FB984F9}">
55             <gp_ext name="System Access">
56                 <attribute name="minPwdAge">-864000000000</attribute>
57                 <attribute name="maxPwdAge">-36288000000000</attribute>
58                 <attribute name="minPwdLength">7</attribute>
59                 <attribute name="pwdProperties">1</attribute>
60             </gp_ext>
61             <gp_ext name="Kerberos Policy">
62                 <attribute name="ticket_lifetime">1d</attribute>
63                 <attribute name="renew_lifetime" />
64                 <attribute name="clockskew">300</attribute>
65             </gp_ext>
66         </guid>
67     </user>
68 </gp>
69
70     Each guid value contains a list of extensions, which contain a list of
71     attributes. The guid value represents a GPO. The attributes are the values
72     of those settings prior to the application of the GPO.
73     The list of guids is enclosed within a user name, which represents the user
74     the settings were applied to. This user may be the samaccountname of the
75     local computer, which implies that these are machine policies.
76     The applylog keeps track of the order in which the GPOs were applied, so
77     that they can be rolled back in reverse, returning the machine to the state
78     prior to policy application.
79     '''
80     def __init__(self, user, gpostore, db_log=None):
81         ''' Initialize the gp_log
82         param user          - the username (or machine name) that policies are
83                               being applied to
84         param gpostore      - the GPOStorage obj which references the tdb which
85                               contains gp_logs
86         param db_log        - (optional) a string to initialize the gp_log
87         '''
88         self._state = GPOSTATE.APPLY
89         self.gpostore = gpostore
90         self.username = user
91         if db_log:
92             self.gpdb = etree.fromstring(db_log)
93         else:
94             self.gpdb = etree.Element('gp')
95         self.user = user
96         user_obj = self.gpdb.find('user[@name="%s"]' % user)
97         if user_obj is None:
98             user_obj = etree.SubElement(self.gpdb, 'user')
99             user_obj.attrib['name'] = user
100
101     def state(self, value):
102         ''' Policy application state
103         param value         - APPLY, ENFORCE, or UNAPPLY
104
105         The behavior of the gp_log depends on whether we are applying policy,
106         enforcing policy, or unapplying policy. During an apply, old settings
107         are recorded in the log. During an enforce, settings are being applied
108         but the gp_log does not change. During an unapply, additions to the log
109         should be ignored (since function calls to apply settings are actually
110         reverting policy), but removals from the log are allowed.
111         '''
112         # If we're enforcing, but we've unapplied, apply instead
113         if value == GPOSTATE.ENFORCE:
114             user_obj = self.gpdb.find('user[@name="%s"]' % self.user)
115             apply_log = user_obj.find('applylog')
116             if apply_log is None or len(apply_log) == 0:
117                 self._state = GPOSTATE.APPLY
118             else:
119                 self._state = value
120         else:
121             self._state = value
122
123     def set_guid(self, guid):
124         ''' Log to a different GPO guid
125         param guid          - guid value of the GPO from which we're applying
126                               policy
127         '''
128         self.guid = guid
129         user_obj = self.gpdb.find('user[@name="%s"]' % self.user)
130         obj = user_obj.find('guid[@value="%s"]' % guid)
131         if obj is None:
132             obj = etree.SubElement(user_obj, 'guid')
133             obj.attrib['value'] = guid
134         if self._state == GPOSTATE.APPLY:
135             apply_log = user_obj.find('applylog')
136             if apply_log is None:
137                 apply_log = etree.SubElement(user_obj, 'applylog')
138             item = etree.SubElement(apply_log, 'guid')
139             item.attrib['count'] = '%d' % (len(apply_log)-1)
140             item.attrib['value'] = guid
141
142     def apply_log_pop(self):
143         ''' Pop a GPO guid from the applylog
144         return              - last applied GPO guid
145
146         Removes the GPO guid last added to the list, which is the most recently
147         applied GPO.
148         '''
149         user_obj = self.gpdb.find('user[@name="%s"]' % self.user)
150         apply_log = user_obj.find('applylog')
151         if apply_log is not None:
152             ret = apply_log.find('guid[@count="%d"]' % (len(apply_log)-1))
153             if ret is not None:
154                 apply_log.remove(ret)
155                 return ret.attrib['value']
156             if len(apply_log) == 0 and apply_log in user_obj:
157                 user_obj.remove(apply_log)
158         return None
159
160     def store(self, gp_ext_name, attribute, old_val):
161         ''' Store an attribute in the gp_log
162         param gp_ext_name   - Name of the extension applying policy
163         param attribute     - The attribute being modified
164         param old_val       - The value of the attribute prior to policy
165                               application
166         '''
167         if self._state == GPOSTATE.UNAPPLY or self._state == GPOSTATE.ENFORCE:
168             return None
169         user_obj = self.gpdb.find('user[@name="%s"]' % self.user)
170         guid_obj = user_obj.find('guid[@value="%s"]' % self.guid)
171         assert guid_obj is not None, "gpo guid was not set"
172         ext = guid_obj.find('gp_ext[@name="%s"]' % gp_ext_name)
173         if ext is None:
174             ext = etree.SubElement(guid_obj, 'gp_ext')
175             ext.attrib['name'] = gp_ext_name
176         attr = ext.find('attribute[@name="%s"]' % attribute)
177         if attr is None:
178             attr = etree.SubElement(ext, 'attribute')
179             attr.attrib['name'] = attribute
180             attr.text = old_val
181
182     def retrieve(self, gp_ext_name, attribute):
183         ''' Retrieve a stored attribute from the gp_log
184         param gp_ext_name   - Name of the extension which applied policy
185         param attribute     - The attribute being retrieved
186         return              - The value of the attribute prior to policy
187                               application
188         '''
189         user_obj = self.gpdb.find('user[@name="%s"]' % self.user)
190         guid_obj = user_obj.find('guid[@value="%s"]' % self.guid)
191         assert guid_obj is not None, "gpo guid was not set"
192         ext = guid_obj.find('gp_ext[@name="%s"]' % gp_ext_name)
193         if ext is not None:
194             attr = ext.find('attribute[@name="%s"]' % attribute)
195             if attr is not None:
196                 return attr.text
197         return None
198
199     def list(self, gp_extensions):
200         ''' Return a list of attributes, their previous values, and functions
201             to set them
202         param gp_extensions - list of extension objects, for retrieving attr to
203                               func mappings
204         return              - list of (attr, value, apply_func) tuples for
205                               unapplying policy
206         '''
207         user_obj = self.gpdb.find('user[@name="%s"]' % self.user)
208         guid_obj = user_obj.find('guid[@value="%s"]' % self.guid)
209         assert guid_obj is not None, "gpo guid was not set"
210         ret = []
211         data_maps = {}
212         for gp_ext in gp_extensions:
213             data_maps.update(gp_ext.apply_map())
214         exts = guid_obj.findall('gp_ext')
215         if exts is not None:
216             for ext in exts:
217                 attrs = ext.findall('attribute')
218                 for attr in attrs:
219                     func = None
220                     if attr.attrib['name'] in data_maps[ext.attrib['name']]:
221                         func = data_maps[ext.attrib['name']]\
222                                [attr.attrib['name']][-1]
223                     else:
224                         for dmap in data_maps[ext.attrib['name']].keys():
225                             if data_maps[ext.attrib['name']][dmap][0] == \
226                                attr.attrib['name']:
227                                 func = data_maps[ext.attrib['name']][dmap][-1]
228                                 break
229                     ret.append((attr.attrib['name'], attr.text, func))
230         return ret
231
232     def delete(self, gp_ext_name, attribute):
233         ''' Remove an attribute from the gp_log
234         param gp_ext_name   - name of extension from which to remove the
235                               attribute
236         param attribute     - attribute to remove
237         '''
238         user_obj = self.gpdb.find('user[@name="%s"]' % self.user)
239         guid_obj = user_obj.find('guid[@value="%s"]' % self.guid)
240         assert guid_obj is not None, "gpo guid was not set"
241         ext = guid_obj.find('gp_ext[@name="%s"]' % gp_ext_name)
242         if ext is not None:
243             attr = ext.find('attribute[@name="%s"]' % attribute)
244             if attr is not None:
245                 ext.remove(attr)
246                 if len(ext) == 0:
247                     guid_obj.remove(ext)
248
249     def commit(self):
250         ''' Write gp_log changes to disk '''
251         self.gpostore.store(self.username, etree.tostring(self.gpdb, 'utf-8'))
252
253 class GPOStorage:
254     def __init__(self, log_file):
255         if os.path.isfile(log_file):
256             self.log = tdb.open(log_file)
257         else:
258             self.log = tdb.Tdb(log_file, 0, tdb.DEFAULT, os.O_CREAT|os.O_RDWR)
259
260     def start(self):
261         self.log.transaction_start()
262
263     def get_int(self, key):
264         try:
265             return int(self.log.get(key))
266         except TypeError:
267             return None
268
269     def get(self, key):
270         return self.log.get(key)
271
272     def get_gplog(self, user):
273         return gp_log(user, self, self.log.get(user))
274
275     def store(self, key, val):
276         self.log.store(key, val)
277
278     def cancel(self):
279         self.log.transaction_cancel()
280
281     def delete(self, key):
282         self.log.delete(key)
283
284     def commit(self):
285         self.log.transaction_commit()
286
287     def __del__(self):
288         self.log.close()
289
290 class gp_ext(object):
291     __metaclass__ = ABCMeta
292
293     def __init__(self, logger):
294         self.logger = logger
295
296     @abstractmethod
297     def list(self, rootpath):
298         pass
299
300     @abstractmethod
301     def apply_map(self):
302         pass
303
304     @abstractmethod
305     def read(self, policy):
306         pass
307
308     def parse(self, afile, ldb, conn, gp_db, lp):
309         self.ldb = ldb
310         self.gp_db = gp_db
311         self.lp = lp
312
313         # Fixing the bug where only some Linux Boxes capitalize MACHINE
314         try:
315             blist = afile.split('/')
316             idx = afile.lower().split('/').index('machine')
317             for case in [
318                             blist[idx].upper(),
319                             blist[idx].capitalize(),
320                             blist[idx].lower()
321                         ]:
322                 bfile = '/'.join(blist[:idx]) + '/' + case + '/' + \
323                     '/'.join(blist[idx+1:])
324                 try:
325                     return self.read(conn.loadfile(bfile.replace('/', '\\')))
326                 except NTSTATUSError:
327                     continue
328         except ValueError:
329             try:
330                 return self.read(conn.loadfile(afile.replace('/', '\\')))
331             except Exception as e:
332                 self.logger.error(str(e))
333                 return None
334
335     @abstractmethod
336     def __str__(self):
337         pass
338
339 class gp_ext_setter():
340     __metaclass__ = ABCMeta
341
342     def __init__(self, logger, ldb, gp_db, lp, attribute, val):
343         self.logger = logger
344         self.ldb = ldb
345         self.attribute = attribute
346         self.val = val
347         self.lp = lp
348         self.gp_db = gp_db
349
350     def explicit(self):
351         return self.val
352
353     def update_samba(self):
354         (upd_sam, value) = self.mapper().get(self.attribute)
355         upd_sam(value())
356
357     @abstractmethod
358     def mapper(self):
359         pass
360
361     @abstractmethod
362     def __str__(self):
363         pass
364
365 class gp_inf_ext(gp_ext):
366     @abstractmethod
367     def list(self, rootpath):
368         pass
369
370     @abstractmethod
371     def apply_map(self):
372         pass
373
374     def read(self, policy):
375         ret = False
376         inftable = self.apply_map()
377
378         current_section = None
379
380         # So here we would declare a boolean,
381         # that would get changed to TRUE.
382         #
383         # If at any point in time a GPO was applied,
384         # then we return that boolean at the end.
385
386         inf_conf = ConfigParser()
387         inf_conf.optionxform=str
388         try:
389             inf_conf.readfp(StringIO(policy))
390         except:
391             inf_conf.readfp(StringIO(policy.decode('utf-16')))
392
393         for section in inf_conf.sections():
394             current_section = inftable.get(section)
395             if not current_section:
396                 continue
397             for key, value in inf_conf.items(section):
398                 if current_section.get(key):
399                     (att, setter) = current_section.get(key)
400                     value = value.encode('ascii', 'ignore')
401                     ret = True
402                     setter(self.logger, self.ldb, self.gp_db, self.lp, att,
403                            value).update_samba()
404                     self.gp_db.commit()
405         return ret
406
407     @abstractmethod
408     def __str__(self):
409         pass
410
411 ''' Fetch the hostname of a writable DC '''
412 def get_dc_hostname(creds, lp):
413     net = Net(creds=creds, lp=lp)
414     cldap_ret = net.finddc(domain=lp.get('realm'), flags=(nbt.NBT_SERVER_LDAP |
415         nbt.NBT_SERVER_DS))
416     return cldap_ret.pdc_dns_name
417
418 ''' Fetch a list of GUIDs for applicable GPOs '''
419 def get_gpo_list(dc_hostname, creds, lp):
420     gpos = []
421     ads = gpo.ADS_STRUCT(dc_hostname, lp, creds)
422     if ads.connect():
423         gpos = ads.get_gpo_list(creds.get_username())
424     return gpos
425
426 def apply_gp(lp, creds, test_ldb, logger, store, gp_extensions):
427     gp_db = store.get_gplog(creds.get_username())
428     dc_hostname = get_dc_hostname(creds, lp)
429     try:
430         conn =  smb.SMB(dc_hostname, 'sysvol', lp=lp, creds=creds)
431     except:
432         logger.error('Error connecting to \'%s\' using SMB' % dc_hostname)
433         raise
434     gpos = get_gpo_list(dc_hostname, creds, lp)
435
436     for gpo_obj in gpos:
437         guid = gpo_obj.name
438         if guid == 'Local Policy':
439             continue
440         path = os.path.join(lp.get('realm').lower(), 'Policies', guid)
441         local_path = os.path.join(lp.get("path", "sysvol"), path)
442         version = int(gpo.gpo_get_sysvol_gpt_version(local_path)[1])
443         if version != store.get_int(guid):
444             logger.info('GPO %s has changed' % guid)
445             gp_db.state(GPOSTATE.APPLY)
446         else:
447             gp_db.state(GPOSTATE.ENFORCE)
448         gp_db.set_guid(guid)
449         store.start()
450         for ext in gp_extensions:
451             try:
452                 ext.parse(ext.list(path), test_ldb, conn, gp_db, lp)
453             except Exception as e:
454                 logger.error('Failed to parse gpo %s for extension %s' % \
455                     (guid, str(ext)))
456                 logger.error('Message was: ' + str(e))
457                 store.cancel()
458                 continue
459         store.store(guid, '%i' % version)
460         store.commit()
461
462 def unapply_log(gp_db):
463     while True:
464         item = gp_db.apply_log_pop()
465         if item:
466             yield item
467         else:
468             break
469
470 def unapply_gp(lp, creds, test_ldb, logger, store, gp_extensions):
471     gp_db = store.get_gplog(creds.get_username())
472     gp_db.state(GPOSTATE.UNAPPLY)
473     for gpo_guid in unapply_log(gp_db):
474         gp_db.set_guid(gpo_guid)
475         unapply_attributes = gp_db.list(gp_extensions)
476         for attr in unapply_attributes:
477             attr_obj = attr[-1](logger, test_ldb, gp_db, lp, attr[0], attr[1])
478             attr_obj.mapper()[attr[0]][0](attr[1]) # Set the old value
479             gp_db.delete(str(attr_obj), attr[0])
480         gp_db.commit()
481