def create_whitelist_obj(**kwargs):
"""
:param kwargs:
:return:
"""
issue_obj = kwargs.get('issue_obj', None)
operator = kwargs.get('operator', None)
app_obj = kwargs.get('app_obj', None)
comment = kwargs.get('comment', None)
is_active = kwargs.get('is_active', True)
if not all((issue_obj, operator, app_obj)):
raise ParameterIsEmptyException(
u'"issue_obj, operator, app_obj" parameters cannot be empty !')
if comment:
comment = comment[:500]
close_old_connections()
whitelist = IssueWhiteListInfo(
issue=issue_obj,
operator=operator,
app=app_obj,
comment=comment,
is_active=is_active,
)
whitelist.save()
return whitelist
def _get_periodic_obj(**kwargs):
"""
:param kwargs:
:return:
"""
result = None
periodic_id = kwargs.get('periodic_id', None)
task = kwargs.get('task', None)
name = kwargs.get('name', None)
close_old_connections()
try:
sql_where = {}
if periodic_id:
sql_where['id'] = int(periodic_id)
if task:
sql_where['task'] = task.strip()
if name:
sql_where['name'] = name.strip()
if not sql_where:
raise QueryConditionIsEmptyException(
u'Missing "periodic_id, task, name" key parameters!')
item = PeriodicTask.objects.get(**sql_where)
result = item
except PeriodicTask.DoesNotExist as ex:
logger.warning(ex)
return result
def _get_pro_member_perm(**kwargs):
"""
:param kwargs:
:return:
"""
result = None
member_id = kwargs.get('member_id', None)
project_id = kwargs.get('project_id', None)
close_old_connections()
try:
sql_where = {}
if member_id:
sql_where['member__id'] = int(member_id)
if project_id:
sql_where['project__id'] = int(project_id)
if not sql_where:
raise QueryConditionIsEmptyException(
u'Missing "member_id, project_id" key parameters!')
result = ProjectPermissionInfo.objects.filter(**sql_where).first()
except ProjectPermissionInfo.DoesNotExist as ex:
logger.warning(ex)
return result
def create_tag_obj(**kwargs):
"""
:param kwargs:
:return:
"""
name = kwargs.get('name', None)
description = kwargs.get('description', None)
parent = kwargs.get('parent', None)
if not all((name, )):
raise ParameterIsEmptyException(u'"name" parameters cannot be empty !')
if name and len(name) > 64:
name = name[:64]
close_old_connections()
tag = TagInfo(
name=name,
description=description,
parent=parent,
)
tag.save()
return tag
def _get_statistics_obj(**kwargs):
"""
:param kwargs:
:return:
"""
result = None
stat_id = kwargs.get('stat_id', None)
language = kwargs.get('language', None)
app_id = kwargs.get('app_id', None)
close_old_connections()
try:
sql_where = {}
if stat_id:
sql_where['id'] = int(stat_id)
if language:
sql_where['language__iexact'] = language.strip()
if app_id:
sql_where['app__id'] = int(app_id)
if not sql_where:
raise QueryConditionIsEmptyException(
u'Missing "stat_id, language, app_id" key parameters!')
item = FileStatisticsInfo.objects.get(**sql_where)
result = item
except FileStatisticsInfo.DoesNotExist as ex:
logger.warning(ex)
return result
def _get_node_obj(**kwargs):
"""
:param kwargs:
:return:
"""
result = None
node_id = kwargs.get('node_id', None)
hostname = kwargs.get('hostname', None)
ipv4 = kwargs.get('ipv4', None)
close_old_connections()
try:
sql_where = {}
if node_id:
sql_where['id'] = int(node_id)
if hostname:
sql_where['hostname'] = hostname
if ipv4:
sql_where['ipv4'] = ipv4
if not sql_where:
raise QueryConditionIsEmptyException(
u'Missing "node_id, hostname" key parameters!')
item = HostInfo.objects.get(**sql_where)
result = item
except HostInfo.DoesNotExist as ex:
logger.warning(ex)
return result
def create_pro_history_obj(**kwargs):
"""
:param kwargs:
:return:
"""
project_obj = kwargs.get('project_obj', None)
htype = kwargs.get('type', 1)
user = kwargs.get('user', None)
title = kwargs.get('title', None)
is_first = kwargs.get('is_first', False)
description = kwargs.get('description', None)
if not description:
raise ParameterIsEmptyException(
u'Project description cannot be empty!')
if len(title) > 128:
title = title[:128]
close_old_connections()
his = ProjectHistoryInfo(project=project_obj,
type=htype,
user=user,
title=title,
is_first=is_first,
description=description)
his.save()
return his
def get_permissions_by_all_module():
"""
获取所有模块
:return:
"""
#if cache.get(SYSTEM_CACHE[3]):
# return cache.get(CACHE_KEY)
result = {
"sys": [],
"project": [],
"engine": [],
"task": [],
"node": [],
"report": [],
}
""""
"""
close_old_connections()
result['sys'] = ContentType.objects.filter(
id__in=[12, 13, 14, 15, 16, 21, 22, 23, 24, 25, 26])
result['project'] = ContentType.objects.filter(id__in=[4, 5, 6, 7, 8])
result['engine'] = ContentType.objects.filter(id__in=[17, 18, 19, 20])
result['task'] = ContentType.objects.filter(id__in=[9, 10, 11, 1])
result['node'] = ContentType.objects.filter(id__in=[2, 3])
# result['report'] = ContentType.objects.filter(id__in=[18, 19, 20, 21])
set_cache(result)
return result
def _get_group_member_perm(**kwargs):
"""
:param kwargs:
:return:
"""
result = None
member_id = kwargs.get('member_id', None)
group_id = kwargs.get('group_id', None)
close_old_connections()
try:
sql_where = {}
if member_id:
sql_where['member__id'] = int(member_id)
if group_id:
sql_where['group__id'] = int(group_id)
if not sql_where:
raise QueryConditionIsEmptyException(u'Missing "member_id, group_id" key parameters!')
result = GroupPermissionInfo.objects.get(**sql_where)
except GroupPermissionInfo.DoesNotExist as ex:
logger.warning(ex)
return result
def create_service_obj(**kwargs):
"""
:param kwargs:
:return:
"""
name = kwargs.get('name', None)
key = kwargs.get('key', None)
role = kwargs.get('role', None)
process_keyword = kwargs.get('process_keyword', None)
description = kwargs.get('description', None)
if not all((
name,
key,
process_keyword,
)):
raise ParameterIsEmptyException(
u'"name, key, process_keyword" parameters cannot be empty !')
close_old_connections()
service = ServiceInfo(
name=name,
key=key,
process_keyword=process_keyword,
description=description,
role=role,
)
service.save()
return service
def create_host_obj(**kwargs):
"""
:param kwargs:
:return:
"""
hostname = kwargs.get('hostname', None)
ipv4 = kwargs.get('ipv4', None)
ipv6 = kwargs.get('ipv6', None)
role = kwargs.get('role', 'client')
ui_version = kwargs.get('ui_version', None)
client_version = kwargs.get('client_version', None)
if not all((
hostname,
role,
)):
raise ParameterIsEmptyException(
u'"hostname, role" parameters cannot be empty !')
close_old_connections()
host = HostInfo(
hostname=hostname,
ipv4=ipv4,
)
if role and role.lower() == 'ui':
host.is_role_ui = True
else:
host.is_role_client = True
if ui_version:
host.ui_version = ui_version.strip()
if client_version:
host.client_version = client_version.strip()
host.save()
return host
def create_node_service_obj(**kwargs):
"""
:param kwargs:
:return:
"""
node_obj = kwargs.get('node_obj', None)
service_obj = kwargs.get('service_obj', None)
ppid = kwargs.get('ppid', None)
pid = kwargs.get('pid', None)
status = kwargs.get('status', None)
if not all((node_obj, service_obj, ppid, pid)):
raise ParameterIsEmptyException(u'"node_obj, service_obj, ppid, pid" parameters cannot be empty !')
close_old_connections()
node = HostServiceInfo(
node=node_obj,
service=service_obj,
ppid=ppid,
pid=pid,
status=status,
)
node.save()
return node
def create_flow_obj(**kwargs):
"""
:param kwargs:
:return:
"""
issue_obj = kwargs.get('issue_obj', None)
user = kwargs.get('user', None)
comment = kwargs.get('comment', None)
if not all((issue_obj, comment)):
raise ParameterIsEmptyException(u'"issue_obj, comment" parameters cannot be empty !')
close_old_connections()
issue = IssueFlowInfo(
issue=issue_obj,
user=user,
behavior=behavior_type.HUMAN if user else behavior_type.SYS,
status=issue_obj.status,
comment=comment,
)
issue.save()
return issue
def _get_whitelist_obj(**kwargs):
"""
:param kwargs:
:return:
"""
result = None
white_id = kwargs.get('white_id', None)
issue_id = kwargs.get('issue_id', None)
close_old_connections()
try:
sql_where = {}
if white_id:
sql_where['id'] = int(white_id)
if issue_id:
sql_where['issue__id'] = int(issue_id)
if not sql_where:
raise QueryConditionIsEmptyException(
u'Missing "white_id, issue_id" key parameters!')
item = IssueWhiteListInfo.objects.get(**sql_where)
result = item
except IssueWhiteListInfo.DoesNotExist as ex:
logger.warning(ex)
return result
def create_lang_obj(**kwargs):
"""
:param kwargs:
:return:
"""
name = kwargs.get('name', None)
key = kwargs.get('key', None)
if not name:
raise ParameterIsEmptyException(u'Language name cannot be empty!')
if name and len(name) > 16:
name = name[:16]
if not key:
key = name.lower()
else:
key = key.lower()
close_old_connections()
lang = LanguageInfo(
name=name,
key=key,
)
lang.save()
cache.set(CONFIG_LANG_CACHE[2], None, 0)
return lang
def _get_group_obj(**kwargs):
"""
:param kwargs:
:return:
"""
git_id = kwargs.get('git_id', None)
group_id = kwargs.get('group_id', None)
name = kwargs.get('name', None)
close_old_connections()
try:
sql_where = {}
if git_id:
sql_where['git_id'] = int(git_id)
if group_id:
sql_where['id'] = int(group_id)
if name:
sql_where['name'] = name.strip()
if not sql_where:
raise QueryConditionIsEmptyException(u'Missing "group_id, git_id, name" key parameters!')
item = GroupInfo.objects.filter(**sql_where).first()
return item
except GroupInfo.DoesNotExist as ex:
logger.warning(ex)
return None
def _get_lang_obj(**kwargs):
"""
:param kwargs:
:return:
"""
result = None
lang_id = kwargs.get('lang_id', None)
name = kwargs.get('name', None)
key = kwargs.get('key', None)
close_old_connections()
try:
sql_where = {}
if name:
sql_where['name__iexact'] = name.strip()
if key:
sql_where['key'] = key.lower()
if lang_id:
sql_where['id'] = int(lang_id)
if not sql_where:
raise QueryConditionIsEmptyException(u'Missing "lang_id, name, key" key parameters!')
item = LanguageInfo.objects.get(**sql_where)
result = item
except LanguageInfo.DoesNotExist as ex:
logger.warning(ex)
return result
def _get_sched_obj(**kwargs):
"""
:param kwargs:
:return:
"""
result = None
sched_id = kwargs.get('sched_id', None)
close_old_connections()
try:
sql_where = {}
if sched_id:
sql_where['id'] = int(sched_id)
if not sql_where:
raise QueryConditionIsEmptyException(
u'Missing "sched_id" key parameters!')
item = SchedInfo.objects.get(**sql_where)
result = item
except SchedInfo.DoesNotExist as ex:
logger.warning(ex)
return result
def _get_vuln_obj(**kwargs):
"""
:param kwargs:
:return:
"""
result = None
vuln_id = kwargs.get('vuln_id', None)
title = kwargs.get('title', None)
cve = kwargs.get('cve', None)
close_old_connections()
try:
sql_where = {}
if vuln_id:
sql_where['id'] = int(vuln_id)
if title:
sql_where['title'] = title.strip()
if cve:
sql_where['cve'] = cve.strip()
if not sql_where:
raise QueryConditionIsEmptyException(
u'Missing "vuln_id, title" key parameters!')
item = VulnInfo.objects.get(**sql_where)
result = item
except VulnInfo.DoesNotExist as ex:
logger.warning(ex)
return result
def _get_crontab(**kwargs):
"""
:param kwargs:
:return:
"""
result = None
cron_expression = kwargs.get('cron_expression', None)
cron_id = kwargs.get('cron_id', None)
close_old_connections()
try:
if cron_expression:
cron_expression = cron_expression.strip()
minute, hour, day_of_week, day_of_month, month_of_year = cron_expression.split(
' ')
result = CrontabSchedule.objects.get(minute=minute,
hour=hour,
day_of_week=day_of_week,
day_of_month=day_of_month,
month_of_year=month_of_year)
if cron_id:
result = CrontabSchedule.objects.get(id=int(cron_id))
except CrontabSchedule.DoesNotExist as ex:
logger.warning(ex)
return result
def _get_app_obj(**kwargs):
"""
:param kwargs:
:return:
"""
result = None
app_id = kwargs.get('app_id', None)
module_name = kwargs.get('module_name', None)
app_name = kwargs.get('app_name', None)
project_id = kwargs.get('project_id', None)
close_old_connections()
try:
sql_where = {}
if app_id:
sql_where['id'] = int(app_id)
if project_id:
sql_where['project__id'] = int(project_id)
if module_name:
sql_where['module_name__iexact'] = module_name.lower().strip()
if app_name:
sql_where['app_name__iexact'] = app_name.strip()
if not sql_where:
raise QueryConditionIsEmptyException(
u'Missing "app_id, module_name, app_name" key parameters!')
item = ApplicationInfo.objects.filter(**sql_where).first()
result = item
except ApplicationInfo.DoesNotExist as ex:
logger.warning(ex)
return result
def _get_task_obj(**kwargs):
"""
:param kwargs:
:return:
"""
task_id = kwargs.get('task_id', None)
app_id = kwargs.get('app_id', None)
status = kwargs.get('status', None)
close_old_connections()
try:
sql_where = {}
if task_id:
sql_where['id'] = int(task_id)
if app_id:
sql_where["app__id"] = int(app_id)
if status:
sql_where["status__in"] = status
if not sql_where:
raise QueryConditionIsEmptyException(u'Missing "task_id" key parameters!')
item = TaskInfo.objects.filter(**sql_where).first()
return item
except TaskInfo.DoesNotExist as ex:
logger.warn(ex)
return None
def _get_tag_obj(**kwargs):
"""
:param kwargs:
:return:
"""
result = None
tag_id = kwargs.get('tag_id', None)
parent_id = kwargs.get('parent_id', None)
name = kwargs.get('name', None)
close_old_connections()
try:
sql_where = {}
if tag_id:
sql_where['id'] = int(tag_id)
if parent_id:
sql_where['parent__id'] = int(parent_id)
if name:
sql_where['name'] = name
if not sql_where:
raise QueryConditionIsEmptyException(
u'Missing "parent_id, name" key parameters!')
item = TagInfo.objects.get(**sql_where)
result = item
except TagInfo.DoesNotExist as ex:
logger.warning(ex)
return result
def create_t_group_obj(**kwargs):
"""
:param kwargs:
:return:
"""
profile_obj = kwargs.get('profile_obj', None)
periodic_obj = kwargs.get('periodic_obj', None)
sched_obj = kwargs.get('sched_obj', None)
is_default = kwargs.get('is_default', False)
name = kwargs.get('name', '')
branch = kwargs.get('branch', '')
args = kwargs.get('args', '')
if not all((name, )):
raise ParameterIsEmptyException(u'"name" parameters cannot be empty !')
if name and len(name) > 255:
name = name[:255]
close_old_connections()
grp = TaskGroupInfo(profile=profile_obj,
periodic=periodic_obj,
sched=sched_obj,
name=name.strip(),
branch=branch,
is_default=is_default,
args=args.strip())
grp.save()
return grp
def _get_tactic_obj(**kwargs):
"""
:param kwargs:
:return:
"""
result = None
tactic_id = kwargs.get('tactic_id', None)
name = kwargs.get('name', None)
key = kwargs.get('key', None)
attribution_type = kwargs.get('attribution_type', None)
close_old_connections()
try:
sql_where = {}
if tactic_id:
sql_where['id'] = int(tactic_id)
if name:
sql_where['name'] = name
if key:
sql_where['key'] = key
if attribution_type:
sql_where['attribution_type'] = int(attribution_type)
if not sql_where:
raise QueryConditionIsEmptyException(
u'Missing "tactic_id, name, key" key parameters!')
result = TacticInfo.objects.filter(**sql_where).first()
except TacticInfo.DoesNotExist as ex:
logger.warning(ex)
return result
def update_t_group_obj(**kwargs):
"""
:param kwargs:
:return:
"""
group_id = kwargs.get('group_id', None)
name = kwargs.get('name', None)
profile_obj = kwargs.get('profile_obj', None)
is_default = kwargs.get('is_default', False)
close_old_connections()
grp = TaskGroupInfo.objects.filter(id=group_id).first()
if grp:
if name:
grp.name = name.strip()
if profile_obj:
grp.profile = profile_obj
if is_default:
TaskGroupInfo.objects.filter().update(is_default=False)
grp.is_default = True
cache.set(SCAN_CACHE[5], None, 0)
grp.save()
cache.set('{0}:{1}'.format(SCAN_CACHE[1], group_id), None, 0)
return grp
def _get_project_obj(**kwargs):
"""
:param kwargs:
:return:
"""
result = None
git_id = kwargs.get('git_id', None)
project_id = kwargs.get('project_id', None)
name = kwargs.get('name', None)
ssh_url = kwargs.get('ssh_url', None)
close_old_connections()
try:
sql_where = {}
if git_id:
sql_where['git_id'] = int(git_id)
if project_id:
sql_where['id'] = int(project_id)
if name:
sql_where['name'] = name.strip()
if ssh_url:
sql_where['ssh_url_to_repo__iexact'] = ssh_url.strip()
if not sql_where:
raise QueryConditionIsEmptyException(
u'Missing "project_id, git_id, name" key parameters!')
item = ProjectInfo.objects.get(**sql_where)
result = item
except ProjectInfo.DoesNotExist as ex:
logger.warning(ex)
return result
def get_issue_by_info(tactic_id, app_id, file_name, start_line):
"""
:param tactic_id:
:param app_id:
:param file_name:
:param start_line:
:return:
"""
result = None
close_old_connections()
try:
sql_where = {}
if tactic_id:
sql_where['tactic__id'] = int(tactic_id)
if app_id:
sql_where['app__id'] = int(app_id)
if file_name:
sql_where['file_name'] = file_name.strip()
if start_line:
sql_where['start_line'] = int(start_line)
if not sql_where:
raise QueryConditionIsEmptyException(
u'Missing "tactic_id, app_id, file_name, start_line" key parameters!'
)
result = IssueInfo.objects.filter(**sql_where).first()
except IssueInfo.DoesNotExist as ex:
import traceback
traceback.print_exc() # FIXME log
return result
def _get_engine_obj(**kwargs):
"""
:param kwargs:
:return:
"""
result = None
engine_id = kwargs.get('engine_id', None)
module_name = kwargs.get('module_name', None)
close_old_connections()
try:
sql_where = {}
if engine_id:
sql_where['id'] = int(engine_id)
if module_name:
sql_where['module_name'] = module_name
if not sql_where:
raise QueryConditionIsEmptyException(
u'Missing "engine_id" key parameters!')
item = EngineInfo.objects.get(**sql_where)
result = item
except EngineInfo.DoesNotExist as ex:
logger.warning(ex)
return result
def _get_member_obj(**kwargs):
"""
:param kwargs:
:return:
"""
result = None
git_id = kwargs.get('git_id', None)
member_id = kwargs.get('member_id', None)
username = kwargs.get('username', None)
close_old_connections()
try:
sql_where = {}
if git_id:
sql_where['git_id'] = int(git_id)
if member_id:
sql_where['id'] = int(member_id)
if username:
sql_where['username'] = username.strip()
if not sql_where:
raise QueryConditionIsEmptyException(u'Missing "member_id, git_id, username" key parameters!')
item = MemberInfo.objects.filter(**sql_where).first()
result = item
except MemberInfo.DoesNotExist as ex:
logger.warning(ex)
return result
