/mandos/trunk

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

« back to all changes in this revision

Viewing changes to mandos

  • Committer: Teddy Hogeborn
  • Date: 2016-03-19 03:48:56 UTC
  • Revision ID: teddy@recompile.se-20160319034856-d8rox0kdxekgr03g
Server: Make persistent state directory mode u=rwx,go=

The Makefile target "install-server" creates the server persistent
state directory /var/lib/mandos as mode u=rwx,go= (0700).  Make this
also the case for the Debian package (unless overridden by
dpkg-statoverride).

* debian/mandos.postinst (configure): Fix state directory permissions,
  but only if not listed by "dpkg-statoverride".

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
#!/usr/bin/python3 -bI
2
 
# -*- mode: python; after-save-hook: (lambda () (let ((command (if (fboundp 'file-local-name) (file-local-name (buffer-file-name)) (or (file-remote-p (buffer-file-name) 'localname) (buffer-file-name))))) (if (= (progn (if (get-buffer "*Test*") (kill-buffer "*Test*")) (process-file-shell-command (format "%s --check" (shell-quote-argument command)) nil "*Test*")) 0) (let ((w (get-buffer-window "*Test*"))) (if w (delete-window w))) (progn (with-current-buffer "*Test*" (compilation-mode)) (display-buffer "*Test*" '(display-buffer-in-side-window)))))); coding: utf-8 -*-
3
 
#
 
1
#!/usr/bin/python
 
2
# -*- mode: python; coding: utf-8 -*-
 
3
4
4
# Mandos server - give out binary blobs to connecting clients.
5
 
#
 
5
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
9
# methods "add", "remove", "server_state_changed",
10
10
# "entry_group_state_changed", "cleanup", and "activate" in the
11
11
# "AvahiService" class, and some lines in "main".
12
 
#
 
12
13
13
# Everything else is
14
 
# Copyright © 2008-2020 Teddy Hogeborn
15
 
# Copyright © 2008-2020 Björn Påhlsson
16
 
#
17
 
# This file is part of Mandos.
18
 
#
19
 
# Mandos is free software: you can redistribute it and/or modify it
20
 
# under the terms of the GNU General Public License as published by
 
14
# Copyright © 2008-2016 Teddy Hogeborn
 
15
# Copyright © 2008-2016 Björn Påhlsson
 
16
 
17
# This program is free software: you can redistribute it and/or modify
 
18
# it under the terms of the GNU General Public License as published by
21
19
# the Free Software Foundation, either version 3 of the License, or
22
20
# (at your option) any later version.
23
21
#
24
 
#     Mandos is distributed in the hope that it will be useful, but
25
 
#     WITHOUT ANY WARRANTY; without even the implied warranty of
 
22
#     This program is distributed in the hope that it will be useful,
 
23
#     but WITHOUT ANY WARRANTY; without even the implied warranty of
26
24
#     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
27
25
#     GNU General Public License for more details.
28
 
#
 
26
29
27
# You should have received a copy of the GNU General Public License
30
 
# along with Mandos.  If not, see <http://www.gnu.org/licenses/>.
31
 
#
 
28
# along with this program.  If not, see
 
29
# <http://www.gnu.org/licenses/>.
 
30
32
31
# Contact the authors at <mandos@recompile.se>.
33
 
#
 
32
34
33
 
35
34
from __future__ import (division, absolute_import, print_function,
36
35
                        unicode_literals)
77
76
import itertools
78
77
import collections
79
78
import codecs
80
 
import unittest
81
 
import random
82
 
import shlex
83
79
 
84
80
import dbus
85
81
import dbus.service
86
 
import gi
87
82
from gi.repository import GLib
88
83
from dbus.mainloop.glib import DBusGMainLoop
89
84
import ctypes
91
86
import xml.dom.minidom
92
87
import inspect
93
88
 
94
 
if sys.version_info.major == 2:
95
 
    __metaclass__ = type
96
 
    str = unicode
97
 
 
98
 
# Add collections.abc.Callable if it does not exist
99
 
try:
100
 
    collections.abc.Callable
101
 
except AttributeError:
102
 
    class abc:
103
 
        Callable = collections.Callable
104
 
    collections.abc = abc
105
 
    del abc
106
 
 
107
 
# Add shlex.quote if it does not exist
108
 
try:
109
 
    shlex.quote
110
 
except AttributeError:
111
 
    shlex.quote = re.escape
112
 
 
113
 
# Show warnings by default
114
 
if not sys.warnoptions:
115
 
    import warnings
116
 
    warnings.simplefilter("default")
117
 
 
118
 
# Try to find the value of SO_BINDTODEVICE:
119
 
try:
120
 
    # This is where SO_BINDTODEVICE is in Python 3.3 (or 3.4?) and
121
 
    # newer, and it is also the most natural place for it:
 
89
try:
122
90
    SO_BINDTODEVICE = socket.SO_BINDTODEVICE
123
91
except AttributeError:
124
92
    try:
125
 
        # This is where SO_BINDTODEVICE was up to and including Python
126
 
        # 2.6, and also 3.2:
127
93
        from IN import SO_BINDTODEVICE
128
94
    except ImportError:
129
 
        # In Python 2.7 it seems to have been removed entirely.
130
 
        # Try running the C preprocessor:
131
 
        try:
132
 
            cc = subprocess.Popen(["cc", "--language=c", "-E",
133
 
                                   "/dev/stdin"],
134
 
                                  stdin=subprocess.PIPE,
135
 
                                  stdout=subprocess.PIPE)
136
 
            stdout = cc.communicate(
137
 
                "#include <sys/socket.h>\nSO_BINDTODEVICE\n")[0]
138
 
            SO_BINDTODEVICE = int(stdout.splitlines()[-1])
139
 
        except (OSError, ValueError, IndexError):
140
 
            # No value found
141
 
            SO_BINDTODEVICE = None
142
 
 
143
 
if sys.version_info < (3, 2):
144
 
    configparser.Configparser = configparser.SafeConfigParser
145
 
 
146
 
version = "1.8.14"
 
95
        SO_BINDTODEVICE = None
 
96
 
 
97
if sys.version_info.major == 2:
 
98
    str = unicode
 
99
 
 
100
version = "1.7.6"
147
101
stored_state_file = "clients.pickle"
148
102
 
149
103
logger = logging.getLogger()
150
 
logging.captureWarnings(True)   # Show warnings via the logging system
151
104
syslogger = None
152
105
 
153
106
try:
154
107
    if_nametoindex = ctypes.cdll.LoadLibrary(
155
108
        ctypes.util.find_library("c")).if_nametoindex
156
109
except (OSError, AttributeError):
157
 
 
 
110
    
158
111
    def if_nametoindex(interface):
159
112
        "Get an interface index the hard way, i.e. using fcntl()"
160
113
        SIOCGIFINDEX = 0x8933  # From /usr/include/linux/sockios.h
183
136
 
184
137
def initlogger(debug, level=logging.WARNING):
185
138
    """init logger and add loglevel"""
186
 
 
 
139
    
187
140
    global syslogger
188
141
    syslogger = (logging.handlers.SysLogHandler(
189
 
        facility=logging.handlers.SysLogHandler.LOG_DAEMON,
190
 
        address="/dev/log"))
 
142
        facility = logging.handlers.SysLogHandler.LOG_DAEMON,
 
143
        address = "/dev/log"))
191
144
    syslogger.setFormatter(logging.Formatter
192
 
                           ("Mandos [%(process)d]: %(levelname)s:"
193
 
                            " %(message)s"))
 
145
                           ('Mandos [%(process)d]: %(levelname)s:'
 
146
                            ' %(message)s'))
194
147
    logger.addHandler(syslogger)
195
 
 
 
148
    
196
149
    if debug:
197
150
        console = logging.StreamHandler()
198
 
        console.setFormatter(logging.Formatter("%(asctime)s %(name)s"
199
 
                                               " [%(process)d]:"
200
 
                                               " %(levelname)s:"
201
 
                                               " %(message)s"))
 
151
        console.setFormatter(logging.Formatter('%(asctime)s %(name)s'
 
152
                                               ' [%(process)d]:'
 
153
                                               ' %(levelname)s:'
 
154
                                               ' %(message)s'))
202
155
        logger.addHandler(console)
203
156
    logger.setLevel(level)
204
157
 
208
161
    pass
209
162
 
210
163
 
211
 
class PGPEngine:
 
164
class PGPEngine(object):
212
165
    """A simple class for OpenPGP symmetric encryption & decryption"""
213
 
 
 
166
    
214
167
    def __init__(self):
215
168
        self.tempdir = tempfile.mkdtemp(prefix="mandos-")
216
169
        self.gpg = "gpg"
218
171
            output = subprocess.check_output(["gpgconf"])
219
172
            for line in output.splitlines():
220
173
                name, text, path = line.split(b":")
221
 
                if name == b"gpg":
 
174
                if name == "gpg":
222
175
                    self.gpg = path
223
176
                    break
224
177
        except OSError as e:
225
178
            if e.errno != errno.ENOENT:
226
179
                raise
227
 
        self.gnupgargs = ["--batch",
228
 
                          "--homedir", self.tempdir,
229
 
                          "--force-mdc",
230
 
                          "--quiet"]
231
 
        # Only GPG version 1 has the --no-use-agent option.
232
 
        if self.gpg == b"gpg" or self.gpg.endswith(b"/gpg"):
233
 
            self.gnupgargs.append("--no-use-agent")
234
 
 
 
180
        self.gnupgargs = ['--batch',
 
181
                          '--homedir', self.tempdir,
 
182
                          '--force-mdc',
 
183
                          '--quiet',
 
184
                          '--no-use-agent']
 
185
    
235
186
    def __enter__(self):
236
187
        return self
237
 
 
 
188
    
238
189
    def __exit__(self, exc_type, exc_value, traceback):
239
190
        self._cleanup()
240
191
        return False
241
 
 
 
192
    
242
193
    def __del__(self):
243
194
        self._cleanup()
244
 
 
 
195
    
245
196
    def _cleanup(self):
246
197
        if self.tempdir is not None:
247
198
            # Delete contents of tempdir
248
199
            for root, dirs, files in os.walk(self.tempdir,
249
 
                                             topdown=False):
 
200
                                             topdown = False):
250
201
                for filename in files:
251
202
                    os.remove(os.path.join(root, filename))
252
203
                for dirname in dirs:
254
205
            # Remove tempdir
255
206
            os.rmdir(self.tempdir)
256
207
            self.tempdir = None
257
 
 
 
208
    
258
209
    def password_encode(self, password):
259
210
        # Passphrase can not be empty and can not contain newlines or
260
211
        # NUL bytes.  So we prefix it and hex encode it.
265
216
                       .replace(b"\n", b"\\n")
266
217
                       .replace(b"\0", b"\\x00"))
267
218
        return encoded
268
 
 
 
219
    
269
220
    def encrypt(self, data, password):
270
221
        passphrase = self.password_encode(password)
271
222
        with tempfile.NamedTemporaryFile(
272
223
                dir=self.tempdir) as passfile:
273
224
            passfile.write(passphrase)
274
225
            passfile.flush()
275
 
            proc = subprocess.Popen([self.gpg, "--symmetric",
276
 
                                     "--passphrase-file",
 
226
            proc = subprocess.Popen([self.gpg, '--symmetric',
 
227
                                     '--passphrase-file',
277
228
                                     passfile.name]
278
229
                                    + self.gnupgargs,
279
 
                                    stdin=subprocess.PIPE,
280
 
                                    stdout=subprocess.PIPE,
281
 
                                    stderr=subprocess.PIPE)
282
 
            ciphertext, err = proc.communicate(input=data)
 
230
                                    stdin = subprocess.PIPE,
 
231
                                    stdout = subprocess.PIPE,
 
232
                                    stderr = subprocess.PIPE)
 
233
            ciphertext, err = proc.communicate(input = data)
283
234
        if proc.returncode != 0:
284
235
            raise PGPError(err)
285
236
        return ciphertext
286
 
 
 
237
    
287
238
    def decrypt(self, data, password):
288
239
        passphrase = self.password_encode(password)
289
240
        with tempfile.NamedTemporaryFile(
290
 
                dir=self.tempdir) as passfile:
 
241
                dir = self.tempdir) as passfile:
291
242
            passfile.write(passphrase)
292
243
            passfile.flush()
293
 
            proc = subprocess.Popen([self.gpg, "--decrypt",
294
 
                                     "--passphrase-file",
 
244
            proc = subprocess.Popen([self.gpg, '--decrypt',
 
245
                                     '--passphrase-file',
295
246
                                     passfile.name]
296
247
                                    + self.gnupgargs,
297
 
                                    stdin=subprocess.PIPE,
298
 
                                    stdout=subprocess.PIPE,
299
 
                                    stderr=subprocess.PIPE)
300
 
            decrypted_plaintext, err = proc.communicate(input=data)
 
248
                                    stdin = subprocess.PIPE,
 
249
                                    stdout = subprocess.PIPE,
 
250
                                    stderr = subprocess.PIPE)
 
251
            decrypted_plaintext, err = proc.communicate(input = data)
301
252
        if proc.returncode != 0:
302
253
            raise PGPError(err)
303
254
        return decrypted_plaintext
304
255
 
305
 
 
306
256
# Pretend that we have an Avahi module
307
 
class avahi:
308
 
    """This isn't so much a class as it is a module-like namespace."""
309
 
    IF_UNSPEC = -1               # avahi-common/address.h
310
 
    PROTO_UNSPEC = -1            # avahi-common/address.h
311
 
    PROTO_INET = 0               # avahi-common/address.h
312
 
    PROTO_INET6 = 1              # avahi-common/address.h
 
257
class Avahi(object):
 
258
    """This isn't so much a class as it is a module-like namespace.
 
259
    It is instantiated once, and simulates having an Avahi module."""
 
260
    IF_UNSPEC = -1              # avahi-common/address.h
 
261
    PROTO_UNSPEC = -1           # avahi-common/address.h
 
262
    PROTO_INET = 0              # avahi-common/address.h
 
263
    PROTO_INET6 = 1             # avahi-common/address.h
313
264
    DBUS_NAME = "org.freedesktop.Avahi"
314
265
    DBUS_INTERFACE_ENTRY_GROUP = DBUS_NAME + ".EntryGroup"
315
266
    DBUS_INTERFACE_SERVER = DBUS_NAME + ".Server"
316
267
    DBUS_PATH_SERVER = "/"
317
 
 
318
 
    @staticmethod
319
 
    def string_array_to_txt_array(t):
 
268
    def string_array_to_txt_array(self, t):
320
269
        return dbus.Array((dbus.ByteArray(s.encode("utf-8"))
321
270
                           for s in t), signature="ay")
322
 
    ENTRY_GROUP_ESTABLISHED = 2  # avahi-common/defs.h
323
 
    ENTRY_GROUP_COLLISION = 3    # avahi-common/defs.h
324
 
    ENTRY_GROUP_FAILURE = 4      # avahi-common/defs.h
325
 
    SERVER_INVALID = 0           # avahi-common/defs.h
326
 
    SERVER_REGISTERING = 1       # avahi-common/defs.h
327
 
    SERVER_RUNNING = 2           # avahi-common/defs.h
328
 
    SERVER_COLLISION = 3         # avahi-common/defs.h
329
 
    SERVER_FAILURE = 4           # avahi-common/defs.h
330
 
 
 
271
    ENTRY_GROUP_ESTABLISHED = 2 # avahi-common/defs.h
 
272
    ENTRY_GROUP_COLLISION = 3   # avahi-common/defs.h
 
273
    ENTRY_GROUP_FAILURE = 4     # avahi-common/defs.h
 
274
    SERVER_INVALID = 0          # avahi-common/defs.h
 
275
    SERVER_REGISTERING = 1      # avahi-common/defs.h
 
276
    SERVER_RUNNING = 2          # avahi-common/defs.h
 
277
    SERVER_COLLISION = 3        # avahi-common/defs.h
 
278
    SERVER_FAILURE = 4          # avahi-common/defs.h
 
279
avahi = Avahi()
331
280
 
332
281
class AvahiError(Exception):
333
282
    def __init__(self, value, *args, **kwargs):
344
293
    pass
345
294
 
346
295
 
347
 
class AvahiService:
 
296
class AvahiService(object):
348
297
    """An Avahi (Zeroconf) service.
349
 
 
 
298
    
350
299
    Attributes:
351
300
    interface: integer; avahi.IF_UNSPEC or an interface index.
352
301
               Used to optionally bind to the specified interface.
353
 
    name: string; Example: "Mandos"
354
 
    type: string; Example: "_mandos._tcp".
 
302
    name: string; Example: 'Mandos'
 
303
    type: string; Example: '_mandos._tcp'.
355
304
     See <https://www.iana.org/assignments/service-names-port-numbers>
356
305
    port: integer; what port to announce
357
306
    TXT: list of strings; TXT record for the service
364
313
    server: D-Bus Server
365
314
    bus: dbus.SystemBus()
366
315
    """
367
 
 
 
316
    
368
317
    def __init__(self,
369
 
                 interface=avahi.IF_UNSPEC,
370
 
                 name=None,
371
 
                 servicetype=None,
372
 
                 port=None,
373
 
                 TXT=None,
374
 
                 domain="",
375
 
                 host="",
376
 
                 max_renames=32768,
377
 
                 protocol=avahi.PROTO_UNSPEC,
378
 
                 bus=None):
 
318
                 interface = avahi.IF_UNSPEC,
 
319
                 name = None,
 
320
                 servicetype = None,
 
321
                 port = None,
 
322
                 TXT = None,
 
323
                 domain = "",
 
324
                 host = "",
 
325
                 max_renames = 32768,
 
326
                 protocol = avahi.PROTO_UNSPEC,
 
327
                 bus = None):
379
328
        self.interface = interface
380
329
        self.name = name
381
330
        self.type = servicetype
390
339
        self.server = None
391
340
        self.bus = bus
392
341
        self.entry_group_state_changed_match = None
393
 
 
 
342
    
394
343
    def rename(self, remove=True):
395
344
        """Derived from the Avahi example code"""
396
345
        if self.rename_count >= self.max_renames:
416
365
                logger.critical("D-Bus Exception", exc_info=error)
417
366
                self.cleanup()
418
367
                os._exit(1)
419
 
 
 
368
    
420
369
    def remove(self):
421
370
        """Derived from the Avahi example code"""
422
371
        if self.entry_group_state_changed_match is not None:
424
373
            self.entry_group_state_changed_match = None
425
374
        if self.group is not None:
426
375
            self.group.Reset()
427
 
 
 
376
    
428
377
    def add(self):
429
378
        """Derived from the Avahi example code"""
430
379
        self.remove()
435
384
                avahi.DBUS_INTERFACE_ENTRY_GROUP)
436
385
        self.entry_group_state_changed_match = (
437
386
            self.group.connect_to_signal(
438
 
                "StateChanged", self.entry_group_state_changed))
 
387
                'StateChanged', self.entry_group_state_changed))
439
388
        logger.debug("Adding Zeroconf service '%s' of type '%s' ...",
440
389
                     self.name, self.type)
441
390
        self.group.AddService(
447
396
            dbus.UInt16(self.port),
448
397
            avahi.string_array_to_txt_array(self.TXT))
449
398
        self.group.Commit()
450
 
 
 
399
    
451
400
    def entry_group_state_changed(self, state, error):
452
401
        """Derived from the Avahi example code"""
453
402
        logger.debug("Avahi entry group state change: %i", state)
454
 
 
 
403
        
455
404
        if state == avahi.ENTRY_GROUP_ESTABLISHED:
456
405
            logger.debug("Zeroconf service established.")
457
406
        elif state == avahi.ENTRY_GROUP_COLLISION:
461
410
            logger.critical("Avahi: Error in group state changed %s",
462
411
                            str(error))
463
412
            raise AvahiGroupError("State changed: {!s}".format(error))
464
 
 
 
413
    
465
414
    def cleanup(self):
466
415
        """Derived from the Avahi example code"""
467
416
        if self.group is not None:
472
421
                pass
473
422
            self.group = None
474
423
        self.remove()
475
 
 
 
424
    
476
425
    def server_state_changed(self, state, error=None):
477
426
        """Derived from the Avahi example code"""
478
427
        logger.debug("Avahi server state change: %i", state)
507
456
                logger.debug("Unknown state: %r", state)
508
457
            else:
509
458
                logger.debug("Unknown state: %r: %r", state, error)
510
 
 
 
459
    
511
460
    def activate(self):
512
461
        """Derived from the Avahi example code"""
513
462
        if self.server is None:
524
473
class AvahiServiceToSyslog(AvahiService):
525
474
    def rename(self, *args, **kwargs):
526
475
        """Add the new name to the syslog messages"""
527
 
        ret = super(AvahiServiceToSyslog, self).rename(*args,
528
 
                                                       **kwargs)
 
476
        ret = AvahiService.rename(self, *args, **kwargs)
529
477
        syslogger.setFormatter(logging.Formatter(
530
 
            "Mandos ({}) [%(process)d]: %(levelname)s: %(message)s"
 
478
            'Mandos ({}) [%(process)d]: %(levelname)s: %(message)s'
531
479
            .format(self.name)))
532
480
        return ret
533
481
 
534
 
 
535
482
# Pretend that we have a GnuTLS module
536
 
class gnutls:
537
 
    """This isn't so much a class as it is a module-like namespace."""
538
 
 
539
 
    library = ctypes.util.find_library("gnutls")
540
 
    if library is None:
541
 
        library = ctypes.util.find_library("gnutls-deb0")
542
 
    _library = ctypes.cdll.LoadLibrary(library)
543
 
    del library
544
 
 
 
483
class GnuTLS(object):
 
484
    """This isn't so much a class as it is a module-like namespace.
 
485
    It is instantiated once, and simulates having a GnuTLS module."""
 
486
    
 
487
    _library = ctypes.cdll.LoadLibrary(
 
488
        ctypes.util.find_library("gnutls"))
 
489
    _need_version = b"3.3.0"
 
490
    def __init__(self):
 
491
        # Need to use class name "GnuTLS" here, since this method is
 
492
        # called before the assignment to the "gnutls" global variable
 
493
        # happens.
 
494
        if GnuTLS.check_version(self._need_version) is None:
 
495
            raise GnuTLS.Error("Needs GnuTLS {} or later"
 
496
                               .format(self._need_version))
 
497
    
545
498
    # Unless otherwise indicated, the constants and types below are
546
499
    # all from the gnutls/gnutls.h C header file.
547
 
 
 
500
    
548
501
    # Constants
549
502
    E_SUCCESS = 0
550
503
    E_INTERRUPTED = -52
551
504
    E_AGAIN = -28
552
505
    CRT_OPENPGP = 2
553
 
    CRT_RAWPK = 3
554
506
    CLIENT = 2
555
507
    SHUT_RDWR = 0
556
508
    CRD_CERTIFICATE = 1
557
509
    E_NO_CERTIFICATE_FOUND = -49
558
 
    X509_FMT_DER = 0
559
 
    NO_TICKETS = 1<<10
560
 
    ENABLE_RAWPK = 1<<18
561
 
    CTYPE_PEERS = 3
562
 
    KEYID_USE_SHA256 = 1        # gnutls/x509.h
563
510
    OPENPGP_FMT_RAW = 0         # gnutls/openpgp.h
564
 
 
 
511
    
565
512
    # Types
566
 
    class _session_int(ctypes.Structure):
 
513
    class session_int(ctypes.Structure):
567
514
        _fields_ = []
568
 
    session_t = ctypes.POINTER(_session_int)
569
 
 
 
515
    session_t = ctypes.POINTER(session_int)
570
516
    class certificate_credentials_st(ctypes.Structure):
571
517
        _fields_ = []
572
518
    certificate_credentials_t = ctypes.POINTER(
573
519
        certificate_credentials_st)
574
520
    certificate_type_t = ctypes.c_int
575
 
 
576
521
    class datum_t(ctypes.Structure):
577
 
        _fields_ = [("data", ctypes.POINTER(ctypes.c_ubyte)),
578
 
                    ("size", ctypes.c_uint)]
579
 
 
580
 
    class _openpgp_crt_int(ctypes.Structure):
 
522
        _fields_ = [('data', ctypes.POINTER(ctypes.c_ubyte)),
 
523
                    ('size', ctypes.c_uint)]
 
524
    class openpgp_crt_int(ctypes.Structure):
581
525
        _fields_ = []
582
 
    openpgp_crt_t = ctypes.POINTER(_openpgp_crt_int)
583
 
    openpgp_crt_fmt_t = ctypes.c_int  # gnutls/openpgp.h
 
526
    openpgp_crt_t = ctypes.POINTER(openpgp_crt_int)
 
527
    openpgp_crt_fmt_t = ctypes.c_int # gnutls/openpgp.h
584
528
    log_func = ctypes.CFUNCTYPE(None, ctypes.c_int, ctypes.c_char_p)
585
529
    credentials_type_t = ctypes.c_int
586
530
    transport_ptr_t = ctypes.c_void_p
587
531
    close_request_t = ctypes.c_int
588
 
 
 
532
    
589
533
    # Exceptions
590
534
    class Error(Exception):
591
 
        def __init__(self, message=None, code=None, args=()):
 
535
        # We need to use the class name "GnuTLS" here, since this
 
536
        # exception might be raised from within GnuTLS.__init__,
 
537
        # which is called before the assignment to the "gnutls"
 
538
        # global variable has happened.
 
539
        def __init__(self, message = None, code = None, args=()):
592
540
            # Default usage is by a message string, but if a return
593
541
            # code is passed, convert it to a string with
594
542
            # gnutls.strerror()
595
543
            self.code = code
596
544
            if message is None and code is not None:
597
 
                message = gnutls.strerror(code).decode(
598
 
                    "utf-8", errors="replace")
599
 
            return super(gnutls.Error, self).__init__(
 
545
                message = GnuTLS.strerror(code)
 
546
            return super(GnuTLS.Error, self).__init__(
600
547
                message, *args)
601
 
 
 
548
    
602
549
    class CertificateSecurityError(Error):
603
550
        pass
604
 
 
605
 
    class PointerTo:
606
 
        def __init__(self, cls):
607
 
            self.cls = cls
608
 
 
609
 
        def from_param(self, obj):
610
 
            if not isinstance(obj, self.cls):
611
 
                raise TypeError("Not of type {}: {!r}"
612
 
                                .format(self.cls.__name__, obj))
613
 
            return ctypes.byref(obj.from_param(obj))
614
 
 
615
 
    class CastToVoidPointer:
616
 
        def __init__(self, cls):
617
 
            self.cls = cls
618
 
 
619
 
        def from_param(self, obj):
620
 
            if not isinstance(obj, self.cls):
621
 
                raise TypeError("Not of type {}: {!r}"
622
 
                                .format(self.cls.__name__, obj))
623
 
            return ctypes.cast(obj.from_param(obj), ctypes.c_void_p)
624
 
 
625
 
    class With_from_param:
626
 
        @classmethod
627
 
        def from_param(cls, obj):
628
 
            return obj._as_parameter_
629
 
 
 
551
    
630
552
    # Classes
631
 
    class Credentials(With_from_param):
 
553
    class Credentials(object):
632
554
        def __init__(self):
633
 
            self._as_parameter_ = gnutls.certificate_credentials_t()
634
 
            gnutls.certificate_allocate_credentials(self)
 
555
            self._c_object = gnutls.certificate_credentials_t()
 
556
            gnutls.certificate_allocate_credentials(
 
557
                ctypes.byref(self._c_object))
635
558
            self.type = gnutls.CRD_CERTIFICATE
636
 
 
 
559
        
637
560
        def __del__(self):
638
 
            gnutls.certificate_free_credentials(self)
639
 
 
640
 
    class ClientSession(With_from_param):
641
 
        def __init__(self, socket, credentials=None):
642
 
            self._as_parameter_ = gnutls.session_t()
643
 
            gnutls_flags = gnutls.CLIENT
644
 
            if gnutls.check_version(b"3.5.6"):
645
 
                gnutls_flags |= gnutls.NO_TICKETS
646
 
            if gnutls.has_rawpk:
647
 
                gnutls_flags |= gnutls.ENABLE_RAWPK
648
 
            gnutls.init(self, gnutls_flags)
649
 
            del gnutls_flags
650
 
            gnutls.set_default_priority(self)
651
 
            gnutls.transport_set_ptr(self, socket.fileno())
652
 
            gnutls.handshake_set_private_extensions(self, True)
 
561
            gnutls.certificate_free_credentials(self._c_object)
 
562
    
 
563
    class ClientSession(object):
 
564
        def __init__(self, socket, credentials = None):
 
565
            self._c_object = gnutls.session_t()
 
566
            gnutls.init(ctypes.byref(self._c_object), gnutls.CLIENT)
 
567
            gnutls.set_default_priority(self._c_object)
 
568
            gnutls.transport_set_ptr(self._c_object, socket.fileno())
 
569
            gnutls.handshake_set_private_extensions(self._c_object,
 
570
                                                    True)
653
571
            self.socket = socket
654
572
            if credentials is None:
655
573
                credentials = gnutls.Credentials()
656
 
            gnutls.credentials_set(self, credentials.type,
657
 
                                   credentials)
 
574
            gnutls.credentials_set(self._c_object, credentials.type,
 
575
                                   ctypes.cast(credentials._c_object,
 
576
                                               ctypes.c_void_p))
658
577
            self.credentials = credentials
659
 
 
 
578
        
660
579
        def __del__(self):
661
 
            gnutls.deinit(self)
662
 
 
 
580
            gnutls.deinit(self._c_object)
 
581
        
663
582
        def handshake(self):
664
 
            return gnutls.handshake(self)
665
 
 
 
583
            return gnutls.handshake(self._c_object)
 
584
        
666
585
        def send(self, data):
667
586
            data = bytes(data)
668
587
            data_len = len(data)
669
588
            while data_len > 0:
670
 
                data_len -= gnutls.record_send(self, data[-data_len:],
 
589
                data_len -= gnutls.record_send(self._c_object,
 
590
                                               data[-data_len:],
671
591
                                               data_len)
672
 
 
 
592
        
673
593
        def bye(self):
674
 
            return gnutls.bye(self, gnutls.SHUT_RDWR)
675
 
 
 
594
            return gnutls.bye(self._c_object, gnutls.SHUT_RDWR)
 
595
    
676
596
    # Error handling functions
677
597
    def _error_code(result):
678
598
        """A function to raise exceptions on errors, suitable
679
 
        for the "restype" attribute on ctypes functions"""
680
 
        if result >= gnutls.E_SUCCESS:
 
599
        for the 'restype' attribute on ctypes functions"""
 
600
        if result >= 0:
681
601
            return result
682
602
        if result == gnutls.E_NO_CERTIFICATE_FOUND:
683
 
            raise gnutls.CertificateSecurityError(code=result)
684
 
        raise gnutls.Error(code=result)
685
 
 
686
 
    def _retry_on_error(result, func, arguments,
687
 
                        _error_code=_error_code):
 
603
            raise gnutls.CertificateSecurityError(code = result)
 
604
        raise gnutls.Error(code = result)
 
605
    
 
606
    def _retry_on_error(result, func, arguments):
688
607
        """A function to retry on some errors, suitable
689
 
        for the "errcheck" attribute on ctypes functions"""
690
 
        while result < gnutls.E_SUCCESS:
 
608
        for the 'errcheck' attribute on ctypes functions"""
 
609
        while result < 0:
691
610
            if result not in (gnutls.E_INTERRUPTED, gnutls.E_AGAIN):
692
611
                return _error_code(result)
693
612
            result = func(*arguments)
694
613
        return result
695
 
 
 
614
    
696
615
    # Unless otherwise indicated, the function declarations below are
697
616
    # all from the gnutls/gnutls.h C header file.
698
 
 
 
617
    
699
618
    # Functions
700
619
    priority_set_direct = _library.gnutls_priority_set_direct
701
 
    priority_set_direct.argtypes = [ClientSession, ctypes.c_char_p,
 
620
    priority_set_direct.argtypes = [session_t, ctypes.c_char_p,
702
621
                                    ctypes.POINTER(ctypes.c_char_p)]
703
622
    priority_set_direct.restype = _error_code
704
 
 
 
623
    
705
624
    init = _library.gnutls_init
706
 
    init.argtypes = [PointerTo(ClientSession), ctypes.c_int]
 
625
    init.argtypes = [ctypes.POINTER(session_t), ctypes.c_int]
707
626
    init.restype = _error_code
708
 
 
 
627
    
709
628
    set_default_priority = _library.gnutls_set_default_priority
710
 
    set_default_priority.argtypes = [ClientSession]
 
629
    set_default_priority.argtypes = [session_t]
711
630
    set_default_priority.restype = _error_code
712
 
 
 
631
    
713
632
    record_send = _library.gnutls_record_send
714
 
    record_send.argtypes = [ClientSession, ctypes.c_void_p,
 
633
    record_send.argtypes = [session_t, ctypes.c_void_p,
715
634
                            ctypes.c_size_t]
716
635
    record_send.restype = ctypes.c_ssize_t
717
636
    record_send.errcheck = _retry_on_error
718
 
 
 
637
    
719
638
    certificate_allocate_credentials = (
720
639
        _library.gnutls_certificate_allocate_credentials)
721
640
    certificate_allocate_credentials.argtypes = [
722
 
        PointerTo(Credentials)]
 
641
        ctypes.POINTER(certificate_credentials_t)]
723
642
    certificate_allocate_credentials.restype = _error_code
724
 
 
 
643
    
725
644
    certificate_free_credentials = (
726
645
        _library.gnutls_certificate_free_credentials)
727
 
    certificate_free_credentials.argtypes = [Credentials]
 
646
    certificate_free_credentials.argtypes = [certificate_credentials_t]
728
647
    certificate_free_credentials.restype = None
729
 
 
 
648
    
730
649
    handshake_set_private_extensions = (
731
650
        _library.gnutls_handshake_set_private_extensions)
732
 
    handshake_set_private_extensions.argtypes = [ClientSession,
 
651
    handshake_set_private_extensions.argtypes = [session_t,
733
652
                                                 ctypes.c_int]
734
653
    handshake_set_private_extensions.restype = None
735
 
 
 
654
    
736
655
    credentials_set = _library.gnutls_credentials_set
737
 
    credentials_set.argtypes = [ClientSession, credentials_type_t,
738
 
                                CastToVoidPointer(Credentials)]
 
656
    credentials_set.argtypes = [session_t, credentials_type_t,
 
657
                                ctypes.c_void_p]
739
658
    credentials_set.restype = _error_code
740
 
 
 
659
    
741
660
    strerror = _library.gnutls_strerror
742
661
    strerror.argtypes = [ctypes.c_int]
743
662
    strerror.restype = ctypes.c_char_p
744
 
 
 
663
    
745
664
    certificate_type_get = _library.gnutls_certificate_type_get
746
 
    certificate_type_get.argtypes = [ClientSession]
 
665
    certificate_type_get.argtypes = [session_t]
747
666
    certificate_type_get.restype = _error_code
748
 
 
 
667
    
749
668
    certificate_get_peers = _library.gnutls_certificate_get_peers
750
 
    certificate_get_peers.argtypes = [ClientSession,
 
669
    certificate_get_peers.argtypes = [session_t,
751
670
                                      ctypes.POINTER(ctypes.c_uint)]
752
671
    certificate_get_peers.restype = ctypes.POINTER(datum_t)
753
 
 
 
672
    
754
673
    global_set_log_level = _library.gnutls_global_set_log_level
755
674
    global_set_log_level.argtypes = [ctypes.c_int]
756
675
    global_set_log_level.restype = None
757
 
 
 
676
    
758
677
    global_set_log_function = _library.gnutls_global_set_log_function
759
678
    global_set_log_function.argtypes = [log_func]
760
679
    global_set_log_function.restype = None
761
 
 
 
680
    
762
681
    deinit = _library.gnutls_deinit
763
 
    deinit.argtypes = [ClientSession]
 
682
    deinit.argtypes = [session_t]
764
683
    deinit.restype = None
765
 
 
 
684
    
766
685
    handshake = _library.gnutls_handshake
767
 
    handshake.argtypes = [ClientSession]
768
 
    handshake.restype = ctypes.c_int
 
686
    handshake.argtypes = [session_t]
 
687
    handshake.restype = _error_code
769
688
    handshake.errcheck = _retry_on_error
770
 
 
 
689
    
771
690
    transport_set_ptr = _library.gnutls_transport_set_ptr
772
 
    transport_set_ptr.argtypes = [ClientSession, transport_ptr_t]
 
691
    transport_set_ptr.argtypes = [session_t, transport_ptr_t]
773
692
    transport_set_ptr.restype = None
774
 
 
 
693
    
775
694
    bye = _library.gnutls_bye
776
 
    bye.argtypes = [ClientSession, close_request_t]
777
 
    bye.restype = ctypes.c_int
 
695
    bye.argtypes = [session_t, close_request_t]
 
696
    bye.restype = _error_code
778
697
    bye.errcheck = _retry_on_error
779
 
 
 
698
    
780
699
    check_version = _library.gnutls_check_version
781
700
    check_version.argtypes = [ctypes.c_char_p]
782
701
    check_version.restype = ctypes.c_char_p
783
 
 
784
 
    _need_version = b"3.3.0"
785
 
    if check_version(_need_version) is None:
786
 
        raise self.Error("Needs GnuTLS {} or later"
787
 
                         .format(_need_version))
788
 
 
789
 
    _tls_rawpk_version = b"3.6.6"
790
 
    has_rawpk = bool(check_version(_tls_rawpk_version))
791
 
 
792
 
    if has_rawpk:
793
 
        # Types
794
 
        class pubkey_st(ctypes.Structure):
795
 
            _fields = []
796
 
        pubkey_t = ctypes.POINTER(pubkey_st)
797
 
 
798
 
        x509_crt_fmt_t = ctypes.c_int
799
 
 
800
 
        # All the function declarations below are from
801
 
        # gnutls/abstract.h
802
 
        pubkey_init = _library.gnutls_pubkey_init
803
 
        pubkey_init.argtypes = [ctypes.POINTER(pubkey_t)]
804
 
        pubkey_init.restype = _error_code
805
 
 
806
 
        pubkey_import = _library.gnutls_pubkey_import
807
 
        pubkey_import.argtypes = [pubkey_t, ctypes.POINTER(datum_t),
808
 
                                  x509_crt_fmt_t]
809
 
        pubkey_import.restype = _error_code
810
 
 
811
 
        pubkey_get_key_id = _library.gnutls_pubkey_get_key_id
812
 
        pubkey_get_key_id.argtypes = [pubkey_t, ctypes.c_int,
813
 
                                      ctypes.POINTER(ctypes.c_ubyte),
814
 
                                      ctypes.POINTER(ctypes.c_size_t)]
815
 
        pubkey_get_key_id.restype = _error_code
816
 
 
817
 
        pubkey_deinit = _library.gnutls_pubkey_deinit
818
 
        pubkey_deinit.argtypes = [pubkey_t]
819
 
        pubkey_deinit.restype = None
820
 
    else:
821
 
        # All the function declarations below are from
822
 
        # gnutls/openpgp.h
823
 
 
824
 
        openpgp_crt_init = _library.gnutls_openpgp_crt_init
825
 
        openpgp_crt_init.argtypes = [ctypes.POINTER(openpgp_crt_t)]
826
 
        openpgp_crt_init.restype = _error_code
827
 
 
828
 
        openpgp_crt_import = _library.gnutls_openpgp_crt_import
829
 
        openpgp_crt_import.argtypes = [openpgp_crt_t,
830
 
                                       ctypes.POINTER(datum_t),
831
 
                                       openpgp_crt_fmt_t]
832
 
        openpgp_crt_import.restype = _error_code
833
 
 
834
 
        openpgp_crt_verify_self = \
835
 
            _library.gnutls_openpgp_crt_verify_self
836
 
        openpgp_crt_verify_self.argtypes = [
837
 
            openpgp_crt_t,
838
 
            ctypes.c_uint,
839
 
            ctypes.POINTER(ctypes.c_uint),
840
 
        ]
841
 
        openpgp_crt_verify_self.restype = _error_code
842
 
 
843
 
        openpgp_crt_deinit = _library.gnutls_openpgp_crt_deinit
844
 
        openpgp_crt_deinit.argtypes = [openpgp_crt_t]
845
 
        openpgp_crt_deinit.restype = None
846
 
 
847
 
        openpgp_crt_get_fingerprint = (
848
 
            _library.gnutls_openpgp_crt_get_fingerprint)
849
 
        openpgp_crt_get_fingerprint.argtypes = [openpgp_crt_t,
850
 
                                                ctypes.c_void_p,
851
 
                                                ctypes.POINTER(
852
 
                                                    ctypes.c_size_t)]
853
 
        openpgp_crt_get_fingerprint.restype = _error_code
854
 
 
855
 
    if check_version(b"3.6.4"):
856
 
        certificate_type_get2 = _library.gnutls_certificate_type_get2
857
 
        certificate_type_get2.argtypes = [ClientSession, ctypes.c_int]
858
 
        certificate_type_get2.restype = _error_code
859
 
 
 
702
    
 
703
    # All the function declarations below are from gnutls/openpgp.h
 
704
    
 
705
    openpgp_crt_init = _library.gnutls_openpgp_crt_init
 
706
    openpgp_crt_init.argtypes = [ctypes.POINTER(openpgp_crt_t)]
 
707
    openpgp_crt_init.restype = _error_code
 
708
    
 
709
    openpgp_crt_import = _library.gnutls_openpgp_crt_import
 
710
    openpgp_crt_import.argtypes = [openpgp_crt_t,
 
711
                                   ctypes.POINTER(datum_t),
 
712
                                   openpgp_crt_fmt_t]
 
713
    openpgp_crt_import.restype = _error_code
 
714
    
 
715
    openpgp_crt_verify_self = _library.gnutls_openpgp_crt_verify_self
 
716
    openpgp_crt_verify_self.argtypes = [openpgp_crt_t, ctypes.c_uint,
 
717
                                        ctypes.POINTER(ctypes.c_uint)]
 
718
    openpgp_crt_verify_self.restype = _error_code
 
719
    
 
720
    openpgp_crt_deinit = _library.gnutls_openpgp_crt_deinit
 
721
    openpgp_crt_deinit.argtypes = [openpgp_crt_t]
 
722
    openpgp_crt_deinit.restype = None
 
723
    
 
724
    openpgp_crt_get_fingerprint = (
 
725
        _library.gnutls_openpgp_crt_get_fingerprint)
 
726
    openpgp_crt_get_fingerprint.argtypes = [openpgp_crt_t,
 
727
                                            ctypes.c_void_p,
 
728
                                            ctypes.POINTER(
 
729
                                                ctypes.c_size_t)]
 
730
    openpgp_crt_get_fingerprint.restype = _error_code
 
731
    
860
732
    # Remove non-public functions
861
733
    del _error_code, _retry_on_error
862
 
 
 
734
# Create the global "gnutls" object, simulating a module
 
735
gnutls = GnuTLS()
863
736
 
864
737
def call_pipe(connection,       # : multiprocessing.Connection
865
738
              func, *args, **kwargs):
866
739
    """This function is meant to be called by multiprocessing.Process
867
 
 
 
740
    
868
741
    This function runs func(*args, **kwargs), and writes the resulting
869
742
    return value on the provided multiprocessing.Connection.
870
743
    """
871
744
    connection.send(func(*args, **kwargs))
872
745
    connection.close()
873
746
 
874
 
 
875
 
class Client:
 
747
class Client(object):
876
748
    """A representation of a client host served by this server.
877
 
 
 
749
    
878
750
    Attributes:
879
 
    approved:   bool(); None if not yet approved/disapproved
 
751
    approved:   bool(); 'None' if not yet approved/disapproved
880
752
    approval_delay: datetime.timedelta(); Time to wait for approval
881
753
    approval_duration: datetime.timedelta(); Duration of one approval
882
 
    checker: multiprocessing.Process(); a running checker process used
883
 
             to see if the client lives. None if no process is
884
 
             running.
 
754
    checker:    subprocess.Popen(); a running checker process used
 
755
                                    to see if the client lives.
 
756
                                    'None' if no process is running.
885
757
    checker_callback_tag: a GLib event source tag, or None
886
758
    checker_command: string; External command which is run to check
887
759
                     if client lives.  %() expansions are done at
895
767
    disable_initiator_tag: a GLib event source tag, or None
896
768
    enabled:    bool()
897
769
    fingerprint: string (40 or 32 hexadecimal digits); used to
898
 
                 uniquely identify an OpenPGP client
899
 
    key_id: string (64 hexadecimal digits); used to uniquely identify
900
 
            a client using raw public keys
 
770
                 uniquely identify the client
901
771
    host:       string; available for use by the checker command
902
772
    interval:   datetime.timedelta(); How often to start a new checker
903
773
    last_approval_request: datetime.datetime(); (UTC) or None
919
789
                disabled, or None
920
790
    server_settings: The server_settings dict from main()
921
791
    """
922
 
 
 
792
    
923
793
    runtime_expansions = ("approval_delay", "approval_duration",
924
 
                          "created", "enabled", "expires", "key_id",
 
794
                          "created", "enabled", "expires",
925
795
                          "fingerprint", "host", "interval",
926
796
                          "last_approval_request", "last_checked_ok",
927
797
                          "last_enabled", "name", "timeout")
936
806
        "approved_by_default": "True",
937
807
        "enabled": "True",
938
808
    }
939
 
 
 
809
    
940
810
    @staticmethod
941
811
    def config_parser(config):
942
812
        """Construct a new dict of client settings of this form:
949
819
        for client_name in config.sections():
950
820
            section = dict(config.items(client_name))
951
821
            client = settings[client_name] = {}
952
 
 
 
822
            
953
823
            client["host"] = section["host"]
954
824
            # Reformat values from string types to Python types
955
825
            client["approved_by_default"] = config.getboolean(
956
826
                client_name, "approved_by_default")
957
827
            client["enabled"] = config.getboolean(client_name,
958
828
                                                  "enabled")
959
 
 
960
 
            # Uppercase and remove spaces from key_id and fingerprint
961
 
            # for later comparison purposes with return value from the
962
 
            # key_id() and fingerprint() functions
963
 
            client["key_id"] = (section.get("key_id", "").upper()
964
 
                                .replace(" ", ""))
 
829
            
 
830
            # Uppercase and remove spaces from fingerprint for later
 
831
            # comparison purposes with return value from the
 
832
            # fingerprint() function
965
833
            client["fingerprint"] = (section["fingerprint"].upper()
966
834
                                     .replace(" ", ""))
967
835
            if "secret" in section:
988
856
            client["last_approval_request"] = None
989
857
            client["last_checked_ok"] = None
990
858
            client["last_checker_status"] = -2
991
 
 
 
859
        
992
860
        return settings
993
 
 
994
 
    def __init__(self, settings, name=None, server_settings=None):
 
861
    
 
862
    def __init__(self, settings, name = None, server_settings=None):
995
863
        self.name = name
996
864
        if server_settings is None:
997
865
            server_settings = {}
999
867
        # adding all client settings
1000
868
        for setting, value in settings.items():
1001
869
            setattr(self, setting, value)
1002
 
 
 
870
        
1003
871
        if self.enabled:
1004
872
            if not hasattr(self, "last_enabled"):
1005
873
                self.last_enabled = datetime.datetime.utcnow()
1009
877
        else:
1010
878
            self.last_enabled = None
1011
879
            self.expires = None
1012
 
 
 
880
        
1013
881
        logger.debug("Creating client %r", self.name)
1014
 
        logger.debug("  Key ID: %s", self.key_id)
1015
882
        logger.debug("  Fingerprint: %s", self.fingerprint)
1016
883
        self.created = settings.get("created",
1017
884
                                    datetime.datetime.utcnow())
1018
 
 
 
885
        
1019
886
        # attributes specific for this server instance
1020
887
        self.checker = None
1021
888
        self.checker_initiator_tag = None
1030
897
                                 for attr in self.__dict__.keys()
1031
898
                                 if not attr.startswith("_")]
1032
899
        self.client_structure.append("client_structure")
1033
 
 
 
900
        
1034
901
        for name, t in inspect.getmembers(
1035
902
                type(self), lambda obj: isinstance(obj, property)):
1036
903
            if not name.startswith("_"):
1037
904
                self.client_structure.append(name)
1038
 
 
 
905
    
1039
906
    # Send notice to process children that client state has changed
1040
907
    def send_changedstate(self):
1041
908
        with self.changedstate:
1042
909
            self.changedstate.notify_all()
1043
 
 
 
910
    
1044
911
    def enable(self):
1045
912
        """Start this client's checker and timeout hooks"""
1046
913
        if getattr(self, "enabled", False):
1051
918
        self.last_enabled = datetime.datetime.utcnow()
1052
919
        self.init_checker()
1053
920
        self.send_changedstate()
1054
 
 
 
921
    
1055
922
    def disable(self, quiet=True):
1056
923
        """Disable this client."""
1057
924
        if not getattr(self, "enabled", False):
1071
938
            self.send_changedstate()
1072
939
        # Do not run this again if called by a GLib.timeout_add
1073
940
        return False
1074
 
 
 
941
    
1075
942
    def __del__(self):
1076
943
        self.disable()
1077
 
 
 
944
    
1078
945
    def init_checker(self):
1079
946
        # Schedule a new checker to be started an 'interval' from now,
1080
947
        # and every interval from then on.
1081
948
        if self.checker_initiator_tag is not None:
1082
949
            GLib.source_remove(self.checker_initiator_tag)
1083
950
        self.checker_initiator_tag = GLib.timeout_add(
1084
 
            random.randrange(int(self.interval.total_seconds() * 1000
1085
 
                                 + 1)),
 
951
            int(self.interval.total_seconds() * 1000),
1086
952
            self.start_checker)
1087
953
        # Schedule a disable() when 'timeout' has passed
1088
954
        if self.disable_initiator_tag is not None:
1091
957
            int(self.timeout.total_seconds() * 1000), self.disable)
1092
958
        # Also start a new checker *right now*.
1093
959
        self.start_checker()
1094
 
 
 
960
    
1095
961
    def checker_callback(self, source, condition, connection,
1096
962
                         command):
1097
963
        """The checker has completed, so take appropriate actions."""
 
964
        self.checker_callback_tag = None
 
965
        self.checker = None
1098
966
        # Read return code from connection (see call_pipe)
1099
967
        returncode = connection.recv()
1100
968
        connection.close()
1101
 
        if self.checker is not None:
1102
 
            self.checker.join()
1103
 
        self.checker_callback_tag = None
1104
 
        self.checker = None
1105
 
 
 
969
        
1106
970
        if returncode >= 0:
1107
971
            self.last_checker_status = returncode
1108
972
            self.last_checker_signal = None
1118
982
            logger.warning("Checker for %(name)s crashed?",
1119
983
                           vars(self))
1120
984
        return False
1121
 
 
 
985
    
1122
986
    def checked_ok(self):
1123
987
        """Assert that the client has been seen, alive and well."""
1124
988
        self.last_checked_ok = datetime.datetime.utcnow()
1125
989
        self.last_checker_status = 0
1126
990
        self.last_checker_signal = None
1127
991
        self.bump_timeout()
1128
 
 
 
992
    
1129
993
    def bump_timeout(self, timeout=None):
1130
994
        """Bump up the timeout for this client."""
1131
995
        if timeout is None:
1137
1001
            self.disable_initiator_tag = GLib.timeout_add(
1138
1002
                int(timeout.total_seconds() * 1000), self.disable)
1139
1003
            self.expires = datetime.datetime.utcnow() + timeout
1140
 
 
 
1004
    
1141
1005
    def need_approval(self):
1142
1006
        self.last_approval_request = datetime.datetime.utcnow()
1143
 
 
 
1007
    
1144
1008
    def start_checker(self):
1145
1009
        """Start a new checker subprocess if one is not running.
1146
 
 
 
1010
        
1147
1011
        If a checker already exists, leave it running and do
1148
1012
        nothing."""
1149
1013
        # The reason for not killing a running checker is that if we
1154
1018
        # checkers alone, the checker would have to take more time
1155
1019
        # than 'timeout' for the client to be disabled, which is as it
1156
1020
        # should be.
1157
 
 
 
1021
        
1158
1022
        if self.checker is not None and not self.checker.is_alive():
1159
1023
            logger.warning("Checker was not alive; joining")
1160
1024
            self.checker.join()
1163
1027
        if self.checker is None:
1164
1028
            # Escape attributes for the shell
1165
1029
            escaped_attrs = {
1166
 
                attr: shlex.quote(str(getattr(self, attr)))
1167
 
                for attr in self.runtime_expansions}
 
1030
                attr: re.escape(str(getattr(self, attr)))
 
1031
                for attr in self.runtime_expansions }
1168
1032
            try:
1169
1033
                command = self.checker_command % escaped_attrs
1170
1034
            except TypeError as error:
1182
1046
            # The exception is when not debugging but nevertheless
1183
1047
            # running in the foreground; use the previously
1184
1048
            # created wnull.
1185
 
            popen_args = {"close_fds": True,
1186
 
                          "shell": True,
1187
 
                          "cwd": "/"}
 
1049
            popen_args = { "close_fds": True,
 
1050
                           "shell": True,
 
1051
                           "cwd": "/" }
1188
1052
            if (not self.server_settings["debug"]
1189
1053
                and self.server_settings["foreground"]):
1190
1054
                popen_args.update({"stdout": wnull,
1191
 
                                   "stderr": wnull})
1192
 
            pipe = multiprocessing.Pipe(duplex=False)
 
1055
                                   "stderr": wnull })
 
1056
            pipe = multiprocessing.Pipe(duplex = False)
1193
1057
            self.checker = multiprocessing.Process(
1194
 
                target=call_pipe,
1195
 
                args=(pipe[1], subprocess.call, command),
1196
 
                kwargs=popen_args)
 
1058
                target = call_pipe,
 
1059
                args = (pipe[1], subprocess.call, command),
 
1060
                kwargs = popen_args)
1197
1061
            self.checker.start()
1198
1062
            self.checker_callback_tag = GLib.io_add_watch(
1199
 
                GLib.IOChannel.unix_new(pipe[0].fileno()),
1200
 
                GLib.PRIORITY_DEFAULT, GLib.IO_IN,
 
1063
                pipe[0].fileno(), GLib.IO_IN,
1201
1064
                self.checker_callback, pipe[0], command)
1202
1065
        # Re-run this periodically if run by GLib.timeout_add
1203
1066
        return True
1204
 
 
 
1067
    
1205
1068
    def stop_checker(self):
1206
1069
        """Force the checker process, if any, to stop."""
1207
1070
        if self.checker_callback_tag:
1220
1083
                          byte_arrays=False):
1221
1084
    """Decorators for marking methods of a DBusObjectWithProperties to
1222
1085
    become properties on the D-Bus.
1223
 
 
 
1086
    
1224
1087
    The decorated method will be called with no arguments by "Get"
1225
1088
    and with one argument by "Set".
1226
 
 
 
1089
    
1227
1090
    The parameters, where they are supported, are the same as
1228
1091
    dbus.service.method, except there is only "signature", since the
1229
1092
    type from Get() and the type sent to Set() is the same.
1233
1096
    if byte_arrays and signature != "ay":
1234
1097
        raise ValueError("Byte arrays not supported for non-'ay'"
1235
1098
                         " signature {!r}".format(signature))
1236
 
 
 
1099
    
1237
1100
    def decorator(func):
1238
1101
        func._dbus_is_property = True
1239
1102
        func._dbus_interface = dbus_interface
1242
1105
        func._dbus_name = func.__name__
1243
1106
        if func._dbus_name.endswith("_dbus_property"):
1244
1107
            func._dbus_name = func._dbus_name[:-14]
1245
 
        func._dbus_get_args_options = {"byte_arrays": byte_arrays}
 
1108
        func._dbus_get_args_options = {'byte_arrays': byte_arrays }
1246
1109
        return func
1247
 
 
 
1110
    
1248
1111
    return decorator
1249
1112
 
1250
1113
 
1251
1114
def dbus_interface_annotations(dbus_interface):
1252
1115
    """Decorator for marking functions returning interface annotations
1253
 
 
 
1116
    
1254
1117
    Usage:
1255
 
 
 
1118
    
1256
1119
    @dbus_interface_annotations("org.example.Interface")
1257
1120
    def _foo(self):  # Function name does not matter
1258
1121
        return {"org.freedesktop.DBus.Deprecated": "true",
1259
1122
                "org.freedesktop.DBus.Property.EmitsChangedSignal":
1260
1123
                    "false"}
1261
1124
    """
1262
 
 
 
1125
    
1263
1126
    def decorator(func):
1264
1127
        func._dbus_is_interface = True
1265
1128
        func._dbus_interface = dbus_interface
1266
1129
        func._dbus_name = dbus_interface
1267
1130
        return func
1268
 
 
 
1131
    
1269
1132
    return decorator
1270
1133
 
1271
1134
 
1272
1135
def dbus_annotations(annotations):
1273
1136
    """Decorator to annotate D-Bus methods, signals or properties
1274
1137
    Usage:
1275
 
 
 
1138
    
1276
1139
    @dbus_annotations({"org.freedesktop.DBus.Deprecated": "true",
1277
1140
                       "org.freedesktop.DBus.Property."
1278
1141
                       "EmitsChangedSignal": "false"})
1280
1143
                           access="r")
1281
1144
    def Property_dbus_property(self):
1282
1145
        return dbus.Boolean(False)
1283
 
 
 
1146
    
1284
1147
    See also the DBusObjectWithAnnotations class.
1285
1148
    """
1286
 
 
 
1149
    
1287
1150
    def decorator(func):
1288
1151
        func._dbus_annotations = annotations
1289
1152
        return func
1290
 
 
 
1153
    
1291
1154
    return decorator
1292
1155
 
1293
1156
 
1311
1174
 
1312
1175
class DBusObjectWithAnnotations(dbus.service.Object):
1313
1176
    """A D-Bus object with annotations.
1314
 
 
 
1177
    
1315
1178
    Classes inheriting from this can use the dbus_annotations
1316
1179
    decorator to add annotations to methods or signals.
1317
1180
    """
1318
 
 
 
1181
    
1319
1182
    @staticmethod
1320
1183
    def _is_dbus_thing(thing):
1321
1184
        """Returns a function testing if an attribute is a D-Bus thing
1322
 
 
 
1185
        
1323
1186
        If called like _is_dbus_thing("method") it returns a function
1324
1187
        suitable for use as predicate to inspect.getmembers().
1325
1188
        """
1326
1189
        return lambda obj: getattr(obj, "_dbus_is_{}".format(thing),
1327
1190
                                   False)
1328
 
 
 
1191
    
1329
1192
    def _get_all_dbus_things(self, thing):
1330
1193
        """Returns a generator of (name, attribute) pairs
1331
1194
        """
1334
1197
                for cls in self.__class__.__mro__
1335
1198
                for name, athing in
1336
1199
                inspect.getmembers(cls, self._is_dbus_thing(thing)))
1337
 
 
 
1200
    
1338
1201
    @dbus.service.method(dbus.INTROSPECTABLE_IFACE,
1339
 
                         out_signature="s",
1340
 
                         path_keyword="object_path",
1341
 
                         connection_keyword="connection")
 
1202
                         out_signature = "s",
 
1203
                         path_keyword = 'object_path',
 
1204
                         connection_keyword = 'connection')
1342
1205
    def Introspect(self, object_path, connection):
1343
1206
        """Overloading of standard D-Bus method.
1344
 
 
 
1207
        
1345
1208
        Inserts annotation tags on methods and signals.
1346
1209
        """
1347
1210
        xmlstring = dbus.service.Object.Introspect(self, object_path,
1348
1211
                                                   connection)
1349
1212
        try:
1350
1213
            document = xml.dom.minidom.parseString(xmlstring)
1351
 
 
 
1214
            
1352
1215
            for if_tag in document.getElementsByTagName("interface"):
1353
1216
                # Add annotation tags
1354
1217
                for typ in ("method", "signal"):
1381
1244
                    if_tag.appendChild(ann_tag)
1382
1245
                # Fix argument name for the Introspect method itself
1383
1246
                if (if_tag.getAttribute("name")
1384
 
                    == dbus.INTROSPECTABLE_IFACE):
 
1247
                                == dbus.INTROSPECTABLE_IFACE):
1385
1248
                    for cn in if_tag.getElementsByTagName("method"):
1386
1249
                        if cn.getAttribute("name") == "Introspect":
1387
1250
                            for arg in cn.getElementsByTagName("arg"):
1400
1263
 
1401
1264
class DBusObjectWithProperties(DBusObjectWithAnnotations):
1402
1265
    """A D-Bus object with properties.
1403
 
 
 
1266
    
1404
1267
    Classes inheriting from this can use the dbus_service_property
1405
1268
    decorator to expose methods as D-Bus properties.  It exposes the
1406
1269
    standard Get(), Set(), and GetAll() methods on the D-Bus.
1407
1270
    """
1408
 
 
 
1271
    
1409
1272
    def _get_dbus_property(self, interface_name, property_name):
1410
1273
        """Returns a bound method if one exists which is a D-Bus
1411
1274
        property with the specified name and interface.
1416
1279
                if (value._dbus_name == property_name
1417
1280
                    and value._dbus_interface == interface_name):
1418
1281
                    return value.__get__(self)
1419
 
 
 
1282
        
1420
1283
        # No such property
1421
1284
        raise DBusPropertyNotFound("{}:{}.{}".format(
1422
1285
            self.dbus_object_path, interface_name, property_name))
1423
 
 
 
1286
    
1424
1287
    @classmethod
1425
1288
    def _get_all_interface_names(cls):
1426
1289
        """Get a sequence of all interfaces supported by an object"""
1429
1292
                                     for x in (inspect.getmro(cls))
1430
1293
                                     for attr in dir(x))
1431
1294
                if name is not None)
1432
 
 
 
1295
    
1433
1296
    @dbus.service.method(dbus.PROPERTIES_IFACE,
1434
1297
                         in_signature="ss",
1435
1298
                         out_signature="v")
1443
1306
        if not hasattr(value, "variant_level"):
1444
1307
            return value
1445
1308
        return type(value)(value, variant_level=value.variant_level+1)
1446
 
 
 
1309
    
1447
1310
    @dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="ssv")
1448
1311
    def Set(self, interface_name, property_name, value):
1449
1312
        """Standard D-Bus property Set() method, see D-Bus standard.
1458
1321
                raise ValueError("Byte arrays not supported for non-"
1459
1322
                                 "'ay' signature {!r}"
1460
1323
                                 .format(prop._dbus_signature))
1461
 
            value = dbus.ByteArray(bytes(value))
 
1324
            value = dbus.ByteArray(b''.join(chr(byte)
 
1325
                                            for byte in value))
1462
1326
        prop(value)
1463
 
 
 
1327
    
1464
1328
    @dbus.service.method(dbus.PROPERTIES_IFACE,
1465
1329
                         in_signature="s",
1466
1330
                         out_signature="a{sv}")
1467
1331
    def GetAll(self, interface_name):
1468
1332
        """Standard D-Bus property GetAll() method, see D-Bus
1469
1333
        standard.
1470
 
 
 
1334
        
1471
1335
        Note: Will not include properties with access="write".
1472
1336
        """
1473
1337
        properties = {}
1484
1348
                properties[name] = value
1485
1349
                continue
1486
1350
            properties[name] = type(value)(
1487
 
                value, variant_level=value.variant_level + 1)
 
1351
                value, variant_level = value.variant_level + 1)
1488
1352
        return dbus.Dictionary(properties, signature="sv")
1489
 
 
 
1353
    
1490
1354
    @dbus.service.signal(dbus.PROPERTIES_IFACE, signature="sa{sv}as")
1491
1355
    def PropertiesChanged(self, interface_name, changed_properties,
1492
1356
                          invalidated_properties):
1494
1358
        standard.
1495
1359
        """
1496
1360
        pass
1497
 
 
 
1361
    
1498
1362
    @dbus.service.method(dbus.INTROSPECTABLE_IFACE,
1499
1363
                         out_signature="s",
1500
 
                         path_keyword="object_path",
1501
 
                         connection_keyword="connection")
 
1364
                         path_keyword='object_path',
 
1365
                         connection_keyword='connection')
1502
1366
    def Introspect(self, object_path, connection):
1503
1367
        """Overloading of standard D-Bus method.
1504
 
 
 
1368
        
1505
1369
        Inserts property tags and interface annotation tags.
1506
1370
        """
1507
1371
        xmlstring = DBusObjectWithAnnotations.Introspect(self,
1509
1373
                                                         connection)
1510
1374
        try:
1511
1375
            document = xml.dom.minidom.parseString(xmlstring)
1512
 
 
 
1376
            
1513
1377
            def make_tag(document, name, prop):
1514
1378
                e = document.createElement("property")
1515
1379
                e.setAttribute("name", name)
1516
1380
                e.setAttribute("type", prop._dbus_signature)
1517
1381
                e.setAttribute("access", prop._dbus_access)
1518
1382
                return e
1519
 
 
 
1383
            
1520
1384
            for if_tag in document.getElementsByTagName("interface"):
1521
1385
                # Add property tags
1522
1386
                for tag in (make_tag(document, name, prop)
1564
1428
                         exc_info=error)
1565
1429
        return xmlstring
1566
1430
 
1567
 
 
1568
1431
try:
1569
1432
    dbus.OBJECT_MANAGER_IFACE
1570
1433
except AttributeError:
1571
1434
    dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"
1572
1435
 
1573
 
 
1574
1436
class DBusObjectWithObjectManager(DBusObjectWithAnnotations):
1575
1437
    """A D-Bus object with an ObjectManager.
1576
 
 
 
1438
    
1577
1439
    Classes inheriting from this exposes the standard
1578
1440
    GetManagedObjects call and the InterfacesAdded and
1579
1441
    InterfacesRemoved signals on the standard
1580
1442
    "org.freedesktop.DBus.ObjectManager" interface.
1581
 
 
 
1443
    
1582
1444
    Note: No signals are sent automatically; they must be sent
1583
1445
    manually.
1584
1446
    """
1585
1447
    @dbus.service.method(dbus.OBJECT_MANAGER_IFACE,
1586
 
                         out_signature="a{oa{sa{sv}}}")
 
1448
                         out_signature = "a{oa{sa{sv}}}")
1587
1449
    def GetManagedObjects(self):
1588
1450
        """This function must be overridden"""
1589
1451
        raise NotImplementedError()
1590
 
 
 
1452
    
1591
1453
    @dbus.service.signal(dbus.OBJECT_MANAGER_IFACE,
1592
 
                         signature="oa{sa{sv}}")
 
1454
                         signature = "oa{sa{sv}}")
1593
1455
    def InterfacesAdded(self, object_path, interfaces_and_properties):
1594
1456
        pass
1595
 
 
1596
 
    @dbus.service.signal(dbus.OBJECT_MANAGER_IFACE, signature="oas")
 
1457
    
 
1458
    @dbus.service.signal(dbus.OBJECT_MANAGER_IFACE, signature = "oas")
1597
1459
    def InterfacesRemoved(self, object_path, interfaces):
1598
1460
        pass
1599
 
 
 
1461
    
1600
1462
    @dbus.service.method(dbus.INTROSPECTABLE_IFACE,
1601
 
                         out_signature="s",
1602
 
                         path_keyword="object_path",
1603
 
                         connection_keyword="connection")
 
1463
                         out_signature = "s",
 
1464
                         path_keyword = 'object_path',
 
1465
                         connection_keyword = 'connection')
1604
1466
    def Introspect(self, object_path, connection):
1605
1467
        """Overloading of standard D-Bus method.
1606
 
 
 
1468
        
1607
1469
        Override return argument name of GetManagedObjects to be
1608
1470
        "objpath_interfaces_and_properties"
1609
1471
        """
1612
1474
                                                         connection)
1613
1475
        try:
1614
1476
            document = xml.dom.minidom.parseString(xmlstring)
1615
 
 
 
1477
            
1616
1478
            for if_tag in document.getElementsByTagName("interface"):
1617
1479
                # Fix argument name for the GetManagedObjects method
1618
1480
                if (if_tag.getAttribute("name")
1619
 
                    == dbus.OBJECT_MANAGER_IFACE):
 
1481
                                == dbus.OBJECT_MANAGER_IFACE):
1620
1482
                    for cn in if_tag.getElementsByTagName("method"):
1621
1483
                        if (cn.getAttribute("name")
1622
1484
                            == "GetManagedObjects"):
1632
1494
        except (AttributeError, xml.dom.DOMException,
1633
1495
                xml.parsers.expat.ExpatError) as error:
1634
1496
            logger.error("Failed to override Introspection method",
1635
 
                         exc_info=error)
 
1497
                         exc_info = error)
1636
1498
        return xmlstring
1637
1499
 
1638
 
 
1639
1500
def datetime_to_dbus(dt, variant_level=0):
1640
1501
    """Convert a UTC datetime.datetime() to a D-Bus type."""
1641
1502
    if dt is None:
1642
 
        return dbus.String("", variant_level=variant_level)
 
1503
        return dbus.String("", variant_level = variant_level)
1643
1504
    return dbus.String(dt.isoformat(), variant_level=variant_level)
1644
1505
 
1645
1506
 
1648
1509
    dbus.service.Object, it will add alternate D-Bus attributes with
1649
1510
    interface names according to the "alt_interface_names" mapping.
1650
1511
    Usage:
1651
 
 
 
1512
    
1652
1513
    @alternate_dbus_interfaces({"org.example.Interface":
1653
1514
                                    "net.example.AlternateInterface"})
1654
1515
    class SampleDBusObject(dbus.service.Object):
1655
1516
        @dbus.service.method("org.example.Interface")
1656
1517
        def SampleDBusMethod():
1657
1518
            pass
1658
 
 
 
1519
    
1659
1520
    The above "SampleDBusMethod" on "SampleDBusObject" will be
1660
1521
    reachable via two interfaces: "org.example.Interface" and
1661
1522
    "net.example.AlternateInterface", the latter of which will have
1662
1523
    its D-Bus annotation "org.freedesktop.DBus.Deprecated" set to
1663
1524
    "true", unless "deprecate" is passed with a False value.
1664
 
 
 
1525
    
1665
1526
    This works for methods and signals, and also for D-Bus properties
1666
1527
    (from DBusObjectWithProperties) and interfaces (from the
1667
1528
    dbus_interface_annotations decorator).
1668
1529
    """
1669
 
 
 
1530
    
1670
1531
    def wrapper(cls):
1671
1532
        for orig_interface_name, alt_interface_name in (
1672
1533
                alt_interface_names.items()):
1712
1573
                            attribute._dbus_annotations)
1713
1574
                    except AttributeError:
1714
1575
                        pass
1715
 
 
1716
1576
                    # Define a creator of a function to call both the
1717
1577
                    # original and alternate functions, so both the
1718
1578
                    # original and alternate signals gets sent when
1721
1581
                        """This function is a scope container to pass
1722
1582
                        func1 and func2 to the "call_both" function
1723
1583
                        outside of its arguments"""
1724
 
 
 
1584
                        
1725
1585
                        @functools.wraps(func2)
1726
1586
                        def call_both(*args, **kwargs):
1727
1587
                            """This function will emit two D-Bus
1728
1588
                            signals by calling func1 and func2"""
1729
1589
                            func1(*args, **kwargs)
1730
1590
                            func2(*args, **kwargs)
1731
 
                        # Make wrapper function look like a D-Bus
1732
 
                        # signal
 
1591
                        # Make wrapper function look like a D-Bus signal
1733
1592
                        for name, attr in inspect.getmembers(func2):
1734
1593
                            if name.startswith("_dbus_"):
1735
1594
                                setattr(call_both, name, attr)
1736
 
 
 
1595
                        
1737
1596
                        return call_both
1738
1597
                    # Create the "call_both" function and add it to
1739
1598
                    # the class
1785
1644
                        (copy_function(attribute)))
1786
1645
            if deprecate:
1787
1646
                # Deprecate all alternate interfaces
1788
 
                iname = "_AlternateDBusNames_interface_annotation{}"
 
1647
                iname="_AlternateDBusNames_interface_annotation{}"
1789
1648
                for interface_name in interface_names:
1790
 
 
 
1649
                    
1791
1650
                    @dbus_interface_annotations(interface_name)
1792
1651
                    def func(self):
1793
 
                        return {"org.freedesktop.DBus.Deprecated":
1794
 
                                "true"}
 
1652
                        return { "org.freedesktop.DBus.Deprecated":
 
1653
                                 "true" }
1795
1654
                    # Find an unused name
1796
1655
                    for aname in (iname.format(i)
1797
1656
                                  for i in itertools.count()):
1808
1667
                    cls = type("{}Alternate".format(cls.__name__),
1809
1668
                               (cls, ), attr)
1810
1669
        return cls
1811
 
 
 
1670
    
1812
1671
    return wrapper
1813
1672
 
1814
1673
 
1816
1675
                            "se.bsnet.fukt.Mandos"})
1817
1676
class ClientDBus(Client, DBusObjectWithProperties):
1818
1677
    """A Client class using D-Bus
1819
 
 
 
1678
    
1820
1679
    Attributes:
1821
1680
    dbus_object_path: dbus.ObjectPath
1822
1681
    bus: dbus.SystemBus()
1823
1682
    """
1824
 
 
 
1683
    
1825
1684
    runtime_expansions = (Client.runtime_expansions
1826
1685
                          + ("dbus_object_path", ))
1827
 
 
 
1686
    
1828
1687
    _interface = "se.recompile.Mandos.Client"
1829
 
 
 
1688
    
1830
1689
    # dbus.service.Object doesn't use super(), so we can't either.
1831
 
 
1832
 
    def __init__(self, bus=None, *args, **kwargs):
 
1690
    
 
1691
    def __init__(self, bus = None, *args, **kwargs):
1833
1692
        self.bus = bus
1834
1693
        Client.__init__(self, *args, **kwargs)
1835
1694
        # Only now, when this client is initialized, can it show up on
1841
1700
            "/clients/" + client_object_name)
1842
1701
        DBusObjectWithProperties.__init__(self, self.bus,
1843
1702
                                          self.dbus_object_path)
1844
 
 
 
1703
    
1845
1704
    def notifychangeproperty(transform_func, dbus_name,
1846
1705
                             type_func=lambda x: x,
1847
1706
                             variant_level=1,
1849
1708
                             _interface=_interface):
1850
1709
        """ Modify a variable so that it's a property which announces
1851
1710
        its changes to DBus.
1852
 
 
 
1711
        
1853
1712
        transform_fun: Function that takes a value and a variant_level
1854
1713
                       and transforms it to a D-Bus type.
1855
1714
        dbus_name: D-Bus name of the variable
1858
1717
        variant_level: D-Bus variant level.  Default: 1
1859
1718
        """
1860
1719
        attrname = "_{}".format(dbus_name)
1861
 
 
 
1720
        
1862
1721
        def setter(self, value):
1863
1722
            if hasattr(self, "dbus_object_path"):
1864
1723
                if (not hasattr(self, attrname) or
1871
1730
                    else:
1872
1731
                        dbus_value = transform_func(
1873
1732
                            type_func(value),
1874
 
                            variant_level=variant_level)
 
1733
                            variant_level = variant_level)
1875
1734
                        self.PropertyChanged(dbus.String(dbus_name),
1876
1735
                                             dbus_value)
1877
1736
                        self.PropertiesChanged(
1878
1737
                            _interface,
1879
 
                            dbus.Dictionary({dbus.String(dbus_name):
1880
 
                                             dbus_value}),
 
1738
                            dbus.Dictionary({ dbus.String(dbus_name):
 
1739
                                              dbus_value }),
1881
1740
                            dbus.Array())
1882
1741
            setattr(self, attrname, value)
1883
 
 
 
1742
        
1884
1743
        return property(lambda self: getattr(self, attrname), setter)
1885
 
 
 
1744
    
1886
1745
    expires = notifychangeproperty(datetime_to_dbus, "Expires")
1887
1746
    approvals_pending = notifychangeproperty(dbus.Boolean,
1888
1747
                                             "ApprovalPending",
1889
 
                                             type_func=bool)
 
1748
                                             type_func = bool)
1890
1749
    enabled = notifychangeproperty(dbus.Boolean, "Enabled")
1891
1750
    last_enabled = notifychangeproperty(datetime_to_dbus,
1892
1751
                                        "LastEnabled")
1893
1752
    checker = notifychangeproperty(
1894
1753
        dbus.Boolean, "CheckerRunning",
1895
 
        type_func=lambda checker: checker is not None)
 
1754
        type_func = lambda checker: checker is not None)
1896
1755
    last_checked_ok = notifychangeproperty(datetime_to_dbus,
1897
1756
                                           "LastCheckedOK")
1898
1757
    last_checker_status = notifychangeproperty(dbus.Int16,
1903
1762
                                               "ApprovedByDefault")
1904
1763
    approval_delay = notifychangeproperty(
1905
1764
        dbus.UInt64, "ApprovalDelay",
1906
 
        type_func=lambda td: td.total_seconds() * 1000)
 
1765
        type_func = lambda td: td.total_seconds() * 1000)
1907
1766
    approval_duration = notifychangeproperty(
1908
1767
        dbus.UInt64, "ApprovalDuration",
1909
 
        type_func=lambda td: td.total_seconds() * 1000)
 
1768
        type_func = lambda td: td.total_seconds() * 1000)
1910
1769
    host = notifychangeproperty(dbus.String, "Host")
1911
1770
    timeout = notifychangeproperty(
1912
1771
        dbus.UInt64, "Timeout",
1913
 
        type_func=lambda td: td.total_seconds() * 1000)
 
1772
        type_func = lambda td: td.total_seconds() * 1000)
1914
1773
    extended_timeout = notifychangeproperty(
1915
1774
        dbus.UInt64, "ExtendedTimeout",
1916
 
        type_func=lambda td: td.total_seconds() * 1000)
 
1775
        type_func = lambda td: td.total_seconds() * 1000)
1917
1776
    interval = notifychangeproperty(
1918
1777
        dbus.UInt64, "Interval",
1919
 
        type_func=lambda td: td.total_seconds() * 1000)
 
1778
        type_func = lambda td: td.total_seconds() * 1000)
1920
1779
    checker_command = notifychangeproperty(dbus.String, "Checker")
1921
1780
    secret = notifychangeproperty(dbus.ByteArray, "Secret",
1922
1781
                                  invalidate_only=True)
1923
 
 
 
1782
    
1924
1783
    del notifychangeproperty
1925
 
 
 
1784
    
1926
1785
    def __del__(self, *args, **kwargs):
1927
1786
        try:
1928
1787
            self.remove_from_connection()
1931
1790
        if hasattr(DBusObjectWithProperties, "__del__"):
1932
1791
            DBusObjectWithProperties.__del__(self, *args, **kwargs)
1933
1792
        Client.__del__(self, *args, **kwargs)
1934
 
 
 
1793
    
1935
1794
    def checker_callback(self, source, condition,
1936
1795
                         connection, command, *args, **kwargs):
1937
1796
        ret = Client.checker_callback(self, source, condition,
1953
1812
                                      | self.last_checker_signal),
1954
1813
                                  dbus.String(command))
1955
1814
        return ret
1956
 
 
 
1815
    
1957
1816
    def start_checker(self, *args, **kwargs):
1958
1817
        old_checker_pid = getattr(self.checker, "pid", None)
1959
1818
        r = Client.start_checker(self, *args, **kwargs)
1963
1822
            # Emit D-Bus signal
1964
1823
            self.CheckerStarted(self.current_checker_command)
1965
1824
        return r
1966
 
 
 
1825
    
1967
1826
    def _reset_approved(self):
1968
1827
        self.approved = None
1969
1828
        return False
1970
 
 
 
1829
    
1971
1830
    def approve(self, value=True):
1972
1831
        self.approved = value
1973
1832
        GLib.timeout_add(int(self.approval_duration.total_seconds()
1974
1833
                             * 1000), self._reset_approved)
1975
1834
        self.send_changedstate()
1976
 
 
1977
 
    #  D-Bus methods, signals & properties
1978
 
 
1979
 
    #  Interfaces
1980
 
 
1981
 
    #  Signals
1982
 
 
 
1835
    
 
1836
    ## D-Bus methods, signals & properties
 
1837
    
 
1838
    ## Interfaces
 
1839
    
 
1840
    ## Signals
 
1841
    
1983
1842
    # CheckerCompleted - signal
1984
1843
    @dbus.service.signal(_interface, signature="nxs")
1985
1844
    def CheckerCompleted(self, exitcode, waitstatus, command):
1986
1845
        "D-Bus signal"
1987
1846
        pass
1988
 
 
 
1847
    
1989
1848
    # CheckerStarted - signal
1990
1849
    @dbus.service.signal(_interface, signature="s")
1991
1850
    def CheckerStarted(self, command):
1992
1851
        "D-Bus signal"
1993
1852
        pass
1994
 
 
 
1853
    
1995
1854
    # PropertyChanged - signal
1996
1855
    @dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1997
1856
    @dbus.service.signal(_interface, signature="sv")
1998
1857
    def PropertyChanged(self, property, value):
1999
1858
        "D-Bus signal"
2000
1859
        pass
2001
 
 
 
1860
    
2002
1861
    # GotSecret - signal
2003
1862
    @dbus.service.signal(_interface)
2004
1863
    def GotSecret(self):
2007
1866
        server to mandos-client
2008
1867
        """
2009
1868
        pass
2010
 
 
 
1869
    
2011
1870
    # Rejected - signal
2012
1871
    @dbus.service.signal(_interface, signature="s")
2013
1872
    def Rejected(self, reason):
2014
1873
        "D-Bus signal"
2015
1874
        pass
2016
 
 
 
1875
    
2017
1876
    # NeedApproval - signal
2018
1877
    @dbus.service.signal(_interface, signature="tb")
2019
1878
    def NeedApproval(self, timeout, default):
2020
1879
        "D-Bus signal"
2021
1880
        return self.need_approval()
2022
 
 
2023
 
    #  Methods
2024
 
 
 
1881
    
 
1882
    ## Methods
 
1883
    
2025
1884
    # Approve - method
2026
1885
    @dbus.service.method(_interface, in_signature="b")
2027
1886
    def Approve(self, value):
2028
1887
        self.approve(value)
2029
 
 
 
1888
    
2030
1889
    # CheckedOK - method
2031
1890
    @dbus.service.method(_interface)
2032
1891
    def CheckedOK(self):
2033
1892
        self.checked_ok()
2034
 
 
 
1893
    
2035
1894
    # Enable - method
2036
1895
    @dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
2037
1896
    @dbus.service.method(_interface)
2038
1897
    def Enable(self):
2039
1898
        "D-Bus method"
2040
1899
        self.enable()
2041
 
 
 
1900
    
2042
1901
    # StartChecker - method
2043
1902
    @dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
2044
1903
    @dbus.service.method(_interface)
2045
1904
    def StartChecker(self):
2046
1905
        "D-Bus method"
2047
1906
        self.start_checker()
2048
 
 
 
1907
    
2049
1908
    # Disable - method
2050
1909
    @dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
2051
1910
    @dbus.service.method(_interface)
2052
1911
    def Disable(self):
2053
1912
        "D-Bus method"
2054
1913
        self.disable()
2055
 
 
 
1914
    
2056
1915
    # StopChecker - method
2057
1916
    @dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
2058
1917
    @dbus.service.method(_interface)
2059
1918
    def StopChecker(self):
2060
1919
        self.stop_checker()
2061
 
 
2062
 
    #  Properties
2063
 
 
 
1920
    
 
1921
    ## Properties
 
1922
    
2064
1923
    # ApprovalPending - property
2065
1924
    @dbus_service_property(_interface, signature="b", access="read")
2066
1925
    def ApprovalPending_dbus_property(self):
2067
1926
        return dbus.Boolean(bool(self.approvals_pending))
2068
 
 
 
1927
    
2069
1928
    # ApprovedByDefault - property
2070
1929
    @dbus_service_property(_interface,
2071
1930
                           signature="b",
2074
1933
        if value is None:       # get
2075
1934
            return dbus.Boolean(self.approved_by_default)
2076
1935
        self.approved_by_default = bool(value)
2077
 
 
 
1936
    
2078
1937
    # ApprovalDelay - property
2079
1938
    @dbus_service_property(_interface,
2080
1939
                           signature="t",
2084
1943
            return dbus.UInt64(self.approval_delay.total_seconds()
2085
1944
                               * 1000)
2086
1945
        self.approval_delay = datetime.timedelta(0, 0, 0, value)
2087
 
 
 
1946
    
2088
1947
    # ApprovalDuration - property
2089
1948
    @dbus_service_property(_interface,
2090
1949
                           signature="t",
2094
1953
            return dbus.UInt64(self.approval_duration.total_seconds()
2095
1954
                               * 1000)
2096
1955
        self.approval_duration = datetime.timedelta(0, 0, 0, value)
2097
 
 
 
1956
    
2098
1957
    # Name - property
2099
1958
    @dbus_annotations(
2100
1959
        {"org.freedesktop.DBus.Property.EmitsChangedSignal": "const"})
2101
1960
    @dbus_service_property(_interface, signature="s", access="read")
2102
1961
    def Name_dbus_property(self):
2103
1962
        return dbus.String(self.name)
2104
 
 
2105
 
    # KeyID - property
2106
 
    @dbus_annotations(
2107
 
        {"org.freedesktop.DBus.Property.EmitsChangedSignal": "const"})
2108
 
    @dbus_service_property(_interface, signature="s", access="read")
2109
 
    def KeyID_dbus_property(self):
2110
 
        return dbus.String(self.key_id)
2111
 
 
 
1963
    
2112
1964
    # Fingerprint - property
2113
1965
    @dbus_annotations(
2114
1966
        {"org.freedesktop.DBus.Property.EmitsChangedSignal": "const"})
2115
1967
    @dbus_service_property(_interface, signature="s", access="read")
2116
1968
    def Fingerprint_dbus_property(self):
2117
1969
        return dbus.String(self.fingerprint)
2118
 
 
 
1970
    
2119
1971
    # Host - property
2120
1972
    @dbus_service_property(_interface,
2121
1973
                           signature="s",
2124
1976
        if value is None:       # get
2125
1977
            return dbus.String(self.host)
2126
1978
        self.host = str(value)
2127
 
 
 
1979
    
2128
1980
    # Created - property
2129
1981
    @dbus_annotations(
2130
1982
        {"org.freedesktop.DBus.Property.EmitsChangedSignal": "const"})
2131
1983
    @dbus_service_property(_interface, signature="s", access="read")
2132
1984
    def Created_dbus_property(self):
2133
1985
        return datetime_to_dbus(self.created)
2134
 
 
 
1986
    
2135
1987
    # LastEnabled - property
2136
1988
    @dbus_service_property(_interface, signature="s", access="read")
2137
1989
    def LastEnabled_dbus_property(self):
2138
1990
        return datetime_to_dbus(self.last_enabled)
2139
 
 
 
1991
    
2140
1992
    # Enabled - property
2141
1993
    @dbus_service_property(_interface,
2142
1994
                           signature="b",
2148
2000
            self.enable()
2149
2001
        else:
2150
2002
            self.disable()
2151
 
 
 
2003
    
2152
2004
    # LastCheckedOK - property
2153
2005
    @dbus_service_property(_interface,
2154
2006
                           signature="s",
2158
2010
            self.checked_ok()
2159
2011
            return
2160
2012
        return datetime_to_dbus(self.last_checked_ok)
2161
 
 
 
2013
    
2162
2014
    # LastCheckerStatus - property
2163
2015
    @dbus_service_property(_interface, signature="n", access="read")
2164
2016
    def LastCheckerStatus_dbus_property(self):
2165
2017
        return dbus.Int16(self.last_checker_status)
2166
 
 
 
2018
    
2167
2019
    # Expires - property
2168
2020
    @dbus_service_property(_interface, signature="s", access="read")
2169
2021
    def Expires_dbus_property(self):
2170
2022
        return datetime_to_dbus(self.expires)
2171
 
 
 
2023
    
2172
2024
    # LastApprovalRequest - property
2173
2025
    @dbus_service_property(_interface, signature="s", access="read")
2174
2026
    def LastApprovalRequest_dbus_property(self):
2175
2027
        return datetime_to_dbus(self.last_approval_request)
2176
 
 
 
2028
    
2177
2029
    # Timeout - property
2178
2030
    @dbus_service_property(_interface,
2179
2031
                           signature="t",
2198
2050
                self.disable_initiator_tag = GLib.timeout_add(
2199
2051
                    int((self.expires - now).total_seconds() * 1000),
2200
2052
                    self.disable)
2201
 
 
 
2053
    
2202
2054
    # ExtendedTimeout - property
2203
2055
    @dbus_service_property(_interface,
2204
2056
                           signature="t",
2208
2060
            return dbus.UInt64(self.extended_timeout.total_seconds()
2209
2061
                               * 1000)
2210
2062
        self.extended_timeout = datetime.timedelta(0, 0, 0, value)
2211
 
 
 
2063
    
2212
2064
    # Interval - property
2213
2065
    @dbus_service_property(_interface,
2214
2066
                           signature="t",
2224
2076
            GLib.source_remove(self.checker_initiator_tag)
2225
2077
            self.checker_initiator_tag = GLib.timeout_add(
2226
2078
                value, self.start_checker)
2227
 
            self.start_checker()  # Start one now, too
2228
 
 
 
2079
            self.start_checker() # Start one now, too
 
2080
    
2229
2081
    # Checker - property
2230
2082
    @dbus_service_property(_interface,
2231
2083
                           signature="s",
2234
2086
        if value is None:       # get
2235
2087
            return dbus.String(self.checker_command)
2236
2088
        self.checker_command = str(value)
2237
 
 
 
2089
    
2238
2090
    # CheckerRunning - property
2239
2091
    @dbus_service_property(_interface,
2240
2092
                           signature="b",
2246
2098
            self.start_checker()
2247
2099
        else:
2248
2100
            self.stop_checker()
2249
 
 
 
2101
    
2250
2102
    # ObjectPath - property
2251
2103
    @dbus_annotations(
2252
2104
        {"org.freedesktop.DBus.Property.EmitsChangedSignal": "const",
2253
2105
         "org.freedesktop.DBus.Deprecated": "true"})
2254
2106
    @dbus_service_property(_interface, signature="o", access="read")
2255
2107
    def ObjectPath_dbus_property(self):
2256
 
        return self.dbus_object_path  # is already a dbus.ObjectPath
2257
 
 
 
2108
        return self.dbus_object_path # is already a dbus.ObjectPath
 
2109
    
2258
2110
    # Secret = property
2259
2111
    @dbus_annotations(
2260
2112
        {"org.freedesktop.DBus.Property.EmitsChangedSignal":
2265
2117
                           byte_arrays=True)
2266
2118
    def Secret_dbus_property(self, value):
2267
2119
        self.secret = bytes(value)
2268
 
 
 
2120
    
2269
2121
    del _interface
2270
2122
 
2271
2123
 
2272
 
class ProxyClient:
2273
 
    def __init__(self, child_pipe, key_id, fpr, address):
 
2124
class ProxyClient(object):
 
2125
    def __init__(self, child_pipe, fpr, address):
2274
2126
        self._pipe = child_pipe
2275
 
        self._pipe.send(("init", key_id, fpr, address))
 
2127
        self._pipe.send(('init', fpr, address))
2276
2128
        if not self._pipe.recv():
2277
 
            raise KeyError(key_id or fpr)
2278
 
 
 
2129
            raise KeyError(fpr)
 
2130
    
2279
2131
    def __getattribute__(self, name):
2280
 
        if name == "_pipe":
 
2132
        if name == '_pipe':
2281
2133
            return super(ProxyClient, self).__getattribute__(name)
2282
 
        self._pipe.send(("getattr", name))
 
2134
        self._pipe.send(('getattr', name))
2283
2135
        data = self._pipe.recv()
2284
 
        if data[0] == "data":
 
2136
        if data[0] == 'data':
2285
2137
            return data[1]
2286
 
        if data[0] == "function":
2287
 
 
 
2138
        if data[0] == 'function':
 
2139
            
2288
2140
            def func(*args, **kwargs):
2289
 
                self._pipe.send(("funcall", name, args, kwargs))
 
2141
                self._pipe.send(('funcall', name, args, kwargs))
2290
2142
                return self._pipe.recv()[1]
2291
 
 
 
2143
            
2292
2144
            return func
2293
 
 
 
2145
    
2294
2146
    def __setattr__(self, name, value):
2295
 
        if name == "_pipe":
 
2147
        if name == '_pipe':
2296
2148
            return super(ProxyClient, self).__setattr__(name, value)
2297
 
        self._pipe.send(("setattr", name, value))
 
2149
        self._pipe.send(('setattr', name, value))
2298
2150
 
2299
2151
 
2300
2152
class ClientHandler(socketserver.BaseRequestHandler, object):
2301
2153
    """A class to handle client connections.
2302
 
 
 
2154
    
2303
2155
    Instantiated once for each connection to handle it.
2304
2156
    Note: This will run in its own forked process."""
2305
 
 
 
2157
    
2306
2158
    def handle(self):
2307
2159
        with contextlib.closing(self.server.child_pipe) as child_pipe:
2308
2160
            logger.info("TCP connection from: %s",
2309
2161
                        str(self.client_address))
2310
2162
            logger.debug("Pipe FD: %d",
2311
2163
                         self.server.child_pipe.fileno())
2312
 
 
 
2164
            
2313
2165
            session = gnutls.ClientSession(self.request)
2314
 
 
2315
 
            # priority = ":".join(("NONE", "+VERS-TLS1.1",
2316
 
            #                       "+AES-256-CBC", "+SHA1",
2317
 
            #                       "+COMP-NULL", "+CTYPE-OPENPGP",
2318
 
            #                       "+DHE-DSS"))
 
2166
            
 
2167
            #priority = ':'.join(("NONE", "+VERS-TLS1.1",
 
2168
            #                      "+AES-256-CBC", "+SHA1",
 
2169
            #                      "+COMP-NULL", "+CTYPE-OPENPGP",
 
2170
            #                      "+DHE-DSS"))
2319
2171
            # Use a fallback default, since this MUST be set.
2320
2172
            priority = self.server.gnutls_priority
2321
2173
            if priority is None:
2322
2174
                priority = "NORMAL"
2323
 
            gnutls.priority_set_direct(session,
2324
 
                                       priority.encode("utf-8"), None)
2325
 
 
 
2175
            gnutls.priority_set_direct(session._c_object, priority,
 
2176
                                       None)
 
2177
            
2326
2178
            # Start communication using the Mandos protocol
2327
2179
            # Get protocol number
2328
2180
            line = self.request.makefile().readline()
2333
2185
            except (ValueError, IndexError, RuntimeError) as error:
2334
2186
                logger.error("Unknown protocol version: %s", error)
2335
2187
                return
2336
 
 
 
2188
            
2337
2189
            # Start GnuTLS connection
2338
2190
            try:
2339
2191
                session.handshake()
2343
2195
                # established.  Just abandon the request.
2344
2196
                return
2345
2197
            logger.debug("Handshake succeeded")
2346
 
 
 
2198
            
2347
2199
            approval_required = False
2348
2200
            try:
2349
 
                if gnutls.has_rawpk:
2350
 
                    fpr = b""
2351
 
                    try:
2352
 
                        key_id = self.key_id(
2353
 
                            self.peer_certificate(session))
2354
 
                    except (TypeError, gnutls.Error) as error:
2355
 
                        logger.warning("Bad certificate: %s", error)
2356
 
                        return
2357
 
                    logger.debug("Key ID: %s",
2358
 
                                 key_id.decode("utf-8",
2359
 
                                               errors="replace"))
2360
 
 
2361
 
                else:
2362
 
                    key_id = b""
2363
 
                    try:
2364
 
                        fpr = self.fingerprint(
2365
 
                            self.peer_certificate(session))
2366
 
                    except (TypeError, gnutls.Error) as error:
2367
 
                        logger.warning("Bad certificate: %s", error)
2368
 
                        return
2369
 
                    logger.debug("Fingerprint: %s", fpr)
2370
 
 
2371
 
                try:
2372
 
                    client = ProxyClient(child_pipe, key_id, fpr,
 
2201
                try:
 
2202
                    fpr = self.fingerprint(
 
2203
                        self.peer_certificate(session))
 
2204
                except (TypeError, gnutls.Error) as error:
 
2205
                    logger.warning("Bad certificate: %s", error)
 
2206
                    return
 
2207
                logger.debug("Fingerprint: %s", fpr)
 
2208
                
 
2209
                try:
 
2210
                    client = ProxyClient(child_pipe, fpr,
2373
2211
                                         self.client_address)
2374
2212
                except KeyError:
2375
2213
                    return
2376
 
 
 
2214
                
2377
2215
                if client.approval_delay:
2378
2216
                    delay = client.approval_delay
2379
2217
                    client.approvals_pending += 1
2380
2218
                    approval_required = True
2381
 
 
 
2219
                
2382
2220
                while True:
2383
2221
                    if not client.enabled:
2384
2222
                        logger.info("Client %s is disabled",
2387
2225
                            # Emit D-Bus signal
2388
2226
                            client.Rejected("Disabled")
2389
2227
                        return
2390
 
 
 
2228
                    
2391
2229
                    if client.approved or not client.approval_delay:
2392
 
                        # We are approved or approval is disabled
 
2230
                        #We are approved or approval is disabled
2393
2231
                        break
2394
2232
                    elif client.approved is None:
2395
2233
                        logger.info("Client %s needs approval",
2406
2244
                            # Emit D-Bus signal
2407
2245
                            client.Rejected("Denied")
2408
2246
                        return
2409
 
 
2410
 
                    # wait until timeout or approved
 
2247
                    
 
2248
                    #wait until timeout or approved
2411
2249
                    time = datetime.datetime.now()
2412
2250
                    client.changedstate.acquire()
2413
2251
                    client.changedstate.wait(delay.total_seconds())
2426
2264
                            break
2427
2265
                    else:
2428
2266
                        delay -= time2 - time
2429
 
 
 
2267
                
2430
2268
                try:
2431
2269
                    session.send(client.secret)
2432
2270
                except gnutls.Error as error:
2433
2271
                    logger.warning("gnutls send failed",
2434
 
                                   exc_info=error)
 
2272
                                   exc_info = error)
2435
2273
                    return
2436
 
 
 
2274
                
2437
2275
                logger.info("Sending secret to %s", client.name)
2438
2276
                # bump the timeout using extended_timeout
2439
2277
                client.bump_timeout(client.extended_timeout)
2440
2278
                if self.server.use_dbus:
2441
2279
                    # Emit D-Bus signal
2442
2280
                    client.GotSecret()
2443
 
 
 
2281
            
2444
2282
            finally:
2445
2283
                if approval_required:
2446
2284
                    client.approvals_pending -= 1
2449
2287
                except gnutls.Error as error:
2450
2288
                    logger.warning("GnuTLS bye failed",
2451
2289
                                   exc_info=error)
2452
 
 
 
2290
    
2453
2291
    @staticmethod
2454
2292
    def peer_certificate(session):
2455
 
        "Return the peer's certificate as a bytestring"
2456
 
        try:
2457
 
            cert_type = gnutls.certificate_type_get2(
2458
 
                session, gnutls.CTYPE_PEERS)
2459
 
        except AttributeError:
2460
 
            cert_type = gnutls.certificate_type_get(session)
2461
 
        if gnutls.has_rawpk:
2462
 
            valid_cert_types = frozenset((gnutls.CRT_RAWPK,))
2463
 
        else:
2464
 
            valid_cert_types = frozenset((gnutls.CRT_OPENPGP,))
2465
 
        # If not a valid certificate type...
2466
 
        if cert_type not in valid_cert_types:
2467
 
            logger.info("Cert type %r not in %r", cert_type,
2468
 
                        valid_cert_types)
 
2293
        "Return the peer's OpenPGP certificate as a bytestring"
 
2294
        # If not an OpenPGP certificate...
 
2295
        if (gnutls.certificate_type_get(session._c_object)
 
2296
            != gnutls.CRT_OPENPGP):
2469
2297
            # ...return invalid data
2470
2298
            return b""
2471
2299
        list_size = ctypes.c_uint(1)
2472
2300
        cert_list = (gnutls.certificate_get_peers
2473
 
                     (session, ctypes.byref(list_size)))
 
2301
                     (session._c_object, ctypes.byref(list_size)))
2474
2302
        if not bool(cert_list) and list_size.value != 0:
2475
2303
            raise gnutls.Error("error getting peer certificate")
2476
2304
        if list_size.value == 0:
2477
2305
            return None
2478
2306
        cert = cert_list[0]
2479
2307
        return ctypes.string_at(cert.data, cert.size)
2480
 
 
2481
 
    @staticmethod
2482
 
    def key_id(certificate):
2483
 
        "Convert a certificate bytestring to a hexdigit key ID"
2484
 
        # New GnuTLS "datum" with the public key
2485
 
        datum = gnutls.datum_t(
2486
 
            ctypes.cast(ctypes.c_char_p(certificate),
2487
 
                        ctypes.POINTER(ctypes.c_ubyte)),
2488
 
            ctypes.c_uint(len(certificate)))
2489
 
        # XXX all these need to be created in the gnutls "module"
2490
 
        # New empty GnuTLS certificate
2491
 
        pubkey = gnutls.pubkey_t()
2492
 
        gnutls.pubkey_init(ctypes.byref(pubkey))
2493
 
        # Import the raw public key into the certificate
2494
 
        gnutls.pubkey_import(pubkey,
2495
 
                             ctypes.byref(datum),
2496
 
                             gnutls.X509_FMT_DER)
2497
 
        # New buffer for the key ID
2498
 
        buf = ctypes.create_string_buffer(32)
2499
 
        buf_len = ctypes.c_size_t(len(buf))
2500
 
        # Get the key ID from the raw public key into the buffer
2501
 
        gnutls.pubkey_get_key_id(
2502
 
            pubkey,
2503
 
            gnutls.KEYID_USE_SHA256,
2504
 
            ctypes.cast(ctypes.byref(buf),
2505
 
                        ctypes.POINTER(ctypes.c_ubyte)),
2506
 
            ctypes.byref(buf_len))
2507
 
        # Deinit the certificate
2508
 
        gnutls.pubkey_deinit(pubkey)
2509
 
 
2510
 
        # Convert the buffer to a Python bytestring
2511
 
        key_id = ctypes.string_at(buf, buf_len.value)
2512
 
        # Convert the bytestring to hexadecimal notation
2513
 
        hex_key_id = binascii.hexlify(key_id).upper()
2514
 
        return hex_key_id
2515
 
 
 
2308
    
2516
2309
    @staticmethod
2517
2310
    def fingerprint(openpgp):
2518
2311
        "Convert an OpenPGP bytestring to a hexdigit fingerprint"
2533
2326
                                       ctypes.byref(crtverify))
2534
2327
        if crtverify.value != 0:
2535
2328
            gnutls.openpgp_crt_deinit(crt)
2536
 
            raise gnutls.CertificateSecurityError(code
2537
 
                                                  =crtverify.value)
 
2329
            raise gnutls.CertificateSecurityError("Verify failed")
2538
2330
        # New buffer for the fingerprint
2539
2331
        buf = ctypes.create_string_buffer(20)
2540
2332
        buf_len = ctypes.c_size_t()
2550
2342
        return hex_fpr
2551
2343
 
2552
2344
 
2553
 
class MultiprocessingMixIn:
 
2345
class MultiprocessingMixIn(object):
2554
2346
    """Like socketserver.ThreadingMixIn, but with multiprocessing"""
2555
 
 
 
2347
    
2556
2348
    def sub_process_main(self, request, address):
2557
2349
        try:
2558
2350
            self.finish_request(request, address)
2559
2351
        except Exception:
2560
2352
            self.handle_error(request, address)
2561
2353
        self.close_request(request)
2562
 
 
 
2354
    
2563
2355
    def process_request(self, request, address):
2564
2356
        """Start a new process to process the request."""
2565
 
        proc = multiprocessing.Process(target=self.sub_process_main,
2566
 
                                       args=(request, address))
 
2357
        proc = multiprocessing.Process(target = self.sub_process_main,
 
2358
                                       args = (request, address))
2567
2359
        proc.start()
2568
2360
        return proc
2569
2361
 
2570
2362
 
2571
 
class MultiprocessingMixInWithPipe(MultiprocessingMixIn):
 
2363
class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):
2572
2364
    """ adds a pipe to the MixIn """
2573
 
 
 
2365
    
2574
2366
    def process_request(self, request, client_address):
2575
2367
        """Overrides and wraps the original process_request().
2576
 
 
 
2368
        
2577
2369
        This function creates a new pipe in self.pipe
2578
2370
        """
2579
2371
        parent_pipe, self.child_pipe = multiprocessing.Pipe()
2580
 
 
 
2372
        
2581
2373
        proc = MultiprocessingMixIn.process_request(self, request,
2582
2374
                                                    client_address)
2583
2375
        self.child_pipe.close()
2584
2376
        self.add_pipe(parent_pipe, proc)
2585
 
 
 
2377
    
2586
2378
    def add_pipe(self, parent_pipe, proc):
2587
2379
        """Dummy function; override as necessary"""
2588
2380
        raise NotImplementedError()
2589
2381
 
2590
2382
 
2591
2383
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
2592
 
                     socketserver.TCPServer):
2593
 
    """IPv6-capable TCP server.  Accepts None as address and/or port
2594
 
 
 
2384
                     socketserver.TCPServer, object):
 
2385
    """IPv6-capable TCP server.  Accepts 'None' as address and/or port
 
2386
    
2595
2387
    Attributes:
2596
2388
        enabled:        Boolean; whether this server is activated yet
2597
2389
        interface:      None or a network interface name (string)
2598
2390
        use_ipv6:       Boolean; to use IPv6 or not
2599
2391
    """
2600
 
 
 
2392
    
2601
2393
    def __init__(self, server_address, RequestHandlerClass,
2602
2394
                 interface=None,
2603
2395
                 use_ipv6=True,
2613
2405
            self.socketfd = socketfd
2614
2406
            # Save the original socket.socket() function
2615
2407
            self.socket_socket = socket.socket
2616
 
 
2617
2408
            # To implement --socket, we monkey patch socket.socket.
2618
 
            #
 
2409
            # 
2619
2410
            # (When socketserver.TCPServer is a new-style class, we
2620
2411
            # could make self.socket into a property instead of monkey
2621
2412
            # patching socket.socket.)
2622
 
            #
 
2413
            # 
2623
2414
            # Create a one-time-only replacement for socket.socket()
2624
2415
            @functools.wraps(socket.socket)
2625
2416
            def socket_wrapper(*args, **kwargs):
2637
2428
        # socket_wrapper(), if socketfd was set.
2638
2429
        socketserver.TCPServer.__init__(self, server_address,
2639
2430
                                        RequestHandlerClass)
2640
 
 
 
2431
    
2641
2432
    def server_bind(self):
2642
2433
        """This overrides the normal server_bind() function
2643
2434
        to bind to an interface if one was specified, and also NOT to
2644
2435
        bind to an address or port if they were not specified."""
2645
 
        global SO_BINDTODEVICE
2646
2436
        if self.interface is not None:
2647
2437
            if SO_BINDTODEVICE is None:
2648
 
                # Fall back to a hard-coded value which seems to be
2649
 
                # common enough.
2650
 
                logger.warning("SO_BINDTODEVICE not found, trying 25")
2651
 
                SO_BINDTODEVICE = 25
2652
 
            try:
2653
 
                self.socket.setsockopt(
2654
 
                    socket.SOL_SOCKET, SO_BINDTODEVICE,
2655
 
                    (self.interface + "\0").encode("utf-8"))
2656
 
            except socket.error as error:
2657
 
                if error.errno == errno.EPERM:
2658
 
                    logger.error("No permission to bind to"
2659
 
                                 " interface %s", self.interface)
2660
 
                elif error.errno == errno.ENOPROTOOPT:
2661
 
                    logger.error("SO_BINDTODEVICE not available;"
2662
 
                                 " cannot bind to interface %s",
2663
 
                                 self.interface)
2664
 
                elif error.errno == errno.ENODEV:
2665
 
                    logger.error("Interface %s does not exist,"
2666
 
                                 " cannot bind", self.interface)
2667
 
                else:
2668
 
                    raise
 
2438
                logger.error("SO_BINDTODEVICE does not exist;"
 
2439
                             " cannot bind to interface %s",
 
2440
                             self.interface)
 
2441
            else:
 
2442
                try:
 
2443
                    self.socket.setsockopt(
 
2444
                        socket.SOL_SOCKET, SO_BINDTODEVICE,
 
2445
                        (self.interface + "\0").encode("utf-8"))
 
2446
                except socket.error as error:
 
2447
                    if error.errno == errno.EPERM:
 
2448
                        logger.error("No permission to bind to"
 
2449
                                     " interface %s", self.interface)
 
2450
                    elif error.errno == errno.ENOPROTOOPT:
 
2451
                        logger.error("SO_BINDTODEVICE not available;"
 
2452
                                     " cannot bind to interface %s",
 
2453
                                     self.interface)
 
2454
                    elif error.errno == errno.ENODEV:
 
2455
                        logger.error("Interface %s does not exist,"
 
2456
                                     " cannot bind", self.interface)
 
2457
                    else:
 
2458
                        raise
2669
2459
        # Only bind(2) the socket if we really need to.
2670
2460
        if self.server_address[0] or self.server_address[1]:
2671
 
            if self.server_address[1]:
2672
 
                self.allow_reuse_address = True
2673
2461
            if not self.server_address[0]:
2674
2462
                if self.address_family == socket.AF_INET6:
2675
 
                    any_address = "::"  # in6addr_any
 
2463
                    any_address = "::" # in6addr_any
2676
2464
                else:
2677
 
                    any_address = "0.0.0.0"  # INADDR_ANY
 
2465
                    any_address = "0.0.0.0" # INADDR_ANY
2678
2466
                self.server_address = (any_address,
2679
2467
                                       self.server_address[1])
2680
2468
            elif not self.server_address[1]:
2690
2478
 
2691
2479
class MandosServer(IPv6_TCPServer):
2692
2480
    """Mandos server.
2693
 
 
 
2481
    
2694
2482
    Attributes:
2695
2483
        clients:        set of Client objects
2696
2484
        gnutls_priority GnuTLS priority string
2697
2485
        use_dbus:       Boolean; to emit D-Bus signals or not
2698
 
 
 
2486
    
2699
2487
    Assumes a GLib.MainLoop event loop.
2700
2488
    """
2701
 
 
 
2489
    
2702
2490
    def __init__(self, server_address, RequestHandlerClass,
2703
2491
                 interface=None,
2704
2492
                 use_ipv6=True,
2714
2502
        self.gnutls_priority = gnutls_priority
2715
2503
        IPv6_TCPServer.__init__(self, server_address,
2716
2504
                                RequestHandlerClass,
2717
 
                                interface=interface,
2718
 
                                use_ipv6=use_ipv6,
2719
 
                                socketfd=socketfd)
2720
 
 
 
2505
                                interface = interface,
 
2506
                                use_ipv6 = use_ipv6,
 
2507
                                socketfd = socketfd)
 
2508
    
2721
2509
    def server_activate(self):
2722
2510
        if self.enabled:
2723
2511
            return socketserver.TCPServer.server_activate(self)
2724
 
 
 
2512
    
2725
2513
    def enable(self):
2726
2514
        self.enabled = True
2727
 
 
 
2515
    
2728
2516
    def add_pipe(self, parent_pipe, proc):
2729
2517
        # Call "handle_ipc" for both data and EOF events
2730
2518
        GLib.io_add_watch(
2731
 
            GLib.IOChannel.unix_new(parent_pipe.fileno()),
2732
 
            GLib.PRIORITY_DEFAULT, GLib.IO_IN | GLib.IO_HUP,
 
2519
            parent_pipe.fileno(),
 
2520
            GLib.IO_IN | GLib.IO_HUP,
2733
2521
            functools.partial(self.handle_ipc,
2734
 
                              parent_pipe=parent_pipe,
2735
 
                              proc=proc))
2736
 
 
 
2522
                              parent_pipe = parent_pipe,
 
2523
                              proc = proc))
 
2524
    
2737
2525
    def handle_ipc(self, source, condition,
2738
2526
                   parent_pipe=None,
2739
 
                   proc=None,
 
2527
                   proc = None,
2740
2528
                   client_object=None):
2741
2529
        # error, or the other end of multiprocessing.Pipe has closed
2742
2530
        if condition & (GLib.IO_ERR | GLib.IO_HUP):
2743
2531
            # Wait for other process to exit
2744
2532
            proc.join()
2745
2533
            return False
2746
 
 
 
2534
        
2747
2535
        # Read a request from the child
2748
2536
        request = parent_pipe.recv()
2749
2537
        command = request[0]
2750
 
 
2751
 
        if command == "init":
2752
 
            key_id = request[1].decode("ascii")
2753
 
            fpr = request[2].decode("ascii")
2754
 
            address = request[3]
2755
 
 
 
2538
        
 
2539
        if command == 'init':
 
2540
            fpr = request[1]
 
2541
            address = request[2]
 
2542
            
2756
2543
            for c in self.clients.values():
2757
 
                if key_id == ("E3B0C44298FC1C149AFBF4C8996FB924"
2758
 
                              "27AE41E4649B934CA495991B7852B855"):
2759
 
                    continue
2760
 
                if key_id and c.key_id == key_id:
2761
 
                    client = c
2762
 
                    break
2763
 
                if fpr and c.fingerprint == fpr:
 
2544
                if c.fingerprint == fpr:
2764
2545
                    client = c
2765
2546
                    break
2766
2547
            else:
2767
 
                logger.info("Client not found for key ID: %s, address"
2768
 
                            ": %s", key_id or fpr, address)
 
2548
                logger.info("Client not found for fingerprint: %s, ad"
 
2549
                            "dress: %s", fpr, address)
2769
2550
                if self.use_dbus:
2770
2551
                    # Emit D-Bus signal
2771
 
                    mandos_dbus_service.ClientNotFound(key_id or fpr,
 
2552
                    mandos_dbus_service.ClientNotFound(fpr,
2772
2553
                                                       address[0])
2773
2554
                parent_pipe.send(False)
2774
2555
                return False
2775
 
 
 
2556
            
2776
2557
            GLib.io_add_watch(
2777
 
                GLib.IOChannel.unix_new(parent_pipe.fileno()),
2778
 
                GLib.PRIORITY_DEFAULT, GLib.IO_IN | GLib.IO_HUP,
 
2558
                parent_pipe.fileno(),
 
2559
                GLib.IO_IN | GLib.IO_HUP,
2779
2560
                functools.partial(self.handle_ipc,
2780
 
                                  parent_pipe=parent_pipe,
2781
 
                                  proc=proc,
2782
 
                                  client_object=client))
 
2561
                                  parent_pipe = parent_pipe,
 
2562
                                  proc = proc,
 
2563
                                  client_object = client))
2783
2564
            parent_pipe.send(True)
2784
2565
            # remove the old hook in favor of the new above hook on
2785
2566
            # same fileno
2786
2567
            return False
2787
 
        if command == "funcall":
 
2568
        if command == 'funcall':
2788
2569
            funcname = request[1]
2789
2570
            args = request[2]
2790
2571
            kwargs = request[3]
2791
 
 
2792
 
            parent_pipe.send(("data", getattr(client_object,
 
2572
            
 
2573
            parent_pipe.send(('data', getattr(client_object,
2793
2574
                                              funcname)(*args,
2794
2575
                                                        **kwargs)))
2795
 
 
2796
 
        if command == "getattr":
 
2576
        
 
2577
        if command == 'getattr':
2797
2578
            attrname = request[1]
2798
2579
            if isinstance(client_object.__getattribute__(attrname),
2799
 
                          collections.abc.Callable):
2800
 
                parent_pipe.send(("function", ))
 
2580
                          collections.Callable):
 
2581
                parent_pipe.send(('function', ))
2801
2582
            else:
2802
2583
                parent_pipe.send((
2803
 
                    "data", client_object.__getattribute__(attrname)))
2804
 
 
2805
 
        if command == "setattr":
 
2584
                    'data', client_object.__getattribute__(attrname)))
 
2585
        
 
2586
        if command == 'setattr':
2806
2587
            attrname = request[1]
2807
2588
            value = request[2]
2808
2589
            setattr(client_object, attrname, value)
2809
 
 
 
2590
        
2810
2591
        return True
2811
2592
 
2812
2593
 
2813
2594
def rfc3339_duration_to_delta(duration):
2814
2595
    """Parse an RFC 3339 "duration" and return a datetime.timedelta
2815
 
 
2816
 
    >>> timedelta = datetime.timedelta
2817
 
    >>> rfc3339_duration_to_delta("P7D") == timedelta(7)
2818
 
    True
2819
 
    >>> rfc3339_duration_to_delta("PT60S") == timedelta(0, 60)
2820
 
    True
2821
 
    >>> rfc3339_duration_to_delta("PT60M") == timedelta(0, 3600)
2822
 
    True
2823
 
    >>> rfc3339_duration_to_delta("PT24H") == timedelta(1)
2824
 
    True
2825
 
    >>> rfc3339_duration_to_delta("P1W") == timedelta(7)
2826
 
    True
2827
 
    >>> rfc3339_duration_to_delta("PT5M30S") == timedelta(0, 330)
2828
 
    True
2829
 
    >>> rfc3339_duration_to_delta("P1DT3M20S") == timedelta(1, 200)
2830
 
    True
2831
 
    >>> del timedelta
 
2596
    
 
2597
    >>> rfc3339_duration_to_delta("P7D")
 
2598
    datetime.timedelta(7)
 
2599
    >>> rfc3339_duration_to_delta("PT60S")
 
2600
    datetime.timedelta(0, 60)
 
2601
    >>> rfc3339_duration_to_delta("PT60M")
 
2602
    datetime.timedelta(0, 3600)
 
2603
    >>> rfc3339_duration_to_delta("PT24H")
 
2604
    datetime.timedelta(1)
 
2605
    >>> rfc3339_duration_to_delta("P1W")
 
2606
    datetime.timedelta(7)
 
2607
    >>> rfc3339_duration_to_delta("PT5M30S")
 
2608
    datetime.timedelta(0, 330)
 
2609
    >>> rfc3339_duration_to_delta("P1DT3M20S")
 
2610
    datetime.timedelta(1, 200)
2832
2611
    """
2833
 
 
 
2612
    
2834
2613
    # Parsing an RFC 3339 duration with regular expressions is not
2835
2614
    # possible - there would have to be multiple places for the same
2836
2615
    # values, like seconds.  The current code, while more esoteric, is
2837
2616
    # cleaner without depending on a parsing library.  If Python had a
2838
2617
    # built-in library for parsing we would use it, but we'd like to
2839
2618
    # avoid excessive use of external libraries.
2840
 
 
 
2619
    
2841
2620
    # New type for defining tokens, syntax, and semantics all-in-one
2842
2621
    Token = collections.namedtuple("Token", (
2843
2622
        "regexp",  # To match token; if "value" is not None, must have
2876
2655
                           frozenset((token_year, token_month,
2877
2656
                                      token_day, token_time,
2878
2657
                                      token_week)))
2879
 
    # Define starting values:
2880
 
    # Value so far
2881
 
    value = datetime.timedelta()
 
2658
    # Define starting values
 
2659
    value = datetime.timedelta() # Value so far
2882
2660
    found_token = None
2883
 
    # Following valid tokens
2884
 
    followers = frozenset((token_duration, ))
2885
 
    # String left to parse
2886
 
    s = duration
 
2661
    followers = frozenset((token_duration, )) # Following valid tokens
 
2662
    s = duration                # String left to parse
2887
2663
    # Loop until end token is found
2888
2664
    while found_token is not token_end:
2889
2665
        # Search for any currently valid tokens
2913
2689
 
2914
2690
def string_to_delta(interval):
2915
2691
    """Parse a string and return a datetime.timedelta
2916
 
 
2917
 
    >>> string_to_delta("7d") == datetime.timedelta(7)
2918
 
    True
2919
 
    >>> string_to_delta("60s") == datetime.timedelta(0, 60)
2920
 
    True
2921
 
    >>> string_to_delta("60m") == datetime.timedelta(0, 3600)
2922
 
    True
2923
 
    >>> string_to_delta("24h") == datetime.timedelta(1)
2924
 
    True
2925
 
    >>> string_to_delta("1w") == datetime.timedelta(7)
2926
 
    True
2927
 
    >>> string_to_delta("5m 30s") == datetime.timedelta(0, 330)
2928
 
    True
 
2692
    
 
2693
    >>> string_to_delta('7d')
 
2694
    datetime.timedelta(7)
 
2695
    >>> string_to_delta('60s')
 
2696
    datetime.timedelta(0, 60)
 
2697
    >>> string_to_delta('60m')
 
2698
    datetime.timedelta(0, 3600)
 
2699
    >>> string_to_delta('24h')
 
2700
    datetime.timedelta(1)
 
2701
    >>> string_to_delta('1w')
 
2702
    datetime.timedelta(7)
 
2703
    >>> string_to_delta('5m 30s')
 
2704
    datetime.timedelta(0, 330)
2929
2705
    """
2930
 
 
 
2706
    
2931
2707
    try:
2932
2708
        return rfc3339_duration_to_delta(interval)
2933
2709
    except ValueError:
2934
2710
        pass
2935
 
 
 
2711
    
2936
2712
    timevalue = datetime.timedelta(0)
2937
2713
    for s in interval.split():
2938
2714
        try:
2956
2732
    return timevalue
2957
2733
 
2958
2734
 
2959
 
def daemon(nochdir=False, noclose=False):
 
2735
def daemon(nochdir = False, noclose = False):
2960
2736
    """See daemon(3).  Standard BSD Unix function.
2961
 
 
 
2737
    
2962
2738
    This should really exist as os.daemon, but it doesn't (yet)."""
2963
2739
    if os.fork():
2964
2740
        sys.exit()
2982
2758
 
2983
2759
 
2984
2760
def main():
2985
 
 
 
2761
    
2986
2762
    ##################################################################
2987
2763
    # Parsing of options, both command line and config file
2988
 
 
 
2764
    
2989
2765
    parser = argparse.ArgumentParser()
2990
2766
    parser.add_argument("-v", "--version", action="version",
2991
 
                        version="%(prog)s {}".format(version),
 
2767
                        version = "%(prog)s {}".format(version),
2992
2768
                        help="show version number and exit")
2993
2769
    parser.add_argument("-i", "--interface", metavar="IF",
2994
2770
                        help="Bind to interface IF")
3030
2806
    parser.add_argument("--no-zeroconf", action="store_false",
3031
2807
                        dest="zeroconf", help="Do not use Zeroconf",
3032
2808
                        default=None)
3033
 
 
 
2809
    
3034
2810
    options = parser.parse_args()
3035
 
 
 
2811
    
 
2812
    if options.check:
 
2813
        import doctest
 
2814
        fail_count, test_count = doctest.testmod()
 
2815
        sys.exit(os.EX_OK if fail_count == 0 else 1)
 
2816
    
3036
2817
    # Default values for config file for server-global settings
3037
 
    if gnutls.has_rawpk:
3038
 
        priority = ("SECURE128:!CTYPE-X.509:+CTYPE-RAWPK:!RSA"
3039
 
                    ":!VERS-ALL:+VERS-TLS1.3:%PROFILE_ULTRA")
3040
 
    else:
3041
 
        priority = ("SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:!RSA"
3042
 
                    ":+SIGN-DSA-SHA256")
3043
 
    server_defaults = {"interface": "",
3044
 
                       "address": "",
3045
 
                       "port": "",
3046
 
                       "debug": "False",
3047
 
                       "priority": priority,
3048
 
                       "servicename": "Mandos",
3049
 
                       "use_dbus": "True",
3050
 
                       "use_ipv6": "True",
3051
 
                       "debuglevel": "",
3052
 
                       "restore": "True",
3053
 
                       "socket": "",
3054
 
                       "statedir": "/var/lib/mandos",
3055
 
                       "foreground": "False",
3056
 
                       "zeroconf": "True",
3057
 
                       }
3058
 
    del priority
3059
 
 
 
2818
    server_defaults = { "interface": "",
 
2819
                        "address": "",
 
2820
                        "port": "",
 
2821
                        "debug": "False",
 
2822
                        "priority":
 
2823
                        "SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:!RSA"
 
2824
                        ":+SIGN-DSA-SHA256",
 
2825
                        "servicename": "Mandos",
 
2826
                        "use_dbus": "True",
 
2827
                        "use_ipv6": "True",
 
2828
                        "debuglevel": "",
 
2829
                        "restore": "True",
 
2830
                        "socket": "",
 
2831
                        "statedir": "/var/lib/mandos",
 
2832
                        "foreground": "False",
 
2833
                        "zeroconf": "True",
 
2834
                    }
 
2835
    
3060
2836
    # Parse config file for server-global settings
3061
 
    server_config = configparser.ConfigParser(server_defaults)
 
2837
    server_config = configparser.SafeConfigParser(server_defaults)
3062
2838
    del server_defaults
3063
2839
    server_config.read(os.path.join(options.configdir, "mandos.conf"))
3064
 
    # Convert the ConfigParser object to a dict
 
2840
    # Convert the SafeConfigParser object to a dict
3065
2841
    server_settings = server_config.defaults()
3066
2842
    # Use the appropriate methods on the non-string config options
3067
 
    for option in ("debug", "use_dbus", "use_ipv6", "restore",
3068
 
                   "foreground", "zeroconf"):
 
2843
    for option in ("debug", "use_dbus", "use_ipv6", "foreground"):
3069
2844
        server_settings[option] = server_config.getboolean("DEFAULT",
3070
2845
                                                           option)
3071
2846
    if server_settings["port"]:
3081
2856
            server_settings["socket"] = os.dup(server_settings
3082
2857
                                               ["socket"])
3083
2858
    del server_config
3084
 
 
 
2859
    
3085
2860
    # Override the settings from the config file with command line
3086
2861
    # options, if set.
3087
2862
    for option in ("interface", "address", "port", "debug",
3105
2880
    if server_settings["debug"]:
3106
2881
        server_settings["foreground"] = True
3107
2882
    # Now we have our good server settings in "server_settings"
3108
 
 
 
2883
    
3109
2884
    ##################################################################
3110
 
 
 
2885
    
3111
2886
    if (not server_settings["zeroconf"]
3112
2887
        and not (server_settings["port"]
3113
2888
                 or server_settings["socket"] != "")):
3114
2889
        parser.error("Needs port or socket to work without Zeroconf")
3115
 
 
 
2890
    
3116
2891
    # For convenience
3117
2892
    debug = server_settings["debug"]
3118
2893
    debuglevel = server_settings["debuglevel"]
3122
2897
                                     stored_state_file)
3123
2898
    foreground = server_settings["foreground"]
3124
2899
    zeroconf = server_settings["zeroconf"]
3125
 
 
 
2900
    
3126
2901
    if debug:
3127
2902
        initlogger(debug, logging.DEBUG)
3128
2903
    else:
3131
2906
        else:
3132
2907
            level = getattr(logging, debuglevel.upper())
3133
2908
            initlogger(debug, level)
3134
 
 
 
2909
    
3135
2910
    if server_settings["servicename"] != "Mandos":
3136
2911
        syslogger.setFormatter(
3137
 
            logging.Formatter("Mandos ({}) [%(process)d]:"
3138
 
                              " %(levelname)s: %(message)s".format(
 
2912
            logging.Formatter('Mandos ({}) [%(process)d]:'
 
2913
                              ' %(levelname)s: %(message)s'.format(
3139
2914
                                  server_settings["servicename"])))
3140
 
 
 
2915
    
3141
2916
    # Parse config file with clients
3142
 
    client_config = configparser.ConfigParser(Client.client_defaults)
 
2917
    client_config = configparser.SafeConfigParser(Client
 
2918
                                                  .client_defaults)
3143
2919
    client_config.read(os.path.join(server_settings["configdir"],
3144
2920
                                    "clients.conf"))
3145
 
 
 
2921
    
3146
2922
    global mandos_dbus_service
3147
2923
    mandos_dbus_service = None
3148
 
 
 
2924
    
3149
2925
    socketfd = None
3150
2926
    if server_settings["socket"] != "":
3151
2927
        socketfd = server_settings["socket"]
3167
2943
        except IOError as e:
3168
2944
            logger.error("Could not open file %r", pidfilename,
3169
2945
                         exc_info=e)
3170
 
 
 
2946
    
3171
2947
    for name, group in (("_mandos", "_mandos"),
3172
2948
                        ("mandos", "mandos"),
3173
2949
                        ("nobody", "nogroup")):
3191
2967
                       .format(uid, gid, os.strerror(error.errno)))
3192
2968
        if error.errno != errno.EPERM:
3193
2969
            raise
3194
 
 
 
2970
    
3195
2971
    if debug:
3196
2972
        # Enable all possible GnuTLS debugging
3197
 
 
 
2973
        
3198
2974
        # "Use a log level over 10 to enable all debugging options."
3199
2975
        # - GnuTLS manual
3200
2976
        gnutls.global_set_log_level(11)
3201
 
 
 
2977
        
3202
2978
        @gnutls.log_func
3203
2979
        def debug_gnutls(level, string):
3204
 
            logger.debug("GnuTLS: %s",
3205
 
                         string[:-1].decode("utf-8",
3206
 
                                            errors="replace"))
3207
 
 
 
2980
            logger.debug("GnuTLS: %s", string[:-1])
 
2981
        
3208
2982
        gnutls.global_set_log_function(debug_gnutls)
3209
 
 
 
2983
        
3210
2984
        # Redirect stdin so all checkers get /dev/null
3211
2985
        null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)
3212
2986
        os.dup2(null, sys.stdin.fileno())
3213
2987
        if null > 2:
3214
2988
            os.close(null)
3215
 
 
 
2989
    
3216
2990
    # Need to fork before connecting to D-Bus
3217
2991
    if not foreground:
3218
2992
        # Close all input and output, do double fork, etc.
3219
2993
        daemon()
3220
 
 
3221
 
    if gi.version_info < (3, 10, 2):
3222
 
        # multiprocessing will use threads, so before we use GLib we
3223
 
        # need to inform GLib that threads will be used.
3224
 
        GLib.threads_init()
3225
 
 
 
2994
    
 
2995
    # multiprocessing will use threads, so before we use GLib we need
 
2996
    # to inform GLib that threads will be used.
 
2997
    GLib.threads_init()
 
2998
    
3226
2999
    global main_loop
3227
3000
    # From the Avahi example code
3228
3001
    DBusGMainLoop(set_as_default=True)
3245
3018
    if zeroconf:
3246
3019
        protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
3247
3020
        service = AvahiServiceToSyslog(
3248
 
            name=server_settings["servicename"],
3249
 
            servicetype="_mandos._tcp",
3250
 
            protocol=protocol,
3251
 
            bus=bus)
 
3021
            name = server_settings["servicename"],
 
3022
            servicetype = "_mandos._tcp",
 
3023
            protocol = protocol,
 
3024
            bus = bus)
3252
3025
        if server_settings["interface"]:
3253
3026
            service.interface = if_nametoindex(
3254
3027
                server_settings["interface"].encode("utf-8"))
3255
 
 
 
3028
    
3256
3029
    global multiprocessing_manager
3257
3030
    multiprocessing_manager = multiprocessing.Manager()
3258
 
 
 
3031
    
3259
3032
    client_class = Client
3260
3033
    if use_dbus:
3261
 
        client_class = functools.partial(ClientDBus, bus=bus)
3262
 
 
 
3034
        client_class = functools.partial(ClientDBus, bus = bus)
 
3035
    
3263
3036
    client_settings = Client.config_parser(client_config)
3264
3037
    old_client_settings = {}
3265
3038
    clients_data = {}
3266
 
 
 
3039
    
3267
3040
    # This is used to redirect stdout and stderr for checker processes
3268
3041
    global wnull
3269
 
    wnull = open(os.devnull, "w")  # A writable /dev/null
 
3042
    wnull = open(os.devnull, "w") # A writable /dev/null
3270
3043
    # Only used if server is running in foreground but not in debug
3271
3044
    # mode
3272
3045
    if debug or not foreground:
3273
3046
        wnull.close()
3274
 
 
 
3047
    
3275
3048
    # Get client data and settings from last running state.
3276
3049
    if server_settings["restore"]:
3277
3050
        try:
3278
3051
            with open(stored_state_path, "rb") as stored_state:
3279
 
                if sys.version_info.major == 2:
 
3052
                if sys.version_info.major == 2:                
3280
3053
                    clients_data, old_client_settings = pickle.load(
3281
3054
                        stored_state)
3282
3055
                else:
3283
3056
                    bytes_clients_data, bytes_old_client_settings = (
3284
 
                        pickle.load(stored_state, encoding="bytes"))
3285
 
                    #   Fix bytes to strings
3286
 
                    #  clients_data
 
3057
                        pickle.load(stored_state, encoding = "bytes"))
 
3058
                    ### Fix bytes to strings
 
3059
                    ## clients_data
3287
3060
                    # .keys()
3288
 
                    clients_data = {(key.decode("utf-8")
3289
 
                                     if isinstance(key, bytes)
3290
 
                                     else key): value
3291
 
                                    for key, value in
3292
 
                                    bytes_clients_data.items()}
 
3061
                    clients_data = { (key.decode("utf-8")
 
3062
                                      if isinstance(key, bytes)
 
3063
                                      else key): value
 
3064
                                     for key, value in
 
3065
                                     bytes_clients_data.items() }
3293
3066
                    del bytes_clients_data
3294
3067
                    for key in clients_data:
3295
 
                        value = {(k.decode("utf-8")
3296
 
                                  if isinstance(k, bytes) else k): v
3297
 
                                 for k, v in
3298
 
                                 clients_data[key].items()}
 
3068
                        value = { (k.decode("utf-8")
 
3069
                                   if isinstance(k, bytes) else k): v
 
3070
                                  for k, v in
 
3071
                                  clients_data[key].items() }
3299
3072
                        clients_data[key] = value
3300
3073
                        # .client_structure
3301
3074
                        value["client_structure"] = [
3302
3075
                            (s.decode("utf-8")
3303
3076
                             if isinstance(s, bytes)
3304
3077
                             else s) for s in
3305
 
                            value["client_structure"]]
3306
 
                        # .name, .host, and .checker_command
3307
 
                        for k in ("name", "host", "checker_command"):
 
3078
                            value["client_structure"] ]
 
3079
                        # .name & .host
 
3080
                        for k in ("name", "host"):
3308
3081
                            if isinstance(value[k], bytes):
3309
3082
                                value[k] = value[k].decode("utf-8")
3310
 
                        if "key_id" not in value:
3311
 
                            value["key_id"] = ""
3312
 
                        elif "fingerprint" not in value:
3313
 
                            value["fingerprint"] = ""
3314
 
                    #  old_client_settings
 
3083
                    ## old_client_settings
3315
3084
                    # .keys()
3316
3085
                    old_client_settings = {
3317
3086
                        (key.decode("utf-8")
3318
3087
                         if isinstance(key, bytes)
3319
3088
                         else key): value
3320
3089
                        for key, value in
3321
 
                        bytes_old_client_settings.items()}
 
3090
                        bytes_old_client_settings.items() }
3322
3091
                    del bytes_old_client_settings
3323
 
                    # .host and .checker_command
 
3092
                    # .host
3324
3093
                    for value in old_client_settings.values():
3325
 
                        for attribute in ("host", "checker_command"):
3326
 
                            if isinstance(value[attribute], bytes):
3327
 
                                value[attribute] = (value[attribute]
3328
 
                                                    .decode("utf-8"))
 
3094
                        if isinstance(value["host"], bytes):
 
3095
                            value["host"] = (value["host"]
 
3096
                                             .decode("utf-8"))
3329
3097
            os.remove(stored_state_path)
3330
3098
        except IOError as e:
3331
3099
            if e.errno == errno.ENOENT:
3339
3107
            logger.warning("Could not load persistent state: "
3340
3108
                           "EOFError:",
3341
3109
                           exc_info=e)
3342
 
 
 
3110
    
3343
3111
    with PGPEngine() as pgp:
3344
3112
        for client_name, client in clients_data.items():
3345
3113
            # Skip removed clients
3346
3114
            if client_name not in client_settings:
3347
3115
                continue
3348
 
 
 
3116
            
3349
3117
            # Decide which value to use after restoring saved state.
3350
3118
            # We have three different values: Old config file,
3351
3119
            # new config file, and saved state.
3362
3130
                        client[name] = value
3363
3131
                except KeyError:
3364
3132
                    pass
3365
 
 
 
3133
            
3366
3134
            # Clients who has passed its expire date can still be
3367
3135
            # enabled if its last checker was successful.  A Client
3368
3136
            # whose checker succeeded before we stored its state is
3401
3169
                    client_name))
3402
3170
                client["secret"] = (client_settings[client_name]
3403
3171
                                    ["secret"])
3404
 
 
 
3172
    
3405
3173
    # Add/remove clients based on new changes made to config
3406
3174
    for client_name in (set(old_client_settings)
3407
3175
                        - set(client_settings)):
3409
3177
    for client_name in (set(client_settings)
3410
3178
                        - set(old_client_settings)):
3411
3179
        clients_data[client_name] = client_settings[client_name]
3412
 
 
 
3180
    
3413
3181
    # Create all client objects
3414
3182
    for client_name, client in clients_data.items():
3415
3183
        tcp_server.clients[client_name] = client_class(
3416
 
            name=client_name,
3417
 
            settings=client,
3418
 
            server_settings=server_settings)
3419
 
 
 
3184
            name = client_name,
 
3185
            settings = client,
 
3186
            server_settings = server_settings)
 
3187
    
3420
3188
    if not tcp_server.clients:
3421
3189
        logger.warning("No clients defined")
3422
 
 
 
3190
    
3423
3191
    if not foreground:
3424
3192
        if pidfile is not None:
3425
3193
            pid = os.getpid()
3431
3199
                             pidfilename, pid)
3432
3200
        del pidfile
3433
3201
        del pidfilename
3434
 
 
 
3202
    
3435
3203
    for termsig in (signal.SIGHUP, signal.SIGTERM):
3436
3204
        GLib.unix_signal_add(GLib.PRIORITY_HIGH, termsig,
3437
3205
                             lambda: main_loop.quit() and False)
3438
 
 
 
3206
    
3439
3207
    if use_dbus:
3440
 
 
 
3208
        
3441
3209
        @alternate_dbus_interfaces(
3442
 
            {"se.recompile.Mandos": "se.bsnet.fukt.Mandos"})
 
3210
            { "se.recompile.Mandos": "se.bsnet.fukt.Mandos" })
3443
3211
        class MandosDBusService(DBusObjectWithObjectManager):
3444
3212
            """A D-Bus proxy object"""
3445
 
 
 
3213
            
3446
3214
            def __init__(self):
3447
3215
                dbus.service.Object.__init__(self, bus, "/")
3448
 
 
 
3216
            
3449
3217
            _interface = "se.recompile.Mandos"
3450
 
 
 
3218
            
3451
3219
            @dbus.service.signal(_interface, signature="o")
3452
3220
            def ClientAdded(self, objpath):
3453
3221
                "D-Bus signal"
3454
3222
                pass
3455
 
 
 
3223
            
3456
3224
            @dbus.service.signal(_interface, signature="ss")
3457
 
            def ClientNotFound(self, key_id, address):
 
3225
            def ClientNotFound(self, fingerprint, address):
3458
3226
                "D-Bus signal"
3459
3227
                pass
3460
 
 
 
3228
            
3461
3229
            @dbus_annotations({"org.freedesktop.DBus.Deprecated":
3462
3230
                               "true"})
3463
3231
            @dbus.service.signal(_interface, signature="os")
3464
3232
            def ClientRemoved(self, objpath, name):
3465
3233
                "D-Bus signal"
3466
3234
                pass
3467
 
 
 
3235
            
3468
3236
            @dbus_annotations({"org.freedesktop.DBus.Deprecated":
3469
3237
                               "true"})
3470
3238
            @dbus.service.method(_interface, out_signature="ao")
3472
3240
                "D-Bus method"
3473
3241
                return dbus.Array(c.dbus_object_path for c in
3474
3242
                                  tcp_server.clients.values())
3475
 
 
 
3243
            
3476
3244
            @dbus_annotations({"org.freedesktop.DBus.Deprecated":
3477
3245
                               "true"})
3478
3246
            @dbus.service.method(_interface,
3480
3248
            def GetAllClientsWithProperties(self):
3481
3249
                "D-Bus method"
3482
3250
                return dbus.Dictionary(
3483
 
                    {c.dbus_object_path: c.GetAll(
 
3251
                    { c.dbus_object_path: c.GetAll(
3484
3252
                        "se.recompile.Mandos.Client")
3485
 
                     for c in tcp_server.clients.values()},
 
3253
                      for c in tcp_server.clients.values() },
3486
3254
                    signature="oa{sv}")
3487
 
 
 
3255
            
3488
3256
            @dbus.service.method(_interface, in_signature="o")
3489
3257
            def RemoveClient(self, object_path):
3490
3258
                "D-Bus method"
3498
3266
                        self.client_removed_signal(c)
3499
3267
                        return
3500
3268
                raise KeyError(object_path)
3501
 
 
 
3269
            
3502
3270
            del _interface
3503
 
 
 
3271
            
3504
3272
            @dbus.service.method(dbus.OBJECT_MANAGER_IFACE,
3505
 
                                 out_signature="a{oa{sa{sv}}}")
 
3273
                                 out_signature = "a{oa{sa{sv}}}")
3506
3274
            def GetManagedObjects(self):
3507
3275
                """D-Bus method"""
3508
3276
                return dbus.Dictionary(
3509
 
                    {client.dbus_object_path:
3510
 
                     dbus.Dictionary(
3511
 
                         {interface: client.GetAll(interface)
3512
 
                          for interface in
3513
 
                          client._get_all_interface_names()})
3514
 
                     for client in tcp_server.clients.values()})
3515
 
 
 
3277
                    { client.dbus_object_path:
 
3278
                      dbus.Dictionary(
 
3279
                          { interface: client.GetAll(interface)
 
3280
                            for interface in
 
3281
                                 client._get_all_interface_names()})
 
3282
                      for client in tcp_server.clients.values()})
 
3283
            
3516
3284
            def client_added_signal(self, client):
3517
3285
                """Send the new standard signal and the old signal"""
3518
3286
                if use_dbus:
3520
3288
                    self.InterfacesAdded(
3521
3289
                        client.dbus_object_path,
3522
3290
                        dbus.Dictionary(
3523
 
                            {interface: client.GetAll(interface)
3524
 
                             for interface in
3525
 
                             client._get_all_interface_names()}))
 
3291
                            { interface: client.GetAll(interface)
 
3292
                              for interface in
 
3293
                              client._get_all_interface_names()}))
3526
3294
                    # Old signal
3527
3295
                    self.ClientAdded(client.dbus_object_path)
3528
 
 
 
3296
            
3529
3297
            def client_removed_signal(self, client):
3530
3298
                """Send the new standard signal and the old signal"""
3531
3299
                if use_dbus:
3536
3304
                    # Old signal
3537
3305
                    self.ClientRemoved(client.dbus_object_path,
3538
3306
                                       client.name)
3539
 
 
 
3307
        
3540
3308
        mandos_dbus_service = MandosDBusService()
3541
 
 
3542
 
    # Save modules to variables to exempt the modules from being
3543
 
    # unloaded before the function registered with atexit() is run.
3544
 
    mp = multiprocessing
3545
 
    wn = wnull
3546
 
 
 
3309
    
3547
3310
    def cleanup():
3548
3311
        "Cleanup function; run on exit"
3549
3312
        if zeroconf:
3550
3313
            service.cleanup()
3551
 
 
3552
 
        mp.active_children()
3553
 
        wn.close()
 
3314
        
 
3315
        multiprocessing.active_children()
 
3316
        wnull.close()
3554
3317
        if not (tcp_server.clients or client_settings):
3555
3318
            return
3556
 
 
 
3319
        
3557
3320
        # Store client before exiting. Secrets are encrypted with key
3558
3321
        # based on what config file has. If config file is
3559
3322
        # removed/edited, old secret will thus be unrecovable.
3564
3327
                client.encrypted_secret = pgp.encrypt(client.secret,
3565
3328
                                                      key)
3566
3329
                client_dict = {}
3567
 
 
 
3330
                
3568
3331
                # A list of attributes that can not be pickled
3569
3332
                # + secret.
3570
 
                exclude = {"bus", "changedstate", "secret",
3571
 
                           "checker", "server_settings"}
 
3333
                exclude = { "bus", "changedstate", "secret",
 
3334
                            "checker", "server_settings" }
3572
3335
                for name, typ in inspect.getmembers(dbus.service
3573
3336
                                                    .Object):
3574
3337
                    exclude.add(name)
3575
 
 
 
3338
                
3576
3339
                client_dict["encrypted_secret"] = (client
3577
3340
                                                   .encrypted_secret)
3578
3341
                for attr in client.client_structure:
3579
3342
                    if attr not in exclude:
3580
3343
                        client_dict[attr] = getattr(client, attr)
3581
 
 
 
3344
                
3582
3345
                clients[client.name] = client_dict
3583
3346
                del client_settings[client.name]["secret"]
3584
 
 
 
3347
        
3585
3348
        try:
3586
3349
            with tempfile.NamedTemporaryFile(
3587
 
                    mode="wb",
 
3350
                    mode='wb',
3588
3351
                    suffix=".pickle",
3589
 
                    prefix="clients-",
 
3352
                    prefix='clients-',
3590
3353
                    dir=os.path.dirname(stored_state_path),
3591
3354
                    delete=False) as stored_state:
3592
3355
                pickle.dump((clients, client_settings), stored_state,
3593
 
                            protocol=2)
 
3356
                            protocol = 2)
3594
3357
                tempname = stored_state.name
3595
3358
            os.rename(tempname, stored_state_path)
3596
3359
        except (IOError, OSError) as e:
3606
3369
                logger.warning("Could not save persistent state:",
3607
3370
                               exc_info=e)
3608
3371
                raise
3609
 
 
 
3372
        
3610
3373
        # Delete all clients, and settings from config
3611
3374
        while tcp_server.clients:
3612
3375
            name, client = tcp_server.clients.popitem()
3618
3381
            if use_dbus:
3619
3382
                mandos_dbus_service.client_removed_signal(client)
3620
3383
        client_settings.clear()
3621
 
 
 
3384
    
3622
3385
    atexit.register(cleanup)
3623
 
 
 
3386
    
3624
3387
    for client in tcp_server.clients.values():
3625
3388
        if use_dbus:
3626
3389
            # Emit D-Bus signal for adding
3628
3391
        # Need to initiate checking of clients
3629
3392
        if client.enabled:
3630
3393
            client.init_checker()
3631
 
 
 
3394
    
3632
3395
    tcp_server.enable()
3633
3396
    tcp_server.server_activate()
3634
 
 
 
3397
    
3635
3398
    # Find out what port we got
3636
3399
    if zeroconf:
3637
3400
        service.port = tcp_server.socket.getsockname()[1]
3642
3405
    else:                       # IPv4
3643
3406
        logger.info("Now listening on address %r, port %d",
3644
3407
                    *tcp_server.socket.getsockname())
3645
 
 
3646
 
    # service.interface = tcp_server.socket.getsockname()[3]
3647
 
 
 
3408
    
 
3409
    #service.interface = tcp_server.socket.getsockname()[3]
 
3410
    
3648
3411
    try:
3649
3412
        if zeroconf:
3650
3413
            # From the Avahi example code
3655
3418
                cleanup()
3656
3419
                sys.exit(1)
3657
3420
            # End of Avahi example code
3658
 
 
3659
 
        GLib.io_add_watch(
3660
 
            GLib.IOChannel.unix_new(tcp_server.fileno()),
3661
 
            GLib.PRIORITY_DEFAULT, GLib.IO_IN,
3662
 
            lambda *args, **kwargs: (tcp_server.handle_request
3663
 
                                     (*args[2:], **kwargs) or True))
3664
 
 
 
3421
        
 
3422
        GLib.io_add_watch(tcp_server.fileno(), GLib.IO_IN,
 
3423
                          lambda *args, **kwargs:
 
3424
                          (tcp_server.handle_request
 
3425
                           (*args[2:], **kwargs) or True))
 
3426
        
3665
3427
        logger.debug("Starting main loop")
3666
3428
        main_loop.run()
3667
3429
    except AvahiError as error:
3676
3438
    # Must run before the D-Bus bus name gets deregistered
3677
3439
    cleanup()
3678
3440
 
3679
 
 
3680
 
def should_only_run_tests():
3681
 
    parser = argparse.ArgumentParser(add_help=False)
3682
 
    parser.add_argument("--check", action="store_true")
3683
 
    args, unknown_args = parser.parse_known_args()
3684
 
    run_tests = args.check
3685
 
    if run_tests:
3686
 
        # Remove --check argument from sys.argv
3687
 
        sys.argv[1:] = unknown_args
3688
 
    return run_tests
3689
 
 
3690
 
# Add all tests from doctest strings
3691
 
def load_tests(loader, tests, none):
3692
 
    import doctest
3693
 
    tests.addTests(doctest.DocTestSuite())
3694
 
    return tests
3695
 
 
3696
 
if __name__ == "__main__":
3697
 
    try:
3698
 
        if should_only_run_tests():
3699
 
            # Call using ./mandos --check [--verbose]
3700
 
            unittest.main()
3701
 
        else:
3702
 
            main()
3703
 
    finally:
3704
 
        logging.shutdown()
 
3441
 
 
3442
if __name__ == '__main__':
 
3443
    main()