/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: 2019-09-04 21:12:32 UTC
  • mfrom: (237.7.726 trunk)
  • Revision ID: teddy@recompile.se-20190904211232-qwuiramck8i8wmhe
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 -b
 
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
88
89
import xml.dom.minidom
89
90
import inspect
90
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
 
91
100
# Try to find the value of SO_BINDTODEVICE:
92
101
try:
93
102
    # This is where SO_BINDTODEVICE is in Python 3.3 (or 3.4?) and
119
128
if sys.version_info < (3, 2):
120
129
    configparser.Configparser = configparser.SafeConfigParser
121
130
 
122
 
version = "1.8.7"
 
131
version = "1.8.9"
123
132
stored_state_file = "clients.pickle"
124
133
 
125
134
logger = logging.getLogger()
 
135
logging.captureWarnings(True)   # Show warnings via the logging system
126
136
syslogger = None
127
137
 
128
138
try:
183
193
    pass
184
194
 
185
195
 
186
 
class PGPEngine(object):
 
196
class PGPEngine:
187
197
    """A simple class for OpenPGP symmetric encryption & decryption"""
188
198
 
189
199
    def __init__(self):
193
203
            output = subprocess.check_output(["gpgconf"])
194
204
            for line in output.splitlines():
195
205
                name, text, path = line.split(b":")
196
 
                if name == "gpg":
 
206
                if name == b"gpg":
197
207
                    self.gpg = path
198
208
                    break
199
209
        except OSError as e:
204
214
                          '--force-mdc',
205
215
                          '--quiet']
206
216
        # Only GPG version 1 has the --no-use-agent option.
207
 
        if self.gpg == "gpg" or self.gpg.endswith("/gpg"):
 
217
        if self.gpg == b"gpg" or self.gpg.endswith(b"/gpg"):
208
218
            self.gnupgargs.append("--no-use-agent")
209
219
 
210
220
    def __enter__(self):
279
289
 
280
290
 
281
291
# Pretend that we have an Avahi module
282
 
class avahi(object):
 
292
class avahi:
283
293
    """This isn't so much a class as it is a module-like namespace."""
284
294
    IF_UNSPEC = -1               # avahi-common/address.h
285
295
    PROTO_UNSPEC = -1            # avahi-common/address.h
319
329
    pass
320
330
 
321
331
 
322
 
class AvahiService(object):
 
332
class AvahiService:
323
333
    """An Avahi (Zeroconf) service.
324
334
 
325
335
    Attributes:
507
517
 
508
518
 
509
519
# Pretend that we have a GnuTLS module
510
 
class gnutls(object):
 
520
class gnutls:
511
521
    """This isn't so much a class as it is a module-like namespace."""
512
522
 
513
523
    library = ctypes.util.find_library("gnutls")
576
586
        pass
577
587
 
578
588
    # Classes
579
 
    class Credentials(object):
 
589
    class Credentials:
580
590
        def __init__(self):
581
591
            self._c_object = gnutls.certificate_credentials_t()
582
592
            gnutls.certificate_allocate_credentials(
586
596
        def __del__(self):
587
597
            gnutls.certificate_free_credentials(self._c_object)
588
598
 
589
 
    class ClientSession(object):
 
599
    class ClientSession:
590
600
        def __init__(self, socket, credentials=None):
591
601
            self._c_object = gnutls.session_t()
592
602
            gnutls_flags = gnutls.CLIENT
818
828
    connection.close()
819
829
 
820
830
 
821
 
class Client(object):
 
831
class Client:
822
832
    """A representation of a client host served by this server.
823
833
 
824
834
    Attributes:
1043
1053
        # Read return code from connection (see call_pipe)
1044
1054
        returncode = connection.recv()
1045
1055
        connection.close()
1046
 
        self.checker.join()
 
1056
        if self.checker is not None:
 
1057
            self.checker.join()
1047
1058
        self.checker_callback_tag = None
1048
1059
        self.checker = None
1049
1060
 
1140
1151
                kwargs=popen_args)
1141
1152
            self.checker.start()
1142
1153
            self.checker_callback_tag = GLib.io_add_watch(
1143
 
                pipe[0].fileno(), GLib.IO_IN,
 
1154
                GLib.IOChannel.unix_new(pipe[0].fileno()),
 
1155
                GLib.PRIORITY_DEFAULT, GLib.IO_IN,
1144
1156
                self.checker_callback, pipe[0], command)
1145
1157
        # Re-run this periodically if run by GLib.timeout_add
1146
1158
        return True
2213
2225
    del _interface
2214
2226
 
2215
2227
 
2216
 
class ProxyClient(object):
 
2228
class ProxyClient:
2217
2229
    def __init__(self, child_pipe, key_id, fpr, address):
2218
2230
        self._pipe = child_pipe
2219
2231
        self._pipe.send(('init', key_id, fpr, address))
2492
2504
        return hex_fpr
2493
2505
 
2494
2506
 
2495
 
class MultiprocessingMixIn(object):
 
2507
class MultiprocessingMixIn:
2496
2508
    """Like socketserver.ThreadingMixIn, but with multiprocessing"""
2497
2509
 
2498
2510
    def sub_process_main(self, request, address):
2510
2522
        return proc
2511
2523
 
2512
2524
 
2513
 
class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):
 
2525
class MultiprocessingMixInWithPipe(MultiprocessingMixIn):
2514
2526
    """ adds a pipe to the MixIn """
2515
2527
 
2516
2528
    def process_request(self, request, client_address):
2531
2543
 
2532
2544
 
2533
2545
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
2534
 
                     socketserver.TCPServer, object):
 
2546
                     socketserver.TCPServer):
2535
2547
    """IPv6-capable TCP server.  Accepts 'None' as address and/or port
2536
2548
 
2537
2549
    Attributes:
2670
2682
    def add_pipe(self, parent_pipe, proc):
2671
2683
        # Call "handle_ipc" for both data and EOF events
2672
2684
        GLib.io_add_watch(
2673
 
            parent_pipe.fileno(),
2674
 
            GLib.IO_IN | GLib.IO_HUP,
 
2685
            GLib.IOChannel.unix_new(parent_pipe.fileno()),
 
2686
            GLib.PRIORITY_DEFAULT, GLib.IO_IN | GLib.IO_HUP,
2675
2687
            functools.partial(self.handle_ipc,
2676
2688
                              parent_pipe=parent_pipe,
2677
2689
                              proc=proc))
2715
2727
                return False
2716
2728
 
2717
2729
            GLib.io_add_watch(
2718
 
                parent_pipe.fileno(),
2719
 
                GLib.IO_IN | GLib.IO_HUP,
 
2730
                GLib.IOChannel.unix_new(parent_pipe.fileno()),
 
2731
                GLib.PRIORITY_DEFAULT, GLib.IO_IN | GLib.IO_HUP,
2720
2732
                functools.partial(self.handle_ipc,
2721
2733
                                  parent_pipe=parent_pipe,
2722
2734
                                  proc=proc,
2754
2766
def rfc3339_duration_to_delta(duration):
2755
2767
    """Parse an RFC 3339 "duration" and return a datetime.timedelta
2756
2768
 
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)
 
2769
    >>> rfc3339_duration_to_delta("P7D") == datetime.timedelta(7)
 
2770
    True
 
2771
    >>> rfc3339_duration_to_delta("PT60S") == datetime.timedelta(0, 60)
 
2772
    True
 
2773
    >>> rfc3339_duration_to_delta("PT60M") == datetime.timedelta(0, 3600)
 
2774
    True
 
2775
    >>> rfc3339_duration_to_delta("PT24H") == datetime.timedelta(1)
 
2776
    True
 
2777
    >>> rfc3339_duration_to_delta("P1W") == datetime.timedelta(7)
 
2778
    True
 
2779
    >>> rfc3339_duration_to_delta("PT5M30S") == datetime.timedelta(0, 330)
 
2780
    True
 
2781
    >>> rfc3339_duration_to_delta("P1DT3M20S") == datetime.timedelta(1, 200)
 
2782
    True
2771
2783
    """
2772
2784
 
2773
2785
    # Parsing an RFC 3339 duration with regular expressions is not
2853
2865
def string_to_delta(interval):
2854
2866
    """Parse a string and return a datetime.timedelta
2855
2867
 
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)
 
2868
    >>> string_to_delta('7d') == datetime.timedelta(7)
 
2869
    True
 
2870
    >>> string_to_delta('60s') == datetime.timedelta(0, 60)
 
2871
    True
 
2872
    >>> string_to_delta('60m') == datetime.timedelta(0, 3600)
 
2873
    True
 
2874
    >>> string_to_delta('24h') == datetime.timedelta(1)
 
2875
    True
 
2876
    >>> string_to_delta('1w') == datetime.timedelta(7)
 
2877
    True
 
2878
    >>> string_to_delta('5m 30s') == datetime.timedelta(0, 330)
 
2879
    True
2868
2880
    """
2869
2881
 
2870
2882
    try:
2972
2984
 
2973
2985
    options = parser.parse_args()
2974
2986
 
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
2987
    # Default values for config file for server-global settings
2981
2988
    if gnutls.has_rawpk:
2982
2989
        priority = ("SECURE128:!CTYPE-X.509:+CTYPE-RAWPK:!RSA"
3245
3252
                             if isinstance(s, bytes)
3246
3253
                             else s) for s in
3247
3254
                            value["client_structure"]]
3248
 
                        # .name & .host
3249
 
                        for k in ("name", "host"):
 
3255
                        # .name, .host, and .checker_command
 
3256
                        for k in ("name", "host", "checker_command"):
3250
3257
                            if isinstance(value[k], bytes):
3251
3258
                                value[k] = value[k].decode("utf-8")
3252
3259
                        if "key_id" not in value:
3262
3269
                        for key, value in
3263
3270
                        bytes_old_client_settings.items()}
3264
3271
                    del bytes_old_client_settings
3265
 
                    # .host
 
3272
                    # .host and .checker_command
3266
3273
                    for value in old_client_settings.values():
3267
 
                        if isinstance(value["host"], bytes):
3268
 
                            value["host"] = (value["host"]
3269
 
                                             .decode("utf-8"))
 
3274
                        for attribute in ("host", "checker_command"):
 
3275
                            if isinstance(value[attribute], bytes):
 
3276
                                value[attribute] = (value[attribute]
 
3277
                                                    .decode("utf-8"))
3270
3278
            os.remove(stored_state_path)
3271
3279
        except IOError as e:
3272
3280
            if e.errno == errno.ENOENT:
3597
3605
                sys.exit(1)
3598
3606
            # End of Avahi example code
3599
3607
 
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))
 
3608
        GLib.io_add_watch(
 
3609
            GLib.IOChannel.unix_new(tcp_server.fileno()),
 
3610
            GLib.PRIORITY_DEFAULT, GLib.IO_IN,
 
3611
            lambda *args, **kwargs: (tcp_server.handle_request
 
3612
                                     (*args[2:], **kwargs) or True))
3604
3613
 
3605
3614
        logger.debug("Starting main loop")
3606
3615
        main_loop.run()
3616
3625
    # Must run before the D-Bus bus name gets deregistered
3617
3626
    cleanup()
3618
3627
 
 
3628
 
 
3629
def should_only_run_tests():
 
3630
    parser = argparse.ArgumentParser(add_help=False)
 
3631
    parser.add_argument("--check", action='store_true')
 
3632
    args, unknown_args = parser.parse_known_args()
 
3633
    run_tests = args.check
 
3634
    if run_tests:
 
3635
        # Remove --check argument from sys.argv
 
3636
        sys.argv[1:] = unknown_args
 
3637
    return run_tests
 
3638
 
 
3639
# Add all tests from doctest strings
 
3640
def load_tests(loader, tests, none):
 
3641
    import doctest
 
3642
    tests.addTests(doctest.DocTestSuite())
 
3643
    return tests
3619
3644
 
3620
3645
if __name__ == '__main__':
3621
 
    main()
 
3646
    try:
 
3647
        if should_only_run_tests():
 
3648
            # Call using ./mandos --check [--verbose]
 
3649
            unittest.main()
 
3650
        else:
 
3651
            main()
 
3652
    finally:
 
3653
        logging.shutdown()