/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: 2021-02-03 08:41:01 UTC
  • mfrom: (237.7.783 trunk)
  • Revision ID: teddy@recompile.se-20210203084101-411siabek78fx6bi
Merge from trunk

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-2019 Teddy Hogeborn
15
 
# Copyright © 2008-2019 Björn Påhlsson
 
14
# Copyright © 2008-2020 Teddy Hogeborn
 
15
# Copyright © 2008-2020 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
 
81
import random
 
82
import shlex
80
83
 
81
84
import dbus
82
85
import dbus.service
88
91
import xml.dom.minidom
89
92
import inspect
90
93
 
 
94
if sys.version_info.major == 2:
 
95
    __metaclass__ = type
 
96
    str = unicode
 
97
 
 
98
# Add collections.abc.Callable if it does not exist
 
99
try:
 
100
    collections.abc.Callable
 
101
except AttributeError:
 
102
    class abc:
 
103
        Callable = collections.Callable
 
104
    collections.abc = abc
 
105
    del abc
 
106
 
 
107
# Add shlex.quote if it does not exist
 
108
try:
 
109
    shlex.quote
 
110
except AttributeError:
 
111
    shlex.quote = re.escape
 
112
 
 
113
# Show warnings by default
 
114
if not sys.warnoptions:
 
115
    import warnings
 
116
    warnings.simplefilter("default")
 
117
 
91
118
# Try to find the value of SO_BINDTODEVICE:
92
119
try:
93
120
    # This is where SO_BINDTODEVICE is in Python 3.3 (or 3.4?) and
113
140
            # No value found
114
141
            SO_BINDTODEVICE = None
115
142
 
116
 
if sys.version_info.major == 2:
117
 
    str = unicode
118
 
 
119
143
if sys.version_info < (3, 2):
120
144
    configparser.Configparser = configparser.SafeConfigParser
121
145
 
122
 
version = "1.8.7"
 
146
version = "1.8.13"
123
147
stored_state_file = "clients.pickle"
124
148
 
125
149
logger = logging.getLogger()
 
150
logging.captureWarnings(True)   # Show warnings via the logging system
126
151
syslogger = None
127
152
 
128
153
try:
183
208
    pass
184
209
 
185
210
 
186
 
class PGPEngine(object):
 
211
class PGPEngine:
187
212
    """A simple class for OpenPGP symmetric encryption & decryption"""
188
213
 
189
214
    def __init__(self):
193
218
            output = subprocess.check_output(["gpgconf"])
194
219
            for line in output.splitlines():
195
220
                name, text, path = line.split(b":")
196
 
                if name == "gpg":
 
221
                if name == b"gpg":
197
222
                    self.gpg = path
198
223
                    break
199
224
        except OSError as e:
204
229
                          '--force-mdc',
205
230
                          '--quiet']
206
231
        # Only GPG version 1 has the --no-use-agent option.
207
 
        if self.gpg == "gpg" or self.gpg.endswith("/gpg"):
 
232
        if self.gpg == b"gpg" or self.gpg.endswith(b"/gpg"):
208
233
            self.gnupgargs.append("--no-use-agent")
209
234
 
210
235
    def __enter__(self):
279
304
 
280
305
 
281
306
# Pretend that we have an Avahi module
282
 
class avahi(object):
 
307
class avahi:
283
308
    """This isn't so much a class as it is a module-like namespace."""
284
309
    IF_UNSPEC = -1               # avahi-common/address.h
285
310
    PROTO_UNSPEC = -1            # avahi-common/address.h
319
344
    pass
320
345
 
321
346
 
322
 
class AvahiService(object):
 
347
class AvahiService:
323
348
    """An Avahi (Zeroconf) service.
324
349
 
325
350
    Attributes:
499
524
class AvahiServiceToSyslog(AvahiService):
500
525
    def rename(self, *args, **kwargs):
501
526
        """Add the new name to the syslog messages"""
502
 
        ret = super(AvahiServiceToSyslog, self).rename(*args, **kwargs)
 
527
        ret = super(AvahiServiceToSyslog, self).rename(*args,
 
528
                                                       **kwargs)
503
529
        syslogger.setFormatter(logging.Formatter(
504
530
            'Mandos ({}) [%(process)d]: %(levelname)s: %(message)s'
505
531
            .format(self.name)))
507
533
 
508
534
 
509
535
# Pretend that we have a GnuTLS module
510
 
class gnutls(object):
 
536
class gnutls:
511
537
    """This isn't so much a class as it is a module-like namespace."""
512
538
 
513
539
    library = ctypes.util.find_library("gnutls")
576
602
        pass
577
603
 
578
604
    # Classes
579
 
    class Credentials(object):
 
605
    class Credentials:
580
606
        def __init__(self):
581
607
            self._c_object = gnutls.certificate_credentials_t()
582
608
            gnutls.certificate_allocate_credentials(
586
612
        def __del__(self):
587
613
            gnutls.certificate_free_credentials(self._c_object)
588
614
 
589
 
    class ClientSession(object):
 
615
    class ClientSession:
590
616
        def __init__(self, socket, credentials=None):
591
617
            self._c_object = gnutls.session_t()
592
618
            gnutls_flags = gnutls.CLIENT
749
775
 
750
776
        x509_crt_fmt_t = ctypes.c_int
751
777
 
752
 
        # All the function declarations below are from gnutls/abstract.h
 
778
        # All the function declarations below are from
 
779
        # gnutls/abstract.h
753
780
        pubkey_init = _library.gnutls_pubkey_init
754
781
        pubkey_init.argtypes = [ctypes.POINTER(pubkey_t)]
755
782
        pubkey_init.restype = _error_code
769
796
        pubkey_deinit.argtypes = [pubkey_t]
770
797
        pubkey_deinit.restype = None
771
798
    else:
772
 
        # All the function declarations below are from gnutls/openpgp.h
 
799
        # All the function declarations below are from
 
800
        # gnutls/openpgp.h
773
801
 
774
802
        openpgp_crt_init = _library.gnutls_openpgp_crt_init
775
803
        openpgp_crt_init.argtypes = [ctypes.POINTER(openpgp_crt_t)]
781
809
                                       openpgp_crt_fmt_t]
782
810
        openpgp_crt_import.restype = _error_code
783
811
 
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)]
 
812
        openpgp_crt_verify_self = \
 
813
            _library.gnutls_openpgp_crt_verify_self
 
814
        openpgp_crt_verify_self.argtypes = [
 
815
            openpgp_crt_t,
 
816
            ctypes.c_uint,
 
817
            ctypes.POINTER(ctypes.c_uint),
 
818
        ]
787
819
        openpgp_crt_verify_self.restype = _error_code
788
820
 
789
821
        openpgp_crt_deinit = _library.gnutls_openpgp_crt_deinit
818
850
    connection.close()
819
851
 
820
852
 
821
 
class Client(object):
 
853
class Client:
822
854
    """A representation of a client host served by this server.
823
855
 
824
856
    Attributes:
1027
1059
        if self.checker_initiator_tag is not None:
1028
1060
            GLib.source_remove(self.checker_initiator_tag)
1029
1061
        self.checker_initiator_tag = GLib.timeout_add(
1030
 
            int(self.interval.total_seconds() * 1000),
 
1062
            random.randrange(int(self.interval.total_seconds() * 1000
 
1063
                                 + 1)),
1031
1064
            self.start_checker)
1032
1065
        # Schedule a disable() when 'timeout' has passed
1033
1066
        if self.disable_initiator_tag is not None:
1043
1076
        # Read return code from connection (see call_pipe)
1044
1077
        returncode = connection.recv()
1045
1078
        connection.close()
1046
 
        self.checker.join()
 
1079
        if self.checker is not None:
 
1080
            self.checker.join()
1047
1081
        self.checker_callback_tag = None
1048
1082
        self.checker = None
1049
1083
 
1107
1141
        if self.checker is None:
1108
1142
            # Escape attributes for the shell
1109
1143
            escaped_attrs = {
1110
 
                attr: re.escape(str(getattr(self, attr)))
 
1144
                attr: shlex.quote(str(getattr(self, attr)))
1111
1145
                for attr in self.runtime_expansions}
1112
1146
            try:
1113
1147
                command = self.checker_command % escaped_attrs
1140
1174
                kwargs=popen_args)
1141
1175
            self.checker.start()
1142
1176
            self.checker_callback_tag = GLib.io_add_watch(
1143
 
                pipe[0].fileno(), GLib.IO_IN,
 
1177
                GLib.IOChannel.unix_new(pipe[0].fileno()),
 
1178
                GLib.PRIORITY_DEFAULT, GLib.IO_IN,
1144
1179
                self.checker_callback, pipe[0], command)
1145
1180
        # Re-run this periodically if run by GLib.timeout_add
1146
1181
        return True
1401
1436
                raise ValueError("Byte arrays not supported for non-"
1402
1437
                                 "'ay' signature {!r}"
1403
1438
                                 .format(prop._dbus_signature))
1404
 
            value = dbus.ByteArray(b''.join(chr(byte)
1405
 
                                            for byte in value))
 
1439
            value = dbus.ByteArray(bytes(value))
1406
1440
        prop(value)
1407
1441
 
1408
1442
    @dbus.service.method(dbus.PROPERTIES_IFACE,
2213
2247
    del _interface
2214
2248
 
2215
2249
 
2216
 
class ProxyClient(object):
 
2250
class ProxyClient:
2217
2251
    def __init__(self, child_pipe, key_id, fpr, address):
2218
2252
        self._pipe = child_pipe
2219
2253
        self._pipe.send(('init', key_id, fpr, address))
2441
2475
        buf = ctypes.create_string_buffer(32)
2442
2476
        buf_len = ctypes.c_size_t(len(buf))
2443
2477
        # 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))
 
2478
        gnutls.pubkey_get_key_id(
 
2479
            pubkey,
 
2480
            gnutls.KEYID_USE_SHA256,
 
2481
            ctypes.cast(ctypes.byref(buf),
 
2482
                        ctypes.POINTER(ctypes.c_ubyte)),
 
2483
            ctypes.byref(buf_len))
2449
2484
        # Deinit the certificate
2450
2485
        gnutls.pubkey_deinit(pubkey)
2451
2486
 
2492
2527
        return hex_fpr
2493
2528
 
2494
2529
 
2495
 
class MultiprocessingMixIn(object):
 
2530
class MultiprocessingMixIn:
2496
2531
    """Like socketserver.ThreadingMixIn, but with multiprocessing"""
2497
2532
 
2498
2533
    def sub_process_main(self, request, address):
2510
2545
        return proc
2511
2546
 
2512
2547
 
2513
 
class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):
 
2548
class MultiprocessingMixInWithPipe(MultiprocessingMixIn):
2514
2549
    """ adds a pipe to the MixIn """
2515
2550
 
2516
2551
    def process_request(self, request, client_address):
2531
2566
 
2532
2567
 
2533
2568
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
2534
 
                     socketserver.TCPServer, object):
 
2569
                     socketserver.TCPServer):
2535
2570
    """IPv6-capable TCP server.  Accepts 'None' as address and/or port
2536
2571
 
2537
2572
    Attributes:
2670
2705
    def add_pipe(self, parent_pipe, proc):
2671
2706
        # Call "handle_ipc" for both data and EOF events
2672
2707
        GLib.io_add_watch(
2673
 
            parent_pipe.fileno(),
2674
 
            GLib.IO_IN | GLib.IO_HUP,
 
2708
            GLib.IOChannel.unix_new(parent_pipe.fileno()),
 
2709
            GLib.PRIORITY_DEFAULT, GLib.IO_IN | GLib.IO_HUP,
2675
2710
            functools.partial(self.handle_ipc,
2676
2711
                              parent_pipe=parent_pipe,
2677
2712
                              proc=proc))
2696
2731
            address = request[3]
2697
2732
 
2698
2733
            for c in self.clients.values():
2699
 
                if key_id == "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855":
 
2734
                if key_id == ("E3B0C44298FC1C149AFBF4C8996FB924"
 
2735
                              "27AE41E4649B934CA495991B7852B855"):
2700
2736
                    continue
2701
2737
                if key_id and c.key_id == key_id:
2702
2738
                    client = c
2715
2751
                return False
2716
2752
 
2717
2753
            GLib.io_add_watch(
2718
 
                parent_pipe.fileno(),
2719
 
                GLib.IO_IN | GLib.IO_HUP,
 
2754
                GLib.IOChannel.unix_new(parent_pipe.fileno()),
 
2755
                GLib.PRIORITY_DEFAULT, GLib.IO_IN | GLib.IO_HUP,
2720
2756
                functools.partial(self.handle_ipc,
2721
2757
                                  parent_pipe=parent_pipe,
2722
2758
                                  proc=proc,
2737
2773
        if command == 'getattr':
2738
2774
            attrname = request[1]
2739
2775
            if isinstance(client_object.__getattribute__(attrname),
2740
 
                          collections.Callable):
 
2776
                          collections.abc.Callable):
2741
2777
                parent_pipe.send(('function', ))
2742
2778
            else:
2743
2779
                parent_pipe.send((
2754
2790
def rfc3339_duration_to_delta(duration):
2755
2791
    """Parse an RFC 3339 "duration" and return a datetime.timedelta
2756
2792
 
2757
 
    >>> rfc3339_duration_to_delta("P7D")
2758
 
    datetime.timedelta(7)
2759
 
    >>> rfc3339_duration_to_delta("PT60S")
2760
 
    datetime.timedelta(0, 60)
2761
 
    >>> rfc3339_duration_to_delta("PT60M")
2762
 
    datetime.timedelta(0, 3600)
2763
 
    >>> rfc3339_duration_to_delta("PT24H")
2764
 
    datetime.timedelta(1)
2765
 
    >>> rfc3339_duration_to_delta("P1W")
2766
 
    datetime.timedelta(7)
2767
 
    >>> rfc3339_duration_to_delta("PT5M30S")
2768
 
    datetime.timedelta(0, 330)
2769
 
    >>> rfc3339_duration_to_delta("P1DT3M20S")
2770
 
    datetime.timedelta(1, 200)
 
2793
    >>> timedelta = datetime.timedelta
 
2794
    >>> rfc3339_duration_to_delta("P7D") == timedelta(7)
 
2795
    True
 
2796
    >>> rfc3339_duration_to_delta("PT60S") == timedelta(0, 60)
 
2797
    True
 
2798
    >>> rfc3339_duration_to_delta("PT60M") == timedelta(0, 3600)
 
2799
    True
 
2800
    >>> rfc3339_duration_to_delta("PT24H") == timedelta(1)
 
2801
    True
 
2802
    >>> rfc3339_duration_to_delta("P1W") == timedelta(7)
 
2803
    True
 
2804
    >>> rfc3339_duration_to_delta("PT5M30S") == timedelta(0, 330)
 
2805
    True
 
2806
    >>> rfc3339_duration_to_delta("P1DT3M20S") == timedelta(1, 200)
 
2807
    True
 
2808
    >>> del timedelta
2771
2809
    """
2772
2810
 
2773
2811
    # Parsing an RFC 3339 duration with regular expressions is not
2853
2891
def string_to_delta(interval):
2854
2892
    """Parse a string and return a datetime.timedelta
2855
2893
 
2856
 
    >>> string_to_delta('7d')
2857
 
    datetime.timedelta(7)
2858
 
    >>> string_to_delta('60s')
2859
 
    datetime.timedelta(0, 60)
2860
 
    >>> string_to_delta('60m')
2861
 
    datetime.timedelta(0, 3600)
2862
 
    >>> string_to_delta('24h')
2863
 
    datetime.timedelta(1)
2864
 
    >>> string_to_delta('1w')
2865
 
    datetime.timedelta(7)
2866
 
    >>> string_to_delta('5m 30s')
2867
 
    datetime.timedelta(0, 330)
 
2894
    >>> string_to_delta('7d') == datetime.timedelta(7)
 
2895
    True
 
2896
    >>> string_to_delta('60s') == datetime.timedelta(0, 60)
 
2897
    True
 
2898
    >>> string_to_delta('60m') == datetime.timedelta(0, 3600)
 
2899
    True
 
2900
    >>> string_to_delta('24h') == datetime.timedelta(1)
 
2901
    True
 
2902
    >>> string_to_delta('1w') == datetime.timedelta(7)
 
2903
    True
 
2904
    >>> string_to_delta('5m 30s') == datetime.timedelta(0, 330)
 
2905
    True
2868
2906
    """
2869
2907
 
2870
2908
    try:
2972
3010
 
2973
3011
    options = parser.parse_args()
2974
3012
 
2975
 
    if options.check:
2976
 
        import doctest
2977
 
        fail_count, test_count = doctest.testmod()
2978
 
        sys.exit(os.EX_OK if fail_count == 0 else 1)
2979
 
 
2980
3013
    # Default values for config file for server-global settings
2981
3014
    if gnutls.has_rawpk:
2982
3015
        priority = ("SECURE128:!CTYPE-X.509:+CTYPE-RAWPK:!RSA"
3245
3278
                             if isinstance(s, bytes)
3246
3279
                             else s) for s in
3247
3280
                            value["client_structure"]]
3248
 
                        # .name & .host
3249
 
                        for k in ("name", "host"):
 
3281
                        # .name, .host, and .checker_command
 
3282
                        for k in ("name", "host", "checker_command"):
3250
3283
                            if isinstance(value[k], bytes):
3251
3284
                                value[k] = value[k].decode("utf-8")
3252
3285
                        if "key_id" not in value:
3262
3295
                        for key, value in
3263
3296
                        bytes_old_client_settings.items()}
3264
3297
                    del bytes_old_client_settings
3265
 
                    # .host
 
3298
                    # .host and .checker_command
3266
3299
                    for value in old_client_settings.values():
3267
 
                        if isinstance(value["host"], bytes):
3268
 
                            value["host"] = (value["host"]
3269
 
                                             .decode("utf-8"))
 
3300
                        for attribute in ("host", "checker_command"):
 
3301
                            if isinstance(value[attribute], bytes):
 
3302
                                value[attribute] = (value[attribute]
 
3303
                                                    .decode("utf-8"))
3270
3304
            os.remove(stored_state_path)
3271
3305
        except IOError as e:
3272
3306
            if e.errno == errno.ENOENT:
3597
3631
                sys.exit(1)
3598
3632
            # End of Avahi example code
3599
3633
 
3600
 
        GLib.io_add_watch(tcp_server.fileno(), GLib.IO_IN,
3601
 
                          lambda *args, **kwargs:
3602
 
                          (tcp_server.handle_request
3603
 
                           (*args[2:], **kwargs) or True))
 
3634
        GLib.io_add_watch(
 
3635
            GLib.IOChannel.unix_new(tcp_server.fileno()),
 
3636
            GLib.PRIORITY_DEFAULT, GLib.IO_IN,
 
3637
            lambda *args, **kwargs: (tcp_server.handle_request
 
3638
                                     (*args[2:], **kwargs) or True))
3604
3639
 
3605
3640
        logger.debug("Starting main loop")
3606
3641
        main_loop.run()
3616
3651
    # Must run before the D-Bus bus name gets deregistered
3617
3652
    cleanup()
3618
3653
 
 
3654
 
 
3655
def should_only_run_tests():
 
3656
    parser = argparse.ArgumentParser(add_help=False)
 
3657
    parser.add_argument("--check", action='store_true')
 
3658
    args, unknown_args = parser.parse_known_args()
 
3659
    run_tests = args.check
 
3660
    if run_tests:
 
3661
        # Remove --check argument from sys.argv
 
3662
        sys.argv[1:] = unknown_args
 
3663
    return run_tests
 
3664
 
 
3665
# Add all tests from doctest strings
 
3666
def load_tests(loader, tests, none):
 
3667
    import doctest
 
3668
    tests.addTests(doctest.DocTestSuite())
 
3669
    return tests
3619
3670
 
3620
3671
if __name__ == '__main__':
3621
 
    main()
 
3672
    try:
 
3673
        if should_only_run_tests():
 
3674
            # Call using ./mandos --check [--verbose]
 
3675
            unittest.main()
 
3676
        else:
 
3677
            main()
 
3678
    finally:
 
3679
        logging.shutdown()