/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 17:40:26 UTC
  • Revision ID: teddy@recompile.se-20240908174026-yk98lyrpr0phsck1
Fix minor deprecated syntax issue in debian/control

The << syntax should be preferred to the deprecated < notation.

* debian/control (Source: mandos/Build-Depends): Change from having
  "systemd (< 256~rc2-1)" to "systemd (<< 256~rc2-1)".

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-2016 Teddy Hogeborn
15
 
# Copyright © 2008-2016 Björn Påhlsson
16
 
#
17
 
# This program is free software: you can redistribute it and/or modify
18
 
# it under the terms of the GNU General Public License as published by
 
14
# Copyright © 2008-2022 Teddy Hogeborn
 
15
# Copyright © 2008-2022 Björn Påhlsson
 
16
#
 
17
# This file is part of Mandos.
 
18
#
 
19
# Mandos is free software: you can redistribute it and/or modify it
 
20
# under the terms of the GNU General Public License as published by
19
21
# the Free Software Foundation, either version 3 of the License, or
20
22
# (at your option) any later version.
21
23
#
22
 
#     This program is distributed in the hope that it will be useful,
23
 
#     but WITHOUT ANY WARRANTY; without even the implied warranty of
 
24
#     Mandos is distributed in the hope that it will be useful, but
 
25
#     WITHOUT ANY WARRANTY; without even the implied warranty of
24
26
#     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
25
27
#     GNU General Public License for more details.
26
28
#
27
29
# You should have received a copy of the GNU General Public License
28
 
# along with this program.  If not, see
29
 
# <http://www.gnu.org/licenses/>.
 
30
# along with Mandos.  If not, see <http://www.gnu.org/licenses/>.
30
31
#
31
32
# Contact the authors at <mandos@recompile.se>.
32
33
#
33
 
 
34
34
from __future__ import (division, absolute_import, print_function,
35
35
                        unicode_literals)
36
36
 
39
39
except ImportError:
40
40
    pass
41
41
 
 
42
import sys
 
43
import unittest
 
44
import argparse
 
45
import logging
 
46
import os
42
47
try:
43
48
    import SocketServer as socketserver
44
49
except ImportError:
45
50
    import socketserver
46
51
import socket
47
 
import argparse
48
52
import datetime
49
53
import errno
50
54
try:
51
55
    import ConfigParser as configparser
52
56
except ImportError:
53
57
    import configparser
54
 
import sys
55
58
import re
56
 
import os
57
59
import signal
58
60
import subprocess
59
61
import atexit
60
62
import stat
61
 
import logging
62
63
import logging.handlers
63
64
import pwd
64
65
import contextlib
76
77
import itertools
77
78
import collections
78
79
import codecs
 
80
import random
 
81
import shlex
79
82
 
80
83
import dbus
81
84
import dbus.service
 
85
import gi
82
86
from gi.repository import GLib
83
87
from dbus.mainloop.glib import DBusGMainLoop
84
88
import ctypes
86
90
import xml.dom.minidom
87
91
import inspect
88
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
 
89
118
# Try to find the value of SO_BINDTODEVICE:
90
119
try:
91
120
    # This is where SO_BINDTODEVICE is in Python 3.3 (or 3.4?) and
111
140
            # No value found
112
141
            SO_BINDTODEVICE = None
113
142
 
114
 
if sys.version_info.major == 2:
115
 
    str = unicode
 
143
if sys.version_info < (3, 2):
 
144
    configparser.Configparser = configparser.SafeConfigParser
116
145
 
117
 
version = "1.7.10"
 
146
version = "1.8.16"
118
147
stored_state_file = "clients.pickle"
119
148
 
120
 
logger = logging.getLogger()
 
149
log = logging.getLogger(os.path.basename(sys.argv[0]))
 
150
logging.captureWarnings(True)   # Show warnings via the logging system
121
151
syslogger = None
122
152
 
123
153
try:
159
189
        facility=logging.handlers.SysLogHandler.LOG_DAEMON,
160
190
        address="/dev/log"))
161
191
    syslogger.setFormatter(logging.Formatter
162
 
                           ('Mandos [%(process)d]: %(levelname)s:'
163
 
                            ' %(message)s'))
164
 
    logger.addHandler(syslogger)
 
192
                           ("Mandos [%(process)d]: %(levelname)s:"
 
193
                            " %(message)s"))
 
194
    log.addHandler(syslogger)
165
195
 
166
196
    if debug:
167
197
        console = logging.StreamHandler()
168
 
        console.setFormatter(logging.Formatter('%(asctime)s %(name)s'
169
 
                                               ' [%(process)d]:'
170
 
                                               ' %(levelname)s:'
171
 
                                               ' %(message)s'))
172
 
        logger.addHandler(console)
173
 
    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)
174
204
 
175
205
 
176
206
class PGPError(Exception):
178
208
    pass
179
209
 
180
210
 
181
 
class PGPEngine(object):
 
211
class PGPEngine:
182
212
    """A simple class for OpenPGP symmetric encryption & decryption"""
183
213
 
184
214
    def __init__(self):
188
218
            output = subprocess.check_output(["gpgconf"])
189
219
            for line in output.splitlines():
190
220
                name, text, path = line.split(b":")
191
 
                if name == "gpg":
 
221
                if name == b"gpg":
192
222
                    self.gpg = path
193
223
                    break
194
224
        except OSError as e:
195
225
            if e.errno != errno.ENOENT:
196
226
                raise
197
 
        self.gnupgargs = ['--batch',
198
 
                          '--homedir', self.tempdir,
199
 
                          '--force-mdc',
200
 
                          '--quiet']
 
227
        self.gnupgargs = ["--batch",
 
228
                          "--homedir", self.tempdir,
 
229
                          "--force-mdc",
 
230
                          "--quiet"]
201
231
        # Only GPG version 1 has the --no-use-agent option.
202
 
        if self.gpg == "gpg" or self.gpg.endswith("/gpg"):
 
232
        if self.gpg == b"gpg" or self.gpg.endswith(b"/gpg"):
203
233
            self.gnupgargs.append("--no-use-agent")
204
234
 
205
235
    def __enter__(self):
242
272
                dir=self.tempdir) as passfile:
243
273
            passfile.write(passphrase)
244
274
            passfile.flush()
245
 
            proc = subprocess.Popen([self.gpg, '--symmetric',
246
 
                                     '--passphrase-file',
 
275
            proc = subprocess.Popen([self.gpg, "--symmetric",
 
276
                                     "--passphrase-file",
247
277
                                     passfile.name]
248
278
                                    + self.gnupgargs,
249
279
                                    stdin=subprocess.PIPE,
260
290
                dir=self.tempdir) as passfile:
261
291
            passfile.write(passphrase)
262
292
            passfile.flush()
263
 
            proc = subprocess.Popen([self.gpg, '--decrypt',
264
 
                                     '--passphrase-file',
 
293
            proc = subprocess.Popen([self.gpg, "--decrypt",
 
294
                                     "--passphrase-file",
265
295
                                     passfile.name]
266
296
                                    + self.gnupgargs,
267
297
                                    stdin=subprocess.PIPE,
274
304
 
275
305
 
276
306
# Pretend that we have an Avahi module
277
 
class Avahi(object):
278
 
    """This isn't so much a class as it is a module-like namespace.
279
 
    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."""
280
309
    IF_UNSPEC = -1               # avahi-common/address.h
281
310
    PROTO_UNSPEC = -1            # avahi-common/address.h
282
311
    PROTO_INET = 0               # avahi-common/address.h
286
315
    DBUS_INTERFACE_SERVER = DBUS_NAME + ".Server"
287
316
    DBUS_PATH_SERVER = "/"
288
317
 
289
 
    def string_array_to_txt_array(self, t):
 
318
    @staticmethod
 
319
    def string_array_to_txt_array(t):
290
320
        return dbus.Array((dbus.ByteArray(s.encode("utf-8"))
291
321
                           for s in t), signature="ay")
292
322
    ENTRY_GROUP_ESTABLISHED = 2  # avahi-common/defs.h
297
327
    SERVER_RUNNING = 2           # avahi-common/defs.h
298
328
    SERVER_COLLISION = 3         # avahi-common/defs.h
299
329
    SERVER_FAILURE = 4           # avahi-common/defs.h
300
 
avahi = Avahi()
301
330
 
302
331
 
303
332
class AvahiError(Exception):
315
344
    pass
316
345
 
317
346
 
318
 
class AvahiService(object):
 
347
class AvahiService:
319
348
    """An Avahi (Zeroconf) service.
320
349
 
321
350
    Attributes:
322
351
    interface: integer; avahi.IF_UNSPEC or an interface index.
323
352
               Used to optionally bind to the specified interface.
324
 
    name: string; Example: 'Mandos'
325
 
    type: string; Example: '_mandos._tcp'.
 
353
    name: string; Example: "Mandos"
 
354
    type: string; Example: "_mandos._tcp".
326
355
     See <https://www.iana.org/assignments/service-names-port-numbers>
327
356
    port: integer; what port to announce
328
357
    TXT: list of strings; TXT record for the service
365
394
    def rename(self, remove=True):
366
395
        """Derived from the Avahi example code"""
367
396
        if self.rename_count >= self.max_renames:
368
 
            logger.critical("No suitable Zeroconf service name found"
369
 
                            " after %i retries, exiting.",
370
 
                            self.rename_count)
 
397
            log.critical("No suitable Zeroconf service name found"
 
398
                         " after %i retries, exiting.",
 
399
                         self.rename_count)
371
400
            raise AvahiServiceError("Too many renames")
372
401
        self.name = str(
373
402
            self.server.GetAlternativeServiceName(self.name))
374
403
        self.rename_count += 1
375
 
        logger.info("Changing Zeroconf service name to %r ...",
376
 
                    self.name)
 
404
        log.info("Changing Zeroconf service name to %r ...",
 
405
                 self.name)
377
406
        if remove:
378
407
            self.remove()
379
408
        try:
381
410
        except dbus.exceptions.DBusException as error:
382
411
            if (error.get_dbus_name()
383
412
                == "org.freedesktop.Avahi.CollisionError"):
384
 
                logger.info("Local Zeroconf service name collision.")
 
413
                log.info("Local Zeroconf service name collision.")
385
414
                return self.rename(remove=False)
386
415
            else:
387
 
                logger.critical("D-Bus Exception", exc_info=error)
 
416
                log.critical("D-Bus Exception", exc_info=error)
388
417
                self.cleanup()
389
418
                os._exit(1)
390
419
 
406
435
                avahi.DBUS_INTERFACE_ENTRY_GROUP)
407
436
        self.entry_group_state_changed_match = (
408
437
            self.group.connect_to_signal(
409
 
                'StateChanged', self.entry_group_state_changed))
410
 
        logger.debug("Adding Zeroconf service '%s' of type '%s' ...",
411
 
                     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)
412
441
        self.group.AddService(
413
442
            self.interface,
414
443
            self.protocol,
421
450
 
422
451
    def entry_group_state_changed(self, state, error):
423
452
        """Derived from the Avahi example code"""
424
 
        logger.debug("Avahi entry group state change: %i", state)
 
453
        log.debug("Avahi entry group state change: %i", state)
425
454
 
426
455
        if state == avahi.ENTRY_GROUP_ESTABLISHED:
427
 
            logger.debug("Zeroconf service established.")
 
456
            log.debug("Zeroconf service established.")
428
457
        elif state == avahi.ENTRY_GROUP_COLLISION:
429
 
            logger.info("Zeroconf service name collision.")
 
458
            log.info("Zeroconf service name collision.")
430
459
            self.rename()
431
460
        elif state == avahi.ENTRY_GROUP_FAILURE:
432
 
            logger.critical("Avahi: Error in group state changed %s",
433
 
                            str(error))
 
461
            log.critical("Avahi: Error in group state changed %s",
 
462
                         str(error))
434
463
            raise AvahiGroupError("State changed: {!s}".format(error))
435
464
 
436
465
    def cleanup(self):
446
475
 
447
476
    def server_state_changed(self, state, error=None):
448
477
        """Derived from the Avahi example code"""
449
 
        logger.debug("Avahi server state change: %i", state)
 
478
        log.debug("Avahi server state change: %i", state)
450
479
        bad_states = {
451
480
            avahi.SERVER_INVALID: "Zeroconf server invalid",
452
481
            avahi.SERVER_REGISTERING: None,
456
485
        if state in bad_states:
457
486
            if bad_states[state] is not None:
458
487
                if error is None:
459
 
                    logger.error(bad_states[state])
 
488
                    log.error(bad_states[state])
460
489
                else:
461
 
                    logger.error(bad_states[state] + ": %r", error)
 
490
                    log.error(bad_states[state] + ": %r", error)
462
491
            self.cleanup()
463
492
        elif state == avahi.SERVER_RUNNING:
464
493
            try:
466
495
            except dbus.exceptions.DBusException as error:
467
496
                if (error.get_dbus_name()
468
497
                    == "org.freedesktop.Avahi.CollisionError"):
469
 
                    logger.info("Local Zeroconf service name"
470
 
                                " collision.")
 
498
                    log.info("Local Zeroconf service name collision.")
471
499
                    return self.rename(remove=False)
472
500
                else:
473
 
                    logger.critical("D-Bus Exception", exc_info=error)
 
501
                    log.critical("D-Bus Exception", exc_info=error)
474
502
                    self.cleanup()
475
503
                    os._exit(1)
476
504
        else:
477
505
            if error is None:
478
 
                logger.debug("Unknown state: %r", state)
 
506
                log.debug("Unknown state: %r", state)
479
507
            else:
480
 
                logger.debug("Unknown state: %r: %r", state, error)
 
508
                log.debug("Unknown state: %r: %r", state, error)
481
509
 
482
510
    def activate(self):
483
511
        """Derived from the Avahi example code"""
495
523
class AvahiServiceToSyslog(AvahiService):
496
524
    def rename(self, *args, **kwargs):
497
525
        """Add the new name to the syslog messages"""
498
 
        ret = AvahiService.rename(self, *args, **kwargs)
 
526
        ret = super(AvahiServiceToSyslog, self).rename(*args,
 
527
                                                       **kwargs)
499
528
        syslogger.setFormatter(logging.Formatter(
500
 
            'Mandos ({}) [%(process)d]: %(levelname)s: %(message)s'
 
529
            "Mandos ({}) [%(process)d]: %(levelname)s: %(message)s"
501
530
            .format(self.name)))
502
531
        return ret
503
532
 
504
533
 
505
534
# Pretend that we have a GnuTLS module
506
 
class GnuTLS(object):
507
 
    """This isn't so much a class as it is a module-like namespace.
508
 
    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."""
509
537
 
510
538
    library = ctypes.util.find_library("gnutls")
511
539
    if library is None:
512
540
        library = ctypes.util.find_library("gnutls-deb0")
513
541
    _library = ctypes.cdll.LoadLibrary(library)
514
542
    del library
515
 
    _need_version = b"3.3.0"
516
 
 
517
 
    def __init__(self):
518
 
        # Need to use class name "GnuTLS" here, since this method is
519
 
        # called before the assignment to the "gnutls" global variable
520
 
        # happens.
521
 
        if GnuTLS.check_version(self._need_version) is None:
522
 
            raise GnuTLS.Error("Needs GnuTLS {} or later"
523
 
                               .format(self._need_version))
524
543
 
525
544
    # Unless otherwise indicated, the constants and types below are
526
545
    # all from the gnutls/gnutls.h C header file.
530
549
    E_INTERRUPTED = -52
531
550
    E_AGAIN = -28
532
551
    CRT_OPENPGP = 2
 
552
    CRT_RAWPK = 3
533
553
    CLIENT = 2
534
554
    SHUT_RDWR = 0
535
555
    CRD_CERTIFICATE = 1
536
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
537
562
    OPENPGP_FMT_RAW = 0         # gnutls/openpgp.h
538
563
 
539
564
    # Types
540
 
    class session_int(ctypes.Structure):
 
565
    class _session_int(ctypes.Structure):
541
566
        _fields_ = []
542
 
    session_t = ctypes.POINTER(session_int)
 
567
    session_t = ctypes.POINTER(_session_int)
543
568
 
544
569
    class certificate_credentials_st(ctypes.Structure):
545
570
        _fields_ = []
548
573
    certificate_type_t = ctypes.c_int
549
574
 
550
575
    class datum_t(ctypes.Structure):
551
 
        _fields_ = [('data', ctypes.POINTER(ctypes.c_ubyte)),
552
 
                    ('size', ctypes.c_uint)]
 
576
        _fields_ = [("data", ctypes.POINTER(ctypes.c_ubyte)),
 
577
                    ("size", ctypes.c_uint)]
553
578
 
554
 
    class openpgp_crt_int(ctypes.Structure):
 
579
    class _openpgp_crt_int(ctypes.Structure):
555
580
        _fields_ = []
556
 
    openpgp_crt_t = ctypes.POINTER(openpgp_crt_int)
 
581
    openpgp_crt_t = ctypes.POINTER(_openpgp_crt_int)
557
582
    openpgp_crt_fmt_t = ctypes.c_int  # gnutls/openpgp.h
558
583
    log_func = ctypes.CFUNCTYPE(None, ctypes.c_int, ctypes.c_char_p)
559
584
    credentials_type_t = ctypes.c_int
562
587
 
563
588
    # Exceptions
564
589
    class Error(Exception):
565
 
        # We need to use the class name "GnuTLS" here, since this
566
 
        # exception might be raised from within GnuTLS.__init__,
567
 
        # which is called before the assignment to the "gnutls"
568
 
        # global variable has happened.
569
590
        def __init__(self, message=None, code=None, args=()):
570
591
            # Default usage is by a message string, but if a return
571
592
            # code is passed, convert it to a string with
572
593
            # gnutls.strerror()
573
594
            self.code = code
574
595
            if message is None and code is not None:
575
 
                message = GnuTLS.strerror(code)
576
 
            return super(GnuTLS.Error, self).__init__(
 
596
                message = gnutls.strerror(code).decode(
 
597
                    "utf-8", errors="replace")
 
598
            return super(gnutls.Error, self).__init__(
577
599
                message, *args)
578
600
 
579
601
    class CertificateSecurityError(Error):
580
602
        pass
581
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
 
582
629
    # Classes
583
 
    class Credentials(object):
 
630
    class Credentials(With_from_param):
584
631
        def __init__(self):
585
 
            self._c_object = gnutls.certificate_credentials_t()
586
 
            gnutls.certificate_allocate_credentials(
587
 
                ctypes.byref(self._c_object))
 
632
            self._as_parameter_ = gnutls.certificate_credentials_t()
 
633
            gnutls.certificate_allocate_credentials(self)
588
634
            self.type = gnutls.CRD_CERTIFICATE
589
635
 
590
636
        def __del__(self):
591
 
            gnutls.certificate_free_credentials(self._c_object)
 
637
            gnutls.certificate_free_credentials(self)
592
638
 
593
 
    class ClientSession(object):
 
639
    class ClientSession(With_from_param):
594
640
        def __init__(self, socket, credentials=None):
595
 
            self._c_object = gnutls.session_t()
596
 
            gnutls.init(ctypes.byref(self._c_object), gnutls.CLIENT)
597
 
            gnutls.set_default_priority(self._c_object)
598
 
            gnutls.transport_set_ptr(self._c_object, socket.fileno())
599
 
            gnutls.handshake_set_private_extensions(self._c_object,
600
 
                                                    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)
601
652
            self.socket = socket
602
653
            if credentials is None:
603
654
                credentials = gnutls.Credentials()
604
 
            gnutls.credentials_set(self._c_object, credentials.type,
605
 
                                   ctypes.cast(credentials._c_object,
606
 
                                               ctypes.c_void_p))
 
655
            gnutls.credentials_set(self, credentials.type,
 
656
                                   credentials)
607
657
            self.credentials = credentials
608
658
 
609
659
        def __del__(self):
610
 
            gnutls.deinit(self._c_object)
 
660
            gnutls.deinit(self)
611
661
 
612
662
        def handshake(self):
613
 
            return gnutls.handshake(self._c_object)
 
663
            return gnutls.handshake(self)
614
664
 
615
665
        def send(self, data):
616
666
            data = bytes(data)
617
667
            data_len = len(data)
618
668
            while data_len > 0:
619
 
                data_len -= gnutls.record_send(self._c_object,
620
 
                                               data[-data_len:],
 
669
                data_len -= gnutls.record_send(self, data[-data_len:],
621
670
                                               data_len)
622
671
 
623
672
        def bye(self):
624
 
            return gnutls.bye(self._c_object, gnutls.SHUT_RDWR)
 
673
            return gnutls.bye(self, gnutls.SHUT_RDWR)
625
674
 
626
675
    # Error handling functions
627
676
    def _error_code(result):
628
677
        """A function to raise exceptions on errors, suitable
629
 
        for the 'restype' attribute on ctypes functions"""
630
 
        if result >= 0:
 
678
        for the "restype" attribute on ctypes functions"""
 
679
        if result >= gnutls.E_SUCCESS:
631
680
            return result
632
681
        if result == gnutls.E_NO_CERTIFICATE_FOUND:
633
682
            raise gnutls.CertificateSecurityError(code=result)
634
683
        raise gnutls.Error(code=result)
635
684
 
636
 
    def _retry_on_error(result, func, arguments):
 
685
    def _retry_on_error(result, func, arguments,
 
686
                        _error_code=_error_code):
637
687
        """A function to retry on some errors, suitable
638
 
        for the 'errcheck' attribute on ctypes functions"""
639
 
        while result < 0:
 
688
        for the "errcheck" attribute on ctypes functions"""
 
689
        while result < gnutls.E_SUCCESS:
640
690
            if result not in (gnutls.E_INTERRUPTED, gnutls.E_AGAIN):
641
691
                return _error_code(result)
642
692
            result = func(*arguments)
647
697
 
648
698
    # Functions
649
699
    priority_set_direct = _library.gnutls_priority_set_direct
650
 
    priority_set_direct.argtypes = [session_t, ctypes.c_char_p,
 
700
    priority_set_direct.argtypes = [ClientSession, ctypes.c_char_p,
651
701
                                    ctypes.POINTER(ctypes.c_char_p)]
652
702
    priority_set_direct.restype = _error_code
653
703
 
654
704
    init = _library.gnutls_init
655
 
    init.argtypes = [ctypes.POINTER(session_t), ctypes.c_int]
 
705
    init.argtypes = [PointerTo(ClientSession), ctypes.c_int]
656
706
    init.restype = _error_code
657
707
 
658
708
    set_default_priority = _library.gnutls_set_default_priority
659
 
    set_default_priority.argtypes = [session_t]
 
709
    set_default_priority.argtypes = [ClientSession]
660
710
    set_default_priority.restype = _error_code
661
711
 
662
712
    record_send = _library.gnutls_record_send
663
 
    record_send.argtypes = [session_t, ctypes.c_void_p,
 
713
    record_send.argtypes = [ClientSession, ctypes.c_void_p,
664
714
                            ctypes.c_size_t]
665
715
    record_send.restype = ctypes.c_ssize_t
666
716
    record_send.errcheck = _retry_on_error
668
718
    certificate_allocate_credentials = (
669
719
        _library.gnutls_certificate_allocate_credentials)
670
720
    certificate_allocate_credentials.argtypes = [
671
 
        ctypes.POINTER(certificate_credentials_t)]
 
721
        PointerTo(Credentials)]
672
722
    certificate_allocate_credentials.restype = _error_code
673
723
 
674
724
    certificate_free_credentials = (
675
725
        _library.gnutls_certificate_free_credentials)
676
 
    certificate_free_credentials.argtypes = [
677
 
        certificate_credentials_t]
 
726
    certificate_free_credentials.argtypes = [Credentials]
678
727
    certificate_free_credentials.restype = None
679
728
 
680
729
    handshake_set_private_extensions = (
681
730
        _library.gnutls_handshake_set_private_extensions)
682
 
    handshake_set_private_extensions.argtypes = [session_t,
 
731
    handshake_set_private_extensions.argtypes = [ClientSession,
683
732
                                                 ctypes.c_int]
684
733
    handshake_set_private_extensions.restype = None
685
734
 
686
735
    credentials_set = _library.gnutls_credentials_set
687
 
    credentials_set.argtypes = [session_t, credentials_type_t,
688
 
                                ctypes.c_void_p]
 
736
    credentials_set.argtypes = [ClientSession, credentials_type_t,
 
737
                                CastToVoidPointer(Credentials)]
689
738
    credentials_set.restype = _error_code
690
739
 
691
740
    strerror = _library.gnutls_strerror
693
742
    strerror.restype = ctypes.c_char_p
694
743
 
695
744
    certificate_type_get = _library.gnutls_certificate_type_get
696
 
    certificate_type_get.argtypes = [session_t]
 
745
    certificate_type_get.argtypes = [ClientSession]
697
746
    certificate_type_get.restype = _error_code
698
747
 
699
748
    certificate_get_peers = _library.gnutls_certificate_get_peers
700
 
    certificate_get_peers.argtypes = [session_t,
 
749
    certificate_get_peers.argtypes = [ClientSession,
701
750
                                      ctypes.POINTER(ctypes.c_uint)]
702
751
    certificate_get_peers.restype = ctypes.POINTER(datum_t)
703
752
 
710
759
    global_set_log_function.restype = None
711
760
 
712
761
    deinit = _library.gnutls_deinit
713
 
    deinit.argtypes = [session_t]
 
762
    deinit.argtypes = [ClientSession]
714
763
    deinit.restype = None
715
764
 
716
765
    handshake = _library.gnutls_handshake
717
 
    handshake.argtypes = [session_t]
718
 
    handshake.restype = _error_code
 
766
    handshake.argtypes = [ClientSession]
 
767
    handshake.restype = ctypes.c_int
719
768
    handshake.errcheck = _retry_on_error
720
769
 
721
770
    transport_set_ptr = _library.gnutls_transport_set_ptr
722
 
    transport_set_ptr.argtypes = [session_t, transport_ptr_t]
 
771
    transport_set_ptr.argtypes = [ClientSession, transport_ptr_t]
723
772
    transport_set_ptr.restype = None
724
773
 
725
774
    bye = _library.gnutls_bye
726
 
    bye.argtypes = [session_t, close_request_t]
727
 
    bye.restype = _error_code
 
775
    bye.argtypes = [ClientSession, close_request_t]
 
776
    bye.restype = ctypes.c_int
728
777
    bye.errcheck = _retry_on_error
729
778
 
730
779
    check_version = _library.gnutls_check_version
731
780
    check_version.argtypes = [ctypes.c_char_p]
732
781
    check_version.restype = ctypes.c_char_p
733
782
 
734
 
    # All the function declarations below are from gnutls/openpgp.h
735
 
 
736
 
    openpgp_crt_init = _library.gnutls_openpgp_crt_init
737
 
    openpgp_crt_init.argtypes = [ctypes.POINTER(openpgp_crt_t)]
738
 
    openpgp_crt_init.restype = _error_code
739
 
 
740
 
    openpgp_crt_import = _library.gnutls_openpgp_crt_import
741
 
    openpgp_crt_import.argtypes = [openpgp_crt_t,
742
 
                                   ctypes.POINTER(datum_t),
743
 
                                   openpgp_crt_fmt_t]
744
 
    openpgp_crt_import.restype = _error_code
745
 
 
746
 
    openpgp_crt_verify_self = _library.gnutls_openpgp_crt_verify_self
747
 
    openpgp_crt_verify_self.argtypes = [openpgp_crt_t, ctypes.c_uint,
748
 
                                        ctypes.POINTER(ctypes.c_uint)]
749
 
    openpgp_crt_verify_self.restype = _error_code
750
 
 
751
 
    openpgp_crt_deinit = _library.gnutls_openpgp_crt_deinit
752
 
    openpgp_crt_deinit.argtypes = [openpgp_crt_t]
753
 
    openpgp_crt_deinit.restype = None
754
 
 
755
 
    openpgp_crt_get_fingerprint = (
756
 
        _library.gnutls_openpgp_crt_get_fingerprint)
757
 
    openpgp_crt_get_fingerprint.argtypes = [openpgp_crt_t,
758
 
                                            ctypes.c_void_p,
759
 
                                            ctypes.POINTER(
760
 
                                                ctypes.c_size_t)]
761
 
    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
762
858
 
763
859
    # Remove non-public functions
764
860
    del _error_code, _retry_on_error
765
 
# Create the global "gnutls" object, simulating a module
766
 
gnutls = GnuTLS()
767
861
 
768
862
 
769
863
def call_pipe(connection,       # : multiprocessing.Connection
777
871
    connection.close()
778
872
 
779
873
 
780
 
class Client(object):
 
874
class Client:
781
875
    """A representation of a client host served by this server.
782
876
 
783
877
    Attributes:
784
 
    approved:   bool(); 'None' if not yet approved/disapproved
 
878
    approved:   bool(); None if not yet approved/disapproved
785
879
    approval_delay: datetime.timedelta(); Time to wait for approval
786
880
    approval_duration: datetime.timedelta(); Duration of one approval
787
 
    checker:    subprocess.Popen(); a running checker process used
788
 
                                    to see if the client lives.
789
 
                                    '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.
790
884
    checker_callback_tag: a GLib event source tag, or None
791
885
    checker_command: string; External command which is run to check
792
886
                     if client lives.  %() expansions are done at
800
894
    disable_initiator_tag: a GLib event source tag, or None
801
895
    enabled:    bool()
802
896
    fingerprint: string (40 or 32 hexadecimal digits); used to
803
 
                 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
804
900
    host:       string; available for use by the checker command
805
901
    interval:   datetime.timedelta(); How often to start a new checker
806
902
    last_approval_request: datetime.datetime(); (UTC) or None
824
920
    """
825
921
 
826
922
    runtime_expansions = ("approval_delay", "approval_duration",
827
 
                          "created", "enabled", "expires",
 
923
                          "created", "enabled", "expires", "key_id",
828
924
                          "fingerprint", "host", "interval",
829
925
                          "last_approval_request", "last_checked_ok",
830
926
                          "last_enabled", "name", "timeout")
860
956
            client["enabled"] = config.getboolean(client_name,
861
957
                                                  "enabled")
862
958
 
863
 
            # Uppercase and remove spaces from fingerprint for later
864
 
            # comparison purposes with return value from the
865
 
            # fingerprint() function
866
 
            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()
867
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
868
972
            if "secret" in section:
869
973
                client["secret"] = codecs.decode(section["secret"]
870
974
                                                 .encode("utf-8"),
911
1015
            self.last_enabled = None
912
1016
            self.expires = None
913
1017
 
914
 
        logger.debug("Creating client %r", self.name)
915
 
        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)
916
1021
        self.created = settings.get("created",
917
1022
                                    datetime.datetime.utcnow())
918
1023
 
946
1051
        if getattr(self, "enabled", False):
947
1052
            # Already enabled
948
1053
            return
949
 
        self.expires = datetime.datetime.utcnow() + self.timeout
950
1054
        self.enabled = True
951
1055
        self.last_enabled = datetime.datetime.utcnow()
952
1056
        self.init_checker()
957
1061
        if not getattr(self, "enabled", False):
958
1062
            return False
959
1063
        if not quiet:
960
 
            logger.info("Disabling client %s", self.name)
 
1064
            log.info("Disabling client %s", self.name)
961
1065
        if getattr(self, "disable_initiator_tag", None) is not None:
962
1066
            GLib.source_remove(self.disable_initiator_tag)
963
1067
            self.disable_initiator_tag = None
975
1079
    def __del__(self):
976
1080
        self.disable()
977
1081
 
978
 
    def init_checker(self):
979
 
        # Schedule a new checker to be started an 'interval' from now,
980
 
        # 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.
981
1087
        if self.checker_initiator_tag is not None:
982
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
983
1096
        self.checker_initiator_tag = GLib.timeout_add(
984
 
            int(self.interval.total_seconds() * 1000),
985
 
            self.start_checker)
986
 
        # 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
987
1106
        if self.disable_initiator_tag is not None:
988
1107
            GLib.source_remove(self.disable_initiator_tag)
989
1108
        self.disable_initiator_tag = GLib.timeout_add(
990
 
            int(self.timeout.total_seconds() * 1000), self.disable)
991
 
        # Also start a new checker *right now*.
992
 
        self.start_checker()
 
1109
            int((self.expires - now).total_seconds() * 1000),
 
1110
            self.disable)
993
1111
 
994
1112
    def checker_callback(self, source, condition, connection,
995
1113
                         command):
996
1114
        """The checker has completed, so take appropriate actions."""
997
 
        self.checker_callback_tag = None
998
 
        self.checker = None
999
1115
        # Read return code from connection (see call_pipe)
1000
1116
        returncode = connection.recv()
1001
1117
        connection.close()
 
1118
        if self.checker is not None:
 
1119
            self.checker.join()
 
1120
        self.checker_callback_tag = None
 
1121
        self.checker = None
1002
1122
 
1003
1123
        if returncode >= 0:
1004
1124
            self.last_checker_status = returncode
1005
1125
            self.last_checker_signal = None
1006
1126
            if self.last_checker_status == 0:
1007
 
                logger.info("Checker for %(name)s succeeded",
1008
 
                            vars(self))
 
1127
                log.info("Checker for %(name)s succeeded", vars(self))
1009
1128
                self.checked_ok()
1010
1129
            else:
1011
 
                logger.info("Checker for %(name)s failed", vars(self))
 
1130
                log.info("Checker for %(name)s failed", vars(self))
1012
1131
        else:
1013
1132
            self.last_checker_status = -1
1014
1133
            self.last_checker_signal = -returncode
1015
 
            logger.warning("Checker for %(name)s crashed?",
1016
 
                           vars(self))
 
1134
            log.warning("Checker for %(name)s crashed?", vars(self))
1017
1135
        return False
1018
1136
 
1019
1137
    def checked_ok(self):
1038
1156
    def need_approval(self):
1039
1157
        self.last_approval_request = datetime.datetime.utcnow()
1040
1158
 
1041
 
    def start_checker(self):
 
1159
    def start_checker(self, start_was_randomized=False):
1042
1160
        """Start a new checker subprocess if one is not running.
1043
1161
 
1044
1162
        If a checker already exists, leave it running and do
1053
1171
        # should be.
1054
1172
 
1055
1173
        if self.checker is not None and not self.checker.is_alive():
1056
 
            logger.warning("Checker was not alive; joining")
 
1174
            log.warning("Checker was not alive; joining")
1057
1175
            self.checker.join()
1058
1176
            self.checker = None
1059
1177
        # Start a new checker if needed
1060
1178
        if self.checker is None:
1061
1179
            # Escape attributes for the shell
1062
1180
            escaped_attrs = {
1063
 
                attr: re.escape(str(getattr(self, attr)))
 
1181
                attr: shlex.quote(str(getattr(self, attr)))
1064
1182
                for attr in self.runtime_expansions}
1065
1183
            try:
1066
1184
                command = self.checker_command % escaped_attrs
1067
1185
            except TypeError as error:
1068
 
                logger.error('Could not format string "%s"',
1069
 
                             self.checker_command,
1070
 
                             exc_info=error)
 
1186
                log.error('Could not format string "%s"',
 
1187
                          self.checker_command, exc_info=error)
1071
1188
                return True     # Try again later
1072
1189
            self.current_checker_command = command
1073
 
            logger.info("Starting checker %r for %s", command,
1074
 
                        self.name)
 
1190
            log.info("Starting checker %r for %s", command, self.name)
1075
1191
            # We don't need to redirect stdout and stderr, since
1076
1192
            # in normal mode, that is already done by daemon(),
1077
1193
            # and in debug mode we don't want to.  (Stdin is
1093
1209
                kwargs=popen_args)
1094
1210
            self.checker.start()
1095
1211
            self.checker_callback_tag = GLib.io_add_watch(
1096
 
                pipe[0].fileno(), GLib.IO_IN,
 
1212
                GLib.IOChannel.unix_new(pipe[0].fileno()),
 
1213
                GLib.PRIORITY_DEFAULT, GLib.IO_IN,
1097
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
1098
1226
        # Re-run this periodically if run by GLib.timeout_add
1099
1227
        return True
1100
1228
 
1105
1233
            self.checker_callback_tag = None
1106
1234
        if getattr(self, "checker", None) is None:
1107
1235
            return
1108
 
        logger.debug("Stopping checker for %(name)s", vars(self))
 
1236
        log.debug("Stopping checker for %(name)s", vars(self))
1109
1237
        self.checker.terminate()
1110
1238
        self.checker = None
1111
1239
 
1138
1266
        func._dbus_name = func.__name__
1139
1267
        if func._dbus_name.endswith("_dbus_property"):
1140
1268
            func._dbus_name = func._dbus_name[:-14]
1141
 
        func._dbus_get_args_options = {'byte_arrays': byte_arrays}
 
1269
        func._dbus_get_args_options = {"byte_arrays": byte_arrays}
1142
1270
        return func
1143
1271
 
1144
1272
    return decorator
1233
1361
 
1234
1362
    @dbus.service.method(dbus.INTROSPECTABLE_IFACE,
1235
1363
                         out_signature="s",
1236
 
                         path_keyword='object_path',
1237
 
                         connection_keyword='connection')
 
1364
                         path_keyword="object_path",
 
1365
                         connection_keyword="connection")
1238
1366
    def Introspect(self, object_path, connection):
1239
1367
        """Overloading of standard D-Bus method.
1240
1368
 
1289
1417
            document.unlink()
1290
1418
        except (AttributeError, xml.dom.DOMException,
1291
1419
                xml.parsers.expat.ExpatError) as error:
1292
 
            logger.error("Failed to override Introspection method",
1293
 
                         exc_info=error)
 
1420
            log.error("Failed to override Introspection method",
 
1421
                      exc_info=error)
1294
1422
        return xmlstring
1295
1423
 
1296
1424
 
1354
1482
                raise ValueError("Byte arrays not supported for non-"
1355
1483
                                 "'ay' signature {!r}"
1356
1484
                                 .format(prop._dbus_signature))
1357
 
            value = dbus.ByteArray(b''.join(chr(byte)
1358
 
                                            for byte in value))
 
1485
            value = dbus.ByteArray(bytes(value))
1359
1486
        prop(value)
1360
1487
 
1361
1488
    @dbus.service.method(dbus.PROPERTIES_IFACE,
1394
1521
 
1395
1522
    @dbus.service.method(dbus.INTROSPECTABLE_IFACE,
1396
1523
                         out_signature="s",
1397
 
                         path_keyword='object_path',
1398
 
                         connection_keyword='connection')
 
1524
                         path_keyword="object_path",
 
1525
                         connection_keyword="connection")
1399
1526
    def Introspect(self, object_path, connection):
1400
1527
        """Overloading of standard D-Bus method.
1401
1528
 
1457
1584
            document.unlink()
1458
1585
        except (AttributeError, xml.dom.DOMException,
1459
1586
                xml.parsers.expat.ExpatError) as error:
1460
 
            logger.error("Failed to override Introspection method",
1461
 
                         exc_info=error)
 
1587
            log.error("Failed to override Introspection method",
 
1588
                      exc_info=error)
1462
1589
        return xmlstring
1463
1590
 
 
1591
 
1464
1592
try:
1465
1593
    dbus.OBJECT_MANAGER_IFACE
1466
1594
except AttributeError:
1495
1623
 
1496
1624
    @dbus.service.method(dbus.INTROSPECTABLE_IFACE,
1497
1625
                         out_signature="s",
1498
 
                         path_keyword='object_path',
1499
 
                         connection_keyword='connection')
 
1626
                         path_keyword="object_path",
 
1627
                         connection_keyword="connection")
1500
1628
    def Introspect(self, object_path, connection):
1501
1629
        """Overloading of standard D-Bus method.
1502
1630
 
1527
1655
            document.unlink()
1528
1656
        except (AttributeError, xml.dom.DOMException,
1529
1657
                xml.parsers.expat.ExpatError) as error:
1530
 
            logger.error("Failed to override Introspection method",
1531
 
                         exc_info=error)
 
1658
            log.error("Failed to override Introspection method",
 
1659
                      exc_info=error)
1532
1660
        return xmlstring
1533
1661
 
1534
1662
 
1998
2126
    def Name_dbus_property(self):
1999
2127
        return dbus.String(self.name)
2000
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
 
2001
2136
    # Fingerprint - property
2002
2137
    @dbus_annotations(
2003
2138
        {"org.freedesktop.DBus.Property.EmitsChangedSignal": "const"})
2158
2293
    del _interface
2159
2294
 
2160
2295
 
2161
 
class ProxyClient(object):
2162
 
    def __init__(self, child_pipe, fpr, address):
 
2296
class ProxyClient:
 
2297
    def __init__(self, child_pipe, key_id, fpr, address):
2163
2298
        self._pipe = child_pipe
2164
 
        self._pipe.send(('init', fpr, address))
 
2299
        self._pipe.send(("init", key_id, fpr, address))
2165
2300
        if not self._pipe.recv():
2166
 
            raise KeyError(fpr)
 
2301
            raise KeyError(key_id or fpr)
2167
2302
 
2168
2303
    def __getattribute__(self, name):
2169
 
        if name == '_pipe':
 
2304
        if name == "_pipe":
2170
2305
            return super(ProxyClient, self).__getattribute__(name)
2171
 
        self._pipe.send(('getattr', name))
 
2306
        self._pipe.send(("getattr", name))
2172
2307
        data = self._pipe.recv()
2173
 
        if data[0] == 'data':
 
2308
        if data[0] == "data":
2174
2309
            return data[1]
2175
 
        if data[0] == 'function':
 
2310
        if data[0] == "function":
2176
2311
 
2177
2312
            def func(*args, **kwargs):
2178
 
                self._pipe.send(('funcall', name, args, kwargs))
 
2313
                self._pipe.send(("funcall", name, args, kwargs))
2179
2314
                return self._pipe.recv()[1]
2180
2315
 
2181
2316
            return func
2182
2317
 
2183
2318
    def __setattr__(self, name, value):
2184
 
        if name == '_pipe':
 
2319
        if name == "_pipe":
2185
2320
            return super(ProxyClient, self).__setattr__(name, value)
2186
 
        self._pipe.send(('setattr', name, value))
 
2321
        self._pipe.send(("setattr", name, value))
2187
2322
 
2188
2323
 
2189
2324
class ClientHandler(socketserver.BaseRequestHandler, object):
2194
2329
 
2195
2330
    def handle(self):
2196
2331
        with contextlib.closing(self.server.child_pipe) as child_pipe:
2197
 
            logger.info("TCP connection from: %s",
2198
 
                        str(self.client_address))
2199
 
            logger.debug("Pipe FD: %d",
2200
 
                         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())
2201
2335
 
2202
2336
            session = gnutls.ClientSession(self.request)
2203
2337
 
2204
 
            # priority = ':'.join(("NONE", "+VERS-TLS1.1",
 
2338
            # priority = ":".join(("NONE", "+VERS-TLS1.1",
2205
2339
            #                       "+AES-256-CBC", "+SHA1",
2206
2340
            #                       "+COMP-NULL", "+CTYPE-OPENPGP",
2207
2341
            #                       "+DHE-DSS"))
2209
2343
            priority = self.server.gnutls_priority
2210
2344
            if priority is None:
2211
2345
                priority = "NORMAL"
2212
 
            gnutls.priority_set_direct(session._c_object,
2213
 
                                       priority.encode("utf-8"),
2214
 
                                       None)
 
2346
            gnutls.priority_set_direct(session,
 
2347
                                       priority.encode("utf-8"), None)
2215
2348
 
2216
2349
            # Start communication using the Mandos protocol
2217
2350
            # Get protocol number
2218
2351
            line = self.request.makefile().readline()
2219
 
            logger.debug("Protocol version: %r", line)
 
2352
            log.debug("Protocol version: %r", line)
2220
2353
            try:
2221
2354
                if int(line.strip().split()[0]) > 1:
2222
2355
                    raise RuntimeError(line)
2223
2356
            except (ValueError, IndexError, RuntimeError) as error:
2224
 
                logger.error("Unknown protocol version: %s", error)
 
2357
                log.error("Unknown protocol version: %s", error)
2225
2358
                return
2226
2359
 
2227
2360
            # Start GnuTLS connection
2228
2361
            try:
2229
2362
                session.handshake()
2230
2363
            except gnutls.Error as error:
2231
 
                logger.warning("Handshake failed: %s", error)
 
2364
                log.warning("Handshake failed: %s", error)
2232
2365
                # Do not run session.bye() here: the session is not
2233
2366
                # established.  Just abandon the request.
2234
2367
                return
2235
 
            logger.debug("Handshake succeeded")
 
2368
            log.debug("Handshake succeeded")
2236
2369
 
2237
2370
            approval_required = False
2238
2371
            try:
2239
 
                try:
2240
 
                    fpr = self.fingerprint(
2241
 
                        self.peer_certificate(session))
2242
 
                except (TypeError, gnutls.Error) as error:
2243
 
                    logger.warning("Bad certificate: %s", error)
2244
 
                    return
2245
 
                logger.debug("Fingerprint: %s", fpr)
2246
 
 
2247
 
                try:
2248
 
                    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,
2249
2396
                                         self.client_address)
2250
2397
                except KeyError:
2251
2398
                    return
2257
2404
 
2258
2405
                while True:
2259
2406
                    if not client.enabled:
2260
 
                        logger.info("Client %s is disabled",
2261
 
                                    client.name)
 
2407
                        log.info("Client %s is disabled", client.name)
2262
2408
                        if self.server.use_dbus:
2263
2409
                            # Emit D-Bus signal
2264
2410
                            client.Rejected("Disabled")
2268
2414
                        # We are approved or approval is disabled
2269
2415
                        break
2270
2416
                    elif client.approved is None:
2271
 
                        logger.info("Client %s needs approval",
2272
 
                                    client.name)
 
2417
                        log.info("Client %s needs approval",
 
2418
                                 client.name)
2273
2419
                        if self.server.use_dbus:
2274
2420
                            # Emit D-Bus signal
2275
2421
                            client.NeedApproval(
2276
2422
                                client.approval_delay.total_seconds()
2277
2423
                                * 1000, client.approved_by_default)
2278
2424
                    else:
2279
 
                        logger.warning("Client %s was not approved",
2280
 
                                       client.name)
 
2425
                        log.warning("Client %s was not approved",
 
2426
                                    client.name)
2281
2427
                        if self.server.use_dbus:
2282
2428
                            # Emit D-Bus signal
2283
2429
                            client.Rejected("Denied")
2291
2437
                    time2 = datetime.datetime.now()
2292
2438
                    if (time2 - time) >= delay:
2293
2439
                        if not client.approved_by_default:
2294
 
                            logger.warning("Client %s timed out while"
2295
 
                                           " waiting for approval",
2296
 
                                           client.name)
 
2440
                            log.warning("Client %s timed out while"
 
2441
                                        " waiting for approval",
 
2442
                                        client.name)
2297
2443
                            if self.server.use_dbus:
2298
2444
                                # Emit D-Bus signal
2299
2445
                                client.Rejected("Approval timed out")
2306
2452
                try:
2307
2453
                    session.send(client.secret)
2308
2454
                except gnutls.Error as error:
2309
 
                    logger.warning("gnutls send failed",
2310
 
                                   exc_info=error)
 
2455
                    log.warning("gnutls send failed", exc_info=error)
2311
2456
                    return
2312
2457
 
2313
 
                logger.info("Sending secret to %s", client.name)
 
2458
                log.info("Sending secret to %s", client.name)
2314
2459
                # bump the timeout using extended_timeout
2315
2460
                client.bump_timeout(client.extended_timeout)
2316
2461
                if self.server.use_dbus:
2323
2468
                try:
2324
2469
                    session.bye()
2325
2470
                except gnutls.Error as error:
2326
 
                    logger.warning("GnuTLS bye failed",
2327
 
                                   exc_info=error)
 
2471
                    log.warning("GnuTLS bye failed", exc_info=error)
2328
2472
 
2329
2473
    @staticmethod
2330
2474
    def peer_certificate(session):
2331
 
        "Return the peer's OpenPGP certificate as a bytestring"
2332
 
        # If not an OpenPGP certificate...
2333
 
        if (gnutls.certificate_type_get(session._c_object)
2334
 
            != 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)
2335
2489
            # ...return invalid data
2336
2490
            return b""
2337
2491
        list_size = ctypes.c_uint(1)
2338
2492
        cert_list = (gnutls.certificate_get_peers
2339
 
                     (session._c_object, ctypes.byref(list_size)))
 
2493
                     (session, ctypes.byref(list_size)))
2340
2494
        if not bool(cert_list) and list_size.value != 0:
2341
2495
            raise gnutls.Error("error getting peer certificate")
2342
2496
        if list_size.value == 0:
2345
2499
        return ctypes.string_at(cert.data, cert.size)
2346
2500
 
2347
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
2348
2537
    def fingerprint(openpgp):
2349
2538
        "Convert an OpenPGP bytestring to a hexdigit fingerprint"
2350
2539
        # New GnuTLS "datum" with the OpenPGP public key
2364
2553
                                       ctypes.byref(crtverify))
2365
2554
        if crtverify.value != 0:
2366
2555
            gnutls.openpgp_crt_deinit(crt)
2367
 
            raise gnutls.CertificateSecurityError("Verify failed")
 
2556
            raise gnutls.CertificateSecurityError(code
 
2557
                                                  =crtverify.value)
2368
2558
        # New buffer for the fingerprint
2369
2559
        buf = ctypes.create_string_buffer(20)
2370
2560
        buf_len = ctypes.c_size_t()
2380
2570
        return hex_fpr
2381
2571
 
2382
2572
 
2383
 
class MultiprocessingMixIn(object):
 
2573
class MultiprocessingMixIn:
2384
2574
    """Like socketserver.ThreadingMixIn, but with multiprocessing"""
2385
2575
 
2386
2576
    def sub_process_main(self, request, address):
2398
2588
        return proc
2399
2589
 
2400
2590
 
2401
 
class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):
 
2591
class MultiprocessingMixInWithPipe(MultiprocessingMixIn):
2402
2592
    """ adds a pipe to the MixIn """
2403
2593
 
2404
2594
    def process_request(self, request, client_address):
2419
2609
 
2420
2610
 
2421
2611
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
2422
 
                     socketserver.TCPServer, object):
2423
 
    """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
2424
2614
 
2425
2615
    Attributes:
2426
2616
        enabled:        Boolean; whether this server is activated yet
2477
2667
            if SO_BINDTODEVICE is None:
2478
2668
                # Fall back to a hard-coded value which seems to be
2479
2669
                # common enough.
2480
 
                logger.warning("SO_BINDTODEVICE not found, trying 25")
 
2670
                log.warning("SO_BINDTODEVICE not found, trying 25")
2481
2671
                SO_BINDTODEVICE = 25
2482
2672
            try:
2483
2673
                self.socket.setsockopt(
2485
2675
                    (self.interface + "\0").encode("utf-8"))
2486
2676
            except socket.error as error:
2487
2677
                if error.errno == errno.EPERM:
2488
 
                    logger.error("No permission to bind to"
2489
 
                                 " interface %s", self.interface)
 
2678
                    log.error("No permission to bind to interface %s",
 
2679
                              self.interface)
2490
2680
                elif error.errno == errno.ENOPROTOOPT:
2491
 
                    logger.error("SO_BINDTODEVICE not available;"
2492
 
                                 " cannot bind to interface %s",
2493
 
                                 self.interface)
 
2681
                    log.error("SO_BINDTODEVICE not available; cannot"
 
2682
                              " bind to interface %s", self.interface)
2494
2683
                elif error.errno == errno.ENODEV:
2495
 
                    logger.error("Interface %s does not exist,"
2496
 
                                 " cannot bind", self.interface)
 
2684
                    log.error("Interface %s does not exist, cannot"
 
2685
                              " bind", self.interface)
2497
2686
                else:
2498
2687
                    raise
2499
2688
        # Only bind(2) the socket if we really need to.
2500
2689
        if self.server_address[0] or self.server_address[1]:
 
2690
            if self.server_address[1]:
 
2691
                self.allow_reuse_address = True
2501
2692
            if not self.server_address[0]:
2502
2693
                if self.address_family == socket.AF_INET6:
2503
2694
                    any_address = "::"  # in6addr_any
2556
2747
    def add_pipe(self, parent_pipe, proc):
2557
2748
        # Call "handle_ipc" for both data and EOF events
2558
2749
        GLib.io_add_watch(
2559
 
            parent_pipe.fileno(),
2560
 
            GLib.IO_IN | GLib.IO_HUP,
 
2750
            GLib.IOChannel.unix_new(parent_pipe.fileno()),
 
2751
            GLib.PRIORITY_DEFAULT, GLib.IO_IN | GLib.IO_HUP,
2561
2752
            functools.partial(self.handle_ipc,
2562
2753
                              parent_pipe=parent_pipe,
2563
2754
                              proc=proc))
2576
2767
        request = parent_pipe.recv()
2577
2768
        command = request[0]
2578
2769
 
2579
 
        if command == 'init':
2580
 
            fpr = request[1]
2581
 
            address = request[2]
 
2770
        if command == "init":
 
2771
            key_id = request[1].decode("ascii")
 
2772
            fpr = request[2].decode("ascii")
 
2773
            address = request[3]
2582
2774
 
2583
2775
            for c in self.clients.values():
2584
 
                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:
2585
2783
                    client = c
2586
2784
                    break
2587
2785
            else:
2588
 
                logger.info("Client not found for fingerprint: %s, ad"
2589
 
                            "dress: %s", fpr, address)
 
2786
                log.info("Client not found for key ID: %s, address:"
 
2787
                         " %s", key_id or fpr, address)
2590
2788
                if self.use_dbus:
2591
2789
                    # Emit D-Bus signal
2592
 
                    mandos_dbus_service.ClientNotFound(fpr,
 
2790
                    mandos_dbus_service.ClientNotFound(key_id or fpr,
2593
2791
                                                       address[0])
2594
2792
                parent_pipe.send(False)
2595
2793
                return False
2596
2794
 
2597
2795
            GLib.io_add_watch(
2598
 
                parent_pipe.fileno(),
2599
 
                GLib.IO_IN | GLib.IO_HUP,
 
2796
                GLib.IOChannel.unix_new(parent_pipe.fileno()),
 
2797
                GLib.PRIORITY_DEFAULT, GLib.IO_IN | GLib.IO_HUP,
2600
2798
                functools.partial(self.handle_ipc,
2601
2799
                                  parent_pipe=parent_pipe,
2602
2800
                                  proc=proc,
2605
2803
            # remove the old hook in favor of the new above hook on
2606
2804
            # same fileno
2607
2805
            return False
2608
 
        if command == 'funcall':
 
2806
        if command == "funcall":
2609
2807
            funcname = request[1]
2610
2808
            args = request[2]
2611
2809
            kwargs = request[3]
2612
2810
 
2613
 
            parent_pipe.send(('data', getattr(client_object,
 
2811
            parent_pipe.send(("data", getattr(client_object,
2614
2812
                                              funcname)(*args,
2615
2813
                                                        **kwargs)))
2616
2814
 
2617
 
        if command == 'getattr':
 
2815
        if command == "getattr":
2618
2816
            attrname = request[1]
2619
2817
            if isinstance(client_object.__getattribute__(attrname),
2620
 
                          collections.Callable):
2621
 
                parent_pipe.send(('function', ))
 
2818
                          collections.abc.Callable):
 
2819
                parent_pipe.send(("function", ))
2622
2820
            else:
2623
2821
                parent_pipe.send((
2624
 
                    'data', client_object.__getattribute__(attrname)))
 
2822
                    "data", client_object.__getattribute__(attrname)))
2625
2823
 
2626
 
        if command == 'setattr':
 
2824
        if command == "setattr":
2627
2825
            attrname = request[1]
2628
2826
            value = request[2]
2629
2827
            setattr(client_object, attrname, value)
2634
2832
def rfc3339_duration_to_delta(duration):
2635
2833
    """Parse an RFC 3339 "duration" and return a datetime.timedelta
2636
2834
 
2637
 
    >>> rfc3339_duration_to_delta("P7D")
2638
 
    datetime.timedelta(7)
2639
 
    >>> rfc3339_duration_to_delta("PT60S")
2640
 
    datetime.timedelta(0, 60)
2641
 
    >>> rfc3339_duration_to_delta("PT60M")
2642
 
    datetime.timedelta(0, 3600)
2643
 
    >>> rfc3339_duration_to_delta("PT24H")
2644
 
    datetime.timedelta(1)
2645
 
    >>> rfc3339_duration_to_delta("P1W")
2646
 
    datetime.timedelta(7)
2647
 
    >>> rfc3339_duration_to_delta("PT5M30S")
2648
 
    datetime.timedelta(0, 330)
2649
 
    >>> rfc3339_duration_to_delta("P1DT3M20S")
2650
 
    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
2651
2851
    """
2652
2852
 
2653
2853
    # Parsing an RFC 3339 duration with regular expressions is not
2733
2933
def string_to_delta(interval):
2734
2934
    """Parse a string and return a datetime.timedelta
2735
2935
 
2736
 
    >>> string_to_delta('7d')
2737
 
    datetime.timedelta(7)
2738
 
    >>> string_to_delta('60s')
2739
 
    datetime.timedelta(0, 60)
2740
 
    >>> string_to_delta('60m')
2741
 
    datetime.timedelta(0, 3600)
2742
 
    >>> string_to_delta('24h')
2743
 
    datetime.timedelta(1)
2744
 
    >>> string_to_delta('1w')
2745
 
    datetime.timedelta(7)
2746
 
    >>> string_to_delta('5m 30s')
2747
 
    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
2748
2948
    """
2749
2949
 
2750
2950
    try:
2852
3052
 
2853
3053
    options = parser.parse_args()
2854
3054
 
2855
 
    if options.check:
2856
 
        import doctest
2857
 
        fail_count, test_count = doctest.testmod()
2858
 
        sys.exit(os.EX_OK if fail_count == 0 else 1)
2859
 
 
2860
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")
2861
3062
    server_defaults = {"interface": "",
2862
3063
                       "address": "",
2863
3064
                       "port": "",
2864
3065
                       "debug": "False",
2865
 
                       "priority":
2866
 
                       "SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:!RSA"
2867
 
                       ":+SIGN-DSA-SHA256",
 
3066
                       "priority": priority,
2868
3067
                       "servicename": "Mandos",
2869
3068
                       "use_dbus": "True",
2870
3069
                       "use_ipv6": "True",
2875
3074
                       "foreground": "False",
2876
3075
                       "zeroconf": "True",
2877
3076
                       }
 
3077
    del priority
2878
3078
 
2879
3079
    # Parse config file for server-global settings
2880
 
    server_config = configparser.SafeConfigParser(server_defaults)
 
3080
    server_config = configparser.ConfigParser(server_defaults)
2881
3081
    del server_defaults
2882
3082
    server_config.read(os.path.join(options.configdir, "mandos.conf"))
2883
 
    # Convert the SafeConfigParser object to a dict
 
3083
    # Convert the ConfigParser object to a dict
2884
3084
    server_settings = server_config.defaults()
2885
3085
    # Use the appropriate methods on the non-string config options
2886
 
    for option in ("debug", "use_dbus", "use_ipv6", "foreground"):
 
3086
    for option in ("debug", "use_dbus", "use_ipv6", "restore",
 
3087
                   "foreground", "zeroconf"):
2887
3088
        server_settings[option] = server_config.getboolean("DEFAULT",
2888
3089
                                                           option)
2889
3090
    if server_settings["port"]:
2952
3153
 
2953
3154
    if server_settings["servicename"] != "Mandos":
2954
3155
        syslogger.setFormatter(
2955
 
            logging.Formatter('Mandos ({}) [%(process)d]:'
2956
 
                              ' %(levelname)s: %(message)s'.format(
 
3156
            logging.Formatter("Mandos ({}) [%(process)d]:"
 
3157
                              " %(levelname)s: %(message)s".format(
2957
3158
                                  server_settings["servicename"])))
2958
3159
 
2959
3160
    # Parse config file with clients
2960
 
    client_config = configparser.SafeConfigParser(Client
2961
 
                                                  .client_defaults)
 
3161
    client_config = configparser.ConfigParser(Client.client_defaults)
2962
3162
    client_config.read(os.path.join(server_settings["configdir"],
2963
3163
                                    "clients.conf"))
2964
3164
 
2984
3184
        try:
2985
3185
            pidfile = codecs.open(pidfilename, "w", encoding="utf-8")
2986
3186
        except IOError as e:
2987
 
            logger.error("Could not open file %r", pidfilename,
2988
 
                         exc_info=e)
 
3187
            log.error("Could not open file %r", pidfilename,
 
3188
                      exc_info=e)
2989
3189
 
2990
3190
    for name, group in (("_mandos", "_mandos"),
2991
3191
                        ("mandos", "mandos"),
3002
3202
    try:
3003
3203
        os.setgid(gid)
3004
3204
        os.setuid(uid)
3005
 
        if debug:
3006
 
            logger.debug("Did setuid/setgid to {}:{}".format(uid,
3007
 
                                                             gid))
 
3205
        log.debug("Did setuid/setgid to %s:%s", uid, gid)
3008
3206
    except OSError as error:
3009
 
        logger.warning("Failed to setuid/setgid to {}:{}: {}"
3010
 
                       .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))
3011
3209
        if error.errno != errno.EPERM:
3012
3210
            raise
3013
3211
 
3020
3218
 
3021
3219
        @gnutls.log_func
3022
3220
        def debug_gnutls(level, string):
3023
 
            logger.debug("GnuTLS: %s", string[:-1])
 
3221
            log.debug("GnuTLS: %s",
 
3222
                      string[:-1].decode("utf-8", errors="replace"))
3024
3223
 
3025
3224
        gnutls.global_set_log_function(debug_gnutls)
3026
3225
 
3035
3234
        # Close all input and output, do double fork, etc.
3036
3235
        daemon()
3037
3236
 
3038
 
    # multiprocessing will use threads, so before we use GLib we need
3039
 
    # to inform GLib that threads will be used.
3040
 
    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()
3041
3241
 
3042
3242
    global main_loop
3043
3243
    # From the Avahi example code
3054
3254
                "se.bsnet.fukt.Mandos", bus,
3055
3255
                do_not_queue=True)
3056
3256
        except dbus.exceptions.DBusException as e:
3057
 
            logger.error("Disabling D-Bus:", exc_info=e)
 
3257
            log.error("Disabling D-Bus:", exc_info=e)
3058
3258
            use_dbus = False
3059
3259
            server_settings["use_dbus"] = False
3060
3260
            tcp_server.use_dbus = False
3119
3319
                             if isinstance(s, bytes)
3120
3320
                             else s) for s in
3121
3321
                            value["client_structure"]]
3122
 
                        # .name & .host
3123
 
                        for k in ("name", "host"):
 
3322
                        # .name, .host, and .checker_command
 
3323
                        for k in ("name", "host", "checker_command"):
3124
3324
                            if isinstance(value[k], bytes):
3125
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"] = ""
3126
3330
                    #  old_client_settings
3127
3331
                    # .keys()
3128
3332
                    old_client_settings = {
3132
3336
                        for key, value in
3133
3337
                        bytes_old_client_settings.items()}
3134
3338
                    del bytes_old_client_settings
3135
 
                    # .host
 
3339
                    # .host and .checker_command
3136
3340
                    for value in old_client_settings.values():
3137
 
                        if isinstance(value["host"], bytes):
3138
 
                            value["host"] = (value["host"]
3139
 
                                             .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"))
3140
3345
            os.remove(stored_state_path)
3141
3346
        except IOError as e:
3142
3347
            if e.errno == errno.ENOENT:
3143
 
                logger.warning("Could not load persistent state:"
3144
 
                               " {}".format(os.strerror(e.errno)))
 
3348
                log.warning("Could not load persistent state:"
 
3349
                            " %s", os.strerror(e.errno))
3145
3350
            else:
3146
 
                logger.critical("Could not load persistent state:",
3147
 
                                exc_info=e)
 
3351
                log.critical("Could not load persistent state:",
 
3352
                             exc_info=e)
3148
3353
                raise
3149
3354
        except EOFError as e:
3150
 
            logger.warning("Could not load persistent state: "
3151
 
                           "EOFError:",
3152
 
                           exc_info=e)
 
3355
            log.warning("Could not load persistent state: EOFError:",
 
3356
                        exc_info=e)
3153
3357
 
3154
3358
    with PGPEngine() as pgp:
3155
3359
        for client_name, client in clients_data.items():
3182
3386
            if client["enabled"]:
3183
3387
                if datetime.datetime.utcnow() >= client["expires"]:
3184
3388
                    if not client["last_checked_ok"]:
3185
 
                        logger.warning(
3186
 
                            "disabling client {} - Client never "
3187
 
                            "performed a successful checker".format(
3188
 
                                client_name))
 
3389
                        log.warning("disabling client %s - Client"
 
3390
                                    " never performed a successful"
 
3391
                                    " checker", client_name)
3189
3392
                        client["enabled"] = False
3190
3393
                    elif client["last_checker_status"] != 0:
3191
 
                        logger.warning(
3192
 
                            "disabling client {} - Client last"
3193
 
                            " checker failed with error code"
3194
 
                            " {}".format(
3195
 
                                client_name,
3196
 
                                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"])
3197
3398
                        client["enabled"] = False
3198
3399
                    else:
3199
3400
                        client["expires"] = (
3200
3401
                            datetime.datetime.utcnow()
3201
3402
                            + client["timeout"])
3202
 
                        logger.debug("Last checker succeeded,"
3203
 
                                     " keeping {} enabled".format(
3204
 
                                         client_name))
 
3403
                        log.debug("Last checker succeeded, keeping %s"
 
3404
                                  " enabled", client_name)
3205
3405
            try:
3206
3406
                client["secret"] = pgp.decrypt(
3207
3407
                    client["encrypted_secret"],
3208
3408
                    client_settings[client_name]["secret"])
3209
3409
            except PGPError:
3210
3410
                # If decryption fails, we use secret from new settings
3211
 
                logger.debug("Failed to decrypt {} old secret".format(
3212
 
                    client_name))
 
3411
                log.debug("Failed to decrypt %s old secret",
 
3412
                          client_name)
3213
3413
                client["secret"] = (client_settings[client_name]
3214
3414
                                    ["secret"])
3215
3415
 
3229
3429
            server_settings=server_settings)
3230
3430
 
3231
3431
    if not tcp_server.clients:
3232
 
        logger.warning("No clients defined")
 
3432
        log.warning("No clients defined")
3233
3433
 
3234
3434
    if not foreground:
3235
3435
        if pidfile is not None:
3238
3438
                with pidfile:
3239
3439
                    print(pid, file=pidfile)
3240
3440
            except IOError:
3241
 
                logger.error("Could not write to file %r with PID %d",
3242
 
                             pidfilename, pid)
 
3441
                log.error("Could not write to file %r with PID %d",
 
3442
                          pidfilename, pid)
3243
3443
        del pidfile
3244
3444
        del pidfilename
3245
3445
 
3265
3465
                pass
3266
3466
 
3267
3467
            @dbus.service.signal(_interface, signature="ss")
3268
 
            def ClientNotFound(self, fingerprint, address):
 
3468
            def ClientNotFound(self, key_id, address):
3269
3469
                "D-Bus signal"
3270
3470
                pass
3271
3471
 
3395
3595
 
3396
3596
        try:
3397
3597
            with tempfile.NamedTemporaryFile(
3398
 
                    mode='wb',
 
3598
                    mode="wb",
3399
3599
                    suffix=".pickle",
3400
 
                    prefix='clients-',
 
3600
                    prefix="clients-",
3401
3601
                    dir=os.path.dirname(stored_state_path),
3402
3602
                    delete=False) as stored_state:
3403
3603
                pickle.dump((clients, client_settings), stored_state,
3411
3611
                except NameError:
3412
3612
                    pass
3413
3613
            if e.errno in (errno.ENOENT, errno.EACCES, errno.EEXIST):
3414
 
                logger.warning("Could not save persistent state: {}"
3415
 
                               .format(os.strerror(e.errno)))
 
3614
                log.warning("Could not save persistent state: %s",
 
3615
                            os.strerror(e.errno))
3416
3616
            else:
3417
 
                logger.warning("Could not save persistent state:",
3418
 
                               exc_info=e)
 
3617
                log.warning("Could not save persistent state:",
 
3618
                            exc_info=e)
3419
3619
                raise
3420
3620
 
3421
3621
        # Delete all clients, and settings from config
3438
3638
            mandos_dbus_service.client_added_signal(client)
3439
3639
        # Need to initiate checking of clients
3440
3640
        if client.enabled:
3441
 
            client.init_checker()
 
3641
            client.init_checker(randomize_start=True)
3442
3642
 
3443
3643
    tcp_server.enable()
3444
3644
    tcp_server.server_activate()
3447
3647
    if zeroconf:
3448
3648
        service.port = tcp_server.socket.getsockname()[1]
3449
3649
    if use_ipv6:
3450
 
        logger.info("Now listening on address %r, port %d,"
3451
 
                    " flowinfo %d, scope_id %d",
3452
 
                    *tcp_server.socket.getsockname())
 
3650
        log.info("Now listening on address %r, port %d, flowinfo %d,"
 
3651
                 " scope_id %d", *tcp_server.socket.getsockname())
3453
3652
    else:                       # IPv4
3454
 
        logger.info("Now listening on address %r, port %d",
3455
 
                    *tcp_server.socket.getsockname())
 
3653
        log.info("Now listening on address %r, port %d",
 
3654
                 *tcp_server.socket.getsockname())
3456
3655
 
3457
3656
    # service.interface = tcp_server.socket.getsockname()[3]
3458
3657
 
3462
3661
            try:
3463
3662
                service.activate()
3464
3663
            except dbus.exceptions.DBusException as error:
3465
 
                logger.critical("D-Bus Exception", exc_info=error)
 
3664
                log.critical("D-Bus Exception", exc_info=error)
3466
3665
                cleanup()
3467
3666
                sys.exit(1)
3468
3667
            # End of Avahi example code
3469
3668
 
3470
 
        GLib.io_add_watch(tcp_server.fileno(), GLib.IO_IN,
3471
 
                          lambda *args, **kwargs:
3472
 
                          (tcp_server.handle_request
3473
 
                           (*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))
3474
3674
 
3475
 
        logger.debug("Starting main loop")
 
3675
        log.debug("Starting main loop")
3476
3676
        main_loop.run()
3477
3677
    except AvahiError as error:
3478
 
        logger.critical("Avahi Error", exc_info=error)
 
3678
        log.critical("Avahi Error", exc_info=error)
3479
3679
        cleanup()
3480
3680
        sys.exit(1)
3481
3681
    except KeyboardInterrupt:
3482
3682
        if debug:
3483
3683
            print("", file=sys.stderr)
3484
 
        logger.debug("Server received KeyboardInterrupt")
3485
 
    logger.debug("Server exiting")
 
3684
        log.debug("Server received KeyboardInterrupt")
 
3685
    log.debug("Server exiting")
3486
3686
    # Must run before the D-Bus bus name gets deregistered
3487
3687
    cleanup()
3488
3688
 
3489
 
 
3490
 
if __name__ == '__main__':
3491
 
    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: