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-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
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,
31
from future_builtins import *
29
from future_builtins import *
79
58
"ApprovalDelay": "Approval Delay",
80
59
"ApprovalDuration": "Approval Duration",
81
60
"Checker": "Checker",
82
"ExtendedTimeout": "Extended Timeout",
84
"LastCheckerStatus": "Last Checker Status",
61
"ExtendedTimeout" : "Extended Timeout"
86
63
defaultkeywords = ("Name", "Enabled", "Timeout", "LastCheckedOK")
87
64
domain = "se.recompile"
88
65
busname = domain + ".Mandos"
90
67
server_interface = domain + ".Mandos"
91
68
client_interface = domain + ".Mandos.Client"
96
dbus.OBJECT_MANAGER_IFACE
97
except AttributeError:
98
dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"
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))
101
77
def milliseconds_to_string(ms):
102
78
td = datetime.timedelta(0, 0, 0, ms)
103
79
return ("{days}{hours:02}:{minutes:02}:{seconds:02}"
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))
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,
110
87
def rfc3339_duration_to_delta(duration):
111
"""Parse an RFC 3339 "duration" and return a datetime.timedelta
88
"""Parse a RFC 3339 "duration" and return a datetime.timedelta
113
90
>>> rfc3339_duration_to_delta("P7D")
114
91
datetime.timedelta(7)
115
92
>>> rfc3339_duration_to_delta("PT60S")
125
102
>>> rfc3339_duration_to_delta("P1DT3M20S")
126
103
datetime.timedelta(1, 200)
129
# Parsing an RFC 3339 duration with regular expressions is not
106
# Parsing a RFC 3339 duration with regular expressions is not
130
107
# possible - there would have to be multiple places for the same
131
# values, like seconds. The current code, while more esoteric, is
132
# cleaner without depending on a parsing library. If Python had a
108
# values, like seconds. This, while more esoteric, is cleaner
109
# without depending on a parsing library. If Python had a
133
110
# built-in library for parsing we would use it, but we'd like to
134
111
# avoid excessive use of external libraries.
136
113
# New type for defining tokens, syntax, and semantics all-in-one
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
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
142
123
# RFC 3339 "duration" tokens, syntax, and semantics; taken from
143
124
# the "duration" ABNF definition in RFC 3339, Appendix A.
144
125
token_end = Token(re.compile(r"$"), None, frozenset())
145
126
token_second = Token(re.compile(r"(\d+)S"),
146
127
datetime.timedelta(seconds=1),
147
frozenset((token_end, )))
128
frozenset((token_end,)))
148
129
token_minute = Token(re.compile(r"(\d+)M"),
149
130
datetime.timedelta(minutes=1),
150
131
frozenset((token_second, token_end)))
202
180
# No currently valid tokens were found
203
raise ValueError("Invalid RFC 3339 duration: {!r}"
181
raise ValueError("Invalid RFC 3339 duration")
205
182
# End token found
209
186
def string_to_delta(interval):
210
187
"""Parse a string and return a datetime.timedelta
212
>>> string_to_delta('7d')
189
>>> string_to_delta("7d")
213
190
datetime.timedelta(7)
214
>>> string_to_delta('60s')
191
>>> string_to_delta("60s")
215
192
datetime.timedelta(0, 60)
216
>>> string_to_delta('60m')
193
>>> string_to_delta("60m")
217
194
datetime.timedelta(0, 3600)
218
>>> string_to_delta('24h')
195
>>> string_to_delta("24h")
219
196
datetime.timedelta(1)
220
>>> string_to_delta('1w')
197
>>> string_to_delta("1w")
221
198
datetime.timedelta(7)
222
>>> string_to_delta('5m 30s')
199
>>> string_to_delta("5m 30s")
223
200
datetime.timedelta(0, 330)
202
value = datetime.timedelta(0)
203
regexp = re.compile(r"(\d+)([dsmhw]?)")
227
206
return rfc3339_duration_to_delta(interval)
228
207
except ValueError:
231
value = datetime.timedelta(0)
232
regexp = re.compile(r"(\d+)([dsmhw]?)")
234
210
for num, suffix in regexp.findall(interval):
235
211
if suffix == "d":
236
212
value += datetime.timedelta(int(num))
254
229
if keyword in ("Timeout", "Interval", "ApprovalDelay",
255
230
"ApprovalDuration", "ExtendedTimeout"):
256
231
return milliseconds_to_string(value)
232
return unicode(value)
259
234
# Create format string to print table rows
260
235
format_string = " ".join("{{{key}:{width}}}".format(
261
width=max(len(tablewords[key]),
262
max(len(valuetostring(client[key], key))
263
for client in clients)),
236
width = max(len(tablewords[key]),
237
max(len(valuetostring(client[key],
241
key = key) for key in keywords)
266
242
# Print header line
267
243
print(format_string.format(**tablewords))
268
244
for client in clients:
270
.format(**{key: valuetostring(client[key], key)
271
for key in keywords}))
245
print(format_string.format(**dict((key,
246
valuetostring(client[key],
248
for key in keywords)))
274
250
def has_actions(options):
275
251
return any((options.enable,
296
271
parser = argparse.ArgumentParser()
297
272
parser.add_argument("--version", action="version",
298
version="%(prog)s {}".format(version),
273
version = "%(prog)s {0}".format(version),
299
274
help="show version number and exit")
300
275
parser.add_argument("-a", "--all", action="store_true",
301
276
help="Select all clients")
302
277
parser.add_argument("-v", "--verbose", action="store_true",
303
278
help="Print all fields")
304
parser.add_argument("-j", "--dump-json", action="store_true",
305
help="Dump client data in JSON format")
306
279
parser.add_argument("-e", "--enable", action="store_true",
307
280
help="Enable client")
308
281
parser.add_argument("-d", "--disable", action="store_true",
347
319
help="Run self-test")
348
320
parser.add_argument("client", nargs="*", help="Client name")
349
321
options = parser.parse_args()
351
323
if has_actions(options) and not (options.client or options.all):
352
324
parser.error("Options require clients names or --all.")
353
325
if options.verbose and has_actions(options):
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.")
326
parser.error("--verbose can only be used alone or with"
358
328
if options.all and not has_actions(options):
359
329
parser.error("--all requires an action.")
332
fail_count, test_count = doctest.testmod()
333
sys.exit(0 if fail_count == 0 else 1)
362
336
bus = dbus.SystemBus()
363
337
mandos_dbus_objc = bus.get_object(busname, server_path)
364
338
except dbus.exceptions.DBusException:
365
log.critical("Could not connect to Mandos server")
339
print("Could not connect to Mandos server",
368
343
mandos_serv = dbus.Interface(mandos_dbus_objc,
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
344
dbus_interface = server_interface)
346
#block stderr since dbus library prints to stderr
374
347
null = os.open(os.path.devnull, os.O_RDWR)
375
348
stderrcopy = os.dup(sys.stderr.fileno())
376
349
os.dup2(null, sys.stderr.fileno())
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}
353
mandos_clients = mandos_serv.GetAllClientsWithProperties()
387
356
os.dup2(stderrcopy, sys.stderr.fileno())
388
357
os.close(stderrcopy)
389
except dbus.exceptions.DBusException as e:
390
log.critical("Failed to access Mandos server through D-Bus:"
358
except dbus.exceptions.DBusException:
359
print("Access denied: Accessing mandos server through dbus.",
394
363
# Compile dict of (clients: properties) to process
397
366
if options.all or not options.client:
398
clients = {bus.get_object(busname, path): properties
399
for path, properties in mandos_clients.items()}
367
clients = dict((bus.get_object(busname, path), properties)
368
for path, properties in
369
mandos_clients.iteritems())
401
371
for name in options.client:
402
for path, client in mandos_clients.items():
372
for path, client in mandos_clients.iteritems():
403
373
if client["Name"] == name:
404
374
client_objc = bus.get_object(busname, path)
405
375
clients[client_objc] = client
408
log.critical("Client not found on server: %r", name)
378
print("Client not found on server: {0!r}"
379
.format(name), file=sys.stderr)
411
382
if not has_actions(options) and clients:
412
if options.verbose or options.dump_json:
413
keywords = ("Name", "Enabled", "Timeout", "LastCheckedOK",
414
"Created", "Interval", "Host", "KeyID",
415
"Fingerprint", "CheckerRunning",
384
keywords = ("Name", "Enabled", "Timeout",
385
"LastCheckedOK", "Created", "Interval",
386
"Host", "Fingerprint", "CheckerRunning",
416
387
"LastEnabled", "ApprovalPending",
417
"ApprovedByDefault", "LastApprovalRequest",
418
"ApprovalDelay", "ApprovalDuration",
419
"Checker", "ExtendedTimeout", "Expires",
389
"LastApprovalRequest", "ApprovalDelay",
390
"ApprovalDuration", "Checker",
422
393
keywords = defaultkeywords
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)
395
print_clients(clients.values(), keywords)
438
397
# Process each client in the list by all selected options
439
398
for client in clients:
441
399
def set_client_prop(prop, value):
442
400
"""Set a Client D-Bus property"""
443
401
client.Set(client_interface, prop, value,
444
402
dbus_interface=dbus.PROPERTIES_IFACE)
446
403
def set_client_prop_ms(prop, value):
447
404
"""Set a Client D-Bus property, converted
448
405
from a string to milliseconds."""
449
406
set_client_prop(prop,
450
string_to_delta(value).total_seconds()
407
timedelta_to_milliseconds
408
(string_to_delta(value)))
453
409
if options.remove:
454
410
mandos_serv.RemoveClient(client.__dbus_object_path__)
455
411
if options.enable:
499
455
client.Approve(dbus.Boolean(False),
500
456
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())
533
458
if __name__ == "__main__":
534
if should_only_run_tests():
535
# Call using ./tdd-python-script --check [--verbose]