def __agents_state_monitor(self):
while self.__running:
if len(self.agent_state_dict) > 0:
for agent_state in list(self.agent_state_dict.values()):
new_state = self.__check_state(agent_state)
if new_state == "Dead":
logger.info(
"Agent {0} is dead.\nAgent {1} is removed.".format(
agent_state.agent_identifier,
agent_state.agent_identifier))
agent_state.state = new_state
CommonMsg.msg_agent_state_update.data = agent_state.gen_json_object(
)
MessageBus.send_msg(CommonMsg.msg_agent_state_update)
self.agent_state_dict.pop(agent_state.agent_identifier)
else:
agent_state.state = new_state
self.agent_state_dict[
agent_state.agent_identifier] = agent_state
CommonMsg.msg_agent_state_update.data = agent_state.gen_json_object(
)
MessageBus.send_msg(CommonMsg.msg_agent_state_update)
time.sleep(1)
time.sleep(CCServerConfig.STATE_UPDATE_INTERVAL)
def __init__(self):
self.agent_state_dict = dict()
self.__running = threading.Event()
self.__state_monitor_thread = threading.Thread(
target=self.__agents_state_monitor)
MessageBus.add_msg_listener(CommonMsg.MSG_HEARTBEAT,
self.add_new_agent_state)
def start_scan(task_name):
_, scan_setting, _ = ScanTaskManager().load_task_info(task_name)
if scan_setting[1] is "":
return redirect(url_for("task.index"))
ScanTaskManager().save_task(task_name)
start_scan_cmd = {
"Type": "WVSCommand",
"Data": {
"Action": "StartNewScan",
"Config": { # 可选，当命令为StartNewScan时需提供该字段作为扫描参数
"StartURL": scan_setting[1],
"ScanPolicy": scan_setting[2]
}
}
}
WvssState().set_current_scan_config(ScanSetting().get_scan_setting())
CommonMsg.msg_server_command.data = start_scan_cmd
MessageBus.send_msg(CommonMsg.msg_server_command)
GlobalVar.ScanState = "Started"
log.info("Start scan....")
return redirect(url_for("monitor.index"))
def index():
scan_control_form = ScanControlForm()
if scan_control_form.is_submitted():
task_name, start_url, scan_policy = ScanSetting().get_scan_setting()
if task_name is "" or start_url is "":
return redirect(url_for("monitor.index"))
if request.form.get("submit_start_scan") == u"开始扫描":
start_scan_cmd = {
"Type": "WVSCommand",
"Data": {
"Action": "StartNewScan",
"Config": { # 可选，当命令为StartNewScan时需提供该字段作为扫描参数
"StartURL": start_url,
"ScanPolicy": scan_policy
}
}
}
CommonMsg.msg_server_command.data = start_scan_cmd
MessageBus.send_msg(CommonMsg.msg_server_command)
WvssState().set_current_scan_config(
ScanSetting().get_scan_setting())
GlobalVar.ScanState = "Started"
logger.info("Start scan....")
return redirect(url_for("monitor.index"))
elif request.form.get("submit_stop_scan") == u"停止扫描":
stop_scan_cmd = {
"Type": "WVSCommand",
"Data": {
"Action": "StopScan",
}
}
CommonMsg.msg_server_command.data = stop_scan_cmd
MessageBus.send_msg(CommonMsg.msg_server_command)
WvssState().set_current_scan_config(None)
GlobalVar.ScanState = "Stopped"
logger.info("Stopped scan")
return redirect(url_for("monitor.index"))
else:
pass
return render_template("monitor.html",
title="监控中心",
server_config=CCServerConfig(),
scan_config=WvssState().get_current_scan_config(),
agent_state_list=AgentsState().get_agent_list(),
wvs_state_list=WvssState().get_wvs_state_list(),
scan_state=GlobalVar.ScanState,
scan_control_form=scan_control_form)
def run(self):
if self.__is_running:
pass
else:
self.__is_running = True
logger.info("CCServer is running <{}>...".format(
CCServerConfig.Address))
MessageBus.start()
self.server.start()
self.agent_state_manager.start_monitor()
def stop_scan(task_name):
stop_scan_cmd = {
"Type": "WVSCommand",
"Data": {
"Action": "StopScan",
}
}
_, scan_setting, _ = ScanTaskManager().load_task_info(task_name)
CommonMsg.msg_server_command.data = stop_scan_cmd
MessageBus.send_msg(CommonMsg.msg_server_command)
WvssState().set_current_scan_config(None)
GlobalVar.ScanState = "Stopped"
log.info("Stopped scan")
return redirect(url_for("task.index"))
def index():
new_task_form = NewScanTaskForm()
task_info_list, _ = ScanTaskManager().load_all_task_info()
task_name = WvssState().get_current_scan_config()[0]
if new_task_form.is_submitted():
if not new_task_form.Name.validate(new_task_form):
log.info("任务名称错误")
elif not new_task_form.StartURL.validate(new_task_form):
log.info("URL名称错误")
else:
task_name = new_task_form.Name.data
start_url = new_task_form.StartURL.data
scan_policy = new_task_form.ScanPolicy.data
log.info("{}>>{}>>{}".format(task_name, start_url, scan_policy))
ScanTaskManager().new_task(task_name, start_url, scan_policy)
task_info_list, _ = ScanTaskManager().load_all_task_info()
if request.form.get("submit_new_and_start") == u"新建任务并运行":
setting = ScanSetting()
WvssState().set_current_scan_config(
ScanSetting().get_scan_setting())
start_scan_cmd = {
"Type": "WVSCommand",
"Data": {
"Action": "StartNewScan",
"Config": {
"StartURL": setting.start_url,
"ScanPolicy": setting.scan_policy
}
}
}
CommonMsg.msg_server_command.data = start_scan_cmd
MessageBus.send_msg(CommonMsg.msg_server_command)
GlobalVar.ScanState = "Started"
log.info("Start scan....")
return redirect(url_for("monitor.index"))
return redirect(url_for('task.index'))
return render_template('task.html',
title="扫描任务管理",
NewTaskForm=new_task_form,
task_info_list=task_info_list,
scan_state=GlobalVar.ScanState,
run_task_name=task_name)
def __init__(self, ip=None, port=6000):
"""类的初始化
Args:
ip (str, optional): 服务器IP. Defaults to None.
port (int, optional): 服务器端口. Defaults to 6000.
"""
self.server_ip = ip
self.port = port
self.agent_list = []
self.agent_state_monitor = AgentStateMonitor()
MessageBus.add_msg_listener(CommonMsg.MSG_SERVER_COMMAND,
self.send_command)
super(CCServer, self).__init__(ip=self.server_ip,
port=self.port,
handler=self.receive_data_handler)
def receive_data_handler(self, data, address):
"""接收数据处理函数
Args:
data ([type]): 接收的数据
address ([type]): 接收数据的IP地址
"""
if address not in self.agent_list:
self.agent_list.append(address)
pkg_obj = dict(json.loads(str(data, encoding='utf-8')))
try:
if pkg_obj["Type"] == "Heartbeat": #心跳包
CommonMsg.msg_heartbeat.data = pkg_obj["Data"]
MessageBus.send_msg(CommonMsg.msg_heartbeat)
# logger.info(CommonMsg.msg_heartbeat.data)
elif pkg_obj["Type"] == "WVSState":
CommonMsg.msg_wvs_state.data = pkg_obj["Data"]
MessageBus.send_msg(CommonMsg.msg_wvs_state)
logger.info(CommonMsg.msg_wvs_state.data)
# print("收到代理{}的漏扫状态数据".format(address))
elif pkg_obj["Type"] == "ScanResult":
CommonMsg.msg_scan_result_receive.data = pkg_obj["Data"]
MessageBus.send_msg(CommonMsg.msg_scan_result_receive)
self.__print_scan_result(pkg_obj["Data"])
else:
print("收到来自{}的未知类型数据".format(address))
except KeyError as e:
print("收到来自{}的未知类型数据——{}".format(address, data))
def create_app(config_name):
"""创建web程序
Args:
config_name (对象)): 配置名称
Returns:
[type]: [description]
"""
app = Flask(__name__)
app.config.from_object(web_server_config[config_name])
web_server_config[config_name].init_app(app)
# socketio赋给全局变量GlobalVar.SocketIO
async_mode = None
GlobalVar.SocketIO = SocketIO(app, async_mode=async_mode)
# 附加路由及默认错误处理页面
# 主页面
from .main import main as main_bp
app.register_blueprint(main_bp)
# 扫描任务管理蓝图
from .task import task as task_bp
app.register_blueprint(task_bp, url_prefix='/task')
# 扫描监控蓝图
from .monitor import monitor as monitor_bp
app.register_blueprint(monitor_bp, url_prefix='/monitor')
# 扫描结果处理蓝图
from .result import result as result_bp
app.register_blueprint(result_bp, url_prefix='/result')
# 运行CC服务器
CliApp().run()
from app.lib import MessageBus, CommonMsg
import app.result.views as result_view
MessageBus.add_msg_listener(CommonMsg.MSG_SCAN_RESULT_RECEIVE,
result_view.scan_result_handler)
import app.monitor.views as monitor_view
MessageBus.add_msg_listener(CommonMsg.MSG_WVS_STATE,
monitor_view.ws_wvs_state_send)
MessageBus.add_msg_listener(CommonMsg.MSG_AGENT_STATE_UPDATE,
monitor_view.ws_agent_state_send)
return app
def stop(self):
self.__is_running = False
self.server.stop()
self.agent_state_manager.stop_monitor()
MessageBus.stop()
CCServerConfig.save_config()
def __check_state(self, agent_state):
"""
根据前后两次时标对比判断代理状态，时标间隔大于2倍更新时间小于3倍更新时间时为离线，更长时间为Dead
:param agent_state: 代理状态对象
:return: 代理状态：Offline、Dead、Online
"""
last_time = time.time() - agent_state.timestamp
if CCServerConfig.STATE_UPDATE_INTERVAL * 2.0 < last_time <= CCServerConfig.STATE_UPDATE_INTERVAL * 5.0:
return "Offline"
elif last_time > CCServerConfig.STATE_UPDATE_INTERVAL * 5.0:
return "Dead"
else:
return "Online"
if __name__ == '__main__':
monitor = AgentStateMonitor()
print(id(monitor))
monitor.start_monitor()
CommonMsg.msg_heartbeat.data = {
"Name": "tste",
"Address": ("127.0.0.1", 5555),
"Timestamp": time.time(),
"State": "Online"
}
MessageBus().send_msg(CommonMsg.msg_heartbeat)
time.sleep(20)