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-2011 Teddy Hogeborn
7
# Copyright © 2008-2011 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 <http://www.gnu.org/licenses/>.
24
22
# Contact the authors at <mandos@recompile.se>.
27
25
from __future__ import (division, absolute_import, print_function,
31
from future_builtins import *
48
# Show warnings by default
49
if not sys.warnoptions:
51
warnings.simplefilter("default")
53
log = logging.getLogger(sys.argv[0])
54
logging.basicConfig(level="INFO", # Show info level messages
55
format="%(message)s") # Show basic log messages
57
logging.captureWarnings(True) # Show warnings via the logging system
59
if sys.version_info.major == 2:
62
36
locale.setlocale(locale.LC_ALL, "")
79
52
"ApprovalDelay": "Approval Delay",
80
53
"ApprovalDuration": "Approval Duration",
81
54
"Checker": "Checker",
82
"ExtendedTimeout": "Extended Timeout",
84
"LastCheckerStatus": "Last Checker Status",
55
"ExtendedTimeout" : "Extended Timeout"
86
57
defaultkeywords = ("Name", "Enabled", "Timeout", "LastCheckedOK")
87
58
domain = "se.recompile"
88
59
busname = domain + ".Mandos"
90
61
server_interface = domain + ".Mandos"
91
62
client_interface = domain + ".Mandos.Client"
96
dbus.OBJECT_MANAGER_IFACE
97
except AttributeError:
98
dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"
65
def timedelta_to_milliseconds(td):
66
"""Convert a datetime.timedelta object to milliseconds"""
67
return ((td.days * 24 * 60 * 60 * 1000)
69
+ (td.microseconds // 1000))
101
71
def milliseconds_to_string(ms):
102
72
td = datetime.timedelta(0, 0, 0, ms)
103
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))
110
def rfc3339_duration_to_delta(duration):
111
"""Parse an RFC 3339 "duration" and return a datetime.timedelta
113
>>> rfc3339_duration_to_delta("P7D")
114
datetime.timedelta(7)
115
>>> rfc3339_duration_to_delta("PT60S")
116
datetime.timedelta(0, 60)
117
>>> rfc3339_duration_to_delta("PT60M")
118
datetime.timedelta(0, 3600)
119
>>> rfc3339_duration_to_delta("P60M")
120
datetime.timedelta(1680)
121
>>> rfc3339_duration_to_delta("PT24H")
122
datetime.timedelta(1)
123
>>> rfc3339_duration_to_delta("P1W")
124
datetime.timedelta(7)
125
>>> rfc3339_duration_to_delta("PT5M30S")
126
datetime.timedelta(0, 330)
127
>>> rfc3339_duration_to_delta("P1DT3M20S")
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'
160
# Parsing an RFC 3339 duration with regular expressions is not
161
# possible - there would have to be multiple places for the same
162
# values, like seconds. The current code, while more esoteric, is
163
# cleaner without depending on a parsing library. If Python had a
164
# built-in library for parsing we would use it, but we'd like to
165
# avoid excessive use of external libraries.
167
# 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
173
# RFC 3339 "duration" tokens, syntax, and semantics; taken from
174
# the "duration" ABNF definition in RFC 3339, Appendix A.
175
token_end = Token(re.compile(r"$"), None, frozenset())
176
token_second = Token(re.compile(r"(\d+)S"),
177
datetime.timedelta(seconds=1),
178
frozenset((token_end, )))
179
token_minute = Token(re.compile(r"(\d+)M"),
180
datetime.timedelta(minutes=1),
181
frozenset((token_second, token_end)))
182
token_hour = Token(re.compile(r"(\d+)H"),
183
datetime.timedelta(hours=1),
184
frozenset((token_minute, token_end)))
185
token_time = Token(re.compile(r"T"),
187
frozenset((token_hour, token_minute,
189
token_day = Token(re.compile(r"(\d+)D"),
190
datetime.timedelta(days=1),
191
frozenset((token_time, token_end)))
192
token_month = Token(re.compile(r"(\d+)M"),
193
datetime.timedelta(weeks=4),
194
frozenset((token_day, token_end)))
195
token_year = Token(re.compile(r"(\d+)Y"),
196
datetime.timedelta(weeks=52),
197
frozenset((token_month, token_end)))
198
token_week = Token(re.compile(r"(\d+)W"),
199
datetime.timedelta(weeks=1),
200
frozenset((token_end, )))
201
token_duration = Token(re.compile(r"P"), None,
202
frozenset((token_year, token_month,
203
token_day, token_time,
205
# Define starting values:
207
value = datetime.timedelta()
209
# Following valid tokens
210
followers = frozenset((token_duration, ))
211
# String left to parse
213
# Loop until end token is found
214
while found_token is not token_end:
215
# Search for any currently valid tokens
216
for token in followers:
217
match = token.regexp.match(s)
218
if match is not None:
220
if token.value is not None:
221
# Value found, parse digits
222
factor = int(match.group(1), 10)
223
# Add to value so far
224
value += factor * token.value
225
# Strip token from string
226
s = token.regexp.sub("", s, 1)
229
# Set valid next tokens
230
followers = found_token.followers
233
# No currently valid tokens were found
234
raise ValueError("Invalid RFC 3339 duration: {!r}"
73
return ("%(days)s%(hours)02d:%(minutes)02d:%(seconds)02d"
74
% { "days": "%dT" % td.days if td.days else "",
75
"hours": td.seconds // 3600,
76
"minutes": (td.seconds % 3600) // 60,
77
"seconds": td.seconds % 60,
240
80
def string_to_delta(interval):
241
81
"""Parse a string and return a datetime.timedelta
243
>>> string_to_delta('7d')
83
>>> string_to_delta("7d")
244
84
datetime.timedelta(7)
245
>>> string_to_delta('60s')
85
>>> string_to_delta("60s")
246
86
datetime.timedelta(0, 60)
247
>>> string_to_delta('60m')
87
>>> string_to_delta("60m")
248
88
datetime.timedelta(0, 3600)
249
>>> string_to_delta('24h')
89
>>> string_to_delta("24h")
250
90
datetime.timedelta(1)
251
>>> string_to_delta('1w')
91
>>> string_to_delta("1w")
252
92
datetime.timedelta(7)
253
>>> string_to_delta('5m 30s')
93
>>> string_to_delta("5m 30s")
254
94
datetime.timedelta(0, 330)
258
return rfc3339_duration_to_delta(interval)
262
96
value = datetime.timedelta(0)
263
regexp = re.compile(r"(\d+)([dsmhw]?)")
97
regexp = re.compile("(\d+)([dsmhw]?)")
265
99
for num, suffix in regexp.findall(interval):
266
100
if suffix == "d":
267
101
value += datetime.timedelta(int(num))
367
196
parser.add_argument("--approval-duration",
368
197
help="Set duration of one client approval")
369
198
parser.add_argument("-H", "--host", help="Set host for client")
370
parser.add_argument("-s", "--secret",
371
type=argparse.FileType(mode="rb"),
199
parser.add_argument("-s", "--secret", type=file,
372
200
help="Set password blob (file) for client")
373
201
parser.add_argument("-A", "--approve", action="store_true",
374
202
help="Approve any current client request")
375
203
parser.add_argument("-D", "--deny", action="store_true",
376
204
help="Deny any current client request")
377
parser.add_argument("--check", action="store_true",
378
help="Run self-test")
379
205
parser.add_argument("client", nargs="*", help="Client name")
380
206
options = parser.parse_args()
382
if has_actions(options) and not (options.client or options.all):
208
if has_actions(options) and not options.client and not options.all:
383
209
parser.error("Options require clients names or --all.")
384
210
if options.verbose and has_actions(options):
385
parser.error("--verbose can only be used alone.")
386
if options.dump_json and (options.verbose
387
or has_actions(options)):
388
parser.error("--dump-json can only be used alone.")
211
parser.error("--verbose can only be used alone or with"
389
213
if options.all and not has_actions(options):
390
214
parser.error("--all requires an action.")
393
217
bus = dbus.SystemBus()
394
218
mandos_dbus_objc = bus.get_object(busname, server_path)
395
219
except dbus.exceptions.DBusException:
396
log.critical("Could not connect to Mandos server")
220
print("Could not connect to Mandos server",
399
224
mandos_serv = dbus.Interface(mandos_dbus_objc,
400
dbus_interface=server_interface)
401
mandos_serv_object_manager = dbus.Interface(
402
mandos_dbus_objc, dbus_interface=dbus.OBJECT_MANAGER_IFACE)
404
# block stderr since dbus library prints to stderr
225
dbus_interface = server_interface)
227
#block stderr since dbus library prints to stderr
405
228
null = os.open(os.path.devnull, os.O_RDWR)
406
229
stderrcopy = os.dup(sys.stderr.fileno())
407
230
os.dup2(null, sys.stderr.fileno())
411
mandos_clients = {path: ifs_and_props[client_interface]
412
for path, ifs_and_props in
413
mandos_serv_object_manager
414
.GetManagedObjects().items()
415
if client_interface in ifs_and_props}
234
mandos_clients = mandos_serv.GetAllClientsWithProperties()
418
237
os.dup2(stderrcopy, sys.stderr.fileno())
419
238
os.close(stderrcopy)
420
except dbus.exceptions.DBusException as e:
421
log.critical("Failed to access Mandos server through D-Bus:"
239
except dbus.exceptions.DBusException, e:
240
print("Access denied: Accessing mandos server through dbus.",
425
244
# Compile dict of (clients: properties) to process
428
247
if options.all or not options.client:
429
clients = {bus.get_object(busname, path): properties
430
for path, properties in mandos_clients.items()}
248
clients = dict((bus.get_object(busname, path), properties)
249
for path, properties in
250
mandos_clients.iteritems())
432
252
for name in options.client:
433
for path, client in mandos_clients.items():
253
for path, client in mandos_clients.iteritems():
434
254
if client["Name"] == name:
435
255
client_objc = bus.get_object(busname, path)
436
256
clients[client_objc] = client
439
log.critical("Client not found on server: %r", name)
259
print("Client not found on server: %r" % name,
442
263
if not has_actions(options) and clients:
443
if options.verbose or options.dump_json:
444
keywords = ("Name", "Enabled", "Timeout", "LastCheckedOK",
445
"Created", "Interval", "Host", "KeyID",
446
"Fingerprint", "CheckerRunning",
265
keywords = ("Name", "Enabled", "Timeout",
266
"LastCheckedOK", "Created", "Interval",
267
"Host", "Fingerprint", "CheckerRunning",
447
268
"LastEnabled", "ApprovalPending",
448
"ApprovedByDefault", "LastApprovalRequest",
449
"ApprovalDelay", "ApprovalDuration",
450
"Checker", "ExtendedTimeout", "Expires",
270
"LastApprovalRequest", "ApprovalDelay",
271
"ApprovalDuration", "Checker",
453
274
keywords = defaultkeywords
455
if options.dump_json:
456
json.dump({client["Name"]: {key:
458
if isinstance(client[key],
462
for client in clients.values()},
463
fp=sys.stdout, indent=4,
464
separators=(',', ': '))
467
print_clients(clients.values(), keywords)
276
print_clients(clients.values(), keywords)
469
278
# Process each client in the list by all selected options
470
279
for client in clients:
472
def set_client_prop(prop, value):
473
"""Set a Client D-Bus property"""
474
client.Set(client_interface, prop, value,
475
dbus_interface=dbus.PROPERTIES_IFACE)
477
def set_client_prop_ms(prop, value):
478
"""Set a Client D-Bus property, converted
479
from a string to milliseconds."""
480
set_client_prop(prop,
481
string_to_delta(value).total_seconds()
484
280
if options.remove:
485
281
mandos_serv.RemoveClient(client.__dbus_object_path__)
486
282
if options.enable:
487
set_client_prop("Enabled", dbus.Boolean(True))
283
client.Enable(dbus_interface=client_interface)
488
284
if options.disable:
489
set_client_prop("Enabled", dbus.Boolean(False))
285
client.Disable(dbus_interface=client_interface)
490
286
if options.bump_timeout:
491
set_client_prop("LastCheckedOK", "")
287
client.CheckedOK(dbus_interface=client_interface)
492
288
if options.start_checker:
493
set_client_prop("CheckerRunning", dbus.Boolean(True))
289
client.StartChecker(dbus_interface=client_interface)
494
290
if options.stop_checker:
495
set_client_prop("CheckerRunning", dbus.Boolean(False))
291
client.StopChecker(dbus_interface=client_interface)
496
292
if options.is_enabled:
497
if client.Get(client_interface, "Enabled",
498
dbus_interface=dbus.PROPERTIES_IFACE):
293
sys.exit(0 if client.Get(client_interface,
296
dbus.PROPERTIES_IFACE)
502
298
if options.checker is not None:
503
set_client_prop("Checker", options.checker)
299
client.Set(client_interface, "Checker",
301
dbus_interface=dbus.PROPERTIES_IFACE)
504
302
if options.host is not None:
505
set_client_prop("Host", options.host)
303
client.Set(client_interface, "Host", options.host,
304
dbus_interface=dbus.PROPERTIES_IFACE)
506
305
if options.interval is not None:
507
set_client_prop_ms("Interval", options.interval)
306
client.Set(client_interface, "Interval",
307
timedelta_to_milliseconds
308
(string_to_delta(options.interval)),
309
dbus_interface=dbus.PROPERTIES_IFACE)
508
310
if options.approval_delay is not None:
509
set_client_prop_ms("ApprovalDelay",
510
options.approval_delay)
311
client.Set(client_interface, "ApprovalDelay",
312
timedelta_to_milliseconds
313
(string_to_delta(options.
315
dbus_interface=dbus.PROPERTIES_IFACE)
511
316
if options.approval_duration is not None:
512
set_client_prop_ms("ApprovalDuration",
513
options.approval_duration)
317
client.Set(client_interface, "ApprovalDuration",
318
timedelta_to_milliseconds
319
(string_to_delta(options.
321
dbus_interface=dbus.PROPERTIES_IFACE)
514
322
if options.timeout is not None:
515
set_client_prop_ms("Timeout", options.timeout)
323
client.Set(client_interface, "Timeout",
324
timedelta_to_milliseconds
325
(string_to_delta(options.timeout)),
326
dbus_interface=dbus.PROPERTIES_IFACE)
516
327
if options.extended_timeout is not None:
517
set_client_prop_ms("ExtendedTimeout",
518
options.extended_timeout)
328
client.Set(client_interface, "ExtendedTimeout",
329
timedelta_to_milliseconds
330
(string_to_delta(options.extended_timeout)),
331
dbus_interface=dbus.PROPERTIES_IFACE)
519
332
if options.secret is not None:
520
set_client_prop("Secret",
521
dbus.ByteArray(options.secret.read()))
333
client.Set(client_interface, "Secret",
334
dbus.ByteArray(open(options.secret,
336
dbus_interface=dbus.PROPERTIES_IFACE)
522
337
if options.approved_by_default is not None:
523
set_client_prop("ApprovedByDefault",
525
.approved_by_default))
338
client.Set(client_interface, "ApprovedByDefault",
340
.approved_by_default),
341
dbus_interface=dbus.PROPERTIES_IFACE)
526
342
if options.approve:
527
343
client.Approve(dbus.Boolean(True),
528
344
dbus_interface=client_interface)