def taskstatus(task_id): """ Requests the status of a Celery task. :param task_id: Task's id to be requested. :return: Response object containing the status of the request """ task = getTaskStatus(task_id) status = "" if task.state == 'PENDING': status = task.state body = {'state': task.state, 'current': 0, 'total': 1} elif task.state != 'FAILURE': status = "IN_PROGRESS" status = task.info.get('status', '') body = { 'state': task.state, 'current': task.info.get('current', 0), 'total': task.info.get('total', 1), } if 'result' in task.info: body['result'] = task.info['result'] else: # something went wrong in the background job body = { 'state': task.state, 'current': 1, 'total': 1, 'status': str(task.info), # this is the exception raised } response = Response(True, "Task status", status, task_id) response.setBody(body) return jsonify(response.dictionary())
def editOne(self, scenario_json): """ Edits a current scenario with a JSON file :param scenario_json: JSON file with the new scenario :return: Response object containing the status of the request """ response = Response() print(scenario_json) scenario_name = scenario_json["scenario_name"] if scenario_name in self.scenarios_dict: if "machines" in scenario_json: for machine in scenario_json["machines"]: if scenario_json["machines"][machine]["uuid"] == "": new_uuid = uuid.uuid4() new_uuid = str(new_uuid).replace('-', '') print("Unique id: ", new_uuid) scenario_json['machines'][machine]['uuid'] = new_uuid scenario_json = Scenario(scenario_name).objectFromDictionary( scenario_json) self.scenarios_dict[scenario_name] = scenario_json #self._saveScenarioAsJSON(new_scenario) self.db_manager.editScenario(scenario_json.dictionary().copy()) response.setResponse(True) response.setBody(self.scenarios_dict[scenario_name].dictionary()) else: response.setReason('Scenario doesn\'t exist') response.setResponse(False) response.setBody(dict()) return response.dictionary()
def getAll(self): """ Gets the available exploits :return: Response object containing the status of the request """ # Variables exploits_dict = { "exploits": [self.exploits_dict[e].name for e in self.exploits_dict] } response = Response() response.setResponse(True) response.setBody(exploits_dict) return response.dictionary()
def getOne(self, exploit_name): """ Gets the scenario as a JSON file :param exploit_name: Exploit's name string :return: Response object containing the status of the request """ response = Response() if exploit_name in self.exploits_dict: response.setResponse(True) response.setBody(self.exploits_dict[exploit_name].dictionary()) else: response.setResponse(False) response.setReason('Exploit doesn\'t exist') response.setBody(dict()) return response.dictionary()
def getOne(self, scenario_name): """ Gets the scenario as a JSON file :param scenario_name: String with the scenario name :return: Response object containing the status of the request """ response = Response() if scenario_name in self.scenarios_dict: response.setResponse(True) response.setBody(self.scenarios_dict[scenario_name].dictionary()) else: response.setResponse(False) response.setReason('Scenario doesn\'t exist') response.setBody(dict()) return response.dictionary()
def getOne(self, vulnerability_name): """ Gets the scenario as a JSON file :param vulnerability_name: VUlnerability's name string :return: Response object containing the status of the request """ response = Response() if vulnerability_name in self.vulnerabilities_dict: response.setResponse(True) response.setBody( self.vulnerabilities_dict[vulnerability_name].dictionary()) else: response.setResponse(False) response.setReason('Vulnerability doesn\'t exist') response.setBody(dict()) return response.dictionary()
def getAll(self): """ Gets the available exploits :return: Response object containing the status of the request """ # Variables vulnerabilities_dict = { "vulnerabilities": [ self.vulnerabilities_dict[v].name for v in self.vulnerabilities_dict ] } response = Response() response.setResponse(True) response.setBody(vulnerabilities_dict) return response.dictionary()
def getAll(self): """ Gets the available scenarios :return: Response object containing the status of the request """ # Variables scenarios_dict = { "scenarios": [ self.scenarios_dict[s].scenario_name for s in self.scenarios_dict ] } response = Response() response.setResponse(True) response.setBody(scenarios_dict) return response.dictionary()
def deleteOne(self, exploit_name): """ Deletes an exploit from the database. :param exploit_name: Exploit's name string :return: Response object containing the status of the request """ response = Response() if exploit_name in self.exploits_dict: deleted_exploit = self.exploits_dict.pop(exploit_name) self.db_manager.deleteExploit(exploit_name) response.setResponse(True) response.setBody(deleted_exploit.dictionary()) else: response.setResponse(False) response.setReason('Exploit doesn\'t exist') response.setBody(dict()) return response.dictionary()
def deleteOne(self, scenario_name): """ Deletes one scenario from the database. :param scenario_name: Scenario's name string :return: Response object containing the status of the request """ response = Response() if scenario_name in self.scenarios_dict: deleted_scenario = self.scenarios_dict.pop(scenario_name) #self.file_manager.deleteScenariosFolder(scenario_name) self.db_manager.deleteScenario(scenario_name) response.setResponse(True) response.setBody(deleted_scenario.dictionary()) else: response.setResponse(False) response.setReason('Scenario doesn\'t exist') response.setBody(dict()) return response.dictionary()
def deleteOne(self, vulnerability_name): """ Deletes a vulnerability from the database. :param vulnerability_name: Vulnerability's name string :return: Response object containing the status of the request """ response = Response() if vulnerability_name in self.vulnerabilities_dict: deleted_vulnerability = self.vulnerabilities_dict.pop( vulnerability_name) self.db_manager.deleteVulnerability(vulnerability_name) response.setResponse(True) response.setBody(deleted_vulnerability.dictionary()) else: response.setResponse(False) response.setReason('Vulnerability doesn\'t exist') response.setBody(dict()) return response.dictionary()
def newEmpty(self, exploit_name): """ Creates a new exploit which includes the folders and the exploit JSON file :param exploit_name: String with the exploit name :return: Response object containing the status of the request """ response = Response() if exploit_name not in self.exploits_dict: exploit = Exploit(exploit_name) self.exploits_dict[exploit_name] = exploit self.db_manager.insertExploit(exploit.dictionary().copy()) response.setResponse(True) response.setBody(exploit.dictionary()) else: response.setResponse(False) response.setReason('Exploit already exist') response.setBody(dict()) return response.dictionary()
def newEmpty(self, vulnerability_name): """ Creates a new vulnerability which includes the folders and the vulnerability JSON file :param vulnerability_name: String with the vulnerability name :return: Response object containing the status of the request """ response = Response() if vulnerability_name not in self.vulnerabilities_dict: vulnerability = Vulnerability(vulnerability_name) self.vulnerabilities_dict[vulnerability_name] = vulnerability self.db_manager.insertVulnerability( vulnerability.dictionary().copy()) response.setResponse(True) response.setBody(vulnerability.dictionary()) else: response.setResponse(False) response.setReason('Vulnerability already exist') response.setBody(dict()) return response.dictionary()
def editOne(self, exploit_json): """ Edits a current scenario with a JSON file :param exploit_json: JSON file with the exploit's data :return: Response object containing the status of the request """ response = Response() print(exploit_json) exploit_name = exploit_json["name"] if exploit_name in self.exploits_dict: exploit_json = Exploit().objectFromDictionary(exploit_json) self.exploits_dict[exploit_name] = exploit_json self.db_manager.editExploit(exploit_json.dictionary().copy()) response.setResponse(True) response.setBody(self.exploits_dict[exploit_name].dictionary()) else: response.setReason('Exploit doesn\'t exist') response.setResponse(False) response.setBody(dict()) return response.dictionary()
def getSystemInfo(self): """ Gets the system info. :return: Response object containing request info """ cpu_count_logical = psutil.cpu_count(logical=True) cpu_count = psutil.cpu_count(logical=False) memory = psutil.virtual_memory() mem = getattr(memory, 'total') memory_bytes = int(mem) gigabytes = float(1024**3) total_ram = ceil(memory_bytes / gigabytes) info = { 'cpu_count_logical': cpu_count, 'cpu_count': cpu_count, 'total_ram': total_ram } response = Response() response.setResponse(True) response.setBody(info) return response.dictionary()
def newEmpty(self, scenario_name): """ Creates a new scenario which includes the folders and the scenario JSON file :param scenario_name: String with the scenario name :return: Response object containing the status of the request """ #Folder creation moved to FileManager response = Response() if scenario_name not in self.scenarios_dict: #self.file_manager.createScenarioFolders(scenario_name) scenario = Scenario(scenario_name) self.scenarios_dict[scenario_name] = scenario #self._saveScenarioAsJSON(scenario) self.db_manager.insertScenario(scenario.dictionary().copy()) response.setResponse(True) response.setBody(scenario.dictionary()) else: response.setResponse(False) response.setReason('Scenario already exist') response.setBody(dict()) return response.dictionary()
def editOne(self, vulnerability_json): """ Edits a current scenario with a JSON file :param vulnerability_json: JSON file new vulnerability :return: Response object containing the status of the request """ response = Response() print(vulnerability_json) vulnerability_name = vulnerability_json["name"] if vulnerability_name in self.vulnerabilities_dict: vulnerability_json = Vulnerability().objectFromDictionary( vulnerability_json) self.vulnerabilities_dict[vulnerability_name] = vulnerability_json self.db_manager.editVulnerability( vulnerability_json.dictionary().copy()) response.setResponse(True) response.setBody( self.vulnerabilities_dict[vulnerability_name].dictionary()) else: response.setReason('Vulnerability doesn\'t exist') response.setResponse(False) response.setBody(dict()) return response.dictionary()
def getAvailableBoxes(self): """ Gets the available boxes in the Vagrant context :return: A list of string with the available boxes """ # Variables response = Response() boxes = {} boxNum = 0 boxlist = subprocess.check_output("vagrant box list", shell=True) boxlist = str(boxlist) boxlist = re.sub(r"(^[b']|'|\s(.*?)\\n)", " ", boxlist) boxlist = boxlist.split(" ") boxlist = filter(None, boxlist) print("Loading available Vanilla VMs") for boxName in boxlist: boxNum = boxNum + 1 boxes[boxNum] = boxName print("[ " + str(boxNum) + " ]" + boxName) response.setResponse(True) response.setBody(boxes) return response.dictionary()