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
- browse files at revision 1024
- compare with another revision
- download diff
- download tarball
- view history from revision 1024
- Committer: Teddy Hogeborn
- Date: 2019-03-05 21:39:15 UTC
- Revision ID: teddy@recompile.se-20190305213915-xm1vw00jyy3a5tfn
mandos-ctl: Add more tests, including tests for all commands
* mandos-ctl (Test_string_to_delta.test_handles_basic_rfc3339): Add a
few more test cases.
(TestCmd.setUp.MockClient.Set, TestCmd.setUp.MockClient.Get): Don't
append to self.calls, since nobody should use it to check for Set()
or Get() calls; instead, the return value of Get() should be
inspected, and the MockClient.attributes dict should be inspected
after (implicitly) calling Set().
(Unique): New; stand-in for unittest.mock.sentinel.
(TestPropertyCmd): New; abstract class testing PropertyCmd classes.
(TestBumpTimeoutCmd, TestStartCheckerCmd, TestStopCheckerCmd,
TestApproveByDefaultCmd, TestDenyByDefaultCmd): New.
(TestValueArgumentPropertyCmd): New; abstract class for testing
those PropertyCmd classes which also
inherit from ValueArgumentMixIn.
(TestSetCheckerCmd, TestSetHostCmd, TestSetSecretCmd,
TestSetTimeoutCmd, TestSetExtendedTimeoutCmd, TestSetIntervalCmd,
TestSetApprovalDelayCmd, TestSetApprovalDurationCmd): New.
* mandos-ctl (Test_string_to_delta.test_handles_basic_rfc3339): Add a
few more test cases.
(TestCmd.setUp.MockClient.Set, TestCmd.setUp.MockClient.Get): Don't
append to self.calls, since nobody should use it to check for Set()
or Get() calls; instead, the return value of Get() should be
inspected, and the MockClient.attributes dict should be inspected
after (implicitly) calling Set().
(Unique): New; stand-in for unittest.mock.sentinel.
(TestPropertyCmd): New; abstract class testing PropertyCmd classes.
(TestBumpTimeoutCmd, TestStartCheckerCmd, TestStopCheckerCmd,
TestApproveByDefaultCmd, TestDenyByDefaultCmd): New.
(TestValueArgumentPropertyCmd): New; abstract class for testing
those PropertyCmd classes which also
inherit from ValueArgumentMixIn.
(TestSetCheckerCmd, TestSetHostCmd, TestSetSecretCmd,
TestSetTimeoutCmd, TestSetExtendedTimeoutCmd, TestSetIntervalCmd,
TestSetApprovalDelayCmd, TestSetApprovalDurationCmd): New.
- files removed:
- debian/po/POTFILES.in
- debian/tests
- dracut-module
- files modified:
- .bzrignore
added
removed
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
80
82
81
import dbus
83
82
import dbus.service
84
import gi
85
83
from gi.repository import GLib
86
84
from dbus.mainloop.glib import DBusGMainLoop
87
85
import ctypes
89
87
import xml.dom.minidom
90
88
import inspect
91
89
92
if sys.version_info.major == 2:
93
__metaclass__ = type
94
str = unicode
95
96
# Show warnings by default
97
if not sys.warnoptions:
98
import warnings
99
warnings.simplefilter("default")
100
101
90
# Try to find the value of SO_BINDTODEVICE:
102
91
try:
103
92
# This is where SO_BINDTODEVICE is in Python 3.3 (or 3.4?) and
123
112
# No value found
124
113
SO_BINDTODEVICE = None
125
114
126
if sys.version_info < (3, 2):
127
configparser.Configparser = configparser.SafeConfigParser
115
if sys.version_info.major == 2:
116
str = unicode
128
117
129
version = "1.8.9"
118
version = "1.8.3"
130
119
stored_state_file = "clients.pickle"
131
120
132
121
logger = logging.getLogger()
133
logging.captureWarnings(True) # Show warnings via the logging system
134
122
syslogger = None
135
123
136
124
try:
191
179
pass
192
180
193
181
194
class PGPEngine:
182
class PGPEngine(object):
195
183
"""A simple class for OpenPGP symmetric encryption & decryption"""
196
184
197
185
def __init__(self):
201
189
output = subprocess.check_output(["gpgconf"])
202
190
for line in output.splitlines():
203
191
name, text, path = line.split(b":")
204
if name == b"gpg":
192
if name == "gpg":
205
193
self.gpg = path
206
194
break
207
195
except OSError as e:
212
200
'--force-mdc',
213
201
'--quiet']
214
202
# Only GPG version 1 has the --no-use-agent option.
215
if self.gpg == b"gpg" or self.gpg.endswith(b"/gpg"):
203
if self.gpg == "gpg" or self.gpg.endswith("/gpg"):
216
204
self.gnupgargs.append("--no-use-agent")
217
205
218
206
def __enter__(self):
287
275
288
276
289
277
# Pretend that we have an Avahi module
290
class avahi:
291
"""This isn't so much a class as it is a module-like namespace."""
278
class Avahi(object):
279
"""This isn't so much a class as it is a module-like namespace.
280
It is instantiated once, and simulates having an Avahi module."""
292
281
IF_UNSPEC = -1 # avahi-common/address.h
293
282
PROTO_UNSPEC = -1 # avahi-common/address.h
294
283
PROTO_INET = 0 # avahi-common/address.h
298
287
DBUS_INTERFACE_SERVER = DBUS_NAME + ".Server"
299
288
DBUS_PATH_SERVER = "/"
300
289
301
@staticmethod
302
def string_array_to_txt_array(t):
290
def string_array_to_txt_array(self, t):
303
291
return dbus.Array((dbus.ByteArray(s.encode("utf-8"))
304
292
for s in t), signature="ay")
305
293
ENTRY_GROUP_ESTABLISHED = 2 # avahi-common/defs.h
310
298
SERVER_RUNNING = 2 # avahi-common/defs.h
311
299
SERVER_COLLISION = 3 # avahi-common/defs.h
312
300
SERVER_FAILURE = 4 # avahi-common/defs.h
301
avahi = Avahi()
313
302
314
303
315
304
class AvahiError(Exception):
327
316
pass
328
317
329
318
330
class AvahiService:
319
class AvahiService(object):
331
320
"""An Avahi (Zeroconf) service.
332
321
333
322
Attributes:
515
504
516
505
517
506
# Pretend that we have a GnuTLS module
518
class gnutls:
519
"""This isn't so much a class as it is a module-like namespace."""
507
class GnuTLS(object):
508
"""This isn't so much a class as it is a module-like namespace.
509
It is instantiated once, and simulates having a GnuTLS module."""
520
510
521
511
library = ctypes.util.find_library("gnutls")
522
512
if library is None:
523
513
library = ctypes.util.find_library("gnutls-deb0")
524
514
_library = ctypes.cdll.LoadLibrary(library)
525
515
del library
516
_need_version = b"3.3.0"
517
_tls_rawpk_version = b"3.6.6"
518
519
def __init__(self):
520
# Need to use "self" here, since this method is called before
521
# the assignment to the "gnutls" global variable happens.
522
if self.check_version(self._need_version) is None:
523
raise self.Error("Needs GnuTLS {} or later"
524
.format(self._need_version))
526
525
527
526
# Unless otherwise indicated, the constants and types below are
528
527
# all from the gnutls/gnutls.h C header file.
570
569
571
570
# Exceptions
572
571
class Error(Exception):
572
# We need to use the class name "GnuTLS" here, since this
573
# exception might be raised from within GnuTLS.__init__,
574
# which is called before the assignment to the "gnutls"
575
# global variable has happened.
573
576
def __init__(self, message=None, code=None, args=()):
574
577
# Default usage is by a message string, but if a return
575
578
# code is passed, convert it to a string with
576
579
# gnutls.strerror()
577
580
self.code = code
578
581
if message is None and code is not None:
579
message = gnutls.strerror(code)
580
return super(gnutls.Error, self).__init__(
582
message = GnuTLS.strerror(code)
583
return super(GnuTLS.Error, self).__init__(
581
584
message, *args)
582
585
583
586
class CertificateSecurityError(Error):
584
587
pass
585
588
586
589
# Classes
587
class Credentials:
590
class Credentials(object):
588
591
def __init__(self):
589
592
self._c_object = gnutls.certificate_credentials_t()
590
593
gnutls.certificate_allocate_credentials(
594
597
def __del__(self):
595
598
gnutls.certificate_free_credentials(self._c_object)
596
599
597
class ClientSession:
600
class ClientSession(object):
598
601
def __init__(self, socket, credentials=None):
599
602
self._c_object = gnutls.session_t()
600
603
gnutls_flags = gnutls.CLIENT
601
if gnutls.check_version(b"3.5.6"):
604
if gnutls.check_version("3.5.6"):
602
605
gnutls_flags |= gnutls.NO_TICKETS
603
606
if gnutls.has_rawpk:
604
607
gnutls_flags |= gnutls.ENABLE_RAWPK
741
744
check_version.argtypes = [ctypes.c_char_p]
742
745
check_version.restype = ctypes.c_char_p
743
746
744
_need_version = b"3.3.0"
745
if check_version(_need_version) is None:
746
raise self.Error("Needs GnuTLS {} or later"
747
.format(_need_version))
748
749
_tls_rawpk_version = b"3.6.6"
750
747
has_rawpk = bool(check_version(_tls_rawpk_version))
751
748
752
749
if has_rawpk:
806
803
ctypes.c_size_t)]
807
804
openpgp_crt_get_fingerprint.restype = _error_code
808
805
809
if check_version(b"3.6.4"):
806
if check_version("3.6.4"):
810
807
certificate_type_get2 = _library.gnutls_certificate_type_get2
811
808
certificate_type_get2.argtypes = [session_t, ctypes.c_int]
812
809
certificate_type_get2.restype = _error_code
813
810
814
811
# Remove non-public functions
815
812
del _error_code, _retry_on_error
813
# Create the global "gnutls" object, simulating a module
814
gnutls = GnuTLS()
816
815
817
816
818
817
def call_pipe(connection, # : multiprocessing.Connection
826
825
connection.close()
827
826
828
827
829
class Client:
828
class Client(object):
830
829
"""A representation of a client host served by this server.
831
830
832
831
Attributes:
833
832
approved: bool(); 'None' if not yet approved/disapproved
834
833
approval_delay: datetime.timedelta(); Time to wait for approval
835
834
approval_duration: datetime.timedelta(); Duration of one approval
836
checker: multiprocessing.Process(); a running checker process used
837
to see if the client lives. 'None' if no process is
838
running.
835
checker: subprocess.Popen(); a running checker process used
836
to see if the client lives.
837
'None' if no process is running.
839
838
checker_callback_tag: a GLib event source tag, or None
840
839
checker_command: string; External command which is run to check
841
840
if client lives. %() expansions are done at
1048
1047
def checker_callback(self, source, condition, connection,
1049
1048
command):
1050
1049
"""The checker has completed, so take appropriate actions."""
1050
self.checker_callback_tag = None
1051
self.checker = None
1051
1052
# Read return code from connection (see call_pipe)
1052
1053
returncode = connection.recv()
1053
1054
connection.close()
1054
if self.checker is not None:
1055
self.checker.join()
1056
self.checker_callback_tag = None
1057
self.checker = None
1058
1055
1059
1056
if returncode >= 0:
1060
1057
self.last_checker_status = returncode
1149
1146
kwargs=popen_args)
1150
1147
self.checker.start()
1151
1148
self.checker_callback_tag = GLib.io_add_watch(
1152
GLib.IOChannel.unix_new(pipe[0].fileno()),
1153
GLib.PRIORITY_DEFAULT, GLib.IO_IN,
1149
pipe[0].fileno(), GLib.IO_IN,
1154
1150
self.checker_callback, pipe[0], command)
1155
1151
# Re-run this periodically if run by GLib.timeout_add
1156
1152
return True
1411
1407
raise ValueError("Byte arrays not supported for non-"
1412
1408
"'ay' signature {!r}"
1413
1409
.format(prop._dbus_signature))
1414
value = dbus.ByteArray(bytes(value))
1410
value = dbus.ByteArray(b''.join(chr(byte)
1411
for byte in value))
1415
1412
prop(value)
1416
1413
1417
1414
@dbus.service.method(dbus.PROPERTIES_IFACE,
2222
2219
del _interface
2223
2220
2224
2221
2225
class ProxyClient:
2222
class ProxyClient(object):
2226
2223
def __init__(self, child_pipe, key_id, fpr, address):
2227
2224
self._pipe = child_pipe
2228
2225
self._pipe.send(('init', key_id, fpr, address))
2301
2298
approval_required = False
2302
2299
try:
2303
2300
if gnutls.has_rawpk:
2304
fpr = b""
2301
fpr = ""
2305
2302
try:
2306
2303
key_id = self.key_id(
2307
2304
self.peer_certificate(session))
2311
2308
logger.debug("Key ID: %s", key_id)
2312
2309
2313
2310
else:
2314
key_id = b""
2311
key_id = ""
2315
2312
try:
2316
2313
fpr = self.fingerprint(
2317
2314
self.peer_certificate(session))
2501
2498
return hex_fpr
2502
2499
2503
2500
2504
class MultiprocessingMixIn:
2501
class MultiprocessingMixIn(object):
2505
2502
"""Like socketserver.ThreadingMixIn, but with multiprocessing"""
2506
2503
2507
2504
def sub_process_main(self, request, address):
2519
2516
return proc
2520
2517
2521
2518
2522
class MultiprocessingMixInWithPipe(MultiprocessingMixIn):
2519
class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):
2523
2520
""" adds a pipe to the MixIn """
2524
2521
2525
2522
def process_request(self, request, client_address):
2540
2537
2541
2538
2542
2539
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
2543
socketserver.TCPServer):
2540
socketserver.TCPServer, object):
2544
2541
"""IPv6-capable TCP server. Accepts 'None' as address and/or port
2545
2542
2546
2543
Attributes:
2619
2616
raise
2620
2617
# Only bind(2) the socket if we really need to.
2621
2618
if self.server_address[0] or self.server_address[1]:
2622
if self.server_address[1]:
2623
self.allow_reuse_address = True
2624
2619
if not self.server_address[0]:
2625
2620
if self.address_family == socket.AF_INET6:
2626
2621
any_address = "::" # in6addr_any
2679
2674
def add_pipe(self, parent_pipe, proc):
2680
2675
# Call "handle_ipc" for both data and EOF events
2681
2676
GLib.io_add_watch(
2682
GLib.IOChannel.unix_new(parent_pipe.fileno()),
2683
GLib.PRIORITY_DEFAULT, GLib.IO_IN | GLib.IO_HUP,
2677
parent_pipe.fileno(),
2678
GLib.IO_IN | GLib.IO_HUP,
2684
2679
functools.partial(self.handle_ipc,
2685
2680
parent_pipe=parent_pipe,
2686
2681
proc=proc))
2724
2719
return False
2725
2720
2726
2721
GLib.io_add_watch(
2727
GLib.IOChannel.unix_new(parent_pipe.fileno()),
2728
GLib.PRIORITY_DEFAULT, GLib.IO_IN | GLib.IO_HUP,
2722
parent_pipe.fileno(),
2723
GLib.IO_IN | GLib.IO_HUP,
2729
2724
functools.partial(self.handle_ipc,
2730
2725
parent_pipe=parent_pipe,
2731
2726
proc=proc,
2763
2758
def rfc3339_duration_to_delta(duration):
2764
2759
"""Parse an RFC 3339 "duration" and return a datetime.timedelta
2765
2760
2766
>>> rfc3339_duration_to_delta("P7D") == datetime.timedelta(7)
2767
True
2768
>>> rfc3339_duration_to_delta("PT60S") == datetime.timedelta(0, 60)
2769
True
2770
>>> rfc3339_duration_to_delta("PT60M") == datetime.timedelta(0, 3600)
2771
True
2772
>>> rfc3339_duration_to_delta("PT24H") == datetime.timedelta(1)
2773
True
2774
>>> rfc3339_duration_to_delta("P1W") == datetime.timedelta(7)
2775
True
2776
>>> rfc3339_duration_to_delta("PT5M30S") == datetime.timedelta(0, 330)
2777
True
2778
>>> rfc3339_duration_to_delta("P1DT3M20S") == datetime.timedelta(1, 200)
2779
True
2761
>>> rfc3339_duration_to_delta("P7D")
2762
datetime.timedelta(7)
2763
>>> rfc3339_duration_to_delta("PT60S")
2764
datetime.timedelta(0, 60)
2765
>>> rfc3339_duration_to_delta("PT60M")
2766
datetime.timedelta(0, 3600)
2767
>>> rfc3339_duration_to_delta("PT24H")
2768
datetime.timedelta(1)
2769
>>> rfc3339_duration_to_delta("P1W")
2770
datetime.timedelta(7)
2771
>>> rfc3339_duration_to_delta("PT5M30S")
2772
datetime.timedelta(0, 330)
2773
>>> rfc3339_duration_to_delta("P1DT3M20S")
2774
datetime.timedelta(1, 200)
2780
2775
"""
2781
2776
2782
2777
# Parsing an RFC 3339 duration with regular expressions is not
2862
2857
def string_to_delta(interval):
2863
2858
"""Parse a string and return a datetime.timedelta
2864
2859
2865
>>> string_to_delta('7d') == datetime.timedelta(7)
2866
True
2867
>>> string_to_delta('60s') == datetime.timedelta(0, 60)
2868
True
2869
>>> string_to_delta('60m') == datetime.timedelta(0, 3600)
2870
True
2871
>>> string_to_delta('24h') == datetime.timedelta(1)
2872
True
2873
>>> string_to_delta('1w') == datetime.timedelta(7)
2874
True
2875
>>> string_to_delta('5m 30s') == datetime.timedelta(0, 330)
2876
True
2860
>>> string_to_delta('7d')
2861
datetime.timedelta(7)
2862
>>> string_to_delta('60s')
2863
datetime.timedelta(0, 60)
2864
>>> string_to_delta('60m')
2865
datetime.timedelta(0, 3600)
2866
>>> string_to_delta('24h')
2867
datetime.timedelta(1)
2868
>>> string_to_delta('1w')
2869
datetime.timedelta(7)
2870
>>> string_to_delta('5m 30s')
2871
datetime.timedelta(0, 330)
2877
2872
"""
2878
2873
2879
2874
try:
2981
2976
2982
2977
options = parser.parse_args()
2983
2978
2979
if options.check:
2980
import doctest
2981
fail_count, test_count = doctest.testmod()
2982
sys.exit(os.EX_OK if fail_count == 0 else 1)
2983
2984
2984
# Default values for config file for server-global settings
2985
2985
if gnutls.has_rawpk:
2986
2986
priority = ("SECURE128:!CTYPE-X.509:+CTYPE-RAWPK:!RSA"
3006
3006
del priority
3007
3007
3008
3008
# Parse config file for server-global settings
3009
server_config = configparser.ConfigParser(server_defaults)
3009
server_config = configparser.SafeConfigParser(server_defaults)
3010
3010
del server_defaults
3011
3011
server_config.read(os.path.join(options.configdir, "mandos.conf"))
3012
# Convert the ConfigParser object to a dict
3012
# Convert the SafeConfigParser object to a dict
3013
3013
server_settings = server_config.defaults()
3014
3014
# Use the appropriate methods on the non-string config options
3015
3015
for option in ("debug", "use_dbus", "use_ipv6", "restore",
3087
3087
server_settings["servicename"])))
3088
3088
3089
3089
# Parse config file with clients
3090
client_config = configparser.ConfigParser(Client.client_defaults)
3090
client_config = configparser.SafeConfigParser(Client
3091
.client_defaults)
3091
3092
client_config.read(os.path.join(server_settings["configdir"],
3092
3093
"clients.conf"))
3093
3094
3164
3165
# Close all input and output, do double fork, etc.
3165
3166
daemon()
3166
3167
3167
if gi.version_info < (3, 10, 2):
3168
# multiprocessing will use threads, so before we use GLib we
3169
# need to inform GLib that threads will be used.
3170
GLib.threads_init()
3168
# multiprocessing will use threads, so before we use GLib we need
3169
# to inform GLib that threads will be used.
3170
GLib.threads_init()
3171
3171
3172
3172
global main_loop
3173
3173
# From the Avahi example code
3249
3249
if isinstance(s, bytes)
3250
3250
else s) for s in
3251
3251
value["client_structure"]]
3252
# .name, .host, and .checker_command
3253
for k in ("name", "host", "checker_command"):
3252
# .name & .host
3253
for k in ("name", "host"):
3254
3254
if isinstance(value[k], bytes):
3255
3255
value[k] = value[k].decode("utf-8")
3256
if "key_id" not in value:
3256
if not value.has_key("key_id"):
3257
3257
value["key_id"] = ""
3258
elif "fingerprint" not in value:
3258
elif not value.has_key("fingerprint"):
3259
3259
value["fingerprint"] = ""
3260
3260
# old_client_settings
3261
3261
# .keys()
3266
3266
for key, value in
3267
3267
bytes_old_client_settings.items()}
3268
3268
del bytes_old_client_settings
3269
# .host and .checker_command
3269
# .host
3270
3270
for value in old_client_settings.values():
3271
for attribute in ("host", "checker_command"):
3272
if isinstance(value[attribute], bytes):
3273
value[attribute] = (value[attribute]
3274
.decode("utf-8"))
3271
if isinstance(value["host"], bytes):
3272
value["host"] = (value["host"]
3273
.decode("utf-8"))
3275
3274
os.remove(stored_state_path)
3276
3275
except IOError as e:
3277
3276
if e.errno == errno.ENOENT:
3602
3601
sys.exit(1)
3603
3602
# End of Avahi example code
3604
3603
3605
GLib.io_add_watch(
3606
GLib.IOChannel.unix_new(tcp_server.fileno()),
3607
GLib.PRIORITY_DEFAULT, GLib.IO_IN,
3608
lambda *args, **kwargs: (tcp_server.handle_request
3609
(*args[2:], **kwargs) or True))
3604
GLib.io_add_watch(tcp_server.fileno(), GLib.IO_IN,
3605
lambda *args, **kwargs:
3606
(tcp_server.handle_request
3607
(*args[2:], **kwargs) or True))
3610
3608
3611
3609
logger.debug("Starting main loop")
3612
3610
main_loop.run()
3622
3620
# Must run before the D-Bus bus name gets deregistered
3623
3621
cleanup()
3624
3622
3625
3626
def should_only_run_tests():
3627
parser = argparse.ArgumentParser(add_help=False)
3628
parser.add_argument("--check", action='store_true')
3629
args, unknown_args = parser.parse_known_args()
3630
run_tests = args.check
3631
if run_tests:
3632
# Remove --check argument from sys.argv
3633
sys.argv[1:] = unknown_args
3634
return run_tests
3635
3636
# Add all tests from doctest strings
3637
def load_tests(loader, tests, none):
3638
import doctest
3639
tests.addTests(doctest.DocTestSuite())
3640
return tests
3641
3623
3642
3624
if __name__ == '__main__':
3643
try:
3644
if should_only_run_tests():
3645
# Call using ./mandos --check [--verbose]
3646
unittest.main()
3647
else:
3648
main()
3649
finally:
3650
logging.shutdown()
3625
main()
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0