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")
108
125
>>> rfc3339_duration_to_delta("P1DT3M20S")
109
126
datetime.timedelta(1, 200)
112
129
# Parsing an RFC 3339 duration with regular expressions is not
113
130
# possible - there would have to be multiple places for the same
114
131
# values, like seconds. The current code, while more esoteric, is
115
132
# cleaner without depending on a parsing library. If Python had a
116
133
# built-in library for parsing we would use it, but we'd like to
117
134
# avoid excessive use of external libraries.
119
136
# 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
137
Token = collections.namedtuple("Token", (
138
"regexp", # To match token; if "value" is not None, must have
139
# a "group" containing digits
140
"value", # datetime.timedelta or None
141
"followers")) # Tokens valid after this token
129
142
# RFC 3339 "duration" tokens, syntax, and semantics; taken from
130
143
# the "duration" ABNF definition in RFC 3339, Appendix A.
131
144
token_end = Token(re.compile(r"$"), None, frozenset())
132
145
token_second = Token(re.compile(r"(\d+)S"),
133
146
datetime.timedelta(seconds=1),
134
frozenset((token_end,)))
147
frozenset((token_end, )))
135
148
token_minute = Token(re.compile(r"(\d+)M"),
136
149
datetime.timedelta(minutes=1),
137
150
frozenset((token_second, token_end)))
186
202
# No currently valid tokens were found
187
raise ValueError("Invalid RFC 3339 duration")
203
raise ValueError("Invalid RFC 3339 duration: {!r}"
188
205
# End token found
192
209
def string_to_delta(interval):
193
210
"""Parse a string and return a datetime.timedelta
195
>>> string_to_delta("7d")
212
>>> string_to_delta('7d')
196
213
datetime.timedelta(7)
197
>>> string_to_delta("60s")
214
>>> string_to_delta('60s')
198
215
datetime.timedelta(0, 60)
199
>>> string_to_delta("60m")
216
>>> string_to_delta('60m')
200
217
datetime.timedelta(0, 3600)
201
>>> string_to_delta("24h")
218
>>> string_to_delta('24h')
202
219
datetime.timedelta(1)
203
>>> string_to_delta("1w")
220
>>> string_to_delta('1w')
204
221
datetime.timedelta(7)
205
>>> string_to_delta("5m 30s")
222
>>> string_to_delta('5m 30s')
206
223
datetime.timedelta(0, 330)
210
227
return rfc3339_duration_to_delta(interval)
211
228
except ValueError:
214
231
value = datetime.timedelta(0)
215
232
regexp = re.compile(r"(\d+)([dsmhw]?)")
217
234
for num, suffix in regexp.findall(interval):
218
235
if suffix == "d":
219
236
value += datetime.timedelta(int(num))
229
246
value += datetime.timedelta(0, 0, 0, int(num))
232
250
def print_clients(clients, keywords):
233
251
def valuetostring(value, keyword):
234
if type(value) is dbus.Boolean:
252
if isinstance(value, dbus.Boolean):
235
253
return "Yes" if value else "No"
236
254
if keyword in ("Timeout", "Interval", "ApprovalDelay",
237
255
"ApprovalDuration", "ExtendedTimeout"):
238
256
return milliseconds_to_string(value)
239
257
return str(value)
241
259
# Create format string to print table rows
242
260
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)
261
width=max(len(tablewords[key]),
262
max(len(valuetostring(client[key], key))
263
for client in clients)),
249
266
# Print header line
250
267
print(format_string.format(**tablewords))
251
268
for client in clients:
252
print(format_string.format(**dict((key,
253
valuetostring(client[key],
255
for key in keywords)))
270
.format(**{key: valuetostring(client[key], key)
271
for key in keywords}))
257
274
def has_actions(options):
258
275
return any((options.enable,
278
296
parser = argparse.ArgumentParser()
279
297
parser.add_argument("--version", action="version",
280
version = "%(prog)s {0}".format(version),
298
version="%(prog)s {}".format(version),
281
299
help="show version number and exit")
282
300
parser.add_argument("-a", "--all", action="store_true",
283
301
help="Select all clients")
284
302
parser.add_argument("-v", "--verbose", action="store_true",
285
303
help="Print all fields")
304
parser.add_argument("-j", "--dump-json", action="store_true",
305
help="Dump client data in JSON format")
286
306
parser.add_argument("-e", "--enable", action="store_true",
287
307
help="Enable client")
288
308
parser.add_argument("-d", "--disable", action="store_true",
327
347
help="Run self-test")
328
348
parser.add_argument("client", nargs="*", help="Client name")
329
349
options = parser.parse_args()
331
351
if has_actions(options) and not (options.client or options.all):
332
352
parser.error("Options require clients names or --all.")
333
353
if options.verbose and has_actions(options):
334
parser.error("--verbose can only be used alone or with"
354
parser.error("--verbose can only be used alone.")
355
if options.dump_json and (options.verbose
356
or has_actions(options)):
357
parser.error("--dump-json can only be used alone.")
336
358
if options.all and not has_actions(options):
337
359
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
362
bus = dbus.SystemBus()
345
363
mandos_dbus_objc = bus.get_object(busname, server_path)
346
364
except dbus.exceptions.DBusException:
347
print("Could not connect to Mandos server",
365
log.critical("Could not connect to Mandos server")
351
368
mandos_serv = dbus.Interface(mandos_dbus_objc,
352
dbus_interface = server_interface)
354
#block stderr since dbus library prints to stderr
369
dbus_interface=server_interface)
370
mandos_serv_object_manager = dbus.Interface(
371
mandos_dbus_objc, dbus_interface=dbus.OBJECT_MANAGER_IFACE)
373
# block stderr since dbus library prints to stderr
355
374
null = os.open(os.path.devnull, os.O_RDWR)
356
375
stderrcopy = os.dup(sys.stderr.fileno())
357
376
os.dup2(null, sys.stderr.fileno())
361
mandos_clients = mandos_serv.GetAllClientsWithProperties()
380
mandos_clients = {path: ifs_and_props[client_interface]
381
for path, ifs_and_props in
382
mandos_serv_object_manager
383
.GetManagedObjects().items()
384
if client_interface in ifs_and_props}
364
387
os.dup2(stderrcopy, sys.stderr.fileno())
365
388
os.close(stderrcopy)
366
except dbus.exceptions.DBusException:
367
print("Access denied: Accessing mandos server through dbus.",
389
except dbus.exceptions.DBusException as e:
390
log.critical("Failed to access Mandos server through D-Bus:"
371
394
# Compile dict of (clients: properties) to process
374
397
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())
398
clients = {bus.get_object(busname, path): properties
399
for path, properties in mandos_clients.items()}
379
401
for name in options.client:
380
for path, client in mandos_clients.iteritems():
402
for path, client in mandos_clients.items():
381
403
if client["Name"] == name:
382
404
client_objc = bus.get_object(busname, path)
383
405
clients[client_objc] = client
386
print("Client not found on server: {0!r}"
387
.format(name), file=sys.stderr)
408
log.critical("Client not found on server: %r", name)
390
411
if not has_actions(options) and clients:
392
keywords = ("Name", "Enabled", "Timeout",
393
"LastCheckedOK", "Created", "Interval",
394
"Host", "Fingerprint", "CheckerRunning",
412
if options.verbose or options.dump_json:
413
keywords = ("Name", "Enabled", "Timeout", "LastCheckedOK",
414
"Created", "Interval", "Host", "KeyID",
415
"Fingerprint", "CheckerRunning",
395
416
"LastEnabled", "ApprovalPending",
397
"LastApprovalRequest", "ApprovalDelay",
398
"ApprovalDuration", "Checker",
417
"ApprovedByDefault", "LastApprovalRequest",
418
"ApprovalDelay", "ApprovalDuration",
419
"Checker", "ExtendedTimeout", "Expires",
401
422
keywords = defaultkeywords
403
print_clients(clients.values(), keywords)
424
if options.dump_json:
425
json.dump({client["Name"]: {key:
427
if isinstance(client[key],
431
for client in clients.values()},
432
fp=sys.stdout, indent=4,
433
separators=(',', ': '))
436
print_clients(clients.values(), keywords)
405
438
# Process each client in the list by all selected options
406
439
for client in clients:
407
441
def set_client_prop(prop, value):
408
442
"""Set a Client D-Bus property"""
409
443
client.Set(client_interface, prop, value,
410
444
dbus_interface=dbus.PROPERTIES_IFACE)
411
446
def set_client_prop_ms(prop, value):
412
447
"""Set a Client D-Bus property, converted
413
448
from a string to milliseconds."""
414
449
set_client_prop(prop,
415
timedelta_to_milliseconds
416
(string_to_delta(value)))
450
string_to_delta(value).total_seconds()
417
453
if options.remove:
418
454
mandos_serv.RemoveClient(client.__dbus_object_path__)
419
455
if options.enable:
463
499
client.Approve(dbus.Boolean(False),
464
500
dbus_interface=client_interface)
503
class Test_milliseconds_to_string(unittest.TestCase):
505
self.assertEqual(milliseconds_to_string(93785000),
507
def test_no_days(self):
508
self.assertEqual(milliseconds_to_string(7385000), "02:03:05")
509
def test_all_zero(self):
510
self.assertEqual(milliseconds_to_string(0), "00:00:00")
511
def test_no_fractional_seconds(self):
512
self.assertEqual(milliseconds_to_string(400), "00:00:00")
513
self.assertEqual(milliseconds_to_string(900), "00:00:00")
514
self.assertEqual(milliseconds_to_string(1900), "00:00:01")
517
def should_only_run_tests():
518
parser = argparse.ArgumentParser(add_help=False)
519
parser.add_argument("--check", action='store_true')
520
args, unknown_args = parser.parse_known_args()
521
run_tests = args.check
523
# Remove --check argument from sys.argv
524
sys.argv[1:] = unknown_args
527
# Add all tests from doctest strings
528
def load_tests(loader, tests, none):
530
tests.addTests(doctest.DocTestSuite())
466
533
if __name__ == "__main__":
534
if should_only_run_tests():
535
# Call using ./tdd-python-script --check [--verbose]