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-2015 Teddy Hogeborn
7
# Copyright © 2008-2015 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,
48
# Show warnings by default
49
if not sys.warnoptions:
51
warnings.simplefilter("default")
53
log = logging.getLogger(sys.argv[0])
54
logging.basicConfig(level="INFO", # Show info level messages
55
format="%(message)s") # Show basic log messages
57
logging.captureWarnings(True) # Show warnings via the logging system
59
45
if sys.version_info.major == 2:
62
48
locale.setlocale(locale.LC_ALL, "")
54
"LastCheckedOK": "Last Successful Check",
55
"LastApprovalRequest": "Last Approval Request",
57
"Interval": "Interval",
59
"Fingerprint": "Fingerprint",
60
"CheckerRunning": "Check Is Running",
61
"LastEnabled": "Last Enabled",
62
"ApprovalPending": "Approval Is Pending",
63
"ApprovedByDefault": "Approved By Default",
64
"ApprovalDelay": "Approval Delay",
65
"ApprovalDuration": "Approval Duration",
67
"ExtendedTimeout": "Extended Timeout"
64
69
defaultkeywords = ("Name", "Enabled", "Timeout", "LastCheckedOK")
65
70
domain = "se.recompile"
66
71
busname = domain + ".Mandos"
68
73
server_interface = domain + ".Mandos"
69
74
client_interface = domain + ".Mandos.Client"
74
dbus.OBJECT_MANAGER_IFACE
75
except AttributeError:
76
dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"
79
78
def milliseconds_to_string(ms):
80
79
td = datetime.timedelta(0, 0, 0, ms)
81
return ("{days}{hours:02}:{minutes:02}:{seconds:02}"
82
.format(days="{}T".format(td.days) if td.days else "",
83
hours=td.seconds // 3600,
84
minutes=(td.seconds % 3600) // 60,
85
seconds=td.seconds % 60))
80
return ("{days}{hours:02}:{minutes:02}:{seconds:02}".format(
81
days = "{}T".format(td.days) if td.days else "",
82
hours = td.seconds // 3600,
83
minutes = (td.seconds % 3600) // 60,
84
seconds = td.seconds % 60))
88
87
def rfc3339_duration_to_delta(duration):
89
88
"""Parse an RFC 3339 "duration" and return a datetime.timedelta
91
90
>>> rfc3339_duration_to_delta("P7D")
92
91
datetime.timedelta(7)
93
92
>>> rfc3339_duration_to_delta("PT60S")
94
93
datetime.timedelta(0, 60)
95
94
>>> rfc3339_duration_to_delta("PT60M")
96
95
datetime.timedelta(0, 3600)
97
>>> rfc3339_duration_to_delta("P60M")
98
datetime.timedelta(1680)
99
96
>>> rfc3339_duration_to_delta("PT24H")
100
97
datetime.timedelta(1)
101
98
>>> rfc3339_duration_to_delta("P1W")
104
101
datetime.timedelta(0, 330)
105
102
>>> rfc3339_duration_to_delta("P1DT3M20S")
106
103
datetime.timedelta(1, 200)
107
>>> # Can not be empty:
108
>>> rfc3339_duration_to_delta("")
109
Traceback (most recent call last):
111
ValueError: Invalid RFC 3339 duration: u''
112
>>> # Must start with "P":
113
>>> rfc3339_duration_to_delta("1D")
114
Traceback (most recent call last):
116
ValueError: Invalid RFC 3339 duration: u'1D'
117
>>> # Must use correct order
118
>>> rfc3339_duration_to_delta("PT1S2M")
119
Traceback (most recent call last):
121
ValueError: Invalid RFC 3339 duration: u'PT1S2M'
122
>>> # Time needs time marker
123
>>> rfc3339_duration_to_delta("P1H2S")
124
Traceback (most recent call last):
126
ValueError: Invalid RFC 3339 duration: u'P1H2S'
127
>>> # Weeks can not be combined with anything else
128
>>> rfc3339_duration_to_delta("P1D2W")
129
Traceback (most recent call last):
131
ValueError: Invalid RFC 3339 duration: u'P1D2W'
132
>>> rfc3339_duration_to_delta("P2W2H")
133
Traceback (most recent call last):
135
ValueError: Invalid RFC 3339 duration: u'P2W2H'
138
106
# Parsing an RFC 3339 duration with regular expressions is not
139
107
# possible - there would have to be multiple places for the same
140
108
# values, like seconds. The current code, while more esoteric, is
141
109
# cleaner without depending on a parsing library. If Python had a
142
110
# built-in library for parsing we would use it, but we'd like to
143
111
# avoid excessive use of external libraries.
145
113
# New type for defining tokens, syntax, and semantics all-in-one
146
114
Token = collections.namedtuple("Token", (
147
115
"regexp", # To match token; if "value" is not None, must have
218
183
def string_to_delta(interval):
219
184
"""Parse a string and return a datetime.timedelta
186
>>> string_to_delta('7d')
187
datetime.timedelta(7)
188
>>> string_to_delta('60s')
189
datetime.timedelta(0, 60)
190
>>> string_to_delta('60m')
191
datetime.timedelta(0, 3600)
192
>>> string_to_delta('24h')
193
datetime.timedelta(1)
194
>>> string_to_delta('1w')
195
datetime.timedelta(7)
196
>>> string_to_delta('5m 30s')
197
datetime.timedelta(0, 330)
223
201
return rfc3339_duration_to_delta(interval)
224
except ValueError as e:
225
log.warning("%s - Parsing as pre-1.6.1 interval instead",
227
return parse_pre_1_6_1_interval(interval)
230
def parse_pre_1_6_1_interval(interval):
231
"""Parse an interval string as documented by Mandos before 1.6.1, and
232
return a datetime.timedelta
233
>>> parse_pre_1_6_1_interval('7d')
234
datetime.timedelta(7)
235
>>> parse_pre_1_6_1_interval('60s')
236
datetime.timedelta(0, 60)
237
>>> parse_pre_1_6_1_interval('60m')
238
datetime.timedelta(0, 3600)
239
>>> parse_pre_1_6_1_interval('24h')
240
datetime.timedelta(1)
241
>>> parse_pre_1_6_1_interval('1w')
242
datetime.timedelta(7)
243
>>> parse_pre_1_6_1_interval('5m 30s')
244
datetime.timedelta(0, 330)
245
>>> parse_pre_1_6_1_interval('')
246
datetime.timedelta(0)
247
>>> # Ignore unknown characters, allow any order and repetitions
248
>>> parse_pre_1_6_1_interval('2dxy7zz11y3m5m')
249
datetime.timedelta(2, 480, 18000)
253
205
value = datetime.timedelta(0)
254
206
regexp = re.compile(r"(\d+)([dsmhw]?)")
256
208
for num, suffix in regexp.findall(interval):
257
209
if suffix == "d":
258
210
value += datetime.timedelta(int(num))
272
class TableOfClients(object):
275
"Enabled": "Enabled",
276
"Timeout": "Timeout",
277
"LastCheckedOK": "Last Successful Check",
278
"LastApprovalRequest": "Last Approval Request",
279
"Created": "Created",
280
"Interval": "Interval",
282
"Fingerprint": "Fingerprint",
284
"CheckerRunning": "Check Is Running",
285
"LastEnabled": "Last Enabled",
286
"ApprovalPending": "Approval Is Pending",
287
"ApprovedByDefault": "Approved By Default",
288
"ApprovalDelay": "Approval Delay",
289
"ApprovalDuration": "Approval Duration",
290
"Checker": "Checker",
291
"ExtendedTimeout": "Extended Timeout",
292
"Expires": "Expires",
293
"LastCheckerStatus": "Last Checker Status",
296
def __init__(self, clients, keywords, tablewords=None):
297
self.clients = clients
298
self.keywords = keywords
299
if tablewords is not None:
300
self.tablewords = tablewords
303
return "\n".join(self.rows())
305
if sys.version_info.major == 2:
306
__unicode__ = __str__
308
return str(self).encode(locale.getpreferredencoding())
311
format_string = self.row_formatting_string()
312
rows = [self.header_line(format_string)]
313
rows.extend(self.client_line(client, format_string)
314
for client in self.clients)
317
def row_formatting_string(self):
318
"Format string used to format table rows"
319
return " ".join("{{{key}:{width}}}".format(
320
width=max(len(self.tablewords[key]),
321
*(len(self.string_from_client(client, key))
322
for client in self.clients)),
324
for key in self.keywords)
326
def string_from_client(self, client, key):
327
return self.valuetostring(client[key], key)
224
def print_clients(clients, keywords):
330
225
def valuetostring(value, keyword):
331
if isinstance(value, dbus.Boolean):
226
if type(value) is dbus.Boolean:
332
227
return "Yes" if value else "No"
333
228
if keyword in ("Timeout", "Interval", "ApprovalDelay",
334
229
"ApprovalDuration", "ExtendedTimeout"):
335
230
return milliseconds_to_string(value)
336
231
return str(value)
338
def header_line(self, format_string):
339
return format_string.format(**self.tablewords)
341
def client_line(self, client, format_string):
342
return format_string.format(
343
**{key: self.string_from_client(client, key)
344
for key in self.keywords})
233
# Create format string to print table rows
234
format_string = " ".join("{{{key}:{width}}}".format(
235
width = max(len(tablewords[key]),
236
max(len(valuetostring(client[key], key))
237
for client in clients)),
241
print(format_string.format(**tablewords))
242
for client in clients:
243
print(format_string.format(**{
244
key: valuetostring(client[key], key)
245
for key in keywords }))
347
248
def has_actions(options):
369
270
parser = argparse.ArgumentParser()
370
271
parser.add_argument("--version", action="version",
371
version="%(prog)s {}".format(version),
272
version = "%(prog)s {}".format(version),
372
273
help="show version number and exit")
373
274
parser.add_argument("-a", "--all", action="store_true",
374
275
help="Select all clients")
375
276
parser.add_argument("-v", "--verbose", action="store_true",
376
277
help="Print all fields")
377
parser.add_argument("-j", "--dump-json", action="store_true",
378
help="Dump client data in JSON format")
379
278
parser.add_argument("-e", "--enable", action="store_true",
380
279
help="Enable client")
381
280
parser.add_argument("-d", "--disable", action="store_true",
420
319
help="Run self-test")
421
320
parser.add_argument("client", nargs="*", help="Client name")
422
321
options = parser.parse_args()
424
323
if has_actions(options) and not (options.client or options.all):
425
324
parser.error("Options require clients names or --all.")
426
325
if options.verbose and has_actions(options):
427
parser.error("--verbose can only be used alone.")
428
if options.dump_json and (options.verbose
429
or has_actions(options)):
430
parser.error("--dump-json can only be used alone.")
326
parser.error("--verbose can only be used alone or with"
431
328
if options.all and not has_actions(options):
432
329
parser.error("--all requires an action.")
332
fail_count, test_count = doctest.testmod()
333
sys.exit(os.EX_OK if fail_count == 0 else 1)
435
336
bus = dbus.SystemBus()
436
337
mandos_dbus_objc = bus.get_object(busname, server_path)
437
338
except dbus.exceptions.DBusException:
438
log.critical("Could not connect to Mandos server")
339
print("Could not connect to Mandos server", file=sys.stderr)
441
342
mandos_serv = dbus.Interface(mandos_dbus_objc,
442
dbus_interface=server_interface)
443
mandos_serv_object_manager = dbus.Interface(
444
mandos_dbus_objc, dbus_interface=dbus.OBJECT_MANAGER_IFACE)
446
# block stderr since dbus library prints to stderr
343
dbus_interface = server_interface)
345
#block stderr since dbus library prints to stderr
447
346
null = os.open(os.path.devnull, os.O_RDWR)
448
347
stderrcopy = os.dup(sys.stderr.fileno())
449
348
os.dup2(null, sys.stderr.fileno())
453
mandos_clients = {path: ifs_and_props[client_interface]
454
for path, ifs_and_props in
455
mandos_serv_object_manager
456
.GetManagedObjects().items()
457
if client_interface in ifs_and_props}
352
mandos_clients = mandos_serv.GetAllClientsWithProperties()
460
355
os.dup2(stderrcopy, sys.stderr.fileno())
461
356
os.close(stderrcopy)
462
except dbus.exceptions.DBusException as e:
463
log.critical("Failed to access Mandos server through D-Bus:"
357
except dbus.exceptions.DBusException:
358
print("Access denied: Accessing mandos server through dbus.",
467
362
# Compile dict of (clients: properties) to process
470
365
if options.all or not options.client:
471
clients = {bus.get_object(busname, path): properties
472
for path, properties in mandos_clients.items()}
366
clients = { bus.get_object(busname, path): properties
367
for path, properties in mandos_clients.items() }
474
369
for name in options.client:
475
370
for path, client in mandos_clients.items():
478
373
clients[client_objc] = client
481
log.critical("Client not found on server: %r", name)
376
print("Client not found on server: {!r}"
377
.format(name), file=sys.stderr)
484
380
if not has_actions(options) and clients:
485
if options.verbose or options.dump_json:
486
382
keywords = ("Name", "Enabled", "Timeout", "LastCheckedOK",
487
"Created", "Interval", "Host", "KeyID",
488
"Fingerprint", "CheckerRunning",
489
"LastEnabled", "ApprovalPending",
490
"ApprovedByDefault", "LastApprovalRequest",
491
"ApprovalDelay", "ApprovalDuration",
492
"Checker", "ExtendedTimeout", "Expires",
383
"Created", "Interval", "Host", "Fingerprint",
384
"CheckerRunning", "LastEnabled",
385
"ApprovalPending", "ApprovedByDefault",
386
"LastApprovalRequest", "ApprovalDelay",
387
"ApprovalDuration", "Checker",
495
390
keywords = defaultkeywords
497
if options.dump_json:
498
json.dump({client["Name"]: {key:
500
if isinstance(client[key],
504
for client in clients.values()},
505
fp=sys.stdout, indent=4,
506
separators=(',', ': '))
509
print(TableOfClients(clients.values(), keywords))
392
print_clients(clients.values(), keywords)
511
394
# Process each client in the list by all selected options
512
395
for client in clients:
514
397
def set_client_prop(prop, value):
515
398
"""Set a Client D-Bus property"""
516
399
client.Set(client_interface, prop, value,
517
400
dbus_interface=dbus.PROPERTIES_IFACE)
519
402
def set_client_prop_ms(prop, value):
520
403
"""Set a Client D-Bus property, converted
521
404
from a string to milliseconds."""
522
405
set_client_prop(prop,
523
406
string_to_delta(value).total_seconds()
526
409
if options.remove:
527
410
mandos_serv.RemoveClient(client.__dbus_object_path__)
528
411
if options.enable:
572
455
client.Approve(dbus.Boolean(False),
573
456
dbus_interface=client_interface)
576
class Test_milliseconds_to_string(unittest.TestCase):
578
self.assertEqual(milliseconds_to_string(93785000),
580
def test_no_days(self):
581
self.assertEqual(milliseconds_to_string(7385000), "02:03:05")
582
def test_all_zero(self):
583
self.assertEqual(milliseconds_to_string(0), "00:00:00")
584
def test_no_fractional_seconds(self):
585
self.assertEqual(milliseconds_to_string(400), "00:00:00")
586
self.assertEqual(milliseconds_to_string(900), "00:00:00")
587
self.assertEqual(milliseconds_to_string(1900), "00:00:01")
589
class Test_string_to_delta(unittest.TestCase):
590
def test_handles_basic_rfc3339(self):
591
self.assertEqual(string_to_delta("PT2H"),
592
datetime.timedelta(0, 7200))
593
def test_falls_back_to_pre_1_6_1_with_warning(self):
594
# assertLogs only exists in Python 3.4
595
if hasattr(self, "assertLogs"):
596
with self.assertLogs(log, logging.WARNING):
597
value = string_to_delta("2h")
599
value = string_to_delta("2h")
600
self.assertEqual(value, datetime.timedelta(0, 7200))
602
class Test_TableOfClients(unittest.TestCase):
608
"Bool": "A D-BUS Boolean",
609
"NonDbusBoolean": "A Non-D-BUS Boolean",
610
"Integer": "An Integer",
611
"Timeout": "Timedelta 1",
612
"Interval": "Timedelta 2",
613
"ApprovalDelay": "Timedelta 3",
614
"ApprovalDuration": "Timedelta 4",
615
"ExtendedTimeout": "Timedelta 5",
616
"String": "A String",
618
self.keywords = ["Attr1", "AttrTwo"]
624
"Bool": dbus.Boolean(False),
625
"NonDbusBoolean": False,
629
"ApprovalDelay": 2000,
630
"ApprovalDuration": 3000,
631
"ExtendedTimeout": 4000,
638
"Bool": dbus.Boolean(True),
639
"NonDbusBoolean": True,
642
"Interval": 93786000,
643
"ApprovalDelay": 93787000,
644
"ApprovalDuration": 93788000,
645
"ExtendedTimeout": 93789000,
646
"String": "A huge string which will not fit," * 10,
649
def test_short_header(self):
650
text = str(TableOfClients(self.clients, self.keywords,
657
self.assertEqual(text, expected_text)
658
def test_booleans(self):
659
keywords = ["Bool", "NonDbusBoolean"]
660
text = str(TableOfClients(self.clients, keywords,
663
A D-BUS Boolean A Non-D-BUS Boolean
667
self.assertEqual(text, expected_text)
668
def test_milliseconds_detection(self):
669
keywords = ["Integer", "Timeout", "Interval", "ApprovalDelay",
670
"ApprovalDuration", "ExtendedTimeout"]
671
text = str(TableOfClients(self.clients, keywords,
674
An Integer Timedelta 1 Timedelta 2 Timedelta 3 Timedelta 4 Timedelta 5
675
0 00:00:00 00:00:01 00:00:02 00:00:03 00:00:04
676
1 1T02:03:05 1T02:03:06 1T02:03:07 1T02:03:08 1T02:03:09
678
self.assertEqual(text, expected_text)
679
def test_empty_and_long_string_values(self):
680
keywords = ["String"]
681
text = str(TableOfClients(self.clients, keywords,
686
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,
688
self.assertEqual(text, expected_text)
692
def should_only_run_tests():
693
parser = argparse.ArgumentParser(add_help=False)
694
parser.add_argument("--check", action='store_true')
695
args, unknown_args = parser.parse_known_args()
696
run_tests = args.check
698
# Remove --check argument from sys.argv
699
sys.argv[1:] = unknown_args
702
# Add all tests from doctest strings
703
def load_tests(loader, tests, none):
705
tests.addTests(doctest.DocTestSuite())
708
459
if __name__ == "__main__":
709
if should_only_run_tests():
710
# Call using ./tdd-python-script --check [--verbose]