轻量又灵活：一款伪造TCP数据包的iptables扩展实现解析（C/C++代码实现）

程序猿编码2026-03-19 8:46

在网络测试、安全验证等场景中，伪造TCP数据包是一项常用的技术手段。本文要介绍的，是一个轻量级的Linux内核模块+iptables扩展工具，它能让我们通过简单的iptables命令，灵活定制并发送伪造的TCP数据包，覆盖IPv4和IPv6双协议栈，还支持自定义TTL、TCP标志位、校验和篡改等丰富功能。

一、工具核心能力与应用场景

先说说这个工具到底能干嘛，用大白话讲清楚核心价值：

  • 自定义伪造TCP包的TTL（生存时间），0则继承原数据包的TTL；
  • 自由设置TCP标志位（FIN/SYN/RST等），模拟不同的TCP握手/断开行为；
  • 可选篡改TCP校验和、序列号，用于测试网络设备的容错能力；
  • 延迟原数据包转发，控制伪造包与原包的发送时序；
  • 自定义TCP载荷长度，还能自动填充指定内容；
  • 支持添加TCP MD5、Timestamp扩展选项，模拟真实业务包特征；
  • 适配MASQUERADE（地址伪装）场景，解决NAT环境下的伪造包发送问题；
  • 同时支持IPv4和IPv6，通用性强。

这个工具主要用在网络设备兼容性测试 （比如测试防火墙对异常TCP包的处理）、安全攻防演练 （模拟特定TCP攻击行为）、协议栈健壮性验证（比如测试系统对错误校验和/序列号包的处理）等场景。

二、核心设计思路与实现原理

c 复制代码 
...

static unsigned int spooftcp_tg4(struct sk_buff *oskb, const struct xt_action_param *par)
{
	const struct iphdr *oiph;
	struct tcphdr *otcph;
	struct net *net;
	struct dst_entry *dst;
	struct sk_buff *nskb;
	struct iphdr *iph;
	struct tcphdr *tcph;
	const struct xt_spooftcp_info *info = par->targinfo;

	if (unlikely(__this_cpu_read(spooftcp_active)))
		return XT_CONTINUE;

	oiph = ip_hdr(oskb);

	if (unlikely(ip_hdr(oskb)->frag_off & htons(IP_OFFSET)))
		return XT_CONTINUE;

	if (unlikely(skb_rtable(oskb)->rt_flags & (RTCF_BROADCAST | RTCF_MULTICAST)))
		return XT_CONTINUE;

	otcph = skb_header_pointer(oskb, ip_hdrlen(oskb), sizeof(struct tcphdr),
			   otcph);
	
	if (unlikely(!otcph))
		return XT_CONTINUE;

#if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 10, 0)
	net = xt_net(par);
#elif LINUX_VERSION_CODE >= KERNEL_VERSION(4, 4, 0)
	net = par->net;
#endif

	dst = dst_clone(skb_dst(oskb));
	if (unlikely(dst->error)) {
		dst_release(dst);
		return XT_CONTINUE;
	}
	
	nskb = alloc_skb(sizeof(struct iphdr) + sizeof(struct tcphdr) +
			 ALIGN((info->md5 ? OPT_MD5_SIZE : 0) + (info->ts ? OPT_TS_SIZE : 0), 4) +
			 LL_MAX_HEADER + info->payload_len,
			 GFP_ATOMIC);

	if (unlikely(!nskb)) {
		net_dbg_ratelimited("cannot alloc skb\n");
		dst_release(dst);
		return XT_CONTINUE;
	}			 

	skb_dst_set(nskb, dst);
	skb_reserve(nskb, LL_MAX_HEADER);

	skb_put(nskb, sizeof(struct iphdr));
	skb_reset_network_header(nskb);
	iph = ip_hdr(nskb);

	iph->version	= 4;
	iph->ihl	= sizeof(struct iphdr) / 4;
	iph->tos	= 0;
	iph->id		= 0;
	iph->frag_off	= htons(IP_DF);
	iph->protocol	= IPPROTO_TCP;
	iph->check	= 0;

	if (info->masq) {
#if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 10, 0)
		iph->saddr	= inet_select_addr(xt_out(par), 0, RT_SCOPE_UNIVERSE);
#else
		iph->saddr	= inet_select_addr(par->out, 0, RT_SCOPE_UNIVERSE);
#endif
	} else {
		iph->saddr	= oiph->saddr;
	}

	iph->daddr	= oiph->daddr;
	if (info->ttl)
		iph->ttl = info->ttl;
	else
		iph->ttl = oiph->ttl;

	nskb->protocol = htons(ETH_P_IP);

	tcph = spooftcp_tcphdr_put(nskb, otcph, info);

	tcph->check = ~tcp_v4_check(sizeof(struct tcphdr) + info->payload_len +
				  ALIGN((info->md5 ? OPT_MD5_SIZE : 0) + (info->ts ? OPT_TS_SIZE : 0), 4),
				  iph->saddr, iph->daddr, 0);
	nskb->ip_summed = CHECKSUM_PARTIAL;
	nskb->csum_start = (unsigned char *)tcph - nskb->head;
	nskb->csum_offset = offsetof(struct tcphdr, check);
	if (info->corrupt_chksum)
		tcph->check = ~tcph->check;

#if IS_ENABLED(CONFIG_NF_CONNTRACK)
	/* Do not track this spoofed packet */
#	if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 11, 0)
	nf_reset(nskb);
	nf_ct_set(nskb, NULL, IP_CT_UNTRACKED);
#	else
	nf_conntrack_put(nskb->nfct);
	nskb->nfct     = &nf_ct_untracked_get()->ct_general;
	nskb->nfctinfo = IP_CT_NEW;
	nf_conntrack_get(nskb->nfct);
#	endif
#endif

	__this_cpu_write(spooftcp_active, true);
#if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 4, 0)
	ip_local_out(net, nskb->sk, nskb);
#else
	ip_local_out(nskb);
#endif
	__this_cpu_write(spooftcp_active, false);
	if (info->delay)
		mdelay(info->delay);

	return XT_CONTINUE;
}

static unsigned int spooftcp_tg6(struct sk_buff *oskb, const struct xt_action_param *par)
{
	const struct ipv6hdr *oip6h;
	__be16 frag_off;
	__u8 proto;
	int tcphoff;
	unsigned int otcplen;
	struct tcphdr *otcph;
	struct net *net;
	struct dst_entry *dst;
	unsigned int hh_len;
	struct sk_buff *nskb;
	struct ipv6hdr *ip6h;
	const struct xt_spooftcp_info *info = par->targinfo;
	struct tcphdr *tcph;

	if (unlikely(__this_cpu_read(spooftcp_active)))
		return XT_CONTINUE;
	
	oip6h = ipv6_hdr(oskb);

	if (unlikely((!(ipv6_addr_type(&oip6h->saddr) & IPV6_ADDR_UNICAST)) ||
	    (!(ipv6_addr_type(&oip6h->daddr) & IPV6_ADDR_UNICAST)))) {
		pr_warn("addr is not unicast.\n");
		return XT_CONTINUE;
	}

	proto = oip6h->nexthdr;
	tcphoff = ipv6_skip_exthdr(oskb, ((u8 *)(oip6h + 1) - oskb->data),
				   &proto, &frag_off);

	if (unlikely((tcphoff < 0) || (tcphoff > oskb->len))) {
		pr_warn("Cannot get TCP header.\n");
		return XT_CONTINUE;
	}

	otcplen = oskb->len - tcphoff;

	if (unlikely(proto != IPPROTO_TCP || otcplen < sizeof(struct tcphdr))) {
		pr_warn("proto(%d) != IPPROTO_TCP or too short (len = %d)\n",
			 proto, otcplen);
		return XT_CONTINUE;
	}

	otcph = skb_header_pointer(oskb, tcphoff, sizeof(struct tcphdr),
				   otcph);
	
	if (unlikely(!otcph))
		return XT_CONTINUE;

#if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 10, 0)
	net = xt_net(par);
#elif LINUX_VERSION_CODE >= KERNEL_VERSION(4, 4, 0)
	net = par->net;
#endif

	dst = dst_clone(skb_dst(oskb));
	if (unlikely(dst->error)) {
		dst_release(dst);
		return XT_CONTINUE;
	}
	
	hh_len = (dst->dev->hard_header_len + 15)&~15;
	
	nskb = alloc_skb(hh_len + 15 + dst->header_len + sizeof(struct ipv6hdr)
			 + sizeof(struct tcphdr) + dst->trailer_len + info->payload_len +
			 ALIGN((info->md5 ? OPT_MD5_SIZE : 0) + (info->ts ? OPT_TS_SIZE : 0), 4),
			 GFP_ATOMIC);

	if (unlikely(!nskb)) {
		net_dbg_ratelimited("cannot alloc skb\n");
		dst_release(dst);
		return XT_CONTINUE;
	}			 

	skb_dst_set(nskb, dst);
	skb_reserve(nskb, hh_len + dst->header_len);

	skb_put(nskb, sizeof(struct ipv6hdr));
	skb_reset_network_header(nskb);
	ip6h = ipv6_hdr(nskb);
	ip6_flow_hdr(ip6h, 0, 0);
	ip6h->hop_limit = info->ttl ? info->ttl : oip6h->hop_limit;
	ip6h->nexthdr = IPPROTO_TCP;

	if (info->masq) {
#if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 10, 0)
		ipv6_dev_get_saddr(net, xt_out(par), &oip6h->daddr, 0, &ip6h->saddr);
#else
		ipv6_dev_get_saddr(net, par->out, &oip6h->daddr, 0, &ip6h->saddr);
#endif
	} else {
		ip6h->saddr = oip6h->saddr;
	}

	ip6h->daddr = oip6h->daddr;
	nskb->protocol = htons(ETH_P_IPV6);

	tcph = spooftcp_tcphdr_put(nskb, otcph, info);

	tcph->check = 0;
	tcph->check = csum_ipv6_magic(&ipv6_hdr(nskb)->saddr,
				      &ipv6_hdr(nskb)->daddr,
				      sizeof(struct tcphdr) + info->payload_len + ALIGN((info->md5 ? OPT_MD5_SIZE : 0) + (info->ts ? OPT_TS_SIZE : 0), 4),
				      IPPROTO_TCP,
				      csum_partial(tcph,
						   sizeof(struct tcphdr) + info->payload_len + ALIGN((info->md5 ? OPT_MD5_SIZE : 0) + (info->ts ? OPT_TS_SIZE : 0), 4), 0));
	
	if (info->corrupt_chksum)
		tcph->check = ~tcph->check;

#if IS_ENABLED(CONFIG_NF_CONNTRACK)
	/* Do not track this spoofed packet */
#	if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 11, 0)
	nf_reset(nskb);
	nf_ct_set(nskb, NULL, IP_CT_UNTRACKED);
#	else
	nf_conntrack_put(nskb->nfct);
	nskb->nfct     = &nf_ct_untracked_get()->ct_general;
	nskb->nfctinfo = IP_CT_NEW;
	nf_conntrack_get(nskb->nfct);
#	endif
#endif
	__this_cpu_write(spooftcp_active, true);
#if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 4, 0)
	ip6_local_out(net, nskb->sk, nskb);
#else
	ip6_local_out(nskb);
#endif
	__this_cpu_write(spooftcp_active, false);
	if (info->delay)
		mdelay(info->delay);

	return XT_CONTINUE;
}

static struct xt_target spooftcp_tg_regs[] __read_mostly = {
	{
		.family		= NFPROTO_IPV4,
		.name		= "SPOOFTCP",
		.target		= spooftcp_tg4,
		.targetsize 	= sizeof(struct xt_spooftcp_info),
		.hooks		= 1 << NF_INET_POST_ROUTING,
		.proto		= IPPROTO_TCP,
		.me		= THIS_MODULE,
	},
	{
		.family		= NFPROTO_IPV6,
		.name		= "SPOOFTCP",
		.target		= spooftcp_tg6,
		.targetsize 	= sizeof(struct xt_spooftcp_info),
		.hooks		= 1 << NF_INET_POST_ROUTING,
		.proto		= IPPROTO_TCP,
		.me		= THIS_MODULE,
	}
};

static int __init spooftcp_tg_init(void)
{
	return xt_register_targets(spooftcp_tg_regs, ARRAY_SIZE(spooftcp_tg_regs));
}

static void __exit spooftcp_tg_exit(void)
{
	xt_unregister_targets(spooftcp_tg_regs, ARRAY_SIZE(spooftcp_tg_regs));
}

module_init(spooftcp_tg_init);
module_exit(spooftcp_tg_exit);

If you need the complete source code, please add the WeChat number (c17865354792)

1. 整体架构：用户态+内核态分工

这个工具分为两部分，分工很清晰：

  • 用户态（iptables扩展） ：负责解析我们输入的iptables命令参数（比如--ttl 64、--tcp-flags SYN），把参数封装成固定格式的结构体，传递给内核态；
  • 内核态（Netfilter模块）：挂钩Netfilter的POST_ROUTING钩子点（数据包即将出网卡时），捕获符合条件的TCP包，根据用户态传递的参数构造伪造包，发送出去，还能按要求延迟原包。

用一张简单的流程图理解整体流程：
是
否
用户执行iptables命令
用户态扩展解析参数
参数封装为xt_spooftcp_info结构体
内核态模块挂钩POST_ROUTING钩子
捕获符合规则的TCP包
构造伪造TCP包（自定义TTL/标志位/载荷等）
发送伪造包
是否设置延迟?
延迟原包转发
直接转发原包

2. 关键知识点铺垫

先解释几个核心概念，不然看原理会懵：

  • Netfilter钩子：Linux内核的网络数据包处理框架，有5个核心钩子点，这里用的POST_ROUTING是数据包离开本机前的最后一个处理点，适合做包伪造（此时已经确定了出网卡和路由，能准确构造包的路由信息）；
  • iptables扩展：iptables本身只是个命令行工具，真正的功能靠扩展实现，我们写的用户态代码就是给iptables加了个"SPOOFTCP"目标（target），让iptables能识别我们的自定义参数；
  • TCP头部结构：TCP包的核心是头部，包含源端口、目的端口、序列号、标志位、校验和等字段，我们的伪造本质就是修改这些字段，还能加扩展选项（比如MD5）；
  • Per-CPU变量 ：内核里用DEFINE_PER_CPU(bool, spooftcp_active)定义的变量，每个CPU核心一份，用来防止伪造包处理过程中递归调用（避免自己伪造的包又被钩子捕获，无限循环）。

3. 核心代码实现拆解

（1）用户态：参数解析与传递

用户态代码的核心是把我们输入的命令行参数转成内核能识别的结构体，关键步骤：

  1. 定义参数选项（比如--ttl对应O_TTL，--tcp-flags对应O_TCP_FLAGS）；
  2. 解析TCP标志位字符串（比如把"SYN,ACK"转成对应的二进制值0x12）；
  3. 把所有参数填充到struct xt_spooftcp_info结构体，这个结构体是用户态和内核态的"沟通桥梁"，包含了TTL、TCP标志位、是否篡改校验和等所有配置。

关键代码片段解读（解析TCP标志位）：

c 复制代码 
static __u8 parse_tcp_flag(const char *flags) {
    __u8 ret = 0;
    char *ptr;
    char *buffer = strdup(flags);
    // 按逗号分割标志位字符串，比如"SYN,ACK"拆成"SYN"和"ACK"
    for (ptr = strtok(buffer, ","); ptr; ptr = strtok(NULL, ",")) {
        unsigned int i;
        // 匹配预定义的标志位（FIN/SYN/RST等），转成二进制值
        for (i = 0; i < TCP_FLAG_NAMES_SIZE; ++i)
            if (strcasecmp(tcp_flag_names[i].name, ptr) == 0) {
                ret |= tcp_flag_names[i].flag; // 按位或，组合多个标志位
                break;
            }
        if (i == TCP_FLAG_NAMES_SIZE)
            xtables_error(PARAMETER_PROBLEM, "Unknown TCP flag `%s'", ptr);
    }
    free(buffer);
    return ret;
}
（2）内核态：伪造包构造与发送

内核态是核心，重点看怎么构造并发送伪造的TCP包：

  1. 钩子触发：当数据包经过POST_ROUTING钩子时，先做基础校验（比如不是分片包、不是广播/组播包），避免无效处理；
  2. 克隆路由信息：从原数据包克隆路由表项（dst_clone），保证伪造包走和原包一样的路由；
  3. 分配新skb缓冲区 ：skb是Linux内核中表示网络数据包的核心结构体，alloc_skb分配新的缓冲区，大小要包含IP头、TCP头、扩展选项、载荷；
  4. 构造IP头 ：
    • IPv4：设置版本、头部长度、协议（TCP）、源/目的IP（支持MASQUERADE时自动选出口IP）、TTL；
    • IPv6：类似，设置流标签、跳数限制、源/目的IPv6地址；
  5. 构造TCP头 ：
    • 复制原包的源/目的端口，按配置设置序列号（可反转）、标志位；
    • 按需添加MD5/Timestamp扩展选项，自动补齐4字节对齐；
    • 填充自定义载荷（比如默认的"GET / HTTP/1.1..."）；
  6. 校验和处理：计算TCP校验和，支持故意篡改（取反）；
  7. 绕过连接跟踪：如果开启了nf_conntrack，把伪造包标记为"不跟踪"，避免被连接跟踪模块干扰；
  8. 发送伪造包 ：调用ip_local_out/ip6_local_out发送，发送前后用Per-CPU变量标记"活跃"，防止递归；
  9. 延迟原包 ：如果配置了delay，用mdelay延迟原包转发。

关键代码片段解读（构造TCP头）：

c 复制代码 
static struct tcphdr * spooftcp_tcphdr_put(struct sk_buff *nskb, const struct tcphdr *otcph, const struct xt_spooftcp_info *info) {
    struct tcphdr *tcph;
    u_int8_t * tcpopt;
    u_int8_t optoff;

    skb_reset_transport_header(nskb);
    // 分配TCP头空间并初始化
    tcph = (struct tcphdr *)skb_put(nskb, sizeof(struct tcphdr));
    memset(tcph, 0, sizeof(struct tcphdr));
    tcph->doff = sizeof(struct tcphdr)/4; // 数据偏移（TCP头长度）
    tcph->source = otcph->source; // 源端口继承原包
    tcph->dest = otcph->dest;     // 目的端口继承原包
    // 设置TCP标志位（第13字节）
    ((u_int8_t *)tcph)[13] = info->tcp_flags;
    // 序列号：可选反转（篡改）
    if (info->corrupt_seq) 
        tcph->seq = ~otcph->seq;
    else
        tcph->seq = otcph->seq;
    
    // 处理TCP扩展选项（MD5/Timestamp）
    tcpopt = (u_int8_t *)tcph + sizeof(struct tcphdr);
    optoff = 0;
    if (info->md5) { // 添加MD5选项
        skb_put(nskb, OPT_MD5_SIZE);
        tcpopt[optoff + 0] = OPT_MD5_KIND; // MD5选项类型
        tcpopt[optoff + 1] = OPT_MD5_SIZE; // 选项长度
        memset(tcpopt + optoff + 2, 0, OPT_MD5_SIZE - 2); // 填充空MD5值
        optoff += OPT_MD5_SIZE;
    }
    // 处理Timestamp选项（逻辑类似MD5）...
    
    // 4字节对齐填充
    if (optoff % 4) {
        skb_put(nskb, ALIGN(optoff, 4) - optoff);
        memset(tcpopt + optoff, 0, ALIGN(optoff, 4) - optoff);
        optoff = ALIGN(optoff, 4);
    }
    // 调整TCP头长度（包含扩展选项）
    tcph->doff += optoff/4;
    
    // 填充载荷
    if (info->payload_len) {
        skb_put(nskb, info->payload_len);
        strncpy(tcpopt + optoff, PAYLOAD_BUFF, info->payload_len);
    }

    return tcph;
}
（3）双协议栈适配

代码同时支持IPv4和IPv6，核心差异在：

  • IPv4用iphdr结构体，校验和计算用tcp_v4_check；
  • IPv6用ipv6hdr结构体，校验和计算用csum_ipv6_magic；
  • IPv6需要跳过扩展头（ipv6_skip_exthdr）才能找到TCP头，而IPv4直接通过IP头长度定位。

三、设计亮点与领域知识点总结

1. 设计上的巧思

  • 轻量级：只处理核心的TCP包伪造逻辑，不引入多余依赖，内核模块体积小，性能开销低；
  • 兼容性：适配不同Linux内核版本（4.4/4.10/4.11+），通过宏定义处理API差异；
  • 安全性：用Per-CPU变量防止递归处理，绕过连接跟踪避免干扰系统网络状态；
  • 易用性：复用iptables命令行接口，运维人员不用学新工具，直接用熟悉的iptables语法。

2. 核心领域知识点

  • Netfilter框架：Linux内核网络的核心，所有iptables规则都基于它实现，POST_ROUTING钩子是出口包处理的关键节点；
  • skb结构体 ：内核中数据包的载体，理解skb_put（扩展缓冲区）、skb_reset_network_header（重置头部指针）等操作是内核网络编程的基础；
  • TCP/IP协议细节：TCP标志位、校验和计算、扩展选项格式、IPv6扩展头处理，这些是构造合法/异常TCP包的前提；
  • Per-CPU变量：内核中解决并发问题的常用手段，避免锁开销，适合标记"当前CPU是否在处理伪造包"这类场景；
  • iptables扩展开发：遵循xtables规范，定义选项、解析函数、校验函数，实现和iptables的无缝集成。

四、编译&安装

1. 编译代码

进入代码所在目录，执行编译命令：

bash 复制代码 
make

编译成功后，目录下会生成：

  • xt_SPOOFTCP.ko：内核模块文件
  • libxt_SPOOFTCP.so：iptables扩展库文件

2. 安装内核模块

bash 复制代码 
# 加载内核模块（临时生效，重启后失效）
sudo insmod xt_SPOOFTCP.ko
# 验证模块是否加载成功
lsmod | grep SPOOFTCP
# 若输出xt_SPOOFTCP相关内容，说明加载成功

3. 安装iptables扩展

把编译好的libxt_SPOOFTCP.so复制到iptables的扩展库目录（不同系统路径可能不同）：

bash 复制代码 
# 第一步：查看系统iptables扩展目录
pkg-config --variable=xtlibdir xtables
# 输出示例：/usr/lib/x86_64-linux-gnu/xtables

# 第二步：复制扩展库到该目录（替换成你查到的路径）
sudo cp libxt_SPOOFTCP.so /usr/lib/x86_64-linux-gnu/xtables/

# 第三步：验证扩展是否识别
iptables -j SPOOFTCP --help
# 若输出SPOOFTCP的帮助信息（比如--ttl、--tcp-flags等），说明安装成功

五、实际测试运行

测试场景说明

我们以IPv4环境 为例，测试核心功能：对发往80端口的TCP SYN包，伪造一个SYN+ACK包发送，同时延迟原包100ms。

（IPv6测试只需把iptables换成ip6tables，逻辑完全一致）

分步测试操作

1. 配置iptables规则

执行以下命令添加规则（mangle表，POSTROUTING链，匹配TCP 80端口SYN包）：

bash 复制代码 
# 添加规则：伪造SYN+ACK包，TTL设为64，延迟原包100ms
sudo iptables -t mangle -A POSTROUTING -p tcp --dport 80 --syn -j SPOOFTCP \
  --ttl 64 \
  --tcp-flags SYN,ACK \
  --delay 100
# 查看规则是否生效
sudo iptables -t mangle -L POSTROUTING -nv
# 输出中能看到SPOOFTCP相关规则，说明配置成功
2. 抓包验证（核心！）

用tcpdump抓包，验证是否真的发送了伪造的SYN+ACK包：

bash 复制代码 
# 启动抓包（监听网卡eth0，过滤80端口TCP包，显示详细信息）
sudo tcpdump -i eth0 -nnvv tcp port 80
3. 触发测试流量

打开另一个终端，向任意80端口的IPv4地址发送SYN包（模拟客户端请求）：

bash 复制代码 
# 用nc命令发送TCP SYN包（只建立连接不传输数据）
nc -zv 目标IP 80
# 示例：nc -zv 192.168.1.100 80
4. 查看抓包结果（验证效果）

在tcpdump终端会看到两类包：

  • 伪造的包 ：先出现一个SYN,ACK标志的TCP包（TTL=64，和我们配置的一致）；
  • 原包 ：延迟约100ms后，出现原本的SYN包；
    这就说明模块工作正常！

更多测试场景示例

测试需求 对应的iptables命令
伪造带MD5选项的TCP包 sudo iptables -t mangle -A POSTROUTING -p tcp --dport 443 -j SPOOFTCP --tcp-flags ACK --md5
篡改TCP校验和+序列号 sudo iptables -t mangle -A POSTROUTING -p tcp --sport 22 -j SPOOFTCP --tcp-flags ACK --corrupt-checksum --corrupt-seq
自定义TCP载荷长度（50字节） sudo iptables -t mangle -A POSTROUTING -p tcp --dport 8080 -j SPOOFTCP --tcp-flags PSH,ACK --payload-length 50

六、测试后清理

测试完成后，记得清理规则和卸载模块：

bash 复制代码 
# 删除iptables规则
sudo iptables -t mangle -D POSTROUTING -p tcp --dport 80 --syn -j SPOOFTCP --ttl 64 --tcp-flags SYN,ACK --delay 100
# 卸载内核模块
sudo rmmod xt_SPOOFTCP
# 删除iptables扩展库（可选）
sudo rm /usr/lib/x86_64-linux-gnu/xtables/libxt_SPOOFTCP.so

总结

这款轻量级的iptables扩展+内核模块，本质是把复杂的内核网络编程封装成简单的iptables命令，核心是利用Netfilter钩子捕获数据包，按自定义规则构造并发送伪造的TCP包。它既体现了Linux内核网络编程的核心思想（skb操作、协议头构造、钩子机制），也兼顾了易用性和兼容性，是理解TCP/IP协议、Netfilter框架的绝佳实践案例，也能直接用于网络测试、安全验证等实际场景。

Welcome to follow WeChat official account【程序猿编码】

相关推荐
wregjru2 小时前
【网络】7.数据链路层：MAC 帧与 ARP 协议详解
网络
j_xxx404_2 小时前
LeetCode模拟算法精解I：替换问号，提莫攻击与Z字形变换
开发语言·数据结构·c++·算法·leetcode
_OP_CHEN2 小时前
【Linux网络编程】（二）计算机网络概念进阶：彻底搞懂协议本质、传输流程与封装分用
linux·运维·服务器·网络·网络协议·计算机网络·c/c++
风曦Kisaki2 小时前
# 云计算基础Day06:Linux权限管理
linux·云计算
勇闯逆流河2 小时前
【Linux】linux进程概念（fork，进程状态，僵尸进程,孤儿进程）
linux·运维·服务器·开发语言·c++
牛十二2 小时前
宝塔安装openclaw+企业微信操作手册
linux·运维·服务器
⑩-2 小时前
API 网关的作用？Spring Cloud Gateway 原理？
java·服务器·网络·spring cloud
70asunflower2 小时前
CUDA基础知识巩固检验练习题【附有参考答案】（7）
c++·人工智能·cuda
开开心心_Every2 小时前
免费抽奖软件支持内定名单+防重复中奖
linux·运维·服务器·edge·pdf·c5全栈·c4python
热门推荐
01GitHub 镜像站点02Qwen3.5 开源全解析：从 0.8B 到 397B，代际升级 + 全场景选型指南03OpenClaw 使用和管理 MCP 完全指南04UV安装并设置国内源05OpenClaw Control UI安全上下文访问配置06小黑课堂计算机二级WPSoffice题库软件下载安装教程（2026年3月最新版）07Claude Code + GLM4.7 避坑指南：解决 Unable to connect to Anthropic services08OpenClaw macOS 完整安装与本地模型配置教程（实战版）09本地部署 OpenClaw + DeepSeek-R1 完全指南10AI 编程三剑客：Spec-Kit、OpenSpec、Superpowers 深度对比与实战指南