/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.8.4"
 
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):
 
292
class avahi:
279
293
    """This isn't so much a class as it is a module-like namespace."""
280
294
    IF_UNSPEC = -1               # avahi-common/address.h
281
295
    PROTO_UNSPEC = -1            # avahi-common/address.h
315
329
    pass
316
330
 
317
331
 
318
 
class AvahiService(object):
 
332
class AvahiService:
319
333
    """An Avahi (Zeroconf) service.
320
334
 
321
335
    Attributes:
503
517
 
504
518
 
505
519
# Pretend that we have a GnuTLS module
506
 
class gnutls(object):
 
520
class gnutls:
507
521
    """This isn't so much a class as it is a module-like namespace."""
508
522
 
509
523
    library = ctypes.util.find_library("gnutls")
572
586
        pass
573
587
 
574
588
    # Classes
575
 
    class Credentials(object):
 
589
    class Credentials:
576
590
        def __init__(self):
577
591
            self._c_object = gnutls.certificate_credentials_t()
578
592
            gnutls.certificate_allocate_credentials(
582
596
        def __del__(self):
583
597
            gnutls.certificate_free_credentials(self._c_object)
584
598
 
585
 
    class ClientSession(object):
 
599
    class ClientSession:
586
600
        def __init__(self, socket, credentials=None):
587
601
            self._c_object = gnutls.session_t()
588
602
            gnutls_flags = gnutls.CLIENT
589
 
            if gnutls.check_version("3.5.6"):
 
603
            if gnutls.check_version(b"3.5.6"):
590
604
                gnutls_flags |= gnutls.NO_TICKETS
591
605
            if gnutls.has_rawpk:
592
606
                gnutls_flags |= gnutls.ENABLE_RAWPK
794
808
                                                    ctypes.c_size_t)]
795
809
        openpgp_crt_get_fingerprint.restype = _error_code
796
810
 
797
 
    if check_version("3.6.4"):
 
811
    if check_version(b"3.6.4"):
798
812
        certificate_type_get2 = _library.gnutls_certificate_type_get2
799
813
        certificate_type_get2.argtypes = [session_t, ctypes.c_int]
800
814
        certificate_type_get2.restype = _error_code
814
828
    connection.close()
815
829
 
816
830
 
817
 
class Client(object):
 
831
class Client:
818
832
    """A representation of a client host served by this server.
819
833
 
820
834
    Attributes:
821
835
    approved:   bool(); 'None' if not yet approved/disapproved
822
836
    approval_delay: datetime.timedelta(); Time to wait for approval
823
837
    approval_duration: datetime.timedelta(); Duration of one approval
824
 
    checker:    subprocess.Popen(); a running checker process used
825
 
                                    to see if the client lives.
826
 
                                    '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.
827
841
    checker_callback_tag: a GLib event source tag, or None
828
842
    checker_command: string; External command which is run to check
829
843
                     if client lives.  %() expansions are done at
1036
1050
    def checker_callback(self, source, condition, connection,
1037
1051
                         command):
1038
1052
        """The checker has completed, so take appropriate actions."""
1039
 
        self.checker_callback_tag = None
1040
 
        self.checker = None
1041
1053
        # Read return code from connection (see call_pipe)
1042
1054
        returncode = connection.recv()
1043
1055
        connection.close()
 
1056
        self.checker.join()
 
1057
        self.checker_callback_tag = None
 
1058
        self.checker = None
1044
1059
 
1045
1060
        if returncode >= 0:
1046
1061
            self.last_checker_status = returncode
1135
1150
                kwargs=popen_args)
1136
1151
            self.checker.start()
1137
1152
            self.checker_callback_tag = GLib.io_add_watch(
1138
 
                pipe[0].fileno(), GLib.IO_IN,
 
1153
                GLib.IOChannel.unix_new(pipe[0].fileno()),
 
1154
                GLib.PRIORITY_DEFAULT, GLib.IO_IN,
1139
1155
                self.checker_callback, pipe[0], command)
1140
1156
        # Re-run this periodically if run by GLib.timeout_add
1141
1157
        return True
2208
2224
    del _interface
2209
2225
 
2210
2226
 
2211
 
class ProxyClient(object):
 
2227
class ProxyClient:
2212
2228
    def __init__(self, child_pipe, key_id, fpr, address):
2213
2229
        self._pipe = child_pipe
2214
2230
        self._pipe.send(('init', key_id, fpr, address))
2287
2303
            approval_required = False
2288
2304
            try:
2289
2305
                if gnutls.has_rawpk:
2290
 
                    fpr = ""
 
2306
                    fpr = b""
2291
2307
                    try:
2292
2308
                        key_id = self.key_id(
2293
2309
                            self.peer_certificate(session))
2297
2313
                    logger.debug("Key ID: %s", key_id)
2298
2314
 
2299
2315
                else:
2300
 
                    key_id = ""
 
2316
                    key_id = b""
2301
2317
                    try:
2302
2318
                        fpr = self.fingerprint(
2303
2319
                            self.peer_certificate(session))
2487
2503
        return hex_fpr
2488
2504
 
2489
2505
 
2490
 
class MultiprocessingMixIn(object):
 
2506
class MultiprocessingMixIn:
2491
2507
    """Like socketserver.ThreadingMixIn, but with multiprocessing"""
2492
2508
 
2493
2509
    def sub_process_main(self, request, address):
2505
2521
        return proc
2506
2522
 
2507
2523
 
2508
 
class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):
 
2524
class MultiprocessingMixInWithPipe(MultiprocessingMixIn):
2509
2525
    """ adds a pipe to the MixIn """
2510
2526
 
2511
2527
    def process_request(self, request, client_address):
2526
2542
 
2527
2543
 
2528
2544
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
2529
 
                     socketserver.TCPServer, object):
 
2545
                     socketserver.TCPServer):
2530
2546
    """IPv6-capable TCP server.  Accepts 'None' as address and/or port
2531
2547
 
2532
2548
    Attributes:
2665
2681
    def add_pipe(self, parent_pipe, proc):
2666
2682
        # Call "handle_ipc" for both data and EOF events
2667
2683
        GLib.io_add_watch(
2668
 
            parent_pipe.fileno(),
2669
 
            GLib.IO_IN | GLib.IO_HUP,
 
2684
            GLib.IOChannel.unix_new(parent_pipe.fileno()),
 
2685
            GLib.PRIORITY_DEFAULT, GLib.IO_IN | GLib.IO_HUP,
2670
2686
            functools.partial(self.handle_ipc,
2671
2687
                              parent_pipe=parent_pipe,
2672
2688
                              proc=proc))
2710
2726
                return False
2711
2727
 
2712
2728
            GLib.io_add_watch(
2713
 
                parent_pipe.fileno(),
2714
 
                GLib.IO_IN | GLib.IO_HUP,
 
2729
                GLib.IOChannel.unix_new(parent_pipe.fileno()),
 
2730
                GLib.PRIORITY_DEFAULT, GLib.IO_IN | GLib.IO_HUP,
2715
2731
                functools.partial(self.handle_ipc,
2716
2732
                                  parent_pipe=parent_pipe,
2717
2733
                                  proc=proc,
2967
2983
 
2968
2984
    options = parser.parse_args()
2969
2985
 
2970
 
    if options.check:
2971
 
        import doctest
2972
 
        fail_count, test_count = doctest.testmod()
2973
 
        sys.exit(os.EX_OK if fail_count == 0 else 1)
2974
 
 
2975
2986
    # Default values for config file for server-global settings
2976
2987
    if gnutls.has_rawpk:
2977
2988
        priority = ("SECURE128:!CTYPE-X.509:+CTYPE-RAWPK:!RSA"
2997
3008
    del priority
2998
3009
 
2999
3010
    # Parse config file for server-global settings
3000
 
    server_config = configparser.SafeConfigParser(server_defaults)
 
3011
    server_config = configparser.ConfigParser(server_defaults)
3001
3012
    del server_defaults
3002
3013
    server_config.read(os.path.join(options.configdir, "mandos.conf"))
3003
 
    # Convert the SafeConfigParser object to a dict
 
3014
    # Convert the ConfigParser object to a dict
3004
3015
    server_settings = server_config.defaults()
3005
3016
    # Use the appropriate methods on the non-string config options
3006
3017
    for option in ("debug", "use_dbus", "use_ipv6", "restore",
3078
3089
                                  server_settings["servicename"])))
3079
3090
 
3080
3091
    # Parse config file with clients
3081
 
    client_config = configparser.SafeConfigParser(Client
3082
 
                                                  .client_defaults)
 
3092
    client_config = configparser.ConfigParser(Client.client_defaults)
3083
3093
    client_config.read(os.path.join(server_settings["configdir"],
3084
3094
                                    "clients.conf"))
3085
3095
 
3156
3166
        # Close all input and output, do double fork, etc.
3157
3167
        daemon()
3158
3168
 
3159
 
    # multiprocessing will use threads, so before we use GLib we need
3160
 
    # to inform GLib that threads will be used.
3161
 
    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()
3162
3173
 
3163
3174
    global main_loop
3164
3175
    # From the Avahi example code
3244
3255
                        for k in ("name", "host"):
3245
3256
                            if isinstance(value[k], bytes):
3246
3257
                                value[k] = value[k].decode("utf-8")
3247
 
                        if not value.has_key("key_id"):
 
3258
                        if "key_id" not in value:
3248
3259
                            value["key_id"] = ""
3249
 
                        elif not value.has_key("fingerprint"):
 
3260
                        elif "fingerprint" not in value:
3250
3261
                            value["fingerprint"] = ""
3251
3262
                    #  old_client_settings
3252
3263
                    # .keys()
3592
3603
                sys.exit(1)
3593
3604
            # End of Avahi example code
3594
3605
 
3595
 
        GLib.io_add_watch(tcp_server.fileno(), GLib.IO_IN,
3596
 
                          lambda *args, **kwargs:
3597
 
                          (tcp_server.handle_request
3598
 
                           (*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))
3599
3611
 
3600
3612
        logger.debug("Starting main loop")
3601
3613
        main_loop.run()
3611
3623
    # Must run before the D-Bus bus name gets deregistered
3612
3624
    cleanup()
3613
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
3614
3642
 
3615
3643
if __name__ == '__main__':
3616
 
    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()