/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-05 21:39:28 UTC
  • Revision ID: teddy@recompile.se-20200205213928-vpvt0fwfg47ikv6f
Allow users to alter ask-password-mandos.service

If a user uses dracut with systemd and wishes to modify the options
passed to password-agent(8mandos) or mandos-client(8mandos), they
should be able to do so by simply creating a file
/etc/systemd/system/ask-password-mandos.service.d/override.conf,
containing, for instance:

[Service]
Environment=MANDOS_CLIENT_OPTIONS=--debug

Adding PASSWORD_AGENT_OPTIONS should also be possible (but should not
normally be needed).

* dracut-module/ask-password-mandos.service ([Service]/ExecStart): Add
  $PASSWORD_AGENT_OPTIONS before "--" and "$MANDOS_CLIENT_OPTIONS" to
  end of line.
* dracut-module/module-setup.sh (install): Install all files named
  /etc/systemd/system/ask-password-mandos.service.d/*.conf if any
  exists.  Also add --dh-params before $MANDOS_CLIENT_OPTIONS instead
  of at end of line.

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
 
85
import gi
83
86
from gi.repository import GLib
84
87
from dbus.mainloop.glib import DBusGMainLoop
85
88
import ctypes
87
90
import xml.dom.minidom
88
91
import inspect
89
92
 
 
93
if sys.version_info.major == 2:
 
94
    __metaclass__ = type
 
95
    str = unicode
 
96
 
 
97
# Show warnings by default
 
98
if not sys.warnoptions:
 
99
    import warnings
 
100
    warnings.simplefilter("default")
 
101
 
90
102
# Try to find the value of SO_BINDTODEVICE:
91
103
try:
92
104
    # This is where SO_BINDTODEVICE is in Python 3.3 (or 3.4?) and
112
124
            # No value found
113
125
            SO_BINDTODEVICE = None
114
126
 
115
 
if sys.version_info.major == 2:
116
 
    str = unicode
 
127
if sys.version_info < (3, 2):
 
128
    configparser.Configparser = configparser.SafeConfigParser
117
129
 
118
 
version = "1.8.4"
 
130
version = "1.8.9"
119
131
stored_state_file = "clients.pickle"
120
132
 
121
133
logger = logging.getLogger()
 
134
logging.captureWarnings(True)   # Show warnings via the logging system
122
135
syslogger = None
123
136
 
124
137
try:
179
192
    pass
180
193
 
181
194
 
182
 
class PGPEngine(object):
 
195
class PGPEngine:
183
196
    """A simple class for OpenPGP symmetric encryption & decryption"""
184
197
 
185
198
    def __init__(self):
189
202
            output = subprocess.check_output(["gpgconf"])
190
203
            for line in output.splitlines():
191
204
                name, text, path = line.split(b":")
192
 
                if name == "gpg":
 
205
                if name == b"gpg":
193
206
                    self.gpg = path
194
207
                    break
195
208
        except OSError as e:
200
213
                          '--force-mdc',
201
214
                          '--quiet']
202
215
        # Only GPG version 1 has the --no-use-agent option.
203
 
        if self.gpg == "gpg" or self.gpg.endswith("/gpg"):
 
216
        if self.gpg == b"gpg" or self.gpg.endswith(b"/gpg"):
204
217
            self.gnupgargs.append("--no-use-agent")
205
218
 
206
219
    def __enter__(self):
275
288
 
276
289
 
277
290
# Pretend that we have an Avahi module
278
 
class avahi(object):
 
291
class avahi:
279
292
    """This isn't so much a class as it is a module-like namespace."""
280
293
    IF_UNSPEC = -1               # avahi-common/address.h
281
294
    PROTO_UNSPEC = -1            # avahi-common/address.h
315
328
    pass
316
329
 
317
330
 
318
 
class AvahiService(object):
 
331
class AvahiService:
319
332
    """An Avahi (Zeroconf) service.
320
333
 
321
334
    Attributes:
503
516
 
504
517
 
505
518
# Pretend that we have a GnuTLS module
506
 
class gnutls(object):
 
519
class gnutls:
507
520
    """This isn't so much a class as it is a module-like namespace."""
508
521
 
509
522
    library = ctypes.util.find_library("gnutls")
572
585
        pass
573
586
 
574
587
    # Classes
575
 
    class Credentials(object):
 
588
    class Credentials:
576
589
        def __init__(self):
577
590
            self._c_object = gnutls.certificate_credentials_t()
578
591
            gnutls.certificate_allocate_credentials(
582
595
        def __del__(self):
583
596
            gnutls.certificate_free_credentials(self._c_object)
584
597
 
585
 
    class ClientSession(object):
 
598
    class ClientSession:
586
599
        def __init__(self, socket, credentials=None):
587
600
            self._c_object = gnutls.session_t()
588
601
            gnutls_flags = gnutls.CLIENT
589
 
            if gnutls.check_version("3.5.6"):
 
602
            if gnutls.check_version(b"3.5.6"):
590
603
                gnutls_flags |= gnutls.NO_TICKETS
591
604
            if gnutls.has_rawpk:
592
605
                gnutls_flags |= gnutls.ENABLE_RAWPK
794
807
                                                    ctypes.c_size_t)]
795
808
        openpgp_crt_get_fingerprint.restype = _error_code
796
809
 
797
 
    if check_version("3.6.4"):
 
810
    if check_version(b"3.6.4"):
798
811
        certificate_type_get2 = _library.gnutls_certificate_type_get2
799
812
        certificate_type_get2.argtypes = [session_t, ctypes.c_int]
800
813
        certificate_type_get2.restype = _error_code
814
827
    connection.close()
815
828
 
816
829
 
817
 
class Client(object):
 
830
class Client:
818
831
    """A representation of a client host served by this server.
819
832
 
820
833
    Attributes:
821
834
    approved:   bool(); 'None' if not yet approved/disapproved
822
835
    approval_delay: datetime.timedelta(); Time to wait for approval
823
836
    approval_duration: datetime.timedelta(); Duration of one approval
824
 
    checker:    subprocess.Popen(); a running checker process used
825
 
                                    to see if the client lives.
826
 
                                    'None' if no process is running.
 
837
    checker: multiprocessing.Process(); a running checker process used
 
838
             to see if the client lives. 'None' if no process is
 
839
             running.
827
840
    checker_callback_tag: a GLib event source tag, or None
828
841
    checker_command: string; External command which is run to check
829
842
                     if client lives.  %() expansions are done at
1023
1036
        if self.checker_initiator_tag is not None:
1024
1037
            GLib.source_remove(self.checker_initiator_tag)
1025
1038
        self.checker_initiator_tag = GLib.timeout_add(
1026
 
            int(self.interval.total_seconds() * 1000),
 
1039
            random.randrange(int(self.interval.total_seconds() * 1000
 
1040
                                 + 1)),
1027
1041
            self.start_checker)
1028
1042
        # Schedule a disable() when 'timeout' has passed
1029
1043
        if self.disable_initiator_tag is not None:
1036
1050
    def checker_callback(self, source, condition, connection,
1037
1051
                         command):
1038
1052
        """The checker has completed, so take appropriate actions."""
1039
 
        self.checker_callback_tag = None
1040
 
        self.checker = None
1041
1053
        # Read return code from connection (see call_pipe)
1042
1054
        returncode = connection.recv()
1043
1055
        connection.close()
 
1056
        if self.checker is not None:
 
1057
            self.checker.join()
 
1058
        self.checker_callback_tag = None
 
1059
        self.checker = None
1044
1060
 
1045
1061
        if returncode >= 0:
1046
1062
            self.last_checker_status = returncode
1135
1151
                kwargs=popen_args)
1136
1152
            self.checker.start()
1137
1153
            self.checker_callback_tag = GLib.io_add_watch(
1138
 
                pipe[0].fileno(), GLib.IO_IN,
 
1154
                GLib.IOChannel.unix_new(pipe[0].fileno()),
 
1155
                GLib.PRIORITY_DEFAULT, GLib.IO_IN,
1139
1156
                self.checker_callback, pipe[0], command)
1140
1157
        # Re-run this periodically if run by GLib.timeout_add
1141
1158
        return True
1396
1413
                raise ValueError("Byte arrays not supported for non-"
1397
1414
                                 "'ay' signature {!r}"
1398
1415
                                 .format(prop._dbus_signature))
1399
 
            value = dbus.ByteArray(b''.join(chr(byte)
1400
 
                                            for byte in value))
 
1416
            value = dbus.ByteArray(bytes(value))
1401
1417
        prop(value)
1402
1418
 
1403
1419
    @dbus.service.method(dbus.PROPERTIES_IFACE,
2208
2224
    del _interface
2209
2225
 
2210
2226
 
2211
 
class ProxyClient(object):
 
2227
class ProxyClient:
2212
2228
    def __init__(self, child_pipe, key_id, fpr, address):
2213
2229
        self._pipe = child_pipe
2214
2230
        self._pipe.send(('init', key_id, fpr, address))
2287
2303
            approval_required = False
2288
2304
            try:
2289
2305
                if gnutls.has_rawpk:
2290
 
                    fpr = ""
 
2306
                    fpr = b""
2291
2307
                    try:
2292
2308
                        key_id = self.key_id(
2293
2309
                            self.peer_certificate(session))
2297
2313
                    logger.debug("Key ID: %s", key_id)
2298
2314
 
2299
2315
                else:
2300
 
                    key_id = ""
 
2316
                    key_id = b""
2301
2317
                    try:
2302
2318
                        fpr = self.fingerprint(
2303
2319
                            self.peer_certificate(session))
2487
2503
        return hex_fpr
2488
2504
 
2489
2505
 
2490
 
class MultiprocessingMixIn(object):
 
2506
class MultiprocessingMixIn:
2491
2507
    """Like socketserver.ThreadingMixIn, but with multiprocessing"""
2492
2508
 
2493
2509
    def sub_process_main(self, request, address):
2505
2521
        return proc
2506
2522
 
2507
2523
 
2508
 
class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):
 
2524
class MultiprocessingMixInWithPipe(MultiprocessingMixIn):
2509
2525
    """ adds a pipe to the MixIn """
2510
2526
 
2511
2527
    def process_request(self, request, client_address):
2526
2542
 
2527
2543
 
2528
2544
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
2529
 
                     socketserver.TCPServer, object):
 
2545
                     socketserver.TCPServer):
2530
2546
    """IPv6-capable TCP server.  Accepts 'None' as address and/or port
2531
2547
 
2532
2548
    Attributes:
2605
2621
                    raise
2606
2622
        # Only bind(2) the socket if we really need to.
2607
2623
        if self.server_address[0] or self.server_address[1]:
 
2624
            if self.server_address[1]:
 
2625
                self.allow_reuse_address = True
2608
2626
            if not self.server_address[0]:
2609
2627
                if self.address_family == socket.AF_INET6:
2610
2628
                    any_address = "::"  # in6addr_any
2663
2681
    def add_pipe(self, parent_pipe, proc):
2664
2682
        # Call "handle_ipc" for both data and EOF events
2665
2683
        GLib.io_add_watch(
2666
 
            parent_pipe.fileno(),
2667
 
            GLib.IO_IN | GLib.IO_HUP,
 
2684
            GLib.IOChannel.unix_new(parent_pipe.fileno()),
 
2685
            GLib.PRIORITY_DEFAULT, GLib.IO_IN | GLib.IO_HUP,
2668
2686
            functools.partial(self.handle_ipc,
2669
2687
                              parent_pipe=parent_pipe,
2670
2688
                              proc=proc))
2708
2726
                return False
2709
2727
 
2710
2728
            GLib.io_add_watch(
2711
 
                parent_pipe.fileno(),
2712
 
                GLib.IO_IN | GLib.IO_HUP,
 
2729
                GLib.IOChannel.unix_new(parent_pipe.fileno()),
 
2730
                GLib.PRIORITY_DEFAULT, GLib.IO_IN | GLib.IO_HUP,
2713
2731
                functools.partial(self.handle_ipc,
2714
2732
                                  parent_pipe=parent_pipe,
2715
2733
                                  proc=proc,
2747
2765
def rfc3339_duration_to_delta(duration):
2748
2766
    """Parse an RFC 3339 "duration" and return a datetime.timedelta
2749
2767
 
2750
 
    >>> rfc3339_duration_to_delta("P7D")
2751
 
    datetime.timedelta(7)
2752
 
    >>> rfc3339_duration_to_delta("PT60S")
2753
 
    datetime.timedelta(0, 60)
2754
 
    >>> rfc3339_duration_to_delta("PT60M")
2755
 
    datetime.timedelta(0, 3600)
2756
 
    >>> rfc3339_duration_to_delta("PT24H")
2757
 
    datetime.timedelta(1)
2758
 
    >>> rfc3339_duration_to_delta("P1W")
2759
 
    datetime.timedelta(7)
2760
 
    >>> rfc3339_duration_to_delta("PT5M30S")
2761
 
    datetime.timedelta(0, 330)
2762
 
    >>> rfc3339_duration_to_delta("P1DT3M20S")
2763
 
    datetime.timedelta(1, 200)
 
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
2764
2782
    """
2765
2783
 
2766
2784
    # Parsing an RFC 3339 duration with regular expressions is not
2846
2864
def string_to_delta(interval):
2847
2865
    """Parse a string and return a datetime.timedelta
2848
2866
 
2849
 
    >>> string_to_delta('7d')
2850
 
    datetime.timedelta(7)
2851
 
    >>> string_to_delta('60s')
2852
 
    datetime.timedelta(0, 60)
2853
 
    >>> string_to_delta('60m')
2854
 
    datetime.timedelta(0, 3600)
2855
 
    >>> string_to_delta('24h')
2856
 
    datetime.timedelta(1)
2857
 
    >>> string_to_delta('1w')
2858
 
    datetime.timedelta(7)
2859
 
    >>> string_to_delta('5m 30s')
2860
 
    datetime.timedelta(0, 330)
 
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
2861
2879
    """
2862
2880
 
2863
2881
    try:
2965
2983
 
2966
2984
    options = parser.parse_args()
2967
2985
 
2968
 
    if options.check:
2969
 
        import doctest
2970
 
        fail_count, test_count = doctest.testmod()
2971
 
        sys.exit(os.EX_OK if fail_count == 0 else 1)
2972
 
 
2973
2986
    # Default values for config file for server-global settings
2974
2987
    if gnutls.has_rawpk:
2975
2988
        priority = ("SECURE128:!CTYPE-X.509:+CTYPE-RAWPK:!RSA"
2995
3008
    del priority
2996
3009
 
2997
3010
    # Parse config file for server-global settings
2998
 
    server_config = configparser.SafeConfigParser(server_defaults)
 
3011
    server_config = configparser.ConfigParser(server_defaults)
2999
3012
    del server_defaults
3000
3013
    server_config.read(os.path.join(options.configdir, "mandos.conf"))
3001
 
    # Convert the SafeConfigParser object to a dict
 
3014
    # Convert the ConfigParser object to a dict
3002
3015
    server_settings = server_config.defaults()
3003
3016
    # Use the appropriate methods on the non-string config options
3004
3017
    for option in ("debug", "use_dbus", "use_ipv6", "restore",
3076
3089
                                  server_settings["servicename"])))
3077
3090
 
3078
3091
    # Parse config file with clients
3079
 
    client_config = configparser.SafeConfigParser(Client
3080
 
                                                  .client_defaults)
 
3092
    client_config = configparser.ConfigParser(Client.client_defaults)
3081
3093
    client_config.read(os.path.join(server_settings["configdir"],
3082
3094
                                    "clients.conf"))
3083
3095
 
3154
3166
        # Close all input and output, do double fork, etc.
3155
3167
        daemon()
3156
3168
 
3157
 
    # multiprocessing will use threads, so before we use GLib we need
3158
 
    # to inform GLib that threads will be used.
3159
 
    GLib.threads_init()
 
3169
    if gi.version_info < (3, 10, 2):
 
3170
        # multiprocessing will use threads, so before we use GLib we
 
3171
        # need to inform GLib that threads will be used.
 
3172
        GLib.threads_init()
3160
3173
 
3161
3174
    global main_loop
3162
3175
    # From the Avahi example code
3238
3251
                             if isinstance(s, bytes)
3239
3252
                             else s) for s in
3240
3253
                            value["client_structure"]]
3241
 
                        # .name & .host
3242
 
                        for k in ("name", "host"):
 
3254
                        # .name, .host, and .checker_command
 
3255
                        for k in ("name", "host", "checker_command"):
3243
3256
                            if isinstance(value[k], bytes):
3244
3257
                                value[k] = value[k].decode("utf-8")
3245
 
                        if not value.has_key("key_id"):
 
3258
                        if "key_id" not in value:
3246
3259
                            value["key_id"] = ""
3247
 
                        elif not value.has_key("fingerprint"):
 
3260
                        elif "fingerprint" not in value:
3248
3261
                            value["fingerprint"] = ""
3249
3262
                    #  old_client_settings
3250
3263
                    # .keys()
3255
3268
                        for key, value in
3256
3269
                        bytes_old_client_settings.items()}
3257
3270
                    del bytes_old_client_settings
3258
 
                    # .host
 
3271
                    # .host and .checker_command
3259
3272
                    for value in old_client_settings.values():
3260
 
                        if isinstance(value["host"], bytes):
3261
 
                            value["host"] = (value["host"]
3262
 
                                             .decode("utf-8"))
 
3273
                        for attribute in ("host", "checker_command"):
 
3274
                            if isinstance(value[attribute], bytes):
 
3275
                                value[attribute] = (value[attribute]
 
3276
                                                    .decode("utf-8"))
3263
3277
            os.remove(stored_state_path)
3264
3278
        except IOError as e:
3265
3279
            if e.errno == errno.ENOENT:
3590
3604
                sys.exit(1)
3591
3605
            # End of Avahi example code
3592
3606
 
3593
 
        GLib.io_add_watch(tcp_server.fileno(), GLib.IO_IN,
3594
 
                          lambda *args, **kwargs:
3595
 
                          (tcp_server.handle_request
3596
 
                           (*args[2:], **kwargs) or True))
 
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))
3597
3612
 
3598
3613
        logger.debug("Starting main loop")
3599
3614
        main_loop.run()
3609
3624
    # Must run before the D-Bus bus name gets deregistered
3610
3625
    cleanup()
3611
3626
 
 
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
3612
3643
 
3613
3644
if __name__ == '__main__':
3614
 
    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()