/mandos/trunk

To get this branch, use:
bzr branch http://bzr.recompile.se/loggerhead/mandos/trunk

« back to all changes in this revision

Viewing changes to mandos

  • Committer: Teddy Hogeborn
  • Date: 2008-08-27 01:18:25 UTC
  • Revision ID: teddy@fukt.bsnet.se-20080827011825-ka3ni6xvy2ehi1y8
* .bzrignore: New.

* clients.conf ([foo]): Remove Radix-64 checksum.

* mandos (AvahiService.rename, server_state_changed,
          entry_group_state_changed): Make Avahi log messages more
                                      clear that they are about
                                      Zeroconf.
  (fingerprint): Use plain "0" instead of "ctypes.c_uint(0)".

Show diffs side-by-side

added added

removed removed

Lines of Context:
mandos
11
11
# and some lines in "main".
12
12
# 
13
13
# Everything else is
14
 
# Copyright © 2008 Teddy Hogeborn
15
 
# Copyright © 2008 Björn Påhlsson
 
14
# Copyright © 2007-2008 Teddy Hogeborn & Björn Påhlsson
16
15
# 
17
16
# This program is free software: you can redistribute it and/or modify
18
17
# it under the terms of the GNU General Public License as published by
31
30
# Contact the authors at <mandos@fukt.bsnet.se>.
32
31
# 
33
32
 
34
 
from __future__ import division, with_statement, absolute_import
 
33
from __future__ import division
35
34
 
36
35
import SocketServer
37
36
import socket
 
37
import select
38
38
from optparse import OptionParser
39
39
import datetime
40
40
import errno
55
55
import stat
56
56
import logging
57
57
import logging.handlers
58
 
import pwd
59
 
from contextlib import closing
60
58
 
61
59
import dbus
62
 
import dbus.service
63
60
import gobject
64
61
import avahi
65
62
from dbus.mainloop.glib import DBusGMainLoop
66
63
import ctypes
67
 
import ctypes.util
68
64
 
69
 
version = "1.0.2"
 
65
version = "1.0"
70
66
 
71
67
logger = logging.Logger('mandos')
72
 
syslogger = (logging.handlers.SysLogHandler
73
 
             (facility = logging.handlers.SysLogHandler.LOG_DAEMON,
74
 
              address = "/dev/log"))
75
 
syslogger.setFormatter(logging.Formatter
76
 
                       ('Mandos: %(levelname)s: %(message)s'))
 
68
syslogger = logging.handlers.SysLogHandler\
 
69
            (facility = logging.handlers.SysLogHandler.LOG_DAEMON,
 
70
             address = "/dev/log")
 
71
syslogger.setFormatter(logging.Formatter\
 
72
                        ('Mandos: %(levelname)s: %(message)s'))
77
73
logger.addHandler(syslogger)
78
74
 
79
75
console = logging.StreamHandler()
84
80
class AvahiError(Exception):
85
81
    def __init__(self, value):
86
82
        self.value = value
87
 
        super(AvahiError, self).__init__()
88
83
    def __str__(self):
89
84
        return repr(self.value)
90
85
 
112
107
                  a sensible number of times
113
108
    """
114
109
    def __init__(self, interface = avahi.IF_UNSPEC, name = None,
115
 
                 servicetype = None, port = None, TXT = None,
116
 
                 domain = "", host = "", max_renames = 32768):
 
110
                 type = None, port = None, TXT = None, domain = "",
 
111
                 host = "", max_renames = 32768):
117
112
        self.interface = interface
118
113
        self.name = name
119
 
        self.type = servicetype
 
114
        self.type = type
120
115
        self.port = port
121
 
        self.TXT = TXT if TXT is not None else []
 
116
        if TXT is None:
 
117
            self.TXT = []
 
118
        else:
 
119
            self.TXT = TXT
122
120
        self.domain = domain
123
121
        self.host = host
124
122
        self.rename_count = 0
128
126
        if self.rename_count >= self.max_renames:
129
127
            logger.critical(u"No suitable Zeroconf service name found"
130
128
                            u" after %i retries, exiting.",
131
 
                            self.rename_count)
 
129
                            rename_count)
132
130
            raise AvahiServiceError("Too many renames")
133
131
        self.name = server.GetAlternativeServiceName(self.name)
134
132
        logger.info(u"Changing Zeroconf service name to %r ...",
135
133
                    str(self.name))
136
 
        syslogger.setFormatter(logging.Formatter
 
134
        syslogger.setFormatter(logging.Formatter\
137
135
                               ('Mandos (%s): %%(levelname)s:'
138
 
                                ' %%(message)s' % self.name))
 
136
                               ' %%(message)s' % self.name))
139
137
        self.remove()
140
138
        self.add()
141
139
        self.rename_count += 1
147
145
        """Derived from the Avahi example code"""
148
146
        global group
149
147
        if group is None:
150
 
            group = dbus.Interface(bus.get_object
151
 
                                   (avahi.DBUS_NAME,
 
148
            group = dbus.Interface\
 
149
                    (bus.get_object(avahi.DBUS_NAME,
152
150
                                    server.EntryGroupNew()),
153
 
                                   avahi.DBUS_INTERFACE_ENTRY_GROUP)
 
151
                     avahi.DBUS_INTERFACE_ENTRY_GROUP)
154
152
            group.connect_to_signal('StateChanged',
155
153
                                    entry_group_state_changed)
156
154
        logger.debug(u"Adding Zeroconf service '%s' of type '%s' ...",
170
168
# End of Avahi example code
171
169
 
172
170
 
173
 
def _datetime_to_dbus(dt, variant_level=0):
174
 
    """Convert a UTC datetime.datetime() to a D-Bus type."""
175
 
    return dbus.String(dt.isoformat(), variant_level=variant_level)
176
 
 
177
 
 
178
 
class Client(dbus.service.Object):
 
171
class Client(object):
179
172
    """A representation of a client host served by this server.
180
173
    Attributes:
181
 
    name:       string; from the config file, used in log messages
 
174
    name:      string; from the config file, used in log messages
182
175
    fingerprint: string (40 or 32 hexadecimal digits); used to
183
176
                 uniquely identify the client
184
 
    secret:     bytestring; sent verbatim (over TLS) to client
185
 
    host:       string; available for use by the checker command
186
 
    created:    datetime.datetime(); (UTC) object creation
187
 
    last_enabled: datetime.datetime(); (UTC)
188
 
    enabled:    bool()
189
 
    last_checked_ok: datetime.datetime(); (UTC) or None
190
 
    timeout:    datetime.timedelta(); How long from last_checked_ok
191
 
                                      until this client is invalid
192
 
    interval:   datetime.timedelta(); How often to start a new checker
193
 
    disable_hook:  If set, called by disable() as disable_hook(self)
194
 
    checker:    subprocess.Popen(); a running checker process used
195
 
                                    to see if the client lives.
196
 
                                    'None' if no process is running.
 
177
    secret:    bytestring; sent verbatim (over TLS) to client
 
178
    host:      string; available for use by the checker command
 
179
    created:   datetime.datetime(); object creation, not client host
 
180
    last_checked_ok: datetime.datetime() or None if not yet checked OK
 
181
    timeout:   datetime.timedelta(); How long from last_checked_ok
 
182
                                     until this client is invalid
 
183
    interval:  datetime.timedelta(); How often to start a new checker
 
184
    stop_hook: If set, called by stop() as stop_hook(self)
 
185
    checker:   subprocess.Popen(); a running checker process used
 
186
                                   to see if the client lives.
 
187
                                   'None' if no process is running.
197
188
    checker_initiator_tag: a gobject event source tag, or None
198
 
    disable_initiator_tag:    - '' -
 
189
    stop_initiator_tag:    - '' -
199
190
    checker_callback_tag:  - '' -
200
191
    checker_command: string; External command which is run to check if
201
192
                     client lives.  %() expansions are done at
202
193
                     runtime with vars(self) as dict, so that for
203
194
                     instance %(name)s can be used in the command.
204
 
    dbus_object_path: dbus.ObjectPath
205
195
    Private attibutes:
206
196
    _timeout: Real variable for 'timeout'
207
197
    _interval: Real variable for 'interval'
209
199
    _interval_milliseconds: - '' -
210
200
    """
211
201
    def _set_timeout(self, timeout):
212
 
        "Setter function for the 'timeout' attribute"
 
202
        "Setter function for 'timeout' attribute"
213
203
        self._timeout = timeout
214
204
        self._timeout_milliseconds = ((self.timeout.days
215
205
                                       * 24 * 60 * 60 * 1000)
216
206
                                      + (self.timeout.seconds * 1000)
217
207
                                      + (self.timeout.microseconds
218
208
                                         // 1000))
219
 
        # Emit D-Bus signal
220
 
        self.PropertyChanged(dbus.String(u"timeout"),
221
 
                             (dbus.UInt64(self._timeout_milliseconds,
222
 
                                          variant_level=1)))
223
 
    timeout = property(lambda self: self._timeout, _set_timeout)
 
209
    timeout = property(lambda self: self._timeout,
 
210
                       _set_timeout)
224
211
    del _set_timeout
225
 
    
226
212
    def _set_interval(self, interval):
227
 
        "Setter function for the 'interval' attribute"
 
213
        "Setter function for 'interval' attribute"
228
214
        self._interval = interval
229
215
        self._interval_milliseconds = ((self.interval.days
230
216
                                        * 24 * 60 * 60 * 1000)
232
218
                                          * 1000)
233
219
                                       + (self.interval.microseconds
234
220
                                          // 1000))
235
 
        # Emit D-Bus signal
236
 
        self.PropertyChanged(dbus.String(u"interval"),
237
 
                             (dbus.UInt64(self._interval_milliseconds,
238
 
                                          variant_level=1)))
239
 
    interval = property(lambda self: self._interval, _set_interval)
 
221
    interval = property(lambda self: self._interval,
 
222
                        _set_interval)
240
223
    del _set_interval
241
 
    
242
 
    def __init__(self, name = None, disable_hook=None, config=None):
 
224
    def __init__(self, name = None, stop_hook=None, config={}):
243
225
        """Note: the 'checker' key in 'config' sets the
244
226
        'checker_command' attribute and *not* the 'checker'
245
227
        attribute."""
246
 
        self.dbus_object_path = (dbus.ObjectPath
247
 
                                 ("/Mandos/clients/"
248
 
                                  + name.replace(".", "_")))
249
 
        dbus.service.Object.__init__(self, bus,
250
 
                                     self.dbus_object_path)
251
 
        if config is None:
252
 
            config = {}
253
228
        self.name = name
254
229
        logger.debug(u"Creating client %r", self.name)
255
230
        # Uppercase and remove spaces from fingerprint for later
256
231
        # comparison purposes with return value from the fingerprint()
257
232
        # function
258
 
        self.fingerprint = (config["fingerprint"].upper()
259
 
                            .replace(u" ", u""))
 
233
        self.fingerprint = config["fingerprint"].upper()\
 
234
                           .replace(u" ", u"")
260
235
        logger.debug(u"  Fingerprint: %s", self.fingerprint)
261
236
        if "secret" in config:
262
237
            self.secret = config["secret"].decode(u"base64")
263
238
        elif "secfile" in config:
264
 
            with closing(open(os.path.expanduser
265
 
                              (os.path.expandvars
266
 
                               (config["secfile"])))) as secfile:
267
 
                self.secret = secfile.read()
 
239
            sf = open(config["secfile"])
 
240
            self.secret = sf.read()
 
241
            sf.close()
268
242
        else:
269
243
            raise TypeError(u"No secret or secfile for client %s"
270
244
                            % self.name)
271
245
        self.host = config.get("host", "")
272
 
        self.created = datetime.datetime.utcnow()
273
 
        self.enabled = False
274
 
        self.last_enabled = None
 
246
        self.created = datetime.datetime.now()
275
247
        self.last_checked_ok = None
276
248
        self.timeout = string_to_delta(config["timeout"])
277
249
        self.interval = string_to_delta(config["interval"])
278
 
        self.disable_hook = disable_hook
 
250
        self.stop_hook = stop_hook
279
251
        self.checker = None
280
252
        self.checker_initiator_tag = None
281
 
        self.disable_initiator_tag = None
 
253
        self.stop_initiator_tag = None
282
254
        self.checker_callback_tag = None
283
 
        self.checker_command = config["checker"]
284
 
    
285
 
    def enable(self):
 
255
        self.check_command = config["checker"]
 
256
    def start(self):
286
257
        """Start this client's checker and timeout hooks"""
287
 
        self.last_enabled = datetime.datetime.utcnow()
288
258
        # Schedule a new checker to be started an 'interval' from now,
289
259
        # and every interval from then on.
290
 
        self.checker_initiator_tag = (gobject.timeout_add
291
 
                                      (self._interval_milliseconds,
292
 
                                       self.start_checker))
 
260
        self.checker_initiator_tag = gobject.timeout_add\
 
261
                                     (self._interval_milliseconds,
 
262
                                      self.start_checker)
293
263
        # Also start a new checker *right now*.
294
264
        self.start_checker()
295
 
        # Schedule a disable() when 'timeout' has passed
296
 
        self.disable_initiator_tag = (gobject.timeout_add
297
 
                                   (self._timeout_milliseconds,
298
 
                                    self.disable))
299
 
        self.enabled = True
300
 
        # Emit D-Bus signal
301
 
        self.PropertyChanged(dbus.String(u"enabled"),
302
 
                             dbus.Boolean(True, variant_level=1))
303
 
        self.PropertyChanged(dbus.String(u"last_enabled"),
304
 
                             (_datetime_to_dbus(self.last_enabled,
305
 
                                                variant_level=1)))
306
 
    
307
 
    def disable(self):
308
 
        """Disable this client."""
309
 
        if not getattr(self, "enabled", False):
 
265
        # Schedule a stop() when 'timeout' has passed
 
266
        self.stop_initiator_tag = gobject.timeout_add\
 
267
                                  (self._timeout_milliseconds,
 
268
                                   self.stop)
 
269
    def stop(self):
 
270
        """Stop this client.
 
271
        The possibility that a client might be restarted is left open,
 
272
        but not currently used."""
 
273
        # If this client doesn't have a secret, it is already stopped.
 
274
        if hasattr(self, "secret") and self.secret:
 
275
            logger.info(u"Stopping client %s", self.name)
 
276
            self.secret = None
 
277
        else:
310
278
            return False
311
 
        logger.info(u"Disabling client %s", self.name)
312
 
        if getattr(self, "disable_initiator_tag", False):
313
 
            gobject.source_remove(self.disable_initiator_tag)
314
 
            self.disable_initiator_tag = None
 
279
        if getattr(self, "stop_initiator_tag", False):
 
280
            gobject.source_remove(self.stop_initiator_tag)
 
281
            self.stop_initiator_tag = None
315
282
        if getattr(self, "checker_initiator_tag", False):
316
283
            gobject.source_remove(self.checker_initiator_tag)
317
284
            self.checker_initiator_tag = None
318
285
        self.stop_checker()
319
 
        if self.disable_hook:
320
 
            self.disable_hook(self)
321
 
        self.enabled = False
322
 
        # Emit D-Bus signal
323
 
        self.PropertyChanged(dbus.String(u"enabled"),
324
 
                             dbus.Boolean(False, variant_level=1))
 
286
        if self.stop_hook:
 
287
            self.stop_hook(self)
325
288
        # Do not run this again if called by a gobject.timeout_add
326
289
        return False
327
 
    
328
290
    def __del__(self):
329
 
        self.disable_hook = None
330
 
        self.disable()
331
 
    
332
 
    def checker_callback(self, pid, condition, command):
 
291
        self.stop_hook = None
 
292
        self.stop()
 
293
    def checker_callback(self, pid, condition):
333
294
        """The checker has completed, so take appropriate actions."""
 
295
        now = datetime.datetime.now()
334
296
        self.checker_callback_tag = None
335
297
        self.checker = None
336
 
        # Emit D-Bus signal
337
 
        self.PropertyChanged(dbus.String(u"checker_running"),
338
 
                             dbus.Boolean(False, variant_level=1))
339
 
        if (os.WIFEXITED(condition)
340
 
            and (os.WEXITSTATUS(condition) == 0)):
 
298
        if os.WIFEXITED(condition) \
 
299
               and (os.WEXITSTATUS(condition) == 0):
341
300
            logger.info(u"Checker for %(name)s succeeded",
342
301
                        vars(self))
343
 
            # Emit D-Bus signal
344
 
            self.CheckerCompleted(dbus.Boolean(True),
345
 
                                  dbus.UInt16(condition),
346
 
                                  dbus.String(command))
347
 
            self.bump_timeout()
 
302
            self.last_checked_ok = now
 
303
            gobject.source_remove(self.stop_initiator_tag)
 
304
            self.stop_initiator_tag = gobject.timeout_add\
 
305
                                      (self._timeout_milliseconds,
 
306
                                       self.stop)
348
307
        elif not os.WIFEXITED(condition):
349
308
            logger.warning(u"Checker for %(name)s crashed?",
350
309
                           vars(self))
351
 
            # Emit D-Bus signal
352
 
            self.CheckerCompleted(dbus.Boolean(False),
353
 
                                  dbus.UInt16(condition),
354
 
                                  dbus.String(command))
355
310
        else:
356
311
            logger.info(u"Checker for %(name)s failed",
357
312
                        vars(self))
358
 
            # Emit D-Bus signal
359
 
            self.CheckerCompleted(dbus.Boolean(False),
360
 
                                  dbus.UInt16(condition),
361
 
                                  dbus.String(command))
362
 
    
363
 
    def bump_timeout(self):
364
 
        """Bump up the timeout for this client.
365
 
        This should only be called when the client has been seen,
366
 
        alive and well.
367
 
        """
368
 
        self.last_checked_ok = datetime.datetime.utcnow()
369
 
        gobject.source_remove(self.disable_initiator_tag)
370
 
        self.disable_initiator_tag = (gobject.timeout_add
371
 
                                      (self._timeout_milliseconds,
372
 
                                       self.disable))
373
 
        self.PropertyChanged(dbus.String(u"last_checked_ok"),
374
 
                             (_datetime_to_dbus(self.last_checked_ok,
375
 
                                                variant_level=1)))
376
 
    
377
313
    def start_checker(self):
378
314
        """Start a new checker subprocess if one is not running.
379
315
        If a checker already exists, leave it running and do
388
324
        # is as it should be.
389
325
        if self.checker is None:
390
326
            try:
391
 
                # In case checker_command has exactly one % operator
392
 
                command = self.checker_command % self.host
 
327
                # In case check_command has exactly one % operator
 
328
                command = self.check_command % self.host
393
329
            except TypeError:
394
330
                # Escape attributes for the shell
395
331
                escaped_attrs = dict((key, re.escape(str(val)))
396
332
                                     for key, val in
397
333
                                     vars(self).iteritems())
398
334
                try:
399
 
                    command = self.checker_command % escaped_attrs
 
335
                    command = self.check_command % escaped_attrs
400
336
                except TypeError, error:
401
337
                    logger.error(u'Could not format string "%s":'
402
 
                                 u' %s', self.checker_command, error)
 
338
                                 u' %s', self.check_command, error)
403
339
                    return True # Try again later
404
340
            try:
405
341
                logger.info(u"Starting checker %r for %s",
411
347
                self.checker = subprocess.Popen(command,
412
348
                                                close_fds=True,
413
349
                                                shell=True, cwd="/")
414
 
                # Emit D-Bus signal
415
 
                self.CheckerStarted(command)
416
 
                self.PropertyChanged(dbus.String("checker_running"),
417
 
                                     dbus.Boolean(True, variant_level=1))
418
 
                self.checker_callback_tag = (gobject.child_watch_add
419
 
                                             (self.checker.pid,
420
 
                                              self.checker_callback,
421
 
                                              data=command))
 
350
                self.checker_callback_tag = gobject.child_watch_add\
 
351
                                            (self.checker.pid,
 
352
                                             self.checker_callback)
422
353
            except OSError, error:
423
354
                logger.error(u"Failed to start subprocess: %s",
424
355
                             error)
425
356
        # Re-run this periodically if run by gobject.timeout_add
426
357
        return True
427
 
    
428
358
    def stop_checker(self):
429
359
        """Force the checker process, if any, to stop."""
430
360
        if self.checker_callback_tag:
442
372
            if error.errno != errno.ESRCH: # No such process
443
373
                raise
444
374
        self.checker = None
445
 
        self.PropertyChanged(dbus.String(u"checker_running"),
446
 
                             dbus.Boolean(False, variant_level=1))
447
 
    
448
375
    def still_valid(self):
449
376
        """Has the timeout not yet passed for this client?"""
450
 
        if not getattr(self, "enabled", False):
451
 
            return False
452
 
        now = datetime.datetime.utcnow()
 
377
        now = datetime.datetime.now()
453
378
        if self.last_checked_ok is None:
454
379
            return now < (self.created + self.timeout)
455
380
        else:
456
381
            return now < (self.last_checked_ok + self.timeout)
457
 
    
458
 
    ## D-Bus methods & signals
459
 
    _interface = u"org.mandos_system.Mandos.Client"
460
 
    
461
 
    # BumpTimeout - method
462
 
    BumpTimeout = dbus.service.method(_interface)(bump_timeout)
463
 
    BumpTimeout.__name__ = "BumpTimeout"
464
 
    
465
 
    # CheckerCompleted - signal
466
 
    @dbus.service.signal(_interface, signature="bqs")
467
 
    def CheckerCompleted(self, success, condition, command):
468
 
        "D-Bus signal"
469
 
        pass
470
 
    
471
 
    # CheckerStarted - signal
472
 
    @dbus.service.signal(_interface, signature="s")
473
 
    def CheckerStarted(self, command):
474
 
        "D-Bus signal"
475
 
        pass
476
 
    
477
 
    # GetAllProperties - method
478
 
    @dbus.service.method(_interface, out_signature="a{sv}")
479
 
    def GetAllProperties(self):
480
 
        "D-Bus method"
481
 
        return dbus.Dictionary({
482
 
                dbus.String("name"):
483
 
                    dbus.String(self.name, variant_level=1),
484
 
                dbus.String("fingerprint"):
485
 
                    dbus.String(self.fingerprint, variant_level=1),
486
 
                dbus.String("host"):
487
 
                    dbus.String(self.host, variant_level=1),
488
 
                dbus.String("created"):
489
 
                    _datetime_to_dbus(self.created, variant_level=1),
490
 
                dbus.String("last_enabled"):
491
 
                    (_datetime_to_dbus(self.last_enabled,
492
 
                                       variant_level=1)
493
 
                     if self.last_enabled is not None
494
 
                     else dbus.Boolean(False, variant_level=1)),
495
 
                dbus.String("enabled"):
496
 
                    dbus.Boolean(self.enabled, variant_level=1),
497
 
                dbus.String("last_checked_ok"):
498
 
                    (_datetime_to_dbus(self.last_checked_ok,
499
 
                                       variant_level=1)
500
 
                     if self.last_checked_ok is not None
501
 
                     else dbus.Boolean (False, variant_level=1)),
502
 
                dbus.String("timeout"):
503
 
                    dbus.UInt64(self._timeout_milliseconds,
504
 
                                variant_level=1),
505
 
                dbus.String("interval"):
506
 
                    dbus.UInt64(self._interval_milliseconds,
507
 
                                variant_level=1),
508
 
                dbus.String("checker"):
509
 
                    dbus.String(self.checker_command,
510
 
                                variant_level=1),
511
 
                dbus.String("checker_running"):
512
 
                    dbus.Boolean(self.checker is not None,
513
 
                                 variant_level=1),
514
 
                }, signature="sv")
515
 
    
516
 
    # IsStillValid - method
517
 
    IsStillValid = (dbus.service.method(_interface, out_signature="b")
518
 
                    (still_valid))
519
 
    IsStillValid.__name__ = "IsStillValid"
520
 
    
521
 
    # PropertyChanged - signal
522
 
    @dbus.service.signal(_interface, signature="sv")
523
 
    def PropertyChanged(self, property, value):
524
 
        "D-Bus signal"
525
 
        pass
526
 
    
527
 
    # SetChecker - method
528
 
    @dbus.service.method(_interface, in_signature="s")
529
 
    def SetChecker(self, checker):
530
 
        "D-Bus setter method"
531
 
        self.checker_command = checker
532
 
    
533
 
    # SetHost - method
534
 
    @dbus.service.method(_interface, in_signature="s")
535
 
    def SetHost(self, host):
536
 
        "D-Bus setter method"
537
 
        self.host = host
538
 
    
539
 
    # SetInterval - method
540
 
    @dbus.service.method(_interface, in_signature="t")
541
 
    def SetInterval(self, milliseconds):
542
 
        self.interval = datetime.timdeelta(0, 0, 0, milliseconds)
543
 
    
544
 
    # SetSecret - method
545
 
    @dbus.service.method(_interface, in_signature="ay",
546
 
                         byte_arrays=True)
547
 
    def SetSecret(self, secret):
548
 
        "D-Bus setter method"
549
 
        self.secret = str(secret)
550
 
    
551
 
    # SetTimeout - method
552
 
    @dbus.service.method(_interface, in_signature="t")
553
 
    def SetTimeout(self, milliseconds):
554
 
        self.timeout = datetime.timedelta(0, 0, 0, milliseconds)
555
 
    
556
 
    # Enable - method
557
 
    Enable = dbus.service.method(_interface)(enable)
558
 
    Enable.__name__ = "Enable"
559
 
    
560
 
    # StartChecker - method
561
 
    @dbus.service.method(_interface)
562
 
    def StartChecker(self):
563
 
        "D-Bus method"
564
 
        self.start_checker()
565
 
    
566
 
    # Disable - method
567
 
    @dbus.service.method(_interface)
568
 
    def Disable(self):
569
 
        "D-Bus method"
570
 
        self.disable()
571
 
    
572
 
    # StopChecker - method
573
 
    StopChecker = dbus.service.method(_interface)(stop_checker)
574
 
    StopChecker.__name__ = "StopChecker"
575
 
    
576
 
    del _interface
577
382
 
578
383
 
579
384
def peer_certificate(session):
580
385
    "Return the peer's OpenPGP certificate as a bytestring"
581
386
    # If not an OpenPGP certificate...
582
 
    if (gnutls.library.functions
583
 
        .gnutls_certificate_type_get(session._c_object)
584
 
        != gnutls.library.constants.GNUTLS_CRT_OPENPGP):
 
387
    if gnutls.library.functions.gnutls_certificate_type_get\
 
388
            (session._c_object) \
 
389
           != gnutls.library.constants.GNUTLS_CRT_OPENPGP:
585
390
        # ...do the normal thing
586
391
        return session.peer_certificate
587
392
    list_size = ctypes.c_uint()
588
 
    cert_list = (gnutls.library.functions
589
 
                 .gnutls_certificate_get_peers
590
 
                 (session._c_object, ctypes.byref(list_size)))
 
393
    cert_list = gnutls.library.functions.gnutls_certificate_get_peers\
 
394
        (session._c_object, ctypes.byref(list_size))
591
395
    if list_size.value == 0:
592
396
        return None
593
397
    cert = cert_list[0]
597
401
def fingerprint(openpgp):
598
402
    "Convert an OpenPGP bytestring to a hexdigit fingerprint string"
599
403
    # New GnuTLS "datum" with the OpenPGP public key
600
 
    datum = (gnutls.library.types
601
 
             .gnutls_datum_t(ctypes.cast(ctypes.c_char_p(openpgp),
602
 
                                         ctypes.POINTER
603
 
                                         (ctypes.c_ubyte)),
604
 
                             ctypes.c_uint(len(openpgp))))
 
404
    datum = gnutls.library.types.gnutls_datum_t\
 
405
        (ctypes.cast(ctypes.c_char_p(openpgp),
 
406
                     ctypes.POINTER(ctypes.c_ubyte)),
 
407
         ctypes.c_uint(len(openpgp)))
605
408
    # New empty GnuTLS certificate
606
409
    crt = gnutls.library.types.gnutls_openpgp_crt_t()
607
 
    (gnutls.library.functions
608
 
     .gnutls_openpgp_crt_init(ctypes.byref(crt)))
 
410
    gnutls.library.functions.gnutls_openpgp_crt_init\
 
411
        (ctypes.byref(crt))
609
412
    # Import the OpenPGP public key into the certificate
610
 
    (gnutls.library.functions
611
 
     .gnutls_openpgp_crt_import(crt, ctypes.byref(datum),
612
 
                                gnutls.library.constants
613
 
                                .GNUTLS_OPENPGP_FMT_RAW))
 
413
    gnutls.library.functions.gnutls_openpgp_crt_import\
 
414
                    (crt, ctypes.byref(datum),
 
415
                     gnutls.library.constants.GNUTLS_OPENPGP_FMT_RAW)
614
416
    # Verify the self signature in the key
615
 
    crtverify = ctypes.c_uint()
616
 
    (gnutls.library.functions
617
 
     .gnutls_openpgp_crt_verify_self(crt, 0, ctypes.byref(crtverify)))
 
417
    crtverify = ctypes.c_uint();
 
418
    gnutls.library.functions.gnutls_openpgp_crt_verify_self\
 
419
        (crt, 0, ctypes.byref(crtverify))
618
420
    if crtverify.value != 0:
619
421
        gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
620
422
        raise gnutls.errors.CertificateSecurityError("Verify failed")
621
423
    # New buffer for the fingerprint
622
 
    buf = ctypes.create_string_buffer(20)
623
 
    buf_len = ctypes.c_size_t()
 
424
    buffer = ctypes.create_string_buffer(20)
 
425
    buffer_length = ctypes.c_size_t()
624
426
    # Get the fingerprint from the certificate into the buffer
625
 
    (gnutls.library.functions
626
 
     .gnutls_openpgp_crt_get_fingerprint(crt, ctypes.byref(buf),
627
 
                                         ctypes.byref(buf_len)))
 
427
    gnutls.library.functions.gnutls_openpgp_crt_get_fingerprint\
 
428
        (crt, ctypes.byref(buffer), ctypes.byref(buffer_length))
628
429
    # Deinit the certificate
629
430
    gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
630
431
    # Convert the buffer to a Python bytestring
631
 
    fpr = ctypes.string_at(buf, buf_len.value)
 
432
    fpr = ctypes.string_at(buffer, buffer_length.value)
632
433
    # Convert the bytestring to hexadecimal notation
633
434
    hex_fpr = u''.join(u"%02X" % ord(char) for char in fpr)
634
435
    return hex_fpr
635
436
 
636
437
 
637
 
class TCP_handler(SocketServer.BaseRequestHandler, object):
 
438
class tcp_handler(SocketServer.BaseRequestHandler, object):
638
439
    """A TCP request handler class.
639
440
    Instantiated by IPv6_TCPServer for each request to handle it.
640
441
    Note: This will run in its own forked process."""
641
442
    
642
443
    def handle(self):
643
444
        logger.info(u"TCP connection from: %s",
644
 
                    unicode(self.client_address))
645
 
        session = (gnutls.connection
646
 
                   .ClientSession(self.request,
647
 
                                  gnutls.connection
648
 
                                  .X509Credentials()))
 
445
                     unicode(self.client_address))
 
446
        session = gnutls.connection.ClientSession\
 
447
                  (self.request, gnutls.connection.X509Credentials())
649
448
        
650
449
        line = self.request.makefile().readline()
651
450
        logger.debug(u"Protocol version: %r", line)
664
463
        #priority = ':'.join(("NONE", "+VERS-TLS1.1", "+AES-256-CBC",
665
464
        #                "+SHA1", "+COMP-NULL", "+CTYPE-OPENPGP",
666
465
        #                "+DHE-DSS"))
667
 
        # Use a fallback default, since this MUST be set.
668
 
        priority = self.server.settings.get("priority", "NORMAL")
669
 
        (gnutls.library.functions
670
 
         .gnutls_priority_set_direct(session._c_object,
671
 
                                     priority, None))
 
466
        priority = "NORMAL"             # Fallback default, since this
 
467
                                        # MUST be set.
 
468
        if self.server.settings["priority"]:
 
469
            priority = self.server.settings["priority"]
 
470
        gnutls.library.functions.gnutls_priority_set_direct\
 
471
            (session._c_object, priority, None);
672
472
        
673
473
        try:
674
474
            session.handshake()
684
484
            session.bye()
685
485
            return
686
486
        logger.debug(u"Fingerprint: %s", fpr)
 
487
        client = None
687
488
        for c in self.server.clients:
688
489
            if c.fingerprint == fpr:
689
490
                client = c
690
491
                break
691
 
        else:
 
492
        if not client:
692
493
            logger.warning(u"Client not found for fingerprint: %s",
693
494
                           fpr)
694
495
            session.bye()
701
502
                           vars(client))
702
503
            session.bye()
703
504
            return
704
 
        ## This won't work here, since we're in a fork.
705
 
        # client.bump_timeout()
706
505
        sent_size = 0
707
506
        while sent_size < len(client.secret):
708
507
            sent = session.send(client.secret[sent_size:])
713
512
        session.bye()
714
513
 
715
514
 
716
 
class IPv6_TCPServer(SocketServer.ForkingMixIn,
717
 
                     SocketServer.TCPServer, object):
 
515
class IPv6_TCPServer(SocketServer.ForkingTCPServer, object):
718
516
    """IPv6 TCP server.  Accepts 'None' as address and/or port.
719
517
    Attributes:
720
518
        settings:       Server settings
721
519
        clients:        Set() of Client objects
722
 
        enabled:        Boolean; whether this server is activated yet
723
520
    """
724
521
    address_family = socket.AF_INET6
725
522
    def __init__(self, *args, **kwargs):
729
526
        if "clients" in kwargs:
730
527
            self.clients = kwargs["clients"]
731
528
            del kwargs["clients"]
732
 
        self.enabled = False
733
 
        super(IPv6_TCPServer, self).__init__(*args, **kwargs)
 
529
        return super(type(self), self).__init__(*args, **kwargs)
734
530
    def server_bind(self):
735
531
        """This overrides the normal server_bind() function
736
532
        to bind to an interface if one was specified, and also NOT to
765
561
#                                            if_nametoindex
766
562
#                                            (self.settings
767
563
#                                             ["interface"]))
768
 
            return super(IPv6_TCPServer, self).server_bind()
769
 
    def server_activate(self):
770
 
        if self.enabled:
771
 
            return super(IPv6_TCPServer, self).server_activate()
772
 
    def enable(self):
773
 
        self.enabled = True
 
564
            return super(type(self), self).server_bind()
774
565
 
775
566
 
776
567
def string_to_delta(interval):
792
583
    timevalue = datetime.timedelta(0)
793
584
    for s in interval.split():
794
585
        try:
795
 
            suffix = unicode(s[-1])
796
 
            value = int(s[:-1])
 
586
            suffix=unicode(s[-1])
 
587
            value=int(s[:-1])
797
588
            if suffix == u"d":
798
589
                delta = datetime.timedelta(value)
799
590
            elif suffix == u"s":
839
630
    """Call the C function if_nametoindex(), or equivalent"""
840
631
    global if_nametoindex
841
632
    try:
842
 
        if_nametoindex = (ctypes.cdll.LoadLibrary
843
 
                          (ctypes.util.find_library("c"))
844
 
                          .if_nametoindex)
 
633
        if "ctypes.util" not in sys.modules:
 
634
            import ctypes.util
 
635
        if_nametoindex = ctypes.cdll.LoadLibrary\
 
636
            (ctypes.util.find_library("c")).if_nametoindex
845
637
    except (OSError, AttributeError):
846
638
        if "struct" not in sys.modules:
847
639
            import struct
850
642
        def if_nametoindex(interface):
851
643
            "Get an interface index the hard way, i.e. using fcntl()"
852
644
            SIOCGIFINDEX = 0x8933  # From /usr/include/linux/sockios.h
853
 
            with closing(socket.socket()) as s:
854
 
                ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
855
 
                                    struct.pack("16s16x", interface))
 
645
            s = socket.socket()
 
646
            ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
 
647
                                struct.pack("16s16x", interface))
 
648
            s.close()
856
649
            interface_index = struct.unpack("I", ifreq[16:20])[0]
857
650
            return interface_index
858
651
    return if_nametoindex(interface)
882
675
 
883
676
 
884
677
def main():
 
678
    global main_loop_started
 
679
    main_loop_started = False
 
680
    
885
681
    parser = OptionParser(version = "%%prog %s" % version)
886
682
    parser.add_option("-i", "--interface", type="string",
887
683
                      metavar="IF", help="Bind to interface IF")
902
698
                      default="/etc/mandos", metavar="DIR",
903
699
                      help="Directory to search for configuration"
904
700
                      " files")
905
 
    options = parser.parse_args()[0]
 
701
    (options, args) = parser.parse_args()
906
702
    
907
703
    if options.check:
908
704
        import doctest
926
722
    # Convert the SafeConfigParser object to a dict
927
723
    server_settings = server_config.defaults()
928
724
    # Use getboolean on the boolean config option
929
 
    server_settings["debug"] = (server_config.getboolean
930
 
                                ("DEFAULT", "debug"))
 
725
    server_settings["debug"] = server_config.getboolean\
 
726
                               ("DEFAULT", "debug")
931
727
    del server_config
932
728
    
933
729
    # Override the settings from the config file with command line
947
743
        console.setLevel(logging.WARNING)
948
744
    
949
745
    if server_settings["servicename"] != "Mandos":
950
 
        syslogger.setFormatter(logging.Formatter
 
746
        syslogger.setFormatter(logging.Formatter\
951
747
                               ('Mandos (%s): %%(levelname)s:'
952
748
                                ' %%(message)s'
953
749
                                % server_settings["servicename"]))
962
758
    client_config.read(os.path.join(server_settings["configdir"],
963
759
                                    "clients.conf"))
964
760
    
965
 
    clients = Set()
966
 
    tcp_server = IPv6_TCPServer((server_settings["address"],
967
 
                                 server_settings["port"]),
968
 
                                TCP_handler,
969
 
                                settings=server_settings,
970
 
                                clients=clients)
971
 
    pidfilename = "/var/run/mandos.pid"
972
 
    try:
973
 
        pidfile = open(pidfilename, "w")
974
 
    except IOError, error:
975
 
        logger.error("Could not open file %r", pidfilename)
976
 
    
977
 
    try:
978
 
        uid = pwd.getpwnam("_mandos").pw_uid
979
 
    except KeyError:
980
 
        try:
981
 
            uid = pwd.getpwnam("mandos").pw_uid
982
 
        except KeyError:
983
 
            try:
984
 
                uid = pwd.getpwnam("nobody").pw_uid
985
 
            except KeyError:
986
 
                uid = 65534
987
 
    try:
988
 
        gid = pwd.getpwnam("_mandos").pw_gid
989
 
    except KeyError:
990
 
        try:
991
 
            gid = pwd.getpwnam("mandos").pw_gid
992
 
        except KeyError:
993
 
            try:
994
 
                gid = pwd.getpwnam("nogroup").pw_gid
995
 
            except KeyError:
996
 
                gid = 65534
997
 
    try:
998
 
        os.setuid(uid)
999
 
        os.setgid(gid)
1000
 
    except OSError, error:
1001
 
        if error[0] != errno.EPERM:
1002
 
            raise error
1003
 
    
1004
761
    global service
1005
762
    service = AvahiService(name = server_settings["servicename"],
1006
 
                           servicetype = "_mandos._tcp", )
 
763
                           type = "_mandos._tcp", );
1007
764
    if server_settings["interface"]:
1008
 
        service.interface = (if_nametoindex
1009
 
                             (server_settings["interface"]))
 
765
        service.interface = if_nametoindex\
 
766
                            (server_settings["interface"])
1010
767
    
1011
768
    global main_loop
1012
769
    global bus
1019
776
                                           avahi.DBUS_PATH_SERVER),
1020
777
                            avahi.DBUS_INTERFACE_SERVER)
1021
778
    # End of Avahi example code
1022
 
    bus_name = dbus.service.BusName(u"org.mandos-system.Mandos", bus)
 
779
    
 
780
    clients = Set()
 
781
    def remove_from_clients(client):
 
782
        clients.remove(client)
 
783
        if not clients:
 
784
            logger.critical(u"No clients left, exiting")
 
785
            sys.exit()
1023
786
    
1024
787
    clients.update(Set(Client(name = section,
 
788
                              stop_hook = remove_from_clients,
1025
789
                              config
1026
790
                              = dict(client_config.items(section)))
1027
791
                       for section in client_config.sections()))
1041
805
        # Close all input and output, do double fork, etc.
1042
806
        daemon()
1043
807
    
 
808
    pidfilename = "/var/run/mandos/mandos.pid"
 
809
    pid = os.getpid()
1044
810
    try:
1045
 
        pid = os.getpid()
 
811
        pidfile = open(pidfilename, "w")
1046
812
        pidfile.write(str(pid) + "\n")
1047
813
        pidfile.close()
1048
814
        del pidfile
1049
 
    except IOError:
1050
 
        logger.error(u"Could not write to file %r with PID %d",
1051
 
                     pidfilename, pid)
1052
 
    except NameError:
1053
 
        # "pidfile" was never created
1054
 
        pass
1055
 
    del pidfilename
 
815
    except IOError, err:
 
816
        logger.error(u"Could not write %s file with PID %d",
 
817
                     pidfilename, os.getpid())
1056
818
    
1057
819
    def cleanup():
1058
820
        "Cleanup function; run on exit"
1065
827
        
1066
828
        while clients:
1067
829
            client = clients.pop()
1068
 
            client.disable_hook = None
1069
 
            client.disable()
 
830
            client.stop_hook = None
 
831
            client.stop()
1070
832
    
1071
833
    atexit.register(cleanup)
1072
834
    
1075
837
    signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
1076
838
    signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
1077
839
    
1078
 
    class MandosServer(dbus.service.Object):
1079
 
        """A D-Bus proxy object"""
1080
 
        def __init__(self):
1081
 
            dbus.service.Object.__init__(self, bus,
1082
 
                                         "/Mandos")
1083
 
        _interface = u"org.mandos_system.Mandos"
1084
 
        
1085
 
        @dbus.service.signal(_interface, signature="oa{sv}")
1086
 
        def ClientAdded(self, objpath, properties):
1087
 
            "D-Bus signal"
1088
 
            pass
1089
 
        
1090
 
        @dbus.service.signal(_interface, signature="o")
1091
 
        def ClientRemoved(self, objpath):
1092
 
            "D-Bus signal"
1093
 
            pass
1094
 
        
1095
 
        @dbus.service.method(_interface, out_signature="ao")
1096
 
        def GetAllClients(self):
1097
 
            return dbus.Array(c.dbus_object_path for c in clients)
1098
 
        
1099
 
        @dbus.service.method(_interface, out_signature="a{oa{sv}}")
1100
 
        def GetAllClientsWithProperties(self):
1101
 
            return dbus.Dictionary(
1102
 
                ((c.dbus_object_path, c.GetAllProperties())
1103
 
                 for c in clients),
1104
 
                signature="oa{sv}")
1105
 
        
1106
 
        @dbus.service.method(_interface, in_signature="o")
1107
 
        def RemoveClient(self, object_path):
1108
 
            for c in clients:
1109
 
                if c.dbus_object_path == object_path:
1110
 
                    c.disable()
1111
 
                    clients.remove(c)
1112
 
                    return
1113
 
            raise KeyError
1114
 
        
1115
 
        del _interface
1116
 
    
1117
 
    mandos_server = MandosServer()
1118
 
    
1119
840
    for client in clients:
1120
 
        # Emit D-Bus signal
1121
 
        mandos_server.ClientAdded(client.dbus_object_path,
1122
 
                                  client.GetAllProperties())
1123
 
        client.enable()
1124
 
    
1125
 
    tcp_server.enable()
1126
 
    tcp_server.server_activate()
1127
 
    
 
841
        client.start()
 
842
    
 
843
    tcp_server = IPv6_TCPServer((server_settings["address"],
 
844
                                 server_settings["port"]),
 
845
                                tcp_handler,
 
846
                                settings=server_settings,
 
847
                                clients=clients)
1128
848
    # Find out what port we got
1129
849
    service.port = tcp_server.socket.getsockname()[1]
1130
850
    logger.info(u"Now listening on address %r, port %d, flowinfo %d,"
1144
864
        
1145
865
        gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,
1146
866
                             lambda *args, **kwargs:
1147
 
                             (tcp_server.handle_request
1148
 
                              (*args[2:], **kwargs) or True))
 
867
                             tcp_server.handle_request\
 
868
                             (*args[2:], **kwargs) or True)
1149
869
        
1150
870
        logger.debug(u"Starting main loop")
 
871
        main_loop_started = True
1151
872
        main_loop.run()
1152
873
    except AvahiError, error:
1153
874
        logger.critical(u"AvahiError: %s" + unicode(error))