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