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-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
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,
64
79
"ApprovalDelay": "Approval Delay",
65
80
"ApprovalDuration": "Approval Duration",
66
81
"Checker": "Checker",
67
"ExtendedTimeout" : "Extended Timeout"
82
"ExtendedTimeout": "Extended Timeout",
84
"LastCheckerStatus": "Last Checker Status",
69
86
defaultkeywords = ("Name", "Enabled", "Timeout", "LastCheckedOK")
70
87
domain = "se.recompile"
71
88
busname = domain + ".Mandos"
73
90
server_interface = domain + ".Mandos"
74
91
client_interface = domain + ".Mandos.Client"
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))
96
dbus.OBJECT_MANAGER_IFACE
97
except AttributeError:
98
dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"
83
101
def milliseconds_to_string(ms):
84
102
td = datetime.timedelta(0, 0, 0, ms)
85
103
return ("{days}{hours:02}:{minutes:02}:{seconds:02}"
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,
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))
93
110
def rfc3339_duration_to_delta(duration):
94
111
"""Parse an RFC 3339 "duration" and return a datetime.timedelta
96
113
>>> rfc3339_duration_to_delta("P7D")
97
114
datetime.timedelta(7)
98
115
>>> rfc3339_duration_to_delta("PT60S")
99
116
datetime.timedelta(0, 60)
100
117
>>> rfc3339_duration_to_delta("PT60M")
101
118
datetime.timedelta(0, 3600)
119
>>> rfc3339_duration_to_delta("P60M")
120
datetime.timedelta(1680)
102
121
>>> rfc3339_duration_to_delta("PT24H")
103
122
datetime.timedelta(1)
104
123
>>> rfc3339_duration_to_delta("P1W")
107
126
datetime.timedelta(0, 330)
108
127
>>> rfc3339_duration_to_delta("P1DT3M20S")
109
128
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'
112
160
# Parsing an RFC 3339 duration with regular expressions is not
113
161
# possible - there would have to be multiple places for the same
114
162
# values, like seconds. The current code, while more esoteric, is
115
163
# cleaner without depending on a parsing library. If Python had a
116
164
# built-in library for parsing we would use it, but we'd like to
117
165
# avoid excessive use of external libraries.
119
167
# New type for defining tokens, syntax, and semantics all-in-one
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
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
129
173
# RFC 3339 "duration" tokens, syntax, and semantics; taken from
130
174
# the "duration" ABNF definition in RFC 3339, Appendix A.
131
175
token_end = Token(re.compile(r"$"), None, frozenset())
132
176
token_second = Token(re.compile(r"(\d+)S"),
133
177
datetime.timedelta(seconds=1),
134
frozenset((token_end,)))
178
frozenset((token_end, )))
135
179
token_minute = Token(re.compile(r"(\d+)M"),
136
180
datetime.timedelta(minutes=1),
137
181
frozenset((token_second, token_end)))
186
233
# No currently valid tokens were found
187
raise ValueError("Invalid RFC 3339 duration")
234
raise ValueError("Invalid RFC 3339 duration: {!r}"
188
236
# End token found
192
240
def string_to_delta(interval):
193
241
"""Parse a string and return a datetime.timedelta
195
>>> string_to_delta("7d")
243
>>> string_to_delta('7d')
196
244
datetime.timedelta(7)
197
>>> string_to_delta("60s")
245
>>> string_to_delta('60s')
198
246
datetime.timedelta(0, 60)
199
>>> string_to_delta("60m")
247
>>> string_to_delta('60m')
200
248
datetime.timedelta(0, 3600)
201
>>> string_to_delta("24h")
249
>>> string_to_delta('24h')
202
250
datetime.timedelta(1)
203
>>> string_to_delta("1w")
251
>>> string_to_delta('1w')
204
252
datetime.timedelta(7)
205
>>> string_to_delta("5m 30s")
253
>>> string_to_delta('5m 30s')
206
254
datetime.timedelta(0, 330)
210
258
return rfc3339_duration_to_delta(interval)
211
259
except ValueError:
214
262
value = datetime.timedelta(0)
215
263
regexp = re.compile(r"(\d+)([dsmhw]?)")
217
265
for num, suffix in regexp.findall(interval):
218
266
if suffix == "d":
219
267
value += datetime.timedelta(int(num))
229
277
value += datetime.timedelta(0, 0, 0, int(num))
232
281
def print_clients(clients, keywords):
233
282
def valuetostring(value, keyword):
234
if type(value) is dbus.Boolean:
283
if isinstance(value, dbus.Boolean):
235
284
return "Yes" if value else "No"
236
285
if keyword in ("Timeout", "Interval", "ApprovalDelay",
237
286
"ApprovalDuration", "ExtendedTimeout"):
238
287
return milliseconds_to_string(value)
239
288
return str(value)
241
290
# Create format string to print table rows
242
291
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)
292
width=max(len(tablewords[key]),
293
max(len(valuetostring(client[key], key))
294
for client in clients)),
249
297
# Print header line
250
298
print(format_string.format(**tablewords))
251
299
for client in clients:
252
print(format_string.format(**dict((key,
253
valuetostring(client[key],
255
for key in keywords)))
301
.format(**{key: valuetostring(client[key], key)
302
for key in keywords}))
257
305
def has_actions(options):
258
306
return any((options.enable,
278
327
parser = argparse.ArgumentParser()
279
328
parser.add_argument("--version", action="version",
280
version = "%(prog)s {0}".format(version),
329
version="%(prog)s {}".format(version),
281
330
help="show version number and exit")
282
331
parser.add_argument("-a", "--all", action="store_true",
283
332
help="Select all clients")
284
333
parser.add_argument("-v", "--verbose", action="store_true",
285
334
help="Print all fields")
335
parser.add_argument("-j", "--dump-json", action="store_true",
336
help="Dump client data in JSON format")
286
337
parser.add_argument("-e", "--enable", action="store_true",
287
338
help="Enable client")
288
339
parser.add_argument("-d", "--disable", action="store_true",
327
378
help="Run self-test")
328
379
parser.add_argument("client", nargs="*", help="Client name")
329
380
options = parser.parse_args()
331
382
if has_actions(options) and not (options.client or options.all):
332
383
parser.error("Options require clients names or --all.")
333
384
if options.verbose and has_actions(options):
334
parser.error("--verbose can only be used alone or with"
385
parser.error("--verbose can only be used alone.")
386
if options.dump_json and (options.verbose
387
or has_actions(options)):
388
parser.error("--dump-json can only be used alone.")
336
389
if options.all and not has_actions(options):
337
390
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)
344
393
bus = dbus.SystemBus()
345
394
mandos_dbus_objc = bus.get_object(busname, server_path)
346
395
except dbus.exceptions.DBusException:
347
print("Could not connect to Mandos server",
396
log.critical("Could not connect to Mandos server")
351
399
mandos_serv = dbus.Interface(mandos_dbus_objc,
352
dbus_interface = server_interface)
354
#block stderr since dbus library prints to stderr
400
dbus_interface=server_interface)
401
mandos_serv_object_manager = dbus.Interface(
402
mandos_dbus_objc, dbus_interface=dbus.OBJECT_MANAGER_IFACE)
404
# block stderr since dbus library prints to stderr
355
405
null = os.open(os.path.devnull, os.O_RDWR)
356
406
stderrcopy = os.dup(sys.stderr.fileno())
357
407
os.dup2(null, sys.stderr.fileno())
361
mandos_clients = mandos_serv.GetAllClientsWithProperties()
411
mandos_clients = {path: ifs_and_props[client_interface]
412
for path, ifs_and_props in
413
mandos_serv_object_manager
414
.GetManagedObjects().items()
415
if client_interface in ifs_and_props}
364
418
os.dup2(stderrcopy, sys.stderr.fileno())
365
419
os.close(stderrcopy)
366
except dbus.exceptions.DBusException:
367
print("Access denied: Accessing mandos server through dbus.",
420
except dbus.exceptions.DBusException as e:
421
log.critical("Failed to access Mandos server through D-Bus:"
371
425
# Compile dict of (clients: properties) to process
374
428
if options.all or not options.client:
375
clients = dict((bus.get_object(busname, path), properties)
376
for path, properties in
377
mandos_clients.items())
429
clients = {bus.get_object(busname, path): properties
430
for path, properties in mandos_clients.items()}
379
432
for name in options.client:
380
for path, client in mandos_clients.iteritems():
433
for path, client in mandos_clients.items():
381
434
if client["Name"] == name:
382
435
client_objc = bus.get_object(busname, path)
383
436
clients[client_objc] = client
386
print("Client not found on server: {0!r}"
387
.format(name), file=sys.stderr)
439
log.critical("Client not found on server: %r", name)
390
442
if not has_actions(options) and clients:
392
keywords = ("Name", "Enabled", "Timeout",
393
"LastCheckedOK", "Created", "Interval",
394
"Host", "Fingerprint", "CheckerRunning",
443
if options.verbose or options.dump_json:
444
keywords = ("Name", "Enabled", "Timeout", "LastCheckedOK",
445
"Created", "Interval", "Host", "KeyID",
446
"Fingerprint", "CheckerRunning",
395
447
"LastEnabled", "ApprovalPending",
397
"LastApprovalRequest", "ApprovalDelay",
398
"ApprovalDuration", "Checker",
448
"ApprovedByDefault", "LastApprovalRequest",
449
"ApprovalDelay", "ApprovalDuration",
450
"Checker", "ExtendedTimeout", "Expires",
401
453
keywords = defaultkeywords
403
print_clients(clients.values(), keywords)
455
if options.dump_json:
456
json.dump({client["Name"]: {key:
458
if isinstance(client[key],
462
for client in clients.values()},
463
fp=sys.stdout, indent=4,
464
separators=(',', ': '))
467
print_clients(clients.values(), keywords)
405
469
# Process each client in the list by all selected options
406
470
for client in clients:
407
472
def set_client_prop(prop, value):
408
473
"""Set a Client D-Bus property"""
409
474
client.Set(client_interface, prop, value,
410
475
dbus_interface=dbus.PROPERTIES_IFACE)
411
477
def set_client_prop_ms(prop, value):
412
478
"""Set a Client D-Bus property, converted
413
479
from a string to milliseconds."""
414
480
set_client_prop(prop,
415
timedelta_to_milliseconds
416
(string_to_delta(value)))
481
string_to_delta(value).total_seconds()
417
484
if options.remove:
418
485
mandos_serv.RemoveClient(client.__dbus_object_path__)
419
486
if options.enable:
463
530
client.Approve(dbus.Boolean(False),
464
531
dbus_interface=client_interface)
534
class Test_milliseconds_to_string(unittest.TestCase):
536
self.assertEqual(milliseconds_to_string(93785000),
538
def test_no_days(self):
539
self.assertEqual(milliseconds_to_string(7385000), "02:03:05")
540
def test_all_zero(self):
541
self.assertEqual(milliseconds_to_string(0), "00:00:00")
542
def test_no_fractional_seconds(self):
543
self.assertEqual(milliseconds_to_string(400), "00:00:00")
544
self.assertEqual(milliseconds_to_string(900), "00:00:00")
545
self.assertEqual(milliseconds_to_string(1900), "00:00:01")
548
def should_only_run_tests():
549
parser = argparse.ArgumentParser(add_help=False)
550
parser.add_argument("--check", action='store_true')
551
args, unknown_args = parser.parse_known_args()
552
run_tests = args.check
554
# Remove --check argument from sys.argv
555
sys.argv[1:] = unknown_args
558
# Add all tests from doctest strings
559
def load_tests(loader, tests, none):
561
tests.addTests(doctest.DocTestSuite())
466
564
if __name__ == "__main__":
565
if should_only_run_tests():
566
# Call using ./tdd-python-script --check [--verbose]