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,
29
from future_builtins import *
31
from future_builtins import *
58
79
"ApprovalDelay": "Approval Delay",
59
80
"ApprovalDuration": "Approval Duration",
60
81
"Checker": "Checker",
61
"ExtendedTimeout" : "Extended Timeout"
82
"ExtendedTimeout": "Extended Timeout",
84
"LastCheckerStatus": "Last Checker Status",
63
86
defaultkeywords = ("Name", "Enabled", "Timeout", "LastCheckedOK")
64
87
domain = "se.recompile"
65
88
busname = domain + ".Mandos"
67
90
server_interface = domain + ".Mandos"
68
91
client_interface = domain + ".Mandos.Client"
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))
96
dbus.OBJECT_MANAGER_IFACE
97
except AttributeError:
98
dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"
77
101
def milliseconds_to_string(ms):
78
102
td = datetime.timedelta(0, 0, 0, ms)
79
103
return ("{days}{hours:02}:{minutes:02}:{seconds:02}"
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,
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))
87
110
def rfc3339_duration_to_delta(duration):
88
111
"""Parse an RFC 3339 "duration" and return a datetime.timedelta
90
113
>>> rfc3339_duration_to_delta("P7D")
91
114
datetime.timedelta(7)
92
115
>>> rfc3339_duration_to_delta("PT60S")
93
116
datetime.timedelta(0, 60)
94
117
>>> rfc3339_duration_to_delta("PT60M")
95
118
datetime.timedelta(0, 3600)
119
>>> rfc3339_duration_to_delta("P60M")
120
datetime.timedelta(1680)
96
121
>>> rfc3339_duration_to_delta("PT24H")
97
122
datetime.timedelta(1)
98
123
>>> rfc3339_duration_to_delta("P1W")
101
126
datetime.timedelta(0, 330)
102
127
>>> rfc3339_duration_to_delta("P1DT3M20S")
103
128
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'
106
160
# Parsing an RFC 3339 duration with regular expressions is not
107
161
# possible - there would have to be multiple places for the same
108
162
# values, like seconds. The current code, while more esoteric, is
109
163
# cleaner without depending on a parsing library. If Python had a
110
164
# built-in library for parsing we would use it, but we'd like to
111
165
# avoid excessive use of external libraries.
113
167
# New type for defining tokens, syntax, and semantics all-in-one
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
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
123
173
# RFC 3339 "duration" tokens, syntax, and semantics; taken from
124
174
# the "duration" ABNF definition in RFC 3339, Appendix A.
125
175
token_end = Token(re.compile(r"$"), None, frozenset())
126
176
token_second = Token(re.compile(r"(\d+)S"),
127
177
datetime.timedelta(seconds=1),
128
frozenset((token_end,)))
178
frozenset((token_end, )))
129
179
token_minute = Token(re.compile(r"(\d+)M"),
130
180
datetime.timedelta(minutes=1),
131
181
frozenset((token_second, token_end)))
180
233
# No currently valid tokens were found
181
raise ValueError("Invalid RFC 3339 duration")
234
raise ValueError("Invalid RFC 3339 duration: {!r}"
182
236
# End token found
186
240
def string_to_delta(interval):
187
241
"""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)
204
245
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)
208
275
value = datetime.timedelta(0)
209
276
regexp = re.compile(r"(\d+)([dsmhw]?)")
211
278
for num, suffix in regexp.findall(interval):
212
279
if suffix == "d":
213
280
value += datetime.timedelta(int(num))
223
290
value += datetime.timedelta(0, 0, 0, int(num))
226
294
def print_clients(clients, keywords):
227
295
def valuetostring(value, keyword):
228
if type(value) is dbus.Boolean:
296
if isinstance(value, dbus.Boolean):
229
297
return "Yes" if value else "No"
230
298
if keyword in ("Timeout", "Interval", "ApprovalDelay",
231
299
"ApprovalDuration", "ExtendedTimeout"):
232
300
return milliseconds_to_string(value)
233
return unicode(value)
235
303
# Create format string to print table rows
236
304
format_string = " ".join("{{{key}:{width}}}".format(
237
width = max(len(tablewords[key]),
238
max(len(valuetostring(client[key],
242
key = key) for key in keywords)
305
width=max(len(tablewords[key]),
306
max(len(valuetostring(client[key], key))
307
for client in clients)),
243
310
# Print header line
244
311
print(format_string.format(**tablewords))
245
312
for client in clients:
246
print(format_string.format(**dict((key,
247
valuetostring(client[key],
249
for key in keywords)))
314
.format(**{key: valuetostring(client[key], key)
315
for key in keywords}))
251
318
def has_actions(options):
252
319
return any((options.enable,
272
340
parser = argparse.ArgumentParser()
273
341
parser.add_argument("--version", action="version",
274
version = "%(prog)s {0}".format(version),
342
version="%(prog)s {}".format(version),
275
343
help="show version number and exit")
276
344
parser.add_argument("-a", "--all", action="store_true",
277
345
help="Select all clients")
278
346
parser.add_argument("-v", "--verbose", action="store_true",
279
347
help="Print all fields")
348
parser.add_argument("-j", "--dump-json", action="store_true",
349
help="Dump client data in JSON format")
280
350
parser.add_argument("-e", "--enable", action="store_true",
281
351
help="Enable client")
282
352
parser.add_argument("-d", "--disable", action="store_true",
320
391
help="Run self-test")
321
392
parser.add_argument("client", nargs="*", help="Client name")
322
393
options = parser.parse_args()
324
395
if has_actions(options) and not (options.client or options.all):
325
396
parser.error("Options require clients names or --all.")
326
397
if options.verbose and has_actions(options):
327
parser.error("--verbose can only be used alone or with"
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.")
329
402
if options.all and not has_actions(options):
330
403
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)
337
406
bus = dbus.SystemBus()
338
407
mandos_dbus_objc = bus.get_object(busname, server_path)
339
408
except dbus.exceptions.DBusException:
340
print("Could not connect to Mandos server",
409
log.critical("Could not connect to Mandos server")
344
412
mandos_serv = dbus.Interface(mandos_dbus_objc,
345
dbus_interface = server_interface)
347
#block stderr since dbus library prints to stderr
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
348
418
null = os.open(os.path.devnull, os.O_RDWR)
349
419
stderrcopy = os.dup(sys.stderr.fileno())
350
420
os.dup2(null, sys.stderr.fileno())
354
mandos_clients = mandos_serv.GetAllClientsWithProperties()
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}
357
431
os.dup2(stderrcopy, sys.stderr.fileno())
358
432
os.close(stderrcopy)
359
except dbus.exceptions.DBusException:
360
print("Access denied: Accessing mandos server through dbus.",
433
except dbus.exceptions.DBusException as e:
434
log.critical("Failed to access Mandos server through D-Bus:"
364
438
# Compile dict of (clients: properties) to process
367
441
if options.all or not options.client:
368
clients = dict((bus.get_object(busname, path), properties)
369
for path, properties in
370
mandos_clients.iteritems())
442
clients = {bus.get_object(busname, path): properties
443
for path, properties in mandos_clients.items()}
372
445
for name in options.client:
373
for path, client in mandos_clients.iteritems():
446
for path, client in mandos_clients.items():
374
447
if client["Name"] == name:
375
448
client_objc = bus.get_object(busname, path)
376
449
clients[client_objc] = client
379
print("Client not found on server: {0!r}"
380
.format(name), file=sys.stderr)
452
log.critical("Client not found on server: %r", name)
383
455
if not has_actions(options) and clients:
385
keywords = ("Name", "Enabled", "Timeout",
386
"LastCheckedOK", "Created", "Interval",
387
"Host", "Fingerprint", "CheckerRunning",
456
if options.verbose or options.dump_json:
457
keywords = ("Name", "Enabled", "Timeout", "LastCheckedOK",
458
"Created", "Interval", "Host", "KeyID",
459
"Fingerprint", "CheckerRunning",
388
460
"LastEnabled", "ApprovalPending",
390
"LastApprovalRequest", "ApprovalDelay",
391
"ApprovalDuration", "Checker",
461
"ApprovedByDefault", "LastApprovalRequest",
462
"ApprovalDelay", "ApprovalDuration",
463
"Checker", "ExtendedTimeout", "Expires",
394
466
keywords = defaultkeywords
396
print_clients(clients.values(), keywords)
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)
398
482
# Process each client in the list by all selected options
399
483
for client in clients:
400
485
def set_client_prop(prop, value):
401
486
"""Set a Client D-Bus property"""
402
487
client.Set(client_interface, prop, value,
403
488
dbus_interface=dbus.PROPERTIES_IFACE)
404
490
def set_client_prop_ms(prop, value):
405
491
"""Set a Client D-Bus property, converted
406
492
from a string to milliseconds."""
407
493
set_client_prop(prop,
408
timedelta_to_milliseconds
409
(string_to_delta(value)))
494
string_to_delta(value).total_seconds()
410
497
if options.remove:
411
498
mandos_serv.RemoveClient(client.__dbus_object_path__)
412
499
if options.enable:
456
543
client.Approve(dbus.Boolean(False),
457
544
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")
561
def should_only_run_tests():
562
parser = argparse.ArgumentParser(add_help=False)
563
parser.add_argument("--check", action='store_true')
564
args, unknown_args = parser.parse_known_args()
565
run_tests = args.check
567
# Remove --check argument from sys.argv
568
sys.argv[1:] = unknown_args
571
# Add all tests from doctest strings
572
def load_tests(loader, tests, none):
574
tests.addTests(doctest.DocTestSuite())
459
577
if __name__ == "__main__":
578
if should_only_run_tests():
579
# Call using ./tdd-python-script --check [--verbose]