/mandos/trunk

import logging

import io

import tempfile

 

import dbus

 

 

locale.setlocale(locale.LC_ALL, "")

 

version = "1.8.3"

 

 

# Abstract classes first

class Command(object):

    """Abstract class for commands"""

        """Normal commands should implement run_on_one_client(), but

        commands which want to operate on all clients at the same time

        can override this run() method instead."""

        self.mandos = mandos

            self.run_on_one_client(client, properties)

 

class PrintCmd(Command):

                    "LastApprovalRequest", "ApprovalDelay",

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

                    "Expires", "LastCheckerStatus")

 

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)

 

    def __init__(self, value):

        self.value_to_set = value

 

    @property

    def value_to_set(self):

        return self._vts

    @value_to_set.setter

    def value_to_set(self, value):

        self._vts = int(round(value.total_seconds() * 1000))

 

# Actual (non-abstract) command classes

        keywords = default_keywords

        if self.verbose:

            keywords = self.all_keywords

 

    class TableOfClients(object):

        tableheaders = {

        return value

 

class IsEnabledCmd(Command):

        if self.is_enabled(client, properties):

            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),

 

class DenyCmd(Command):

    def run_on_one_client(self, client, properties):

        client.Approve(dbus.Boolean(False),

 

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)

 

    @property

    def value_to_set(self):

        return self._vts

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

        self._vts = value.read()

        value.close()

 

def add_command_line_options(parser):

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

        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:

 

 

def check_option_syntax(parser, options):

 

    def has_actions(options):

        return any((options.enable,

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

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

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

 

 

def main():

 

    clientnames = options.client

 

    try:

        bus = dbus.SystemBus()

    except dbus.exceptions.DBusException:

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

        sys.exit(1)

 

    mandos_serv = dbus.Interface(mandos_dbus_objc,

    mandos_serv_object_manager = dbus.Interface(

        mandos_dbus_objc, dbus_interface=dbus.OBJECT_MANAGER_IFACE)

 

    dbus_filter = NullFilter()

    try:

        dbus_logger.addFilter(dbus_filter)

                          for path, ifs_and_props in

                          mandos_serv_object_manager

                          .GetManagedObjects().items()

    except dbus.exceptions.DBusException as e:

        log.critical("Failed to access Mandos server through D-Bus:"

                     "\n%s", e)

    clients = {}

 

    if not clientnames:

    else:

        for name in clientnames:

                    break

            else:

                log.critical("Client not found on server: %r", name)

    # Run all commands on clients

    commands = commands_from_options(options)

    for command in commands:

 

 

class Test_milliseconds_to_string(unittest.TestCase):

        testcase = self

        class MockClient(object):

            def __init__(self, name, **attributes):

                self.attributes = attributes

                self.attributes["Name"] = name

                self.calls = []

            def Approve(self, approve, dbus_interface):

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

                                               dbus_interface)))

        self.client = MockClient(

            LastCheckerStatus=-2)

        self.clients =  collections.OrderedDict(

            [

            ])

 

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 client, properties in self.clients.items()))

    def test_is_enabled_run_exits_successfully(self):

        with self.assertRaises(SystemExit) as e:

        if e.exception.code is not None:

            self.assertEqual(e.exception.code, 0)

        else:

    def test_is_enabled_run_exits_with_failure(self):

        self.client.attributes["Enabled"] = dbus.Boolean(False)

        with self.assertRaises(SystemExit) as e:

        if isinstance(e.exception.code, int):

            self.assertNotEqual(e.exception.code, 0)

        else:

                self.calls.append(("RemoveClient", (dbus_path,)))

        mandos = MockMandos()

        super(TestRemoveCmd, self).setUp()

        self.assertEqual(len(mandos.calls), 2)

                          mandos.calls)

 

class TestApproveCmd(TestCmd):

    def test_approve(self):

                          client.calls)

 

class TestDenyCmd(TestCmd):

    def test_deny(self):

                          client.calls)

 

class TestEnableCmd(TestCmd):

    def test_enable(self):

            client.attributes["Enabled"] = False

 

 

            self.assertTrue(client.attributes["Enabled"])

 

class TestDisableCmd(TestCmd):

    def test_disable(self):

            self.assertFalse(client.attributes["Enabled"])

 

class Unique(object):

                                self.values_to_set)

        for value_to_set, value_to_get in zip(self.values_to_set,

                                              values_to_get):

                self.assertNotIsInstance(old_value, Unique)

            self.run_command(value_to_set, 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)]

 

    def runTest(self):

            return

    def run_command(self, value, clients):

 

    command = SetCheckerCmd

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

 

    command = SetHostCmd

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

 

    command = SetSecretCmd

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

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

 

    command = SetTimeoutCmd

    values_to_set = [datetime.timedelta(),

                     datetime.timedelta(minutes=5),

                     datetime.timedelta(seconds=1),

                     datetime.timedelta(weeks=52)]

    values_to_get = [0, 300000, 1000, 604800000, 31449600000]

 

    command = SetExtendedTimeoutCmd

    values_to_set = [datetime.timedelta(),

                     datetime.timedelta(minutes=5),

                     datetime.timedelta(seconds=1),

                     datetime.timedelta(weeks=52)]

    values_to_get = [0, 300000, 1000, 604800000, 31449600000]

 

    command = SetIntervalCmd

    values_to_set = [datetime.timedelta(),

                     datetime.timedelta(minutes=5),

                     datetime.timedelta(seconds=1),

                     datetime.timedelta(weeks=52)]

    values_to_get = [0, 300000, 1000, 604800000, 31449600000]

 

    command = SetApprovalDelayCmd

    values_to_set = [datetime.timedelta(),

                     datetime.timedelta(minutes=5),

                     datetime.timedelta(seconds=1),

                     datetime.timedelta(weeks=52)]

    values_to_get = [0, 300000, 1000, 604800000, 31449600000]

 

    command = SetApprovalDurationCmd

    values_to_set = [datetime.timedelta(),

                     datetime.timedelta(minutes=5),

                     datetime.timedelta(seconds=1),

    def test_is_enabled_short(self):

        self.assert_command_from_args(["-V", "foo"], IsEnabledCmd)

 

 

 

def should_only_run_tests():