def setUp(self): RoutersploitInterpreter.setup = mock.Mock() self.interpreter = RoutersploitInterpreter() self.interpreter.current_module = mock.MagicMock() self.raw_prompt_default = "\001\033[4m\002rsf\001\033[0m\002 > " self.module_prompt_default = lambda x: "\001\033[4m\002rsf\001\033[0m\002 (\001\033[91m\002{}\001\033[0m\002) > ".format( x)
def setUp(self): RoutersploitInterpreter.setup = mock.Mock() self.interpreter = RoutersploitInterpreter() self.interpreter.current_module = mock.MagicMock() self.raw_prompt_default = "\001\033[4m\002rsf\001\033[0m\002 > " self.module_prompt_default = lambda x: "\001\033[4m\002rsf\001\033[0m\002 (\001\033[91m\002{}\001\033[0m\002) > ".format(x) GLOBAL_OPTS.clear()
def setUp(self): RoutersploitInterpreter.setup = mock.Mock() self.interpreter = RoutersploitInterpreter() self.interpreter.current_module = mock.MagicMock() self.raw_prompt_default = "\033[4mrsf\033[0m > " self.module_prompt_default = lambda x: "\033[4mrsf\033[0m (\033[91m{}\033[0m) > ".format(x)
class RoutersploitInterpreterTest(unittest.TestCase): def setUp(self): RoutersploitInterpreter.setup = mock.Mock() self.interpreter = RoutersploitInterpreter() self.interpreter.current_module = mock.MagicMock() self.raw_prompt_default = "\033[4mrsf\033[0m > " self.module_prompt_default = lambda x: "\033[4mrsf\033[0m (\033[91m{}\033[0m) > ".format(x) def prepare_prompt_env_variables(self, raw_prompt=None, module_prompt=None): if raw_prompt: os.environ["RSF_RAW_PROMPT"] = raw_prompt else: try: os.environ["RSF_RAW_PROMPT"] except KeyError: pass if module_prompt: os.environ["RSF_MODULE_PROMPT"] = module_prompt else: try: del os.environ["RSF_MODULE_PROMPT"] except KeyError: pass getattr(self.interpreter, '_{}__parse_prompt'.format(self.interpreter.__class__.__name__))() def assertIsDecorated(self, function, decorator_name): try: decorator_list = function.__decorators__ except AttributeError: decorator_list = [] self.assertIn( decorator_name, decorator_list, msg="'{}' method should be decorated with 'module_required'".format(function.__name__) ) @mock.patch('routersploit.utils.print_success') def test_command_set(self, mock_print_success): rhost, new_rhost_value = 'rhost_value', "new_rhost_value" port, new_port_value = 'port_value', "new_port_value" self.interpreter.current_module.options = ['rhost', 'port'] self.interpreter.current_module.rhost = rhost self.interpreter.current_module.port = port self.assertEqual(self.interpreter.current_module.rhost, rhost) self.assertEqual(self.interpreter.current_module.port, port) self.interpreter.command_set('rhost {}'.format(new_rhost_value)) self.interpreter.command_set('port {}'.format(new_port_value)) self.assertEqual(self.interpreter.current_module.rhost, new_rhost_value) self.assertEqual(self.interpreter.current_module.port, new_port_value) self.assertEqual( mock_print_success.mock_calls, [mock.call({'rhost': new_rhost_value}), mock.call({'port': new_port_value})] ) @mock.patch('routersploit.utils.print_error') def test_command_set_unknown_option(self, mock_print_error): unknown_option = "unknown" del self.interpreter.current_module.unknown known_options = ['known_option_1', 'known_option_2'] self.interpreter.current_module.options = known_options self.interpreter.command_set('{} doesnt_matter_value'.format(unknown_option)) self.assertEqual( mock_print_error.mock_calls, [mock.call("You can't set option '{}'.\nAvailable options: {}".format(unknown_option, known_options))] ) def test_command_run(self): with mock.patch.object(self.interpreter.current_module, 'run') as mock_run: self.interpreter.command_run() mock_run.assert_called_once_with() @mock.patch('routersploit.utils.print_success') def test_command_check_target_vulnerable(self, mock_print_success): with mock.patch.object(self.interpreter.current_module, 'check') as mock_check: mock_check.return_value = True self.interpreter.command_check() mock_check.assert_called_once_with() mock_print_success.assert_called_once_with('Target is vulnerable') @mock.patch('routersploit.utils.print_error') def test_command_check_target_not_vulnerable(self, print_error): with mock.patch.object(self.interpreter.current_module, 'check') as mock_check: mock_check.return_value = False self.interpreter.command_check() mock_check.assert_called_once_with() print_error.assert_called_once_with('Target is not vulnerable') @mock.patch('routersploit.utils.print_status') def test_command_check_target_could_not_be_verified_1(self, print_status): with mock.patch.object(self.interpreter.current_module, 'check') as mock_check: mock_check.return_value = "something" self.interpreter.command_check() mock_check.assert_called_once_with() print_status.assert_called_once_with('Target could not be verified') @mock.patch('routersploit.utils.print_status') def test_command_check_target_could_not_be_verified_2(self, print_status): with mock.patch.object(self.interpreter.current_module, 'check') as mock_check: mock_check.return_value = None self.interpreter.command_check() mock_check.assert_called_once_with() print_status.assert_called_once_with('Target could not be verified') @mock.patch('sys.exc_info') @mock.patch('traceback.format_exc') @mock.patch('routersploit.utils.print_error') def test_command_run_exception_during_exploit_execution(self, mock_print_error, mock_format_exc, mock_exc_info): with mock.patch.object(self.interpreter.current_module, 'run') as mock_run: mock_run.side_effect = RuntimeError mock_format_exc.return_value = stacktrace = "stacktrace" mock_exc_info.return_value = info = "info" self.interpreter.command_run() mock_run.assert_called_once_with() mock_format_exc.assert_called_once_with(info) mock_print_error.assert_called_once_with(stacktrace) def test_command_back(self): self.assertIsNotNone(self.interpreter.current_module) self.interpreter.command_back() self.assertIsNone(self.interpreter.current_module) def test_custom_raw_prompt(self): self.prepare_prompt_env_variables(raw_prompt="***{host}***") self.interpreter.current_module = None self.assertEqual("***rsf***", self.interpreter.prompt) def test_default_raw_prompt_no_env_variable(self): self.prepare_prompt_env_variables() self.interpreter.current_module = None self.assertEqual(self.raw_prompt_default, self.interpreter.prompt) def test_default_raw_prompt_wrong_env_variable_format(self): self.prepare_prompt_env_variables(raw_prompt="wrong_format >") # no '{host}' substring self.interpreter.current_module = None self.assertEqual(self.raw_prompt_default, self.interpreter.prompt) def test_custom_module_\ (self): self.prepare_prompt_env_variables(module_prompt="*{host}*{module} >>>") module_name = "module_name" self.interpreter.current_module._MagicMock__info__ = {'name': module_name} self.assertEqual("*rsf*{} >>>".format(module_name), self.interpreter.prompt) def test_default_module_prompt_no_env_variable(self): self.prepare_prompt_env_variables() name = "current_module_name" self.interpreter.current_module._MagicMock__info__ = {'name': name} self.assertEqual(self.module_prompt_default(name), self.interpreter.prompt) def test_default_module_prompt_wrong_env_variable_format_1(self): self.prepare_prompt_env_variables(raw_prompt="{module} >") # no '{host}' substring name = "current_module_name" self.interpreter.current_module._MagicMock__info__ = {'name': name} self.assertEqual(self.module_prompt_default(name), self.interpreter.prompt) def test_default_module_prompt_wrong_env_variable_format_2(self): self.prepare_prompt_env_variables(module_prompt="{host} >") # no '{module}' substring name = "current_module_name" self.interpreter.current_module._MagicMock__info__ = {'name': name} self.assertEqual(self.module_prompt_default(name), self.interpreter.prompt) def test_module_prompt_module_has_no_metadata(self): del self.interpreter.current_module._MagicMock__info__ self.assertEqual(self.module_prompt_default('UnnamedModule'), self.interpreter.prompt) def test_module_prompt_module_has_no_name_key_in_metadata(self): self.interpreter.current_module._MagicMock__info__ = {} self.assertEqual(self.module_prompt_default('UnnamedModule'), self.interpreter.prompt) def test_suggested_commands_with_loaded_module(self): self.assertEqual( self.interpreter.suggested_commands(), ['run', 'back', 'set ', 'show ', 'check'] # Extra space at the end because of following param ) def test_suggested_commands_without_loaded_module(self): self.interpreter.current_module = None self.assertEqual( self.interpreter.suggested_commands(), # Extra space at the end because of following param ['use '] ) @mock.patch('importlib.import_module') def test_command_use_01(self, mocked_import_module): """ Testing command_use() * Known Exploit * Known module """ module_path = "exploits/foo/bar" self.interpreter.current_module = None self.interpreter.modules = [module_path, 'doo/pa/foo/bar'] exploit_class = mock.MagicMock(name="password_disclosure_module") mocked_import_module.return_value = mocked_module = mock.MagicMock(name='module') mocked_module.Exploit = exploit_class self.interpreter.command_use(module_path) mocked_import_module.assert_called_once_with('routersploit.modules.exploits.foo.bar') self.assertEqual(self.interpreter.current_module, exploit_class()) @mock.patch('importlib.import_module') def test_command_use_02(self, mocked_import_module): """ Testing command_use() * Known Exploit * Known module """ module_path = "creds/foo/bar/baz" self.interpreter.current_module = None self.interpreter.modules = [module_path, 'doo/pa/foo/bar'] exploit_class = mock.MagicMock(name="password_disclosure_module") mocked_import_module.return_value = mocked_module = mock.MagicMock(name='module') mocked_module.Exploit = exploit_class self.interpreter.command_use(module_path) mocked_import_module.assert_called_once_with('routersploit.modules.creds.foo.bar.baz') self.assertEqual(self.interpreter.current_module, exploit_class()) @mock.patch('importlib.import_module') @mock.patch('routersploit.utils.print_error') def test_command_unknown_extension(self, mocked_print_error, mocked_import_module): """ Testing command_use() * Unknown module """ self.interpreter.current_module = None self.interpreter.modules = ['doo/pa/foo/bar'] module_path = "creds/foo/bar/baz" mocked_import_module.side_effect = ImportError self.interpreter.command_use(module_path) mocked_import_module.assert_called_once_with('routersploit.modules.creds.foo.bar') mocked_print_error.assert_called_once_with("Error during loading 'routersploit/modules/creds/foo/bar' module") self.assertEqual(self.interpreter.current_module, None) @mock.patch('importlib.import_module') @mock.patch('routersploit.utils.print_error') def test_command_unknown_extension(self, mocked_print_error, mocked_import_module): """ Testing command_use() * Unknown Exploit * Known module """ module_path = "exploits/foo/bar" self.interpreter.current_module = None self.interpreter.modules = [module_path, 'doo/pa/foo/bar'] mocked_import_module.return_value = mocked_module = mock.MagicMock(name='module') del mocked_module.Exploit self.interpreter.command_use(module_path) mocked_import_module.assert_called_once_with('routersploit.modules.exploits.foo.bar') mocked_print_error.assert_called_once_with("Error during loading 'routersploit/modules/exploits/foo/bar' module") self.assertEqual(self.interpreter.current_module, None) @mock.patch('__builtin__.print') def test_command_show_info(self, mock_print): metadata = { 'target': 'target_desc', 'port': 'port_desc', 'foo': 'foo_desc', 'bar': 'bar_desc', 'baz': 'baz_desc' } description = "Elaborate description fo the module" self.interpreter.current_module.__doc__ = description self.interpreter.current_module._MagicMock__info__ = metadata self.interpreter.command_show('info') self.assertEqual( mock_print.mock_calls, [ mock.call(description), mock.call('Baz', ': ', 'baz_desc', sep=''), mock.call('Foo', ': ', 'foo_desc', sep=''), mock.call('Bar', ': ', 'bar_desc', sep=''), mock.call('Target', ': ', 'target_desc', sep=''), mock.call('Port', ': ', 'port_desc', sep=''), mock.call()] ) @mock.patch('__builtin__.print') def test_command_show_info_module_with_no_metadata(self, mock_print): metadata = {} description = "Elaborate description fo the module" self.interpreter.current_module.__doc__ = description self.interpreter.current_module._MagicMock__info__ = metadata self.interpreter.command_show('info') self.assertEqual( mock_print.mock_calls, [ mock.call(description), mock.call()] ) @mock.patch('__builtin__.print') def test_command_show_options(self, mock_print): exploit_attributes = { 'target': 'target_desc', 'port': 'port_desc', 'foo': 'foo_desc', 'bar': 'bar_desc', 'baz': 'baz_desc' } self.interpreter.current_module.options = ['target', 'port', 'foo', 'bar', 'baz'] self.interpreter.current_module.exploit_attributes.__getitem__.side_effect = lambda key: exploit_attributes[key] self.interpreter.current_module.foo = 1 self.interpreter.current_module.bar = 2 self.interpreter.current_module.baz = 3 self.interpreter.current_module.target = '127.0.0.1' self.interpreter.current_module.port = 22 self.interpreter.command_show('options') self.assertEqual( mock_print.mock_calls, [ mock.call('\nTarget options:\n'), mock.call(' Name Current settings Description '), mock.call(' ---- ---------------- ----------- '), mock.call(' target 127.0.0.1 target_desc '), mock.call(' port 22 port_desc '), mock.call('\nModule options:\n'), mock.call(' Name Current settings Description '), mock.call(' ---- ---------------- ----------- '), mock.call(' bar 2 bar_desc '), mock.call(' foo 1 foo_desc '), mock.call(' baz 3 baz_desc '), mock.call(), ] ) @mock.patch('__builtin__.print') def test_command_show_options_when_there_is_no_module_opts(self, mock_print): exploit_attributes = { 'target': 'target_desc', 'port': 'port_desc', } self.interpreter.current_module.options = ['target', 'port'] self.interpreter.current_module.exploit_attributes.__getitem__.side_effect = lambda key: exploit_attributes[key] self.interpreter.current_module.target = '127.0.0.1' self.interpreter.current_module.port = 22 self.interpreter.command_show('options') self.assertEqual( mock_print.mock_calls, [ mock.call('\nTarget options:\n'), mock.call(' Name Current settings Description '), mock.call(' ---- ---------------- ----------- '), mock.call(' target 127.0.0.1 target_desc '), mock.call(' port 22 port_desc '), mock.call(), ] ) @mock.patch('__builtin__.print') def test_command_show_unknown_sub_command(self, mock_print): help_text = "Unknown command 'show unknown_sub_command'. You want to 'show info' or 'show options'?" self.interpreter.command_show('unknown_sub_command') self.assertEqual( mock_print.mock_calls, [mock.call(help_text)] ) def test_if_command_run_has_module_required_decorator(self): self.assertIsDecorated( self.interpreter.command_run, "module_required" ) def test_if_command_set_has_module_required_decorator(self): self.assertIsDecorated( self.interpreter.command_set, "module_required" ) def test_if_command_show_has_module_required_decorator(self): self.assertIsDecorated( self.interpreter.command_show, "module_required" ) def test_if_command_check_has_module_required_decorator(self): self.assertIsDecorated( self.interpreter.command_check, "module_required" ) @mock.patch('os.walk') @mock.patch('importlib.import_module') @mock.patch('inspect.getmembers') def test_load_modules(self, mock_getmembers, mock_import_module, mock_walk): mock_walk.return_value = ( ('/Abs/Path/routersploit/routersploit/modules', ['asmax', 'creds'], ['__init__.py', '__init__.pyc']), ('/Abs/Path/routersploit/routersploit/modules/creds', [], ['__init__.py', '__init__.pyc', 'ftp_bruteforce.py', 'ftp_bruteforce.pyc']), ('/Abs/Path/routersploit/routersploit/modules/exploits/asmax', [], ['__init__.py', '__init__.pyc', 'asmax_exploit.py', 'asmax_exploit.pyc']), ) mock_import_module.side_effect = [1, 2, 3, 4, 5] mock_getmembers.side_effect = [ [], [], [("FTPBruteforce", TestExploit), ('SomeClass', mock.MagicMock), ('Exploit123', TestExploit)], [], [("Exploit", TestExploit), ('SomeClass', mock.MagicMock)] ] self.interpreter.load_modules() mock_walk.assert_called_once_with(self.interpreter.modules_directory) self.assertEqual( mock_import_module.mock_calls, [ mock.call('routersploit.modules.__init__'), mock.call('routersploit.modules.creds.__init__'), mock.call('routersploit.modules.creds.ftp_bruteforce'), mock.call('routersploit.modules.exploits.asmax.__init__'), mock.call('routersploit.modules.exploits.asmax.asmax_exploit') ] ) self.assertEqual( mock_getmembers.mock_calls, [ mock.call(1, inspect.isclass), mock.call(2, inspect.isclass), mock.call(3, inspect.isclass), mock.call(4, inspect.isclass), mock.call(5, inspect.isclass), ] ) self.assertEqual( self.interpreter.modules, [ 'creds.ftp_bruteforce', 'exploits.asmax.asmax_exploit' ] ) @mock.patch('os.walk') @mock.patch('importlib.import_module') @mock.patch('inspect.getmembers') def test_load_modules_import_error(self, mock_getmembers, mock_import_module, mock_walk): mock_walk.return_value = ( ('/Abs/Path/routersploit/routersploit/modules', ['asmax', 'creds'], ['__init__.py', '__init__.pyc']), ('/Abs/Path/routersploit/routersploit/modules/creds', [], ['__init__.py', '__init__.pyc', 'ftp_bruteforce.py', 'ftp_bruteforce.pyc']), ('/Abs/Path/routersploit/routersploit/modules/exploits/asmax', [], ['__init__.py', '__init__.pyc', 'asmax_exploit.py', 'asmax_exploit.pyc']), ) mock_import_module.side_effect = [1, 2, ImportError, 4, 5] mock_getmembers.side_effect = [ [], [], [], [("Exploit", TestExploit), ('SomeClass', mock.MagicMock)] ] self.interpreter.load_modules() mock_walk.assert_called_once_with(self.interpreter.modules_directory) self.assertEqual( mock_import_module.mock_calls, [ mock.call('routersploit.modules.__init__'), mock.call('routersploit.modules.creds.__init__'), mock.call('routersploit.modules.creds.ftp_bruteforce'), mock.call('routersploit.modules.exploits.asmax.__init__'), mock.call('routersploit.modules.exploits.asmax.asmax_exploit') ] ) self.assertEqual( mock_getmembers.mock_calls, [ mock.call(1, inspect.isclass), mock.call(2, inspect.isclass), mock.call(4, inspect.isclass), mock.call(5, inspect.isclass), ] ) self.assertEqual( self.interpreter.modules, [ 'exploits.asmax.asmax_exploit' ] )
class RoutersploitInterpreterTest(RoutersploitTestCase): def setUp(self): RoutersploitInterpreter.setup = mock.Mock() self.interpreter = RoutersploitInterpreter() self.interpreter.current_module = mock.MagicMock() self.raw_prompt_default = "\001\033[4m\002rsf\001\033[0m\002 > " self.module_prompt_default = lambda x: "\001\033[4m\002rsf\001\033[0m\002 (\001\033[91m\002{}\001\033[0m\002) > ".format(x) def prepare_prompt_env_variables(self, raw_prompt=None, module_prompt=None): if raw_prompt: os.environ["RSF_RAW_PROMPT"] = raw_prompt else: try: os.environ["RSF_RAW_PROMPT"] except KeyError: pass if module_prompt: os.environ["RSF_MODULE_PROMPT"] = module_prompt else: try: del os.environ["RSF_MODULE_PROMPT"] except KeyError: pass getattr(self.interpreter, '_{}__parse_prompt'.format(self.interpreter.__class__.__name__))() @mock.patch('routersploit.utils.print_success') def test_command_set(self, mock_print_success): rhost, new_rhost_value = 'rhost_value', "new_rhost_value" port, new_port_value = 'port_value', "new_port_value" self.interpreter.current_module.options = ['rhost', 'port'] self.interpreter.current_module.rhost = rhost self.interpreter.current_module.port = port self.assertEqual(self.interpreter.current_module.rhost, rhost) self.assertEqual(self.interpreter.current_module.port, port) self.interpreter.command_set('rhost {}'.format(new_rhost_value)) self.interpreter.command_set('port {}'.format(new_port_value)) self.assertEqual(self.interpreter.current_module.rhost, new_rhost_value) self.assertEqual(self.interpreter.current_module.port, new_port_value) self.assertEqual( mock_print_success.mock_calls, [mock.call({'rhost': new_rhost_value}), mock.call({'port': new_port_value})] ) @mock.patch('routersploit.utils.print_error') def test_command_set_unknown_option(self, mock_print_error): unknown_option = "unknown" del self.interpreter.current_module.unknown known_options = ['known_option_1', 'known_option_2'] self.interpreter.current_module.options = known_options self.interpreter.command_set('{} doesnt_matter_value'.format(unknown_option)) self.assertEqual( mock_print_error.mock_calls, [mock.call("You can't set option '{}'.\nAvailable options: {}".format(unknown_option, known_options))] ) def test_command_run(self): with mock.patch.object(self.interpreter.current_module, 'run') as mock_run: self.interpreter.command_run() mock_run.assert_called_once_with() @mock.patch('routersploit.utils.print_success') def test_command_check_target_vulnerable(self, mock_print_success): with mock.patch.object(self.interpreter.current_module, 'check') as mock_check: mock_check.return_value = True self.interpreter.command_check() mock_check.assert_called_once_with() mock_print_success.assert_called_once_with('Target is vulnerable') @mock.patch('routersploit.utils.print_error') def test_command_check_target_not_vulnerable(self, print_error): with mock.patch.object(self.interpreter.current_module, 'check') as mock_check: mock_check.return_value = False self.interpreter.command_check() mock_check.assert_called_once_with() print_error.assert_called_once_with('Target is not vulnerable') @mock.patch('routersploit.utils.print_status') def test_command_check_target_could_not_be_verified_1(self, print_status): with mock.patch.object(self.interpreter.current_module, 'check') as mock_check: mock_check.return_value = "something" self.interpreter.command_check() mock_check.assert_called_once_with() print_status.assert_called_once_with('Target could not be verified') @mock.patch('routersploit.utils.print_status') def test_command_check_target_could_not_be_verified_2(self, print_status): with mock.patch.object(self.interpreter.current_module, 'check') as mock_check: mock_check.return_value = None self.interpreter.command_check() mock_check.assert_called_once_with() print_status.assert_called_once_with('Target could not be verified') @mock.patch('routersploit.utils.print_error') def test_command_check_not_supported_by_module(self, print_error): with mock.patch.object(self.interpreter.current_module, 'check') as mock_check: exception = NotImplementedError("Not available") mock_check.side_effect = exception self.interpreter.command_check() mock_check.assert_called_once_with() print_error.assert_called_once_with(exception) @mock.patch('sys.exc_info') @mock.patch('traceback.format_exc') @mock.patch('routersploit.utils.print_error') def test_command_run_exception_during_exploit_execution(self, mock_print_error, mock_format_exc, mock_exc_info): with mock.patch.object(self.interpreter.current_module, 'run') as mock_run: mock_run.side_effect = RuntimeError mock_format_exc.return_value = stacktrace = "stacktrace" mock_exc_info.return_value = info = "info" self.interpreter.command_run() mock_run.assert_called_once_with() mock_format_exc.assert_called_once_with(info) mock_print_error.assert_called_once_with(stacktrace) def test_command_back(self): self.assertIsNotNone(self.interpreter.current_module) self.interpreter.command_back() self.assertIsNone(self.interpreter.current_module) def test_custom_raw_prompt(self): self.prepare_prompt_env_variables(raw_prompt="***{host}***") self.interpreter.current_module = None self.assertEqual("***rsf***", self.interpreter.prompt) def test_default_raw_prompt_no_env_variable(self): self.prepare_prompt_env_variables() self.interpreter.current_module = None self.assertEqual(self.raw_prompt_default, self.interpreter.prompt) def test_default_raw_prompt_wrong_env_variable_format(self): self.prepare_prompt_env_variables(raw_prompt="wrong_format >") # no '{host}' substring self.interpreter.current_module = None self.assertEqual(self.raw_prompt_default, self.interpreter.prompt) def test_custom_module_\ (self): self.prepare_prompt_env_variables(module_prompt="*{host}*{module} >>>") module_name = "module_name" self.interpreter.current_module._MagicMock__info__ = {'name': module_name} self.assertEqual("*rsf*{} >>>".format(module_name), self.interpreter.prompt) def test_default_module_prompt_no_env_variable(self): self.prepare_prompt_env_variables() name = "current_module_name" self.interpreter.current_module._MagicMock__info__ = {'name': name} self.assertEqual(self.module_prompt_default(name), self.interpreter.prompt) def test_default_module_prompt_wrong_env_variable_format_1(self): self.prepare_prompt_env_variables(raw_prompt="{module} >") # no '{host}' substring name = "current_module_name" self.interpreter.current_module._MagicMock__info__ = {'name': name} self.assertEqual(self.module_prompt_default(name), self.interpreter.prompt) def test_default_module_prompt_wrong_env_variable_format_2(self): self.prepare_prompt_env_variables(module_prompt="{host} >") # no '{module}' substring name = "current_module_name" self.interpreter.current_module._MagicMock__info__ = {'name': name} self.assertEqual(self.module_prompt_default(name), self.interpreter.prompt) def test_module_prompt_module_has_no_metadata(self): del self.interpreter.current_module._MagicMock__info__ self.assertEqual(self.module_prompt_default('UnnamedModule'), self.interpreter.prompt) def test_module_prompt_module_has_no_name_key_in_metadata(self): self.interpreter.current_module._MagicMock__info__ = {} self.assertEqual(self.module_prompt_default('UnnamedModule'), self.interpreter.prompt) def test_suggested_commands_with_loaded_module(self): self.assertEqual( self.interpreter.suggested_commands(), ['run', 'back', 'set ', 'show ', 'check', 'exec', 'help', 'exit'] # Extra space at the end because of following param ) def test_suggested_commands_without_loaded_module(self): self.interpreter.current_module = None self.assertEqual( self.interpreter.suggested_commands(), # Extra space at the end because of following param ['use ', 'exec', 'help', 'exit'] ) @mock.patch('importlib.import_module') def test_command_use_01(self, mocked_import_module): """ Testing command_use() * Known Exploit * Known module """ module_path = "exploits/foo/bar" self.interpreter.current_module = None self.interpreter.modules = [module_path, 'doo/pa/foo/bar'] exploit_class = mock.MagicMock(name="password_disclosure_module") mocked_import_module.return_value = mocked_module = mock.MagicMock(name='module') mocked_module.Exploit = exploit_class self.interpreter.command_use(module_path) mocked_import_module.assert_called_once_with('routersploit.modules.exploits.foo.bar') self.assertEqual(self.interpreter.current_module, exploit_class()) @mock.patch('importlib.import_module') def test_command_use_02(self, mocked_import_module): """ Testing command_use() * Known Exploit * Known module """ module_path = "creds/foo/bar/baz" self.interpreter.current_module = None self.interpreter.modules = [module_path, 'doo/pa/foo/bar'] exploit_class = mock.MagicMock(name="password_disclosure_module") mocked_import_module.return_value = mocked_module = mock.MagicMock(name='module') mocked_module.Exploit = exploit_class self.interpreter.command_use(module_path) mocked_import_module.assert_called_once_with('routersploit.modules.creds.foo.bar.baz') self.assertEqual(self.interpreter.current_module, exploit_class()) @mock.patch('importlib.import_module') @mock.patch('routersploit.utils.print_error') def test_command_use_unknown_module(self, mocked_print_error, mocked_import_module): """ Testing command_use() * Unknown module """ self.interpreter.current_module = None self.interpreter.modules = ['doo/pa/foo/bar'] module_path = "creds/foo/bar/baz" mocked_import_module.side_effect = ImportError("Not working") self.interpreter.command_use(module_path) mocked_import_module.assert_called_once_with('routersploit.modules.creds.foo.bar.baz') mocked_print_error.assert_called_once_with( "Error during loading 'routersploit/modules/creds/foo/bar/baz'\n\n" "Error: Not working\n\n" "It should be valid path to the module. Use <tab> key multiple times for completion." ) self.assertEqual(self.interpreter.current_module, None) @mock.patch('importlib.import_module') @mock.patch('routersploit.utils.print_error') def test_command_use_unknown_extension(self, mocked_print_error, mocked_import_module): """ Testing command_use() * Unknown Exploit * Known module """ module_path = "exploits/foo/bar" self.interpreter.current_module = None self.interpreter.modules = [module_path, 'doo/pa/foo/bar'] mocked_import_module.return_value = mocked_module = mock.MagicMock(name='module') del mocked_module.Exploit self.interpreter.command_use(module_path) mocked_import_module.assert_called_once_with('routersploit.modules.exploits.foo.bar') mocked_print_error.assert_called_once_with( "Error during loading 'routersploit/modules/exploits/foo/bar'\n\n" "Error: Exploit\n\n" "It should be valid path to the module. Use <tab> key multiple times for completion." ) self.assertEqual(self.interpreter.current_module, None) @mock.patch('__builtin__.print') def test_command_show_info(self, mock_print): metadata = { 'devices': 'target_desc', 'authors': 'authors_desc', 'references': 'references_desc', 'description': 'description_desc', 'name': 'name_desc' } description = "Elaborate description fo the module" self.interpreter.current_module.__doc__ = description self.interpreter.current_module._MagicMock__info__ = metadata self.interpreter.command_show('info') self.assertEqual( mock_print.mock_calls, [ mock.call('\nName:'), mock.call('name_desc'), mock.call('\nDescription:'), mock.call('description_desc'), mock.call('\nDevices:'), mock.call('target_desc'), mock.call('\nAuthors:'), mock.call('authors_desc'), mock.call('\nReferences:'), mock.call('references_desc'), mock.call()] ) @mock.patch('__builtin__.print') def test_command_show_info_module_with_no_metadata(self, mock_print): metadata = {} description = "Elaborate description fo the module" self.interpreter.current_module.__doc__ = description self.interpreter.current_module._MagicMock__info__ = metadata self.interpreter.command_show('info') self.assertEqual( mock_print.mock_calls, [ mock.call()] ) @mock.patch('__builtin__.print') def test_command_show_options(self, mock_print): exploit_attributes = { 'target': 'target_desc', 'port': 'port_desc', 'foo': 'foo_desc', 'bar': 'bar_desc', 'baz': 'baz_desc' } self.interpreter.current_module.options = ['target', 'port', 'foo', 'bar', 'baz'] self.interpreter.current_module.exploit_attributes.__getitem__.side_effect = lambda key: exploit_attributes[key] self.interpreter.current_module.foo = 1 self.interpreter.current_module.bar = 2 self.interpreter.current_module.baz = 3 self.interpreter.current_module.target = '127.0.0.1' self.interpreter.current_module.port = 22 self.interpreter.command_show('options') self.assertEqual( mock_print.mock_calls, [ mock.call('\nTarget options:'), mock.call(), mock.call(' Name Current settings Description '), mock.call(' ---- ---------------- ----------- '), mock.call(' target 127.0.0.1 target_desc '), mock.call(' port 22 port_desc '), mock.call(), mock.call('\nModule options:'), mock.call(), mock.call(' Name Current settings Description '), mock.call(' ---- ---------------- ----------- '), mock.call(' bar 2 bar_desc '), mock.call(' foo 1 foo_desc '), mock.call(' baz 3 baz_desc '), mock.call(), mock.call(), ] ) @mock.patch('__builtin__.print') def test_command_show_options_when_there_is_no_module_opts(self, mock_print): exploit_attributes = { 'target': 'target_desc', 'port': 'port_desc', } self.interpreter.current_module.options = ['target', 'port'] self.interpreter.current_module.exploit_attributes.__getitem__.side_effect = lambda key: exploit_attributes[key] self.interpreter.current_module.target = '127.0.0.1' self.interpreter.current_module.port = 22 self.interpreter.command_show('options') self.assertEqual( mock_print.mock_calls, [ mock.call('\nTarget options:'), mock.call(), mock.call(' Name Current settings Description '), mock.call(' ---- ---------------- ----------- '), mock.call(' target 127.0.0.1 target_desc '), mock.call(' port 22 port_desc '), mock.call(), mock.call(), ] ) @mock.patch('__builtin__.print') def test_command_show_unknown_sub_command(self, mock_print): help_text = "Unknown command 'show unknown_sub_command'. You want to 'show info' or 'show options'?" self.interpreter.command_show('unknown_sub_command') self.assertEqual( mock_print.mock_calls, [mock.call(help_text)] ) def test_if_command_run_has_module_required_decorator(self): self.assertIsDecorated( self.interpreter.command_run, "module_required" ) def test_if_command_set_has_module_required_decorator(self): self.assertIsDecorated( self.interpreter.command_set, "module_required" ) def test_if_command_show_has_module_required_decorator(self): self.assertIsDecorated( self.interpreter.command_show, "module_required" ) def test_if_command_check_has_module_required_decorator(self): self.assertIsDecorated( self.interpreter.command_check, "module_required" ) def test_command_exit(self): with self.assertRaises(KeyboardInterrupt): self.interpreter.command_exit() @mock.patch('os.system') def test_command_exec(self, mock_system): self.interpreter.command_exec("foo -bar") mock_system.assert_called_once_with("foo -bar") @mock.patch('__builtin__.print') def test_command_help(self, mock_print): self.interpreter.current_module = None self.interpreter.command_help() mock_print.assert_called_once_with(self.interpreter.global_help) @mock.patch('__builtin__.print') def test_command_help_with_module_loaded(self, mock_print): self.interpreter.command_help() self.assertEqual( mock_print.mock_calls, [ mock.call(self.interpreter.global_help), mock.call("\n", self.interpreter.module_help), ] )
def routersploit(): rsf = RoutersploitInterpreter() rsf.start()
def routersploit(argv): rsf = RoutersploitInterpreter() if len(argv[1:]): rsf.nonInteractive(argv) else: rsf.start()