/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: 2015-03-10 18:03:38 UTC
  • Revision ID: teddy@recompile.se-20150310180338-pcxw6r2qmw9k6br9
Add ":!RSA" to GnuTLS priority string, to disallow non-DHE kx.

If Mandos was somehow made to use a non-ephemeral Diffie-Hellman key
exchange algorithm in the TLS handshake, any saved network traffic
could then be decrypted later if the Mandos client key was obtained.
By default, Mandos uses ephemeral DH key exchanges which does not have
this problem, but a non-ephemeral key exchange algorithm was still
enabled by default.  The simplest solution is to simply turn that off,
which ensures that Mandos will always use ephemeral DH key exchanges.

There is a "PFS" priority string specifier, but we can't use it because:

1. Security-wise, it is a mix between "NORMAL" and "SECURE128" - it
   enables a lot more algorithms than "SECURE256".

2. It is only available since GnuTLS 3.2.4.

Thanks to Andreas Fischer <af@bantuX.org> for reporting this issue.

Show diffs side-by-side

added added

removed removed

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