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-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
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,
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
45
59
if sys.version_info.major == 2:
48
62
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"
69
64
defaultkeywords = ("Name", "Enabled", "Timeout", "LastCheckedOK")
70
65
domain = "se.recompile"
71
66
busname = domain + ".Mandos"
73
68
server_interface = domain + ".Mandos"
74
69
client_interface = domain + ".Mandos.Client"
74
dbus.OBJECT_MANAGER_IFACE
75
except AttributeError:
76
dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"
78
79
def milliseconds_to_string(ms):
79
80
td = datetime.timedelta(0, 0, 0, ms)
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))
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))
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
146
Token = collections.namedtuple("Token", (
115
147
"regexp", # To match token; if "value" is not None, must have
183
218
def string_to_delta(interval):
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)
219
"""Parse a string and return a datetime.timedelta"""
201
222
return rfc3339_duration_to_delta(interval)
223
except ValueError as e:
224
log.warning("%s - Parsing as pre-1.6.1 interval instead",
226
return parse_pre_1_6_1_interval(interval)
229
def parse_pre_1_6_1_interval(interval):
230
"""Parse an interval string as documented by Mandos before 1.6.1,
231
and 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)
205
253
value = datetime.timedelta(0)
206
254
regexp = re.compile(r"(\d+)([dsmhw]?)")
208
256
for num, suffix in regexp.findall(interval):
209
257
if suffix == "d":
210
258
value += datetime.timedelta(int(num))
224
def print_clients(clients, keywords):
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)
225
330
def valuetostring(value, keyword):
226
if type(value) is dbus.Boolean:
331
if isinstance(value, dbus.Boolean):
227
332
return "Yes" if value else "No"
228
333
if keyword in ("Timeout", "Interval", "ApprovalDelay",
229
334
"ApprovalDuration", "ExtendedTimeout"):
230
335
return milliseconds_to_string(value)
231
336
return str(value)
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 }))
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})
248
347
def has_actions(options):
270
369
parser = argparse.ArgumentParser()
271
370
parser.add_argument("--version", action="version",
272
version = "%(prog)s {}".format(version),
371
version="%(prog)s {}".format(version),
273
372
help="show version number and exit")
274
373
parser.add_argument("-a", "--all", action="store_true",
275
374
help="Select all clients")
276
375
parser.add_argument("-v", "--verbose", action="store_true",
277
376
help="Print all fields")
278
parser.add_argument("-e", "--enable", action="store_true",
279
help="Enable client")
280
parser.add_argument("-d", "--disable", action="store_true",
281
help="disable client")
377
parser.add_argument("-j", "--dump-json", action="store_true",
378
help="Dump client data in JSON format")
379
enable_disable = parser.add_mutually_exclusive_group()
380
enable_disable.add_argument("-e", "--enable", action="store_true",
381
help="Enable client")
382
enable_disable.add_argument("-d", "--disable",
384
help="disable client")
282
385
parser.add_argument("-b", "--bump-timeout", action="store_true",
283
386
help="Bump timeout for client")
284
parser.add_argument("--start-checker", action="store_true",
285
help="Start checker for client")
286
parser.add_argument("--stop-checker", action="store_true",
287
help="Stop checker for client")
387
start_stop_checker = parser.add_mutually_exclusive_group()
388
start_stop_checker.add_argument("--start-checker",
390
help="Start checker for client")
391
start_stop_checker.add_argument("--stop-checker",
393
help="Stop checker for client")
288
394
parser.add_argument("-V", "--is-enabled", action="store_true",
289
395
help="Check if client is enabled")
290
396
parser.add_argument("-r", "--remove", action="store_true",
297
403
help="Set extended timeout for client")
298
404
parser.add_argument("-i", "--interval",
299
405
help="Set checker interval for client")
300
parser.add_argument("--approve-by-default", action="store_true",
301
default=None, dest="approved_by_default",
302
help="Set client to be approved by default")
303
parser.add_argument("--deny-by-default", action="store_false",
304
dest="approved_by_default",
305
help="Set client to be denied by default")
406
approve_deny_default = parser.add_mutually_exclusive_group()
407
approve_deny_default.add_argument(
408
"--approve-by-default", action="store_true",
409
default=None, dest="approved_by_default",
410
help="Set client to be approved by default")
411
approve_deny_default.add_argument(
412
"--deny-by-default", action="store_false",
413
dest="approved_by_default",
414
help="Set client to be denied by default")
306
415
parser.add_argument("--approval-delay",
307
416
help="Set delay before client approve/deny")
308
417
parser.add_argument("--approval-duration",
311
420
parser.add_argument("-s", "--secret",
312
421
type=argparse.FileType(mode="rb"),
313
422
help="Set password blob (file) for client")
314
parser.add_argument("-A", "--approve", action="store_true",
315
help="Approve any current client request")
316
parser.add_argument("-D", "--deny", action="store_true",
317
help="Deny any current client request")
423
approve_deny = parser.add_mutually_exclusive_group()
424
approve_deny.add_argument(
425
"-A", "--approve", action="store_true",
426
help="Approve any current client request")
427
approve_deny.add_argument("-D", "--deny", action="store_true",
428
help="Deny any current client request")
318
429
parser.add_argument("--check", action="store_true",
319
430
help="Run self-test")
320
431
parser.add_argument("client", nargs="*", help="Client name")
321
432
options = parser.parse_args()
323
434
if has_actions(options) and not (options.client or options.all):
324
435
parser.error("Options require clients names or --all.")
325
436
if options.verbose and has_actions(options):
326
parser.error("--verbose can only be used alone or with"
437
parser.error("--verbose can only be used alone.")
438
if options.dump_json and (options.verbose
439
or has_actions(options)):
440
parser.error("--dump-json can only be used alone.")
328
441
if options.all and not has_actions(options):
329
442
parser.error("--all requires an action.")
443
if options.is_enabled and len(options.client) > 1:
444
parser.error("--is-enabled requires exactly one client")
332
fail_count, test_count = doctest.testmod()
333
sys.exit(os.EX_OK if fail_count == 0 else 1)
336
447
bus = dbus.SystemBus()
337
448
mandos_dbus_objc = bus.get_object(busname, server_path)
338
449
except dbus.exceptions.DBusException:
339
print("Could not connect to Mandos server", file=sys.stderr)
450
log.critical("Could not connect to Mandos server")
342
453
mandos_serv = dbus.Interface(mandos_dbus_objc,
343
dbus_interface = server_interface)
345
#block stderr since dbus library prints to stderr
454
dbus_interface=server_interface)
455
mandos_serv_object_manager = dbus.Interface(
456
mandos_dbus_objc, dbus_interface=dbus.OBJECT_MANAGER_IFACE)
458
# block stderr since dbus library prints to stderr
346
459
null = os.open(os.path.devnull, os.O_RDWR)
347
460
stderrcopy = os.dup(sys.stderr.fileno())
348
461
os.dup2(null, sys.stderr.fileno())
352
mandos_clients = mandos_serv.GetAllClientsWithProperties()
465
mandos_clients = {path: ifs_and_props[client_interface]
466
for path, ifs_and_props in
467
mandos_serv_object_manager
468
.GetManagedObjects().items()
469
if client_interface in ifs_and_props}
355
472
os.dup2(stderrcopy, sys.stderr.fileno())
356
473
os.close(stderrcopy)
357
except dbus.exceptions.DBusException:
358
print("Access denied: Accessing mandos server through dbus.",
474
except dbus.exceptions.DBusException as e:
475
log.critical("Failed to access Mandos server through D-Bus:"
362
479
# Compile dict of (clients: properties) to process
365
482
if options.all or not options.client:
366
clients = { bus.get_object(busname, path): properties
367
for path, properties in mandos_clients.items() }
483
clients = {bus.get_object(busname, path): properties
484
for path, properties in mandos_clients.items()}
369
486
for name in options.client:
370
487
for path, client in mandos_clients.items():
373
490
clients[client_objc] = client
376
print("Client not found on server: {!r}"
377
.format(name), file=sys.stderr)
493
log.critical("Client not found on server: %r", name)
380
496
if not has_actions(options) and clients:
497
if options.verbose or options.dump_json:
382
498
keywords = ("Name", "Enabled", "Timeout", "LastCheckedOK",
383
"Created", "Interval", "Host", "Fingerprint",
384
"CheckerRunning", "LastEnabled",
385
"ApprovalPending", "ApprovedByDefault",
386
"LastApprovalRequest", "ApprovalDelay",
387
"ApprovalDuration", "Checker",
499
"Created", "Interval", "Host", "KeyID",
500
"Fingerprint", "CheckerRunning",
501
"LastEnabled", "ApprovalPending",
502
"ApprovedByDefault", "LastApprovalRequest",
503
"ApprovalDelay", "ApprovalDuration",
504
"Checker", "ExtendedTimeout", "Expires",
390
507
keywords = defaultkeywords
392
print_clients(clients.values(), keywords)
509
if options.dump_json:
510
json.dump({client["Name"]: {key:
512
if isinstance(client[key],
516
for client in clients.values()},
517
fp=sys.stdout, indent=4,
518
separators=(',', ': '))
521
print(TableOfClients(clients.values(), keywords))
394
523
# Process each client in the list by all selected options
395
524
for client in clients:
397
526
def set_client_prop(prop, value):
398
527
"""Set a Client D-Bus property"""
399
528
client.Set(client_interface, prop, value,
400
529
dbus_interface=dbus.PROPERTIES_IFACE)
402
531
def set_client_prop_ms(prop, value):
403
532
"""Set a Client D-Bus property, converted
404
533
from a string to milliseconds."""
405
534
set_client_prop(prop,
406
535
string_to_delta(value).total_seconds()
409
538
if options.remove:
410
539
mandos_serv.RemoveClient(client.__dbus_object_path__)
411
540
if options.enable:
455
584
client.Approve(dbus.Boolean(False),
456
585
dbus_interface=client_interface)
588
class Test_milliseconds_to_string(unittest.TestCase):
590
self.assertEqual(milliseconds_to_string(93785000),
592
def test_no_days(self):
593
self.assertEqual(milliseconds_to_string(7385000), "02:03:05")
594
def test_all_zero(self):
595
self.assertEqual(milliseconds_to_string(0), "00:00:00")
596
def test_no_fractional_seconds(self):
597
self.assertEqual(milliseconds_to_string(400), "00:00:00")
598
self.assertEqual(milliseconds_to_string(900), "00:00:00")
599
self.assertEqual(milliseconds_to_string(1900), "00:00:01")
601
class Test_string_to_delta(unittest.TestCase):
602
def test_handles_basic_rfc3339(self):
603
self.assertEqual(string_to_delta("PT2H"),
604
datetime.timedelta(0, 7200))
605
def test_falls_back_to_pre_1_6_1_with_warning(self):
606
# assertLogs only exists in Python 3.4
607
if hasattr(self, "assertLogs"):
608
with self.assertLogs(log, logging.WARNING):
609
value = string_to_delta("2h")
611
value = string_to_delta("2h")
612
self.assertEqual(value, datetime.timedelta(0, 7200))
614
class Test_TableOfClients(unittest.TestCase):
620
"Bool": "A D-BUS Boolean",
621
"NonDbusBoolean": "A Non-D-BUS Boolean",
622
"Integer": "An Integer",
623
"Timeout": "Timedelta 1",
624
"Interval": "Timedelta 2",
625
"ApprovalDelay": "Timedelta 3",
626
"ApprovalDuration": "Timedelta 4",
627
"ExtendedTimeout": "Timedelta 5",
628
"String": "A String",
630
self.keywords = ["Attr1", "AttrTwo"]
636
"Bool": dbus.Boolean(False),
637
"NonDbusBoolean": False,
641
"ApprovalDelay": 2000,
642
"ApprovalDuration": 3000,
643
"ExtendedTimeout": 4000,
650
"Bool": dbus.Boolean(True),
651
"NonDbusBoolean": True,
654
"Interval": 93786000,
655
"ApprovalDelay": 93787000,
656
"ApprovalDuration": 93788000,
657
"ExtendedTimeout": 93789000,
658
"String": "A huge string which will not fit," * 10,
661
def test_short_header(self):
662
text = str(TableOfClients(self.clients, self.keywords,
669
self.assertEqual(text, expected_text)
670
def test_booleans(self):
671
keywords = ["Bool", "NonDbusBoolean"]
672
text = str(TableOfClients(self.clients, keywords,
675
A D-BUS Boolean A Non-D-BUS Boolean
679
self.assertEqual(text, expected_text)
680
def test_milliseconds_detection(self):
681
keywords = ["Integer", "Timeout", "Interval", "ApprovalDelay",
682
"ApprovalDuration", "ExtendedTimeout"]
683
text = str(TableOfClients(self.clients, keywords,
686
An Integer Timedelta 1 Timedelta 2 Timedelta 3 Timedelta 4 Timedelta 5
687
0 00:00:00 00:00:01 00:00:02 00:00:03 00:00:04
688
1 1T02:03:05 1T02:03:06 1T02:03:07 1T02:03:08 1T02:03:09
690
self.assertEqual(text, expected_text)
691
def test_empty_and_long_string_values(self):
692
keywords = ["String"]
693
text = str(TableOfClients(self.clients, keywords,
698
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,
700
self.assertEqual(text, expected_text)
704
def should_only_run_tests():
705
parser = argparse.ArgumentParser(add_help=False)
706
parser.add_argument("--check", action='store_true')
707
args, unknown_args = parser.parse_known_args()
708
run_tests = args.check
710
# Remove --check argument from sys.argv
711
sys.argv[1:] = unknown_args
714
# Add all tests from doctest strings
715
def load_tests(loader, tests, none):
717
tests.addTests(doctest.DocTestSuite())
459
720
if __name__ == "__main__":
721
if should_only_run_tests():
722
# Call using ./tdd-python-script --check [--verbose]