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 比较这一串吃透,这题的主体就算真正做完了