72
52
"ApprovalDelay": "Approval Delay",
73
53
"ApprovalDuration": "Approval Duration",
74
54
"Checker": "Checker",
75
"ExtendedTimeout": "Extended Timeout",
77
"LastCheckerStatus": "Last Checker Status",
55
"ExtendedTimeout" : "Extended Timeout"
79
57
defaultkeywords = ("Name", "Enabled", "Timeout", "LastCheckedOK")
80
domain = "se.recompile"
58
domain = "se.bsnet.fukt"
81
59
busname = domain + ".Mandos"
83
61
server_interface = domain + ".Mandos"
84
62
client_interface = domain + ".Mandos.Client"
89
dbus.OBJECT_MANAGER_IFACE
90
except AttributeError:
91
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))
94
71
def milliseconds_to_string(ms):
95
72
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}"
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,
202
80
def string_to_delta(interval):
203
81
"""Parse a string and return a datetime.timedelta
205
>>> string_to_delta('7d')
83
>>> string_to_delta("7d")
206
84
datetime.timedelta(7)
207
>>> string_to_delta('60s')
85
>>> string_to_delta("60s")
208
86
datetime.timedelta(0, 60)
209
>>> string_to_delta('60m')
87
>>> string_to_delta("60m")
210
88
datetime.timedelta(0, 3600)
211
>>> string_to_delta('24h')
89
>>> string_to_delta("24h")
212
90
datetime.timedelta(1)
213
>>> string_to_delta('1w')
91
>>> string_to_delta("1w")
214
92
datetime.timedelta(7)
215
>>> string_to_delta('5m 30s')
93
>>> string_to_delta("5m 30s")
216
94
datetime.timedelta(0, 330)
220
return rfc3339_duration_to_delta(interval)
224
value = datetime.timedelta(0)
225
regexp = re.compile(r"(\d+)([dsmhw]?)")
227
for num, suffix in regexp.findall(interval):
229
value += datetime.timedelta(int(num))
231
value += datetime.timedelta(0, int(num))
233
value += datetime.timedelta(0, 0, 0, 0, int(num))
235
value += datetime.timedelta(0, 0, 0, 0, 0, int(num))
237
value += datetime.timedelta(0, 0, 0, 0, 0, 0, int(num))
239
value += datetime.timedelta(0, 0, 0, int(num))
96
timevalue = datetime.timedelta(0)
97
regexp = re.compile("\d+[dsmhw]")
99
for s in regexp.findall(interval):
101
suffix = unicode(s[-1])
104
delta = datetime.timedelta(value)
106
delta = datetime.timedelta(0, value)
108
delta = datetime.timedelta(0, 0, 0, 0, value)
110
delta = datetime.timedelta(0, 0, 0, 0, 0, value)
112
delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
115
except (ValueError, IndexError):
243
120
def print_clients(clients, keywords):
244
121
def valuetostring(value, keyword):
245
122
if type(value) is dbus.Boolean:
246
123
return "Yes" if value else "No"
247
124
if keyword in ("Timeout", "Interval", "ApprovalDelay",
248
"ApprovalDuration", "ExtendedTimeout"):
249
126
return milliseconds_to_string(value)
127
return unicode(value)
252
129
# Create format string to print table rows
253
format_string = " ".join("{{{key}:{width}}}".format(
254
width=max(len(tablewords[key]),
255
max(len(valuetostring(client[key], key))
256
for client in clients)),
130
format_string = " ".join("%%-%ds" %
131
max(len(tablewords[key]),
132
max(len(valuetostring(client[key],
258
136
for key in keywords)
259
137
# Print header line
260
print(format_string.format(**tablewords))
138
print(format_string % tuple(tablewords[key] for key in keywords))
261
139
for client in clients:
263
.format(**{key: valuetostring(client[key], key)
264
for key in keywords}))
140
print(format_string % tuple(valuetostring(client[key], key)
141
for key in keywords))
267
143
def has_actions(options):
268
144
return any((options.enable,
329
202
parser.add_argument("--approval-duration",
330
203
help="Set duration of one client approval")
331
204
parser.add_argument("-H", "--host", help="Set host for client")
332
parser.add_argument("-s", "--secret",
333
type=argparse.FileType(mode="rb"),
205
parser.add_argument("-s", "--secret", type=file,
334
206
help="Set password blob (file) for client")
335
207
parser.add_argument("-A", "--approve", action="store_true",
336
208
help="Approve any current client request")
337
209
parser.add_argument("-D", "--deny", action="store_true",
338
210
help="Deny any current client request")
339
parser.add_argument("--check", action="store_true",
340
help="Run self-test")
341
211
parser.add_argument("client", nargs="*", help="Client name")
342
212
options = parser.parse_args()
344
if has_actions(options) and not (options.client or options.all):
214
if has_actions(options) and not options.client and not options.all:
345
215
parser.error("Options require clients names or --all.")
346
216
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.")
217
parser.error("--verbose can only be used alone or with"
351
219
if options.all and not has_actions(options):
352
220
parser.error("--all requires an action.")
355
223
bus = dbus.SystemBus()
356
224
mandos_dbus_objc = bus.get_object(busname, server_path)
357
225
except dbus.exceptions.DBusException:
358
log.critical("Could not connect to Mandos server")
226
print("Could not connect to Mandos server",
361
230
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
231
dbus_interface = server_interface)
233
#block stderr since dbus library prints to stderr
367
234
null = os.open(os.path.devnull, os.O_RDWR)
368
235
stderrcopy = os.dup(sys.stderr.fileno())
369
236
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}
240
mandos_clients = mandos_serv.GetAllClientsWithProperties()
380
243
os.dup2(stderrcopy, sys.stderr.fileno())
381
244
os.close(stderrcopy)
382
except dbus.exceptions.DBusException as e:
383
log.critical("Failed to access Mandos server through D-Bus:"
245
except dbus.exceptions.DBusException, e:
246
print("Access denied: Accessing mandos server through dbus.",
387
250
# Compile dict of (clients: properties) to process
390
253
if options.all or not options.client:
391
clients = {bus.get_object(busname, path): properties
392
for path, properties in mandos_clients.items()}
254
clients = dict((bus.get_object(busname, path), properties)
255
for path, properties in
256
mandos_clients.iteritems())
394
258
for name in options.client:
395
for path, client in mandos_clients.items():
259
for path, client in mandos_clients.iteritems():
396
260
if client["Name"] == name:
397
261
client_objc = bus.get_object(busname, path)
398
262
clients[client_objc] = client
401
log.critical("Client not found on server: %r", name)
265
print("Client not found on server: %r" % name,
404
269
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",
271
keywords = ("Name", "Enabled", "Timeout",
272
"LastCheckedOK", "Created", "Interval",
273
"Host", "Fingerprint", "CheckerRunning",
409
274
"LastEnabled", "ApprovalPending",
410
"ApprovedByDefault", "LastApprovalRequest",
411
"ApprovalDelay", "ApprovalDuration",
412
"Checker", "ExtendedTimeout", "Expires",
276
"LastApprovalRequest", "ApprovalDelay",
277
"ApprovalDuration", "Checker",
415
280
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)
282
print_clients(clients.values(), keywords)
431
284
# Process each client in the list by all selected options
432
285
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()
446
286
if options.remove:
447
287
mandos_serv.RemoveClient(client.__dbus_object_path__)
448
288
if options.enable:
449
set_client_prop("Enabled", dbus.Boolean(True))
289
client.Enable(dbus_interface=client_interface)
450
290
if options.disable:
451
set_client_prop("Enabled", dbus.Boolean(False))
291
client.Disable(dbus_interface=client_interface)
452
292
if options.bump_timeout:
453
set_client_prop("LastCheckedOK", "")
293
client.CheckedOK(dbus_interface=client_interface)
454
294
if options.start_checker:
455
set_client_prop("CheckerRunning", dbus.Boolean(True))
295
client.StartChecker(dbus_interface=client_interface)
456
296
if options.stop_checker:
457
set_client_prop("CheckerRunning", dbus.Boolean(False))
297
client.StopChecker(dbus_interface=client_interface)
458
298
if options.is_enabled:
459
if client.Get(client_interface, "Enabled",
460
dbus_interface=dbus.PROPERTIES_IFACE):
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()))
299
sys.exit(0 if client.Get(client_interface,
302
dbus.PROPERTIES_IFACE)
305
client.Set(client_interface, "Checker",
307
dbus_interface=dbus.PROPERTIES_IFACE)
309
client.Set(client_interface, "Host", options.host,
310
dbus_interface=dbus.PROPERTIES_IFACE)
312
client.Set(client_interface, "Interval",
313
timedelta_to_milliseconds
314
(string_to_delta(options.interval)),
315
dbus_interface=dbus.PROPERTIES_IFACE)
316
if options.approval_delay:
317
client.Set(client_interface, "ApprovalDelay",
318
timedelta_to_milliseconds
319
(string_to_delta(options.
321
dbus_interface=dbus.PROPERTIES_IFACE)
322
if options.approval_duration:
323
client.Set(client_interface, "ApprovalDuration",
324
timedelta_to_milliseconds
325
(string_to_delta(options.
327
dbus_interface=dbus.PROPERTIES_IFACE)
329
client.Set(client_interface, "Timeout",
330
timedelta_to_milliseconds
331
(string_to_delta(options.timeout)),
332
dbus_interface=dbus.PROPERTIES_IFACE)
333
if options.extended_timeout:
334
client.Set(client_interface, "ExtendedTimeout",
335
timedelta_to_milliseconds
336
(string_to_delta(options.extended_timeout)),
337
dbus_interface=dbus.PROPERTIES_IFACE)
339
client.Set(client_interface, "Secret",
340
dbus.ByteArray(open(options.secret,
342
dbus_interface=dbus.PROPERTIES_IFACE)
484
343
if options.approved_by_default is not None:
485
set_client_prop("ApprovedByDefault",
487
.approved_by_default))
344
client.Set(client_interface, "ApprovedByDefault",
346
.approved_by_default),
347
dbus_interface=dbus.PROPERTIES_IFACE)
488
348
if options.approve:
489
349
client.Approve(dbus.Boolean(True),
490
350
dbus_interface=client_interface)