/mandos/trunk

import logging

import io

import tempfile

 

import dbus

 

                    "ApprovalDuration", "Checker", "ExtendedTimeout",

                    "Expires", "LastCheckerStatus")

    def run(self, mandos, clients):

 

class PropertyCmd(Command):

    """Abstract class for Actions for setting one client property"""

    def run_on_one_client(self, client, properties):

        """Set the Client's D-Bus property"""

                   dbus_interface=dbus.PROPERTIES_IFACE)

 

class ValueArgumentMixIn(object):

    @value_to_set.setter

    def value_to_set(self, value):

        """When setting, convert value to a datetime.timedelta"""

 

# Actual (non-abstract) command classes

 

        keywords = default_keywords

        if self.verbose:

            keywords = self.all_keywords

 

    class TableOfClients(object):

        tableheaders = {

            sys.exit(0)

        sys.exit(1)

    def is_enabled(self, client, properties):

 

class RemoveCmd(Command):

    def run_on_one_client(self, client, properties):

        self.mandos.RemoveClient(client.__dbus_object_path__)

 

class ApproveCmd(Command):

    def run_on_one_client(self, client, properties):

        client.Approve(dbus.Boolean(True),

                       dbus_interface=client_interface)

 

class DenyCmd(Command):

    def run_on_one_client(self, client, properties):

        client.Approve(dbus.Boolean(False),

                       dbus_interface=client_interface)

 

class EnableCmd(PropertyCmd):

    value_to_set = dbus.Boolean(True)

 

class DisableCmd(PropertyCmd):

    value_to_set = dbus.Boolean(False)

 

class BumpTimeoutCmd(PropertyCmd):

    value_to_set = ""

 

class StartCheckerCmd(PropertyCmd):

    value_to_set = dbus.Boolean(True)

 

class StopCheckerCmd(PropertyCmd):

    value_to_set = dbus.Boolean(False)

 

class ApproveByDefaultCmd(PropertyCmd):

    value_to_set = dbus.Boolean(True)

 

class DenyByDefaultCmd(PropertyCmd):

    value_to_set = dbus.Boolean(False)

 

class SetCheckerCmd(PropertyCmd, ValueArgumentMixIn):

 

class SetHostCmd(PropertyCmd, ValueArgumentMixIn):

 

class SetSecretCmd(PropertyCmd, ValueArgumentMixIn):

    @property

    def value_to_set(self):

        return self._vts

        """When setting, read data from supplied file object"""

        self._vts = value.read()

        value.close()

 

class SetTimeoutCmd(PropertyCmd, MillisecondsValueArgumentMixIn):

 

class SetExtendedTimeoutCmd(PropertyCmd,

                            MillisecondsValueArgumentMixIn):

 

class SetIntervalCmd(PropertyCmd, MillisecondsValueArgumentMixIn):

 

class SetApprovalDelayCmd(PropertyCmd,

                          MillisecondsValueArgumentMixIn):

 

class SetApprovalDurationCmd(PropertyCmd,

                             MillisecondsValueArgumentMixIn):

 

def add_command_line_options(parser):

    parser.add_argument("--version", action="version",

                        help="Remove client")

    parser.add_argument("-c", "--checker",

                        help="Set checker command for client")

                        help="Set timeout for client")

                        help="Set extended timeout for client")

                        help="Set checker interval for client")

    approve_deny_default = parser.add_mutually_exclusive_group()

    approve_deny_default.add_argument(

        "--deny-by-default", action="store_false",

        dest="approved_by_default",

        help="Set client to be denied by default")

                        help="Set delay before client approve/deny")

                        help="Set duration of one client approval")

    parser.add_argument("-H", "--host", help="Set host for client")

    parser.add_argument("-s", "--secret",

        help="Approve any current client request")

    approve_deny.add_argument("-D", "--deny", action="store_true",

                              help="Deny any current client request")

    parser.add_argument("--check", action="store_true",

                        help="Run self-test")

    parser.add_argument("client", nargs="*", help="Client name")

    if options.is_enabled:

        commands.append(IsEnabledCmd())

 

    if options.checker is not None:

        commands.append(SetCheckerCmd(options.checker))

 

    if options.deny:

        commands.append(DenyCmd())

 

    # If no command option has been given, show table of clients,

    # optionally verbosely

    if not commands:

    return commands

 

 

 

    if has_actions(options) and not (options.client or options.all):

        parser.error("Options require clients names or --all.")

        parser.error("--all requires an action.")

    if options.is_enabled and len(options.client) > 1:

        parser.error("--is-enabled requires exactly one client")

 

    clientnames = options.client

 

    try:

        bus = dbus.SystemBus()

        mandos_dbus_objc = bus.get_object(busname, server_path)

    except dbus.exceptions.DBusException:

        log.critical("Could not connect to Mandos server")

    dbus_filter = NullFilter()

    try:

        dbus_logger.addFilter(dbus_filter)

        mandos_clients = {path: ifs_and_props[client_interface]

                          for path, ifs_and_props in

                          mandos_serv_object_manager

    clients = {}

 

    if not clientnames:

                   for path, properties in mandos_clients.items()}

    else:

        for name in clientnames:

            for path, client in mandos_clients.items():

                if client["Name"] == name:

                    client_objc = bus.get_object(busname, path)

                    clients[client_objc] = client

                    break

                self.attributes = attributes

                self.attributes["Name"] = name

                self.calls = []

            def Approve(self, approve, dbus_interface):

                testcase.assertEqual(dbus_interface, client_interface)

                self.calls.append(("Approve", (approve,

 

class TestPrintTableCmd(TestCmd):

    def test_normal(self):

        expected_output = """

Name   Enabled Timeout  Last Successful Check

foo    Yes     00:05:00 2019-02-03T00:00:00  

"""[1:-1]

        self.assertEqual(output, expected_output)

    def test_verbose(self):

        expected_output = """

Name   Enabled Timeout  Last Successful Check Created             Interval Host            Key ID                                                           Fingerprint                              Check Is Running Last Enabled        Approval Is Pending Approved By Default Last Approval Request Approval Delay Approval Duration Checker              Extended Timeout Expires             Last Checker Status

foo    Yes     00:05:00 2019-02-03T00:00:00   2019-01-02T00:00:00 00:02:00 foo.example.org 92ed150794387c03ce684574b1139a6594a34f895daaaf09fd8ea90a27cddb12 778827225BA7DE539C5A7CFA59CFF7CDBD9A5920 No               2019-01-03T00:00:00 No                  Yes                                       00:00:00       00:00:01          fping -q -- %(host)s 00:15:00         2019-02-04T00:00:00 0                  

"""[1:-1]

        self.assertEqual(output, expected_output)

    def test_one_client(self):

        expected_output = """

Name Enabled Timeout  Last Successful Check

foo  Yes     00:05:00 2019-02-03T00:00:00  

        for value_to_set, value_to_get in zip(self.values_to_set,

                                              values_to_get):

            for client in self.clients:

                self.assertNotIsInstance(old_value, Unique)

            self.run_command(value_to_set, self.clients)

            for client in self.clients:

                self.assertNotIsInstance(value, Unique)

                self.assertEqual(value, value_to_get)

    def run_command(self, value, clients):

 

class TestBumpTimeoutCmd(TestPropertyCmd):

    command = BumpTimeoutCmd

    values_to_set = [""]

 

class TestStartCheckerCmd(TestPropertyCmd):

    command = StartCheckerCmd

    values_to_set = [dbus.Boolean(True)]

 

class TestStopCheckerCmd(TestPropertyCmd):

    command = StopCheckerCmd

    values_to_set = [dbus.Boolean(False)]

 

class TestApproveByDefaultCmd(TestPropertyCmd):

    command = ApproveByDefaultCmd

    values_to_set = [dbus.Boolean(True)]

 

class TestDenyByDefaultCmd(TestPropertyCmd):

    command = DenyByDefaultCmd

    values_to_set = [dbus.Boolean(False)]

 

class TestValueArgumentPropertyCmd(TestPropertyCmd):

 

class TestSetCheckerCmd(TestValueArgumentPropertyCmd):

    command = SetCheckerCmd

    values_to_set = ["", ":", "fping -q -- %s"]

 

class TestSetHostCmd(TestValueArgumentPropertyCmd):

    command = SetHostCmd

    values_to_set = ["192.0.2.3", "foo.example.org"]

 

class TestSetSecretCmd(TestValueArgumentPropertyCmd):

    command = SetSecretCmd

                     io.BytesIO(b"secret\0xyzzy\nbar")]

    values_to_get = [b"", b"secret\0xyzzy\nbar"]

 

class TestSetTimeoutCmd(TestValueArgumentPropertyCmd):

    command = SetTimeoutCmd

 

class TestSetExtendedTimeoutCmd(TestValueArgumentPropertyCmd):

    command = SetExtendedTimeoutCmd

 

class TestSetIntervalCmd(TestValueArgumentPropertyCmd):

    command = SetIntervalCmd

 

class TestSetApprovalDelayCmd(TestValueArgumentPropertyCmd):

    command = SetApprovalDelayCmd

 

class TestSetApprovalDurationCmd(TestValueArgumentPropertyCmd):

    command = SetApprovalDurationCmd

 

class Test_command_from_options(unittest.TestCase):

    def setUp(self):

        """Assert that parsing ARGS should result in an instance of

COMMAND_CLS with (optionally) all supplied attributes (CMD_ATTRS)."""

        options = self.parser.parse_args(args)

        commands = commands_from_options(options)

        self.assertEqual(len(commands), 1)

        command = commands[0]

        self.assert_command_from_args(["--verbose"], PrintTableCmd,

                                      verbose=True)

 

    def test_enable(self):

        self.assert_command_from_args(["--enable", "foo"], EnableCmd)

 

    def test_disable(self):

        self.assert_command_from_args(["--disable", "foo"],

                                      DisableCmd)

 

    def test_bump_timeout(self):

        self.assert_command_from_args(["--bump-timeout", "foo"],

                                      BumpTimeoutCmd)

 

    def test_start_checker(self):

        self.assert_command_from_args(["--start-checker", "foo"],

                                      StartCheckerCmd)

        self.assert_command_from_args(["--remove", "foo"],

                                      RemoveCmd)

 

    def test_checker(self):

        self.assert_command_from_args(["--checker", ":", "foo"],

                                      SetCheckerCmd, value_to_set=":")

 

    def test_timeout(self):

        self.assert_command_from_args(["--timeout", "PT5M", "foo"],

                                      SetTimeoutCmd,

                                      value_to_set=300000)

 

    def test_extended_timeout(self):

        self.assert_command_from_args(["--extended-timeout", "PT15M",

                                       "foo"],

                                      SetIntervalCmd,

                                      value_to_set=120000)

 

    def test_approve_by_default(self):

        self.assert_command_from_args(["--approve-by-default", "foo"],

                                      ApproveByDefaultCmd)

                                       "foo"], SetHostCmd,

                                      value_to_set="foo.example.org")

 

    def test_secret_devnull(self):

        self.assert_command_from_args(["--secret", os.path.devnull,

                                       "foo"], SetSecretCmd,

                                           "foo"], SetSecretCmd,

                                          value_to_set=value)

 

    def test_approve(self):

        self.assert_command_from_args(["--approve", "foo"],

                                      ApproveCmd)

 

    def test_deny(self):

        self.assert_command_from_args(["--deny", "foo"], DenyCmd)

 

    def test_dump_json(self):

        self.assert_command_from_args(["--dump-json"], DumpJSONCmd)

 

        self.assert_command_from_args(["--is-enabled", "foo"],

                                      IsEnabledCmd)

 

 

 

def should_only_run_tests():