/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: 2016-10-29 13:44:49 UTC
  • mto: (237.7.594 trunk)
  • mto: This revision was merged to the branch mainline in revision 356.
  • Revision ID: teddy@recompile.se-20161029134449-imf8eidhzwfnax9w
mandos: Use "self" instead of class name "GnuTLS" in __init__.

* mandos (GnuTLS.__init__): Use "self" instead of class name "GnuTLS".

Show diffs side-by-side

added added

removed removed

Lines of Context:
mandos
11
11
# "AvahiService" class, and some lines in "main".
12
12
#
13
13
# Everything else is
14
 
# Copyright © 2008-2019 Teddy Hogeborn
15
 
# Copyright © 2008-2019 Björn Påhlsson
16
 
#
17
 
# This file is part of Mandos.
18
 
#
19
 
# Mandos is free software: you can redistribute it and/or modify it
20
 
# under the terms of the GNU General Public License as published by
 
14
# Copyright © 2008-2016 Teddy Hogeborn
 
15
# Copyright © 2008-2016 Björn Påhlsson
 
16
#
 
17
# This program is free software: you can redistribute it and/or modify
 
18
# it under the terms of the GNU General Public License as published by
21
19
# the Free Software Foundation, either version 3 of the License, or
22
20
# (at your option) any later version.
23
21
#
24
 
#     Mandos is distributed in the hope that it will be useful, but
25
 
#     WITHOUT ANY WARRANTY; without even the implied warranty of
 
22
#     This program is distributed in the hope that it will be useful,
 
23
#     but WITHOUT ANY WARRANTY; without even the implied warranty of
26
24
#     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
27
25
#     GNU General Public License for more details.
28
26
#
29
27
# You should have received a copy of the GNU General Public License
30
 
# along with Mandos.  If not, see <http://www.gnu.org/licenses/>.
 
28
# along with this program.  If not, see
 
29
# <http://www.gnu.org/licenses/>.
31
30
#
32
31
# Contact the authors at <mandos@recompile.se>.
33
32
#
80
79
 
81
80
import dbus
82
81
import dbus.service
83
 
import gi
84
82
from gi.repository import GLib
85
83
from dbus.mainloop.glib import DBusGMainLoop
86
84
import ctypes
116
114
if sys.version_info.major == 2:
117
115
    str = unicode
118
116
 
119
 
if sys.version_info < (3, 2):
120
 
    configparser.Configparser = configparser.SafeConfigParser
121
 
 
122
 
version = "1.8.6"
 
117
version = "1.7.13"
123
118
stored_state_file = "clients.pickle"
124
119
 
125
120
logger = logging.getLogger()
279
274
 
280
275
 
281
276
# Pretend that we have an Avahi module
282
 
class avahi(object):
283
 
    """This isn't so much a class as it is a module-like namespace."""
 
277
class Avahi(object):
 
278
    """This isn't so much a class as it is a module-like namespace.
 
279
    It is instantiated once, and simulates having an Avahi module."""
284
280
    IF_UNSPEC = -1               # avahi-common/address.h
285
281
    PROTO_UNSPEC = -1            # avahi-common/address.h
286
282
    PROTO_INET = 0               # avahi-common/address.h
290
286
    DBUS_INTERFACE_SERVER = DBUS_NAME + ".Server"
291
287
    DBUS_PATH_SERVER = "/"
292
288
 
293
 
    @staticmethod
294
 
    def string_array_to_txt_array(t):
 
289
    def string_array_to_txt_array(self, t):
295
290
        return dbus.Array((dbus.ByteArray(s.encode("utf-8"))
296
291
                           for s in t), signature="ay")
297
292
    ENTRY_GROUP_ESTABLISHED = 2  # avahi-common/defs.h
302
297
    SERVER_RUNNING = 2           # avahi-common/defs.h
303
298
    SERVER_COLLISION = 3         # avahi-common/defs.h
304
299
    SERVER_FAILURE = 4           # avahi-common/defs.h
 
300
avahi = Avahi()
305
301
 
306
302
 
307
303
class AvahiError(Exception):
499
495
class AvahiServiceToSyslog(AvahiService):
500
496
    def rename(self, *args, **kwargs):
501
497
        """Add the new name to the syslog messages"""
502
 
        ret = super(AvahiServiceToSyslog, self).rename(*args, **kwargs)
 
498
        ret = AvahiService.rename(self, *args, **kwargs)
503
499
        syslogger.setFormatter(logging.Formatter(
504
500
            'Mandos ({}) [%(process)d]: %(levelname)s: %(message)s'
505
501
            .format(self.name)))
507
503
 
508
504
 
509
505
# Pretend that we have a GnuTLS module
510
 
class gnutls(object):
511
 
    """This isn't so much a class as it is a module-like namespace."""
 
506
class GnuTLS(object):
 
507
    """This isn't so much a class as it is a module-like namespace.
 
508
    It is instantiated once, and simulates having a GnuTLS module."""
512
509
 
513
510
    library = ctypes.util.find_library("gnutls")
514
511
    if library is None:
515
512
        library = ctypes.util.find_library("gnutls-deb0")
516
513
    _library = ctypes.cdll.LoadLibrary(library)
517
514
    del library
 
515
    _need_version = b"3.3.0"
 
516
 
 
517
    def __init__(self):
 
518
        # Need to use "self" here, since this method is called before
 
519
        # the assignment to the "gnutls" global variable happens.
 
520
        if self.check_version(self._need_version) is None:
 
521
            raise self.Error("Needs GnuTLS {} or later"
 
522
                             .format(self._need_version))
518
523
 
519
524
    # Unless otherwise indicated, the constants and types below are
520
525
    # all from the gnutls/gnutls.h C header file.
524
529
    E_INTERRUPTED = -52
525
530
    E_AGAIN = -28
526
531
    CRT_OPENPGP = 2
527
 
    CRT_RAWPK = 3
528
532
    CLIENT = 2
529
533
    SHUT_RDWR = 0
530
534
    CRD_CERTIFICATE = 1
531
535
    E_NO_CERTIFICATE_FOUND = -49
532
 
    X509_FMT_DER = 0
533
 
    NO_TICKETS = 1<<10
534
 
    ENABLE_RAWPK = 1<<18
535
 
    CTYPE_PEERS = 3
536
 
    KEYID_USE_SHA256 = 1        # gnutls/x509.h
537
536
    OPENPGP_FMT_RAW = 0         # gnutls/openpgp.h
538
537
 
539
538
    # Types
562
561
 
563
562
    # Exceptions
564
563
    class Error(Exception):
 
564
        # We need to use the class name "GnuTLS" here, since this
 
565
        # exception might be raised from within GnuTLS.__init__,
 
566
        # which is called before the assignment to the "gnutls"
 
567
        # global variable has happened.
565
568
        def __init__(self, message=None, code=None, args=()):
566
569
            # Default usage is by a message string, but if a return
567
570
            # code is passed, convert it to a string with
568
571
            # gnutls.strerror()
569
572
            self.code = code
570
573
            if message is None and code is not None:
571
 
                message = gnutls.strerror(code)
572
 
            return super(gnutls.Error, self).__init__(
 
574
                message = GnuTLS.strerror(code)
 
575
            return super(GnuTLS.Error, self).__init__(
573
576
                message, *args)
574
577
 
575
578
    class CertificateSecurityError(Error):
589
592
    class ClientSession(object):
590
593
        def __init__(self, socket, credentials=None):
591
594
            self._c_object = gnutls.session_t()
592
 
            gnutls_flags = gnutls.CLIENT
593
 
            if gnutls.check_version(b"3.5.6"):
594
 
                gnutls_flags |= gnutls.NO_TICKETS
595
 
            if gnutls.has_rawpk:
596
 
                gnutls_flags |= gnutls.ENABLE_RAWPK
597
 
            gnutls.init(ctypes.byref(self._c_object), gnutls_flags)
598
 
            del gnutls_flags
 
595
            gnutls.init(ctypes.byref(self._c_object), gnutls.CLIENT)
599
596
            gnutls.set_default_priority(self._c_object)
600
597
            gnutls.transport_set_ptr(self._c_object, socket.fileno())
601
598
            gnutls.handshake_set_private_extensions(self._c_object,
733
730
    check_version.argtypes = [ctypes.c_char_p]
734
731
    check_version.restype = ctypes.c_char_p
735
732
 
736
 
    _need_version = b"3.3.0"
737
 
    if check_version(_need_version) is None:
738
 
        raise self.Error("Needs GnuTLS {} or later"
739
 
                         .format(_need_version))
740
 
 
741
 
    _tls_rawpk_version = b"3.6.6"
742
 
    has_rawpk = bool(check_version(_tls_rawpk_version))
743
 
 
744
 
    if has_rawpk:
745
 
        # Types
746
 
        class pubkey_st(ctypes.Structure):
747
 
            _fields = []
748
 
        pubkey_t = ctypes.POINTER(pubkey_st)
749
 
 
750
 
        x509_crt_fmt_t = ctypes.c_int
751
 
 
752
 
        # All the function declarations below are from gnutls/abstract.h
753
 
        pubkey_init = _library.gnutls_pubkey_init
754
 
        pubkey_init.argtypes = [ctypes.POINTER(pubkey_t)]
755
 
        pubkey_init.restype = _error_code
756
 
 
757
 
        pubkey_import = _library.gnutls_pubkey_import
758
 
        pubkey_import.argtypes = [pubkey_t, ctypes.POINTER(datum_t),
759
 
                                  x509_crt_fmt_t]
760
 
        pubkey_import.restype = _error_code
761
 
 
762
 
        pubkey_get_key_id = _library.gnutls_pubkey_get_key_id
763
 
        pubkey_get_key_id.argtypes = [pubkey_t, ctypes.c_int,
764
 
                                      ctypes.POINTER(ctypes.c_ubyte),
765
 
                                      ctypes.POINTER(ctypes.c_size_t)]
766
 
        pubkey_get_key_id.restype = _error_code
767
 
 
768
 
        pubkey_deinit = _library.gnutls_pubkey_deinit
769
 
        pubkey_deinit.argtypes = [pubkey_t]
770
 
        pubkey_deinit.restype = None
771
 
    else:
772
 
        # All the function declarations below are from gnutls/openpgp.h
773
 
 
774
 
        openpgp_crt_init = _library.gnutls_openpgp_crt_init
775
 
        openpgp_crt_init.argtypes = [ctypes.POINTER(openpgp_crt_t)]
776
 
        openpgp_crt_init.restype = _error_code
777
 
 
778
 
        openpgp_crt_import = _library.gnutls_openpgp_crt_import
779
 
        openpgp_crt_import.argtypes = [openpgp_crt_t,
780
 
                                       ctypes.POINTER(datum_t),
781
 
                                       openpgp_crt_fmt_t]
782
 
        openpgp_crt_import.restype = _error_code
783
 
 
784
 
        openpgp_crt_verify_self = _library.gnutls_openpgp_crt_verify_self
785
 
        openpgp_crt_verify_self.argtypes = [openpgp_crt_t, ctypes.c_uint,
786
 
                                            ctypes.POINTER(ctypes.c_uint)]
787
 
        openpgp_crt_verify_self.restype = _error_code
788
 
 
789
 
        openpgp_crt_deinit = _library.gnutls_openpgp_crt_deinit
790
 
        openpgp_crt_deinit.argtypes = [openpgp_crt_t]
791
 
        openpgp_crt_deinit.restype = None
792
 
 
793
 
        openpgp_crt_get_fingerprint = (
794
 
            _library.gnutls_openpgp_crt_get_fingerprint)
795
 
        openpgp_crt_get_fingerprint.argtypes = [openpgp_crt_t,
796
 
                                                ctypes.c_void_p,
797
 
                                                ctypes.POINTER(
798
 
                                                    ctypes.c_size_t)]
799
 
        openpgp_crt_get_fingerprint.restype = _error_code
800
 
 
801
 
    if check_version(b"3.6.4"):
802
 
        certificate_type_get2 = _library.gnutls_certificate_type_get2
803
 
        certificate_type_get2.argtypes = [session_t, ctypes.c_int]
804
 
        certificate_type_get2.restype = _error_code
 
733
    # All the function declarations below are from gnutls/openpgp.h
 
734
 
 
735
    openpgp_crt_init = _library.gnutls_openpgp_crt_init
 
736
    openpgp_crt_init.argtypes = [ctypes.POINTER(openpgp_crt_t)]
 
737
    openpgp_crt_init.restype = _error_code
 
738
 
 
739
    openpgp_crt_import = _library.gnutls_openpgp_crt_import
 
740
    openpgp_crt_import.argtypes = [openpgp_crt_t,
 
741
                                   ctypes.POINTER(datum_t),
 
742
                                   openpgp_crt_fmt_t]
 
743
    openpgp_crt_import.restype = _error_code
 
744
 
 
745
    openpgp_crt_verify_self = _library.gnutls_openpgp_crt_verify_self
 
746
    openpgp_crt_verify_self.argtypes = [openpgp_crt_t, ctypes.c_uint,
 
747
                                        ctypes.POINTER(ctypes.c_uint)]
 
748
    openpgp_crt_verify_self.restype = _error_code
 
749
 
 
750
    openpgp_crt_deinit = _library.gnutls_openpgp_crt_deinit
 
751
    openpgp_crt_deinit.argtypes = [openpgp_crt_t]
 
752
    openpgp_crt_deinit.restype = None
 
753
 
 
754
    openpgp_crt_get_fingerprint = (
 
755
        _library.gnutls_openpgp_crt_get_fingerprint)
 
756
    openpgp_crt_get_fingerprint.argtypes = [openpgp_crt_t,
 
757
                                            ctypes.c_void_p,
 
758
                                            ctypes.POINTER(
 
759
                                                ctypes.c_size_t)]
 
760
    openpgp_crt_get_fingerprint.restype = _error_code
805
761
 
806
762
    # Remove non-public functions
807
763
    del _error_code, _retry_on_error
 
764
# Create the global "gnutls" object, simulating a module
 
765
gnutls = GnuTLS()
808
766
 
809
767
 
810
768
def call_pipe(connection,       # : multiprocessing.Connection
825
783
    approved:   bool(); 'None' if not yet approved/disapproved
826
784
    approval_delay: datetime.timedelta(); Time to wait for approval
827
785
    approval_duration: datetime.timedelta(); Duration of one approval
828
 
    checker: multiprocessing.Process(); a running checker process used
829
 
             to see if the client lives. 'None' if no process is
830
 
             running.
 
786
    checker:    subprocess.Popen(); a running checker process used
 
787
                                    to see if the client lives.
 
788
                                    'None' if no process is running.
831
789
    checker_callback_tag: a GLib event source tag, or None
832
790
    checker_command: string; External command which is run to check
833
791
                     if client lives.  %() expansions are done at
841
799
    disable_initiator_tag: a GLib event source tag, or None
842
800
    enabled:    bool()
843
801
    fingerprint: string (40 or 32 hexadecimal digits); used to
844
 
                 uniquely identify an OpenPGP client
845
 
    key_id: string (64 hexadecimal digits); used to uniquely identify
846
 
            a client using raw public keys
 
802
                 uniquely identify the client
847
803
    host:       string; available for use by the checker command
848
804
    interval:   datetime.timedelta(); How often to start a new checker
849
805
    last_approval_request: datetime.datetime(); (UTC) or None
867
823
    """
868
824
 
869
825
    runtime_expansions = ("approval_delay", "approval_duration",
870
 
                          "created", "enabled", "expires", "key_id",
 
826
                          "created", "enabled", "expires",
871
827
                          "fingerprint", "host", "interval",
872
828
                          "last_approval_request", "last_checked_ok",
873
829
                          "last_enabled", "name", "timeout")
903
859
            client["enabled"] = config.getboolean(client_name,
904
860
                                                  "enabled")
905
861
 
906
 
            # Uppercase and remove spaces from key_id and fingerprint
907
 
            # for later comparison purposes with return value from the
908
 
            # key_id() and fingerprint() functions
909
 
            client["key_id"] = (section.get("key_id", "").upper()
910
 
                                .replace(" ", ""))
 
862
            # Uppercase and remove spaces from fingerprint for later
 
863
            # comparison purposes with return value from the
 
864
            # fingerprint() function
911
865
            client["fingerprint"] = (section["fingerprint"].upper()
912
866
                                     .replace(" ", ""))
913
867
            if "secret" in section:
957
911
            self.expires = None
958
912
 
959
913
        logger.debug("Creating client %r", self.name)
960
 
        logger.debug("  Key ID: %s", self.key_id)
961
914
        logger.debug("  Fingerprint: %s", self.fingerprint)
962
915
        self.created = settings.get("created",
963
916
                                    datetime.datetime.utcnow())
1040
993
    def checker_callback(self, source, condition, connection,
1041
994
                         command):
1042
995
        """The checker has completed, so take appropriate actions."""
 
996
        self.checker_callback_tag = None
 
997
        self.checker = None
1043
998
        # Read return code from connection (see call_pipe)
1044
999
        returncode = connection.recv()
1045
1000
        connection.close()
1046
 
        self.checker.join()
1047
 
        self.checker_callback_tag = None
1048
 
        self.checker = None
1049
1001
 
1050
1002
        if returncode >= 0:
1051
1003
            self.last_checker_status = returncode
1508
1460
                         exc_info=error)
1509
1461
        return xmlstring
1510
1462
 
1511
 
 
1512
1463
try:
1513
1464
    dbus.OBJECT_MANAGER_IFACE
1514
1465
except AttributeError:
2046
1997
    def Name_dbus_property(self):
2047
1998
        return dbus.String(self.name)
2048
1999
 
2049
 
    # KeyID - property
2050
 
    @dbus_annotations(
2051
 
        {"org.freedesktop.DBus.Property.EmitsChangedSignal": "const"})
2052
 
    @dbus_service_property(_interface, signature="s", access="read")
2053
 
    def KeyID_dbus_property(self):
2054
 
        return dbus.String(self.key_id)
2055
 
 
2056
2000
    # Fingerprint - property
2057
2001
    @dbus_annotations(
2058
2002
        {"org.freedesktop.DBus.Property.EmitsChangedSignal": "const"})
2214
2158
 
2215
2159
 
2216
2160
class ProxyClient(object):
2217
 
    def __init__(self, child_pipe, key_id, fpr, address):
 
2161
    def __init__(self, child_pipe, fpr, address):
2218
2162
        self._pipe = child_pipe
2219
 
        self._pipe.send(('init', key_id, fpr, address))
 
2163
        self._pipe.send(('init', fpr, address))
2220
2164
        if not self._pipe.recv():
2221
 
            raise KeyError(key_id or fpr)
 
2165
            raise KeyError(fpr)
2222
2166
 
2223
2167
    def __getattribute__(self, name):
2224
2168
        if name == '_pipe':
2291
2235
 
2292
2236
            approval_required = False
2293
2237
            try:
2294
 
                if gnutls.has_rawpk:
2295
 
                    fpr = b""
2296
 
                    try:
2297
 
                        key_id = self.key_id(
2298
 
                            self.peer_certificate(session))
2299
 
                    except (TypeError, gnutls.Error) as error:
2300
 
                        logger.warning("Bad certificate: %s", error)
2301
 
                        return
2302
 
                    logger.debug("Key ID: %s", key_id)
2303
 
 
2304
 
                else:
2305
 
                    key_id = b""
2306
 
                    try:
2307
 
                        fpr = self.fingerprint(
2308
 
                            self.peer_certificate(session))
2309
 
                    except (TypeError, gnutls.Error) as error:
2310
 
                        logger.warning("Bad certificate: %s", error)
2311
 
                        return
2312
 
                    logger.debug("Fingerprint: %s", fpr)
2313
 
 
2314
 
                try:
2315
 
                    client = ProxyClient(child_pipe, key_id, fpr,
 
2238
                try:
 
2239
                    fpr = self.fingerprint(
 
2240
                        self.peer_certificate(session))
 
2241
                except (TypeError, gnutls.Error) as error:
 
2242
                    logger.warning("Bad certificate: %s", error)
 
2243
                    return
 
2244
                logger.debug("Fingerprint: %s", fpr)
 
2245
 
 
2246
                try:
 
2247
                    client = ProxyClient(child_pipe, fpr,
2316
2248
                                         self.client_address)
2317
2249
                except KeyError:
2318
2250
                    return
2395
2327
 
2396
2328
    @staticmethod
2397
2329
    def peer_certificate(session):
2398
 
        "Return the peer's certificate as a bytestring"
2399
 
        try:
2400
 
            cert_type = gnutls.certificate_type_get2(session._c_object,
2401
 
                                                     gnutls.CTYPE_PEERS)
2402
 
        except AttributeError:
2403
 
            cert_type = gnutls.certificate_type_get(session._c_object)
2404
 
        if gnutls.has_rawpk:
2405
 
            valid_cert_types = frozenset((gnutls.CRT_RAWPK,))
2406
 
        else:
2407
 
            valid_cert_types = frozenset((gnutls.CRT_OPENPGP,))
2408
 
        # If not a valid certificate type...
2409
 
        if cert_type not in valid_cert_types:
2410
 
            logger.info("Cert type %r not in %r", cert_type,
2411
 
                        valid_cert_types)
 
2330
        "Return the peer's OpenPGP certificate as a bytestring"
 
2331
        # If not an OpenPGP certificate...
 
2332
        if (gnutls.certificate_type_get(session._c_object)
 
2333
            != gnutls.CRT_OPENPGP):
2412
2334
            # ...return invalid data
2413
2335
            return b""
2414
2336
        list_size = ctypes.c_uint(1)
2422
2344
        return ctypes.string_at(cert.data, cert.size)
2423
2345
 
2424
2346
    @staticmethod
2425
 
    def key_id(certificate):
2426
 
        "Convert a certificate bytestring to a hexdigit key ID"
2427
 
        # New GnuTLS "datum" with the public key
2428
 
        datum = gnutls.datum_t(
2429
 
            ctypes.cast(ctypes.c_char_p(certificate),
2430
 
                        ctypes.POINTER(ctypes.c_ubyte)),
2431
 
            ctypes.c_uint(len(certificate)))
2432
 
        # XXX all these need to be created in the gnutls "module"
2433
 
        # New empty GnuTLS certificate
2434
 
        pubkey = gnutls.pubkey_t()
2435
 
        gnutls.pubkey_init(ctypes.byref(pubkey))
2436
 
        # Import the raw public key into the certificate
2437
 
        gnutls.pubkey_import(pubkey,
2438
 
                             ctypes.byref(datum),
2439
 
                             gnutls.X509_FMT_DER)
2440
 
        # New buffer for the key ID
2441
 
        buf = ctypes.create_string_buffer(32)
2442
 
        buf_len = ctypes.c_size_t(len(buf))
2443
 
        # Get the key ID from the raw public key into the buffer
2444
 
        gnutls.pubkey_get_key_id(pubkey,
2445
 
                                 gnutls.KEYID_USE_SHA256,
2446
 
                                 ctypes.cast(ctypes.byref(buf),
2447
 
                                             ctypes.POINTER(ctypes.c_ubyte)),
2448
 
                                 ctypes.byref(buf_len))
2449
 
        # Deinit the certificate
2450
 
        gnutls.pubkey_deinit(pubkey)
2451
 
 
2452
 
        # Convert the buffer to a Python bytestring
2453
 
        key_id = ctypes.string_at(buf, buf_len.value)
2454
 
        # Convert the bytestring to hexadecimal notation
2455
 
        hex_key_id = binascii.hexlify(key_id).upper()
2456
 
        return hex_key_id
2457
 
 
2458
 
    @staticmethod
2459
2347
    def fingerprint(openpgp):
2460
2348
        "Convert an OpenPGP bytestring to a hexdigit fingerprint"
2461
2349
        # New GnuTLS "datum" with the OpenPGP public key
2475
2363
                                       ctypes.byref(crtverify))
2476
2364
        if crtverify.value != 0:
2477
2365
            gnutls.openpgp_crt_deinit(crt)
2478
 
            raise gnutls.CertificateSecurityError(code
2479
 
                                                  =crtverify.value)
 
2366
            raise gnutls.CertificateSecurityError("Verify failed")
2480
2367
        # New buffer for the fingerprint
2481
2368
        buf = ctypes.create_string_buffer(20)
2482
2369
        buf_len = ctypes.c_size_t()
2610
2497
                    raise
2611
2498
        # Only bind(2) the socket if we really need to.
2612
2499
        if self.server_address[0] or self.server_address[1]:
2613
 
            if self.server_address[1]:
2614
 
                self.allow_reuse_address = True
2615
2500
            if not self.server_address[0]:
2616
2501
                if self.address_family == socket.AF_INET6:
2617
2502
                    any_address = "::"  # in6addr_any
2691
2576
        command = request[0]
2692
2577
 
2693
2578
        if command == 'init':
2694
 
            key_id = request[1].decode("ascii")
2695
 
            fpr = request[2].decode("ascii")
2696
 
            address = request[3]
 
2579
            fpr = request[1]
 
2580
            address = request[2]
2697
2581
 
2698
2582
            for c in self.clients.values():
2699
 
                if key_id == "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855":
2700
 
                    continue
2701
 
                if key_id and c.key_id == key_id:
2702
 
                    client = c
2703
 
                    break
2704
 
                if fpr and c.fingerprint == fpr:
 
2583
                if c.fingerprint == fpr:
2705
2584
                    client = c
2706
2585
                    break
2707
2586
            else:
2708
 
                logger.info("Client not found for key ID: %s, address"
2709
 
                            ": %s", key_id or fpr, address)
 
2587
                logger.info("Client not found for fingerprint: %s, ad"
 
2588
                            "dress: %s", fpr, address)
2710
2589
                if self.use_dbus:
2711
2590
                    # Emit D-Bus signal
2712
 
                    mandos_dbus_service.ClientNotFound(key_id or fpr,
 
2591
                    mandos_dbus_service.ClientNotFound(fpr,
2713
2592
                                                       address[0])
2714
2593
                parent_pipe.send(False)
2715
2594
                return False
2978
2857
        sys.exit(os.EX_OK if fail_count == 0 else 1)
2979
2858
 
2980
2859
    # Default values for config file for server-global settings
2981
 
    if gnutls.has_rawpk:
2982
 
        priority = ("SECURE128:!CTYPE-X.509:+CTYPE-RAWPK:!RSA"
2983
 
                    ":!VERS-ALL:+VERS-TLS1.3:%PROFILE_ULTRA")
2984
 
    else:
2985
 
        priority = ("SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:!RSA"
2986
 
                    ":+SIGN-DSA-SHA256")
2987
2860
    server_defaults = {"interface": "",
2988
2861
                       "address": "",
2989
2862
                       "port": "",
2990
2863
                       "debug": "False",
2991
 
                       "priority": priority,
 
2864
                       "priority":
 
2865
                       "SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:!RSA"
 
2866
                       ":+SIGN-DSA-SHA256",
2992
2867
                       "servicename": "Mandos",
2993
2868
                       "use_dbus": "True",
2994
2869
                       "use_ipv6": "True",
2999
2874
                       "foreground": "False",
3000
2875
                       "zeroconf": "True",
3001
2876
                       }
3002
 
    del priority
3003
2877
 
3004
2878
    # Parse config file for server-global settings
3005
 
    server_config = configparser.ConfigParser(server_defaults)
 
2879
    server_config = configparser.SafeConfigParser(server_defaults)
3006
2880
    del server_defaults
3007
2881
    server_config.read(os.path.join(options.configdir, "mandos.conf"))
3008
 
    # Convert the ConfigParser object to a dict
 
2882
    # Convert the SafeConfigParser object to a dict
3009
2883
    server_settings = server_config.defaults()
3010
2884
    # Use the appropriate methods on the non-string config options
3011
 
    for option in ("debug", "use_dbus", "use_ipv6", "restore",
3012
 
                   "foreground", "zeroconf"):
 
2885
    for option in ("debug", "use_dbus", "use_ipv6", "foreground"):
3013
2886
        server_settings[option] = server_config.getboolean("DEFAULT",
3014
2887
                                                           option)
3015
2888
    if server_settings["port"]:
3083
2956
                                  server_settings["servicename"])))
3084
2957
 
3085
2958
    # Parse config file with clients
3086
 
    client_config = configparser.ConfigParser(Client.client_defaults)
 
2959
    client_config = configparser.SafeConfigParser(Client
 
2960
                                                  .client_defaults)
3087
2961
    client_config.read(os.path.join(server_settings["configdir"],
3088
2962
                                    "clients.conf"))
3089
2963
 
3160
3034
        # Close all input and output, do double fork, etc.
3161
3035
        daemon()
3162
3036
 
3163
 
    if gi.version_info < (3, 10, 2):
3164
 
        # multiprocessing will use threads, so before we use GLib we
3165
 
        # need to inform GLib that threads will be used.
3166
 
        GLib.threads_init()
 
3037
    # multiprocessing will use threads, so before we use GLib we need
 
3038
    # to inform GLib that threads will be used.
 
3039
    GLib.threads_init()
3167
3040
 
3168
3041
    global main_loop
3169
3042
    # From the Avahi example code
3249
3122
                        for k in ("name", "host"):
3250
3123
                            if isinstance(value[k], bytes):
3251
3124
                                value[k] = value[k].decode("utf-8")
3252
 
                        if "key_id" not in value:
3253
 
                            value["key_id"] = ""
3254
 
                        elif "fingerprint" not in value:
3255
 
                            value["fingerprint"] = ""
3256
3125
                    #  old_client_settings
3257
3126
                    # .keys()
3258
3127
                    old_client_settings = {
3395
3264
                pass
3396
3265
 
3397
3266
            @dbus.service.signal(_interface, signature="ss")
3398
 
            def ClientNotFound(self, key_id, address):
 
3267
            def ClientNotFound(self, fingerprint, address):
3399
3268
                "D-Bus signal"
3400
3269
                pass
3401
3270