/mandos/release

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

« back to all changes in this revision

Viewing changes to mandos

  • Committer: Teddy Hogeborn
  • Date: 2015-07-12 01:41:14 UTC
  • mto: (237.7.594 trunk)
  • mto: This revision was merged to the branch mainline in revision 325.
  • Revision ID: teddy@recompile.se-20150712014114-qbala4mutkixxct3
Handle local Zeroconf service name collisions on startup, too.

* mandos (AvahiService.server_state_changed): Catch name collision
                                              error when adding
                                              server.

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