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,
67
64
"ApprovalDelay": "Approval Delay",
68
65
"ApprovalDuration": "Approval Duration",
69
66
"Checker": "Checker",
70
"ExtendedTimeout": "Extended Timeout",
72
"LastCheckerStatus": "Last Checker Status",
67
"ExtendedTimeout" : "Extended Timeout"
74
69
defaultkeywords = ("Name", "Enabled", "Timeout", "LastCheckedOK")
75
70
domain = "se.recompile"
76
71
busname = domain + ".Mandos"
78
73
server_interface = domain + ".Mandos"
79
74
client_interface = domain + ".Mandos.Client"
84
dbus.OBJECT_MANAGER_IFACE
85
except AttributeError:
86
dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"
89
77
def milliseconds_to_string(ms):
90
78
td = datetime.timedelta(0, 0, 0, ms)
91
79
return ("{days}{hours:02}:{minutes:02}:{seconds:02}"
92
.format(days="{}T".format(td.days) if td.days else "",
93
hours=td.seconds // 3600,
94
minutes=(td.seconds % 3600) // 60,
95
seconds=td.seconds % 60))
80
.format(days = "{}T".format(td.days) if td.days else "",
81
hours = td.seconds // 3600,
82
minutes = (td.seconds % 3600) // 60,
83
seconds = td.seconds % 60,
98
87
def rfc3339_duration_to_delta(duration):
99
88
"""Parse an RFC 3339 "duration" and return a datetime.timedelta
101
90
>>> rfc3339_duration_to_delta("P7D")
102
91
datetime.timedelta(7)
103
92
>>> rfc3339_duration_to_delta("PT60S")
113
102
>>> rfc3339_duration_to_delta("P1DT3M20S")
114
103
datetime.timedelta(1, 200)
117
106
# Parsing an RFC 3339 duration with regular expressions is not
118
107
# possible - there would have to be multiple places for the same
119
108
# values, like seconds. The current code, while more esoteric, is
120
109
# cleaner without depending on a parsing library. If Python had a
121
110
# built-in library for parsing we would use it, but we'd like to
122
111
# avoid excessive use of external libraries.
124
113
# New type for defining tokens, syntax, and semantics all-in-one
125
Token = collections.namedtuple("Token", (
126
"regexp", # To match token; if "value" is not None, must have
127
# a "group" containing digits
128
"value", # datetime.timedelta or None
129
"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
130
123
# RFC 3339 "duration" tokens, syntax, and semantics; taken from
131
124
# the "duration" ABNF definition in RFC 3339, Appendix A.
132
125
token_end = Token(re.compile(r"$"), None, frozenset())
133
126
token_second = Token(re.compile(r"(\d+)S"),
134
127
datetime.timedelta(seconds=1),
135
frozenset((token_end, )))
128
frozenset((token_end,)))
136
129
token_minute = Token(re.compile(r"(\d+)M"),
137
130
datetime.timedelta(minutes=1),
138
131
frozenset((token_second, token_end)))
154
147
frozenset((token_month, token_end)))
155
148
token_week = Token(re.compile(r"(\d+)W"),
156
149
datetime.timedelta(weeks=1),
157
frozenset((token_end, )))
150
frozenset((token_end,)))
158
151
token_duration = Token(re.compile(r"P"), None,
159
152
frozenset((token_year, token_month,
160
153
token_day, token_time,
162
# Define starting values:
164
value = datetime.timedelta()
155
# Define starting values
156
value = datetime.timedelta() # Value so far
165
157
found_token = None
166
# Following valid tokens
167
followers = frozenset((token_duration, ))
168
# String left to parse
158
followers = frozenset((token_duration,)) # Following valid tokens
159
s = duration # String left to parse
170
160
# Loop until end token is found
171
161
while found_token is not token_end:
172
162
# Search for any currently valid tokens
190
180
# No currently valid tokens were found
191
raise ValueError("Invalid RFC 3339 duration: {!r}"
181
raise ValueError("Invalid RFC 3339 duration")
193
182
# End token found
197
186
def string_to_delta(interval):
198
187
"""Parse a string and return a datetime.timedelta
200
>>> string_to_delta('7d')
189
>>> string_to_delta("7d")
201
190
datetime.timedelta(7)
202
>>> string_to_delta('60s')
191
>>> string_to_delta("60s")
203
192
datetime.timedelta(0, 60)
204
>>> string_to_delta('60m')
193
>>> string_to_delta("60m")
205
194
datetime.timedelta(0, 3600)
206
>>> string_to_delta('24h')
195
>>> string_to_delta("24h")
207
196
datetime.timedelta(1)
208
>>> string_to_delta('1w')
197
>>> string_to_delta("1w")
209
198
datetime.timedelta(7)
210
>>> string_to_delta('5m 30s')
199
>>> string_to_delta("5m 30s")
211
200
datetime.timedelta(0, 330)
215
204
return rfc3339_duration_to_delta(interval)
216
205
except ValueError:
219
208
value = datetime.timedelta(0)
220
209
regexp = re.compile(r"(\d+)([dsmhw]?)")
222
211
for num, suffix in regexp.findall(interval):
223
212
if suffix == "d":
224
213
value += datetime.timedelta(int(num))
243
231
"ApprovalDuration", "ExtendedTimeout"):
244
232
return milliseconds_to_string(value)
245
233
return str(value)
247
235
# Create format string to print table rows
248
236
format_string = " ".join("{{{key}:{width}}}".format(
249
width=max(len(tablewords[key]),
250
max(len(valuetostring(client[key], key))
251
for client in clients)),
237
width = max(len(tablewords[key]),
238
max(len(valuetostring(client[key],
242
key = key) for key in keywords)
254
243
# Print header line
255
244
print(format_string.format(**tablewords))
256
245
for client in clients:
258
.format(**{key: valuetostring(client[key], key)
259
for key in keywords}))
246
print(format_string.format(**{ key:
247
valuetostring(client[key],
249
for key in keywords }))
262
251
def has_actions(options):
263
252
return any((options.enable,
284
272
parser = argparse.ArgumentParser()
285
273
parser.add_argument("--version", action="version",
286
version="%(prog)s {}".format(version),
274
version = "%(prog)s {}".format(version),
287
275
help="show version number and exit")
288
276
parser.add_argument("-a", "--all", action="store_true",
289
277
help="Select all clients")
290
278
parser.add_argument("-v", "--verbose", action="store_true",
291
279
help="Print all fields")
292
parser.add_argument("-j", "--dump-json", action="store_true",
293
help="Dump client data in JSON format")
294
280
parser.add_argument("-e", "--enable", action="store_true",
295
281
help="Enable client")
296
282
parser.add_argument("-d", "--disable", action="store_true",
335
321
help="Run self-test")
336
322
parser.add_argument("client", nargs="*", help="Client name")
337
323
options = parser.parse_args()
339
325
if has_actions(options) and not (options.client or options.all):
340
326
parser.error("Options require clients names or --all.")
341
327
if options.verbose and has_actions(options):
342
parser.error("--verbose can only be used alone.")
343
if options.dump_json and (options.verbose
344
or has_actions(options)):
345
parser.error("--dump-json can only be used alone.")
328
parser.error("--verbose can only be used alone or with"
346
330
if options.all and not has_actions(options):
347
331
parser.error("--all requires an action.")
334
fail_count, test_count = doctest.testmod()
335
sys.exit(os.EX_OK if fail_count == 0 else 1)
350
338
bus = dbus.SystemBus()
351
339
mandos_dbus_objc = bus.get_object(busname, server_path)
352
340
except dbus.exceptions.DBusException:
353
print("Could not connect to Mandos server", file=sys.stderr)
341
print("Could not connect to Mandos server",
356
345
mandos_serv = dbus.Interface(mandos_dbus_objc,
357
dbus_interface=server_interface)
358
mandos_serv_object_manager = dbus.Interface(
359
mandos_dbus_objc, dbus_interface=dbus.OBJECT_MANAGER_IFACE)
361
# block stderr since dbus library prints to stderr
346
dbus_interface = server_interface)
348
#block stderr since dbus library prints to stderr
362
349
null = os.open(os.path.devnull, os.O_RDWR)
363
350
stderrcopy = os.dup(sys.stderr.fileno())
364
351
os.dup2(null, sys.stderr.fileno())
368
mandos_clients = {path: ifs_and_props[client_interface]
369
for path, ifs_and_props in
370
mandos_serv_object_manager
371
.GetManagedObjects().items()
372
if client_interface in ifs_and_props}
355
mandos_clients = mandos_serv.GetAllClientsWithProperties()
375
358
os.dup2(stderrcopy, sys.stderr.fileno())
376
359
os.close(stderrcopy)
377
except dbus.exceptions.DBusException as e:
378
print("Access denied: "
379
"Accessing mandos server through D-Bus: {}".format(e),
360
except dbus.exceptions.DBusException:
361
print("Access denied: Accessing mandos server through dbus.",
383
365
# Compile dict of (clients: properties) to process
386
368
if options.all or not options.client:
387
clients = {bus.get_object(busname, path): properties
388
for path, properties in mandos_clients.items()}
369
clients = { bus.get_object(busname, path): properties
370
for path, properties in mandos_clients.items() }
390
372
for name in options.client:
391
373
for path, client in mandos_clients.items():
397
379
print("Client not found on server: {!r}"
398
380
.format(name), file=sys.stderr)
401
383
if not has_actions(options) and clients:
402
if options.verbose or options.dump_json:
403
keywords = ("Name", "Enabled", "Timeout", "LastCheckedOK",
404
"Created", "Interval", "Host", "KeyID",
405
"Fingerprint", "CheckerRunning",
385
keywords = ("Name", "Enabled", "Timeout",
386
"LastCheckedOK", "Created", "Interval",
387
"Host", "Fingerprint", "CheckerRunning",
406
388
"LastEnabled", "ApprovalPending",
407
"ApprovedByDefault", "LastApprovalRequest",
408
"ApprovalDelay", "ApprovalDuration",
409
"Checker", "ExtendedTimeout", "Expires",
390
"LastApprovalRequest", "ApprovalDelay",
391
"ApprovalDuration", "Checker",
412
394
keywords = defaultkeywords
414
if options.dump_json:
415
json.dump({client["Name"]: {key:
417
if isinstance(client[key],
421
for client in clients.values()},
422
fp=sys.stdout, indent=4,
423
separators=(',', ': '))
426
print_clients(clients.values(), keywords)
396
print_clients(clients.values(), keywords)
428
398
# Process each client in the list by all selected options
429
399
for client in clients:
431
400
def set_client_prop(prop, value):
432
401
"""Set a Client D-Bus property"""
433
402
client.Set(client_interface, prop, value,
434
403
dbus_interface=dbus.PROPERTIES_IFACE)
436
404
def set_client_prop_ms(prop, value):
437
405
"""Set a Client D-Bus property, converted
438
406
from a string to milliseconds."""
439
407
set_client_prop(prop,
440
408
string_to_delta(value).total_seconds()
443
410
if options.remove:
444
411
mandos_serv.RemoveClient(client.__dbus_object_path__)
445
412
if options.enable:
453
420
if options.stop_checker:
454
421
set_client_prop("CheckerRunning", dbus.Boolean(False))
455
422
if options.is_enabled:
456
if client.Get(client_interface, "Enabled",
457
dbus_interface=dbus.PROPERTIES_IFACE):
423
sys.exit(0 if client.Get(client_interface,
426
dbus.PROPERTIES_IFACE)
461
428
if options.checker is not None:
462
429
set_client_prop("Checker", options.checker)
463
430
if options.host is not None:
489
456
client.Approve(dbus.Boolean(False),
490
457
dbus_interface=client_interface)
493
class Test_milliseconds_to_string(unittest.TestCase):
495
self.assertEqual(milliseconds_to_string(93785000),
497
def test_no_days(self):
498
self.assertEqual(milliseconds_to_string(7385000), "02:03:05")
499
def test_all_zero(self):
500
self.assertEqual(milliseconds_to_string(0), "00:00:00")
501
def test_no_fractional_seconds(self):
502
self.assertEqual(milliseconds_to_string(400), "00:00:00")
503
self.assertEqual(milliseconds_to_string(900), "00:00:00")
504
self.assertEqual(milliseconds_to_string(1900), "00:00:01")
507
def should_only_run_tests():
508
parser = argparse.ArgumentParser(add_help=False)
509
parser.add_argument("--check", action='store_true')
510
args, unknown_args = parser.parse_known_args()
511
run_tests = args.check
513
# Remove --check argument from sys.argv
514
sys.argv[1:] = unknown_args
517
# Add all tests from doctest strings
518
def load_tests(loader, tests, none):
520
tests.addTests(doctest.DocTestSuite())
523
459
if __name__ == "__main__":
524
if should_only_run_tests():
525
# Call using ./tdd-python-script --check [--verbose]