/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: 2018-02-10 13:23:58 UTC
  • mto: (237.7.594 trunk)
  • mto: This revision was merged to the branch mainline in revision 362.
  • Revision ID: teddy@recompile.se-20180210132358-8pfvo9vshq9l32y5
Remove unnecessary text left from old example init.d file

* init.d-mandos: Remove unnecessary text left from old example init.d
  file.

Show diffs side-by-side

added added

removed removed

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