/mandos/trunk

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

« back to all changes in this revision

Viewing changes to mandos

  • Committer: Teddy Hogeborn
  • Date: 2019-11-03 19:09:41 UTC
  • Revision ID: teddy@recompile.se-20191103190941-9gfivh2mjuvi4z3f
Add -I option to python 3 on the interpreter script ("shebang") line

* mandos: Add -I option to /usr/bin/python3.
* mandos-ctl: - '' -
* mandos-monitor: - '' -

Show diffs side-by-side

added added

removed removed

Lines of Context:
mandos
1
 
#!/usr/bin/python
2
 
# -*- mode: python; coding: utf-8 -*-
 
1
#!/usr/bin/python3 -bI
 
2
# -*- mode: python; after-save-hook: (lambda () (let ((command (if (fboundp 'file-local-name) (file-local-name (buffer-file-name)) (or (file-remote-p (buffer-file-name) 'localname) (buffer-file-name))))) (if (= (progn (if (get-buffer "*Test*") (kill-buffer "*Test*")) (process-file-shell-command (format "%s --check" (shell-quote-argument command)) nil "*Test*")) 0) (let ((w (get-buffer-window "*Test*"))) (if w (delete-window w))) (progn (with-current-buffer "*Test*" (compilation-mode)) (display-buffer "*Test*" '(display-buffer-in-side-window)))))); coding: utf-8 -*-
3
3
#
4
4
# Mandos server - give out binary blobs to connecting clients.
5
5
#
11
11
# "AvahiService" class, and some lines in "main".
12
12
#
13
13
# Everything else is
14
 
# Copyright © 2008-2018 Teddy Hogeborn
15
 
# Copyright © 2008-2018 Björn Påhlsson
 
14
# Copyright © 2008-2019 Teddy Hogeborn
 
15
# Copyright © 2008-2019 Björn Påhlsson
16
16
#
17
17
# This file is part of Mandos.
18
18
#
77
77
import itertools
78
78
import collections
79
79
import codecs
 
80
import unittest
80
81
 
81
82
import dbus
82
83
import dbus.service
 
84
import gi
83
85
from gi.repository import GLib
84
86
from dbus.mainloop.glib import DBusGMainLoop
85
87
import ctypes
87
89
import xml.dom.minidom
88
90
import inspect
89
91
 
 
92
if sys.version_info.major == 2:
 
93
    __metaclass__ = type
 
94
 
 
95
# Show warnings by default
 
96
if not sys.warnoptions:
 
97
    import warnings
 
98
    warnings.simplefilter("default")
 
99
 
90
100
# Try to find the value of SO_BINDTODEVICE:
91
101
try:
92
102
    # This is where SO_BINDTODEVICE is in Python 3.3 (or 3.4?) and
115
125
if sys.version_info.major == 2:
116
126
    str = unicode
117
127
 
118
 
version = "1.7.16"
 
128
if sys.version_info < (3, 2):
 
129
    configparser.Configparser = configparser.SafeConfigParser
 
130
 
 
131
version = "1.8.9"
119
132
stored_state_file = "clients.pickle"
120
133
 
121
134
logger = logging.getLogger()
 
135
logging.captureWarnings(True)   # Show warnings via the logging system
122
136
syslogger = None
123
137
 
124
138
try:
179
193
    pass
180
194
 
181
195
 
182
 
class PGPEngine(object):
 
196
class PGPEngine:
183
197
    """A simple class for OpenPGP symmetric encryption & decryption"""
184
198
 
185
199
    def __init__(self):
189
203
            output = subprocess.check_output(["gpgconf"])
190
204
            for line in output.splitlines():
191
205
                name, text, path = line.split(b":")
192
 
                if name == "gpg":
 
206
                if name == b"gpg":
193
207
                    self.gpg = path
194
208
                    break
195
209
        except OSError as e:
200
214
                          '--force-mdc',
201
215
                          '--quiet']
202
216
        # Only GPG version 1 has the --no-use-agent option.
203
 
        if self.gpg == "gpg" or self.gpg.endswith("/gpg"):
 
217
        if self.gpg == b"gpg" or self.gpg.endswith(b"/gpg"):
204
218
            self.gnupgargs.append("--no-use-agent")
205
219
 
206
220
    def __enter__(self):
275
289
 
276
290
 
277
291
# Pretend that we have an Avahi module
278
 
class Avahi(object):
279
 
    """This isn't so much a class as it is a module-like namespace.
280
 
    It is instantiated once, and simulates having an Avahi module."""
 
292
class avahi:
 
293
    """This isn't so much a class as it is a module-like namespace."""
281
294
    IF_UNSPEC = -1               # avahi-common/address.h
282
295
    PROTO_UNSPEC = -1            # avahi-common/address.h
283
296
    PROTO_INET = 0               # avahi-common/address.h
287
300
    DBUS_INTERFACE_SERVER = DBUS_NAME + ".Server"
288
301
    DBUS_PATH_SERVER = "/"
289
302
 
290
 
    def string_array_to_txt_array(self, t):
 
303
    @staticmethod
 
304
    def string_array_to_txt_array(t):
291
305
        return dbus.Array((dbus.ByteArray(s.encode("utf-8"))
292
306
                           for s in t), signature="ay")
293
307
    ENTRY_GROUP_ESTABLISHED = 2  # avahi-common/defs.h
298
312
    SERVER_RUNNING = 2           # avahi-common/defs.h
299
313
    SERVER_COLLISION = 3         # avahi-common/defs.h
300
314
    SERVER_FAILURE = 4           # avahi-common/defs.h
301
 
avahi = Avahi()
302
315
 
303
316
 
304
317
class AvahiError(Exception):
316
329
    pass
317
330
 
318
331
 
319
 
class AvahiService(object):
 
332
class AvahiService:
320
333
    """An Avahi (Zeroconf) service.
321
334
 
322
335
    Attributes:
496
509
class AvahiServiceToSyslog(AvahiService):
497
510
    def rename(self, *args, **kwargs):
498
511
        """Add the new name to the syslog messages"""
499
 
        ret = super(AvahiServiceToSyslog, self).rename(self, *args,
500
 
                                                       **kwargs)
 
512
        ret = super(AvahiServiceToSyslog, self).rename(*args, **kwargs)
501
513
        syslogger.setFormatter(logging.Formatter(
502
514
            'Mandos ({}) [%(process)d]: %(levelname)s: %(message)s'
503
515
            .format(self.name)))
505
517
 
506
518
 
507
519
# Pretend that we have a GnuTLS module
508
 
class GnuTLS(object):
509
 
    """This isn't so much a class as it is a module-like namespace.
510
 
    It is instantiated once, and simulates having a GnuTLS module."""
 
520
class gnutls:
 
521
    """This isn't so much a class as it is a module-like namespace."""
511
522
 
512
523
    library = ctypes.util.find_library("gnutls")
513
524
    if library is None:
514
525
        library = ctypes.util.find_library("gnutls-deb0")
515
526
    _library = ctypes.cdll.LoadLibrary(library)
516
527
    del library
517
 
    _need_version = b"3.3.0"
518
 
 
519
 
    def __init__(self):
520
 
        # Need to use "self" here, since this method is called before
521
 
        # the assignment to the "gnutls" global variable happens.
522
 
        if self.check_version(self._need_version) is None:
523
 
            raise self.Error("Needs GnuTLS {} or later"
524
 
                             .format(self._need_version))
525
528
 
526
529
    # Unless otherwise indicated, the constants and types below are
527
530
    # all from the gnutls/gnutls.h C header file.
531
534
    E_INTERRUPTED = -52
532
535
    E_AGAIN = -28
533
536
    CRT_OPENPGP = 2
 
537
    CRT_RAWPK = 3
534
538
    CLIENT = 2
535
539
    SHUT_RDWR = 0
536
540
    CRD_CERTIFICATE = 1
537
541
    E_NO_CERTIFICATE_FOUND = -49
 
542
    X509_FMT_DER = 0
 
543
    NO_TICKETS = 1<<10
 
544
    ENABLE_RAWPK = 1<<18
 
545
    CTYPE_PEERS = 3
 
546
    KEYID_USE_SHA256 = 1        # gnutls/x509.h
538
547
    OPENPGP_FMT_RAW = 0         # gnutls/openpgp.h
539
548
 
540
549
    # Types
563
572
 
564
573
    # Exceptions
565
574
    class Error(Exception):
566
 
        # We need to use the class name "GnuTLS" here, since this
567
 
        # exception might be raised from within GnuTLS.__init__,
568
 
        # which is called before the assignment to the "gnutls"
569
 
        # global variable has happened.
570
575
        def __init__(self, message=None, code=None, args=()):
571
576
            # Default usage is by a message string, but if a return
572
577
            # code is passed, convert it to a string with
573
578
            # gnutls.strerror()
574
579
            self.code = code
575
580
            if message is None and code is not None:
576
 
                message = GnuTLS.strerror(code)
577
 
            return super(GnuTLS.Error, self).__init__(
 
581
                message = gnutls.strerror(code)
 
582
            return super(gnutls.Error, self).__init__(
578
583
                message, *args)
579
584
 
580
585
    class CertificateSecurityError(Error):
581
586
        pass
582
587
 
583
588
    # Classes
584
 
    class Credentials(object):
 
589
    class Credentials:
585
590
        def __init__(self):
586
591
            self._c_object = gnutls.certificate_credentials_t()
587
592
            gnutls.certificate_allocate_credentials(
591
596
        def __del__(self):
592
597
            gnutls.certificate_free_credentials(self._c_object)
593
598
 
594
 
    class ClientSession(object):
 
599
    class ClientSession:
595
600
        def __init__(self, socket, credentials=None):
596
601
            self._c_object = gnutls.session_t()
597
 
            gnutls.init(ctypes.byref(self._c_object), gnutls.CLIENT)
 
602
            gnutls_flags = gnutls.CLIENT
 
603
            if gnutls.check_version(b"3.5.6"):
 
604
                gnutls_flags |= gnutls.NO_TICKETS
 
605
            if gnutls.has_rawpk:
 
606
                gnutls_flags |= gnutls.ENABLE_RAWPK
 
607
            gnutls.init(ctypes.byref(self._c_object), gnutls_flags)
 
608
            del gnutls_flags
598
609
            gnutls.set_default_priority(self._c_object)
599
610
            gnutls.transport_set_ptr(self._c_object, socket.fileno())
600
611
            gnutls.handshake_set_private_extensions(self._c_object,
732
743
    check_version.argtypes = [ctypes.c_char_p]
733
744
    check_version.restype = ctypes.c_char_p
734
745
 
735
 
    # All the function declarations below are from gnutls/openpgp.h
736
 
 
737
 
    openpgp_crt_init = _library.gnutls_openpgp_crt_init
738
 
    openpgp_crt_init.argtypes = [ctypes.POINTER(openpgp_crt_t)]
739
 
    openpgp_crt_init.restype = _error_code
740
 
 
741
 
    openpgp_crt_import = _library.gnutls_openpgp_crt_import
742
 
    openpgp_crt_import.argtypes = [openpgp_crt_t,
743
 
                                   ctypes.POINTER(datum_t),
744
 
                                   openpgp_crt_fmt_t]
745
 
    openpgp_crt_import.restype = _error_code
746
 
 
747
 
    openpgp_crt_verify_self = _library.gnutls_openpgp_crt_verify_self
748
 
    openpgp_crt_verify_self.argtypes = [openpgp_crt_t, ctypes.c_uint,
749
 
                                        ctypes.POINTER(ctypes.c_uint)]
750
 
    openpgp_crt_verify_self.restype = _error_code
751
 
 
752
 
    openpgp_crt_deinit = _library.gnutls_openpgp_crt_deinit
753
 
    openpgp_crt_deinit.argtypes = [openpgp_crt_t]
754
 
    openpgp_crt_deinit.restype = None
755
 
 
756
 
    openpgp_crt_get_fingerprint = (
757
 
        _library.gnutls_openpgp_crt_get_fingerprint)
758
 
    openpgp_crt_get_fingerprint.argtypes = [openpgp_crt_t,
759
 
                                            ctypes.c_void_p,
760
 
                                            ctypes.POINTER(
761
 
                                                ctypes.c_size_t)]
762
 
    openpgp_crt_get_fingerprint.restype = _error_code
 
746
    _need_version = b"3.3.0"
 
747
    if check_version(_need_version) is None:
 
748
        raise self.Error("Needs GnuTLS {} or later"
 
749
                         .format(_need_version))
 
750
 
 
751
    _tls_rawpk_version = b"3.6.6"
 
752
    has_rawpk = bool(check_version(_tls_rawpk_version))
 
753
 
 
754
    if has_rawpk:
 
755
        # Types
 
756
        class pubkey_st(ctypes.Structure):
 
757
            _fields = []
 
758
        pubkey_t = ctypes.POINTER(pubkey_st)
 
759
 
 
760
        x509_crt_fmt_t = ctypes.c_int
 
761
 
 
762
        # All the function declarations below are from gnutls/abstract.h
 
763
        pubkey_init = _library.gnutls_pubkey_init
 
764
        pubkey_init.argtypes = [ctypes.POINTER(pubkey_t)]
 
765
        pubkey_init.restype = _error_code
 
766
 
 
767
        pubkey_import = _library.gnutls_pubkey_import
 
768
        pubkey_import.argtypes = [pubkey_t, ctypes.POINTER(datum_t),
 
769
                                  x509_crt_fmt_t]
 
770
        pubkey_import.restype = _error_code
 
771
 
 
772
        pubkey_get_key_id = _library.gnutls_pubkey_get_key_id
 
773
        pubkey_get_key_id.argtypes = [pubkey_t, ctypes.c_int,
 
774
                                      ctypes.POINTER(ctypes.c_ubyte),
 
775
                                      ctypes.POINTER(ctypes.c_size_t)]
 
776
        pubkey_get_key_id.restype = _error_code
 
777
 
 
778
        pubkey_deinit = _library.gnutls_pubkey_deinit
 
779
        pubkey_deinit.argtypes = [pubkey_t]
 
780
        pubkey_deinit.restype = None
 
781
    else:
 
782
        # All the function declarations below are from gnutls/openpgp.h
 
783
 
 
784
        openpgp_crt_init = _library.gnutls_openpgp_crt_init
 
785
        openpgp_crt_init.argtypes = [ctypes.POINTER(openpgp_crt_t)]
 
786
        openpgp_crt_init.restype = _error_code
 
787
 
 
788
        openpgp_crt_import = _library.gnutls_openpgp_crt_import
 
789
        openpgp_crt_import.argtypes = [openpgp_crt_t,
 
790
                                       ctypes.POINTER(datum_t),
 
791
                                       openpgp_crt_fmt_t]
 
792
        openpgp_crt_import.restype = _error_code
 
793
 
 
794
        openpgp_crt_verify_self = _library.gnutls_openpgp_crt_verify_self
 
795
        openpgp_crt_verify_self.argtypes = [openpgp_crt_t, ctypes.c_uint,
 
796
                                            ctypes.POINTER(ctypes.c_uint)]
 
797
        openpgp_crt_verify_self.restype = _error_code
 
798
 
 
799
        openpgp_crt_deinit = _library.gnutls_openpgp_crt_deinit
 
800
        openpgp_crt_deinit.argtypes = [openpgp_crt_t]
 
801
        openpgp_crt_deinit.restype = None
 
802
 
 
803
        openpgp_crt_get_fingerprint = (
 
804
            _library.gnutls_openpgp_crt_get_fingerprint)
 
805
        openpgp_crt_get_fingerprint.argtypes = [openpgp_crt_t,
 
806
                                                ctypes.c_void_p,
 
807
                                                ctypes.POINTER(
 
808
                                                    ctypes.c_size_t)]
 
809
        openpgp_crt_get_fingerprint.restype = _error_code
 
810
 
 
811
    if check_version(b"3.6.4"):
 
812
        certificate_type_get2 = _library.gnutls_certificate_type_get2
 
813
        certificate_type_get2.argtypes = [session_t, ctypes.c_int]
 
814
        certificate_type_get2.restype = _error_code
763
815
 
764
816
    # Remove non-public functions
765
817
    del _error_code, _retry_on_error
766
 
# Create the global "gnutls" object, simulating a module
767
 
gnutls = GnuTLS()
768
818
 
769
819
 
770
820
def call_pipe(connection,       # : multiprocessing.Connection
778
828
    connection.close()
779
829
 
780
830
 
781
 
class Client(object):
 
831
class Client:
782
832
    """A representation of a client host served by this server.
783
833
 
784
834
    Attributes:
785
835
    approved:   bool(); 'None' if not yet approved/disapproved
786
836
    approval_delay: datetime.timedelta(); Time to wait for approval
787
837
    approval_duration: datetime.timedelta(); Duration of one approval
788
 
    checker:    subprocess.Popen(); a running checker process used
789
 
                                    to see if the client lives.
790
 
                                    'None' if no process is running.
 
838
    checker: multiprocessing.Process(); a running checker process used
 
839
             to see if the client lives. 'None' if no process is
 
840
             running.
791
841
    checker_callback_tag: a GLib event source tag, or None
792
842
    checker_command: string; External command which is run to check
793
843
                     if client lives.  %() expansions are done at
801
851
    disable_initiator_tag: a GLib event source tag, or None
802
852
    enabled:    bool()
803
853
    fingerprint: string (40 or 32 hexadecimal digits); used to
804
 
                 uniquely identify the client
 
854
                 uniquely identify an OpenPGP client
 
855
    key_id: string (64 hexadecimal digits); used to uniquely identify
 
856
            a client using raw public keys
805
857
    host:       string; available for use by the checker command
806
858
    interval:   datetime.timedelta(); How often to start a new checker
807
859
    last_approval_request: datetime.datetime(); (UTC) or None
825
877
    """
826
878
 
827
879
    runtime_expansions = ("approval_delay", "approval_duration",
828
 
                          "created", "enabled", "expires",
 
880
                          "created", "enabled", "expires", "key_id",
829
881
                          "fingerprint", "host", "interval",
830
882
                          "last_approval_request", "last_checked_ok",
831
883
                          "last_enabled", "name", "timeout")
861
913
            client["enabled"] = config.getboolean(client_name,
862
914
                                                  "enabled")
863
915
 
864
 
            # Uppercase and remove spaces from fingerprint for later
865
 
            # comparison purposes with return value from the
866
 
            # fingerprint() function
 
916
            # Uppercase and remove spaces from key_id and fingerprint
 
917
            # for later comparison purposes with return value from the
 
918
            # key_id() and fingerprint() functions
 
919
            client["key_id"] = (section.get("key_id", "").upper()
 
920
                                .replace(" ", ""))
867
921
            client["fingerprint"] = (section["fingerprint"].upper()
868
922
                                     .replace(" ", ""))
869
923
            if "secret" in section:
913
967
            self.expires = None
914
968
 
915
969
        logger.debug("Creating client %r", self.name)
 
970
        logger.debug("  Key ID: %s", self.key_id)
916
971
        logger.debug("  Fingerprint: %s", self.fingerprint)
917
972
        self.created = settings.get("created",
918
973
                                    datetime.datetime.utcnow())
995
1050
    def checker_callback(self, source, condition, connection,
996
1051
                         command):
997
1052
        """The checker has completed, so take appropriate actions."""
998
 
        self.checker_callback_tag = None
999
 
        self.checker = None
1000
1053
        # Read return code from connection (see call_pipe)
1001
1054
        returncode = connection.recv()
1002
1055
        connection.close()
 
1056
        if self.checker is not None:
 
1057
            self.checker.join()
 
1058
        self.checker_callback_tag = None
 
1059
        self.checker = None
1003
1060
 
1004
1061
        if returncode >= 0:
1005
1062
            self.last_checker_status = returncode
1094
1151
                kwargs=popen_args)
1095
1152
            self.checker.start()
1096
1153
            self.checker_callback_tag = GLib.io_add_watch(
1097
 
                pipe[0].fileno(), GLib.IO_IN,
 
1154
                GLib.IOChannel.unix_new(pipe[0].fileno()),
 
1155
                GLib.PRIORITY_DEFAULT, GLib.IO_IN,
1098
1156
                self.checker_callback, pipe[0], command)
1099
1157
        # Re-run this periodically if run by GLib.timeout_add
1100
1158
        return True
2000
2058
    def Name_dbus_property(self):
2001
2059
        return dbus.String(self.name)
2002
2060
 
 
2061
    # KeyID - property
 
2062
    @dbus_annotations(
 
2063
        {"org.freedesktop.DBus.Property.EmitsChangedSignal": "const"})
 
2064
    @dbus_service_property(_interface, signature="s", access="read")
 
2065
    def KeyID_dbus_property(self):
 
2066
        return dbus.String(self.key_id)
 
2067
 
2003
2068
    # Fingerprint - property
2004
2069
    @dbus_annotations(
2005
2070
        {"org.freedesktop.DBus.Property.EmitsChangedSignal": "const"})
2160
2225
    del _interface
2161
2226
 
2162
2227
 
2163
 
class ProxyClient(object):
2164
 
    def __init__(self, child_pipe, fpr, address):
 
2228
class ProxyClient:
 
2229
    def __init__(self, child_pipe, key_id, fpr, address):
2165
2230
        self._pipe = child_pipe
2166
 
        self._pipe.send(('init', fpr, address))
 
2231
        self._pipe.send(('init', key_id, fpr, address))
2167
2232
        if not self._pipe.recv():
2168
 
            raise KeyError(fpr)
 
2233
            raise KeyError(key_id or fpr)
2169
2234
 
2170
2235
    def __getattribute__(self, name):
2171
2236
        if name == '_pipe':
2238
2303
 
2239
2304
            approval_required = False
2240
2305
            try:
2241
 
                try:
2242
 
                    fpr = self.fingerprint(
2243
 
                        self.peer_certificate(session))
2244
 
                except (TypeError, gnutls.Error) as error:
2245
 
                    logger.warning("Bad certificate: %s", error)
2246
 
                    return
2247
 
                logger.debug("Fingerprint: %s", fpr)
2248
 
 
2249
 
                try:
2250
 
                    client = ProxyClient(child_pipe, fpr,
 
2306
                if gnutls.has_rawpk:
 
2307
                    fpr = b""
 
2308
                    try:
 
2309
                        key_id = self.key_id(
 
2310
                            self.peer_certificate(session))
 
2311
                    except (TypeError, gnutls.Error) as error:
 
2312
                        logger.warning("Bad certificate: %s", error)
 
2313
                        return
 
2314
                    logger.debug("Key ID: %s", key_id)
 
2315
 
 
2316
                else:
 
2317
                    key_id = b""
 
2318
                    try:
 
2319
                        fpr = self.fingerprint(
 
2320
                            self.peer_certificate(session))
 
2321
                    except (TypeError, gnutls.Error) as error:
 
2322
                        logger.warning("Bad certificate: %s", error)
 
2323
                        return
 
2324
                    logger.debug("Fingerprint: %s", fpr)
 
2325
 
 
2326
                try:
 
2327
                    client = ProxyClient(child_pipe, key_id, fpr,
2251
2328
                                         self.client_address)
2252
2329
                except KeyError:
2253
2330
                    return
2330
2407
 
2331
2408
    @staticmethod
2332
2409
    def peer_certificate(session):
2333
 
        "Return the peer's OpenPGP certificate as a bytestring"
2334
 
        # If not an OpenPGP certificate...
2335
 
        if (gnutls.certificate_type_get(session._c_object)
2336
 
            != gnutls.CRT_OPENPGP):
 
2410
        "Return the peer's certificate as a bytestring"
 
2411
        try:
 
2412
            cert_type = gnutls.certificate_type_get2(session._c_object,
 
2413
                                                     gnutls.CTYPE_PEERS)
 
2414
        except AttributeError:
 
2415
            cert_type = gnutls.certificate_type_get(session._c_object)
 
2416
        if gnutls.has_rawpk:
 
2417
            valid_cert_types = frozenset((gnutls.CRT_RAWPK,))
 
2418
        else:
 
2419
            valid_cert_types = frozenset((gnutls.CRT_OPENPGP,))
 
2420
        # If not a valid certificate type...
 
2421
        if cert_type not in valid_cert_types:
 
2422
            logger.info("Cert type %r not in %r", cert_type,
 
2423
                        valid_cert_types)
2337
2424
            # ...return invalid data
2338
2425
            return b""
2339
2426
        list_size = ctypes.c_uint(1)
2347
2434
        return ctypes.string_at(cert.data, cert.size)
2348
2435
 
2349
2436
    @staticmethod
 
2437
    def key_id(certificate):
 
2438
        "Convert a certificate bytestring to a hexdigit key ID"
 
2439
        # New GnuTLS "datum" with the public key
 
2440
        datum = gnutls.datum_t(
 
2441
            ctypes.cast(ctypes.c_char_p(certificate),
 
2442
                        ctypes.POINTER(ctypes.c_ubyte)),
 
2443
            ctypes.c_uint(len(certificate)))
 
2444
        # XXX all these need to be created in the gnutls "module"
 
2445
        # New empty GnuTLS certificate
 
2446
        pubkey = gnutls.pubkey_t()
 
2447
        gnutls.pubkey_init(ctypes.byref(pubkey))
 
2448
        # Import the raw public key into the certificate
 
2449
        gnutls.pubkey_import(pubkey,
 
2450
                             ctypes.byref(datum),
 
2451
                             gnutls.X509_FMT_DER)
 
2452
        # New buffer for the key ID
 
2453
        buf = ctypes.create_string_buffer(32)
 
2454
        buf_len = ctypes.c_size_t(len(buf))
 
2455
        # Get the key ID from the raw public key into the buffer
 
2456
        gnutls.pubkey_get_key_id(pubkey,
 
2457
                                 gnutls.KEYID_USE_SHA256,
 
2458
                                 ctypes.cast(ctypes.byref(buf),
 
2459
                                             ctypes.POINTER(ctypes.c_ubyte)),
 
2460
                                 ctypes.byref(buf_len))
 
2461
        # Deinit the certificate
 
2462
        gnutls.pubkey_deinit(pubkey)
 
2463
 
 
2464
        # Convert the buffer to a Python bytestring
 
2465
        key_id = ctypes.string_at(buf, buf_len.value)
 
2466
        # Convert the bytestring to hexadecimal notation
 
2467
        hex_key_id = binascii.hexlify(key_id).upper()
 
2468
        return hex_key_id
 
2469
 
 
2470
    @staticmethod
2350
2471
    def fingerprint(openpgp):
2351
2472
        "Convert an OpenPGP bytestring to a hexdigit fingerprint"
2352
2473
        # New GnuTLS "datum" with the OpenPGP public key
2366
2487
                                       ctypes.byref(crtverify))
2367
2488
        if crtverify.value != 0:
2368
2489
            gnutls.openpgp_crt_deinit(crt)
2369
 
            raise gnutls.CertificateSecurityError("Verify failed")
 
2490
            raise gnutls.CertificateSecurityError(code
 
2491
                                                  =crtverify.value)
2370
2492
        # New buffer for the fingerprint
2371
2493
        buf = ctypes.create_string_buffer(20)
2372
2494
        buf_len = ctypes.c_size_t()
2382
2504
        return hex_fpr
2383
2505
 
2384
2506
 
2385
 
class MultiprocessingMixIn(object):
 
2507
class MultiprocessingMixIn:
2386
2508
    """Like socketserver.ThreadingMixIn, but with multiprocessing"""
2387
2509
 
2388
2510
    def sub_process_main(self, request, address):
2400
2522
        return proc
2401
2523
 
2402
2524
 
2403
 
class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):
 
2525
class MultiprocessingMixInWithPipe(MultiprocessingMixIn):
2404
2526
    """ adds a pipe to the MixIn """
2405
2527
 
2406
2528
    def process_request(self, request, client_address):
2421
2543
 
2422
2544
 
2423
2545
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
2424
 
                     socketserver.TCPServer, object):
 
2546
                     socketserver.TCPServer):
2425
2547
    """IPv6-capable TCP server.  Accepts 'None' as address and/or port
2426
2548
 
2427
2549
    Attributes:
2500
2622
                    raise
2501
2623
        # Only bind(2) the socket if we really need to.
2502
2624
        if self.server_address[0] or self.server_address[1]:
 
2625
            if self.server_address[1]:
 
2626
                self.allow_reuse_address = True
2503
2627
            if not self.server_address[0]:
2504
2628
                if self.address_family == socket.AF_INET6:
2505
2629
                    any_address = "::"  # in6addr_any
2558
2682
    def add_pipe(self, parent_pipe, proc):
2559
2683
        # Call "handle_ipc" for both data and EOF events
2560
2684
        GLib.io_add_watch(
2561
 
            parent_pipe.fileno(),
2562
 
            GLib.IO_IN | GLib.IO_HUP,
 
2685
            GLib.IOChannel.unix_new(parent_pipe.fileno()),
 
2686
            GLib.PRIORITY_DEFAULT, GLib.IO_IN | GLib.IO_HUP,
2563
2687
            functools.partial(self.handle_ipc,
2564
2688
                              parent_pipe=parent_pipe,
2565
2689
                              proc=proc))
2579
2703
        command = request[0]
2580
2704
 
2581
2705
        if command == 'init':
2582
 
            fpr = request[1].decode("ascii")
2583
 
            address = request[2]
 
2706
            key_id = request[1].decode("ascii")
 
2707
            fpr = request[2].decode("ascii")
 
2708
            address = request[3]
2584
2709
 
2585
2710
            for c in self.clients.values():
2586
 
                if c.fingerprint == fpr:
 
2711
                if key_id == "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855":
 
2712
                    continue
 
2713
                if key_id and c.key_id == key_id:
 
2714
                    client = c
 
2715
                    break
 
2716
                if fpr and c.fingerprint == fpr:
2587
2717
                    client = c
2588
2718
                    break
2589
2719
            else:
2590
 
                logger.info("Client not found for fingerprint: %s, ad"
2591
 
                            "dress: %s", fpr, address)
 
2720
                logger.info("Client not found for key ID: %s, address"
 
2721
                            ": %s", key_id or fpr, address)
2592
2722
                if self.use_dbus:
2593
2723
                    # Emit D-Bus signal
2594
 
                    mandos_dbus_service.ClientNotFound(fpr,
 
2724
                    mandos_dbus_service.ClientNotFound(key_id or fpr,
2595
2725
                                                       address[0])
2596
2726
                parent_pipe.send(False)
2597
2727
                return False
2598
2728
 
2599
2729
            GLib.io_add_watch(
2600
 
                parent_pipe.fileno(),
2601
 
                GLib.IO_IN | GLib.IO_HUP,
 
2730
                GLib.IOChannel.unix_new(parent_pipe.fileno()),
 
2731
                GLib.PRIORITY_DEFAULT, GLib.IO_IN | GLib.IO_HUP,
2602
2732
                functools.partial(self.handle_ipc,
2603
2733
                                  parent_pipe=parent_pipe,
2604
2734
                                  proc=proc,
2636
2766
def rfc3339_duration_to_delta(duration):
2637
2767
    """Parse an RFC 3339 "duration" and return a datetime.timedelta
2638
2768
 
2639
 
    >>> rfc3339_duration_to_delta("P7D")
2640
 
    datetime.timedelta(7)
2641
 
    >>> rfc3339_duration_to_delta("PT60S")
2642
 
    datetime.timedelta(0, 60)
2643
 
    >>> rfc3339_duration_to_delta("PT60M")
2644
 
    datetime.timedelta(0, 3600)
2645
 
    >>> rfc3339_duration_to_delta("PT24H")
2646
 
    datetime.timedelta(1)
2647
 
    >>> rfc3339_duration_to_delta("P1W")
2648
 
    datetime.timedelta(7)
2649
 
    >>> rfc3339_duration_to_delta("PT5M30S")
2650
 
    datetime.timedelta(0, 330)
2651
 
    >>> rfc3339_duration_to_delta("P1DT3M20S")
2652
 
    datetime.timedelta(1, 200)
 
2769
    >>> rfc3339_duration_to_delta("P7D") == datetime.timedelta(7)
 
2770
    True
 
2771
    >>> rfc3339_duration_to_delta("PT60S") == datetime.timedelta(0, 60)
 
2772
    True
 
2773
    >>> rfc3339_duration_to_delta("PT60M") == datetime.timedelta(0, 3600)
 
2774
    True
 
2775
    >>> rfc3339_duration_to_delta("PT24H") == datetime.timedelta(1)
 
2776
    True
 
2777
    >>> rfc3339_duration_to_delta("P1W") == datetime.timedelta(7)
 
2778
    True
 
2779
    >>> rfc3339_duration_to_delta("PT5M30S") == datetime.timedelta(0, 330)
 
2780
    True
 
2781
    >>> rfc3339_duration_to_delta("P1DT3M20S") == datetime.timedelta(1, 200)
 
2782
    True
2653
2783
    """
2654
2784
 
2655
2785
    # Parsing an RFC 3339 duration with regular expressions is not
2735
2865
def string_to_delta(interval):
2736
2866
    """Parse a string and return a datetime.timedelta
2737
2867
 
2738
 
    >>> string_to_delta('7d')
2739
 
    datetime.timedelta(7)
2740
 
    >>> string_to_delta('60s')
2741
 
    datetime.timedelta(0, 60)
2742
 
    >>> string_to_delta('60m')
2743
 
    datetime.timedelta(0, 3600)
2744
 
    >>> string_to_delta('24h')
2745
 
    datetime.timedelta(1)
2746
 
    >>> string_to_delta('1w')
2747
 
    datetime.timedelta(7)
2748
 
    >>> string_to_delta('5m 30s')
2749
 
    datetime.timedelta(0, 330)
 
2868
    >>> string_to_delta('7d') == datetime.timedelta(7)
 
2869
    True
 
2870
    >>> string_to_delta('60s') == datetime.timedelta(0, 60)
 
2871
    True
 
2872
    >>> string_to_delta('60m') == datetime.timedelta(0, 3600)
 
2873
    True
 
2874
    >>> string_to_delta('24h') == datetime.timedelta(1)
 
2875
    True
 
2876
    >>> string_to_delta('1w') == datetime.timedelta(7)
 
2877
    True
 
2878
    >>> string_to_delta('5m 30s') == datetime.timedelta(0, 330)
 
2879
    True
2750
2880
    """
2751
2881
 
2752
2882
    try:
2854
2984
 
2855
2985
    options = parser.parse_args()
2856
2986
 
2857
 
    if options.check:
2858
 
        import doctest
2859
 
        fail_count, test_count = doctest.testmod()
2860
 
        sys.exit(os.EX_OK if fail_count == 0 else 1)
2861
 
 
2862
2987
    # Default values for config file for server-global settings
 
2988
    if gnutls.has_rawpk:
 
2989
        priority = ("SECURE128:!CTYPE-X.509:+CTYPE-RAWPK:!RSA"
 
2990
                    ":!VERS-ALL:+VERS-TLS1.3:%PROFILE_ULTRA")
 
2991
    else:
 
2992
        priority = ("SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:!RSA"
 
2993
                    ":+SIGN-DSA-SHA256")
2863
2994
    server_defaults = {"interface": "",
2864
2995
                       "address": "",
2865
2996
                       "port": "",
2866
2997
                       "debug": "False",
2867
 
                       "priority":
2868
 
                       "SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:!RSA"
2869
 
                       ":+SIGN-DSA-SHA256",
 
2998
                       "priority": priority,
2870
2999
                       "servicename": "Mandos",
2871
3000
                       "use_dbus": "True",
2872
3001
                       "use_ipv6": "True",
2877
3006
                       "foreground": "False",
2878
3007
                       "zeroconf": "True",
2879
3008
                       }
 
3009
    del priority
2880
3010
 
2881
3011
    # Parse config file for server-global settings
2882
 
    server_config = configparser.SafeConfigParser(server_defaults)
 
3012
    server_config = configparser.ConfigParser(server_defaults)
2883
3013
    del server_defaults
2884
3014
    server_config.read(os.path.join(options.configdir, "mandos.conf"))
2885
 
    # Convert the SafeConfigParser object to a dict
 
3015
    # Convert the ConfigParser object to a dict
2886
3016
    server_settings = server_config.defaults()
2887
3017
    # Use the appropriate methods on the non-string config options
2888
3018
    for option in ("debug", "use_dbus", "use_ipv6", "restore",
2960
3090
                                  server_settings["servicename"])))
2961
3091
 
2962
3092
    # Parse config file with clients
2963
 
    client_config = configparser.SafeConfigParser(Client
2964
 
                                                  .client_defaults)
 
3093
    client_config = configparser.ConfigParser(Client.client_defaults)
2965
3094
    client_config.read(os.path.join(server_settings["configdir"],
2966
3095
                                    "clients.conf"))
2967
3096
 
3038
3167
        # Close all input and output, do double fork, etc.
3039
3168
        daemon()
3040
3169
 
3041
 
    # multiprocessing will use threads, so before we use GLib we need
3042
 
    # to inform GLib that threads will be used.
3043
 
    GLib.threads_init()
 
3170
    if gi.version_info < (3, 10, 2):
 
3171
        # multiprocessing will use threads, so before we use GLib we
 
3172
        # need to inform GLib that threads will be used.
 
3173
        GLib.threads_init()
3044
3174
 
3045
3175
    global main_loop
3046
3176
    # From the Avahi example code
3122
3252
                             if isinstance(s, bytes)
3123
3253
                             else s) for s in
3124
3254
                            value["client_structure"]]
3125
 
                        # .name & .host
3126
 
                        for k in ("name", "host"):
 
3255
                        # .name, .host, and .checker_command
 
3256
                        for k in ("name", "host", "checker_command"):
3127
3257
                            if isinstance(value[k], bytes):
3128
3258
                                value[k] = value[k].decode("utf-8")
 
3259
                        if "key_id" not in value:
 
3260
                            value["key_id"] = ""
 
3261
                        elif "fingerprint" not in value:
 
3262
                            value["fingerprint"] = ""
3129
3263
                    #  old_client_settings
3130
3264
                    # .keys()
3131
3265
                    old_client_settings = {
3135
3269
                        for key, value in
3136
3270
                        bytes_old_client_settings.items()}
3137
3271
                    del bytes_old_client_settings
3138
 
                    # .host
 
3272
                    # .host and .checker_command
3139
3273
                    for value in old_client_settings.values():
3140
 
                        if isinstance(value["host"], bytes):
3141
 
                            value["host"] = (value["host"]
3142
 
                                             .decode("utf-8"))
 
3274
                        for attribute in ("host", "checker_command"):
 
3275
                            if isinstance(value[attribute], bytes):
 
3276
                                value[attribute] = (value[attribute]
 
3277
                                                    .decode("utf-8"))
3143
3278
            os.remove(stored_state_path)
3144
3279
        except IOError as e:
3145
3280
            if e.errno == errno.ENOENT:
3268
3403
                pass
3269
3404
 
3270
3405
            @dbus.service.signal(_interface, signature="ss")
3271
 
            def ClientNotFound(self, fingerprint, address):
 
3406
            def ClientNotFound(self, key_id, address):
3272
3407
                "D-Bus signal"
3273
3408
                pass
3274
3409
 
3470
3605
                sys.exit(1)
3471
3606
            # End of Avahi example code
3472
3607
 
3473
 
        GLib.io_add_watch(tcp_server.fileno(), GLib.IO_IN,
3474
 
                          lambda *args, **kwargs:
3475
 
                          (tcp_server.handle_request
3476
 
                           (*args[2:], **kwargs) or True))
 
3608
        GLib.io_add_watch(
 
3609
            GLib.IOChannel.unix_new(tcp_server.fileno()),
 
3610
            GLib.PRIORITY_DEFAULT, GLib.IO_IN,
 
3611
            lambda *args, **kwargs: (tcp_server.handle_request
 
3612
                                     (*args[2:], **kwargs) or True))
3477
3613
 
3478
3614
        logger.debug("Starting main loop")
3479
3615
        main_loop.run()
3489
3625
    # Must run before the D-Bus bus name gets deregistered
3490
3626
    cleanup()
3491
3627
 
 
3628
 
 
3629
def should_only_run_tests():
 
3630
    parser = argparse.ArgumentParser(add_help=False)
 
3631
    parser.add_argument("--check", action='store_true')
 
3632
    args, unknown_args = parser.parse_known_args()
 
3633
    run_tests = args.check
 
3634
    if run_tests:
 
3635
        # Remove --check argument from sys.argv
 
3636
        sys.argv[1:] = unknown_args
 
3637
    return run_tests
 
3638
 
 
3639
# Add all tests from doctest strings
 
3640
def load_tests(loader, tests, none):
 
3641
    import doctest
 
3642
    tests.addTests(doctest.DocTestSuite())
 
3643
    return tests
3492
3644
 
3493
3645
if __name__ == '__main__':
3494
 
    main()
 
3646
    try:
 
3647
        if should_only_run_tests():
 
3648
            # Call using ./mandos --check [--verbose]
 
3649
            unittest.main()
 
3650
        else:
 
3651
            main()
 
3652
    finally:
 
3653
        logging.shutdown()