def post(self): """ 任务删除 """ done_status = [TaskStatus.DONE, TaskStatus.STOP, TaskStatus.ERROR] args = self.parse_args(delete_task_fields) task_id_list = args.pop('task_id') del_task_data_flag = args.pop('del_task_data') for task_id in task_id_list: task_data = utils.conn_db('task').find_one( {'_id': ObjectId(task_id)}) if not task_data: return utils.build_ret(ErrorMsg.NotFoundTask, {"task_id": task_id}) if task_data["status"] not in done_status: return utils.build_ret(ErrorMsg.TaskIsRunning, {"task_id": task_id}) for task_id in task_id_list: utils.conn_db('task').delete_many({'_id': ObjectId(task_id)}) table_list = [ "cert", "domain", "fileleak", "ip", "service", "site", "url" ] if del_task_data_flag: for name in table_list: utils.conn_db(name).delete_many({'task_id': task_id}) return utils.build_ret(ErrorMsg.Success, {"task_id": task_id_list})
def post(self): """ 删除资产站点Tag """ args = self.parse_args(delete_asset_site_tag_fields) site_id = args.pop("_id") tag = args.pop("tag") query = {"_id": ObjectId(site_id)} data = utils.conn_db('asset_site').find_one(query) if not data: return utils.build_ret(ErrorMsg.SiteIdNotFound, {"site_id": site_id}) tag_list = [] old_tag = data.get("tag") if old_tag: if isinstance(old_tag, str): tag_list.append(old_tag) if isinstance(old_tag, list): tag_list.extend(old_tag) if tag not in tag_list: return utils.build_ret(ErrorMsg.SiteTagNotExist, {"tag": tag}) tag_list.remove(tag) utils.conn_db('asset_site').update_one(query, {"$set": { "tag": tag_list }}) return utils.build_ret(ErrorMsg.Success, {"tag": tag})
def post(self): """ 策略编辑 """ args = self.parse_args(edit_policy_fields) policy_id = args.pop('policy_id') policy_data = args.pop('policy_data', {}) query = {'_id': ObjectId(policy_id)} item = utils.conn_db('policy').find_one(query) if not item: return utils.build_ret(ErrorMsg.PolicyIDNotFound, {}) if not policy_data: return utils.build_ret(ErrorMsg.PolicyDataIsEmpty, {}) item = change_dict(item, policy_data) poc_config = item["policy"].pop("poc_config", []) poc_config = _update_plugin_config(poc_config) if isinstance(poc_config, str): return utils.build_ret(poc_config, {}) item["policy"]["poc_config"] = poc_config brute_config = item["policy"].pop("brute_config", []) brute_config = _update_plugin_config(brute_config) if isinstance(brute_config, str): return utils.build_ret(brute_config, {}) item["policy"]["brute_config"] = brute_config item["update_date"] = utils.curr_date() utils.conn_db('policy').find_one_and_replace(query, item) item.pop('_id') return utils.build_ret(ErrorMsg.Success, {"data": item})
def get(self): """ 针对资产组删除范围 """ args = self.parser.parse_args() scope = str(args.pop('scope', "")).lower() scope_id = str(args.pop('scope_id', "")).lower() scope_data = self.get_scope_data(scope_id) if not scope_data: return utils.build_ret(ErrorMsg.NotFoundScopeID, {"scope_id": scope_id}) query = {'_id': ObjectId(scope_id)} if scope not in scope_data.get("scope_array", []): return utils.build_ret(ErrorMsg.NotFoundScope, { "scope_id": scope_id, "scope": scope }) scope_data["scope_array"].remove(scope) scope_data["scope"] = ",".join(scope_data["scope_array"]) utils.conn_db(self._table).find_one_and_replace(query, scope_data) return utils.build_ret(ErrorMsg.Success, { "scope_id": scope_id, "scope": scope })
def _add_task(self, target_lists, task_data): try: ip_list, domain_list = self._get_ip_domain_list(target_lists) except Exception as e: return utils.build_ret(str(e), {}) ret_items = [] if domain_list: submit_result = self._submit_domain_list(domain_list, task_data) if isinstance(submit_result, str): return utils.build_ret(ErrorMsg.Error, {"error": submit_result}) ret_items.extend(submit_result) if ip_list: submit_result = self._submit_ip_list(ip_list, task_data) if isinstance(submit_result, str): return utils.build_ret(ErrorMsg.Error, {"error": submit_result}) ret_items.extend(submit_result) if not ret_items: return utils.build_ret(ErrorMsg.TaskTargetIsEmpty, {}) return utils.build_ret(ErrorMsg.Success, {"items": ret_items})
def post(self): """ 添加指纹信息 """ args = self.parse_args(add_fingerprint_fields) human_rule = args.pop('human_rule') name = args.pop('name') rule_map = parse_human_rule(human_rule) if rule_map is None: return utils.build_ret(ErrorMsg.RuleInvalid, {"rule": human_rule}) data = { "name": name, "rule": rule_map, "human_rule": transform_rule_map(rule_map), "update_date": utils.curr_date_obj() } utils.conn_db('fingerprint').insert_one(data) finger_id = str(data.pop('_id')) data.pop('update_date') return utils.build_ret(ErrorMsg.Success, { "_id": finger_id, "data": data })
def post(self): """ 资产组添加 """ args = self.parse_args(add_asset_scope_fields) name = args.pop('name') scope = args.pop('scope') black_scope = args.pop('black_scope') black_scope_array = [] if black_scope: black_scope_array = re.split(r",|\s", black_scope) scope_array = re.split(r",|\s", scope) for x in scope_array: if not utils.is_valid_domain(x): return utils.build_ret(ErrorMsg.DomainInvalid, {"scope": x}) if not scope_array: return utils.build_ret(ErrorMsg.DomainInvalid, {"scope": ""}) scope_data = { "name": name, "scope": scope, "scope_array": scope_array, "black_scope": black_scope, "black_scope_array": black_scope_array, } conn('asset_scope').insert(scope_data) scope_id = str(scope_data.pop("_id")) scope_data["scope_id"] = scope_id data = {"message": "success", "data": scope_data, "code": 200} return data
def get(self, task_id=None): """ 任务停止 """ done_status = [TaskStatus.DONE, TaskStatus.STOP, TaskStatus.ERROR] task_data = utils.conn_db('task').find_one({'_id': ObjectId(task_id)}) if not task_data: return utils.build_ret(ErrorMsg.NotFoundTask, {"task_id": task_id}) if task_data["status"] in done_status: return utils.build_ret(ErrorMsg.TaskIsRunning, {"task_id": task_id}) celery_id = task_data.get("celery_id") if not celery_id: return utils.build_ret(ErrorMsg.CeleryIdNotFound, {"task_id": task_id}) control = celerytask.celery.control control.revoke(celery_id, signal='SIGTERM', terminate=True) utils.conn_db('task').update_one({'_id': ObjectId(task_id)}, {"$set": { "status": TaskStatus.STOP }}) utils.conn_db('task').update_one( {'_id': ObjectId(task_id)}, {"$set": { "end_time": utils.curr_date() }}) return {"message": "success", "task_id": task_id, "code": 200}
def post(self): """ 添加域名到资产组中 """ args = self.parse_args(add_domain_fields) domain = args.pop("domain") scope_id = args.pop("scope_id") if not utils.is_valid_domain(domain): return utils.build_ret(ErrorMsg.DomainInvalid, {"domain": domain}) scope_data = utils.conn_db('asset_scope').find_one({"_id": ObjectId(scope_id)}) if not scope_data: return utils.build_ret(ErrorMsg.NotFoundScopeID, {"scope_id": scope_id}) if utils.get_fld(domain) not in scope_data["scope"]: return utils.build_ret(ErrorMsg.DomainNotFoundViaScope, {"domain": domain}) domain_data = utils.conn_db("asset_domain").find_one({"domain": domain, "scope_id": scope_id}) if domain_data: return utils.build_ret(ErrorMsg.DomainInScope, {"domain": domain}) options = { "celery_action": CeleryAction.ADD_DOMAIN_TO_SCOPE, "data": { "domain": domain, "scope_id": scope_id } } celerytask.arl_task.delay(options=options) return utils.build_ret(ErrorMsg.Success, options["data"])
def post(self): """ 添加域名到资产组中 """ args = self.parse_args(add_domain_fields) raw_domain = args.pop("domain") domain_list = re.split(r",|\s", raw_domain) domain_list = list(set(filter(None, domain_list))) scope_id = args.pop("scope_id") scope_data = utils.conn_db('asset_scope').find_one( {"_id": ObjectId(scope_id)}) if not scope_data: return utils.build_ret(ErrorMsg.NotFoundScopeID, {"scope_id": scope_id}) domain_in_scope_list = [] add_domain_list = [] for domain in domain_list: if not utils.is_valid_domain(domain): return utils.build_ret(ErrorMsg.DomainInvalid, {"domain": domain}) if utils.get_fld(domain) not in scope_data["scope"]: return utils.build_ret(ErrorMsg.DomainNotFoundViaScope, {"domain": domain}) domain_data = utils.conn_db("asset_domain").find_one({ "domain": domain, "scope_id": scope_id }) if domain_data: domain_in_scope_list.append(domain) continue add_domain_list.append(domain) for domain in add_domain_list: options = { "celery_action": CeleryAction.ADD_DOMAIN_TO_SCOPE, "data": { "domain": domain, "scope_id": scope_id } } celerytask.arl_task.delay(options=options) ret_data = { "domain": ",".join(add_domain_list), "scope_id": scope_id, "domain_in_scope": ",".join(domain_in_scope_list) } if len(add_domain_list) == 0: return utils.build_ret(ErrorMsg.DomainNotFoundNotInScope, ret_data) return utils.build_ret(ErrorMsg.Success, ret_data)
def post(self): """ 添加监控周期任务 """ args = self.parse_args(add_scheduler_fields) scope_id = args.pop("scope_id") domain = args.pop("domain") interval = args.pop("interval") name = args.pop("name") if interval < 3600 * 6: return utils.build_ret(ErrorMsg.IntervalLessThan3600, {"interval": interval}) monitor_domain = utils.arl.get_monitor_domain_by_id(scope_id) scope_data = utils.arl.scope_data_by_id(scope_id) if not scope_data: return utils.build_ret(ErrorMsg.NotFoundScopeID, {"scope_id": scope_id}) domains = domain.split(",") for x in domains: curr_domain = x.strip() if curr_domain not in scope_data["scope_array"]: return utils.build_ret(ErrorMsg.DomainNotFoundViaScope, { "domain": curr_domain, "scope_id": scope_id }) if curr_domain in monitor_domain: return utils.build_ret(ErrorMsg.DomainViaJob, { "domain": curr_domain, "scope_id": scope_id }) ret_data = [] for x in domains: curr_name = name if not name: curr_name = "监控-{}-{}".format(scope_data["name"], x) job_id = app_scheduler.add_job(domain=x, scope_id=scope_id, options=None, interval=interval, name=curr_name) ret_data.append({ "domain": x, "scope_id": scope_id, "job_id": job_id }) return utils.build_ret(ErrorMsg.Success, ret_data)
def post(self): """ 资产组添加 """ args = self.parse_args(add_asset_scope_fields) name = args.pop('name') scope = args.pop('scope') black_scope = args.pop('black_scope') scope_type = args.pop('scope_type') if scope_type not in [AssetScopeType.IP, AssetScopeType.DOMAIN]: scope_type = AssetScopeType.DOMAIN black_scope_array = [] if black_scope: black_scope_array = re.split(r",|\s", black_scope) scope_array = re.split(r",|\s", scope) # 清除空白符 scope_array = list(filter(None, scope_array)) new_scope_array = [] for x in scope_array: if scope_type == AssetScopeType.DOMAIN: if not utils.is_valid_domain(x): return utils.build_ret(ErrorMsg.DomainInvalid, {"scope": x}) new_scope_array.append(x) if scope_type == AssetScopeType.IP: transfer = utils.ip.transfer_ip_scope(x) if transfer is None: return utils.build_ret(ErrorMsg.ScopeTypeIsNotIP, {"scope": x}) new_scope_array.append(transfer) if not new_scope_array: return utils.build_ret(ErrorMsg.DomainInvalid, {"scope": ""}) scope_data = { "name": name, "scope_type": scope_type, "scope": ",".join(new_scope_array), "scope_array": new_scope_array, "black_scope": black_scope, "black_scope_array": black_scope_array, } conn('asset_scope').insert(scope_data) scope_id = str(scope_data.pop("_id")) scope_data["scope_id"] = scope_id return utils.build_ret(ErrorMsg.Success, scope_data)
def post(self): args = self.parse_args(add_policy_fields) name = args.pop("name") policy = args.pop("policy", {}) if policy is None: return utils.build_ret("Missing policy parameter", {}) domain_config = policy.pop("domain_config", {}) domain_config = self._update_arg(domain_config, domain_config_fields) ip_config = policy.pop("ip_config", {}) ip_config = self._update_arg(ip_config, ip_config_fields) site_config = policy.pop("site_config", {}) site_config = self._update_arg(site_config, site_config_fields) poc_config = policy.pop("poc_config", []) if poc_config is None: poc_config = [] poc_config = _update_plugin_config(poc_config) if isinstance(poc_config, str): return utils.build_ret(poc_config, {}) brute_config = policy.pop("brute_config", []) if brute_config is None: brute_config = [] brute_config = _update_plugin_config(brute_config) if isinstance(brute_config, str): return utils.build_ret(brute_config, {}) file_leak = fields.boolean(policy.pop("file_leak", False)) npoc_service_detection = fields.boolean( policy.pop("npoc_service_detection", False)) desc = args.pop("desc", "") item = { "name": name, "policy": { "domain_config": domain_config, "ip_config": ip_config, "site_config": site_config, "poc_config": poc_config, "brute_config": brute_config, "file_leak": file_leak, "npoc_service_detection": npoc_service_detection }, "desc": desc, "update_date": utils.curr_date() } utils.conn_db("policy").insert_one(item) return utils.build_ret(ErrorMsg.Success, {"policy_id": str(item["_id"])})
def post(self): args = self.parse_args(delete_task_post_fields) scope_id_list = args.pop('scope_id') for scope_id in scope_id_list: if not self.get_scope_data(scope_id): return utils.build_ret(ErrorMsg.NotFoundScopeID, {"scope_id": scope_id}) table_list = ["asset_domain", "asset_site", "asset_ip", "scheduler"] for scope_id in scope_id_list: utils.conn_db(self._table).delete_many({'_id': ObjectId(scope_id)}) for name in table_list: utils.conn_db(name).delete_many({'scope_id': scope_id}) return utils.build_ret(ErrorMsg.Success, {"scope_id": scope_id_list})
def get(self): """ 清空 PoC 信息 """ result = utils.conn_db('poc').delete_many({}) delete_cnt = result.deleted_count return utils.build_ret(ErrorMsg.Success, {"delete_cnt": delete_cnt})
def post(self): """ 删除监控周期任务 """ args = self.parse_args(delete_scheduler_fields) job_id_list = args.get("job_id", []) ret_data = {"job_id": job_id_list} for job_id in job_id_list: item = app_scheduler.find_job(job_id) if not item: return utils.build_ret(ErrorMsg.JobNotFound, ret_data) for job_id in job_id_list: app_scheduler.delete_job(job_id) return utils.build_ret(ErrorMsg.Success, ret_data)
def post(self): """ 添加资产范围 """ args = self.parse_args(add_scope_fields) scope = str(args.pop('scope', "")).lower() scope_array = re.split(r",|\s", scope) # 清除空白符 scope_array = list(filter(None, scope_array)) if not scope_array: return utils.build_ret(ErrorMsg.DomainInvalid, {"scope": ""}) scope_id = args.pop('scope_id', "") table = 'asset_scope' query = {'_id': ObjectId(scope_id)} scope_data = utils.conn_db(table).find_one(query) if not scope_data: return utils.build_ret(ErrorMsg.NotFoundScopeID, { "scope_id": scope_id, "scope": scope }) logger.info(scope_array) for x in scope_array: if not utils.is_valid_domain(x): return utils.build_ret(ErrorMsg.DomainInvalid, {"scope": x}) if x in scope_data.get("scope_array", []): return utils.build_ret(ErrorMsg.ExistScope, { "scope_id": scope_id, "scope": x }) scope_data["scope_array"].append(x) scope_data["scope"] = ",".join(scope_data["scope_array"]) utils.conn_db(table).find_one_and_replace(query, scope_data) return utils.build_ret(ErrorMsg.Success, { "scope_id": scope_id, "scope": scope })
def post(self): """ 停止监控周期任务 """ args = self.parse_args(stop_scheduler_fields) job_id = args.get("job_id") item = app_scheduler.find_job(job_id) if not item: return utils.build_ret(ErrorMsg.JobNotFound, {"job_id": job_id}) status = item.get("status", SchedulerStatus.RUNNING) if status != SchedulerStatus.RUNNING: return utils.build_ret(ErrorMsg.SchedulerStatusNotRunning, {"job_id": job_id}) app_scheduler.stop_job(job_id) return utils.build_ret(ErrorMsg.Success, {"job_id": job_id})
def get(self): """ 更新 PoC 信息 """ n = NPoC() plugin_cnt = len(n.plugin_name_list) n.sync_to_db() n.delete_db() return utils.build_ret(ErrorMsg.Success, {"plugin_cnt": plugin_cnt})
def get(self): """ 控制台信息查看 """ data = { "device_info": utils.device_info() # 包含 CPU 内存和磁盘信息 } return utils.build_ret(ErrorMsg.Success, data)
def post(self): """ 删除站点 """ args = self.parse_args(delete_site_fields) id_list = args.pop('_id', []) for _id in id_list: query = {'_id': ObjectId(_id)} utils.conn_db('site').delete_one(query) return utils.build_ret(ErrorMsg.Success, {'_id': id_list})
def post(self): """ 删除资产组中的IP """ args = self.parse_args(delete_ip_fields) id_list = args.pop('_id', "") for _id in id_list: query = {'_id': ObjectId(_id)} utils.conn_db('asset_ip').delete_one(query) return utils.build_ret(ErrorMsg.Success, {'_id': id_list})
def post(self): """ 策略删除 """ args = self.parse_args(delete_policy_fields) policy_id_list = args.pop('policy_id') for policy_id in policy_id_list: if not policy_id: continue utils.conn_db('policy').delete_one({'_id': ObjectId(policy_id)}) """这里直接返回成功了""" return utils.build_ret(ErrorMsg.Success, {})
def post(self): """ 添加站点到资产组中 """ args = self.parse_args(add_site_fields) site = args.pop("site") scope_id = args.pop("scope_id") url = utils.normal_url(site).strip("/") if not url: return utils.build_ret(ErrorMsg.DomainInvalid, {"site": site}) scope_data = utils.conn_db('asset_scope').find_one( {"_id": ObjectId(scope_id)}) if not scope_data: return utils.build_ret(ErrorMsg.NotFoundScopeID, {"scope_id": scope_id}) fld = utils.get_fld(url) if not fld: return utils.build_ret(ErrorMsg.SiteURLNotDomain, {"site": url}) if fld not in scope_data["scope"]: return utils.build_ret(ErrorMsg.DomainNotFoundViaScope, {"site": url}) site_data = utils.conn_db('asset_site').find_one({ "site": url, "scope_id": scope_id }) if site_data: return utils.build_ret(ErrorMsg.SiteInScope, {"site": url}) add_site_to_scope(url, scope_id) return utils.build_ret(ErrorMsg.Success, {"site": url})
def post(self): """ 任务同步 """ done_status = [TaskStatus.DONE, TaskStatus.STOP, TaskStatus.ERROR] args = self.parse_args(sync_task_fields) task_id = args.pop('task_id') scope_id = args.pop('scope_id') query = {'_id': ObjectId(task_id)} task_data = utils.conn_db('task').find_one(query) if not task_data: return utils.build_ret(ErrorMsg.NotFoundTask, {"task_id": task_id}) asset_scope_data = utils.conn_db('asset_scope').find_one( {'_id': ObjectId(scope_id)}) if not asset_scope_data: return utils.build_ret(ErrorMsg.NotFoundScopeID, {"task_id": task_id}) if task_data.get("type") != "domain": return utils.build_ret(ErrorMsg.TaskTypeIsNotDomain, {"task_id": task_id}) if not utils.is_in_scopes(task_data["target"], asset_scope_data["scope_array"]): return utils.build_ret(ErrorMsg.TaskTargetNotInScope, {"task_id": task_id}) if task_data["status"] not in done_status: return utils.build_ret(ErrorMsg.TaskIsRunning, {"task_id": task_id}) task_sync_status = task_data.get("sync_status", TaskSyncStatus.DEFAULT) if task_sync_status not in [ TaskSyncStatus.DEFAULT, TaskSyncStatus.ERROR ]: return utils.build_ret(ErrorMsg.TaskSyncDealing, {"task_id": task_id}) task_data["sync_status"] = TaskSyncStatus.WAITING options = { "celery_action": CeleryAction.DOMAIN_TASK_SYNC_TASK, "data": { "task_id": task_id, "scope_id": scope_id } } celerytask.arl_task.delay(options=options) conn('task').find_one_and_replace(query, task_data) return utils.build_ret(ErrorMsg.Success, {"task_id": task_id})
def post(self): """ 任务批量停止 """ args = self.parse_args(batch_stop_fields) task_id_list = args.pop("task_id", []) for task_id in task_id_list: if not task_id: continue stop_task(task_id) """这里直接返回成功了""" return utils.build_ret(ErrorMsg.Success, {})
def get(self): """ 保存资产站点到结果集 """ args = self.parser.parse_args() query = self.build_db_query(args) items = utils.conn_db('asset_site').distinct("site", query) items = list(set([utils.url.cut_filename(x) for x in items])) if len(items) == 0: return utils.build_ret(ErrorMsg.QueryResultIsEmpty, {}) data = {"items": items, "type": "asset_site", "total": len(items)} result = utils.conn_db('result_set').insert_one(data) ret_data = { "result_set_id": str(result.inserted_id), "result_total": len(items), "type": "asset_site" } return utils.build_ret(ErrorMsg.Success, ret_data)
def post(self): """ 添加资产范围 """ args = self.parse_args(add_scope_fields) scope = str(args.pop('scope', "")).lower() scope_id = args.pop('scope_id', "") table = 'asset_scope' query = {'_id': ObjectId(scope_id)} scope_data = utils.conn_db(table).find_one(query) if not scope_data: return utils.build_ret(ErrorMsg.NotFoundScopeID, { "scope_id": scope_id, "scope": scope }) scope_type = scope_data.get("scope_type") if scope_type not in [AssetScopeType.IP, AssetScopeType.DOMAIN]: scope_type = AssetScopeType.DOMAIN scope_array = re.split(r",|\s", scope) # 清除空白符 scope_array = list(filter(None, scope_array)) if not scope_array: return utils.build_ret(ErrorMsg.DomainInvalid, {"scope": ""}) for x in scope_array: new_scope = x if scope_type == AssetScopeType.DOMAIN: if not utils.is_valid_domain(x): return utils.build_ret(ErrorMsg.DomainInvalid, {"scope": x}) if scope_type == AssetScopeType.IP: transfer = utils.ip.transfer_ip_scope(x) if transfer is None: return utils.build_ret(ErrorMsg.ScopeTypeIsNotIP, {"scope": x}) new_scope = transfer if new_scope in scope_data.get("scope_array", []): return utils.build_ret(ErrorMsg.ExistScope, { "scope_id": scope_id, "scope": x }) scope_data["scope_array"].append(new_scope) scope_data["scope"] = ",".join(scope_data["scope_array"]) utils.conn_db(table).find_one_and_replace(query, scope_data) return utils.build_ret(ErrorMsg.Success, { "scope_id": scope_id, "scope": scope })
def get(self): """ 任务同步资产组查询 """ args = self.parser.parse_args() target = args.pop("target") if not utils.is_valid_domain(target): return utils.build_ret(ErrorMsg.DomainInvalid, {"target": target}) args["scope_array"] = utils.get_fld(target) args["size"] = 100 args["order"] = "_id" data = self.build_data(args=args, collection='asset_scope') ret = [] for item in data["items"]: if utils.is_in_scopes(target, item["scope_array"]): ret.append(item) data["items"] = ret data["total"] = len(ret) return data
def post(self): """ 任务提交 """ args = self.parse_args(add_task_fields) name = args.pop('name') target = args.pop('target') target = target.strip().lower() task_data = { "name": name, "target": target, "start_time": "-", "end_time": "-", "task_tag": "task", #标记为正常下发的任务 "service": [], "status": "waiting", "options": args, "type": "domain" } logger.info(task_data) target_lists = re.split(r",|\s", target) # 清除空白符 target_lists = list(filter(None, target_lists)) ip_target_list = [] ret_items = [] for item in target_lists: if not utils.is_valid_domain( item) and not utils.is_vaild_ip_target(item): return utils.build_ret(ErrorMsg.TargetInvalid, data={"target": item}) if utils.is_vaild_ip_target(item): if not utils.not_in_black_ips(item): return utils.build_ret(ErrorMsg.IPInBlackIps, data={"ip": item}) for item in target_lists: if utils.is_valid_domain(item): ret_item = {"target": item, "type": "domain"} domain_task_data = task_data.copy() domain_task_data["target"] = item _task_data = submit_task(domain_task_data) ret_item["task_id"] = _task_data.get("task_id", "") ret_item["celery_id"] = _task_data.get("celery_id", "") ret_items.append(ret_item) elif utils.is_vaild_ip_target(item): if utils.not_in_black_ips(item): ip_target_list.append(item) else: ret_item = { "target": item, "type": "in black ip list", "task_id": "", "celery_id": "" } ret_items.append(ret_item) else: ret_item = { "target": item, "type": "unknown", "task_id": "", "celery_id": "" } ret_items.append(ret_item) if ip_target_list: ip_task_data = task_data.copy() ip_task_data["target"] = " ".join(ip_target_list) ip_task_data["type"] = "ip" ret_item = { "target": ip_task_data["target"], "type": ip_task_data["type"] } _task_data = submit_task(ip_task_data) ret_item["task_id"] = _task_data.get("task_id", "") ret_item["celery_id"] = _task_data.get("celery_id", "") ret_items.append(ret_item) ret_data = { "items": ret_items, "options": args, "message": "success", "code": 200 } return ret_data