/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 at recompile
  • Date: 2020-02-07 20:53:34 UTC
  • mto: This revision was merged to the branch mainline in revision 396.
  • Revision ID: teddy@recompile.se-20200207205334-dp41p8c8vw0ytik5
Allow users to more easily alter mandos.service

The sysvinit script uses /etc/default/mandos as an environment file,
and supports adding additional server options to a DAEMON_ARGS
environment variable.  This should be supported by the systemd
service, too.

* mandos.service ([Service]/EnvironmentFile): New; set to
  "/etc/default/mandos ".
  ([Service]/ExecStart): Append "$DAEMON_ARGS".

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
#
77
77
import itertools
78
78
import collections
79
79
import codecs
 
80
import unittest
 
81
import random
80
82
 
81
83
import dbus
82
84
import dbus.service
88
90
import xml.dom.minidom
89
91
import inspect
90
92
 
 
93
if sys.version_info.major == 2:
 
94
    __metaclass__ = type
 
95
    str = unicode
 
96
 
 
97
# Add collections.abc.Callable if it does not exist
 
98
try:
 
99
    collections.abc.Callable
 
100
except AttributeError:
 
101
    class abc:
 
102
        Callable = collections.Callable
 
103
    collections.abc = abc
 
104
    del abc
 
105
 
 
106
# Show warnings by default
 
107
if not sys.warnoptions:
 
108
    import warnings
 
109
    warnings.simplefilter("default")
 
110
 
91
111
# Try to find the value of SO_BINDTODEVICE:
92
112
try:
93
113
    # This is where SO_BINDTODEVICE is in Python 3.3 (or 3.4?) and
113
133
            # No value found
114
134
            SO_BINDTODEVICE = None
115
135
 
116
 
if sys.version_info.major == 2:
117
 
    str = unicode
118
 
 
119
136
if sys.version_info < (3, 2):
120
137
    configparser.Configparser = configparser.SafeConfigParser
121
138
 
122
 
version = "1.8.5"
 
139
version = "1.8.9"
123
140
stored_state_file = "clients.pickle"
124
141
 
125
142
logger = logging.getLogger()
 
143
logging.captureWarnings(True)   # Show warnings via the logging system
126
144
syslogger = None
127
145
 
128
146
try:
183
201
    pass
184
202
 
185
203
 
186
 
class PGPEngine(object):
 
204
class PGPEngine:
187
205
    """A simple class for OpenPGP symmetric encryption & decryption"""
188
206
 
189
207
    def __init__(self):
193
211
            output = subprocess.check_output(["gpgconf"])
194
212
            for line in output.splitlines():
195
213
                name, text, path = line.split(b":")
196
 
                if name == "gpg":
 
214
                if name == b"gpg":
197
215
                    self.gpg = path
198
216
                    break
199
217
        except OSError as e:
204
222
                          '--force-mdc',
205
223
                          '--quiet']
206
224
        # Only GPG version 1 has the --no-use-agent option.
207
 
        if self.gpg == "gpg" or self.gpg.endswith("/gpg"):
 
225
        if self.gpg == b"gpg" or self.gpg.endswith(b"/gpg"):
208
226
            self.gnupgargs.append("--no-use-agent")
209
227
 
210
228
    def __enter__(self):
279
297
 
280
298
 
281
299
# Pretend that we have an Avahi module
282
 
class avahi(object):
 
300
class avahi:
283
301
    """This isn't so much a class as it is a module-like namespace."""
284
302
    IF_UNSPEC = -1               # avahi-common/address.h
285
303
    PROTO_UNSPEC = -1            # avahi-common/address.h
319
337
    pass
320
338
 
321
339
 
322
 
class AvahiService(object):
 
340
class AvahiService:
323
341
    """An Avahi (Zeroconf) service.
324
342
 
325
343
    Attributes:
507
525
 
508
526
 
509
527
# Pretend that we have a GnuTLS module
510
 
class gnutls(object):
 
528
class gnutls:
511
529
    """This isn't so much a class as it is a module-like namespace."""
512
530
 
513
531
    library = ctypes.util.find_library("gnutls")
576
594
        pass
577
595
 
578
596
    # Classes
579
 
    class Credentials(object):
 
597
    class Credentials:
580
598
        def __init__(self):
581
599
            self._c_object = gnutls.certificate_credentials_t()
582
600
            gnutls.certificate_allocate_credentials(
586
604
        def __del__(self):
587
605
            gnutls.certificate_free_credentials(self._c_object)
588
606
 
589
 
    class ClientSession(object):
 
607
    class ClientSession:
590
608
        def __init__(self, socket, credentials=None):
591
609
            self._c_object = gnutls.session_t()
592
610
            gnutls_flags = gnutls.CLIENT
818
836
    connection.close()
819
837
 
820
838
 
821
 
class Client(object):
 
839
class Client:
822
840
    """A representation of a client host served by this server.
823
841
 
824
842
    Attributes:
1027
1045
        if self.checker_initiator_tag is not None:
1028
1046
            GLib.source_remove(self.checker_initiator_tag)
1029
1047
        self.checker_initiator_tag = GLib.timeout_add(
1030
 
            int(self.interval.total_seconds() * 1000),
 
1048
            random.randrange(int(self.interval.total_seconds() * 1000
 
1049
                                 + 1)),
1031
1050
            self.start_checker)
1032
1051
        # Schedule a disable() when 'timeout' has passed
1033
1052
        if self.disable_initiator_tag is not None:
1043
1062
        # Read return code from connection (see call_pipe)
1044
1063
        returncode = connection.recv()
1045
1064
        connection.close()
1046
 
        self.checker.join()
 
1065
        if self.checker is not None:
 
1066
            self.checker.join()
1047
1067
        self.checker_callback_tag = None
1048
1068
        self.checker = None
1049
1069
 
1140
1160
                kwargs=popen_args)
1141
1161
            self.checker.start()
1142
1162
            self.checker_callback_tag = GLib.io_add_watch(
1143
 
                pipe[0].fileno(), GLib.IO_IN,
 
1163
                GLib.IOChannel.unix_new(pipe[0].fileno()),
 
1164
                GLib.PRIORITY_DEFAULT, GLib.IO_IN,
1144
1165
                self.checker_callback, pipe[0], command)
1145
1166
        # Re-run this periodically if run by GLib.timeout_add
1146
1167
        return True
1401
1422
                raise ValueError("Byte arrays not supported for non-"
1402
1423
                                 "'ay' signature {!r}"
1403
1424
                                 .format(prop._dbus_signature))
1404
 
            value = dbus.ByteArray(b''.join(chr(byte)
1405
 
                                            for byte in value))
 
1425
            value = dbus.ByteArray(bytes(value))
1406
1426
        prop(value)
1407
1427
 
1408
1428
    @dbus.service.method(dbus.PROPERTIES_IFACE,
2213
2233
    del _interface
2214
2234
 
2215
2235
 
2216
 
class ProxyClient(object):
 
2236
class ProxyClient:
2217
2237
    def __init__(self, child_pipe, key_id, fpr, address):
2218
2238
        self._pipe = child_pipe
2219
2239
        self._pipe.send(('init', key_id, fpr, address))
2492
2512
        return hex_fpr
2493
2513
 
2494
2514
 
2495
 
class MultiprocessingMixIn(object):
 
2515
class MultiprocessingMixIn:
2496
2516
    """Like socketserver.ThreadingMixIn, but with multiprocessing"""
2497
2517
 
2498
2518
    def sub_process_main(self, request, address):
2510
2530
        return proc
2511
2531
 
2512
2532
 
2513
 
class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):
 
2533
class MultiprocessingMixInWithPipe(MultiprocessingMixIn):
2514
2534
    """ adds a pipe to the MixIn """
2515
2535
 
2516
2536
    def process_request(self, request, client_address):
2531
2551
 
2532
2552
 
2533
2553
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
2534
 
                     socketserver.TCPServer, object):
 
2554
                     socketserver.TCPServer):
2535
2555
    """IPv6-capable TCP server.  Accepts 'None' as address and/or port
2536
2556
 
2537
2557
    Attributes:
2670
2690
    def add_pipe(self, parent_pipe, proc):
2671
2691
        # Call "handle_ipc" for both data and EOF events
2672
2692
        GLib.io_add_watch(
2673
 
            parent_pipe.fileno(),
2674
 
            GLib.IO_IN | GLib.IO_HUP,
 
2693
            GLib.IOChannel.unix_new(parent_pipe.fileno()),
 
2694
            GLib.PRIORITY_DEFAULT, GLib.IO_IN | GLib.IO_HUP,
2675
2695
            functools.partial(self.handle_ipc,
2676
2696
                              parent_pipe=parent_pipe,
2677
2697
                              proc=proc))
2715
2735
                return False
2716
2736
 
2717
2737
            GLib.io_add_watch(
2718
 
                parent_pipe.fileno(),
2719
 
                GLib.IO_IN | GLib.IO_HUP,
 
2738
                GLib.IOChannel.unix_new(parent_pipe.fileno()),
 
2739
                GLib.PRIORITY_DEFAULT, GLib.IO_IN | GLib.IO_HUP,
2720
2740
                functools.partial(self.handle_ipc,
2721
2741
                                  parent_pipe=parent_pipe,
2722
2742
                                  proc=proc,
2737
2757
        if command == 'getattr':
2738
2758
            attrname = request[1]
2739
2759
            if isinstance(client_object.__getattribute__(attrname),
2740
 
                          collections.Callable):
 
2760
                          collections.abc.Callable):
2741
2761
                parent_pipe.send(('function', ))
2742
2762
            else:
2743
2763
                parent_pipe.send((
2754
2774
def rfc3339_duration_to_delta(duration):
2755
2775
    """Parse an RFC 3339 "duration" and return a datetime.timedelta
2756
2776
 
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)
 
2777
    >>> rfc3339_duration_to_delta("P7D") == datetime.timedelta(7)
 
2778
    True
 
2779
    >>> rfc3339_duration_to_delta("PT60S") == datetime.timedelta(0, 60)
 
2780
    True
 
2781
    >>> rfc3339_duration_to_delta("PT60M") == datetime.timedelta(0, 3600)
 
2782
    True
 
2783
    >>> rfc3339_duration_to_delta("PT24H") == datetime.timedelta(1)
 
2784
    True
 
2785
    >>> rfc3339_duration_to_delta("P1W") == datetime.timedelta(7)
 
2786
    True
 
2787
    >>> rfc3339_duration_to_delta("PT5M30S") == datetime.timedelta(0, 330)
 
2788
    True
 
2789
    >>> rfc3339_duration_to_delta("P1DT3M20S") == datetime.timedelta(1, 200)
 
2790
    True
2771
2791
    """
2772
2792
 
2773
2793
    # Parsing an RFC 3339 duration with regular expressions is not
2853
2873
def string_to_delta(interval):
2854
2874
    """Parse a string and return a datetime.timedelta
2855
2875
 
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)
 
2876
    >>> string_to_delta('7d') == datetime.timedelta(7)
 
2877
    True
 
2878
    >>> string_to_delta('60s') == datetime.timedelta(0, 60)
 
2879
    True
 
2880
    >>> string_to_delta('60m') == datetime.timedelta(0, 3600)
 
2881
    True
 
2882
    >>> string_to_delta('24h') == datetime.timedelta(1)
 
2883
    True
 
2884
    >>> string_to_delta('1w') == datetime.timedelta(7)
 
2885
    True
 
2886
    >>> string_to_delta('5m 30s') == datetime.timedelta(0, 330)
 
2887
    True
2868
2888
    """
2869
2889
 
2870
2890
    try:
2972
2992
 
2973
2993
    options = parser.parse_args()
2974
2994
 
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
2995
    # Default values for config file for server-global settings
2981
2996
    if gnutls.has_rawpk:
2982
2997
        priority = ("SECURE128:!CTYPE-X.509:+CTYPE-RAWPK:!RSA"
3245
3260
                             if isinstance(s, bytes)
3246
3261
                             else s) for s in
3247
3262
                            value["client_structure"]]
3248
 
                        # .name & .host
3249
 
                        for k in ("name", "host"):
 
3263
                        # .name, .host, and .checker_command
 
3264
                        for k in ("name", "host", "checker_command"):
3250
3265
                            if isinstance(value[k], bytes):
3251
3266
                                value[k] = value[k].decode("utf-8")
3252
3267
                        if "key_id" not in value:
3262
3277
                        for key, value in
3263
3278
                        bytes_old_client_settings.items()}
3264
3279
                    del bytes_old_client_settings
3265
 
                    # .host
 
3280
                    # .host and .checker_command
3266
3281
                    for value in old_client_settings.values():
3267
 
                        if isinstance(value["host"], bytes):
3268
 
                            value["host"] = (value["host"]
3269
 
                                             .decode("utf-8"))
 
3282
                        for attribute in ("host", "checker_command"):
 
3283
                            if isinstance(value[attribute], bytes):
 
3284
                                value[attribute] = (value[attribute]
 
3285
                                                    .decode("utf-8"))
3270
3286
            os.remove(stored_state_path)
3271
3287
        except IOError as e:
3272
3288
            if e.errno == errno.ENOENT:
3597
3613
                sys.exit(1)
3598
3614
            # End of Avahi example code
3599
3615
 
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))
 
3616
        GLib.io_add_watch(
 
3617
            GLib.IOChannel.unix_new(tcp_server.fileno()),
 
3618
            GLib.PRIORITY_DEFAULT, GLib.IO_IN,
 
3619
            lambda *args, **kwargs: (tcp_server.handle_request
 
3620
                                     (*args[2:], **kwargs) or True))
3604
3621
 
3605
3622
        logger.debug("Starting main loop")
3606
3623
        main_loop.run()
3616
3633
    # Must run before the D-Bus bus name gets deregistered
3617
3634
    cleanup()
3618
3635
 
 
3636
 
 
3637
def should_only_run_tests():
 
3638
    parser = argparse.ArgumentParser(add_help=False)
 
3639
    parser.add_argument("--check", action='store_true')
 
3640
    args, unknown_args = parser.parse_known_args()
 
3641
    run_tests = args.check
 
3642
    if run_tests:
 
3643
        # Remove --check argument from sys.argv
 
3644
        sys.argv[1:] = unknown_args
 
3645
    return run_tests
 
3646
 
 
3647
# Add all tests from doctest strings
 
3648
def load_tests(loader, tests, none):
 
3649
    import doctest
 
3650
    tests.addTests(doctest.DocTestSuite())
 
3651
    return tests
3619
3652
 
3620
3653
if __name__ == '__main__':
3621
 
    main()
 
3654
    try:
 
3655
        if should_only_run_tests():
 
3656
            # Call using ./mandos --check [--verbose]
 
3657
            unittest.main()
 
3658
        else:
 
3659
            main()
 
3660
    finally:
 
3661
        logging.shutdown()