/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-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:
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.5"
 
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 and
182
 
                        D-Bus identifiers
 
176
    name:      string; from the config file, used in log messages
183
177
    fingerprint: string (40 or 32 hexadecimal digits); used to
184
178
                 uniquely identify the client
185
 
    secret:     bytestring; sent verbatim (over TLS) to client
186
 
    host:       string; available for use by the checker command
187
 
    created:    datetime.datetime(); (UTC) object creation
188
 
    last_enabled: datetime.datetime(); (UTC)
189
 
    enabled:    bool()
190
 
    last_checked_ok: datetime.datetime(); (UTC) or None
191
 
    timeout:    datetime.timedelta(); How long from last_checked_ok
192
 
                                      until this client is invalid
193
 
    interval:   datetime.timedelta(); How often to start a new checker
194
 
    disable_hook:  If set, called by disable() as disable_hook(self)
195
 
    checker:    subprocess.Popen(); a running checker process used
196
 
                                    to see if the client lives.
197
 
                                    '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.
198
190
    checker_initiator_tag: a gobject event source tag, or None
199
 
    disable_initiator_tag:    - '' -
 
191
    stop_initiator_tag:    - '' -
200
192
    checker_callback_tag:  - '' -
201
193
    checker_command: string; External command which is run to check if
202
194
                     client lives.  %() expansions are done at
203
195
                     runtime with vars(self) as dict, so that for
204
196
                     instance %(name)s can be used in the command.
205
 
    use_dbus: bool(); Whether to provide D-Bus interface and signals
206
 
    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: - '' -
207
202
    """
208
 
    def timeout_milliseconds(self):
209
 
        "Return the 'timeout' attribute in milliseconds"
210
 
        return ((self.timeout.days * 24 * 60 * 60 * 1000)
211
 
                + (self.timeout.seconds * 1000)
212
 
                + (self.timeout.microseconds // 1000))
213
 
    
214
 
    def interval_milliseconds(self):
215
 
        "Return the 'interval' attribute in milliseconds"
216
 
        return ((self.interval.days * 24 * 60 * 60 * 1000)
217
 
                + (self.interval.seconds * 1000)
218
 
                + (self.interval.microseconds // 1000))
219
 
    
220
 
    def __init__(self, name = None, disable_hook=None, config=None,
221
 
                 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):
222
227
        """Note: the 'checker' key in 'config' sets the
223
228
        'checker_command' attribute and *not* the 'checker'
224
229
        attribute."""
225
 
        self.name = name
226
230
        if config is None:
227
231
            config = {}
 
232
        self.name = name
228
233
        logger.debug(u"Creating client %r", self.name)
229
 
        self.use_dbus = False   # During __init__
230
234
        # Uppercase and remove spaces from fingerprint for later
231
235
        # comparison purposes with return value from the fingerprint()
232
236
        # function
233
 
        self.fingerprint = (config["fingerprint"].upper()
234
 
                            .replace(u" ", u""))
 
237
        self.fingerprint = config["fingerprint"].upper()\
 
238
                           .replace(u" ", u"")
235
239
        logger.debug(u"  Fingerprint: %s", self.fingerprint)
236
240
        if "secret" in config:
237
241
            self.secret = config["secret"].decode(u"base64")
238
242
        elif "secfile" in config:
239
 
            with closing(open(os.path.expanduser
240
 
                              (os.path.expandvars
241
 
                               (config["secfile"])))) as secfile:
242
 
                self.secret = secfile.read()
 
243
            secfile = open(config["secfile"])
 
244
            self.secret = secfile.read()
 
245
            secfile.close()
243
246
        else:
244
247
            raise TypeError(u"No secret or secfile for client %s"
245
248
                            % self.name)
246
249
        self.host = config.get("host", "")
247
 
        self.created = datetime.datetime.utcnow()
248
 
        self.enabled = False
249
 
        self.last_enabled = None
 
250
        self.created = datetime.datetime.now()
250
251
        self.last_checked_ok = None
251
252
        self.timeout = string_to_delta(config["timeout"])
252
253
        self.interval = string_to_delta(config["interval"])
253
 
        self.disable_hook = disable_hook
 
254
        self.stop_hook = stop_hook
254
255
        self.checker = None
255
256
        self.checker_initiator_tag = None
256
 
        self.disable_initiator_tag = None
 
257
        self.stop_initiator_tag = None
257
258
        self.checker_callback_tag = None
258
 
        self.checker_command = config["checker"]
259
 
        self.last_connect = None
260
 
        # Only now, when this client is initialized, can it show up on
261
 
        # the D-Bus
262
 
        self.use_dbus = use_dbus
263
 
        if self.use_dbus:
264
 
            self.dbus_object_path = (dbus.ObjectPath
265
 
                                     ("/clients/"
266
 
                                      + self.name.replace(".", "_")))
267
 
            dbus.service.Object.__init__(self, bus,
268
 
                                         self.dbus_object_path)
269
 
    
270
 
    def enable(self):
 
259
        self.check_command = config["checker"]
 
260
    def start(self):
271
261
        """Start this client's checker and timeout hooks"""
272
 
        self.last_enabled = datetime.datetime.utcnow()
273
262
        # Schedule a new checker to be started an 'interval' from now,
274
263
        # and every interval from then on.
275
 
        self.checker_initiator_tag = (gobject.timeout_add
276
 
                                      (self.interval_milliseconds(),
277
 
                                       self.start_checker))
 
264
        self.checker_initiator_tag = gobject.timeout_add\
 
265
                                     (self._interval_milliseconds,
 
266
                                      self.start_checker)
278
267
        # Also start a new checker *right now*.
279
268
        self.start_checker()
280
 
        # Schedule a disable() when 'timeout' has passed
281
 
        self.disable_initiator_tag = (gobject.timeout_add
282
 
                                   (self.timeout_milliseconds(),
283
 
                                    self.disable))
284
 
        self.enabled = True
285
 
        if self.use_dbus:
286
 
            # Emit D-Bus signals
287
 
            self.PropertyChanged(dbus.String(u"enabled"),
288
 
                                 dbus.Boolean(True, variant_level=1))
289
 
            self.PropertyChanged(dbus.String(u"last_enabled"),
290
 
                                 (_datetime_to_dbus(self.last_enabled,
291
 
                                                    variant_level=1)))
292
 
    
293
 
    def disable(self):
294
 
        """Disable this client."""
295
 
        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:
296
282
            return False
297
 
        logger.info(u"Disabling client %s", self.name)
298
 
        if getattr(self, "disable_initiator_tag", False):
299
 
            gobject.source_remove(self.disable_initiator_tag)
300
 
            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
301
286
        if getattr(self, "checker_initiator_tag", False):
302
287
            gobject.source_remove(self.checker_initiator_tag)
303
288
            self.checker_initiator_tag = None
304
289
        self.stop_checker()
305
 
        if self.disable_hook:
306
 
            self.disable_hook(self)
307
 
        self.enabled = False
308
 
        if self.use_dbus:
309
 
            # Emit D-Bus signal
310
 
            self.PropertyChanged(dbus.String(u"enabled"),
311
 
                                 dbus.Boolean(False, variant_level=1))
 
290
        if self.stop_hook:
 
291
            self.stop_hook(self)
312
292
        # Do not run this again if called by a gobject.timeout_add
313
293
        return False
314
 
    
315
294
    def __del__(self):
316
 
        self.disable_hook = None
317
 
        self.disable()
318
 
    
319
 
    def checker_callback(self, pid, condition, command):
 
295
        self.stop_hook = None
 
296
        self.stop()
 
297
    def checker_callback(self, pid, condition):
320
298
        """The checker has completed, so take appropriate actions."""
 
299
        now = datetime.datetime.now()
321
300
        self.checker_callback_tag = None
322
301
        self.checker = None
323
 
        if self.use_dbus:
324
 
            # Emit D-Bus signal
325
 
            self.PropertyChanged(dbus.String(u"checker_running"),
326
 
                                 dbus.Boolean(False, variant_level=1))
327
 
        if os.WIFEXITED(condition):
328
 
            exitstatus = os.WEXITSTATUS(condition)
329
 
            if exitstatus == 0:
330
 
                logger.info(u"Checker for %(name)s succeeded",
331
 
                            vars(self))
332
 
                self.checked_ok()
333
 
            else:
334
 
                logger.info(u"Checker for %(name)s failed",
335
 
                            vars(self))
336
 
            if self.use_dbus:
337
 
                # Emit D-Bus signal
338
 
                self.CheckerCompleted(dbus.Int16(exitstatus),
339
 
                                      dbus.Int64(condition),
340
 
                                      dbus.String(command))
341
 
        else:
 
302
        if os.WIFEXITED(condition) \
 
303
               and (os.WEXITSTATUS(condition) == 0):
 
304
            logger.info(u"Checker for %(name)s succeeded",
 
305
                        vars(self))
 
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)
 
311
        elif not os.WIFEXITED(condition):
342
312
            logger.warning(u"Checker for %(name)s crashed?",
343
313
                           vars(self))
344
 
            if self.use_dbus:
345
 
                # Emit D-Bus signal
346
 
                self.CheckerCompleted(dbus.Int16(-1),
347
 
                                      dbus.Int64(condition),
348
 
                                      dbus.String(command))
349
 
    
350
 
    def checked_ok(self):
351
 
        """Bump up the timeout for this client.
352
 
        This should only be called when the client has been seen,
353
 
        alive and well.
354
 
        """
355
 
        self.last_checked_ok = datetime.datetime.utcnow()
356
 
        gobject.source_remove(self.disable_initiator_tag)
357
 
        self.disable_initiator_tag = (gobject.timeout_add
358
 
                                      (self.timeout_milliseconds(),
359
 
                                       self.disable))
360
 
        if self.use_dbus:
361
 
            # Emit D-Bus signal
362
 
            self.PropertyChanged(
363
 
                dbus.String(u"last_checked_ok"),
364
 
                (_datetime_to_dbus(self.last_checked_ok,
365
 
                                   variant_level=1)))
366
 
    
 
314
        else:
 
315
            logger.info(u"Checker for %(name)s failed",
 
316
                        vars(self))
367
317
    def start_checker(self):
368
318
        """Start a new checker subprocess if one is not running.
369
319
        If a checker already exists, leave it running and do
378
328
        # is as it should be.
379
329
        if self.checker is None:
380
330
            try:
381
 
                # In case checker_command has exactly one % operator
382
 
                command = self.checker_command % self.host
 
331
                # In case check_command has exactly one % operator
 
332
                command = self.check_command % self.host
383
333
            except TypeError:
384
334
                # Escape attributes for the shell
385
335
                escaped_attrs = dict((key, re.escape(str(val)))
386
336
                                     for key, val in
387
337
                                     vars(self).iteritems())
388
338
                try:
389
 
                    command = self.checker_command % escaped_attrs
 
339
                    command = self.check_command % escaped_attrs
390
340
                except TypeError, error:
391
341
                    logger.error(u'Could not format string "%s":'
392
 
                                 u' %s', self.checker_command, error)
 
342
                                 u' %s', self.check_command, error)
393
343
                    return True # Try again later
394
344
            try:
395
345
                logger.info(u"Starting checker %r for %s",
401
351
                self.checker = subprocess.Popen(command,
402
352
                                                close_fds=True,
403
353
                                                shell=True, cwd="/")
404
 
                if self.use_dbus:
405
 
                    # Emit D-Bus signal
406
 
                    self.CheckerStarted(command)
407
 
                    self.PropertyChanged(
408
 
                        dbus.String("checker_running"),
409
 
                        dbus.Boolean(True, variant_level=1))
410
 
                self.checker_callback_tag = (gobject.child_watch_add
411
 
                                             (self.checker.pid,
412
 
                                              self.checker_callback,
413
 
                                              data=command))
 
354
                self.checker_callback_tag = gobject.child_watch_add\
 
355
                                            (self.checker.pid,
 
356
                                             self.checker_callback)
414
357
            except OSError, error:
415
358
                logger.error(u"Failed to start subprocess: %s",
416
359
                             error)
417
360
        # Re-run this periodically if run by gobject.timeout_add
418
361
        return True
419
 
    
420
362
    def stop_checker(self):
421
363
        """Force the checker process, if any, to stop."""
422
364
        if self.checker_callback_tag:
434
376
            if error.errno != errno.ESRCH: # No such process
435
377
                raise
436
378
        self.checker = None
437
 
        if self.use_dbus:
438
 
            self.PropertyChanged(dbus.String(u"checker_running"),
439
 
                                 dbus.Boolean(False, variant_level=1))
440
 
    
441
379
    def still_valid(self):
442
380
        """Has the timeout not yet passed for this client?"""
443
 
        if not getattr(self, "enabled", False):
444
 
            return False
445
 
        now = datetime.datetime.utcnow()
 
381
        now = datetime.datetime.now()
446
382
        if self.last_checked_ok is None:
447
383
            return now < (self.created + self.timeout)
448
384
        else:
449
385
            return now < (self.last_checked_ok + self.timeout)
450
 
    
451
 
    ## D-Bus methods & signals
452
 
    _interface = u"se.bsnet.fukt.Mandos.Client"
453
 
    
454
 
    # CheckedOK - method
455
 
    CheckedOK = dbus.service.method(_interface)(checked_ok)
456
 
    CheckedOK.__name__ = "CheckedOK"
457
 
    
458
 
    # CheckerCompleted - signal
459
 
    @dbus.service.signal(_interface, signature="nxs")
460
 
    def CheckerCompleted(self, exitcode, waitstatus, command):
461
 
        "D-Bus signal"
462
 
        pass
463
 
    
464
 
    # CheckerStarted - signal
465
 
    @dbus.service.signal(_interface, signature="s")
466
 
    def CheckerStarted(self, command):
467
 
        "D-Bus signal"
468
 
        pass
469
 
    
470
 
    # GetAllProperties - method
471
 
    @dbus.service.method(_interface, out_signature="a{sv}")
472
 
    def GetAllProperties(self):
473
 
        "D-Bus method"
474
 
        return dbus.Dictionary({
475
 
                dbus.String("name"):
476
 
                    dbus.String(self.name, variant_level=1),
477
 
                dbus.String("fingerprint"):
478
 
                    dbus.String(self.fingerprint, variant_level=1),
479
 
                dbus.String("host"):
480
 
                    dbus.String(self.host, variant_level=1),
481
 
                dbus.String("created"):
482
 
                    _datetime_to_dbus(self.created, variant_level=1),
483
 
                dbus.String("last_enabled"):
484
 
                    (_datetime_to_dbus(self.last_enabled,
485
 
                                       variant_level=1)
486
 
                     if self.last_enabled is not None
487
 
                     else dbus.Boolean(False, variant_level=1)),
488
 
                dbus.String("enabled"):
489
 
                    dbus.Boolean(self.enabled, variant_level=1),
490
 
                dbus.String("last_checked_ok"):
491
 
                    (_datetime_to_dbus(self.last_checked_ok,
492
 
                                       variant_level=1)
493
 
                     if self.last_checked_ok is not None
494
 
                     else dbus.Boolean (False, variant_level=1)),
495
 
                dbus.String("timeout"):
496
 
                    dbus.UInt64(self.timeout_milliseconds(),
497
 
                                variant_level=1),
498
 
                dbus.String("interval"):
499
 
                    dbus.UInt64(self.interval_milliseconds(),
500
 
                                variant_level=1),
501
 
                dbus.String("checker"):
502
 
                    dbus.String(self.checker_command,
503
 
                                variant_level=1),
504
 
                dbus.String("checker_running"):
505
 
                    dbus.Boolean(self.checker is not None,
506
 
                                 variant_level=1),
507
 
                dbus.String("object_path"):
508
 
                    dbus.ObjectPath(self.dbus_object_path,
509
 
                                    variant_level=1)
510
 
                }, signature="sv")
511
 
    
512
 
    # IsStillValid - method
513
 
    IsStillValid = (dbus.service.method(_interface, out_signature="b")
514
 
                    (still_valid))
515
 
    IsStillValid.__name__ = "IsStillValid"
516
 
    
517
 
    # PropertyChanged - signal
518
 
    @dbus.service.signal(_interface, signature="sv")
519
 
    def PropertyChanged(self, property, value):
520
 
        "D-Bus signal"
521
 
        pass
522
 
    
523
 
    # SetChecker - method
524
 
    @dbus.service.method(_interface, in_signature="s")
525
 
    def SetChecker(self, checker):
526
 
        "D-Bus setter method"
527
 
        self.checker_command = checker
528
 
        # Emit D-Bus signal
529
 
        self.PropertyChanged(dbus.String(u"checker"),
530
 
                             dbus.String(self.checker_command,
531
 
                                         variant_level=1))
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
 
        # Emit D-Bus signal
539
 
        self.PropertyChanged(dbus.String(u"host"),
540
 
                             dbus.String(self.host, variant_level=1))
541
 
    
542
 
    # SetInterval - method
543
 
    @dbus.service.method(_interface, in_signature="t")
544
 
    def SetInterval(self, milliseconds):
545
 
        self.interval = datetime.timedelta(0, 0, 0, milliseconds)
546
 
        # Emit D-Bus signal
547
 
        self.PropertyChanged(dbus.String(u"interval"),
548
 
                             (dbus.UInt64(self.interval_milliseconds(),
549
 
                                          variant_level=1)))
550
 
    
551
 
    # SetSecret - method
552
 
    @dbus.service.method(_interface, in_signature="ay",
553
 
                         byte_arrays=True)
554
 
    def SetSecret(self, secret):
555
 
        "D-Bus setter method"
556
 
        self.secret = str(secret)
557
 
    
558
 
    # SetTimeout - method
559
 
    @dbus.service.method(_interface, in_signature="t")
560
 
    def SetTimeout(self, milliseconds):
561
 
        self.timeout = datetime.timedelta(0, 0, 0, milliseconds)
562
 
        # Emit D-Bus signal
563
 
        self.PropertyChanged(dbus.String(u"timeout"),
564
 
                             (dbus.UInt64(self.timeout_milliseconds(),
565
 
                                          variant_level=1)))
566
 
    
567
 
    # Enable - method
568
 
    Enable = dbus.service.method(_interface)(enable)
569
 
    Enable.__name__ = "Enable"
570
 
    
571
 
    # StartChecker - method
572
 
    @dbus.service.method(_interface)
573
 
    def StartChecker(self):
574
 
        "D-Bus method"
575
 
        self.start_checker()
576
 
    
577
 
    # Disable - method
578
 
    @dbus.service.method(_interface)
579
 
    def Disable(self):
580
 
        "D-Bus method"
581
 
        self.disable()
582
 
    
583
 
    # StopChecker - method
584
 
    StopChecker = dbus.service.method(_interface)(stop_checker)
585
 
    StopChecker.__name__ = "StopChecker"
586
 
    
587
 
    del _interface
588
386
 
589
387
 
590
388
def peer_certificate(session):
591
389
    "Return the peer's OpenPGP certificate as a bytestring"
592
390
    # If not an OpenPGP certificate...
593
 
    if (gnutls.library.functions
594
 
        .gnutls_certificate_type_get(session._c_object)
595
 
        != 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:
596
394
        # ...do the normal thing
597
395
        return session.peer_certificate
598
 
    list_size = ctypes.c_uint(1)
599
 
    cert_list = (gnutls.library.functions
600
 
                 .gnutls_certificate_get_peers
601
 
                 (session._c_object, ctypes.byref(list_size)))
602
 
    if not bool(cert_list) and list_size.value != 0:
603
 
        raise gnutls.errors.GNUTLSError("error getting peer"
604
 
                                        " certificate")
 
396
    list_size = ctypes.c_uint()
 
397
    cert_list = gnutls.library.functions.gnutls_certificate_get_peers\
 
398
        (session._c_object, ctypes.byref(list_size))
605
399
    if list_size.value == 0:
606
400
        return None
607
401
    cert = cert_list[0]
611
405
def fingerprint(openpgp):
612
406
    "Convert an OpenPGP bytestring to a hexdigit fingerprint string"
613
407
    # New GnuTLS "datum" with the OpenPGP public key
614
 
    datum = (gnutls.library.types
615
 
             .gnutls_datum_t(ctypes.cast(ctypes.c_char_p(openpgp),
616
 
                                         ctypes.POINTER
617
 
                                         (ctypes.c_ubyte)),
618
 
                             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)))
619
412
    # New empty GnuTLS certificate
620
413
    crt = gnutls.library.types.gnutls_openpgp_crt_t()
621
 
    (gnutls.library.functions
622
 
     .gnutls_openpgp_crt_init(ctypes.byref(crt)))
 
414
    gnutls.library.functions.gnutls_openpgp_crt_init\
 
415
        (ctypes.byref(crt))
623
416
    # Import the OpenPGP public key into the certificate
624
 
    (gnutls.library.functions
625
 
     .gnutls_openpgp_crt_import(crt, ctypes.byref(datum),
626
 
                                gnutls.library.constants
627
 
                                .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)
628
420
    # Verify the self signature in the key
629
421
    crtverify = ctypes.c_uint()
630
 
    (gnutls.library.functions
631
 
     .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))
632
424
    if crtverify.value != 0:
633
425
        gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
634
426
        raise gnutls.errors.CertificateSecurityError("Verify failed")
636
428
    buf = ctypes.create_string_buffer(20)
637
429
    buf_len = ctypes.c_size_t()
638
430
    # Get the fingerprint from the certificate into the buffer
639
 
    (gnutls.library.functions
640
 
     .gnutls_openpgp_crt_get_fingerprint(crt, ctypes.byref(buf),
641
 
                                         ctypes.byref(buf_len)))
 
431
    gnutls.library.functions.gnutls_openpgp_crt_get_fingerprint\
 
432
        (crt, ctypes.byref(buf), ctypes.byref(buf_len))
642
433
    # Deinit the certificate
643
434
    gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
644
435
    # Convert the buffer to a Python bytestring
655
446
    
656
447
    def handle(self):
657
448
        logger.info(u"TCP connection from: %s",
658
 
                    unicode(self.client_address))
659
 
        session = (gnutls.connection
660
 
                   .ClientSession(self.request,
661
 
                                  gnutls.connection
662
 
                                  .X509Credentials()))
 
449
                     unicode(self.client_address))
 
450
        session = gnutls.connection.ClientSession\
 
451
                  (self.request, gnutls.connection.X509Credentials())
663
452
        
664
453
        line = self.request.makefile().readline()
665
454
        logger.debug(u"Protocol version: %r", line)
678
467
        #priority = ':'.join(("NONE", "+VERS-TLS1.1", "+AES-256-CBC",
679
468
        #                "+SHA1", "+COMP-NULL", "+CTYPE-OPENPGP",
680
469
        #                "+DHE-DSS"))
681
 
        # Use a fallback default, since this MUST be set.
682
 
        priority = self.server.settings.get("priority", "NORMAL")
683
 
        (gnutls.library.functions
684
 
         .gnutls_priority_set_direct(session._c_object,
685
 
                                     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)
686
476
        
687
477
        try:
688
478
            session.handshake()
691
481
            # Do not run session.bye() here: the session is not
692
482
            # established.  Just abandon the request.
693
483
            return
694
 
        logger.debug(u"Handshake succeeded")
695
484
        try:
696
485
            fpr = fingerprint(peer_certificate(session))
697
486
        except (TypeError, gnutls.errors.GNUTLSError), error:
699
488
            session.bye()
700
489
            return
701
490
        logger.debug(u"Fingerprint: %s", fpr)
 
491
        client = None
702
492
        for c in self.server.clients:
703
493
            if c.fingerprint == fpr:
704
494
                client = c
705
495
                break
706
 
        else:
 
496
        if not client:
707
497
            logger.warning(u"Client not found for fingerprint: %s",
708
498
                           fpr)
709
499
            session.bye()
716
506
                           vars(client))
717
507
            session.bye()
718
508
            return
719
 
        ## This won't work here, since we're in a fork.
720
 
        # client.checked_ok()
721
509
        sent_size = 0
722
510
        while sent_size < len(client.secret):
723
511
            sent = session.send(client.secret[sent_size:])
728
516
        session.bye()
729
517
 
730
518
 
731
 
class IPv6_TCPServer(SocketServer.ForkingMixIn,
732
 
                     SocketServer.TCPServer, object):
 
519
class IPv6_TCPServer(SocketServer.ForkingTCPServer, object):
733
520
    """IPv6 TCP server.  Accepts 'None' as address and/or port.
734
521
    Attributes:
735
522
        settings:       Server settings
848
635
    elif state == avahi.ENTRY_GROUP_FAILURE:
849
636
        logger.critical(u"Avahi: Error in group state changed %s",
850
637
                        unicode(error))
851
 
        raise AvahiGroupError(u"State changed: %s" % unicode(error))
 
638
        raise AvahiGroupError("State changed: %s", str(error))
852
639
 
853
640
def if_nametoindex(interface):
854
641
    """Call the C function if_nametoindex(), or equivalent"""
855
642
    global if_nametoindex
856
643
    try:
857
 
        if_nametoindex = (ctypes.cdll.LoadLibrary
858
 
                          (ctypes.util.find_library("c"))
859
 
                          .if_nametoindex)
 
644
        if_nametoindex = ctypes.cdll.LoadLibrary\
 
645
            (ctypes.util.find_library("c")).if_nametoindex
860
646
    except (OSError, AttributeError):
861
647
        if "struct" not in sys.modules:
862
648
            import struct
865
651
        def if_nametoindex(interface):
866
652
            "Get an interface index the hard way, i.e. using fcntl()"
867
653
            SIOCGIFINDEX = 0x8933  # From /usr/include/linux/sockios.h
868
 
            with closing(socket.socket()) as s:
869
 
                ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
870
 
                                    struct.pack("16s16x", interface))
 
654
            s = socket.socket()
 
655
            ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
 
656
                                struct.pack("16s16x", interface))
 
657
            s.close()
871
658
            interface_index = struct.unpack("I", ifreq[16:20])[0]
872
659
            return interface_index
873
660
    return if_nametoindex(interface)
897
684
 
898
685
 
899
686
def main():
900
 
    parser = optparse.OptionParser(version = "%%prog %s" % version)
 
687
    parser = OptionParser(version = "%%prog %s" % version)
901
688
    parser.add_option("-i", "--interface", type="string",
902
689
                      metavar="IF", help="Bind to interface IF")
903
690
    parser.add_option("-a", "--address", type="string",
904
691
                      help="Address to listen for requests on")
905
692
    parser.add_option("-p", "--port", type="int",
906
693
                      help="Port number to receive requests on")
907
 
    parser.add_option("--check", action="store_true",
 
694
    parser.add_option("--check", action="store_true", default=False,
908
695
                      help="Run self-test")
909
696
    parser.add_option("--debug", action="store_true",
910
697
                      help="Debug mode; run in foreground and log to"
917
704
                      default="/etc/mandos", metavar="DIR",
918
705
                      help="Directory to search for configuration"
919
706
                      " files")
920
 
    parser.add_option("--no-dbus", action="store_false",
921
 
                      dest="use_dbus",
922
 
                      help="Do not provide D-Bus system bus"
923
 
                      " interface")
924
707
    options = parser.parse_args()[0]
925
708
    
926
709
    if options.check:
936
719
                        "priority":
937
720
                        "SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
938
721
                        "servicename": "Mandos",
939
 
                        "use_dbus": "True",
940
722
                        }
941
723
    
942
724
    # Parse config file for server-global settings
945
727
    server_config.read(os.path.join(options.configdir, "mandos.conf"))
946
728
    # Convert the SafeConfigParser object to a dict
947
729
    server_settings = server_config.defaults()
948
 
    # Use the appropriate methods on the non-string config options
949
 
    server_settings["debug"] = server_config.getboolean("DEFAULT",
950
 
                                                        "debug")
951
 
    server_settings["use_dbus"] = server_config.getboolean("DEFAULT",
952
 
                                                           "use_dbus")
953
 
    if server_settings["port"]:
954
 
        server_settings["port"] = server_config.getint("DEFAULT",
955
 
                                                       "port")
 
730
    # Use getboolean on the boolean config option
 
731
    server_settings["debug"] = server_config.getboolean\
 
732
                               ("DEFAULT", "debug")
956
733
    del server_config
957
734
    
958
735
    # Override the settings from the config file with command line
959
736
    # options, if set.
960
737
    for option in ("interface", "address", "port", "debug",
961
 
                   "priority", "servicename", "configdir",
962
 
                   "use_dbus"):
 
738
                   "priority", "servicename", "configdir"):
963
739
        value = getattr(options, option)
964
740
        if value is not None:
965
741
            server_settings[option] = value
966
742
    del options
967
743
    # Now we have our good server settings in "server_settings"
968
744
    
969
 
    # For convenience
970
745
    debug = server_settings["debug"]
971
 
    use_dbus = server_settings["use_dbus"]
972
746
    
973
747
    if not debug:
974
748
        syslogger.setLevel(logging.WARNING)
975
749
        console.setLevel(logging.WARNING)
976
750
    
977
751
    if server_settings["servicename"] != "Mandos":
978
 
        syslogger.setFormatter(logging.Formatter
 
752
        syslogger.setFormatter(logging.Formatter\
979
753
                               ('Mandos (%s): %%(levelname)s:'
980
754
                                ' %%(message)s'
981
755
                                % server_settings["servicename"]))
983
757
    # Parse config file with clients
984
758
    client_defaults = { "timeout": "1h",
985
759
                        "interval": "5m",
986
 
                        "checker": "fping -q -- %%(host)s",
 
760
                        "checker": "fping -q -- %(host)s",
987
761
                        "host": "",
988
762
                        }
989
763
    client_config = ConfigParser.SafeConfigParser(client_defaults)
1002
776
    except IOError, error:
1003
777
        logger.error("Could not open file %r", pidfilename)
1004
778
    
1005
 
    try:
1006
 
        uid = pwd.getpwnam("_mandos").pw_uid
1007
 
        gid = pwd.getpwnam("_mandos").pw_gid
1008
 
    except KeyError:
1009
 
        try:
1010
 
            uid = pwd.getpwnam("mandos").pw_uid
1011
 
            gid = pwd.getpwnam("mandos").pw_gid
1012
 
        except KeyError:
1013
 
            try:
1014
 
                uid = pwd.getpwnam("nobody").pw_uid
1015
 
                gid = pwd.getpwnam("nogroup").pw_gid
1016
 
            except KeyError:
1017
 
                uid = 65534
1018
 
                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
1019
795
    try:
1020
796
        os.setuid(uid)
1021
797
        os.setgid(gid)
1027
803
    service = AvahiService(name = server_settings["servicename"],
1028
804
                           servicetype = "_mandos._tcp", )
1029
805
    if server_settings["interface"]:
1030
 
        service.interface = (if_nametoindex
1031
 
                             (server_settings["interface"]))
 
806
        service.interface = if_nametoindex\
 
807
                            (server_settings["interface"])
1032
808
    
1033
809
    global main_loop
1034
810
    global bus
1041
817
                                           avahi.DBUS_PATH_SERVER),
1042
818
                            avahi.DBUS_INTERFACE_SERVER)
1043
819
    # End of Avahi example code
1044
 
    if use_dbus:
1045
 
        bus_name = dbus.service.BusName(u"se.bsnet.fukt.Mandos", 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()
1046
826
    
1047
827
    clients.update(Set(Client(name = section,
 
828
                              stop_hook = remove_from_clients,
1048
829
                              config
1049
 
                              = dict(client_config.items(section)),
1050
 
                              use_dbus = use_dbus)
 
830
                              = dict(client_config.items(section)))
1051
831
                       for section in client_config.sections()))
1052
832
    if not clients:
1053
 
        logger.warning(u"No clients defined")
 
833
        logger.critical(u"No clients defined")
 
834
        sys.exit(1)
1054
835
    
1055
836
    if debug:
1056
837
        # Redirect stdin so all checkers get /dev/null
1088
869
        
1089
870
        while clients:
1090
871
            client = clients.pop()
1091
 
            client.disable_hook = None
1092
 
            client.disable()
 
872
            client.stop_hook = None
 
873
            client.stop()
1093
874
    
1094
875
    atexit.register(cleanup)
1095
876
    
1098
879
    signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
1099
880
    signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
1100
881
    
1101
 
    if use_dbus:
1102
 
        class MandosServer(dbus.service.Object):
1103
 
            """A D-Bus proxy object"""
1104
 
            def __init__(self):
1105
 
                dbus.service.Object.__init__(self, bus, "/")
1106
 
            _interface = u"se.bsnet.fukt.Mandos"
1107
 
            
1108
 
            @dbus.service.signal(_interface, signature="oa{sv}")
1109
 
            def ClientAdded(self, objpath, properties):
1110
 
                "D-Bus signal"
1111
 
                pass
1112
 
            
1113
 
            @dbus.service.signal(_interface, signature="os")
1114
 
            def ClientRemoved(self, objpath, name):
1115
 
                "D-Bus signal"
1116
 
                pass
1117
 
            
1118
 
            @dbus.service.method(_interface, out_signature="ao")
1119
 
            def GetAllClients(self):
1120
 
                "D-Bus method"
1121
 
                return dbus.Array(c.dbus_object_path for c in clients)
1122
 
            
1123
 
            @dbus.service.method(_interface, out_signature="a{oa{sv}}")
1124
 
            def GetAllClientsWithProperties(self):
1125
 
                "D-Bus method"
1126
 
                return dbus.Dictionary(
1127
 
                    ((c.dbus_object_path, c.GetAllProperties())
1128
 
                     for c in clients),
1129
 
                    signature="oa{sv}")
1130
 
            
1131
 
            @dbus.service.method(_interface, in_signature="o")
1132
 
            def RemoveClient(self, object_path):
1133
 
                "D-Bus method"
1134
 
                for c in clients:
1135
 
                    if c.dbus_object_path == object_path:
1136
 
                        clients.remove(c)
1137
 
                        # Don't signal anything except ClientRemoved
1138
 
                        c.use_dbus = False
1139
 
                        c.disable()
1140
 
                        # Emit D-Bus signal
1141
 
                        self.ClientRemoved(object_path, c.name)
1142
 
                        return
1143
 
                raise KeyError
1144
 
            
1145
 
            del _interface
1146
 
        
1147
 
        mandos_server = MandosServer()
1148
 
    
1149
882
    for client in clients:
1150
 
        if use_dbus:
1151
 
            # Emit D-Bus signal
1152
 
            mandos_server.ClientAdded(client.dbus_object_path,
1153
 
                                      client.GetAllProperties())
1154
 
        client.enable()
 
883
        client.start()
1155
884
    
1156
885
    tcp_server.enable()
1157
886
    tcp_server.server_activate()
1175
904
        
1176
905
        gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,
1177
906
                             lambda *args, **kwargs:
1178
 
                             (tcp_server.handle_request
1179
 
                              (*args[2:], **kwargs) or True))
 
907
                             tcp_server.handle_request\
 
908
                             (*args[2:], **kwargs) or True)
1180
909
        
1181
910
        logger.debug(u"Starting main loop")
1182
911
        main_loop.run()
1183
912
    except AvahiError, error:
1184
 
        logger.critical(u"AvahiError: %s", error)
 
913
        logger.critical(u"AvahiError: %s" + unicode(error))
1185
914
        sys.exit(1)
1186
915
    except KeyboardInterrupt:
1187
916
        if debug: