2
# -*- mode: python; coding: utf-8; after-save-hook: (lambda () (let ((command (if (and (boundp 'tramp-file-name-structure) (string-match (car tramp-file-name-structure) (buffer-file-name))) (tramp-file-name-localname (tramp-dissect-file-name (buffer-file-name))) (buffer-file-name)))) (if (= (shell-command (format "%s --check" (shell-quote-argument command)) "*Test*") 0) (let ((w (get-buffer-window "*Test*"))) (if w (delete-window w)) (kill-buffer "*Test*")) (display-buffer "*Test*")))); -*-
2
# -*- mode: python; coding: utf-8 -*-
4
4
# Mandos Monitor - Control and monitor the Mandos server
6
# Copyright © 2008-2019 Teddy Hogeborn
7
# Copyright © 2008-2019 Björn Påhlsson
9
# This file is part of Mandos.
11
# Mandos is free software: you can redistribute it and/or modify it
12
# under the terms of the GNU General Public License as published by
6
# Copyright © 2008-2014 Teddy Hogeborn
7
# Copyright © 2008-2014 Björn Påhlsson
9
# This program is free software: you can redistribute it and/or modify
10
# it under the terms of the GNU General Public License as published by
13
11
# the Free Software Foundation, either version 3 of the License, or
14
12
# (at your option) any later version.
16
# Mandos is distributed in the hope that it will be useful, but
17
# WITHOUT ANY WARRANTY; without even the implied warranty of
14
# This program is distributed in the hope that it will be useful,
15
# but WITHOUT ANY WARRANTY; without even the implied warranty of
18
16
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19
17
# GNU General Public License for more details.
21
19
# You should have received a copy of the GNU General Public License
22
# along with Mandos. If not, see <http://www.gnu.org/licenses/>.
20
# along with this program. If not, see
21
# <http://www.gnu.org/licenses/>.
24
23
# Contact the authors at <mandos@recompile.se>.
27
26
from __future__ import (division, absolute_import, print_function,
79
64
"ApprovalDelay": "Approval Delay",
80
65
"ApprovalDuration": "Approval Duration",
81
66
"Checker": "Checker",
82
"ExtendedTimeout": "Extended Timeout",
84
"LastCheckerStatus": "Last Checker Status",
67
"ExtendedTimeout" : "Extended Timeout"
86
69
defaultkeywords = ("Name", "Enabled", "Timeout", "LastCheckedOK")
87
70
domain = "se.recompile"
88
71
busname = domain + ".Mandos"
90
73
server_interface = domain + ".Mandos"
91
74
client_interface = domain + ".Mandos.Client"
96
dbus.OBJECT_MANAGER_IFACE
97
except AttributeError:
98
dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"
77
def timedelta_to_milliseconds(td):
78
"""Convert a datetime.timedelta object to milliseconds"""
79
return ((td.days * 24 * 60 * 60 * 1000)
81
+ (td.microseconds // 1000))
101
83
def milliseconds_to_string(ms):
102
84
td = datetime.timedelta(0, 0, 0, ms)
103
85
return ("{days}{hours:02}:{minutes:02}:{seconds:02}"
104
.format(days="{}T".format(td.days) if td.days else "",
105
hours=td.seconds // 3600,
106
minutes=(td.seconds % 3600) // 60,
107
seconds=td.seconds % 60))
86
.format(days = "{0}T".format(td.days) if td.days else "",
87
hours = td.seconds // 3600,
88
minutes = (td.seconds % 3600) // 60,
89
seconds = td.seconds % 60,
110
93
def rfc3339_duration_to_delta(duration):
111
94
"""Parse an RFC 3339 "duration" and return a datetime.timedelta
113
96
>>> rfc3339_duration_to_delta("P7D")
114
97
datetime.timedelta(7)
115
98
>>> rfc3339_duration_to_delta("PT60S")
116
99
datetime.timedelta(0, 60)
117
100
>>> rfc3339_duration_to_delta("PT60M")
118
101
datetime.timedelta(0, 3600)
119
>>> rfc3339_duration_to_delta("P60M")
120
datetime.timedelta(1680)
121
102
>>> rfc3339_duration_to_delta("PT24H")
122
103
datetime.timedelta(1)
123
104
>>> rfc3339_duration_to_delta("P1W")
126
107
datetime.timedelta(0, 330)
127
108
>>> rfc3339_duration_to_delta("P1DT3M20S")
128
109
datetime.timedelta(1, 200)
129
>>> # Can not be empty:
130
>>> rfc3339_duration_to_delta("")
131
Traceback (most recent call last):
133
ValueError: Invalid RFC 3339 duration: u''
134
>>> # Must start with "P":
135
>>> rfc3339_duration_to_delta("1D")
136
Traceback (most recent call last):
138
ValueError: Invalid RFC 3339 duration: u'1D'
139
>>> # Must use correct order
140
>>> rfc3339_duration_to_delta("PT1S2M")
141
Traceback (most recent call last):
143
ValueError: Invalid RFC 3339 duration: u'PT1S2M'
144
>>> # Time needs time marker
145
>>> rfc3339_duration_to_delta("P1H2S")
146
Traceback (most recent call last):
148
ValueError: Invalid RFC 3339 duration: u'P1H2S'
149
>>> # Weeks can not be combined with anything else
150
>>> rfc3339_duration_to_delta("P1D2W")
151
Traceback (most recent call last):
153
ValueError: Invalid RFC 3339 duration: u'P1D2W'
154
>>> rfc3339_duration_to_delta("P2W2H")
155
Traceback (most recent call last):
157
ValueError: Invalid RFC 3339 duration: u'P2W2H'
160
112
# Parsing an RFC 3339 duration with regular expressions is not
161
113
# possible - there would have to be multiple places for the same
162
114
# values, like seconds. The current code, while more esoteric, is
163
115
# cleaner without depending on a parsing library. If Python had a
164
116
# built-in library for parsing we would use it, but we'd like to
165
117
# avoid excessive use of external libraries.
167
119
# New type for defining tokens, syntax, and semantics all-in-one
168
Token = collections.namedtuple("Token", (
169
"regexp", # To match token; if "value" is not None, must have
170
# a "group" containing digits
171
"value", # datetime.timedelta or None
172
"followers")) # Tokens valid after this token
120
Token = collections.namedtuple("Token",
121
("regexp", # To match token; if
122
# "value" is not None,
123
# must have a "group"
125
"value", # datetime.timedelta or
127
"followers")) # Tokens valid after
173
129
# RFC 3339 "duration" tokens, syntax, and semantics; taken from
174
130
# the "duration" ABNF definition in RFC 3339, Appendix A.
175
131
token_end = Token(re.compile(r"$"), None, frozenset())
176
132
token_second = Token(re.compile(r"(\d+)S"),
177
133
datetime.timedelta(seconds=1),
178
frozenset((token_end, )))
134
frozenset((token_end,)))
179
135
token_minute = Token(re.compile(r"(\d+)M"),
180
136
datetime.timedelta(minutes=1),
181
137
frozenset((token_second, token_end)))
233
186
# No currently valid tokens were found
234
raise ValueError("Invalid RFC 3339 duration: {!r}"
187
raise ValueError("Invalid RFC 3339 duration")
236
188
# End token found
240
192
def string_to_delta(interval):
241
193
"""Parse a string and return a datetime.timedelta
195
>>> string_to_delta("7d")
196
datetime.timedelta(7)
197
>>> string_to_delta("60s")
198
datetime.timedelta(0, 60)
199
>>> string_to_delta("60m")
200
datetime.timedelta(0, 3600)
201
>>> string_to_delta("24h")
202
datetime.timedelta(1)
203
>>> string_to_delta("1w")
204
datetime.timedelta(7)
205
>>> string_to_delta("5m 30s")
206
datetime.timedelta(0, 330)
245
210
return rfc3339_duration_to_delta(interval)
246
except ValueError as e:
247
log.warning("%s - Parsing as pre-1.6.1 interval instead",
249
return parse_pre_1_6_1_interval(interval)
252
def parse_pre_1_6_1_interval(interval):
253
"""Parse an interval string as documented by Mandos before 1.6.1, and
254
return a datetime.timedelta
255
>>> parse_pre_1_6_1_interval('7d')
256
datetime.timedelta(7)
257
>>> parse_pre_1_6_1_interval('60s')
258
datetime.timedelta(0, 60)
259
>>> parse_pre_1_6_1_interval('60m')
260
datetime.timedelta(0, 3600)
261
>>> parse_pre_1_6_1_interval('24h')
262
datetime.timedelta(1)
263
>>> parse_pre_1_6_1_interval('1w')
264
datetime.timedelta(7)
265
>>> parse_pre_1_6_1_interval('5m 30s')
266
datetime.timedelta(0, 330)
267
>>> parse_pre_1_6_1_interval('')
268
datetime.timedelta(0)
269
>>> # Ignore unknown characters, allow any order and repetitions
270
>>> parse_pre_1_6_1_interval('2dxy7zz11y3m5m')
271
datetime.timedelta(2, 480, 18000)
275
214
value = datetime.timedelta(0)
276
215
regexp = re.compile(r"(\d+)([dsmhw]?)")
278
217
for num, suffix in regexp.findall(interval):
279
218
if suffix == "d":
280
219
value += datetime.timedelta(int(num))
290
229
value += datetime.timedelta(0, 0, 0, int(num))
294
232
def print_clients(clients, keywords):
295
print('\n'.join(TableOfClients(clients, keywords).rows()))
297
class TableOfClients(object):
298
def __init__(self, clients, keywords):
299
self.clients = clients
300
self.keywords = keywords
303
233
def valuetostring(value, keyword):
304
if isinstance(value, dbus.Boolean):
234
if type(value) is dbus.Boolean:
305
235
return "Yes" if value else "No"
306
236
if keyword in ("Timeout", "Interval", "ApprovalDelay",
307
237
"ApprovalDuration", "ExtendedTimeout"):
308
238
return milliseconds_to_string(value)
309
239
return str(value)
312
# Create format string to format table rows
313
format_string = " ".join("{{{key}:{width}}}".format(
314
width=max(len(tablewords[key]),
315
max(len(self.valuetostring(client[key], key))
316
for client in self.clients)),
318
for key in self.keywords)
319
# Start with header line
320
rows = [format_string.format(**tablewords)]
321
for client in self.clients:
322
rows.append(format_string
323
.format(**{key: self.valuetostring(client[key], key)
324
for key in self.keywords}))
241
# Create format string to print table rows
242
format_string = " ".join("{{{key}:{width}}}".format(
243
width = max(len(tablewords[key]),
244
max(len(valuetostring(client[key],
248
key = key) for key in keywords)
250
print(format_string.format(**tablewords))
251
for client in clients:
252
print(format_string.format(**dict((key,
253
valuetostring(client[key],
255
for key in keywords)))
328
257
def has_actions(options):
329
258
return any((options.enable,
350
278
parser = argparse.ArgumentParser()
351
279
parser.add_argument("--version", action="version",
352
version="%(prog)s {}".format(version),
280
version = "%(prog)s {0}".format(version),
353
281
help="show version number and exit")
354
282
parser.add_argument("-a", "--all", action="store_true",
355
283
help="Select all clients")
356
284
parser.add_argument("-v", "--verbose", action="store_true",
357
285
help="Print all fields")
358
parser.add_argument("-j", "--dump-json", action="store_true",
359
help="Dump client data in JSON format")
360
286
parser.add_argument("-e", "--enable", action="store_true",
361
287
help="Enable client")
362
288
parser.add_argument("-d", "--disable", action="store_true",
401
327
help="Run self-test")
402
328
parser.add_argument("client", nargs="*", help="Client name")
403
329
options = parser.parse_args()
405
331
if has_actions(options) and not (options.client or options.all):
406
332
parser.error("Options require clients names or --all.")
407
333
if options.verbose and has_actions(options):
408
parser.error("--verbose can only be used alone.")
409
if options.dump_json and (options.verbose
410
or has_actions(options)):
411
parser.error("--dump-json can only be used alone.")
334
parser.error("--verbose can only be used alone or with"
412
336
if options.all and not has_actions(options):
413
337
parser.error("--all requires an action.")
340
fail_count, test_count = doctest.testmod()
341
sys.exit(os.EX_OK if fail_count == 0 else 1)
416
344
bus = dbus.SystemBus()
417
345
mandos_dbus_objc = bus.get_object(busname, server_path)
418
346
except dbus.exceptions.DBusException:
419
log.critical("Could not connect to Mandos server")
347
print("Could not connect to Mandos server",
422
351
mandos_serv = dbus.Interface(mandos_dbus_objc,
423
dbus_interface=server_interface)
424
mandos_serv_object_manager = dbus.Interface(
425
mandos_dbus_objc, dbus_interface=dbus.OBJECT_MANAGER_IFACE)
427
# block stderr since dbus library prints to stderr
352
dbus_interface = server_interface)
354
#block stderr since dbus library prints to stderr
428
355
null = os.open(os.path.devnull, os.O_RDWR)
429
356
stderrcopy = os.dup(sys.stderr.fileno())
430
357
os.dup2(null, sys.stderr.fileno())
434
mandos_clients = {path: ifs_and_props[client_interface]
435
for path, ifs_and_props in
436
mandos_serv_object_manager
437
.GetManagedObjects().items()
438
if client_interface in ifs_and_props}
361
mandos_clients = mandos_serv.GetAllClientsWithProperties()
441
364
os.dup2(stderrcopy, sys.stderr.fileno())
442
365
os.close(stderrcopy)
443
except dbus.exceptions.DBusException as e:
444
log.critical("Failed to access Mandos server through D-Bus:"
366
except dbus.exceptions.DBusException:
367
print("Access denied: Accessing mandos server through dbus.",
448
371
# Compile dict of (clients: properties) to process
451
374
if options.all or not options.client:
452
clients = {bus.get_object(busname, path): properties
453
for path, properties in mandos_clients.items()}
375
clients = dict((bus.get_object(busname, path), properties)
376
for path, properties in
377
mandos_clients.items())
455
379
for name in options.client:
456
for path, client in mandos_clients.items():
380
for path, client in mandos_clients.iteritems():
457
381
if client["Name"] == name:
458
382
client_objc = bus.get_object(busname, path)
459
383
clients[client_objc] = client
462
log.critical("Client not found on server: %r", name)
386
print("Client not found on server: {0!r}"
387
.format(name), file=sys.stderr)
465
390
if not has_actions(options) and clients:
466
if options.verbose or options.dump_json:
467
keywords = ("Name", "Enabled", "Timeout", "LastCheckedOK",
468
"Created", "Interval", "Host", "KeyID",
469
"Fingerprint", "CheckerRunning",
392
keywords = ("Name", "Enabled", "Timeout",
393
"LastCheckedOK", "Created", "Interval",
394
"Host", "Fingerprint", "CheckerRunning",
470
395
"LastEnabled", "ApprovalPending",
471
"ApprovedByDefault", "LastApprovalRequest",
472
"ApprovalDelay", "ApprovalDuration",
473
"Checker", "ExtendedTimeout", "Expires",
397
"LastApprovalRequest", "ApprovalDelay",
398
"ApprovalDuration", "Checker",
476
401
keywords = defaultkeywords
478
if options.dump_json:
479
json.dump({client["Name"]: {key:
481
if isinstance(client[key],
485
for client in clients.values()},
486
fp=sys.stdout, indent=4,
487
separators=(',', ': '))
490
print_clients(clients.values(), keywords)
403
print_clients(clients.values(), keywords)
492
405
# Process each client in the list by all selected options
493
406
for client in clients:
495
407
def set_client_prop(prop, value):
496
408
"""Set a Client D-Bus property"""
497
409
client.Set(client_interface, prop, value,
498
410
dbus_interface=dbus.PROPERTIES_IFACE)
500
411
def set_client_prop_ms(prop, value):
501
412
"""Set a Client D-Bus property, converted
502
413
from a string to milliseconds."""
503
414
set_client_prop(prop,
504
string_to_delta(value).total_seconds()
415
timedelta_to_milliseconds
416
(string_to_delta(value)))
507
417
if options.remove:
508
418
mandos_serv.RemoveClient(client.__dbus_object_path__)
509
419
if options.enable:
553
463
client.Approve(dbus.Boolean(False),
554
464
dbus_interface=client_interface)
557
class Test_milliseconds_to_string(unittest.TestCase):
559
self.assertEqual(milliseconds_to_string(93785000),
561
def test_no_days(self):
562
self.assertEqual(milliseconds_to_string(7385000), "02:03:05")
563
def test_all_zero(self):
564
self.assertEqual(milliseconds_to_string(0), "00:00:00")
565
def test_no_fractional_seconds(self):
566
self.assertEqual(milliseconds_to_string(400), "00:00:00")
567
self.assertEqual(milliseconds_to_string(900), "00:00:00")
568
self.assertEqual(milliseconds_to_string(1900), "00:00:01")
570
class Test_string_to_delta(unittest.TestCase):
571
def test_handles_basic_rfc3339(self):
572
self.assertEqual(string_to_delta("PT2H"),
573
datetime.timedelta(0, 7200))
574
def test_falls_back_to_pre_1_6_1_with_warning(self):
575
# assertLogs only exists in Python 3.4
576
if hasattr(self, "assertLogs"):
577
with self.assertLogs(log, logging.WARNING):
578
value = string_to_delta("2h")
580
value = string_to_delta("2h")
581
self.assertEqual(value, datetime.timedelta(0, 7200))
583
class Test_TableOfClients(unittest.TestCase):
586
self.old_tablewords = tablewords
591
"Bool": "A D-BUS Boolean",
592
"NonDbusBoolean": "A Non-D-BUS Boolean",
593
"Integer": "An Integer",
594
"Timeout": "Timedelta 1",
595
"Interval": "Timedelta 2",
596
"ApprovalDelay": "Timedelta 3",
597
"ApprovalDuration": "Timedelta 4",
598
"ExtendedTimeout": "Timedelta 5",
599
"String": "A String",
601
self.keywords = ["Attr1", "AttrTwo"]
607
"Bool": dbus.Boolean(False),
608
"NonDbusBoolean": False,
612
"ApprovalDelay": 2000,
613
"ApprovalDuration": 3000,
614
"ExtendedTimeout": 4000,
621
"Bool": dbus.Boolean(True),
622
"NonDbusBoolean": True,
625
"Interval": 93786000,
626
"ApprovalDelay": 93787000,
627
"ApprovalDuration": 93788000,
628
"ExtendedTimeout": 93789000,
629
"String": "A huge string which will not fit," * 10,
634
tablewords = self.old_tablewords
635
def test_short_header(self):
636
rows = TableOfClients(self.clients, self.keywords).rows()
641
self.assertEqual(rows, expected_rows)
642
def test_booleans(self):
643
keywords = ["Bool", "NonDbusBoolean"]
644
rows = TableOfClients(self.clients, keywords).rows()
646
"A D-BUS Boolean A Non-D-BUS Boolean",
650
self.assertEqual(rows, expected_rows)
651
def test_milliseconds_detection(self):
652
keywords = ["Integer", "Timeout", "Interval", "ApprovalDelay",
653
"ApprovalDuration", "ExtendedTimeout"]
654
rows = TableOfClients(self.clients, keywords).rows()
656
An Integer Timedelta 1 Timedelta 2 Timedelta 3 Timedelta 4 Timedelta 5
657
0 00:00:00 00:00:01 00:00:02 00:00:03 00:00:04
658
1 1T02:03:05 1T02:03:06 1T02:03:07 1T02:03:08 1T02:03:09
661
self.assertEqual(rows, expected_rows)
662
def test_empty_and_long_string_values(self):
663
keywords = ["String"]
664
rows = TableOfClients(self.clients, keywords).rows()
668
A huge string which will not fit,A huge string which will not fit,A huge string which will not fit,A huge string which will not fit,A huge string which will not fit,A huge string which will not fit,A huge string which will not fit,A huge string which will not fit,A huge string which will not fit,A huge string which will not fit,
671
self.assertEqual(rows, expected_rows)
675
def should_only_run_tests():
676
parser = argparse.ArgumentParser(add_help=False)
677
parser.add_argument("--check", action='store_true')
678
args, unknown_args = parser.parse_known_args()
679
run_tests = args.check
681
# Remove --check argument from sys.argv
682
sys.argv[1:] = unknown_args
685
# Add all tests from doctest strings
686
def load_tests(loader, tests, none):
688
tests.addTests(doctest.DocTestSuite())
691
466
if __name__ == "__main__":
692
if should_only_run_tests():
693
# Call using ./tdd-python-script --check [--verbose]