/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-02-09 03:38:33 UTC
  • Revision ID: teddy@recompile.se-20200209033833-2la1pujrnv2m0so4
Use reallocarray() if available, or check for overflow

* dracut-module/password-agent.c (add_to_queue): Check for overflow.
  (test_add_to_queue_overflow): New test.
* plugin-runner.c (add_to_char_array, main): Use reallocarray().
* plugins.d/plymouth.c (exec_and_wait): - '' -

Show diffs side-by-side

added added

removed removed

Lines of Context:
mandos
1
 
#!/usr/bin/python
 
1
#!/usr/bin/python3 -bI
2
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.
78
78
import collections
79
79
import codecs
80
80
import unittest
 
81
import random
 
82
import shlex
81
83
 
82
84
import dbus
83
85
import dbus.service
91
93
 
92
94
if sys.version_info.major == 2:
93
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
94
112
 
95
113
# Show warnings by default
96
114
if not sys.warnoptions:
122
140
            # No value found
123
141
            SO_BINDTODEVICE = None
124
142
 
125
 
if sys.version_info.major == 2:
126
 
    str = unicode
127
 
 
128
143
if sys.version_info < (3, 2):
129
144
    configparser.Configparser = configparser.SafeConfigParser
130
145
 
131
 
version = "1.8.8"
 
146
version = "1.8.9"
132
147
stored_state_file = "clients.pickle"
133
148
 
134
149
logger = logging.getLogger()
203
218
            output = subprocess.check_output(["gpgconf"])
204
219
            for line in output.splitlines():
205
220
                name, text, path = line.split(b":")
206
 
                if name == "gpg":
 
221
                if name == b"gpg":
207
222
                    self.gpg = path
208
223
                    break
209
224
        except OSError as e:
214
229
                          '--force-mdc',
215
230
                          '--quiet']
216
231
        # Only GPG version 1 has the --no-use-agent option.
217
 
        if self.gpg == "gpg" or self.gpg.endswith("/gpg"):
 
232
        if self.gpg == b"gpg" or self.gpg.endswith(b"/gpg"):
218
233
            self.gnupgargs.append("--no-use-agent")
219
234
 
220
235
    def __enter__(self):
1037
1052
        if self.checker_initiator_tag is not None:
1038
1053
            GLib.source_remove(self.checker_initiator_tag)
1039
1054
        self.checker_initiator_tag = GLib.timeout_add(
1040
 
            int(self.interval.total_seconds() * 1000),
 
1055
            random.randrange(int(self.interval.total_seconds() * 1000
 
1056
                                 + 1)),
1041
1057
            self.start_checker)
1042
1058
        # Schedule a disable() when 'timeout' has passed
1043
1059
        if self.disable_initiator_tag is not None:
1053
1069
        # Read return code from connection (see call_pipe)
1054
1070
        returncode = connection.recv()
1055
1071
        connection.close()
1056
 
        self.checker.join()
 
1072
        if self.checker is not None:
 
1073
            self.checker.join()
1057
1074
        self.checker_callback_tag = None
1058
1075
        self.checker = None
1059
1076
 
1117
1134
        if self.checker is None:
1118
1135
            # Escape attributes for the shell
1119
1136
            escaped_attrs = {
1120
 
                attr: re.escape(str(getattr(self, attr)))
 
1137
                attr: shlex.quote(str(getattr(self, attr)))
1121
1138
                for attr in self.runtime_expansions}
1122
1139
            try:
1123
1140
                command = self.checker_command % escaped_attrs
1412
1429
                raise ValueError("Byte arrays not supported for non-"
1413
1430
                                 "'ay' signature {!r}"
1414
1431
                                 .format(prop._dbus_signature))
1415
 
            value = dbus.ByteArray(b''.join(chr(byte)
1416
 
                                            for byte in value))
 
1432
            value = dbus.ByteArray(bytes(value))
1417
1433
        prop(value)
1418
1434
 
1419
1435
    @dbus.service.method(dbus.PROPERTIES_IFACE,
2748
2764
        if command == 'getattr':
2749
2765
            attrname = request[1]
2750
2766
            if isinstance(client_object.__getattribute__(attrname),
2751
 
                          collections.Callable):
 
2767
                          collections.abc.Callable):
2752
2768
                parent_pipe.send(('function', ))
2753
2769
            else:
2754
2770
                parent_pipe.send((
2765
2781
def rfc3339_duration_to_delta(duration):
2766
2782
    """Parse an RFC 3339 "duration" and return a datetime.timedelta
2767
2783
 
2768
 
    >>> rfc3339_duration_to_delta("P7D")
2769
 
    datetime.timedelta(7)
2770
 
    >>> rfc3339_duration_to_delta("PT60S")
2771
 
    datetime.timedelta(0, 60)
2772
 
    >>> rfc3339_duration_to_delta("PT60M")
2773
 
    datetime.timedelta(0, 3600)
2774
 
    >>> rfc3339_duration_to_delta("PT24H")
2775
 
    datetime.timedelta(1)
2776
 
    >>> rfc3339_duration_to_delta("P1W")
2777
 
    datetime.timedelta(7)
2778
 
    >>> rfc3339_duration_to_delta("PT5M30S")
2779
 
    datetime.timedelta(0, 330)
2780
 
    >>> rfc3339_duration_to_delta("P1DT3M20S")
2781
 
    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
2782
2798
    """
2783
2799
 
2784
2800
    # Parsing an RFC 3339 duration with regular expressions is not
2864
2880
def string_to_delta(interval):
2865
2881
    """Parse a string and return a datetime.timedelta
2866
2882
 
2867
 
    >>> string_to_delta('7d')
2868
 
    datetime.timedelta(7)
2869
 
    >>> string_to_delta('60s')
2870
 
    datetime.timedelta(0, 60)
2871
 
    >>> string_to_delta('60m')
2872
 
    datetime.timedelta(0, 3600)
2873
 
    >>> string_to_delta('24h')
2874
 
    datetime.timedelta(1)
2875
 
    >>> string_to_delta('1w')
2876
 
    datetime.timedelta(7)
2877
 
    >>> string_to_delta('5m 30s')
2878
 
    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
2879
2895
    """
2880
2896
 
2881
2897
    try:
3251
3267
                             if isinstance(s, bytes)
3252
3268
                             else s) for s in
3253
3269
                            value["client_structure"]]
3254
 
                        # .name & .host
3255
 
                        for k in ("name", "host"):
 
3270
                        # .name, .host, and .checker_command
 
3271
                        for k in ("name", "host", "checker_command"):
3256
3272
                            if isinstance(value[k], bytes):
3257
3273
                                value[k] = value[k].decode("utf-8")
3258
3274
                        if "key_id" not in value:
3268
3284
                        for key, value in
3269
3285
                        bytes_old_client_settings.items()}
3270
3286
                    del bytes_old_client_settings
3271
 
                    # .host
 
3287
                    # .host and .checker_command
3272
3288
                    for value in old_client_settings.values():
3273
 
                        if isinstance(value["host"], bytes):
3274
 
                            value["host"] = (value["host"]
3275
 
                                             .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"))
3276
3293
            os.remove(stored_state_path)
3277
3294
        except IOError as e:
3278
3295
            if e.errno == errno.ENOENT: