2
# -*- mode: python; coding: utf-8 -*-
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*")))); -*-
4
4
# Mandos Monitor - Control and monitor the Mandos server
6
# Copyright © 2008-2012 Teddy Hogeborn
7
# Copyright © 2008-2012 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
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
11
13
# the Free Software Foundation, either version 3 of the License, or
12
14
# (at your option) any later version.
14
# This program is distributed in the hope that it will be useful,
15
# but WITHOUT ANY WARRANTY; without even the implied warranty of
16
# Mandos is distributed in the hope that it will be useful, but
17
# WITHOUT ANY WARRANTY; without even the implied warranty of
16
18
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17
19
# GNU General Public License for more details.
19
21
# You should have received a copy of the GNU General Public License
20
# along with this program. If not, see
21
# <http://www.gnu.org/licenses/>.
22
# along with Mandos. If not, see <http://www.gnu.org/licenses/>.
23
24
# Contact the authors at <mandos@recompile.se>.
26
27
from __future__ import (division, absolute_import, print_function,
29
from future_builtins import *
31
from future_builtins import *
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
if sys.version_info.major == 2:
42
62
locale.setlocale(locale.LC_ALL, "")
48
"LastCheckedOK": "Last Successful Check",
49
"LastApprovalRequest": "Last Approval Request",
51
"Interval": "Interval",
53
"Fingerprint": "Fingerprint",
54
"CheckerRunning": "Check Is Running",
55
"LastEnabled": "Last Enabled",
56
"ApprovalPending": "Approval Is Pending",
57
"ApprovedByDefault": "Approved By Default",
58
"ApprovalDelay": "Approval Delay",
59
"ApprovalDuration": "Approval Duration",
61
"ExtendedTimeout" : "Extended Timeout"
63
64
defaultkeywords = ("Name", "Enabled", "Timeout", "LastCheckedOK")
64
65
domain = "se.recompile"
65
66
busname = domain + ".Mandos"
67
68
server_interface = domain + ".Mandos"
68
69
client_interface = domain + ".Mandos.Client"
71
def timedelta_to_milliseconds(td):
72
"""Convert a datetime.timedelta object to milliseconds"""
73
return ((td.days * 24 * 60 * 60 * 1000)
75
+ (td.microseconds // 1000))
74
dbus.OBJECT_MANAGER_IFACE
75
except AttributeError:
76
dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"
77
79
def milliseconds_to_string(ms):
78
80
td = datetime.timedelta(0, 0, 0, ms)
79
81
return ("{days}{hours:02}:{minutes:02}:{seconds:02}"
80
.format(days = "{0}T".format(td.days) if td.days else "",
81
hours = td.seconds // 3600,
82
minutes = (td.seconds % 3600) // 60,
83
seconds = td.seconds % 60,
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))
87
88
def rfc3339_duration_to_delta(duration):
88
89
"""Parse an RFC 3339 "duration" and return a datetime.timedelta
90
91
>>> rfc3339_duration_to_delta("P7D")
91
92
datetime.timedelta(7)
92
93
>>> rfc3339_duration_to_delta("PT60S")
93
94
datetime.timedelta(0, 60)
94
95
>>> rfc3339_duration_to_delta("PT60M")
95
96
datetime.timedelta(0, 3600)
97
>>> rfc3339_duration_to_delta("P60M")
98
datetime.timedelta(1680)
96
99
>>> rfc3339_duration_to_delta("PT24H")
97
100
datetime.timedelta(1)
98
101
>>> rfc3339_duration_to_delta("P1W")
101
104
datetime.timedelta(0, 330)
102
105
>>> rfc3339_duration_to_delta("P1DT3M20S")
103
106
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'
106
138
# Parsing an RFC 3339 duration with regular expressions is not
107
139
# possible - there would have to be multiple places for the same
108
140
# values, like seconds. The current code, while more esoteric, is
109
141
# cleaner without depending on a parsing library. If Python had a
110
142
# built-in library for parsing we would use it, but we'd like to
111
143
# avoid excessive use of external libraries.
113
145
# New type for defining tokens, syntax, and semantics all-in-one
114
Token = collections.namedtuple("Token",
115
("regexp", # To match token; if
116
# "value" is not None,
117
# must have a "group"
119
"value", # datetime.timedelta or
121
"followers")) # Tokens valid after
146
Token = collections.namedtuple("Token", (
147
"regexp", # To match token; if "value" is not None, must have
148
# a "group" containing digits
149
"value", # datetime.timedelta or None
150
"followers")) # Tokens valid after this token
123
151
# RFC 3339 "duration" tokens, syntax, and semantics; taken from
124
152
# the "duration" ABNF definition in RFC 3339, Appendix A.
125
153
token_end = Token(re.compile(r"$"), None, frozenset())
126
154
token_second = Token(re.compile(r"(\d+)S"),
127
155
datetime.timedelta(seconds=1),
128
frozenset((token_end,)))
156
frozenset((token_end, )))
129
157
token_minute = Token(re.compile(r"(\d+)M"),
130
158
datetime.timedelta(minutes=1),
131
159
frozenset((token_second, token_end)))
180
211
# No currently valid tokens were found
181
raise ValueError("Invalid RFC 3339 duration")
212
raise ValueError("Invalid RFC 3339 duration: {!r}"
182
214
# End token found
186
218
def string_to_delta(interval):
187
219
"""Parse a string and return a datetime.timedelta
189
>>> string_to_delta("7d")
223
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')
190
234
datetime.timedelta(7)
191
>>> string_to_delta("60s")
235
>>> parse_pre_1_6_1_interval('60s')
192
236
datetime.timedelta(0, 60)
193
>>> string_to_delta("60m")
237
>>> parse_pre_1_6_1_interval('60m')
194
238
datetime.timedelta(0, 3600)
195
>>> string_to_delta("24h")
239
>>> parse_pre_1_6_1_interval('24h')
196
240
datetime.timedelta(1)
197
>>> string_to_delta("1w")
241
>>> parse_pre_1_6_1_interval('1w')
198
242
datetime.timedelta(7)
199
>>> string_to_delta("5m 30s")
243
>>> parse_pre_1_6_1_interval('5m 30s')
200
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)
202
253
value = datetime.timedelta(0)
203
254
regexp = re.compile(r"(\d+)([dsmhw]?)")
206
return rfc3339_duration_to_delta(interval)
210
256
for num, suffix in regexp.findall(interval):
211
257
if suffix == "d":
212
258
value += datetime.timedelta(int(num))
222
268
value += datetime.timedelta(0, 0, 0, int(num))
225
272
def print_clients(clients, keywords):
273
print('\n'.join(TableOfClients(clients, keywords).rows()))
275
class TableOfClients(object):
278
"Enabled": "Enabled",
279
"Timeout": "Timeout",
280
"LastCheckedOK": "Last Successful Check",
281
"LastApprovalRequest": "Last Approval Request",
282
"Created": "Created",
283
"Interval": "Interval",
285
"Fingerprint": "Fingerprint",
287
"CheckerRunning": "Check Is Running",
288
"LastEnabled": "Last Enabled",
289
"ApprovalPending": "Approval Is Pending",
290
"ApprovedByDefault": "Approved By Default",
291
"ApprovalDelay": "Approval Delay",
292
"ApprovalDuration": "Approval Duration",
293
"Checker": "Checker",
294
"ExtendedTimeout": "Extended Timeout",
295
"Expires": "Expires",
296
"LastCheckerStatus": "Last Checker Status",
299
def __init__(self, clients, keywords, tablewords=None):
300
self.clients = clients
301
self.keywords = keywords
302
if tablewords is not None:
303
self.tablewords = tablewords
306
format_string = self.row_formatting_string()
307
rows = [self.header_line(format_string)]
308
rows.extend(self.client_line(client, format_string)
309
for client in self.clients)
312
def row_formatting_string(self):
313
"Format string used to format table rows"
314
return " ".join("{{{key}:{width}}}".format(
315
width=max(len(self.tablewords[key]),
316
max(len(self.string_from_client(client, key))
317
for client in self.clients)),
319
for key in self.keywords)
321
def string_from_client(self, client, key):
322
return self.valuetostring(client[key], key)
226
325
def valuetostring(value, keyword):
227
if type(value) is dbus.Boolean:
326
if isinstance(value, dbus.Boolean):
228
327
return "Yes" if value else "No"
229
328
if keyword in ("Timeout", "Interval", "ApprovalDelay",
230
329
"ApprovalDuration", "ExtendedTimeout"):
231
330
return milliseconds_to_string(value)
232
return unicode(value)
234
# Create format string to print table rows
235
format_string = " ".join("{{{key}:{width}}}".format(
236
width = max(len(tablewords[key]),
237
max(len(valuetostring(client[key],
241
key = key) for key in keywords)
243
print(format_string.format(**tablewords))
244
for client in clients:
245
print(format_string.format(**dict((key,
246
valuetostring(client[key],
248
for key in keywords)))
333
def header_line(self, format_string):
334
return format_string.format(**self.tablewords)
336
def client_line(self, client, format_string):
337
return format_string.format(
338
**{key: self.string_from_client(client, key)
339
for key in self.keywords})
250
342
def has_actions(options):
251
343
return any((options.enable,
271
364
parser = argparse.ArgumentParser()
272
365
parser.add_argument("--version", action="version",
273
version = "%(prog)s {0}".format(version),
366
version="%(prog)s {}".format(version),
274
367
help="show version number and exit")
275
368
parser.add_argument("-a", "--all", action="store_true",
276
369
help="Select all clients")
277
370
parser.add_argument("-v", "--verbose", action="store_true",
278
371
help="Print all fields")
372
parser.add_argument("-j", "--dump-json", action="store_true",
373
help="Dump client data in JSON format")
279
374
parser.add_argument("-e", "--enable", action="store_true",
280
375
help="Enable client")
281
376
parser.add_argument("-d", "--disable", action="store_true",
319
415
help="Run self-test")
320
416
parser.add_argument("client", nargs="*", help="Client name")
321
417
options = parser.parse_args()
323
419
if has_actions(options) and not (options.client or options.all):
324
420
parser.error("Options require clients names or --all.")
325
421
if options.verbose and has_actions(options):
326
parser.error("--verbose can only be used alone or with"
422
parser.error("--verbose can only be used alone.")
423
if options.dump_json and (options.verbose
424
or has_actions(options)):
425
parser.error("--dump-json can only be used alone.")
328
426
if options.all and not has_actions(options):
329
427
parser.error("--all requires an action.")
332
fail_count, test_count = doctest.testmod()
333
sys.exit(0 if fail_count == 0 else 1)
336
430
bus = dbus.SystemBus()
337
431
mandos_dbus_objc = bus.get_object(busname, server_path)
338
432
except dbus.exceptions.DBusException:
339
print("Could not connect to Mandos server",
433
log.critical("Could not connect to Mandos server")
343
436
mandos_serv = dbus.Interface(mandos_dbus_objc,
344
dbus_interface = server_interface)
346
#block stderr since dbus library prints to stderr
437
dbus_interface=server_interface)
438
mandos_serv_object_manager = dbus.Interface(
439
mandos_dbus_objc, dbus_interface=dbus.OBJECT_MANAGER_IFACE)
441
# block stderr since dbus library prints to stderr
347
442
null = os.open(os.path.devnull, os.O_RDWR)
348
443
stderrcopy = os.dup(sys.stderr.fileno())
349
444
os.dup2(null, sys.stderr.fileno())
353
mandos_clients = mandos_serv.GetAllClientsWithProperties()
448
mandos_clients = {path: ifs_and_props[client_interface]
449
for path, ifs_and_props in
450
mandos_serv_object_manager
451
.GetManagedObjects().items()
452
if client_interface in ifs_and_props}
356
455
os.dup2(stderrcopy, sys.stderr.fileno())
357
456
os.close(stderrcopy)
358
except dbus.exceptions.DBusException:
359
print("Access denied: Accessing mandos server through dbus.",
457
except dbus.exceptions.DBusException as e:
458
log.critical("Failed to access Mandos server through D-Bus:"
363
462
# Compile dict of (clients: properties) to process
366
465
if options.all or not options.client:
367
clients = dict((bus.get_object(busname, path), properties)
368
for path, properties in
369
mandos_clients.iteritems())
466
clients = {bus.get_object(busname, path): properties
467
for path, properties in mandos_clients.items()}
371
469
for name in options.client:
372
for path, client in mandos_clients.iteritems():
470
for path, client in mandos_clients.items():
373
471
if client["Name"] == name:
374
472
client_objc = bus.get_object(busname, path)
375
473
clients[client_objc] = client
378
print("Client not found on server: {0!r}"
379
.format(name), file=sys.stderr)
476
log.critical("Client not found on server: %r", name)
382
479
if not has_actions(options) and clients:
384
keywords = ("Name", "Enabled", "Timeout",
385
"LastCheckedOK", "Created", "Interval",
386
"Host", "Fingerprint", "CheckerRunning",
480
if options.verbose or options.dump_json:
481
keywords = ("Name", "Enabled", "Timeout", "LastCheckedOK",
482
"Created", "Interval", "Host", "KeyID",
483
"Fingerprint", "CheckerRunning",
387
484
"LastEnabled", "ApprovalPending",
389
"LastApprovalRequest", "ApprovalDelay",
390
"ApprovalDuration", "Checker",
485
"ApprovedByDefault", "LastApprovalRequest",
486
"ApprovalDelay", "ApprovalDuration",
487
"Checker", "ExtendedTimeout", "Expires",
393
490
keywords = defaultkeywords
395
print_clients(clients.values(), keywords)
492
if options.dump_json:
493
json.dump({client["Name"]: {key:
495
if isinstance(client[key],
499
for client in clients.values()},
500
fp=sys.stdout, indent=4,
501
separators=(',', ': '))
504
print_clients(clients.values(), keywords)
397
506
# Process each client in the list by all selected options
398
507
for client in clients:
399
509
def set_client_prop(prop, value):
400
510
"""Set a Client D-Bus property"""
401
511
client.Set(client_interface, prop, value,
402
512
dbus_interface=dbus.PROPERTIES_IFACE)
403
514
def set_client_prop_ms(prop, value):
404
515
"""Set a Client D-Bus property, converted
405
516
from a string to milliseconds."""
406
517
set_client_prop(prop,
407
timedelta_to_milliseconds
408
(string_to_delta(value)))
518
string_to_delta(value).total_seconds()
409
521
if options.remove:
410
522
mandos_serv.RemoveClient(client.__dbus_object_path__)
411
523
if options.enable:
455
567
client.Approve(dbus.Boolean(False),
456
568
dbus_interface=client_interface)
571
class Test_milliseconds_to_string(unittest.TestCase):
573
self.assertEqual(milliseconds_to_string(93785000),
575
def test_no_days(self):
576
self.assertEqual(milliseconds_to_string(7385000), "02:03:05")
577
def test_all_zero(self):
578
self.assertEqual(milliseconds_to_string(0), "00:00:00")
579
def test_no_fractional_seconds(self):
580
self.assertEqual(milliseconds_to_string(400), "00:00:00")
581
self.assertEqual(milliseconds_to_string(900), "00:00:00")
582
self.assertEqual(milliseconds_to_string(1900), "00:00:01")
584
class Test_string_to_delta(unittest.TestCase):
585
def test_handles_basic_rfc3339(self):
586
self.assertEqual(string_to_delta("PT2H"),
587
datetime.timedelta(0, 7200))
588
def test_falls_back_to_pre_1_6_1_with_warning(self):
589
# assertLogs only exists in Python 3.4
590
if hasattr(self, "assertLogs"):
591
with self.assertLogs(log, logging.WARNING):
592
value = string_to_delta("2h")
594
value = string_to_delta("2h")
595
self.assertEqual(value, datetime.timedelta(0, 7200))
597
class Test_TableOfClients(unittest.TestCase):
603
"Bool": "A D-BUS Boolean",
604
"NonDbusBoolean": "A Non-D-BUS Boolean",
605
"Integer": "An Integer",
606
"Timeout": "Timedelta 1",
607
"Interval": "Timedelta 2",
608
"ApprovalDelay": "Timedelta 3",
609
"ApprovalDuration": "Timedelta 4",
610
"ExtendedTimeout": "Timedelta 5",
611
"String": "A String",
613
self.keywords = ["Attr1", "AttrTwo"]
619
"Bool": dbus.Boolean(False),
620
"NonDbusBoolean": False,
624
"ApprovalDelay": 2000,
625
"ApprovalDuration": 3000,
626
"ExtendedTimeout": 4000,
633
"Bool": dbus.Boolean(True),
634
"NonDbusBoolean": True,
637
"Interval": 93786000,
638
"ApprovalDelay": 93787000,
639
"ApprovalDuration": 93788000,
640
"ExtendedTimeout": 93789000,
641
"String": "A huge string which will not fit," * 10,
644
def test_short_header(self):
645
rows = TableOfClients(self.clients, self.keywords,
646
self.tablewords).rows()
651
self.assertEqual(rows, expected_rows)
652
def test_booleans(self):
653
keywords = ["Bool", "NonDbusBoolean"]
654
rows = TableOfClients(self.clients, keywords,
655
self.tablewords).rows()
657
"A D-BUS Boolean A Non-D-BUS Boolean",
661
self.assertEqual(rows, expected_rows)
662
def test_milliseconds_detection(self):
663
keywords = ["Integer", "Timeout", "Interval", "ApprovalDelay",
664
"ApprovalDuration", "ExtendedTimeout"]
665
rows = TableOfClients(self.clients, keywords,
666
self.tablewords).rows()
668
An Integer Timedelta 1 Timedelta 2 Timedelta 3 Timedelta 4 Timedelta 5
669
0 00:00:00 00:00:01 00:00:02 00:00:03 00:00:04
670
1 1T02:03:05 1T02:03:06 1T02:03:07 1T02:03:08 1T02:03:09
673
self.assertEqual(rows, expected_rows)
674
def test_empty_and_long_string_values(self):
675
keywords = ["String"]
676
rows = TableOfClients(self.clients, keywords,
677
self.tablewords).rows()
681
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,
684
self.assertEqual(rows, expected_rows)
688
def should_only_run_tests():
689
parser = argparse.ArgumentParser(add_help=False)
690
parser.add_argument("--check", action='store_true')
691
args, unknown_args = parser.parse_known_args()
692
run_tests = args.check
694
# Remove --check argument from sys.argv
695
sys.argv[1:] = unknown_args
698
# Add all tests from doctest strings
699
def load_tests(loader, tests, none):
701
tests.addTests(doctest.DocTestSuite())
458
704
if __name__ == "__main__":
705
if should_only_run_tests():
706
# Call using ./tdd-python-script --check [--verbose]