2026数字中国创新大赛数字安全赛道 网络安全 决赛 FlagVault
决赛一共有3个题目有解, 一个misc,两个逆向 ,misc考的是流量分析,逆向考的是 安卓native逆向,和 exe逆向 这个题目全场12解,也是感受到了CTF 线上和线下的巨大差异,在AI时代,线上貌似谁都可以成为全栈,大家都很浮躁,静下心来学东西的人变少了,线下一脱离ai,就原型毕露了 (当然也包括我),还是想要劝勉一下自己,希望自己不要浮躁,踏实求学
2026数字中国创新大赛数字安全赛道 网络安全 决赛 FlagVault
摘要
这题表面上是一个普通的 Android 登录框,真正的校验逻辑却基本全部下沉到了 native 层。Java 代码只保留了界面交互、登录按钮回调和 flag 回显入口,真正决定用户名密码是否正确的部分,在 libre_flagvault.so 里完成。题目把 JNI 桥接、用户名参与密钥派生、XTEA 风格分组加密、十六进制编码和 SSE 常量比较揉在了一起,最后再用一个更浅的 getFlag 分支留出赛场上的快速得分路径。
写在前面
决赛一共有3个题目有解, 一个misc,两个逆向 ,misc考的是流量分析,逆向考的是 安卓native逆向,和 exe逆向
这个题目全场12解,也是感受到了CTF 线上和线下的巨大差异,在AI时代,线上貌似谁都可以成为全栈,大家都很浮躁,静下心来学东西的人变少了,线下一脱离ai,就原型毕露了 (当然也包括我),还是想要劝勉一下自己,希望自己不要浮躁,踏实求学
附件与分析入口
附件地址
通过网盘分享的文件:26bca527277d4957ac4b3e27d5a12db4.zip
链接: https://pan.baidu.com/s/12BDj271i0HYv4ZeDd2tZ7w?pwd=qnfh 提取码: qnfh
--来自百度网盘超级会员v1的分享
这个apk逆向题目的重点就在native层上, Java 层只负责 UI 交互,而核心的校验逻辑和 Flag 生成都放在了 Native层的函数
分析过程
java层
主界面 MainActivity
package com.example.re_flagvault;
import android.content.DialogInterface;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
import android.widget.TextView;
import android.widget.Toast;
import androidx.appcompat.app.AlertDialog;
import androidx.appcompat.app.AppCompatActivity;
/* loaded from: classes.dex */
public class MainActivity extends AppCompatActivity {
private Button btnLogin;
private EditText etPassword;
private EditText etUsername;
public native String getFlag();
public native boolean verifyLogin(String str, String str2);
static {
System.loadLibrary("re_flagvault");
}
@Override // androidx.fragment.app.FragmentActivity, androidx.activity.ComponentActivity, androidx.core.app.ComponentActivity, android.app.Activity
protected void onCreate(Bundle bundle) {
super.onCreate(bundle);
setContentView(C0541R.layout.activity_main);
((TextView) findViewById(C0541R.id.tv_title)).setText("🏴 FlagVault 🏴\n\n请输入正确的用户名和密码");
this.etUsername = (EditText) findViewById(C0541R.id.et_username);
this.etPassword = (EditText) findViewById(C0541R.id.et_password);
Button button = (Button) findViewById(C0541R.id.btn_login);
this.btnLogin = button;
button.setOnClickListener(new View.OnClickListener() { // from class: com.example.re_flagvault.MainActivity.1
@Override // android.view.View.OnClickListener
public void onClick(View view) {
String string = MainActivity.this.etUsername.getText().toString();
String string2 = MainActivity.this.etPassword.getText().toString();
if (string.isEmpty() || string2.isEmpty()) {
Toast.makeText(MainActivity.this, "请输入用户名和密码", 0).show();
} else if (MainActivity.this.verifyLogin(string, string2)) {
MainActivity.this.showFlag();
} else {
Toast.makeText(MainActivity.this, "用户名或密码错误!", 0).show();
}
}
});
}
/* JADX INFO: Access modifiers changed from: private */
public void showFlag() {
new AlertDialog.Builder(this).setTitle("🎉 恭喜!").setMessage("登录成功!\n\nFlag: " + getFlag()).setPositiveButton("确定", (DialogInterface.OnClickListener) null).show();
}
}可以看出来 Java 层只负责 UI 交互,而核心的校验逻辑和 Flag 生成都放在了 Native
所以我们需要重点去分析一下native 层函数,也就是 \FlagVault\lib\x86_64\libre_flagvault.so
核心结构与本地库加载
代码开头定义了两个 Native 方法(本地方法),这意味着它们的具体实现不在 Java 代码中,而是在编译后的 .so 二进制文件中。
public native String getFlag();:用于获取最终的 Flag 字符串。
public native boolean verifyLogin(String str, String str2);:用于验证用户名和密码是否正确。
static {
System.loadLibrary("re_flagvault");
}程序启动时会加载名为 libre_flagvault.so 的库文件。逆向的重点通常就在这个文件中。
UI 组件初始化
在 onCreate 方法中,程序完成了界面的基本设置:
输入框:etUsername(用户名)和 etPassword(密码)。
按钮:btnLogin(登录按钮)。
提示文案:标题被设置为 “FlagVault”,并提示用户输入正确的用户名和密码。
登录逻辑流程
程序为登录按钮设置了一个 OnClickListener。点击之后,它先读取输入框中的 string 和 string2,也就是用户名和密码。
如果任一字段为空,界面层不会把请求继续往下传,而是直接弹出 Toast,提示用户先输入完整信息。
真正的校验动作发生在 verifyLogin(string, string2)。这个函数是 native 方法,Java 层本身不参与用户名密码的判断,只负责把两个字符串转交给底层 C/C++ 代码。
当 verifyLogin 返回 true 时,程序继续调用 showFlag()。如果返回 false,界面层只会弹出用户名或密码错误的提示,不会再进入取 flag 的流程。
Flag 展示机制
当校验通过后,showFlag() 方法会被触发:
private void showFlag() {
new AlertDialog.Builder(this)
.setTitle("🎉 恭喜!")
.setMessage("登录成功!\n\nFlag: " + getFlag())
.setPositiveButton("确定", null)
.show();
}这里再次调用了 Native 方法 getFlag(),将获取到的 Flag 以弹窗的形式展示给用户。
Native层
经过上面的分析,我们要想获取flag的话,其实直接去看.so文件中的getflag函数即可,但是出于深度探讨的目的,继续分析一下,登录的校验逻辑
重点看两个函数
verifyLogin() 和 showFlag()
verifyLogin()
__int64 __fastcall Java_com_example_re_1flagvault_MainActivity_verifyLogin(
__int64 a1,
__int64 a2,
__int64 a3,
__int64 a4)
{
const char *v6; // r15
const char *v7; // r13
size_t v8; // rax
__int64 v9; // rdx
size_t v10; // rbx
char *v11; // rbp
unsigned __int64 v12; // r15
int v13; // eax
int v14; // ecx
int v15; // edx
int v16; // esi
unsigned __int64 i; // rdi
unsigned int v18; // r8d
unsigned int v19; // ebx
int v20; // r9d
int v21; // r10d
__int64 (__fastcall **v22)(); // rax
__int64 v23; // rax
char *v24; // rbx
__int64 v25; // rax
__int64 j; // r12
__int64 v27; // rsi
const __m128i *v28; // rax
__m128i v29; // xmm0
__int64 v32; // [rsp+18h] [rbp-190h]
char *s1; // [rsp+20h] [rbp-188h]
unsigned __int8 v34; // [rsp+28h] [rbp-180h] BYREF
char v35; // [rsp+29h] [rbp-17Fh] BYREF
__int64 v36; // [rsp+30h] [rbp-178h]
void *v37; // [rsp+38h] [rbp-170h]
_BYTE v38[8]; // [rsp+40h] [rbp-168h] BYREF
_QWORD v39[2]; // [rsp+48h] [rbp-160h] BYREF
__int64 (__fastcall **v40)(); // [rsp+58h] [rbp-150h] BYREF
_QWORD v41[8]; // [rsp+60h] [rbp-148h] BYREF
char v42; // [rsp+A0h] [rbp-108h]
void *ptr; // [rsp+B0h] [rbp-F8h]
_BYTE v44[152]; // [rsp+C8h] [rbp-E0h] BYREF
__int128 v45; // [rsp+160h] [rbp-48h] BYREF
unsigned __int64 v46; // [rsp+170h] [rbp-38h]
v46 = __readfsqword(0x28u);
v6 = (const char *)(*(__int64 (__fastcall **)(__int64, __int64, _QWORD))(*(_QWORD *)a1 + 1352LL))(a1, a3, 0);
v32 = a4;
v7 = (const char *)(*(__int64 (__fastcall **)(__int64, __int64, _QWORD))(*(_QWORD *)a1 + 1352LL))(a1, a4, 0);
v45 = 0;
v8 = strlen(v6);
v9 = 16;
if ( v8 < 0x10 )
v9 = v8;
s1 = (char *)v6;
__memcpy_chk(&v45, v6, v9, 16);
v10 = strlen(v7);
v11 = (char *)operator new[]((v10 + 7) & 0xFFFFFFFFFFFFFFF8LL);
memset(v11, 0, (v10 + 7) & 0xFFFFFFFFFFFFFFF8LL);
memcpy(v11, v7, v10);
v12 = (v10 + 7) & 0xFFFFFFFFFFFFFFF8LL;
if ( v12 )
{
v13 = v45;
v14 = DWORD1(v45);
v15 = DWORD2(v45);
v16 = HIDWORD(v45);
for ( i = 0; i < v12; i += 8LL )
{
v18 = *(_DWORD *)&v11[i];
v19 = *(_DWORD *)&v11[i + 4];
v20 = 16;
v21 = -1640531527;
do
{
v18 += (v13 + 16 * v19) ^ (v19 + v21) ^ (v14 + (v19 >> 5));
v19 += (v15 + 16 * v18) ^ (v21 + v18) ^ (v16 + (v18 >> 5));
v21 -= 1640531527;
--v20;
}
while ( v20 );
*(_DWORD *)&v11[i] = v18;
*(_DWORD *)&v11[i + 4] = v19;
}
}
sub_60F70((__int64)v39);
v22 = v40;
*(_DWORD *)((char *)v41 + (_QWORD)*(v40 - 3)) = *(_DWORD *)((_BYTE *)v41 + (_QWORD)*(v40 - 3)) & 0xFFFFFFB5 | 8;
v23 = (__int64)*(v22 - 3);
v24 = (char *)&v41[-1] + v23;
if ( *(_DWORD *)&v44[v23 + 32] == -1 )
{
std::ios_base::getloc((#42 *)v38);
v25 = std::locale::use_facet((#48 *)v38, (#75 *)&std::ctype<char>::id);
(*(void (__fastcall **)(__int64, __int64))(*(_QWORD *)v25 + 56LL))(v25, 32);
std::locale::~locale((#48 *)v38);
}
*((_DWORD *)v24 + 36) = 48;
if ( v12 )
{
for ( j = 0; j != v12; ++j )
{
*(_QWORD *)((char *)&v41[2] + (_QWORD)*(v40 - 3)) = 2;
std::ostream::operator<<(&v40, (unsigned __int8)v11[j]);
}
}
std::stringbuf::str(&v34, v41);
v39[0] = off_CBED0;
*(_QWORD *)((char *)v39 + (_QWORD)off_CBED0[-3]) = off_CBF20;
v40 = off_CBEF8;
v41[0] = off_CBBA8;
if ( (v42 & 1) != 0 )
operator delete(ptr);
std::streambuf::~streambuf(v41);
std::iostream::~iostream((__int64)v39, (__int64)&off_CBF38);
std::ios::~ios(v44);
operator delete[](v11);
if ( strcmp(s1, "admin") )
{
LODWORD(v11) = 0;
v27 = a3;
goto LABEL_25;
}
v27 = a3;
if ( (v34 & 1) == 0 )
{
if ( v34 >> 1 != 32 )
goto LABEL_19;
LABEL_21:
if ( (v34 & 1) != 0 )
v28 = (const __m128i *)v37;
else
v28 = (const __m128i *)&v35;
v29 = _mm_or_si128(
_mm_xor_si128(_mm_loadu_si128(v28), (__m128i)xmmword_41D20),
_mm_xor_si128(_mm_loadu_si128(v28 + 1), (__m128i)xmmword_41CD0));
LOBYTE(v11) = _mm_testz_si128(v29, v29);
goto LABEL_25;
}
if ( v36 == 32 )
goto LABEL_21;
LABEL_19:
LODWORD(v11) = 0;
LABEL_25:
(*(void (__fastcall **)(__int64, __int64, char *))(*(_QWORD *)a1 + 1360LL))(a1, v27, s1);
(*(void (__fastcall **)(__int64, __int64, const char *))(*(_QWORD *)a1 + 1360LL))(a1, v32, v7);
if ( (v34 & 1) != 0 )
operator delete(v37);
return (unsigned int)v11;
}接收两个 Java 字符串参数,并通过 GetStringUTFChars 取出
a3 -> 用户名
a4 -> 密码
函数末尾返回 0/1,就是Native登录判断。
用户名校验
函数尾部
if ( strcmp(s1, "admin") )
{
result = 0;
goto end;
}用户名是
admin密码加密逻辑
Key 来源
函数先把用户名前 16 字节复制到局部变量 v45 中,不足 16 字节补零:
v45 = 0;
memcpy(&v45, username, min(strlen(username), 16));因为正确用户名是 admin,所以最终 key 的 16 字节内容就是:
61 64 6d 69 6e 00 00 00 00 00 00 00 00 00 00 00按小端拆成 4 个 uint32:
k0 = 0x696d6461
k1 = 0x0000006e
k2 = 0x00000000
k3 = 0x00000000分组加密算法
密码会被复制到新缓冲区,并按 8 字节对齐,不足部分补零:
buf = new char[(len + 7) & ~7];
memset(buf, 0, aligned_len);
memcpy(buf, password, len);之后每 8 字节作为一组,按两个 uint32 执行 16 轮迭代:
for each 8-byte block:
v0 = *(uint32*)(buf + i)
v1 = *(uint32*)(buf + i + 4)
sum = 0x9e3779b9
repeat 16 times:
v0 += (k0 + 16*v1) ^ (v1 + sum) ^ (k1 + (v1 >> 5))
v1 += (k2 + 16*v0) ^ (sum + v0) ^ (k3 + (v0 >> 5))
sum -= 0x61c88647这就是 XTEA 64-bit 分组加密。
密文比较
加密后的每个字节不会直接比较,而是被格式化成 2 位十六进制字符串:
std::hex
std::setfill('0')
std::setw(2)
ostream << (unsigned __int8)buf[i]所以最终比较对象是一个长度固定为 32 的十六进制字符串
函数中用于比较的两个 16-byte 常量分别位于:
xmmword_41D20 -> ef639eee55113f25
xmmword_41CD0 -> 49554199fff1d33f
拼接后目标串为:
ef639eee55113f2549554199fff1d33f还原登录口令
import struct
hexs = "ef639eee55113f2549554199fff1d33f"
ct = bytes.fromhex(hexs)
key_bytes = b"admin" + b"\x00" * 11
k = struct.unpack("<4I", key_bytes)
DELTA = 0x9E3779B9
SUM = (DELTA * 16) & 0xffffffff
pt = b""
for i in range(0, len(ct), 8):
v0, v1 = struct.unpack("<2I", ct[i:i+8])
s = SUM
for _ in range(16):
v1 = (v1 - ((k[2] + ((v0 << 4) & 0xffffffff)) ^ ((s + v0) & 0xffffffff) ^ (k[3] + (v0 >> 5)))) & 0xffffffff
v0 = (v0 - ((k[0] + ((v1 << 4) & 0xffffffff)) ^ ((v1 + s) & 0xffffffff) ^ (k[1] + (v1 >> 5)))) & 0xffffffff
s = (s - DELTA) & 0xffffffff
pt += struct.pack("<2I", v0, v1)
print(pt)
print(pt.rstrip(b"\x00"))b'r3vers3_m4st3r\x00\x00'
b'r3vers3_m4st3r'因此正确密码为:
r3vers3_m4st3r在雷电模拟器登录成功
直接还原 getFlag
在赛场上,其实根本不需要去逆向登录逻辑,我们从java层主入口函数就看出来有个 getflag函数,会在登录后把flag回显
getFlag
__int64 __fastcall Java_com_example_re_1flagvault_MainActivity_getFlag(__int64 a1)
{
char v1; // cl
char *v2; // rax
char v4[32]; // [rsp+0h] [rbp-28h] BYREF
unsigned __int64 v5; // [rsp+20h] [rbp-8h]
v5 = __readfsqword(0x28u);
strcpy(v4, "akf`|fk`7unsojXjfts4uX5751z");
v1 = 97;
v2 = &v4[1];
do
{
*(v2 - 1) = v1 ^ 7;
v1 = *v2++;
}
while ( v1 );
return (*(__int64 (__fastcall **)(__int64, char *))(*(_QWORD *)a1 + 1336LL))(a1, v4);
}核心逻辑就是将akf|fk7unsojXjfts4uX5751z 异或 0x7 然后输出
flag恢复脚本
a="akf`|fk`7unsojXjfts4uX5751z"
for i in a:
print(chr(ord(i)^7),end="")flag
flag{alg0rithm_mast3r_2026}引发的思考
这题真正的分析重心在哪里
这个题表面上是一个 Android 登录框,实际重心基本不在界面层。Java 层只有两个工作。一个是把用户名和密码从输入框里取出来,然后调用 verifyLogin。另一个是在校验通过之后调用 getFlag 把 flag 显示出来。也就是说,Java 层没有参与任何真正意义上的秘密生成,它只是桥。
从这个角度回看主入口,其实切入点非常明确。MainActivity 里只有两个 native 方法:
public native String getFlag();
public native boolean verifyLogin(String str, String str2);如果只求交 flag,getFlag 天然值得怀疑,因为它显然是最终值的来源。如果想把登录过程吃透,那 verifyLogin 才是最该优先解的函数。换句话说,这题有两条路,一条是功能路径,一条是结果路径。功能路径更完整,结果路径更短。两条路最后都能收敛到答案,但文章要写深一点,肯定不能只满足于走最短那条。
从 JNI 函数签名开始看,native 层到底拿到了什么
verifyLogin 的导出名是:
Java_com_example_re_1flagvault_MainActivity_verifyLogin这类名字非常标准,说明没有做动态注册,JNI 映射关系在符号层面就是明牌。函数原型虽然在反编译结果里被还原成四个 __int64,但结合 JNI 约定可以知道:
jboolean Java_com_example_re_1flagvault_MainActivity_verifyLogin(
JNIEnv *env,
jobject thiz,
jstring username,
jstring password
)这里最值得注意的不是参数本身,而是它后面那两次通过虚表偏移发起的调用。反编译里这两句长得很像噪音:
v6 = (const char *)(*(__int64 (__fastcall **)(__int64, __int64, _QWORD))(*(_QWORD *)a1 + 1352LL))(a1, a3, 0);
v7 = (const char *)(*(__int64 (__fastcall **)(__int64, __int64, _QWORD))(*(_QWORD *)a1 + 1352LL))(a1, a4, 0);但 JNI 题不能把这种虚表调用当成噪音。因为一旦把偏移认出来,整段函数的结构就会瞬间干净很多。+1352 对应的就是 GetStringUTFChars,函数结尾那两次 +1360 则对应 ReleaseStringUTFChars。也就是说 native 层先把 Java 字符串拉成 C 字符串,处理完再释放,整个资源管理动作是完整的。
把这些 JNI 调用语义抹掉之后,函数骨架其实可以压缩成这样:
const char *user = GetStringUTFChars(env, username, 0);
const char *pass = GetStringUTFChars(env, password, 0);
build_key_from_username(user);
encrypt_password_buffer(pass);
hex_encode_ciphertext();
compare_with_embedded_target();
ReleaseStringUTFChars(env, username, user);
ReleaseStringUTFChars(env, password, pass);
return result;到这一步,这题已经从 Android 题缩成了一个普通的 native 校验题。真正后面需要做的事,只剩下把 build_key_from_username、encrypt_password_buffer 和 compare_with_embedded_target 逐段拆开。
用户名不只是做了字符串比较,它还参与了密钥构造
原文里已经指出用户名必须是 admin,这个结论当然对,但如果只写到这里,读者会以为用户名的作用仅仅是最后那句 strcmp。其实不是。用户名在这题里还承担了一个更关键的职责,就是直接参与构造密码加密时使用的 128 bit key。
相关代码很短:
v45 = 0;
v8 = strlen(v6);
v9 = 16;
if ( v8 < 0x10 )
v9 = v8;
__memcpy_chk(&v45, v6, v9, 16);这段逻辑说得直白一点,就是先把一个 16 字节缓冲区清零,再把用户名拷贝进去,最多拷 16 字节。短于 16 的部分保持为 0。也就是说,用户名会变成一个零填充后的 16 字节密钥材料。
如果用户名是 admin,按 ASCII 展开就是:
61 64 6d 69 6e 00 00 00 00 00 00 00 00 00 00 00在 x86_64 little-endian 环境下把它拆成四个 32 位整数,得到的是:
k0 = 0x696d6461
k1 = 0x0000006e
k2 = 0x00000000
k3 = 0x00000000这个细节其实很有意思。题目最后的显式用户名检查把值锁死成了 admin,所以从可满足性上看,用户名不是一个真正自由的输入。但在算法结构上,出题人并没有把用户名写死到加密函数里,而是让它真的参与了 key 生成。
密码缓冲区的对齐方式,直接限制了正确密码长度区间
密码进来之后,并不是立即拿去比较,而是先被重新分配到一块按 8 字节对齐的新缓冲区里:
v10 = strlen(v7);
v11 = (char *)operator new[]((v10 + 7) & 0xFFFFFFFFFFFFFFF8LL);
memset(v11, 0, (v10 + 7) & 0xFFFFFFFFFFFFFFF8LL);
memcpy(v11, v7, v10);
v12 = (v10 + 7) & 0xFFFFFFFFFFFFFFF8LL;这里的 (len + 7) & ~7 很典型,就是把长度向上对齐到 8 的倍数。因为后面加密循环每次处理 8 字节,所以出题人先做了零填充。这个地方如果只是看成“为了方便循环”,其实还是浅了点。更有价值的地方在于,它和后面十六进制输出后的长度检查组合起来之后,能够反推出明文密码长度所在的范围。
后面程序会把密文每个字节都格式化成两位十六进制字符,最终要求结果串长度是 32。32 个十六进制字符对应 16 个字节密文,而 16 个字节密文又对应对齐后的密码缓冲区长度必须是 16。
加密循环有很强的 XTEA 指纹
核心循环如下:
v18 = *(_DWORD *)&v11[i];
v19 = *(_DWORD *)&v11[i + 4];
v20 = 16;
v21 = -1640531527;
do
{
v18 += (v13 + 16 * v19) ^ (v19 + v21) ^ (v14 + (v19 >> 5));
v19 += (v15 + 16 * v18) ^ (v21 + v18) ^ (v16 + (v18 >> 5));
v21 -= 1640531527;
--v20;
}
while ( v20 );这段代码的几个特征几乎是明牌。
先看分组大小。每次取两个 32 位字,合起来就是 64 bit block。这和 TEA 家族的基本块大小一致。
再看轮函数。里面同时出现了左移 4 位、右移 5 位、与 key 的四个 32 位字混合、再加上一个不断变化的 sum 值。这也是 TEA/XTEA 非常典型的结构。普通人自己手写一个加密校验,通常写不出这种轮函数;一旦出现这种组合,基本就该往 TEA 家族上靠。
最后看常量。1640531527 的十六进制形式是 0x61C88647,而 0x9E3779B9 + 0x61C88647 == 2^32。这两个数本质上是互为补码关系。TEA 家族里最有辨识度的常量就是黄金分割相关的 0x9E3779B9。反编译器因为把它按有符号整数解释,才会在代码里出现 -1640531527 这种看着别扭的写法。把它重新看成无符号,整个结构就顺了。
可以把这段代码整理成更接近算法本体的形式:
uint32_t v0 = block[0];
uint32_t v1 = block[1];
uint32_t sum = 0x9E3779B9;
for (int r = 0; r < 16; r++) {
v0 += ((k0 + (v1 << 4)) ^ (v1 + sum) ^ (k1 + (v1 >> 5)));
v1 += ((k2 + (v0 << 4)) ^ (sum + v0) ^ (k3 + (v0 >> 5)));
sum += 0x9E3779B9;
}这里写成 sum += 0x9E3779B9 或写成反编译里的负数递减,本质没有区别,都是在模 2^32 环境里滚动。
再和标准 TEA/XTEA 对照,这题采用了更接近 XTEA 风格的组合形式,轮数 16
十六进制输出不是装饰,它决定了最后比较的语义
前文给了 std::hex、setfill('0')、setw(2) 这三句的效果。这里可以再往下说一下,为什么它们一出现,基本就能断定这是在把密文写成连续小写 hex 字符串。
反编译里相关调用看起来比较绕,因为它经过了 std::stringstream 这一套 C++ 模板展开,还夹着 locale、streambuf、iostream 构造和析构。第一次看很容易被这些 C++ 标准库碎片干扰。
真正有意义的只有两处。
一处是:
*((_DWORD *)v24 + 36) = 48;这里把填充字符设成了 0x30,也就是字符 0。
另一处是循环中每次在写入前都会把 width 设成 2,然后把当前字节按 unsigned __int8 输出到流里:
*(_QWORD *)((char *)&v41[2] + (_QWORD)*(v40 - 3)) = 2;
std::ostream::operator<<(&v40, (unsigned __int8)v11[j]);结合前面 ios 标志位被改成 hex 模式,最后形成的就是标准的两位十六进制输出。例如字节 0x0a 会输出成 0a,字节 0xef 会输出成 ef。
这一步其实把二进制比较变成了文本比较。对出题人来说,这样做有两个好处。其一,密文常量可以直接以可见字符串形式放在只读区,不需要额外的二进制对比逻辑。其二,逆向时读常量更方便,但因为前面还隔着加密,所以也不至于失去题目价值。
最后的比较不是普通 strcmp,而是用 SIMD 一次性对 32 字节做全量归零判断
这一段是整题里我觉得写得比较漂亮的地方。出题人没有把最终目标串放成一个显式的 strcmp(cipher_hex, "...."),而是拆成了两个 16-byte 常量,用 SSE 指令做异或和归零测试:
v29 = _mm_or_si128(
_mm_xor_si128(_mm_loadu_si128(v28), (__m128i)xmmword_41D20),
_mm_xor_si128(_mm_loadu_si128(v28 + 1), (__m128i)xmmword_41CD0));
LOBYTE(v11) = _mm_testz_si128(v29, v29);把这三句拆开看,逻辑其实非常直给。
先把待比较的 32 字节拆成前后两个 16 字节。
每半段分别和目标常量做 XOR。
只要有任何一个字节不同,对应位置就不会是 0。
再把两段 XOR 结果做 OR。
最后 ptest 判断结果向量是否全为 0。
只要全为 0,就说明 32 字节完全相等。
这个比较方式比 strcmp 更“native 一点”,也更容易让文章写出味道来。因为它体现出出题人不是简单把逻辑编译了一遍,而是让编译器或手写实现留下了更接近底层的痕迹。对逆向来说,这种 SIMD 比较通常不是障碍,反而是证据。它明确告诉你这里比较的是固定长度二进制区域,不依赖 \0 截断,也不走普通字符串函数。
std::string 的那段分支,说明程序兼容了短字符串和堆字符串两种布局
反编译里有一段很多人会直接跳过去,因为看起来像 C++ 标准库噪音:
if ( (v34 & 1) == 0 )
{
if ( v34 >> 1 != 32 )
goto LABEL_19;
}
else if ( v36 != 32 )
{
goto LABEL_19;
}后面还有:
if ( (v34 & 1) != 0 )
v28 = (const __m128i *)v37;
else
v28 = (const __m128i *)&v35;这里其实是在处理 std::string 的两种存储形式。短字符串时内容直接放在对象内部,小于某个长度阈值就不分配堆内存。长字符串时才把指针、长度这些字段放到对象里,真实数据在堆上。不同标准库实现布局不同,但这个题里这套判断逻辑已经足够说明,程序在先判断字符串对象当前处于哪种模式,再按不同路径取长度和数据指针。
这段如果不看懂,也不影响拿到答案,但它对文章深度很关键。因为它表明你不是只盯着算法主循环,而是把比较前后的数据形态也吃透了。特别是在 Android NDK 题里,libc++ 的小字符串优化经常会把伪代码搅得很乱,能把这层噪音剥掉,说明逆向过程是扎实的。
把这段语义化后,就是:
std::string hex = stringstream.str();
if (hex.size() != 32)
return false;
const char *buf = hex.is_long() ? hex.heap_ptr() : hex.inline_buf();
return memcmp_32_bytes(buf, target) == 0;这样一还原,整个 verifyLogin 的控制流就变得非常清晰。
把整个 verifyLogin 压成伪代码之后,题意就完全展开了
如果把 JNI 细节、C++ 流对象、SSE 比较这些都折叠掉,verifyLogin 的实质可以写成下面这个版本:
bool verifyLogin(const char *user, const char *pass) {
uint32_t k[4] = {0};
memcpy(k, user, min(strlen(user), 16));
size_t n = align8(strlen(pass));
uint8_t *buf = calloc(1, n);
memcpy(buf, pass, strlen(pass));
for (size_t i = 0; i < n; i += 8) {
xtea_like_encrypt((uint32_t *)&buf[i], k, 16);
}
std::string hex = to_lower_hex(buf, n);
free(buf);
if (strcmp(user, "admin") != 0)
return false;
if (hex.size() != 32)
return false;
return hex == "ef639eee55113f2549554199fff1d33f";
}写到这一步,题已经没有任何黑盒成分了。用户名条件、密码长度条件、加密算法、比较常量,全都在一个平面上了。后续反推密码只是机械活。
这题的目标 hex 串是:
ef639eee55113f2549554199fff1d33f把它按 8 字节分成两组密文块:
ef 63 9e ee 55 11 3f 25
49 55 41 99 ff f1 d3 3f按 little-endian 解释,就是两对 uint32_t。再配合前面从 admin 派生出的 k0..k3,就能一轮轮逆回来。
import struct
hexs = "ef639eee55113f2549554199fff1d33f"
ct = bytes.fromhex(hexs)
key = b"admin" + b"\x00" * 11
k0, k1, k2, k3 = struct.unpack("<4I", key)
DELTA = 0x9E3779B9
SUM = (DELTA * 16) & 0xffffffff
pt = bytearray()
for off in range(0, len(ct), 8):
v0, v1 = struct.unpack("<2I", ct[off:off + 8])
s = SUM
for _ in range(16):
v1 = (v1 - (((k2 + ((v0 << 4) & 0xffffffff)) ^ ((s + v0) & 0xffffffff) ^ (k3 + (v0 >> 5))))) & 0xffffffff
v0 = (v0 - (((k0 + ((v1 << 4) & 0xffffffff)) ^ ((v1 + s) & 0xffffffff) ^ (k1 + (v1 >> 5))))) & 0xffffffff
s = (s - DELTA) & 0xffffffff
pt += struct.pack("<2I", v0, v1)
print(pt)
print(pt.rstrip(b"\x00"))跑出来是:
b'r3vers3_m4st3r\x00\x00'
b'r3vers3_m4st3r'尾部两个 \x00 正好对应前面讲过的 8 字节对齐补零。这个输出既验证了解密逻辑,也反向印证了长度分析。因为 r3vers3_m4st3r 正好 14 个字符,对齐后是 16 字节,非常吻合。
我个人觉得这题出得挺顺手。不是那种堆满陷阱、全程恶心人的题,也不是白给。它有明确入口,有算法主体,有可以静态完成的证据链,还有一个给比赛节奏留出口的 getFlag。对真正做逆向的人来说,这种题其实很舒服,因为每往下啃一层都会有收获,不会出现啃了半天全是壳和噪音的情况。
同时它也挺适合拿来区分两种状态。一种是只会跟着 Java 层走,看到 native 就发怵。另一种是能很快判断 Java 只是桥,然后把视线稳稳落到 .so。这两种状态差距不在知识点多寡,而在有没有形成自己的分析顺序。
我自己复盘这题时比较明显的感受就是,native 题一旦入口找对,后面其实不需要太花哨的技巧。耐心把数据流梳直,比什么都重要。用户名怎么进 key,密码怎么补齐,密文怎么编码,常量怎么比较,这几件事一件件落地,题自然就开了。
结语
这题真正值得写的不是最后那句用户名和密码,而是整个认证链路怎么在 native 层被组织起来。只要把 Java 层、JNI 桥接、用户名密钥派生、XTEA 风格加密、hex 编码和 SSE 比较这一串吃透,这题的主体就算真正做完了