题目给了一个没有扩展名的文件,附一句「运行后输入 flag,正确会提示 correct」。你把它拖进终端,随便输入一串字符,屏幕回了一个 wrong,然后退出。没有错误信息,没有提示长度,也没有网络请求。接下来干什么?很多人会直接打开反汇编器,从入口点开始读,读了两百行之后迷失在寄存器和跳转里。

这道题是本文自己构造的,源码和二进制都来自本机编译,属于完全授权的练习对象。它的难度不高,但包含一道逆向题最典型的完整链路:信息收集、静态定位、动态确认、脚本求解、回验结果。把这套流程走顺,比多做十道同质题有用。下面每一步都给出实际命令和预期现象。

第一步:先收集,不急着读代码

拿到文件先确认三件事:它是什么、有没有符号、运行时依赖什么。命令很短,但能省掉后面大量弯路。

file flagcheck
readelf -h flagcheck
readelf --dyn-syms flagcheck
strings -n 5 flagcheck | head -30
./flagcheck
./flagcheck test
echo $?

预期能看到 ELF 64 位、x86-64、动态链接;动态符号里出现 strlen、puts;字符串里有 usage: ./flagcheck <flag>、correct、wrong。这几条信息已经圈定了程序的大致形状:读一个参数,检查长度,逐字符计算比较,最后打印两种结果之一。

先跑一次再分析,成本极低。运行结果、退出码、是否有输出,都是后面验证假设的基准。不要一上来就把样本扔进反汇编器,那样连「正常长什么样」都不知道。

第二步:建立一条可回退的流程

逆向题卡住,往往不是因为某条指令看不懂,而是因为步骤之间没有回退点。推荐把流程固定成五步,每一步都有明确的产出,卡住时退回上一步,而不是在原地死磕。

一道逆向题的标准推进顺序
信息收集
静态定位
动态确认
脚本求解
回验结果

信息收集的产出是「程序大概在做什么」;静态定位的产出是「关键函数和关键循环的地址」;动态确认的产出是「某个值在运行时确实等于多少」;脚本求解的产出是「一个候选输入」;回验的产出是「程序对这个输入的真实反应」。任何一步没有产出,就不要进入下一步。

第三步:静态定位校验循环

先看符号。如果题目没有 strip,nm 能直接给出 check 和 main 的地址;如果剥离了,就从字符串的交叉引用往回找。用 objdump 反汇编,把注意力放在 correct 和 wrong 被引用的位置附近。

objdump -d -M intel flagcheck | sed -n '/<check>:/,+40p'

核心片段大致如下(地址和寄存器分配会随编译器变化):

xor    eax,0x2a
add    eax,edx
movzx  eax,al
cmp    al,BYTE PTR [rbp+rax*1-0x30]
jne    <check+0x...>

这段已经说明了三件事:输入字节先和 0x2a 异或,再加上一个随位置变化的量(edx,很可能就是循环下标 i),然后和一个字节数组逐项比较。比较失败就跳到失败分支。循环的长度由前面的 strlen 检查限定,通常是 21。

静态分析到这里就够了,不需要把每条指令都翻译成 C。接下来要确认两件事:数组的地址和内容,以及 edx 到底是不是下标。数组可以从反汇编里的 lea 或 mov 目标找到,也可以直接用 objdump -s -j .rodata 转储。下标的作用则用动态调试确认,或者通过相邻两次比较的差值推断。导出数组时建议连同地址范围一起记录,比如「数组起始于某地址,长 21 字节」,这样脚本、反汇编和运行时内存三处的数据才能对齐,不会出现抄错一位却查不出来源的情况。

第四步:动态确认关键值

静态看到 xor 0x2a 和 add edx 之后,最怕的是理解错方向:到底是先加后异或,还是先异或后加?寄存器里的 edx 是 i 还是别的值?这类问题用一次断点就能回答。

gdb -q ./flagcheck
(gdb) set disassembly-flavor intel
(gdb) break check
(gdb) run AAAAAAAAAAAAAAAAAAAAA
(gdb) disassemble check
(gdb) break *check+0x2a
(gdb) continue
(gdb) info registers eax edx
(gdb) x/21bx $rbp-0x30

本机没有 gdb,以上命令按 Linux 靶场写法给出,未在本机实测。预期在比较指令前停下时,edx 依次是 0、1、2、3,eax 是当前字节变换后的结果。把每一轮的 eax 和数组对应项对照,就能确认变换顺序。如果 edx 不是下标,而是另一个常量,那就说明前面的推断错了,退回静态重新看。

没有 gdb 也能做一部分确认:用不同长度的输入观察程序是否在长度检查处提前失败;用只改一个字符的输入,看失败位置是否随字符位置变化。这些黑盒实验能验证「逐字符比较」这个假设,但确认不了具体的算术顺序。还有一个省事的办法:把候选数组按脚本解一遍,得到字符串后再跑程序;如果程序说对,说明方向至少有一半是对的,再回头补动态证据也不迟。

第五步:写脚本反推输入

假设已经确认:对每个位置 i,程序计算 (input[i] ^ 0x2a) + i,再与目标数组比较。反推就是逆运算:先减 i,再异或 0x2a。目标数组从 .rodata 导出,或者直接从反汇编里的字节序列抄下来。

target = [
    0x4c, 0x47, 0x4d, 0x50, 0x55, 0x5d, 0x55, 0x63, 0x7d, 0x51, 0x55,
    0x64, 0x4f, 0x56, 0x67, 0x84, 0x28, 0x2b, 0x2a, 0x2f, 0x6b
]

flag = bytes(((target[i] - i) & 0xff) ^ 0x2a for i in range(len(target)))
print(flag.decode())

运行输出是 flag{rev_basics_2026}。本机用 Python 3.15 实际跑过这段脚本,结果与预期一致。注意 & 0xff:减法可能得到负数,Python 的整数没有固定位宽,不减到字节范围就会在异或时得到错误结果。这类边界处理是脚本求解里最常见的翻车点。

脚本只对这道自造题有效。把同样的思路套到真实软件上,可能涉及绕过授权或破解付费功能,那不属于 CTF 练习。CTF 题的授权范围是题目本身,出了这个范围就要重新确认许可。

第六步:回验,不要相信「看起来对」

得到候选 flag 后,必须回到原程序验证。运行 ./flagcheck 'flag{rev_basics_2026}',预期输出 correct,退出码为 0。再故意改一个字符,确认输出变成 wrong。两次结果都符合,才能说求解成立。

./flagcheck 'flag{rev_basics_2026}'
echo $?
./flagcheck 'flag{rev_basics_2025}'
echo $?

回验还有一个作用:排除「脚本碰巧算出可打印字符串」的假阳性。如果程序对长度、字符集还有额外检查,单看脚本输出发现不了。以程序的实际反应为准,不以脚本的输出为准,是逆向求解的基本纪律。

卡住时退回哪一步

卡住的表现不同,退回的位置也不同。下面这张表按现象给出建议,避免在原地反复尝试。

现象真实原因第一步查什么
反汇编找不到 check符号被剥离,或函数被内联从 correct/wrong 字符串的引用往回找
循环只跑一次就退出长度检查提前失败,或断点位置不对先用合法长度的输入,再确认循环边界
脚本算出的字符不可打印变换顺序理解错,或目标数组抄错用动态调试核对第一轮的中间值
算出的 flag 程序仍说 wrong还有第二处校验,或大小端、符号扩展问题搜目标数组的所有引用,检查字节与整数转换
断点停下时 edx 不是下标寄存器被复用,或优化改变了变量位置看循环尾部谁在递增,回到 -O0 版本对照
程序在调试器里行为异常反调试或时序检测先脱开调试器黑盒验证,再检查 ptrace

流程里还有一件小事值得养成:边做边记。每次反汇编窗口里找到一处关键地址,就把地址、指令和当时的假设写进一个临时文本;每做一次实验,就记下令、输入和输出。等到写报告或回头排查时,这些记录就是现成的证据。靠记忆重建过程,往往会漏掉转折点,也说不清某个结论到底是怎么来的。

这道题背后的通用方法

题目本身很简单,但流程可以复用。第一,永远先做信息收集,确认文件类型、符号、字符串和正常运行的表现。第二,静态分析只求定位,不求读懂全部;找到关键循环和比较点就停。第三,动态分析只回答静态定不了的疑问,比如寄存器含义、变换顺序、实际分支。第四,求解脚本要能解释每一步,而不是调一个库碰运气。第五,必须回验。

有人会问:这类题能不能直接用符号执行或自动求解工具跑出来?答案是能,但那是另一种训练。自动工具擅长处理约束明确的小程序,遇到环境依赖、间接调用、加密字符串就要人工建模。先用手工流程把假设和证据走一遍,再拿自动工具做交叉验证,才知道工具给出的结果为什么可信。只会点「运行」,遇到工具失败就没有下一步。

有效率的做法

从字符串和导入函数建立假设,用少量断点验证,写最小脚本复现变换,最后跑程序确认。每一步都有可检查的产出。

容易陷进去的做法

从入口点顺序读完全部反汇编,遇到不懂的指令就查手册,没有假设也没有验证,读完仍然不知道关键逻辑在哪。

边界与代价

CTF 题为了可解,通常会留下明确的线索:字符串、固定长度、简单的算术变换。真实软件没有这些善意,可能有混淆、反调试、运行时解密、多线程和环境依赖。把 CTF 流程当成万能模板,会在真实样本上碰壁。它真正训练的是「提出假设、设计验证、记录结论」的习惯,而不是某一种变换的解法。反过来说,也不要因为题目简单就跳过验证:能解出来和能解释清楚是两回事,后者才是可迁移的能力。

时间成本也要有意识。一道题卡两小时,可能只是某个字节抄错;先回到最短的可验证步骤,比继续扩大阅读范围有效。写脚本时保留中间输出,比如每轮的下标、目标字节、计算结果,出问题时能一眼看出哪一轮偏离。给自己设一个时间盒:超过预定时间还没有新证据,就停下来重新写一遍「已知什么、还缺什么、下一步能验证什么」。很多时候问题不在技术,而在假设一直没有被拆成可验证的小问题。

当天能自己验证的练习

  1. 把目标数组里的一个字节改掉,重新编译,用脚本求解,观察输出的哪个字符变了,验证「逐字符独立」这个假设。
  2. 把变换改成先加下标再异或,重新生成数组,故意用原来的脚本求解,确认它会失败,然后修正脚本。
  3. 用 -O2 编译同一个程序,重新反汇编,观察循环是否被展开、check 是否被内联,记录定位难度的变化。
  4. 用 strings 找不到 correct 时,尝试从 .rodata 转储里手工找,练习地址和内容的对应。
  5. 给程序加一个简单的长度二次检查,让脚本算出的 flag 无法通过,练习「回验发现隐藏条件」的排查。

小结

三句话:先收集再分析,先定位再精读;静态提假设,动态做确认,脚本做复现,程序做回验;卡住时退回上一步,不要在原地扩大阅读量。

下一篇讲分析报告。题做出来了不等于工作完成,别人要能看懂你的结论、证据和复现步骤。那篇会把这道题的求解过程写成一份可交付的报告,讲清楚哪些内容该写、哪些结论不能夸大、证据链怎么组织。