def com_sourcecode_files_tree(request):
pack_id, tree_type = ReqParams.many(request, ['pack_id', 'tree_type'])
file_list = SourceCodeFileDO.search_files_of_pack(pack_id)
if tree_type is None or len(tree_type) == 0 or tree_type == 'normal':
tree_type = 'normal'
exec_tree = {}
elif tree_type == 'antd':
exec_tree = []
else:
tree_type = 'normal'
exec_tree = {}
# 对每个文件做树的各级节点定位和创建
for file in file_list:
# 获取文件路径
file_path = file['file_path']
file_id = file['file_id']
if file_path is None or len(file_path) == 0:
continue
if tree_type == 'normal':
MyTree.file_path_insert_into_tree(exec_tree, file_path, file_id)
elif tree_type == 'antd':
MyTree.file_path_insert_into_antd_tree(exec_tree, file_path,
file_id)
# 保存操作日志
LogRecords.save('',
category='statistics',
action='查询组件源码文件目录树',
desc='获取组件源码文件目录树（模式为：%s）' % (tree_type))
return sys_app_ok_p(exec_tree)
def init_exec_status(self):
# 初始化缓存的任务信息
task_info = {
'task_id': self._task_id,
'start_time': SysUtils.get_now_time_str(),
'task_status': TaskStatus.RUNNING,
'percentage': 0.0,
'progress_history': [],
'result': {}
}
task_info = dict(task_info, **self._extra_info)
# 缓存该任务信息
MyRedis.set(self._task_id, task_info, category=task_cat)
# 在数据库中保存任务记录
TasksDAO.save(task_info)
# 保存任务详情日志
LogRecords.save(task_info,
category='task',
action='任务启动',
desc='记录任务启动时状态及任务信息')
# 返回该任务信息
return task_info
def pack_delete(request):
pack_id = ReqParams.one(request, 'pack_id')
# delete fw_files_storage
# delete fw_files
# delete pack_files_storage
# delete pack_files
file_list = FwFileDO.search_files_of_pack(pack_id)
for file in file_list:
FwFilesStorage.delete(file['file_id'])
# if len(file_list) > 0:
FwFileDO.delete_many_of_pack(pack_id)
pack_info = PackFileDO.fetch_pack(pack_id)
PackFilesStorage.delete(pack_info['file_id'])
PackFileDO.delete(pack_id)
# 保存操作日志
LogRecords.save('',
category='statistics',
action='删除固件包',
desc='删除指定固件包（ID=%s）的信息，' % pack_id)
return sys_app_ok_p([])
def test_log_switch(request):
log_configs = SystemConfig.get_cache_log_cfg()
keys = log_configs.keys()
for category in keys:
LogRecords.save('test_log_switch: ' + category,
category=category,
action='test_log_switch')
return sys_app_ok()
def function_info(request):
# 从请求中取参数：文件 ID、函数地址
file_id, func_addr, extra_info = ReqParams.many(
request, ['file_id', 'func_addr.hex', 'extra_info'])
# 获取指定函数的汇编、中间码等代码信息
codes_dict = FunctionsService.func_codes(file_id, func_addr)
infos_dict = codes_dict
if extra_info is not None:
# 取出首尾空格后分割成列表（用逗号分隔）
extra_list = extra_info.strip().split(',')
if 'props' in extra_list:
# 如指定 props 则附加函数属性信息
props_dict = FunctionsService.func_props(file_id, func_addr)
infos_dict['props'] = props_dict
if 'vars' in extra_list:
# 如指定 props 则附加函数变量信息
vars_dict = VarsService.extract_vars(file_id, func_addr)
infos_dict['vars'] = vars_dict
infos_dict['vulnerabe'] = {
'flag': '0',
'desc': '非脆弱性函数'
} # 0:非脆弱性函数 1:脆弱性函数
infos_dict['taint'] = {'flag': '0', 'desc': '非污点函数'} # 0:非污点函数 1:非污点函数
func_name = infos_dict.get('function_name')
if func_name is not None:
vulner_info = func_vulner_col.find_one(
{'func_name': {
'$regex': func_name
}})
if vulner_info is not None:
infos_dict['vulnerabe'] = {
'flag': '1',
'desc': '脆弱性函数'
} # 0:非脆弱性函数 1:脆弱性函数
taint_info = func_taint_col.find_one(
{'func_name': {
'$regex': func_name
}})
if taint_info is not None:
infos_dict['taint'] = {
'flag': '1',
'desc': '污点函数'
} # 0:非污点函数 1:非污点函数
# 保存操作日志
LogRecords.save('',
category='query',
action='查询函数分析信息',
desc='查询代码分析后的函数信息，文件ID=%s，函数地址=0x%x' %
(file_id, func_addr))
return sys_app_ok_p(infos_dict)
def pack_exec_files_tree(request):
pack_id, tree_type = ReqParams.many(request, ['pack_id', 'tree_type'])
start_check_component_task(pack_id)
# # # 检查组件关联
# # check_component(pack_id, FileType.EXEC_FILE)
# # 修改为任务处理方式进行检查组件关联 关联组件标记，相似度匹配计算，标记漏洞(version/edbid)
# # 启动编译任务
# extra_info = {'task_type': TaskType.COMPONENT_CHECK,
# 'task_name': '检查组件关联',
# 'task_desc': '检查组件关联,相似度匹配计算，标记漏洞(version/edbid)'}
# task = MyTask(check_component, (pack_id,), extra_info=extra_info)
# task_id = task.get_task_id()
# 读取所有可执行文件
exec_list = FwFileDO.search_files_of_pack(pack_id, FileType.EXEC_FILE)
if tree_type is None or len(tree_type) == 0 or tree_type == 'normal':
# file_path_insert_into_tree 树，初始化为字典
tree_type = 'normal'
exec_tree = {}
elif tree_type == 'antd':
# file_path_insert_into_antd_tree 树，初始化为数组
exec_tree = []
else:
tree_type = 'normal'
exec_tree = {}
# 对每个文件做树的各级节点定位和创建
for exec_file in exec_list:
# 获取文件路径
file_path = exec_file['file_path']
file_id = exec_file['file_id']
component = exec_file['component']
# if exec_file['component'] is not None:
# component = exec_file['component']
# else:
# component = 0
if file_path is None or len(file_path) == 0:
continue
if tree_type == 'normal':
MyTree.file_path_insert_into_tree(exec_tree, file_path, file_id,
component)
elif tree_type == 'antd':
MyTree.file_path_insert_into_antd_tree(exec_tree, file_path,
file_id, component)
# 保存操作日志
LogRecords.save('',
category='statistics',
action='读取固件包文件结构',
desc='获取指定固件包（ID=%s）的文件结构（模式为：%s）' % (pack_id, tree_type))
return sys_app_ok_p(exec_tree)
def query_component(request):
# path('task/query_component', task_view.query_component, name='task_query_component'),
# 读取数据库任务集合
task_id_list = TasksDAO.all_component()
# 保存操作日志
LogRecords.save(task_id_list, category='query', action='查询组件任务状态')
return sys_app_ok_p(task_id_list)
def taintmodify(request):
# 从请求中取参数：文件 ID
func_name, hazard, solution = ReqParams.many(request, ['func_name', 'hazard', 'solution'], protocol='POST')
TaintdictDO.update(func_name, hazard, solution)
# 保存操作日志
LogRecords.save('', category='statistics', action='自定义污点函数－删除',
desc='污点函数（func_name=%s）的信息，' % func_name)
return sys_app_ok_p([])
def stop_task(request):
# 从请求中取参数：任务 ID
task_id = req_get_param(request, 'task_id')
task_info = MyTask.stop_task(task_id)
# 保存操作日志
LogRecords.save(task_info, category='task', action='停止任务',
desc='停止指定的任务（ID=%s）' % task_id)
return sys_app_ok_p(task_info)
def com_files_list(request):
# 读取所有组件文件
com_list = FwFileDO.search_all_com_files()
print(com_list)
comlist = []
for com in com_list:
print(com)
inverted = com.get('inverted')
cfg_analyze = com.get('cfg_analyze')
file_type_verified = com.get('file_type_verified')
extra_props = com.get('extra_props')
if extra_props is not None:
extra_props.setdefault('name', '')
extra_props.setdefault('version', '')
extra_props.setdefault('edb_id', '')
extra_props.setdefault('similarity', '')
name = extra_props['name']
version = extra_props['version']
edb_id = extra_props['edb_id']
similarity = extra_props['similarity']
else:
name = ""
version = ""
edb_id = ""
similarity = ""
doc = {
'file_id': com['file_id'],
'file_path': com['file_path'],
'component': com['component'],
'create_time': com['create_time'],
'file_name': com['file_name'],
'file_type': com['file_type'],
'pack_id': com['pack_id'],
'version': version,
'name': name,
'edb_id': edb_id,
'file_type_verified': file_type_verified,
'cfg_analyze': cfg_analyze,
'inverted': inverted,
'similarity': similarity,
'fw_name': com['pack_docs'][0]['name']
}
comlist.append(doc)
# 保存操作日志
LogRecords.save('',
category='statistics',
action='查询所有组件文件列表',
desc='查询所有组件文件列表')
return sys_app_ok_p(comlist)
def get_task_result(request):
# 从请求中取参数：任务 ID
task_id = req_get_param(request, 'task_id')
# 从缓存中读取任务执行信息
task_info = MyTask.fetch_exec_info(task_id)
# 保存操作日志
LogRecords.save(task_info, category='query_task', action='查询任务状态',
desc='读取任务（ID=%s）当前执行状态及结果信息' % task_id)
return sys_app_ok_p(task_info)
def read_sys_config(request):
read_all = ReqParams.one(request, 'all_config.int')
# 从数据库中读取系统配置
config = SystemConfig.read_db(read_all)
# 保存操作日志
LogRecords.save(config,
category='system_config',
action='读取系统配置',
desc='读取系统各项配置参数')
return sys_app_ok_p(config)
def search_tasks_by_file(request):
# 从请求中取参数：文件 ID
file_id = req_get_param(request, 'file_id')
if file_id is None:
return sys_app_ok_p([])
tasks_list = TasksDAO.search_by_file(file_id)
# 保存查询日志
LogRecords.save(tasks_list, category='query_task', action='查询文件任务',
desc='查询指定的文件（ID=%s）所有的任务信息' % file_id)
return sys_app_ok_p(tasks_list)
def taintdel(request):
# 从请求中取参数：文件 ID
func_name = ReqParams.one(request, 'func_name')
ret = TaintdictDO.delete(func_name)
# 保存操作日志
LogRecords.save('', category='statistics', action='自定义污点函数－删除',
desc='污点函数（func_name=%s）的信息，' % func_name)
if ret:
return sys_app_ok_p('删除成功')
else:
return sys_app_ok_p('删除失败')
def entry_state_info(request):
# 从请求中取参数：文件 ID
file_id = req_get_param(request, 'file_id')
info = FilesService.bin_state_info(file_id)
# 保存操作日志
LogRecords.save(info,
category='analysis',
action='入口状态机',
desc='分析可执行文件的入口状态机参数')
return sys_app_ok_p(info)
def taint_func_list(request):
# 从请求中取参数：文件 ID
file_id = ReqParams.one(request, 'file_id')
# 查找函数列表分析结果
# 查询文件 CFG 分析的标记
is_cfg = CfgAnalyzeService.has_cfg_analyze(file_id)
if not is_cfg:
# 启动分析任务
task_id = CfgAnalyzeService.start_cfg_task(file_id)
# 保存操作日志
LogRecords.save({
'task_id': task_id,
'file_id': file_id
},
category='analysis',
action='分析CFG',
desc='对二进制文件做调用流程图分析')
# 返回响应：任务初始化的信息
return sys_app_ok_p(MyTask.fetch_exec_info(task_id))
# 启动分析任务
functions = FilesService.functions_list(file_id)
if len(functions) == 0:
return sys_app_err(Error.FW_FILE_NO_CFG_ANALYZE)
taint_func_list = []
taint_funcs = []
taint_list = func_taint_col.find()
for taint_info in taint_list:
taint_funcs.append(taint_info.get('func_name'))
for func_info in functions:
func_name = func_info.get('name')
for taint_func_info in taint_funcs:
if taint_func_info == func_name:
taint_func_list.append(taint_func_info)
# 保存操作日志
LogRecords.save('',
category='query',
action='查询污点函数列表',
desc='查询指定固件文件（ID=%s）在代码分析中产生的函数列表' % file_id)
return sys_app_ok_p({
'taint_num': len(taint_func_list),
'taint_func_list': taint_func_list
})
def pack_info(request):
pack_id = ReqParams.one(request, 'pack_id')
# 读取指定固件包的信息
pack_service = PackInfoService(pack_id, None)
info = pack_service.pack_summary()
# 保存操作日志
LogRecords.save('',
category='statistics',
action='查询包信息',
desc='查询指定固件包（ID=%s）的信息，统计其文件数量，查询任务信息' % pack_id)
return sys_app_ok_p(info)
def get_all_task_result(request):
# 读取数据库任务集合
task_id_list = TasksDAO.all_tasks()
# task_info_list = []
# # 从缓存中读取任务执行信息
# for task in task_id_list:
# print(task['task_id'])
# task_info = MyTask.fetch_exec_info(task['task_id'])
# task_id_list.append(task_info)
# 保存操作日志
LogRecords.save(task_id_list, category='query', action='查询全部任务状态')
return sys_app_ok_p(task_id_list)
def pack_edit(request):
pack_id, manufacturer, model, version = ReqParams.many(
request, ['pack_id', 'manufacturer', 'model', 'version'],
protocol='POST')
PackFileDO.save_manufacturer(pack_id, manufacturer, model, version)
# 保存操作日志
LogRecords.save('',
category='statistics',
action='编辑指定固件包信息',
desc='编辑指定固件包信息 厂商 型号（ID=%s）的信息' % pack_id)
return sys_app_ok_p([])
def async_funcs_fetch(request):
# 获取固件ID
firmware_id = req_get_param(request, 'firmware_id')
# 启动任务 存储桶读取固件内容
task = MyTask(_proc_fetch, (firmware_id, settings.FW_PATH))
task_id = task.get_task_id()
# 保存操作日志
LogRecords.save({'task_id': task_id, 'file_id': firmware_id}, category='fetch', action='下载固件',
desc='存储桶读取固件保存并进行文件抽取')
# 返回响应：任务初始化的信息
return sys_app_ok_p(MyTask.fetch_exec_info(task_id))
def info(request):
pack_id = ReqParams.one(request, 'pack_id')
com_info = PackCOMFileDO.fetch_pack(pack_id)
# 读取指定固件包的信息
files_stat = get_sourcecode_files_stat(pack_id)
pack_info = dict(com_info, **files_stat)
# 保存操作日志
LogRecords.save('',
category='statistics',
action='查询组件源码包信息',
desc='查询组件源码包的信息，统计其文件数量，查询任务信息')
return sys_app_ok_p(pack_info)
def async_com_download(request):
com_download_url = ReqParams.one(request, 'url', protocol='POST')
# 启动下载任务
extra_info = {'task_type': TaskType.REMOTE_DOWNLOAD,
'task_name': '组件源码下载',
'task_desc': '下载组件源码入库存储桶'}
task = MyTask(_proc_component_tasks, (com_download_url, MyPath.component()), extra_info=extra_info)
task_id = task.get_task_id()
# 保存操作日志
LogRecords.save({'task_id': task_id}, category='download', action='组件源码下载',
desc='下载组件源码入库存储桶')
# 返回响应：任务初始化的信息
return sys_app_ok_p(MyTask.fetch_exec_info(task_id))
def save_exec_info(task_id, percent, result=None, notify=True):
# 从缓存或数据库中读取该任务的记录
task_info = MyTask.fetch_exec_info(task_id)
# 没有该任务信息记录时，返回失败
if task_info is None:
return False
# 设置百分比和运行状态
task_info['percentage'] = percent
# 结果集不为空时，用新的结果集替换
if result is not None:
task_info['result'] = result
# 计算并记录执行时间（预计剩余时间）
task_info['remain_time'] = MyTask._calc_exec_time(task_info)
# 设置当前记录时间
task_info['record_time'] = SysUtils.get_now_time_str()
# 保存处理进程的历史记录
MyTask._save_progress_history(task_info)
# 调用 websocket task_feedback
task_feedback(task_id, task_info)
# 运行100%时，设置任务完成状态，并更新数据库，清理缓存
if percent == 100.0:
task_info['task_status'] = TaskStatus.COMPLETE
TasksDAO.save(task_info)
MyRedis.delete(task_id, category=task_cat)
# 保存任务详情日志
LogRecords.save(task_info,
category='task',
action='任务完成',
desc='任务执行100%，记录任务执行结果信息')
else:
# 缓存该任务的记录
MyRedis.set(task_id, task_info, category=task_cat)
# 发送执行状态的更新消息
if notify:
MyTask.notify_task_exec_info(task_info)
return True
def recover_config(request):
# 从请求中取参数：新的系统配置
new_config_key = req_get_param(request, 'config_key')
# 数据库中写入系统配置参数
SystemConfig.recover_db(new_config_key)
# 重新加载新的配置参数到缓存
config = SystemConfig.cache_load()
# 保存操作日志
LogRecords.save(config,
category='system_config',
action='备份系统配置',
desc='备份系统各项配置参数')
return sys_app_ok_p(config)
def async_fwdownload(request):
# 获取下载URL
fw_download_url, ftp_user, ftp_password = ReqParams.many(request, ['url', 'user', 'password'], protocol='POST')
# 启动下载任务
extra_info = {'task_type': TaskType.REMOTE_DOWNLOAD,
'task_name': '固件下载',
'task_desc': '下载固件入库存储桶并进行文件抽取操作'}
task = MyTask(_proc_tasks, (fw_download_url, settings.FW_PATH, ftp_user, ftp_password), extra_info=extra_info)
task_id = task.get_task_id()
# 保存操作日志
LogRecords.save({'task_id': task_id}, category='download', action='固件下载',
desc='下载固件入库存储桶并进行文件抽取操作')
# 返回响应：任务初始化的信息
return sys_app_ok_p(MyTask.fetch_exec_info(task_id))
def list_name(request):
component_name = ReqParams.one(request, 'name')
com_info = PackCOMFileDO.fetch_name(component_name)
""" 获取源码包所有的文件统计信息 """
# info_list = []
# for pack in com_list:
# # 各个包的所含文件信息
# files_stat = get_sourcecode_files_stat(pack['pack_id'])
# pack_info = dict(pack, **files_stat)
# info_list.append(pack_info)
# 保存操作日志
LogRecords.save('',
category='statistics',
action='组件源码查询_按名称查询',
desc='组件源码查询_按名称查询')
return sys_app_ok_p(com_info)
def analyze_cfg(request):
# 从请求中取参数：文件 ID
file_id = req_post_param(request, 'file_id')
# 启动分析任务
task_id = CfgAnalyzeService.start_cfg_task(file_id)
# 保存操作日志
LogRecords.save({
'task_id': task_id,
'file_id': file_id
},
category='analysis',
action='分析CFG',
desc='对二进制文件做调用流程图分析')
# 返回响应：任务初始化的信息
return sys_app_ok_p(MyTask.fetch_exec_info(task_id))
def taintadd(request):
# 从请求中取参数：文件 ID
func_name, hazard, solution = ReqParams.many(request, ['func_name', 'hazard', 'solution'], protocol='POST')
# find func_name in taint_dict
if TaintdictDO.search_func_name(func_name) is None:
print("add func_name")
# 新的 fun ID
fun_id = StrUtils.uuid_str()
TaintdictDO.save(fun_id, func_name, hazard, solution)
# 保存操作日志
LogRecords.save('', category='statistics', action='自定义污点函数－增加',
desc='污点函数（ID=%s）的信息，' % fun_id)
return sys_app_ok_p('添加成功')
else:
print("already has func_name")
return sys_app_ok_p(['函数已存在'])
def list(request):
# 所有包的基本信息
com_list = PackCOMFileDO.all_packs()
""" 获取源码包所有的文件统计信息 """
info_list = []
for pack in com_list:
# 各个包的所含文件信息
files_stat = get_sourcecode_files_stat(pack['pack_id'])
pack_info = dict(pack, **files_stat)
info_list.append(pack_info)
# 保存操作日志
LogRecords.save('',
category='statistics',
action='查询所有组件源码包信息',
desc='查询所有组件源码包的信息，统计其文件数量，查询任务信息')
return sys_app_ok_p(info_list)
def write_sys_config(request):
# 从请求中取参数：新的系统配置
new_config_str = req_post_param(request, 'sys_config')
new_config = eval(new_config_str)
# 数据库中写入系统配置参数
SystemConfig.write_db(new_config)
# 重新加载新的配置参数到缓存
config = SystemConfig.cache_load()
# 保存操作日志
LogRecords.save(config,
category='system_config',
action='更新系统配置',
desc='更新系统各项配置参数')
return sys_app_ok_p(config)