/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 server.py

  • Committer: Teddy Hogeborn
  • Date: 2008-08-03 16:05:52 UTC
  • Revision ID: teddy@fukt.bsnet.se-20080803160552-mvqy5klry3wn57x1
* plugins.d/mandosclient.c (initgnutls): Moved "err" variable into its
                                         own code block.
  (start_mandos_communication): Moved call to "initgnutls" to
                                beginning.  Renamed label "exit" to
                                "mandos_end".  Bug fix: set return
                                code if failure to realloc buffer.
                                Close TLS session as early as
                                possible.
  (resolve_callback): Also print interface number when debugging.
  (main): Moved "debug_int" and "config" into their own respective
          code blocks.

Show diffs side-by-side

added added

removed removed

Lines of Context:
server.py
6
6
# This program is partly derived from an example program for an Avahi
7
7
# service publisher, downloaded from
8
8
# <http://avahi.org/wiki/PythonPublishExample>.  This includes the
9
 
# methods "add" and "remove" in the "AvahiService" class, the
10
 
# "server_state_changed" and "entry_group_state_changed" functions,
11
 
# and some lines in "main".
 
9
# following functions: "AvahiService.add", "AvahiService.remove",
 
10
# "server_state_changed", "entry_group_state_changed", and some lines
 
11
# in "main".
12
12
# 
13
13
# Everything else is
14
 
# Copyright © 2008 Teddy Hogeborn & Björn Påhlsson
 
14
# Copyright © 2007-2008 Teddy Hogeborn & Björn Påhlsson
15
15
# 
16
16
# This program is free software: you can redistribute it and/or modify
17
17
# it under the terms of the GNU General Public License as published by
24
24
#     GNU General Public License for more details.
25
25
# 
26
26
# You should have received a copy of the GNU General Public License
27
 
# along with this program.  If not, see
28
 
# <http://www.gnu.org/licenses/>.
 
27
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
29
28
# 
30
29
# Contact the authors at <mandos@fukt.bsnet.se>.
31
30
# 
32
31
 
33
 
from __future__ import division, with_statement, absolute_import
 
32
from __future__ import division
34
33
 
35
34
import SocketServer
36
35
import socket
 
36
import select
37
37
from optparse import OptionParser
38
38
import datetime
39
39
import errno
54
54
import stat
55
55
import logging
56
56
import logging.handlers
57
 
import pwd
58
 
from contextlib import closing
59
57
 
60
58
import dbus
61
 
import dbus.service
62
59
import gobject
63
60
import avahi
64
61
from dbus.mainloop.glib import DBusGMainLoop
65
62
import ctypes
66
 
import ctypes.util
67
 
 
68
 
version = "1.0.2"
 
63
 
 
64
# Brief description of the operation of this program:
 
65
# 
 
66
# This server announces itself as a Zeroconf service.  Connecting
 
67
# clients use the TLS protocol, with the unusual quirk that this
 
68
# server program acts as a TLS "client" while a connecting client acts
 
69
# as a TLS "server".  The client (acting as a TLS "server") must
 
70
# supply an OpenPGP certificate, and the fingerprint of this
 
71
# certificate is used by this server to look up (in a list read from a
 
72
# file at start time) which binary blob to give the client.  No other
 
73
# authentication or authorization is done by this server.
 
74
 
69
75
 
70
76
logger = logging.Logger('mandos')
71
77
syslogger = logging.handlers.SysLogHandler\
72
 
            (facility = logging.handlers.SysLogHandler.LOG_DAEMON,
73
 
             address = "/dev/log")
 
78
            (facility = logging.handlers.SysLogHandler.LOG_DAEMON)
74
79
syslogger.setFormatter(logging.Formatter\
75
 
                        ('Mandos: %(levelname)s: %(message)s'))
 
80
                        ('%(levelname)s: %(message)s'))
76
81
logger.addHandler(syslogger)
 
82
del syslogger
77
83
 
78
 
console = logging.StreamHandler()
79
 
console.setFormatter(logging.Formatter('%(name)s: %(levelname)s:'
80
 
                                       ' %(message)s'))
81
 
logger.addHandler(console)
82
84
 
83
85
class AvahiError(Exception):
84
86
    def __init__(self, value):
85
87
        self.value = value
86
 
        super(AvahiError, self).__init__()
87
88
    def __str__(self):
88
89
        return repr(self.value)
89
90
 
95
96
 
96
97
 
97
98
class AvahiService(object):
98
 
    """An Avahi (Zeroconf) service.
99
 
    Attributes:
 
99
    """
100
100
    interface: integer; avahi.IF_UNSPEC or an interface index.
101
101
               Used to optionally bind to the specified interface.
102
 
    name: string; Example: 'Mandos'
103
 
    type: string; Example: '_mandos._tcp'.
104
 
                  See <http://www.dns-sd.org/ServiceTypes.html>
105
 
    port: integer; what port to announce
106
 
    TXT: list of strings; TXT record for the service
107
 
    domain: string; Domain to publish on, default to .local if empty.
108
 
    host: string; Host to publish records for, default is localhost
109
 
    max_renames: integer; maximum number of renames
110
 
    rename_count: integer; counter so we only rename after collisions
111
 
                  a sensible number of times
 
102
    name = string; Example: "Mandos"
 
103
    type = string; Example: "_mandos._tcp".
 
104
                   See <http://www.dns-sd.org/ServiceTypes.html>
 
105
    port = integer; what port to announce
 
106
    TXT = list of strings; TXT record for the service
 
107
    domain = string; Domain to publish on, default to .local if empty.
 
108
    host = string; Host to publish records for, default to localhost
 
109
                   if empty.
 
110
    max_renames = integer; maximum number of renames
 
111
    rename_count = integer; counter so we only rename after collisions
 
112
                   a sensible number of times
112
113
    """
113
114
    def __init__(self, interface = avahi.IF_UNSPEC, name = None,
114
 
                 servicetype = None, port = None, TXT = None, domain = "",
115
 
                 host = "", max_renames = 32768):
 
115
                 type = None, port = None, TXT = None, domain = "",
 
116
                 host = "", max_renames = 12):
 
117
        """An Avahi (Zeroconf) service. """
116
118
        self.interface = interface
117
119
        self.name = name
118
 
        self.type = servicetype
 
120
        self.type = type
119
121
        self.port = port
120
122
        if TXT is None:
121
123
            self.TXT = []
124
126
        self.domain = domain
125
127
        self.host = host
126
128
        self.rename_count = 0
127
 
        self.max_renames = max_renames
128
129
    def rename(self):
129
130
        """Derived from the Avahi example code"""
130
131
        if self.rename_count >= self.max_renames:
131
 
            logger.critical(u"No suitable Zeroconf service name found"
132
 
                            u" after %i retries, exiting.",
133
 
                            self.rename_count)
 
132
            logger.critical(u"No suitable service name found after %i"
 
133
                            u" retries, exiting.", rename_count)
134
134
            raise AvahiServiceError("Too many renames")
135
 
        self.name = server.GetAlternativeServiceName(self.name)
136
 
        logger.info(u"Changing Zeroconf service name to %r ...",
137
 
                    str(self.name))
138
 
        syslogger.setFormatter(logging.Formatter\
139
 
                               ('Mandos (%s): %%(levelname)s:'
140
 
                               ' %%(message)s' % self.name))
 
135
        name = server.GetAlternativeServiceName(name)
 
136
        logger.notice(u"Changing name to %r ...", name)
141
137
        self.remove()
142
138
        self.add()
143
139
        self.rename_count += 1
155
151
                     avahi.DBUS_INTERFACE_ENTRY_GROUP)
156
152
            group.connect_to_signal('StateChanged',
157
153
                                    entry_group_state_changed)
158
 
        logger.debug(u"Adding Zeroconf service '%s' of type '%s' ...",
 
154
        logger.debug(u"Adding service '%s' of type '%s' ...",
159
155
                     service.name, service.type)
160
156
        group.AddService(
161
157
                self.interface,         # interface
172
168
# End of Avahi example code
173
169
 
174
170
 
175
 
class Client(dbus.service.Object):
 
171
class Client(object):
176
172
    """A representation of a client host served by this server.
177
173
    Attributes:
178
174
    name:      string; from the config file, used in log messages
179
175
    fingerprint: string (40 or 32 hexadecimal digits); used to
180
176
                 uniquely identify the client
181
177
    secret:    bytestring; sent verbatim (over TLS) to client
182
 
    host:      string; available for use by the checker command
 
178
    fqdn:      string (FQDN); available for use by the checker command
183
179
    created:   datetime.datetime(); object creation, not client host
184
 
    started:   bool()
185
180
    last_checked_ok: datetime.datetime() or None if not yet checked OK
186
181
    timeout:   datetime.timedelta(); How long from last_checked_ok
187
182
                                     until this client is invalid
203
198
    _timeout_milliseconds: Used when calling gobject.timeout_add()
204
199
    _interval_milliseconds: - '' -
205
200
    """
206
 
    interface = u"org.mandos_system.Mandos.Clients"
207
 
    
208
 
    @dbus.service.method(interface, out_signature="s")
209
 
    def getName(self):
210
 
        "D-Bus getter method"
211
 
        return self.name
212
 
    
213
 
    @dbus.service.method(interface, out_signature="s")
214
 
    def getFingerprint(self):
215
 
        "D-Bus getter method"
216
 
        return self.fingerprint
217
 
    
218
 
    @dbus.service.method(interface, in_signature="ay",
219
 
                         byte_arrays=True)
220
 
    def setSecret(self, secret):
221
 
        "D-Bus setter method"
222
 
        self.secret = secret
223
 
    
224
201
    def _set_timeout(self, timeout):
225
 
        "Setter function for the 'timeout' attribute"
 
202
        "Setter function for 'timeout' attribute"
226
203
        self._timeout = timeout
227
204
        self._timeout_milliseconds = ((self.timeout.days
228
205
                                       * 24 * 60 * 60 * 1000)
229
206
                                      + (self.timeout.seconds * 1000)
230
207
                                      + (self.timeout.microseconds
231
208
                                         // 1000))
232
 
        # Emit D-Bus signal
233
 
        self.TimeoutChanged(self._timeout_milliseconds)
234
 
    timeout = property(lambda self: self._timeout, _set_timeout)
 
209
    timeout = property(lambda self: self._timeout,
 
210
                       _set_timeout)
235
211
    del _set_timeout
236
 
    
237
 
    @dbus.service.method(interface, out_signature="t")
238
 
    def getTimeout(self):
239
 
        "D-Bus getter method"
240
 
        return self._timeout_milliseconds
241
 
    
242
 
    @dbus.service.signal(interface, signature="t")
243
 
    def TimeoutChanged(self, t):
244
 
        "D-Bus signal"
245
 
        pass
246
 
    
247
212
    def _set_interval(self, interval):
248
 
        "Setter function for the 'interval' attribute"
 
213
        "Setter function for 'interval' attribute"
249
214
        self._interval = interval
250
215
        self._interval_milliseconds = ((self.interval.days
251
216
                                        * 24 * 60 * 60 * 1000)
253
218
                                          * 1000)
254
219
                                       + (self.interval.microseconds
255
220
                                          // 1000))
256
 
        # Emit D-Bus signal
257
 
        self.IntervalChanged(self._interval_milliseconds)
258
 
    interval = property(lambda self: self._interval, _set_interval)
 
221
    interval = property(lambda self: self._interval,
 
222
                        _set_interval)
259
223
    del _set_interval
260
 
    
261
 
    @dbus.service.method(interface, out_signature="t")
262
 
    def getInterval(self):
263
 
        "D-Bus getter method"
264
 
        return self._interval_milliseconds
265
 
    
266
 
    @dbus.service.signal(interface, signature="t")
267
 
    def IntervalChanged(self, t):
268
 
        "D-Bus signal"
269
 
        pass
270
 
    
271
 
    def __init__(self, name = None, stop_hook=None, config=None):
272
 
        """Note: the 'checker' key in 'config' sets the
273
 
        'checker_command' attribute and *not* the 'checker'
274
 
        attribute."""
275
 
        dbus.service.Object.__init__(self, bus,
276
 
                                     "/Mandos/Clients/%s"
277
 
                                     % name.replace(".", "_"))
278
 
        if config is None:
279
 
            config = {}
 
224
    def __init__(self, name=None, stop_hook=None, fingerprint=None,
 
225
                 secret=None, secfile=None, fqdn=None, timeout=None,
 
226
                 interval=-1, checker=None):
 
227
        """Note: the 'checker' argument sets the 'checker_command'
 
228
        attribute and not the 'checker' attribute.."""
280
229
        self.name = name
281
230
        logger.debug(u"Creating client %r", self.name)
282
 
        # Uppercase and remove spaces from fingerprint for later
283
 
        # comparison purposes with return value from the fingerprint()
284
 
        # function
285
 
        self.fingerprint = config["fingerprint"].upper()\
286
 
                           .replace(u" ", u"")
 
231
        # Uppercase and remove spaces from fingerprint
 
232
        # for later comparison purposes with return value of
 
233
        # the fingerprint() function
 
234
        self.fingerprint = fingerprint.upper().replace(u" ", u"")
287
235
        logger.debug(u"  Fingerprint: %s", self.fingerprint)
288
 
        if "secret" in config:
289
 
            self.secret = config["secret"].decode(u"base64")
290
 
        elif "secfile" in config:
291
 
            with closing(open(os.path.expanduser
292
 
                              (os.path.expandvars
293
 
                               (config["secfile"])))) \
294
 
                               as secfile:
295
 
                self.secret = secfile.read()
 
236
        if secret:
 
237
            self.secret = secret.decode(u"base64")
 
238
        elif secfile:
 
239
            sf = open(secfile)
 
240
            self.secret = sf.read()
 
241
            sf.close()
296
242
        else:
297
243
            raise TypeError(u"No secret or secfile for client %s"
298
244
                            % self.name)
299
 
        self.host = config.get("host", "")
 
245
        self.fqdn = fqdn
300
246
        self.created = datetime.datetime.now()
301
 
        self.started = False
302
247
        self.last_checked_ok = None
303
 
        self.timeout = string_to_delta(config["timeout"])
304
 
        self.interval = string_to_delta(config["interval"])
 
248
        self.timeout = string_to_delta(timeout)
 
249
        self.interval = string_to_delta(interval)
305
250
        self.stop_hook = stop_hook
306
251
        self.checker = None
307
252
        self.checker_initiator_tag = None
308
253
        self.stop_initiator_tag = None
309
254
        self.checker_callback_tag = None
310
 
        self.check_command = config["checker"]
311
 
    
 
255
        self.check_command = checker
312
256
    def start(self):
313
257
        """Start this client's checker and timeout hooks"""
314
 
        self.started = True
315
258
        # Schedule a new checker to be started an 'interval' from now,
316
259
        # and every interval from then on.
317
260
        self.checker_initiator_tag = gobject.timeout_add\
323
266
        self.stop_initiator_tag = gobject.timeout_add\
324
267
                                  (self._timeout_milliseconds,
325
268
                                   self.stop)
326
 
        # Emit D-Bus signal
327
 
        self.StateChanged(True)
328
 
    
329
 
    @dbus.service.signal(interface, signature="b")
330
 
    def StateChanged(self, started):
331
 
        "D-Bus signal"
332
 
        pass
333
 
    
334
269
    def stop(self):
335
 
        """Stop this client."""
336
 
        if getattr(self, "started", False):
337
 
            logger.info(u"Stopping client %s", self.name)
 
270
        """Stop this client.
 
271
        The possibility that a client might be restarted is left open,
 
272
        but not currently used."""
 
273
        # If this client doesn't have a secret, it is already stopped.
 
274
        if self.secret:
 
275
            logger.debug(u"Stopping client %s", self.name)
 
276
            self.secret = None
338
277
        else:
339
278
            return False
340
279
        if getattr(self, "stop_initiator_tag", False):
346
285
        self.stop_checker()
347
286
        if self.stop_hook:
348
287
            self.stop_hook(self)
349
 
        # Emit D-Bus signal
350
 
        self.StateChanged(False)
351
288
        # Do not run this again if called by a gobject.timeout_add
352
289
        return False
353
 
    # D-Bus variant
354
 
    Stop = dbus.service.method(interface)(stop)
355
 
    
356
290
    def __del__(self):
357
291
        self.stop_hook = None
358
292
        self.stop()
359
 
    
360
293
    def checker_callback(self, pid, condition):
361
294
        """The checker has completed, so take appropriate actions."""
 
295
        now = datetime.datetime.now()
362
296
        self.checker_callback_tag = None
363
297
        self.checker = None
364
298
        if os.WIFEXITED(condition) \
365
299
               and (os.WEXITSTATUS(condition) == 0):
366
 
            logger.info(u"Checker for %(name)s succeeded",
367
 
                        vars(self))
368
 
            # Emit D-Bus signal
369
 
            self.CheckerCompleted(True)
370
 
            self.bump_timeout()
 
300
            logger.debug(u"Checker for %(name)s succeeded",
 
301
                         vars(self))
 
302
            self.last_checked_ok = now
 
303
            gobject.source_remove(self.stop_initiator_tag)
 
304
            self.stop_initiator_tag = gobject.timeout_add\
 
305
                                      (self._timeout_milliseconds,
 
306
                                       self.stop)
371
307
        elif not os.WIFEXITED(condition):
372
308
            logger.warning(u"Checker for %(name)s crashed?",
373
309
                           vars(self))
374
 
            # Emit D-Bus signal
375
 
            self.CheckerCompleted(False)
376
310
        else:
377
 
            logger.info(u"Checker for %(name)s failed",
378
 
                        vars(self))
379
 
            # Emit D-Bus signal
380
 
            self.CheckerCompleted(False)
381
 
    
382
 
    @dbus.service.signal(interface, signature="b")
383
 
    def CheckerCompleted(self, success):
384
 
        "D-Bus signal"
385
 
        pass
386
 
    
387
 
    def bump_timeout(self):
388
 
        """Bump up the timeout for this client.
389
 
        This should only be called when the client has been seen,
390
 
        alive and well.
391
 
        """
392
 
        self.last_checked_ok = datetime.datetime.now()
393
 
        gobject.source_remove(self.stop_initiator_tag)
394
 
        self.stop_initiator_tag = gobject.timeout_add\
395
 
            (self._timeout_milliseconds, self.stop)
396
 
    # D-Bus variant
397
 
    bumpTimeout = dbus.service.method(interface)(bump_timeout)
398
 
    
 
311
            logger.debug(u"Checker for %(name)s failed",
 
312
                         vars(self))
399
313
    def start_checker(self):
400
314
        """Start a new checker subprocess if one is not running.
401
315
        If a checker already exists, leave it running and do
411
325
        if self.checker is None:
412
326
            try:
413
327
                # In case check_command has exactly one % operator
414
 
                command = self.check_command % self.host
 
328
                command = self.check_command % self.fqdn
415
329
            except TypeError:
416
330
                # Escape attributes for the shell
417
331
                escaped_attrs = dict((key, re.escape(str(val)))
424
338
                                 u' %s', self.check_command, error)
425
339
                    return True # Try again later
426
340
            try:
427
 
                logger.info(u"Starting checker %r for %s",
428
 
                            command, self.name)
429
 
                # We don't need to redirect stdout and stderr, since
430
 
                # in normal mode, that is already done by daemon(),
431
 
                # and in debug mode we don't want to.  (Stdin is
432
 
                # always replaced by /dev/null.)
 
341
                logger.debug(u"Starting checker %r for %s",
 
342
                             command, self.name)
433
343
                self.checker = subprocess.Popen(command,
434
344
                                                close_fds=True,
435
345
                                                shell=True, cwd="/")
436
346
                self.checker_callback_tag = gobject.child_watch_add\
437
347
                                            (self.checker.pid,
438
348
                                             self.checker_callback)
439
 
                # Emit D-Bus signal
440
 
                self.CheckerStarted(command)
441
 
            except OSError, error:
 
349
            except subprocess.OSError, error:
442
350
                logger.error(u"Failed to start subprocess: %s",
443
351
                             error)
444
352
        # Re-run this periodically if run by gobject.timeout_add
445
353
        return True
446
 
    
447
 
    @dbus.service.signal(interface, signature="s")
448
 
    def CheckerStarted(self, command):
449
 
        pass
450
 
    
451
 
    @dbus.service.method(interface, out_signature="b")
452
 
    def checkerIsRunning(self):
453
 
        "D-Bus getter method"
454
 
        return self.checker is not None
455
 
    
456
354
    def stop_checker(self):
457
355
        """Force the checker process, if any, to stop."""
458
356
        if self.checker_callback_tag:
460
358
            self.checker_callback_tag = None
461
359
        if getattr(self, "checker", None) is None:
462
360
            return
463
 
        logger.debug(u"Stopping checker for %(name)s", vars(self))
 
361
        logger.debug("Stopping checker for %(name)s", vars(self))
464
362
        try:
465
363
            os.kill(self.checker.pid, signal.SIGTERM)
466
364
            #os.sleep(0.5)
470
368
            if error.errno != errno.ESRCH: # No such process
471
369
                raise
472
370
        self.checker = None
473
 
    # D-Bus variant
474
 
    StopChecker = dbus.service.method(interface)(stop_checker)
475
 
    
476
371
    def still_valid(self):
477
372
        """Has the timeout not yet passed for this client?"""
478
 
        if not self.started:
479
 
            return False
480
373
        now = datetime.datetime.now()
481
374
        if self.last_checked_ok is None:
482
375
            return now < (self.created + self.timeout)
483
376
        else:
484
377
            return now < (self.last_checked_ok + self.timeout)
485
 
    # D-Bus variant
486
 
    stillValid = dbus.service.method(interface, out_signature="b")\
487
 
        (still_valid)
488
 
    
489
 
    del interface
490
378
 
491
379
 
492
380
def peer_certificate(session):
508
396
 
509
397
def fingerprint(openpgp):
510
398
    "Convert an OpenPGP bytestring to a hexdigit fingerprint string"
 
399
    # New empty GnuTLS certificate
 
400
    crt = gnutls.library.types.gnutls_openpgp_crt_t()
 
401
    gnutls.library.functions.gnutls_openpgp_crt_init\
 
402
        (ctypes.byref(crt))
511
403
    # New GnuTLS "datum" with the OpenPGP public key
512
404
    datum = gnutls.library.types.gnutls_datum_t\
513
405
        (ctypes.cast(ctypes.c_char_p(openpgp),
514
406
                     ctypes.POINTER(ctypes.c_ubyte)),
515
407
         ctypes.c_uint(len(openpgp)))
516
 
    # New empty GnuTLS certificate
517
 
    crt = gnutls.library.types.gnutls_openpgp_crt_t()
518
 
    gnutls.library.functions.gnutls_openpgp_crt_init\
519
 
        (ctypes.byref(crt))
520
408
    # Import the OpenPGP public key into the certificate
521
 
    gnutls.library.functions.gnutls_openpgp_crt_import\
522
 
                    (crt, ctypes.byref(datum),
523
 
                     gnutls.library.constants.GNUTLS_OPENPGP_FMT_RAW)
524
 
    # Verify the self signature in the key
525
 
    crtverify = ctypes.c_uint()
526
 
    gnutls.library.functions.gnutls_openpgp_crt_verify_self\
527
 
        (crt, 0, ctypes.byref(crtverify))
528
 
    if crtverify.value != 0:
529
 
        gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
530
 
        raise gnutls.errors.CertificateSecurityError("Verify failed")
 
409
    ret = gnutls.library.functions.gnutls_openpgp_crt_import\
 
410
        (crt,
 
411
         ctypes.byref(datum),
 
412
         gnutls.library.constants.GNUTLS_OPENPGP_FMT_RAW)
531
413
    # New buffer for the fingerprint
532
 
    buf = ctypes.create_string_buffer(20)
533
 
    buf_len = ctypes.c_size_t()
 
414
    buffer = ctypes.create_string_buffer(20)
 
415
    buffer_length = ctypes.c_size_t()
534
416
    # Get the fingerprint from the certificate into the buffer
535
417
    gnutls.library.functions.gnutls_openpgp_crt_get_fingerprint\
536
 
        (crt, ctypes.byref(buf), ctypes.byref(buf_len))
 
418
        (crt, ctypes.byref(buffer), ctypes.byref(buffer_length))
537
419
    # Deinit the certificate
538
420
    gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
539
421
    # Convert the buffer to a Python bytestring
540
 
    fpr = ctypes.string_at(buf, buf_len.value)
 
422
    fpr = ctypes.string_at(buffer, buffer_length.value)
541
423
    # Convert the bytestring to hexadecimal notation
542
424
    hex_fpr = u''.join(u"%02X" % ord(char) for char in fpr)
543
425
    return hex_fpr
544
426
 
545
427
 
546
 
class TCP_handler(SocketServer.BaseRequestHandler, object):
 
428
class tcp_handler(SocketServer.BaseRequestHandler, object):
547
429
    """A TCP request handler class.
548
430
    Instantiated by IPv6_TCPServer for each request to handle it.
549
431
    Note: This will run in its own forked process."""
550
432
    
551
433
    def handle(self):
552
 
        logger.info(u"TCP connection from: %s",
553
 
                    unicode(self.client_address))
 
434
        logger.debug(u"TCP connection from: %s",
 
435
                     unicode(self.client_address))
554
436
        session = gnutls.connection.ClientSession\
555
437
                  (self.request, gnutls.connection.X509Credentials())
556
 
        
557
 
        line = self.request.makefile().readline()
558
 
        logger.debug(u"Protocol version: %r", line)
559
 
        try:
560
 
            if int(line.strip().split()[0]) > 1:
561
 
                raise RuntimeError
562
 
        except (ValueError, IndexError, RuntimeError), error:
563
 
            logger.error(u"Unknown protocol version: %s", error)
564
 
            return
565
 
        
566
438
        # Note: gnutls.connection.X509Credentials is really a generic
567
439
        # GnuTLS certificate credentials object so long as no X.509
568
440
        # keys are added to it.  Therefore, we can use it here despite
571
443
        #priority = ':'.join(("NONE", "+VERS-TLS1.1", "+AES-256-CBC",
572
444
        #                "+SHA1", "+COMP-NULL", "+CTYPE-OPENPGP",
573
445
        #                "+DHE-DSS"))
574
 
        # Use a fallback default, since this MUST be set.
575
 
        priority = self.server.settings.get("priority", "NORMAL")
 
446
        priority = "NORMAL"             # Fallback default, since this
 
447
                                        # MUST be set.
 
448
        if self.server.settings["priority"]:
 
449
            priority = self.server.settings["priority"]
576
450
        gnutls.library.functions.gnutls_priority_set_direct\
577
 
            (session._c_object, priority, None)
 
451
            (session._c_object, priority, None);
578
452
        
579
453
        try:
580
454
            session.handshake()
581
455
        except gnutls.errors.GNUTLSError, error:
582
 
            logger.warning(u"Handshake failed: %s", error)
 
456
            logger.debug(u"Handshake failed: %s", error)
583
457
            # Do not run session.bye() here: the session is not
584
458
            # established.  Just abandon the request.
585
459
            return
586
460
        try:
587
461
            fpr = fingerprint(peer_certificate(session))
588
462
        except (TypeError, gnutls.errors.GNUTLSError), error:
589
 
            logger.warning(u"Bad certificate: %s", error)
 
463
            logger.debug(u"Bad certificate: %s", error)
590
464
            session.bye()
591
465
            return
592
466
        logger.debug(u"Fingerprint: %s", fpr)
596
470
                client = c
597
471
                break
598
472
        if not client:
599
 
            logger.warning(u"Client not found for fingerprint: %s",
600
 
                           fpr)
 
473
            logger.debug(u"Client not found for fingerprint: %s", fpr)
601
474
            session.bye()
602
475
            return
603
476
        # Have to check if client.still_valid(), since it is possible
604
477
        # that the client timed out while establishing the GnuTLS
605
478
        # session.
606
479
        if not client.still_valid():
607
 
            logger.warning(u"Client %(name)s is invalid",
608
 
                           vars(client))
 
480
            logger.debug(u"Client %(name)s is invalid", vars(client))
609
481
            session.bye()
610
482
            return
611
 
        ## This won't work here, since we're in a fork.
612
 
        # client.bump_timeout()
613
483
        sent_size = 0
614
484
        while sent_size < len(client.secret):
615
485
            sent = session.send(client.secret[sent_size:])
620
490
        session.bye()
621
491
 
622
492
 
623
 
class IPv6_TCPServer(SocketServer.ForkingMixIn,
624
 
                     SocketServer.TCPServer, object):
 
493
class IPv6_TCPServer(SocketServer.ForkingTCPServer, object):
625
494
    """IPv6 TCP server.  Accepts 'None' as address and/or port.
626
495
    Attributes:
627
496
        settings:       Server settings
628
497
        clients:        Set() of Client objects
629
 
        enabled:        Boolean; whether this server is activated yet
630
498
    """
631
499
    address_family = socket.AF_INET6
632
500
    def __init__(self, *args, **kwargs):
636
504
        if "clients" in kwargs:
637
505
            self.clients = kwargs["clients"]
638
506
            del kwargs["clients"]
639
 
        self.enabled = False
640
 
        super(IPv6_TCPServer, self).__init__(*args, **kwargs)
 
507
        return super(type(self), self).__init__(*args, **kwargs)
641
508
    def server_bind(self):
642
509
        """This overrides the normal server_bind() function
643
510
        to bind to an interface if one was specified, and also NOT to
651
518
                                       self.settings["interface"])
652
519
            except socket.error, error:
653
520
                if error[0] == errno.EPERM:
654
 
                    logger.error(u"No permission to"
655
 
                                 u" bind to interface %s",
656
 
                                 self.settings["interface"])
 
521
                    logger.warning(u"No permission to"
 
522
                                   u" bind to interface %s",
 
523
                                   self.settings["interface"])
657
524
                else:
658
525
                    raise error
659
526
        # Only bind(2) the socket if we really need to.
662
529
                in6addr_any = "::"
663
530
                self.server_address = (in6addr_any,
664
531
                                       self.server_address[1])
665
 
            elif not self.server_address[1]:
 
532
            elif self.server_address[1] is None:
666
533
                self.server_address = (self.server_address[0],
667
534
                                       0)
668
 
#                 if self.settings["interface"]:
669
 
#                     self.server_address = (self.server_address[0],
670
 
#                                            0, # port
671
 
#                                            0, # flowinfo
672
 
#                                            if_nametoindex
673
 
#                                            (self.settings
674
 
#                                             ["interface"]))
675
 
            return super(IPv6_TCPServer, self).server_bind()
676
 
    def server_activate(self):
677
 
        if self.enabled:
678
 
            return super(IPv6_TCPServer, self).server_activate()
679
 
    def enable(self):
680
 
        self.enabled = True
 
535
            return super(type(self), self).server_bind()
681
536
 
682
537
 
683
538
def string_to_delta(interval):
693
548
    datetime.timedelta(1)
694
549
    >>> string_to_delta(u'1w')
695
550
    datetime.timedelta(7)
696
 
    >>> string_to_delta('5m 30s')
697
 
    datetime.timedelta(0, 330)
698
551
    """
699
 
    timevalue = datetime.timedelta(0)
700
 
    for s in interval.split():
701
 
        try:
702
 
            suffix = unicode(s[-1])
703
 
            value = int(s[:-1])
704
 
            if suffix == u"d":
705
 
                delta = datetime.timedelta(value)
706
 
            elif suffix == u"s":
707
 
                delta = datetime.timedelta(0, value)
708
 
            elif suffix == u"m":
709
 
                delta = datetime.timedelta(0, 0, 0, 0, value)
710
 
            elif suffix == u"h":
711
 
                delta = datetime.timedelta(0, 0, 0, 0, 0, value)
712
 
            elif suffix == u"w":
713
 
                delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
714
 
            else:
715
 
                raise ValueError
716
 
        except (ValueError, IndexError):
 
552
    try:
 
553
        suffix=unicode(interval[-1])
 
554
        value=int(interval[:-1])
 
555
        if suffix == u"d":
 
556
            delta = datetime.timedelta(value)
 
557
        elif suffix == u"s":
 
558
            delta = datetime.timedelta(0, value)
 
559
        elif suffix == u"m":
 
560
            delta = datetime.timedelta(0, 0, 0, 0, value)
 
561
        elif suffix == u"h":
 
562
            delta = datetime.timedelta(0, 0, 0, 0, 0, value)
 
563
        elif suffix == u"w":
 
564
            delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
 
565
        else:
717
566
            raise ValueError
718
 
        timevalue += delta
719
 
    return timevalue
 
567
    except (ValueError, IndexError):
 
568
        raise ValueError
 
569
    return delta
720
570
 
721
571
 
722
572
def server_state_changed(state):
723
573
    """Derived from the Avahi example code"""
724
574
    if state == avahi.SERVER_COLLISION:
725
 
        logger.error(u"Zeroconf server name collision")
 
575
        logger.warning(u"Server name collision")
726
576
        service.remove()
727
577
    elif state == avahi.SERVER_RUNNING:
728
578
        service.add()
730
580
 
731
581
def entry_group_state_changed(state, error):
732
582
    """Derived from the Avahi example code"""
733
 
    logger.debug(u"Avahi state change: %i", state)
 
583
    logger.debug(u"state change: %i", state)
734
584
    
735
585
    if state == avahi.ENTRY_GROUP_ESTABLISHED:
736
 
        logger.debug(u"Zeroconf service established.")
 
586
        logger.debug(u"Service established.")
737
587
    elif state == avahi.ENTRY_GROUP_COLLISION:
738
 
        logger.warning(u"Zeroconf service name collision.")
 
588
        logger.warning(u"Service name collision.")
739
589
        service.rename()
740
590
    elif state == avahi.ENTRY_GROUP_FAILURE:
741
 
        logger.critical(u"Avahi: Error in group state changed %s",
 
591
        logger.critical(u"Error in group state changed %s",
742
592
                        unicode(error))
743
593
        raise AvahiGroupError("State changed: %s", str(error))
744
594
 
745
 
def if_nametoindex(interface):
 
595
def if_nametoindex(interface, _func=[None]):
746
596
    """Call the C function if_nametoindex(), or equivalent"""
747
 
    global if_nametoindex
 
597
    if _func[0] is not None:
 
598
        return _func[0](interface)
748
599
    try:
749
 
        if_nametoindex = ctypes.cdll.LoadLibrary\
750
 
            (ctypes.util.find_library("c")).if_nametoindex
 
600
        if "ctypes.util" not in sys.modules:
 
601
            import ctypes.util
 
602
        while True:
 
603
            try:
 
604
                libc = ctypes.cdll.LoadLibrary\
 
605
                       (ctypes.util.find_library("c"))
 
606
                _func[0] = libc.if_nametoindex
 
607
                return _func[0](interface)
 
608
            except IOError, e:
 
609
                if e != errno.EINTR:
 
610
                    raise
751
611
    except (OSError, AttributeError):
752
612
        if "struct" not in sys.modules:
753
613
            import struct
754
614
        if "fcntl" not in sys.modules:
755
615
            import fcntl
756
 
        def if_nametoindex(interface):
 
616
        def the_hard_way(interface):
757
617
            "Get an interface index the hard way, i.e. using fcntl()"
758
618
            SIOCGIFINDEX = 0x8933  # From /usr/include/linux/sockios.h
759
 
            with closing(socket.socket()) as s:
760
 
                ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
761
 
                                    struct.pack("16s16x", interface))
 
619
            s = socket.socket()
 
620
            ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
 
621
                                struct.pack("16s16x", interface))
 
622
            s.close()
762
623
            interface_index = struct.unpack("I", ifreq[16:20])[0]
763
624
            return interface_index
764
 
    return if_nametoindex(interface)
765
 
 
766
 
 
767
 
def daemon(nochdir = False, noclose = False):
 
625
        _func[0] = the_hard_way
 
626
        return _func[0](interface)
 
627
 
 
628
 
 
629
def daemon(nochdir, noclose):
768
630
    """See daemon(3).  Standard BSD Unix function.
769
631
    This should really exist as os.daemon, but it doesn't (yet)."""
770
632
    if os.fork():
772
634
    os.setsid()
773
635
    if not nochdir:
774
636
        os.chdir("/")
775
 
    if os.fork():
776
 
        sys.exit()
777
637
    if not noclose:
778
638
        # Close all standard open file descriptors
779
639
        null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
788
648
 
789
649
 
790
650
def main():
791
 
    parser = OptionParser(version = "%%prog %s" % version)
 
651
    global main_loop_started
 
652
    main_loop_started = False
 
653
    
 
654
    parser = OptionParser()
792
655
    parser.add_option("-i", "--interface", type="string",
793
656
                      metavar="IF", help="Bind to interface IF")
794
657
    parser.add_option("-a", "--address", type="string",
797
660
                      help="Port number to receive requests on")
798
661
    parser.add_option("--check", action="store_true", default=False,
799
662
                      help="Run self-test")
800
 
    parser.add_option("--debug", action="store_true",
 
663
    parser.add_option("--debug", action="store_true", default=False,
801
664
                      help="Debug mode; run in foreground and log to"
802
665
                      " terminal")
803
666
    parser.add_option("--priority", type="string", help="GnuTLS"
808
671
                      default="/etc/mandos", metavar="DIR",
809
672
                      help="Directory to search for configuration"
810
673
                      " files")
811
 
    options = parser.parse_args()[0]
 
674
    (options, args) = parser.parse_args()
812
675
    
813
676
    if options.check:
814
677
        import doctest
828
691
    # Parse config file for server-global settings
829
692
    server_config = ConfigParser.SafeConfigParser(server_defaults)
830
693
    del server_defaults
831
 
    server_config.read(os.path.join(options.configdir, "mandos.conf"))
 
694
    server_config.read(os.path.join(options.configdir, "server.conf"))
 
695
    server_section = "server"
832
696
    # Convert the SafeConfigParser object to a dict
833
 
    server_settings = server_config.defaults()
 
697
    server_settings = dict(server_config.items(server_section))
834
698
    # Use getboolean on the boolean config option
835
699
    server_settings["debug"] = server_config.getboolean\
836
 
                               ("DEFAULT", "debug")
 
700
                               (server_section, "debug")
837
701
    del server_config
838
702
    
839
703
    # Override the settings from the config file with command line
846
710
    del options
847
711
    # Now we have our good server settings in "server_settings"
848
712
    
849
 
    debug = server_settings["debug"]
850
 
    
851
 
    if not debug:
852
 
        syslogger.setLevel(logging.WARNING)
853
 
        console.setLevel(logging.WARNING)
854
 
    
855
 
    if server_settings["servicename"] != "Mandos":
856
 
        syslogger.setFormatter(logging.Formatter\
857
 
                               ('Mandos (%s): %%(levelname)s:'
858
 
                                ' %%(message)s'
859
 
                                % server_settings["servicename"]))
860
 
    
861
713
    # Parse config file with clients
862
714
    client_defaults = { "timeout": "1h",
863
715
                        "interval": "5m",
864
 
                        "checker": "fping -q -- %(host)s",
865
 
                        "host": "",
 
716
                        "checker": "fping -q -- %%(fqdn)s",
866
717
                        }
867
718
    client_config = ConfigParser.SafeConfigParser(client_defaults)
868
719
    client_config.read(os.path.join(server_settings["configdir"],
869
720
                                    "clients.conf"))
870
721
    
871
 
    clients = Set()
872
 
    tcp_server = IPv6_TCPServer((server_settings["address"],
873
 
                                 server_settings["port"]),
874
 
                                TCP_handler,
875
 
                                settings=server_settings,
876
 
                                clients=clients)
877
 
    pidfilename = "/var/run/mandos.pid"
878
 
    try:
879
 
        pidfile = open(pidfilename, "w")
880
 
    except IOError, error:
881
 
        logger.error("Could not open file %r", pidfilename)
882
 
    
883
 
    uid = 65534
884
 
    gid = 65534
885
 
    try:
886
 
        uid = pwd.getpwnam("mandos").pw_uid
887
 
    except KeyError:
888
 
        try:
889
 
            uid = pwd.getpwnam("nobody").pw_uid
890
 
        except KeyError:
891
 
            pass
892
 
    try:
893
 
        gid = pwd.getpwnam("mandos").pw_gid
894
 
    except KeyError:
895
 
        try:
896
 
            gid = pwd.getpwnam("nogroup").pw_gid
897
 
        except KeyError:
898
 
            pass
899
 
    try:
900
 
        os.setuid(uid)
901
 
        os.setgid(gid)
902
 
    except OSError, error:
903
 
        if error[0] != errno.EPERM:
904
 
            raise error
905
 
    
906
722
    global service
907
723
    service = AvahiService(name = server_settings["servicename"],
908
 
                           servicetype = "_mandos._tcp", )
 
724
                           type = "_mandos._tcp", );
909
725
    if server_settings["interface"]:
910
 
        service.interface = if_nametoindex\
911
 
                            (server_settings["interface"])
 
726
        service.interface = if_nametoindex(server_settings["interface"])
912
727
    
913
728
    global main_loop
914
729
    global bus
917
732
    DBusGMainLoop(set_as_default=True )
918
733
    main_loop = gobject.MainLoop()
919
734
    bus = dbus.SystemBus()
920
 
    server = dbus.Interface(bus.get_object(avahi.DBUS_NAME,
921
 
                                           avahi.DBUS_PATH_SERVER),
922
 
                            avahi.DBUS_INTERFACE_SERVER)
 
735
    server = dbus.Interface(
 
736
            bus.get_object( avahi.DBUS_NAME, avahi.DBUS_PATH_SERVER ),
 
737
            avahi.DBUS_INTERFACE_SERVER )
923
738
    # End of Avahi example code
924
739
    
 
740
    debug = server_settings["debug"]
 
741
    
 
742
    if debug:
 
743
        console = logging.StreamHandler()
 
744
        # console.setLevel(logging.DEBUG)
 
745
        console.setFormatter(logging.Formatter\
 
746
                             ('%(levelname)s: %(message)s'))
 
747
        logger.addHandler(console)
 
748
        del console
 
749
    
 
750
    clients = Set()
925
751
    def remove_from_clients(client):
926
752
        clients.remove(client)
927
753
        if not clients:
928
 
            logger.critical(u"No clients left, exiting")
 
754
            logger.debug(u"No clients left, exiting")
929
755
            sys.exit()
930
756
    
931
 
    clients.update(Set(Client(name = section,
 
757
    clients.update(Set(Client(name=section,
932
758
                              stop_hook = remove_from_clients,
933
 
                              config
934
 
                              = dict(client_config.items(section)))
 
759
                              **(dict(client_config\
 
760
                                      .items(section))))
935
761
                       for section in client_config.sections()))
936
 
    if not clients:
937
 
        logger.critical(u"No clients defined")
938
 
        sys.exit(1)
939
 
    
940
 
    if debug:
941
 
        # Redirect stdin so all checkers get /dev/null
942
 
        null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
943
 
        os.dup2(null, sys.stdin.fileno())
944
 
        if null > 2:
945
 
            os.close(null)
946
 
    else:
947
 
        # No console logging
948
 
        logger.removeHandler(console)
949
 
        # Close all input and output, do double fork, etc.
950
 
        daemon()
951
 
    
952
 
    try:
953
 
        pid = os.getpid()
954
 
        pidfile.write(str(pid) + "\n")
955
 
        pidfile.close()
956
 
        del pidfile
957
 
    except IOError:
958
 
        logger.error(u"Could not write to file %r with PID %d",
959
 
                     pidfilename, pid)
960
 
    except NameError:
961
 
        # "pidfile" was never created
962
 
        pass
963
 
    del pidfilename
 
762
    
 
763
    if not debug:
 
764
        daemon(False, False)
964
765
    
965
766
    def cleanup():
966
767
        "Cleanup function; run on exit"
986
787
    for client in clients:
987
788
        client.start()
988
789
    
989
 
    tcp_server.enable()
990
 
    tcp_server.server_activate()
991
 
    
 
790
    tcp_server = IPv6_TCPServer((server_settings["address"],
 
791
                                 server_settings["port"]),
 
792
                                tcp_handler,
 
793
                                settings=server_settings,
 
794
                                clients=clients)
992
795
    # Find out what port we got
993
796
    service.port = tcp_server.socket.getsockname()[1]
994
 
    logger.info(u"Now listening on address %r, port %d, flowinfo %d,"
995
 
                u" scope_id %d" % tcp_server.socket.getsockname())
 
797
    logger.debug(u"Now listening on address %r, port %d, flowinfo %d,"
 
798
                 u" scope_id %d" % tcp_server.socket.getsockname())
996
799
    
997
800
    #service.interface = tcp_server.socket.getsockname()[3]
998
801
    
1011
814
                             tcp_server.handle_request\
1012
815
                             (*args[2:], **kwargs) or True)
1013
816
        
1014
 
        logger.debug(u"Starting main loop")
 
817
        logger.debug("Starting main loop")
 
818
        main_loop_started = True
1015
819
        main_loop.run()
1016
820
    except AvahiError, error:
1017
821
        logger.critical(u"AvahiError: %s" + unicode(error))