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