/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-08-24 15:33:58 UTC
  • Revision ID: teddy@recompile.se-20190824153358-o69zprg8yiub1t0d
mandos-monitor: Use new GLib.io_add_watch() call signature

* mandos-monitor: When calling GLib.io_add_watch(), always pass a
                  channel as the first argument instead of a file
                  descriptor, and pass priority as the second
                  argument.  This is supported by PyGObject 3.8 or
                  later.

Show diffs side-by-side

added added

removed removed

Lines of Context:
mandos
1
1
#!/usr/bin/python
2
 
# -*- mode: python; coding: utf-8 -*-
 
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
#
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.20"
 
128
if sys.version_info < (3, 2):
 
129
    configparser.Configparser = configparser.SafeConfigParser
 
130
 
 
131
version = "1.8.8"
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):
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:
504
517
 
505
518
 
506
519
# Pretend that we have a GnuTLS module
507
 
class GnuTLS(object):
508
 
    """This isn't so much a class as it is a module-like namespace.
509
 
    It is instantiated once, and simulates having a GnuTLS module."""
 
520
class gnutls:
 
521
    """This isn't so much a class as it is a module-like namespace."""
510
522
 
511
523
    library = ctypes.util.find_library("gnutls")
512
524
    if library is None:
513
525
        library = ctypes.util.find_library("gnutls-deb0")
514
526
    _library = ctypes.cdll.LoadLibrary(library)
515
527
    del library
516
 
    _need_version = b"3.3.0"
517
 
    _tls_rawpk_version = b"3.6.6"
518
 
 
519
 
    def __init__(self):
520
 
        # Need to use "self" here, since this method is called before
521
 
        # the assignment to the "gnutls" global variable happens.
522
 
        if self.check_version(self._need_version) is None:
523
 
            raise self.Error("Needs GnuTLS {} or later"
524
 
                             .format(self._need_version))
525
528
 
526
529
    # Unless otherwise indicated, the constants and types below are
527
530
    # all from the gnutls/gnutls.h C header file.
569
572
 
570
573
    # Exceptions
571
574
    class Error(Exception):
572
 
        # We need to use the class name "GnuTLS" here, since this
573
 
        # exception might be raised from within GnuTLS.__init__,
574
 
        # which is called before the assignment to the "gnutls"
575
 
        # global variable has happened.
576
575
        def __init__(self, message=None, code=None, args=()):
577
576
            # Default usage is by a message string, but if a return
578
577
            # code is passed, convert it to a string with
579
578
            # gnutls.strerror()
580
579
            self.code = code
581
580
            if message is None and code is not None:
582
 
                message = GnuTLS.strerror(code)
583
 
            return super(GnuTLS.Error, self).__init__(
 
581
                message = gnutls.strerror(code)
 
582
            return super(gnutls.Error, self).__init__(
584
583
                message, *args)
585
584
 
586
585
    class CertificateSecurityError(Error):
587
586
        pass
588
587
 
589
588
    # Classes
590
 
    class Credentials(object):
 
589
    class Credentials:
591
590
        def __init__(self):
592
591
            self._c_object = gnutls.certificate_credentials_t()
593
592
            gnutls.certificate_allocate_credentials(
597
596
        def __del__(self):
598
597
            gnutls.certificate_free_credentials(self._c_object)
599
598
 
600
 
    class ClientSession(object):
 
599
    class ClientSession:
601
600
        def __init__(self, socket, credentials=None):
602
601
            self._c_object = gnutls.session_t()
603
602
            gnutls_flags = gnutls.CLIENT
604
 
            if gnutls.check_version("3.5.6"):
 
603
            if gnutls.check_version(b"3.5.6"):
605
604
                gnutls_flags |= gnutls.NO_TICKETS
606
605
            if gnutls.has_rawpk:
607
606
                gnutls_flags |= gnutls.ENABLE_RAWPK
744
743
    check_version.argtypes = [ctypes.c_char_p]
745
744
    check_version.restype = ctypes.c_char_p
746
745
 
 
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"
747
752
    has_rawpk = bool(check_version(_tls_rawpk_version))
748
753
 
749
754
    if has_rawpk:
803
808
                                                    ctypes.c_size_t)]
804
809
        openpgp_crt_get_fingerprint.restype = _error_code
805
810
 
806
 
    if check_version("3.6.4"):
 
811
    if check_version(b"3.6.4"):
807
812
        certificate_type_get2 = _library.gnutls_certificate_type_get2
808
813
        certificate_type_get2.argtypes = [session_t, ctypes.c_int]
809
814
        certificate_type_get2.restype = _error_code
810
815
 
811
816
    # Remove non-public functions
812
817
    del _error_code, _retry_on_error
813
 
# Create the global "gnutls" object, simulating a module
814
 
gnutls = GnuTLS()
815
818
 
816
819
 
817
820
def call_pipe(connection,       # : multiprocessing.Connection
825
828
    connection.close()
826
829
 
827
830
 
828
 
class Client(object):
 
831
class Client:
829
832
    """A representation of a client host served by this server.
830
833
 
831
834
    Attributes:
832
835
    approved:   bool(); 'None' if not yet approved/disapproved
833
836
    approval_delay: datetime.timedelta(); Time to wait for approval
834
837
    approval_duration: datetime.timedelta(); Duration of one approval
835
 
    checker:    subprocess.Popen(); a running checker process used
836
 
                                    to see if the client lives.
837
 
                                    'None' if no process is running.
 
838
    checker: multiprocessing.Process(); a running checker process used
 
839
             to see if the client lives. 'None' if no process is
 
840
             running.
838
841
    checker_callback_tag: a GLib event source tag, or None
839
842
    checker_command: string; External command which is run to check
840
843
                     if client lives.  %() expansions are done at
1047
1050
    def checker_callback(self, source, condition, connection,
1048
1051
                         command):
1049
1052
        """The checker has completed, so take appropriate actions."""
1050
 
        self.checker_callback_tag = None
1051
 
        self.checker = None
1052
1053
        # Read return code from connection (see call_pipe)
1053
1054
        returncode = connection.recv()
1054
1055
        connection.close()
 
1056
        self.checker.join()
 
1057
        self.checker_callback_tag = None
 
1058
        self.checker = None
1055
1059
 
1056
1060
        if returncode >= 0:
1057
1061
            self.last_checker_status = returncode
1146
1150
                kwargs=popen_args)
1147
1151
            self.checker.start()
1148
1152
            self.checker_callback_tag = GLib.io_add_watch(
1149
 
                pipe[0].fileno(), GLib.IO_IN,
 
1153
                GLib.IOChannel.unix_new(pipe[0].fileno()),
 
1154
                GLib.PRIORITY_DEFAULT, GLib.IO_IN,
1150
1155
                self.checker_callback, pipe[0], command)
1151
1156
        # Re-run this periodically if run by GLib.timeout_add
1152
1157
        return True
2219
2224
    del _interface
2220
2225
 
2221
2226
 
2222
 
class ProxyClient(object):
 
2227
class ProxyClient:
2223
2228
    def __init__(self, child_pipe, key_id, fpr, address):
2224
2229
        self._pipe = child_pipe
2225
2230
        self._pipe.send(('init', key_id, fpr, address))
2298
2303
            approval_required = False
2299
2304
            try:
2300
2305
                if gnutls.has_rawpk:
2301
 
                    fpr = ""
 
2306
                    fpr = b""
2302
2307
                    try:
2303
2308
                        key_id = self.key_id(
2304
2309
                            self.peer_certificate(session))
2308
2313
                    logger.debug("Key ID: %s", key_id)
2309
2314
 
2310
2315
                else:
2311
 
                    key_id = ""
 
2316
                    key_id = b""
2312
2317
                    try:
2313
2318
                        fpr = self.fingerprint(
2314
2319
                            self.peer_certificate(session))
2498
2503
        return hex_fpr
2499
2504
 
2500
2505
 
2501
 
class MultiprocessingMixIn(object):
 
2506
class MultiprocessingMixIn:
2502
2507
    """Like socketserver.ThreadingMixIn, but with multiprocessing"""
2503
2508
 
2504
2509
    def sub_process_main(self, request, address):
2516
2521
        return proc
2517
2522
 
2518
2523
 
2519
 
class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):
 
2524
class MultiprocessingMixInWithPipe(MultiprocessingMixIn):
2520
2525
    """ adds a pipe to the MixIn """
2521
2526
 
2522
2527
    def process_request(self, request, client_address):
2537
2542
 
2538
2543
 
2539
2544
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
2540
 
                     socketserver.TCPServer, object):
 
2545
                     socketserver.TCPServer):
2541
2546
    """IPv6-capable TCP server.  Accepts 'None' as address and/or port
2542
2547
 
2543
2548
    Attributes:
2616
2621
                    raise
2617
2622
        # Only bind(2) the socket if we really need to.
2618
2623
        if self.server_address[0] or self.server_address[1]:
 
2624
            if self.server_address[1]:
 
2625
                self.allow_reuse_address = True
2619
2626
            if not self.server_address[0]:
2620
2627
                if self.address_family == socket.AF_INET6:
2621
2628
                    any_address = "::"  # in6addr_any
2674
2681
    def add_pipe(self, parent_pipe, proc):
2675
2682
        # Call "handle_ipc" for both data and EOF events
2676
2683
        GLib.io_add_watch(
2677
 
            parent_pipe.fileno(),
2678
 
            GLib.IO_IN | GLib.IO_HUP,
 
2684
            GLib.IOChannel.unix_new(parent_pipe.fileno()),
 
2685
            GLib.PRIORITY_DEFAULT, GLib.IO_IN | GLib.IO_HUP,
2679
2686
            functools.partial(self.handle_ipc,
2680
2687
                              parent_pipe=parent_pipe,
2681
2688
                              proc=proc))
2700
2707
            address = request[3]
2701
2708
 
2702
2709
            for c in self.clients.values():
 
2710
                if key_id == "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855":
 
2711
                    continue
2703
2712
                if key_id and c.key_id == key_id:
2704
2713
                    client = c
2705
2714
                    break
2717
2726
                return False
2718
2727
 
2719
2728
            GLib.io_add_watch(
2720
 
                parent_pipe.fileno(),
2721
 
                GLib.IO_IN | GLib.IO_HUP,
 
2729
                GLib.IOChannel.unix_new(parent_pipe.fileno()),
 
2730
                GLib.PRIORITY_DEFAULT, GLib.IO_IN | GLib.IO_HUP,
2722
2731
                functools.partial(self.handle_ipc,
2723
2732
                                  parent_pipe=parent_pipe,
2724
2733
                                  proc=proc,
2974
2983
 
2975
2984
    options = parser.parse_args()
2976
2985
 
2977
 
    if options.check:
2978
 
        import doctest
2979
 
        fail_count, test_count = doctest.testmod()
2980
 
        sys.exit(os.EX_OK if fail_count == 0 else 1)
2981
 
 
2982
2986
    # Default values for config file for server-global settings
2983
2987
    if gnutls.has_rawpk:
2984
2988
        priority = ("SECURE128:!CTYPE-X.509:+CTYPE-RAWPK:!RSA"
3004
3008
    del priority
3005
3009
 
3006
3010
    # Parse config file for server-global settings
3007
 
    server_config = configparser.SafeConfigParser(server_defaults)
 
3011
    server_config = configparser.ConfigParser(server_defaults)
3008
3012
    del server_defaults
3009
3013
    server_config.read(os.path.join(options.configdir, "mandos.conf"))
3010
 
    # Convert the SafeConfigParser object to a dict
 
3014
    # Convert the ConfigParser object to a dict
3011
3015
    server_settings = server_config.defaults()
3012
3016
    # Use the appropriate methods on the non-string config options
3013
3017
    for option in ("debug", "use_dbus", "use_ipv6", "restore",
3085
3089
                                  server_settings["servicename"])))
3086
3090
 
3087
3091
    # Parse config file with clients
3088
 
    client_config = configparser.SafeConfigParser(Client
3089
 
                                                  .client_defaults)
 
3092
    client_config = configparser.ConfigParser(Client.client_defaults)
3090
3093
    client_config.read(os.path.join(server_settings["configdir"],
3091
3094
                                    "clients.conf"))
3092
3095
 
3163
3166
        # Close all input and output, do double fork, etc.
3164
3167
        daemon()
3165
3168
 
3166
 
    # multiprocessing will use threads, so before we use GLib we need
3167
 
    # to inform GLib that threads will be used.
3168
 
    GLib.threads_init()
 
3169
    if gi.version_info < (3, 10, 2):
 
3170
        # multiprocessing will use threads, so before we use GLib we
 
3171
        # need to inform GLib that threads will be used.
 
3172
        GLib.threads_init()
3169
3173
 
3170
3174
    global main_loop
3171
3175
    # From the Avahi example code
3251
3255
                        for k in ("name", "host"):
3252
3256
                            if isinstance(value[k], bytes):
3253
3257
                                value[k] = value[k].decode("utf-8")
3254
 
                        if not value.has_key("key_id"):
 
3258
                        if "key_id" not in value:
3255
3259
                            value["key_id"] = ""
3256
 
                        elif not value.has_key("fingerprint"):
 
3260
                        elif "fingerprint" not in value:
3257
3261
                            value["fingerprint"] = ""
3258
3262
                    #  old_client_settings
3259
3263
                    # .keys()
3599
3603
                sys.exit(1)
3600
3604
            # End of Avahi example code
3601
3605
 
3602
 
        GLib.io_add_watch(tcp_server.fileno(), GLib.IO_IN,
3603
 
                          lambda *args, **kwargs:
3604
 
                          (tcp_server.handle_request
3605
 
                           (*args[2:], **kwargs) or True))
 
3606
        GLib.io_add_watch(
 
3607
            GLib.IOChannel.unix_new(tcp_server.fileno()),
 
3608
            GLib.PRIORITY_DEFAULT, GLib.IO_IN,
 
3609
            lambda *args, **kwargs: (tcp_server.handle_request
 
3610
                                     (*args[2:], **kwargs) or True))
3606
3611
 
3607
3612
        logger.debug("Starting main loop")
3608
3613
        main_loop.run()
3618
3623
    # Must run before the D-Bus bus name gets deregistered
3619
3624
    cleanup()
3620
3625
 
 
3626
 
 
3627
def should_only_run_tests():
 
3628
    parser = argparse.ArgumentParser(add_help=False)
 
3629
    parser.add_argument("--check", action='store_true')
 
3630
    args, unknown_args = parser.parse_known_args()
 
3631
    run_tests = args.check
 
3632
    if run_tests:
 
3633
        # Remove --check argument from sys.argv
 
3634
        sys.argv[1:] = unknown_args
 
3635
    return run_tests
 
3636
 
 
3637
# Add all tests from doctest strings
 
3638
def load_tests(loader, tests, none):
 
3639
    import doctest
 
3640
    tests.addTests(doctest.DocTestSuite())
 
3641
    return tests
3621
3642
 
3622
3643
if __name__ == '__main__':
3623
 
    main()
 
3644
    try:
 
3645
        if should_only_run_tests():
 
3646
            # Call using ./mandos --check [--verbose]
 
3647
            unittest.main()
 
3648
        else:
 
3649
            main()
 
3650
    finally:
 
3651
        logging.shutdown()