/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-10-20 01:48:38 UTC
  • Revision ID: teddy@recompile.se-20191020014838-w0pin3z8oe6he6gn
Update comment text

* dracut-module/password-agent.c (task_func): Fix comment to not still
                                              call this type
                                              "func_type".

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
 
84
import gi
83
85
from gi.repository import GLib
84
86
from dbus.mainloop.glib import DBusGMainLoop
85
87
import ctypes
87
89
import xml.dom.minidom
88
90
import inspect
89
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
 
90
100
# Try to find the value of SO_BINDTODEVICE:
91
101
try:
92
102
    # This is where SO_BINDTODEVICE is in Python 3.3 (or 3.4?) and
115
125
if sys.version_info.major == 2:
116
126
    str = unicode
117
127
 
118
 
version = "1.8.4"
 
128
if sys.version_info < (3, 2):
 
129
    configparser.Configparser = configparser.SafeConfigParser
 
130
 
 
131
version = "1.8.9"
119
132
stored_state_file = "clients.pickle"
120
133
 
121
134
logger = logging.getLogger()
 
135
logging.captureWarnings(True)   # Show warnings via the logging system
122
136
syslogger = None
123
137
 
124
138
try:
179
193
    pass
180
194
 
181
195
 
182
 
class PGPEngine(object):
 
196
class PGPEngine:
183
197
    """A simple class for OpenPGP symmetric encryption & decryption"""
184
198
 
185
199
    def __init__(self):
189
203
            output = subprocess.check_output(["gpgconf"])
190
204
            for line in output.splitlines():
191
205
                name, text, path = line.split(b":")
192
 
                if name == "gpg":
 
206
                if name == b"gpg":
193
207
                    self.gpg = path
194
208
                    break
195
209
        except OSError as e:
200
214
                          '--force-mdc',
201
215
                          '--quiet']
202
216
        # Only GPG version 1 has the --no-use-agent option.
203
 
        if self.gpg == "gpg" or self.gpg.endswith("/gpg"):
 
217
        if self.gpg == b"gpg" or self.gpg.endswith(b"/gpg"):
204
218
            self.gnupgargs.append("--no-use-agent")
205
219
 
206
220
    def __enter__(self):
275
289
 
276
290
 
277
291
# Pretend that we have an Avahi module
278
 
class avahi(object):
 
292
class avahi:
279
293
    """This isn't so much a class as it is a module-like namespace."""
280
294
    IF_UNSPEC = -1               # avahi-common/address.h
281
295
    PROTO_UNSPEC = -1            # avahi-common/address.h
315
329
    pass
316
330
 
317
331
 
318
 
class AvahiService(object):
 
332
class AvahiService:
319
333
    """An Avahi (Zeroconf) service.
320
334
 
321
335
    Attributes:
503
517
 
504
518
 
505
519
# Pretend that we have a GnuTLS module
506
 
class gnutls(object):
 
520
class gnutls:
507
521
    """This isn't so much a class as it is a module-like namespace."""
508
522
 
509
523
    library = ctypes.util.find_library("gnutls")
572
586
        pass
573
587
 
574
588
    # Classes
575
 
    class Credentials(object):
 
589
    class Credentials:
576
590
        def __init__(self):
577
591
            self._c_object = gnutls.certificate_credentials_t()
578
592
            gnutls.certificate_allocate_credentials(
582
596
        def __del__(self):
583
597
            gnutls.certificate_free_credentials(self._c_object)
584
598
 
585
 
    class ClientSession(object):
 
599
    class ClientSession:
586
600
        def __init__(self, socket, credentials=None):
587
601
            self._c_object = gnutls.session_t()
588
602
            gnutls_flags = gnutls.CLIENT
589
 
            if gnutls.check_version("3.5.6"):
 
603
            if gnutls.check_version(b"3.5.6"):
590
604
                gnutls_flags |= gnutls.NO_TICKETS
591
605
            if gnutls.has_rawpk:
592
606
                gnutls_flags |= gnutls.ENABLE_RAWPK
794
808
                                                    ctypes.c_size_t)]
795
809
        openpgp_crt_get_fingerprint.restype = _error_code
796
810
 
797
 
    if check_version("3.6.4"):
 
811
    if check_version(b"3.6.4"):
798
812
        certificate_type_get2 = _library.gnutls_certificate_type_get2
799
813
        certificate_type_get2.argtypes = [session_t, ctypes.c_int]
800
814
        certificate_type_get2.restype = _error_code
814
828
    connection.close()
815
829
 
816
830
 
817
 
class Client(object):
 
831
class Client:
818
832
    """A representation of a client host served by this server.
819
833
 
820
834
    Attributes:
821
835
    approved:   bool(); 'None' if not yet approved/disapproved
822
836
    approval_delay: datetime.timedelta(); Time to wait for approval
823
837
    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.
 
838
    checker: multiprocessing.Process(); a running checker process used
 
839
             to see if the client lives. 'None' if no process is
 
840
             running.
827
841
    checker_callback_tag: a GLib event source tag, or None
828
842
    checker_command: string; External command which is run to check
829
843
                     if client lives.  %() expansions are done at
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
2208
2225
    del _interface
2209
2226
 
2210
2227
 
2211
 
class ProxyClient(object):
 
2228
class ProxyClient:
2212
2229
    def __init__(self, child_pipe, key_id, fpr, address):
2213
2230
        self._pipe = child_pipe
2214
2231
        self._pipe.send(('init', key_id, fpr, address))
2287
2304
            approval_required = False
2288
2305
            try:
2289
2306
                if gnutls.has_rawpk:
2290
 
                    fpr = ""
 
2307
                    fpr = b""
2291
2308
                    try:
2292
2309
                        key_id = self.key_id(
2293
2310
                            self.peer_certificate(session))
2297
2314
                    logger.debug("Key ID: %s", key_id)
2298
2315
 
2299
2316
                else:
2300
 
                    key_id = ""
 
2317
                    key_id = b""
2301
2318
                    try:
2302
2319
                        fpr = self.fingerprint(
2303
2320
                            self.peer_certificate(session))
2487
2504
        return hex_fpr
2488
2505
 
2489
2506
 
2490
 
class MultiprocessingMixIn(object):
 
2507
class MultiprocessingMixIn:
2491
2508
    """Like socketserver.ThreadingMixIn, but with multiprocessing"""
2492
2509
 
2493
2510
    def sub_process_main(self, request, address):
2505
2522
        return proc
2506
2523
 
2507
2524
 
2508
 
class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):
 
2525
class MultiprocessingMixInWithPipe(MultiprocessingMixIn):
2509
2526
    """ adds a pipe to the MixIn """
2510
2527
 
2511
2528
    def process_request(self, request, client_address):
2526
2543
 
2527
2544
 
2528
2545
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
2529
 
                     socketserver.TCPServer, object):
 
2546
                     socketserver.TCPServer):
2530
2547
    """IPv6-capable TCP server.  Accepts 'None' as address and/or port
2531
2548
 
2532
2549
    Attributes:
2605
2622
                    raise
2606
2623
        # Only bind(2) the socket if we really need to.
2607
2624
        if self.server_address[0] or self.server_address[1]:
 
2625
            if self.server_address[1]:
 
2626
                self.allow_reuse_address = True
2608
2627
            if not self.server_address[0]:
2609
2628
                if self.address_family == socket.AF_INET6:
2610
2629
                    any_address = "::"  # in6addr_any
2663
2682
    def add_pipe(self, parent_pipe, proc):
2664
2683
        # Call "handle_ipc" for both data and EOF events
2665
2684
        GLib.io_add_watch(
2666
 
            parent_pipe.fileno(),
2667
 
            GLib.IO_IN | GLib.IO_HUP,
 
2685
            GLib.IOChannel.unix_new(parent_pipe.fileno()),
 
2686
            GLib.PRIORITY_DEFAULT, GLib.IO_IN | GLib.IO_HUP,
2668
2687
            functools.partial(self.handle_ipc,
2669
2688
                              parent_pipe=parent_pipe,
2670
2689
                              proc=proc))
2708
2727
                return False
2709
2728
 
2710
2729
            GLib.io_add_watch(
2711
 
                parent_pipe.fileno(),
2712
 
                GLib.IO_IN | GLib.IO_HUP,
 
2730
                GLib.IOChannel.unix_new(parent_pipe.fileno()),
 
2731
                GLib.PRIORITY_DEFAULT, GLib.IO_IN | GLib.IO_HUP,
2713
2732
                functools.partial(self.handle_ipc,
2714
2733
                                  parent_pipe=parent_pipe,
2715
2734
                                  proc=proc,
2747
2766
def rfc3339_duration_to_delta(duration):
2748
2767
    """Parse an RFC 3339 "duration" and return a datetime.timedelta
2749
2768
 
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)
 
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
2764
2783
    """
2765
2784
 
2766
2785
    # Parsing an RFC 3339 duration with regular expressions is not
2846
2865
def string_to_delta(interval):
2847
2866
    """Parse a string and return a datetime.timedelta
2848
2867
 
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)
 
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
2861
2880
    """
2862
2881
 
2863
2882
    try:
2965
2984
 
2966
2985
    options = parser.parse_args()
2967
2986
 
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
2987
    # Default values for config file for server-global settings
2974
2988
    if gnutls.has_rawpk:
2975
2989
        priority = ("SECURE128:!CTYPE-X.509:+CTYPE-RAWPK:!RSA"
2995
3009
    del priority
2996
3010
 
2997
3011
    # Parse config file for server-global settings
2998
 
    server_config = configparser.SafeConfigParser(server_defaults)
 
3012
    server_config = configparser.ConfigParser(server_defaults)
2999
3013
    del server_defaults
3000
3014
    server_config.read(os.path.join(options.configdir, "mandos.conf"))
3001
 
    # Convert the SafeConfigParser object to a dict
 
3015
    # Convert the ConfigParser object to a dict
3002
3016
    server_settings = server_config.defaults()
3003
3017
    # Use the appropriate methods on the non-string config options
3004
3018
    for option in ("debug", "use_dbus", "use_ipv6", "restore",
3076
3090
                                  server_settings["servicename"])))
3077
3091
 
3078
3092
    # Parse config file with clients
3079
 
    client_config = configparser.SafeConfigParser(Client
3080
 
                                                  .client_defaults)
 
3093
    client_config = configparser.ConfigParser(Client.client_defaults)
3081
3094
    client_config.read(os.path.join(server_settings["configdir"],
3082
3095
                                    "clients.conf"))
3083
3096
 
3154
3167
        # Close all input and output, do double fork, etc.
3155
3168
        daemon()
3156
3169
 
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()
 
3170
    if gi.version_info < (3, 10, 2):
 
3171
        # multiprocessing will use threads, so before we use GLib we
 
3172
        # need to inform GLib that threads will be used.
 
3173
        GLib.threads_init()
3160
3174
 
3161
3175
    global main_loop
3162
3176
    # From the Avahi example code
3238
3252
                             if isinstance(s, bytes)
3239
3253
                             else s) for s in
3240
3254
                            value["client_structure"]]
3241
 
                        # .name & .host
3242
 
                        for k in ("name", "host"):
 
3255
                        # .name, .host, and .checker_command
 
3256
                        for k in ("name", "host", "checker_command"):
3243
3257
                            if isinstance(value[k], bytes):
3244
3258
                                value[k] = value[k].decode("utf-8")
3245
 
                        if not value.has_key("key_id"):
 
3259
                        if "key_id" not in value:
3246
3260
                            value["key_id"] = ""
3247
 
                        elif not value.has_key("fingerprint"):
 
3261
                        elif "fingerprint" not in value:
3248
3262
                            value["fingerprint"] = ""
3249
3263
                    #  old_client_settings
3250
3264
                    # .keys()
3255
3269
                        for key, value in
3256
3270
                        bytes_old_client_settings.items()}
3257
3271
                    del bytes_old_client_settings
3258
 
                    # .host
 
3272
                    # .host and .checker_command
3259
3273
                    for value in old_client_settings.values():
3260
 
                        if isinstance(value["host"], bytes):
3261
 
                            value["host"] = (value["host"]
3262
 
                                             .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"))
3263
3278
            os.remove(stored_state_path)
3264
3279
        except IOError as e:
3265
3280
            if e.errno == errno.ENOENT:
3590
3605
                sys.exit(1)
3591
3606
            # End of Avahi example code
3592
3607
 
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))
 
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))
3597
3613
 
3598
3614
        logger.debug("Starting main loop")
3599
3615
        main_loop.run()
3609
3625
    # Must run before the D-Bus bus name gets deregistered
3610
3626
    cleanup()
3611
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
3612
3644
 
3613
3645
if __name__ == '__main__':
3614
 
    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()