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
88
"""Parse an 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")
116
93
datetime.timedelta(0, 60)
117
94
>>> rfc3339_duration_to_delta("PT60M")
118
95
datetime.timedelta(0, 3600)
119
>>> rfc3339_duration_to_delta("P60M")
120
datetime.timedelta(1680)
121
96
>>> rfc3339_duration_to_delta("PT24H")
122
97
datetime.timedelta(1)
123
98
>>> rfc3339_duration_to_delta("P1W")
126
101
datetime.timedelta(0, 330)
127
102
>>> rfc3339_duration_to_delta("P1DT3M20S")
128
103
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
106
# Parsing an RFC 3339 duration with regular expressions is not
161
107
# possible - there would have to be multiple places for the same
162
108
# values, like seconds. The current code, while more esoteric, is
163
109
# cleaner without depending on a parsing library. If Python had a
164
110
# built-in library for parsing we would use it, but we'd like to
165
111
# avoid excessive use of external libraries.
167
113
# 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
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
173
123
# RFC 3339 "duration" tokens, syntax, and semantics; taken from
174
124
# the "duration" ABNF definition in RFC 3339, Appendix A.
175
125
token_end = Token(re.compile(r"$"), None, frozenset())
176
126
token_second = Token(re.compile(r"(\d+)S"),
177
127
datetime.timedelta(seconds=1),
178
frozenset((token_end, )))
128
frozenset((token_end,)))
179
129
token_minute = Token(re.compile(r"(\d+)M"),
180
130
datetime.timedelta(minutes=1),
181
131
frozenset((token_second, token_end)))
233
180
# No currently valid tokens were found
234
raise ValueError("Invalid RFC 3339 duration: {!r}"
181
raise ValueError("Invalid RFC 3339 duration")
236
182
# End token found
240
186
def string_to_delta(interval):
241
187
"""Parse a string and return a datetime.timedelta
189
>>> string_to_delta("7d")
190
datetime.timedelta(7)
191
>>> string_to_delta("60s")
192
datetime.timedelta(0, 60)
193
>>> string_to_delta("60m")
194
datetime.timedelta(0, 3600)
195
>>> string_to_delta("24h")
196
datetime.timedelta(1)
197
>>> string_to_delta("1w")
198
datetime.timedelta(7)
199
>>> string_to_delta("5m 30s")
200
datetime.timedelta(0, 330)
245
204
return rfc3339_duration_to_delta(interval)
246
except ValueError as e:
247
log.warning("%s - Parsing as pre-1.6.1 interval instead",
249
return parse_pre_1_6_1_interval(interval)
252
def parse_pre_1_6_1_interval(interval):
253
"""Parse an interval string as documented by Mandos before 1.6.1, and
254
return a datetime.timedelta
255
>>> parse_pre_1_6_1_interval('7d')
256
datetime.timedelta(7)
257
>>> parse_pre_1_6_1_interval('60s')
258
datetime.timedelta(0, 60)
259
>>> parse_pre_1_6_1_interval('60m')
260
datetime.timedelta(0, 3600)
261
>>> parse_pre_1_6_1_interval('24h')
262
datetime.timedelta(1)
263
>>> parse_pre_1_6_1_interval('1w')
264
datetime.timedelta(7)
265
>>> parse_pre_1_6_1_interval('5m 30s')
266
datetime.timedelta(0, 330)
267
>>> parse_pre_1_6_1_interval('')
268
datetime.timedelta(0)
269
>>> # Ignore unknown characters, allow any order and repetitions
270
>>> parse_pre_1_6_1_interval('2dxy7zz11y3m5m')
271
datetime.timedelta(2, 480, 18000)
275
208
value = datetime.timedelta(0)
276
209
regexp = re.compile(r"(\d+)([dsmhw]?)")
278
211
for num, suffix in regexp.findall(interval):
279
212
if suffix == "d":
280
213
value += datetime.timedelta(int(num))
290
223
value += datetime.timedelta(0, 0, 0, int(num))
294
226
def print_clients(clients, keywords):
295
227
def valuetostring(value, keyword):
296
if isinstance(value, dbus.Boolean):
228
if type(value) is dbus.Boolean:
297
229
return "Yes" if value else "No"
298
230
if keyword in ("Timeout", "Interval", "ApprovalDelay",
299
231
"ApprovalDuration", "ExtendedTimeout"):
300
232
return milliseconds_to_string(value)
233
return unicode(value)
303
235
# Create format string to print table rows
304
236
format_string = " ".join("{{{key}:{width}}}".format(
305
width=max(len(tablewords[key]),
306
max(len(valuetostring(client[key], key))
307
for client in clients)),
237
width = max(len(tablewords[key]),
238
max(len(valuetostring(client[key],
242
key = key) for key in keywords)
310
243
# Print header line
311
244
print(format_string.format(**tablewords))
312
245
for client in clients:
314
.format(**{key: valuetostring(client[key], key)
315
for key in keywords}))
246
print(format_string.format(**dict((key,
247
valuetostring(client[key],
249
for key in keywords)))
318
251
def has_actions(options):
319
252
return any((options.enable,
340
272
parser = argparse.ArgumentParser()
341
273
parser.add_argument("--version", action="version",
342
version="%(prog)s {}".format(version),
274
version = "%(prog)s {0}".format(version),
343
275
help="show version number and exit")
344
276
parser.add_argument("-a", "--all", action="store_true",
345
277
help="Select all clients")
346
278
parser.add_argument("-v", "--verbose", action="store_true",
347
279
help="Print all fields")
348
parser.add_argument("-j", "--dump-json", action="store_true",
349
help="Dump client data in JSON format")
350
280
parser.add_argument("-e", "--enable", action="store_true",
351
281
help="Enable client")
352
282
parser.add_argument("-d", "--disable", action="store_true",
391
320
help="Run self-test")
392
321
parser.add_argument("client", nargs="*", help="Client name")
393
322
options = parser.parse_args()
395
324
if has_actions(options) and not (options.client or options.all):
396
325
parser.error("Options require clients names or --all.")
397
326
if options.verbose and has_actions(options):
398
parser.error("--verbose can only be used alone.")
399
if options.dump_json and (options.verbose
400
or has_actions(options)):
401
parser.error("--dump-json can only be used alone.")
327
parser.error("--verbose can only be used alone or with"
402
329
if options.all and not has_actions(options):
403
330
parser.error("--all requires an action.")
333
fail_count, test_count = doctest.testmod()
334
sys.exit(os.EX_OK if fail_count == 0 else 1)
406
337
bus = dbus.SystemBus()
407
338
mandos_dbus_objc = bus.get_object(busname, server_path)
408
339
except dbus.exceptions.DBusException:
409
log.critical("Could not connect to Mandos server")
340
print("Could not connect to Mandos server",
412
344
mandos_serv = dbus.Interface(mandos_dbus_objc,
413
dbus_interface=server_interface)
414
mandos_serv_object_manager = dbus.Interface(
415
mandos_dbus_objc, dbus_interface=dbus.OBJECT_MANAGER_IFACE)
417
# block stderr since dbus library prints to stderr
345
dbus_interface = server_interface)
347
#block stderr since dbus library prints to stderr
418
348
null = os.open(os.path.devnull, os.O_RDWR)
419
349
stderrcopy = os.dup(sys.stderr.fileno())
420
350
os.dup2(null, sys.stderr.fileno())
424
mandos_clients = {path: ifs_and_props[client_interface]
425
for path, ifs_and_props in
426
mandos_serv_object_manager
427
.GetManagedObjects().items()
428
if client_interface in ifs_and_props}
354
mandos_clients = mandos_serv.GetAllClientsWithProperties()
431
357
os.dup2(stderrcopy, sys.stderr.fileno())
432
358
os.close(stderrcopy)
433
except dbus.exceptions.DBusException as e:
434
log.critical("Failed to access Mandos server through D-Bus:"
359
except dbus.exceptions.DBusException:
360
print("Access denied: Accessing mandos server through dbus.",
438
364
# Compile dict of (clients: properties) to process
441
367
if options.all or not options.client:
442
clients = {bus.get_object(busname, path): properties
443
for path, properties in mandos_clients.items()}
368
clients = dict((bus.get_object(busname, path), properties)
369
for path, properties in
370
mandos_clients.iteritems())
445
372
for name in options.client:
446
for path, client in mandos_clients.items():
373
for path, client in mandos_clients.iteritems():
447
374
if client["Name"] == name:
448
375
client_objc = bus.get_object(busname, path)
449
376
clients[client_objc] = client
452
log.critical("Client not found on server: %r", name)
379
print("Client not found on server: {0!r}"
380
.format(name), file=sys.stderr)
455
383
if not has_actions(options) and clients:
456
if options.verbose or options.dump_json:
457
keywords = ("Name", "Enabled", "Timeout", "LastCheckedOK",
458
"Created", "Interval", "Host", "KeyID",
459
"Fingerprint", "CheckerRunning",
385
keywords = ("Name", "Enabled", "Timeout",
386
"LastCheckedOK", "Created", "Interval",
387
"Host", "Fingerprint", "CheckerRunning",
460
388
"LastEnabled", "ApprovalPending",
461
"ApprovedByDefault", "LastApprovalRequest",
462
"ApprovalDelay", "ApprovalDuration",
463
"Checker", "ExtendedTimeout", "Expires",
390
"LastApprovalRequest", "ApprovalDelay",
391
"ApprovalDuration", "Checker",
466
394
keywords = defaultkeywords
468
if options.dump_json:
469
json.dump({client["Name"]: {key:
471
if isinstance(client[key],
475
for client in clients.values()},
476
fp=sys.stdout, indent=4,
477
separators=(',', ': '))
480
print_clients(clients.values(), keywords)
396
print_clients(clients.values(), keywords)
482
398
# Process each client in the list by all selected options
483
399
for client in clients:
485
400
def set_client_prop(prop, value):
486
401
"""Set a Client D-Bus property"""
487
402
client.Set(client_interface, prop, value,
488
403
dbus_interface=dbus.PROPERTIES_IFACE)
490
404
def set_client_prop_ms(prop, value):
491
405
"""Set a Client D-Bus property, converted
492
406
from a string to milliseconds."""
493
407
set_client_prop(prop,
494
string_to_delta(value).total_seconds()
408
timedelta_to_milliseconds
409
(string_to_delta(value)))
497
410
if options.remove:
498
411
mandos_serv.RemoveClient(client.__dbus_object_path__)
499
412
if options.enable:
543
456
client.Approve(dbus.Boolean(False),
544
457
dbus_interface=client_interface)
547
class Test_milliseconds_to_string(unittest.TestCase):
549
self.assertEqual(milliseconds_to_string(93785000),
551
def test_no_days(self):
552
self.assertEqual(milliseconds_to_string(7385000), "02:03:05")
553
def test_all_zero(self):
554
self.assertEqual(milliseconds_to_string(0), "00:00:00")
555
def test_no_fractional_seconds(self):
556
self.assertEqual(milliseconds_to_string(400), "00:00:00")
557
self.assertEqual(milliseconds_to_string(900), "00:00:00")
558
self.assertEqual(milliseconds_to_string(1900), "00:00:01")
560
class Test_string_to_delta(unittest.TestCase):
561
def test_handles_basic_rfc3339(self):
562
self.assertEqual(string_to_delta("PT2H"),
563
datetime.timedelta(0, 7200))
564
def test_falls_back_to_pre_1_6_1_with_warning(self):
565
# assertLogs only exists in Python 3.4
566
if hasattr(self, "assertLogs"):
567
with self.assertLogs(log, logging.WARNING):
568
value = string_to_delta("2h")
570
value = string_to_delta("2h")
571
self.assertEqual(value, datetime.timedelta(0, 7200))
574
def should_only_run_tests():
575
parser = argparse.ArgumentParser(add_help=False)
576
parser.add_argument("--check", action='store_true')
577
args, unknown_args = parser.parse_known_args()
578
run_tests = args.check
580
# Remove --check argument from sys.argv
581
sys.argv[1:] = unknown_args
584
# Add all tests from doctest strings
585
def load_tests(loader, tests, none):
587
tests.addTests(doctest.DocTestSuite())
590
459
if __name__ == "__main__":
591
if should_only_run_tests():
592
# Call using ./tdd-python-script --check [--verbose]