/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: 2012-05-17 01:55:58 UTC
  • Revision ID: teddy@recompile.se-20120517015558-5703p8nkquc2rhgd
* .bzrignore (statedir): Added.

Show diffs side-by-side

added added

removed removed

Lines of Context:
mandos
1
1
#!/usr/bin/python
2
 
 
3
 
from __future__ import division
4
 
 
5
 
import SocketServer
 
2
# -*- mode: python; coding: utf-8 -*-
 
3
# 
 
4
# Mandos server - give out binary blobs to connecting clients.
 
5
# 
 
6
# This program is partly derived from an example program for an Avahi
 
7
# service publisher, downloaded from
 
8
# <http://avahi.org/wiki/PythonPublishExample>.  This includes the
 
9
# methods "add", "remove", "server_state_changed",
 
10
# "entry_group_state_changed", "cleanup", and "activate" in the
 
11
# "AvahiService" class, and some lines in "main".
 
12
# 
 
13
# Everything else is
 
14
# Copyright © 2008-2012 Teddy Hogeborn
 
15
# Copyright © 2008-2012 Björn Påhlsson
 
16
# 
 
17
# This program is free software: you can redistribute it and/or modify
 
18
# it under the terms of the GNU General Public License as published by
 
19
# the Free Software Foundation, either version 3 of the License, or
 
20
# (at your option) any later version.
 
21
#
 
22
#     This program is distributed in the hope that it will be useful,
 
23
#     but WITHOUT ANY WARRANTY; without even the implied warranty of
 
24
#     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
25
#     GNU General Public License for more details.
 
26
# 
 
27
# You should have received a copy of the GNU General Public License
 
28
# along with this program.  If not, see
 
29
# <http://www.gnu.org/licenses/>.
 
30
# 
 
31
# Contact the authors at <mandos@recompile.se>.
 
32
# 
 
33
 
 
34
from __future__ import (division, absolute_import, print_function,
 
35
                        unicode_literals)
 
36
 
 
37
from future_builtins import *
 
38
 
 
39
import SocketServer as socketserver
6
40
import socket
7
 
import select
8
 
from optparse import OptionParser
 
41
import argparse
9
42
import datetime
10
43
import errno
11
44
import gnutls.crypto
14
47
import gnutls.library.functions
15
48
import gnutls.library.constants
16
49
import gnutls.library.types
17
 
import ConfigParser
 
50
import ConfigParser as configparser
18
51
import sys
19
52
import re
20
53
import os
21
54
import signal
22
 
from sets import Set
23
55
import subprocess
 
56
import atexit
 
57
import stat
 
58
import logging
 
59
import logging.handlers
 
60
import pwd
 
61
import contextlib
 
62
import struct
 
63
import fcntl
 
64
import functools
 
65
import cPickle as pickle
 
66
import multiprocessing
 
67
import types
 
68
import binascii
 
69
import tempfile
 
70
import itertools
24
71
 
25
72
import dbus
 
73
import dbus.service
26
74
import gobject
27
75
import avahi
28
76
from dbus.mainloop.glib import DBusGMainLoop
29
77
import ctypes
30
 
 
31
 
import logging
32
 
import logging.handlers
33
 
 
34
 
# logghandler.setFormatter(logging.Formatter('%(levelname)s %(message)s')
35
 
 
36
 
logger = logging.Logger('mandos')
37
 
logger.addHandler(logging.handlers.SysLogHandler(facility = logging.handlers.SysLogHandler.LOG_DAEMON))
38
 
 
39
 
# This variable is used to optionally bind to a specified interface.
40
 
# It is a global variable to fit in with the other variables from the
41
 
# Avahi server example code.
42
 
serviceInterface = avahi.IF_UNSPEC
43
 
# From the Avahi server example code:
44
 
serviceName = "Mandos"
45
 
serviceType = "_mandos._tcp" # http://www.dns-sd.org/ServiceTypes.html
46
 
servicePort = None                      # Not known at startup
47
 
serviceTXT = []                         # TXT record for the service
48
 
domain = ""                  # Domain to publish on, default to .local
49
 
host = ""          # Host to publish records for, default to localhost
50
 
group = None #our entry group
51
 
rename_count = 12       # Counter so we only rename after collisions a
52
 
                        # sensible number of times
53
 
# End of Avahi example code
 
78
import ctypes.util
 
79
import xml.dom.minidom
 
80
import inspect
 
81
import GnuPGInterface
 
82
 
 
83
try:
 
84
    SO_BINDTODEVICE = socket.SO_BINDTODEVICE
 
85
except AttributeError:
 
86
    try:
 
87
        from IN import SO_BINDTODEVICE
 
88
    except ImportError:
 
89
        SO_BINDTODEVICE = None
 
90
 
 
91
version = "1.5.3"
 
92
stored_state_file = "clients.pickle"
 
93
 
 
94
logger = logging.getLogger()
 
95
syslogger = (logging.handlers.SysLogHandler
 
96
             (facility = logging.handlers.SysLogHandler.LOG_DAEMON,
 
97
              address = str("/dev/log")))
 
98
 
 
99
try:
 
100
    if_nametoindex = (ctypes.cdll.LoadLibrary
 
101
                      (ctypes.util.find_library("c"))
 
102
                      .if_nametoindex)
 
103
except (OSError, AttributeError):
 
104
    def if_nametoindex(interface):
 
105
        "Get an interface index the hard way, i.e. using fcntl()"
 
106
        SIOCGIFINDEX = 0x8933  # From /usr/include/linux/sockios.h
 
107
        with contextlib.closing(socket.socket()) as s:
 
108
            ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
 
109
                                struct.pack(str("16s16x"),
 
110
                                            interface))
 
111
        interface_index = struct.unpack(str("I"),
 
112
                                        ifreq[16:20])[0]
 
113
        return interface_index
 
114
 
 
115
 
 
116
def initlogger(debug, level=logging.WARNING):
 
117
    """init logger and add loglevel"""
 
118
    
 
119
    syslogger.setFormatter(logging.Formatter
 
120
                           ('Mandos [%(process)d]: %(levelname)s:'
 
121
                            ' %(message)s'))
 
122
    logger.addHandler(syslogger)
 
123
    
 
124
    if debug:
 
125
        console = logging.StreamHandler()
 
126
        console.setFormatter(logging.Formatter('%(asctime)s %(name)s'
 
127
                                               ' [%(process)d]:'
 
128
                                               ' %(levelname)s:'
 
129
                                               ' %(message)s'))
 
130
        logger.addHandler(console)
 
131
    logger.setLevel(level)
 
132
 
 
133
 
 
134
class PGPError(Exception):
 
135
    """Exception if encryption/decryption fails"""
 
136
    pass
 
137
 
 
138
 
 
139
class PGPEngine(object):
 
140
    """A simple class for OpenPGP symmetric encryption & decryption"""
 
141
    def __init__(self):
 
142
        self.gnupg = GnuPGInterface.GnuPG()
 
143
        self.tempdir = tempfile.mkdtemp(prefix="mandos-")
 
144
        self.gnupg = GnuPGInterface.GnuPG()
 
145
        self.gnupg.options.meta_interactive = False
 
146
        self.gnupg.options.homedir = self.tempdir
 
147
        self.gnupg.options.extra_args.extend(['--force-mdc',
 
148
                                              '--quiet',
 
149
                                              '--no-use-agent'])
 
150
    
 
151
    def __enter__(self):
 
152
        return self
 
153
    
 
154
    def __exit__ (self, exc_type, exc_value, traceback):
 
155
        self._cleanup()
 
156
        return False
 
157
    
 
158
    def __del__(self):
 
159
        self._cleanup()
 
160
    
 
161
    def _cleanup(self):
 
162
        if self.tempdir is not None:
 
163
            # Delete contents of tempdir
 
164
            for root, dirs, files in os.walk(self.tempdir,
 
165
                                             topdown = False):
 
166
                for filename in files:
 
167
                    os.remove(os.path.join(root, filename))
 
168
                for dirname in dirs:
 
169
                    os.rmdir(os.path.join(root, dirname))
 
170
            # Remove tempdir
 
171
            os.rmdir(self.tempdir)
 
172
            self.tempdir = None
 
173
    
 
174
    def password_encode(self, password):
 
175
        # Passphrase can not be empty and can not contain newlines or
 
176
        # NUL bytes.  So we prefix it and hex encode it.
 
177
        return b"mandos" + binascii.hexlify(password)
 
178
    
 
179
    def encrypt(self, data, password):
 
180
        self.gnupg.passphrase = self.password_encode(password)
 
181
        with open(os.devnull, "w") as devnull:
 
182
            try:
 
183
                proc = self.gnupg.run(['--symmetric'],
 
184
                                      create_fhs=['stdin', 'stdout'],
 
185
                                      attach_fhs={'stderr': devnull})
 
186
                with contextlib.closing(proc.handles['stdin']) as f:
 
187
                    f.write(data)
 
188
                with contextlib.closing(proc.handles['stdout']) as f:
 
189
                    ciphertext = f.read()
 
190
                proc.wait()
 
191
            except IOError as e:
 
192
                raise PGPError(e)
 
193
        self.gnupg.passphrase = None
 
194
        return ciphertext
 
195
    
 
196
    def decrypt(self, data, password):
 
197
        self.gnupg.passphrase = self.password_encode(password)
 
198
        with open(os.devnull, "w") as devnull:
 
199
            try:
 
200
                proc = self.gnupg.run(['--decrypt'],
 
201
                                      create_fhs=['stdin', 'stdout'],
 
202
                                      attach_fhs={'stderr': devnull})
 
203
                with contextlib.closing(proc.handles['stdin']) as f:
 
204
                    f.write(data)
 
205
                with contextlib.closing(proc.handles['stdout']) as f:
 
206
                    decrypted_plaintext = f.read()
 
207
                proc.wait()
 
208
            except IOError as e:
 
209
                raise PGPError(e)
 
210
        self.gnupg.passphrase = None
 
211
        return decrypted_plaintext
 
212
 
 
213
 
 
214
class AvahiError(Exception):
 
215
    def __init__(self, value, *args, **kwargs):
 
216
        self.value = value
 
217
        super(AvahiError, self).__init__(value, *args, **kwargs)
 
218
    def __unicode__(self):
 
219
        return unicode(repr(self.value))
 
220
 
 
221
class AvahiServiceError(AvahiError):
 
222
    pass
 
223
 
 
224
class AvahiGroupError(AvahiError):
 
225
    pass
 
226
 
 
227
 
 
228
class AvahiService(object):
 
229
    """An Avahi (Zeroconf) service.
 
230
    
 
231
    Attributes:
 
232
    interface: integer; avahi.IF_UNSPEC or an interface index.
 
233
               Used to optionally bind to the specified interface.
 
234
    name: string; Example: 'Mandos'
 
235
    type: string; Example: '_mandos._tcp'.
 
236
                  See <http://www.dns-sd.org/ServiceTypes.html>
 
237
    port: integer; what port to announce
 
238
    TXT: list of strings; TXT record for the service
 
239
    domain: string; Domain to publish on, default to .local if empty.
 
240
    host: string; Host to publish records for, default is localhost
 
241
    max_renames: integer; maximum number of renames
 
242
    rename_count: integer; counter so we only rename after collisions
 
243
                  a sensible number of times
 
244
    group: D-Bus Entry Group
 
245
    server: D-Bus Server
 
246
    bus: dbus.SystemBus()
 
247
    """
 
248
    
 
249
    def __init__(self, interface = avahi.IF_UNSPEC, name = None,
 
250
                 servicetype = None, port = None, TXT = None,
 
251
                 domain = "", host = "", max_renames = 32768,
 
252
                 protocol = avahi.PROTO_UNSPEC, bus = None):
 
253
        self.interface = interface
 
254
        self.name = name
 
255
        self.type = servicetype
 
256
        self.port = port
 
257
        self.TXT = TXT if TXT is not None else []
 
258
        self.domain = domain
 
259
        self.host = host
 
260
        self.rename_count = 0
 
261
        self.max_renames = max_renames
 
262
        self.protocol = protocol
 
263
        self.group = None       # our entry group
 
264
        self.server = None
 
265
        self.bus = bus
 
266
        self.entry_group_state_changed_match = None
 
267
    
 
268
    def rename(self):
 
269
        """Derived from the Avahi example code"""
 
270
        if self.rename_count >= self.max_renames:
 
271
            logger.critical("No suitable Zeroconf service name found"
 
272
                            " after %i retries, exiting.",
 
273
                            self.rename_count)
 
274
            raise AvahiServiceError("Too many renames")
 
275
        self.name = unicode(self.server
 
276
                            .GetAlternativeServiceName(self.name))
 
277
        logger.info("Changing Zeroconf service name to %r ...",
 
278
                    self.name)
 
279
        self.remove()
 
280
        try:
 
281
            self.add()
 
282
        except dbus.exceptions.DBusException as error:
 
283
            logger.critical("D-Bus Exception", exc_info=error)
 
284
            self.cleanup()
 
285
            os._exit(1)
 
286
        self.rename_count += 1
 
287
    
 
288
    def remove(self):
 
289
        """Derived from the Avahi example code"""
 
290
        if self.entry_group_state_changed_match is not None:
 
291
            self.entry_group_state_changed_match.remove()
 
292
            self.entry_group_state_changed_match = None
 
293
        if self.group is not None:
 
294
            self.group.Reset()
 
295
    
 
296
    def add(self):
 
297
        """Derived from the Avahi example code"""
 
298
        self.remove()
 
299
        if self.group is None:
 
300
            self.group = dbus.Interface(
 
301
                self.bus.get_object(avahi.DBUS_NAME,
 
302
                                    self.server.EntryGroupNew()),
 
303
                avahi.DBUS_INTERFACE_ENTRY_GROUP)
 
304
        self.entry_group_state_changed_match = (
 
305
            self.group.connect_to_signal(
 
306
                'StateChanged', self.entry_group_state_changed))
 
307
        logger.debug("Adding Zeroconf service '%s' of type '%s' ...",
 
308
                     self.name, self.type)
 
309
        self.group.AddService(
 
310
            self.interface,
 
311
            self.protocol,
 
312
            dbus.UInt32(0),     # flags
 
313
            self.name, self.type,
 
314
            self.domain, self.host,
 
315
            dbus.UInt16(self.port),
 
316
            avahi.string_array_to_txt_array(self.TXT))
 
317
        self.group.Commit()
 
318
    
 
319
    def entry_group_state_changed(self, state, error):
 
320
        """Derived from the Avahi example code"""
 
321
        logger.debug("Avahi entry group state change: %i", state)
 
322
        
 
323
        if state == avahi.ENTRY_GROUP_ESTABLISHED:
 
324
            logger.debug("Zeroconf service established.")
 
325
        elif state == avahi.ENTRY_GROUP_COLLISION:
 
326
            logger.info("Zeroconf service name collision.")
 
327
            self.rename()
 
328
        elif state == avahi.ENTRY_GROUP_FAILURE:
 
329
            logger.critical("Avahi: Error in group state changed %s",
 
330
                            unicode(error))
 
331
            raise AvahiGroupError("State changed: {0!s}"
 
332
                                  .format(error))
 
333
    
 
334
    def cleanup(self):
 
335
        """Derived from the Avahi example code"""
 
336
        if self.group is not None:
 
337
            try:
 
338
                self.group.Free()
 
339
            except (dbus.exceptions.UnknownMethodException,
 
340
                    dbus.exceptions.DBusException):
 
341
                pass
 
342
            self.group = None
 
343
        self.remove()
 
344
    
 
345
    def server_state_changed(self, state, error=None):
 
346
        """Derived from the Avahi example code"""
 
347
        logger.debug("Avahi server state change: %i", state)
 
348
        bad_states = { avahi.SERVER_INVALID:
 
349
                           "Zeroconf server invalid",
 
350
                       avahi.SERVER_REGISTERING: None,
 
351
                       avahi.SERVER_COLLISION:
 
352
                           "Zeroconf server name collision",
 
353
                       avahi.SERVER_FAILURE:
 
354
                           "Zeroconf server failure" }
 
355
        if state in bad_states:
 
356
            if bad_states[state] is not None:
 
357
                if error is None:
 
358
                    logger.error(bad_states[state])
 
359
                else:
 
360
                    logger.error(bad_states[state] + ": %r", error)
 
361
            self.cleanup()
 
362
        elif state == avahi.SERVER_RUNNING:
 
363
            self.add()
 
364
        else:
 
365
            if error is None:
 
366
                logger.debug("Unknown state: %r", state)
 
367
            else:
 
368
                logger.debug("Unknown state: %r: %r", state, error)
 
369
    
 
370
    def activate(self):
 
371
        """Derived from the Avahi example code"""
 
372
        if self.server is None:
 
373
            self.server = dbus.Interface(
 
374
                self.bus.get_object(avahi.DBUS_NAME,
 
375
                                    avahi.DBUS_PATH_SERVER,
 
376
                                    follow_name_owner_changes=True),
 
377
                avahi.DBUS_INTERFACE_SERVER)
 
378
        self.server.connect_to_signal("StateChanged",
 
379
                                 self.server_state_changed)
 
380
        self.server_state_changed(self.server.GetState())
 
381
 
 
382
 
 
383
class AvahiServiceToSyslog(AvahiService):
 
384
    def rename(self):
 
385
        """Add the new name to the syslog messages"""
 
386
        ret = AvahiService.rename(self)
 
387
        syslogger.setFormatter(logging.Formatter
 
388
                               ('Mandos ({0}) [%(process)d]:'
 
389
                                ' %(levelname)s: %(message)s'
 
390
                                .format(self.name)))
 
391
        return ret
 
392
 
 
393
 
 
394
def timedelta_to_milliseconds(td):
 
395
    "Convert a datetime.timedelta() to milliseconds"
 
396
    return ((td.days * 24 * 60 * 60 * 1000)
 
397
            + (td.seconds * 1000)
 
398
            + (td.microseconds // 1000))
54
399
 
55
400
 
56
401
class Client(object):
57
402
    """A representation of a client host served by this server.
 
403
    
58
404
    Attributes:
59
 
    name:      string; from the config file, used in log messages
 
405
    approved:   bool(); 'None' if not yet approved/disapproved
 
406
    approval_delay: datetime.timedelta(); Time to wait for approval
 
407
    approval_duration: datetime.timedelta(); Duration of one approval
 
408
    checker:    subprocess.Popen(); a running checker process used
 
409
                                    to see if the client lives.
 
410
                                    'None' if no process is running.
 
411
    checker_callback_tag: a gobject event source tag, or None
 
412
    checker_command: string; External command which is run to check
 
413
                     if client lives.  %() expansions are done at
 
414
                     runtime with vars(self) as dict, so that for
 
415
                     instance %(name)s can be used in the command.
 
416
    checker_initiator_tag: a gobject event source tag, or None
 
417
    created:    datetime.datetime(); (UTC) object creation
 
418
    client_structure: Object describing what attributes a client has
 
419
                      and is used for storing the client at exit
 
420
    current_checker_command: string; current running checker_command
 
421
    disable_initiator_tag: a gobject event source tag, or None
 
422
    enabled:    bool()
60
423
    fingerprint: string (40 or 32 hexadecimal digits); used to
61
424
                 uniquely identify the client
62
 
    secret:    bytestring; sent verbatim (over TLS) to client
63
 
    fqdn:      string (FQDN); available for use by the checker command
64
 
    created:   datetime.datetime()
65
 
    last_seen: datetime.datetime() or None if not yet seen
66
 
    timeout:   datetime.timedelta(); How long from last_seen until
67
 
                                     this client is invalid
68
 
    interval:  datetime.timedelta(); How often to start a new checker
69
 
    stop_hook: If set, called by stop() as stop_hook(self)
70
 
    checker:   subprocess.Popen(); a running checker process used
71
 
                                   to see if the client lives.
72
 
                                   Is None if no process is running.
73
 
    checker_initiator_tag: a gobject event source tag, or None
74
 
    stop_initiator_tag:    - '' -
75
 
    checker_callback_tag:  - '' -
76
 
    checker_command: string; External command which is run to check if
77
 
                     client lives.  %()s expansions are done at
78
 
                     runtime with vars(self) as dict, so that for
79
 
                     instance %(name)s can be used in the command.
80
 
    Private attibutes:
81
 
    _timeout: Real variable for 'timeout'
82
 
    _interval: Real variable for 'interval'
83
 
    _timeout_milliseconds: Used by gobject.timeout_add()
84
 
    _interval_milliseconds: - '' -
 
425
    host:       string; available for use by the checker command
 
426
    interval:   datetime.timedelta(); How often to start a new checker
 
427
    last_approval_request: datetime.datetime(); (UTC) or None
 
428
    last_checked_ok: datetime.datetime(); (UTC) or None
 
429
    last_checker_status: integer between 0 and 255 reflecting exit
 
430
                         status of last checker. -1 reflects crashed
 
431
                         checker, -2 means no checker completed yet.
 
432
    last_enabled: datetime.datetime(); (UTC) or None
 
433
    name:       string; from the config file, used in log messages and
 
434
                        D-Bus identifiers
 
435
    secret:     bytestring; sent verbatim (over TLS) to client
 
436
    timeout:    datetime.timedelta(); How long from last_checked_ok
 
437
                                      until this client is disabled
 
438
    extended_timeout:   extra long timeout when secret has been sent
 
439
    runtime_expansions: Allowed attributes for runtime expansion.
 
440
    expires:    datetime.datetime(); time (UTC) when a client will be
 
441
                disabled, or None
85
442
    """
86
 
    def _set_timeout(self, timeout):
87
 
        "Setter function for 'timeout' attribute"
88
 
        self._timeout = timeout
89
 
        self._timeout_milliseconds = ((self.timeout.days
90
 
                                       * 24 * 60 * 60 * 1000)
91
 
                                      + (self.timeout.seconds * 1000)
92
 
                                      + (self.timeout.microseconds
93
 
                                         // 1000))
94
 
    timeout = property(lambda self: self._timeout,
95
 
                       _set_timeout)
96
 
    del _set_timeout
97
 
    def _set_interval(self, interval):
98
 
        "Setter function for 'interval' attribute"
99
 
        self._interval = interval
100
 
        self._interval_milliseconds = ((self.interval.days
101
 
                                        * 24 * 60 * 60 * 1000)
102
 
                                       + (self.interval.seconds
103
 
                                          * 1000)
104
 
                                       + (self.interval.microseconds
105
 
                                          // 1000))
106
 
    interval = property(lambda self: self._interval,
107
 
                        _set_interval)
108
 
    del _set_interval
109
 
    def __init__(self, name=None, options=None, stop_hook=None,
110
 
                 fingerprint=None, secret=None, secfile=None, fqdn=None,
111
 
                 timeout=None, interval=-1, checker=None):
 
443
    
 
444
    runtime_expansions = ("approval_delay", "approval_duration",
 
445
                          "created", "enabled", "expires",
 
446
                          "fingerprint", "host", "interval",
 
447
                          "last_approval_request", "last_checked_ok",
 
448
                          "last_enabled", "name", "timeout")
 
449
    client_defaults = { "timeout": "5m",
 
450
                        "extended_timeout": "15m",
 
451
                        "interval": "2m",
 
452
                        "checker": "fping -q -- %%(host)s",
 
453
                        "host": "",
 
454
                        "approval_delay": "0s",
 
455
                        "approval_duration": "1s",
 
456
                        "approved_by_default": "True",
 
457
                        "enabled": "True",
 
458
                        }
 
459
    
 
460
    def timeout_milliseconds(self):
 
461
        "Return the 'timeout' attribute in milliseconds"
 
462
        return timedelta_to_milliseconds(self.timeout)
 
463
    
 
464
    def extended_timeout_milliseconds(self):
 
465
        "Return the 'extended_timeout' attribute in milliseconds"
 
466
        return timedelta_to_milliseconds(self.extended_timeout)
 
467
    
 
468
    def interval_milliseconds(self):
 
469
        "Return the 'interval' attribute in milliseconds"
 
470
        return timedelta_to_milliseconds(self.interval)
 
471
    
 
472
    def approval_delay_milliseconds(self):
 
473
        return timedelta_to_milliseconds(self.approval_delay)
 
474
    
 
475
    @staticmethod
 
476
    def config_parser(config):
 
477
        """Construct a new dict of client settings of this form:
 
478
        { client_name: {setting_name: value, ...}, ...}
 
479
        with exceptions for any special settings as defined above.
 
480
        NOTE: Must be a pure function. Must return the same result
 
481
        value given the same arguments.
 
482
        """
 
483
        settings = {}
 
484
        for client_name in config.sections():
 
485
            section = dict(config.items(client_name))
 
486
            client = settings[client_name] = {}
 
487
            
 
488
            client["host"] = section["host"]
 
489
            # Reformat values from string types to Python types
 
490
            client["approved_by_default"] = config.getboolean(
 
491
                client_name, "approved_by_default")
 
492
            client["enabled"] = config.getboolean(client_name,
 
493
                                                  "enabled")
 
494
            
 
495
            client["fingerprint"] = (section["fingerprint"].upper()
 
496
                                     .replace(" ", ""))
 
497
            if "secret" in section:
 
498
                client["secret"] = section["secret"].decode("base64")
 
499
            elif "secfile" in section:
 
500
                with open(os.path.expanduser(os.path.expandvars
 
501
                                             (section["secfile"])),
 
502
                          "rb") as secfile:
 
503
                    client["secret"] = secfile.read()
 
504
            else:
 
505
                raise TypeError("No secret or secfile for section {0}"
 
506
                                .format(section))
 
507
            client["timeout"] = string_to_delta(section["timeout"])
 
508
            client["extended_timeout"] = string_to_delta(
 
509
                section["extended_timeout"])
 
510
            client["interval"] = string_to_delta(section["interval"])
 
511
            client["approval_delay"] = string_to_delta(
 
512
                section["approval_delay"])
 
513
            client["approval_duration"] = string_to_delta(
 
514
                section["approval_duration"])
 
515
            client["checker_command"] = section["checker"]
 
516
            client["last_approval_request"] = None
 
517
            client["last_checked_ok"] = None
 
518
            client["last_checker_status"] = -2
 
519
        
 
520
        return settings
 
521
    
 
522
    def __init__(self, settings, name = None):
112
523
        self.name = name
113
 
        # Uppercase and remove spaces from fingerprint
114
 
        # for later comparison purposes with return value of
115
 
        # the fingerprint() function
116
 
        self.fingerprint = fingerprint.upper().replace(u" ", u"")
117
 
        if secret:
118
 
            self.secret = secret.decode(u"base64")
119
 
        elif secfile:
120
 
            sf = open(secfile)
121
 
            self.secret = sf.read()
122
 
            sf.close()
123
 
        else:
124
 
            raise RuntimeError(u"No secret or secfile for client %s"
125
 
                               % self.name)
126
 
        self.fqdn = fqdn                # string
127
 
        self.created = datetime.datetime.now()
128
 
        self.last_seen = None
129
 
        if timeout is None:
130
 
            timeout = options.timeout
131
 
        self.timeout = timeout
132
 
        if interval == -1:
133
 
            interval = options.interval
134
 
        else:
135
 
            interval = string_to_delta(interval)
136
 
        self.interval = interval
137
 
        self.stop_hook = stop_hook
 
524
        # adding all client settings
 
525
        for setting, value in settings.iteritems():
 
526
            setattr(self, setting, value)
 
527
        
 
528
        if self.enabled:
 
529
            if not hasattr(self, "last_enabled"):
 
530
                self.last_enabled = datetime.datetime.utcnow()
 
531
            if not hasattr(self, "expires"):
 
532
                self.expires = (datetime.datetime.utcnow()
 
533
                                + self.timeout)
 
534
        else:
 
535
            self.last_enabled = None
 
536
            self.expires = None
 
537
        
 
538
        logger.debug("Creating client %r", self.name)
 
539
        # Uppercase and remove spaces from fingerprint for later
 
540
        # comparison purposes with return value from the fingerprint()
 
541
        # function
 
542
        logger.debug("  Fingerprint: %s", self.fingerprint)
 
543
        self.created = settings.get("created",
 
544
                                    datetime.datetime.utcnow())
 
545
        
 
546
        # attributes specific for this server instance
138
547
        self.checker = None
139
548
        self.checker_initiator_tag = None
140
 
        self.stop_initiator_tag = None
 
549
        self.disable_initiator_tag = None
141
550
        self.checker_callback_tag = None
142
 
        self.check_command = checker
143
 
    def start(self):
144
 
        """Start this clients checker and timeout hooks"""
 
551
        self.current_checker_command = None
 
552
        self.approved = None
 
553
        self.approvals_pending = 0
 
554
        self.changedstate = (multiprocessing_manager
 
555
                             .Condition(multiprocessing_manager
 
556
                                        .Lock()))
 
557
        self.client_structure = [attr for attr in
 
558
                                 self.__dict__.iterkeys()
 
559
                                 if not attr.startswith("_")]
 
560
        self.client_structure.append("client_structure")
 
561
        
 
562
        for name, t in inspect.getmembers(type(self),
 
563
                                          lambda obj:
 
564
                                              isinstance(obj,
 
565
                                                         property)):
 
566
            if not name.startswith("_"):
 
567
                self.client_structure.append(name)
 
568
    
 
569
    # Send notice to process children that client state has changed
 
570
    def send_changedstate(self):
 
571
        with self.changedstate:
 
572
            self.changedstate.notify_all()
 
573
    
 
574
    def enable(self):
 
575
        """Start this client's checker and timeout hooks"""
 
576
        if getattr(self, "enabled", False):
 
577
            # Already enabled
 
578
            return
 
579
        self.expires = datetime.datetime.utcnow() + self.timeout
 
580
        self.enabled = True
 
581
        self.last_enabled = datetime.datetime.utcnow()
 
582
        self.init_checker()
 
583
        self.send_changedstate()
 
584
    
 
585
    def disable(self, quiet=True):
 
586
        """Disable this client."""
 
587
        if not getattr(self, "enabled", False):
 
588
            return False
 
589
        if not quiet:
 
590
            logger.info("Disabling client %s", self.name)
 
591
        if getattr(self, "disable_initiator_tag", None) is not None:
 
592
            gobject.source_remove(self.disable_initiator_tag)
 
593
            self.disable_initiator_tag = None
 
594
        self.expires = None
 
595
        if getattr(self, "checker_initiator_tag", None) is not None:
 
596
            gobject.source_remove(self.checker_initiator_tag)
 
597
            self.checker_initiator_tag = None
 
598
        self.stop_checker()
 
599
        self.enabled = False
 
600
        if not quiet:
 
601
            self.send_changedstate()
 
602
        # Do not run this again if called by a gobject.timeout_add
 
603
        return False
 
604
    
 
605
    def __del__(self):
 
606
        self.disable()
 
607
    
 
608
    def init_checker(self):
145
609
        # Schedule a new checker to be started an 'interval' from now,
146
610
        # and every interval from then on.
147
 
        self.checker_initiator_tag = gobject.timeout_add\
148
 
                                     (self._interval_milliseconds,
149
 
                                      self.start_checker)
 
611
        if self.checker_initiator_tag is not None:
 
612
            gobject.source_remove(self.checker_initiator_tag)
 
613
        self.checker_initiator_tag = (gobject.timeout_add
 
614
                                      (self.interval_milliseconds(),
 
615
                                       self.start_checker))
 
616
        # Schedule a disable() when 'timeout' has passed
 
617
        if self.disable_initiator_tag is not None:
 
618
            gobject.source_remove(self.disable_initiator_tag)
 
619
        self.disable_initiator_tag = (gobject.timeout_add
 
620
                                   (self.timeout_milliseconds(),
 
621
                                    self.disable))
150
622
        # Also start a new checker *right now*.
151
623
        self.start_checker()
152
 
        # Schedule a stop() when 'timeout' has passed
153
 
        self.stop_initiator_tag = gobject.timeout_add\
154
 
                                  (self._timeout_milliseconds,
155
 
                                   self.stop)
156
 
    def stop(self):
157
 
        """Stop this client.
158
 
        The possibility that this client might be restarted is left
159
 
        open, but not currently used."""
160
 
        logger.debug(u"Stopping client %s", self.name)
161
 
        self.secret = None
162
 
        if self.stop_initiator_tag:
163
 
            gobject.source_remove(self.stop_initiator_tag)
164
 
            self.stop_initiator_tag = None
165
 
        if self.checker_initiator_tag:
166
 
            gobject.source_remove(self.checker_initiator_tag)
167
 
            self.checker_initiator_tag = None
168
 
        self.stop_checker()
169
 
        if self.stop_hook:
170
 
            self.stop_hook(self)
171
 
        # Do not run this again if called by a gobject.timeout_add
172
 
        return False
173
 
    def __del__(self):
174
 
        # Some code duplication here and in stop()
175
 
        if hasattr(self, "stop_initiator_tag") \
176
 
               and self.stop_initiator_tag:
177
 
            gobject.source_remove(self.stop_initiator_tag)
178
 
            self.stop_initiator_tag = None
179
 
        if hasattr(self, "checker_initiator_tag") \
180
 
               and self.checker_initiator_tag:
181
 
            gobject.source_remove(self.checker_initiator_tag)
182
 
            self.checker_initiator_tag = None
183
 
        self.stop_checker()
184
 
    def checker_callback(self, pid, condition):
 
624
    
 
625
    def checker_callback(self, pid, condition, command):
185
626
        """The checker has completed, so take appropriate actions."""
186
 
        now = datetime.datetime.now()
187
 
        if os.WIFEXITED(condition) \
188
 
               and (os.WEXITSTATUS(condition) == 0):
189
 
            logger.debug(u"Checker for %(name)s succeeded",
190
 
                         vars(self))
191
 
            self.last_seen = now
192
 
            gobject.source_remove(self.stop_initiator_tag)
193
 
            self.stop_initiator_tag = gobject.timeout_add\
194
 
                                      (self._timeout_milliseconds,
195
 
                                       self.stop)
196
 
        if not os.WIFEXITED(condition):
197
 
            logger.warning(u"Checker for %(name)s crashed?",
 
627
        self.checker_callback_tag = None
 
628
        self.checker = None
 
629
        if os.WIFEXITED(condition):
 
630
            self.last_checker_status = os.WEXITSTATUS(condition)
 
631
            if self.last_checker_status == 0:
 
632
                logger.info("Checker for %(name)s succeeded",
 
633
                            vars(self))
 
634
                self.checked_ok()
 
635
            else:
 
636
                logger.info("Checker for %(name)s failed",
 
637
                            vars(self))
 
638
        else:
 
639
            self.last_checker_status = -1
 
640
            logger.warning("Checker for %(name)s crashed?",
198
641
                           vars(self))
199
 
        else:
200
 
            logger.debug(u"Checker for %(name)s failed",
201
 
                         vars(self))
202
 
            self.checker = None
203
 
        self.checker_callback_tag = None
 
642
    
 
643
    def checked_ok(self):
 
644
        """Assert that the client has been seen, alive and well."""
 
645
        self.last_checked_ok = datetime.datetime.utcnow()
 
646
        self.last_checker_status = 0
 
647
        self.bump_timeout()
 
648
    
 
649
    def bump_timeout(self, timeout=None):
 
650
        """Bump up the timeout for this client."""
 
651
        if timeout is None:
 
652
            timeout = self.timeout
 
653
        if self.disable_initiator_tag is not None:
 
654
            gobject.source_remove(self.disable_initiator_tag)
 
655
            self.disable_initiator_tag = None
 
656
        if getattr(self, "enabled", False):
 
657
            self.disable_initiator_tag = (gobject.timeout_add
 
658
                                          (timedelta_to_milliseconds
 
659
                                           (timeout), self.disable))
 
660
            self.expires = datetime.datetime.utcnow() + timeout
 
661
    
 
662
    def need_approval(self):
 
663
        self.last_approval_request = datetime.datetime.utcnow()
 
664
    
204
665
    def start_checker(self):
205
666
        """Start a new checker subprocess if one is not running.
 
667
        
206
668
        If a checker already exists, leave it running and do
207
669
        nothing."""
 
670
        # The reason for not killing a running checker is that if we
 
671
        # did that, and if a checker (for some reason) started running
 
672
        # slowly and taking more than 'interval' time, then the client
 
673
        # would inevitably timeout, since no checker would get a
 
674
        # chance to run to completion.  If we instead leave running
 
675
        # checkers alone, the checker would have to take more time
 
676
        # than 'timeout' for the client to be disabled, which is as it
 
677
        # should be.
 
678
        
 
679
        # If a checker exists, make sure it is not a zombie
 
680
        try:
 
681
            pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
 
682
        except (AttributeError, OSError) as error:
 
683
            if (isinstance(error, OSError)
 
684
                and error.errno != errno.ECHILD):
 
685
                raise error
 
686
        else:
 
687
            if pid:
 
688
                logger.warning("Checker was a zombie")
 
689
                gobject.source_remove(self.checker_callback_tag)
 
690
                self.checker_callback(pid, status,
 
691
                                      self.current_checker_command)
 
692
        # Start a new checker if needed
208
693
        if self.checker is None:
209
 
            logger.debug(u"Starting checker for %s",
210
 
                         self.name)
211
 
            try:
212
 
                command = self.check_command % self.fqdn
213
 
            except TypeError:
214
 
                escaped_attrs = dict((key, re.escape(str(val)))
215
 
                                     for key, val in
216
 
                                     vars(self).iteritems())
217
 
                try:
218
 
                    command = self.check_command % escaped_attrs
219
 
                except TypeError, error:
220
 
                    logger.critical(u'Could not format string "%s": %s',
221
 
                                    self.check_command, error)
222
 
                    return True # Try again later
223
 
            try:
224
 
                self.checker = subprocess.\
225
 
                               Popen(command,
226
 
                                     stdout=subprocess.PIPE,
227
 
                                     close_fds=True, shell=True,
228
 
                                     cwd="/")
229
 
                self.checker_callback_tag = gobject.\
230
 
                                            child_watch_add(self.checker.pid,
231
 
                                                            self.\
232
 
                                                            checker_callback)
233
 
            except subprocess.OSError, error:
234
 
                logger.error(u"Failed to start subprocess: %s",
235
 
                             error)
 
694
            # Escape attributes for the shell
 
695
            escaped_attrs = dict(
 
696
                (attr, re.escape(unicode(getattr(self, attr))))
 
697
                for attr in
 
698
                self.runtime_expansions)
 
699
            try:
 
700
                command = self.checker_command % escaped_attrs
 
701
            except TypeError as error:
 
702
                logger.error('Could not format string "%s"',
 
703
                             self.checker_command, exc_info=error)
 
704
                return True # Try again later
 
705
            self.current_checker_command = command
 
706
            try:
 
707
                logger.info("Starting checker %r for %s",
 
708
                            command, self.name)
 
709
                # We don't need to redirect stdout and stderr, since
 
710
                # in normal mode, that is already done by daemon(),
 
711
                # and in debug mode we don't want to.  (Stdin is
 
712
                # always replaced by /dev/null.)
 
713
                self.checker = subprocess.Popen(command,
 
714
                                                close_fds=True,
 
715
                                                shell=True, cwd="/")
 
716
            except OSError as error:
 
717
                logger.error("Failed to start subprocess",
 
718
                             exc_info=error)
 
719
            self.checker_callback_tag = (gobject.child_watch_add
 
720
                                         (self.checker.pid,
 
721
                                          self.checker_callback,
 
722
                                          data=command))
 
723
            # The checker may have completed before the gobject
 
724
            # watch was added.  Check for this.
 
725
            pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
 
726
            if pid:
 
727
                gobject.source_remove(self.checker_callback_tag)
 
728
                self.checker_callback(pid, status, command)
236
729
        # Re-run this periodically if run by gobject.timeout_add
237
730
        return True
 
731
    
238
732
    def stop_checker(self):
239
733
        """Force the checker process, if any, to stop."""
240
 
        if not hasattr(self, "checker") or self.checker is None:
 
734
        if self.checker_callback_tag:
 
735
            gobject.source_remove(self.checker_callback_tag)
 
736
            self.checker_callback_tag = None
 
737
        if getattr(self, "checker", None) is None:
241
738
            return
242
 
        gobject.source_remove(self.checker_callback_tag)
 
739
        logger.debug("Stopping checker for %(name)s", vars(self))
 
740
        try:
 
741
            self.checker.terminate()
 
742
            #time.sleep(0.5)
 
743
            #if self.checker.poll() is None:
 
744
            #    self.checker.kill()
 
745
        except OSError as error:
 
746
            if error.errno != errno.ESRCH: # No such process
 
747
                raise
 
748
        self.checker = None
 
749
 
 
750
 
 
751
def dbus_service_property(dbus_interface, signature="v",
 
752
                          access="readwrite", byte_arrays=False):
 
753
    """Decorators for marking methods of a DBusObjectWithProperties to
 
754
    become properties on the D-Bus.
 
755
    
 
756
    The decorated method will be called with no arguments by "Get"
 
757
    and with one argument by "Set".
 
758
    
 
759
    The parameters, where they are supported, are the same as
 
760
    dbus.service.method, except there is only "signature", since the
 
761
    type from Get() and the type sent to Set() is the same.
 
762
    """
 
763
    # Encoding deeply encoded byte arrays is not supported yet by the
 
764
    # "Set" method, so we fail early here:
 
765
    if byte_arrays and signature != "ay":
 
766
        raise ValueError("Byte arrays not supported for non-'ay'"
 
767
                         " signature {0!r}".format(signature))
 
768
    def decorator(func):
 
769
        func._dbus_is_property = True
 
770
        func._dbus_interface = dbus_interface
 
771
        func._dbus_signature = signature
 
772
        func._dbus_access = access
 
773
        func._dbus_name = func.__name__
 
774
        if func._dbus_name.endswith("_dbus_property"):
 
775
            func._dbus_name = func._dbus_name[:-14]
 
776
        func._dbus_get_args_options = {'byte_arrays': byte_arrays }
 
777
        return func
 
778
    return decorator
 
779
 
 
780
 
 
781
def dbus_interface_annotations(dbus_interface):
 
782
    """Decorator for marking functions returning interface annotations
 
783
    
 
784
    Usage:
 
785
    
 
786
    @dbus_interface_annotations("org.example.Interface")
 
787
    def _foo(self):  # Function name does not matter
 
788
        return {"org.freedesktop.DBus.Deprecated": "true",
 
789
                "org.freedesktop.DBus.Property.EmitsChangedSignal":
 
790
                    "false"}
 
791
    """
 
792
    def decorator(func):
 
793
        func._dbus_is_interface = True
 
794
        func._dbus_interface = dbus_interface
 
795
        func._dbus_name = dbus_interface
 
796
        return func
 
797
    return decorator
 
798
 
 
799
 
 
800
def dbus_annotations(annotations):
 
801
    """Decorator to annotate D-Bus methods, signals or properties
 
802
    Usage:
 
803
    
 
804
    @dbus_service_property("org.example.Interface", signature="b",
 
805
                           access="r")
 
806
    @dbus_annotations({{"org.freedesktop.DBus.Deprecated": "true",
 
807
                        "org.freedesktop.DBus.Property."
 
808
                        "EmitsChangedSignal": "false"})
 
809
    def Property_dbus_property(self):
 
810
        return dbus.Boolean(False)
 
811
    """
 
812
    def decorator(func):
 
813
        func._dbus_annotations = annotations
 
814
        return func
 
815
    return decorator
 
816
 
 
817
 
 
818
class DBusPropertyException(dbus.exceptions.DBusException):
 
819
    """A base class for D-Bus property-related exceptions
 
820
    """
 
821
    def __unicode__(self):
 
822
        return unicode(str(self))
 
823
 
 
824
 
 
825
class DBusPropertyAccessException(DBusPropertyException):
 
826
    """A property's access permissions disallows an operation.
 
827
    """
 
828
    pass
 
829
 
 
830
 
 
831
class DBusPropertyNotFound(DBusPropertyException):
 
832
    """An attempt was made to access a non-existing property.
 
833
    """
 
834
    pass
 
835
 
 
836
 
 
837
class DBusObjectWithProperties(dbus.service.Object):
 
838
    """A D-Bus object with properties.
 
839
    
 
840
    Classes inheriting from this can use the dbus_service_property
 
841
    decorator to expose methods as D-Bus properties.  It exposes the
 
842
    standard Get(), Set(), and GetAll() methods on the D-Bus.
 
843
    """
 
844
    
 
845
    @staticmethod
 
846
    def _is_dbus_thing(thing):
 
847
        """Returns a function testing if an attribute is a D-Bus thing
 
848
        
 
849
        If called like _is_dbus_thing("method") it returns a function
 
850
        suitable for use as predicate to inspect.getmembers().
 
851
        """
 
852
        return lambda obj: getattr(obj, "_dbus_is_{0}".format(thing),
 
853
                                   False)
 
854
    
 
855
    def _get_all_dbus_things(self, thing):
 
856
        """Returns a generator of (name, attribute) pairs
 
857
        """
 
858
        return ((getattr(athing.__get__(self), "_dbus_name",
 
859
                         name),
 
860
                 athing.__get__(self))
 
861
                for cls in self.__class__.__mro__
 
862
                for name, athing in
 
863
                inspect.getmembers(cls,
 
864
                                   self._is_dbus_thing(thing)))
 
865
    
 
866
    def _get_dbus_property(self, interface_name, property_name):
 
867
        """Returns a bound method if one exists which is a D-Bus
 
868
        property with the specified name and interface.
 
869
        """
 
870
        for cls in  self.__class__.__mro__:
 
871
            for name, value in (inspect.getmembers
 
872
                                (cls,
 
873
                                 self._is_dbus_thing("property"))):
 
874
                if (value._dbus_name == property_name
 
875
                    and value._dbus_interface == interface_name):
 
876
                    return value.__get__(self)
 
877
        
 
878
        # No such property
 
879
        raise DBusPropertyNotFound(self.dbus_object_path + ":"
 
880
                                   + interface_name + "."
 
881
                                   + property_name)
 
882
    
 
883
    @dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="ss",
 
884
                         out_signature="v")
 
885
    def Get(self, interface_name, property_name):
 
886
        """Standard D-Bus property Get() method, see D-Bus standard.
 
887
        """
 
888
        prop = self._get_dbus_property(interface_name, property_name)
 
889
        if prop._dbus_access == "write":
 
890
            raise DBusPropertyAccessException(property_name)
 
891
        value = prop()
 
892
        if not hasattr(value, "variant_level"):
 
893
            return value
 
894
        return type(value)(value, variant_level=value.variant_level+1)
 
895
    
 
896
    @dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="ssv")
 
897
    def Set(self, interface_name, property_name, value):
 
898
        """Standard D-Bus property Set() method, see D-Bus standard.
 
899
        """
 
900
        prop = self._get_dbus_property(interface_name, property_name)
 
901
        if prop._dbus_access == "read":
 
902
            raise DBusPropertyAccessException(property_name)
 
903
        if prop._dbus_get_args_options["byte_arrays"]:
 
904
            # The byte_arrays option is not supported yet on
 
905
            # signatures other than "ay".
 
906
            if prop._dbus_signature != "ay":
 
907
                raise ValueError
 
908
            value = dbus.ByteArray(b''.join(chr(byte)
 
909
                                            for byte in value))
 
910
        prop(value)
 
911
    
 
912
    @dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="s",
 
913
                         out_signature="a{sv}")
 
914
    def GetAll(self, interface_name):
 
915
        """Standard D-Bus property GetAll() method, see D-Bus
 
916
        standard.
 
917
        
 
918
        Note: Will not include properties with access="write".
 
919
        """
 
920
        properties = {}
 
921
        for name, prop in self._get_all_dbus_things("property"):
 
922
            if (interface_name
 
923
                and interface_name != prop._dbus_interface):
 
924
                # Interface non-empty but did not match
 
925
                continue
 
926
            # Ignore write-only properties
 
927
            if prop._dbus_access == "write":
 
928
                continue
 
929
            value = prop()
 
930
            if not hasattr(value, "variant_level"):
 
931
                properties[name] = value
 
932
                continue
 
933
            properties[name] = type(value)(value, variant_level=
 
934
                                           value.variant_level+1)
 
935
        return dbus.Dictionary(properties, signature="sv")
 
936
    
 
937
    @dbus.service.method(dbus.INTROSPECTABLE_IFACE,
 
938
                         out_signature="s",
 
939
                         path_keyword='object_path',
 
940
                         connection_keyword='connection')
 
941
    def Introspect(self, object_path, connection):
 
942
        """Overloading of standard D-Bus method.
 
943
        
 
944
        Inserts property tags and interface annotation tags.
 
945
        """
 
946
        xmlstring = dbus.service.Object.Introspect(self, object_path,
 
947
                                                   connection)
 
948
        try:
 
949
            document = xml.dom.minidom.parseString(xmlstring)
 
950
            def make_tag(document, name, prop):
 
951
                e = document.createElement("property")
 
952
                e.setAttribute("name", name)
 
953
                e.setAttribute("type", prop._dbus_signature)
 
954
                e.setAttribute("access", prop._dbus_access)
 
955
                return e
 
956
            for if_tag in document.getElementsByTagName("interface"):
 
957
                # Add property tags
 
958
                for tag in (make_tag(document, name, prop)
 
959
                            for name, prop
 
960
                            in self._get_all_dbus_things("property")
 
961
                            if prop._dbus_interface
 
962
                            == if_tag.getAttribute("name")):
 
963
                    if_tag.appendChild(tag)
 
964
                # Add annotation tags
 
965
                for typ in ("method", "signal", "property"):
 
966
                    for tag in if_tag.getElementsByTagName(typ):
 
967
                        annots = dict()
 
968
                        for name, prop in (self.
 
969
                                           _get_all_dbus_things(typ)):
 
970
                            if (name == tag.getAttribute("name")
 
971
                                and prop._dbus_interface
 
972
                                == if_tag.getAttribute("name")):
 
973
                                annots.update(getattr
 
974
                                              (prop,
 
975
                                               "_dbus_annotations",
 
976
                                               {}))
 
977
                        for name, value in annots.iteritems():
 
978
                            ann_tag = document.createElement(
 
979
                                "annotation")
 
980
                            ann_tag.setAttribute("name", name)
 
981
                            ann_tag.setAttribute("value", value)
 
982
                            tag.appendChild(ann_tag)
 
983
                # Add interface annotation tags
 
984
                for annotation, value in dict(
 
985
                    itertools.chain.from_iterable(
 
986
                        annotations().iteritems()
 
987
                        for name, annotations in
 
988
                        self._get_all_dbus_things("interface")
 
989
                        if name == if_tag.getAttribute("name")
 
990
                        )).iteritems():
 
991
                    ann_tag = document.createElement("annotation")
 
992
                    ann_tag.setAttribute("name", annotation)
 
993
                    ann_tag.setAttribute("value", value)
 
994
                    if_tag.appendChild(ann_tag)
 
995
                # Add the names to the return values for the
 
996
                # "org.freedesktop.DBus.Properties" methods
 
997
                if (if_tag.getAttribute("name")
 
998
                    == "org.freedesktop.DBus.Properties"):
 
999
                    for cn in if_tag.getElementsByTagName("method"):
 
1000
                        if cn.getAttribute("name") == "Get":
 
1001
                            for arg in cn.getElementsByTagName("arg"):
 
1002
                                if (arg.getAttribute("direction")
 
1003
                                    == "out"):
 
1004
                                    arg.setAttribute("name", "value")
 
1005
                        elif cn.getAttribute("name") == "GetAll":
 
1006
                            for arg in cn.getElementsByTagName("arg"):
 
1007
                                if (arg.getAttribute("direction")
 
1008
                                    == "out"):
 
1009
                                    arg.setAttribute("name", "props")
 
1010
            xmlstring = document.toxml("utf-8")
 
1011
            document.unlink()
 
1012
        except (AttributeError, xml.dom.DOMException,
 
1013
                xml.parsers.expat.ExpatError) as error:
 
1014
            logger.error("Failed to override Introspection method",
 
1015
                         exc_info=error)
 
1016
        return xmlstring
 
1017
 
 
1018
 
 
1019
def datetime_to_dbus (dt, variant_level=0):
 
1020
    """Convert a UTC datetime.datetime() to a D-Bus type."""
 
1021
    if dt is None:
 
1022
        return dbus.String("", variant_level = variant_level)
 
1023
    return dbus.String(dt.isoformat(),
 
1024
                       variant_level=variant_level)
 
1025
 
 
1026
 
 
1027
def alternate_dbus_interfaces(alt_interface_names, deprecate=True):
 
1028
    """A class decorator; applied to a subclass of
 
1029
    dbus.service.Object, it will add alternate D-Bus attributes with
 
1030
    interface names according to the "alt_interface_names" mapping.
 
1031
    Usage:
 
1032
    
 
1033
    @alternate_dbus_names({"org.example.Interface":
 
1034
                               "net.example.AlternateInterface"})
 
1035
    class SampleDBusObject(dbus.service.Object):
 
1036
        @dbus.service.method("org.example.Interface")
 
1037
        def SampleDBusMethod():
 
1038
            pass
 
1039
    
 
1040
    The above "SampleDBusMethod" on "SampleDBusObject" will be
 
1041
    reachable via two interfaces: "org.example.Interface" and
 
1042
    "net.example.AlternateInterface", the latter of which will have
 
1043
    its D-Bus annotation "org.freedesktop.DBus.Deprecated" set to
 
1044
    "true", unless "deprecate" is passed with a False value.
 
1045
    
 
1046
    This works for methods and signals, and also for D-Bus properties
 
1047
    (from DBusObjectWithProperties) and interfaces (from the
 
1048
    dbus_interface_annotations decorator).
 
1049
    """
 
1050
    def wrapper(cls):
 
1051
        for orig_interface_name, alt_interface_name in (
 
1052
            alt_interface_names.iteritems()):
 
1053
            attr = {}
 
1054
            interface_names = set()
 
1055
            # Go though all attributes of the class
 
1056
            for attrname, attribute in inspect.getmembers(cls):
 
1057
                # Ignore non-D-Bus attributes, and D-Bus attributes
 
1058
                # with the wrong interface name
 
1059
                if (not hasattr(attribute, "_dbus_interface")
 
1060
                    or not attribute._dbus_interface
 
1061
                    .startswith(orig_interface_name)):
 
1062
                    continue
 
1063
                # Create an alternate D-Bus interface name based on
 
1064
                # the current name
 
1065
                alt_interface = (attribute._dbus_interface
 
1066
                                 .replace(orig_interface_name,
 
1067
                                          alt_interface_name))
 
1068
                interface_names.add(alt_interface)
 
1069
                # Is this a D-Bus signal?
 
1070
                if getattr(attribute, "_dbus_is_signal", False):
 
1071
                    # Extract the original non-method function by
 
1072
                    # black magic
 
1073
                    nonmethod_func = (dict(
 
1074
                            zip(attribute.func_code.co_freevars,
 
1075
                                attribute.__closure__))["func"]
 
1076
                                      .cell_contents)
 
1077
                    # Create a new, but exactly alike, function
 
1078
                    # object, and decorate it to be a new D-Bus signal
 
1079
                    # with the alternate D-Bus interface name
 
1080
                    new_function = (dbus.service.signal
 
1081
                                    (alt_interface,
 
1082
                                     attribute._dbus_signature)
 
1083
                                    (types.FunctionType(
 
1084
                                nonmethod_func.func_code,
 
1085
                                nonmethod_func.func_globals,
 
1086
                                nonmethod_func.func_name,
 
1087
                                nonmethod_func.func_defaults,
 
1088
                                nonmethod_func.func_closure)))
 
1089
                    # Copy annotations, if any
 
1090
                    try:
 
1091
                        new_function._dbus_annotations = (
 
1092
                            dict(attribute._dbus_annotations))
 
1093
                    except AttributeError:
 
1094
                        pass
 
1095
                    # Define a creator of a function to call both the
 
1096
                    # original and alternate functions, so both the
 
1097
                    # original and alternate signals gets sent when
 
1098
                    # the function is called
 
1099
                    def fixscope(func1, func2):
 
1100
                        """This function is a scope container to pass
 
1101
                        func1 and func2 to the "call_both" function
 
1102
                        outside of its arguments"""
 
1103
                        def call_both(*args, **kwargs):
 
1104
                            """This function will emit two D-Bus
 
1105
                            signals by calling func1 and func2"""
 
1106
                            func1(*args, **kwargs)
 
1107
                            func2(*args, **kwargs)
 
1108
                        return call_both
 
1109
                    # Create the "call_both" function and add it to
 
1110
                    # the class
 
1111
                    attr[attrname] = fixscope(attribute, new_function)
 
1112
                # Is this a D-Bus method?
 
1113
                elif getattr(attribute, "_dbus_is_method", False):
 
1114
                    # Create a new, but exactly alike, function
 
1115
                    # object.  Decorate it to be a new D-Bus method
 
1116
                    # with the alternate D-Bus interface name.  Add it
 
1117
                    # to the class.
 
1118
                    attr[attrname] = (dbus.service.method
 
1119
                                      (alt_interface,
 
1120
                                       attribute._dbus_in_signature,
 
1121
                                       attribute._dbus_out_signature)
 
1122
                                      (types.FunctionType
 
1123
                                       (attribute.func_code,
 
1124
                                        attribute.func_globals,
 
1125
                                        attribute.func_name,
 
1126
                                        attribute.func_defaults,
 
1127
                                        attribute.func_closure)))
 
1128
                    # Copy annotations, if any
 
1129
                    try:
 
1130
                        attr[attrname]._dbus_annotations = (
 
1131
                            dict(attribute._dbus_annotations))
 
1132
                    except AttributeError:
 
1133
                        pass
 
1134
                # Is this a D-Bus property?
 
1135
                elif getattr(attribute, "_dbus_is_property", False):
 
1136
                    # Create a new, but exactly alike, function
 
1137
                    # object, and decorate it to be a new D-Bus
 
1138
                    # property with the alternate D-Bus interface
 
1139
                    # name.  Add it to the class.
 
1140
                    attr[attrname] = (dbus_service_property
 
1141
                                      (alt_interface,
 
1142
                                       attribute._dbus_signature,
 
1143
                                       attribute._dbus_access,
 
1144
                                       attribute
 
1145
                                       ._dbus_get_args_options
 
1146
                                       ["byte_arrays"])
 
1147
                                      (types.FunctionType
 
1148
                                       (attribute.func_code,
 
1149
                                        attribute.func_globals,
 
1150
                                        attribute.func_name,
 
1151
                                        attribute.func_defaults,
 
1152
                                        attribute.func_closure)))
 
1153
                    # Copy annotations, if any
 
1154
                    try:
 
1155
                        attr[attrname]._dbus_annotations = (
 
1156
                            dict(attribute._dbus_annotations))
 
1157
                    except AttributeError:
 
1158
                        pass
 
1159
                # Is this a D-Bus interface?
 
1160
                elif getattr(attribute, "_dbus_is_interface", False):
 
1161
                    # Create a new, but exactly alike, function
 
1162
                    # object.  Decorate it to be a new D-Bus interface
 
1163
                    # with the alternate D-Bus interface name.  Add it
 
1164
                    # to the class.
 
1165
                    attr[attrname] = (dbus_interface_annotations
 
1166
                                      (alt_interface)
 
1167
                                      (types.FunctionType
 
1168
                                       (attribute.func_code,
 
1169
                                        attribute.func_globals,
 
1170
                                        attribute.func_name,
 
1171
                                        attribute.func_defaults,
 
1172
                                        attribute.func_closure)))
 
1173
            if deprecate:
 
1174
                # Deprecate all alternate interfaces
 
1175
                iname="_AlternateDBusNames_interface_annotation{0}"
 
1176
                for interface_name in interface_names:
 
1177
                    @dbus_interface_annotations(interface_name)
 
1178
                    def func(self):
 
1179
                        return { "org.freedesktop.DBus.Deprecated":
 
1180
                                     "true" }
 
1181
                    # Find an unused name
 
1182
                    for aname in (iname.format(i)
 
1183
                                  for i in itertools.count()):
 
1184
                        if aname not in attr:
 
1185
                            attr[aname] = func
 
1186
                            break
 
1187
            if interface_names:
 
1188
                # Replace the class with a new subclass of it with
 
1189
                # methods, signals, etc. as created above.
 
1190
                cls = type(b"{0}Alternate".format(cls.__name__),
 
1191
                           (cls,), attr)
 
1192
        return cls
 
1193
    return wrapper
 
1194
 
 
1195
 
 
1196
@alternate_dbus_interfaces({"se.recompile.Mandos":
 
1197
                                "se.bsnet.fukt.Mandos"})
 
1198
class ClientDBus(Client, DBusObjectWithProperties):
 
1199
    """A Client class using D-Bus
 
1200
    
 
1201
    Attributes:
 
1202
    dbus_object_path: dbus.ObjectPath
 
1203
    bus: dbus.SystemBus()
 
1204
    """
 
1205
    
 
1206
    runtime_expansions = (Client.runtime_expansions
 
1207
                          + ("dbus_object_path",))
 
1208
    
 
1209
    # dbus.service.Object doesn't use super(), so we can't either.
 
1210
    
 
1211
    def __init__(self, bus = None, *args, **kwargs):
 
1212
        self.bus = bus
 
1213
        Client.__init__(self, *args, **kwargs)
 
1214
        # Only now, when this client is initialized, can it show up on
 
1215
        # the D-Bus
 
1216
        client_object_name = unicode(self.name).translate(
 
1217
            {ord("."): ord("_"),
 
1218
             ord("-"): ord("_")})
 
1219
        self.dbus_object_path = (dbus.ObjectPath
 
1220
                                 ("/clients/" + client_object_name))
 
1221
        DBusObjectWithProperties.__init__(self, self.bus,
 
1222
                                          self.dbus_object_path)
 
1223
    
 
1224
    def notifychangeproperty(transform_func,
 
1225
                             dbus_name, type_func=lambda x: x,
 
1226
                             variant_level=1):
 
1227
        """ Modify a variable so that it's a property which announces
 
1228
        its changes to DBus.
 
1229
        
 
1230
        transform_fun: Function that takes a value and a variant_level
 
1231
                       and transforms it to a D-Bus type.
 
1232
        dbus_name: D-Bus name of the variable
 
1233
        type_func: Function that transform the value before sending it
 
1234
                   to the D-Bus.  Default: no transform
 
1235
        variant_level: D-Bus variant level.  Default: 1
 
1236
        """
 
1237
        attrname = "_{0}".format(dbus_name)
 
1238
        def setter(self, value):
 
1239
            if hasattr(self, "dbus_object_path"):
 
1240
                if (not hasattr(self, attrname) or
 
1241
                    type_func(getattr(self, attrname, None))
 
1242
                    != type_func(value)):
 
1243
                    dbus_value = transform_func(type_func(value),
 
1244
                                                variant_level
 
1245
                                                =variant_level)
 
1246
                    self.PropertyChanged(dbus.String(dbus_name),
 
1247
                                         dbus_value)
 
1248
            setattr(self, attrname, value)
 
1249
        
 
1250
        return property(lambda self: getattr(self, attrname), setter)
 
1251
    
 
1252
    expires = notifychangeproperty(datetime_to_dbus, "Expires")
 
1253
    approvals_pending = notifychangeproperty(dbus.Boolean,
 
1254
                                             "ApprovalPending",
 
1255
                                             type_func = bool)
 
1256
    enabled = notifychangeproperty(dbus.Boolean, "Enabled")
 
1257
    last_enabled = notifychangeproperty(datetime_to_dbus,
 
1258
                                        "LastEnabled")
 
1259
    checker = notifychangeproperty(dbus.Boolean, "CheckerRunning",
 
1260
                                   type_func = lambda checker:
 
1261
                                       checker is not None)
 
1262
    last_checked_ok = notifychangeproperty(datetime_to_dbus,
 
1263
                                           "LastCheckedOK")
 
1264
    last_checker_status = notifychangeproperty(dbus.Int16,
 
1265
                                               "LastCheckerStatus")
 
1266
    last_approval_request = notifychangeproperty(
 
1267
        datetime_to_dbus, "LastApprovalRequest")
 
1268
    approved_by_default = notifychangeproperty(dbus.Boolean,
 
1269
                                               "ApprovedByDefault")
 
1270
    approval_delay = notifychangeproperty(dbus.UInt64,
 
1271
                                          "ApprovalDelay",
 
1272
                                          type_func =
 
1273
                                          timedelta_to_milliseconds)
 
1274
    approval_duration = notifychangeproperty(
 
1275
        dbus.UInt64, "ApprovalDuration",
 
1276
        type_func = timedelta_to_milliseconds)
 
1277
    host = notifychangeproperty(dbus.String, "Host")
 
1278
    timeout = notifychangeproperty(dbus.UInt64, "Timeout",
 
1279
                                   type_func =
 
1280
                                   timedelta_to_milliseconds)
 
1281
    extended_timeout = notifychangeproperty(
 
1282
        dbus.UInt64, "ExtendedTimeout",
 
1283
        type_func = timedelta_to_milliseconds)
 
1284
    interval = notifychangeproperty(dbus.UInt64,
 
1285
                                    "Interval",
 
1286
                                    type_func =
 
1287
                                    timedelta_to_milliseconds)
 
1288
    checker_command = notifychangeproperty(dbus.String, "Checker")
 
1289
    
 
1290
    del notifychangeproperty
 
1291
    
 
1292
    def __del__(self, *args, **kwargs):
 
1293
        try:
 
1294
            self.remove_from_connection()
 
1295
        except LookupError:
 
1296
            pass
 
1297
        if hasattr(DBusObjectWithProperties, "__del__"):
 
1298
            DBusObjectWithProperties.__del__(self, *args, **kwargs)
 
1299
        Client.__del__(self, *args, **kwargs)
 
1300
    
 
1301
    def checker_callback(self, pid, condition, command,
 
1302
                         *args, **kwargs):
243
1303
        self.checker_callback_tag = None
244
 
        os.kill(self.checker.pid, signal.SIGTERM)
245
 
        if self.checker.poll() is None:
246
 
            os.kill(self.checker.pid, signal.SIGKILL)
247
1304
        self.checker = None
248
 
    def still_valid(self, now=None):
249
 
        """Has the timeout not yet passed for this client?"""
250
 
        if now is None:
251
 
            now = datetime.datetime.now()
252
 
        if self.last_seen is None:
253
 
            return now < (self.created + self.timeout)
254
 
        else:
255
 
            return now < (self.last_seen + self.timeout)
256
 
 
257
 
 
258
 
def peer_certificate(session):
259
 
    # If not an OpenPGP certificate...
260
 
    if gnutls.library.functions.gnutls_certificate_type_get\
261
 
            (session._c_object) \
262
 
           != gnutls.library.constants.GNUTLS_CRT_OPENPGP:
263
 
        # ...do the normal thing
264
 
        return session.peer_certificate
265
 
    list_size = ctypes.c_uint()
266
 
    cert_list = gnutls.library.functions.gnutls_certificate_get_peers\
267
 
        (session._c_object, ctypes.byref(list_size))
268
 
    if list_size.value == 0:
269
 
        return None
270
 
    cert = cert_list[0]
271
 
    return ctypes.string_at(cert.data, cert.size)
272
 
 
273
 
 
274
 
def fingerprint(openpgp):
275
 
    # New empty GnuTLS certificate
276
 
    crt = gnutls.library.types.gnutls_openpgp_crt_t()
277
 
    gnutls.library.functions.gnutls_openpgp_crt_init\
278
 
        (ctypes.byref(crt))
279
 
    # New GnuTLS "datum" with the OpenPGP public key
280
 
    datum = gnutls.library.types.gnutls_datum_t\
281
 
        (ctypes.cast(ctypes.c_char_p(openpgp),
282
 
                     ctypes.POINTER(ctypes.c_ubyte)),
283
 
         ctypes.c_uint(len(openpgp)))
284
 
    # Import the OpenPGP public key into the certificate
285
 
    ret = gnutls.library.functions.gnutls_openpgp_crt_import\
286
 
        (crt,
287
 
         ctypes.byref(datum),
288
 
         gnutls.library.constants.GNUTLS_OPENPGP_FMT_RAW)
289
 
    # New buffer for the fingerprint
290
 
    buffer = ctypes.create_string_buffer(20)
291
 
    buffer_length = ctypes.c_size_t()
292
 
    # Get the fingerprint from the certificate into the buffer
293
 
    gnutls.library.functions.gnutls_openpgp_crt_get_fingerprint\
294
 
        (crt, ctypes.byref(buffer), ctypes.byref(buffer_length))
295
 
    # Deinit the certificate
296
 
    gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
297
 
    # Convert the buffer to a Python bytestring
298
 
    fpr = ctypes.string_at(buffer, buffer_length.value)
299
 
    # Convert the bytestring to hexadecimal notation
300
 
    hex_fpr = u''.join(u"%02X" % ord(char) for char in fpr)
301
 
    return hex_fpr
302
 
 
303
 
 
304
 
class tcp_handler(SocketServer.BaseRequestHandler, object):
305
 
    """A TCP request handler class.
306
 
    Instantiated by IPv6_TCPServer for each request to handle it.
 
1305
        if os.WIFEXITED(condition):
 
1306
            exitstatus = os.WEXITSTATUS(condition)
 
1307
            # Emit D-Bus signal
 
1308
            self.CheckerCompleted(dbus.Int16(exitstatus),
 
1309
                                  dbus.Int64(condition),
 
1310
                                  dbus.String(command))
 
1311
        else:
 
1312
            # Emit D-Bus signal
 
1313
            self.CheckerCompleted(dbus.Int16(-1),
 
1314
                                  dbus.Int64(condition),
 
1315
                                  dbus.String(command))
 
1316
        
 
1317
        return Client.checker_callback(self, pid, condition, command,
 
1318
                                       *args, **kwargs)
 
1319
    
 
1320
    def start_checker(self, *args, **kwargs):
 
1321
        old_checker = self.checker
 
1322
        if self.checker is not None:
 
1323
            old_checker_pid = self.checker.pid
 
1324
        else:
 
1325
            old_checker_pid = None
 
1326
        r = Client.start_checker(self, *args, **kwargs)
 
1327
        # Only if new checker process was started
 
1328
        if (self.checker is not None
 
1329
            and old_checker_pid != self.checker.pid):
 
1330
            # Emit D-Bus signal
 
1331
            self.CheckerStarted(self.current_checker_command)
 
1332
        return r
 
1333
    
 
1334
    def _reset_approved(self):
 
1335
        self.approved = None
 
1336
        return False
 
1337
    
 
1338
    def approve(self, value=True):
 
1339
        self.approved = value
 
1340
        gobject.timeout_add(timedelta_to_milliseconds
 
1341
                            (self.approval_duration),
 
1342
                            self._reset_approved)
 
1343
        self.send_changedstate()
 
1344
    
 
1345
    ## D-Bus methods, signals & properties
 
1346
    _interface = "se.recompile.Mandos.Client"
 
1347
    
 
1348
    ## Interfaces
 
1349
    
 
1350
    @dbus_interface_annotations(_interface)
 
1351
    def _foo(self):
 
1352
        return { "org.freedesktop.DBus.Property.EmitsChangedSignal":
 
1353
                     "false"}
 
1354
    
 
1355
    ## Signals
 
1356
    
 
1357
    # CheckerCompleted - signal
 
1358
    @dbus.service.signal(_interface, signature="nxs")
 
1359
    def CheckerCompleted(self, exitcode, waitstatus, command):
 
1360
        "D-Bus signal"
 
1361
        pass
 
1362
    
 
1363
    # CheckerStarted - signal
 
1364
    @dbus.service.signal(_interface, signature="s")
 
1365
    def CheckerStarted(self, command):
 
1366
        "D-Bus signal"
 
1367
        pass
 
1368
    
 
1369
    # PropertyChanged - signal
 
1370
    @dbus.service.signal(_interface, signature="sv")
 
1371
    def PropertyChanged(self, property, value):
 
1372
        "D-Bus signal"
 
1373
        pass
 
1374
    
 
1375
    # GotSecret - signal
 
1376
    @dbus.service.signal(_interface)
 
1377
    def GotSecret(self):
 
1378
        """D-Bus signal
 
1379
        Is sent after a successful transfer of secret from the Mandos
 
1380
        server to mandos-client
 
1381
        """
 
1382
        pass
 
1383
    
 
1384
    # Rejected - signal
 
1385
    @dbus.service.signal(_interface, signature="s")
 
1386
    def Rejected(self, reason):
 
1387
        "D-Bus signal"
 
1388
        pass
 
1389
    
 
1390
    # NeedApproval - signal
 
1391
    @dbus.service.signal(_interface, signature="tb")
 
1392
    def NeedApproval(self, timeout, default):
 
1393
        "D-Bus signal"
 
1394
        return self.need_approval()
 
1395
    
 
1396
    ## Methods
 
1397
    
 
1398
    # Approve - method
 
1399
    @dbus.service.method(_interface, in_signature="b")
 
1400
    def Approve(self, value):
 
1401
        self.approve(value)
 
1402
    
 
1403
    # CheckedOK - method
 
1404
    @dbus.service.method(_interface)
 
1405
    def CheckedOK(self):
 
1406
        self.checked_ok()
 
1407
    
 
1408
    # Enable - method
 
1409
    @dbus.service.method(_interface)
 
1410
    def Enable(self):
 
1411
        "D-Bus method"
 
1412
        self.enable()
 
1413
    
 
1414
    # StartChecker - method
 
1415
    @dbus.service.method(_interface)
 
1416
    def StartChecker(self):
 
1417
        "D-Bus method"
 
1418
        self.start_checker()
 
1419
    
 
1420
    # Disable - method
 
1421
    @dbus.service.method(_interface)
 
1422
    def Disable(self):
 
1423
        "D-Bus method"
 
1424
        self.disable()
 
1425
    
 
1426
    # StopChecker - method
 
1427
    @dbus.service.method(_interface)
 
1428
    def StopChecker(self):
 
1429
        self.stop_checker()
 
1430
    
 
1431
    ## Properties
 
1432
    
 
1433
    # ApprovalPending - property
 
1434
    @dbus_service_property(_interface, signature="b", access="read")
 
1435
    def ApprovalPending_dbus_property(self):
 
1436
        return dbus.Boolean(bool(self.approvals_pending))
 
1437
    
 
1438
    # ApprovedByDefault - property
 
1439
    @dbus_service_property(_interface, signature="b",
 
1440
                           access="readwrite")
 
1441
    def ApprovedByDefault_dbus_property(self, value=None):
 
1442
        if value is None:       # get
 
1443
            return dbus.Boolean(self.approved_by_default)
 
1444
        self.approved_by_default = bool(value)
 
1445
    
 
1446
    # ApprovalDelay - property
 
1447
    @dbus_service_property(_interface, signature="t",
 
1448
                           access="readwrite")
 
1449
    def ApprovalDelay_dbus_property(self, value=None):
 
1450
        if value is None:       # get
 
1451
            return dbus.UInt64(self.approval_delay_milliseconds())
 
1452
        self.approval_delay = datetime.timedelta(0, 0, 0, value)
 
1453
    
 
1454
    # ApprovalDuration - property
 
1455
    @dbus_service_property(_interface, signature="t",
 
1456
                           access="readwrite")
 
1457
    def ApprovalDuration_dbus_property(self, value=None):
 
1458
        if value is None:       # get
 
1459
            return dbus.UInt64(timedelta_to_milliseconds(
 
1460
                    self.approval_duration))
 
1461
        self.approval_duration = datetime.timedelta(0, 0, 0, value)
 
1462
    
 
1463
    # Name - property
 
1464
    @dbus_service_property(_interface, signature="s", access="read")
 
1465
    def Name_dbus_property(self):
 
1466
        return dbus.String(self.name)
 
1467
    
 
1468
    # Fingerprint - property
 
1469
    @dbus_service_property(_interface, signature="s", access="read")
 
1470
    def Fingerprint_dbus_property(self):
 
1471
        return dbus.String(self.fingerprint)
 
1472
    
 
1473
    # Host - property
 
1474
    @dbus_service_property(_interface, signature="s",
 
1475
                           access="readwrite")
 
1476
    def Host_dbus_property(self, value=None):
 
1477
        if value is None:       # get
 
1478
            return dbus.String(self.host)
 
1479
        self.host = unicode(value)
 
1480
    
 
1481
    # Created - property
 
1482
    @dbus_service_property(_interface, signature="s", access="read")
 
1483
    def Created_dbus_property(self):
 
1484
        return datetime_to_dbus(self.created)
 
1485
    
 
1486
    # LastEnabled - property
 
1487
    @dbus_service_property(_interface, signature="s", access="read")
 
1488
    def LastEnabled_dbus_property(self):
 
1489
        return datetime_to_dbus(self.last_enabled)
 
1490
    
 
1491
    # Enabled - property
 
1492
    @dbus_service_property(_interface, signature="b",
 
1493
                           access="readwrite")
 
1494
    def Enabled_dbus_property(self, value=None):
 
1495
        if value is None:       # get
 
1496
            return dbus.Boolean(self.enabled)
 
1497
        if value:
 
1498
            self.enable()
 
1499
        else:
 
1500
            self.disable()
 
1501
    
 
1502
    # LastCheckedOK - property
 
1503
    @dbus_service_property(_interface, signature="s",
 
1504
                           access="readwrite")
 
1505
    def LastCheckedOK_dbus_property(self, value=None):
 
1506
        if value is not None:
 
1507
            self.checked_ok()
 
1508
            return
 
1509
        return datetime_to_dbus(self.last_checked_ok)
 
1510
    
 
1511
    # LastCheckerStatus - property
 
1512
    @dbus_service_property(_interface, signature="n",
 
1513
                           access="read")
 
1514
    def LastCheckerStatus_dbus_property(self):
 
1515
        return dbus.Int16(self.last_checker_status)
 
1516
    
 
1517
    # Expires - property
 
1518
    @dbus_service_property(_interface, signature="s", access="read")
 
1519
    def Expires_dbus_property(self):
 
1520
        return datetime_to_dbus(self.expires)
 
1521
    
 
1522
    # LastApprovalRequest - property
 
1523
    @dbus_service_property(_interface, signature="s", access="read")
 
1524
    def LastApprovalRequest_dbus_property(self):
 
1525
        return datetime_to_dbus(self.last_approval_request)
 
1526
    
 
1527
    # Timeout - property
 
1528
    @dbus_service_property(_interface, signature="t",
 
1529
                           access="readwrite")
 
1530
    def Timeout_dbus_property(self, value=None):
 
1531
        if value is None:       # get
 
1532
            return dbus.UInt64(self.timeout_milliseconds())
 
1533
        old_timeout = self.timeout
 
1534
        self.timeout = datetime.timedelta(0, 0, 0, value)
 
1535
        # Reschedule disabling
 
1536
        if self.enabled:
 
1537
            now = datetime.datetime.utcnow()
 
1538
            self.expires += self.timeout - old_timeout
 
1539
            if self.expires <= now:
 
1540
                # The timeout has passed
 
1541
                self.disable()
 
1542
            else:
 
1543
                if (getattr(self, "disable_initiator_tag", None)
 
1544
                    is None):
 
1545
                    return
 
1546
                gobject.source_remove(self.disable_initiator_tag)
 
1547
                self.disable_initiator_tag = (
 
1548
                    gobject.timeout_add(
 
1549
                        timedelta_to_milliseconds(self.expires - now),
 
1550
                        self.disable))
 
1551
    
 
1552
    # ExtendedTimeout - property
 
1553
    @dbus_service_property(_interface, signature="t",
 
1554
                           access="readwrite")
 
1555
    def ExtendedTimeout_dbus_property(self, value=None):
 
1556
        if value is None:       # get
 
1557
            return dbus.UInt64(self.extended_timeout_milliseconds())
 
1558
        self.extended_timeout = datetime.timedelta(0, 0, 0, value)
 
1559
    
 
1560
    # Interval - property
 
1561
    @dbus_service_property(_interface, signature="t",
 
1562
                           access="readwrite")
 
1563
    def Interval_dbus_property(self, value=None):
 
1564
        if value is None:       # get
 
1565
            return dbus.UInt64(self.interval_milliseconds())
 
1566
        self.interval = datetime.timedelta(0, 0, 0, value)
 
1567
        if getattr(self, "checker_initiator_tag", None) is None:
 
1568
            return
 
1569
        if self.enabled:
 
1570
            # Reschedule checker run
 
1571
            gobject.source_remove(self.checker_initiator_tag)
 
1572
            self.checker_initiator_tag = (gobject.timeout_add
 
1573
                                          (value, self.start_checker))
 
1574
            self.start_checker()    # Start one now, too
 
1575
    
 
1576
    # Checker - property
 
1577
    @dbus_service_property(_interface, signature="s",
 
1578
                           access="readwrite")
 
1579
    def Checker_dbus_property(self, value=None):
 
1580
        if value is None:       # get
 
1581
            return dbus.String(self.checker_command)
 
1582
        self.checker_command = unicode(value)
 
1583
    
 
1584
    # CheckerRunning - property
 
1585
    @dbus_service_property(_interface, signature="b",
 
1586
                           access="readwrite")
 
1587
    def CheckerRunning_dbus_property(self, value=None):
 
1588
        if value is None:       # get
 
1589
            return dbus.Boolean(self.checker is not None)
 
1590
        if value:
 
1591
            self.start_checker()
 
1592
        else:
 
1593
            self.stop_checker()
 
1594
    
 
1595
    # ObjectPath - property
 
1596
    @dbus_service_property(_interface, signature="o", access="read")
 
1597
    def ObjectPath_dbus_property(self):
 
1598
        return self.dbus_object_path # is already a dbus.ObjectPath
 
1599
    
 
1600
    # Secret = property
 
1601
    @dbus_service_property(_interface, signature="ay",
 
1602
                           access="write", byte_arrays=True)
 
1603
    def Secret_dbus_property(self, value):
 
1604
        self.secret = str(value)
 
1605
    
 
1606
    del _interface
 
1607
 
 
1608
 
 
1609
class ProxyClient(object):
 
1610
    def __init__(self, child_pipe, fpr, address):
 
1611
        self._pipe = child_pipe
 
1612
        self._pipe.send(('init', fpr, address))
 
1613
        if not self._pipe.recv():
 
1614
            raise KeyError()
 
1615
    
 
1616
    def __getattribute__(self, name):
 
1617
        if name == '_pipe':
 
1618
            return super(ProxyClient, self).__getattribute__(name)
 
1619
        self._pipe.send(('getattr', name))
 
1620
        data = self._pipe.recv()
 
1621
        if data[0] == 'data':
 
1622
            return data[1]
 
1623
        if data[0] == 'function':
 
1624
            def func(*args, **kwargs):
 
1625
                self._pipe.send(('funcall', name, args, kwargs))
 
1626
                return self._pipe.recv()[1]
 
1627
            return func
 
1628
    
 
1629
    def __setattr__(self, name, value):
 
1630
        if name == '_pipe':
 
1631
            return super(ProxyClient, self).__setattr__(name, value)
 
1632
        self._pipe.send(('setattr', name, value))
 
1633
 
 
1634
 
 
1635
class ClientHandler(socketserver.BaseRequestHandler, object):
 
1636
    """A class to handle client connections.
 
1637
    
 
1638
    Instantiated once for each connection to handle it.
307
1639
    Note: This will run in its own forked process."""
308
1640
    
309
1641
    def handle(self):
310
 
        logger.debug(u"TCP connection from: %s",
311
 
                     unicode(self.client_address))
312
 
        session = gnutls.connection.ClientSession(self.request,
313
 
                                                  gnutls.connection.\
314
 
                                                  X509Credentials())
315
 
        
316
 
        #priority = ':'.join(("NONE", "+VERS-TLS1.1", "+AES-256-CBC",
317
 
        #                "+SHA1", "+COMP-NULL", "+CTYPE-OPENPGP",
318
 
        #                "+DHE-DSS"))
319
 
        priority = "SECURE256"
320
 
        
321
 
        gnutls.library.functions.gnutls_priority_set_direct\
322
 
            (session._c_object, priority, None);
323
 
        
324
 
        try:
325
 
            session.handshake()
326
 
        except gnutls.errors.GNUTLSError, error:
327
 
            logger.debug(u"Handshake failed: %s", error)
328
 
            # Do not run session.bye() here: the session is not
329
 
            # established.  Just abandon the request.
330
 
            return
331
 
        try:
332
 
            fpr = fingerprint(peer_certificate(session))
333
 
        except (TypeError, gnutls.errors.GNUTLSError), error:
334
 
            logger.debug(u"Bad certificate: %s", error)
335
 
            session.bye()
336
 
            return
337
 
        logger.debug(u"Fingerprint: %s", fpr)
338
 
        client = None
339
 
        for c in clients:
340
 
            if c.fingerprint == fpr:
341
 
                client = c
342
 
                break
343
 
        # Have to check if client.still_valid(), since it is possible
344
 
        # that the client timed out while establishing the GnuTLS
345
 
        # session.
346
 
        if (not client) or (not client.still_valid()):
347
 
            if client:
348
 
                logger.debug(u"Client %(name)s is invalid",
349
 
                             vars(client))
350
 
            else:
351
 
                logger.debug(u"Client not found for fingerprint: %s",
352
 
                             fpr)
353
 
            session.bye()
354
 
            return
355
 
        sent_size = 0
356
 
        while sent_size < len(client.secret):
357
 
            sent = session.send(client.secret[sent_size:])
358
 
            logger.debug(u"Sent: %d, remaining: %d",
359
 
                         sent, len(client.secret)
360
 
                         - (sent_size + sent))
361
 
            sent_size += sent
362
 
        session.bye()
363
 
 
364
 
 
365
 
class IPv6_TCPServer(SocketServer.ForkingTCPServer, object):
366
 
    """IPv6 TCP server.  Accepts 'None' as address and/or port.
 
1642
        with contextlib.closing(self.server.child_pipe) as child_pipe:
 
1643
            logger.info("TCP connection from: %s",
 
1644
                        unicode(self.client_address))
 
1645
            logger.debug("Pipe FD: %d",
 
1646
                         self.server.child_pipe.fileno())
 
1647
            
 
1648
            session = (gnutls.connection
 
1649
                       .ClientSession(self.request,
 
1650
                                      gnutls.connection
 
1651
                                      .X509Credentials()))
 
1652
            
 
1653
            # Note: gnutls.connection.X509Credentials is really a
 
1654
            # generic GnuTLS certificate credentials object so long as
 
1655
            # no X.509 keys are added to it.  Therefore, we can use it
 
1656
            # here despite using OpenPGP certificates.
 
1657
            
 
1658
            #priority = ':'.join(("NONE", "+VERS-TLS1.1",
 
1659
            #                      "+AES-256-CBC", "+SHA1",
 
1660
            #                      "+COMP-NULL", "+CTYPE-OPENPGP",
 
1661
            #                      "+DHE-DSS"))
 
1662
            # Use a fallback default, since this MUST be set.
 
1663
            priority = self.server.gnutls_priority
 
1664
            if priority is None:
 
1665
                priority = "NORMAL"
 
1666
            (gnutls.library.functions
 
1667
             .gnutls_priority_set_direct(session._c_object,
 
1668
                                         priority, None))
 
1669
            
 
1670
            # Start communication using the Mandos protocol
 
1671
            # Get protocol number
 
1672
            line = self.request.makefile().readline()
 
1673
            logger.debug("Protocol version: %r", line)
 
1674
            try:
 
1675
                if int(line.strip().split()[0]) > 1:
 
1676
                    raise RuntimeError
 
1677
            except (ValueError, IndexError, RuntimeError) as error:
 
1678
                logger.error("Unknown protocol version: %s", error)
 
1679
                return
 
1680
            
 
1681
            # Start GnuTLS connection
 
1682
            try:
 
1683
                session.handshake()
 
1684
            except gnutls.errors.GNUTLSError as error:
 
1685
                logger.warning("Handshake failed: %s", error)
 
1686
                # Do not run session.bye() here: the session is not
 
1687
                # established.  Just abandon the request.
 
1688
                return
 
1689
            logger.debug("Handshake succeeded")
 
1690
            
 
1691
            approval_required = False
 
1692
            try:
 
1693
                try:
 
1694
                    fpr = self.fingerprint(self.peer_certificate
 
1695
                                           (session))
 
1696
                except (TypeError,
 
1697
                        gnutls.errors.GNUTLSError) as error:
 
1698
                    logger.warning("Bad certificate: %s", error)
 
1699
                    return
 
1700
                logger.debug("Fingerprint: %s", fpr)
 
1701
                
 
1702
                try:
 
1703
                    client = ProxyClient(child_pipe, fpr,
 
1704
                                         self.client_address)
 
1705
                except KeyError:
 
1706
                    return
 
1707
                
 
1708
                if client.approval_delay:
 
1709
                    delay = client.approval_delay
 
1710
                    client.approvals_pending += 1
 
1711
                    approval_required = True
 
1712
                
 
1713
                while True:
 
1714
                    if not client.enabled:
 
1715
                        logger.info("Client %s is disabled",
 
1716
                                       client.name)
 
1717
                        if self.server.use_dbus:
 
1718
                            # Emit D-Bus signal
 
1719
                            client.Rejected("Disabled")
 
1720
                        return
 
1721
                    
 
1722
                    if client.approved or not client.approval_delay:
 
1723
                        #We are approved or approval is disabled
 
1724
                        break
 
1725
                    elif client.approved is None:
 
1726
                        logger.info("Client %s needs approval",
 
1727
                                    client.name)
 
1728
                        if self.server.use_dbus:
 
1729
                            # Emit D-Bus signal
 
1730
                            client.NeedApproval(
 
1731
                                client.approval_delay_milliseconds(),
 
1732
                                client.approved_by_default)
 
1733
                    else:
 
1734
                        logger.warning("Client %s was not approved",
 
1735
                                       client.name)
 
1736
                        if self.server.use_dbus:
 
1737
                            # Emit D-Bus signal
 
1738
                            client.Rejected("Denied")
 
1739
                        return
 
1740
                    
 
1741
                    #wait until timeout or approved
 
1742
                    time = datetime.datetime.now()
 
1743
                    client.changedstate.acquire()
 
1744
                    client.changedstate.wait(
 
1745
                        float(timedelta_to_milliseconds(delay)
 
1746
                              / 1000))
 
1747
                    client.changedstate.release()
 
1748
                    time2 = datetime.datetime.now()
 
1749
                    if (time2 - time) >= delay:
 
1750
                        if not client.approved_by_default:
 
1751
                            logger.warning("Client %s timed out while"
 
1752
                                           " waiting for approval",
 
1753
                                           client.name)
 
1754
                            if self.server.use_dbus:
 
1755
                                # Emit D-Bus signal
 
1756
                                client.Rejected("Approval timed out")
 
1757
                            return
 
1758
                        else:
 
1759
                            break
 
1760
                    else:
 
1761
                        delay -= time2 - time
 
1762
                
 
1763
                sent_size = 0
 
1764
                while sent_size < len(client.secret):
 
1765
                    try:
 
1766
                        sent = session.send(client.secret[sent_size:])
 
1767
                    except gnutls.errors.GNUTLSError as error:
 
1768
                        logger.warning("gnutls send failed",
 
1769
                                       exc_info=error)
 
1770
                        return
 
1771
                    logger.debug("Sent: %d, remaining: %d",
 
1772
                                 sent, len(client.secret)
 
1773
                                 - (sent_size + sent))
 
1774
                    sent_size += sent
 
1775
                
 
1776
                logger.info("Sending secret to %s", client.name)
 
1777
                # bump the timeout using extended_timeout
 
1778
                client.bump_timeout(client.extended_timeout)
 
1779
                if self.server.use_dbus:
 
1780
                    # Emit D-Bus signal
 
1781
                    client.GotSecret()
 
1782
            
 
1783
            finally:
 
1784
                if approval_required:
 
1785
                    client.approvals_pending -= 1
 
1786
                try:
 
1787
                    session.bye()
 
1788
                except gnutls.errors.GNUTLSError as error:
 
1789
                    logger.warning("GnuTLS bye failed",
 
1790
                                   exc_info=error)
 
1791
    
 
1792
    @staticmethod
 
1793
    def peer_certificate(session):
 
1794
        "Return the peer's OpenPGP certificate as a bytestring"
 
1795
        # If not an OpenPGP certificate...
 
1796
        if (gnutls.library.functions
 
1797
            .gnutls_certificate_type_get(session._c_object)
 
1798
            != gnutls.library.constants.GNUTLS_CRT_OPENPGP):
 
1799
            # ...do the normal thing
 
1800
            return session.peer_certificate
 
1801
        list_size = ctypes.c_uint(1)
 
1802
        cert_list = (gnutls.library.functions
 
1803
                     .gnutls_certificate_get_peers
 
1804
                     (session._c_object, ctypes.byref(list_size)))
 
1805
        if not bool(cert_list) and list_size.value != 0:
 
1806
            raise gnutls.errors.GNUTLSError("error getting peer"
 
1807
                                            " certificate")
 
1808
        if list_size.value == 0:
 
1809
            return None
 
1810
        cert = cert_list[0]
 
1811
        return ctypes.string_at(cert.data, cert.size)
 
1812
    
 
1813
    @staticmethod
 
1814
    def fingerprint(openpgp):
 
1815
        "Convert an OpenPGP bytestring to a hexdigit fingerprint"
 
1816
        # New GnuTLS "datum" with the OpenPGP public key
 
1817
        datum = (gnutls.library.types
 
1818
                 .gnutls_datum_t(ctypes.cast(ctypes.c_char_p(openpgp),
 
1819
                                             ctypes.POINTER
 
1820
                                             (ctypes.c_ubyte)),
 
1821
                                 ctypes.c_uint(len(openpgp))))
 
1822
        # New empty GnuTLS certificate
 
1823
        crt = gnutls.library.types.gnutls_openpgp_crt_t()
 
1824
        (gnutls.library.functions
 
1825
         .gnutls_openpgp_crt_init(ctypes.byref(crt)))
 
1826
        # Import the OpenPGP public key into the certificate
 
1827
        (gnutls.library.functions
 
1828
         .gnutls_openpgp_crt_import(crt, ctypes.byref(datum),
 
1829
                                    gnutls.library.constants
 
1830
                                    .GNUTLS_OPENPGP_FMT_RAW))
 
1831
        # Verify the self signature in the key
 
1832
        crtverify = ctypes.c_uint()
 
1833
        (gnutls.library.functions
 
1834
         .gnutls_openpgp_crt_verify_self(crt, 0,
 
1835
                                         ctypes.byref(crtverify)))
 
1836
        if crtverify.value != 0:
 
1837
            gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
 
1838
            raise (gnutls.errors.CertificateSecurityError
 
1839
                   ("Verify failed"))
 
1840
        # New buffer for the fingerprint
 
1841
        buf = ctypes.create_string_buffer(20)
 
1842
        buf_len = ctypes.c_size_t()
 
1843
        # Get the fingerprint from the certificate into the buffer
 
1844
        (gnutls.library.functions
 
1845
         .gnutls_openpgp_crt_get_fingerprint(crt, ctypes.byref(buf),
 
1846
                                             ctypes.byref(buf_len)))
 
1847
        # Deinit the certificate
 
1848
        gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
 
1849
        # Convert the buffer to a Python bytestring
 
1850
        fpr = ctypes.string_at(buf, buf_len.value)
 
1851
        # Convert the bytestring to hexadecimal notation
 
1852
        hex_fpr = binascii.hexlify(fpr).upper()
 
1853
        return hex_fpr
 
1854
 
 
1855
 
 
1856
class MultiprocessingMixIn(object):
 
1857
    """Like socketserver.ThreadingMixIn, but with multiprocessing"""
 
1858
    def sub_process_main(self, request, address):
 
1859
        try:
 
1860
            self.finish_request(request, address)
 
1861
        except Exception:
 
1862
            self.handle_error(request, address)
 
1863
        self.close_request(request)
 
1864
    
 
1865
    def process_request(self, request, address):
 
1866
        """Start a new process to process the request."""
 
1867
        proc = multiprocessing.Process(target = self.sub_process_main,
 
1868
                                       args = (request, address))
 
1869
        proc.start()
 
1870
        return proc
 
1871
 
 
1872
 
 
1873
class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):
 
1874
    """ adds a pipe to the MixIn """
 
1875
    def process_request(self, request, client_address):
 
1876
        """Overrides and wraps the original process_request().
 
1877
        
 
1878
        This function creates a new pipe in self.pipe
 
1879
        """
 
1880
        parent_pipe, self.child_pipe = multiprocessing.Pipe()
 
1881
        
 
1882
        proc = MultiprocessingMixIn.process_request(self, request,
 
1883
                                                    client_address)
 
1884
        self.child_pipe.close()
 
1885
        self.add_pipe(parent_pipe, proc)
 
1886
    
 
1887
    def add_pipe(self, parent_pipe, proc):
 
1888
        """Dummy function; override as necessary"""
 
1889
        raise NotImplementedError
 
1890
 
 
1891
 
 
1892
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
 
1893
                     socketserver.TCPServer, object):
 
1894
    """IPv6-capable TCP server.  Accepts 'None' as address and/or port
 
1895
    
367
1896
    Attributes:
368
 
        options:        Command line options
369
 
        clients:        Set() of Client objects
 
1897
        enabled:        Boolean; whether this server is activated yet
 
1898
        interface:      None or a network interface name (string)
 
1899
        use_ipv6:       Boolean; to use IPv6 or not
370
1900
    """
371
 
    address_family = socket.AF_INET6
372
 
    def __init__(self, *args, **kwargs):
373
 
        if "options" in kwargs:
374
 
            self.options = kwargs["options"]
375
 
            del kwargs["options"]
376
 
        if "clients" in kwargs:
377
 
            self.clients = kwargs["clients"]
378
 
            del kwargs["clients"]
379
 
        return super(type(self), self).__init__(*args, **kwargs)
 
1901
    def __init__(self, server_address, RequestHandlerClass,
 
1902
                 interface=None, use_ipv6=True):
 
1903
        self.interface = interface
 
1904
        if use_ipv6:
 
1905
            self.address_family = socket.AF_INET6
 
1906
        socketserver.TCPServer.__init__(self, server_address,
 
1907
                                        RequestHandlerClass)
380
1908
    def server_bind(self):
381
1909
        """This overrides the normal server_bind() function
382
1910
        to bind to an interface if one was specified, and also NOT to
383
1911
        bind to an address or port if they were not specified."""
384
 
        if self.options.interface:
385
 
            if not hasattr(socket, "SO_BINDTODEVICE"):
386
 
                # From /usr/include/asm-i486/socket.h
387
 
                socket.SO_BINDTODEVICE = 25
388
 
            try:
389
 
                self.socket.setsockopt(socket.SOL_SOCKET,
390
 
                                       socket.SO_BINDTODEVICE,
391
 
                                       self.options.interface)
392
 
            except socket.error, error:
393
 
                if error[0] == errno.EPERM:
394
 
                    logger.warning(u"No permission to"
395
 
                                   u" bind to interface %s",
396
 
                                   self.options.interface)
397
 
                else:
398
 
                    raise error
 
1912
        if self.interface is not None:
 
1913
            if SO_BINDTODEVICE is None:
 
1914
                logger.error("SO_BINDTODEVICE does not exist;"
 
1915
                             " cannot bind to interface %s",
 
1916
                             self.interface)
 
1917
            else:
 
1918
                try:
 
1919
                    self.socket.setsockopt(socket.SOL_SOCKET,
 
1920
                                           SO_BINDTODEVICE,
 
1921
                                           str(self.interface
 
1922
                                               + '\0'))
 
1923
                except socket.error as error:
 
1924
                    if error.errno == errno.EPERM:
 
1925
                        logger.error("No permission to"
 
1926
                                     " bind to interface %s",
 
1927
                                     self.interface)
 
1928
                    elif error.errno == errno.ENOPROTOOPT:
 
1929
                        logger.error("SO_BINDTODEVICE not available;"
 
1930
                                     " cannot bind to interface %s",
 
1931
                                     self.interface)
 
1932
                    elif error.errno == errno.ENODEV:
 
1933
                        logger.error("Interface %s does not"
 
1934
                                     " exist, cannot bind",
 
1935
                                     self.interface)
 
1936
                    else:
 
1937
                        raise
399
1938
        # Only bind(2) the socket if we really need to.
400
1939
        if self.server_address[0] or self.server_address[1]:
401
1940
            if not self.server_address[0]:
402
 
                in6addr_any = "::"
403
 
                self.server_address = (in6addr_any,
 
1941
                if self.address_family == socket.AF_INET6:
 
1942
                    any_address = "::" # in6addr_any
 
1943
                else:
 
1944
                    any_address = socket.INADDR_ANY
 
1945
                self.server_address = (any_address,
404
1946
                                       self.server_address[1])
405
 
            elif self.server_address[1] is None:
 
1947
            elif not self.server_address[1]:
406
1948
                self.server_address = (self.server_address[0],
407
1949
                                       0)
408
 
            return super(type(self), self).server_bind()
 
1950
#                 if self.interface:
 
1951
#                     self.server_address = (self.server_address[0],
 
1952
#                                            0, # port
 
1953
#                                            0, # flowinfo
 
1954
#                                            if_nametoindex
 
1955
#                                            (self.interface))
 
1956
            return socketserver.TCPServer.server_bind(self)
 
1957
 
 
1958
 
 
1959
class MandosServer(IPv6_TCPServer):
 
1960
    """Mandos server.
 
1961
    
 
1962
    Attributes:
 
1963
        clients:        set of Client objects
 
1964
        gnutls_priority GnuTLS priority string
 
1965
        use_dbus:       Boolean; to emit D-Bus signals or not
 
1966
    
 
1967
    Assumes a gobject.MainLoop event loop.
 
1968
    """
 
1969
    def __init__(self, server_address, RequestHandlerClass,
 
1970
                 interface=None, use_ipv6=True, clients=None,
 
1971
                 gnutls_priority=None, use_dbus=True):
 
1972
        self.enabled = False
 
1973
        self.clients = clients
 
1974
        if self.clients is None:
 
1975
            self.clients = {}
 
1976
        self.use_dbus = use_dbus
 
1977
        self.gnutls_priority = gnutls_priority
 
1978
        IPv6_TCPServer.__init__(self, server_address,
 
1979
                                RequestHandlerClass,
 
1980
                                interface = interface,
 
1981
                                use_ipv6 = use_ipv6)
 
1982
    def server_activate(self):
 
1983
        if self.enabled:
 
1984
            return socketserver.TCPServer.server_activate(self)
 
1985
    
 
1986
    def enable(self):
 
1987
        self.enabled = True
 
1988
    
 
1989
    def add_pipe(self, parent_pipe, proc):
 
1990
        # Call "handle_ipc" for both data and EOF events
 
1991
        gobject.io_add_watch(parent_pipe.fileno(),
 
1992
                             gobject.IO_IN | gobject.IO_HUP,
 
1993
                             functools.partial(self.handle_ipc,
 
1994
                                               parent_pipe =
 
1995
                                               parent_pipe,
 
1996
                                               proc = proc))
 
1997
    
 
1998
    def handle_ipc(self, source, condition, parent_pipe=None,
 
1999
                   proc = None, client_object=None):
 
2000
        # error, or the other end of multiprocessing.Pipe has closed
 
2001
        if condition & (gobject.IO_ERR | gobject.IO_HUP):
 
2002
            # Wait for other process to exit
 
2003
            proc.join()
 
2004
            return False
 
2005
        
 
2006
        # Read a request from the child
 
2007
        request = parent_pipe.recv()
 
2008
        command = request[0]
 
2009
        
 
2010
        if command == 'init':
 
2011
            fpr = request[1]
 
2012
            address = request[2]
 
2013
            
 
2014
            for c in self.clients.itervalues():
 
2015
                if c.fingerprint == fpr:
 
2016
                    client = c
 
2017
                    break
 
2018
            else:
 
2019
                logger.info("Client not found for fingerprint: %s, ad"
 
2020
                            "dress: %s", fpr, address)
 
2021
                if self.use_dbus:
 
2022
                    # Emit D-Bus signal
 
2023
                    mandos_dbus_service.ClientNotFound(fpr,
 
2024
                                                       address[0])
 
2025
                parent_pipe.send(False)
 
2026
                return False
 
2027
            
 
2028
            gobject.io_add_watch(parent_pipe.fileno(),
 
2029
                                 gobject.IO_IN | gobject.IO_HUP,
 
2030
                                 functools.partial(self.handle_ipc,
 
2031
                                                   parent_pipe =
 
2032
                                                   parent_pipe,
 
2033
                                                   proc = proc,
 
2034
                                                   client_object =
 
2035
                                                   client))
 
2036
            parent_pipe.send(True)
 
2037
            # remove the old hook in favor of the new above hook on
 
2038
            # same fileno
 
2039
            return False
 
2040
        if command == 'funcall':
 
2041
            funcname = request[1]
 
2042
            args = request[2]
 
2043
            kwargs = request[3]
 
2044
            
 
2045
            parent_pipe.send(('data', getattr(client_object,
 
2046
                                              funcname)(*args,
 
2047
                                                         **kwargs)))
 
2048
        
 
2049
        if command == 'getattr':
 
2050
            attrname = request[1]
 
2051
            if callable(client_object.__getattribute__(attrname)):
 
2052
                parent_pipe.send(('function',))
 
2053
            else:
 
2054
                parent_pipe.send(('data', client_object
 
2055
                                  .__getattribute__(attrname)))
 
2056
        
 
2057
        if command == 'setattr':
 
2058
            attrname = request[1]
 
2059
            value = request[2]
 
2060
            setattr(client_object, attrname, value)
 
2061
        
 
2062
        return True
409
2063
 
410
2064
 
411
2065
def string_to_delta(interval):
412
2066
    """Parse a string and return a datetime.timedelta
413
 
 
 
2067
    
414
2068
    >>> string_to_delta('7d')
415
2069
    datetime.timedelta(7)
416
2070
    >>> string_to_delta('60s')
419
2073
    datetime.timedelta(0, 3600)
420
2074
    >>> string_to_delta('24h')
421
2075
    datetime.timedelta(1)
422
 
    >>> string_to_delta(u'1w')
 
2076
    >>> string_to_delta('1w')
423
2077
    datetime.timedelta(7)
 
2078
    >>> string_to_delta('5m 30s')
 
2079
    datetime.timedelta(0, 330)
424
2080
    """
425
 
    try:
426
 
        suffix=unicode(interval[-1])
427
 
        value=int(interval[:-1])
428
 
        if suffix == u"d":
429
 
            delta = datetime.timedelta(value)
430
 
        elif suffix == u"s":
431
 
            delta = datetime.timedelta(0, value)
432
 
        elif suffix == u"m":
433
 
            delta = datetime.timedelta(0, 0, 0, 0, value)
434
 
        elif suffix == u"h":
435
 
            delta = datetime.timedelta(0, 0, 0, 0, 0, value)
436
 
        elif suffix == u"w":
437
 
            delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
438
 
        else:
439
 
            raise ValueError
440
 
    except (ValueError, IndexError):
441
 
        raise ValueError
442
 
    return delta
443
 
 
444
 
 
445
 
def add_service():
446
 
    """From the Avahi server example code"""
447
 
    global group, serviceName, serviceType, servicePort, serviceTXT, \
448
 
           domain, host
449
 
    if group is None:
450
 
        group = dbus.Interface(
451
 
                bus.get_object( avahi.DBUS_NAME,
452
 
                                server.EntryGroupNew()),
453
 
                avahi.DBUS_INTERFACE_ENTRY_GROUP)
454
 
        group.connect_to_signal('StateChanged',
455
 
                                entry_group_state_changed)
456
 
    logger.debug(u"Adding service '%s' of type '%s' ...",
457
 
                 serviceName, serviceType)
458
 
    
459
 
    group.AddService(
460
 
            serviceInterface,           # interface
461
 
            avahi.PROTO_INET6,          # protocol
462
 
            dbus.UInt32(0),             # flags
463
 
            serviceName, serviceType,
464
 
            domain, host,
465
 
            dbus.UInt16(servicePort),
466
 
            avahi.string_array_to_txt_array(serviceTXT))
467
 
    group.Commit()
468
 
 
469
 
 
470
 
def remove_service():
471
 
    """From the Avahi server example code"""
472
 
    global group
473
 
    
474
 
    if not group is None:
475
 
        group.Reset()
476
 
 
477
 
 
478
 
def server_state_changed(state):
479
 
    """From the Avahi server example code"""
480
 
    if state == avahi.SERVER_COLLISION:
481
 
        logger.warning(u"Server name collision")
482
 
        remove_service()
483
 
    elif state == avahi.SERVER_RUNNING:
484
 
        add_service()
485
 
 
486
 
 
487
 
def entry_group_state_changed(state, error):
488
 
    """From the Avahi server example code"""
489
 
    global serviceName, server, rename_count
490
 
    
491
 
    logger.debug(u"state change: %i", state)
492
 
    
493
 
    if state == avahi.ENTRY_GROUP_ESTABLISHED:
494
 
        logger.debug(u"Service established.")
495
 
    elif state == avahi.ENTRY_GROUP_COLLISION:
496
 
        
497
 
        rename_count = rename_count - 1
498
 
        if rename_count > 0:
499
 
            name = server.GetAlternativeServiceName(name)
500
 
            logger.warning(u"Service name collision, "
501
 
                           u"changing name to '%s' ...", name)
502
 
            remove_service()
503
 
            add_service()
504
 
            
505
 
        else:
506
 
            logger.error(u"No suitable service name found "
507
 
                         u"after %i retries, exiting.",
508
 
                         n_rename)
509
 
            main_loop.quit()
510
 
    elif state == avahi.ENTRY_GROUP_FAILURE:
511
 
        logger.error(u"Error in group state changed %s",
512
 
                     unicode(error))
513
 
        main_loop.quit()
514
 
        return
515
 
 
516
 
 
517
 
def if_nametoindex(interface):
518
 
    """Call the C function if_nametoindex()"""
519
 
    try:
520
 
        libc = ctypes.cdll.LoadLibrary("libc.so.6")
521
 
        return libc.if_nametoindex(interface)
522
 
    except (OSError, AttributeError):
523
 
        if "struct" not in sys.modules:
524
 
            import struct
525
 
        if "fcntl" not in sys.modules:
526
 
            import fcntl
527
 
        SIOCGIFINDEX = 0x8933      # From /usr/include/linux/sockios.h
528
 
        s = socket.socket()
529
 
        ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
530
 
                            struct.pack("16s16x", interface))
531
 
        s.close()
532
 
        interface_index = struct.unpack("I", ifreq[16:20])[0]
533
 
        return interface_index
534
 
 
535
 
 
536
 
if __name__ == '__main__':
537
 
    parser = OptionParser()
538
 
    parser.add_option("-i", "--interface", type="string",
539
 
                      default=None, metavar="IF",
540
 
                      help="Bind to interface IF")
541
 
    parser.add_option("--cert", type="string", default="cert.pem",
542
 
                      metavar="FILE",
543
 
                      help="Public key certificate PEM file to use")
544
 
    parser.add_option("--key", type="string", default="key.pem",
545
 
                      metavar="FILE",
546
 
                      help="Private key PEM file to use")
547
 
    parser.add_option("--ca", type="string", default="ca.pem",
548
 
                      metavar="FILE",
549
 
                      help="Certificate Authority certificate PEM file to use")
550
 
    parser.add_option("--crl", type="string", default="crl.pem",
551
 
                      metavar="FILE",
552
 
                      help="Certificate Revokation List PEM file to use")
553
 
    parser.add_option("-p", "--port", type="int", default=None,
554
 
                      help="Port number to receive requests on")
555
 
    parser.add_option("--timeout", type="string", # Parsed later
556
 
                      default="1h",
557
 
                      help="Amount of downtime allowed for clients")
558
 
    parser.add_option("--interval", type="string", # Parsed later
559
 
                      default="5m",
560
 
                      help="How often to check that a client is up")
561
 
    parser.add_option("--check", action="store_true", default=False,
562
 
                      help="Run self-test")
563
 
    parser.add_option("--debug", action="store_true", default=False,
564
 
                      help="Debug mode")
565
 
    (options, args) = parser.parse_args()
 
2081
    timevalue = datetime.timedelta(0)
 
2082
    for s in interval.split():
 
2083
        try:
 
2084
            suffix = unicode(s[-1])
 
2085
            value = int(s[:-1])
 
2086
            if suffix == "d":
 
2087
                delta = datetime.timedelta(value)
 
2088
            elif suffix == "s":
 
2089
                delta = datetime.timedelta(0, value)
 
2090
            elif suffix == "m":
 
2091
                delta = datetime.timedelta(0, 0, 0, 0, value)
 
2092
            elif suffix == "h":
 
2093
                delta = datetime.timedelta(0, 0, 0, 0, 0, value)
 
2094
            elif suffix == "w":
 
2095
                delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
 
2096
            else:
 
2097
                raise ValueError("Unknown suffix {0!r}"
 
2098
                                 .format(suffix))
 
2099
        except (ValueError, IndexError) as e:
 
2100
            raise ValueError(*(e.args))
 
2101
        timevalue += delta
 
2102
    return timevalue
 
2103
 
 
2104
 
 
2105
def daemon(nochdir = False, noclose = False):
 
2106
    """See daemon(3).  Standard BSD Unix function.
 
2107
    
 
2108
    This should really exist as os.daemon, but it doesn't (yet)."""
 
2109
    if os.fork():
 
2110
        sys.exit()
 
2111
    os.setsid()
 
2112
    if not nochdir:
 
2113
        os.chdir("/")
 
2114
    if os.fork():
 
2115
        sys.exit()
 
2116
    if not noclose:
 
2117
        # Close all standard open file descriptors
 
2118
        null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)
 
2119
        if not stat.S_ISCHR(os.fstat(null).st_mode):
 
2120
            raise OSError(errno.ENODEV,
 
2121
                          "{0} not a character device"
 
2122
                          .format(os.devnull))
 
2123
        os.dup2(null, sys.stdin.fileno())
 
2124
        os.dup2(null, sys.stdout.fileno())
 
2125
        os.dup2(null, sys.stderr.fileno())
 
2126
        if null > 2:
 
2127
            os.close(null)
 
2128
 
 
2129
 
 
2130
def main():
 
2131
    
 
2132
    ##################################################################
 
2133
    # Parsing of options, both command line and config file
 
2134
    
 
2135
    parser = argparse.ArgumentParser()
 
2136
    parser.add_argument("-v", "--version", action="version",
 
2137
                        version = "%(prog)s {0}".format(version),
 
2138
                        help="show version number and exit")
 
2139
    parser.add_argument("-i", "--interface", metavar="IF",
 
2140
                        help="Bind to interface IF")
 
2141
    parser.add_argument("-a", "--address",
 
2142
                        help="Address to listen for requests on")
 
2143
    parser.add_argument("-p", "--port", type=int,
 
2144
                        help="Port number to receive requests on")
 
2145
    parser.add_argument("--check", action="store_true",
 
2146
                        help="Run self-test")
 
2147
    parser.add_argument("--debug", action="store_true",
 
2148
                        help="Debug mode; run in foreground and log"
 
2149
                        " to terminal")
 
2150
    parser.add_argument("--debuglevel", metavar="LEVEL",
 
2151
                        help="Debug level for stdout output")
 
2152
    parser.add_argument("--priority", help="GnuTLS"
 
2153
                        " priority string (see GnuTLS documentation)")
 
2154
    parser.add_argument("--servicename",
 
2155
                        metavar="NAME", help="Zeroconf service name")
 
2156
    parser.add_argument("--configdir",
 
2157
                        default="/etc/mandos", metavar="DIR",
 
2158
                        help="Directory to search for configuration"
 
2159
                        " files")
 
2160
    parser.add_argument("--no-dbus", action="store_false",
 
2161
                        dest="use_dbus", help="Do not provide D-Bus"
 
2162
                        " system bus interface")
 
2163
    parser.add_argument("--no-ipv6", action="store_false",
 
2164
                        dest="use_ipv6", help="Do not use IPv6")
 
2165
    parser.add_argument("--no-restore", action="store_false",
 
2166
                        dest="restore", help="Do not restore stored"
 
2167
                        " state")
 
2168
    parser.add_argument("--statedir", metavar="DIR",
 
2169
                        help="Directory to save/restore state in")
 
2170
    
 
2171
    options = parser.parse_args()
566
2172
    
567
2173
    if options.check:
568
2174
        import doctest
569
2175
        doctest.testmod()
570
2176
        sys.exit()
571
2177
    
572
 
    # Parse the time arguments
573
 
    try:
574
 
        options.timeout = string_to_delta(options.timeout)
575
 
    except ValueError:
576
 
        parser.error("option --timeout: Unparseable time")
577
 
    try:
578
 
        options.interval = string_to_delta(options.interval)
579
 
    except ValueError:
580
 
        parser.error("option --interval: Unparseable time")
581
 
    
582
 
    # Parse config file
583
 
    defaults = { "checker": "sleep 1; fping -q -- %%(fqdn)s" }
584
 
    client_config = ConfigParser.SafeConfigParser(defaults)
585
 
    #client_config.readfp(open("secrets.conf"), "secrets.conf")
586
 
    client_config.read("mandos-clients.conf")
587
 
    
588
 
    # From the Avahi server example code
589
 
    DBusGMainLoop(set_as_default=True )
 
2178
    # Default values for config file for server-global settings
 
2179
    server_defaults = { "interface": "",
 
2180
                        "address": "",
 
2181
                        "port": "",
 
2182
                        "debug": "False",
 
2183
                        "priority":
 
2184
                        "SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
 
2185
                        "servicename": "Mandos",
 
2186
                        "use_dbus": "True",
 
2187
                        "use_ipv6": "True",
 
2188
                        "debuglevel": "",
 
2189
                        "restore": "True",
 
2190
                        "statedir": "/var/lib/mandos"
 
2191
                        }
 
2192
    
 
2193
    # Parse config file for server-global settings
 
2194
    server_config = configparser.SafeConfigParser(server_defaults)
 
2195
    del server_defaults
 
2196
    server_config.read(os.path.join(options.configdir,
 
2197
                                    "mandos.conf"))
 
2198
    # Convert the SafeConfigParser object to a dict
 
2199
    server_settings = server_config.defaults()
 
2200
    # Use the appropriate methods on the non-string config options
 
2201
    for option in ("debug", "use_dbus", "use_ipv6"):
 
2202
        server_settings[option] = server_config.getboolean("DEFAULT",
 
2203
                                                           option)
 
2204
    if server_settings["port"]:
 
2205
        server_settings["port"] = server_config.getint("DEFAULT",
 
2206
                                                       "port")
 
2207
    del server_config
 
2208
    
 
2209
    # Override the settings from the config file with command line
 
2210
    # options, if set.
 
2211
    for option in ("interface", "address", "port", "debug",
 
2212
                   "priority", "servicename", "configdir",
 
2213
                   "use_dbus", "use_ipv6", "debuglevel", "restore",
 
2214
                   "statedir"):
 
2215
        value = getattr(options, option)
 
2216
        if value is not None:
 
2217
            server_settings[option] = value
 
2218
    del options
 
2219
    # Force all strings to be unicode
 
2220
    for option in server_settings.keys():
 
2221
        if type(server_settings[option]) is str:
 
2222
            server_settings[option] = unicode(server_settings[option])
 
2223
    # Now we have our good server settings in "server_settings"
 
2224
    
 
2225
    ##################################################################
 
2226
    
 
2227
    # For convenience
 
2228
    debug = server_settings["debug"]
 
2229
    debuglevel = server_settings["debuglevel"]
 
2230
    use_dbus = server_settings["use_dbus"]
 
2231
    use_ipv6 = server_settings["use_ipv6"]
 
2232
    stored_state_path = os.path.join(server_settings["statedir"],
 
2233
                                     stored_state_file)
 
2234
    
 
2235
    if debug:
 
2236
        initlogger(debug, logging.DEBUG)
 
2237
    else:
 
2238
        if not debuglevel:
 
2239
            initlogger(debug)
 
2240
        else:
 
2241
            level = getattr(logging, debuglevel.upper())
 
2242
            initlogger(debug, level)
 
2243
    
 
2244
    if server_settings["servicename"] != "Mandos":
 
2245
        syslogger.setFormatter(logging.Formatter
 
2246
                               ('Mandos ({0}) [%(process)d]:'
 
2247
                                ' %(levelname)s: %(message)s'
 
2248
                                .format(server_settings
 
2249
                                        ["servicename"])))
 
2250
    
 
2251
    # Parse config file with clients
 
2252
    client_config = configparser.SafeConfigParser(Client
 
2253
                                                  .client_defaults)
 
2254
    client_config.read(os.path.join(server_settings["configdir"],
 
2255
                                    "clients.conf"))
 
2256
    
 
2257
    global mandos_dbus_service
 
2258
    mandos_dbus_service = None
 
2259
    
 
2260
    tcp_server = MandosServer((server_settings["address"],
 
2261
                               server_settings["port"]),
 
2262
                              ClientHandler,
 
2263
                              interface=(server_settings["interface"]
 
2264
                                         or None),
 
2265
                              use_ipv6=use_ipv6,
 
2266
                              gnutls_priority=
 
2267
                              server_settings["priority"],
 
2268
                              use_dbus=use_dbus)
 
2269
    if not debug:
 
2270
        pidfilename = "/var/run/mandos.pid"
 
2271
        try:
 
2272
            pidfile = open(pidfilename, "w")
 
2273
        except IOError as e:
 
2274
            logger.error("Could not open file %r", pidfilename,
 
2275
                         exc_info=e)
 
2276
    
 
2277
    for name in ("_mandos", "mandos", "nobody"):
 
2278
        try:
 
2279
            uid = pwd.getpwnam(name).pw_uid
 
2280
            gid = pwd.getpwnam(name).pw_gid
 
2281
            break
 
2282
        except KeyError:
 
2283
            continue
 
2284
    else:
 
2285
        uid = 65534
 
2286
        gid = 65534
 
2287
    try:
 
2288
        os.setgid(gid)
 
2289
        os.setuid(uid)
 
2290
    except OSError as error:
 
2291
        if error.errno != errno.EPERM:
 
2292
            raise error
 
2293
    
 
2294
    if debug:
 
2295
        # Enable all possible GnuTLS debugging
 
2296
        
 
2297
        # "Use a log level over 10 to enable all debugging options."
 
2298
        # - GnuTLS manual
 
2299
        gnutls.library.functions.gnutls_global_set_log_level(11)
 
2300
        
 
2301
        @gnutls.library.types.gnutls_log_func
 
2302
        def debug_gnutls(level, string):
 
2303
            logger.debug("GnuTLS: %s", string[:-1])
 
2304
        
 
2305
        (gnutls.library.functions
 
2306
         .gnutls_global_set_log_function(debug_gnutls))
 
2307
        
 
2308
        # Redirect stdin so all checkers get /dev/null
 
2309
        null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)
 
2310
        os.dup2(null, sys.stdin.fileno())
 
2311
        if null > 2:
 
2312
            os.close(null)
 
2313
    
 
2314
    # Need to fork before connecting to D-Bus
 
2315
    if not debug:
 
2316
        # Close all input and output, do double fork, etc.
 
2317
        daemon()
 
2318
    
 
2319
    gobject.threads_init()
 
2320
    
 
2321
    global main_loop
 
2322
    # From the Avahi example code
 
2323
    DBusGMainLoop(set_as_default=True)
590
2324
    main_loop = gobject.MainLoop()
591
2325
    bus = dbus.SystemBus()
592
 
    server = dbus.Interface(
593
 
            bus.get_object( avahi.DBUS_NAME, avahi.DBUS_PATH_SERVER ),
594
 
            avahi.DBUS_INTERFACE_SERVER )
595
 
    # End of Avahi example code
596
 
    
597
 
    debug = options.debug
598
 
    
599
 
    clients = Set()
600
 
    def remove_from_clients(client):
601
 
        clients.remove(client)
602
 
        if not clients:
603
 
            logger.debug(u"No clients left, exiting")
604
 
            main_loop.quit()
605
 
    
606
 
    clients.update(Set(Client(name=section, options=options,
607
 
                              stop_hook = remove_from_clients,
608
 
                              **(dict(client_config\
609
 
                                      .items(section))))
610
 
                       for section in client_config.sections()))
611
 
    for client in clients:
612
 
        client.start()
613
 
    
614
 
    tcp_server = IPv6_TCPServer((None, options.port),
615
 
                                tcp_handler,
616
 
                                options=options,
617
 
                                clients=clients)
618
 
    # Find out what random port we got
619
 
    servicePort = tcp_server.socket.getsockname()[1]
620
 
    logger.debug(u"Now listening on port %d", servicePort)
621
 
    
622
 
    if options.interface is not None:
623
 
        serviceInterface = if_nametoindex(options.interface)
624
 
    
625
 
    # From the Avahi server example code
626
 
    server.connect_to_signal("StateChanged", server_state_changed)
627
 
    server_state_changed(server.GetState())
628
 
    # End of Avahi example code
629
 
    
630
 
    gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,
631
 
                         lambda *args, **kwargs:
632
 
                         tcp_server.handle_request(*args[2:],
633
 
                                                   **kwargs) or True)
 
2326
    # End of Avahi example code
 
2327
    if use_dbus:
 
2328
        try:
 
2329
            bus_name = dbus.service.BusName("se.recompile.Mandos",
 
2330
                                            bus, do_not_queue=True)
 
2331
            old_bus_name = (dbus.service.BusName
 
2332
                            ("se.bsnet.fukt.Mandos", bus,
 
2333
                             do_not_queue=True))
 
2334
        except dbus.exceptions.NameExistsException as e:
 
2335
            logger.error("Disabling D-Bus:", exc_info=e)
 
2336
            use_dbus = False
 
2337
            server_settings["use_dbus"] = False
 
2338
            tcp_server.use_dbus = False
 
2339
    protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
 
2340
    service = AvahiServiceToSyslog(name =
 
2341
                                   server_settings["servicename"],
 
2342
                                   servicetype = "_mandos._tcp",
 
2343
                                   protocol = protocol, bus = bus)
 
2344
    if server_settings["interface"]:
 
2345
        service.interface = (if_nametoindex
 
2346
                             (str(server_settings["interface"])))
 
2347
    
 
2348
    global multiprocessing_manager
 
2349
    multiprocessing_manager = multiprocessing.Manager()
 
2350
    
 
2351
    client_class = Client
 
2352
    if use_dbus:
 
2353
        client_class = functools.partial(ClientDBus, bus = bus)
 
2354
    
 
2355
    client_settings = Client.config_parser(client_config)
 
2356
    old_client_settings = {}
 
2357
    clients_data = {}
 
2358
    
 
2359
    # Get client data and settings from last running state.
 
2360
    if server_settings["restore"]:
 
2361
        try:
 
2362
            with open(stored_state_path, "rb") as stored_state:
 
2363
                clients_data, old_client_settings = (pickle.load
 
2364
                                                     (stored_state))
 
2365
            os.remove(stored_state_path)
 
2366
        except IOError as e:
 
2367
            if e.errno == errno.ENOENT:
 
2368
                logger.warning("Could not load persistent state: {0}"
 
2369
                                .format(os.strerror(e.errno)))
 
2370
            else:
 
2371
                logger.critical("Could not load persistent state:",
 
2372
                                exc_info=e)
 
2373
                raise
 
2374
        except EOFError as e:
 
2375
            logger.warning("Could not load persistent state: "
 
2376
                           "EOFError:", exc_info=e)
 
2377
    
 
2378
    with PGPEngine() as pgp:
 
2379
        for client_name, client in clients_data.iteritems():
 
2380
            # Decide which value to use after restoring saved state.
 
2381
            # We have three different values: Old config file,
 
2382
            # new config file, and saved state.
 
2383
            # New config value takes precedence if it differs from old
 
2384
            # config value, otherwise use saved state.
 
2385
            for name, value in client_settings[client_name].items():
 
2386
                try:
 
2387
                    # For each value in new config, check if it
 
2388
                    # differs from the old config value (Except for
 
2389
                    # the "secret" attribute)
 
2390
                    if (name != "secret" and
 
2391
                        value != old_client_settings[client_name]
 
2392
                        [name]):
 
2393
                        client[name] = value
 
2394
                except KeyError:
 
2395
                    pass
 
2396
            
 
2397
            # Clients who has passed its expire date can still be
 
2398
            # enabled if its last checker was successful.  Clients
 
2399
            # whose checker succeeded before we stored its state is
 
2400
            # assumed to have successfully run all checkers during
 
2401
            # downtime.
 
2402
            if client["enabled"]:
 
2403
                if datetime.datetime.utcnow() >= client["expires"]:
 
2404
                    if not client["last_checked_ok"]:
 
2405
                        logger.warning(
 
2406
                            "disabling client {0} - Client never "
 
2407
                            "performed a successful checker"
 
2408
                            .format(client_name))
 
2409
                        client["enabled"] = False
 
2410
                    elif client["last_checker_status"] != 0:
 
2411
                        logger.warning(
 
2412
                            "disabling client {0} - Client "
 
2413
                            "last checker failed with error code {1}"
 
2414
                            .format(client_name,
 
2415
                                    client["last_checker_status"]))
 
2416
                        client["enabled"] = False
 
2417
                    else:
 
2418
                        client["expires"] = (datetime.datetime
 
2419
                                             .utcnow()
 
2420
                                             + client["timeout"])
 
2421
                        logger.debug("Last checker succeeded,"
 
2422
                                     " keeping {0} enabled"
 
2423
                                     .format(client_name))
 
2424
            try:
 
2425
                client["secret"] = (
 
2426
                    pgp.decrypt(client["encrypted_secret"],
 
2427
                                client_settings[client_name]
 
2428
                                ["secret"]))
 
2429
            except PGPError:
 
2430
                # If decryption fails, we use secret from new settings
 
2431
                logger.debug("Failed to decrypt {0} old secret"
 
2432
                             .format(client_name))
 
2433
                client["secret"] = (
 
2434
                    client_settings[client_name]["secret"])
 
2435
    
 
2436
    # Add/remove clients based on new changes made to config
 
2437
    for client_name in (set(old_client_settings)
 
2438
                        - set(client_settings)):
 
2439
        del clients_data[client_name]
 
2440
    for client_name in (set(client_settings)
 
2441
                        - set(old_client_settings)):
 
2442
        clients_data[client_name] = client_settings[client_name]
 
2443
    
 
2444
    # Create all client objects
 
2445
    for client_name, client in clients_data.iteritems():
 
2446
        tcp_server.clients[client_name] = client_class(
 
2447
            name = client_name, settings = client)
 
2448
    
 
2449
    if not tcp_server.clients:
 
2450
        logger.warning("No clients defined")
 
2451
    
 
2452
    if not debug:
 
2453
        try:
 
2454
            with pidfile:
 
2455
                pid = os.getpid()
 
2456
                pidfile.write(str(pid) + "\n".encode("utf-8"))
 
2457
            del pidfile
 
2458
        except IOError:
 
2459
            logger.error("Could not write to file %r with PID %d",
 
2460
                         pidfilename, pid)
 
2461
        except NameError:
 
2462
            # "pidfile" was never created
 
2463
            pass
 
2464
        del pidfilename
 
2465
    
 
2466
    signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
 
2467
    signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
 
2468
    
 
2469
    if use_dbus:
 
2470
        @alternate_dbus_interfaces({"se.recompile.Mandos":
 
2471
                                        "se.bsnet.fukt.Mandos"})
 
2472
        class MandosDBusService(DBusObjectWithProperties):
 
2473
            """A D-Bus proxy object"""
 
2474
            def __init__(self):
 
2475
                dbus.service.Object.__init__(self, bus, "/")
 
2476
            _interface = "se.recompile.Mandos"
 
2477
            
 
2478
            @dbus_interface_annotations(_interface)
 
2479
            def _foo(self):
 
2480
                return { "org.freedesktop.DBus.Property"
 
2481
                         ".EmitsChangedSignal":
 
2482
                             "false"}
 
2483
            
 
2484
            @dbus.service.signal(_interface, signature="o")
 
2485
            def ClientAdded(self, objpath):
 
2486
                "D-Bus signal"
 
2487
                pass
 
2488
            
 
2489
            @dbus.service.signal(_interface, signature="ss")
 
2490
            def ClientNotFound(self, fingerprint, address):
 
2491
                "D-Bus signal"
 
2492
                pass
 
2493
            
 
2494
            @dbus.service.signal(_interface, signature="os")
 
2495
            def ClientRemoved(self, objpath, name):
 
2496
                "D-Bus signal"
 
2497
                pass
 
2498
            
 
2499
            @dbus.service.method(_interface, out_signature="ao")
 
2500
            def GetAllClients(self):
 
2501
                "D-Bus method"
 
2502
                return dbus.Array(c.dbus_object_path
 
2503
                                  for c in
 
2504
                                  tcp_server.clients.itervalues())
 
2505
            
 
2506
            @dbus.service.method(_interface,
 
2507
                                 out_signature="a{oa{sv}}")
 
2508
            def GetAllClientsWithProperties(self):
 
2509
                "D-Bus method"
 
2510
                return dbus.Dictionary(
 
2511
                    ((c.dbus_object_path, c.GetAll(""))
 
2512
                     for c in tcp_server.clients.itervalues()),
 
2513
                    signature="oa{sv}")
 
2514
            
 
2515
            @dbus.service.method(_interface, in_signature="o")
 
2516
            def RemoveClient(self, object_path):
 
2517
                "D-Bus method"
 
2518
                for c in tcp_server.clients.itervalues():
 
2519
                    if c.dbus_object_path == object_path:
 
2520
                        del tcp_server.clients[c.name]
 
2521
                        c.remove_from_connection()
 
2522
                        # Don't signal anything except ClientRemoved
 
2523
                        c.disable(quiet=True)
 
2524
                        # Emit D-Bus signal
 
2525
                        self.ClientRemoved(object_path, c.name)
 
2526
                        return
 
2527
                raise KeyError(object_path)
 
2528
            
 
2529
            del _interface
 
2530
        
 
2531
        mandos_dbus_service = MandosDBusService()
 
2532
    
 
2533
    def cleanup():
 
2534
        "Cleanup function; run on exit"
 
2535
        service.cleanup()
 
2536
        
 
2537
        multiprocessing.active_children()
 
2538
        if not (tcp_server.clients or client_settings):
 
2539
            return
 
2540
        
 
2541
        # Store client before exiting. Secrets are encrypted with key
 
2542
        # based on what config file has. If config file is
 
2543
        # removed/edited, old secret will thus be unrecovable.
 
2544
        clients = {}
 
2545
        with PGPEngine() as pgp:
 
2546
            for client in tcp_server.clients.itervalues():
 
2547
                key = client_settings[client.name]["secret"]
 
2548
                client.encrypted_secret = pgp.encrypt(client.secret,
 
2549
                                                      key)
 
2550
                client_dict = {}
 
2551
                
 
2552
                # A list of attributes that can not be pickled
 
2553
                # + secret.
 
2554
                exclude = set(("bus", "changedstate", "secret",
 
2555
                               "checker"))
 
2556
                for name, typ in (inspect.getmembers
 
2557
                                  (dbus.service.Object)):
 
2558
                    exclude.add(name)
 
2559
                
 
2560
                client_dict["encrypted_secret"] = (client
 
2561
                                                   .encrypted_secret)
 
2562
                for attr in client.client_structure:
 
2563
                    if attr not in exclude:
 
2564
                        client_dict[attr] = getattr(client, attr)
 
2565
                
 
2566
                clients[client.name] = client_dict
 
2567
                del client_settings[client.name]["secret"]
 
2568
        
 
2569
        try:
 
2570
            with (tempfile.NamedTemporaryFile
 
2571
                  (mode='wb', suffix=".pickle", prefix='clients-',
 
2572
                   dir=os.path.dirname(stored_state_path),
 
2573
                   delete=False)) as stored_state:
 
2574
                pickle.dump((clients, client_settings), stored_state)
 
2575
                tempname=stored_state.name
 
2576
            os.rename(tempname, stored_state_path)
 
2577
        except (IOError, OSError) as e:
 
2578
            if not debug:
 
2579
                try:
 
2580
                    os.remove(tempname)
 
2581
                except NameError:
 
2582
                    pass
 
2583
            if e.errno in (errno.ENOENT, errno.EACCES, errno.EEXIST):
 
2584
                logger.warning("Could not save persistent state: {0}"
 
2585
                               .format(os.strerror(e.errno)))
 
2586
            else:
 
2587
                logger.warning("Could not save persistent state:",
 
2588
                               exc_info=e)
 
2589
                raise e
 
2590
        
 
2591
        # Delete all clients, and settings from config
 
2592
        while tcp_server.clients:
 
2593
            name, client = tcp_server.clients.popitem()
 
2594
            if use_dbus:
 
2595
                client.remove_from_connection()
 
2596
            # Don't signal anything except ClientRemoved
 
2597
            client.disable(quiet=True)
 
2598
            if use_dbus:
 
2599
                # Emit D-Bus signal
 
2600
                mandos_dbus_service.ClientRemoved(client
 
2601
                                                  .dbus_object_path,
 
2602
                                                  client.name)
 
2603
        client_settings.clear()
 
2604
    
 
2605
    atexit.register(cleanup)
 
2606
    
 
2607
    for client in tcp_server.clients.itervalues():
 
2608
        if use_dbus:
 
2609
            # Emit D-Bus signal
 
2610
            mandos_dbus_service.ClientAdded(client.dbus_object_path)
 
2611
        # Need to initiate checking of clients
 
2612
        if client.enabled:
 
2613
            client.init_checker()
 
2614
    
 
2615
    tcp_server.enable()
 
2616
    tcp_server.server_activate()
 
2617
    
 
2618
    # Find out what port we got
 
2619
    service.port = tcp_server.socket.getsockname()[1]
 
2620
    if use_ipv6:
 
2621
        logger.info("Now listening on address %r, port %d,"
 
2622
                    " flowinfo %d, scope_id %d",
 
2623
                    *tcp_server.socket.getsockname())
 
2624
    else:                       # IPv4
 
2625
        logger.info("Now listening on address %r, port %d",
 
2626
                    *tcp_server.socket.getsockname())
 
2627
    
 
2628
    #service.interface = tcp_server.socket.getsockname()[3]
 
2629
    
634
2630
    try:
 
2631
        # From the Avahi example code
 
2632
        try:
 
2633
            service.activate()
 
2634
        except dbus.exceptions.DBusException as error:
 
2635
            logger.critical("D-Bus Exception", exc_info=error)
 
2636
            cleanup()
 
2637
            sys.exit(1)
 
2638
        # End of Avahi example code
 
2639
        
 
2640
        gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,
 
2641
                             lambda *args, **kwargs:
 
2642
                             (tcp_server.handle_request
 
2643
                              (*args[2:], **kwargs) or True))
 
2644
        
 
2645
        logger.debug("Starting main loop")
635
2646
        main_loop.run()
 
2647
    except AvahiError as error:
 
2648
        logger.critical("Avahi Error", exc_info=error)
 
2649
        cleanup()
 
2650
        sys.exit(1)
636
2651
    except KeyboardInterrupt:
637
 
        print
638
 
    
639
 
    # Cleanup here
 
2652
        if debug:
 
2653
            print("", file=sys.stderr)
 
2654
        logger.debug("Server received KeyboardInterrupt")
 
2655
    logger.debug("Server exiting")
 
2656
    # Must run before the D-Bus bus name gets deregistered
 
2657
    cleanup()
640
2658
 
641
 
    # From the Avahi server example code
642
 
    if not group is None:
643
 
        group.Free()
644
 
    # End of Avahi example code
645
 
    
646
 
    for client in clients:
647
 
        client.stop_hook = None
648
 
        client.stop()
 
2659
if __name__ == '__main__':
 
2660
    main()