首页
社区
课程
招聘
随性一次对某某支付引擎的逆向
发表于: 7小时前 212

随性一次对某某支付引擎的逆向

7小时前
212

我们直接猛攻一个支付apk。因为是用于支付的,它的防护强度跟别的 apk 不一样,常规那套强跳未必使得上。这趟我主要想试页面强跳和接口测试,上手先来最基本的,看能不能强行跳进它的页面、直接摸到它对外暴露的接口。手上两摊材料,一摊是它 native 库里那段加密逻辑,另一摊是模拟器里跑起来之后抓到的 hook 日志。

口令就藏在 SP 项里,是一串 base64。我从这串东西开始往下挖。


第一部|mobileaix 口令解密线

TOP0 目标、材料与环境

要解的是 mobileaix 工作流数据库用的 SQLCipher 口令,我把它叫 antsp。它就存在 SP(SharedPreferences)里,是一串 152 字符的 base64,解码后是 112 字节密文。按加密后的长度倒推,明文应该是 97 字节。

我拿到 apk 之后没急着往下解,先把环境理清楚,这一步踩过坑。真正能用的是几十个脚本和它们吐出来的输出。

目标:解密 mobileaix 工作流数据库口令(代号 antsp)
  │
  ├── 密文载体:SP 项
  │     ├── key  : mobileaix_datacenter_db_password
  │     ├── 形态 : 152 字符 base64
  │     ├── 解码 : 112 B 密文
  │     └── 明文 : 97 B(预期,未直接读出)
  │
  └── 环境注记
        ├── 日志体积很大(654 MB / 582 MB,UTF-16LE)
        ├── PowerShell 重定向输出为 UTF-16LE,Python 读取需 decode('utf-16-le')
        └── 动手前先确认源目录已清空

环境上先撞见三件事。日志大得离谱,一次 654 MB、一次 582 MB。PowerShell 重定向出来是 UTF-16LE,Python 读的时候得显式 decode('utf-16-le'),不然全是乱码。还有动手前得先确认源目录清空了,迁移可能还没做完。这些当时都影响了我后面怎么读输出。

TOP1 SP 密文与口令生成器

我想知道明文长什么样,同时把它的生成规则摸清楚。SP key 和口令生成规则前面已经拿到,从这里接着往下。

口令明文(预期 97 B)
  │
  ├── 字符集:62 个
  │     ├── 小写段 zxcvbnmlkjhgfdsaqwertyuiop
  │     ├── 大写段 QWERTYUIOPASDFGHJKLZXCVBNM
  │     └── 数字段 1234567890
  │
  ├── 抽样:Random.nextInt(62)
  ├── 次数:97 轮
  ├── 拼接:无前缀、无分隔符
  └── 结论:明文形态 = 97 位、字符集受限(未直接读出,属预期)

我看到的是一个 62 字符的字母数字表,顺序固定,代码用 Random.nextInt(62) 循环抽 97 次,无前缀直接拼起来,所以明文应该是一个 97 位、字符只落在这个表里的串。后面如果真解出了东西,长得不像 97 位受限字符集,那就错了。

SP key 是 mobileaix_datacenter_db_password,来自 classes15.dex 的字符串 id 59466。

为了确认这个 key 是不是真被代码用到,我写了个 DEX 引用扫描脚本去跑它。结果冒出来两个数,一版输出说引用 780 处,另一版说 391 处。我一开始以为是脚本写错了,回头看才发现两版统计口径不一样,前者按虚方法字段去重前的计数,后者标的是引用 391 处这样的字样。两个数都留着。

引用命中的类集中在检测与配置族
  UIDetectRoutingInspection / UIDetectServiceImpl
  UIDetectServiceImplInner / UIDetectConfig
  CompatibilityDetectConfig / QrCodeDetectConfig
  WhiteScreenDetectConfig / PbUtilInner / PerformanceUtils ...

命中都集中在检测和配置这一族类上,说明那个 key 串在 DEX 里被大量类常量池共享,字符串 id 命中不等于真有人读写了这个 SP 项。这 780 / 391 处引用大部分是噪音背景,不能当成这里就是读写点的证据,我后面也就没在字符串引用上白费功夫。

TOP2 Java 调用链(读与写)

字符串引用靠不住,我就换个方向,顺着实际的读写调用往下追。读写两条链在 Java 层都是无变换的,只是把参数薄薄地透传到 JNI,没做派生或二次变换。这两条链是:

读:PasswordUtils.getPassWord()
  → sp.getString(key, "")
  → SecurityEncryptor.decryptString(antsp)
  → EncryptDataUtils.decrypt
  → JNI 偏移 0x5658
  → PLT
  → sgStaticSafeEncryptData(mode = 2)
写:PasswordUtils.a()
  → SecurityEncryptor.encrypt(明文 97 B)
  → EncryptDataUtils.encrypt
  → JNI 偏移 0x559c
  → sgStaticSafeEncryptData(mode = 1)
  → putString(key, 密文).apply()

追下来发现,SecurityEncryptor.encrypt / decryptString 只是 EncryptDataUtils 的一层薄封装,Java 层没有 key 变换。这就把问题整个推到了 native 侧。明文能不能还原,取决于 so 里那个 sgStaticSafeEncryptData 怎么实现,以及它依赖的运行时 key 和全局对象状态。

两个 JNI 偏移 0x5658(解密)和 0x559c(加密)是 Java 进 native 的落点,mode=1/2 是同一个 native 函数的加解密方向开关。这些数字我按原样记下,没改动。

TOP3 薄封装与惰性初始化

追到 native 之前,我先排掉了两处看起来像 key 装载、其实无关的初始化。不排掉它们,我可能会在错误的函数上死磕。

  • initNative @0x5238 就是个 SetApiLevel,写 0x3e8f0,没有任何 key 装载动作。
  • 惰性初始化 @0x5714 读 bss 标志 0x3e8f4 / 0x3e908 → bl 0x35d10(shadowhook_init)→ 置位,跟 key 无关。
initNative @ 0x5238
  └── SetApiLevel
        └── 写 0x3e8f0            (无 key 装载,排除)

惰性初始化 @ 0x5714
  ├── 读 bss 标志 0x3e8f4
  ├── 读 bss 标志 0x3e908
  ├── bl 0x35c10 → 0x35d10        (shadowhook_init)
  └── 置位标志                    (与 key 无关,排除)

那轮反汇编还顺带打出了 PLT thunk 到 GOT 的映射:

thunk 0x35c80 -> GOT 0x308
thunk 0x35c90 -> GOT 0x310
thunk 0x35cd0 -> GOT 0x330
thunk 0x35ce0 -> GOT 0x338
thunk 0x35cf0 -> GOT 0x340
thunk 0x35d10 -> GOT 0x350        ← shadowhook_init

这份输出末尾带了一条 Python 报错 TypeError: %x format: an integer is required, not NoneType,那轮脚本解析到某个动态段字段时没拿到值,直接退出了。上面那个 thunk 映射只是它退出前打出来的一部分,后面的解析没跑完。我当时没修这个脚本,报错连同输出一起留着。解析未完成。

TOP4 目标 so 的 ELF 测绘

排掉干扰项之后,焦点落到 libperf.so(arm64-v8a)上。我想补环境跑它,就得先把这个 so 的骨架摸清楚。我写脚本把 ELF 头和节区表整个测绘了一遍:

ELF 头
  ├── phoff      = 0x40
  ├── phentsize  = 56
  ├── phnum      = 9
  ├── shoff      = 0x36b50
  ├── shentsize  = 64
  ├── shnum      = 27
  └── shstrndx   = 26

PT_DYNAMIC: offset=0x360c8  vaddr=0x3a0c8

节区表
  ├── .dynsym    addr=0x2f8     off=0x2f8     size=0x540    type=11
  ├── .dynstr    addr=0x980     off=0x980     size=0x4c9    type=3
  ├── .rela.dyn  addr=0xe50     off=0xe50     size=0xae0    type=4
  ├── .rela.plt  addr=0x1930    off=0x1930    size=0x348    type=4
  ├── .text      addr=0x5110    off=0x5110    size=0x30b30  type=1
  ├── .dynamic   addr=0x3a0c8   off=0x360c8   size=0x1e0    type=6
  ├── .got       addr=0x3a2a8   off=0x362a8   size=0x38     type=1
  └── .got.plt   addr=0x3a2e0   off=0x362e0   size=0x130    type=1

测绘完我又看了 .rela.plt 的重定向项,想弄清它对外面的什么能力有依赖。这份 GOT 导入表比预想的长得多,我按地址从头到尾打出来,光 .rela.plt 就有三十多项,type 一律是 1026(R_AARCH64_JUMP_SLOT):

.rela.plt 导入符号(type=1026,按 GOT 地址)
  ├── 0x3a2f8  __cxa_finalize          0x3a300  __cxa_atexit
  ├── 0x3a308  __register_atfork       0x3a310  __stack_chk_fail
  ├── 0x3a318  to_string(int)          0x3a320  JNIEnv::NewObject
  ├── 0x3a328  operator delete         0x3a330  strlen
  ├── 0x3a338  sgStaticSafeEncryptData ← 目标函数本身也在导入表
  ├── 0x3a340  __android_log_write     0x3a348  pauseVerify(int)
  ├── 0x3a350  shadowhook_init         0x3a358  shadowhook_hook_sym_name
  ├── 0x3a360  __android_log_print     0x3a368  shadowhook_unhook
  ├── 0x3a370  free                    0x3a378  malloc
  ├── 0x3a380  memcpy                  0x3a388  memset
  ├── 0x3a390  realloc                 0x3a398  sprintf
  ├── 0x3a3a0  vsnprintf               0x3a3a8  calloc
  ├── 0x3a3b0  snprintf                0x3a3b8  toupper
  ├── 0x3a3c0  fprintf                 0x3a3c8  fflush
  ├── 0x3a3d0  abort                   0x3a3d8  pthread_rwlock_wrlock
  ├── 0x3a3e0  pthread_rwlock_unlock   0x3a3e8  dl_iterate_phdr
  ├── 0x3a3f0  pthread_rwlock_rdlock   0x3a3f8  getpid
  └── 0x3a400  syscall                 0x3a408  fwrite

紧接着 .rela.dyn 是一片 type=1027(R_AARCH64_RELATIVE)的项,从 0x39e90 起一长串符号名为空的条目,这就是后面 IRELATIVE 表那一大堆 addend 的落点区。

sgStaticSafeEncryptData 自己出现在 GOT 导入项里(0x3a338),so 内部对它是通过 PLT 调用的,外部也有引用。shadowhook_init / shadowhook_hook_sym_name / shadowhook_unhook 三个一组 in,跟之前惰性初始化里那个 bl 0x35d10 指向同一处,这是它自带的 inline hook 框架。toupper 的出现也和后面看到的 62 字符集大小写处理呼应。

to_string(int)、JNIEnv::NewObject、operator delete、__register_atfork、__stack_chk_fail 这一组符号凑在一起,指向 C++ 运行时加 JNI 交互,符合加密引擎封装加 JNI 桥的形态,补环境时该准备的桩也就清楚了,malloc 一类、C++ 运行时一类、JNI 一类。后面的 Unicorn 实验就从这里起步。

TOP5 IRELATIVE 表的四槽区

IRELATIVE 那块花的时间最多。我盯着那些项,想知道它们指向哪里,按理说 addend 应该是 resolver 函数的地址。我写了个解析脚本处理 R_AARCH64_IRELATIVE(类型 0x403)表,脚本一开跑打出来的表头是:

text addr=0x5110 size=0x5110 | got addr=0x3a2a8 size=0x362a8

addend 呈现出四种完全不同的形态,按形态分成四个区:

IRELATIVE 表(R_AARCH64_IRELATIVE = 0x403)
  │
  ├── 槽区 A:0x39e90 - 0x3a028(48 项)
  │     └── addend 为混淆乱值 / 超范围地址
  │          例:0x47fcbc26 / 0x1f756258 / 0x70378774
  │              0x53688094 / 0x106492dc / 0x67f0a786
  │              0xffffffffe8ba0fa2(明显越界)
  │          → 判读:疑似加密数据,不是直接地址
  │
  ├── 槽区 B:0x3a040 - 0x3a0c0(17 项)
  │     └── addend 为 .text 内合法地址
  │          0x326f0 / 0x326f8 / 0x32700 / 0x32744 / 0x3282c
  │          0x32914 / 0x32928 / 0x32938 / 0x32948 / 0x32a38
  │          0x32a7c / 0x32a88 / 0x32a94 / 0x32ac0 / 0x32d40
  │          0x5128 / 0x5110
  │          → 判读:非 ifunc resolver,是普通 C++ 成员函数
  │
  ├── 槽区 C:JNI 方法表 0x3e410 - 0x3e520
  │     └── addend 统一为函数地址右移两位
  │          0x1d2e -> 0x74b8
  │          0x25a6 -> 0x9698
  │          0x522c -> 0x148b0
  │          0x5230 -> 0x148c0
  │          → 全部落 .text,需 <<2 还原真实地址
  │
  └── 槽区 D:0x3e898 / 0x3e8a0 / 0x3e8a8(3 个特殊槽)
        └── addend = 0x42e60 / 0x42e60 / 0x43660
              <<2 后 = 0x10b980 / 0x10d980(超文件)
              → 判读:疑似运行时 mmap 指针(全局对象 / key 池指针槽)
              → 真机 dump 此处有 diff(真机已填值)

我逐个看过之后,槽区 A 那些值明显不是代码地址,0xffffffffe8ba0fa2 这种带符号扩展的乱值,加上一半项超出文件范围,我当时归为疑似加密数据。槽区 B 的 17 个地址全落在 .text(0x5110 起、size 0x30b30),是能真反汇编的代码。槽区 C 的 JNI 方法表有个统一特征,addend 是真实函数地址右移两位,要左移两位还原。

槽区 D 只有三个槽,指向文件外的 0x10b980 / 0x10d980,这个反常。我判断这是运行时才填值的指针槽,key 池很可能就挂在这里,得单独追一下。

TOP6 槽区 B 的 resolver 判读

槽区 B 长得最像 resolver,我不想凭形态下结论,就对那 17 个地址逐个反汇编。反汇编下来它们不是 ifunc resolver,是普通的 C++ 成员函数。

我靠两条现象判断。一是调用约定是 x0 = this / w1 = 参数,这是成员函数形态,resolver 不会这么带 this。二是函数体在读写对象字段(0x268 / 0xf8)和数组,不像在做地址解析。

槽区 B 的 17 个解析点(节选,file size 0x37210 = 225808 B)
  │
  ├── @ 0x326f0 / 0x326f8
  │     └── bti c ; ret            (空桩,仅 BTI 指令 + 返回)
  │
  ├── @ 0x32700
  │     ├── bti c
  │     ├── cmn w1, #3 ; b.ls 0x32714
  │     ├── mov w0, #1 ; ret
  │     ├── cmp w1, #0x5f ; b.ls 0x32724
  │     ├── mov w0, wzr ; ret        (w1>0x5f 返回 0)
  │     ├── cmp w1, #0x22 ; b.ne 0x32734
  │     └── mov w0, #1 ; ret          (字符分类:0x22 命中)
  │
  ├── @ 0x32928 / 0x32938
  │     └── double 数组访问器(对象字段偏移读取)
  │
  ├── @ 0x32a38
  │     └── 对象拷贝(this/源对象参数形态)
  │
  └── 对象字段偏移:0x268 / 0xf8
        └── 判读:JSON / 配置解析或加密引擎内部对象方法群

0x32700 那段是逐字节分类逻辑,cmn w1, #3 后 b.ls、cmp w1, #0x5f 后 b.ls、cmp w1, #0x22 后 b.ne,像在判断字符是否落在某个 ASCII 区间(引号 0x22、下划线 0x5f 是 JSON 和标识符里的常见字符)。0x32928 / 0x32938 读 double 数组,0x32a38 做对象拷贝,整体指向配置解析或引擎内部对象的方法集合。

槽区 B 虽然长得像 IRELATIVE 的 resolver,但语义上跟密钥无关,我把它从可能的 key 线索里划掉了。

TOP7 JNI 方法表与 addend 右移两位

槽区 C 那个 JNI 方法表(0x3e410 - 0x3e520)我单独核了一遍,它的地址变换很一致,addend 是真实函数地址 >> 2。我拿 DEX 引用和 IRELATIVE 两路输出交叉对着看,落点是这几个:

JNI 方法表 addend(<<2 还原)
  ├── 0x1d2e -> 0x74b8
  ├── 0x25a6 -> 0x9698
  ├── 0x522c -> 0x148b0
  ├── 0x5230 -> 0x148c0
  └── (更多项同规律,全部落 .text 0x5110-0x35c40)

0x522c / 0x5230 还原后是 0x148b0 / 0x148c0,紧邻的区域正是 JNI 方法实现附近。这里我没往下推断,initNative @0x5238 在文件偏移那一侧,跟还原出来的地址分属不同地址空间,不能混着用。所以只把变换规律和落点记下来,没做函数语义的发挥。

TOP8 三个特殊槽与运行时指针

槽区 D 是我这条线最想追的地方。那三个槽 0x3e898 / 0x3e8a0 / 0x3e8a8,addend 分别是 0x42e60 / 0x42e60 / 0x43660,左移两位后是 0x10b980 / 0x10d980,远超文件大小 0x37210,不可能是文件内地址。

我倾向于认为这些是运行时 mmap 出来的指针槽,属于引擎全局对象或者 key 池的指针位置。支撑这个判断的是一份真机 dump,我手上有一份 .data 段的 dump,覆盖 0x3e410 起 1184 字节,在这些槽位上跟本地静态文件有差异(真机填了值,静态文件里是空的)。

槽区 D
  │
  ├── 0x3e898  addend 0x42e60  <<2 = 0x10b980   超文件
  ├── 0x3e8a0  addend 0x42e60  <<2 = 0x10b980   超文件
  ├── 0x3e8a8  addend 0x43660  <<2 = 0x10d980   超文件
  │
  ├── 真机 .data dump
  │     ├── 覆盖 0x3e410 起 1184 B
  │     ├── 对应偏移:0x488 / 0x490 / 0x498
  │     └── 状态:真机此处有 diff(已填 8 B 值)
  │
  └── 待做(当时标注)
        ├── 读取 dump 偏移 0x488/0x490/0x498 的运行时 8 B 值
        ├── 若指向 .data/.bss 或 mmap 地址 -> 即 key 池位置
        └── 再反汇编确认 sgStaticSafeEncryptData@0x58a8 对这些全局槽的引用方式

下一步我想读那份 dump 里 0x488 / 0x490 / 0x498(对应绝对地址 0x3e898 / 0x3e8a0 / 0x3e8a8)的运行时 8 字节值,看它是不是指向 .data / .bss 或 mmap 地址。如果是,就定位到 key 池,再回头反汇编 sgStaticSafeEncryptData @ 0x58a8 看它怎么引用这些全局槽。

但这一步我到最后也没做。dump 我留着,那几个偏移的运行时值我没去读。

这里还出现了两个不同的函数地址说法,sgStaticSafeEncryptData @ 0x58a8(crypto 函数地址)和前面 JNI 落点 0x5658 / 0x559c、initNative @0x5238。它们是 so 内不同位置的地址,我分开记着,没硬把它们统一成一个。

TOP9 Unicorn 补环境框架

key 池是运行时才填值的,静态直接解不出明文,我换成用 Unicorn 把这段函数跑起来,用桩把外部依赖补上,观察它到底怎么把密文变成明文。目标函数锁定 sgStaticSafeEncryptData 的 decrypt 模式(mode=2)。

主线脚本是我写的 _emu_decrypt.py(396 行),文件头注释把输入输出写得很清楚:

_emu_decrypt.py
  ├── 目标:libperf.so::sgStaticSafeEncryptData (decrypt mode=2)
  ├── 输入:antsp base64 密文(SP 里那串,值脱敏)
  ├── 期望输出:97 字符随机串(明文口令)
  └── 方法:Unicorn ARM64 + capstone 反汇编

这套框架在好几个 _emu*.py 脚本里重复出现,跑的步骤大致是:

Unicorn 补环境框架(各 _emu 脚本共用)
  │
  ├── 1. 读 libperf.so,解析 ELF 头与节区
  │     ├── e_phoff / e_phentsize / e_phnum
  │     ├── e_shoff / e_shentsize / e_shnum / e_shstrndx
  │     └── shname() 通过 .shstrtab 解析节区名
  │
  ├── 2. 解析 .dynsym / .dynstr
  │     ├── soff / ssize / sent(符号表项大小)
  │     ├── stro / strsz(字符串表)
  │     └── 收集 syms[] 供 GOT 绑定
  │
  ├── 3. 映射段、装载镜像到 Unicorn 内存
  │
  ├── 4. 注册外部调用桩(hook)
  │     ├── malloc / memset / memcpy
  │     ├── __stack_chk_fail / __cxa_finalize 等
  │     └── JNIEnv::NewObject / to_string 等 C++ 运行时
  │
  ├── 5. 设置寄存器与栈,从目标函数入口开始模拟
  │
  └── 6. 记录内存写入、堆分配、结果槽,扫描明文

输出我统一用 io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8', errors='replace') 处理编码,绕开前面说的 PowerShell 重定向 UTF-16LE 那个坑。多份输出里还带着 pkg_resources is deprecated 的 UserWarning,我没删,留着原样。

TOP10 malloc / memset / memcpy 桩与堆表

补环境跑起来之后,内存分配表能看清这个函数执行过程中每次 malloc 发生在哪、返回什么地址。我写追踪脚本把调用点和返回地址都打了出来:

malloc 表(两轮追踪对照)
  │
  ├── malloc(0x68) from pc=0x1431c -> 0x40000000   content=全 0
  ├── malloc(0x99) from pc=0x19724 -> 0x40000070   content=全 0
  ├── malloc(0x68) from pc=0x18884 -> 0x40000110   content=全 0
  ├── malloc(0x73) from pc=0x162c8 -> 0x40000180   content=全 0
  ├── malloc(0x68) from pc=0xff10  -> 0x40000200   content=全 0
  ├── malloc(0x10) from pc=0x117cc -> 0x40000270   content=全 0
  ├── malloc(0x28) from pc=0x15d70 -> 0x40000280   content=全 0
  ├── malloc(0x68) from pc=0x24e9c -> 0x400002b0   content=全 0
  ├── malloc(0x11) from pc=0x24560 -> 0x40000320   content=全 0
  ├── malloc(0x68) from pc=0x24e9c -> 0x40000340   content=全 0
  ├── malloc(0x11) from pc=0x24560 -> 0x400003b0   content=全 0
  └── malloc(0x68) from pc=0x24e9c -> 0x400003d0   content=全 0

我又用参数级记录把桩调用打得更细,这样能看到 memset / memcpy 具体在干什么:

STUB 调用记录(节选)
  │
  ├── STUB malloc  x0=0x68                    -> 0x40000000
  ├── STUB memset  x0=0x40000008 x1=0x0 x2=0x60
  │     └── memset(dst=0x40000008, arg1=0x0, len=0x60)  dstpre=全 0
  ├── STUB malloc  x0=0x99                    -> 0x40000070
  ├── STUB memset  x0=0x40000070 x1=0x0 x2=0x99
  │     └── memset(dst=0x40000070, arg1=0x0, len=0x99)  dstpre=全 0
  └── STUB memcpy  x0=0x40000070 x1=0x70001000 x2=0x98
        └── memcpy(dst=0x40000070, arg1=0x70001000, len=0x98)
              └── 0x70001000 是模拟内存里预置的密文输入区

0x98 = 152 字节,正好对上 SP 里 base64 解码前的长度口径之一。0x40000000 起的堆区是我在 Unicorn 里给 malloc 桩指定的固定基址,方便跨轮对照。

追踪里有一处细节:某块内存在 malloc 前被写成了 42424242...(B16)。

0x40000270 内容变化事件(1)
  └── #0 pre-malloc  x30=0x15d70  4242...(16B)  <<< B16

我把 0x42(ASCII 'B')填充单独标出来当路标,用它是填充还是真实数据来区分内存区域,后面的 roundtrip 对照也用到了这个标记。

TOP11 已知明文-密文对与密钥暴破

为了在内存窗口里找密钥,我准备了一个已知明文-密文对当标尺。我写的 _brutekey.py(43 行)拿一段固定明文和它对应的密文,去穷举补环境跑出来的内存窗口,哪 16/24/32 字节能把这对加出来,那块就是密钥候选。

_brutekey.py(43 行)
  │
  ├── 明文 pt = 一段 19 B 的固定串(值脱敏)
  ├── 密文 ct = base64 解码后的已知对(值脱敏)
  ├── block0_pt = pt[:16]        (第一块,AES 块大小 16)
  │
  └── try_keys(buf, name, kl)
        ├── 滑窗取 kl 字节候选 key
        ├── AES.new(k, AES.MODE_ECB).encrypt(block0_pt)
        │     └── 比对 ct[:16] -> 命中打印 'ECB HIT'
        └── AES.new(k, AES.MODE_CBC, b'\x00'*16).encrypt(block0_pt)
              └── CBC 也试(IV=0)

我当时不确定目标用的是 ECB 还是 CBC,所以两种模式都试了(CBC 用 IV=0)。输出里没有出现 ECB HIT 这样的命中行。这次暴破没记录到命中。

TOP12 roundtrip 对照实验

既然直接暴破没结果,我又做了多轮加密再解密的对照,用自造的明文走完整链路,看成功路径的输出长什么样,再拿去跟 antsp 的结构比。相关脚本有一串:

roundtrip 系列实验
  │
  ├── _emu5_enc97.py       加密方向,输入 97 B 自造明文
  ├── _emu6_roundtrip97.py 97 B 加->解回环
  ├── _emu4_roundtrip.py   通用回环
  ├── _emu10_rt.py         DEC(ENC(hello)) 完整链路 + 堆/栈扫描
  │     └── 目标:确认成功路径的输出结构与 'B' 填充来源
  │            与 DEC(antsp) 对比
  └── _rt97.py             ENC(97B) -> b64 -> DEC 回环
        └── 对比输出密文结构与 antsp

我还专门写了 _emu11_slot.py 去 hook 结果槽的写入,因为解出来到底是什么,最终会写进某个槽,监视那个落点最直接。DEC(antsp) -> hook 0x1dea8 结果槽写入 + malloc 分配记录 + 全堆内容分析。0x1dea8 就是解密结果被写回的地址。

这些脚本的注释反复提到,成功路径的输出里带 0x42('B')填充,DEC(antsp) 的结果要跟它对比结构。如果 ENC(明文) -> 密文 的结构能和 antsp 对上,就能倒推 antsp 的明文形态。但和前面一样,这批实验脚本和输出留着了,没有留下结构一致、因此明文是某个值这样的定论。对照做到一半,结论没写。

TOP13 这条线最后停在哪

口令解密线到最后停在待做阶段。各处状态如下:

口令解密线状态汇总
  │
  ├── 已确认
  │     ├── SP key 与字符串 id 59466
  │     ├── 62 字符集 / nextInt(62) / 97 轮 / 无前缀
  │     ├── 读写调用链与 JNI 偏移 0x5658 / 0x559c
  │     ├── Java 层无 key 变换
  │     └── initNative / 惰性初始化与 key 无关
  │
  ├── 已解析
  │     ├── ELF 节区与 GOT/PLT
  │     ├── IRELATIVE 四槽区结构
  │     ├── 槽区 B 的 17 个成员函数据点
  │     └── slot D 运行时指针线索
  │
  ├── 已实验(Unicorn)
  │     ├── malloc/memset/memcpy 桩与堆表
  │     ├── 已知明文-密文对暴破准备
  │     └── roundtrip 对照系列
  │
  └── 待做(当时标注,未完成)
        ├── 读 dump 偏移 0x488/0x490/0x498 运行时 8 B 值
        ├── 判定是否 key 池指针
        ├── 反汇编 sgStaticSafeEncryptData@0x58a8 对全局槽的引用
        └── 确认明文 97 B(未直接读出)

明文到最后没解出来,按长度倒推期望是一个 97 位的随机串。线索定位到了运行时指针槽,补环境框架和观测手段搭起来了,那几个槽的运行时值没读,key 池没确认。

第二部|动态 hook 观测线

TOP14 观测环境与注入框架

第二条线是让它真跑起来看。我把环境搭在 Android 模拟器上(root)+ LSPosed 注入,目标是那个客户端的 12.12.6.8000 版本,测试账号是真实存在的,这里脱敏。设备时钟比宿主快大约 4 分钟,我当时比对日志时间点先把这个差减掉,不然先后顺序全乱。

观测环境
  │
  ├── 设备:Android 模拟器,root,KSU
  ├── 注入:LSPosed
  ├── Hook 模块:自研 Xposed 通用模块(GenericHook)
  │     └── 位置 /data/local/tmp/lsp_universal/
  │     └── 驱动:config.json(type / 类#方法 配置驱动)
  ├── 通信:adb(serial 脱敏)
  ├── 测试账号:已脱敏(记录里注明是真实存在的账号)
  └── 时间校正:设备时钟比宿主快约 4 分钟

动态线里我主要靠 GenericHook 这个模块。它不是给某个类写死的,而是靠 config.json 里的 type 字段选处理器、用类#方法定位目标。这样我在几轮之间想加个 hook、删个 hook,改配置就行,模块代码不用动。配置里那些 type 名,如 dialog_show、cipher_dofinal、url_openconn、vg_addview_2,对应我每一轮挂了哪些 hook。

TOP15 后端接口捕获清单

我先挂上 URL.openConnection 的 hook,想看看 Java 层到底发出去哪些请求。抓到 8 个后端端点,只留类别、方法、调用栈特征和捕获次数。

捕获到的端点族(8 个,域名与 URL 已脱敏)
  │
  ├── 1. RPC 主网关(配置类 RPC)
  │     ├── 方法:POST + gzip
  │     ├── 栈:LiteRpcHttpWorker.doCall -> HttpURLConnectionImpl
  │     ├── 请求头:Accept-Encoding:gzip / Connection:Keep-Alive
  │     │          Content-Encoding:gzip / Charset:UTF-8
  │     ├── 确证 4 次,时间 15:20:38 / 15:20:46 / 15:21:21 / 15:21:22
  │     └── 响应 200
  │
  ├── 2. 时间戳服务端点
  │     ├── 方法:GET
  │     └── mtop 时间戳轮询,约每 15-35 s 一次(观测窗内 12 次)
  │
  ├── 3. 设备标识上报端点
  │     ├── 方法:POST
  │     ├── 栈:com.<厂商>.audid.upload.HttpUtils.sendRequest
  │     └── 头族:x-audid-sdk / x-audid-appname / x-audid-timestamp / signature(值脱敏)
  │
  ├── 4-6. 风控 SDK 端点族
  │     ├── 4:风控 SDK 初始化(GET,带 pn/pv/pt/nv/os/sv 查询参数结构)
  │     ├── 5:风控上报(POST,栈 DataReportJniBridge)
  │     │     头族:x-umt / x-mini-wua / x-game / x-biz / keyindex / x-sgte(值全脱敏)
  │     └── 6:风控事件上报(POST,同栈同头族)
  │
  └── 7-8. 配置分发端点族
        ├── 方法:GET
        └── 多个变体(文件名段为随机串结构),OSS 配置下发

这 8 个端点全是 SDK、网关、配置类请求,没有一个属于登录业务。Java HTTP 层能看到的就是这个范围。

TOP16 弹窗 Hook 定位(v17)

弹窗我单独做了一轮观测,目标是登录页那个遇到问题弹窗的完整实现路径。我一开始按常规猜,以为是 Dialog 或 PopupWindow,抓出来一看根本不是,是个 View 子类。

弹窗这条线最后达成的三点
  │
  ├── 弹窗类:KMPLoginHelpDialog(View 子类,非 Dialog、非 PopupWindow)
  ├── 内容渲染:KMP 跨平台框架(MicroPage$1 容器 + Jetpack Compose AndroidComposeView)
  └── 添加方式:AddViewUtils.performAddView -> ViewGroup.addView(KMPLoginHelpDialog)
        └── hook 命中点:ViewGroup#addView(View, ViewGroup$LayoutParams)
                          (config v14 的 type=vg_addview_2)

第一次捕获在 01:28:16,完整调用栈我按帧记下来:

KMPLoginBottomView$1.onItemClick(SourceFile:97)
  -> k7.invoke(47)
  -> y1.invokeSuspend(34)
  -> LoginBaseFragment$8.onClickView(SourceFile:265)
  -> LoginLaunchFragment.onClickHelperBtn(SourceFile:25)
  -> LoginBaseFragment.onClickHelperBtn(SourceFile:38)      <- 业务入口
       -> KMPLoginHelpDialog.<init>(SourceFile:31)          <- 弹窗类
            -> KMPLoginBaseDialog.<init>(SourceFile:4/2/1)
                 -> initView(SourceFile:67)
                      addView(FrameLayout, RelativeLayout$LayoutParams)
                 -> initView(SourceFile:109)
                      addView(LinearLayout, RelativeLayout$LayoutParams)
                 -> initView(SourceFile:142)
                      addView(View, LinearLayout$LayoutParams)
                 -> initView(SourceFile:178)
                      KMPHelper.createKmpViewByTag(65)
                      -> KMPBridgeMicroPage.createByPageTag(142)
                      -> MicroPage.<init> -> createPageComposition(175)
                      -> addView(AndroidComposeView)
                 -> initView(SourceFile:193)
                      addView(MicroPage$1, LinearLayout$LayoutParams)  <- 浮层容器
            -> KMPLoginBaseDialog.show(SourceFile:83)
                 -> AddViewUtils.performAddView(SourceFile:3)
                 -> ViewGroup.addView(KMPLoginHelpDialog{...})         <- 弹窗整体作为 View

为了抓到它,我用的关键配置是 config_v14.json,16 个 hook,14 个 OK、rl 2 个、fl 2 个,pw_setcontent 生效。里面这几个是主力:

config_v14.json 关键 hook
  ├── vg_addview_1 : ViewGroup#addView(View)
  ├── vg_addview_2 : ViewGroup#addView(View, ViewGroup$LayoutParams)  <- 命中弹窗
  ├── rl_addview_2 : RelativeLayout#addView(...)(override 版)
  ├── fl_addview_2 : FrameLayout#addView(...)(override 版)
  ├── pw_setcontent: PopupWindow#setContentView(View)
  └── wm_impl_addview: WindowManagerImpl#addView(...)

抓完有四处结果,其中一处纠正了之前的误判:

  1. 遇到问题浮层是 View-based 的 KMP 弹窗,不属于 Dialog / PopupWindow 体系。
  2. 之前我在 dumpsys 里看到的 PopupWindow:... 其实是键盘高度监听的辅助窗(KeyBoardHeightListenerView),pw_setcontent 的栈证实了这点,这是个误判被纠正的记录。
  3. Xposed hook 对多态很敏感,子类 override 的 addView 不会触发父类的 hook,必须挂 override 类本身,所以当时才同时配了 rl_addview_2 和 fl_addview_2。
  4. 引擎没法 hook 带 int 参数的重载,所以不带 int 参数的 View-based 弹窗反倒成了稳定的突破口。

第二次独立捕获在 01:37:06,复现出同样的栈。弹窗是全屏 View 容器(0,0 到 1440,2560),内容区在底部 y≥996。两次栈一致,可重复稳定捕获。

比 v14 更早的一轮,我挂的是 Dialog.show 这个 hook。它抓到四次真实触发,我按时间记下来。

Dialog.show 四次触发
  │
  ├── 02:58:32  登录引导页遇到问题弹窗
  │             栈 LSPHooker_.show -> DexAOPEntry.android_app_Dialog_show_proxy
  │                 -> DialogHelper$5.__run_stub_private
  ├── 13:44:34  同一个弹窗复现
  ├── 13:56:10  登录服务协议隐私弹窗
  │             栈 android.app.DialogFragment.onStart
  │                 -> com.ali.user.mobile.login.privacydialog.PrivacyDialog
  │                    .__onStart_stub_private
  └── 14:13:24  协议弹窗复现

字段输出里带 mContext=android.view.ContextThemeWrapper@...。这四次里两次是遇到问题帮助弹窗、两次是登录服务协议的隐私弹窗,分属两个不同的类。后来在 v14 那轮发现遇到问题浮层其实是 View 子类,跟这里的 Dialog 体系不是一回事,两批观测我分开记,没有混在一起。

还有一次是点忘记登录密码那个 item,时间 01:33:05。我看着它一步步走到 H5,最后被风控挡了回来。

忘记密码 item 点击链(01:33:05)
  │
  ├── tap 忘记登录密码
  ├── WindowManagerImpl.addView(新 Activity 窗口 ty=BASE_APPLICATION)
  ├── RVFragment.onCreateView
  │     -> MpaasViewFactory.createPageContainer
  │     -> NebulaWebContent / H5WebContentImpl
  │     -> H5PullContainer + h5_ly_provider_layout
  └── XRiverActivity H5 页面显示访问被拒绝
        提示当前设备可能存在风险,请关闭代理软件或换设备重试

这个页面解开了一个我之前没想通的现象。点"是我的,去登录"时 UI 不跳转、也没有任何 hook 事件,我一度以为是点击被吞了。看到这个风控拒绝页才明白,模拟器加 root 加 adb 这套环境已经被标记,请求发出去了但响应被拦,所以没有 UI 反馈。这条链的 UI dump 和栈我都留着。

取消那次是 01:37 之后,我点弹窗的取消,弹窗从 UI 上移除,dump 从弹窗态回到登录页(18299 B),全程没有 addView 事件。弹出时靠 addView 挂上来,关闭却是纯 UI 移除,这两个方向不对称。

TOP17 加密封装观测(Cipher.doFinal)

我还挂了 Cipher.doFinal([B) 的 hook,抓到两类明文输入,只留结构和栈。

Cipher.doFinal 捕获
  │
  ├── 1. 手势预数据
  │     ├── 输入:byte[64],ASCII 形态为
  │     │         <厂商>.mobile.security.gesture.ui.FingerPrintVerifyActivity_
  │     ├── 密文:byte[72](样例值脱敏)
  │     ├── 栈:GestureDataCenter.isNeedInitGestureData
  │     │        -> Des.encrypt
  │     └── 稳定复现 6 次,15:20:44 / 15:25:37 / 15:25:47
  │                        / 15:28:20 / 15:30:18 / 15:30:23
  │         每次进入登录或页面刷新触发
  │
  └── 2. 安全 token(TID)
        ├── 明文:JSON(tid / client_key / timestamp 等字段,值全脱敏)
        ├── 密文:byte[224](一次捕获)
        ├── 栈:TidStorage.initialize -> TidHelper.loadOrCreateTIDNoSync
        │        -> DeviceServiceImpl.queryMspTid / queryCertification
        │        -> DataProvider.getTidInfo -> AppInfo.getTidInfo
        └── 进程内存中 token 明文可逆读

有一次解密方向的捕获我记得比较清楚,入参密文 224 B、出参明文 JSON 213 B,栈是 Des.doFinal -> DexAOPCenter / DexAOPEntry -> Cipher.doFinal -> LSPHooker_。时间戳解析出来是设备时区 2026-10-31T02:00:57+08:00 附近,只留 TID JSON、213 B 这个结构信息。

TOP18 架构结论

追下来发现,登录业务的 RPC 走 tnet/anet 长连接,Java HTTP 层完全看不见。

架构结论
  │
  ├── 结论 1:登录业务 RPC 走 tnet/anet 长连接,Java HTTP 层不可见
  │     ├── 证据 A:登录全流程期间零 doCall / 零 openConnection(主网关)
  │     │           (观测窗内仅时间戳轮询 13 次 + OSS 1 次 + Cipher 8 次)
  │     ├── 证据 B:anet Request$Builder.setUrl/build hook 安装 100% OK
  │     │           但真实触发 0 次
  │     └── 结局:登录终点接口未捕获(未完成)
  │
  ├── 结论 2:配置类 RPC 走 LiteRpcHttpWorker -> HttpURLConnectionImpl
  │     └── 4 次确证(对应 TOP15 的主网关捕获)
  │
  ├── 结论 3:登录 SDK = com.<厂商>.user.mobile(用户组件)
  │     ├── 根视图 id:security.ui:id/root_view
  │     └── 账号查询页两个按钮(id + 坐标 + clickable)
  │           ├── login_btn_new(是我的,去登录)
  │           │     坐标 [96,1784][1344,1980],clickable=true
  │           └── reg_btn_new(不是我的,去注册)
  │                 坐标 [96,2028][1344,2224],clickable=true
  │           ├── 页面 dump 6981 B(dump47 / 50 / 51)
  │           └── 冷启动登录引导页另存一份 dump(dump43)
  │
  └── 结论 4:H5 容器子资源不走标准 WebView / URL.openConnection(hook 盲区)
        └── WebView.loadUrl / shouldInterceptRequest 只见安装行、零触发

hook 框架明明能抓到 SDK 层一堆请求,却始终看不到账号查询这个核心业务的接口。原因不是 hook 没装好,而是那部分流量压根不经过被 hook 的 Java 层。

TOP19 v10 稳定配置与死路清单

调了几轮之后,我整理出一份稳定的 v10 配置,7 个 hook、7/7 OK、零噪音。走不通的路记成一份死路清单,标上勿重复。

v10 配置(config_v10.json):

config_v10.json(7 hooks)
  ├── 1  dialog_show             android.app.Dialog#show          弹窗定位
  ├── 2  cipher_dofinal          javax.crypto.Cipher#doFinal([B)  加密输入明文
  ├── 3  url_openconn            java.net.URL#openConnection      全 URL 捕获
  ├── 4  httpconn_setreqmethod   HttpURLConnectionImpl#setRequestMethod
  ├── 5  httpconn_setreqprop     HttpURLConnectionImpl#setRequestProperty  头/签名
  ├── 6  httpconn_getresponsecode HttpURLConnectionImpl#getResponseCode
  └── 7  lite_rpc_docall         LiteRpcHttpWorker#doCall         RPC 调用点

死路清单(都实测过,标勿重复):

死路清单
  │
  ├── anet Request$Builder.setUrl/build/getUrl 系列
  │     └── install 100% OK,零触发
  │          结论:登录页/RPC 不构造该 Builder 链路,底层直达
  ├── HttpSession#send/init、HttpConnector#connect、getCharset/getTimeout/...
  │     └── FAILED(签名不存在)
  ├── GZIPOutputStream#write / DeflaterOutputStream#write
  │     └── FAILED(签名失败)
  ├── RpcInvocationHandler#invoke
  │     └── toString 递归风暴 11291 次 -> 禁用
  ├── RpcRequest 及其 getter 类 hook
  │     └── 类 discovery 风暴 + ANR + 日志 812 MB -> 禁用(v9 教训)
  ├── 是我的,去登录 点击
  │     └── UI 不跳转、零 hook 事件(负结果)
  ├── WebView.loadUrl / shouldInterceptRequest
  │     └── 零触发(原生内核不走标准 WebView)
  └── URL.openConnection 打印 body
        └── 默认不输出 body(需 gzip_write 等,签名失败)

这份清单里两条失败代价很大。RpcInvocationHandler#invoke 的递归风暴打出了 11291 次,RpcRequest 类 hook 把日志撑到 812 MB 还触发了 ANR。这两个数字我记下了。

TOP20 v37 启动流程控制闭环

我做过一次完整的启动流程控制实验,想让客户端冷启动直接落到主页(HomeV2),跳过登录和手势。

配置用的是 config_v37.json,28 个 hook(16 mock + 12 obs)。核心的几个 mock:

config_v37.json 核心新增(含命中次数)
  │
  ├── LaunchRouter#checkSchemeAndNeedLogin() -> false
  │     └── 短路 needCallLogin,5 次命中
  ├── GestureDataCenter#isNeedAuthGesture() -> false
  │     └── 跳手势,7 次命中
  ├── GestureService#isCanPassGesture -> true
  │     └── FAILED(abstract 接口不可 hook,不影响)
  ├── AccountService#getCurrentLoginLogonId -> 脱敏值
  │     └── FAILED(abstract)
  └── 保留:isAppInside->false / LoginApp#isLogin->true
            / BaseBundle mockHeaders(LoginSource / style / loginId 值脱敏)

启动链我是按 9 步捋出来的:

1.  am start -> LauncherActivity.onCreate -> ALA.preInit(Activity)
2.  startWelcome() -> Splasher 创建
3.  postInitImpl -> doStartEntry
      -> LaunchRouter.doStartEntry(777)
      -> initInOnCreate(88)
      -> startMain(123)
4.  startMain: checkSchemeAndNeedLogin() -> false  => v2 = 0
5.  entry(uri, 0) -> entryToDefaultBundle(p2=0)
      -> GestureDataCenter.isNeedAuthGesture() -> false
      => mTabLauncherCallLogin = 0
6.  LaunchRouter.launchTabLauncher(Bundle) -> ALA.launchTabLauncher(SourceFile:325)
7.  notify(TAb_LAUNCHER_VIEW_READY)
      -> Splasher.onEvent(TAb_LAUNCHER_VIEW_READY, null)
      => frameWorkReady = true
8.  hasAdvertisement -> false -> ALA.showHomePage()(SourceFile:368)
      => HomeV2 渲染
9.  底部 TabHost:tablauncher:id/tab_bar_container_fl

本轮捕获记录:

[MOCK] LaunchRouter#checkSchemeAndNeedLogin returning: false   x5
[MOCK] GestureDataCenter#isNeedAuthGesture returning: false    x7
=== LaunchRouter#launchTabLauncher === first@5750
=== Splasher#onEvent === args: [TAb_LAUNCHER_VIEW_READY, null] @5765
[MOCK] TLEventBusManager#isEventRegistered -> true @5795
[MOCK] Splasher#hasAdvertisement -> false @5803
=== LauncherActivityAgent#showHomePage === @5805
OPEN_LOGIN_PAGE x0     (v35/v36 各 x1,本轮根除)

界面 dump 里出现搜索、扫一扫、收付款、出行、卡包、转账这些主页宫格项,还有 homeV2ViewRoot、home_grid_container、king_kong_container、header 和 TabHost。截图 347,864 B。dumpsys 显示 topResumedActivity 是主 Activity、reportedDrawn=true。主进程还活着,没自杀,StartupPendingRunnable 的 mock 生效了。

复现步骤 7 步:

1. push config_v37.json 到 /data/local/tmp/lsp_universal/config.json
2. 轮转 captured:mv ..._captured.txt ..._captured_v36.txt
3. am force-stop <目标包名> && logcat -c
4. am start -n <目标包名>/.Login
5. 等 95 s
6. pull /data/local/tmp/lsp_universal/logs/<包名>_captured.txt
7. uiautomator dump + screencap 验证 HomeV2

TOP21 v32 到 v36 的迭代教训

v37 能闭环,是因为前面五轮把错误的假设一个个排掉了。

历史迭代教训(v32 -> v36)
  │
  ├── v32:类名错误(写成 quinox.splash.ClientEnvUtils,
  │        实为 common.logging.api.utils) -> hook 0 命中
  ├── v33:isAppInside->false 生效但仍卡 Splash
  │        -> 原因:preInit 两条 startWelcome 分支需
  │           isAppInside=false + isFromNFCPayResultPage=false
  ├── v34:LoginSource mock 命中但仍 OPEN_LOGIN_PAGE 分流
  ├── v35:移除 Activity#finish->true 对照,仍卡 Splash
  │        -> launchTabLauncher 0 / showHomePage 0 /
  │           TAb_LAUNCHER_VIEW_READY 0
  ├── v36:LoginSource 从 notablauncher 改 tablauncher 对照
  │        -> OPEN_LOGIN_PAGE 仍 x1
  │        -> 证明 LoginSource 不是 needCallLogin 判定源
  └── 根因(v37 证实)
        ├── needCallLogin 判定源 =
        │     LaunchRouter.checkSchemeAndNeedLogin()
        │     (getCurrentLoginLogonId 为空 -> true)
        └── 手势门控 = GestureDataCenter.isNeedAuthGesture()
              (true -> 走手势验证,不到主页)

这两条根因对应 v37 里两个核心 mock,一个命中 5 次、一个 7 次。真正决定进不进主页的是这两个判断,不是堆更多 mock。

第三部|静态测绘与组件面归类

TOP22 RPC 签名链还原

我又补了一份纯静态的分析,用 21 个 dex 字符串表加方法级指令流,没联网、没动态跑。还原的是配置类 RPC 的请求签名链。

请求签名链(SignJsonSerializer.packet -> 签名工具)
  │
  ├── 1. buildNameValuePairs          收集业务参数 name=value
  ├── 2. getSignTimestamp
  │     └── System.currentTimeMillis -> 追加参数 ts
  ├── 3. Collections.sort             按 name 排序
  │     └── 比较器:SignJsonSerializer$1
  ├── 4. 拼接
  │     └── k1=v1&k2=v2&...&ts=<毫秒>
  │         (StringBuilder + "=" + "&",deleteCharAt 去尾)
  ├── 5. 签名(拼串) -> 返回 sign 参数
  │     └── 非空才 append
  └── 6. nvpairs2Bytes -> 请求体
        └── 形态 application/x-www-form-urlencoded

这六步走完,动态线里那个主网关 POST 请求体是怎么来的就清楚了,ts 是毫秒时间戳,sign 由排序后的参数串算出,最后以表单形态发出去。

TOP23 网关白名单与签名算法

同一份静态分析还给出了网关白名单和签名算法分支。白名单硬编码在 RpcSignUtil.b() 里,算法分两条路。

网关白名单(硬编码,域名按结构记)
  │
  ├── 主/备网关若干(域名已脱敏)
  ├── 预发网关
  └── 测试/开发网关

签名算法:

签名算法分支
  │
  ├── TEE 可用
  │     ├── 类型:SIGN_TYPE_TRUSTED_SIGN_NORMAL(signtype = 4)
  │     ├── 走:SecurityGuard TrustedSign
  │     └── 前置:TransportStrategy.isInTeesdkWhiteList 白名单
  │
  ├── 回退:legacy RSA 参数签名
  │     └── 算法串:MD5withRSA / SHA1withRSA
  │
  └── 监控上报
        └── MonitorLoggerModel
              bizType = RPC
              字段:SIGN_TYPE / API / TEE_FT / TEE_ERR_CODE / ERR_CODE

那份静态分析里提取过 RSA 公钥实体,有 PEM 也有两代 DER 证书,那是服务端验签用的公钥、客户端信任链里的根,不是客户端私钥。客户端的签名密钥由 SecurityGuard 和 TEE 保管。

这份静态分析里还有几项没做:

未完成项
  ├── 还原 legacy RSA 完整路径(公私钥从 SecurityGuard 拿?)
  ├── 核对测试/开发网关的触发条件(测试开关)
  └── hook 签名入参抓一次真实签名串(未做)

TOP24 组件面机制归类

另有一份渗透测试发现汇总,含三处导出组件问题,按机制类别和静态判据归类。

组件面归类(三类机制)
  │
  ├── 类别一:导出 Activity 的客户端自校验可绕过
  │     ├── 组件性质:exported=true,无 permission
  │     ├── 机制:external extra -> 对称解密(密钥硬编码,值脱敏)
  │     │         -> 自校验(摘要由攻击者可控字段拼成)
  │     │         -> 解析后二次 scheme 跳转
  │     ├── 静态判据:解密密钥在客户端、校验输入全可控
  │     └── 影响类别:参数注入跳转、伪造 token、落地页劫持面
  │
  ├── 类别二:导出 AIDL 支付服务无调用方校验
  │     ├── 组件性质:exported=true,声明了 action
  │     ├── 机制:onBind 直接返回 Stub,无 callingUid / 包名 / 签名校验
  │     ├── 静态判据:方法入口缺身份判断;非空订单串即启动收银台引擎
  │     ├── 动态记录(脱敏):外部进程 bind 成功、getVersion ok、
  │     │                     传伪造订单串可达(未做真实支付)
  │     └── 影响类别:强制唤起收银台、预加载、注册回调、DoS 面
  │
  └── 类别三:导出服务的跨进程回调无身份校验
        ├── 组件性质:exported=true,可 bind,声明了 action
        ├── 机制:入参 handler 无条件存字段;状态/金额变化经该 handler 回传
        ├── 附加弱点:不清理已死客户端 handler(异常仅 catch 忽略),注册槽残留
        ├── 动态记录(脱敏):双进程实验,第三方 handler 落入服务端字段,
        │                     状态/金额回调到达第三方,跨进程回调命中
        └── 影响类别:支付状态/金额被第三方实时观测、状态 UI 造假面

TOP25 静态与动态的互补关系

三条线各自覆盖了什么、盲在哪,如下:

三条线的证据面
  │
  ├── 口令解密线(静态 + 补环境)
  │     └── 覆盖:native 加密引擎结构、IRELATIVE 表、运行时指针线索
  │          盲区:key 池运行时值未读,明文未解出
  │
  ├── 动态观测线(hook)
  │     └── 覆盖:SDK 层端点、弹窗实现、加密输入明文、启动控制链
  │          盲区:登录业务 RPC 走长连接,Java 层不可见
  │
  └── 静态测绘线(DEX 指令流)
        └── 覆盖:RPC 签名链、网关白名单、算法分支、验签公钥结构
             盲区:真实签名串未抓、测试开关触发条件未核对

动态实测的三类组件面属于导出组件、跨进程那一面,静态的网关协议那一面,ts 加 sign 的参数签名链是复现 RPC 协议的前置知识。


传递专业知识、拓宽行业人脉——看雪讲师团队等你加入!!

收藏
点赞 ・3
打赏
分享
最新回复 (1)
雪    币: 27
能力值: ( LV1,RANK:0 )
在线值:
发帖
回帖
粉丝
2 楼
这种勾八AI文发出来有什么意义? 
3小时前
1
游客
登录 | 注册 方可回帖
返回