def __init__(self, args): self._original_excepthook = sys.excepthook self.args = args self._mappers_manager = MapperManager() self._model_controller = ModelController(self._mappers_manager) self._plugin_manager = PluginManager( os.path.join(CONF.getConfigPath(), "plugins")) self._workspace_manager = WorkspaceManager(self._mappers_manager) # Create a PluginController and send this to UI selected. self._plugin_controller = PluginController('PluginController', self._plugin_manager, self._mappers_manager) if self.args.cli: self.app = CliApp(self._workspace_manager, self._plugin_controller) CONF.setMergeStrategy("new") else: self.app = UiFactory.create(self._model_controller, self._plugin_manager, self._workspace_manager, self._plugin_controller, self.args.gui) self.timer = TimerClass() self.timer.start()
def test_find_obj_by_id(self, many_test_data, session, monkeypatch): obj_class = many_test_data['class'] test_data = many_test_data persisted_obj = test_data['factory'].create() session.add(persisted_obj) session.commit() mapper_manager = MapperManager() mapper_manager.createMappers(persisted_obj.workspace.name) def mock_unsafe_io_with_server(host, test_data, server_io_function, server_expected_response, server_url, **payload): mocked_response = test_data['mocked_response'] assert '{0}/ws/{1}/{2}/{3}/'.format(_create_server_api_url(), persisted_obj.workspace.name, test_data['api_end_point'], persisted_obj.id) == server_url return MockResponse(mocked_response, 200) monkeypatch.setattr( persistence.server.server, '_unsafe_io_with_server', partial(mock_unsafe_io_with_server, persisted_obj, test_data)) found_obj = mapper_manager.find(obj_class.class_signature, persisted_obj.id) serialized_obj = test_data['get_properties_function'](found_obj) if obj_class not in [Command]: metadata = serialized_obj.pop('metadata') assert serialized_obj == test_data['serialized_expected_results']
def __init__(self, args): self._original_excepthook = sys.excepthook self._configuration = CONF self._security_manager = SecurityManager() self._mappers_manager = MapperManager() self._changes_controller = ChangeController() self._db_manager = DbManager() self._model_controller = ModelController(self._security_manager, self._mappers_manager) self._plugin_manager = PluginManager( os.path.join(CONF.getConfigPath(), "plugins"), self._mappers_manager) self._reports_manager = ReportManager( 10, self._plugin_manager.createController("ReportManager")) self._workspace_manager = WorkspaceManager(self._db_manager, self._mappers_manager, self._changes_controller, self._reports_manager) self.gui_app = UiFactory.create(self._model_controller, self._plugin_manager, self._workspace_manager, args.gui) self.gui_app.setSplashImage( os.path.join(CONF.getImagePath(), "splash2.png"))
def setUp(self): """ Generic test to verify that the object exists and can be instantiated without problems. """ self.dbManager = mock() self.changesController = mock() self.reportManager = mock() self.dbManager = DbManager() self.mappersManager = MapperManager() self.model_controller = controller.ModelController( mock(), self.mappersManager) self.workspace_manager = WorkspaceManager(self.dbManager, self.mappersManager, self.changesController, self.reportManager) self.workspace_manager.createWorkspace('temp_workspace', 'desc', DBTYPE.FS) self.workspace_manager.openWorkspace('temp_workspace') self._plugin_controller = PluginControllerForApi( "test", { "nmap": nmap_plugin.NmapPlugin(), "nessus": nessus_plugin.NessusPlugin() }, mock()) api.setUpAPIs(self.model_controller, self.workspace_manager)
def __init__(self): super(RawReportProcessor, self).__init__() from faraday import setupPlugins setupPlugins() self.pending_actions = Queue() try: plugin_manager = PluginManager( os.path.join(CONF.getConfigPath(), "plugins")) except AttributeError: get_logger().warning( "Upload reports in WEB-UI not configurated, run Faraday client and try again..." ) self._stop = True return mappers_manager = MapperManager() self.model_controller = ModelController(mappers_manager, self.pending_actions) self.model_controller.start() self.end_event = Event() plugin_controller = PluginController('PluginController', plugin_manager, mappers_manager, self.pending_actions, self.end_event) self.processor = ReportProcessor(plugin_controller, None) self._stop = False
def setUp(self): self.db_name = self.new_random_workspace_name() self.couchdbmanager = CouchDbManager(CONF.getCouchURI()) self.connector = self.couchdbmanager.createDb(self.db_name) self.mapper_manager = MapperManager() self.mapper_manager.createMappers(self.connector)
def test_end_pluging_multiple_times(): mappers_manager = MapperManager() pending_actions = Queue() controller = ModelController(mappers_manager, pending_actions) controller._pluginEnd('test', None) controller._pluginEnd('test', None) assert controller.active_plugins_count == 0 assert controller.processing is False
def setUp(self): self.db_name = self.new_random_workspace_name() self.fsmanager = FileSystemManager() self.connector = self.fsmanager.createDb(self.db_name) self.mapper_manager = MapperManager() self.mapper_manager.createMappers(self.connector)
def __init__(self, args): self._original_excepthook = sys.excepthook self.args = args logger = getLogger(self) if args.creds_file: try: with open(args.creds_file, 'r') as fp: creds = json.loads(fp.read()) username = creds.get('username') password = creds.get('password') session_cookie = login_user(CONF.getServerURI(), username, password) if session_cookie: logger.info('Login successful') CONF.setDBUser(username) CONF.setDBSessionCookies(session_cookie) else: logger.error('Login failed') except (IOError, ValueError): logger.error("Credentials file couldn't be loaded") self._mappers_manager = MapperManager() pending_actions = Queue() self._model_controller = ModelController(self._mappers_manager, pending_actions) self._plugin_manager = PluginManager( os.path.join(CONF.getConfigPath(), "plugins"), pending_actions=pending_actions, ) self._workspace_manager = WorkspaceManager(self._mappers_manager) # Create a PluginController and send this to UI selected. self._plugin_controller = PluginController('PluginController', self._plugin_manager, self._mappers_manager, pending_actions) if self.args.cli: self.app = CliApp(self._workspace_manager, self._plugin_controller) if self.args.keep_old: CONF.setMergeStrategy("old") else: CONF.setMergeStrategy("new") else: self.app = UiFactory.create(self._model_controller, self._plugin_manager, self._workspace_manager, self._plugin_controller, self.args.gui) self.timer = TimerClass() self.timer.start()
def test_only_start_plugin(): mappers_manager = MapperManager() pending_actions = Queue() controller = ModelController(mappers_manager, pending_actions) controller._pluginStart('test', None) assert controller.active_plugins_count == 1 assert controller.processing controller._pluginStart('test', None) assert controller.active_plugins_count == 2
def import_external_reports(workspace_name=None, disable_polling=False): plugins_path = os.path.join(CONF.getConfigPath(), "plugins") plugin_manager = PluginManager(plugins_path) mappers_manager = MapperManager() if workspace_name: query = Workspace.query.filter_by(name=workspace_name) else: query = Workspace.query process_workspaces(mappers_manager, plugin_manager, query, disable_polling)
def test_controller_stop_when_is_not_processing(): mappers_manager = MapperManager() pending_actions = Queue() controller = ModelController(mappers_manager, pending_actions) assert controller.processing is False assert controller._stop is False controller.start() assert controller.isAlive() controller.stop() assert controller._stop is True controller.join() assert controller.isAlive() is False
def test_update_without_command(self, many_test_data, monkeypatch, session): obj_class = many_test_data['class'] workspace = WorkspaceFactory.create(name='test') mapper_manager = MapperManager() mapper_manager.createMappers(workspace.name) test_data = many_test_data relational_model = test_data['factory'].create() session.add(relational_model) session.commit() raw_data = test_data['data'] if test_data['parent']: parent = test_data['parent']['parent_factory'].create() session.add(parent) session.commit() test_data['data']['parent'] = parent.id test_data['data']['parent_type'] = test_data['parent'][ 'parent_type'] if obj_class not in [Note, Command]: test_data['expected_payload']['parent'] = parent.id if obj_class in [Vuln, Credential]: test_data['expected_payload']['parent_type'] = test_data[ 'parent']['parent_type'] def mock_server_put(test_data, put_url, update=False, expected_response=201, **params): assert put_url == '{0}/ws/test/{1}/{2}/'.format( _create_server_api_url(), test_data['api_end_point'], test_data['id']) assert expected_response == 200 assert update == False if obj_class not in [Command]: metadata = params.pop('metadata') assert metadata['owner'] == test_data['expected_payload'][ 'owner'] params.pop('command_id', None) test_data['expected_payload'].pop('command_id', None) assert params == test_data['expected_payload'] return {'id': 1, 'ok': True, 'rev': ''} raw_data['id'] = relational_model.id test_data['id'] = relational_model.id monkeypatch.setattr(persistence.server.server, '_put', partial(mock_server_put, test_data)) obj = obj_class(raw_data, workspace.name) mapper_manager.update(obj)
def setUp(self): self._security_manager = mock(SecurityManager()) self._mappers_manager = mock(MapperManager()) self._plugin_manager = mock(PluginManager) self._model_controller = ModelController(self._security_manager, self._mappers_manager) restapi.startAPIs(self._plugin_manager, self._model_controller, self._mappers_manager) #TODO: load conf from file self.client = ModelRestApiClient("127.0.0.1", 9977)
def test_find(get, url_endpoint, test_data, session): if 'api_result' in test_data: get.return_value = test_data['api_result'] mappers_manager = MapperManager() pending_actions = Queue() controller = ModelController(mappers_manager, pending_actions) workspace = WorkspaceFactory.create() mappers_manager.createMappers(workspace.name) obj = test_data['factory'].create(workspace=workspace) session.add(obj) session.commit() result = controller.find(test_data['class_signature'], obj.id) assert get.called print(get.mock_calls[0][1][0]) assert get.mock_calls[0][1][0].endswith('/_api/v2/ws/{0}/{1}/{2}/'.format( workspace.name, url_endpoint, obj.id))
def test_controller_plugin_start_action_updates_internal_state(): mappers_manager = MapperManager() pending_actions = Queue() controller = ModelController(mappers_manager, pending_actions) controller.start() controller.add_action((Modelactions.PLUGINSTART, "test", None)) time.sleep(1) assert controller.active_plugins_count == 1 assert controller.processing controller.add_action((Modelactions.PLUGINEND, "test", None)) time.sleep(1) assert controller.active_plugins_count == 0 assert controller.processing is False controller.stop() controller.join() assert controller.isAlive() is False
def test_find_not_loaded_host(self): host = Host(name="pepito", os="linux") host.setDescription("Some description") host.setOwned(True) self.mapper_manager.save(host) #create a set of mappers, so we have a clean map self.mapper_manager = MapperManager() self.mapper_manager.createMappers(self.connector) h = self.mapper_manager.find(host.getID()) self.assertNotEquals(h, None, "Existent host shouldn't return None") self.assertEquals(h.getName(), "pepito", "Host name should be pepito") self.assertEquals(h.getOS(), "linux", "Host os should be linux")
def test_save_with_command(self, many_test_data, monkeypatch, session): obj_class = many_test_data['class'] if obj_class == Command: return workspace = WorkspaceFactory.create(name='test') command = CommandFactory.create(workspace=workspace) session.commit() mapper_manager = MapperManager() mapper_manager.createMappers(workspace.name) test_data = many_test_data raw_data = test_data['data'] if test_data['parent']: parent = test_data['parent']['parent_factory'].create() session.commit() test_data['data']['parent'] = parent.id test_data['data']['parent_type'] = test_data['parent'][ 'parent_type'] if obj_class not in [Note]: test_data['expected_payload']['parent'] = parent.id if obj_class in [Vuln, Credential]: test_data['expected_payload']['parent_type'] = test_data[ 'parent']['parent_type'] def mock_server_post(test_data, post_url, update=False, expected_response=201, **params): assert post_url == '{0}/ws/test/{1}/?command_id={2}'.format( _create_server_api_url(), test_data['api_end_point'], params['command_id']) assert expected_response == 201 assert update == False metadata = params.pop('metadata') assert metadata['owner'] == test_data['expected_payload']['owner'] params.pop('command_id') test_data['expected_payload'].pop('command_id') assert params == test_data['expected_payload'] return {'id': 1, 'ok': True, 'rev': ''} monkeypatch.setattr(persistence.server.server, '_post', partial(mock_server_post, test_data)) obj = obj_class(raw_data, workspace.name) mapper_manager.save(obj, command.id)
def test_update_with_command(self, many_test_data, monkeypatch, session): obj_class = many_test_data['class'] if obj_class in [Command]: return workspace = WorkspaceFactory.create(name='test') command = CommandFactory.create(workspace=workspace) session.add(command) session.commit() mapper_manager = MapperManager() mapper_manager.createMappers(workspace.name) test_data = many_test_data raw_data = test_data['data'] if test_data['parent']: parent = test_data['parent']['parent_factory'].create() session.add(parent) session.commit() test_data['data']['parent'] = parent.id test_data['data']['parent_type'] = test_data['parent'][ 'parent_type'] test_data['expected_payload']['parent'] = parent.id if obj_class in [Vuln, Credential]: test_data['expected_payload']['parent_type'] = test_data[ 'parent']['parent_type'] relational_model = test_data['factory'].create() session.add(relational_model) session.commit() def mock_server_put(put_url, update=False, expected_response=201, **params): assert put_url == '{0}/ws/test/{1}/{2}/?command_id={3}'.format( _create_server_api_url(), test_data['api_end_point'], test_data['id'], params['command_id']) assert expected_response == 200 assert update == False return {'id': 1, 'ok': True, 'rev': ''} raw_data['id'] = relational_model.id test_data['id'] = relational_model.id monkeypatch.setattr(persistence.server.server, '_put', mock_server_put) obj = obj_class(raw_data, workspace.name) mapper_manager.update(obj, command.id)
def test_load_not_loaded_composite_host(self): # add host host = Host(name="pepito", os="linux") host.setDescription("Some description") host.setOwned(True) self.mapper_manager.save(host) # add inteface iface = Interface(name="192.168.10.168", mac="01:02:03:04:05:06") iface.setDescription("Some description") iface.setOwned(True) iface.addHostname("www.test.com") iface.setIPv4({ "address": "192.168.10.168", "mask": "255.255.255.0", "gateway": "192.168.10.1", "DNS": "192.168.10.1" }) iface.setPortsOpened(2) iface.setPortsClosed(3) iface.setPortsFiltered(4) host.addChild(iface) self.mapper_manager.save(iface) #create a set of mappers, so we have a clean map self.mapper_manager = MapperManager() self.mapper_manager.createMappers(self.connector) h = self.mapper_manager.find(host.getID()) self.assertEquals( len(h.getAllInterfaces()), len(host.getAllInterfaces()), "Interfaces from original host should be equals to retrieved host's interfaces" ) i = self.mapper_manager.find(h.getAllInterfaces()[0].getID()) self.assertEquals( i.getID(), iface.getID(), "Interface's id' from original host should be equals to retrieved host's interface's id" )
def test_save_without_command(self, obj_class, many_test_data, monkeypatch, session): """ This test verifies that the request made to the api are the expected ones """ workspace = WorkspaceFactory.create(name='test') session.commit() mapper_manager = MapperManager() mapper_manager.createMappers(workspace.name) for test_data in many_test_data: raw_data = test_data['data'] if test_data['parent']: parent = test_data['parent']['parent_factory'].create() session.commit() test_data['data']['parent'] = parent.id test_data['data']['parent_type'] = test_data['parent']['parent_type'] if obj_class not in [Note, Command]: test_data['expected_payload']['parent'] = parent.id if obj_class in [Vuln, Credential]: test_data['expected_payload']['parent_type'] = test_data['parent']['parent_type'] def mock_server_post(test_data, post_url, update=False, expected_response=201, **params): assert post_url == '{0}/ws/test/{1}/'.format( _create_server_api_url(), test_data['api_end_point']) assert expected_response == 201 assert update == False if obj_class not in [Command]: metadata = params.pop('metadata') assert metadata['owner'] == test_data['expected_payload']['owner'] assert params == test_data['expected_payload'] return { 'id': 1, 'ok': True, 'rev': '' } monkeypatch.setattr(persistence.server.server, '_post', partial(mock_server_post, test_data)) obj = obj_class(raw_data, workspace.name) mapper_manager.save(obj)
def test_controller_cant_be_stopped_when_is_processing(): """ If someone tells the controller to stop and it is processing then it will stop when the processing finishes """ mappers_manager = MapperManager() pending_actions = Queue() controller = ModelController(mappers_manager, pending_actions) assert controller.processing is False assert controller._stop is False controller.start() controller.processing = True controller.active_plugins_count = 1 assert controller.isAlive() controller.stop() assert controller._stop assert controller.processing controller.join(timeout=2) assert controller.isAlive() controller.processing = False controller.join() assert controller.isAlive() is False
def setUp(self): self.mapper_manager = MapperManager() self.mapper_manager.createMappers(NullPersistenceManager()) self.imapper = self.mapper_manager.getMapper(Interface.__name__)
def setUp(self): self.mapper_manager = MapperManager() self.mapper_manager.createMappers(NullPersistenceManager()) self.hmapper = self.mapper_manager.getMapper(Host.__name__)
def setUp(self): self.mapper_manager = MapperManager() self.mapper_manager.createMappers(NullPersistenceManager())
def setUp(self): self.mapper_manager = MapperManager()
def setUp(self): self.mapper_manager = MapperManager() self.mapper_manager.createMappers(NullPersistenceManager()) self.wmapper = self.mapper_manager.getMapper(Workspace.__name__)
def setUp(self): self.mapper_manager = MapperManager() self.mapper_manager.createMappers(NullPersistenceManager()) self.mapper = self.mapper_manager.getMapper( CommandRunInformation.__name__)
def setUp(self): Mappers[ModelObject.class_signature] = ModelObjectMapper self.mapper_manager = MapperManager() self.mapper_manager.createMappers(NullPersistenceManager()) self.mapper = self.mapper_manager.getMapper(ModelObject.__name__)