0x00 前言
QNSM(IQIYI Network Security Monitor)是爱奇艺开源的一个旁路部署的全流量、实时、高性能网络安全监控引擎,基于 DPDK 开发,集成了 DDoS 检测和 IDPS 模块。本文基于 QNSM 源码进行深度剖析,涵盖核心架构、数据包处理流水线、协议解析、DFI/DPI 机制、TCP 连接跟踪、策略下发等核心模块
DDoS 检测
DDoS 检测功能包括:
- 全流量检测,可以部署在 IDC 环境,支持 SYN,ACK,RST,FIN,SYNACK,ICMP,UDP FLOOD 以及反射攻击(DNS/NTP/SSDP 反射等)
- 实时多维度聚合数据
- 流采样数据,提供攻击事件未检出后的 fall back 机制
- 随时停启的聚合数据输出
- 数据以 json 格式输出,便于数据分析
- 针对 UDP 反射攻击,提供 DFI/DPI 机制(MEMCACHE,TFTP,CHARGEN,CLDAP,QOTD 等)
- 事件过程中 dump 攻击数据包
- 支持 IPv4 和 IPv6
IDPS
IDPS 模块基于Suricata,并新增了如下特性:
- 支持 lib 化编译安装,基于 Suricata 4.1.0 版本
- 支持事件以 Kafka 方式输出,提升事件吞吐量,便于进一步数据分析
后文介绍 QNSM 是如何与 suricata 进行配合的
0x01 项目架构总览与核心模块拆解
QNSM 采用 DPDK 流水线(Pipeline)架构,将不同功能分解为独立的组件,每个组件运行在独立的 CPU core 上,通过无锁消息机制进行跨 CPU 通信。整体分为基础模块、流水线模块、控制面和 IDPS 管理服务四大部分
组件定义
所有组件通过宏定义注册,在app.h中统一管理:
#define APP_MAP(XX) \
XX(EN_QNSM_SESSM, "SESSM") \
XX(EN_QNSM_SIP_AGG, "SIP_IN_AGG") \
XX(EN_QNSM_VIP_AGG, "VIP_AGG") \
XX(EN_QNSM_EDGE, "EDGE") \
XX(EN_QNSM_MASTER, "MASTER") \
XX(EN_QNSM_DETECT, "DETECT") \
XX(EN_QNSM_DUMP, "DUMP") \
XX(EN_QNSM_TEST, "TEST") \
XX(EN_QNSM_DUMMY, "DUMMY")
todo
基础模块
1. PORT(端口抽象)
QNSM 将网卡队列(RXQ)和软件队列(SWQ)统一抽象为PORT。在配置文件qnsm_inspect.cfg中,RXQ和SWQ前缀的配置实际上都是 PORT。核心 API 包括:
qnsm_port_rx:从 PORT 收包qnsm_port_tx_lb:按 hash 负载均衡发包qnsm_port_dup_tx_lb:向 duplicate 端口发包(用于 IDPS 分流)qnsm_port_dump_tx:向 DUMP 组件发包
2. MSG(跨 CPU 无锁消息)
基于 DPDK 提供的无锁rte_ring库封装的消息机制,支持一对一和一对多消息通信。主要用途:
- 控制面和转发面间的控制消息传输
- DDoS 检测多维聚合数据输出
核心 API:
int32_t qnsm_msg_publish(void); // 发布消息服务
int32_t qnsm_msg_subscribe(uint32_t target_lcore_id); // 订阅目标 lcore
int32_t qnsm_msg_reg(EN_QNSM_MSG_ID msg_id, // 注册消息回调
QNSM_MSG_PROC msg_proc, QNSM_MSG_ENCAP msg_encap);
int32_t qnsm_msg_send_multi(EN_QNSM_APP app_type, // 一对多发送
EN_QNSM_MSG_ID msg_id, void *data, uint16_t sync);
int32_t qnsm_msg_send_lb(EN_QNSM_APP app_type, // 负载均衡发送
EN_QNSM_MSG_ID msg_id, void *data, uint32_t seed, uint16_t sync);
3. 配置文件
QNSM 使用多个配置文件协同工作:
qnsm_inspect.cfg:流水线配置,定义 EAL 参数、内存池、网卡、各组件的 CPU 绑定和端口关系qnsm_sessm.xml:DPI 协议启用/禁用配置qnsm_edge.xml:Kafka broker 配置、IDC 名称、日志配置、dump 目录qnsm_vip.xml:VIP 分组和静态 VIP 列表
4. 表项管理(TBL)
基于 DPDK hash 表实现的会话表管理,核心特性:
- 使用 CRC32 硬件加速的 hash 计算(
rte_hash_crc) - 每个 lcore 独立的 hash 表,避免竞争
- 通过 mempool 实现表项的快速分配和回收
5. 调度框架
QNSM 提供统一调度框架qnsm_service_run,核心循环如下:
static void qnsm_service_run(QNSM_DATA *data, struct app_pipeline_params *pipeline_params)
{
while (1) {
// 1. 从所有 rx port 收包
for (port_id = 0; port_id < port_handle->rx_port_cnt; port_id++) {
nb_pkts = qnsm_port_rx(port_handle, port_id, mbuf);
// 2. ACL 过滤
if (load_acl) qnsm_acl_run(acl_hdl, mbuf, nb_pkts);
// 3. 逐包处理
for (index = 0; index < nb_pkts; index++) {
if (pkt_proc) pkt_proc(data->app_handle, lcore, mbuf[index]);
if (action) action(mbuf[index]);
}
}
// 4. 自定义 run 回调
if (run) run(data->app_handle);
// 5. 消息分发 + 定时器
qnsm_msg_dispatch(msg_hdl);
rte_timer_manage();
// 6. 批量 flush 发包
QNSM_PORT_TX_FLUSH(port_handle);
}
}
流水线模块
todo
SESSM(会话管理/DDoS 检测核心)
核心组件,运行qnsm_rx_proc包处理函数,负责:
- IPv4/IPv6数据包解析
- 五元组会话查找/创建
- 采样 FLOW 数据聚合
- TCP 连接跟踪
- 应用层 DFI/DPI 分类
- 向 VIP_AGG 和 SIP_AGG 发送聚合数据
SIP_AGG(攻击源 IP 聚合)
接收 SESSM 发送的五元组聚合数据,按攻击源 IP 维度聚合,关联 VIP 列表,输出 TCP/UDP 的 pps 和 bps 数据到 EDGE。
VIP_AGG(VIP 数据聚合)
核心数据聚合组件,功能包括:
- VIP 自学习(动态发现新 VIP)
- 按攻击类型(SYN/ACK/RST/FIN/SYNACK/UDP/ICMP/DNS 等)和方向(in/out)的 pps/bps 聚合
- TopN 源端口/目的端口统计(基于最小堆实现)
- 通过定时器周期性输出聚合数据
DUMP(数据包抓取)
接收 SESSM 标记了need_dump的数据包,使用 pcap 库保存为 pcap 文件。文件按分钟轮转,文件名格式为{VIP}-core{N}-{YYYYMMDD}-{HHMM}.pcap。
EDGE(Kafka 数据输出)
类似 broker 的角色,接收各组件通过 MSG 发送的聚合数据,格式化为 JSON 后发送到对应的 Kafka topic:
qnsm_vip_agg:VIP 聚合数据qnsm_sip_agg:攻击源聚合qnsm_sample_flow:流采样数据qnsm_vip_sport/qnsm_vip_dport:端口统计- 各协议 DPI topic(NTP/DNS/SSDP 等)
DETECT(IDPS 检测)
基于 Suricata lib 的 IDPS 检测组件,通过 DPDK 收包后构造 Suricata Packet 结构进行规则匹配,事件输出到nsm_event Kafka topic。
控制面
Master
Master 组件运行在独立 lcore 上,主要职责:
- 消费
qnsm_commandKafka topic 接收分析中心下发的策略 - 解析 JSON 命令(cJSON 库)
- 通过 MSG 机制将策略下发到转发面各组件(SESSM/DUMP/VIP_AGG)
- VIP 配置同步和动态 VIP 管理
IDPS 管理服务
- FM/FR(CRM):基于
rte_eal_alarm实现的跨线程资源管理和回收机制 - CS:IDPS 统计数据收集
0x02 数据包解析路径与告警机制
数据包解析路径
从网卡收包到完成解析的完整流程如下:
flowchart TD
NIC["NIC RXQ (RSS)"] --> SESSM["SESSM: qnsm_rx_proc"]
SESSM --> ParsePtype["qnsm_parse_ptype\nrte_net_get_ptype"]
ParsePtype --> HasTunnel{有隧道?}
HasTunnel -->|否| DirectL3["直接解析L3\n提取src/dst IP"]
HasTunnel -->|是| TunnelL3["跳过隧道头\n解析内层L3"]
DirectL3 --> L3Type{L3类型}
TunnelL3 --> L3Type
L3Type -->|IPv4| FillV4["填充 pkt_info\naf=IPv4\nsrc_addr/dst_addr"]
L3Type -->|IPv6| FillV6["填充 pkt_info\naf=IPv6\n处理扩展头"]
FillV4 --> L4Parse["L4端口解析\nsport/dport"]
FillV6 --> L4Parse
L4Parse --> DireCheck["qnsm_inet_get_pkt_dire\n判断数据包方向\n匹配VIP"]
DireCheck --> SampleCheck{"流采样检查\nRSS hash % sample_rate"}
SampleCheck -->|采样命中| SessProc["qnsm_sess_proc\n会话处理"]
SampleCheck -->|未命中| VIPAgg["仅VIP聚合统计"]
SessProc --> FindSess["qnsm_sess_find\nhash表查找五元组"]
FindSess --> SessExist{会话存在?}
SessExist -->|否| AddSess["qnsm_sess_add\n创建新会话\n启动agg/aging定时器"]
SessExist -->|是| UpdateSess["更新会话统计\npkt_curr++\nbit_curr+="]
AddSess --> ProtoSwitch["按协议分发处理"]
UpdateSess --> ProtoSwitch
ProtoSwitch -->|TCP| TCPProc["tcp_conn_proc\nTCP状态机"]
ProtoSwitch -->|UDP| UDPProc["DPI匹配\nqnsm_dpi_match"]
ProtoSwitch -->|ICMP| ICMPProc["记录icmp_type"]
TCPProc --> TX["qnsm_port_tx_lb\n转发到下游"]
UDPProc --> TX
ICMPProc --> TX
TX --> DumpCheck{"need_dump?"}
DumpCheck -->|是| DumpTX["qnsm_port_dump_tx\n发送到DUMP组件"]
DumpCheck -->|否| Done["完成"]
DumpTX --> Done
数据聚合流程
QNSM 的多维度数据聚合流程如下:
flowchart LR
subgraph SESSM_Core ["SESSM (每CPU独立)"]
PKT["数据包处理"] --> SessAgg["会话定时聚合\nqnsm_sess_agg\n周期计算pps/bps"]
PKT --> VIPStatis["VIP流量统计\n按攻击类型分类"]
end
subgraph SIP_AGG_Core ["SIP_AGG"]
SIPRecv["接收五元组聚合"] --> SIPHash["按源IP hash聚合"] --> SIPOutput["源IP+VIP列表\nTCP/UDP pps/bps"]
end
subgraph VIP_AGG_Core ["VIP_AGG"]
VIPRecv["接收VIP统计"] --> VIPHash["按VIP hash聚合"] --> TypeAgg["按类型聚合\nSYN/ACK/RST/FIN\nUDP/ICMP/DNS等"]
TypeAgg --> TopN["TopN端口统计\n最小堆排序"]
TypeAgg --> AggOutput["VIP维度输出\n多类型pps/bps"]
end
subgraph EDGE_Core ["EDGE"]
EdgeRecv["接收聚合消息"] --> JSON["cJSON格式化"] --> Kafka["Kafka输出"]
Kafka --> T1["qnsm_vip_agg"]
Kafka --> T2["qnsm_sip_agg"]
Kafka --> T3["qnsm_sample_flow"]
Kafka --> T4["qnsm_vip_sport\nqnsm_vip_dport"]
end
SessAgg -->|MSG: QNSM_MSG_SESS_AGG| SIPRecv
SessAgg -->|MSG: QNSM_MSG_SESS_AGG| EdgeRecv
VIPStatis -->|MSG: QNSM_MSG_SVR_IP_AGG| EdgeRecv
SIPOutput -->|MSG: QNSM_MSG_CUSTOM_IP_AGG| EdgeRecv
AggOutput -->|MSG: QNSM_MSG_SVR_IP_AGG| EdgeRecv
TopN -->|MSG: QNSM_MSG_VIP_SRC/DST_PORT_AGG| EdgeRecv
其中 VIP 聚合的数据维度非常丰富,包含以下类型的 pps 和 bps 统计:
| 类型 | 说明 |
|---|---|
| TOTAL | 总流量 |
| TCP | TCP 总流量 |
| SYN | SYN 包 |
| ACK | ACK 包 |
| FIN | FIN 包 |
| RST | RST 包 |
| SYNACK | SYN+ACK 包 |
| PSHACK | PSH+ACK 包 |
| OTHER_FLAG | 其他 TCP 标志 |
| UDP | UDP 总流量 |
| DNS_QUERY/DNS_REPLY | DNS 查询/响应 |
| NTP | NTP 流量 |
| SSDP_REP | SSDP 响应 |
| ICMP | ICMP 流量 |
告警策略应用流程
QNSM 本身不做告警判定,而是输出聚合数据由外部分析中心进行检测,再通过策略消息反馈控制 QNSM 的行为:
sequenceDiagram
participant AC as 分析中心
participant KafkaCmd as Kafka: qnsm_command
participant Master as QNSM Master
participant SESSM as SESSM
participant VIP_AGG as VIP_AGG
participant DUMP as DUMP
Note over AC: 消费qnsm_vip_agg检测异常
AC->>KafkaCmd: 下发策略JSON<br/>ip_dump_pkt_enable
Master->>KafkaCmd: 消费策略消息
Master->>Master: cJSON解析命令
Master->>SESSM: MSG: QNSM_MSG_SYN_BIZ_VIP<br/>标记VIP的need_dump
Master->>DUMP: MSG: QNSM_MSG_SYN_BIZ_VIP<br/>启用VIP的dump
Master->>VIP_AGG: MSG: QNSM_MSG_SYN_BIZ_VIP<br/>启用SIP聚合输出
Note over AC: 下发DFI检测策略
AC->>KafkaCmd: ddos_type_check<br/>(vip + sport)
Master->>KafkaCmd: 消费DFI策略
Master->>SESSM: MSG: 启用指定sport的DPI检测
SESSM->>SESSM: 对匹配流量执行DPI分析
SESSM-->>AC: 通过EDGE输出DPI结果<br/>到qnsm_command_ack
Note over AC: 攻击事件结束
AC->>KafkaCmd: ip_dump_pkt_disable
Master->>DUMP: 停止dump
Master->>VIP_AGG: 停止SIP聚合输出
支持的策略类型包括:
ip_dump_pkt_enable/ip_dump_pkt_disable:启停攻击包抓取ip_sport_statis_enable/ip_sport_statis_disable:启停源端口统计ddos_type_check:DFI/DPI 检测(识别 UDP 反射攻击的应用层协议)
0x03 协议解析实现
QNSM 在qnsm_decode.c中实现了完整的协议栈解析,支持从链路层到传输层的递归解析。SESSM 组件优先使用 DPDK 的rte_net_get_ptype硬件辅助解析,当存在隧道时回退到软件解析。
Ethernet 解析
qnsm_decode_ethernet是解析入口,根据eth_type字段分发:
int qnsm_decode_ethernet(QNSM_PACKET_INFO *pkt_info, uint8_t *pkt, uint16_t len)
{
EthernetHdr *ethh = (EthernetHdr *)pkt;
switch (ntohs(ethh->eth_type)) {
case ETHERNET_TYPE_IP: // 0x0800
qnsm_decode_ipv4(pkt_info, pkt + ETHERNET_HEADER_LEN, len - ETHERNET_HEADER_LEN);
break;
case ETHERNET_TYPE_IPV6: // 0x86dd
qnsm_decode_ipv6(pkt_info, pkt + ETHERNET_HEADER_LEN, len - ETHERNET_HEADER_LEN);
break;
case ETHERNET_TYPE_8021Q: // 0x8100 VLAN
qnsm_decode_vlan(pkt_info, pkt + ETHERNET_HEADER_LEN, len - ETHERNET_HEADER_LEN);
break;
case ETHERNET_TYPE_8021QINQ: // 0x9100 QinQ
qnsm_decode_qinq(pkt_info, pkt + ETHERNET_HEADER_LEN, len - ETHERNET_HEADER_LEN);
break;
case ETHERNET_TYPE_MPLS_UNICAST: // 0x8847
case ETHERNET_TYPE_MPLS_MULTICAST: // 0x8848
qnsm_decode_mpls(pkt_info, pkt + ETHERNET_HEADER_LEN, len - ETHERNET_HEADER_LEN);
break;
}
return QNSM_DECODE_OK;
}
IPv4 解析
DecodeIPV4Packet完成 IPv4 头的校验和信息提取,包括分片检测和上层协议分发:
int qnsm_decode_ipv4(QNSM_PACKET_INFO *pkt_info, uint8_t *pkt, uint16_t len)
{
IPV4Hdr *ip4h = (IPV4Hdr *)pkt;
if (unlikely(DecodeIPV4Packet(pkt_info, pkt, len) < 0))
return QNSM_DECODE_FAILED;
pkt_info->proto = IPV4_GET_IPPROTO(ip4h);
// 分片检测:offset > 0 或 MF 标志位为 1
if (unlikely(IPV4_GET_IPOFFSET(ip4h) > 0 || IPV4_GET_MF(ip4h) == 1)) {
pkt_info->is_frag = 1;
return QNSM_DECODE_OK; // 分片包不做 L4 解析
}
// 按协议分发到 L4 解码器
switch (IPV4_GET_IPPROTO(ip4h)) {
case IPPROTO_TCP: qnsm_decode_tcp(...); break;
case IPPROTO_UDP: qnsm_decode_udp(...); break;
case IPPROTO_ICMP: qnsm_decode_icmpv4(...); break;
case IPPROTO_GRE: qnsm_decode_gre(...); break;
}
return QNSM_DECODE_OK;
}
IPv6 解析
IPv6 解析需要特别处理扩展头链,通过qnsm_skip_ip6_ext跳过扩展头到达上层协议:
static uint16_t qnsm_skip_ip6_ext(uint16_t proto, const struct rte_mbuf *m,
uint32_t *off, int *frag)
{
*frag = 0;
for (i = 0; i < MAX_EXT_HDRS; i++) {
switch (proto) {
case IPPROTO_HOPOPTS:
case IPPROTO_ROUTING:
case IPPROTO_DSTOPTS:
// 按 (len+1)*8 跳过扩展头
*off += (xh->len + 1) * 8;
proto = xh->next_hdr;
break;
case IPPROTO_FRAGMENT:
*off += 8;
proto = xh->next_hdr;
*frag = 1; // 标记为分片
return proto; // Fragment 总是最后一个扩展头
case IPPROTO_NONE:
return 0; // 无下一个头部
default:
return proto; // 到达上层协议
}
}
return 0;
}
TCP/UDP解析
TCP 和 UDP 的解析相对简单,主要完成头部校验和端口/payload 提取:
// TCP 解析核心
static int DecodeTCPPacket(QNSM_PACKET_INFO *pkt_info, uint8_t *pkt, uint16_t len)
{
TCPHdr *tcph = (TCPHdr *)pkt;
uint8_t hlen = TCP_GET_HLEN(tcph); // offset 字段 << 2
if (unlikely(len < hlen)) return -1;
pkt_info->payload = pkt + hlen;
pkt_info->sport = TCP_GET_SRC_PORT(tcph);
pkt_info->dport = TCP_GET_DST_PORT(tcph);
return 0;
}
// UDP 解析核心
static int DecodeUDPPacket(QNSM_PACKET_INFO *pkt_info, uint8_t *pkt, uint16_t len)
{
UDPHdr *udph = (UDPHdr *)pkt;
if (unlikely(len < UDP_GET_LEN(udph))) return -1;
pkt_info->sport = UDP_GET_SRC_PORT(udph);
pkt_info->dport = UDP_GET_DST_PORT(udph);
pkt_info->payload = pkt + UDP_HEADER_LEN;
return 0;
}
GRE 隧道解析
GRE 隧道解析支持 Version 0 和 Version 1,解析完 GRE 头后递归调用内层协议解析:
int qnsm_decode_gre(QNSM_PACKET_INFO *pkt_info, uint8_t *pkt, uint16_t len)
{
GREHdr *greh = (GREHdr *)pkt;
uint16_t header_len = GRE_HDR_LEN; // 基础头 4 字节
// 根据 flag 调整 header_len
if (GRE_FLAG_ISSET_KY(greh)) header_len += GRE_KEY_LEN;
if (GRE_FLAG_ISSET_SQ(greh)) header_len += GRE_SEQ_LEN;
if (GRE_FLAG_ISSET_CHKSUM(greh)) header_len += GRE_CHKSUM_LEN + GRE_OFFSET_LEN;
// 内层协议递归解析
switch (GRE_GET_PROTO(greh)) {
case ETHERNET_TYPE_IP: qnsm_decode_ipv4(...); break;
case ETHERNET_TYPE_IPV6: qnsm_decode_ipv6(...); break;
case ETHERNET_TYPE_8021Q: qnsm_decode_vlan(...); break;
case ETHERNET_TYPE_BRIDGE: qnsm_decode_ethernet(...); break;
}
}
MPLS 解析
MPLS 解析遍历标签栈,通过 Bottom of Stack 标志位找到内层协议,然后根据特殊标签或首字节猜测内层协议类型:
int qnsm_decode_mpls(QNSM_PACKET_INFO *pkt_info, uint8_t *pkt, uint16_t len)
{
uint32_t shim;
// 遍历标签栈直到 Bottom of Stack
do {
shim = *(uint32_t *)pkt;
pkt += MPLS_HEADER_LEN;
len -= MPLS_HEADER_LEN;
} while (MPLS_BOTTOM(shim) == 0);
// 根据标签值或首字节猜测内层协议
int label = MPLS_LABEL(shim);
if (label == MPLS_LABEL_IPV4) return qnsm_decode_ipv4(...);
if (label == MPLS_LABEL_IPV6) return qnsm_decode_ipv6(...);
switch (pkt[0] >> 4) { // IP 版本号猜测
case 4: qnsm_decode_ipv4(...); break;
case 6: qnsm_decode_ipv6(...); break;
case 0: qnsm_decode_ethernet(pkt + MPLS_PW_LEN, ...); break;
}
}
0x04 UDP 反射攻击 DFI/DPI 机制
DFI/DPI框架设计
QNSM 在libqnsm_service/qnsm_dpi.c中实现了轻量级的 DFI/DPI 框架,用于识别 UDP 反射攻击的应用层协议。框架提供两种分类方法:
端口分类(Service Classify):按 L4 协议 + 端口注册回调,数据结构为service_classifer[l4_prot][port]链表。
内容分类(Content Classify):按 payload 前两字节注册回调,数据结构为udp_content_classifer[byte0][byte1]链表。
DFI 匹配核心函数qnsm_dpi_match的优先级为:先查 dport -> 再查 sport -> 最后查 content:
inline int32_t qnsm_dpi_match(QNSM_PACKET_INFO *pkt_info,
EN_QNSM_DPI_L4_PROT l4_prot, void *sess, void **app_arg)
{
// 1. 按目的端口匹配
port = pkt_info->dport;
classifier_list = &dpi->classify.service_classifer[l4_prot][port];
qnsm_list_for_each_entry_safe(dpi_class, next, classifier_list, class_node) {
if (dpi_class->match_func) { dpi_class->match_func(pkt_info, sess, &arg); goto MATCH; }
}
// 2. 按源端口匹配(响应包场景)
port = pkt_info->sport;
classifier_list = &dpi->classify.service_classifer[l4_prot][port];
// ...同上
// 3. 按 payload 内容匹配
data = (uint8_t *)pkt_info->payload;
classifier_list = &dpi->classify.udp_content_classifer[data[0]][data[1]];
qnsm_list_for_each_entry_safe(dpi_class, next, classifier_list, class_node) {
if (0 == memcmp(data, dpi_class->match_content_key, dpi_class->match_content_key_len)) {
dpi_class->match_func(pkt_info, sess, &arg);
goto MATCH;
}
}
}
协议注册流程
每个协议模块在 SESSM 初始化时注册自己的分类和解析回调。以 NTP 为例:
int32_t ntp_reg(void)
{
if (0 == qnsm_dpi_proto_enable(EN_QNSM_DPI_NTP)) return 0;
// 注册端口分类:UDP port 123 -> ntp_classify
qnsm_dpi_service_classify_reg(EN_DPI_PROT_UDP, NTP_PORT, EN_QNSM_DPI_NTP, ntp_classify);
// 注册 DPI 数据初始化函数
qnsm_dpi_proto_init_reg(EN_QNSM_DPI_NTP, ntp_info_init);
// 注册 DPI 解析函数(优先级 10)
qnsm_dpi_prot_reg(EN_QNSM_DPI_NTP, ntp_parse, 10);
// 注册资源释放函数
qnsm_dpi_prot_final_reg(EN_QNSM_DPI_NTP, ntp_free);
return 0;
}
各反射协议分析
DNS(端口 53)
DNS 协议解析是最复杂的,完整解析 DNS 头部、Question 段和 Resource Record:
- 通过 QR 标志位区分 query(QR=0)和 response(QR=1)
- 解析 QDCOUNT/ANCOUNT/NSCOUNT/ARCOUNT 确定各段数量
- DNS 反射攻击的典型特征是大量 response 包(放大比可达 50 倍以上)
NTP(端口 123)
NTP 反射识别通过解析版本字段实现:
void ntp_classify(QNSM_PACKET_INFO *pkt_info, void *sess, void **arg)
{
ntp_info->ntp_header = pkt_info->payload;
// NTP 版本字段在第一字节的 bit3-5: (header[0] & 0x38) >> 3
// NTP v2 的 monlist 请求会产生大量响应(放大比约 556 倍)
if ((((ntp_info->ntp_header[0] & 0x38) >> 3) <= 4)) {
pkt_info->dpi_app_prot = EN_QNSM_DPI_NTP;
}
}
SSDP(端口 1900)
SSDP 协议通过匹配请求方法字符串识别:
void ssdp_classify(QNSM_PACKET_INFO *pkt_info, void *sess, void **arg)
{
pkt_info->dpi_app_prot = EN_QNSM_DPI_SSDP;
}
// 注册时同时注册端口分类和内容分类
int32_t ssdp_reg(void)
{
// 端口分类
qnsm_dpi_service_classify_reg(EN_DPI_PROT_UDP, SSDP_PORT, EN_QNSM_DPI_SSDP, ssdp_classify);
// 内容分类:匹配"M-SEARCH"/"NOTIFY"/"HTTP"等 method 前缀
for (i = 0; method_strings[i]; i++) {
qnsm_dpi_content_classify_reg(EN_DPI_PROT_UDP, method_strings[i],
strlen(method_strings[i]), EN_QNSM_DPI_SSDP, ssdp_classify);
}
qnsm_dpi_content_classify_reg(EN_DPI_PROT_UDP, "HTTP", 4, EN_QNSM_DPI_SSDP, ssdp_classify);
}
SSDP 解析时区分请求和响应:以”HTTP”开头为响应,匹配 M-SEARCH/NOTIFY 等为请求。
Memcached(端口 11211)
Memcached UDP 协议通过验证 8 字节 UDP 报头结构识别:
static void memcached_udp_classify(QNSM_PACKET_INFO *pkt_info, void *sess, void **arg)
{
// UDP memcached 有 8 字节报头:req_id(2) + seq(2) + total_num(2) + rsvd(2)
MEMCACHED_UDP_HEADER *header = (MEMCACHED_UDP_HEADER *)(pkt_info->payload);
uint16_t len = QNSM_DPI_NTOHS(uh->dgram_len) - sizeof(struct udp_hdr);
// 校验:长度够且 total_num > 0
if ((len < sizeof(MEMCACHED_UDP_HEADER))
|| (0 >= QNSM_DPI_NTOHS(header->total_num))) {
return; // 不是 UDP memcached 包
}
pkt_info->dpi_app_prot = EN_QNSM_DPI_MEMCACHED;
}
注意 memcached 的 TCP classify 函数体为空,注释说明 TCP 需要流重组才能匹配命令,但流重组功能当前关闭。
CHARGEN(端口 19)
CHARGEN 协议按 RFC 864 规范,响应包由可打印 ASCII 字符组成,通过字符范围检查识别:
static void chargen_udp_classify(QNSM_PACKET_INFO *pkt_info, void *sess, void **arg)
{
char *payload = pkt_info->payload;
// RFC 864 推荐的 payload 是 72 个 ASCII 字符的移位行
// 检查首字节在可打印范围 [0x20, 0x7d]
if ((0 < len) && ((payload[0] < 0x20) || (0x7d < payload[0]))) {
return;
}
pkt_info->dpi_app_prot = EN_QNSM_DPI_CHARGEN;
}
其他反射协议
| 协议 | 端口 | 识别方式 | 放大倍数 |
|---|---|---|---|
| CLDAP | 389 | ASN.1 BER 编码检查 | 56-70x |
| QOTD | 17 | 端口匹配 | 140x |
| TFTP | 69 | opcode 字段检查 | 60x |
| SNMP | 161 | 端口匹配 | 6x |
DPI 结果输出
当 DPI 匹配成功后,协议解析结果通过 MSG 发送到 EDGE 组件,EDGE 格式化为 JSON 后发送到对应的 Kafka topic。以 NTP 为例:
// SESSM 侧发送
qnsm_dpi_send_info(pkt_info, EN_QNSM_DPI_NTP, arg);
// EDGE 侧接收并构造 JSON
void ntp_msg_proc(void *data, uint32_t data_len) {
cJSON *root = cJSON_CreateObject();
cJSON_AddStringToObject(root, "sip", tmp);
cJSON_AddStringToObject(root, "dip", tmp);
cJSON_AddNumberToObject(root, "sport", tuple->source);
cJSON_AddNumberToObject(root, "dport", tuple->dest);
cJSON_AddNumberToObject(root, "version", version);
qnsm_kafka_send_msg(QNSM_KAFKA_NTP_TOPIC, root, ...);
}
0x05 TCP 连接跟踪与流重组
TCP 状态机
QNSM 在tcp_session.c中实现了 TCP 连接跟踪,维护 active(主动发起方)和 passive(被动接收方)两个 half_stream 的状态:
todo
typedef struct half_stream {
char state;
u_int seq;
u_int list_count;
struct skbuff *list;
} HALF_STRAEM;
typedef struct tcp_stream {
uint8_t af;
QNSM_SESS_ADDR addr;
HALF_STRAEM active;
HALF_STRAEM passive;
uint8_t established;
} TCP_STREAM;
TCP 状态定义:
#define QNSM_TCP_STATE_MAP(XX) \
XX(1, ESTABLISHED, ESTABLISHED) \
XX(2, SYN_SENT, SYN_SENT) \
XX(3, SYN_RECV, SYN_RECV) \
XX(4, FIN_WAIT1, FIN_WAIT1) \
XX(5, FIN_WAIT2, FIN_WAIT2) \
XX(6, TIME_WAIT, TIME_WAIT) \
XX(7, CLOSE, CLOSE) \
XX(8, CLOSE_WAIT, CLOSE_WAIT) \
XX(9, LAST_ACK, LAST_ACK) \
XX(10, LISTEN, LISTEN) \
XX(11, CLOSING, CLOSING) \
XX(12, FIN_SENT, FIN_SENT) \
XX(13, FIN_CONFIRMED, FIN_CONFIRMED)
TCP 连接跟踪状态机
核心函数tcp_conn_proc实现了完整的三次握手和四次挥手状态跟踪:
stateDiagram-v2
[*] --> CLOSE: 初始状态
state ActiveSide {
CLOSE --> SYN_SENT: 收到SYN包<br/>记录seq+1
SYN_SENT --> ESTABLISHED: 收到ACK<br/>ack==passive.seq
ESTABLISHED --> FIN_SENT: 发送FIN
FIN_SENT --> FIN_CONFIRMED: 对端ACK
}
state PassiveSide {
CLOSE2: CLOSE
CLOSE2 --> SYN_RECV: 收到SYN+ACK<br/>记录seq+1
SYN_RECV --> ESTABLISHED2: active发ACK
ESTABLISHED2: ESTABLISHED
ESTABLISHED2 --> FIN_SENT2: 发送FIN
FIN_SENT2: FIN_SENT
FIN_SENT2 --> FIN_CONFIRMED2: 对端ACK
FIN_CONFIRMED2: FIN_CONFIRMED
}
FIN_CONFIRMED --> [*]: 双方都FIN_CONFIRMED<br/>释放连接
FIN_CONFIRMED2 --> [*]: 双方都FIN_CONFIRMED<br/>释放连接
note right of ActiveSide: RST包直接置为FIN_CONFIRMED
核心状态转换代码:
int32_t tcp_conn_proc(QNSM_PACKET_INFO* pkt_info, void *sess, uint32_t *tcp_seq)
{
tcp_conn = session->tcp_stream;
if (NULL == tcp_conn) {
// 新连接:只接受纯 SYN 包
if ((this_tcphdr->tcp_flags & TH_SYN) &&
!(this_tcphdr->tcp_flags & (TH_ACK | TH_RST | TH_FIN))) {
// 从 mempool 分配 TCP_STREAM
rte_mempool_get(cache->tcp_conn_cache, (void **)&tcp_conn);
tcp_conn->active.state = QNSM_TCP_SYN_SENT;
tcp_conn->active.seq = seq + 1;
}
goto EXIT;
}
// SYN+ACK 处理(passive 回复)
if ((this_tcphdr->tcp_flags & TH_SYN)) {
if (tcp_conn->active.state == QNSM_TCP_SYN_SENT &&
tcp_conn->passive.state == QNSM_TCP_CLOSE &&
(this_tcphdr->tcp_flags & TH_ACK)) {
if (tcp_conn->active.seq == recv_ack) {
tcp_conn->passive.state = QNSM_TCP_SYN_RECV;
tcp_conn->passive.seq = seq + 1;
}
}
}
// RST 处理
if ((this_tcphdr->tcp_flags & TH_RST)) {
if (from_active) tcp_conn->active.state = QNSM_TCP_FIN_CONFIRMED;
else tcp_conn->passive.state = QNSM_TCP_FIN_CONFIRMED;
}
// 三次握手完成
if (from_active && (this_tcphdr->tcp_flags & TH_ACK)) {
if (tcp_conn->active.state == QNSM_TCP_SYN_SENT &&
tcp_conn->passive.state == QNSM_TCP_SYN_RECV) {
if (recv_ack == tcp_conn->passive.seq) {
tcp_conn->active.state = QNSM_TCP_ESTABLISHED;
tcp_conn->passive.state = QNSM_TCP_ESTABLISHED;
}
}
}
// FIN 处理
if (this_tcphdr->tcp_flags & TH_FIN) {
if (from_active) tcp_conn->active.state = QNSM_TCP_FIN_SENT;
else tcp_conn->passive.state = QNSM_TCP_FIN_SENT;
}
// 双方都 FIN_CONFIRMED 则释放连接
if (tcp_conn->passive.state == QNSM_TCP_FIN_CONFIRMED &&
tcp_conn->active.state == QNSM_TCP_FIN_CONFIRMED) {
tcp_free_stream(&tcp_conn);
}
}
TCP 流重组(条件编译 __QNSM_STREAM_REASSEMBLE)
QNSM 实现了 TCP 流重组功能,但通过宏__QNSM_STREAM_REASSEMBLE控制开关。在 DDoS 检测(__DDOS宏)模式下,如果同时未开启__QNSM_STREAM_REASSEMBLE,TCP 只做 flag 统计不做流重组。
流重组的数据结构:
typedef struct {
struct qnsm_list_head node;
QNSM_PACKET_INFO *pkt_info;
uint32_t seq;
uint32_t ack;
uint16_t len;
uint16_t dir;
} TCP_DATA;
typedef struct {
struct qnsm_list_head tcp_que; // 有序队列
uint32_t data_cnt; // 缓存包数
uint32_t tcp_seq[2]; // 双方期望的下一个 seq
} QNSM_TCP_DATA_QUE;
流重组流程(当__QNSM_STREAM_REASSEMBLE开启时):
flowchart TD
PKT["TCP数据包"] --> ConnProc["tcp_conn_proc\n状态机处理"]
ConnProc --> DPIMatch{"首包DPI匹配?\napp_proto == MAX"}
DPIMatch -->|是| Match["qnsm_dpi_match\n识别应用协议"]
DPIMatch -->|否| Skip["已识别,跳过"]
Match --> DataProc["tcp_data_proc\n插入有序队列"]
Skip --> DataProc
DataProc --> CheckQue{"队列长度 > 8?"}
CheckQue -->|是| FlushQue["清空队列\n防止内存溢出"]
CheckQue -->|否| SortInsert["按seq有序插入\n处理乱序/重复"]
SortInsert --> Deliver["遍历队列\n按序交付"]
Deliver --> SeqCheck{"tcp_seq[dir] >= data.seq\n且在范围内?"}
SeqCheck -->|是| DPICbk["qnsm_dpi_prot_cbk\n协议解析回调"]
SeqCheck -->|否| Wait["等待后续包"]
DPICbk --> UpdateSeq["更新tcp_seq[dir]\n释放已处理包"]
tcp_data_proc实现了按 seq 有序插入的逻辑,处理乱序、重复和重传包:
int32_t tcp_data_proc(QNSM_PACKET_INFO* pkt_info, QNSM_TCP_DATA_QUE *que,
uint32_t dir, uint32_t payload_len)
{
if (payload_len <= 0) return -1;
if (que->data_cnt > 8) {
// 队列过长,清空防止内存溢出
qnsm_list_for_each_entry_safe(tmp, n, &que->tcp_que, node) {
rte_pktmbuf_free(...);
tcp_free_data(tmp);
}
que->data_cnt = 0;
return -1;
}
// 从 mempool 分配 TCP_DATA 节点
rte_mempool_get(cache->pkt_info_cache, (void **)&cur_tcp_data);
cur_tcp_data->seq = seq; cur_tcp_data->ack = ack;
cur_tcp_data->len = payload_len; cur_tcp_data->dir = dir;
// 按 seq 有序插入(逆向遍历找到插入位置)
qnsm_list_for_each_prev_entry(tmp, &que->tcp_que, node) {
diff = packet_sequence_diff(sort2, sort1);
if (0 < diff) {
QNSM_LIST_ADD_AFTER(&cur_tcp_data->node, &tmp->node);
break;
}
}
}
重要说明:在当前默认的 DDoS 检测编译配置下,TCP 流重组宏__QNSM_STREAM_REASSEMBLE是关闭的。TCP DDoS 检测主要基于 flag 分类而非流重组:
// DDoS 模式下 TCP 处理(无流重组)
struct tcp_hdr *this_tcphdr = rte_pktmbuf_mtod_offset(...);
sess->tcp_flags[pkt_info->direction] |= this_tcphdr->tcp_flags;
// 后续在 VIP_AGG 中通过 en_tcp_type[tcp_flag] 表进行攻击类型分类
0x06 DUMP 攻击包与流采样
DUMP 实现
DUMP 组件通过qnsm_dump.c实现,核心流程:
1. 策略下发:Master 收到ip_dump_pkt_enable命令后,通过 MSG 通知 DUMP 组件启用目标 VIP 的 dump。
2. 包标记:SESSM 在处理数据包时,如果 VIP 启用了 dump,在pkt_info->need_dump中标记。
3. 包转发:SESSM 通过qnsm_port_dump_tx将标记的包发送到 DUMP 组件的 SWQ。
4. pcap 写入:DUMP 组件收到包后调用qnsm_dump_pkt,使用 libpcap 写入 pcap 文件:
static void qnsm_dump_pkt(QNSM_PACKET_INFO *pkt_info)
{
// 查找 VIP 是否启用 dump
vip_dump = ops->f_find_ip(&pkt_info->src_addr);
if (!vip_dump || !vip_dump->dump_enable) {
vip_dump = ops->f_find_ip(&pkt_info->dst_addr);
if (!vip_dump || !vip_dump->dump_enable) return;
}
// 按分钟轮转文件
time_now = time(NULL);
time_min = time_now / 60;
if ((time_min != vip_dump->dump_time) && vip_dump->dump_fd) {
pcap_dump_close(vip_dump->dump_fd);
vip_dump->dump_fd = NULL;
}
// 创建新文件 格式:{dump_dir}/{VIP}-core{N}-{YYYYMMDD}-{HHMM}.pcap
if (NULL == vip_dump->dump_fd) {
snprintf(filename, ...);
vip_dump->dump_fd = pcap_dump_open(app_data->dump_handle, filename);
}
// 写入 pcap
hdr.len = hdr.caplen = pkt_info->pkt_len;
gettimeofday(&hdr.ts, NULL);
pcap_dump((u_char *)vip_dump->dump_fd, &hdr, rte_pktmbuf_mtod(mbuf, u_char*));
}
5. 性能优化:当没有 VIP 启用 dump 时,DUMP 组件调用usleep释放 CPU。
流采样实现
QNSM 支持两种采样方式,通过配置文件控制:
void qnsm_sess_sample_init(QNSM_SESS_DATA *data)
{
QNSM_SESSM_CFG *sess_cfg = qnsm_get_sessm_conf();
if (sess_cfg->sample_enable) {
switch(sess_cfg->sample_method) {
case EN_QNSM_PACKET_SAMPLE:
data->pkt_sample_rate = sess_cfg->sample_rate;
break;
case EN_QNSM_FLOW_SAMPLE:
data->flow_sample_rate = sess_cfg->sample_rate;
break;
}
}
}
流采样(Flow Sample):利用 RSS hash 值确定采样命中,确保同一流的所有包要么全采样要么全不采样:
// SESSM 收包路径中
if ((1 < app_data->flow_sample_rate) &&
(0 == (uint32_t)(((uint64_t)mbuf->hash.rss * app_data->flow_sample_rate) >> 32))) {
session_enable = 1; // 此流命中采样
}
采样的五元组聚合数据通过 EDGE 输出到qnsm_sample_flow Kafka topic,格式包含 dc、sampling_interval、timestamp、五元组、direction、tcp_flags、packets、bytes。
0x07 DDoS 检测策略下发与无锁高性能设计
策略生效流程
- Master 组件初始化 Kafka consumer,订阅
qnsm_commandtopic - Master 的自定义调度函数周期性调用
qnsm_kafka_msg_dispatch消费消息 - 解析 JSON 命令(使用 cJSON 库),根据
op字段分发处理 - 通过
qnsm_msg_send_multi将策略下发到对应的转发面组件
策略消息格式示例:
{
"op": "ip_dump_pkt_enable",
"content": [
{"idc": "dc_xxx", "proto": "udp", "vip": "A.B.C.D", "vport": "any"}
]
}
{
"id": "1",
"op": "ddos_type_check",
"content": {
"vip": "A.B.C.D",
"idc": "dc_xxx",
"sport": 20
}
}
无锁高性能设计
QNSM 的高性能设计涉及多个层面:
1. 基于rte_ring的无锁跨 CPU 消息
所有组件间通信都通过 DPDK 的rte_ring实现,这是一个无锁的 FIFO 队列,基于 CAS 操作保证线程安全,避免了互斥锁带来的性能损耗。
2. RSS 对称 hash + 流亲和
配置对称 RSS 确保双向流量分到同一 CPU core:
[LINK0]
rss_qs = 0 1 2 3 4 5 6 7
rss_proto_ipv4 = TCP UDP
symmetrical_rss = yes
3. 每组件独占 CPU core
每个组件运行在独立的 lcore 上,不允许在同一 CPU 上部署多个组件。组件间无共享数据结构,彻底消除数据竞争。
4. 批量收包 + prefetch 优化
// 批量收取 burst=32 个包
nb_pkts = qnsm_port_rx(port_handle, port_id, mbuf);
// prefetch 优化
for (index = 0; index < PREFETCH_OFFSET && index < nb_pkts; index++) {
rte_prefetch0(mbuf[index] + 1); // prefetch pkt_info
rte_prefetch0(rte_pktmbuf_mtod(mbuf[index], void *)); // prefetch payload
}
5. 基于 DPDK hash 表的 O(1) 会话查找
会话表使用 CRC32 硬件指令加速 hash 计算:
static inline uint32_t ipv4_hash_crc(const void *data, uint32_t data_len, uint32_t init_val)
{
const union ipv4_5tuple_host *k = data;
init_val = rte_hash_crc_4byte(k->proto, init_val);
init_val = rte_hash_crc_4byte(k->ip_src, init_val);
init_val = rte_hash_crc_4byte(k->ip_dst, init_val);
init_val = rte_hash_crc_4byte(*(const uint32_t *)&k->port_src, init_val);
return init_val;
}
6. per-lcore mempool 替代 rte_malloc
TCP 连接使用 per-lcore 的 mempool 替代全局的rte_malloc/rte_free,避免 spinlock 争用:
// tcp_session.c 中的注释
// because rte_malloc/free used spinlock,
// cause thread syn when sess num increases,
// finally cause pkt loss
lcore_cache.tcp_conn_cache = rte_mempool_create(name,
TCP_CONN_PER_LCORE_MAX, sizeof(TCP_STREAM), ...);
7. 定时器聚合输出
会话统计通过 DPDK rte_timer周期性聚合输出(QNSM_SESS_STATIS_AGG_INTERVAL_SEC),而非每包即时发送,减少消息开销。
8. TopN 端口统计使用最小堆
VIP_AGG 中使用最小堆维护 Top20 端口统计,避免全排序的 O(NlogN) 开销:
// 定义在 qnsm_ip_agg.c
#define QNSM_PORT_TOPN (20)
QNSM_HEAP topn_port_statis[EN_QNSM_PORT_TYPE_MAX];
0x08 DDoS 检测、IDPS、流量监控、DLP
DDoS 检测
DDoS 检测是 QNSM 的核心功能,工作流程:
- 全流量解析:SESSM 解析所有流经的数据包(支持 10Gbps 线速)
- VIP 维度聚合:VIP_AGG 按攻击类型聚合,输出到
qnsm_vip_agg - 攻击类型分类:通过
qnsm_pkt_type_parse函数,基于协议和 TCP flag 分类:
inline int qnsm_pkt_type_parse(QNSM_PACKET_INFO* pkt_info, ...)
{
switch (pkt_info->proto) {
case TCP_PROTOCOL:
tcp_flag = l4_head.raw[13];
detect_type = en_tcp_type[tcp_flag]; // 预计算的 flag->type 映射表
break;
case UDP_PROTOCOL:
detect_type = e_udp;
if (53 == pkt_info->dport) detect_type = e_dns_query;
break;
case ICMP_PROTOCOL: detect_type = e_icmp; break;
case ESP_PROTOCOL: detect_type = e_esp; break;
}
}
- 外部检测:分析中心消费 Kafka 数据,基于阈值/基线/机器学习等方法检测攻击
- 策略反馈:检测到攻击后下发 dump/DFI 等策略到 QNSM
- 攻击源聚合:SIP_AGG 提供攻击源 IP 粒度的数据用于溯源
IDPS
IDPS 模块基于 Suricata 4.1.0 版本的 lib 化集成,通过 DETECT 组件运行。核心集成方式:
// qnsm_idps_core.c
void *QnsmTmThreadsInit(const char* mode, ...)
{
// 1. 创建 Suricata 线程变量
tv = QnsmTmThreadCreatePacketHandler(tname, ...);
// 2. 注册 DPDK 收包模块
tm_module = TmModuleReceiveQnsmRegister();
TmSlotSetFuncAppend(tv, tm_module, rcv_mod_initdata);
// 3. 注册 DPDK 解码模块
tm_module = TmModuleDecodeQnsmRegister();
TmSlotSetFuncAppend(tv, tm_module, NULL);
// 4. 注册 FlowWorker(Suricata 核心流处理)
tm_module = TmModuleGetByName("FlowWorker");
TmSlotSetFuncAppend(tv, tm_module, NULL);
// 5. 注册 RespondReject 模块
tm_module = TmModuleGetByName("RespondReject");
TmSlotSetFuncAppend(tv, tm_module, NULL);
}
收包流程:QNSM 通过QnsmTMReceiveLoop从 PORT 收包,构造 Suricata 的 Packet 结构,然后通过 Suricata 的 slot pipeline 处理链进行规则匹配。事件通过 Kafka 输出到nsm_event topic。
IDPS 可以单独部署也可以与 DDoS 检测混合部署。在混合部署模式下,SESSM 通过qnsm_port_dup_tx_lb将包复制一份发送到 DETECT 组件。
流量监控
流量监控通过两个维度实现:
- 实时 VIP 聚合(
qnsm_vip_aggtopic):提供每个 VIP 的多类型 pps/bps 实时数据 - 五元组流采样(
qnsm_sample_flowtopic):按采样率提供五元组级别的流数据
流采样数据格式:
{
"dc": "dc_aaa",
"sampling_interval": 4000,
"timestamp": 1557718926,
"ip_protocol": 6,
"ip_version": 4,
"src_ip": "A.B.C.D",
"src_port": 52058,
"dst_ip": "E.F.G.H",
"dst_port": 80,
"direction": 1,
"tcp_flags": 16,
"packets": 2,
"out_bytes": 2868
}
DLP
QNSM 项目源码中未实现 DLP(Data Loss Prevention)功能。DLP 通常需要对应用层 payload 进行深度内容检查(关键词匹配、正则规则、文件类型检测等),这与 QNSM 当前以 DDoS 检测和 IDPS 为核心的定位有所不同。但 QNSM 的 DPI 框架具备扩展为 DLP 检测的基础能力,特别是 HTTP 协议解析(src/protos/http.c)已实现了较完整的 HTTP header 和 body 解析。
0x09 补充模块
ACL 机制
QNSM 基于 DPDK ACL 库实现五元组 ACL 过滤,在收包后、业务处理前执行:
// 调度循环中
if (load_acl) {
qnsm_acl_run(acl_hdl, mbuf, nb_pkts);
}
ACL 表支持 IPv4 和 IPv6 两种规则集,字段包括 proto、src_ip、dst_ip、src_port、dst_port。Master 可以动态下发 ACL 规则实现 IP 黑名单等功能。
VIP 自学习
VIP_AGG 组件支持动态 VIP 发现机制。当 VIP_AGG 匹配到未知 IP 时,会通知 Master 组件:
- Master 将新 VIP 通过 Kafka 发送到
qnsm_dyn_viptopic - 分析中心确认后,Master 将 VIP 同步到所有 SESSM 和 VIP_AGG 实例
- 支持 Redis 查询确认 VIP 归属 IDC(编译时通过
__LEARN_SERVICE_VIP宏开启)
VIP_AGG 中 VIP 表的实现:
- IPv4 使用 DPDK LPM(Longest Prefix Match)表,支持 CIDR 匹配
- IPv6 使用 DPDK hash 表
- 每个 VIP 维护独立的聚合定时器和老化定时器
Kafka 批量发送
EDGE 组件通过qnsm_kafka_batch_tx_init初始化批量发送,减少 Kafka API 调用频率:
qnsm_kafka_batch_tx_init(QNSM_KAFKA_VIP_AGG_TOPIC, "dip_traffic", 8);
qnsm_kafka_batch_tx_init(QNSM_KAFKA_SIP_IN_AGG_TOPIC, "sip_in", 8);
配置热加载
Master 通过 MSG 机制实现运行时策略更新,无需重启 QNSM 进程:
- VIP 增删:
QNSM_MSG_SYN_BIZ_VIP消息 - DPI 策略:
QNSM_MSG_DPI_POLICY消息 - dump 开关:通过 VIP 消息携带 cmd 字段
会话 key 生成策略
QNSM 的五元组会话 key 生成采用 IP 地址排序保证双向包映射到同一会话:
inline int32_t qnsm_sess_generate_key(QNSM_PACKET_INFO *pkt_info, QNSM_SESS_ADDR *key)
{
// 按 IP 大小排序,确保双向流量映射到同一 key
if (pkt_info->v4_src_ip < pkt_info->v4_dst_ip) {
key->v4_5tuple.ip_src = pkt_info->v4_src_ip;
key->v4_5tuple.ip_dst = pkt_info->v4_dst_ip;
} else {
key->v4_5tuple.ip_src = pkt_info->v4_dst_ip;
key->v4_5tuple.ip_dst = pkt_info->v4_src_ip;
same_dir = 0; // 标记方向翻转
}
// 返回 same_dir 用于后续判断数据包方向(TO_SERVER/TO_CLIENT)
return same_dir;
}
seq rollover 处理
TCP 流重组中处理序列号回绕:
int32_t packet_sequence_diff(uint32_t a, uint32_t b)
{
if (a > 0xc0000000 && b < 0x40000000)
return (a + 0xffffffffLL - b); // a 在高位,b 回绕到低位
if (b > 0xc0000000 && a < 0x40000000)
return (a - b - 0xffffffffLL); // b 在高位,a 回绕到低位
return b - a;
}