/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 at recompile
  • Date: 2020-07-04 11:58:52 UTC
  • Revision ID: teddy@recompile.se-20200704115852-oquhnmng3zom4ldl
Update copyright year

* DBUS-API: Update copyright year to 2020
* debian/copyright: - '' -
* dracut-module/ask-password-mandos.service: - '' -
* dracut-module/password-agent.c: - '' -
* mandos: - '' -
* mandos-ctl: - '' -
* plugin-runner.c: - '' -
* plugins.d/mandos-client.c: - '' -
* plugins.d/plymouth.c: - '' -
* mandos-to-cryptroot-unlock: Update copyright year to 2019.

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
 
86
import gi
83
87
from gi.repository import GLib
84
88
from dbus.mainloop.glib import DBusGMainLoop
85
89
import ctypes
87
91
import xml.dom.minidom
88
92
import inspect
89
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
 
90
118
# Try to find the value of SO_BINDTODEVICE:
91
119
try:
92
120
    # This is where SO_BINDTODEVICE is in Python 3.3 (or 3.4?) and
112
140
            # No value found
113
141
            SO_BINDTODEVICE = None
114
142
 
115
 
if sys.version_info.major == 2:
116
 
    str = unicode
 
143
if sys.version_info < (3, 2):
 
144
    configparser.Configparser = configparser.SafeConfigParser
117
145
 
118
 
version = "1.8.4"
 
146
version = "1.8.11"
119
147
stored_state_file = "clients.pickle"
120
148
 
121
149
logger = logging.getLogger()
 
150
logging.captureWarnings(True)   # Show warnings via the logging system
122
151
syslogger = None
123
152
 
124
153
try:
179
208
    pass
180
209
 
181
210
 
182
 
class PGPEngine(object):
 
211
class PGPEngine:
183
212
    """A simple class for OpenPGP symmetric encryption & decryption"""
184
213
 
185
214
    def __init__(self):
189
218
            output = subprocess.check_output(["gpgconf"])
190
219
            for line in output.splitlines():
191
220
                name, text, path = line.split(b":")
192
 
                if name == "gpg":
 
221
                if name == b"gpg":
193
222
                    self.gpg = path
194
223
                    break
195
224
        except OSError as e:
200
229
                          '--force-mdc',
201
230
                          '--quiet']
202
231
        # Only GPG version 1 has the --no-use-agent option.
203
 
        if self.gpg == "gpg" or self.gpg.endswith("/gpg"):
 
232
        if self.gpg == b"gpg" or self.gpg.endswith(b"/gpg"):
204
233
            self.gnupgargs.append("--no-use-agent")
205
234
 
206
235
    def __enter__(self):
275
304
 
276
305
 
277
306
# Pretend that we have an Avahi module
278
 
class avahi(object):
 
307
class avahi:
279
308
    """This isn't so much a class as it is a module-like namespace."""
280
309
    IF_UNSPEC = -1               # avahi-common/address.h
281
310
    PROTO_UNSPEC = -1            # avahi-common/address.h
315
344
    pass
316
345
 
317
346
 
318
 
class AvahiService(object):
 
347
class AvahiService:
319
348
    """An Avahi (Zeroconf) service.
320
349
 
321
350
    Attributes:
503
532
 
504
533
 
505
534
# Pretend that we have a GnuTLS module
506
 
class gnutls(object):
 
535
class gnutls:
507
536
    """This isn't so much a class as it is a module-like namespace."""
508
537
 
509
538
    library = ctypes.util.find_library("gnutls")
572
601
        pass
573
602
 
574
603
    # Classes
575
 
    class Credentials(object):
 
604
    class Credentials:
576
605
        def __init__(self):
577
606
            self._c_object = gnutls.certificate_credentials_t()
578
607
            gnutls.certificate_allocate_credentials(
582
611
        def __del__(self):
583
612
            gnutls.certificate_free_credentials(self._c_object)
584
613
 
585
 
    class ClientSession(object):
 
614
    class ClientSession:
586
615
        def __init__(self, socket, credentials=None):
587
616
            self._c_object = gnutls.session_t()
588
617
            gnutls_flags = gnutls.CLIENT
814
843
    connection.close()
815
844
 
816
845
 
817
 
class Client(object):
 
846
class Client:
818
847
    """A representation of a client host served by this server.
819
848
 
820
849
    Attributes:
1023
1052
        if self.checker_initiator_tag is not None:
1024
1053
            GLib.source_remove(self.checker_initiator_tag)
1025
1054
        self.checker_initiator_tag = GLib.timeout_add(
1026
 
            int(self.interval.total_seconds() * 1000),
 
1055
            random.randrange(int(self.interval.total_seconds() * 1000
 
1056
                                 + 1)),
1027
1057
            self.start_checker)
1028
1058
        # Schedule a disable() when 'timeout' has passed
1029
1059
        if self.disable_initiator_tag is not None:
1039
1069
        # Read return code from connection (see call_pipe)
1040
1070
        returncode = connection.recv()
1041
1071
        connection.close()
1042
 
        self.checker.join()
 
1072
        if self.checker is not None:
 
1073
            self.checker.join()
1043
1074
        self.checker_callback_tag = None
1044
1075
        self.checker = None
1045
1076
 
1103
1134
        if self.checker is None:
1104
1135
            # Escape attributes for the shell
1105
1136
            escaped_attrs = {
1106
 
                attr: re.escape(str(getattr(self, attr)))
 
1137
                attr: shlex.quote(str(getattr(self, attr)))
1107
1138
                for attr in self.runtime_expansions}
1108
1139
            try:
1109
1140
                command = self.checker_command % escaped_attrs
1136
1167
                kwargs=popen_args)
1137
1168
            self.checker.start()
1138
1169
            self.checker_callback_tag = GLib.io_add_watch(
1139
 
                pipe[0].fileno(), GLib.IO_IN,
 
1170
                GLib.IOChannel.unix_new(pipe[0].fileno()),
 
1171
                GLib.PRIORITY_DEFAULT, GLib.IO_IN,
1140
1172
                self.checker_callback, pipe[0], command)
1141
1173
        # Re-run this periodically if run by GLib.timeout_add
1142
1174
        return True
1397
1429
                raise ValueError("Byte arrays not supported for non-"
1398
1430
                                 "'ay' signature {!r}"
1399
1431
                                 .format(prop._dbus_signature))
1400
 
            value = dbus.ByteArray(b''.join(chr(byte)
1401
 
                                            for byte in value))
 
1432
            value = dbus.ByteArray(bytes(value))
1402
1433
        prop(value)
1403
1434
 
1404
1435
    @dbus.service.method(dbus.PROPERTIES_IFACE,
2209
2240
    del _interface
2210
2241
 
2211
2242
 
2212
 
class ProxyClient(object):
 
2243
class ProxyClient:
2213
2244
    def __init__(self, child_pipe, key_id, fpr, address):
2214
2245
        self._pipe = child_pipe
2215
2246
        self._pipe.send(('init', key_id, fpr, address))
2488
2519
        return hex_fpr
2489
2520
 
2490
2521
 
2491
 
class MultiprocessingMixIn(object):
 
2522
class MultiprocessingMixIn:
2492
2523
    """Like socketserver.ThreadingMixIn, but with multiprocessing"""
2493
2524
 
2494
2525
    def sub_process_main(self, request, address):
2506
2537
        return proc
2507
2538
 
2508
2539
 
2509
 
class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):
 
2540
class MultiprocessingMixInWithPipe(MultiprocessingMixIn):
2510
2541
    """ adds a pipe to the MixIn """
2511
2542
 
2512
2543
    def process_request(self, request, client_address):
2527
2558
 
2528
2559
 
2529
2560
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
2530
 
                     socketserver.TCPServer, object):
 
2561
                     socketserver.TCPServer):
2531
2562
    """IPv6-capable TCP server.  Accepts 'None' as address and/or port
2532
2563
 
2533
2564
    Attributes:
2666
2697
    def add_pipe(self, parent_pipe, proc):
2667
2698
        # Call "handle_ipc" for both data and EOF events
2668
2699
        GLib.io_add_watch(
2669
 
            parent_pipe.fileno(),
2670
 
            GLib.IO_IN | GLib.IO_HUP,
 
2700
            GLib.IOChannel.unix_new(parent_pipe.fileno()),
 
2701
            GLib.PRIORITY_DEFAULT, GLib.IO_IN | GLib.IO_HUP,
2671
2702
            functools.partial(self.handle_ipc,
2672
2703
                              parent_pipe=parent_pipe,
2673
2704
                              proc=proc))
2711
2742
                return False
2712
2743
 
2713
2744
            GLib.io_add_watch(
2714
 
                parent_pipe.fileno(),
2715
 
                GLib.IO_IN | GLib.IO_HUP,
 
2745
                GLib.IOChannel.unix_new(parent_pipe.fileno()),
 
2746
                GLib.PRIORITY_DEFAULT, GLib.IO_IN | GLib.IO_HUP,
2716
2747
                functools.partial(self.handle_ipc,
2717
2748
                                  parent_pipe=parent_pipe,
2718
2749
                                  proc=proc,
2733
2764
        if command == 'getattr':
2734
2765
            attrname = request[1]
2735
2766
            if isinstance(client_object.__getattribute__(attrname),
2736
 
                          collections.Callable):
 
2767
                          collections.abc.Callable):
2737
2768
                parent_pipe.send(('function', ))
2738
2769
            else:
2739
2770
                parent_pipe.send((
2750
2781
def rfc3339_duration_to_delta(duration):
2751
2782
    """Parse an RFC 3339 "duration" and return a datetime.timedelta
2752
2783
 
2753
 
    >>> rfc3339_duration_to_delta("P7D")
2754
 
    datetime.timedelta(7)
2755
 
    >>> rfc3339_duration_to_delta("PT60S")
2756
 
    datetime.timedelta(0, 60)
2757
 
    >>> rfc3339_duration_to_delta("PT60M")
2758
 
    datetime.timedelta(0, 3600)
2759
 
    >>> rfc3339_duration_to_delta("PT24H")
2760
 
    datetime.timedelta(1)
2761
 
    >>> rfc3339_duration_to_delta("P1W")
2762
 
    datetime.timedelta(7)
2763
 
    >>> rfc3339_duration_to_delta("PT5M30S")
2764
 
    datetime.timedelta(0, 330)
2765
 
    >>> rfc3339_duration_to_delta("P1DT3M20S")
2766
 
    datetime.timedelta(1, 200)
 
2784
    >>> rfc3339_duration_to_delta("P7D") == datetime.timedelta(7)
 
2785
    True
 
2786
    >>> rfc3339_duration_to_delta("PT60S") == datetime.timedelta(0, 60)
 
2787
    True
 
2788
    >>> rfc3339_duration_to_delta("PT60M") == datetime.timedelta(0, 3600)
 
2789
    True
 
2790
    >>> rfc3339_duration_to_delta("PT24H") == datetime.timedelta(1)
 
2791
    True
 
2792
    >>> rfc3339_duration_to_delta("P1W") == datetime.timedelta(7)
 
2793
    True
 
2794
    >>> rfc3339_duration_to_delta("PT5M30S") == datetime.timedelta(0, 330)
 
2795
    True
 
2796
    >>> rfc3339_duration_to_delta("P1DT3M20S") == datetime.timedelta(1, 200)
 
2797
    True
2767
2798
    """
2768
2799
 
2769
2800
    # Parsing an RFC 3339 duration with regular expressions is not
2849
2880
def string_to_delta(interval):
2850
2881
    """Parse a string and return a datetime.timedelta
2851
2882
 
2852
 
    >>> string_to_delta('7d')
2853
 
    datetime.timedelta(7)
2854
 
    >>> string_to_delta('60s')
2855
 
    datetime.timedelta(0, 60)
2856
 
    >>> string_to_delta('60m')
2857
 
    datetime.timedelta(0, 3600)
2858
 
    >>> string_to_delta('24h')
2859
 
    datetime.timedelta(1)
2860
 
    >>> string_to_delta('1w')
2861
 
    datetime.timedelta(7)
2862
 
    >>> string_to_delta('5m 30s')
2863
 
    datetime.timedelta(0, 330)
 
2883
    >>> string_to_delta('7d') == datetime.timedelta(7)
 
2884
    True
 
2885
    >>> string_to_delta('60s') == datetime.timedelta(0, 60)
 
2886
    True
 
2887
    >>> string_to_delta('60m') == datetime.timedelta(0, 3600)
 
2888
    True
 
2889
    >>> string_to_delta('24h') == datetime.timedelta(1)
 
2890
    True
 
2891
    >>> string_to_delta('1w') == datetime.timedelta(7)
 
2892
    True
 
2893
    >>> string_to_delta('5m 30s') == datetime.timedelta(0, 330)
 
2894
    True
2864
2895
    """
2865
2896
 
2866
2897
    try:
2968
2999
 
2969
3000
    options = parser.parse_args()
2970
3001
 
2971
 
    if options.check:
2972
 
        import doctest
2973
 
        fail_count, test_count = doctest.testmod()
2974
 
        sys.exit(os.EX_OK if fail_count == 0 else 1)
2975
 
 
2976
3002
    # Default values for config file for server-global settings
2977
3003
    if gnutls.has_rawpk:
2978
3004
        priority = ("SECURE128:!CTYPE-X.509:+CTYPE-RAWPK:!RSA"
2998
3024
    del priority
2999
3025
 
3000
3026
    # Parse config file for server-global settings
3001
 
    server_config = configparser.SafeConfigParser(server_defaults)
 
3027
    server_config = configparser.ConfigParser(server_defaults)
3002
3028
    del server_defaults
3003
3029
    server_config.read(os.path.join(options.configdir, "mandos.conf"))
3004
 
    # Convert the SafeConfigParser object to a dict
 
3030
    # Convert the ConfigParser object to a dict
3005
3031
    server_settings = server_config.defaults()
3006
3032
    # Use the appropriate methods on the non-string config options
3007
3033
    for option in ("debug", "use_dbus", "use_ipv6", "restore",
3079
3105
                                  server_settings["servicename"])))
3080
3106
 
3081
3107
    # Parse config file with clients
3082
 
    client_config = configparser.SafeConfigParser(Client
3083
 
                                                  .client_defaults)
 
3108
    client_config = configparser.ConfigParser(Client.client_defaults)
3084
3109
    client_config.read(os.path.join(server_settings["configdir"],
3085
3110
                                    "clients.conf"))
3086
3111
 
3157
3182
        # Close all input and output, do double fork, etc.
3158
3183
        daemon()
3159
3184
 
3160
 
    # multiprocessing will use threads, so before we use GLib we need
3161
 
    # to inform GLib that threads will be used.
3162
 
    GLib.threads_init()
 
3185
    if gi.version_info < (3, 10, 2):
 
3186
        # multiprocessing will use threads, so before we use GLib we
 
3187
        # need to inform GLib that threads will be used.
 
3188
        GLib.threads_init()
3163
3189
 
3164
3190
    global main_loop
3165
3191
    # From the Avahi example code
3241
3267
                             if isinstance(s, bytes)
3242
3268
                             else s) for s in
3243
3269
                            value["client_structure"]]
3244
 
                        # .name & .host
3245
 
                        for k in ("name", "host"):
 
3270
                        # .name, .host, and .checker_command
 
3271
                        for k in ("name", "host", "checker_command"):
3246
3272
                            if isinstance(value[k], bytes):
3247
3273
                                value[k] = value[k].decode("utf-8")
3248
3274
                        if "key_id" not in value:
3258
3284
                        for key, value in
3259
3285
                        bytes_old_client_settings.items()}
3260
3286
                    del bytes_old_client_settings
3261
 
                    # .host
 
3287
                    # .host and .checker_command
3262
3288
                    for value in old_client_settings.values():
3263
 
                        if isinstance(value["host"], bytes):
3264
 
                            value["host"] = (value["host"]
3265
 
                                             .decode("utf-8"))
 
3289
                        for attribute in ("host", "checker_command"):
 
3290
                            if isinstance(value[attribute], bytes):
 
3291
                                value[attribute] = (value[attribute]
 
3292
                                                    .decode("utf-8"))
3266
3293
            os.remove(stored_state_path)
3267
3294
        except IOError as e:
3268
3295
            if e.errno == errno.ENOENT:
3593
3620
                sys.exit(1)
3594
3621
            # End of Avahi example code
3595
3622
 
3596
 
        GLib.io_add_watch(tcp_server.fileno(), GLib.IO_IN,
3597
 
                          lambda *args, **kwargs:
3598
 
                          (tcp_server.handle_request
3599
 
                           (*args[2:], **kwargs) or True))
 
3623
        GLib.io_add_watch(
 
3624
            GLib.IOChannel.unix_new(tcp_server.fileno()),
 
3625
            GLib.PRIORITY_DEFAULT, GLib.IO_IN,
 
3626
            lambda *args, **kwargs: (tcp_server.handle_request
 
3627
                                     (*args[2:], **kwargs) or True))
3600
3628
 
3601
3629
        logger.debug("Starting main loop")
3602
3630
        main_loop.run()
3612
3640
    # Must run before the D-Bus bus name gets deregistered
3613
3641
    cleanup()
3614
3642
 
 
3643
 
 
3644
def should_only_run_tests():
 
3645
    parser = argparse.ArgumentParser(add_help=False)
 
3646
    parser.add_argument("--check", action='store_true')
 
3647
    args, unknown_args = parser.parse_known_args()
 
3648
    run_tests = args.check
 
3649
    if run_tests:
 
3650
        # Remove --check argument from sys.argv
 
3651
        sys.argv[1:] = unknown_args
 
3652
    return run_tests
 
3653
 
 
3654
# Add all tests from doctest strings
 
3655
def load_tests(loader, tests, none):
 
3656
    import doctest
 
3657
    tests.addTests(doctest.DocTestSuite())
 
3658
    return tests
3615
3659
 
3616
3660
if __name__ == '__main__':
3617
 
    main()
 
3661
    try:
 
3662
        if should_only_run_tests():
 
3663
            # Call using ./mandos --check [--verbose]
 
3664
            unittest.main()
 
3665
        else:
 
3666
            main()
 
3667
    finally:
 
3668
        logging.shutdown()