Alex Yang
1109 lines
37 KiB
JavaScript
1109 lines
37 KiB
JavaScript
// threats.js - 威胁告警页面功能实现
|
|
|
|
// ==================== 工具函数 ====================
|
|
|
|
// 带超时的 fetch
|
|
async function fetchWithTimeout(url, options = {}, timeout = 10000) {
|
|
const controller = new AbortController();
|
|
const id = setTimeout(() => controller.abort(), timeout);
|
|
|
|
try {
|
|
const response = await fetch(url, {
|
|
...options,
|
|
signal: controller.signal
|
|
});
|
|
clearTimeout(id);
|
|
return response;
|
|
} catch (error) {
|
|
clearTimeout(id);
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
// 带重试的 fetch
|
|
async function fetchWithRetry(url, options = {}, maxRetries = 3) {
|
|
let lastError;
|
|
|
|
for (let i = 0; i < maxRetries; i++) {
|
|
try {
|
|
const response = await fetchWithTimeout(url, options, 10000);
|
|
if (!response.ok) {
|
|
throw new Error(`HTTP error! status: ${response.status}`);
|
|
}
|
|
return await response.json();
|
|
} catch (error) {
|
|
lastError = error;
|
|
console.warn(`请求失败 (${i + 1}/${maxRetries}):`, url, error.message);
|
|
|
|
// 等待后重试（指数退避）
|
|
if (i < maxRetries - 1) {
|
|
const delay = Math.pow(2, i) * 1000; // 1s, 2s, 4s
|
|
await new Promise(resolve => setTimeout(resolve, delay));
|
|
}
|
|
}
|
|
}
|
|
|
|
throw lastError;
|
|
}
|
|
|
|
// 并发控制执行
|
|
async function runWithConcurrency(tasks, concurrencyLimit = 5) {
|
|
const results = [];
|
|
const executing = [];
|
|
|
|
for (const task of tasks) {
|
|
const p = task().then(result => {
|
|
executing.splice(executing.indexOf(p), 1);
|
|
return result;
|
|
});
|
|
results.push(p);
|
|
executing.push(p);
|
|
|
|
if (executing.length >= concurrencyLimit) {
|
|
await Promise.race(executing);
|
|
}
|
|
}
|
|
|
|
return Promise.all(results);
|
|
}
|
|
|
|
// ==================== 缓存管理 ====================
|
|
|
|
// 威胁查询缓存（批量查询结果缓存）
|
|
const threatCache = {
|
|
cache: new Map(),
|
|
ttl: 10 * 60 * 1000, // 10 分钟
|
|
lastQueryTime: 0,
|
|
queryInterval: 30 * 1000, // 30 秒内不重复查询
|
|
|
|
// 检查是否可以查询（避免频繁查询）
|
|
canQuery() {
|
|
return Date.now() - this.lastQueryTime >= this.queryInterval;
|
|
},
|
|
|
|
// 获取缓存的查询结果
|
|
getCachedResult() {
|
|
if (this.cache.size === 0) return null;
|
|
|
|
// 检查是否过期
|
|
if (Date.now() - this.lastQueryTime > this.ttl) {
|
|
console.log('缓存已过期，清除缓存');
|
|
this.cache.clear();
|
|
return null;
|
|
}
|
|
|
|
// 转换为数组返回
|
|
const results = [];
|
|
this.cache.forEach((value, domain) => {
|
|
results.push({
|
|
domain,
|
|
isThreat: value.isThreat,
|
|
data: value.data
|
|
});
|
|
});
|
|
|
|
console.log('使用缓存结果，记录数:', results.length);
|
|
return results;
|
|
},
|
|
|
|
// 缓存批量查询结果
|
|
cacheResults(results) {
|
|
this.cache.clear();
|
|
results.forEach(result => {
|
|
if (result.isThreat && result.data) {
|
|
this.cache.set(result.domain, {
|
|
isThreat: true,
|
|
data: result.data,
|
|
timestamp: Date.now()
|
|
});
|
|
} else {
|
|
this.cache.set(result.domain, {
|
|
isThreat: false,
|
|
timestamp: Date.now()
|
|
});
|
|
}
|
|
});
|
|
this.lastQueryTime = Date.now();
|
|
console.log('缓存批量查询结果，记录数:', this.cache.size);
|
|
|
|
// 持久化到 LocalStorage
|
|
this.saveToLocalStorage();
|
|
},
|
|
|
|
// 保存到 LocalStorage
|
|
saveToLocalStorage() {
|
|
try {
|
|
const serializable = {
|
|
cache: Array.from(this.cache.entries()),
|
|
lastQueryTime: this.lastQueryTime
|
|
};
|
|
localStorage.setItem('threatCache', JSON.stringify(serializable));
|
|
} catch (e) {
|
|
console.warn('LocalStorage 保存失败:', e);
|
|
}
|
|
},
|
|
|
|
// 从 LocalStorage 加载
|
|
loadFromLocalStorage() {
|
|
try {
|
|
const data = localStorage.getItem('threatCache');
|
|
if (data) {
|
|
const parsed = JSON.parse(data);
|
|
// 检查是否过期（最多 1 小时）
|
|
if (Date.now() - parsed.lastQueryTime < 60 * 60 * 1000) {
|
|
parsed.cache.forEach(([key, value]) => {
|
|
this.cache.set(key, value);
|
|
});
|
|
this.lastQueryTime = parsed.lastQueryTime;
|
|
console.log('从 LocalStorage 加载缓存，记录数:', this.cache.size);
|
|
return true;
|
|
} else {
|
|
console.log('LocalStorage 缓存已过期');
|
|
}
|
|
}
|
|
} catch (e) {
|
|
console.warn('LocalStorage 加载失败:', e);
|
|
}
|
|
return false;
|
|
},
|
|
|
|
// 清除缓存
|
|
clear() {
|
|
this.cache.clear();
|
|
this.lastQueryTime = 0;
|
|
localStorage.removeItem('threatCache');
|
|
}
|
|
};
|
|
|
|
// 页面加载时从 LocalStorage 恢复缓存
|
|
threatCache.loadFromLocalStorage();
|
|
|
|
// ==================== 全局变量 ====================
|
|
let threatsDatabase = [];
|
|
let matchedThreats = [];
|
|
let isDatabaseLoaded = false;
|
|
|
|
// 分页相关变量
|
|
const paginationState = {
|
|
currentPage: 1,
|
|
pageSize: 30,
|
|
totalItems: 0,
|
|
totalPages: 0
|
|
};
|
|
|
|
// 加载威胁数据库
|
|
async function loadThreatsDatabase() {
|
|
if (isDatabaseLoaded && threatsDatabase.length > 0) {
|
|
console.log('使用缓存的威胁数据库:', threatsDatabase.length, '条记录');
|
|
return threatsDatabase;
|
|
}
|
|
|
|
try {
|
|
console.log('尝试加载威胁数据库...');
|
|
|
|
// 使用新的API端点获取威胁数据库
|
|
const response = await fetch('/api/domain-info?threats');
|
|
console.log('威胁数据库API请求状态:', response.status);
|
|
|
|
if (!response.ok) {
|
|
throw new Error(`无法加载威胁数据库，状态: ${response.status}`);
|
|
}
|
|
|
|
const data = await response.json();
|
|
console.log('威胁数据库API返回数据:', data);
|
|
|
|
if (!Array.isArray(data)) {
|
|
throw new Error('威胁数据库API返回的数据格式错误，不是数组');
|
|
}
|
|
|
|
// 解析API返回的数据
|
|
threatsDatabase = data.map(item => ({
|
|
type: item.type || '',
|
|
name: item.name || '',
|
|
riskLevel: item.level || '',
|
|
domain: item.domain || ''
|
|
})).filter(item => item.type && item.name && item.riskLevel && item.domain);
|
|
|
|
isDatabaseLoaded = true;
|
|
console.log('威胁数据库加载成功:', threatsDatabase.length, '条记录');
|
|
console.log('威胁数据库前5条记录:', threatsDatabase.slice(0, 5));
|
|
return threatsDatabase;
|
|
} catch (error) {
|
|
console.error('加载威胁数据库失败:', error);
|
|
console.error('错误堆栈:', error.stack);
|
|
// 即使加载失败，也返回一个包含示例数据的数组，确保页面能显示内容
|
|
console.log('加载失败，使用示例威胁数据...');
|
|
return [
|
|
{ type: '钓鱼网站', name: 'Silver fox 团伙', riskLevel: '2', domain: 'kefubahaohonsheng.oss-cn-hongkong.aliyuncs.com' },
|
|
{ type: '钓鱼网站', name: 'Silver fox 团伙', riskLevel: '2', domain: 'baiduwenshen.oss-cn-hongkong.aliyuncs.com' },
|
|
{ type: '木马', name: 'Zegost 后门软件', riskLevel: '1', domain: 'sgkong2.top' },
|
|
{ type: '木马', name: 'Generic 常规木马', riskLevel: '1', domain: 'todesk-1316713808.cos.ap-nanjing.myqcloud.com' }
|
|
];
|
|
}
|
|
}
|
|
|
|
// 加载DNS查询日志
|
|
async function loadDNSLogs() {
|
|
try {
|
|
// 使用 /api/logs/query 接口获取数据，返回DNS查询日志列表
|
|
const response = await fetch('/api/logs/query');
|
|
|
|
// 处理响应
|
|
if (!response.ok) {
|
|
// 如果是未授权错误，记录错误并返回模拟数据
|
|
if (response.status === 401) {
|
|
console.warn('API返回未授权错误，使用模拟数据');
|
|
return getMockDNSLogs();
|
|
}
|
|
throw new Error(`HTTP error! status: ${response.status}`);
|
|
}
|
|
|
|
const logs = await response.json();
|
|
console.log('DNS查询日志加载成功:', logs.length, '条记录');
|
|
console.log('API返回的前3条数据:', logs.slice(0, 3));
|
|
|
|
// 确保返回的数据格式正确
|
|
if (!Array.isArray(logs)) {
|
|
console.error('API返回的数据格式错误，不是数组:', logs);
|
|
// 返回模拟数据作为备用
|
|
return getMockDNSLogs();
|
|
}
|
|
|
|
// 过滤并处理日志数据，确保每个条目都有 domain 字段
|
|
const processedLogs = logs.filter(log => {
|
|
if (log && log.domain) {
|
|
return true;
|
|
}
|
|
console.warn('过滤掉没有 domain 字段的日志条目:', log);
|
|
return false;
|
|
});
|
|
|
|
console.log('处理后有 domain 字段的日志数量:', processedLogs.length);
|
|
|
|
// 如果处理后没有日志，返回模拟数据
|
|
if (processedLogs.length === 0) {
|
|
console.warn('没有找到有 domain 字段的日志，返回模拟数据');
|
|
return getMockDNSLogs();
|
|
}
|
|
|
|
return processedLogs;
|
|
} catch (error) {
|
|
console.error('加载DNS查询日志失败:', error);
|
|
// 返回模拟数据作为备用，包含威胁数据库中的域名
|
|
return getMockDNSLogs();
|
|
}
|
|
}
|
|
|
|
// 获取模拟DNS查询日志
|
|
function getMockDNSLogs() {
|
|
return [
|
|
{
|
|
timestamp: '2023-10-01 14:32:15',
|
|
domain: 'kefubahaohonsheng.oss-cn-hongkong.aliyuncs.com',
|
|
clientIP: '192.168.1.100',
|
|
result: 'allowed'
|
|
},
|
|
{
|
|
timestamp: '2023-10-01 14:28:45',
|
|
domain: 'baiduwenshen.oss-cn-hongkong.aliyuncs.com',
|
|
clientIP: '192.168.1.101',
|
|
result: 'blocked'
|
|
},
|
|
{
|
|
timestamp: '2023-10-01 14:25:30',
|
|
domain: 'sgkong2.top',
|
|
clientIP: '192.168.1.102',
|
|
result: 'blocked'
|
|
},
|
|
{
|
|
timestamp: '2023-10-01 14:20:15',
|
|
domain: 'todesk-1316713808.cos.ap-nanjing.myqcloud.com',
|
|
clientIP: '192.168.1.103',
|
|
result: 'blocked'
|
|
},
|
|
{
|
|
timestamp: '2023-10-01 14:15:00',
|
|
domain: 'shimo-oss1.oss-cn-hangzhou.aliyuncs.com',
|
|
clientIP: '192.168.1.104',
|
|
result: 'allowed'
|
|
},
|
|
{
|
|
timestamp: '2023-10-01 14:10:45',
|
|
domain: 'example.com',
|
|
clientIP: '192.168.1.105',
|
|
result: 'allowed'
|
|
},
|
|
{
|
|
timestamp: '2023-10-01 14:05:30',
|
|
domain: '11bucketyun.oss-cn-hongkong.aliyuncs.com',
|
|
clientIP: '192.168.1.106',
|
|
result: 'allowed'
|
|
},
|
|
{
|
|
timestamp: '2023-10-01 14:00:15',
|
|
domain: 'supervt.oss-cn-hongkong.aliyuncs.com',
|
|
clientIP: '192.168.1.107',
|
|
result: 'blocked'
|
|
}
|
|
];
|
|
}
|
|
|
|
// 匹配威胁数据库与 DNS 查询日志
|
|
async function matchThreatsWithLogs() {
|
|
try {
|
|
// 加载 DNS 查询日志
|
|
const logs = await loadDNSLogs();
|
|
console.log('DNS 查询日志加载完成，记录数:', logs.length);
|
|
|
|
// 提取所有唯一的域名
|
|
const uniqueDomains = [...new Set(logs.filter(log => log && log.domain).map(log => log.domain))];
|
|
console.log('唯一域名数量:', uniqueDomains.length);
|
|
|
|
if (uniqueDomains.length === 0) {
|
|
console.log('没有有效的域名，返回空结果');
|
|
return [];
|
|
}
|
|
|
|
// 检查缓存
|
|
const cachedResults = threatCache.getCachedResult();
|
|
if (cachedResults) {
|
|
console.log('使用缓存的威胁数据');
|
|
// 使用缓存数据匹配
|
|
return matchThreatsFromCache(logs, cachedResults);
|
|
}
|
|
|
|
console.log('开始批量查询威胁数据库...');
|
|
|
|
// 批量查询威胁
|
|
const response = await fetchWithRetry('/api/threat/batch', {
|
|
method: 'POST',
|
|
headers: {
|
|
'Content-Type': 'application/json'
|
|
},
|
|
body: JSON.stringify({
|
|
domains: uniqueDomains
|
|
})
|
|
});
|
|
|
|
const { results } = response;
|
|
console.log('批量查询完成，结果数:', results.length);
|
|
|
|
// 缓存结果
|
|
threatCache.cacheResults(results);
|
|
|
|
// 匹配日志和威胁信息
|
|
return matchThreatsFromResults(logs, results);
|
|
} catch (error) {
|
|
console.error('匹配威胁失败:', error);
|
|
return [];
|
|
}
|
|
}
|
|
|
|
// 从缓存结果匹配威胁
|
|
function matchThreatsFromCache(logs, cachedResults) {
|
|
// 构建域名到威胁信息的映射
|
|
const threatMap = new Map();
|
|
cachedResults.forEach(result => {
|
|
if (result.isThreat && result.data) {
|
|
threatMap.set(result.domain, result.data);
|
|
}
|
|
});
|
|
|
|
return matchThreatsFromMap(logs, threatMap);
|
|
}
|
|
|
|
// 从批量查询结果匹配威胁
|
|
function matchThreatsFromResults(logs, results) {
|
|
// 构建域名到威胁信息的映射
|
|
const threatMap = new Map();
|
|
results.forEach(result => {
|
|
if (result.isThreat && result.data) {
|
|
threatMap.set(result.domain, result.data);
|
|
console.log('发现威胁域名:', result.domain);
|
|
}
|
|
});
|
|
|
|
return matchThreatsFromMap(logs, threatMap);
|
|
}
|
|
|
|
// 从威胁映射匹配日志
|
|
function matchThreatsFromMap(logs, threatMap) {
|
|
const matchedThreats = [];
|
|
let id = 1;
|
|
|
|
logs.forEach(log => {
|
|
const threatData = threatMap.get(log.domain);
|
|
if (threatData) {
|
|
const parts = threatData.split(',');
|
|
if (parts.length >= 4) {
|
|
const [type, name, riskLevel, domain] = parts;
|
|
|
|
// 转换风险等级格式
|
|
let risk;
|
|
switch (riskLevel) {
|
|
case '1':
|
|
risk = 'high';
|
|
break;
|
|
case '2':
|
|
risk = 'medium';
|
|
break;
|
|
case '3':
|
|
risk = 'low';
|
|
break;
|
|
default:
|
|
risk = 'medium';
|
|
}
|
|
|
|
// 转换威胁类型格式
|
|
let typeStr;
|
|
switch (type) {
|
|
case '钓鱼网站':
|
|
typeStr = 'phishing';
|
|
break;
|
|
case '木马':
|
|
typeStr = 'malware';
|
|
break;
|
|
case '僵尸网络':
|
|
typeStr = 'botnet';
|
|
break;
|
|
case 'DGA 域名':
|
|
typeStr = 'dga';
|
|
break;
|
|
default:
|
|
typeStr = 'suspicious';
|
|
}
|
|
|
|
matchedThreats.push({
|
|
id: id++,
|
|
timestamp: log.timestamp,
|
|
type: typeStr,
|
|
domain: log.domain,
|
|
sourceIp: log.clientIP,
|
|
risk: risk,
|
|
status: log.result === 'blocked' ? 'blocked' : 'monitored',
|
|
threatName: name,
|
|
threatType: type,
|
|
riskLevel: riskLevel
|
|
});
|
|
}
|
|
}
|
|
});
|
|
|
|
console.log('威胁匹配完成，匹配记录数:', matchedThreats.length);
|
|
return matchedThreats;
|
|
}
|
|
|
|
// 生成威胁统计数据
|
|
function generateThreatStats(threats) {
|
|
let total = threats.length;
|
|
let high = threats.filter(t => t.risk === 'high').length;
|
|
let medium = threats.filter(t => t.risk === 'medium').length;
|
|
let low = threats.filter(t => t.risk === 'low').length;
|
|
|
|
return {
|
|
total: total,
|
|
high: high,
|
|
medium: medium,
|
|
low: low,
|
|
percentChange: 12.5 // 模拟数据
|
|
};
|
|
}
|
|
|
|
// 生成威胁趋势数据
|
|
function generateThreatTrends(threats) {
|
|
// 生成过去12小时的时间标签
|
|
const labels = [];
|
|
const data = [];
|
|
|
|
for (let i = 11; i >= 0; i--) {
|
|
const hour = new Date();
|
|
hour.setHours(hour.getHours() - i);
|
|
labels.push(`${i}小时前`);
|
|
|
|
// 统计该小时的威胁数量
|
|
const hourStart = new Date(hour);
|
|
hourStart.setMinutes(0, 0, 0);
|
|
const hourEnd = new Date(hourStart);
|
|
hourEnd.setHours(hourEnd.getHours() + 1);
|
|
|
|
const hourThreats = threats.filter(t => {
|
|
const threatTime = new Date(t.timestamp);
|
|
return threatTime >= hourStart && threatTime < hourEnd;
|
|
});
|
|
|
|
data.push(hourThreats.length);
|
|
}
|
|
|
|
return {
|
|
labels: labels,
|
|
data: data
|
|
};
|
|
}
|
|
|
|
// 威胁数据结构
|
|
const threatData = {
|
|
summary: {
|
|
total: 0,
|
|
high: 0,
|
|
medium: 0,
|
|
low: 0,
|
|
percentChange: 0
|
|
},
|
|
trends: {
|
|
labels: [],
|
|
data: []
|
|
},
|
|
threats: []
|
|
};
|
|
|
|
// 显示局部加载状态
|
|
function showLoadingStates() {
|
|
// 统计卡片显示加载状态
|
|
const statElements = [
|
|
'total-threats',
|
|
'high-risk-threats',
|
|
'medium-risk-threats',
|
|
'low-risk-threats'
|
|
];
|
|
|
|
statElements.forEach(id => {
|
|
const element = document.getElementById(id);
|
|
if (element) {
|
|
element.innerHTML = '<i class="fa fa-spinner fa-spin"></i>';
|
|
}
|
|
});
|
|
|
|
// 图表区域显示加载状态
|
|
const trendChart = document.getElementById('threat-trend-chart');
|
|
if (trendChart && trendChart.parentNode) {
|
|
trendChart.parentNode.innerHTML = '<div class="flex items-center justify-center h-48 sm:h-64"><i class="fa fa-spinner fa-spin text-4xl text-primary"></i></div>';
|
|
}
|
|
|
|
const riskChart = document.getElementById('risk-distribution-chart');
|
|
if (riskChart && riskChart.parentNode) {
|
|
riskChart.parentNode.innerHTML = '<div class="flex items-center justify-center h-48 sm:h-64"><i class="fa fa-spinner fa-spin text-4xl text-primary"></i></div>';
|
|
}
|
|
|
|
// 列表区域显示加载状态和进度提示
|
|
const threatList = document.getElementById('threat-list');
|
|
if (threatList) {
|
|
threatList.innerHTML = '<tr><td colspan="7" class="py-8 text-center text-gray-500"><i class="fa fa-spinner fa-spin mr-2"></i>正在查询威胁数据，请稍候...</td></tr>';
|
|
}
|
|
}
|
|
|
|
// 显示加载错误
|
|
function showLoadingError(error) {
|
|
console.error('加载错误:', error);
|
|
|
|
// 统计卡片显示错误
|
|
const statElements = [
|
|
'total-threats',
|
|
'high-risk-threats',
|
|
'medium-risk-threats',
|
|
'low-risk-threats'
|
|
];
|
|
|
|
statElements.forEach(id => {
|
|
const element = document.getElementById(id);
|
|
if (element) {
|
|
element.textContent = '0';
|
|
}
|
|
});
|
|
|
|
// 图表区域显示错误
|
|
const trendChartContainer = document.getElementById('threat-trend-chart')?.parentNode;
|
|
if (trendChartContainer) {
|
|
trendChartContainer.innerHTML = '<div class="flex items-center justify-center h-48 sm:h-64 text-danger"><i class="fa fa-exclamation-triangle mr-2"></i>加载失败</div>';
|
|
}
|
|
|
|
const riskChartContainer = document.getElementById('risk-distribution-chart')?.parentNode;
|
|
if (riskChartContainer) {
|
|
riskChartContainer.innerHTML = '<div class="flex items-center justify-center h-48 sm:h-64 text-danger"><i class="fa fa-exclamation-triangle mr-2"></i>加载失败</div>';
|
|
}
|
|
|
|
// 列表区域显示错误
|
|
const threatList = document.getElementById('threat-list');
|
|
if (threatList) {
|
|
threatList.innerHTML = '<tr><td colspan="7" class="py-8 text-center text-danger"><i class="fa fa-exclamation-triangle mr-2"></i>加载失败，请刷新重试</td></tr>';
|
|
}
|
|
}
|
|
|
|
// 初始化威胁告警页面
|
|
async function initThreatsPage() {
|
|
console.log('初始化威胁告警页面');
|
|
|
|
// 显示局部加载状态
|
|
showLoadingStates();
|
|
|
|
try {
|
|
console.log('开始加载威胁数据库...');
|
|
const database = await loadThreatsDatabase();
|
|
console.log('威胁数据库加载完成，记录数:', database.length);
|
|
|
|
console.log('开始加载 DNS 查询日志...');
|
|
const logs = await loadDNSLogs();
|
|
console.log('DNS 查询日志加载完成，记录数:', logs.length);
|
|
|
|
console.log('开始匹配威胁...');
|
|
const threats = await matchThreatsWithLogs();
|
|
console.log('威胁匹配完成，匹配记录数:', threats.length);
|
|
|
|
// 更新威胁数据
|
|
threatData.threats = threats;
|
|
threatData.summary = generateThreatStats(threats);
|
|
threatData.trends = generateThreatTrends(threats);
|
|
|
|
console.log('威胁数据更新完成:', {
|
|
threats: threats.length,
|
|
summary: threatData.summary,
|
|
trends: threatData.trends
|
|
});
|
|
|
|
// 初始化页面组件
|
|
console.log('开始初始化页面组件...');
|
|
populateThreatStats();
|
|
|
|
// 数据加载完成后再渲染图表
|
|
console.log('渲染图表...');
|
|
renderThreatTrendChart();
|
|
renderRiskDistributionChart();
|
|
|
|
populateThreatList();
|
|
bindFilterEvents();
|
|
console.log('页面组件初始化完成');
|
|
} catch (error) {
|
|
console.error('初始化威胁告警页面失败:', error);
|
|
showLoadingError(error);
|
|
}
|
|
}
|
|
|
|
// 填充威胁统计卡片
|
|
function populateThreatStats() {
|
|
const summary = threatData.summary;
|
|
|
|
// 填充总威胁数
|
|
document.getElementById('total-threats').textContent = summary.total;
|
|
document.getElementById('threats-percent').textContent = `${summary.percentChange}%`;
|
|
|
|
// 填充高风险威胁数
|
|
document.getElementById('high-risk-threats').textContent = summary.high;
|
|
document.getElementById('high-risk-percent').textContent = `${Math.round((summary.high / summary.total) * 100)}%`;
|
|
|
|
// 填充中风险威胁数
|
|
document.getElementById('medium-risk-threats').textContent = summary.medium;
|
|
document.getElementById('medium-risk-percent').textContent = `${Math.round((summary.medium / summary.total) * 100)}%`;
|
|
|
|
// 填充低风险威胁数
|
|
document.getElementById('low-risk-threats').textContent = summary.low;
|
|
document.getElementById('low-risk-percent').textContent = `${Math.round((summary.low / summary.total) * 100)}%`;
|
|
}
|
|
|
|
// 渲染威胁趋势图表
|
|
function renderThreatTrendChart() {
|
|
try {
|
|
const canvas = document.getElementById('threat-trend-chart');
|
|
if (!canvas) {
|
|
console.warn('威胁趋势图表 canvas 元素不存在');
|
|
return;
|
|
}
|
|
|
|
const ctx = canvas.getContext('2d');
|
|
|
|
// 销毁已存在的图表
|
|
if (window.threatTrendChart) {
|
|
window.threatTrendChart.destroy();
|
|
}
|
|
|
|
// 如果没有数据，显示空图表
|
|
const labels = threatData.trends.labels || [];
|
|
const data = threatData.trends.data || [];
|
|
|
|
// 创建新图表
|
|
window.threatTrendChart = new Chart(ctx, {
|
|
type: 'line',
|
|
data: {
|
|
labels: labels.length > 0 ? labels : ['无数据'],
|
|
datasets: [{
|
|
label: '威胁数量',
|
|
data: data.length > 0 ? data : [0],
|
|
borderColor: '#ef4444',
|
|
backgroundColor: 'rgba(239, 68, 68, 0.1)',
|
|
tension: 0.4,
|
|
fill: true
|
|
}]
|
|
},
|
|
options: {
|
|
responsive: true,
|
|
maintainAspectRatio: false,
|
|
plugins: {
|
|
legend: {
|
|
display: false
|
|
}
|
|
},
|
|
scales: {
|
|
y: {
|
|
beginAtZero: true,
|
|
grid: {
|
|
color: 'rgba(0, 0, 0, 0.05)'
|
|
}
|
|
},
|
|
x: {
|
|
grid: {
|
|
display: false
|
|
}
|
|
}
|
|
}
|
|
}
|
|
});
|
|
} catch (error) {
|
|
console.error('渲染威胁趋势图表失败:', error);
|
|
}
|
|
}
|
|
|
|
// 渲染风险等级分布图表
|
|
function renderRiskDistributionChart() {
|
|
try {
|
|
const canvas = document.getElementById('risk-distribution-chart');
|
|
if (!canvas) {
|
|
console.warn('风险等级分布图表 canvas 元素不存在');
|
|
return;
|
|
}
|
|
|
|
const ctx = canvas.getContext('2d');
|
|
const summary = threatData.summary;
|
|
|
|
// 销毁已存在的图表
|
|
if (window.riskDistributionChart) {
|
|
window.riskDistributionChart.destroy();
|
|
}
|
|
|
|
// 检查是否有数据
|
|
const hasData = summary && (summary.high > 0 || summary.medium > 0 || summary.low > 0);
|
|
|
|
if (!hasData) {
|
|
// 没有数据时显示提示
|
|
ctx.font = '16px Arial';
|
|
ctx.fillStyle = '#999';
|
|
ctx.textAlign = 'center';
|
|
ctx.textBaseline = 'middle';
|
|
const centerX = canvas.width / 2;
|
|
const centerY = canvas.height / 2;
|
|
ctx.fillText('暂无威胁数据', centerX, centerY);
|
|
return;
|
|
}
|
|
|
|
// 创建新图表
|
|
window.riskDistributionChart = new Chart(ctx, {
|
|
type: 'doughnut',
|
|
data: {
|
|
labels: ['高风险', '中风险', '低风险'],
|
|
datasets: [{
|
|
data: [summary.high, summary.medium, summary.low],
|
|
backgroundColor: ['#ef4444', '#f59e0b', '#3b82f6'],
|
|
borderWidth: 0
|
|
}]
|
|
},
|
|
options: {
|
|
responsive: true,
|
|
maintainAspectRatio: false,
|
|
plugins: {
|
|
legend: {
|
|
position: 'bottom'
|
|
}
|
|
},
|
|
cutout: '70%'
|
|
}
|
|
});
|
|
} catch (error) {
|
|
console.error('渲染风险等级分布图表失败:', error);
|
|
}
|
|
}
|
|
|
|
// 填充威胁告警列表
|
|
function populateThreatList(filteredThreats = null) {
|
|
const threatList = document.getElementById('threat-list');
|
|
const threats = filteredThreats || threatData.threats;
|
|
|
|
// 清空列表
|
|
threatList.innerHTML = '';
|
|
|
|
// 获取当前页的数据
|
|
const currentPageData = getCurrentPageData(threats);
|
|
|
|
// 如果没有数据
|
|
if (currentPageData.length === 0) {
|
|
threatList.innerHTML = '<tr><td colspan="7" class="py-8 text-center text-gray-500">暂无威胁告警数据</td></tr>';
|
|
updatePaginationState(threats.length);
|
|
renderPagination();
|
|
return;
|
|
}
|
|
|
|
// 填充列表
|
|
currentPageData.forEach(threat => {
|
|
const row = document.createElement('tr');
|
|
|
|
// 获取威胁类型显示文本（优先使用 threatType，如果不存在则使用 type 映射）
|
|
const typeText = threat.threatType || {
|
|
'malware': '恶意软件',
|
|
'phishing': '钓鱼网站',
|
|
'botnet': '僵尸网络',
|
|
'dga': 'DGA 域名',
|
|
'suspicious': '可疑活动'
|
|
}[threat.type] || '未知';
|
|
|
|
// 获取风险等级显示文本和样式
|
|
const riskInfo = {
|
|
'high': { text: '高', class: 'bg-red-100 text-red-800' },
|
|
'medium': { text: '中', class: 'bg-yellow-100 text-yellow-800' },
|
|
'low': { text: '低', class: 'bg-blue-100 text-blue-800' }
|
|
}[threat.risk];
|
|
|
|
// 获取状态显示文本和样式
|
|
const statusInfo = {
|
|
'blocked': { text: '已屏蔽', class: 'bg-green-100 text-green-800' },
|
|
'monitored': { text: '监控中', class: 'bg-yellow-100 text-yellow-800' }
|
|
}[threat.status];
|
|
|
|
// 设置行内容
|
|
row.innerHTML = `
|
|
<td class="py-2 sm:py-3 px-2 sm:px-4 text-sm">${threat.timestamp}</td>
|
|
<td class="py-2 sm:py-3 px-2 sm:px-4 text-sm">${typeText}</td>
|
|
<td class="py-2 sm:py-3 px-2 sm:px-4 text-sm">${threat.threatName || '未知'}</td>
|
|
<td class="py-2 sm:py-3 px-2 sm:px-4 text-sm font-medium">${threat.domain}</td>
|
|
<td class="py-2 sm:py-3 px-2 sm:px-4 text-sm">${threat.sourceIp}</td>
|
|
<td class="py-2 sm:py-3 px-2 sm:px-4 text-sm">
|
|
<span class="px-2 py-1 rounded-full text-xs ${riskInfo.class}">${riskInfo.text}</span>
|
|
</td>
|
|
<td class="py-2 sm:py-3 px-2 sm:px-4 text-sm">
|
|
<span class="px-2 py-1 rounded-full text-xs ${statusInfo.class}">${statusInfo.text}</span>
|
|
</td>
|
|
`;
|
|
|
|
// 添加行到列表
|
|
threatList.appendChild(row);
|
|
});
|
|
|
|
// 更新分页状态
|
|
updatePaginationState(threats.length);
|
|
|
|
// 渲染分页控件
|
|
renderPagination();
|
|
}
|
|
|
|
// 更新分页状态
|
|
function updatePaginationState(totalItems) {
|
|
paginationState.totalItems = totalItems;
|
|
paginationState.totalPages = Math.ceil(totalItems / paginationState.pageSize);
|
|
|
|
// 确保当前页码在有效范围内
|
|
if (paginationState.currentPage > paginationState.totalPages) {
|
|
paginationState.currentPage = Math.max(1, paginationState.totalPages);
|
|
}
|
|
}
|
|
|
|
// 渲染分页控件
|
|
function renderPagination() {
|
|
const pageSizeSelect = document.getElementById('page-size');
|
|
const currentPageInput = document.getElementById('current-page-input');
|
|
const prevPageBtn = document.getElementById('prev-page-btn');
|
|
const nextPageBtn = document.getElementById('next-page-btn');
|
|
const goToPageBtn = document.getElementById('go-to-page-btn');
|
|
|
|
if (!pageSizeSelect || !currentPageInput) return;
|
|
|
|
// 更新每页显示数量
|
|
pageSizeSelect.value = paginationState.pageSize;
|
|
|
|
// 更新当前页码输入
|
|
currentPageInput.value = paginationState.currentPage;
|
|
currentPageInput.max = paginationState.totalPages || 1;
|
|
|
|
// 更新按钮状态
|
|
if (prevPageBtn) {
|
|
prevPageBtn.disabled = paginationState.currentPage === 1;
|
|
prevPageBtn.classList.toggle('opacity-50', paginationState.currentPage === 1);
|
|
prevPageBtn.classList.toggle('cursor-not-allowed', paginationState.currentPage === 1);
|
|
}
|
|
|
|
if (nextPageBtn) {
|
|
nextPageBtn.disabled = paginationState.currentPage >= paginationState.totalPages;
|
|
nextPageBtn.classList.toggle('opacity-50', paginationState.currentPage >= paginationState.totalPages);
|
|
nextPageBtn.classList.toggle('cursor-not-allowed', paginationState.currentPage >= paginationState.totalPages);
|
|
}
|
|
|
|
// 绑定事件（只绑定一次）
|
|
if (!window.paginationEventsBound) {
|
|
bindPaginationEvents();
|
|
window.paginationEventsBound = true;
|
|
}
|
|
}
|
|
|
|
// 绑定分页事件
|
|
function bindPaginationEvents() {
|
|
const pageSizeSelect = document.getElementById('page-size');
|
|
const currentPageInput = document.getElementById('current-page-input');
|
|
const prevPageBtn = document.getElementById('prev-page-btn');
|
|
const nextPageBtn = document.getElementById('next-page-btn');
|
|
const goToPageBtn = document.getElementById('go-to-page-btn');
|
|
|
|
// 每页显示数量变化
|
|
if (pageSizeSelect) {
|
|
pageSizeSelect.addEventListener('change', (e) => {
|
|
paginationState.pageSize = parseInt(e.target.value);
|
|
paginationState.currentPage = 1; // 重置到第一页
|
|
applyFilters(); // 重新应用过滤器
|
|
});
|
|
}
|
|
|
|
// 上一页
|
|
if (prevPageBtn) {
|
|
prevPageBtn.addEventListener('click', () => {
|
|
if (paginationState.currentPage > 1) {
|
|
paginationState.currentPage--;
|
|
applyFilters();
|
|
}
|
|
});
|
|
}
|
|
|
|
// 下一页
|
|
if (nextPageBtn) {
|
|
nextPageBtn.addEventListener('click', () => {
|
|
if (paginationState.currentPage < paginationState.totalPages) {
|
|
paginationState.currentPage++;
|
|
applyFilters();
|
|
}
|
|
});
|
|
}
|
|
|
|
// 前往指定页
|
|
if (goToPageBtn && currentPageInput) {
|
|
goToPageBtn.addEventListener('click', () => {
|
|
const page = parseInt(currentPageInput.value);
|
|
if (page >= 1 && page <= paginationState.totalPages) {
|
|
paginationState.currentPage = page;
|
|
applyFilters();
|
|
} else {
|
|
alert(`请输入 1 到 ${paginationState.totalPages} 之间的页码`);
|
|
}
|
|
});
|
|
|
|
// 支持回车键
|
|
currentPageInput.addEventListener('keypress', (e) => {
|
|
if (e.key === 'Enter') {
|
|
goToPageBtn.click();
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
// 获取当前页的数据
|
|
function getCurrentPageData(filteredThreats) {
|
|
const start = (paginationState.currentPage - 1) * paginationState.pageSize;
|
|
const end = start + paginationState.pageSize;
|
|
return filteredThreats.slice(start, end);
|
|
}
|
|
|
|
// 绑定过滤器事件
|
|
function bindFilterEvents() {
|
|
const riskFilter = document.getElementById('threat-filter-risk');
|
|
const typeFilter = document.getElementById('threat-filter-type');
|
|
const domainFilter = document.getElementById('threat-filter-domain');
|
|
const domainFilterBtn = document.getElementById('threat-filter-domain-btn');
|
|
const refreshBtn = document.getElementById('refresh-threats-btn');
|
|
|
|
// 域名筛选器事件（回车键）
|
|
if (domainFilter) {
|
|
domainFilter.addEventListener('keypress', (e) => {
|
|
if (e.key === 'Enter') {
|
|
applyFilters();
|
|
}
|
|
});
|
|
}
|
|
|
|
// 域名筛选按钮事件
|
|
if (domainFilterBtn) {
|
|
domainFilterBtn.addEventListener('click', applyFilters);
|
|
}
|
|
|
|
// 风险等级过滤器事件
|
|
if (riskFilter) {
|
|
riskFilter.addEventListener('change', applyFilters);
|
|
}
|
|
|
|
// 威胁类型过滤器事件
|
|
if (typeFilter) {
|
|
typeFilter.addEventListener('change', applyFilters);
|
|
}
|
|
|
|
// 刷新按钮事件
|
|
if (refreshBtn) {
|
|
refreshBtn.addEventListener('click', async function() {
|
|
console.log('点击刷新威胁告警按钮');
|
|
|
|
// 显示加载状态
|
|
const originalIcon = refreshBtn.innerHTML;
|
|
refreshBtn.innerHTML = '<i class="fa fa-spinner fa-spin"></i>';
|
|
refreshBtn.disabled = true;
|
|
refreshBtn.classList.add('opacity-70', 'cursor-not-allowed');
|
|
|
|
try {
|
|
// 清除缓存
|
|
threatCache.clear();
|
|
|
|
// 重新加载数据
|
|
const threats = await matchThreatsWithLogs();
|
|
|
|
// 更新威胁数据
|
|
threatData.threats = threats;
|
|
threatData.summary = generateThreatStats(threats);
|
|
threatData.trends = generateThreatTrends(threats);
|
|
|
|
// 重置分页
|
|
paginationState.currentPage = 1;
|
|
|
|
// 重新渲染页面
|
|
populateThreatStats();
|
|
renderThreatTrendChart();
|
|
renderRiskDistributionChart();
|
|
applyFilters();
|
|
|
|
console.log('威胁数据刷新完成');
|
|
} catch (error) {
|
|
console.error('刷新威胁数据失败:', error);
|
|
alert('刷新失败，请重试');
|
|
} finally {
|
|
refreshBtn.innerHTML = originalIcon;
|
|
refreshBtn.disabled = false;
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
// 应用过滤器
|
|
function applyFilters() {
|
|
const riskFilter = document.getElementById('threat-filter-risk')?.value || 'all';
|
|
const typeFilter = document.getElementById('threat-filter-type')?.value || 'all';
|
|
const domainFilter = document.getElementById('threat-filter-domain')?.value?.toLowerCase() || '';
|
|
|
|
// 过滤威胁数据
|
|
const filteredThreats = threatData.threats.filter(threat => {
|
|
// 风险等级匹配
|
|
const riskMatch = riskFilter === 'all' || threat.risk === riskFilter;
|
|
|
|
// 威胁类型匹配（使用 threatType，因为它是中文的）
|
|
const typeMatch = typeFilter === 'all' || threat.threatType === typeFilter;
|
|
|
|
// 域名匹配（支持模糊匹配）
|
|
const domainMatch = domainFilter === '' ||
|
|
threat.domain.toLowerCase().includes(domainFilter) ||
|
|
(threat.threatName && threat.threatName.toLowerCase().includes(domainFilter));
|
|
|
|
return riskMatch && typeMatch && domainMatch;
|
|
});
|
|
|
|
// 重置分页到第一页
|
|
paginationState.currentPage = 1;
|
|
|
|
// 填充过滤后的威胁列表
|
|
populateThreatList(filteredThreats);
|
|
} |