红队端口转发工具 — 原理、实战与 AI 编写实践

目标：访问 172.16.1.100:3389
障碍：攻击机与目标不在同一网段
跳板：10.10.10.50（已控）可以访问 172.16.1.100
方案：在 10.10.10.50 上启动转发，监听一个端口，将流量转给 172.16.1.100:3389
验证：攻击机 mstsc 连接 10.10.10.50:8888，如果能弹出 RDP 登录框，则方案生效

# 在跳板机上确认监听端口已打开
netstat -ano | findstr :8888

# 在攻击机上确认端口可达
telnet 10.10.10.50 8888

# 确认服务正常响应
curl -v http://10.10.10.50:8888  # 如果是 HTTP 服务

1. 防火墙是否放行了监听端口？
   → 检查 iptables / Windows Firewall
2. 跳板机能否到达目标地址？
   → telnet 172.16.1.100 3389
3. 目标服务是否正常运行？
   → 在跳板机本地尝试连接
4. 转发器日志显示了什么？
   → 加 -v 参数重跑，观察详细输出

# 在项目目录下编译（Windows）
go build -o portfwd.exe main.go

# Linux / macOS 交叉编译
set GOOS=linux GOARCH=amd64
go build -o portfwd main.go

# 在跳板机上执行：
portfwd -lp 8888 -rp 3389 -r 172.16.1.100

# 攻击机本地连接：
mstsc /v:10.10.10.50:8888

# 将内网 Linux 的 SSH 转发到本地 2222 端口
portfwd -lp 2222 -rp 22 -r 172.16.1.200

# 攻击机连接：
ssh user@10.10.10.50 -p 2222

# 将内网 MySQL（3306）转发到本地 33060
portfwd -lp 33060 -rp 3306 -r 172.16.1.100

# 使用本地客户端连接：
mysql -h 10.10.10.50 -P 33060 -u root -p

# 只监听本地回环地址，提高安全性
portfwd -l 127.0.0.1 -lp 8080 -rp 80 -r 172.16.1.100

# 大文件传输使用更大的缓冲区以提高吞吐量
portfwd -lp 8080 -rp 80 -r 172.16.1.100 -buf 16384

# 显示每个连接的字节传输量，方便排障
portfwd -lp 8080 -rp 80 -r 172.16.1.100 -v

# 终端 1：启动测试服务器
go run test_server.go

# 终端 2：启动转发器（将本机 8080 转发到测试服务器的 9999）
portfwd -lp 8080 -rp 9999 -r 127.0.0.1 -v

# 终端 3：用 nc 或 telnet 测试
nc -v 127.0.0.1 8080
# 输入任意文字，echo 服务器会原样返回

┌─ 已知条件 ─────────────────────────────┐
│ 攻击机 → 可访问 → web.boundary.com      │
│ web.boundary.com → 可访问 → 10.10.10.100:8080 │
│ 攻击机 → 不可访问 → 10.10.10.100:8080   │
└────────────────────────────────────────┘
      ↓
┌─ 结论 ─────────────────────────────────┐
│ 在 web.boundary.com 上启动 portfwd     │
│ 将 10.10.10.100:8080 转发到外网端口    │
└────────────────────────────────────────┘

# 在 web.boundary.com 上执行：
portfwd -lp 8080 -rp 8080 -r 10.10.10.100

# 攻击机访问：
curl http://web.boundary.com:8080/manager/html

攻击机 → A(公网) → B(内网) → DB(核心)
                                └── 3306(MySQL)

# 第一步：在 B 上启动转发，将 DB:3306 映射到 B:33060
（B 机上执行）portfwd -l 127.0.0.1 -lp 33060 -rp 3306 -r 192.168.1.100

# 第二步：在 A 上启动转发，将 B:33060 映射到 A:3306
（A 机上执行）portfwd -lp 3306 -rp 33060 -r 10.10.100.50

# 第三步：攻击机连接 A:3306，直达核心 DB
mysql -h a.boundary.com -P 3306 -u root -p

攻击机 → A:3306 → B:33060 → DB:3306

攻击者视角：我在 4444 等着，但流量出不来
┌─ 制约条件 ──────────────────────┐
│ 跳板机只允许出站到 80/443       │
│ 攻击机需要接收 4444 的连接      │
└────────────────────────────────┘
      ↓
┌─ 解决思路 ──────────────────────┐
│ 在攻击机上把 80 端口的流量转发  │
│ 到本地的 4444                  │
└────────────────────────────────┘

# 攻击机：在本地启动转发，将 80 端口的入站流量转给 4444
portfwd -l 0.0.0.0 -lp 80 -rp 4444 -r 127.0.0.1

# 跳板机：连接攻击机的 80 端口（实际上是连到 4444 的服务）
攻击机的 80 → portfwd → 本机 4444(监听 Reverse Shell)

请用 Go 语言编写一个 TCP 端口转发工具，要求如下：

## 功能需求
1. 支持指定本地监听地址和端口（-l 和 -lp 参数）
2. 支持指定远程目标地址和端口（-r 和 -rp 参数）
3. 支持配置传输缓冲区大小（-buf 参数，默认 4096 字节）
4. 支持详细日志模式（-v 参数）

## 质量要求
1. 支持优雅关闭：能捕获 SIGINT/SIGTERM 信号，等待所有正在传输的连接完成后再退出
2. goroutine 安全和并发：每个连接在独立 goroutine 中处理，使用 WaitGroup 管理生命周期
3. 全双工传输：两个方向的数据流应同时进行（使用两个 goroutine 分别处理）
4. 健壮的错误处理：Accept 超时/临时错误应能自动恢复，不崩溃

## 输出要求
1. 请输出完整的单个 main.go 文件
2. 添加清晰的中文注释解释关键逻辑
3. 使用标准库，不引入外部依赖

你是一名资深红队工具开发者，精通 Go 语言网络编程和并发模式。

## 任务
请编写一个生产级 TCP 端口转发工具，要求编译为单文件静态二进制，
无任何外部依赖，可在 Windows/Linux/macOS 上交叉编译运行。

## 接口设计
- 命令行参数：
  -l  本地监听地址（默认 0.0.0.0）
  -lp 本地监听端口（必填）
  -r  远程目标地址（默认 127.0.0.1）
  -rp 远程目标端口（必填）
  -buf 缓冲区大小（默认 4096）
  -v  详细日志模式

## 架构要求
1. 使用 Config 结构体聚合配置，Forwarder 结构体管理生命周期
2. Start() 启动监听并进入 acceptLoop，Stop() 实现优雅关闭
3. acceptLoop 支持周期性超时（SetDeadline），可被 quit 信号中断
4. 每个连接在独立 goroutine 中双向 pipe，全双工传输
5. 使用 io.CopyBuffer 而非 io.Copy，缓冲区可配置
6. 健壮的错误处理：过滤 EOF、"closed network connection" 等预期错误
7. 外部信号 SIGINT/SIGTERM 触发优雅关闭

## 输出
- 输出单个完整的 main.go 文件
- 关键逻辑添加中文注释
- 添加 flag.Usage 自定义帮助信息
- 同时输出配套的测试工具 test_server.go

┌─────────────────────────────────────────────────────┐
│                      main()                          │
│  parseFlags → NewForwarder → Start → 等待信号 → Stop │
└─────────────┬───────────────────────────────────────┘
              │ Start()
              ▼
┌─────────────────────────────────────────────────────┐
│               acceptLoop(listener)                    │
│  无限循环：Accept() → handleConnection(conn, target) │
└─────────────┬───────────────────────────────────────┘
              │ 每个连接
              ▼
┌─────────────────────────────────────────────────────┐
│           handleConnection(incoming, target)          │
│  Dial(target) → pipe(in→out) + pipe(out→in) 并发复制 │
└─────────────────────────────────────────────────────┘

type Config struct {
    ListenAddr string   // 本地监听地址（默认 0.0.0.0）
    ListenPort int      // 本地监听端口（必填）
    RemoteAddr string   // 远程目标地址（默认 127.0.0.1）
    RemotePort int      // 远程目标端口（必填）
    BufferSize int      // 传输缓冲区大小（默认 4096）
    Verbose    bool     // 详细日志模式
}

type Forwarder struct {
    config Config
    logger *log.Logger    // 结构化日志
    wg     sync.WaitGroup // 跟踪所有活跃 goroutine
    quit   chan struct{}  // 关闭信号，广播给所有协程
}

func (f *Forwarder) Start() error {
    listener, err := net.Listen("tcp", listenAddr)
    // ...
    f.wg.Add(1)
    go f.acceptLoop(listener, targetAddr)
    return nil
}

func (f *Forwarder) acceptLoop(listener net.Listener, targetAddr string) {
    defer f.wg.Done()
    defer listener.Close()
    for {
        select {
        case <-f.quit:
            return// 收到退出信号
        default:
        }
        listener.(*net.TCPListener).SetDeadline(time.Now().Add(1 * time.Second))
        conn, err := listener.Accept()
        // 处理错误...
        f.wg.Add(1)
        go f.handleConnection(conn, targetAddr)
    }
}

func (f *Forwarder) handleConnection(incoming net.Conn, targetAddr string) {
    defer f.wg.Done()
    defer incoming.Close()

    remoteConn, err := net.DialTimeout("tcp", targetAddr, 10*time.Second)
    // ...
    defer remoteConn.Close()

    var innerWg sync.WaitGroup
    innerWg.Add(2)
    gofunc() { defer innerWg.Done(); f.pipe(incoming, remoteConn, "→") }()
    gofunc() { defer innerWg.Done(); f.pipe(remoteConn, incoming, "←") }()
    innerWg.Wait()
}

func (f *Forwarder) pipe(dst io.Writer, src io.Reader, label string) {
    buf := make([]byte, f.config.BufferSize)
    written, err := io.CopyBuffer(dst, src, buf)
    if err != nil && err != io.EOF {
        if opErr, ok := err.(*net.OpError); ok && opErr.Err.Error() == "use of closed network connection" {
            return  // 关闭连接错误可忽略
        }
        f.logf("Pipe error (%s): %v", label, err)
    }
    if f.config.Verbose && written > 0 {
        f.logf("Pipe %s: %d bytes transferred", label, written)
    }
}

func (f *Forwarder) Stop() {
    close(f.quit)  // 广播信号给所有协程
    f.wg.Wait()    // 等待所有连接处理完毕
}

close(f.quit)
    │
    ├──→ acceptLoop: select 检测到 quit 关闭，return
    │      └── listener.Close() 由 defer 执行
    │
    ├──→ handleConnection (进行中): 继续完成 pipe，直到双向复制结束
    │
    └──→ f.wg.Wait() 阻塞等待所有 handleConnection 完成

func main() {
    cfg := parseFlags()
    fwd := NewForwarder(cfg)
    if err := fwd.Start(); err != nil {
        log.Fatalf("Failed to start forwarder: %v", err)
    }
    sigCh := make(chan os.Signal, 1)
    signal.Notify(sigCh, syscall.SIGINT, syscall.SIGTERM)
    sig := <-sigCh  // 阻塞等待信号
    fwd.Stop()
}

main goroutine
  │
  ├── Start()
  │     └── acceptLoop goroutine
  │           ├── handleConnection goroutine (连接1)
  │           │     ├── pipe goroutine (方向A)
  │           │     └── pipe goroutine (方向B)
  │           ├── handleConnection goroutine (连接2)
  │           │     ├── pipe goroutine (方向A)
  │           │     └── pipe goroutine (方向B)
  │           └── ...
  │
  └── 等待信号 → Stop()
        └── close(quit) → 广播通知
        └── wg.Wait() → 等待所有

// 最简单的 TCP 转发 — 自己写一遍
func main() {
    src, _ := net.Dial("tcp", "目标:端口")
    dst, _ := net.Listen("tcp", "本地:端口")
    // 手动处理连接、复制数据……
}

我正在学习红队端口转发相关知识，请帮我构建一个知识图谱，
包含以下概念之间的关系：
- TCP/IP 协议栈
- Socket 编程
- 端口转发
- 网络隧道
- SOCKS 代理
- 正向连接 vs 反向连接
- 防火墙绕过
- 流量混淆

请用 Markdown 格式输出，用缩进和列表表示层级关系，
并在每个节点标注"建议先学"的依赖关系。

1. [理解] "AI，什么是 ICMP 隧道？它和 TCP 端口转发的本质区别是什么？"
   → AI 解释：ICMP 隧道把 TCP 数据封装在 ping 包的 payload 中

2. [改造] "AI，基于现有的端口转发代码，修改 pipe 层使用 ICMP 封装"
   → AI 生成基于 ICMP 的 tunnel 版本

3. [测试] "AI，帮我写一个 ICMP 隧道的测试脚本，模拟限制性网络环境"
   → AI 生成 iptables 规则和测试用例

4. [优化] "AI，分析这个 ICMP 隧道的传输性能瓶颈在哪里"
   → AI 指出 MTU 限制、速率限制等关键因素

传统红队能力模型：
  经验 × 工具数量 × 知识广度

AI 时代红队能力模型：
  (提问质量 × 判断能力 × 整合能力) × AI 杠杆