2
2
# -*- mode: python; coding: utf-8 -*-
4
4
# Mandos Monitor - Control and monitor the Mandos server
6
# Copyright © 2008-2015 Teddy Hogeborn
7
# Copyright © 2008-2015 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-2018 Teddy Hogeborn
7
# Copyright © 2008-2018 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,
64
66
"ApprovalDelay": "Approval Delay",
65
67
"ApprovalDuration": "Approval Duration",
66
68
"Checker": "Checker",
67
"ExtendedTimeout": "Extended Timeout"
69
"ExtendedTimeout": "Extended Timeout",
71
"LastCheckerStatus": "Last Checker Status",
69
73
defaultkeywords = ("Name", "Enabled", "Timeout", "LastCheckedOK")
70
74
domain = "se.recompile"
73
77
server_interface = domain + ".Mandos"
74
78
client_interface = domain + ".Mandos.Client"
83
dbus.OBJECT_MANAGER_IFACE
84
except AttributeError:
85
dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"
78
88
def milliseconds_to_string(ms):
79
89
td = datetime.timedelta(0, 0, 0, ms)
80
return ("{days}{hours:02}:{minutes:02}:{seconds:02}".format(
81
days = "{}T".format(td.days) if td.days else "",
82
hours = td.seconds // 3600,
83
minutes = (td.seconds % 3600) // 60,
84
seconds = td.seconds % 60))
90
return ("{days}{hours:02}:{minutes:02}:{seconds:02}"
91
.format(days="{}T".format(td.days) if td.days else "",
92
hours=td.seconds // 3600,
93
minutes=(td.seconds % 3600) // 60,
94
seconds=td.seconds % 60))
87
97
def rfc3339_duration_to_delta(duration):
88
98
"""Parse an RFC 3339 "duration" and return a datetime.timedelta
90
100
>>> rfc3339_duration_to_delta("P7D")
91
101
datetime.timedelta(7)
92
102
>>> rfc3339_duration_to_delta("PT60S")
102
112
>>> rfc3339_duration_to_delta("P1DT3M20S")
103
113
datetime.timedelta(1, 200)
106
116
# Parsing an RFC 3339 duration with regular expressions is not
107
117
# possible - there would have to be multiple places for the same
108
118
# values, like seconds. The current code, while more esoteric, is
109
119
# cleaner without depending on a parsing library. If Python had a
110
120
# built-in library for parsing we would use it, but we'd like to
111
121
# avoid excessive use of external libraries.
113
123
# New type for defining tokens, syntax, and semantics all-in-one
114
124
Token = collections.namedtuple("Token", (
115
125
"regexp", # To match token; if "value" is not None, must have
148
158
frozenset((token_year, token_month,
149
159
token_day, token_time,
151
# Define starting values
152
value = datetime.timedelta() # Value so far
161
# Define starting values:
163
value = datetime.timedelta()
153
164
found_token = None
154
followers = frozenset((token_duration, )) # Following valid tokens
155
s = duration # String left to parse
165
# Following valid tokens
166
followers = frozenset((token_duration, ))
167
# String left to parse
156
169
# Loop until end token is found
157
170
while found_token is not token_end:
158
171
# Search for any currently valid tokens
196
209
>>> string_to_delta('5m 30s')
197
210
datetime.timedelta(0, 330)
201
214
return rfc3339_duration_to_delta(interval)
202
215
except ValueError:
205
218
value = datetime.timedelta(0)
206
219
regexp = re.compile(r"(\d+)([dsmhw]?)")
208
221
for num, suffix in regexp.findall(interval):
209
222
if suffix == "d":
210
223
value += datetime.timedelta(int(num))
229
242
"ApprovalDuration", "ExtendedTimeout"):
230
243
return milliseconds_to_string(value)
231
244
return str(value)
233
246
# Create format string to print table rows
234
247
format_string = " ".join("{{{key}:{width}}}".format(
235
width = max(len(tablewords[key]),
236
max(len(valuetostring(client[key], key))
237
for client in clients)),
248
width=max(len(tablewords[key]),
249
max(len(valuetostring(client[key], key))
250
for client in clients)),
239
252
for key in keywords)
240
253
# Print header line
241
254
print(format_string.format(**tablewords))
242
255
for client in clients:
243
print(format_string.format(**{
244
key: valuetostring(client[key], key)
245
for key in keywords }))
257
.format(**{key: valuetostring(client[key], key)
258
for key in keywords}))
248
261
def has_actions(options):
270
283
parser = argparse.ArgumentParser()
271
284
parser.add_argument("--version", action="version",
272
version = "%(prog)s {}".format(version),
285
version="%(prog)s {}".format(version),
273
286
help="show version number and exit")
274
287
parser.add_argument("-a", "--all", action="store_true",
275
288
help="Select all clients")
276
289
parser.add_argument("-v", "--verbose", action="store_true",
277
290
help="Print all fields")
291
parser.add_argument("-j", "--dump-json", action="store_true",
292
help="Dump client data in JSON format")
278
293
parser.add_argument("-e", "--enable", action="store_true",
279
294
help="Enable client")
280
295
parser.add_argument("-d", "--disable", action="store_true",
319
334
help="Run self-test")
320
335
parser.add_argument("client", nargs="*", help="Client name")
321
336
options = parser.parse_args()
323
338
if has_actions(options) and not (options.client or options.all):
324
339
parser.error("Options require clients names or --all.")
325
340
if options.verbose and has_actions(options):
326
parser.error("--verbose can only be used alone or with"
341
parser.error("--verbose can only be used alone.")
342
if options.dump_json and (options.verbose
343
or has_actions(options)):
344
parser.error("--dump-json can only be used alone.")
328
345
if options.all and not has_actions(options):
329
346
parser.error("--all requires an action.")
331
348
if options.check:
332
350
fail_count, test_count = doctest.testmod()
333
351
sys.exit(os.EX_OK if fail_count == 0 else 1)
336
354
bus = dbus.SystemBus()
337
355
mandos_dbus_objc = bus.get_object(busname, server_path)
338
356
except dbus.exceptions.DBusException:
339
357
print("Could not connect to Mandos server", file=sys.stderr)
342
360
mandos_serv = dbus.Interface(mandos_dbus_objc,
343
dbus_interface = server_interface)
345
#block stderr since dbus library prints to stderr
361
dbus_interface=server_interface)
362
mandos_serv_object_manager = dbus.Interface(
363
mandos_dbus_objc, dbus_interface=dbus.OBJECT_MANAGER_IFACE)
365
# block stderr since dbus library prints to stderr
346
366
null = os.open(os.path.devnull, os.O_RDWR)
347
367
stderrcopy = os.dup(sys.stderr.fileno())
348
368
os.dup2(null, sys.stderr.fileno())
352
mandos_clients = mandos_serv.GetAllClientsWithProperties()
372
mandos_clients = {path: ifs_and_props[client_interface]
373
for path, ifs_and_props in
374
mandos_serv_object_manager
375
.GetManagedObjects().items()
376
if client_interface in ifs_and_props}
355
379
os.dup2(stderrcopy, sys.stderr.fileno())
356
380
os.close(stderrcopy)
357
except dbus.exceptions.DBusException:
358
print("Access denied: Accessing mandos server through dbus.",
381
except dbus.exceptions.DBusException as e:
382
print("Access denied: "
383
"Accessing mandos server through D-Bus: {}".format(e),
362
387
# Compile dict of (clients: properties) to process
365
390
if options.all or not options.client:
366
clients = { bus.get_object(busname, path): properties
367
for path, properties in mandos_clients.items() }
391
clients = {bus.get_object(busname, path): properties
392
for path, properties in mandos_clients.items()}
369
394
for name in options.client:
370
395
for path, client in mandos_clients.items():
376
401
print("Client not found on server: {!r}"
377
402
.format(name), file=sys.stderr)
380
405
if not has_actions(options) and clients:
406
if options.verbose or options.dump_json:
382
407
keywords = ("Name", "Enabled", "Timeout", "LastCheckedOK",
383
"Created", "Interval", "Host", "Fingerprint",
384
"CheckerRunning", "LastEnabled",
385
"ApprovalPending", "ApprovedByDefault",
386
"LastApprovalRequest", "ApprovalDelay",
387
"ApprovalDuration", "Checker",
408
"Created", "Interval", "Host", "KeyID",
409
"Fingerprint", "CheckerRunning",
410
"LastEnabled", "ApprovalPending",
411
"ApprovedByDefault", "LastApprovalRequest",
412
"ApprovalDelay", "ApprovalDuration",
413
"Checker", "ExtendedTimeout", "Expires",
390
416
keywords = defaultkeywords
392
print_clients(clients.values(), keywords)
418
if options.dump_json:
419
json.dump({client["Name"]: {key:
421
if isinstance(client[key],
425
for client in clients.values()},
426
fp=sys.stdout, indent=4,
427
separators=(',', ': '))
430
print_clients(clients.values(), keywords)
394
432
# Process each client in the list by all selected options
395
433
for client in clients:
397
435
def set_client_prop(prop, value):
398
436
"""Set a Client D-Bus property"""
399
437
client.Set(client_interface, prop, value,
400
438
dbus_interface=dbus.PROPERTIES_IFACE)
402
440
def set_client_prop_ms(prop, value):
403
441
"""Set a Client D-Bus property, converted
404
442
from a string to milliseconds."""
405
443
set_client_prop(prop,
406
444
string_to_delta(value).total_seconds()
409
447
if options.remove:
410
448
mandos_serv.RemoveClient(client.__dbus_object_path__)
411
449
if options.enable:
419
457
if options.stop_checker:
420
458
set_client_prop("CheckerRunning", dbus.Boolean(False))
421
459
if options.is_enabled:
422
sys.exit(0 if client.Get(client_interface,
425
dbus.PROPERTIES_IFACE)
460
if client.Get(client_interface, "Enabled",
461
dbus_interface=dbus.PROPERTIES_IFACE):
427
465
if options.checker is not None:
428
466
set_client_prop("Checker", options.checker)
429
467
if options.host is not None:
added
removed
mandos-ctl
