/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: 2024-09-08 05:08:20 UTC
  • Revision ID: teddy@recompile.se-20240908050820-jpkid6ufjb9n107o
Fix #1079588 by not outputting to stdout in maintainer scripts

From The Debconf Programmer's Tutorial: "Anything your maintainer
scripts output to standard output is passed into the frontend as a
command".  We must make sure to redirect stdout to stderr for every
command in the postinst and postrm scripts which might output to
stdout.

* debian/mandos-client.postinst (update_initramfs): Add "1>&2" to
  invocations of update-initramfs and /etc/kernel/postinst.d/dracut.
  (add_mandos_user): Add "1>&2" to invocations of usermod, groupmod,
  and adduser.
  (create_keys): Add "1>&2" to invocations of mandos-keygen,
  gpg-connect-agent, certtool, and openssl.
  (create_dh_params): Add "1>&2" to invocations of certtool and
  openssl.  Add "--force" option to "rm".
* debian/mandos-client.postrm (update_initramfs): Add "1>&2" to
  invocations of update-initramfs and /etc/kernel/postinst.d/dracut.

Closes: #1079588
Reported-By: Ben Hutchings <ben@decadent.org.uk>

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
#!/usr/bin/python
2
 
# -*- mode: python; coding: utf-8 -*-
 
1
#!/usr/bin/python3 -bI
 
2
# -*- coding: utf-8; lexical-binding: t -*-
3
3
#
4
4
# Mandos server - give out binary blobs to connecting clients.
5
5
#
11
11
# "AvahiService" class, and some lines in "main".
12
12
#
13
13
# Everything else is
14
 
# Copyright © 2008-2018 Teddy Hogeborn
15
 
# Copyright © 2008-2018 Björn Påhlsson
 
14
# Copyright © 2008-2022 Teddy Hogeborn
 
15
# Copyright © 2008-2022 Björn Påhlsson
16
16
#
17
17
# This file is part of Mandos.
18
18
#
31
31
#
32
32
# Contact the authors at <mandos@recompile.se>.
33
33
#
34
 
 
35
34
from __future__ import (division, absolute_import, print_function,
36
35
                        unicode_literals)
37
36
 
40
39
except ImportError:
41
40
    pass
42
41
 
 
42
import sys
 
43
import unittest
 
44
import argparse
 
45
import logging
 
46
import os
43
47
try:
44
48
    import SocketServer as socketserver
45
49
except ImportError:
46
50
    import socketserver
47
51
import socket
48
 
import argparse
49
52
import datetime
50
53
import errno
51
54
try:
52
55
    import ConfigParser as configparser
53
56
except ImportError:
54
57
    import configparser
55
 
import sys
56
58
import re
57
 
import os
58
59
import signal
59
60
import subprocess
60
61
import atexit
61
62
import stat
62
 
import logging
63
63
import logging.handlers
64
64
import pwd
65
65
import contextlib
77
77
import itertools
78
78
import collections
79
79
import codecs
 
80
import random
 
81
import shlex
80
82
 
81
83
import dbus
82
84
import dbus.service
 
85
import gi
83
86
from gi.repository import GLib
84
87
from dbus.mainloop.glib import DBusGMainLoop
85
88
import ctypes
87
90
import xml.dom.minidom
88
91
import inspect
89
92
 
 
93
if sys.version_info.major == 2:
 
94
    __metaclass__ = type
 
95
    str = unicode
 
96
    input = raw_input
 
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
 
90
118
# Try to find the value of SO_BINDTODEVICE:
91
119
try:
92
120
    # This is where SO_BINDTODEVICE is in Python 3.3 (or 3.4?) and
112
140
            # No value found
113
141
            SO_BINDTODEVICE = None
114
142
 
115
 
if sys.version_info.major == 2:
116
 
    str = unicode
 
143
if sys.version_info < (3, 2):
 
144
    configparser.Configparser = configparser.SafeConfigParser
117
145
 
118
 
version = "1.7.16"
 
146
version = "1.8.16"
119
147
stored_state_file = "clients.pickle"
120
148
 
121
 
logger = logging.getLogger()
 
149
log = logging.getLogger(os.path.basename(sys.argv[0]))
 
150
logging.captureWarnings(True)   # Show warnings via the logging system
122
151
syslogger = None
123
152
 
124
153
try:
160
189
        facility=logging.handlers.SysLogHandler.LOG_DAEMON,
161
190
        address="/dev/log"))
162
191
    syslogger.setFormatter(logging.Formatter
163
 
                           ('Mandos [%(process)d]: %(levelname)s:'
164
 
                            ' %(message)s'))
165
 
    logger.addHandler(syslogger)
 
192
                           ("Mandos [%(process)d]: %(levelname)s:"
 
193
                            " %(message)s"))
 
194
    log.addHandler(syslogger)
166
195
 
167
196
    if debug:
168
197
        console = logging.StreamHandler()
169
 
        console.setFormatter(logging.Formatter('%(asctime)s %(name)s'
170
 
                                               ' [%(process)d]:'
171
 
                                               ' %(levelname)s:'
172
 
                                               ' %(message)s'))
173
 
        logger.addHandler(console)
174
 
    logger.setLevel(level)
 
198
        console.setFormatter(logging.Formatter("%(asctime)s %(name)s"
 
199
                                               " [%(process)d]:"
 
200
                                               " %(levelname)s:"
 
201
                                               " %(message)s"))
 
202
        log.addHandler(console)
 
203
    log.setLevel(level)
175
204
 
176
205
 
177
206
class PGPError(Exception):
179
208
    pass
180
209
 
181
210
 
182
 
class PGPEngine(object):
 
211
class PGPEngine:
183
212
    """A simple class for OpenPGP symmetric encryption & decryption"""
184
213
 
185
214
    def __init__(self):
189
218
            output = subprocess.check_output(["gpgconf"])
190
219
            for line in output.splitlines():
191
220
                name, text, path = line.split(b":")
192
 
                if name == "gpg":
 
221
                if name == b"gpg":
193
222
                    self.gpg = path
194
223
                    break
195
224
        except OSError as e:
196
225
            if e.errno != errno.ENOENT:
197
226
                raise
198
 
        self.gnupgargs = ['--batch',
199
 
                          '--homedir', self.tempdir,
200
 
                          '--force-mdc',
201
 
                          '--quiet']
 
227
        self.gnupgargs = ["--batch",
 
228
                          "--homedir", self.tempdir,
 
229
                          "--force-mdc",
 
230
                          "--quiet"]
202
231
        # Only GPG version 1 has the --no-use-agent option.
203
 
        if self.gpg == "gpg" or self.gpg.endswith("/gpg"):
 
232
        if self.gpg == b"gpg" or self.gpg.endswith(b"/gpg"):
204
233
            self.gnupgargs.append("--no-use-agent")
205
234
 
206
235
    def __enter__(self):
243
272
                dir=self.tempdir) as passfile:
244
273
            passfile.write(passphrase)
245
274
            passfile.flush()
246
 
            proc = subprocess.Popen([self.gpg, '--symmetric',
247
 
                                     '--passphrase-file',
 
275
            proc = subprocess.Popen([self.gpg, "--symmetric",
 
276
                                     "--passphrase-file",
248
277
                                     passfile.name]
249
278
                                    + self.gnupgargs,
250
279
                                    stdin=subprocess.PIPE,
261
290
                dir=self.tempdir) as passfile:
262
291
            passfile.write(passphrase)
263
292
            passfile.flush()
264
 
            proc = subprocess.Popen([self.gpg, '--decrypt',
265
 
                                     '--passphrase-file',
 
293
            proc = subprocess.Popen([self.gpg, "--decrypt",
 
294
                                     "--passphrase-file",
266
295
                                     passfile.name]
267
296
                                    + self.gnupgargs,
268
297
                                    stdin=subprocess.PIPE,
275
304
 
276
305
 
277
306
# Pretend that we have an Avahi module
278
 
class Avahi(object):
279
 
    """This isn't so much a class as it is a module-like namespace.
280
 
    It is instantiated once, and simulates having an Avahi module."""
 
307
class avahi:
 
308
    """This isn't so much a class as it is a module-like namespace."""
281
309
    IF_UNSPEC = -1               # avahi-common/address.h
282
310
    PROTO_UNSPEC = -1            # avahi-common/address.h
283
311
    PROTO_INET = 0               # avahi-common/address.h
287
315
    DBUS_INTERFACE_SERVER = DBUS_NAME + ".Server"
288
316
    DBUS_PATH_SERVER = "/"
289
317
 
290
 
    def string_array_to_txt_array(self, t):
 
318
    @staticmethod
 
319
    def string_array_to_txt_array(t):
291
320
        return dbus.Array((dbus.ByteArray(s.encode("utf-8"))
292
321
                           for s in t), signature="ay")
293
322
    ENTRY_GROUP_ESTABLISHED = 2  # avahi-common/defs.h
298
327
    SERVER_RUNNING = 2           # avahi-common/defs.h
299
328
    SERVER_COLLISION = 3         # avahi-common/defs.h
300
329
    SERVER_FAILURE = 4           # avahi-common/defs.h
301
 
avahi = Avahi()
302
330
 
303
331
 
304
332
class AvahiError(Exception):
316
344
    pass
317
345
 
318
346
 
319
 
class AvahiService(object):
 
347
class AvahiService:
320
348
    """An Avahi (Zeroconf) service.
321
349
 
322
350
    Attributes:
323
351
    interface: integer; avahi.IF_UNSPEC or an interface index.
324
352
               Used to optionally bind to the specified interface.
325
 
    name: string; Example: 'Mandos'
326
 
    type: string; Example: '_mandos._tcp'.
 
353
    name: string; Example: "Mandos"
 
354
    type: string; Example: "_mandos._tcp".
327
355
     See <https://www.iana.org/assignments/service-names-port-numbers>
328
356
    port: integer; what port to announce
329
357
    TXT: list of strings; TXT record for the service
366
394
    def rename(self, remove=True):
367
395
        """Derived from the Avahi example code"""
368
396
        if self.rename_count >= self.max_renames:
369
 
            logger.critical("No suitable Zeroconf service name found"
370
 
                            " after %i retries, exiting.",
371
 
                            self.rename_count)
 
397
            log.critical("No suitable Zeroconf service name found"
 
398
                         " after %i retries, exiting.",
 
399
                         self.rename_count)
372
400
            raise AvahiServiceError("Too many renames")
373
401
        self.name = str(
374
402
            self.server.GetAlternativeServiceName(self.name))
375
403
        self.rename_count += 1
376
 
        logger.info("Changing Zeroconf service name to %r ...",
377
 
                    self.name)
 
404
        log.info("Changing Zeroconf service name to %r ...",
 
405
                 self.name)
378
406
        if remove:
379
407
            self.remove()
380
408
        try:
382
410
        except dbus.exceptions.DBusException as error:
383
411
            if (error.get_dbus_name()
384
412
                == "org.freedesktop.Avahi.CollisionError"):
385
 
                logger.info("Local Zeroconf service name collision.")
 
413
                log.info("Local Zeroconf service name collision.")
386
414
                return self.rename(remove=False)
387
415
            else:
388
 
                logger.critical("D-Bus Exception", exc_info=error)
 
416
                log.critical("D-Bus Exception", exc_info=error)
389
417
                self.cleanup()
390
418
                os._exit(1)
391
419
 
407
435
                avahi.DBUS_INTERFACE_ENTRY_GROUP)
408
436
        self.entry_group_state_changed_match = (
409
437
            self.group.connect_to_signal(
410
 
                'StateChanged', self.entry_group_state_changed))
411
 
        logger.debug("Adding Zeroconf service '%s' of type '%s' ...",
412
 
                     self.name, self.type)
 
438
                "StateChanged", self.entry_group_state_changed))
 
439
        log.debug("Adding Zeroconf service '%s' of type '%s' ...",
 
440
                  self.name, self.type)
413
441
        self.group.AddService(
414
442
            self.interface,
415
443
            self.protocol,
422
450
 
423
451
    def entry_group_state_changed(self, state, error):
424
452
        """Derived from the Avahi example code"""
425
 
        logger.debug("Avahi entry group state change: %i", state)
 
453
        log.debug("Avahi entry group state change: %i", state)
426
454
 
427
455
        if state == avahi.ENTRY_GROUP_ESTABLISHED:
428
 
            logger.debug("Zeroconf service established.")
 
456
            log.debug("Zeroconf service established.")
429
457
        elif state == avahi.ENTRY_GROUP_COLLISION:
430
 
            logger.info("Zeroconf service name collision.")
 
458
            log.info("Zeroconf service name collision.")
431
459
            self.rename()
432
460
        elif state == avahi.ENTRY_GROUP_FAILURE:
433
 
            logger.critical("Avahi: Error in group state changed %s",
434
 
                            str(error))
 
461
            log.critical("Avahi: Error in group state changed %s",
 
462
                         str(error))
435
463
            raise AvahiGroupError("State changed: {!s}".format(error))
436
464
 
437
465
    def cleanup(self):
447
475
 
448
476
    def server_state_changed(self, state, error=None):
449
477
        """Derived from the Avahi example code"""
450
 
        logger.debug("Avahi server state change: %i", state)
 
478
        log.debug("Avahi server state change: %i", state)
451
479
        bad_states = {
452
480
            avahi.SERVER_INVALID: "Zeroconf server invalid",
453
481
            avahi.SERVER_REGISTERING: None,
457
485
        if state in bad_states:
458
486
            if bad_states[state] is not None:
459
487
                if error is None:
460
 
                    logger.error(bad_states[state])
 
488
                    log.error(bad_states[state])
461
489
                else:
462
 
                    logger.error(bad_states[state] + ": %r", error)
 
490
                    log.error(bad_states[state] + ": %r", error)
463
491
            self.cleanup()
464
492
        elif state == avahi.SERVER_RUNNING:
465
493
            try:
467
495
            except dbus.exceptions.DBusException as error:
468
496
                if (error.get_dbus_name()
469
497
                    == "org.freedesktop.Avahi.CollisionError"):
470
 
                    logger.info("Local Zeroconf service name"
471
 
                                " collision.")
 
498
                    log.info("Local Zeroconf service name collision.")
472
499
                    return self.rename(remove=False)
473
500
                else:
474
 
                    logger.critical("D-Bus Exception", exc_info=error)
 
501
                    log.critical("D-Bus Exception", exc_info=error)
475
502
                    self.cleanup()
476
503
                    os._exit(1)
477
504
        else:
478
505
            if error is None:
479
 
                logger.debug("Unknown state: %r", state)
 
506
                log.debug("Unknown state: %r", state)
480
507
            else:
481
 
                logger.debug("Unknown state: %r: %r", state, error)
 
508
                log.debug("Unknown state: %r: %r", state, error)
482
509
 
483
510
    def activate(self):
484
511
        """Derived from the Avahi example code"""
496
523
class AvahiServiceToSyslog(AvahiService):
497
524
    def rename(self, *args, **kwargs):
498
525
        """Add the new name to the syslog messages"""
499
 
        ret = super(AvahiServiceToSyslog, self).rename(self, *args,
 
526
        ret = super(AvahiServiceToSyslog, self).rename(*args,
500
527
                                                       **kwargs)
501
528
        syslogger.setFormatter(logging.Formatter(
502
 
            'Mandos ({}) [%(process)d]: %(levelname)s: %(message)s'
 
529
            "Mandos ({}) [%(process)d]: %(levelname)s: %(message)s"
503
530
            .format(self.name)))
504
531
        return ret
505
532
 
506
533
 
507
534
# Pretend that we have a GnuTLS module
508
 
class GnuTLS(object):
509
 
    """This isn't so much a class as it is a module-like namespace.
510
 
    It is instantiated once, and simulates having a GnuTLS module."""
 
535
class gnutls:
 
536
    """This isn't so much a class as it is a module-like namespace."""
511
537
 
512
538
    library = ctypes.util.find_library("gnutls")
513
539
    if library is None:
514
540
        library = ctypes.util.find_library("gnutls-deb0")
515
541
    _library = ctypes.cdll.LoadLibrary(library)
516
542
    del library
517
 
    _need_version = b"3.3.0"
518
 
 
519
 
    def __init__(self):
520
 
        # Need to use "self" here, since this method is called before
521
 
        # the assignment to the "gnutls" global variable happens.
522
 
        if self.check_version(self._need_version) is None:
523
 
            raise self.Error("Needs GnuTLS {} or later"
524
 
                             .format(self._need_version))
525
543
 
526
544
    # Unless otherwise indicated, the constants and types below are
527
545
    # all from the gnutls/gnutls.h C header file.
531
549
    E_INTERRUPTED = -52
532
550
    E_AGAIN = -28
533
551
    CRT_OPENPGP = 2
 
552
    CRT_RAWPK = 3
534
553
    CLIENT = 2
535
554
    SHUT_RDWR = 0
536
555
    CRD_CERTIFICATE = 1
537
556
    E_NO_CERTIFICATE_FOUND = -49
 
557
    X509_FMT_DER = 0
 
558
    NO_TICKETS = 1<<10
 
559
    ENABLE_RAWPK = 1<<18
 
560
    CTYPE_PEERS = 3
 
561
    KEYID_USE_SHA256 = 1        # gnutls/x509.h
538
562
    OPENPGP_FMT_RAW = 0         # gnutls/openpgp.h
539
563
 
540
564
    # Types
541
 
    class session_int(ctypes.Structure):
 
565
    class _session_int(ctypes.Structure):
542
566
        _fields_ = []
543
 
    session_t = ctypes.POINTER(session_int)
 
567
    session_t = ctypes.POINTER(_session_int)
544
568
 
545
569
    class certificate_credentials_st(ctypes.Structure):
546
570
        _fields_ = []
549
573
    certificate_type_t = ctypes.c_int
550
574
 
551
575
    class datum_t(ctypes.Structure):
552
 
        _fields_ = [('data', ctypes.POINTER(ctypes.c_ubyte)),
553
 
                    ('size', ctypes.c_uint)]
 
576
        _fields_ = [("data", ctypes.POINTER(ctypes.c_ubyte)),
 
577
                    ("size", ctypes.c_uint)]
554
578
 
555
 
    class openpgp_crt_int(ctypes.Structure):
 
579
    class _openpgp_crt_int(ctypes.Structure):
556
580
        _fields_ = []
557
 
    openpgp_crt_t = ctypes.POINTER(openpgp_crt_int)
 
581
    openpgp_crt_t = ctypes.POINTER(_openpgp_crt_int)
558
582
    openpgp_crt_fmt_t = ctypes.c_int  # gnutls/openpgp.h
559
583
    log_func = ctypes.CFUNCTYPE(None, ctypes.c_int, ctypes.c_char_p)
560
584
    credentials_type_t = ctypes.c_int
563
587
 
564
588
    # Exceptions
565
589
    class Error(Exception):
566
 
        # We need to use the class name "GnuTLS" here, since this
567
 
        # exception might be raised from within GnuTLS.__init__,
568
 
        # which is called before the assignment to the "gnutls"
569
 
        # global variable has happened.
570
590
        def __init__(self, message=None, code=None, args=()):
571
591
            # Default usage is by a message string, but if a return
572
592
            # code is passed, convert it to a string with
573
593
            # gnutls.strerror()
574
594
            self.code = code
575
595
            if message is None and code is not None:
576
 
                message = GnuTLS.strerror(code)
577
 
            return super(GnuTLS.Error, self).__init__(
 
596
                message = gnutls.strerror(code).decode(
 
597
                    "utf-8", errors="replace")
 
598
            return super(gnutls.Error, self).__init__(
578
599
                message, *args)
579
600
 
580
601
    class CertificateSecurityError(Error):
581
602
        pass
582
603
 
 
604
    class PointerTo:
 
605
        def __init__(self, cls):
 
606
            self.cls = cls
 
607
 
 
608
        def from_param(self, obj):
 
609
            if not isinstance(obj, self.cls):
 
610
                raise TypeError("Not of type {}: {!r}"
 
611
                                .format(self.cls.__name__, obj))
 
612
            return ctypes.byref(obj.from_param(obj))
 
613
 
 
614
    class CastToVoidPointer:
 
615
        def __init__(self, cls):
 
616
            self.cls = cls
 
617
 
 
618
        def from_param(self, obj):
 
619
            if not isinstance(obj, self.cls):
 
620
                raise TypeError("Not of type {}: {!r}"
 
621
                                .format(self.cls.__name__, obj))
 
622
            return ctypes.cast(obj.from_param(obj), ctypes.c_void_p)
 
623
 
 
624
    class With_from_param:
 
625
        @classmethod
 
626
        def from_param(cls, obj):
 
627
            return obj._as_parameter_
 
628
 
583
629
    # Classes
584
 
    class Credentials(object):
 
630
    class Credentials(With_from_param):
585
631
        def __init__(self):
586
 
            self._c_object = gnutls.certificate_credentials_t()
587
 
            gnutls.certificate_allocate_credentials(
588
 
                ctypes.byref(self._c_object))
 
632
            self._as_parameter_ = gnutls.certificate_credentials_t()
 
633
            gnutls.certificate_allocate_credentials(self)
589
634
            self.type = gnutls.CRD_CERTIFICATE
590
635
 
591
636
        def __del__(self):
592
 
            gnutls.certificate_free_credentials(self._c_object)
 
637
            gnutls.certificate_free_credentials(self)
593
638
 
594
 
    class ClientSession(object):
 
639
    class ClientSession(With_from_param):
595
640
        def __init__(self, socket, credentials=None):
596
 
            self._c_object = gnutls.session_t()
597
 
            gnutls.init(ctypes.byref(self._c_object), gnutls.CLIENT)
598
 
            gnutls.set_default_priority(self._c_object)
599
 
            gnutls.transport_set_ptr(self._c_object, socket.fileno())
600
 
            gnutls.handshake_set_private_extensions(self._c_object,
601
 
                                                    True)
 
641
            self._as_parameter_ = gnutls.session_t()
 
642
            gnutls_flags = gnutls.CLIENT
 
643
            if gnutls.check_version(b"3.5.6"):
 
644
                gnutls_flags |= gnutls.NO_TICKETS
 
645
            if gnutls.has_rawpk:
 
646
                gnutls_flags |= gnutls.ENABLE_RAWPK
 
647
            gnutls.init(self, gnutls_flags)
 
648
            del gnutls_flags
 
649
            gnutls.set_default_priority(self)
 
650
            gnutls.transport_set_ptr(self, socket.fileno())
 
651
            gnutls.handshake_set_private_extensions(self, True)
602
652
            self.socket = socket
603
653
            if credentials is None:
604
654
                credentials = gnutls.Credentials()
605
 
            gnutls.credentials_set(self._c_object, credentials.type,
606
 
                                   ctypes.cast(credentials._c_object,
607
 
                                               ctypes.c_void_p))
 
655
            gnutls.credentials_set(self, credentials.type,
 
656
                                   credentials)
608
657
            self.credentials = credentials
609
658
 
610
659
        def __del__(self):
611
 
            gnutls.deinit(self._c_object)
 
660
            gnutls.deinit(self)
612
661
 
613
662
        def handshake(self):
614
 
            return gnutls.handshake(self._c_object)
 
663
            return gnutls.handshake(self)
615
664
 
616
665
        def send(self, data):
617
666
            data = bytes(data)
618
667
            data_len = len(data)
619
668
            while data_len > 0:
620
 
                data_len -= gnutls.record_send(self._c_object,
621
 
                                               data[-data_len:],
 
669
                data_len -= gnutls.record_send(self, data[-data_len:],
622
670
                                               data_len)
623
671
 
624
672
        def bye(self):
625
 
            return gnutls.bye(self._c_object, gnutls.SHUT_RDWR)
 
673
            return gnutls.bye(self, gnutls.SHUT_RDWR)
626
674
 
627
675
    # Error handling functions
628
676
    def _error_code(result):
629
677
        """A function to raise exceptions on errors, suitable
630
 
        for the 'restype' attribute on ctypes functions"""
631
 
        if result >= 0:
 
678
        for the "restype" attribute on ctypes functions"""
 
679
        if result >= gnutls.E_SUCCESS:
632
680
            return result
633
681
        if result == gnutls.E_NO_CERTIFICATE_FOUND:
634
682
            raise gnutls.CertificateSecurityError(code=result)
635
683
        raise gnutls.Error(code=result)
636
684
 
637
 
    def _retry_on_error(result, func, arguments):
 
685
    def _retry_on_error(result, func, arguments,
 
686
                        _error_code=_error_code):
638
687
        """A function to retry on some errors, suitable
639
 
        for the 'errcheck' attribute on ctypes functions"""
640
 
        while result < 0:
 
688
        for the "errcheck" attribute on ctypes functions"""
 
689
        while result < gnutls.E_SUCCESS:
641
690
            if result not in (gnutls.E_INTERRUPTED, gnutls.E_AGAIN):
642
691
                return _error_code(result)
643
692
            result = func(*arguments)
648
697
 
649
698
    # Functions
650
699
    priority_set_direct = _library.gnutls_priority_set_direct
651
 
    priority_set_direct.argtypes = [session_t, ctypes.c_char_p,
 
700
    priority_set_direct.argtypes = [ClientSession, ctypes.c_char_p,
652
701
                                    ctypes.POINTER(ctypes.c_char_p)]
653
702
    priority_set_direct.restype = _error_code
654
703
 
655
704
    init = _library.gnutls_init
656
 
    init.argtypes = [ctypes.POINTER(session_t), ctypes.c_int]
 
705
    init.argtypes = [PointerTo(ClientSession), ctypes.c_int]
657
706
    init.restype = _error_code
658
707
 
659
708
    set_default_priority = _library.gnutls_set_default_priority
660
 
    set_default_priority.argtypes = [session_t]
 
709
    set_default_priority.argtypes = [ClientSession]
661
710
    set_default_priority.restype = _error_code
662
711
 
663
712
    record_send = _library.gnutls_record_send
664
 
    record_send.argtypes = [session_t, ctypes.c_void_p,
 
713
    record_send.argtypes = [ClientSession, ctypes.c_void_p,
665
714
                            ctypes.c_size_t]
666
715
    record_send.restype = ctypes.c_ssize_t
667
716
    record_send.errcheck = _retry_on_error
669
718
    certificate_allocate_credentials = (
670
719
        _library.gnutls_certificate_allocate_credentials)
671
720
    certificate_allocate_credentials.argtypes = [
672
 
        ctypes.POINTER(certificate_credentials_t)]
 
721
        PointerTo(Credentials)]
673
722
    certificate_allocate_credentials.restype = _error_code
674
723
 
675
724
    certificate_free_credentials = (
676
725
        _library.gnutls_certificate_free_credentials)
677
 
    certificate_free_credentials.argtypes = [
678
 
        certificate_credentials_t]
 
726
    certificate_free_credentials.argtypes = [Credentials]
679
727
    certificate_free_credentials.restype = None
680
728
 
681
729
    handshake_set_private_extensions = (
682
730
        _library.gnutls_handshake_set_private_extensions)
683
 
    handshake_set_private_extensions.argtypes = [session_t,
 
731
    handshake_set_private_extensions.argtypes = [ClientSession,
684
732
                                                 ctypes.c_int]
685
733
    handshake_set_private_extensions.restype = None
686
734
 
687
735
    credentials_set = _library.gnutls_credentials_set
688
 
    credentials_set.argtypes = [session_t, credentials_type_t,
689
 
                                ctypes.c_void_p]
 
736
    credentials_set.argtypes = [ClientSession, credentials_type_t,
 
737
                                CastToVoidPointer(Credentials)]
690
738
    credentials_set.restype = _error_code
691
739
 
692
740
    strerror = _library.gnutls_strerror
694
742
    strerror.restype = ctypes.c_char_p
695
743
 
696
744
    certificate_type_get = _library.gnutls_certificate_type_get
697
 
    certificate_type_get.argtypes = [session_t]
 
745
    certificate_type_get.argtypes = [ClientSession]
698
746
    certificate_type_get.restype = _error_code
699
747
 
700
748
    certificate_get_peers = _library.gnutls_certificate_get_peers
701
 
    certificate_get_peers.argtypes = [session_t,
 
749
    certificate_get_peers.argtypes = [ClientSession,
702
750
                                      ctypes.POINTER(ctypes.c_uint)]
703
751
    certificate_get_peers.restype = ctypes.POINTER(datum_t)
704
752
 
711
759
    global_set_log_function.restype = None
712
760
 
713
761
    deinit = _library.gnutls_deinit
714
 
    deinit.argtypes = [session_t]
 
762
    deinit.argtypes = [ClientSession]
715
763
    deinit.restype = None
716
764
 
717
765
    handshake = _library.gnutls_handshake
718
 
    handshake.argtypes = [session_t]
719
 
    handshake.restype = _error_code
 
766
    handshake.argtypes = [ClientSession]
 
767
    handshake.restype = ctypes.c_int
720
768
    handshake.errcheck = _retry_on_error
721
769
 
722
770
    transport_set_ptr = _library.gnutls_transport_set_ptr
723
 
    transport_set_ptr.argtypes = [session_t, transport_ptr_t]
 
771
    transport_set_ptr.argtypes = [ClientSession, transport_ptr_t]
724
772
    transport_set_ptr.restype = None
725
773
 
726
774
    bye = _library.gnutls_bye
727
 
    bye.argtypes = [session_t, close_request_t]
728
 
    bye.restype = _error_code
 
775
    bye.argtypes = [ClientSession, close_request_t]
 
776
    bye.restype = ctypes.c_int
729
777
    bye.errcheck = _retry_on_error
730
778
 
731
779
    check_version = _library.gnutls_check_version
732
780
    check_version.argtypes = [ctypes.c_char_p]
733
781
    check_version.restype = ctypes.c_char_p
734
782
 
735
 
    # All the function declarations below are from gnutls/openpgp.h
736
 
 
737
 
    openpgp_crt_init = _library.gnutls_openpgp_crt_init
738
 
    openpgp_crt_init.argtypes = [ctypes.POINTER(openpgp_crt_t)]
739
 
    openpgp_crt_init.restype = _error_code
740
 
 
741
 
    openpgp_crt_import = _library.gnutls_openpgp_crt_import
742
 
    openpgp_crt_import.argtypes = [openpgp_crt_t,
743
 
                                   ctypes.POINTER(datum_t),
744
 
                                   openpgp_crt_fmt_t]
745
 
    openpgp_crt_import.restype = _error_code
746
 
 
747
 
    openpgp_crt_verify_self = _library.gnutls_openpgp_crt_verify_self
748
 
    openpgp_crt_verify_self.argtypes = [openpgp_crt_t, ctypes.c_uint,
749
 
                                        ctypes.POINTER(ctypes.c_uint)]
750
 
    openpgp_crt_verify_self.restype = _error_code
751
 
 
752
 
    openpgp_crt_deinit = _library.gnutls_openpgp_crt_deinit
753
 
    openpgp_crt_deinit.argtypes = [openpgp_crt_t]
754
 
    openpgp_crt_deinit.restype = None
755
 
 
756
 
    openpgp_crt_get_fingerprint = (
757
 
        _library.gnutls_openpgp_crt_get_fingerprint)
758
 
    openpgp_crt_get_fingerprint.argtypes = [openpgp_crt_t,
759
 
                                            ctypes.c_void_p,
760
 
                                            ctypes.POINTER(
761
 
                                                ctypes.c_size_t)]
762
 
    openpgp_crt_get_fingerprint.restype = _error_code
 
783
    _need_version = b"3.3.0"
 
784
    if check_version(_need_version) is None:
 
785
        raise self.Error("Needs GnuTLS {} or later"
 
786
                         .format(_need_version))
 
787
 
 
788
    _tls_rawpk_version = b"3.6.6"
 
789
    has_rawpk = bool(check_version(_tls_rawpk_version))
 
790
 
 
791
    if has_rawpk:
 
792
        # Types
 
793
        class pubkey_st(ctypes.Structure):
 
794
            _fields = []
 
795
        pubkey_t = ctypes.POINTER(pubkey_st)
 
796
 
 
797
        x509_crt_fmt_t = ctypes.c_int
 
798
 
 
799
        # All the function declarations below are from
 
800
        # gnutls/abstract.h
 
801
        pubkey_init = _library.gnutls_pubkey_init
 
802
        pubkey_init.argtypes = [ctypes.POINTER(pubkey_t)]
 
803
        pubkey_init.restype = _error_code
 
804
 
 
805
        pubkey_import = _library.gnutls_pubkey_import
 
806
        pubkey_import.argtypes = [pubkey_t, ctypes.POINTER(datum_t),
 
807
                                  x509_crt_fmt_t]
 
808
        pubkey_import.restype = _error_code
 
809
 
 
810
        pubkey_get_key_id = _library.gnutls_pubkey_get_key_id
 
811
        pubkey_get_key_id.argtypes = [pubkey_t, ctypes.c_int,
 
812
                                      ctypes.POINTER(ctypes.c_ubyte),
 
813
                                      ctypes.POINTER(ctypes.c_size_t)]
 
814
        pubkey_get_key_id.restype = _error_code
 
815
 
 
816
        pubkey_deinit = _library.gnutls_pubkey_deinit
 
817
        pubkey_deinit.argtypes = [pubkey_t]
 
818
        pubkey_deinit.restype = None
 
819
    else:
 
820
        # All the function declarations below are from
 
821
        # gnutls/openpgp.h
 
822
 
 
823
        openpgp_crt_init = _library.gnutls_openpgp_crt_init
 
824
        openpgp_crt_init.argtypes = [ctypes.POINTER(openpgp_crt_t)]
 
825
        openpgp_crt_init.restype = _error_code
 
826
 
 
827
        openpgp_crt_import = _library.gnutls_openpgp_crt_import
 
828
        openpgp_crt_import.argtypes = [openpgp_crt_t,
 
829
                                       ctypes.POINTER(datum_t),
 
830
                                       openpgp_crt_fmt_t]
 
831
        openpgp_crt_import.restype = _error_code
 
832
 
 
833
        openpgp_crt_verify_self = \
 
834
            _library.gnutls_openpgp_crt_verify_self
 
835
        openpgp_crt_verify_self.argtypes = [
 
836
            openpgp_crt_t,
 
837
            ctypes.c_uint,
 
838
            ctypes.POINTER(ctypes.c_uint),
 
839
        ]
 
840
        openpgp_crt_verify_self.restype = _error_code
 
841
 
 
842
        openpgp_crt_deinit = _library.gnutls_openpgp_crt_deinit
 
843
        openpgp_crt_deinit.argtypes = [openpgp_crt_t]
 
844
        openpgp_crt_deinit.restype = None
 
845
 
 
846
        openpgp_crt_get_fingerprint = (
 
847
            _library.gnutls_openpgp_crt_get_fingerprint)
 
848
        openpgp_crt_get_fingerprint.argtypes = [openpgp_crt_t,
 
849
                                                ctypes.c_void_p,
 
850
                                                ctypes.POINTER(
 
851
                                                    ctypes.c_size_t)]
 
852
        openpgp_crt_get_fingerprint.restype = _error_code
 
853
 
 
854
    if check_version(b"3.6.4"):
 
855
        certificate_type_get2 = _library.gnutls_certificate_type_get2
 
856
        certificate_type_get2.argtypes = [ClientSession, ctypes.c_int]
 
857
        certificate_type_get2.restype = _error_code
763
858
 
764
859
    # Remove non-public functions
765
860
    del _error_code, _retry_on_error
766
 
# Create the global "gnutls" object, simulating a module
767
 
gnutls = GnuTLS()
768
861
 
769
862
 
770
863
def call_pipe(connection,       # : multiprocessing.Connection
778
871
    connection.close()
779
872
 
780
873
 
781
 
class Client(object):
 
874
class Client:
782
875
    """A representation of a client host served by this server.
783
876
 
784
877
    Attributes:
785
 
    approved:   bool(); 'None' if not yet approved/disapproved
 
878
    approved:   bool(); None if not yet approved/disapproved
786
879
    approval_delay: datetime.timedelta(); Time to wait for approval
787
880
    approval_duration: datetime.timedelta(); Duration of one approval
788
 
    checker:    subprocess.Popen(); a running checker process used
789
 
                                    to see if the client lives.
790
 
                                    'None' if no process is running.
 
881
    checker: multiprocessing.Process(); a running checker process used
 
882
             to see if the client lives. None if no process is
 
883
             running.
791
884
    checker_callback_tag: a GLib event source tag, or None
792
885
    checker_command: string; External command which is run to check
793
886
                     if client lives.  %() expansions are done at
801
894
    disable_initiator_tag: a GLib event source tag, or None
802
895
    enabled:    bool()
803
896
    fingerprint: string (40 or 32 hexadecimal digits); used to
804
 
                 uniquely identify the client
 
897
                 uniquely identify an OpenPGP client
 
898
    key_id: string (64 hexadecimal digits); used to uniquely identify
 
899
            a client using raw public keys
805
900
    host:       string; available for use by the checker command
806
901
    interval:   datetime.timedelta(); How often to start a new checker
807
902
    last_approval_request: datetime.datetime(); (UTC) or None
825
920
    """
826
921
 
827
922
    runtime_expansions = ("approval_delay", "approval_duration",
828
 
                          "created", "enabled", "expires",
 
923
                          "created", "enabled", "expires", "key_id",
829
924
                          "fingerprint", "host", "interval",
830
925
                          "last_approval_request", "last_checked_ok",
831
926
                          "last_enabled", "name", "timeout")
861
956
            client["enabled"] = config.getboolean(client_name,
862
957
                                                  "enabled")
863
958
 
864
 
            # Uppercase and remove spaces from fingerprint for later
865
 
            # comparison purposes with return value from the
866
 
            # fingerprint() function
867
 
            client["fingerprint"] = (section["fingerprint"].upper()
 
959
            # Uppercase and remove spaces from key_id and fingerprint
 
960
            # for later comparison purposes with return value from the
 
961
            # key_id() and fingerprint() functions
 
962
            client["key_id"] = (section.get("key_id", "").upper()
 
963
                                .replace(" ", ""))
 
964
            client["fingerprint"] = (section.get("fingerprint",
 
965
                                                 "").upper()
868
966
                                     .replace(" ", ""))
 
967
            if not (client["key_id"] or client["fingerprint"]):
 
968
                log.error("Skipping client %s without key_id or"
 
969
                          " fingerprint", client_name)
 
970
                del settings[client_name]
 
971
                continue
869
972
            if "secret" in section:
870
973
                client["secret"] = codecs.decode(section["secret"]
871
974
                                                 .encode("utf-8"),
912
1015
            self.last_enabled = None
913
1016
            self.expires = None
914
1017
 
915
 
        logger.debug("Creating client %r", self.name)
916
 
        logger.debug("  Fingerprint: %s", self.fingerprint)
 
1018
        log.debug("Creating client %r", self.name)
 
1019
        log.debug("  Key ID: %s", self.key_id)
 
1020
        log.debug("  Fingerprint: %s", self.fingerprint)
917
1021
        self.created = settings.get("created",
918
1022
                                    datetime.datetime.utcnow())
919
1023
 
947
1051
        if getattr(self, "enabled", False):
948
1052
            # Already enabled
949
1053
            return
950
 
        self.expires = datetime.datetime.utcnow() + self.timeout
951
1054
        self.enabled = True
952
1055
        self.last_enabled = datetime.datetime.utcnow()
953
1056
        self.init_checker()
958
1061
        if not getattr(self, "enabled", False):
959
1062
            return False
960
1063
        if not quiet:
961
 
            logger.info("Disabling client %s", self.name)
 
1064
            log.info("Disabling client %s", self.name)
962
1065
        if getattr(self, "disable_initiator_tag", None) is not None:
963
1066
            GLib.source_remove(self.disable_initiator_tag)
964
1067
            self.disable_initiator_tag = None
976
1079
    def __del__(self):
977
1080
        self.disable()
978
1081
 
979
 
    def init_checker(self):
980
 
        # Schedule a new checker to be started an 'interval' from now,
981
 
        # and every interval from then on.
 
1082
    def init_checker(self, randomize_start=False):
 
1083
        # Schedule a new checker to be started a randomly selected
 
1084
        # time (a fraction of 'interval') from now.  This spreads out
 
1085
        # the startup of checkers over time when the server is
 
1086
        # started.
982
1087
        if self.checker_initiator_tag is not None:
983
1088
            GLib.source_remove(self.checker_initiator_tag)
 
1089
        interval_milliseconds = int(self.interval.total_seconds()
 
1090
                                    * 1000)
 
1091
        if randomize_start:
 
1092
            delay_milliseconds = random.randrange(
 
1093
                interval_milliseconds + 1)
 
1094
        else:
 
1095
            delay_milliseconds = interval_milliseconds
984
1096
        self.checker_initiator_tag = GLib.timeout_add(
985
 
            int(self.interval.total_seconds() * 1000),
986
 
            self.start_checker)
987
 
        # Schedule a disable() when 'timeout' has passed
 
1097
            delay_milliseconds, self.start_checker, randomize_start)
 
1098
        delay = datetime.timedelta(0, 0, 0, delay_milliseconds)
 
1099
        # A checker might take up to an 'interval' of time, so we can
 
1100
        # expire at the soonest one interval after a checker was
 
1101
        # started.  Since the initial checker is delayed, the expire
 
1102
        # time might have to be extended.
 
1103
        now = datetime.datetime.utcnow()
 
1104
        self.expires = now + delay + self.interval
 
1105
        # Schedule a disable() at expire time
988
1106
        if self.disable_initiator_tag is not None:
989
1107
            GLib.source_remove(self.disable_initiator_tag)
990
1108
        self.disable_initiator_tag = GLib.timeout_add(
991
 
            int(self.timeout.total_seconds() * 1000), self.disable)
992
 
        # Also start a new checker *right now*.
993
 
        self.start_checker()
 
1109
            int((self.expires - now).total_seconds() * 1000),
 
1110
            self.disable)
994
1111
 
995
1112
    def checker_callback(self, source, condition, connection,
996
1113
                         command):
997
1114
        """The checker has completed, so take appropriate actions."""
998
 
        self.checker_callback_tag = None
999
 
        self.checker = None
1000
1115
        # Read return code from connection (see call_pipe)
1001
1116
        returncode = connection.recv()
1002
1117
        connection.close()
 
1118
        if self.checker is not None:
 
1119
            self.checker.join()
 
1120
        self.checker_callback_tag = None
 
1121
        self.checker = None
1003
1122
 
1004
1123
        if returncode >= 0:
1005
1124
            self.last_checker_status = returncode
1006
1125
            self.last_checker_signal = None
1007
1126
            if self.last_checker_status == 0:
1008
 
                logger.info("Checker for %(name)s succeeded",
1009
 
                            vars(self))
 
1127
                log.info("Checker for %(name)s succeeded", vars(self))
1010
1128
                self.checked_ok()
1011
1129
            else:
1012
 
                logger.info("Checker for %(name)s failed", vars(self))
 
1130
                log.info("Checker for %(name)s failed", vars(self))
1013
1131
        else:
1014
1132
            self.last_checker_status = -1
1015
1133
            self.last_checker_signal = -returncode
1016
 
            logger.warning("Checker for %(name)s crashed?",
1017
 
                           vars(self))
 
1134
            log.warning("Checker for %(name)s crashed?", vars(self))
1018
1135
        return False
1019
1136
 
1020
1137
    def checked_ok(self):
1039
1156
    def need_approval(self):
1040
1157
        self.last_approval_request = datetime.datetime.utcnow()
1041
1158
 
1042
 
    def start_checker(self):
 
1159
    def start_checker(self, start_was_randomized=False):
1043
1160
        """Start a new checker subprocess if one is not running.
1044
1161
 
1045
1162
        If a checker already exists, leave it running and do
1054
1171
        # should be.
1055
1172
 
1056
1173
        if self.checker is not None and not self.checker.is_alive():
1057
 
            logger.warning("Checker was not alive; joining")
 
1174
            log.warning("Checker was not alive; joining")
1058
1175
            self.checker.join()
1059
1176
            self.checker = None
1060
1177
        # Start a new checker if needed
1061
1178
        if self.checker is None:
1062
1179
            # Escape attributes for the shell
1063
1180
            escaped_attrs = {
1064
 
                attr: re.escape(str(getattr(self, attr)))
 
1181
                attr: shlex.quote(str(getattr(self, attr)))
1065
1182
                for attr in self.runtime_expansions}
1066
1183
            try:
1067
1184
                command = self.checker_command % escaped_attrs
1068
1185
            except TypeError as error:
1069
 
                logger.error('Could not format string "%s"',
1070
 
                             self.checker_command,
1071
 
                             exc_info=error)
 
1186
                log.error('Could not format string "%s"',
 
1187
                          self.checker_command, exc_info=error)
1072
1188
                return True     # Try again later
1073
1189
            self.current_checker_command = command
1074
 
            logger.info("Starting checker %r for %s", command,
1075
 
                        self.name)
 
1190
            log.info("Starting checker %r for %s", command, self.name)
1076
1191
            # We don't need to redirect stdout and stderr, since
1077
1192
            # in normal mode, that is already done by daemon(),
1078
1193
            # and in debug mode we don't want to.  (Stdin is
1094
1209
                kwargs=popen_args)
1095
1210
            self.checker.start()
1096
1211
            self.checker_callback_tag = GLib.io_add_watch(
1097
 
                pipe[0].fileno(), GLib.IO_IN,
 
1212
                GLib.IOChannel.unix_new(pipe[0].fileno()),
 
1213
                GLib.PRIORITY_DEFAULT, GLib.IO_IN,
1098
1214
                self.checker_callback, pipe[0], command)
 
1215
        if start_was_randomized:
 
1216
            # We were started after a random delay; Schedule a new
 
1217
            # checker to be started an 'interval' from now, and every
 
1218
            # interval from then on.
 
1219
            now = datetime.datetime.utcnow()
 
1220
            self.checker_initiator_tag = GLib.timeout_add(
 
1221
                int(self.interval.total_seconds() * 1000),
 
1222
                self.start_checker)
 
1223
            self.expires = max(self.expires, now + self.interval)
 
1224
            # Don't start a new checker again after same random delay
 
1225
            return False
1099
1226
        # Re-run this periodically if run by GLib.timeout_add
1100
1227
        return True
1101
1228
 
1106
1233
            self.checker_callback_tag = None
1107
1234
        if getattr(self, "checker", None) is None:
1108
1235
            return
1109
 
        logger.debug("Stopping checker for %(name)s", vars(self))
 
1236
        log.debug("Stopping checker for %(name)s", vars(self))
1110
1237
        self.checker.terminate()
1111
1238
        self.checker = None
1112
1239
 
1139
1266
        func._dbus_name = func.__name__
1140
1267
        if func._dbus_name.endswith("_dbus_property"):
1141
1268
            func._dbus_name = func._dbus_name[:-14]
1142
 
        func._dbus_get_args_options = {'byte_arrays': byte_arrays}
 
1269
        func._dbus_get_args_options = {"byte_arrays": byte_arrays}
1143
1270
        return func
1144
1271
 
1145
1272
    return decorator
1234
1361
 
1235
1362
    @dbus.service.method(dbus.INTROSPECTABLE_IFACE,
1236
1363
                         out_signature="s",
1237
 
                         path_keyword='object_path',
1238
 
                         connection_keyword='connection')
 
1364
                         path_keyword="object_path",
 
1365
                         connection_keyword="connection")
1239
1366
    def Introspect(self, object_path, connection):
1240
1367
        """Overloading of standard D-Bus method.
1241
1368
 
1290
1417
            document.unlink()
1291
1418
        except (AttributeError, xml.dom.DOMException,
1292
1419
                xml.parsers.expat.ExpatError) as error:
1293
 
            logger.error("Failed to override Introspection method",
1294
 
                         exc_info=error)
 
1420
            log.error("Failed to override Introspection method",
 
1421
                      exc_info=error)
1295
1422
        return xmlstring
1296
1423
 
1297
1424
 
1355
1482
                raise ValueError("Byte arrays not supported for non-"
1356
1483
                                 "'ay' signature {!r}"
1357
1484
                                 .format(prop._dbus_signature))
1358
 
            value = dbus.ByteArray(b''.join(chr(byte)
1359
 
                                            for byte in value))
 
1485
            value = dbus.ByteArray(bytes(value))
1360
1486
        prop(value)
1361
1487
 
1362
1488
    @dbus.service.method(dbus.PROPERTIES_IFACE,
1395
1521
 
1396
1522
    @dbus.service.method(dbus.INTROSPECTABLE_IFACE,
1397
1523
                         out_signature="s",
1398
 
                         path_keyword='object_path',
1399
 
                         connection_keyword='connection')
 
1524
                         path_keyword="object_path",
 
1525
                         connection_keyword="connection")
1400
1526
    def Introspect(self, object_path, connection):
1401
1527
        """Overloading of standard D-Bus method.
1402
1528
 
1458
1584
            document.unlink()
1459
1585
        except (AttributeError, xml.dom.DOMException,
1460
1586
                xml.parsers.expat.ExpatError) as error:
1461
 
            logger.error("Failed to override Introspection method",
1462
 
                         exc_info=error)
 
1587
            log.error("Failed to override Introspection method",
 
1588
                      exc_info=error)
1463
1589
        return xmlstring
1464
1590
 
1465
1591
 
1497
1623
 
1498
1624
    @dbus.service.method(dbus.INTROSPECTABLE_IFACE,
1499
1625
                         out_signature="s",
1500
 
                         path_keyword='object_path',
1501
 
                         connection_keyword='connection')
 
1626
                         path_keyword="object_path",
 
1627
                         connection_keyword="connection")
1502
1628
    def Introspect(self, object_path, connection):
1503
1629
        """Overloading of standard D-Bus method.
1504
1630
 
1529
1655
            document.unlink()
1530
1656
        except (AttributeError, xml.dom.DOMException,
1531
1657
                xml.parsers.expat.ExpatError) as error:
1532
 
            logger.error("Failed to override Introspection method",
1533
 
                         exc_info=error)
 
1658
            log.error("Failed to override Introspection method",
 
1659
                      exc_info=error)
1534
1660
        return xmlstring
1535
1661
 
1536
1662
 
2000
2126
    def Name_dbus_property(self):
2001
2127
        return dbus.String(self.name)
2002
2128
 
 
2129
    # KeyID - property
 
2130
    @dbus_annotations(
 
2131
        {"org.freedesktop.DBus.Property.EmitsChangedSignal": "const"})
 
2132
    @dbus_service_property(_interface, signature="s", access="read")
 
2133
    def KeyID_dbus_property(self):
 
2134
        return dbus.String(self.key_id)
 
2135
 
2003
2136
    # Fingerprint - property
2004
2137
    @dbus_annotations(
2005
2138
        {"org.freedesktop.DBus.Property.EmitsChangedSignal": "const"})
2160
2293
    del _interface
2161
2294
 
2162
2295
 
2163
 
class ProxyClient(object):
2164
 
    def __init__(self, child_pipe, fpr, address):
 
2296
class ProxyClient:
 
2297
    def __init__(self, child_pipe, key_id, fpr, address):
2165
2298
        self._pipe = child_pipe
2166
 
        self._pipe.send(('init', fpr, address))
 
2299
        self._pipe.send(("init", key_id, fpr, address))
2167
2300
        if not self._pipe.recv():
2168
 
            raise KeyError(fpr)
 
2301
            raise KeyError(key_id or fpr)
2169
2302
 
2170
2303
    def __getattribute__(self, name):
2171
 
        if name == '_pipe':
 
2304
        if name == "_pipe":
2172
2305
            return super(ProxyClient, self).__getattribute__(name)
2173
 
        self._pipe.send(('getattr', name))
 
2306
        self._pipe.send(("getattr", name))
2174
2307
        data = self._pipe.recv()
2175
 
        if data[0] == 'data':
 
2308
        if data[0] == "data":
2176
2309
            return data[1]
2177
 
        if data[0] == 'function':
 
2310
        if data[0] == "function":
2178
2311
 
2179
2312
            def func(*args, **kwargs):
2180
 
                self._pipe.send(('funcall', name, args, kwargs))
 
2313
                self._pipe.send(("funcall", name, args, kwargs))
2181
2314
                return self._pipe.recv()[1]
2182
2315
 
2183
2316
            return func
2184
2317
 
2185
2318
    def __setattr__(self, name, value):
2186
 
        if name == '_pipe':
 
2319
        if name == "_pipe":
2187
2320
            return super(ProxyClient, self).__setattr__(name, value)
2188
 
        self._pipe.send(('setattr', name, value))
 
2321
        self._pipe.send(("setattr", name, value))
2189
2322
 
2190
2323
 
2191
2324
class ClientHandler(socketserver.BaseRequestHandler, object):
2196
2329
 
2197
2330
    def handle(self):
2198
2331
        with contextlib.closing(self.server.child_pipe) as child_pipe:
2199
 
            logger.info("TCP connection from: %s",
2200
 
                        str(self.client_address))
2201
 
            logger.debug("Pipe FD: %d",
2202
 
                         self.server.child_pipe.fileno())
 
2332
            log.info("TCP connection from: %s",
 
2333
                     str(self.client_address))
 
2334
            log.debug("Pipe FD: %d", self.server.child_pipe.fileno())
2203
2335
 
2204
2336
            session = gnutls.ClientSession(self.request)
2205
2337
 
2206
 
            # priority = ':'.join(("NONE", "+VERS-TLS1.1",
 
2338
            # priority = ":".join(("NONE", "+VERS-TLS1.1",
2207
2339
            #                       "+AES-256-CBC", "+SHA1",
2208
2340
            #                       "+COMP-NULL", "+CTYPE-OPENPGP",
2209
2341
            #                       "+DHE-DSS"))
2211
2343
            priority = self.server.gnutls_priority
2212
2344
            if priority is None:
2213
2345
                priority = "NORMAL"
2214
 
            gnutls.priority_set_direct(session._c_object,
2215
 
                                       priority.encode("utf-8"),
2216
 
                                       None)
 
2346
            gnutls.priority_set_direct(session,
 
2347
                                       priority.encode("utf-8"), None)
2217
2348
 
2218
2349
            # Start communication using the Mandos protocol
2219
2350
            # Get protocol number
2220
2351
            line = self.request.makefile().readline()
2221
 
            logger.debug("Protocol version: %r", line)
 
2352
            log.debug("Protocol version: %r", line)
2222
2353
            try:
2223
2354
                if int(line.strip().split()[0]) > 1:
2224
2355
                    raise RuntimeError(line)
2225
2356
            except (ValueError, IndexError, RuntimeError) as error:
2226
 
                logger.error("Unknown protocol version: %s", error)
 
2357
                log.error("Unknown protocol version: %s", error)
2227
2358
                return
2228
2359
 
2229
2360
            # Start GnuTLS connection
2230
2361
            try:
2231
2362
                session.handshake()
2232
2363
            except gnutls.Error as error:
2233
 
                logger.warning("Handshake failed: %s", error)
 
2364
                log.warning("Handshake failed: %s", error)
2234
2365
                # Do not run session.bye() here: the session is not
2235
2366
                # established.  Just abandon the request.
2236
2367
                return
2237
 
            logger.debug("Handshake succeeded")
 
2368
            log.debug("Handshake succeeded")
2238
2369
 
2239
2370
            approval_required = False
2240
2371
            try:
2241
 
                try:
2242
 
                    fpr = self.fingerprint(
2243
 
                        self.peer_certificate(session))
2244
 
                except (TypeError, gnutls.Error) as error:
2245
 
                    logger.warning("Bad certificate: %s", error)
2246
 
                    return
2247
 
                logger.debug("Fingerprint: %s", fpr)
2248
 
 
2249
 
                try:
2250
 
                    client = ProxyClient(child_pipe, fpr,
 
2372
                if gnutls.has_rawpk:
 
2373
                    fpr = b""
 
2374
                    try:
 
2375
                        key_id = self.key_id(
 
2376
                            self.peer_certificate(session))
 
2377
                    except (TypeError, gnutls.Error) as error:
 
2378
                        log.warning("Bad certificate: %s", error)
 
2379
                        return
 
2380
                    log.debug("Key ID: %s",
 
2381
                              key_id.decode("utf-8",
 
2382
                                            errors="replace"))
 
2383
 
 
2384
                else:
 
2385
                    key_id = b""
 
2386
                    try:
 
2387
                        fpr = self.fingerprint(
 
2388
                            self.peer_certificate(session))
 
2389
                    except (TypeError, gnutls.Error) as error:
 
2390
                        log.warning("Bad certificate: %s", error)
 
2391
                        return
 
2392
                    log.debug("Fingerprint: %s", fpr)
 
2393
 
 
2394
                try:
 
2395
                    client = ProxyClient(child_pipe, key_id, fpr,
2251
2396
                                         self.client_address)
2252
2397
                except KeyError:
2253
2398
                    return
2259
2404
 
2260
2405
                while True:
2261
2406
                    if not client.enabled:
2262
 
                        logger.info("Client %s is disabled",
2263
 
                                    client.name)
 
2407
                        log.info("Client %s is disabled", client.name)
2264
2408
                        if self.server.use_dbus:
2265
2409
                            # Emit D-Bus signal
2266
2410
                            client.Rejected("Disabled")
2270
2414
                        # We are approved or approval is disabled
2271
2415
                        break
2272
2416
                    elif client.approved is None:
2273
 
                        logger.info("Client %s needs approval",
2274
 
                                    client.name)
 
2417
                        log.info("Client %s needs approval",
 
2418
                                 client.name)
2275
2419
                        if self.server.use_dbus:
2276
2420
                            # Emit D-Bus signal
2277
2421
                            client.NeedApproval(
2278
2422
                                client.approval_delay.total_seconds()
2279
2423
                                * 1000, client.approved_by_default)
2280
2424
                    else:
2281
 
                        logger.warning("Client %s was not approved",
2282
 
                                       client.name)
 
2425
                        log.warning("Client %s was not approved",
 
2426
                                    client.name)
2283
2427
                        if self.server.use_dbus:
2284
2428
                            # Emit D-Bus signal
2285
2429
                            client.Rejected("Denied")
2293
2437
                    time2 = datetime.datetime.now()
2294
2438
                    if (time2 - time) >= delay:
2295
2439
                        if not client.approved_by_default:
2296
 
                            logger.warning("Client %s timed out while"
2297
 
                                           " waiting for approval",
2298
 
                                           client.name)
 
2440
                            log.warning("Client %s timed out while"
 
2441
                                        " waiting for approval",
 
2442
                                        client.name)
2299
2443
                            if self.server.use_dbus:
2300
2444
                                # Emit D-Bus signal
2301
2445
                                client.Rejected("Approval timed out")
2308
2452
                try:
2309
2453
                    session.send(client.secret)
2310
2454
                except gnutls.Error as error:
2311
 
                    logger.warning("gnutls send failed",
2312
 
                                   exc_info=error)
 
2455
                    log.warning("gnutls send failed", exc_info=error)
2313
2456
                    return
2314
2457
 
2315
 
                logger.info("Sending secret to %s", client.name)
 
2458
                log.info("Sending secret to %s", client.name)
2316
2459
                # bump the timeout using extended_timeout
2317
2460
                client.bump_timeout(client.extended_timeout)
2318
2461
                if self.server.use_dbus:
2325
2468
                try:
2326
2469
                    session.bye()
2327
2470
                except gnutls.Error as error:
2328
 
                    logger.warning("GnuTLS bye failed",
2329
 
                                   exc_info=error)
 
2471
                    log.warning("GnuTLS bye failed", exc_info=error)
2330
2472
 
2331
2473
    @staticmethod
2332
2474
    def peer_certificate(session):
2333
 
        "Return the peer's OpenPGP certificate as a bytestring"
2334
 
        # If not an OpenPGP certificate...
2335
 
        if (gnutls.certificate_type_get(session._c_object)
2336
 
            != gnutls.CRT_OPENPGP):
 
2475
        "Return the peer's certificate as a bytestring"
 
2476
        try:
 
2477
            cert_type = gnutls.certificate_type_get2(
 
2478
                session, gnutls.CTYPE_PEERS)
 
2479
        except AttributeError:
 
2480
            cert_type = gnutls.certificate_type_get(session)
 
2481
        if gnutls.has_rawpk:
 
2482
            valid_cert_types = frozenset((gnutls.CRT_RAWPK,))
 
2483
        else:
 
2484
            valid_cert_types = frozenset((gnutls.CRT_OPENPGP,))
 
2485
        # If not a valid certificate type...
 
2486
        if cert_type not in valid_cert_types:
 
2487
            log.info("Cert type %r not in %r", cert_type,
 
2488
                     valid_cert_types)
2337
2489
            # ...return invalid data
2338
2490
            return b""
2339
2491
        list_size = ctypes.c_uint(1)
2340
2492
        cert_list = (gnutls.certificate_get_peers
2341
 
                     (session._c_object, ctypes.byref(list_size)))
 
2493
                     (session, ctypes.byref(list_size)))
2342
2494
        if not bool(cert_list) and list_size.value != 0:
2343
2495
            raise gnutls.Error("error getting peer certificate")
2344
2496
        if list_size.value == 0:
2347
2499
        return ctypes.string_at(cert.data, cert.size)
2348
2500
 
2349
2501
    @staticmethod
 
2502
    def key_id(certificate):
 
2503
        "Convert a certificate bytestring to a hexdigit key ID"
 
2504
        # New GnuTLS "datum" with the public key
 
2505
        datum = gnutls.datum_t(
 
2506
            ctypes.cast(ctypes.c_char_p(certificate),
 
2507
                        ctypes.POINTER(ctypes.c_ubyte)),
 
2508
            ctypes.c_uint(len(certificate)))
 
2509
        # XXX all these need to be created in the gnutls "module"
 
2510
        # New empty GnuTLS certificate
 
2511
        pubkey = gnutls.pubkey_t()
 
2512
        gnutls.pubkey_init(ctypes.byref(pubkey))
 
2513
        # Import the raw public key into the certificate
 
2514
        gnutls.pubkey_import(pubkey,
 
2515
                             ctypes.byref(datum),
 
2516
                             gnutls.X509_FMT_DER)
 
2517
        # New buffer for the key ID
 
2518
        buf = ctypes.create_string_buffer(32)
 
2519
        buf_len = ctypes.c_size_t(len(buf))
 
2520
        # Get the key ID from the raw public key into the buffer
 
2521
        gnutls.pubkey_get_key_id(
 
2522
            pubkey,
 
2523
            gnutls.KEYID_USE_SHA256,
 
2524
            ctypes.cast(ctypes.byref(buf),
 
2525
                        ctypes.POINTER(ctypes.c_ubyte)),
 
2526
            ctypes.byref(buf_len))
 
2527
        # Deinit the certificate
 
2528
        gnutls.pubkey_deinit(pubkey)
 
2529
 
 
2530
        # Convert the buffer to a Python bytestring
 
2531
        key_id = ctypes.string_at(buf, buf_len.value)
 
2532
        # Convert the bytestring to hexadecimal notation
 
2533
        hex_key_id = binascii.hexlify(key_id).upper()
 
2534
        return hex_key_id
 
2535
 
 
2536
    @staticmethod
2350
2537
    def fingerprint(openpgp):
2351
2538
        "Convert an OpenPGP bytestring to a hexdigit fingerprint"
2352
2539
        # New GnuTLS "datum" with the OpenPGP public key
2366
2553
                                       ctypes.byref(crtverify))
2367
2554
        if crtverify.value != 0:
2368
2555
            gnutls.openpgp_crt_deinit(crt)
2369
 
            raise gnutls.CertificateSecurityError("Verify failed")
 
2556
            raise gnutls.CertificateSecurityError(code
 
2557
                                                  =crtverify.value)
2370
2558
        # New buffer for the fingerprint
2371
2559
        buf = ctypes.create_string_buffer(20)
2372
2560
        buf_len = ctypes.c_size_t()
2382
2570
        return hex_fpr
2383
2571
 
2384
2572
 
2385
 
class MultiprocessingMixIn(object):
 
2573
class MultiprocessingMixIn:
2386
2574
    """Like socketserver.ThreadingMixIn, but with multiprocessing"""
2387
2575
 
2388
2576
    def sub_process_main(self, request, address):
2400
2588
        return proc
2401
2589
 
2402
2590
 
2403
 
class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):
 
2591
class MultiprocessingMixInWithPipe(MultiprocessingMixIn):
2404
2592
    """ adds a pipe to the MixIn """
2405
2593
 
2406
2594
    def process_request(self, request, client_address):
2421
2609
 
2422
2610
 
2423
2611
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
2424
 
                     socketserver.TCPServer, object):
2425
 
    """IPv6-capable TCP server.  Accepts 'None' as address and/or port
 
2612
                     socketserver.TCPServer):
 
2613
    """IPv6-capable TCP server.  Accepts None as address and/or port
2426
2614
 
2427
2615
    Attributes:
2428
2616
        enabled:        Boolean; whether this server is activated yet
2479
2667
            if SO_BINDTODEVICE is None:
2480
2668
                # Fall back to a hard-coded value which seems to be
2481
2669
                # common enough.
2482
 
                logger.warning("SO_BINDTODEVICE not found, trying 25")
 
2670
                log.warning("SO_BINDTODEVICE not found, trying 25")
2483
2671
                SO_BINDTODEVICE = 25
2484
2672
            try:
2485
2673
                self.socket.setsockopt(
2487
2675
                    (self.interface + "\0").encode("utf-8"))
2488
2676
            except socket.error as error:
2489
2677
                if error.errno == errno.EPERM:
2490
 
                    logger.error("No permission to bind to"
2491
 
                                 " interface %s", self.interface)
 
2678
                    log.error("No permission to bind to interface %s",
 
2679
                              self.interface)
2492
2680
                elif error.errno == errno.ENOPROTOOPT:
2493
 
                    logger.error("SO_BINDTODEVICE not available;"
2494
 
                                 " cannot bind to interface %s",
2495
 
                                 self.interface)
 
2681
                    log.error("SO_BINDTODEVICE not available; cannot"
 
2682
                              " bind to interface %s", self.interface)
2496
2683
                elif error.errno == errno.ENODEV:
2497
 
                    logger.error("Interface %s does not exist,"
2498
 
                                 " cannot bind", self.interface)
 
2684
                    log.error("Interface %s does not exist, cannot"
 
2685
                              " bind", self.interface)
2499
2686
                else:
2500
2687
                    raise
2501
2688
        # Only bind(2) the socket if we really need to.
2502
2689
        if self.server_address[0] or self.server_address[1]:
 
2690
            if self.server_address[1]:
 
2691
                self.allow_reuse_address = True
2503
2692
            if not self.server_address[0]:
2504
2693
                if self.address_family == socket.AF_INET6:
2505
2694
                    any_address = "::"  # in6addr_any
2558
2747
    def add_pipe(self, parent_pipe, proc):
2559
2748
        # Call "handle_ipc" for both data and EOF events
2560
2749
        GLib.io_add_watch(
2561
 
            parent_pipe.fileno(),
2562
 
            GLib.IO_IN | GLib.IO_HUP,
 
2750
            GLib.IOChannel.unix_new(parent_pipe.fileno()),
 
2751
            GLib.PRIORITY_DEFAULT, GLib.IO_IN | GLib.IO_HUP,
2563
2752
            functools.partial(self.handle_ipc,
2564
2753
                              parent_pipe=parent_pipe,
2565
2754
                              proc=proc))
2578
2767
        request = parent_pipe.recv()
2579
2768
        command = request[0]
2580
2769
 
2581
 
        if command == 'init':
2582
 
            fpr = request[1].decode("ascii")
2583
 
            address = request[2]
 
2770
        if command == "init":
 
2771
            key_id = request[1].decode("ascii")
 
2772
            fpr = request[2].decode("ascii")
 
2773
            address = request[3]
2584
2774
 
2585
2775
            for c in self.clients.values():
2586
 
                if c.fingerprint == fpr:
 
2776
                if key_id == ("E3B0C44298FC1C149AFBF4C8996FB924"
 
2777
                              "27AE41E4649B934CA495991B7852B855"):
 
2778
                    continue
 
2779
                if key_id and c.key_id == key_id:
 
2780
                    client = c
 
2781
                    break
 
2782
                if fpr and c.fingerprint == fpr:
2587
2783
                    client = c
2588
2784
                    break
2589
2785
            else:
2590
 
                logger.info("Client not found for fingerprint: %s, ad"
2591
 
                            "dress: %s", fpr, address)
 
2786
                log.info("Client not found for key ID: %s, address:"
 
2787
                         " %s", key_id or fpr, address)
2592
2788
                if self.use_dbus:
2593
2789
                    # Emit D-Bus signal
2594
 
                    mandos_dbus_service.ClientNotFound(fpr,
 
2790
                    mandos_dbus_service.ClientNotFound(key_id or fpr,
2595
2791
                                                       address[0])
2596
2792
                parent_pipe.send(False)
2597
2793
                return False
2598
2794
 
2599
2795
            GLib.io_add_watch(
2600
 
                parent_pipe.fileno(),
2601
 
                GLib.IO_IN | GLib.IO_HUP,
 
2796
                GLib.IOChannel.unix_new(parent_pipe.fileno()),
 
2797
                GLib.PRIORITY_DEFAULT, GLib.IO_IN | GLib.IO_HUP,
2602
2798
                functools.partial(self.handle_ipc,
2603
2799
                                  parent_pipe=parent_pipe,
2604
2800
                                  proc=proc,
2607
2803
            # remove the old hook in favor of the new above hook on
2608
2804
            # same fileno
2609
2805
            return False
2610
 
        if command == 'funcall':
 
2806
        if command == "funcall":
2611
2807
            funcname = request[1]
2612
2808
            args = request[2]
2613
2809
            kwargs = request[3]
2614
2810
 
2615
 
            parent_pipe.send(('data', getattr(client_object,
 
2811
            parent_pipe.send(("data", getattr(client_object,
2616
2812
                                              funcname)(*args,
2617
2813
                                                        **kwargs)))
2618
2814
 
2619
 
        if command == 'getattr':
 
2815
        if command == "getattr":
2620
2816
            attrname = request[1]
2621
2817
            if isinstance(client_object.__getattribute__(attrname),
2622
 
                          collections.Callable):
2623
 
                parent_pipe.send(('function', ))
 
2818
                          collections.abc.Callable):
 
2819
                parent_pipe.send(("function", ))
2624
2820
            else:
2625
2821
                parent_pipe.send((
2626
 
                    'data', client_object.__getattribute__(attrname)))
 
2822
                    "data", client_object.__getattribute__(attrname)))
2627
2823
 
2628
 
        if command == 'setattr':
 
2824
        if command == "setattr":
2629
2825
            attrname = request[1]
2630
2826
            value = request[2]
2631
2827
            setattr(client_object, attrname, value)
2636
2832
def rfc3339_duration_to_delta(duration):
2637
2833
    """Parse an RFC 3339 "duration" and return a datetime.timedelta
2638
2834
 
2639
 
    >>> rfc3339_duration_to_delta("P7D")
2640
 
    datetime.timedelta(7)
2641
 
    >>> rfc3339_duration_to_delta("PT60S")
2642
 
    datetime.timedelta(0, 60)
2643
 
    >>> rfc3339_duration_to_delta("PT60M")
2644
 
    datetime.timedelta(0, 3600)
2645
 
    >>> rfc3339_duration_to_delta("PT24H")
2646
 
    datetime.timedelta(1)
2647
 
    >>> rfc3339_duration_to_delta("P1W")
2648
 
    datetime.timedelta(7)
2649
 
    >>> rfc3339_duration_to_delta("PT5M30S")
2650
 
    datetime.timedelta(0, 330)
2651
 
    >>> rfc3339_duration_to_delta("P1DT3M20S")
2652
 
    datetime.timedelta(1, 200)
 
2835
    >>> timedelta = datetime.timedelta
 
2836
    >>> rfc3339_duration_to_delta("P7D") == timedelta(7)
 
2837
    True
 
2838
    >>> rfc3339_duration_to_delta("PT60S") == timedelta(0, 60)
 
2839
    True
 
2840
    >>> rfc3339_duration_to_delta("PT60M") == timedelta(0, 3600)
 
2841
    True
 
2842
    >>> rfc3339_duration_to_delta("PT24H") == timedelta(1)
 
2843
    True
 
2844
    >>> rfc3339_duration_to_delta("P1W") == timedelta(7)
 
2845
    True
 
2846
    >>> rfc3339_duration_to_delta("PT5M30S") == timedelta(0, 330)
 
2847
    True
 
2848
    >>> rfc3339_duration_to_delta("P1DT3M20S") == timedelta(1, 200)
 
2849
    True
 
2850
    >>> del timedelta
2653
2851
    """
2654
2852
 
2655
2853
    # Parsing an RFC 3339 duration with regular expressions is not
2735
2933
def string_to_delta(interval):
2736
2934
    """Parse a string and return a datetime.timedelta
2737
2935
 
2738
 
    >>> string_to_delta('7d')
2739
 
    datetime.timedelta(7)
2740
 
    >>> string_to_delta('60s')
2741
 
    datetime.timedelta(0, 60)
2742
 
    >>> string_to_delta('60m')
2743
 
    datetime.timedelta(0, 3600)
2744
 
    >>> string_to_delta('24h')
2745
 
    datetime.timedelta(1)
2746
 
    >>> string_to_delta('1w')
2747
 
    datetime.timedelta(7)
2748
 
    >>> string_to_delta('5m 30s')
2749
 
    datetime.timedelta(0, 330)
 
2936
    >>> string_to_delta("7d") == datetime.timedelta(7)
 
2937
    True
 
2938
    >>> string_to_delta("60s") == datetime.timedelta(0, 60)
 
2939
    True
 
2940
    >>> string_to_delta("60m") == datetime.timedelta(0, 3600)
 
2941
    True
 
2942
    >>> string_to_delta("24h") == datetime.timedelta(1)
 
2943
    True
 
2944
    >>> string_to_delta("1w") == datetime.timedelta(7)
 
2945
    True
 
2946
    >>> string_to_delta("5m 30s") == datetime.timedelta(0, 330)
 
2947
    True
2750
2948
    """
2751
2949
 
2752
2950
    try:
2854
3052
 
2855
3053
    options = parser.parse_args()
2856
3054
 
2857
 
    if options.check:
2858
 
        import doctest
2859
 
        fail_count, test_count = doctest.testmod()
2860
 
        sys.exit(os.EX_OK if fail_count == 0 else 1)
2861
 
 
2862
3055
    # Default values for config file for server-global settings
 
3056
    if gnutls.has_rawpk:
 
3057
        priority = ("SECURE128:!CTYPE-X.509:+CTYPE-RAWPK:!RSA"
 
3058
                    ":!VERS-ALL:+VERS-TLS1.3:%PROFILE_ULTRA")
 
3059
    else:
 
3060
        priority = ("SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:!RSA"
 
3061
                    ":+SIGN-DSA-SHA256")
2863
3062
    server_defaults = {"interface": "",
2864
3063
                       "address": "",
2865
3064
                       "port": "",
2866
3065
                       "debug": "False",
2867
 
                       "priority":
2868
 
                       "SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:!RSA"
2869
 
                       ":+SIGN-DSA-SHA256",
 
3066
                       "priority": priority,
2870
3067
                       "servicename": "Mandos",
2871
3068
                       "use_dbus": "True",
2872
3069
                       "use_ipv6": "True",
2877
3074
                       "foreground": "False",
2878
3075
                       "zeroconf": "True",
2879
3076
                       }
 
3077
    del priority
2880
3078
 
2881
3079
    # Parse config file for server-global settings
2882
 
    server_config = configparser.SafeConfigParser(server_defaults)
 
3080
    server_config = configparser.ConfigParser(server_defaults)
2883
3081
    del server_defaults
2884
3082
    server_config.read(os.path.join(options.configdir, "mandos.conf"))
2885
 
    # Convert the SafeConfigParser object to a dict
 
3083
    # Convert the ConfigParser object to a dict
2886
3084
    server_settings = server_config.defaults()
2887
3085
    # Use the appropriate methods on the non-string config options
2888
3086
    for option in ("debug", "use_dbus", "use_ipv6", "restore",
2955
3153
 
2956
3154
    if server_settings["servicename"] != "Mandos":
2957
3155
        syslogger.setFormatter(
2958
 
            logging.Formatter('Mandos ({}) [%(process)d]:'
2959
 
                              ' %(levelname)s: %(message)s'.format(
 
3156
            logging.Formatter("Mandos ({}) [%(process)d]:"
 
3157
                              " %(levelname)s: %(message)s".format(
2960
3158
                                  server_settings["servicename"])))
2961
3159
 
2962
3160
    # Parse config file with clients
2963
 
    client_config = configparser.SafeConfigParser(Client
2964
 
                                                  .client_defaults)
 
3161
    client_config = configparser.ConfigParser(Client.client_defaults)
2965
3162
    client_config.read(os.path.join(server_settings["configdir"],
2966
3163
                                    "clients.conf"))
2967
3164
 
2987
3184
        try:
2988
3185
            pidfile = codecs.open(pidfilename, "w", encoding="utf-8")
2989
3186
        except IOError as e:
2990
 
            logger.error("Could not open file %r", pidfilename,
2991
 
                         exc_info=e)
 
3187
            log.error("Could not open file %r", pidfilename,
 
3188
                      exc_info=e)
2992
3189
 
2993
3190
    for name, group in (("_mandos", "_mandos"),
2994
3191
                        ("mandos", "mandos"),
3005
3202
    try:
3006
3203
        os.setgid(gid)
3007
3204
        os.setuid(uid)
3008
 
        if debug:
3009
 
            logger.debug("Did setuid/setgid to {}:{}".format(uid,
3010
 
                                                             gid))
 
3205
        log.debug("Did setuid/setgid to %s:%s", uid, gid)
3011
3206
    except OSError as error:
3012
 
        logger.warning("Failed to setuid/setgid to {}:{}: {}"
3013
 
                       .format(uid, gid, os.strerror(error.errno)))
 
3207
        log.warning("Failed to setuid/setgid to %s:%s: %s", uid, gid,
 
3208
                    os.strerror(error.errno))
3014
3209
        if error.errno != errno.EPERM:
3015
3210
            raise
3016
3211
 
3023
3218
 
3024
3219
        @gnutls.log_func
3025
3220
        def debug_gnutls(level, string):
3026
 
            logger.debug("GnuTLS: %s", string[:-1])
 
3221
            log.debug("GnuTLS: %s",
 
3222
                      string[:-1].decode("utf-8", errors="replace"))
3027
3223
 
3028
3224
        gnutls.global_set_log_function(debug_gnutls)
3029
3225
 
3038
3234
        # Close all input and output, do double fork, etc.
3039
3235
        daemon()
3040
3236
 
3041
 
    # multiprocessing will use threads, so before we use GLib we need
3042
 
    # to inform GLib that threads will be used.
3043
 
    GLib.threads_init()
 
3237
    if gi.version_info < (3, 10, 2):
 
3238
        # multiprocessing will use threads, so before we use GLib we
 
3239
        # need to inform GLib that threads will be used.
 
3240
        GLib.threads_init()
3044
3241
 
3045
3242
    global main_loop
3046
3243
    # From the Avahi example code
3057
3254
                "se.bsnet.fukt.Mandos", bus,
3058
3255
                do_not_queue=True)
3059
3256
        except dbus.exceptions.DBusException as e:
3060
 
            logger.error("Disabling D-Bus:", exc_info=e)
 
3257
            log.error("Disabling D-Bus:", exc_info=e)
3061
3258
            use_dbus = False
3062
3259
            server_settings["use_dbus"] = False
3063
3260
            tcp_server.use_dbus = False
3122
3319
                             if isinstance(s, bytes)
3123
3320
                             else s) for s in
3124
3321
                            value["client_structure"]]
3125
 
                        # .name & .host
3126
 
                        for k in ("name", "host"):
 
3322
                        # .name, .host, and .checker_command
 
3323
                        for k in ("name", "host", "checker_command"):
3127
3324
                            if isinstance(value[k], bytes):
3128
3325
                                value[k] = value[k].decode("utf-8")
 
3326
                        if "key_id" not in value:
 
3327
                            value["key_id"] = ""
 
3328
                        elif "fingerprint" not in value:
 
3329
                            value["fingerprint"] = ""
3129
3330
                    #  old_client_settings
3130
3331
                    # .keys()
3131
3332
                    old_client_settings = {
3135
3336
                        for key, value in
3136
3337
                        bytes_old_client_settings.items()}
3137
3338
                    del bytes_old_client_settings
3138
 
                    # .host
 
3339
                    # .host and .checker_command
3139
3340
                    for value in old_client_settings.values():
3140
 
                        if isinstance(value["host"], bytes):
3141
 
                            value["host"] = (value["host"]
3142
 
                                             .decode("utf-8"))
 
3341
                        for attribute in ("host", "checker_command"):
 
3342
                            if isinstance(value[attribute], bytes):
 
3343
                                value[attribute] = (value[attribute]
 
3344
                                                    .decode("utf-8"))
3143
3345
            os.remove(stored_state_path)
3144
3346
        except IOError as e:
3145
3347
            if e.errno == errno.ENOENT:
3146
 
                logger.warning("Could not load persistent state:"
3147
 
                               " {}".format(os.strerror(e.errno)))
 
3348
                log.warning("Could not load persistent state:"
 
3349
                            " %s", os.strerror(e.errno))
3148
3350
            else:
3149
 
                logger.critical("Could not load persistent state:",
3150
 
                                exc_info=e)
 
3351
                log.critical("Could not load persistent state:",
 
3352
                             exc_info=e)
3151
3353
                raise
3152
3354
        except EOFError as e:
3153
 
            logger.warning("Could not load persistent state: "
3154
 
                           "EOFError:",
3155
 
                           exc_info=e)
 
3355
            log.warning("Could not load persistent state: EOFError:",
 
3356
                        exc_info=e)
3156
3357
 
3157
3358
    with PGPEngine() as pgp:
3158
3359
        for client_name, client in clients_data.items():
3185
3386
            if client["enabled"]:
3186
3387
                if datetime.datetime.utcnow() >= client["expires"]:
3187
3388
                    if not client["last_checked_ok"]:
3188
 
                        logger.warning(
3189
 
                            "disabling client {} - Client never "
3190
 
                            "performed a successful checker".format(
3191
 
                                client_name))
 
3389
                        log.warning("disabling client %s - Client"
 
3390
                                    " never performed a successful"
 
3391
                                    " checker", client_name)
3192
3392
                        client["enabled"] = False
3193
3393
                    elif client["last_checker_status"] != 0:
3194
 
                        logger.warning(
3195
 
                            "disabling client {} - Client last"
3196
 
                            " checker failed with error code"
3197
 
                            " {}".format(
3198
 
                                client_name,
3199
 
                                client["last_checker_status"]))
 
3394
                        log.warning("disabling client %s - Client"
 
3395
                                    " last checker failed with error"
 
3396
                                    " code %s", client_name,
 
3397
                                    client["last_checker_status"])
3200
3398
                        client["enabled"] = False
3201
3399
                    else:
3202
3400
                        client["expires"] = (
3203
3401
                            datetime.datetime.utcnow()
3204
3402
                            + client["timeout"])
3205
 
                        logger.debug("Last checker succeeded,"
3206
 
                                     " keeping {} enabled".format(
3207
 
                                         client_name))
 
3403
                        log.debug("Last checker succeeded, keeping %s"
 
3404
                                  " enabled", client_name)
3208
3405
            try:
3209
3406
                client["secret"] = pgp.decrypt(
3210
3407
                    client["encrypted_secret"],
3211
3408
                    client_settings[client_name]["secret"])
3212
3409
            except PGPError:
3213
3410
                # If decryption fails, we use secret from new settings
3214
 
                logger.debug("Failed to decrypt {} old secret".format(
3215
 
                    client_name))
 
3411
                log.debug("Failed to decrypt %s old secret",
 
3412
                          client_name)
3216
3413
                client["secret"] = (client_settings[client_name]
3217
3414
                                    ["secret"])
3218
3415
 
3232
3429
            server_settings=server_settings)
3233
3430
 
3234
3431
    if not tcp_server.clients:
3235
 
        logger.warning("No clients defined")
 
3432
        log.warning("No clients defined")
3236
3433
 
3237
3434
    if not foreground:
3238
3435
        if pidfile is not None:
3241
3438
                with pidfile:
3242
3439
                    print(pid, file=pidfile)
3243
3440
            except IOError:
3244
 
                logger.error("Could not write to file %r with PID %d",
3245
 
                             pidfilename, pid)
 
3441
                log.error("Could not write to file %r with PID %d",
 
3442
                          pidfilename, pid)
3246
3443
        del pidfile
3247
3444
        del pidfilename
3248
3445
 
3268
3465
                pass
3269
3466
 
3270
3467
            @dbus.service.signal(_interface, signature="ss")
3271
 
            def ClientNotFound(self, fingerprint, address):
 
3468
            def ClientNotFound(self, key_id, address):
3272
3469
                "D-Bus signal"
3273
3470
                pass
3274
3471
 
3398
3595
 
3399
3596
        try:
3400
3597
            with tempfile.NamedTemporaryFile(
3401
 
                    mode='wb',
 
3598
                    mode="wb",
3402
3599
                    suffix=".pickle",
3403
 
                    prefix='clients-',
 
3600
                    prefix="clients-",
3404
3601
                    dir=os.path.dirname(stored_state_path),
3405
3602
                    delete=False) as stored_state:
3406
3603
                pickle.dump((clients, client_settings), stored_state,
3414
3611
                except NameError:
3415
3612
                    pass
3416
3613
            if e.errno in (errno.ENOENT, errno.EACCES, errno.EEXIST):
3417
 
                logger.warning("Could not save persistent state: {}"
3418
 
                               .format(os.strerror(e.errno)))
 
3614
                log.warning("Could not save persistent state: %s",
 
3615
                            os.strerror(e.errno))
3419
3616
            else:
3420
 
                logger.warning("Could not save persistent state:",
3421
 
                               exc_info=e)
 
3617
                log.warning("Could not save persistent state:",
 
3618
                            exc_info=e)
3422
3619
                raise
3423
3620
 
3424
3621
        # Delete all clients, and settings from config
3441
3638
            mandos_dbus_service.client_added_signal(client)
3442
3639
        # Need to initiate checking of clients
3443
3640
        if client.enabled:
3444
 
            client.init_checker()
 
3641
            client.init_checker(randomize_start=True)
3445
3642
 
3446
3643
    tcp_server.enable()
3447
3644
    tcp_server.server_activate()
3450
3647
    if zeroconf:
3451
3648
        service.port = tcp_server.socket.getsockname()[1]
3452
3649
    if use_ipv6:
3453
 
        logger.info("Now listening on address %r, port %d,"
3454
 
                    " flowinfo %d, scope_id %d",
3455
 
                    *tcp_server.socket.getsockname())
 
3650
        log.info("Now listening on address %r, port %d, flowinfo %d,"
 
3651
                 " scope_id %d", *tcp_server.socket.getsockname())
3456
3652
    else:                       # IPv4
3457
 
        logger.info("Now listening on address %r, port %d",
3458
 
                    *tcp_server.socket.getsockname())
 
3653
        log.info("Now listening on address %r, port %d",
 
3654
                 *tcp_server.socket.getsockname())
3459
3655
 
3460
3656
    # service.interface = tcp_server.socket.getsockname()[3]
3461
3657
 
3465
3661
            try:
3466
3662
                service.activate()
3467
3663
            except dbus.exceptions.DBusException as error:
3468
 
                logger.critical("D-Bus Exception", exc_info=error)
 
3664
                log.critical("D-Bus Exception", exc_info=error)
3469
3665
                cleanup()
3470
3666
                sys.exit(1)
3471
3667
            # End of Avahi example code
3472
3668
 
3473
 
        GLib.io_add_watch(tcp_server.fileno(), GLib.IO_IN,
3474
 
                          lambda *args, **kwargs:
3475
 
                          (tcp_server.handle_request
3476
 
                           (*args[2:], **kwargs) or True))
 
3669
        GLib.io_add_watch(
 
3670
            GLib.IOChannel.unix_new(tcp_server.fileno()),
 
3671
            GLib.PRIORITY_DEFAULT, GLib.IO_IN,
 
3672
            lambda *args, **kwargs: (tcp_server.handle_request
 
3673
                                     (*args[2:], **kwargs) or True))
3477
3674
 
3478
 
        logger.debug("Starting main loop")
 
3675
        log.debug("Starting main loop")
3479
3676
        main_loop.run()
3480
3677
    except AvahiError as error:
3481
 
        logger.critical("Avahi Error", exc_info=error)
 
3678
        log.critical("Avahi Error", exc_info=error)
3482
3679
        cleanup()
3483
3680
        sys.exit(1)
3484
3681
    except KeyboardInterrupt:
3485
3682
        if debug:
3486
3683
            print("", file=sys.stderr)
3487
 
        logger.debug("Server received KeyboardInterrupt")
3488
 
    logger.debug("Server exiting")
 
3684
        log.debug("Server received KeyboardInterrupt")
 
3685
    log.debug("Server exiting")
3489
3686
    # Must run before the D-Bus bus name gets deregistered
3490
3687
    cleanup()
3491
3688
 
3492
 
 
3493
 
if __name__ == '__main__':
3494
 
    main()
 
3689
 
 
3690
def parse_test_args():
 
3691
    # type: () -> argparse.Namespace
 
3692
    parser = argparse.ArgumentParser(add_help=False)
 
3693
    parser.add_argument("--check", action="store_true")
 
3694
    parser.add_argument("--prefix", )
 
3695
    args, unknown_args = parser.parse_known_args()
 
3696
    if args.check:
 
3697
        # Remove test options from sys.argv
 
3698
        sys.argv[1:] = unknown_args
 
3699
    return args
 
3700
 
 
3701
# Add all tests from doctest strings
 
3702
def load_tests(loader, tests, none):
 
3703
    import doctest
 
3704
    tests.addTests(doctest.DocTestSuite())
 
3705
    return tests
 
3706
 
 
3707
if __name__ == "__main__":
 
3708
    options = parse_test_args()
 
3709
    try:
 
3710
        if options.check:
 
3711
            extra_test_prefix = options.prefix
 
3712
            if extra_test_prefix is not None:
 
3713
                if not (unittest.main(argv=[""], exit=False)
 
3714
                        .result.wasSuccessful()):
 
3715
                    sys.exit(1)
 
3716
                class ExtraTestLoader(unittest.TestLoader):
 
3717
                    testMethodPrefix = extra_test_prefix
 
3718
                # Call using ./scriptname --test [--verbose]
 
3719
                unittest.main(argv=[""], testLoader=ExtraTestLoader())
 
3720
            else:
 
3721
                unittest.main(argv=[""])
 
3722
        else:
 
3723
            main()
 
3724
    finally:
 
3725
        logging.shutdown()
 
3726
 
 
3727
# Local Variables:
 
3728
# run-tests:
 
3729
# (lambda (&optional extra)
 
3730
#   (if (not (funcall run-tests-in-test-buffer default-directory
 
3731
#             extra))
 
3732
#       (funcall show-test-buffer-in-test-window)
 
3733
#     (funcall remove-test-window)
 
3734
#     (if extra (message "Extra tests run successfully!"))))
 
3735
# run-tests-in-test-buffer:
 
3736
# (lambda (dir &optional extra)
 
3737
#   (with-current-buffer (get-buffer-create "*Test*")
 
3738
#     (setq buffer-read-only nil
 
3739
#           default-directory dir)
 
3740
#     (erase-buffer)
 
3741
#     (compilation-mode))
 
3742
#   (let ((process-result
 
3743
#          (let ((inhibit-read-only t))
 
3744
#            (process-file-shell-command
 
3745
#             (funcall get-command-line extra) nil "*Test*"))))
 
3746
#     (and (numberp process-result)
 
3747
#          (= process-result 0))))
 
3748
# get-command-line:
 
3749
# (lambda (&optional extra)
 
3750
#   (let ((quoted-script
 
3751
#          (shell-quote-argument (funcall get-script-name))))
 
3752
#     (format
 
3753
#      (concat "%s --check" (if extra " --prefix=atest" ""))
 
3754
#      quoted-script)))
 
3755
# get-script-name:
 
3756
# (lambda ()
 
3757
#   (if (fboundp 'file-local-name)
 
3758
#       (file-local-name (buffer-file-name))
 
3759
#     (or (file-remote-p (buffer-file-name) 'localname)
 
3760
#         (buffer-file-name))))
 
3761
# remove-test-window:
 
3762
# (lambda ()
 
3763
#   (let ((test-window (get-buffer-window "*Test*")))
 
3764
#     (if test-window (delete-window test-window))))
 
3765
# show-test-buffer-in-test-window:
 
3766
# (lambda ()
 
3767
#   (when (not (get-buffer-window-list "*Test*"))
 
3768
#     (setq next-error-last-buffer (get-buffer "*Test*"))
 
3769
#     (let* ((side (if (>= (window-width) 146) 'right 'bottom))
 
3770
#            (display-buffer-overriding-action
 
3771
#             `((display-buffer-in-side-window) (side . ,side)
 
3772
#               (window-height . fit-window-to-buffer)
 
3773
#               (window-width . fit-window-to-buffer))))
 
3774
#       (display-buffer "*Test*"))))
 
3775
# eval:
 
3776
# (progn
 
3777
#   (let* ((run-extra-tests (lambda () (interactive)
 
3778
#                             (funcall run-tests t)))
 
3779
#          (inner-keymap `(keymap (116 . ,run-extra-tests))) ; t
 
3780
#          (outer-keymap `(keymap (3 . ,inner-keymap))))     ; C-c
 
3781
#     (setq minor-mode-overriding-map-alist
 
3782
#           (cons `(run-tests . ,outer-keymap)
 
3783
#                 minor-mode-overriding-map-alist)))
 
3784
#   (add-hook 'after-save-hook run-tests 90 t))
 
3785
# End: