a73cde4c3795bdf2d806b16488690e17cf551560
[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 import samba.gpo as gpo
23 import optparse
24 import ldb
25 from samba.auth import system_session
26 import samba.getopt as options
27 from samba.samdb import SamDB
28 from samba.netcmd import gpo as gpo_user
29 import codecs
30 from samba import NTSTATUSError
31 from ConfigParser import ConfigParser
32 from StringIO import StringIO
33 from abc import ABCMeta, abstractmethod
34 import xml.etree.ElementTree as etree
35
36 try:
37     from enum import Enum
38     GPOSTATE = Enum('GPOSTATE', 'APPLY ENFORCE UNAPPLY')
39 except ImportError:
40     class GPOSTATE:
41         APPLY = 1
42         ENFORCE = 2
43         UNAPPLY = 3
44
45 class gp_log:
46     ''' Log settings overwritten by gpo apply
47     The gp_log is an xml file that stores a history of gpo changes (and the original setting value).
48
49     The log is organized like so:
50
51 <gp>
52     <user name="KDC-1$">
53         <applylog>
54             <guid count="0" value="{31B2F340-016D-11D2-945F-00C04FB984F9}" />
55         </applylog>
56         <guid value="{31B2F340-016D-11D2-945F-00C04FB984F9}">
57             <gp_ext name="System Access">
58                 <attribute name="minPwdAge">-864000000000</attribute>
59                 <attribute name="maxPwdAge">-36288000000000</attribute>
60                 <attribute name="minPwdLength">7</attribute>
61                 <attribute name="pwdProperties">1</attribute>
62             </gp_ext>
63             <gp_ext name="Kerberos Policy">
64                 <attribute name="ticket_lifetime">1d</attribute>
65                 <attribute name="renew_lifetime" />
66                 <attribute name="clockskew">300</attribute>
67             </gp_ext>
68         </guid>
69     </user>
70 </gp>
71
72     Each guid value contains a list of extensions, which contain a list of attributes. The guid value
73     represents a GPO. The attributes are the values of those settings prior to the application of
74     the GPO.
75     The list of guids is enclosed within a user name, which represents the user the settings were
76     applied to. This user may be the samaccountname of the local computer, which implies that these
77     are machine policies.
78     The applylog keeps track of the order in which the GPOs were applied, so that they can be rolled
79     back in reverse, returning the machine to the state prior to policy application.
80     '''
81     def __init__(self, user, gpostore, db_log=None):
82         ''' Initialize the gp_log
83         param user          - the username (or machine name) that policies are being applied to
84         param gpostore      - the GPOStorage obj which references the tdb which contains gp_logs
85         param db_log        - (optional) a string to initialize the gp_log
86         '''
87         self._state = GPOSTATE.APPLY
88         self.gpostore = gpostore
89         self.username = user
90         if db_log:
91             self.gpdb = etree.fromstring(db_log)
92         else:
93             self.gpdb = etree.Element('gp')
94         self.user = self.gpdb.find('user[@name="%s"]' % user)
95         if self.user is None:
96             self.user = etree.SubElement(self.gpdb, 'user')
97             self.user.attrib['name'] = user
98
99     def state(self, value):
100         ''' Policy application state
101         param value         - APPLY, ENFORCE, or UNAPPLY
102
103         The behavior of the gp_log depends on whether we are applying policy, enforcing policy,
104         or unapplying policy. During an apply, old settings are recorded in the log. During an
105         enforce, settings are being applied but the gp_log does not change. During an unapply,
106         additions to the log should be ignored (since function calls to apply settings are actually
107         reverting policy), but removals from the log are allowed.
108         '''
109         # If we're enforcing, but we've unapplied, apply instead
110         if value == GPOSTATE.ENFORCE:
111             apply_log = self.user.find('applylog')
112             if apply_log is None or len(apply_log) == 0:
113                 self._state = GPOSTATE.APPLY
114             else:
115                 self._state = value
116         else:
117             self._state = value
118
119     def set_guid(self, guid):
120         ''' Log to a different GPO guid
121         param guid          - guid value of the GPO from which we're applying policy
122         '''
123         self.guid = self.user.find('guid[@value="%s"]' % guid)
124         if self.guid is None:
125             self.guid = etree.SubElement(self.user, 'guid')
126             self.guid.attrib['value'] = guid
127         if self._state == GPOSTATE.APPLY:
128             apply_log = self.user.find('applylog')
129             if apply_log is None:
130                 apply_log = etree.SubElement(self.user, 'applylog')
131             item = etree.SubElement(apply_log, 'guid')
132             item.attrib['count'] = '%d' % (len(apply_log)-1)
133             item.attrib['value'] = guid
134
135     def apply_log_pop(self):
136         ''' Pop a GPO guid from the applylog
137         return              - last applied GPO guid
138
139         Removes the GPO guid last added to the list, which is the most recently applied GPO.
140         '''
141         apply_log = self.user.find('applylog')
142         if apply_log is not None:
143             ret = apply_log.find('guid[@count="%d"]' % (len(apply_log)-1))
144             if ret is not None:
145                 apply_log.remove(ret)
146                 return ret.attrib['value']
147             if len(apply_log) == 0 and apply_log in self.user:
148                 self.user.remove(apply_log)
149         return None
150
151     def store(self, gp_ext_name, attribute, old_val):
152         ''' Store an attribute in the gp_log
153         param gp_ext_name   - Name of the extension applying policy
154         param attribute     - The attribute being modified
155         param old_val       - The value of the attribute prior to policy application
156         '''
157         if self._state == GPOSTATE.UNAPPLY or self._state == GPOSTATE.ENFORCE:
158             return None
159         assert self.guid is not None, "gpo guid was not set"
160         ext = self.guid.find('gp_ext[@name="%s"]' % gp_ext_name)
161         if ext is None:
162             ext = etree.SubElement(self.guid, 'gp_ext')
163             ext.attrib['name'] = gp_ext_name
164         attr = ext.find('attribute[@name="%s"]' % attribute)
165         if attr is None:
166             attr = etree.SubElement(ext, 'attribute')
167             attr.attrib['name'] = attribute
168         attr.text = old_val
169
170     def retrieve(self, gp_ext_name, attribute):
171         ''' Retrieve a stored attribute from the gp_log
172         param gp_ext_name   - Name of the extension which applied policy
173         param attribute     - The attribute being retrieved
174         return              - The value of the attribute prior to policy application
175         '''
176         assert self.guid is not None, "gpo guid was not set"
177         ext = self.guid.find('gp_ext[@name="%s"]' % gp_ext_name)
178         if ext is not None:
179             attr = ext.find('attribute[@name="%s"]' % attribute)
180             if attr is not None:
181                 return attr.text
182         return None
183
184     def list(self, gp_extensions):
185         ''' Return a list of attributes, their previous values, and functions to set them
186         param gp_extensions - list of extension objects, for retrieving attr to func mappings
187         return              - list of (attr, value, apply_func) tuples for unapplying policy
188         '''
189         assert self.guid is not None, "gpo guid was not set"
190         ret = []
191         data_maps = {}
192         for gp_ext in gp_extensions:
193             data_maps.update(gp_ext.apply_map())
194         exts = self.guid.findall('gp_ext')
195         if exts is not None:
196             for ext in exts:
197                 ext_map = {val[0]: val[1] for (key, val) in data_maps[ext.attrib['name']].items()}
198                 attrs = ext.findall('attribute')
199                 for attr in attrs:
200                     ret.append((attr.attrib['name'], attr.text, ext_map[attr.attrib['name']]))
201         return ret
202
203     def delete(self, gp_ext_name, attribute):
204         ''' Remove an attribute from the gp_log
205         param gp_ext_name   - name of extension from which to remove the attribute
206         param attribute     - attribute to remove
207         '''
208         assert self.guid is not None, "gpo guid was not set"
209         ext = self.guid.find('gp_ext[@name="%s"]' % gp_ext_name)
210         if ext is not None:
211             attr = ext.find('attribute[@name="%s"]' % attribute)
212             if attr is not None:
213                 ext.remove(attr)
214                 if len(ext) == 0:
215                     self.guid.remove(ext)
216
217     def commit(self):
218         ''' Write gp_log changes to disk '''
219         if len(self.guid) == 0 and self.guid in self.user:
220             self.user.remove(self.guid)
221         if len(self.user) == 0 and self.user in self.gpdb:
222             self.gpdb.remove(self.user)
223         self.gpostore.store(self.username, etree.tostring(self.gpdb, 'utf-8'))
224
225 class GPOStorage:
226     def __init__(self, log_file):
227         if os.path.isfile(log_file):
228             self.log = tdb.open(log_file)
229         else:
230             self.log = tdb.Tdb(log_file, 0, tdb.DEFAULT, os.O_CREAT|os.O_RDWR)
231
232     def start(self):
233         self.log.transaction_start()
234
235     def get_int(self, key):
236         try:
237             return int(self.log.get(key))
238         except TypeError:
239             return None
240
241     def get(self, key):
242         return self.log.get(key)
243
244     def get_gplog(self, user):
245         return gp_log(user, self, self.log.get(user))
246
247     def store(self, key, val):
248         self.log.store(key, val)
249
250     def cancel(self):
251         self.log.transaction_cancel()
252
253     def delete(self, key):
254         self.log.delete(key)
255
256     def commit(self):
257         self.log.transaction_commit()
258
259     def __del__(self):
260         self.log.close()
261
262 class gp_ext(object):
263     __metaclass__ = ABCMeta
264
265     @abstractmethod
266     def list(self, rootpath):
267         pass
268
269     @abstractmethod
270     def apply_map(self):
271         pass
272
273     @abstractmethod
274     def parse(self, afile, ldb, conn, gp_db, lp):
275         pass
276
277     @abstractmethod
278     def __str__(self):
279         pass
280
281 class inf_to():
282     __metaclass__ = ABCMeta
283
284     def __init__(self, logger, ldb, gp_db, lp, attribute, val):
285         self.logger = logger
286         self.ldb = ldb
287         self.attribute = attribute
288         self.val = val
289         self.lp = lp
290         self.gp_db = gp_db
291
292     def explicit(self):
293         return self.val
294
295     def update_samba(self):
296         (upd_sam, value) = self.mapper().get(self.attribute)
297         upd_sam(value())
298
299     @abstractmethod
300     def mapper(self):
301         pass
302
303     @abstractmethod
304     def __str__(self):
305         pass
306
307 class inf_to_ldb(inf_to):
308     '''This class takes the .inf file parameter (essentially a GPO file mapped to a GUID),
309     hashmaps it to the Samba parameter, which then uses an ldb object to update the
310     parameter to Samba4. Not registry oriented whatsoever.
311     '''
312
313     def ch_minPwdAge(self, val):
314         old_val = self.ldb.get_minPwdAge()
315         self.logger.info('KDC Minimum Password age was changed from %s to %s' % (old_val, val))
316         self.gp_db.store(str(self), self.attribute, old_val)
317         self.ldb.set_minPwdAge(val)
318
319     def ch_maxPwdAge(self, val):
320         old_val = self.ldb.get_maxPwdAge()
321         self.logger.info('KDC Maximum Password age was changed from %s to %s' % (old_val, val))
322         self.gp_db.store(str(self), self.attribute, old_val)
323         self.ldb.set_maxPwdAge(val)
324
325     def ch_minPwdLength(self, val):
326         old_val = self.ldb.get_minPwdLength()
327         self.logger.info('KDC Minimum Password length was changed from %s to %s' % (old_val, val))
328         self.gp_db.store(str(self), self.attribute, old_val)
329         self.ldb.set_minPwdLength(val)
330
331     def ch_pwdProperties(self, val):
332         old_val = self.ldb.get_pwdProperties()
333         self.logger.info('KDC Password Properties were changed from %s to %s' % (old_val, val))
334         self.gp_db.store(str(self), self.attribute, old_val)
335         self.ldb.set_pwdProperties(val)
336
337     def nttime2unix(self):
338         seconds = 60
339         minutes = 60
340         hours = 24
341         sam_add = 10000000
342         val = (self.val)
343         val = int(val)
344         return  str(-(val * seconds * minutes * hours * sam_add))
345
346     def mapper(self):
347         '''ldap value : samba setter'''
348         return { "minPwdAge" : (self.ch_minPwdAge, self.nttime2unix),
349                  "maxPwdAge" : (self.ch_maxPwdAge, self.nttime2unix),
350                  # Could be none, but I like the method assignment in update_samba
351                  "minPwdLength" : (self.ch_minPwdLength, self.explicit),
352                  "pwdProperties" : (self.ch_pwdProperties, self.explicit),
353
354                }
355
356     def __str__(self):
357         return 'System Access'
358
359
360 class gp_sec_ext(gp_ext):
361     '''This class does the following two things:
362         1) Identifies the GPO if it has a certain kind of filepath,
363         2) Finally parses it.
364     '''
365
366     count = 0
367
368     def __init__(self, logger):
369         self.logger = logger
370
371     def __str__(self):
372         return "Security GPO extension"
373
374     def list(self, rootpath):
375         return os.path.join(rootpath, "MACHINE/Microsoft/Windows NT/SecEdit/GptTmpl.inf")
376
377     def listmachpol(self, rootpath):
378         return os.path.join(rootpath, "Machine/Registry.pol")
379
380     def listuserpol(self, rootpath):
381         return os.path.join(rootpath, "User/Registry.pol")
382
383     def apply_map(self):
384         return {"System Access": {"MinimumPasswordAge": ("minPwdAge", inf_to_ldb),
385                                   "MaximumPasswordAge": ("maxPwdAge", inf_to_ldb),
386                                   "MinimumPasswordLength": ("minPwdLength", inf_to_ldb),
387                                   "PasswordComplexity": ("pwdProperties", inf_to_ldb),
388                                  }
389                }
390
391     def read_inf(self, path, conn):
392         ret = False
393         inftable = self.apply_map()
394
395         policy = conn.loadfile(path.replace('/', '\\'))
396         current_section = None
397
398         # So here we would declare a boolean,
399         # that would get changed to TRUE.
400         #
401         # If at any point in time a GPO was applied,
402         # then we return that boolean at the end.
403
404         inf_conf = ConfigParser()
405         inf_conf.optionxform=str
406         try:
407             inf_conf.readfp(StringIO(policy))
408         except:
409             inf_conf.readfp(StringIO(policy.decode('utf-16')))
410
411         for section in inf_conf.sections():
412             current_section = inftable.get(section)
413             if not current_section:
414                 continue
415             for key, value in inf_conf.items(section):
416                 if current_section.get(key):
417                     (att, setter) = current_section.get(key)
418                     value = value.encode('ascii', 'ignore')
419                     ret = True
420                     setter(self.logger, self.ldb, self.gp_db, self.lp, att, value).update_samba()
421                     self.gp_db.commit()
422         return ret
423
424     def parse(self, afile, ldb, conn, gp_db, lp):
425         self.ldb = ldb
426         self.gp_db = gp_db
427         self.lp = lp
428
429         # Fixing the bug where only some Linux Boxes capitalize MACHINE
430         if afile.endswith('inf'):
431             try:
432                 blist = afile.split('/')
433                 idx = afile.lower().split('/').index('machine')
434                 for case in [blist[idx].upper(), blist[idx].capitalize(), blist[idx].lower()]:
435                     bfile = '/'.join(blist[:idx]) + '/' + case + '/' + '/'.join(blist[idx+1:])
436                     try:
437                         return self.read_inf(bfile, conn)
438                     except NTSTATUSError:
439                         continue
440             except ValueError:
441                 try:
442                     return self.read_inf(afile, conn)
443                 except:
444                     return None
445