/mandos/release

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

« back to all changes in this revision

Viewing changes to mandos

  • Committer: Teddy Hogeborn
  • Date: 2008-09-30 07:23:39 UTC
  • Revision ID: teddy@fukt.bsnet.se-20080930072339-jn15gyrtfpdk2dhx
* .bzrignore: Added "man" directory (created by "make install-html").

* Makefile: Add "common.ent" dependency to all manual pages.
  (htmldir, version, SED): New variables.
  (CFLAGS): Add -D option to define VERSION to $(version).
  (MANPOST, HTMLPOST): Use $(SED).
  (PROGS): Use $(CPROGS)
  (CPROGS): New; C-only programs.
  (objects): Use $(CPROGS).
  (common.ent, mandos, mandos-keygen): New targets; update version
                                       number to $(version).
  (clean): Use $(CPROGS).
  (check): Depend on "all".
  (install-html): Install to $(htmldir).

* common.ent: New file with "version" entity.

* mandos-clients.conf.xml: Use "common.ent".
* mandos-keygen.xml: - '' -
* mandos.conf.xml: - '' -
* mandos.xml: - '' -
* plugin-runner.xml: - '' -
* plugins.d/mandos-client.xml: - '' -
* plugins.d/password-prompt.xml: - '' -

* plugin-runner.c (argp_program_version): Use VERSION.
* plugins.d/mandos-client.c (argp_program_version): - '' -
* plugins.d/password-prompt.c (argp_program_version): - '' -

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,2009 Teddy Hogeborn
15
 
# Copyright © 2008,2009 Björn Påhlsson
 
14
# Copyright © 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
38
 
import optparse
 
37
from optparse import OptionParser
39
38
import datetime
40
39
import errno
41
40
import gnutls.crypto
56
55
import logging
57
56
import logging.handlers
58
57
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
64
import ctypes.util
68
65
 
69
 
version = "1.0.3"
 
66
version = "1.0"
70
67
 
71
68
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'))
 
69
syslogger = logging.handlers.SysLogHandler\
 
70
            (facility = logging.handlers.SysLogHandler.LOG_DAEMON,
 
71
             address = "/dev/log")
 
72
syslogger.setFormatter(logging.Formatter\
 
73
                        ('Mandos: %(levelname)s: %(message)s'))
77
74
logger.addHandler(syslogger)
78
75
 
79
76
console = logging.StreamHandler()
82
79
logger.addHandler(console)
83
80
 
84
81
class AvahiError(Exception):
85
 
    def __init__(self, value, *args, **kwargs):
 
82
    def __init__(self, value):
86
83
        self.value = value
87
 
        super(AvahiError, self).__init__(value, *args, **kwargs)
88
 
    def __unicode__(self):
89
 
        return unicode(repr(self.value))
 
84
        super(AvahiError, self).__init__()
 
85
    def __str__(self):
 
86
        return repr(self.value)
90
87
 
91
88
class AvahiServiceError(AvahiError):
92
89
    pass
112
109
                  a sensible number of times
113
110
    """
114
111
    def __init__(self, interface = avahi.IF_UNSPEC, name = None,
115
 
                 servicetype = None, port = None, TXT = None,
116
 
                 domain = "", host = "", max_renames = 32768):
 
112
                 servicetype = None, port = None, TXT = None, domain = "",
 
113
                 host = "", max_renames = 32768):
117
114
        self.interface = interface
118
115
        self.name = name
119
116
        self.type = servicetype
120
117
        self.port = port
121
 
        self.TXT = TXT if TXT is not None else []
 
118
        if TXT is None:
 
119
            self.TXT = []
 
120
        else:
 
121
            self.TXT = TXT
122
122
        self.domain = domain
123
123
        self.host = host
124
124
        self.rename_count = 0
129
129
            logger.critical(u"No suitable Zeroconf service name found"
130
130
                            u" after %i retries, exiting.",
131
131
                            self.rename_count)
132
 
            raise AvahiServiceError(u"Too many renames")
 
132
            raise AvahiServiceError("Too many renames")
133
133
        self.name = server.GetAlternativeServiceName(self.name)
134
134
        logger.info(u"Changing Zeroconf service name to %r ...",
135
135
                    str(self.name))
136
 
        syslogger.setFormatter(logging.Formatter
 
136
        syslogger.setFormatter(logging.Formatter\
137
137
                               ('Mandos (%s): %%(levelname)s:'
138
 
                                ' %%(message)s' % self.name))
 
138
                               ' %%(message)s' % self.name))
139
139
        self.remove()
140
140
        self.add()
141
141
        self.rename_count += 1
147
147
        """Derived from the Avahi example code"""
148
148
        global group
149
149
        if group is None:
150
 
            group = dbus.Interface(bus.get_object
151
 
                                   (avahi.DBUS_NAME,
 
150
            group = dbus.Interface\
 
151
                    (bus.get_object(avahi.DBUS_NAME,
152
152
                                    server.EntryGroupNew()),
153
 
                                   avahi.DBUS_INTERFACE_ENTRY_GROUP)
 
153
                     avahi.DBUS_INTERFACE_ENTRY_GROUP)
154
154
            group.connect_to_signal('StateChanged',
155
155
                                    entry_group_state_changed)
156
156
        logger.debug(u"Adding Zeroconf service '%s' of type '%s' ...",
170
170
# End of Avahi example code
171
171
 
172
172
 
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):
 
173
class Client(object):
179
174
    """A representation of a client host served by this server.
180
175
    Attributes:
181
 
    name:       string; from the config file, used in log messages
 
176
    name:      string; from the config file, used in log messages
182
177
    fingerprint: string (40 or 32 hexadecimal digits); used to
183
178
                 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.
 
179
    secret:    bytestring; sent verbatim (over TLS) to client
 
180
    host:      string; available for use by the checker command
 
181
    created:   datetime.datetime(); object creation, not client host
 
182
    last_checked_ok: datetime.datetime() or None if not yet checked OK
 
183
    timeout:   datetime.timedelta(); How long from last_checked_ok
 
184
                                     until this client is invalid
 
185
    interval:  datetime.timedelta(); How often to start a new checker
 
186
    stop_hook: If set, called by stop() as stop_hook(self)
 
187
    checker:   subprocess.Popen(); a running checker process used
 
188
                                   to see if the client lives.
 
189
                                   'None' if no process is running.
197
190
    checker_initiator_tag: a gobject event source tag, or None
198
 
    disable_initiator_tag:    - '' -
 
191
    stop_initiator_tag:    - '' -
199
192
    checker_callback_tag:  - '' -
200
193
    checker_command: string; External command which is run to check if
201
194
                     client lives.  %() expansions are done at
202
195
                     runtime with vars(self) as dict, so that for
203
196
                     instance %(name)s can be used in the command.
204
 
    use_dbus: bool(); Whether to provide D-Bus interface and signals
205
 
    dbus_object_path: dbus.ObjectPath ; only set if self.use_dbus
 
197
    Private attibutes:
 
198
    _timeout: Real variable for 'timeout'
 
199
    _interval: Real variable for 'interval'
 
200
    _timeout_milliseconds: Used when calling gobject.timeout_add()
 
201
    _interval_milliseconds: - '' -
206
202
    """
207
 
    def timeout_milliseconds(self):
208
 
        "Return the 'timeout' attribute in milliseconds"
209
 
        return ((self.timeout.days * 24 * 60 * 60 * 1000)
210
 
                + (self.timeout.seconds * 1000)
211
 
                + (self.timeout.microseconds // 1000))
212
 
    
213
 
    def interval_milliseconds(self):
214
 
        "Return the 'interval' attribute in milliseconds"
215
 
        return ((self.interval.days * 24 * 60 * 60 * 1000)
216
 
                + (self.interval.seconds * 1000)
217
 
                + (self.interval.microseconds // 1000))
218
 
    
219
 
    def __init__(self, name = None, disable_hook=None, config=None,
220
 
                 use_dbus=True):
 
203
    def _set_timeout(self, timeout):
 
204
        "Setter function for 'timeout' attribute"
 
205
        self._timeout = timeout
 
206
        self._timeout_milliseconds = ((self.timeout.days
 
207
                                       * 24 * 60 * 60 * 1000)
 
208
                                      + (self.timeout.seconds * 1000)
 
209
                                      + (self.timeout.microseconds
 
210
                                         // 1000))
 
211
    timeout = property(lambda self: self._timeout,
 
212
                       _set_timeout)
 
213
    del _set_timeout
 
214
    def _set_interval(self, interval):
 
215
        "Setter function for 'interval' attribute"
 
216
        self._interval = interval
 
217
        self._interval_milliseconds = ((self.interval.days
 
218
                                        * 24 * 60 * 60 * 1000)
 
219
                                       + (self.interval.seconds
 
220
                                          * 1000)
 
221
                                       + (self.interval.microseconds
 
222
                                          // 1000))
 
223
    interval = property(lambda self: self._interval,
 
224
                        _set_interval)
 
225
    del _set_interval
 
226
    def __init__(self, name = None, stop_hook=None, config=None):
221
227
        """Note: the 'checker' key in 'config' sets the
222
228
        'checker_command' attribute and *not* the 'checker'
223
229
        attribute."""
224
 
        self.name = name
225
230
        if config is None:
226
231
            config = {}
 
232
        self.name = name
227
233
        logger.debug(u"Creating client %r", self.name)
228
 
        self.use_dbus = use_dbus
229
 
        if self.use_dbus:
230
 
            self.dbus_object_path = (dbus.ObjectPath
231
 
                                     ("/Mandos/clients/"
232
 
                                      + self.name.replace(".", "_")))
233
 
            dbus.service.Object.__init__(self, bus,
234
 
                                         self.dbus_object_path)
235
234
        # Uppercase and remove spaces from fingerprint for later
236
235
        # comparison purposes with return value from the fingerprint()
237
236
        # function
238
 
        self.fingerprint = (config["fingerprint"].upper()
239
 
                            .replace(u" ", u""))
 
237
        self.fingerprint = config["fingerprint"].upper()\
 
238
                           .replace(u" ", u"")
240
239
        logger.debug(u"  Fingerprint: %s", self.fingerprint)
241
240
        if "secret" in config:
242
241
            self.secret = config["secret"].decode(u"base64")
243
242
        elif "secfile" in config:
244
 
            with closing(open(os.path.expanduser
245
 
                              (os.path.expandvars
246
 
                               (config["secfile"])))) as secfile:
247
 
                self.secret = secfile.read()
 
243
            secfile = open(config["secfile"])
 
244
            self.secret = secfile.read()
 
245
            secfile.close()
248
246
        else:
249
247
            raise TypeError(u"No secret or secfile for client %s"
250
248
                            % self.name)
251
249
        self.host = config.get("host", "")
252
 
        self.created = datetime.datetime.utcnow()
253
 
        self.enabled = False
254
 
        self.last_enabled = None
 
250
        self.created = datetime.datetime.now()
255
251
        self.last_checked_ok = None
256
252
        self.timeout = string_to_delta(config["timeout"])
257
253
        self.interval = string_to_delta(config["interval"])
258
 
        self.disable_hook = disable_hook
 
254
        self.stop_hook = stop_hook
259
255
        self.checker = None
260
256
        self.checker_initiator_tag = None
261
 
        self.disable_initiator_tag = None
 
257
        self.stop_initiator_tag = None
262
258
        self.checker_callback_tag = None
263
 
        self.checker_command = config["checker"]
264
 
    
265
 
    def enable(self):
 
259
        self.check_command = config["checker"]
 
260
    def start(self):
266
261
        """Start this client's checker and timeout hooks"""
267
 
        self.last_enabled = datetime.datetime.utcnow()
268
262
        # Schedule a new checker to be started an 'interval' from now,
269
263
        # and every interval from then on.
270
 
        self.checker_initiator_tag = (gobject.timeout_add
271
 
                                      (self.interval_milliseconds(),
272
 
                                       self.start_checker))
 
264
        self.checker_initiator_tag = gobject.timeout_add\
 
265
                                     (self._interval_milliseconds,
 
266
                                      self.start_checker)
273
267
        # Also start a new checker *right now*.
274
268
        self.start_checker()
275
 
        # Schedule a disable() when 'timeout' has passed
276
 
        self.disable_initiator_tag = (gobject.timeout_add
277
 
                                   (self.timeout_milliseconds(),
278
 
                                    self.disable))
279
 
        self.enabled = True
280
 
        if self.use_dbus:
281
 
            # Emit D-Bus signals
282
 
            self.PropertyChanged(dbus.String(u"enabled"),
283
 
                                 dbus.Boolean(True, variant_level=1))
284
 
            self.PropertyChanged(dbus.String(u"last_enabled"),
285
 
                                 (_datetime_to_dbus(self.last_enabled,
286
 
                                                    variant_level=1)))
287
 
    
288
 
    def disable(self):
289
 
        """Disable this client."""
290
 
        if not getattr(self, "enabled", False):
 
269
        # Schedule a stop() when 'timeout' has passed
 
270
        self.stop_initiator_tag = gobject.timeout_add\
 
271
                                  (self._timeout_milliseconds,
 
272
                                   self.stop)
 
273
    def stop(self):
 
274
        """Stop this client.
 
275
        The possibility that a client might be restarted is left open,
 
276
        but not currently used."""
 
277
        # If this client doesn't have a secret, it is already stopped.
 
278
        if hasattr(self, "secret") and self.secret:
 
279
            logger.info(u"Stopping client %s", self.name)
 
280
            self.secret = None
 
281
        else:
291
282
            return False
292
 
        logger.info(u"Disabling client %s", self.name)
293
 
        if getattr(self, "disable_initiator_tag", False):
294
 
            gobject.source_remove(self.disable_initiator_tag)
295
 
            self.disable_initiator_tag = None
 
283
        if getattr(self, "stop_initiator_tag", False):
 
284
            gobject.source_remove(self.stop_initiator_tag)
 
285
            self.stop_initiator_tag = None
296
286
        if getattr(self, "checker_initiator_tag", False):
297
287
            gobject.source_remove(self.checker_initiator_tag)
298
288
            self.checker_initiator_tag = None
299
289
        self.stop_checker()
300
 
        if self.disable_hook:
301
 
            self.disable_hook(self)
302
 
        self.enabled = False
303
 
        if self.use_dbus:
304
 
            # Emit D-Bus signal
305
 
            self.PropertyChanged(dbus.String(u"enabled"),
306
 
                                 dbus.Boolean(False, variant_level=1))
 
290
        if self.stop_hook:
 
291
            self.stop_hook(self)
307
292
        # Do not run this again if called by a gobject.timeout_add
308
293
        return False
309
 
    
310
294
    def __del__(self):
311
 
        self.disable_hook = None
312
 
        self.disable()
313
 
    
314
 
    def checker_callback(self, pid, condition, command):
 
295
        self.stop_hook = None
 
296
        self.stop()
 
297
    def checker_callback(self, pid, condition):
315
298
        """The checker has completed, so take appropriate actions."""
 
299
        now = datetime.datetime.now()
316
300
        self.checker_callback_tag = None
317
301
        self.checker = None
318
 
        if self.use_dbus:
319
 
            # Emit D-Bus signal
320
 
            self.PropertyChanged(dbus.String(u"checker_running"),
321
 
                                 dbus.Boolean(False, variant_level=1))
322
 
        if (os.WIFEXITED(condition)
323
 
            and (os.WEXITSTATUS(condition) == 0)):
 
302
        if os.WIFEXITED(condition) \
 
303
               and (os.WEXITSTATUS(condition) == 0):
324
304
            logger.info(u"Checker for %(name)s succeeded",
325
305
                        vars(self))
326
 
            if self.use_dbus:
327
 
                # Emit D-Bus signal
328
 
                self.CheckerCompleted(dbus.Boolean(True),
329
 
                                      dbus.UInt16(condition),
330
 
                                      dbus.String(command))
331
 
            self.bump_timeout()
 
306
            self.last_checked_ok = now
 
307
            gobject.source_remove(self.stop_initiator_tag)
 
308
            self.stop_initiator_tag = gobject.timeout_add\
 
309
                                      (self._timeout_milliseconds,
 
310
                                       self.stop)
332
311
        elif not os.WIFEXITED(condition):
333
312
            logger.warning(u"Checker for %(name)s crashed?",
334
313
                           vars(self))
335
 
            if self.use_dbus:
336
 
                # Emit D-Bus signal
337
 
                self.CheckerCompleted(dbus.Boolean(False),
338
 
                                      dbus.UInt16(condition),
339
 
                                      dbus.String(command))
340
314
        else:
341
315
            logger.info(u"Checker for %(name)s failed",
342
316
                        vars(self))
343
 
            if self.use_dbus:
344
 
                # Emit D-Bus signal
345
 
                self.CheckerCompleted(dbus.Boolean(False),
346
 
                                      dbus.UInt16(condition),
347
 
                                      dbus.String(command))
348
 
    
349
 
    def bump_timeout(self):
350
 
        """Bump up the timeout for this client.
351
 
        This should only be called when the client has been seen,
352
 
        alive and well.
353
 
        """
354
 
        self.last_checked_ok = datetime.datetime.utcnow()
355
 
        gobject.source_remove(self.disable_initiator_tag)
356
 
        self.disable_initiator_tag = (gobject.timeout_add
357
 
                                      (self.timeout_milliseconds(),
358
 
                                       self.disable))
359
 
        if self.use_dbus:
360
 
            # Emit D-Bus signal
361
 
            self.PropertyChanged(
362
 
                dbus.String(u"last_checked_ok"),
363
 
                (_datetime_to_dbus(self.last_checked_ok,
364
 
                                   variant_level=1)))
365
 
    
366
317
    def start_checker(self):
367
318
        """Start a new checker subprocess if one is not running.
368
319
        If a checker already exists, leave it running and do
377
328
        # is as it should be.
378
329
        if self.checker is None:
379
330
            try:
380
 
                # In case checker_command has exactly one % operator
381
 
                command = self.checker_command % self.host
 
331
                # In case check_command has exactly one % operator
 
332
                command = self.check_command % self.host
382
333
            except TypeError:
383
334
                # Escape attributes for the shell
384
335
                escaped_attrs = dict((key, re.escape(str(val)))
385
336
                                     for key, val in
386
337
                                     vars(self).iteritems())
387
338
                try:
388
 
                    command = self.checker_command % escaped_attrs
 
339
                    command = self.check_command % escaped_attrs
389
340
                except TypeError, error:
390
341
                    logger.error(u'Could not format string "%s":'
391
 
                                 u' %s', self.checker_command, error)
 
342
                                 u' %s', self.check_command, error)
392
343
                    return True # Try again later
393
344
            try:
394
345
                logger.info(u"Starting checker %r for %s",
400
351
                self.checker = subprocess.Popen(command,
401
352
                                                close_fds=True,
402
353
                                                shell=True, cwd="/")
403
 
                if self.use_dbus:
404
 
                    # Emit D-Bus signal
405
 
                    self.CheckerStarted(command)
406
 
                    self.PropertyChanged(
407
 
                        dbus.String("checker_running"),
408
 
                        dbus.Boolean(True, variant_level=1))
409
 
                self.checker_callback_tag = (gobject.child_watch_add
410
 
                                             (self.checker.pid,
411
 
                                              self.checker_callback,
412
 
                                              data=command))
 
354
                self.checker_callback_tag = gobject.child_watch_add\
 
355
                                            (self.checker.pid,
 
356
                                             self.checker_callback)
413
357
            except OSError, error:
414
358
                logger.error(u"Failed to start subprocess: %s",
415
359
                             error)
416
360
        # Re-run this periodically if run by gobject.timeout_add
417
361
        return True
418
 
    
419
362
    def stop_checker(self):
420
363
        """Force the checker process, if any, to stop."""
421
364
        if self.checker_callback_tag:
433
376
            if error.errno != errno.ESRCH: # No such process
434
377
                raise
435
378
        self.checker = None
436
 
        if self.use_dbus:
437
 
            self.PropertyChanged(dbus.String(u"checker_running"),
438
 
                                 dbus.Boolean(False, variant_level=1))
439
 
    
440
379
    def still_valid(self):
441
380
        """Has the timeout not yet passed for this client?"""
442
 
        if not getattr(self, "enabled", False):
443
 
            return False
444
 
        now = datetime.datetime.utcnow()
 
381
        now = datetime.datetime.now()
445
382
        if self.last_checked_ok is None:
446
383
            return now < (self.created + self.timeout)
447
384
        else:
448
385
            return now < (self.last_checked_ok + self.timeout)
449
 
    
450
 
    ## D-Bus methods & signals
451
 
    _interface = u"org.mandos_system.Mandos.Client"
452
 
    
453
 
    # BumpTimeout - method
454
 
    BumpTimeout = dbus.service.method(_interface)(bump_timeout)
455
 
    BumpTimeout.__name__ = "BumpTimeout"
456
 
    
457
 
    # CheckerCompleted - signal
458
 
    @dbus.service.signal(_interface, signature="bqs")
459
 
    def CheckerCompleted(self, success, condition, command):
460
 
        "D-Bus signal"
461
 
        pass
462
 
    
463
 
    # CheckerStarted - signal
464
 
    @dbus.service.signal(_interface, signature="s")
465
 
    def CheckerStarted(self, command):
466
 
        "D-Bus signal"
467
 
        pass
468
 
    
469
 
    # GetAllProperties - method
470
 
    @dbus.service.method(_interface, out_signature="a{sv}")
471
 
    def GetAllProperties(self):
472
 
        "D-Bus method"
473
 
        return dbus.Dictionary({
474
 
                dbus.String("name"):
475
 
                    dbus.String(self.name, variant_level=1),
476
 
                dbus.String("fingerprint"):
477
 
                    dbus.String(self.fingerprint, variant_level=1),
478
 
                dbus.String("host"):
479
 
                    dbus.String(self.host, variant_level=1),
480
 
                dbus.String("created"):
481
 
                    _datetime_to_dbus(self.created, variant_level=1),
482
 
                dbus.String("last_enabled"):
483
 
                    (_datetime_to_dbus(self.last_enabled,
484
 
                                       variant_level=1)
485
 
                     if self.last_enabled is not None
486
 
                     else dbus.Boolean(False, variant_level=1)),
487
 
                dbus.String("enabled"):
488
 
                    dbus.Boolean(self.enabled, variant_level=1),
489
 
                dbus.String("last_checked_ok"):
490
 
                    (_datetime_to_dbus(self.last_checked_ok,
491
 
                                       variant_level=1)
492
 
                     if self.last_checked_ok is not None
493
 
                     else dbus.Boolean (False, variant_level=1)),
494
 
                dbus.String("timeout"):
495
 
                    dbus.UInt64(self.timeout_milliseconds(),
496
 
                                variant_level=1),
497
 
                dbus.String("interval"):
498
 
                    dbus.UInt64(self.interval_milliseconds(),
499
 
                                variant_level=1),
500
 
                dbus.String("checker"):
501
 
                    dbus.String(self.checker_command,
502
 
                                variant_level=1),
503
 
                dbus.String("checker_running"):
504
 
                    dbus.Boolean(self.checker is not None,
505
 
                                 variant_level=1),
506
 
                }, signature="sv")
507
 
    
508
 
    # IsStillValid - method
509
 
    IsStillValid = (dbus.service.method(_interface, out_signature="b")
510
 
                    (still_valid))
511
 
    IsStillValid.__name__ = "IsStillValid"
512
 
    
513
 
    # PropertyChanged - signal
514
 
    @dbus.service.signal(_interface, signature="sv")
515
 
    def PropertyChanged(self, property, value):
516
 
        "D-Bus signal"
517
 
        pass
518
 
    
519
 
    # SetChecker - method
520
 
    @dbus.service.method(_interface, in_signature="s")
521
 
    def SetChecker(self, checker):
522
 
        "D-Bus setter method"
523
 
        self.checker_command = checker
524
 
        # Emit D-Bus signal
525
 
        self.PropertyChanged(dbus.String(u"checker"),
526
 
                             dbus.String(self.checker_command,
527
 
                                         variant_level=1))
528
 
    
529
 
    # SetHost - method
530
 
    @dbus.service.method(_interface, in_signature="s")
531
 
    def SetHost(self, host):
532
 
        "D-Bus setter method"
533
 
        self.host = host
534
 
        # Emit D-Bus signal
535
 
        self.PropertyChanged(dbus.String(u"host"),
536
 
                             dbus.String(self.host, variant_level=1))
537
 
    
538
 
    # SetInterval - method
539
 
    @dbus.service.method(_interface, in_signature="t")
540
 
    def SetInterval(self, milliseconds):
541
 
        self.interval = datetime.timedelta(0, 0, 0, milliseconds)
542
 
        # Emit D-Bus signal
543
 
        self.PropertyChanged(dbus.String(u"interval"),
544
 
                             (dbus.UInt64(self.interval_milliseconds(),
545
 
                                          variant_level=1)))
546
 
    
547
 
    # SetSecret - method
548
 
    @dbus.service.method(_interface, in_signature="ay",
549
 
                         byte_arrays=True)
550
 
    def SetSecret(self, secret):
551
 
        "D-Bus setter method"
552
 
        self.secret = str(secret)
553
 
    
554
 
    # SetTimeout - method
555
 
    @dbus.service.method(_interface, in_signature="t")
556
 
    def SetTimeout(self, milliseconds):
557
 
        self.timeout = datetime.timedelta(0, 0, 0, milliseconds)
558
 
        # Emit D-Bus signal
559
 
        self.PropertyChanged(dbus.String(u"timeout"),
560
 
                             (dbus.UInt64(self.timeout_milliseconds(),
561
 
                                          variant_level=1)))
562
 
    
563
 
    # Enable - method
564
 
    Enable = dbus.service.method(_interface)(enable)
565
 
    Enable.__name__ = "Enable"
566
 
    
567
 
    # StartChecker - method
568
 
    @dbus.service.method(_interface)
569
 
    def StartChecker(self):
570
 
        "D-Bus method"
571
 
        self.start_checker()
572
 
    
573
 
    # Disable - method
574
 
    @dbus.service.method(_interface)
575
 
    def Disable(self):
576
 
        "D-Bus method"
577
 
        self.disable()
578
 
    
579
 
    # StopChecker - method
580
 
    StopChecker = dbus.service.method(_interface)(stop_checker)
581
 
    StopChecker.__name__ = "StopChecker"
582
 
    
583
 
    del _interface
584
386
 
585
387
 
586
388
def peer_certificate(session):
587
389
    "Return the peer's OpenPGP certificate as a bytestring"
588
390
    # If not an OpenPGP certificate...
589
 
    if (gnutls.library.functions
590
 
        .gnutls_certificate_type_get(session._c_object)
591
 
        != gnutls.library.constants.GNUTLS_CRT_OPENPGP):
 
391
    if gnutls.library.functions.gnutls_certificate_type_get\
 
392
            (session._c_object) \
 
393
           != gnutls.library.constants.GNUTLS_CRT_OPENPGP:
592
394
        # ...do the normal thing
593
395
        return session.peer_certificate
594
396
    list_size = ctypes.c_uint()
595
 
    cert_list = (gnutls.library.functions
596
 
                 .gnutls_certificate_get_peers
597
 
                 (session._c_object, ctypes.byref(list_size)))
 
397
    cert_list = gnutls.library.functions.gnutls_certificate_get_peers\
 
398
        (session._c_object, ctypes.byref(list_size))
598
399
    if list_size.value == 0:
599
400
        return None
600
401
    cert = cert_list[0]
604
405
def fingerprint(openpgp):
605
406
    "Convert an OpenPGP bytestring to a hexdigit fingerprint string"
606
407
    # New GnuTLS "datum" with the OpenPGP public key
607
 
    datum = (gnutls.library.types
608
 
             .gnutls_datum_t(ctypes.cast(ctypes.c_char_p(openpgp),
609
 
                                         ctypes.POINTER
610
 
                                         (ctypes.c_ubyte)),
611
 
                             ctypes.c_uint(len(openpgp))))
 
408
    datum = gnutls.library.types.gnutls_datum_t\
 
409
        (ctypes.cast(ctypes.c_char_p(openpgp),
 
410
                     ctypes.POINTER(ctypes.c_ubyte)),
 
411
         ctypes.c_uint(len(openpgp)))
612
412
    # New empty GnuTLS certificate
613
413
    crt = gnutls.library.types.gnutls_openpgp_crt_t()
614
 
    (gnutls.library.functions
615
 
     .gnutls_openpgp_crt_init(ctypes.byref(crt)))
 
414
    gnutls.library.functions.gnutls_openpgp_crt_init\
 
415
        (ctypes.byref(crt))
616
416
    # Import the OpenPGP public key into the certificate
617
 
    (gnutls.library.functions
618
 
     .gnutls_openpgp_crt_import(crt, ctypes.byref(datum),
619
 
                                gnutls.library.constants
620
 
                                .GNUTLS_OPENPGP_FMT_RAW))
 
417
    gnutls.library.functions.gnutls_openpgp_crt_import\
 
418
                    (crt, ctypes.byref(datum),
 
419
                     gnutls.library.constants.GNUTLS_OPENPGP_FMT_RAW)
621
420
    # Verify the self signature in the key
622
421
    crtverify = ctypes.c_uint()
623
 
    (gnutls.library.functions
624
 
     .gnutls_openpgp_crt_verify_self(crt, 0, ctypes.byref(crtverify)))
 
422
    gnutls.library.functions.gnutls_openpgp_crt_verify_self\
 
423
        (crt, 0, ctypes.byref(crtverify))
625
424
    if crtverify.value != 0:
626
425
        gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
627
426
        raise gnutls.errors.CertificateSecurityError("Verify failed")
629
428
    buf = ctypes.create_string_buffer(20)
630
429
    buf_len = ctypes.c_size_t()
631
430
    # Get the fingerprint from the certificate into the buffer
632
 
    (gnutls.library.functions
633
 
     .gnutls_openpgp_crt_get_fingerprint(crt, ctypes.byref(buf),
634
 
                                         ctypes.byref(buf_len)))
 
431
    gnutls.library.functions.gnutls_openpgp_crt_get_fingerprint\
 
432
        (crt, ctypes.byref(buf), ctypes.byref(buf_len))
635
433
    # Deinit the certificate
636
434
    gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
637
435
    # Convert the buffer to a Python bytestring
648
446
    
649
447
    def handle(self):
650
448
        logger.info(u"TCP connection from: %s",
651
 
                    unicode(self.client_address))
652
 
        session = (gnutls.connection
653
 
                   .ClientSession(self.request,
654
 
                                  gnutls.connection
655
 
                                  .X509Credentials()))
 
449
                     unicode(self.client_address))
 
450
        session = gnutls.connection.ClientSession\
 
451
                  (self.request, gnutls.connection.X509Credentials())
656
452
        
657
453
        line = self.request.makefile().readline()
658
454
        logger.debug(u"Protocol version: %r", line)
671
467
        #priority = ':'.join(("NONE", "+VERS-TLS1.1", "+AES-256-CBC",
672
468
        #                "+SHA1", "+COMP-NULL", "+CTYPE-OPENPGP",
673
469
        #                "+DHE-DSS"))
674
 
        # Use a fallback default, since this MUST be set.
675
 
        priority = self.server.settings.get("priority", "NORMAL")
676
 
        (gnutls.library.functions
677
 
         .gnutls_priority_set_direct(session._c_object,
678
 
                                     priority, None))
 
470
        priority = "NORMAL"             # Fallback default, since this
 
471
                                        # MUST be set.
 
472
        if self.server.settings["priority"]:
 
473
            priority = self.server.settings["priority"]
 
474
        gnutls.library.functions.gnutls_priority_set_direct\
 
475
            (session._c_object, priority, None)
679
476
        
680
477
        try:
681
478
            session.handshake()
691
488
            session.bye()
692
489
            return
693
490
        logger.debug(u"Fingerprint: %s", fpr)
 
491
        client = None
694
492
        for c in self.server.clients:
695
493
            if c.fingerprint == fpr:
696
494
                client = c
697
495
                break
698
 
        else:
 
496
        if not client:
699
497
            logger.warning(u"Client not found for fingerprint: %s",
700
498
                           fpr)
701
499
            session.bye()
708
506
                           vars(client))
709
507
            session.bye()
710
508
            return
711
 
        ## This won't work here, since we're in a fork.
712
 
        # client.bump_timeout()
713
509
        sent_size = 0
714
510
        while sent_size < len(client.secret):
715
511
            sent = session.send(client.secret[sent_size:])
720
516
        session.bye()
721
517
 
722
518
 
723
 
class IPv6_TCPServer(SocketServer.ForkingMixIn,
724
 
                     SocketServer.TCPServer, object):
 
519
class IPv6_TCPServer(SocketServer.ForkingTCPServer, object):
725
520
    """IPv6 TCP server.  Accepts 'None' as address and/or port.
726
521
    Attributes:
727
522
        settings:       Server settings
840
635
    elif state == avahi.ENTRY_GROUP_FAILURE:
841
636
        logger.critical(u"Avahi: Error in group state changed %s",
842
637
                        unicode(error))
843
 
        raise AvahiGroupError(u"State changed: %s" % unicode(error))
 
638
        raise AvahiGroupError("State changed: %s", str(error))
844
639
 
845
640
def if_nametoindex(interface):
846
641
    """Call the C function if_nametoindex(), or equivalent"""
847
642
    global if_nametoindex
848
643
    try:
849
 
        if_nametoindex = (ctypes.cdll.LoadLibrary
850
 
                          (ctypes.util.find_library("c"))
851
 
                          .if_nametoindex)
 
644
        if_nametoindex = ctypes.cdll.LoadLibrary\
 
645
            (ctypes.util.find_library("c")).if_nametoindex
852
646
    except (OSError, AttributeError):
853
647
        if "struct" not in sys.modules:
854
648
            import struct
857
651
        def if_nametoindex(interface):
858
652
            "Get an interface index the hard way, i.e. using fcntl()"
859
653
            SIOCGIFINDEX = 0x8933  # From /usr/include/linux/sockios.h
860
 
            with closing(socket.socket()) as s:
861
 
                ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
862
 
                                    struct.pack("16s16x", interface))
 
654
            s = socket.socket()
 
655
            ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
 
656
                                struct.pack("16s16x", interface))
 
657
            s.close()
863
658
            interface_index = struct.unpack("I", ifreq[16:20])[0]
864
659
            return interface_index
865
660
    return if_nametoindex(interface)
889
684
 
890
685
 
891
686
def main():
892
 
    parser = optparse.OptionParser(version = "%%prog %s" % version)
 
687
    parser = OptionParser(version = "%%prog %s" % version)
893
688
    parser.add_option("-i", "--interface", type="string",
894
689
                      metavar="IF", help="Bind to interface IF")
895
690
    parser.add_option("-a", "--address", type="string",
896
691
                      help="Address to listen for requests on")
897
692
    parser.add_option("-p", "--port", type="int",
898
693
                      help="Port number to receive requests on")
899
 
    parser.add_option("--check", action="store_true",
 
694
    parser.add_option("--check", action="store_true", default=False,
900
695
                      help="Run self-test")
901
696
    parser.add_option("--debug", action="store_true",
902
697
                      help="Debug mode; run in foreground and log to"
909
704
                      default="/etc/mandos", metavar="DIR",
910
705
                      help="Directory to search for configuration"
911
706
                      " files")
912
 
    parser.add_option("--no-dbus", action="store_false",
913
 
                      dest="use_dbus",
914
 
                      help=optparse.SUPPRESS_HELP)
915
707
    options = parser.parse_args()[0]
916
708
    
917
709
    if options.check:
927
719
                        "priority":
928
720
                        "SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
929
721
                        "servicename": "Mandos",
930
 
                        "use_dbus": "True",
931
722
                        }
932
723
    
933
724
    # Parse config file for server-global settings
936
727
    server_config.read(os.path.join(options.configdir, "mandos.conf"))
937
728
    # Convert the SafeConfigParser object to a dict
938
729
    server_settings = server_config.defaults()
939
 
    # Use getboolean on the boolean config options
940
 
    server_settings["debug"] = (server_config.getboolean
941
 
                                ("DEFAULT", "debug"))
942
 
    server_settings["use_dbus"] = (server_config.getboolean
943
 
                                   ("DEFAULT", "use_dbus"))
 
730
    # Use getboolean on the boolean config option
 
731
    server_settings["debug"] = server_config.getboolean\
 
732
                               ("DEFAULT", "debug")
944
733
    del server_config
945
734
    
946
735
    # Override the settings from the config file with command line
947
736
    # options, if set.
948
737
    for option in ("interface", "address", "port", "debug",
949
 
                   "priority", "servicename", "configdir",
950
 
                   "use_dbus"):
 
738
                   "priority", "servicename", "configdir"):
951
739
        value = getattr(options, option)
952
740
        if value is not None:
953
741
            server_settings[option] = value
954
742
    del options
955
743
    # Now we have our good server settings in "server_settings"
956
744
    
957
 
    # For convenience
958
745
    debug = server_settings["debug"]
959
 
    use_dbus = server_settings["use_dbus"]
960
 
    use_dbus = False
961
746
    
962
747
    if not debug:
963
748
        syslogger.setLevel(logging.WARNING)
964
749
        console.setLevel(logging.WARNING)
965
750
    
966
751
    if server_settings["servicename"] != "Mandos":
967
 
        syslogger.setFormatter(logging.Formatter
 
752
        syslogger.setFormatter(logging.Formatter\
968
753
                               ('Mandos (%s): %%(levelname)s:'
969
754
                                ' %%(message)s'
970
755
                                % server_settings["servicename"]))
991
776
    except IOError, error:
992
777
        logger.error("Could not open file %r", pidfilename)
993
778
    
994
 
    try:
995
 
        uid = pwd.getpwnam("_mandos").pw_uid
996
 
    except KeyError:
997
 
        try:
998
 
            uid = pwd.getpwnam("mandos").pw_uid
999
 
        except KeyError:
1000
 
            try:
1001
 
                uid = pwd.getpwnam("nobody").pw_uid
1002
 
            except KeyError:
1003
 
                uid = 65534
1004
 
    try:
1005
 
        gid = pwd.getpwnam("_mandos").pw_gid
1006
 
    except KeyError:
1007
 
        try:
1008
 
            gid = pwd.getpwnam("mandos").pw_gid
1009
 
        except KeyError:
1010
 
            try:
1011
 
                gid = pwd.getpwnam("nogroup").pw_gid
1012
 
            except KeyError:
1013
 
                gid = 65534
 
779
    uid = 65534
 
780
    gid = 65534
 
781
    try:
 
782
        uid = pwd.getpwnam("mandos").pw_uid
 
783
    except KeyError:
 
784
        try:
 
785
            uid = pwd.getpwnam("nobody").pw_uid
 
786
        except KeyError:
 
787
            pass
 
788
    try:
 
789
        gid = pwd.getpwnam("mandos").pw_gid
 
790
    except KeyError:
 
791
        try:
 
792
            gid = pwd.getpwnam("nogroup").pw_gid
 
793
        except KeyError:
 
794
            pass
1014
795
    try:
1015
796
        os.setuid(uid)
1016
797
        os.setgid(gid)
1022
803
    service = AvahiService(name = server_settings["servicename"],
1023
804
                           servicetype = "_mandos._tcp", )
1024
805
    if server_settings["interface"]:
1025
 
        service.interface = (if_nametoindex
1026
 
                             (server_settings["interface"]))
 
806
        service.interface = if_nametoindex\
 
807
                            (server_settings["interface"])
1027
808
    
1028
809
    global main_loop
1029
810
    global bus
1036
817
                                           avahi.DBUS_PATH_SERVER),
1037
818
                            avahi.DBUS_INTERFACE_SERVER)
1038
819
    # End of Avahi example code
1039
 
    if use_dbus:
1040
 
        bus_name = dbus.service.BusName(u"org.mandos-system.Mandos",
1041
 
                                        bus)
 
820
    
 
821
    def remove_from_clients(client):
 
822
        clients.remove(client)
 
823
        if not clients:
 
824
            logger.critical(u"No clients left, exiting")
 
825
            sys.exit()
1042
826
    
1043
827
    clients.update(Set(Client(name = section,
 
828
                              stop_hook = remove_from_clients,
1044
829
                              config
1045
 
                              = dict(client_config.items(section)),
1046
 
                              use_dbus = use_dbus)
 
830
                              = dict(client_config.items(section)))
1047
831
                       for section in client_config.sections()))
1048
832
    if not clients:
1049
 
        logger.warning(u"No clients defined")
 
833
        logger.critical(u"No clients defined")
 
834
        sys.exit(1)
1050
835
    
1051
836
    if debug:
1052
837
        # Redirect stdin so all checkers get /dev/null
1084
869
        
1085
870
        while clients:
1086
871
            client = clients.pop()
1087
 
            client.disable_hook = None
1088
 
            client.disable()
 
872
            client.stop_hook = None
 
873
            client.stop()
1089
874
    
1090
875
    atexit.register(cleanup)
1091
876
    
1094
879
    signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
1095
880
    signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
1096
881
    
1097
 
    if use_dbus:
1098
 
        class MandosServer(dbus.service.Object):
1099
 
            """A D-Bus proxy object"""
1100
 
            def __init__(self):
1101
 
                dbus.service.Object.__init__(self, bus,
1102
 
                                             "/Mandos")
1103
 
            _interface = u"org.mandos_system.Mandos"
1104
 
 
1105
 
            @dbus.service.signal(_interface, signature="oa{sv}")
1106
 
            def ClientAdded(self, objpath, properties):
1107
 
                "D-Bus signal"
1108
 
                pass
1109
 
 
1110
 
            @dbus.service.signal(_interface, signature="o")
1111
 
            def ClientRemoved(self, objpath):
1112
 
                "D-Bus signal"
1113
 
                pass
1114
 
 
1115
 
            @dbus.service.method(_interface, out_signature="ao")
1116
 
            def GetAllClients(self):
1117
 
                return dbus.Array(c.dbus_object_path for c in clients)
1118
 
 
1119
 
            @dbus.service.method(_interface, out_signature="a{oa{sv}}")
1120
 
            def GetAllClientsWithProperties(self):
1121
 
                return dbus.Dictionary(
1122
 
                    ((c.dbus_object_path, c.GetAllProperties())
1123
 
                     for c in clients),
1124
 
                    signature="oa{sv}")
1125
 
 
1126
 
            @dbus.service.method(_interface, in_signature="o")
1127
 
            def RemoveClient(self, object_path):
1128
 
                for c in clients:
1129
 
                    if c.dbus_object_path == object_path:
1130
 
                        clients.remove(c)
1131
 
                        # Don't signal anything except ClientRemoved
1132
 
                        c.use_dbus = False
1133
 
                        c.disable()
1134
 
                        # Emit D-Bus signal
1135
 
                        self.ClientRemoved(object_path)
1136
 
                        return
1137
 
                raise KeyError
1138
 
            @dbus.service.method(_interface)
1139
 
            def Quit(self):
1140
 
                main_loop.quit()
1141
 
 
1142
 
            del _interface
1143
 
    
1144
 
        mandos_server = MandosServer()
1145
 
    
1146
882
    for client in clients:
1147
 
        if use_dbus:
1148
 
            # Emit D-Bus signal
1149
 
            mandos_server.ClientAdded(client.dbus_object_path,
1150
 
                                      client.GetAllProperties())
1151
 
        client.enable()
 
883
        client.start()
1152
884
    
1153
885
    tcp_server.enable()
1154
886
    tcp_server.server_activate()
1172
904
        
1173
905
        gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,
1174
906
                             lambda *args, **kwargs:
1175
 
                             (tcp_server.handle_request
1176
 
                              (*args[2:], **kwargs) or True))
 
907
                             tcp_server.handle_request\
 
908
                             (*args[2:], **kwargs) or True)
1177
909
        
1178
910
        logger.debug(u"Starting main loop")
1179
911
        main_loop.run()
1180
912
    except AvahiError, error:
1181
 
        logger.critical(u"AvahiError: %s", error)
 
913
        logger.critical(u"AvahiError: %s" + unicode(error))
1182
914
        sys.exit(1)
1183
915
    except KeyboardInterrupt:
1184
916
        if debug: