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
# 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
13
# the Free Software Foundation, either version 3 of the License, or
14
# (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
18
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19
# GNU General Public License for more details.
21
# You should have received a copy of the GNU General Public License
22
# along with Mandos. If not, see <http://www.gnu.org/licenses/>.
24
# Contact the authors at <mandos@recompile.se>.
27
from __future__ import (division, absolute_import, print_function,
31
from future_builtins import *
2
# -*- mode: python; coding: utf-8 -*-
4
from __future__ import division
7
from optparse import OptionParser
48
log = logging.getLogger(sys.argv[0])
49
logging.basicConfig(level="INFO", # Show info level messages
50
format="%(message)s") # Show basic log messages
52
if sys.version_info.major == 2:
55
locale.setlocale(locale.LC_ALL, "")
13
locale.setlocale(locale.LC_ALL, u'')
61
"LastCheckedOK": "Last Successful Check",
62
"LastApprovalRequest": "Last Approval Request",
64
"Interval": "Interval",
66
"Fingerprint": "Fingerprint",
68
"CheckerRunning": "Check Is Running",
69
"LastEnabled": "Last Enabled",
70
"ApprovalPending": "Approval Is Pending",
71
"ApprovedByDefault": "Approved By Default",
72
"ApprovalDelay": "Approval Delay",
73
"ApprovalDuration": "Approval Duration",
75
"ExtendedTimeout": "Extended Timeout",
77
"LastCheckerStatus": "Last Checker Status",
79
defaultkeywords = ("Name", "Enabled", "Timeout", "LastCheckedOK")
80
domain = "se.recompile"
81
busname = domain + ".Mandos"
83
server_interface = domain + ".Mandos"
84
client_interface = domain + ".Mandos.Client"
89
dbus.OBJECT_MANAGER_IFACE
90
except AttributeError:
91
dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"
17
'Enabled': u'Enabled',
18
'Timeout': u'Timeout',
19
'LastCheckedOK': u'Last Successful Check',
20
'Created': u'Created',
21
'Interval': u'Interval',
23
'Fingerprint': u'Fingerprint',
24
'CheckerRunning': u'Check Is Running',
25
'LastEnabled': u'Last Enabled',
26
'ApprovalPending': u'Approval Is Pending',
27
'ApprovedByDefault': u'Approved By Default',
28
'ApprovalDelay': u"Approval Delay",
29
'ApprovalDuration': u"Approval Duration",
30
'Checker': u'Checker',
32
defaultkeywords = ('Name', 'Enabled', 'Timeout', 'LastCheckedOK')
33
domain = 'se.bsnet.fukt'
34
busname = domain + '.Mandos'
36
server_interface = domain + '.Mandos'
37
client_interface = domain + '.Mandos.Client'
40
def timedelta_to_milliseconds(td):
41
"Convert a datetime.timedelta object to milliseconds"
42
return ((td.days * 24 * 60 * 60 * 1000)
44
+ (td.microseconds // 1000))
94
46
def milliseconds_to_string(ms):
95
47
td = datetime.timedelta(0, 0, 0, ms)
96
return ("{days}{hours:02}:{minutes:02}:{seconds:02}"
97
.format(days="{}T".format(td.days) if td.days else "",
98
hours=td.seconds // 3600,
99
minutes=(td.seconds % 3600) // 60,
100
seconds=td.seconds % 60))
103
def rfc3339_duration_to_delta(duration):
104
"""Parse an RFC 3339 "duration" and return a datetime.timedelta
106
>>> rfc3339_duration_to_delta("P7D")
107
datetime.timedelta(7)
108
>>> rfc3339_duration_to_delta("PT60S")
109
datetime.timedelta(0, 60)
110
>>> rfc3339_duration_to_delta("PT60M")
111
datetime.timedelta(0, 3600)
112
>>> rfc3339_duration_to_delta("PT24H")
113
datetime.timedelta(1)
114
>>> rfc3339_duration_to_delta("P1W")
115
datetime.timedelta(7)
116
>>> rfc3339_duration_to_delta("PT5M30S")
117
datetime.timedelta(0, 330)
118
>>> rfc3339_duration_to_delta("P1DT3M20S")
119
datetime.timedelta(1, 200)
122
# Parsing an RFC 3339 duration with regular expressions is not
123
# possible - there would have to be multiple places for the same
124
# values, like seconds. The current code, while more esoteric, is
125
# cleaner without depending on a parsing library. If Python had a
126
# built-in library for parsing we would use it, but we'd like to
127
# avoid excessive use of external libraries.
129
# New type for defining tokens, syntax, and semantics all-in-one
130
Token = collections.namedtuple("Token", (
131
"regexp", # To match token; if "value" is not None, must have
132
# a "group" containing digits
133
"value", # datetime.timedelta or None
134
"followers")) # Tokens valid after this token
135
# RFC 3339 "duration" tokens, syntax, and semantics; taken from
136
# the "duration" ABNF definition in RFC 3339, Appendix A.
137
token_end = Token(re.compile(r"$"), None, frozenset())
138
token_second = Token(re.compile(r"(\d+)S"),
139
datetime.timedelta(seconds=1),
140
frozenset((token_end, )))
141
token_minute = Token(re.compile(r"(\d+)M"),
142
datetime.timedelta(minutes=1),
143
frozenset((token_second, token_end)))
144
token_hour = Token(re.compile(r"(\d+)H"),
145
datetime.timedelta(hours=1),
146
frozenset((token_minute, token_end)))
147
token_time = Token(re.compile(r"T"),
149
frozenset((token_hour, token_minute,
151
token_day = Token(re.compile(r"(\d+)D"),
152
datetime.timedelta(days=1),
153
frozenset((token_time, token_end)))
154
token_month = Token(re.compile(r"(\d+)M"),
155
datetime.timedelta(weeks=4),
156
frozenset((token_day, token_end)))
157
token_year = Token(re.compile(r"(\d+)Y"),
158
datetime.timedelta(weeks=52),
159
frozenset((token_month, token_end)))
160
token_week = Token(re.compile(r"(\d+)W"),
161
datetime.timedelta(weeks=1),
162
frozenset((token_end, )))
163
token_duration = Token(re.compile(r"P"), None,
164
frozenset((token_year, token_month,
165
token_day, token_time,
167
# Define starting values:
169
value = datetime.timedelta()
171
# Following valid tokens
172
followers = frozenset((token_duration, ))
173
# String left to parse
175
# Loop until end token is found
176
while found_token is not token_end:
177
# Search for any currently valid tokens
178
for token in followers:
179
match = token.regexp.match(s)
180
if match is not None:
182
if token.value is not None:
183
# Value found, parse digits
184
factor = int(match.group(1), 10)
185
# Add to value so far
186
value += factor * token.value
187
# Strip token from string
188
s = token.regexp.sub("", s, 1)
191
# Set valid next tokens
192
followers = found_token.followers
195
# No currently valid tokens were found
196
raise ValueError("Invalid RFC 3339 duration: {!r}"
48
return (u"%(days)s%(hours)02d:%(minutes)02d:%(seconds)02d"
49
% { "days": "%dT" % td.days if td.days else "",
50
"hours": td.seconds // 3600,
51
"minutes": (td.seconds % 3600) // 60,
52
"seconds": td.seconds % 60,
202
56
def string_to_delta(interval):
283
134
options.secret is not None,
289
parser = argparse.ArgumentParser()
290
parser.add_argument("--version", action="version",
291
version="%(prog)s {}".format(version),
292
help="show version number and exit")
293
parser.add_argument("-a", "--all", action="store_true",
294
help="Select all clients")
295
parser.add_argument("-v", "--verbose", action="store_true",
296
help="Print all fields")
297
parser.add_argument("-j", "--dump-json", action="store_true",
298
help="Dump client data in JSON format")
299
parser.add_argument("-e", "--enable", action="store_true",
300
help="Enable client")
301
parser.add_argument("-d", "--disable", action="store_true",
302
help="disable client")
303
parser.add_argument("-b", "--bump-timeout", action="store_true",
304
help="Bump timeout for client")
305
parser.add_argument("--start-checker", action="store_true",
306
help="Start checker for client")
307
parser.add_argument("--stop-checker", action="store_true",
308
help="Stop checker for client")
309
parser.add_argument("-V", "--is-enabled", action="store_true",
310
help="Check if client is enabled")
311
parser.add_argument("-r", "--remove", action="store_true",
312
help="Remove client")
313
parser.add_argument("-c", "--checker",
314
help="Set checker command for client")
315
parser.add_argument("-t", "--timeout",
316
help="Set timeout for client")
317
parser.add_argument("--extended-timeout",
318
help="Set extended timeout for client")
319
parser.add_argument("-i", "--interval",
320
help="Set checker interval for client")
321
parser.add_argument("--approve-by-default", action="store_true",
322
default=None, dest="approved_by_default",
323
help="Set client to be approved by default")
324
parser.add_argument("--deny-by-default", action="store_false",
325
dest="approved_by_default",
326
help="Set client to be denied by default")
327
parser.add_argument("--approval-delay",
328
help="Set delay before client approve/deny")
329
parser.add_argument("--approval-duration",
330
help="Set duration of one client approval")
331
parser.add_argument("-H", "--host", help="Set host for client")
332
parser.add_argument("-s", "--secret",
333
type=argparse.FileType(mode="rb"),
334
help="Set password blob (file) for client")
335
parser.add_argument("-A", "--approve", action="store_true",
336
help="Approve any current client request")
337
parser.add_argument("-D", "--deny", action="store_true",
338
help="Deny any current client request")
339
parser.add_argument("--check", action="store_true",
340
help="Run self-test")
341
parser.add_argument("client", nargs="*", help="Client name")
342
options = parser.parse_args()
344
if has_actions(options) and not (options.client or options.all):
345
parser.error("Options require clients names or --all.")
346
if options.verbose and has_actions(options):
347
parser.error("--verbose can only be used alone.")
348
if options.dump_json and (options.verbose
349
or has_actions(options)):
350
parser.error("--dump-json can only be used alone.")
351
if options.all and not has_actions(options):
352
parser.error("--all requires an action.")
355
bus = dbus.SystemBus()
356
mandos_dbus_objc = bus.get_object(busname, server_path)
357
except dbus.exceptions.DBusException:
358
log.critical("Could not connect to Mandos server")
361
mandos_serv = dbus.Interface(mandos_dbus_objc,
362
dbus_interface=server_interface)
363
mandos_serv_object_manager = dbus.Interface(
364
mandos_dbus_objc, dbus_interface=dbus.OBJECT_MANAGER_IFACE)
366
# block stderr since dbus library prints to stderr
367
null = os.open(os.path.devnull, os.O_RDWR)
368
stderrcopy = os.dup(sys.stderr.fileno())
369
os.dup2(null, sys.stderr.fileno())
373
mandos_clients = {path: ifs_and_props[client_interface]
374
for path, ifs_and_props in
375
mandos_serv_object_manager
376
.GetManagedObjects().items()
377
if client_interface in ifs_and_props}
380
os.dup2(stderrcopy, sys.stderr.fileno())
382
except dbus.exceptions.DBusException as e:
383
log.critical("Failed to access Mandos server through D-Bus:"
387
# Compile dict of (clients: properties) to process
390
if options.all or not options.client:
391
clients = {bus.get_object(busname, path): properties
392
for path, properties in mandos_clients.items()}
394
for name in options.client:
395
for path, client in mandos_clients.items():
396
if client["Name"] == name:
397
client_objc = bus.get_object(busname, path)
398
clients[client_objc] = client
401
log.critical("Client not found on server: %r", name)
404
if not has_actions(options) and clients:
405
if options.verbose or options.dump_json:
406
keywords = ("Name", "Enabled", "Timeout", "LastCheckedOK",
407
"Created", "Interval", "Host", "KeyID",
408
"Fingerprint", "CheckerRunning",
409
"LastEnabled", "ApprovalPending",
410
"ApprovedByDefault", "LastApprovalRequest",
411
"ApprovalDelay", "ApprovalDuration",
412
"Checker", "ExtendedTimeout", "Expires",
415
keywords = defaultkeywords
417
if options.dump_json:
418
json.dump({client["Name"]: {key:
420
if isinstance(client[key],
424
for client in clients.values()},
425
fp=sys.stdout, indent=4,
426
separators=(',', ': '))
429
print_clients(clients.values(), keywords)
431
# Process each client in the list by all selected options
432
for client in clients:
434
def set_client_prop(prop, value):
435
"""Set a Client D-Bus property"""
436
client.Set(client_interface, prop, value,
437
dbus_interface=dbus.PROPERTIES_IFACE)
439
def set_client_prop_ms(prop, value):
440
"""Set a Client D-Bus property, converted
441
from a string to milliseconds."""
442
set_client_prop(prop,
443
string_to_delta(value).total_seconds()
447
mandos_serv.RemoveClient(client.__dbus_object_path__)
449
set_client_prop("Enabled", dbus.Boolean(True))
451
set_client_prop("Enabled", dbus.Boolean(False))
452
if options.bump_timeout:
453
set_client_prop("LastCheckedOK", "")
454
if options.start_checker:
455
set_client_prop("CheckerRunning", dbus.Boolean(True))
456
if options.stop_checker:
457
set_client_prop("CheckerRunning", dbus.Boolean(False))
458
if options.is_enabled:
459
if client.Get(client_interface, "Enabled",
460
dbus_interface=dbus.PROPERTIES_IFACE):
139
parser = OptionParser(version = "%%prog %s" % version)
140
parser.add_option("-a", "--all", action="store_true",
141
help="Select all clients")
142
parser.add_option("-v", "--verbose", action="store_true",
143
help="Print all fields")
144
parser.add_option("-e", "--enable", action="store_true",
145
help="Enable client")
146
parser.add_option("-d", "--disable", action="store_true",
147
help="disable client")
148
parser.add_option("-b", "--bump-timeout", action="store_true",
149
help="Bump timeout for client")
150
parser.add_option("--start-checker", action="store_true",
151
help="Start checker for client")
152
parser.add_option("--stop-checker", action="store_true",
153
help="Stop checker for client")
154
parser.add_option("-V", "--is-enabled", action="store_true",
155
help="Check if client is enabled")
156
parser.add_option("-r", "--remove", action="store_true",
157
help="Remove client")
158
parser.add_option("-c", "--checker", type="string",
159
help="Set checker command for client")
160
parser.add_option("-t", "--timeout", type="string",
161
help="Set timeout for client")
162
parser.add_option("-i", "--interval", type="string",
163
help="Set checker interval for client")
164
parser.add_option("--approve-by-default", action="store_true",
165
dest=u"approved_by_default",
166
help="Set client to be approved by default")
167
parser.add_option("--deny-by-default", action="store_false",
168
dest=u"approved_by_default",
169
help="Set client to be denied by default")
170
parser.add_option("--approval-delay", type="string",
171
help="Set delay before client approve/deny")
172
parser.add_option("--approval-duration", type="string",
173
help="Set duration of one client approval")
174
parser.add_option("-H", "--host", type="string",
175
help="Set host for client")
176
parser.add_option("-s", "--secret", type="string",
177
help="Set password blob (file) for client")
178
parser.add_option("-A", "--approve", action="store_true",
179
help="Approve any current client request")
180
parser.add_option("-D", "--deny", action="store_true",
181
help="Deny any current client request")
182
options, client_names = parser.parse_args()
184
if has_actions(options) and not client_names and not options.all:
185
parser.error('Options require clients names or --all.')
186
if options.verbose and has_actions(options):
187
parser.error('--verbose can only be used alone or with'
189
if options.all and not has_actions(options):
190
parser.error('--all requires an action.')
193
bus = dbus.SystemBus()
194
mandos_dbus_objc = bus.get_object(busname, server_path)
195
except dbus.exceptions.DBusException:
196
print >> sys.stderr, "Could not connect to Mandos server"
199
mandos_serv = dbus.Interface(mandos_dbus_objc,
200
dbus_interface = server_interface)
202
#block stderr since dbus library prints to stderr
203
null = os.open(os.path.devnull, os.O_RDWR)
204
stderrcopy = os.dup(sys.stderr.fileno())
205
os.dup2(null, sys.stderr.fileno())
209
mandos_clients = mandos_serv.GetAllClientsWithProperties()
212
os.dup2(stderrcopy, sys.stderr.fileno())
214
except dbus.exceptions.DBusException, e:
215
print >> sys.stderr, "Access denied: Accessing mandos server through dbus."
218
# Compile dict of (clients: properties) to process
221
if options.all or not client_names:
222
clients = dict((bus.get_object(busname, path), properties)
223
for path, properties in
224
mandos_clients.iteritems())
226
for name in client_names:
227
for path, client in mandos_clients.iteritems():
228
if client['Name'] == name:
229
client_objc = bus.get_object(busname, path)
230
clients[client_objc] = client
233
print >> sys.stderr, "Client not found on server: %r" % name
464
if options.checker is not None:
465
set_client_prop("Checker", options.checker)
466
if options.host is not None:
467
set_client_prop("Host", options.host)
468
if options.interval is not None:
469
set_client_prop_ms("Interval", options.interval)
470
if options.approval_delay is not None:
471
set_client_prop_ms("ApprovalDelay",
472
options.approval_delay)
473
if options.approval_duration is not None:
474
set_client_prop_ms("ApprovalDuration",
475
options.approval_duration)
476
if options.timeout is not None:
477
set_client_prop_ms("Timeout", options.timeout)
478
if options.extended_timeout is not None:
479
set_client_prop_ms("ExtendedTimeout",
480
options.extended_timeout)
481
if options.secret is not None:
482
set_client_prop("Secret",
483
dbus.ByteArray(options.secret.read()))
484
if options.approved_by_default is not None:
485
set_client_prop("ApprovedByDefault",
487
.approved_by_default))
489
client.Approve(dbus.Boolean(True),
490
dbus_interface=client_interface)
492
client.Approve(dbus.Boolean(False),
493
dbus_interface=client_interface)
496
class Test_milliseconds_to_string(unittest.TestCase):
498
self.assertEqual(milliseconds_to_string(93785000),
500
def test_no_days(self):
501
self.assertEqual(milliseconds_to_string(7385000), "02:03:05")
502
def test_all_zero(self):
503
self.assertEqual(milliseconds_to_string(0), "00:00:00")
504
def test_no_fractional_seconds(self):
505
self.assertEqual(milliseconds_to_string(400), "00:00:00")
506
self.assertEqual(milliseconds_to_string(900), "00:00:00")
507
self.assertEqual(milliseconds_to_string(1900), "00:00:01")
510
def should_only_run_tests():
511
parser = argparse.ArgumentParser(add_help=False)
512
parser.add_argument("--check", action='store_true')
513
args, unknown_args = parser.parse_known_args()
514
run_tests = args.check
516
# Remove --check argument from sys.argv
517
sys.argv[1:] = unknown_args
520
# Add all tests from doctest strings
521
def load_tests(loader, tests, none):
523
tests.addTests(doctest.DocTestSuite())
526
if __name__ == "__main__":
527
if should_only_run_tests():
528
# Call using ./tdd-python-script --check [--verbose]
236
if not has_actions(options) and clients:
238
keywords = ('Name', 'Enabled', 'Timeout',
239
'LastCheckedOK', 'Created', 'Interval',
240
'Host', 'Fingerprint', 'CheckerRunning',
241
'LastEnabled', 'ApprovalPending',
242
'ApprovedByDefault', 'ApprovalDelay',
243
'ApprovalDuration', 'Checker')
245
keywords = defaultkeywords
247
print_clients(clients.values(), keywords)
249
# Process each client in the list by all selected options
250
for client in clients:
252
mandos_serv.RemoveClient(client.__dbus_object_path__)
254
client.Enable(dbus_interface=client_interface)
256
client.Disable(dbus_interface=client_interface)
257
if options.bump_timeout:
258
client.CheckedOK(dbus_interface=client_interface)
259
if options.start_checker:
260
client.StartChecker(dbus_interface=client_interface)
261
if options.stop_checker:
262
client.StopChecker(dbus_interface=client_interface)
263
if options.is_enabled:
264
sys.exit(0 if client.Get(client_interface,
266
dbus_interface=dbus.PROPERTIES_IFACE)
269
client.Set(client_interface, u"Checker", options.checker,
270
dbus_interface=dbus.PROPERTIES_IFACE)
272
client.Set(client_interface, u"Host", options.host,
273
dbus_interface=dbus.PROPERTIES_IFACE)
275
client.Set(client_interface, u"Interval",
276
timedelta_to_milliseconds
277
(string_to_delta(options.interval)),
278
dbus_interface=dbus.PROPERTIES_IFACE)
279
if options.approval_delay:
280
client.Set(client_interface, u"ApprovalDelay",
281
timedelta_to_milliseconds
282
(string_to_delta(options.
284
dbus_interface=dbus.PROPERTIES_IFACE)
285
if options.approval_duration:
286
client.Set(client_interface, u"ApprovalDuration",
287
timedelta_to_milliseconds
288
(string_to_delta(options.
290
dbus_interface=dbus.PROPERTIES_IFACE)
292
client.Set(client_interface, u"Timeout",
293
timedelta_to_milliseconds
294
(string_to_delta(options.timeout)),
295
dbus_interface=dbus.PROPERTIES_IFACE)
297
client.Set(client_interface, u"Secret",
298
dbus.ByteArray(open(options.secret,
300
dbus_interface=dbus.PROPERTIES_IFACE)
301
if options.approved_by_default is not None:
302
client.Set(client_interface, u"ApprovedByDefault",
304
.approved_by_default),
305
dbus_interface=dbus.PROPERTIES_IFACE)
307
client.Approve(dbus.Boolean(True),
308
dbus_interface=client_interface)
310
client.Approve(dbus.Boolean(False),
311
dbus_interface=client_interface)
313
if __name__ == '__main__':