/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-18 00:42:22 UTC
  • Revision ID: teddy@recompile.se-20190818004222-lfrgtnmqz766a08e
Client: Use the systemd sysusers.d mechanism, if present

* Makefile (install-client-nokey): Also install sysusers.d file, if
                                   $(SYSUSERS) exists.
* sysusers.d-mandos.conf: Adjust comment to match reality.

Show diffs side-by-side

added added

removed removed

Lines of Context:
mandos
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 -*-
 
1
#!/usr/bin/python
 
2
# -*- mode: python; 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
82
80
 
83
81
import dbus
84
82
import dbus.service
92
90
 
93
91
if sys.version_info.major == 2:
94
92
    __metaclass__ = type
95
 
    str = unicode
96
 
 
97
 
# Show warnings by default
98
 
if not sys.warnoptions:
99
 
    import warnings
100
 
    warnings.simplefilter("default")
101
93
 
102
94
# Try to find the value of SO_BINDTODEVICE:
103
95
try:
124
116
            # No value found
125
117
            SO_BINDTODEVICE = None
126
118
 
 
119
if sys.version_info.major == 2:
 
120
    str = unicode
 
121
 
127
122
if sys.version_info < (3, 2):
128
123
    configparser.Configparser = configparser.SafeConfigParser
129
124
 
130
 
version = "1.8.9"
 
125
version = "1.8.7"
131
126
stored_state_file = "clients.pickle"
132
127
 
133
128
logger = logging.getLogger()
134
 
logging.captureWarnings(True)   # Show warnings via the logging system
135
129
syslogger = None
136
130
 
137
131
try:
202
196
            output = subprocess.check_output(["gpgconf"])
203
197
            for line in output.splitlines():
204
198
                name, text, path = line.split(b":")
205
 
                if name == b"gpg":
 
199
                if name == "gpg":
206
200
                    self.gpg = path
207
201
                    break
208
202
        except OSError as e:
213
207
                          '--force-mdc',
214
208
                          '--quiet']
215
209
        # Only GPG version 1 has the --no-use-agent option.
216
 
        if self.gpg == b"gpg" or self.gpg.endswith(b"/gpg"):
 
210
        if self.gpg == "gpg" or self.gpg.endswith("/gpg"):
217
211
            self.gnupgargs.append("--no-use-agent")
218
212
 
219
213
    def __enter__(self):
1036
1030
        if self.checker_initiator_tag is not None:
1037
1031
            GLib.source_remove(self.checker_initiator_tag)
1038
1032
        self.checker_initiator_tag = GLib.timeout_add(
1039
 
            random.randrange(int(self.interval.total_seconds() * 1000
1040
 
                                 + 1)),
 
1033
            int(self.interval.total_seconds() * 1000),
1041
1034
            self.start_checker)
1042
1035
        # Schedule a disable() when 'timeout' has passed
1043
1036
        if self.disable_initiator_tag is not None:
1053
1046
        # Read return code from connection (see call_pipe)
1054
1047
        returncode = connection.recv()
1055
1048
        connection.close()
1056
 
        if self.checker is not None:
1057
 
            self.checker.join()
 
1049
        self.checker.join()
1058
1050
        self.checker_callback_tag = None
1059
1051
        self.checker = None
1060
1052
 
1151
1143
                kwargs=popen_args)
1152
1144
            self.checker.start()
1153
1145
            self.checker_callback_tag = GLib.io_add_watch(
1154
 
                GLib.IOChannel.unix_new(pipe[0].fileno()),
1155
 
                GLib.PRIORITY_DEFAULT, GLib.IO_IN,
 
1146
                pipe[0].fileno(), GLib.IO_IN,
1156
1147
                self.checker_callback, pipe[0], command)
1157
1148
        # Re-run this periodically if run by GLib.timeout_add
1158
1149
        return True
1413
1404
                raise ValueError("Byte arrays not supported for non-"
1414
1405
                                 "'ay' signature {!r}"
1415
1406
                                 .format(prop._dbus_signature))
1416
 
            value = dbus.ByteArray(bytes(value))
 
1407
            value = dbus.ByteArray(b''.join(chr(byte)
 
1408
                                            for byte in value))
1417
1409
        prop(value)
1418
1410
 
1419
1411
    @dbus.service.method(dbus.PROPERTIES_IFACE,
2681
2673
    def add_pipe(self, parent_pipe, proc):
2682
2674
        # Call "handle_ipc" for both data and EOF events
2683
2675
        GLib.io_add_watch(
2684
 
            GLib.IOChannel.unix_new(parent_pipe.fileno()),
2685
 
            GLib.PRIORITY_DEFAULT, GLib.IO_IN | GLib.IO_HUP,
 
2676
            parent_pipe.fileno(),
 
2677
            GLib.IO_IN | GLib.IO_HUP,
2686
2678
            functools.partial(self.handle_ipc,
2687
2679
                              parent_pipe=parent_pipe,
2688
2680
                              proc=proc))
2726
2718
                return False
2727
2719
 
2728
2720
            GLib.io_add_watch(
2729
 
                GLib.IOChannel.unix_new(parent_pipe.fileno()),
2730
 
                GLib.PRIORITY_DEFAULT, GLib.IO_IN | GLib.IO_HUP,
 
2721
                parent_pipe.fileno(),
 
2722
                GLib.IO_IN | GLib.IO_HUP,
2731
2723
                functools.partial(self.handle_ipc,
2732
2724
                                  parent_pipe=parent_pipe,
2733
2725
                                  proc=proc,
2765
2757
def rfc3339_duration_to_delta(duration):
2766
2758
    """Parse an RFC 3339 "duration" and return a datetime.timedelta
2767
2759
 
2768
 
    >>> rfc3339_duration_to_delta("P7D") == datetime.timedelta(7)
2769
 
    True
2770
 
    >>> rfc3339_duration_to_delta("PT60S") == datetime.timedelta(0, 60)
2771
 
    True
2772
 
    >>> rfc3339_duration_to_delta("PT60M") == datetime.timedelta(0, 3600)
2773
 
    True
2774
 
    >>> rfc3339_duration_to_delta("PT24H") == datetime.timedelta(1)
2775
 
    True
2776
 
    >>> rfc3339_duration_to_delta("P1W") == datetime.timedelta(7)
2777
 
    True
2778
 
    >>> rfc3339_duration_to_delta("PT5M30S") == datetime.timedelta(0, 330)
2779
 
    True
2780
 
    >>> rfc3339_duration_to_delta("P1DT3M20S") == datetime.timedelta(1, 200)
2781
 
    True
 
2760
    >>> rfc3339_duration_to_delta("P7D")
 
2761
    datetime.timedelta(7)
 
2762
    >>> rfc3339_duration_to_delta("PT60S")
 
2763
    datetime.timedelta(0, 60)
 
2764
    >>> rfc3339_duration_to_delta("PT60M")
 
2765
    datetime.timedelta(0, 3600)
 
2766
    >>> rfc3339_duration_to_delta("PT24H")
 
2767
    datetime.timedelta(1)
 
2768
    >>> rfc3339_duration_to_delta("P1W")
 
2769
    datetime.timedelta(7)
 
2770
    >>> rfc3339_duration_to_delta("PT5M30S")
 
2771
    datetime.timedelta(0, 330)
 
2772
    >>> rfc3339_duration_to_delta("P1DT3M20S")
 
2773
    datetime.timedelta(1, 200)
2782
2774
    """
2783
2775
 
2784
2776
    # Parsing an RFC 3339 duration with regular expressions is not
2864
2856
def string_to_delta(interval):
2865
2857
    """Parse a string and return a datetime.timedelta
2866
2858
 
2867
 
    >>> string_to_delta('7d') == datetime.timedelta(7)
2868
 
    True
2869
 
    >>> string_to_delta('60s') == datetime.timedelta(0, 60)
2870
 
    True
2871
 
    >>> string_to_delta('60m') == datetime.timedelta(0, 3600)
2872
 
    True
2873
 
    >>> string_to_delta('24h') == datetime.timedelta(1)
2874
 
    True
2875
 
    >>> string_to_delta('1w') == datetime.timedelta(7)
2876
 
    True
2877
 
    >>> string_to_delta('5m 30s') == datetime.timedelta(0, 330)
2878
 
    True
 
2859
    >>> string_to_delta('7d')
 
2860
    datetime.timedelta(7)
 
2861
    >>> string_to_delta('60s')
 
2862
    datetime.timedelta(0, 60)
 
2863
    >>> string_to_delta('60m')
 
2864
    datetime.timedelta(0, 3600)
 
2865
    >>> string_to_delta('24h')
 
2866
    datetime.timedelta(1)
 
2867
    >>> string_to_delta('1w')
 
2868
    datetime.timedelta(7)
 
2869
    >>> string_to_delta('5m 30s')
 
2870
    datetime.timedelta(0, 330)
2879
2871
    """
2880
2872
 
2881
2873
    try:
2983
2975
 
2984
2976
    options = parser.parse_args()
2985
2977
 
 
2978
    if options.check:
 
2979
        import doctest
 
2980
        fail_count, test_count = doctest.testmod()
 
2981
        sys.exit(os.EX_OK if fail_count == 0 else 1)
 
2982
 
2986
2983
    # Default values for config file for server-global settings
2987
2984
    if gnutls.has_rawpk:
2988
2985
        priority = ("SECURE128:!CTYPE-X.509:+CTYPE-RAWPK:!RSA"
3251
3248
                             if isinstance(s, bytes)
3252
3249
                             else s) for s in
3253
3250
                            value["client_structure"]]
3254
 
                        # .name, .host, and .checker_command
3255
 
                        for k in ("name", "host", "checker_command"):
 
3251
                        # .name & .host
 
3252
                        for k in ("name", "host"):
3256
3253
                            if isinstance(value[k], bytes):
3257
3254
                                value[k] = value[k].decode("utf-8")
3258
3255
                        if "key_id" not in value:
3268
3265
                        for key, value in
3269
3266
                        bytes_old_client_settings.items()}
3270
3267
                    del bytes_old_client_settings
3271
 
                    # .host and .checker_command
 
3268
                    # .host
3272
3269
                    for value in old_client_settings.values():
3273
 
                        for attribute in ("host", "checker_command"):
3274
 
                            if isinstance(value[attribute], bytes):
3275
 
                                value[attribute] = (value[attribute]
3276
 
                                                    .decode("utf-8"))
 
3270
                        if isinstance(value["host"], bytes):
 
3271
                            value["host"] = (value["host"]
 
3272
                                             .decode("utf-8"))
3277
3273
            os.remove(stored_state_path)
3278
3274
        except IOError as e:
3279
3275
            if e.errno == errno.ENOENT:
3604
3600
                sys.exit(1)
3605
3601
            # End of Avahi example code
3606
3602
 
3607
 
        GLib.io_add_watch(
3608
 
            GLib.IOChannel.unix_new(tcp_server.fileno()),
3609
 
            GLib.PRIORITY_DEFAULT, GLib.IO_IN,
3610
 
            lambda *args, **kwargs: (tcp_server.handle_request
3611
 
                                     (*args[2:], **kwargs) or True))
 
3603
        GLib.io_add_watch(tcp_server.fileno(), GLib.IO_IN,
 
3604
                          lambda *args, **kwargs:
 
3605
                          (tcp_server.handle_request
 
3606
                           (*args[2:], **kwargs) or True))
3612
3607
 
3613
3608
        logger.debug("Starting main loop")
3614
3609
        main_loop.run()
3624
3619
    # Must run before the D-Bus bus name gets deregistered
3625
3620
    cleanup()
3626
3621
 
3627
 
 
3628
 
def should_only_run_tests():
3629
 
    parser = argparse.ArgumentParser(add_help=False)
3630
 
    parser.add_argument("--check", action='store_true')
3631
 
    args, unknown_args = parser.parse_known_args()
3632
 
    run_tests = args.check
3633
 
    if run_tests:
3634
 
        # Remove --check argument from sys.argv
3635
 
        sys.argv[1:] = unknown_args
3636
 
    return run_tests
3637
 
 
3638
 
# Add all tests from doctest strings
3639
 
def load_tests(loader, tests, none):
3640
 
    import doctest
3641
 
    tests.addTests(doctest.DocTestSuite())
3642
 
    return tests
3643
3622
 
3644
3623
if __name__ == '__main__':
3645
 
    try:
3646
 
        if should_only_run_tests():
3647
 
            # Call using ./mandos --check [--verbose]
3648
 
            unittest.main()
3649
 
        else:
3650
 
            main()
3651
 
    finally:
3652
 
        logging.shutdown()
 
3624
    main()