/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

* mandos-ctl (main): Bug fix: Handle empty strings correctly.

Show diffs side-by-side

added added

removed removed

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