/mandos/release

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

« back to all changes in this revision

Viewing changes to mandos

  • Committer: Teddy Hogeborn
  • Date: 2024-11-03 15:32:05 UTC
  • mto: This revision was merged to the branch mainline in revision 412.
  • Revision ID: teddy@recompile.se-20241103153205-qota5ic1c4m2nqh4
Detect GPGME version correctly

It seems that newer versions of dpkg-query can print an empty version.
Change the code to also parse this output.

Reported-By: Pablo Abelenda <pabelenda@igalia.com>

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-2019 Teddy Hogeborn
15
 
# Copyright © 2008-2019 Björn Påhlsson
 
14
# Copyright © 2008-2022 Teddy Hogeborn
 
15
# Copyright © 2008-2022 Björn Påhlsson
16
16
#
17
17
# This file is part of Mandos.
18
18
#
31
31
#
32
32
# Contact the authors at <mandos@recompile.se>.
33
33
#
34
 
 
35
34
from __future__ import (division, absolute_import, print_function,
36
35
                        unicode_literals)
37
36
 
40
39
except ImportError:
41
40
    pass
42
41
 
 
42
import sys
 
43
import unittest
 
44
import argparse
 
45
import logging
 
46
import os
43
47
try:
44
48
    import SocketServer as socketserver
45
49
except ImportError:
46
50
    import socketserver
47
51
import socket
48
 
import argparse
49
52
import datetime
50
53
import errno
51
54
try:
52
55
    import ConfigParser as configparser
53
56
except ImportError:
54
57
    import configparser
55
 
import sys
56
58
import re
57
 
import os
58
59
import signal
59
60
import subprocess
60
61
import atexit
61
62
import stat
62
 
import logging
63
63
import logging.handlers
64
64
import pwd
65
65
import contextlib
77
77
import itertools
78
78
import collections
79
79
import codecs
 
80
import random
 
81
import shlex
80
82
 
81
83
import dbus
82
84
import dbus.service
 
85
import gi
83
86
from gi.repository import GLib
84
87
from dbus.mainloop.glib import DBusGMainLoop
85
88
import ctypes
87
90
import xml.dom.minidom
88
91
import inspect
89
92
 
 
93
if sys.version_info.major == 2:
 
94
    __metaclass__ = type
 
95
    str = unicode
 
96
    input = raw_input
 
97
 
 
98
# Add collections.abc.Callable if it does not exist
 
99
try:
 
100
    collections.abc.Callable
 
101
except AttributeError:
 
102
    class abc:
 
103
        Callable = collections.Callable
 
104
    collections.abc = abc
 
105
    del abc
 
106
 
 
107
# Add shlex.quote if it does not exist
 
108
try:
 
109
    shlex.quote
 
110
except AttributeError:
 
111
    shlex.quote = re.escape
 
112
 
 
113
# Show warnings by default
 
114
if not sys.warnoptions:
 
115
    import warnings
 
116
    warnings.simplefilter("default")
 
117
 
90
118
# Try to find the value of SO_BINDTODEVICE:
91
119
try:
92
120
    # This is where SO_BINDTODEVICE is in Python 3.3 (or 3.4?) and
112
140
            # No value found
113
141
            SO_BINDTODEVICE = None
114
142
 
115
 
if sys.version_info.major == 2:
116
 
    str = unicode
 
143
if sys.version_info < (3, 2):
 
144
    configparser.Configparser = configparser.SafeConfigParser
117
145
 
118
 
version = "1.8.2"
 
146
version = "1.8.17"
119
147
stored_state_file = "clients.pickle"
120
148
 
121
 
logger = logging.getLogger()
 
149
log = logging.getLogger(os.path.basename(sys.argv[0]))
 
150
logging.captureWarnings(True)   # Show warnings via the logging system
122
151
syslogger = None
123
152
 
124
153
try:
160
189
        facility=logging.handlers.SysLogHandler.LOG_DAEMON,
161
190
        address="/dev/log"))
162
191
    syslogger.setFormatter(logging.Formatter
163
 
                           ('Mandos [%(process)d]: %(levelname)s:'
164
 
                            ' %(message)s'))
165
 
    logger.addHandler(syslogger)
 
192
                           ("Mandos [%(process)d]: %(levelname)s:"
 
193
                            " %(message)s"))
 
194
    log.addHandler(syslogger)
166
195
 
167
196
    if debug:
168
197
        console = logging.StreamHandler()
169
 
        console.setFormatter(logging.Formatter('%(asctime)s %(name)s'
170
 
                                               ' [%(process)d]:'
171
 
                                               ' %(levelname)s:'
172
 
                                               ' %(message)s'))
173
 
        logger.addHandler(console)
174
 
    logger.setLevel(level)
 
198
        console.setFormatter(logging.Formatter("%(asctime)s %(name)s"
 
199
                                               " [%(process)d]:"
 
200
                                               " %(levelname)s:"
 
201
                                               " %(message)s"))
 
202
        log.addHandler(console)
 
203
    log.setLevel(level)
175
204
 
176
205
 
177
206
class PGPError(Exception):
179
208
    pass
180
209
 
181
210
 
182
 
class PGPEngine(object):
 
211
class PGPEngine:
183
212
    """A simple class for OpenPGP symmetric encryption & decryption"""
184
213
 
185
214
    def __init__(self):
189
218
            output = subprocess.check_output(["gpgconf"])
190
219
            for line in output.splitlines():
191
220
                name, text, path = line.split(b":")
192
 
                if name == "gpg":
 
221
                if name == b"gpg":
193
222
                    self.gpg = path
194
223
                    break
195
224
        except OSError as e:
196
225
            if e.errno != errno.ENOENT:
197
226
                raise
198
 
        self.gnupgargs = ['--batch',
199
 
                          '--homedir', self.tempdir,
200
 
                          '--force-mdc',
201
 
                          '--quiet']
 
227
        self.gnupgargs = ["--batch",
 
228
                          "--homedir", self.tempdir,
 
229
                          "--force-mdc",
 
230
                          "--quiet"]
202
231
        # Only GPG version 1 has the --no-use-agent option.
203
 
        if self.gpg == "gpg" or self.gpg.endswith("/gpg"):
 
232
        if self.gpg == b"gpg" or self.gpg.endswith(b"/gpg"):
204
233
            self.gnupgargs.append("--no-use-agent")
205
234
 
206
235
    def __enter__(self):
243
272
                dir=self.tempdir) as passfile:
244
273
            passfile.write(passphrase)
245
274
            passfile.flush()
246
 
            proc = subprocess.Popen([self.gpg, '--symmetric',
247
 
                                     '--passphrase-file',
 
275
            proc = subprocess.Popen([self.gpg, "--symmetric",
 
276
                                     "--passphrase-file",
248
277
                                     passfile.name]
249
278
                                    + self.gnupgargs,
250
279
                                    stdin=subprocess.PIPE,
261
290
                dir=self.tempdir) as passfile:
262
291
            passfile.write(passphrase)
263
292
            passfile.flush()
264
 
            proc = subprocess.Popen([self.gpg, '--decrypt',
265
 
                                     '--passphrase-file',
 
293
            proc = subprocess.Popen([self.gpg, "--decrypt",
 
294
                                     "--passphrase-file",
266
295
                                     passfile.name]
267
296
                                    + self.gnupgargs,
268
297
                                    stdin=subprocess.PIPE,
275
304
 
276
305
 
277
306
# Pretend that we have an Avahi module
278
 
class Avahi(object):
279
 
    """This isn't so much a class as it is a module-like namespace.
280
 
    It is instantiated once, and simulates having an Avahi module."""
 
307
class avahi:
 
308
    """This isn't so much a class as it is a module-like namespace."""
281
309
    IF_UNSPEC = -1               # avahi-common/address.h
282
310
    PROTO_UNSPEC = -1            # avahi-common/address.h
283
311
    PROTO_INET = 0               # avahi-common/address.h
287
315
    DBUS_INTERFACE_SERVER = DBUS_NAME + ".Server"
288
316
    DBUS_PATH_SERVER = "/"
289
317
 
290
 
    def string_array_to_txt_array(self, t):
 
318
    @staticmethod
 
319
    def string_array_to_txt_array(t):
291
320
        return dbus.Array((dbus.ByteArray(s.encode("utf-8"))
292
321
                           for s in t), signature="ay")
293
322
    ENTRY_GROUP_ESTABLISHED = 2  # avahi-common/defs.h
298
327
    SERVER_RUNNING = 2           # avahi-common/defs.h
299
328
    SERVER_COLLISION = 3         # avahi-common/defs.h
300
329
    SERVER_FAILURE = 4           # avahi-common/defs.h
301
 
avahi = Avahi()
302
330
 
303
331
 
304
332
class AvahiError(Exception):
316
344
    pass
317
345
 
318
346
 
319
 
class AvahiService(object):
 
347
class AvahiService:
320
348
    """An Avahi (Zeroconf) service.
321
349
 
322
350
    Attributes:
323
351
    interface: integer; avahi.IF_UNSPEC or an interface index.
324
352
               Used to optionally bind to the specified interface.
325
 
    name: string; Example: 'Mandos'
326
 
    type: string; Example: '_mandos._tcp'.
 
353
    name: string; Example: "Mandos"
 
354
    type: string; Example: "_mandos._tcp".
327
355
     See <https://www.iana.org/assignments/service-names-port-numbers>
328
356
    port: integer; what port to announce
329
357
    TXT: list of strings; TXT record for the service
366
394
    def rename(self, remove=True):
367
395
        """Derived from the Avahi example code"""
368
396
        if self.rename_count >= self.max_renames:
369
 
            logger.critical("No suitable Zeroconf service name found"
370
 
                            " after %i retries, exiting.",
371
 
                            self.rename_count)
 
397
            log.critical("No suitable Zeroconf service name found"
 
398
                         " after %i retries, exiting.",
 
399
                         self.rename_count)
372
400
            raise AvahiServiceError("Too many renames")
373
401
        self.name = str(
374
402
            self.server.GetAlternativeServiceName(self.name))
375
403
        self.rename_count += 1
376
 
        logger.info("Changing Zeroconf service name to %r ...",
377
 
                    self.name)
 
404
        log.info("Changing Zeroconf service name to %r ...",
 
405
                 self.name)
378
406
        if remove:
379
407
            self.remove()
380
408
        try:
382
410
        except dbus.exceptions.DBusException as error:
383
411
            if (error.get_dbus_name()
384
412
                == "org.freedesktop.Avahi.CollisionError"):
385
 
                logger.info("Local Zeroconf service name collision.")
 
413
                log.info("Local Zeroconf service name collision.")
386
414
                return self.rename(remove=False)
387
415
            else:
388
 
                logger.critical("D-Bus Exception", exc_info=error)
 
416
                log.critical("D-Bus Exception", exc_info=error)
389
417
                self.cleanup()
390
418
                os._exit(1)
391
419
 
407
435
                avahi.DBUS_INTERFACE_ENTRY_GROUP)
408
436
        self.entry_group_state_changed_match = (
409
437
            self.group.connect_to_signal(
410
 
                'StateChanged', self.entry_group_state_changed))
411
 
        logger.debug("Adding Zeroconf service '%s' of type '%s' ...",
412
 
                     self.name, self.type)
 
438
                "StateChanged", self.entry_group_state_changed))
 
439
        log.debug("Adding Zeroconf service '%s' of type '%s' ...",
 
440
                  self.name, self.type)
413
441
        self.group.AddService(
414
442
            self.interface,
415
443
            self.protocol,
422
450
 
423
451
    def entry_group_state_changed(self, state, error):
424
452
        """Derived from the Avahi example code"""
425
 
        logger.debug("Avahi entry group state change: %i", state)
 
453
        log.debug("Avahi entry group state change: %i", state)
426
454
 
427
455
        if state == avahi.ENTRY_GROUP_ESTABLISHED:
428
 
            logger.debug("Zeroconf service established.")
 
456
            log.debug("Zeroconf service established.")
429
457
        elif state == avahi.ENTRY_GROUP_COLLISION:
430
 
            logger.info("Zeroconf service name collision.")
 
458
            log.info("Zeroconf service name collision.")
431
459
            self.rename()
432
460
        elif state == avahi.ENTRY_GROUP_FAILURE:
433
 
            logger.critical("Avahi: Error in group state changed %s",
434
 
                            str(error))
 
461
            log.critical("Avahi: Error in group state changed %s",
 
462
                         str(error))
435
463
            raise AvahiGroupError("State changed: {!s}".format(error))
436
464
 
437
465
    def cleanup(self):
447
475
 
448
476
    def server_state_changed(self, state, error=None):
449
477
        """Derived from the Avahi example code"""
450
 
        logger.debug("Avahi server state change: %i", state)
 
478
        log.debug("Avahi server state change: %i", state)
451
479
        bad_states = {
452
480
            avahi.SERVER_INVALID: "Zeroconf server invalid",
453
481
            avahi.SERVER_REGISTERING: None,
457
485
        if state in bad_states:
458
486
            if bad_states[state] is not None:
459
487
                if error is None:
460
 
                    logger.error(bad_states[state])
 
488
                    log.error(bad_states[state])
461
489
                else:
462
 
                    logger.error(bad_states[state] + ": %r", error)
 
490
                    log.error(bad_states[state] + ": %r", error)
463
491
            self.cleanup()
464
492
        elif state == avahi.SERVER_RUNNING:
465
493
            try:
467
495
            except dbus.exceptions.DBusException as error:
468
496
                if (error.get_dbus_name()
469
497
                    == "org.freedesktop.Avahi.CollisionError"):
470
 
                    logger.info("Local Zeroconf service name"
471
 
                                " collision.")
 
498
                    log.info("Local Zeroconf service name collision.")
472
499
                    return self.rename(remove=False)
473
500
                else:
474
 
                    logger.critical("D-Bus Exception", exc_info=error)
 
501
                    log.critical("D-Bus Exception", exc_info=error)
475
502
                    self.cleanup()
476
503
                    os._exit(1)
477
504
        else:
478
505
            if error is None:
479
 
                logger.debug("Unknown state: %r", state)
 
506
                log.debug("Unknown state: %r", state)
480
507
            else:
481
 
                logger.debug("Unknown state: %r: %r", state, error)
 
508
                log.debug("Unknown state: %r: %r", state, error)
482
509
 
483
510
    def activate(self):
484
511
        """Derived from the Avahi example code"""
496
523
class AvahiServiceToSyslog(AvahiService):
497
524
    def rename(self, *args, **kwargs):
498
525
        """Add the new name to the syslog messages"""
499
 
        ret = super(AvahiServiceToSyslog, self).rename(*args, **kwargs)
 
526
        ret = super(AvahiServiceToSyslog, self).rename(*args,
 
527
                                                       **kwargs)
500
528
        syslogger.setFormatter(logging.Formatter(
501
 
            'Mandos ({}) [%(process)d]: %(levelname)s: %(message)s'
 
529
            "Mandos ({}) [%(process)d]: %(levelname)s: %(message)s"
502
530
            .format(self.name)))
503
531
        return ret
504
532
 
505
533
 
506
534
# Pretend that we have a GnuTLS module
507
 
class GnuTLS(object):
508
 
    """This isn't so much a class as it is a module-like namespace.
509
 
    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."""
510
537
 
511
538
    library = ctypes.util.find_library("gnutls")
512
539
    if library is None:
513
540
        library = ctypes.util.find_library("gnutls-deb0")
514
541
    _library = ctypes.cdll.LoadLibrary(library)
515
542
    del library
516
 
    _need_version = b"3.3.0"
517
 
    _tls_rawpk_version = b"3.6.6"
518
 
 
519
 
    def __init__(self):
520
 
        # Need to use "self" here, since this method is called before
521
 
        # the assignment to the "gnutls" global variable happens.
522
 
        if self.check_version(self._need_version) is None:
523
 
            raise self.Error("Needs GnuTLS {} or later"
524
 
                             .format(self._need_version))
525
543
 
526
544
    # Unless otherwise indicated, the constants and types below are
527
545
    # all from the gnutls/gnutls.h C header file.
544
562
    OPENPGP_FMT_RAW = 0         # gnutls/openpgp.h
545
563
 
546
564
    # Types
547
 
    class session_int(ctypes.Structure):
 
565
    class _session_int(ctypes.Structure):
548
566
        _fields_ = []
549
 
    session_t = ctypes.POINTER(session_int)
 
567
    session_t = ctypes.POINTER(_session_int)
550
568
 
551
569
    class certificate_credentials_st(ctypes.Structure):
552
570
        _fields_ = []
555
573
    certificate_type_t = ctypes.c_int
556
574
 
557
575
    class datum_t(ctypes.Structure):
558
 
        _fields_ = [('data', ctypes.POINTER(ctypes.c_ubyte)),
559
 
                    ('size', ctypes.c_uint)]
 
576
        _fields_ = [("data", ctypes.POINTER(ctypes.c_ubyte)),
 
577
                    ("size", ctypes.c_uint)]
560
578
 
561
 
    class openpgp_crt_int(ctypes.Structure):
 
579
    class _openpgp_crt_int(ctypes.Structure):
562
580
        _fields_ = []
563
 
    openpgp_crt_t = ctypes.POINTER(openpgp_crt_int)
 
581
    openpgp_crt_t = ctypes.POINTER(_openpgp_crt_int)
564
582
    openpgp_crt_fmt_t = ctypes.c_int  # gnutls/openpgp.h
565
583
    log_func = ctypes.CFUNCTYPE(None, ctypes.c_int, ctypes.c_char_p)
566
584
    credentials_type_t = ctypes.c_int
569
587
 
570
588
    # Exceptions
571
589
    class Error(Exception):
572
 
        # We need to use the class name "GnuTLS" here, since this
573
 
        # exception might be raised from within GnuTLS.__init__,
574
 
        # which is called before the assignment to the "gnutls"
575
 
        # global variable has happened.
576
590
        def __init__(self, message=None, code=None, args=()):
577
591
            # Default usage is by a message string, but if a return
578
592
            # code is passed, convert it to a string with
579
593
            # gnutls.strerror()
580
594
            self.code = code
581
595
            if message is None and code is not None:
582
 
                message = GnuTLS.strerror(code)
583
 
            return super(GnuTLS.Error, self).__init__(
 
596
                message = gnutls.strerror(code).decode(
 
597
                    "utf-8", errors="replace")
 
598
            return super(gnutls.Error, self).__init__(
584
599
                message, *args)
585
600
 
586
601
    class CertificateSecurityError(Error):
587
602
        pass
588
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
 
589
629
    # Classes
590
 
    class Credentials(object):
 
630
    class Credentials(With_from_param):
591
631
        def __init__(self):
592
 
            self._c_object = gnutls.certificate_credentials_t()
593
 
            gnutls.certificate_allocate_credentials(
594
 
                ctypes.byref(self._c_object))
 
632
            self._as_parameter_ = gnutls.certificate_credentials_t()
 
633
            gnutls.certificate_allocate_credentials(self)
595
634
            self.type = gnutls.CRD_CERTIFICATE
596
635
 
597
636
        def __del__(self):
598
 
            gnutls.certificate_free_credentials(self._c_object)
 
637
            gnutls.certificate_free_credentials(self)
599
638
 
600
 
    class ClientSession(object):
 
639
    class ClientSession(With_from_param):
601
640
        def __init__(self, socket, credentials=None):
602
 
            self._c_object = gnutls.session_t()
 
641
            self._as_parameter_ = gnutls.session_t()
603
642
            gnutls_flags = gnutls.CLIENT
604
 
            if gnutls.check_version("3.5.6"):
 
643
            if gnutls.check_version(b"3.5.6"):
605
644
                gnutls_flags |= gnutls.NO_TICKETS
606
645
            if gnutls.has_rawpk:
607
646
                gnutls_flags |= gnutls.ENABLE_RAWPK
608
 
            gnutls.init(ctypes.byref(self._c_object), gnutls_flags)
 
647
            gnutls.init(self, gnutls_flags)
609
648
            del gnutls_flags
610
 
            gnutls.set_default_priority(self._c_object)
611
 
            gnutls.transport_set_ptr(self._c_object, socket.fileno())
612
 
            gnutls.handshake_set_private_extensions(self._c_object,
613
 
                                                    True)
 
649
            gnutls.set_default_priority(self)
 
650
            gnutls.transport_set_ptr(self, socket.fileno())
 
651
            gnutls.handshake_set_private_extensions(self, True)
614
652
            self.socket = socket
615
653
            if credentials is None:
616
654
                credentials = gnutls.Credentials()
617
 
            gnutls.credentials_set(self._c_object, credentials.type,
618
 
                                   ctypes.cast(credentials._c_object,
619
 
                                               ctypes.c_void_p))
 
655
            gnutls.credentials_set(self, credentials.type,
 
656
                                   credentials)
620
657
            self.credentials = credentials
621
658
 
622
659
        def __del__(self):
623
 
            gnutls.deinit(self._c_object)
 
660
            gnutls.deinit(self)
624
661
 
625
662
        def handshake(self):
626
 
            return gnutls.handshake(self._c_object)
 
663
            return gnutls.handshake(self)
627
664
 
628
665
        def send(self, data):
629
666
            data = bytes(data)
630
667
            data_len = len(data)
631
668
            while data_len > 0:
632
 
                data_len -= gnutls.record_send(self._c_object,
633
 
                                               data[-data_len:],
 
669
                data_len -= gnutls.record_send(self, data[-data_len:],
634
670
                                               data_len)
635
671
 
636
672
        def bye(self):
637
 
            return gnutls.bye(self._c_object, gnutls.SHUT_RDWR)
 
673
            return gnutls.bye(self, gnutls.SHUT_RDWR)
638
674
 
639
675
    # Error handling functions
640
676
    def _error_code(result):
641
677
        """A function to raise exceptions on errors, suitable
642
 
        for the 'restype' attribute on ctypes functions"""
643
 
        if result >= 0:
 
678
        for the "restype" attribute on ctypes functions"""
 
679
        if result >= gnutls.E_SUCCESS:
644
680
            return result
645
681
        if result == gnutls.E_NO_CERTIFICATE_FOUND:
646
682
            raise gnutls.CertificateSecurityError(code=result)
647
683
        raise gnutls.Error(code=result)
648
684
 
649
 
    def _retry_on_error(result, func, arguments):
 
685
    def _retry_on_error(result, func, arguments,
 
686
                        _error_code=_error_code):
650
687
        """A function to retry on some errors, suitable
651
 
        for the 'errcheck' attribute on ctypes functions"""
652
 
        while result < 0:
 
688
        for the "errcheck" attribute on ctypes functions"""
 
689
        while result < gnutls.E_SUCCESS:
653
690
            if result not in (gnutls.E_INTERRUPTED, gnutls.E_AGAIN):
654
691
                return _error_code(result)
655
692
            result = func(*arguments)
660
697
 
661
698
    # Functions
662
699
    priority_set_direct = _library.gnutls_priority_set_direct
663
 
    priority_set_direct.argtypes = [session_t, ctypes.c_char_p,
 
700
    priority_set_direct.argtypes = [ClientSession, ctypes.c_char_p,
664
701
                                    ctypes.POINTER(ctypes.c_char_p)]
665
702
    priority_set_direct.restype = _error_code
666
703
 
667
704
    init = _library.gnutls_init
668
 
    init.argtypes = [ctypes.POINTER(session_t), ctypes.c_int]
 
705
    init.argtypes = [PointerTo(ClientSession), ctypes.c_int]
669
706
    init.restype = _error_code
670
707
 
671
708
    set_default_priority = _library.gnutls_set_default_priority
672
 
    set_default_priority.argtypes = [session_t]
 
709
    set_default_priority.argtypes = [ClientSession]
673
710
    set_default_priority.restype = _error_code
674
711
 
675
712
    record_send = _library.gnutls_record_send
676
 
    record_send.argtypes = [session_t, ctypes.c_void_p,
 
713
    record_send.argtypes = [ClientSession, ctypes.c_void_p,
677
714
                            ctypes.c_size_t]
678
715
    record_send.restype = ctypes.c_ssize_t
679
716
    record_send.errcheck = _retry_on_error
681
718
    certificate_allocate_credentials = (
682
719
        _library.gnutls_certificate_allocate_credentials)
683
720
    certificate_allocate_credentials.argtypes = [
684
 
        ctypes.POINTER(certificate_credentials_t)]
 
721
        PointerTo(Credentials)]
685
722
    certificate_allocate_credentials.restype = _error_code
686
723
 
687
724
    certificate_free_credentials = (
688
725
        _library.gnutls_certificate_free_credentials)
689
 
    certificate_free_credentials.argtypes = [
690
 
        certificate_credentials_t]
 
726
    certificate_free_credentials.argtypes = [Credentials]
691
727
    certificate_free_credentials.restype = None
692
728
 
693
729
    handshake_set_private_extensions = (
694
730
        _library.gnutls_handshake_set_private_extensions)
695
 
    handshake_set_private_extensions.argtypes = [session_t,
 
731
    handshake_set_private_extensions.argtypes = [ClientSession,
696
732
                                                 ctypes.c_int]
697
733
    handshake_set_private_extensions.restype = None
698
734
 
699
735
    credentials_set = _library.gnutls_credentials_set
700
 
    credentials_set.argtypes = [session_t, credentials_type_t,
701
 
                                ctypes.c_void_p]
 
736
    credentials_set.argtypes = [ClientSession, credentials_type_t,
 
737
                                CastToVoidPointer(Credentials)]
702
738
    credentials_set.restype = _error_code
703
739
 
704
740
    strerror = _library.gnutls_strerror
706
742
    strerror.restype = ctypes.c_char_p
707
743
 
708
744
    certificate_type_get = _library.gnutls_certificate_type_get
709
 
    certificate_type_get.argtypes = [session_t]
 
745
    certificate_type_get.argtypes = [ClientSession]
710
746
    certificate_type_get.restype = _error_code
711
747
 
712
748
    certificate_get_peers = _library.gnutls_certificate_get_peers
713
 
    certificate_get_peers.argtypes = [session_t,
 
749
    certificate_get_peers.argtypes = [ClientSession,
714
750
                                      ctypes.POINTER(ctypes.c_uint)]
715
751
    certificate_get_peers.restype = ctypes.POINTER(datum_t)
716
752
 
723
759
    global_set_log_function.restype = None
724
760
 
725
761
    deinit = _library.gnutls_deinit
726
 
    deinit.argtypes = [session_t]
 
762
    deinit.argtypes = [ClientSession]
727
763
    deinit.restype = None
728
764
 
729
765
    handshake = _library.gnutls_handshake
730
 
    handshake.argtypes = [session_t]
731
 
    handshake.restype = _error_code
 
766
    handshake.argtypes = [ClientSession]
 
767
    handshake.restype = ctypes.c_int
732
768
    handshake.errcheck = _retry_on_error
733
769
 
734
770
    transport_set_ptr = _library.gnutls_transport_set_ptr
735
 
    transport_set_ptr.argtypes = [session_t, transport_ptr_t]
 
771
    transport_set_ptr.argtypes = [ClientSession, transport_ptr_t]
736
772
    transport_set_ptr.restype = None
737
773
 
738
774
    bye = _library.gnutls_bye
739
 
    bye.argtypes = [session_t, close_request_t]
740
 
    bye.restype = _error_code
 
775
    bye.argtypes = [ClientSession, close_request_t]
 
776
    bye.restype = ctypes.c_int
741
777
    bye.errcheck = _retry_on_error
742
778
 
743
779
    check_version = _library.gnutls_check_version
744
780
    check_version.argtypes = [ctypes.c_char_p]
745
781
    check_version.restype = ctypes.c_char_p
746
782
 
 
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"
747
789
    has_rawpk = bool(check_version(_tls_rawpk_version))
748
790
 
749
791
    if has_rawpk:
754
796
 
755
797
        x509_crt_fmt_t = ctypes.c_int
756
798
 
757
 
        # All the function declarations below are from gnutls/abstract.h
 
799
        # All the function declarations below are from
 
800
        # gnutls/abstract.h
758
801
        pubkey_init = _library.gnutls_pubkey_init
759
802
        pubkey_init.argtypes = [ctypes.POINTER(pubkey_t)]
760
803
        pubkey_init.restype = _error_code
774
817
        pubkey_deinit.argtypes = [pubkey_t]
775
818
        pubkey_deinit.restype = None
776
819
    else:
777
 
        # All the function declarations below are from gnutls/openpgp.h
 
820
        # All the function declarations below are from
 
821
        # gnutls/openpgp.h
778
822
 
779
823
        openpgp_crt_init = _library.gnutls_openpgp_crt_init
780
824
        openpgp_crt_init.argtypes = [ctypes.POINTER(openpgp_crt_t)]
786
830
                                       openpgp_crt_fmt_t]
787
831
        openpgp_crt_import.restype = _error_code
788
832
 
789
 
        openpgp_crt_verify_self = _library.gnutls_openpgp_crt_verify_self
790
 
        openpgp_crt_verify_self.argtypes = [openpgp_crt_t, ctypes.c_uint,
791
 
                                            ctypes.POINTER(ctypes.c_uint)]
 
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
        ]
792
840
        openpgp_crt_verify_self.restype = _error_code
793
841
 
794
842
        openpgp_crt_deinit = _library.gnutls_openpgp_crt_deinit
803
851
                                                    ctypes.c_size_t)]
804
852
        openpgp_crt_get_fingerprint.restype = _error_code
805
853
 
806
 
    if check_version("3.6.4"):
 
854
    if check_version(b"3.6.4"):
807
855
        certificate_type_get2 = _library.gnutls_certificate_type_get2
808
 
        certificate_type_get2.argtypes = [session_t, ctypes.c_int]
 
856
        certificate_type_get2.argtypes = [ClientSession, ctypes.c_int]
809
857
        certificate_type_get2.restype = _error_code
810
858
 
811
859
    # Remove non-public functions
812
860
    del _error_code, _retry_on_error
813
 
# Create the global "gnutls" object, simulating a module
814
 
gnutls = GnuTLS()
815
861
 
816
862
 
817
863
def call_pipe(connection,       # : multiprocessing.Connection
825
871
    connection.close()
826
872
 
827
873
 
828
 
class Client(object):
 
874
class Client:
829
875
    """A representation of a client host served by this server.
830
876
 
831
877
    Attributes:
832
 
    approved:   bool(); 'None' if not yet approved/disapproved
 
878
    approved:   bool(); None if not yet approved/disapproved
833
879
    approval_delay: datetime.timedelta(); Time to wait for approval
834
880
    approval_duration: datetime.timedelta(); Duration of one approval
835
 
    checker:    subprocess.Popen(); a running checker process used
836
 
                                    to see if the client lives.
837
 
                                    '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.
838
884
    checker_callback_tag: a GLib event source tag, or None
839
885
    checker_command: string; External command which is run to check
840
886
                     if client lives.  %() expansions are done at
915
961
            # key_id() and fingerprint() functions
916
962
            client["key_id"] = (section.get("key_id", "").upper()
917
963
                                .replace(" ", ""))
918
 
            client["fingerprint"] = (section["fingerprint"].upper()
 
964
            client["fingerprint"] = (section.get("fingerprint",
 
965
                                                 "").upper()
919
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
920
972
            if "secret" in section:
921
973
                client["secret"] = codecs.decode(section["secret"]
922
974
                                                 .encode("utf-8"),
963
1015
            self.last_enabled = None
964
1016
            self.expires = None
965
1017
 
966
 
        logger.debug("Creating client %r", self.name)
967
 
        logger.debug("  Key ID: %s", self.key_id)
968
 
        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)
969
1021
        self.created = settings.get("created",
970
1022
                                    datetime.datetime.utcnow())
971
1023
 
999
1051
        if getattr(self, "enabled", False):
1000
1052
            # Already enabled
1001
1053
            return
1002
 
        self.expires = datetime.datetime.utcnow() + self.timeout
1003
1054
        self.enabled = True
1004
1055
        self.last_enabled = datetime.datetime.utcnow()
1005
1056
        self.init_checker()
1010
1061
        if not getattr(self, "enabled", False):
1011
1062
            return False
1012
1063
        if not quiet:
1013
 
            logger.info("Disabling client %s", self.name)
 
1064
            log.info("Disabling client %s", self.name)
1014
1065
        if getattr(self, "disable_initiator_tag", None) is not None:
1015
1066
            GLib.source_remove(self.disable_initiator_tag)
1016
1067
            self.disable_initiator_tag = None
1028
1079
    def __del__(self):
1029
1080
        self.disable()
1030
1081
 
1031
 
    def init_checker(self):
1032
 
        # Schedule a new checker to be started an 'interval' from now,
1033
 
        # 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.
1034
1087
        if self.checker_initiator_tag is not None:
1035
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
1036
1096
        self.checker_initiator_tag = GLib.timeout_add(
1037
 
            int(self.interval.total_seconds() * 1000),
1038
 
            self.start_checker)
1039
 
        # 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
1040
1106
        if self.disable_initiator_tag is not None:
1041
1107
            GLib.source_remove(self.disable_initiator_tag)
1042
1108
        self.disable_initiator_tag = GLib.timeout_add(
1043
 
            int(self.timeout.total_seconds() * 1000), self.disable)
1044
 
        # Also start a new checker *right now*.
1045
 
        self.start_checker()
 
1109
            int((self.expires - now).total_seconds() * 1000),
 
1110
            self.disable)
1046
1111
 
1047
1112
    def checker_callback(self, source, condition, connection,
1048
1113
                         command):
1049
1114
        """The checker has completed, so take appropriate actions."""
1050
 
        self.checker_callback_tag = None
1051
 
        self.checker = None
1052
1115
        # Read return code from connection (see call_pipe)
1053
1116
        returncode = connection.recv()
1054
1117
        connection.close()
 
1118
        if self.checker is not None:
 
1119
            self.checker.join()
 
1120
        self.checker_callback_tag = None
 
1121
        self.checker = None
1055
1122
 
1056
1123
        if returncode >= 0:
1057
1124
            self.last_checker_status = returncode
1058
1125
            self.last_checker_signal = None
1059
1126
            if self.last_checker_status == 0:
1060
 
                logger.info("Checker for %(name)s succeeded",
1061
 
                            vars(self))
 
1127
                log.info("Checker for %(name)s succeeded", vars(self))
1062
1128
                self.checked_ok()
1063
1129
            else:
1064
 
                logger.info("Checker for %(name)s failed", vars(self))
 
1130
                log.info("Checker for %(name)s failed", vars(self))
1065
1131
        else:
1066
1132
            self.last_checker_status = -1
1067
1133
            self.last_checker_signal = -returncode
1068
 
            logger.warning("Checker for %(name)s crashed?",
1069
 
                           vars(self))
 
1134
            log.warning("Checker for %(name)s crashed?", vars(self))
1070
1135
        return False
1071
1136
 
1072
1137
    def checked_ok(self):
1091
1156
    def need_approval(self):
1092
1157
        self.last_approval_request = datetime.datetime.utcnow()
1093
1158
 
1094
 
    def start_checker(self):
 
1159
    def start_checker(self, start_was_randomized=False):
1095
1160
        """Start a new checker subprocess if one is not running.
1096
1161
 
1097
1162
        If a checker already exists, leave it running and do
1106
1171
        # should be.
1107
1172
 
1108
1173
        if self.checker is not None and not self.checker.is_alive():
1109
 
            logger.warning("Checker was not alive; joining")
 
1174
            log.warning("Checker was not alive; joining")
1110
1175
            self.checker.join()
1111
1176
            self.checker = None
1112
1177
        # Start a new checker if needed
1113
1178
        if self.checker is None:
1114
1179
            # Escape attributes for the shell
1115
1180
            escaped_attrs = {
1116
 
                attr: re.escape(str(getattr(self, attr)))
 
1181
                attr: shlex.quote(str(getattr(self, attr)))
1117
1182
                for attr in self.runtime_expansions}
1118
1183
            try:
1119
1184
                command = self.checker_command % escaped_attrs
1120
1185
            except TypeError as error:
1121
 
                logger.error('Could not format string "%s"',
1122
 
                             self.checker_command,
1123
 
                             exc_info=error)
 
1186
                log.error('Could not format string "%s"',
 
1187
                          self.checker_command, exc_info=error)
1124
1188
                return True     # Try again later
1125
1189
            self.current_checker_command = command
1126
 
            logger.info("Starting checker %r for %s", command,
1127
 
                        self.name)
 
1190
            log.info("Starting checker %r for %s", command, self.name)
1128
1191
            # We don't need to redirect stdout and stderr, since
1129
1192
            # in normal mode, that is already done by daemon(),
1130
1193
            # and in debug mode we don't want to.  (Stdin is
1146
1209
                kwargs=popen_args)
1147
1210
            self.checker.start()
1148
1211
            self.checker_callback_tag = GLib.io_add_watch(
1149
 
                pipe[0].fileno(), GLib.IO_IN,
 
1212
                GLib.IOChannel.unix_new(pipe[0].fileno()),
 
1213
                GLib.PRIORITY_DEFAULT, GLib.IO_IN,
1150
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
1151
1226
        # Re-run this periodically if run by GLib.timeout_add
1152
1227
        return True
1153
1228
 
1158
1233
            self.checker_callback_tag = None
1159
1234
        if getattr(self, "checker", None) is None:
1160
1235
            return
1161
 
        logger.debug("Stopping checker for %(name)s", vars(self))
 
1236
        log.debug("Stopping checker for %(name)s", vars(self))
1162
1237
        self.checker.terminate()
1163
1238
        self.checker = None
1164
1239
 
1191
1266
        func._dbus_name = func.__name__
1192
1267
        if func._dbus_name.endswith("_dbus_property"):
1193
1268
            func._dbus_name = func._dbus_name[:-14]
1194
 
        func._dbus_get_args_options = {'byte_arrays': byte_arrays}
 
1269
        func._dbus_get_args_options = {"byte_arrays": byte_arrays}
1195
1270
        return func
1196
1271
 
1197
1272
    return decorator
1286
1361
 
1287
1362
    @dbus.service.method(dbus.INTROSPECTABLE_IFACE,
1288
1363
                         out_signature="s",
1289
 
                         path_keyword='object_path',
1290
 
                         connection_keyword='connection')
 
1364
                         path_keyword="object_path",
 
1365
                         connection_keyword="connection")
1291
1366
    def Introspect(self, object_path, connection):
1292
1367
        """Overloading of standard D-Bus method.
1293
1368
 
1342
1417
            document.unlink()
1343
1418
        except (AttributeError, xml.dom.DOMException,
1344
1419
                xml.parsers.expat.ExpatError) as error:
1345
 
            logger.error("Failed to override Introspection method",
1346
 
                         exc_info=error)
 
1420
            log.error("Failed to override Introspection method",
 
1421
                      exc_info=error)
1347
1422
        return xmlstring
1348
1423
 
1349
1424
 
1407
1482
                raise ValueError("Byte arrays not supported for non-"
1408
1483
                                 "'ay' signature {!r}"
1409
1484
                                 .format(prop._dbus_signature))
1410
 
            value = dbus.ByteArray(b''.join(chr(byte)
1411
 
                                            for byte in value))
 
1485
            value = dbus.ByteArray(bytes(value))
1412
1486
        prop(value)
1413
1487
 
1414
1488
    @dbus.service.method(dbus.PROPERTIES_IFACE,
1447
1521
 
1448
1522
    @dbus.service.method(dbus.INTROSPECTABLE_IFACE,
1449
1523
                         out_signature="s",
1450
 
                         path_keyword='object_path',
1451
 
                         connection_keyword='connection')
 
1524
                         path_keyword="object_path",
 
1525
                         connection_keyword="connection")
1452
1526
    def Introspect(self, object_path, connection):
1453
1527
        """Overloading of standard D-Bus method.
1454
1528
 
1510
1584
            document.unlink()
1511
1585
        except (AttributeError, xml.dom.DOMException,
1512
1586
                xml.parsers.expat.ExpatError) as error:
1513
 
            logger.error("Failed to override Introspection method",
1514
 
                         exc_info=error)
 
1587
            log.error("Failed to override Introspection method",
 
1588
                      exc_info=error)
1515
1589
        return xmlstring
1516
1590
 
1517
1591
 
1549
1623
 
1550
1624
    @dbus.service.method(dbus.INTROSPECTABLE_IFACE,
1551
1625
                         out_signature="s",
1552
 
                         path_keyword='object_path',
1553
 
                         connection_keyword='connection')
 
1626
                         path_keyword="object_path",
 
1627
                         connection_keyword="connection")
1554
1628
    def Introspect(self, object_path, connection):
1555
1629
        """Overloading of standard D-Bus method.
1556
1630
 
1581
1655
            document.unlink()
1582
1656
        except (AttributeError, xml.dom.DOMException,
1583
1657
                xml.parsers.expat.ExpatError) as error:
1584
 
            logger.error("Failed to override Introspection method",
1585
 
                         exc_info=error)
 
1658
            log.error("Failed to override Introspection method",
 
1659
                      exc_info=error)
1586
1660
        return xmlstring
1587
1661
 
1588
1662
 
2219
2293
    del _interface
2220
2294
 
2221
2295
 
2222
 
class ProxyClient(object):
 
2296
class ProxyClient:
2223
2297
    def __init__(self, child_pipe, key_id, fpr, address):
2224
2298
        self._pipe = child_pipe
2225
 
        self._pipe.send(('init', key_id, fpr, address))
 
2299
        self._pipe.send(("init", key_id, fpr, address))
2226
2300
        if not self._pipe.recv():
2227
2301
            raise KeyError(key_id or fpr)
2228
2302
 
2229
2303
    def __getattribute__(self, name):
2230
 
        if name == '_pipe':
 
2304
        if name == "_pipe":
2231
2305
            return super(ProxyClient, self).__getattribute__(name)
2232
 
        self._pipe.send(('getattr', name))
 
2306
        self._pipe.send(("getattr", name))
2233
2307
        data = self._pipe.recv()
2234
 
        if data[0] == 'data':
 
2308
        if data[0] == "data":
2235
2309
            return data[1]
2236
 
        if data[0] == 'function':
 
2310
        if data[0] == "function":
2237
2311
 
2238
2312
            def func(*args, **kwargs):
2239
 
                self._pipe.send(('funcall', name, args, kwargs))
 
2313
                self._pipe.send(("funcall", name, args, kwargs))
2240
2314
                return self._pipe.recv()[1]
2241
2315
 
2242
2316
            return func
2243
2317
 
2244
2318
    def __setattr__(self, name, value):
2245
 
        if name == '_pipe':
 
2319
        if name == "_pipe":
2246
2320
            return super(ProxyClient, self).__setattr__(name, value)
2247
 
        self._pipe.send(('setattr', name, value))
 
2321
        self._pipe.send(("setattr", name, value))
2248
2322
 
2249
2323
 
2250
2324
class ClientHandler(socketserver.BaseRequestHandler, object):
2255
2329
 
2256
2330
    def handle(self):
2257
2331
        with contextlib.closing(self.server.child_pipe) as child_pipe:
2258
 
            logger.info("TCP connection from: %s",
2259
 
                        str(self.client_address))
2260
 
            logger.debug("Pipe FD: %d",
2261
 
                         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())
2262
2335
 
2263
2336
            session = gnutls.ClientSession(self.request)
2264
2337
 
2265
 
            # priority = ':'.join(("NONE", "+VERS-TLS1.1",
 
2338
            # priority = ":".join(("NONE", "+VERS-TLS1.1",
2266
2339
            #                       "+AES-256-CBC", "+SHA1",
2267
2340
            #                       "+COMP-NULL", "+CTYPE-OPENPGP",
2268
2341
            #                       "+DHE-DSS"))
2270
2343
            priority = self.server.gnutls_priority
2271
2344
            if priority is None:
2272
2345
                priority = "NORMAL"
2273
 
            gnutls.priority_set_direct(session._c_object,
2274
 
                                       priority.encode("utf-8"),
2275
 
                                       None)
 
2346
            gnutls.priority_set_direct(session,
 
2347
                                       priority.encode("utf-8"), None)
2276
2348
 
2277
2349
            # Start communication using the Mandos protocol
2278
2350
            # Get protocol number
2279
2351
            line = self.request.makefile().readline()
2280
 
            logger.debug("Protocol version: %r", line)
 
2352
            log.debug("Protocol version: %r", line)
2281
2353
            try:
2282
2354
                if int(line.strip().split()[0]) > 1:
2283
2355
                    raise RuntimeError(line)
2284
2356
            except (ValueError, IndexError, RuntimeError) as error:
2285
 
                logger.error("Unknown protocol version: %s", error)
 
2357
                log.error("Unknown protocol version: %s", error)
2286
2358
                return
2287
2359
 
2288
2360
            # Start GnuTLS connection
2289
2361
            try:
2290
2362
                session.handshake()
2291
2363
            except gnutls.Error as error:
2292
 
                logger.warning("Handshake failed: %s", error)
 
2364
                log.warning("Handshake failed: %s", error)
2293
2365
                # Do not run session.bye() here: the session is not
2294
2366
                # established.  Just abandon the request.
2295
2367
                return
2296
 
            logger.debug("Handshake succeeded")
 
2368
            log.debug("Handshake succeeded")
2297
2369
 
2298
2370
            approval_required = False
2299
2371
            try:
2300
2372
                if gnutls.has_rawpk:
2301
 
                    fpr = ""
 
2373
                    fpr = b""
2302
2374
                    try:
2303
2375
                        key_id = self.key_id(
2304
2376
                            self.peer_certificate(session))
2305
2377
                    except (TypeError, gnutls.Error) as error:
2306
 
                        logger.warning("Bad certificate: %s", error)
 
2378
                        log.warning("Bad certificate: %s", error)
2307
2379
                        return
2308
 
                    logger.debug("Key ID: %s", key_id)
 
2380
                    log.debug("Key ID: %s",
 
2381
                              key_id.decode("utf-8",
 
2382
                                            errors="replace"))
2309
2383
 
2310
2384
                else:
2311
 
                    key_id = ""
 
2385
                    key_id = b""
2312
2386
                    try:
2313
2387
                        fpr = self.fingerprint(
2314
2388
                            self.peer_certificate(session))
2315
2389
                    except (TypeError, gnutls.Error) as error:
2316
 
                        logger.warning("Bad certificate: %s", error)
 
2390
                        log.warning("Bad certificate: %s", error)
2317
2391
                        return
2318
 
                    logger.debug("Fingerprint: %s", fpr)
 
2392
                    log.debug("Fingerprint: %s", fpr)
2319
2393
 
2320
2394
                try:
2321
2395
                    client = ProxyClient(child_pipe, key_id, fpr,
2330
2404
 
2331
2405
                while True:
2332
2406
                    if not client.enabled:
2333
 
                        logger.info("Client %s is disabled",
2334
 
                                    client.name)
 
2407
                        log.info("Client %s is disabled", client.name)
2335
2408
                        if self.server.use_dbus:
2336
2409
                            # Emit D-Bus signal
2337
2410
                            client.Rejected("Disabled")
2341
2414
                        # We are approved or approval is disabled
2342
2415
                        break
2343
2416
                    elif client.approved is None:
2344
 
                        logger.info("Client %s needs approval",
2345
 
                                    client.name)
 
2417
                        log.info("Client %s needs approval",
 
2418
                                 client.name)
2346
2419
                        if self.server.use_dbus:
2347
2420
                            # Emit D-Bus signal
2348
2421
                            client.NeedApproval(
2349
2422
                                client.approval_delay.total_seconds()
2350
2423
                                * 1000, client.approved_by_default)
2351
2424
                    else:
2352
 
                        logger.warning("Client %s was not approved",
2353
 
                                       client.name)
 
2425
                        log.warning("Client %s was not approved",
 
2426
                                    client.name)
2354
2427
                        if self.server.use_dbus:
2355
2428
                            # Emit D-Bus signal
2356
2429
                            client.Rejected("Denied")
2364
2437
                    time2 = datetime.datetime.now()
2365
2438
                    if (time2 - time) >= delay:
2366
2439
                        if not client.approved_by_default:
2367
 
                            logger.warning("Client %s timed out while"
2368
 
                                           " waiting for approval",
2369
 
                                           client.name)
 
2440
                            log.warning("Client %s timed out while"
 
2441
                                        " waiting for approval",
 
2442
                                        client.name)
2370
2443
                            if self.server.use_dbus:
2371
2444
                                # Emit D-Bus signal
2372
2445
                                client.Rejected("Approval timed out")
2379
2452
                try:
2380
2453
                    session.send(client.secret)
2381
2454
                except gnutls.Error as error:
2382
 
                    logger.warning("gnutls send failed",
2383
 
                                   exc_info=error)
 
2455
                    log.warning("gnutls send failed", exc_info=error)
2384
2456
                    return
2385
2457
 
2386
 
                logger.info("Sending secret to %s", client.name)
 
2458
                log.info("Sending secret to %s", client.name)
2387
2459
                # bump the timeout using extended_timeout
2388
2460
                client.bump_timeout(client.extended_timeout)
2389
2461
                if self.server.use_dbus:
2396
2468
                try:
2397
2469
                    session.bye()
2398
2470
                except gnutls.Error as error:
2399
 
                    logger.warning("GnuTLS bye failed",
2400
 
                                   exc_info=error)
 
2471
                    log.warning("GnuTLS bye failed", exc_info=error)
2401
2472
 
2402
2473
    @staticmethod
2403
2474
    def peer_certificate(session):
2404
2475
        "Return the peer's certificate as a bytestring"
2405
2476
        try:
2406
 
            cert_type = gnutls.certificate_type_get2(session._c_object,
2407
 
                                                     gnutls.CTYPE_PEERS)
 
2477
            cert_type = gnutls.certificate_type_get2(
 
2478
                session, gnutls.CTYPE_PEERS)
2408
2479
        except AttributeError:
2409
 
            cert_type = gnutls.certificate_type_get(session._c_object)
 
2480
            cert_type = gnutls.certificate_type_get(session)
2410
2481
        if gnutls.has_rawpk:
2411
2482
            valid_cert_types = frozenset((gnutls.CRT_RAWPK,))
2412
2483
        else:
2413
2484
            valid_cert_types = frozenset((gnutls.CRT_OPENPGP,))
2414
2485
        # If not a valid certificate type...
2415
2486
        if cert_type not in valid_cert_types:
2416
 
            logger.info("Cert type %r not in %r", cert_type,
2417
 
                        valid_cert_types)
 
2487
            log.info("Cert type %r not in %r", cert_type,
 
2488
                     valid_cert_types)
2418
2489
            # ...return invalid data
2419
2490
            return b""
2420
2491
        list_size = ctypes.c_uint(1)
2421
2492
        cert_list = (gnutls.certificate_get_peers
2422
 
                     (session._c_object, ctypes.byref(list_size)))
 
2493
                     (session, ctypes.byref(list_size)))
2423
2494
        if not bool(cert_list) and list_size.value != 0:
2424
2495
            raise gnutls.Error("error getting peer certificate")
2425
2496
        if list_size.value == 0:
2447
2518
        buf = ctypes.create_string_buffer(32)
2448
2519
        buf_len = ctypes.c_size_t(len(buf))
2449
2520
        # Get the key ID from the raw public key into the buffer
2450
 
        gnutls.pubkey_get_key_id(pubkey,
2451
 
                                 gnutls.KEYID_USE_SHA256,
2452
 
                                 ctypes.cast(ctypes.byref(buf),
2453
 
                                             ctypes.POINTER(ctypes.c_ubyte)),
2454
 
                                 ctypes.byref(buf_len))
 
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))
2455
2527
        # Deinit the certificate
2456
2528
        gnutls.pubkey_deinit(pubkey)
2457
2529
 
2498
2570
        return hex_fpr
2499
2571
 
2500
2572
 
2501
 
class MultiprocessingMixIn(object):
 
2573
class MultiprocessingMixIn:
2502
2574
    """Like socketserver.ThreadingMixIn, but with multiprocessing"""
2503
2575
 
2504
2576
    def sub_process_main(self, request, address):
2516
2588
        return proc
2517
2589
 
2518
2590
 
2519
 
class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):
 
2591
class MultiprocessingMixInWithPipe(MultiprocessingMixIn):
2520
2592
    """ adds a pipe to the MixIn """
2521
2593
 
2522
2594
    def process_request(self, request, client_address):
2537
2609
 
2538
2610
 
2539
2611
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
2540
 
                     socketserver.TCPServer, object):
2541
 
    """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
2542
2614
 
2543
2615
    Attributes:
2544
2616
        enabled:        Boolean; whether this server is activated yet
2595
2667
            if SO_BINDTODEVICE is None:
2596
2668
                # Fall back to a hard-coded value which seems to be
2597
2669
                # common enough.
2598
 
                logger.warning("SO_BINDTODEVICE not found, trying 25")
 
2670
                log.warning("SO_BINDTODEVICE not found, trying 25")
2599
2671
                SO_BINDTODEVICE = 25
2600
2672
            try:
2601
2673
                self.socket.setsockopt(
2603
2675
                    (self.interface + "\0").encode("utf-8"))
2604
2676
            except socket.error as error:
2605
2677
                if error.errno == errno.EPERM:
2606
 
                    logger.error("No permission to bind to"
2607
 
                                 " interface %s", self.interface)
 
2678
                    log.error("No permission to bind to interface %s",
 
2679
                              self.interface)
2608
2680
                elif error.errno == errno.ENOPROTOOPT:
2609
 
                    logger.error("SO_BINDTODEVICE not available;"
2610
 
                                 " cannot bind to interface %s",
2611
 
                                 self.interface)
 
2681
                    log.error("SO_BINDTODEVICE not available; cannot"
 
2682
                              " bind to interface %s", self.interface)
2612
2683
                elif error.errno == errno.ENODEV:
2613
 
                    logger.error("Interface %s does not exist,"
2614
 
                                 " cannot bind", self.interface)
 
2684
                    log.error("Interface %s does not exist, cannot"
 
2685
                              " bind", self.interface)
2615
2686
                else:
2616
2687
                    raise
2617
2688
        # Only bind(2) the socket if we really need to.
2618
2689
        if self.server_address[0] or self.server_address[1]:
 
2690
            if self.server_address[1]:
 
2691
                self.allow_reuse_address = True
2619
2692
            if not self.server_address[0]:
2620
2693
                if self.address_family == socket.AF_INET6:
2621
2694
                    any_address = "::"  # in6addr_any
2674
2747
    def add_pipe(self, parent_pipe, proc):
2675
2748
        # Call "handle_ipc" for both data and EOF events
2676
2749
        GLib.io_add_watch(
2677
 
            parent_pipe.fileno(),
2678
 
            GLib.IO_IN | GLib.IO_HUP,
 
2750
            GLib.IOChannel.unix_new(parent_pipe.fileno()),
 
2751
            GLib.PRIORITY_DEFAULT, GLib.IO_IN | GLib.IO_HUP,
2679
2752
            functools.partial(self.handle_ipc,
2680
2753
                              parent_pipe=parent_pipe,
2681
2754
                              proc=proc))
2694
2767
        request = parent_pipe.recv()
2695
2768
        command = request[0]
2696
2769
 
2697
 
        if command == 'init':
 
2770
        if command == "init":
2698
2771
            key_id = request[1].decode("ascii")
2699
2772
            fpr = request[2].decode("ascii")
2700
2773
            address = request[3]
2701
2774
 
2702
2775
            for c in self.clients.values():
2703
 
                if key_id == "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855":
 
2776
                if key_id == ("E3B0C44298FC1C149AFBF4C8996FB924"
 
2777
                              "27AE41E4649B934CA495991B7852B855"):
2704
2778
                    continue
2705
2779
                if key_id and c.key_id == key_id:
2706
2780
                    client = c
2709
2783
                    client = c
2710
2784
                    break
2711
2785
            else:
2712
 
                logger.info("Client not found for key ID: %s, address"
2713
 
                            ": %s", key_id or fpr, address)
 
2786
                log.info("Client not found for key ID: %s, address:"
 
2787
                         " %s", key_id or fpr, address)
2714
2788
                if self.use_dbus:
2715
2789
                    # Emit D-Bus signal
2716
2790
                    mandos_dbus_service.ClientNotFound(key_id or fpr,
2719
2793
                return False
2720
2794
 
2721
2795
            GLib.io_add_watch(
2722
 
                parent_pipe.fileno(),
2723
 
                GLib.IO_IN | GLib.IO_HUP,
 
2796
                GLib.IOChannel.unix_new(parent_pipe.fileno()),
 
2797
                GLib.PRIORITY_DEFAULT, GLib.IO_IN | GLib.IO_HUP,
2724
2798
                functools.partial(self.handle_ipc,
2725
2799
                                  parent_pipe=parent_pipe,
2726
2800
                                  proc=proc,
2729
2803
            # remove the old hook in favor of the new above hook on
2730
2804
            # same fileno
2731
2805
            return False
2732
 
        if command == 'funcall':
 
2806
        if command == "funcall":
2733
2807
            funcname = request[1]
2734
2808
            args = request[2]
2735
2809
            kwargs = request[3]
2736
2810
 
2737
 
            parent_pipe.send(('data', getattr(client_object,
 
2811
            parent_pipe.send(("data", getattr(client_object,
2738
2812
                                              funcname)(*args,
2739
2813
                                                        **kwargs)))
2740
2814
 
2741
 
        if command == 'getattr':
 
2815
        if command == "getattr":
2742
2816
            attrname = request[1]
2743
2817
            if isinstance(client_object.__getattribute__(attrname),
2744
 
                          collections.Callable):
2745
 
                parent_pipe.send(('function', ))
 
2818
                          collections.abc.Callable):
 
2819
                parent_pipe.send(("function", ))
2746
2820
            else:
2747
2821
                parent_pipe.send((
2748
 
                    'data', client_object.__getattribute__(attrname)))
 
2822
                    "data", client_object.__getattribute__(attrname)))
2749
2823
 
2750
 
        if command == 'setattr':
 
2824
        if command == "setattr":
2751
2825
            attrname = request[1]
2752
2826
            value = request[2]
2753
2827
            setattr(client_object, attrname, value)
2758
2832
def rfc3339_duration_to_delta(duration):
2759
2833
    """Parse an RFC 3339 "duration" and return a datetime.timedelta
2760
2834
 
2761
 
    >>> rfc3339_duration_to_delta("P7D")
2762
 
    datetime.timedelta(7)
2763
 
    >>> rfc3339_duration_to_delta("PT60S")
2764
 
    datetime.timedelta(0, 60)
2765
 
    >>> rfc3339_duration_to_delta("PT60M")
2766
 
    datetime.timedelta(0, 3600)
2767
 
    >>> rfc3339_duration_to_delta("PT24H")
2768
 
    datetime.timedelta(1)
2769
 
    >>> rfc3339_duration_to_delta("P1W")
2770
 
    datetime.timedelta(7)
2771
 
    >>> rfc3339_duration_to_delta("PT5M30S")
2772
 
    datetime.timedelta(0, 330)
2773
 
    >>> rfc3339_duration_to_delta("P1DT3M20S")
2774
 
    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
2775
2851
    """
2776
2852
 
2777
2853
    # Parsing an RFC 3339 duration with regular expressions is not
2857
2933
def string_to_delta(interval):
2858
2934
    """Parse a string and return a datetime.timedelta
2859
2935
 
2860
 
    >>> string_to_delta('7d')
2861
 
    datetime.timedelta(7)
2862
 
    >>> string_to_delta('60s')
2863
 
    datetime.timedelta(0, 60)
2864
 
    >>> string_to_delta('60m')
2865
 
    datetime.timedelta(0, 3600)
2866
 
    >>> string_to_delta('24h')
2867
 
    datetime.timedelta(1)
2868
 
    >>> string_to_delta('1w')
2869
 
    datetime.timedelta(7)
2870
 
    >>> string_to_delta('5m 30s')
2871
 
    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
2872
2948
    """
2873
2949
 
2874
2950
    try:
2976
3052
 
2977
3053
    options = parser.parse_args()
2978
3054
 
2979
 
    if options.check:
2980
 
        import doctest
2981
 
        fail_count, test_count = doctest.testmod()
2982
 
        sys.exit(os.EX_OK if fail_count == 0 else 1)
2983
 
 
2984
3055
    # Default values for config file for server-global settings
2985
3056
    if gnutls.has_rawpk:
2986
3057
        priority = ("SECURE128:!CTYPE-X.509:+CTYPE-RAWPK:!RSA"
3006
3077
    del priority
3007
3078
 
3008
3079
    # Parse config file for server-global settings
3009
 
    server_config = configparser.SafeConfigParser(server_defaults)
 
3080
    server_config = configparser.ConfigParser(server_defaults)
3010
3081
    del server_defaults
3011
3082
    server_config.read(os.path.join(options.configdir, "mandos.conf"))
3012
 
    # Convert the SafeConfigParser object to a dict
 
3083
    # Convert the ConfigParser object to a dict
3013
3084
    server_settings = server_config.defaults()
3014
3085
    # Use the appropriate methods on the non-string config options
3015
3086
    for option in ("debug", "use_dbus", "use_ipv6", "restore",
3082
3153
 
3083
3154
    if server_settings["servicename"] != "Mandos":
3084
3155
        syslogger.setFormatter(
3085
 
            logging.Formatter('Mandos ({}) [%(process)d]:'
3086
 
                              ' %(levelname)s: %(message)s'.format(
 
3156
            logging.Formatter("Mandos ({}) [%(process)d]:"
 
3157
                              " %(levelname)s: %(message)s".format(
3087
3158
                                  server_settings["servicename"])))
3088
3159
 
3089
3160
    # Parse config file with clients
3090
 
    client_config = configparser.SafeConfigParser(Client
3091
 
                                                  .client_defaults)
 
3161
    client_config = configparser.ConfigParser(Client.client_defaults)
3092
3162
    client_config.read(os.path.join(server_settings["configdir"],
3093
3163
                                    "clients.conf"))
3094
3164
 
3114
3184
        try:
3115
3185
            pidfile = codecs.open(pidfilename, "w", encoding="utf-8")
3116
3186
        except IOError as e:
3117
 
            logger.error("Could not open file %r", pidfilename,
3118
 
                         exc_info=e)
 
3187
            log.error("Could not open file %r", pidfilename,
 
3188
                      exc_info=e)
3119
3189
 
3120
3190
    for name, group in (("_mandos", "_mandos"),
3121
3191
                        ("mandos", "mandos"),
3132
3202
    try:
3133
3203
        os.setgid(gid)
3134
3204
        os.setuid(uid)
3135
 
        if debug:
3136
 
            logger.debug("Did setuid/setgid to {}:{}".format(uid,
3137
 
                                                             gid))
 
3205
        log.debug("Did setuid/setgid to %s:%s", uid, gid)
3138
3206
    except OSError as error:
3139
 
        logger.warning("Failed to setuid/setgid to {}:{}: {}"
3140
 
                       .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))
3141
3209
        if error.errno != errno.EPERM:
3142
3210
            raise
3143
3211
 
3150
3218
 
3151
3219
        @gnutls.log_func
3152
3220
        def debug_gnutls(level, string):
3153
 
            logger.debug("GnuTLS: %s", string[:-1])
 
3221
            log.debug("GnuTLS: %s",
 
3222
                      string[:-1].decode("utf-8", errors="replace"))
3154
3223
 
3155
3224
        gnutls.global_set_log_function(debug_gnutls)
3156
3225
 
3165
3234
        # Close all input and output, do double fork, etc.
3166
3235
        daemon()
3167
3236
 
3168
 
    # multiprocessing will use threads, so before we use GLib we need
3169
 
    # to inform GLib that threads will be used.
3170
 
    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()
3171
3241
 
3172
3242
    global main_loop
3173
3243
    # From the Avahi example code
3174
3244
    DBusGMainLoop(set_as_default=True)
3175
3245
    main_loop = GLib.MainLoop()
3176
 
    bus = dbus.SystemBus()
 
3246
    if use_dbus or zeroconf:
 
3247
        bus = dbus.SystemBus()
3177
3248
    # End of Avahi example code
3178
3249
    if use_dbus:
3179
3250
        try:
3184
3255
                "se.bsnet.fukt.Mandos", bus,
3185
3256
                do_not_queue=True)
3186
3257
        except dbus.exceptions.DBusException as e:
3187
 
            logger.error("Disabling D-Bus:", exc_info=e)
 
3258
            log.error("Disabling D-Bus:", exc_info=e)
3188
3259
            use_dbus = False
3189
3260
            server_settings["use_dbus"] = False
3190
3261
            tcp_server.use_dbus = False
3249
3320
                             if isinstance(s, bytes)
3250
3321
                             else s) for s in
3251
3322
                            value["client_structure"]]
3252
 
                        # .name & .host
3253
 
                        for k in ("name", "host"):
 
3323
                        # .name, .host, and .checker_command
 
3324
                        for k in ("name", "host", "checker_command"):
3254
3325
                            if isinstance(value[k], bytes):
3255
3326
                                value[k] = value[k].decode("utf-8")
3256
 
                        if not value.has_key("key_id"):
 
3327
                        if "key_id" not in value:
3257
3328
                            value["key_id"] = ""
3258
 
                        elif not value.has_key("fingerprint"):
 
3329
                        elif "fingerprint" not in value:
3259
3330
                            value["fingerprint"] = ""
3260
3331
                    #  old_client_settings
3261
3332
                    # .keys()
3266
3337
                        for key, value in
3267
3338
                        bytes_old_client_settings.items()}
3268
3339
                    del bytes_old_client_settings
3269
 
                    # .host
 
3340
                    # .host and .checker_command
3270
3341
                    for value in old_client_settings.values():
3271
 
                        if isinstance(value["host"], bytes):
3272
 
                            value["host"] = (value["host"]
3273
 
                                             .decode("utf-8"))
 
3342
                        for attribute in ("host", "checker_command"):
 
3343
                            if isinstance(value[attribute], bytes):
 
3344
                                value[attribute] = (value[attribute]
 
3345
                                                    .decode("utf-8"))
3274
3346
            os.remove(stored_state_path)
3275
3347
        except IOError as e:
3276
3348
            if e.errno == errno.ENOENT:
3277
 
                logger.warning("Could not load persistent state:"
3278
 
                               " {}".format(os.strerror(e.errno)))
 
3349
                log.warning("Could not load persistent state:"
 
3350
                            " %s", os.strerror(e.errno))
3279
3351
            else:
3280
 
                logger.critical("Could not load persistent state:",
3281
 
                                exc_info=e)
 
3352
                log.critical("Could not load persistent state:",
 
3353
                             exc_info=e)
3282
3354
                raise
3283
3355
        except EOFError as e:
3284
 
            logger.warning("Could not load persistent state: "
3285
 
                           "EOFError:",
3286
 
                           exc_info=e)
 
3356
            log.warning("Could not load persistent state: EOFError:",
 
3357
                        exc_info=e)
3287
3358
 
3288
3359
    with PGPEngine() as pgp:
3289
3360
        for client_name, client in clients_data.items():
3316
3387
            if client["enabled"]:
3317
3388
                if datetime.datetime.utcnow() >= client["expires"]:
3318
3389
                    if not client["last_checked_ok"]:
3319
 
                        logger.warning(
3320
 
                            "disabling client {} - Client never "
3321
 
                            "performed a successful checker".format(
3322
 
                                client_name))
 
3390
                        log.warning("disabling client %s - Client"
 
3391
                                    " never performed a successful"
 
3392
                                    " checker", client_name)
3323
3393
                        client["enabled"] = False
3324
3394
                    elif client["last_checker_status"] != 0:
3325
 
                        logger.warning(
3326
 
                            "disabling client {} - Client last"
3327
 
                            " checker failed with error code"
3328
 
                            " {}".format(
3329
 
                                client_name,
3330
 
                                client["last_checker_status"]))
 
3395
                        log.warning("disabling client %s - Client"
 
3396
                                    " last checker failed with error"
 
3397
                                    " code %s", client_name,
 
3398
                                    client["last_checker_status"])
3331
3399
                        client["enabled"] = False
3332
3400
                    else:
3333
3401
                        client["expires"] = (
3334
3402
                            datetime.datetime.utcnow()
3335
3403
                            + client["timeout"])
3336
 
                        logger.debug("Last checker succeeded,"
3337
 
                                     " keeping {} enabled".format(
3338
 
                                         client_name))
 
3404
                        log.debug("Last checker succeeded, keeping %s"
 
3405
                                  " enabled", client_name)
3339
3406
            try:
3340
3407
                client["secret"] = pgp.decrypt(
3341
3408
                    client["encrypted_secret"],
3342
3409
                    client_settings[client_name]["secret"])
3343
3410
            except PGPError:
3344
3411
                # If decryption fails, we use secret from new settings
3345
 
                logger.debug("Failed to decrypt {} old secret".format(
3346
 
                    client_name))
 
3412
                log.debug("Failed to decrypt %s old secret",
 
3413
                          client_name)
3347
3414
                client["secret"] = (client_settings[client_name]
3348
3415
                                    ["secret"])
3349
3416
 
3363
3430
            server_settings=server_settings)
3364
3431
 
3365
3432
    if not tcp_server.clients:
3366
 
        logger.warning("No clients defined")
 
3433
        log.warning("No clients defined")
3367
3434
 
3368
3435
    if not foreground:
3369
3436
        if pidfile is not None:
3372
3439
                with pidfile:
3373
3440
                    print(pid, file=pidfile)
3374
3441
            except IOError:
3375
 
                logger.error("Could not write to file %r with PID %d",
3376
 
                             pidfilename, pid)
 
3442
                log.error("Could not write to file %r with PID %d",
 
3443
                          pidfilename, pid)
3377
3444
        del pidfile
3378
3445
        del pidfilename
3379
3446
 
3529
3596
 
3530
3597
        try:
3531
3598
            with tempfile.NamedTemporaryFile(
3532
 
                    mode='wb',
 
3599
                    mode="wb",
3533
3600
                    suffix=".pickle",
3534
 
                    prefix='clients-',
 
3601
                    prefix="clients-",
3535
3602
                    dir=os.path.dirname(stored_state_path),
3536
3603
                    delete=False) as stored_state:
3537
3604
                pickle.dump((clients, client_settings), stored_state,
3545
3612
                except NameError:
3546
3613
                    pass
3547
3614
            if e.errno in (errno.ENOENT, errno.EACCES, errno.EEXIST):
3548
 
                logger.warning("Could not save persistent state: {}"
3549
 
                               .format(os.strerror(e.errno)))
 
3615
                log.warning("Could not save persistent state: %s",
 
3616
                            os.strerror(e.errno))
3550
3617
            else:
3551
 
                logger.warning("Could not save persistent state:",
3552
 
                               exc_info=e)
 
3618
                log.warning("Could not save persistent state:",
 
3619
                            exc_info=e)
3553
3620
                raise
3554
3621
 
3555
3622
        # Delete all clients, and settings from config
3572
3639
            mandos_dbus_service.client_added_signal(client)
3573
3640
        # Need to initiate checking of clients
3574
3641
        if client.enabled:
3575
 
            client.init_checker()
 
3642
            client.init_checker(randomize_start=True)
3576
3643
 
3577
3644
    tcp_server.enable()
3578
3645
    tcp_server.server_activate()
3581
3648
    if zeroconf:
3582
3649
        service.port = tcp_server.socket.getsockname()[1]
3583
3650
    if use_ipv6:
3584
 
        logger.info("Now listening on address %r, port %d,"
3585
 
                    " flowinfo %d, scope_id %d",
3586
 
                    *tcp_server.socket.getsockname())
 
3651
        log.info("Now listening on address %r, port %d, flowinfo %d,"
 
3652
                 " scope_id %d", *tcp_server.socket.getsockname())
3587
3653
    else:                       # IPv4
3588
 
        logger.info("Now listening on address %r, port %d",
3589
 
                    *tcp_server.socket.getsockname())
 
3654
        log.info("Now listening on address %r, port %d",
 
3655
                 *tcp_server.socket.getsockname())
3590
3656
 
3591
3657
    # service.interface = tcp_server.socket.getsockname()[3]
3592
3658
 
3596
3662
            try:
3597
3663
                service.activate()
3598
3664
            except dbus.exceptions.DBusException as error:
3599
 
                logger.critical("D-Bus Exception", exc_info=error)
 
3665
                log.critical("D-Bus Exception", exc_info=error)
3600
3666
                cleanup()
3601
3667
                sys.exit(1)
3602
3668
            # End of Avahi example code
3603
3669
 
3604
 
        GLib.io_add_watch(tcp_server.fileno(), GLib.IO_IN,
3605
 
                          lambda *args, **kwargs:
3606
 
                          (tcp_server.handle_request
3607
 
                           (*args[2:], **kwargs) or True))
 
3670
        GLib.io_add_watch(
 
3671
            GLib.IOChannel.unix_new(tcp_server.fileno()),
 
3672
            GLib.PRIORITY_DEFAULT, GLib.IO_IN,
 
3673
            lambda *args, **kwargs: (tcp_server.handle_request
 
3674
                                     (*args[2:], **kwargs) or True))
3608
3675
 
3609
 
        logger.debug("Starting main loop")
 
3676
        log.debug("Starting main loop")
3610
3677
        main_loop.run()
3611
3678
    except AvahiError as error:
3612
 
        logger.critical("Avahi Error", exc_info=error)
 
3679
        log.critical("Avahi Error", exc_info=error)
3613
3680
        cleanup()
3614
3681
        sys.exit(1)
3615
3682
    except KeyboardInterrupt:
3616
3683
        if debug:
3617
3684
            print("", file=sys.stderr)
3618
 
        logger.debug("Server received KeyboardInterrupt")
3619
 
    logger.debug("Server exiting")
 
3685
        log.debug("Server received KeyboardInterrupt")
 
3686
    log.debug("Server exiting")
3620
3687
    # Must run before the D-Bus bus name gets deregistered
3621
3688
    cleanup()
3622
3689
 
3623
 
 
3624
 
if __name__ == '__main__':
3625
 
    main()
 
3690
 
 
3691
def parse_test_args():
 
3692
    # type: () -> argparse.Namespace
 
3693
    parser = argparse.ArgumentParser(add_help=False)
 
3694
    parser.add_argument("--check", action="store_true")
 
3695
    parser.add_argument("--prefix", )
 
3696
    args, unknown_args = parser.parse_known_args()
 
3697
    if args.check:
 
3698
        # Remove test options from sys.argv
 
3699
        sys.argv[1:] = unknown_args
 
3700
    return args
 
3701
 
 
3702
# Add all tests from doctest strings
 
3703
def load_tests(loader, tests, none):
 
3704
    import doctest
 
3705
    tests.addTests(doctest.DocTestSuite())
 
3706
    return tests
 
3707
 
 
3708
if __name__ == "__main__":
 
3709
    options = parse_test_args()
 
3710
    try:
 
3711
        if options.check:
 
3712
            extra_test_prefix = options.prefix
 
3713
            if extra_test_prefix is not None:
 
3714
                if not (unittest.main(argv=[""], exit=False)
 
3715
                        .result.wasSuccessful()):
 
3716
                    sys.exit(1)
 
3717
                class ExtraTestLoader(unittest.TestLoader):
 
3718
                    testMethodPrefix = extra_test_prefix
 
3719
                # Call using ./scriptname --test [--verbose]
 
3720
                unittest.main(argv=[""], testLoader=ExtraTestLoader())
 
3721
            else:
 
3722
                unittest.main(argv=[""])
 
3723
        else:
 
3724
            main()
 
3725
    finally:
 
3726
        logging.shutdown()
 
3727
 
 
3728
# Local Variables:
 
3729
# run-tests:
 
3730
# (lambda (&optional extra)
 
3731
#   (if (not (funcall run-tests-in-test-buffer default-directory
 
3732
#             extra))
 
3733
#       (funcall show-test-buffer-in-test-window)
 
3734
#     (funcall remove-test-window)
 
3735
#     (if extra (message "Extra tests run successfully!"))))
 
3736
# run-tests-in-test-buffer:
 
3737
# (lambda (dir &optional extra)
 
3738
#   (with-current-buffer (get-buffer-create "*Test*")
 
3739
#     (setq buffer-read-only nil
 
3740
#           default-directory dir)
 
3741
#     (erase-buffer)
 
3742
#     (compilation-mode))
 
3743
#   (let ((process-result
 
3744
#          (let ((inhibit-read-only t))
 
3745
#            (process-file-shell-command
 
3746
#             (funcall get-command-line extra) nil "*Test*"))))
 
3747
#     (and (numberp process-result)
 
3748
#          (= process-result 0))))
 
3749
# get-command-line:
 
3750
# (lambda (&optional extra)
 
3751
#   (let ((quoted-script
 
3752
#          (shell-quote-argument (funcall get-script-name))))
 
3753
#     (format
 
3754
#      (concat "%s --check" (if extra " --prefix=atest" ""))
 
3755
#      quoted-script)))
 
3756
# get-script-name:
 
3757
# (lambda ()
 
3758
#   (if (fboundp 'file-local-name)
 
3759
#       (file-local-name (buffer-file-name))
 
3760
#     (or (file-remote-p (buffer-file-name) 'localname)
 
3761
#         (buffer-file-name))))
 
3762
# remove-test-window:
 
3763
# (lambda ()
 
3764
#   (let ((test-window (get-buffer-window "*Test*")))
 
3765
#     (if test-window (delete-window test-window))))
 
3766
# show-test-buffer-in-test-window:
 
3767
# (lambda ()
 
3768
#   (when (not (get-buffer-window-list "*Test*"))
 
3769
#     (setq next-error-last-buffer (get-buffer "*Test*"))
 
3770
#     (let* ((side (if (>= (window-width) 146) 'right 'bottom))
 
3771
#            (display-buffer-overriding-action
 
3772
#             `((display-buffer-in-side-window) (side . ,side)
 
3773
#               (window-height . fit-window-to-buffer)
 
3774
#               (window-width . fit-window-to-buffer))))
 
3775
#       (display-buffer "*Test*"))))
 
3776
# eval:
 
3777
# (progn
 
3778
#   (let* ((run-extra-tests (lambda () (interactive)
 
3779
#                             (funcall run-tests t)))
 
3780
#          (inner-keymap `(keymap (116 . ,run-extra-tests))) ; t
 
3781
#          (outer-keymap `(keymap (3 . ,inner-keymap))))     ; C-c
 
3782
#     (setq minor-mode-overriding-map-alist
 
3783
#           (cons `(run-tests . ,outer-keymap)
 
3784
#                 minor-mode-overriding-map-alist)))
 
3785
#   (add-hook 'after-save-hook run-tests 90 t))
 
3786
# End: