Wuming 無名

Blog

威胁检测平台全景:从镜像流量到可处置告警(一)

· In Chinese · Technology

下一篇:万兆流量采集

设想一下:企业核心交换机上所有经过的流量,被镜像一份送到一台服务器上,速率 10 Gbps 起步,全天不停。这股数据流里可能藏着一封带毒附件的钓鱼邮件、一条连向远控服务器的心跳,或者一个正在内网文件服务器上悄悄试密码的攻击者。ATD(Advanced Threat Detection,高级威胁检测)平台要做的,就是从海量流量里把这几根针找出来,串成一个完整的故事,交给分析人员一个能直接处置的结论,而不是一屏又一屏的噪音。

没有哪个单一工具能独立完成这件事。签名引擎一次只看一条流;情报匹配不知道五分钟前发生过什么;沙箱又慢,而且只能看文件。所以真正落地的平台必然是分层的:底层快而精确但”不动脑子”,越往上越慢、越聪明,中间靠一条管道把原始流量变成事件,把事件变成告警,再把告警变成安全事件(incident)。

这个系列会把这样一套系统逐层拆开来讲。本篇是总地图:有哪些层、数据怎么流动、两个真实攻击场景从头到尾长什么样、整套东西怎么部署。后面每一篇都会放大下图中的某一个框。

设计目标

先说约束,正是这些约束决定了后面的分层:

目标 带来的设计要求
跟上线速(10G 以上) 内核旁路采集、按核分配 worker,DPI 层之上不再做逐包处理
发现多阶段攻击 需要一个能跨小时、跨天记住主机和事件的关联层
低误报 多个相互独立的检测器交叉印证,再叠加资产上下文和白名单
每条告警都可解释 每条规则、每个情报命中都能映射到分类、严重度和杀伤链阶段
单机和几十台都能跑 组件之间走消息总线,而不是进程内调用
无人值守站点也能活 进程守护、自愈、带回滚的版本化升级

核心思路是一个漏斗:每一层把数据量压低一到两个数量级,同时补充上下文。每秒数百万个包,变成每秒数千条协议记录和告警,最后变成每小时屈指可数的几条关联威胁。

分层架构

下面是整个平台的一页纸视图,右侧标注的是本系列中对应的篇目。

          交换机镜像口 / 网络 TAP / 虚拟交换机镜像
                              │  原始数据包,10G+
┌─────────────────────────────▼────────────────────────────────┐
│ 1. 采集层   网卡 -> PF_RING ZC -> 按流哈希的负载均衡         │  第 2 篇
└──────────────┬──────────────────────────────┬────────────────┘
               │ 每核一个包队列               │
┌──────────────▼───────────────┐  ┌───────────▼────────────────┐
│ 2a. DPI 引擎 (Suricata)      │  │ 2b. 协议分析 (Zeek)        │  第 3、4 篇
│  签名检测 / 应用层日志       │  │  丰富的协议事件            │
│  文件还原                    │  │  可编程脚本逻辑            │
└───┬───────────────┬──────────┘  └───────────┬────────────────┘
    │ 文件          │ 告警 + 元数据           │ 事件
    │               │ (ZeroMQ)                │ (Redis)
    │       ┌───────▼─────────────────────────▼──────────────┐
    │       │ 3. 事件管道  Flume + Esper CEP -> Kafka        │  第 5 篇
    │       └───────┬────────────────────────────────────────┘
    │               │ 归一化后的事件流
    │       ┌───────▼────────────────────────────────────────┐
    │       │ 4. 检测器                                      │
    │       │   威胁情报匹配    (第 6 篇)                  │
    │       │   规则异常检测    (第 7 篇)                  │
    │       │   机器学习检测    (第 8 篇)                  │
    │       └───────┬────────────────────────────────────────┘
    │               │ 候选威胁
    │       ┌───────▼────────────────────────────────────────┐
    │       │ 5. 关联层  资产 / 杀伤链 / 评分                │  第 9 篇
    │       │           降噪 / 聚合                          │
    │       └───────▲───────────────┬────────────────────────┘
┌───▼───────────────┴──┐            │ 安全事件
│ 6. 文件分析          │ 判定结果   │
│  沙箱 (QEMU/KVM)     │            │                          第 10、11 篇
│  多引擎杀毒          │            │
└──────────────────────┘            │
┌────────────────────────────────────▼───────────────────────────┐
│ 7. 存储层   Elasticsearch(事件)/ MySQL(配置、知识库)       │
│             Redis(缓存、队列、实时计数)                      │
└────────────────────────────────────┬───────────────────────────┘
┌────────────────────────────────────▼───────────────────────────┐
│ 8. 管理平台  Django REST API / 单页前端 / Kibana / Celery      │  第 12 篇
└────────────────────────────────────────────────────────────────┘

 横切关注点:  知识库(规则、情报、分类体系)       第 3、6 篇
              轻量级远程探针                       第 13 篇
              打包、版本、升级与回滚               第 14 篇
              运维监控与自愈                       第 15 篇

下面自底向上走一遍。

1. 采集层

Linux 标准网络协议栈对每个包要拷贝好几次,还要按批次触发中断。10 Gbps 的小包大约是每秒 1500 万个包,平均每个包只有约 67 纳秒的处理时间,协议栈根本来不及。采集层用的是 PF_RING ZC(一种内核旁路库,网卡通过 DMA 直接把包写进应用可读的内存,即”零拷贝”),再加一个负载均衡进程,按流对每个包做哈希,分发到 N 个按 CPU 核划分的队列里。同一条连接的所有包一定落到同一个 worker 上,下一层才能维护会话状态。

2. 深度包检测与协议分析

有两个引擎读取这些队列:

  • Suricata 是主力。它重组 TCP 流,解析应用层协议(HTTP、DNS、TLS、SMB、SMTP 等),用大规模签名规则集去匹配,并把经过网络传输的文件还原出来。它输出三类东西:告警(某条签名命中)、元数据(每个 HTTP 请求、DNS 查询、TLS 握手、每条流各一条记录)以及写到磁盘上的文件。
  • Zeek 的角度不一样。它不依赖庞大的签名库,而是把流量翻译成高层次的事件日志,让你用脚本写检测逻辑,特别适合”某主机刚刚失败了 400 次 SSH 登录”这类行为判断。

两个都跑会多花 CPU,但它们互补:Suricata 擅长精确识别已知恶意特征,Zeek 擅长灵活的行为逻辑。

3. 事件管道

这条线以上都是 C 代码、逐包处理;以下都是逐事件处理。连接两者的是一个 Apache Flume agent,配有自定义的 ZeroMQ 数据源(ZeroMQ 是一个轻量、无中心代理的消息库)。Flume 解析 JSON 事件,统一字段名和时间戳,再送进 Esper CEP 拦截器(CEP 即复杂事件处理,在滑动时间窗口上做持续查询),最后写入 Kafka 主题和 Elasticsearch。

Esper 这一环能以很低的成本,提前抓住”一段时间内计数超阈值”这类简单模式。示意规则如下:

-- 仅作示意:同一源地址一分钟内访问了大量不同端口
SELECT src_ip, COUNT(DISTINCT dest_port) AS ports
FROM AlertEvent.win:time(60 sec)
WHERE category = 'scan'
GROUP BY src_ip
HAVING COUNT(DISTINCT dest_port) > 100

4. 检测器

三类检测器消费归一化后的事件流,各自回答不同的问题:

检测器 回答的问题 典型输入
威胁情报匹配 “这个域名、IP、URL、哈希或证书是否出现在已知恶意清单上?” DNS、HTTP、TLS、邮件、文件哈希
规则异常检测 “这个行为是否符合已知攻击模式?“(暴力破解、认证滥用、异常载荷) 协议记录、认证事件
机器学习检测 “这看起来像不像我们还没写规则的东西?“(DGA 域名、钓鱼页面、恶意加密流量) DNS 域名、URL、TLS 及流特征

它们是刻意设计成相互独立的。当其中两个对同一台主机给出一致结论时,置信度会大幅上升。

5. 关联层

这是整个系统的”大脑”。它从流量中被动地构建资产清单(哪些 IP 是服务器、各跑了什么服务、平时的行为基线是什么),并按主机记住最近的检测结果。它要做的事情是:

  1. 去重:同一个文件可能同时触发签名、情报命中和杀毒判定,这是一个事件而不是三个。
  2. 串联:把每个事件映射到杀伤链阶段(侦察、投递、利用、安装、命令与控制、目标行动),并把同一主机或同一攻击者在一段时间内的事件连起来。
  3. 评分:综合严重度、置信度、资产重要性和所处阶段,算出风险分。
  4. 抑制:应用白名单和已知良性模式。
  5. 聚合:周期任务把同类告警按时间窗合并成一条告警。

一个简化的评分思路:

# 仅作示意,并非任何产品的真实公式
def risk(severity, confidence, asset_value, stage_weight):
    base = severity * confidence * asset_value      # 各项已归一化到 0..1
    return round(100 * min(1.0, base * stage_weight))

6. 文件分析

DPI 层还原出来的文件交给两个分析器。一个是基于 QEMU/KVM 的动态沙箱:按文件类型挑选一次性虚拟机(PE 文件和 Office 文档用 Windows,ELF 用 Linux,APK 用模拟器)运行样本,记录进程、文件、注册表和网络行为并打分。另一个是多引擎杀毒:把同一个文件交给几款商业引擎加开源的 ClamAV 扫描,再融合各家结论。杀毒快,擅长认出已知样本;沙箱慢,但能发现新样本。

7. 存储层

三种存储,各司其职:

  • Elasticsearch:所有时序数据(告警、协议元数据、流记录、关联威胁、沙箱报告),按天建索引,配合热/温/冷分层保留。
  • MySQL:配置、用户与权限、资产,以及知识库:规则库、威胁分类体系、杀伤链阶段、CVE 数据和情报。
  • Redis:情报查询缓存、会话、Celery 的消息代理与结果存储,以及仪表盘的实时计数。

8. 管理平台

后端是带基于角色访问控制(RBAC)的 Django REST 服务,前端是单页应用,Kibana 用于自由检索和威胁狩猎,Celery worker 跑定时任务(报表、风险重算、告警邮件、缓存刷新)。分析人员的日常工作都在这里完成。

数据如何流动

可以把整个系统看成三个平面:

 热路径(逐包,C 语言,按核并行)
   网卡 ─► PF_RING ─► Suricata / Zeek
                         │
 事件平面(逐事件,JVM + Python,消息总线)
   ZeroMQ ─► Flume/Esper ─► Kafka ─► 检测器 ─► 关联层
                                                  │
 分析平面(逐查询,Web + 批处理)
   Elasticsearch / MySQL / Redis ◄─ Django + Celery ◄─ 浏览器

几个衔接点值得单独说一下:

  • 引擎与管道之间用 ZeroMQ。 引擎绝不能被慢消费者拖住。ZeroMQ 的 PUB/SUB 是发出即忘:Flume 跟不上时,消息在边界上被丢弃,而不是反压到包处理流程。丢一些元数据可以接受,丢包不行。
  • 管道内部用 Kafka。 归一化之后,可靠性就重要了。Kafka 让检测器和关联引擎可以各自重放、重启和扩容。
  • 统一的事件格式。 各引擎的输出在早期就被映射成同一套字段,下游代码完全不用关心事件来自 Suricata 还是 Zeek:
{
  "ts": "2026-01-14T09:15:02.113Z",
  "sensor": "sensor-a",
  "kind": "alert",
  "src_ip": "<redacted>", "dest_ip": "<redacted>", "dest_port": 443,
  "proto": "tls",
  "sig_id": 1000001,
  "category": "trojan-activity",
  "severity": 2,
  "attack_stage": "command-control",
  "flow_id": 8812734412
}
  • 知识库就是字典。 引擎只输出简短的标识(签名 ID、情报清单名),知识库把它们翻译成人能看懂的含义:分类、严重度、描述、处置建议、杀伤链阶段。把这套映射集中在一个地方,跨引擎的告警才能口径一致。

场景一:一次恶意下载

用户点击了邮件里的链接,通过 HTTP 下载了一个可执行文件。

T+0s    HTTP 响应里带着一个 .exe
T+1s    Suricata:重组数据流,还原文件并计算哈希,
        "通用下载器"类签名命中 → 告警 + 文件信息经 ZeroMQ 发出
T+2s    Flume:归一化,写入 Kafka 和 Elasticsearch
T+3s    情报匹配:SHA-256 出现在某已知恶意家族清单中 → 命中
        多引擎杀毒:多数引擎报毒 → "恶意,中高置信度"
T+5s    关联层:三个信号、同一个文件、同一台主机 → 合并为一个事件
        阶段 = 安装,风险 = 高 → 提交沙箱
T+5min  沙箱:样本把自身复制到临时目录、写入开机自启注册表项、
        注入系统进程、通过 443 端口外连 → 评分为严重
T+5min  DPI:同一主机向沙箱观察到的地址发起 TLS 连接
        → 关联层将其串入,阶段 = 命令与控制
T+6min  事件升级为严重;发送邮件、syslog 推送到 SIEM;
        可选的响应动作(封禁地址、隔离主机)

注意先后顺序。便宜又快的信号(签名、哈希查询、杀毒)几秒内就到,已经足够产生告警;昂贵的沙箱只对已经可疑的文件运行,而它的输出又会变成新的 IOC(失陷指标),反过来交给 DPI 层和情报层在网络上继续盯。

场景二:一次缓慢的多阶段入侵

更难的情况是:攻击者从头到尾都没触发过一条高危规则。

时间 发生了什么 谁看到了 杀伤链阶段 风险
第 1 天 09:15 外部主机扫描某内网网段的常见端口 Suricata 扫描类签名;Esper 统计不同端口数 侦察 低
14:32 人事部员工收到一个来自仿冒域名、带宏的表格 情报匹配(发件域名);DPI 还原文件;杀毒拿不准(宏被混淆) 投递 中
14:45 宏通过 HTTP 下载载荷 可疑下载签名;沙箱看到编码过的 PowerShell 和计划任务 利用 / 安装 高
15:00 该工作站开始每 60 秒一次的 TLS 心跳 机器学习标记加密流量;情报匹配到证书 命令与控制 严重
16:30 该工作站尝试对 15 台内网主机发起 SMB 登录 异常检测:认证尝试呈扇出状 目标行动 严重

每一行单独拿出来,忙碌的分析人员都可能忽略。关联层的价值就在于把它们连起来:第 1、2 行是同一个外部地址,第 3 到 5 行是同一台工作站,各阶段又按正确顺序向前推进。最终呈现的是一个带时间线的事件,而不是五条互不相干的告警。

部署形态

同一套组件有三种打包方式:

 一体机                              分布式
 ┌─────────────────────┐           ┌──────────┐ ┌──────────┐ ┌──────────┐
 │ 采集 + DPI          │           │ 探针 A   │ │ 探针 B   │ │ 探针 C   │
 │ 管道 + 检测器       │           │ 采集     │ │ 采集     │ │ 轻量     │
 │ 关联                │           │ DPI      │ │ DPI      │ │ 探针     │
 │ 沙箱 + 杀毒         │           │ 管道     │ │ 管道     │ │          │
 │ ES + MySQL + Redis  │           └────┬─────┘ └────┬─────┘ └────┬─────┘
 │ 管理平台            │                └──────┬─────┴────────────┘
 └─────────────────────┘                       ▼
  一台双路服务器,                     中心:ES 集群、关联层、
  一条 10G 链路                        管理平台、知识库
                                      分析集群:沙箱池、杀毒池
  • 一体机:一台双路服务器加一张 10G 采集卡。CPU 核按用途划分:几个给操作系统,一组给 DPI worker,一组给 Zeek,剩下的给存储和 Web。适合单站点。
  • 分布式:采集和 DPI 部署在各站点、贴近流量;重分析(沙箱池、杀毒池)和存储集中在中心。跨广域网传输的只有事件和文件,从不传原始包。
  • 轻量级探针:适合分支机构或云主机这类上整机不划算的场景。它以很小的资源占用完成采集和元数据提取,再把事件转发到中心(见第 13 篇)。

取舍与经验

  • 漏斗就是一切。 大部分性能问题都来自在错误的层做了事。对每个包跑正则应该放在 Suricata 里、配合快速模式预过滤,而不是放到下游 Python 里;“同一主机三天内”这种规则属于关联层,而不是 DPI 引擎。
  • 多个独立信号胜过一个聪明信号。 哈希命中 + 签名 + 杀毒判定,远比单个模型的高分可信。设计检测器时,要让它们”意见一致”这件事本身有意义。
  • 在边缘丢,不在中间堵。 过载时宁可在引擎边界丢掉元数据,也不要反压到包处理路径。同时要让每一次丢弃都在监控里看得见。
  • 数据量在元数据,不在告警。 流记录和协议日志比告警大 10 到 100 倍。保留策略、索引设计和磁盘规划都由元数据决定。
  • 组件多就必须讲版本纪律。 几十个包(引擎、规则、模型、Web、库表结构)必须一起演进。版本清单和经过验证的回滚路径不是可选项(见第 14 篇)。
  • 无人值守的设备必须能自愈。 进程守护、资源指标和自动重启,能把凌晨三点的崩溃变成日志里的一行记录(见第 15 篇)。

下一篇

上面的一切都建立在底层不丢包的前提上。下一篇我们下到网卡这一层,看看 PF_RING ZC、按流哈希和 CPU 绑核是怎样跟上 10 Gbps 的。

全系列

  1. 全景:一套网络威胁检测平台
  2. 万兆流量采集
  3. Suricata 深度包检测与规则管理
  4. Zeek 协议分析
  5. Flume + Esper 事件管道
  6. 威胁情报匹配与知识库
  7. 规则驱动的异常检测
  8. 机器学习检测
  9. 告警关联、降噪与聚合
  10. 动态沙箱
  11. 多引擎杀毒
  12. 管理平台
  13. 轻量级探针
  14. 部署、版本与升级回滚
  15. 运维监控与自愈

Comments

  1. Loading comments…

Leave a comment

Plain text; links are fine. Comments with many links wait for review.