236
def print_clients(clients, keywords):
271
class TableOfClients(object):
274
"Enabled": "Enabled",
275
"Timeout": "Timeout",
276
"LastCheckedOK": "Last Successful Check",
277
"LastApprovalRequest": "Last Approval Request",
278
"Created": "Created",
279
"Interval": "Interval",
281
"Fingerprint": "Fingerprint",
283
"CheckerRunning": "Check Is Running",
284
"LastEnabled": "Last Enabled",
285
"ApprovalPending": "Approval Is Pending",
286
"ApprovedByDefault": "Approved By Default",
287
"ApprovalDelay": "Approval Delay",
288
"ApprovalDuration": "Approval Duration",
289
"Checker": "Checker",
290
"ExtendedTimeout": "Extended Timeout",
291
"Expires": "Expires",
292
"LastCheckerStatus": "Last Checker Status",
295
def __init__(self, clients, keywords, tableheaders=None):
296
self.clients = clients
297
self.keywords = keywords
298
if tableheaders is not None:
299
self.tableheaders = tableheaders
302
return "\n".join(self.rows())
304
if sys.version_info.major == 2:
305
__unicode__ = __str__
307
return str(self).encode(locale.getpreferredencoding())
310
format_string = self.row_formatting_string()
311
rows = [self.header_line(format_string)]
312
rows.extend(self.client_line(client, format_string)
313
for client in self.clients)
316
def row_formatting_string(self):
317
"Format string used to format table rows"
318
return " ".join("{{{key}:{width}}}".format(
319
width=max(len(self.tableheaders[key]),
320
*(len(self.string_from_client(client, key))
321
for client in self.clients)),
323
for key in self.keywords)
325
def string_from_client(self, client, key):
326
return self.valuetostring(client[key], key)
237
329
def valuetostring(value, keyword):
238
if type(value) is dbus.Boolean:
330
if isinstance(value, dbus.Boolean):
239
331
return "Yes" if value else "No"
240
332
if keyword in ("Timeout", "Interval", "ApprovalDelay",
241
333
"ApprovalDuration", "ExtendedTimeout"):
242
334
return milliseconds_to_string(value)
243
335
return str(value)
245
# Create format string to print table rows
246
format_string = " ".join("{{{key}:{width}}}".format(
247
width=max(len(tablewords[key]),
248
max(len(valuetostring(client[key], key))
249
for client in clients)),
253
print(format_string.format(**tablewords))
254
for client in clients:
256
.format(**{key: valuetostring(client[key], key)
257
for key in keywords}))
337
def header_line(self, format_string):
338
return format_string.format(**self.tableheaders)
340
def client_line(self, client, format_string):
341
return format_string.format(
342
**{key: self.string_from_client(client, key)
343
for key in self.keywords})
346
## Classes for commands.
348
# Abstract classes first
349
class Command(object):
350
"""Abstract class for commands"""
351
def run(self, mandos, clients):
352
"""Normal commands should implement run_on_one_client(), but
353
commands which want to operate on all clients at the same time
354
can override this run() method instead."""
356
for client in clients:
357
self.run_on_one_client(client)
359
class PrintCmd(Command):
360
"""Abstract class for commands printing client details"""
361
all_keywords = ("Name", "Enabled", "Timeout", "LastCheckedOK",
362
"Created", "Interval", "Host", "KeyID",
363
"Fingerprint", "CheckerRunning", "LastEnabled",
364
"ApprovalPending", "ApprovedByDefault",
365
"LastApprovalRequest", "ApprovalDelay",
366
"ApprovalDuration", "Checker", "ExtendedTimeout",
367
"Expires", "LastCheckerStatus")
368
def run(self, mandos, clients):
369
print(self.output(clients))
371
class PropertyCmd(Command):
372
"""Abstract class for Actions for setting one client property"""
373
def run_on_one_client(self, client):
374
"""Set the Client's D-Bus property"""
375
client.Set(client_interface, self.property, self.value_to_set,
376
dbus_interface=dbus.PROPERTIES_IFACE)
378
class ValueArgumentMixIn(object):
379
"""Mixin class for commands taking a value as argument"""
380
def __init__(self, value):
381
self.value_to_set = value
383
class MillisecondsValueArgumentMixIn(ValueArgumentMixIn):
384
"""Mixin class for commands taking a value argument as
387
def value_to_set(self):
390
def value_to_set(self, value):
391
"""When setting, convert value to a datetime.timedelta"""
392
self._vts = string_to_delta(value).total_seconds() * 1000
394
# Actual (non-abstract) command classes
396
class PrintTableCmd(PrintCmd):
397
def __init__(self, verbose=False):
398
self.verbose = verbose
399
def output(self, clients):
401
keywords = self.all_keywords
403
keywords = ("Name", "Enabled", "Timeout", "LastCheckedOK")
404
return str(TableOfClients(clients.values(), keywords))
406
class DumpJSONCmd(PrintCmd):
407
def output(self, clients):
408
data = {client["Name"]:
409
{key: self.dbus_boolean_to_bool(client[key])
410
for key in self.all_keywords}
411
for client in clients.values()}
412
return json.dumps(data, indent=4, separators=(',', ': '))
414
def dbus_boolean_to_bool(value):
415
if isinstance(value, dbus.Boolean):
419
class IsEnabledCmd(Command):
420
def run_on_one_client(self, client):
421
if self.is_enabled(client):
424
def is_enabled(self, client):
425
return client.Get(client_interface, "Enabled",
426
dbus_interface=dbus.PROPERTIES_IFACE)
428
class RemoveCmd(Command):
429
def run_on_one_client(self, client):
430
self.mandos.RemoveClient(client.__dbus_object_path__)
432
class ApproveCmd(Command):
433
def run_on_one_client(self, client):
434
client.Approve(dbus.Boolean(True),
435
dbus_interface=client_interface)
437
class DenyCmd(Command):
438
def run_on_one_client(self, client):
439
client.Approve(dbus.Boolean(False),
440
dbus_interface=client_interface)
442
class EnableCmd(PropertyCmd):
444
value_to_set = dbus.Boolean(True)
446
class DisableCmd(PropertyCmd):
448
value_to_set = dbus.Boolean(False)
450
class BumpTimeoutCmd(PropertyCmd):
451
property = "LastCheckedOK"
454
class StartCheckerCmd(PropertyCmd):
455
property = "CheckerRunning"
456
value_to_set = dbus.Boolean(True)
458
class StopCheckerCmd(PropertyCmd):
459
property = "CheckerRunning"
460
value_to_set = dbus.Boolean(False)
462
class ApproveByDefaultCmd(PropertyCmd):
463
property = "ApprovedByDefault"
464
value_to_set = dbus.Boolean(True)
466
class DenyByDefaultCmd(PropertyCmd):
467
property = "ApprovedByDefault"
468
value_to_set = dbus.Boolean(False)
470
class SetCheckerCmd(PropertyCmd, ValueArgumentMixIn):
473
class SetHostCmd(PropertyCmd, ValueArgumentMixIn):
476
class SetSecretCmd(PropertyCmd, ValueArgumentMixIn):
479
class SetTimeoutCmd(PropertyCmd, MillisecondsValueArgumentMixIn):
482
class SetExtendedTimeoutCmd(PropertyCmd,
483
MillisecondsValueArgumentMixIn):
484
property = "ExtendedTimeout"
486
class SetIntervalCmd(PropertyCmd, MillisecondsValueArgumentMixIn):
487
property = "Interval"
489
class SetApprovalDelayCmd(PropertyCmd,
490
MillisecondsValueArgumentMixIn):
491
property = "ApprovalDelay"
493
class SetApprovalDurationCmd(PropertyCmd,
494
MillisecondsValueArgumentMixIn):
495
property = "ApprovalDuration"
260
497
def has_actions(options):
261
498
return any((options.enable,
343
590
parser.error("--dump-json can only be used alone.")
344
591
if options.all and not has_actions(options):
345
592
parser.error("--all requires an action.")
348
fail_count, test_count = doctest.testmod()
349
sys.exit(os.EX_OK if fail_count == 0 else 1)
593
if options.is_enabled and len(options.client) > 1:
594
parser.error("--is-enabled requires exactly one client")
598
if options.dump_json:
599
commands.append(DumpJSONCmd())
602
commands.append(EnableCmd())
605
commands.append(DisableCmd())
607
if options.bump_timeout:
608
commands.append(BumpTimeoutCmd(options.bump_timeout))
610
if options.start_checker:
611
commands.append(StartCheckerCmd())
613
if options.stop_checker:
614
commands.append(StopCheckerCmd())
616
if options.is_enabled:
617
commands.append(IsEnabledCmd())
620
commands.append(RemoveCmd())
622
if options.checker is not None:
623
commands.append(SetCheckerCmd())
625
if options.timeout is not None:
626
commands.append(SetTimeoutCmd(options.timeout))
628
if options.extended_timeout:
630
SetExtendedTimeoutCmd(options.extended_timeout))
632
if options.interval is not None:
633
command.append(SetIntervalCmd(options.interval))
635
if options.approved_by_default is not None:
636
if options.approved_by_default:
637
command.append(ApproveByDefaultCmd())
639
command.append(DenyByDefaultCmd())
641
if options.approval_delay is not None:
642
command.append(SetApprovalDelayCmd(options.approval_delay))
644
if options.approval_duration is not None:
646
SetApprovalDurationCmd(options.approval_duration))
648
if options.host is not None:
649
command.append(SetHostCmd(options.host))
651
if options.secret is not None:
652
command.append(SetSecretCmd(options.secret))
655
commands.append(ApproveCmd())
658
commands.append(DenyCmd())
660
# If no command option has been given, show table of clients,
661
# optionally verbosely
663
commands.append(PrintTableCmd(verbose=options.verbose))
665
return commands, options.client
669
commands, clientnames = commands_and_clients_from_options()
352
672
bus = dbus.SystemBus()
353
673
mandos_dbus_objc = bus.get_object(busname, server_path)
354
674
except dbus.exceptions.DBusException:
355
print("Could not connect to Mandos server", file=sys.stderr)
675
log.critical("Could not connect to Mandos server")
358
678
mandos_serv = dbus.Interface(mandos_dbus_objc,
373
695
.GetManagedObjects().items()
374
696
if client_interface in ifs_and_props}
377
os.dup2(stderrcopy, sys.stderr.fileno())
698
# restore dbus logger
699
dbus_logger.removeFilter(dbus_filter)
379
700
except dbus.exceptions.DBusException as e:
380
print("Access denied: "
381
"Accessing mandos server through D-Bus: {}".format(e),
701
log.critical("Failed to access Mandos server through D-Bus:"
385
705
# Compile dict of (clients: properties) to process
388
if options.all or not options.client:
389
709
clients = {bus.get_object(busname, path): properties
390
710
for path, properties in mandos_clients.items()}
392
for name in options.client:
712
for name in clientnames:
393
713
for path, client in mandos_clients.items():
394
714
if client["Name"] == name:
395
715
client_objc = bus.get_object(busname, path)
396
716
clients[client_objc] = client
399
print("Client not found on server: {!r}"
400
.format(name), file=sys.stderr)
719
log.critical("Client not found on server: %r", name)
403
if not has_actions(options) and clients:
404
if options.verbose or options.dump_json:
405
keywords = ("Name", "Enabled", "Timeout", "LastCheckedOK",
406
"Created", "Interval", "Host", "Fingerprint",
407
"CheckerRunning", "LastEnabled",
408
"ApprovalPending", "ApprovedByDefault",
409
"LastApprovalRequest", "ApprovalDelay",
410
"ApprovalDuration", "Checker",
411
"ExtendedTimeout", "Expires",
414
keywords = defaultkeywords
416
if options.dump_json:
417
json.dump({client["Name"]: {key:
419
if isinstance(client[key],
423
for client in clients.values()},
424
fp=sys.stdout, indent=4,
425
separators=(',', ': '))
428
print_clients(clients.values(), keywords)
430
# Process each client in the list by all selected options
431
for client in clients:
433
def set_client_prop(prop, value):
434
"""Set a Client D-Bus property"""
435
client.Set(client_interface, prop, value,
436
dbus_interface=dbus.PROPERTIES_IFACE)
438
def set_client_prop_ms(prop, value):
439
"""Set a Client D-Bus property, converted
440
from a string to milliseconds."""
441
set_client_prop(prop,
442
string_to_delta(value).total_seconds()
446
mandos_serv.RemoveClient(client.__dbus_object_path__)
448
set_client_prop("Enabled", dbus.Boolean(True))
450
set_client_prop("Enabled", dbus.Boolean(False))
451
if options.bump_timeout:
452
set_client_prop("LastCheckedOK", "")
453
if options.start_checker:
454
set_client_prop("CheckerRunning", dbus.Boolean(True))
455
if options.stop_checker:
456
set_client_prop("CheckerRunning", dbus.Boolean(False))
457
if options.is_enabled:
458
if client.Get(client_interface, "Enabled",
459
dbus_interface=dbus.PROPERTIES_IFACE):
463
if options.checker is not None:
464
set_client_prop("Checker", options.checker)
465
if options.host is not None:
466
set_client_prop("Host", options.host)
467
if options.interval is not None:
468
set_client_prop_ms("Interval", options.interval)
469
if options.approval_delay is not None:
470
set_client_prop_ms("ApprovalDelay",
471
options.approval_delay)
472
if options.approval_duration is not None:
473
set_client_prop_ms("ApprovalDuration",
474
options.approval_duration)
475
if options.timeout is not None:
476
set_client_prop_ms("Timeout", options.timeout)
477
if options.extended_timeout is not None:
478
set_client_prop_ms("ExtendedTimeout",
479
options.extended_timeout)
480
if options.secret is not None:
481
set_client_prop("Secret",
482
dbus.ByteArray(options.secret.read()))
483
if options.approved_by_default is not None:
484
set_client_prop("ApprovedByDefault",
486
.approved_by_default))
488
client.Approve(dbus.Boolean(True),
489
dbus_interface=client_interface)
491
client.Approve(dbus.Boolean(False),
492
dbus_interface=client_interface)
722
# Run all commands on clients
723
for command in commands:
724
command.run(mandos_serv, clients)
727
class Test_milliseconds_to_string(unittest.TestCase):
729
self.assertEqual(milliseconds_to_string(93785000),
731
def test_no_days(self):
732
self.assertEqual(milliseconds_to_string(7385000), "02:03:05")
733
def test_all_zero(self):
734
self.assertEqual(milliseconds_to_string(0), "00:00:00")
735
def test_no_fractional_seconds(self):
736
self.assertEqual(milliseconds_to_string(400), "00:00:00")
737
self.assertEqual(milliseconds_to_string(900), "00:00:00")
738
self.assertEqual(milliseconds_to_string(1900), "00:00:01")
740
class Test_string_to_delta(unittest.TestCase):
741
def test_handles_basic_rfc3339(self):
742
self.assertEqual(string_to_delta("PT2H"),
743
datetime.timedelta(0, 7200))
744
def test_falls_back_to_pre_1_6_1_with_warning(self):
745
# assertLogs only exists in Python 3.4
746
if hasattr(self, "assertLogs"):
747
with self.assertLogs(log, logging.WARNING):
748
value = string_to_delta("2h")
750
class WarningFilter(logging.Filter):
751
"""Don't show, but record the presence of, warnings"""
752
def filter(self, record):
753
is_warning = record.levelno >= logging.WARNING
754
self.found = is_warning or getattr(self, "found",
756
return not is_warning
757
warning_filter = WarningFilter()
758
log.addFilter(warning_filter)
760
value = string_to_delta("2h")
762
log.removeFilter(warning_filter)
763
self.assertTrue(getattr(warning_filter, "found", False))
764
self.assertEqual(value, datetime.timedelta(0, 7200))
766
class Test_TableOfClients(unittest.TestCase):
768
self.tableheaders = {
772
"Bool": "A D-BUS Boolean",
773
"NonDbusBoolean": "A Non-D-BUS Boolean",
774
"Integer": "An Integer",
775
"Timeout": "Timedelta 1",
776
"Interval": "Timedelta 2",
777
"ApprovalDelay": "Timedelta 3",
778
"ApprovalDuration": "Timedelta 4",
779
"ExtendedTimeout": "Timedelta 5",
780
"String": "A String",
782
self.keywords = ["Attr1", "AttrTwo"]
788
"Bool": dbus.Boolean(False),
789
"NonDbusBoolean": False,
793
"ApprovalDelay": 2000,
794
"ApprovalDuration": 3000,
795
"ExtendedTimeout": 4000,
802
"Bool": dbus.Boolean(True),
803
"NonDbusBoolean": True,
806
"Interval": 93786000,
807
"ApprovalDelay": 93787000,
808
"ApprovalDuration": 93788000,
809
"ExtendedTimeout": 93789000,
810
"String": "A huge string which will not fit," * 10,
813
def test_short_header(self):
814
text = str(TableOfClients(self.clients, self.keywords,
821
self.assertEqual(text, expected_text)
822
def test_booleans(self):
823
keywords = ["Bool", "NonDbusBoolean"]
824
text = str(TableOfClients(self.clients, keywords,
827
A D-BUS Boolean A Non-D-BUS Boolean
831
self.assertEqual(text, expected_text)
832
def test_milliseconds_detection(self):
833
keywords = ["Integer", "Timeout", "Interval", "ApprovalDelay",
834
"ApprovalDuration", "ExtendedTimeout"]
835
text = str(TableOfClients(self.clients, keywords,
838
An Integer Timedelta 1 Timedelta 2 Timedelta 3 Timedelta 4 Timedelta 5
839
0 00:00:00 00:00:01 00:00:02 00:00:03 00:00:04
840
1 1T02:03:05 1T02:03:06 1T02:03:07 1T02:03:08 1T02:03:09
842
self.assertEqual(text, expected_text)
843
def test_empty_and_long_string_values(self):
844
keywords = ["String"]
845
text = str(TableOfClients(self.clients, keywords,
850
A huge string which will not fit,A huge string which will not fit,A huge string which will not fit,A huge string which will not fit,A huge string which will not fit,A huge string which will not fit,A huge string which will not fit,A huge string which will not fit,A huge string which will not fit,A huge string which will not fit,
852
self.assertEqual(text, expected_text)
856
def should_only_run_tests():
857
parser = argparse.ArgumentParser(add_help=False)
858
parser.add_argument("--check", action='store_true')
859
args, unknown_args = parser.parse_known_args()
860
run_tests = args.check
862
# Remove --check argument from sys.argv
863
sys.argv[1:] = unknown_args
866
# Add all tests from doctest strings
867
def load_tests(loader, tests, none):
869
tests.addTests(doctest.DocTestSuite())
495
872
if __name__ == "__main__":
873
if should_only_run_tests():
874
# Call using ./tdd-python-script --check [--verbose]