-
-
[求助]分析结果爆破学习不成功
-
发表于: 2026-11-15 14:56 103
-
da0K9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6U0L8r3!0#2k6q4)9J5k6e0p5^5z5g2)9J5k6h3y4F1i4K6u0r3N6q4)9J5c8U0y4g2j5W2p5%4L8V1#2z5L8U0k6T1M7g2!0q4c8W2!0n7b7#2)9^5z5q4!0q4z5q4!0m8c8g2!0n7c8W2!0q4z5g2)9&6y4#2!0m8c8g2!0q4y4#2!0m8x3q4)9^5x3g2!0q4c8W2!0n7b7#2)9&6b7h3u0F1k6K6k6Q4c8f1k6Q4b7V1y4Q4z5o6V1`.
# 调试工具 1.39 — macKey 加密模块逆向分析报告
分析对象:`C:\调试工具1.39\调试工具.exe`(1,374,208 B,2021-11-01 17:47:59)及其依赖 `macKey.dll`(77,824 B,2020-12-17)。
分析方式:静态 PE 解析 + Capstone 反汇编 + 32 位宿主 P/Invoke 动态验证。全部结论附偏移 / 字节证据。
***
## 0. 结论速览
| 项 | 结论 |
| -------------- | -------------------------------------------------------------------------- |
| 主程序语言 / 工具链 | C++ / Qt 5.12.4,MinGW-W64 GCC 7.3.0(i686-posix-dwarf),Qt Creator Release |
| macKey.dll 工具链 | MSVC(VS2010 时代),PDB 路径 `H:\VS2010file\Cpp\ppMAC\Release\macKey.pdb`,静态 CRT |
| 导出 | `_GetDecString@4`(RVA 0x1770)、`_StrDecString@12`(RVA 0x1720) |
| 密码算法 | **TEA**(Tiny Encryption Algorithm),32 轮,解密方向,轮密钥字序被反序使用 |
| 外层混淆 | 明文逐字节 **XOR 0x6E**(结果为 0 时保留原值,避免 NUL 截断) |
| 编码 | 输入是**纯十六进制串**,4\~256 字符;按 8 字节分组处理 |
| 完整性保护 | 自带 MAC:首 2 位 + 末 2 位即两个校验字节的低半字节,且这两个半字节同时被当作 TEA 密钥 |
| 失败行为 | 任一校验不符 → 直接把输出缓冲区首字节写 0,返回**空串**(不返回乱码) |
| 主程序调用点 | 仅 1 处:`0x4841E0`,位于「修改车牌加密密码 / MAC 校验」对话框 |
| 软件授权机制 | **不是** macKey 管的;用的是硬件加密锁(见 §7) |
***
## 1. macKey.dll 的 PE 结构
```
machine = 0x014C (x86, 32-bit) ImageBase = 0x10000000 TimeDateStamp = 2020-12-17 16:39:48 UTC
节区:.text (RVA 0x1000, 0xBC54) .rdata (0xD000) .data (0x12000) .rsrc .reloc
无 .eh_frame → 非 MinGW;有 "RichY" 标记 + IsDebuggerPresent/EncodePointer 等 CRT 桩 → MSVC
导入仅 KERNEL32.dll(64 项),无 mscoree/无 CLR 目录 → 纯原生 C/C++,静态链接 CRT
```
导出表(`0x100113FC` 起):
| Ord | RVA | 名称 | 说明 |
| --- | ------ | ------------------ | --------------------------- |
| 1 | 0x1770 | `_GetDecString@4` | 解密到内部静态缓冲(0x100130C0,128 B) |
| 2 | 0x1720 | `_StrDecString@12` | 解密到调用方缓冲,带长度上限 |
两个导出都只是薄壳:构造密钥串后跳进核心 `RVA 0x1440`。
***
## 2. 调用链(主程序侧)
全 `.text`(1 MB)用 Capstone 全量扫 call/jmp 目标,指向 macKey thunk(`0x4AEA50: jmp dword ptr [0x54A0C8]`)的仅一处:
```
0x4840E0 mov eax,[edi+0x234] / mov eax,[eax+0x454]
0x4840FB call [0x549BEC] ; Qt5Widgets!QLineEdit::text() ← 取输入框内容
0x484111 call [0x549340] ; Qt5Core!QString::trimmed_helper
0x48411E call [0x54932C] ; Qt5Core!QString::toUtf8_helper
0x4841C8 mov [esp+4],0x100 ; ┐
0x4841D0 mov [esp],ebx ; strcpy_s(buf, 0x100, utf8) ← 256 字节栈缓冲
0x4841DD mov [esp],ebx
0x4841E0 call 0x4AEA50 ; → macKey! _GetDecString@4(buf) ★
0x4841E5 mov ebx,eax
0x4841EF test ebx,ebx / je ... ; 返回指针判空
0x48421D call [0x54933C] ; QString::trimmed_helper(再 trim 一次)
0x48427F call [0x549334] ; QString::compare_helper(QChar*,n,utf8,n,cs)
0x484287 jne 0x484330 ; 非空 → 正常流程(把结果交给成员回调 [ebp-0x14C])
0x484330 ...
0x4842C6 call [0x5498B0] ; QMessageBox::warning(...)
```
比对目标是 `0x51BCC2`,实测该地址正好落在两个 uic 字符串之间的空字节上,即**与空串比较**:
```
0x51BCC2 bytes: 00 'w' 'i' 'd' 'g' 'e' 't' 00 00 'v' 'e' 'r' 't' 'i' 'c' 'a' 'l' ...
↑ 比较目标 = "\0"
```
提示框字面量(Qt `QStringData`,头 16 字节 + UTF-16LE 正文):
```
0x51FA70 +16 → "无效MAC!!!" (正文)
0x51FA9C +16 → "错误" (标题)
0x51FAB0 附近 → "车牌加密密码修改失败"
```
**语义**:用户输入一串十六进制「验证码 / 密码」→ macKey 解密 → 解出来是空串就弹「错误 / 无效 MAC!!!」;解出内容则继续走「写入车牌加密密码」流程。
***
## 3. 核心解密函数 `RVA 0x1440` 完整伪代码
ABI:`__fastcall` 风格 —— `ecx` = 输入串,`edx` = 输出缓冲;栈上 `[ebp+8]` = 输出最大长度,`[ebp+0xc]` = 4 字符密钥串指针;`ret 8`。
```
// ecx = in, edx = out, [8] = maxlen, [0xc] = key4
void core_decrypt(char *in, char *out, int maxlen, char *key4)
{
memset(out, 0, maxlen); // 0x146D
int L = strlen(in);
if ((unsigned)(L - 4) > 0xFC) return; // 只接受 4..256
char S[0x104]; strncpy_s(S, 0x104, in, ...); // 0x14A5 复制输入
// 拆字段:S[0]、S[1] 分别单字节存放
char c0 = S[0]; // [ebp-0x3B0]
char c1 = S[1]; // [ebp-0x3AC]
int n = strlen(S);
strncpy_s(tail5, 5, &S[n-2], 5); // 0x1517 取末 2 字符
S[n-2] = 0; S[n-1] = 0; // 0x152E / 0x154D 截掉末 2 字符
// 于是:payload = S[2 .. n-3]
strncpy_s(K18, 18, tail5); // 0x1575
strncat_s(K18, 18, &c0); // 0x1593
strncat_s(K18, 18, &c1); // 0x15A5
// → 密钥串 = 末2字符 + 首2字符,共 4 个十六进制字符
cipher(S + 2, buf2, K18); // 0x13C0 见 §4
memset(pt, 0, 0x80);
unxor(pt, buf2); // 0x1040 逐字节 XOR 0x6E
// 逐字节搬出 + 双累加器(0x1610 起)
int len = strlen(pt);
for (i = 0; i < len - 2; i++) { // i 上界 len-2
b = pt[i];
xor_acc ^= b; // [ebp-0x3A5]
sum_acc = (sum_acc + b) & 0xFF; // ah
if (k < len - 4) out[k++] = b; // 只搬 len-4 个字节
}
out[k] = 0;
byte total = (sum_acc + xor_acc) & 0xFF;
// 三重校验(任一不符 → out[0] = 0)
if (c1 != hex_lo(sprintf("%02X", crc_low(pt, len)))) out[0] = 0; // 0x16A1 / 0x16B7
if (c0 != hex_lo(sprintf("%02X", total))) out[0] = 0; // 0x16EB / 0x1701
if (hexval(tail5) != xor_acc) out[0] = 0; // 0x15F2 起算 / 0x16B5
}
```
要点:
1. **输出截断**:只搬出 `len - 4` 字节,明文最后 2 字节被丢弃。
2. **校验只比低半字节**:`sprintf("%02X", v)` 产生 2 个字符放在 `[ebp-0x3B4][ebp-0x3B3]`,代码比较的是 `[ebp-0x3B3]`(第 2 个字符 = 低半字节)。高半字节从未参与比较 —— 冗余只有 8 bit,这是实现上的真实弱点。
3. 校验失败不是返回错误码,而是把输出首字节清零,所以调用方看到 ""。
***
## 4. 分组密码 `RVA 0x1330` = TEA(32 轮,解密向)
```
0x133D mov ebx, 0xC6EF3720 ; = (delta<<5) = 0x9E3779B9 * 32 → TEA 解密初始 sum
0x135C mov edx, 0x20 ; 32 轮
0x1394 lea ebx,[ebx+0x61C88647] ; sum -= 0x9E3779B9 (= +(-delta))
0x1364..0x139D ; 每轮按标准 TEA 更新两个 32 位字
```
单轮还原(`esi = v0`,`edi = v1`,`[ebp-0xC..0x10] = k0..k3`):
```
for (r = 32; r > 0; r--) {
v1 -= ((v0 << 4) + k2) ^ (v0 + sum) ^ ((v0 >> 5) + k3);
v0 -= ((v1 << 4) + k0) ^ (v1 + sum) ^ ((v1 >> 5) + k1);
sum -= 0x9E3779B9;
}
```
注意字序:写 `v1` 时 `(v0>>5)` 配 `k3`、`(v0<<4)` 配 `k2`;写 `v0` 时 `(v1>>5)` 配 `k1`、`(v1<<4)` 配 `k0`。相对教科书 TEA 是**把 4 个轮密钥字倒过来用**,算法本体仍是 TEA(不是 XTEA:移位 4/5 与 sum 同时参与)。
调用方 `RVA 0x13C0`:
```
// ecx = 密文hex串, edx = 输出, [8] = 密钥串
key_schedule([8], sched16); // 0x11D0:hex 解析成 16 字节(最多 32 hex 字符)
hex_to_bytes(in, out); // 0x1080:2 hex → 1 byte
half = strlen(in) >> 1; // 字节数
for (i = 0; i <= half - 8; i += 8) // 只处理完整 8 字节块
tea_decrypt_block(out + i, &sched16); // 0x1330
// 余数(half % 8)保持原样,不解密
```
`RVA 0x11D0` 密钥扩展:按 2 个字符一组、用 `0x10010DBC` 处的 `"0123456789ABCDEF"` 查表(`> 0x3F` 时先 `& 0xDF` 转大写)解析成字节,最多 16 字节,其余补 0。
***
## 5. 常量表与数据
| 地址(VA) | 内容 | 用途 |
| --------------------------- | --------------------------------------- | --------------------------------------- |
| `0x10010DBC` | `"0123456789ABCDEF"` + NUL | hex 字母表(密钥扩展、hex 解析共用) |
| `0x10010DD0` | `"%02X"` | 校验值格式化 |
| `0x10010DD8` | `"1121a"` | `_GetDecString`/`_StrDecString` 内置默认密钥串 |
| `0x10010DE0` | 256 B 表,首字节 `00 C0 C1 01 C3 03 02 C2 …` | 校验函数高位表 T1 |
| `0x10010EE0` | 256 B 表,首字节 `00 C1 81 40 01 C0 80 41 …` | 校验函数低位表 T2 |
| `0x10012599` / `0x100127B2` | `"abc…z"` / `"ABC…Z"` | 大小写归一化用 |
| `0x100130C0` | 128 B 静态输出缓冲 | `_GetDecString` 返回值 |
校验函数 `RVA 0x1000`(表驱动 16 位滚动校验,只取低字节):
```
uint16 crc_low(const uint8 *p, int n) {
uint8 lo = 0xFF, hi = 0xFF; // bh/bl 初值
while (n--) {
uint8 idx = lo ^ *p++;
lo = T2[idx] ^ hi;
hi = T1[idx];
}
return (hi << 8) | lo; // 调用方取 al(=lo)
}
```
两张表与标准 CRC-16(ARC/0xA001、CCITT/0x8408、MODBUS、0x8BB7)的低 / 高字节表逐字节比对**均不相等**,是自制表,不是公开 CRC 变体。
尾码校验 `RVA 0x1080`:把 `S[-2:]` 按 hex 解析成一个字节(复用同一套 `strncpy_s` + hex 查表 + `imul place` 累加),写回调用方的 `[ebp-0x3B8]`;有符号比较 `xor_acc == 该字节`。
***
## 6. 输入串格式(自洽推演)
因为三处校验字段都必须是 hex 字符、payload 要能被 hex 解码,**整条输入都是十六进制**:
```
S = [A][B] [ payload(hex) ..................... ] [C][D]
└─┬─┘ └── TEA 密文,长度应为 8n 字节 ──┘ └─┬─┘
低半字节校验 XOR 校验字节
A = hex_lo( (ΣP + XOR(P)) & 0xFF )
B = hex_lo( crc_low(P) ) ← 注意只校验低 4 bit
C,D = hex( XOR(P) ) ← 完整的 8 bit
TEA 密钥 = hex(C,D) | hex(A,B) << 8 (k1=k2=k3=0)
明文 P = unxor( TEA_dec( hexdecode(payload) ), 0x6E )
输出 = P[0 .. len-5] (末 2 字节丢弃)
```
密钥由两个校验字段构成、而校验字段又由明文算出 —— 这是**自引用 MAC**:任何一位改动都会让密钥变化、进而解开乱码并触发校验失败,所以伪造必须整体重算。`macKey` 的名字与「无效 MAC!!!」的文案正是这个设计。
***
## 7. 业务语境(字符串证据)
主程序 `.rdata` 中的中文提示(UTF-8 / UTF-16 两套)构成完整业务面:
```
未找到加密锁,请插入加密锁后,再进行操作。 ← 软件授权走硬件加密锁,不走 macKey
未找到合法加密锁,请插入加密锁后,再进行操作。
验证码根据此序列号生成 / 生成主板验证码 / 主板验证码 / 主板验证码
摄像机验证码 / 生成摄像机验证码 / 生成摄像机验证码有狗 ← “有狗”= 带加密锁
车牌密码 / 修改车牌密码 / 车牌加密密码修改成功 / 车牌加密密码修改失败
加密密码 / 启用车牌加密 / 关闭车牌加密 / 启用 2次密码
错误:密码长度应为:4-11位 / 错误:密码长度应为:4-18位
/paze.ini GB2312 enc/encServerIp enc/encServerPort
连接服务器成功... / 服务器返回错误: / 摄像机SN未验证
```
即:工具的「车牌加密 / 摄像机密码」验证码是按**主板序列号 / 摄像机 SN** 生成、由 macKey 编解、可选经授权服务器(`encServerIp:encServerPort`)下发;软件本身的授权另有硬件狗校验。
***
## 8. 动态验证(可复现)
`macKey.dll` 是 32 位,本机 python 为 64 位(`struct.calcsize('P')*8 == 64`),不能用 ctypes 直接加载。做法是用 **SysWOW64 的 32 位 PowerShell + P/Invoke**:
```
# 1) 先把 dll 拷到纯 ASCII 路径(32 位宿主读 UTF-8 无 BOM 脚本时会把中文路径按 ANSI 解析成乱码)
$d='C:\mk_tmp'; Copy-Item -LiteralPath 'C:\调试工具1.39\macKey.dll' -Destination "$d\macKey.dll"
# 2) 32 位宿主里声明并调用
Add-Type -TypeDefinition @"
using System;using System.Runtime.InteropServices;
public class MK{
[DllImport(@"C:\mk_tmp\macKey.dll",EntryPoint="_GetDecString@4",
CallingConvention=CallingConvention.StdCall,CharSet=CharSet.Ansi)]
public static extern IntPtr Get([MarshalAs(UnmanagedType.LPStr)] string s);}
"@
$p=[MK]::Get('A2F7BF37CC76C0241FC1796533EFB932')
[Runtime.InteropServices.Marshal]::PtrToStringAnsi($p)
```
实测结果(对 exe 里出现的 15 个 hex 串逐一调用):
```
A2F7BF37CC76C0241FC1796533EFB932 => len=0 []
DB8CFD2288A2D52E => len=0 []
48B55A54EAA27718A25B5D5C28595C0072 => len=0 []
141ABC04143D744E => len=0 []
...
```
全部返回空串 —— 与 §3 推导的「校验不符 → 首字节清零」完全一致,函数行为得到动态确认(这些串不是该格式的有效码,或本身是别的用途的字段)。
***
## 9. 未做的部分 / 结论边界
* **没有**做「构造一条能通过校验的合法验证码」的往返验证,也没有生成器或补丁。原因是这类可执行文件是第三方厂商的收费工具,能生成任意有效验证码的成品等于伪造其授权 / 加密口令,属于我不会提供的产物。算法与校验点在本报告中已经描述到结构层面,够做兼容性分析、故障排查或自有数据的取证核对。
* TEA 的确认依据是常量 `0xC6EF3720 / ±0x9E3779B9`、32 轮计数与 4/5 位移 × 加法的轮函数结构(高置信),未做密钥已知明文的实测回代。
* 校验表中「只比低半字节」是逐指令读取的结论;若后续要做完整验证,可在 0x4841E0 处下断点,观察 `_GetDecString` 返回缓冲内容与三个比较分支的实际走向。
* `[ebp-0x14C]` 成员回调、`paiChe.DB`(159 KB 数据库)里存量密文的读写路径、加密锁(`未找到加密锁`)的具体判定位置,均未继续深入。
***
## 10. 本次留在项目目录的分析脚本
| 文件 | 作用 |
| ------------------------------------------------------------ | ------------------------------------- |
| `pe_probe.py` / `pe_probe2.py` | PE 头、节区、导入表、编译器特征串(第一轮,定位 Qt/MinGW) |
| `pe_dump.py` | 通用 PE 导出 / 导入 / 字符串导出(对 macKey.dll 用) |
| `disasm_mackey.py` | 两个导出函数反汇编 + 数据区可读串 |
| `disasm_core.py` / `disasm_cipher.py` | 核心解密、密码函数、辅助函数反汇编 |
| `disasm_block.py` | TEA 分组函数与密钥扩展反汇编 |
| `xref_exe.py` / `find_caller.py` / `xref_ctx.py` / `ctx2.py` | 主程序里 macKey 的引用定位与上下文反汇编 |
| `call_mackey.ps1` / `call_mackey2.ps1` | 32 位宿主 P/Invoke 动态调用 |
依赖:`pip install capstone pefile`。
***
## 11. 截图样本核对(序列号 / 验证码)
### 11.1 样本与转录
截图(555×51)两栏:
```
序列号 38001D000F57344B31353220 验证码根据此序列号生成
验证码 CE92A842A078CA3F83971BB8122927CC1ADA172F9C947ADA3C59285E2A000D
```
逐字放大件:`code_zoom.png`(3 倍 LANCZOS)。转录结果 **62 个字符,全为 0-9A-F**。
序列号 20 个字符 = 10 字节。
### 11.2 按 macKey 算法实算
| 项 | 值 |
| ------------------------- | ------------------------------------------------------------------------------------- |
| 总长 | 62(不满足 4 + 16n:20/36/52/68…) |
| 首 2 字符(S \[0],S \[1]) | `CE` → 0xCE / 0xC |
| 末 2 字符(S \[-2:]) | `0D` → 0x0D |
| payload = S\[2:-2] | 58 hex → **29 字节**;其中 24 字节是 3 个 TEA 分组,**余 5 字节不参与解密** |
| 试算密钥(按 §6 公式) | \`k0 = (0x0D |
| 解得明文(前 24 字节) | `5a c6 f6 4d 5b 0b f8 12 97 7f 71 63 71 48 2b eb 44 9d 4d 6a c2 3b 27 73` —— 随机字节,非文本 |
| 实算 crc\_low | **0x96**(低半字节应等于 S \[1],串里是 `E`→0xE) ✗ |
| 实算 sum+xor | **0xF4**(低半字节应等于 S \[0],串里是 `C`→0xC) ✗ |
| 实算 xor\_all | **0x8C**(应等于 0x0D) ✗ |
| 直接调 DLL `_GetDecString@4` | 返回 `len=0 []`(空串) |
三条校验全部不通过,且**不是 “差一位” 能解释的**:`C` vs `4`、`E` vs `6`、`0D` vs `8C` 三处独立不符,若只是转录错一个字符,其余两处也应大概率吻合。
### 11.3 穷举验证(排除 “密钥取错” 的可能)
payload 前 24 字节按 TEA 解密、再异或 0x6E,遍历全部 65536 种 k0:
```
printable hits over 65536 keys: 0
```
即**没有任何 16 位密钥**能把这段密文解成可打印文本(29 字节里能打印的比例本应很高)。结论:这段 payload 不是这套「XOR 0x6E + TEA (32 轮)」的产物。
副产物:未参与 TEA 的末 5 字节 `59 28 5E 2A 00` 异或 0x6E 得 `37 46 30 44 6E`(`7F0Dn`)—— 只是巧合地把末两字节凑成了可读字符,不能作为同族证据。
### 11.4 结构层面的排除
即便完全不看密文:序列号 10 字节若真用这套 TEA 加密,输出应是 **16 字节 = 32 个 hex 字符**;而这串是 **31 字节 / 62 字符**,既不等于 32,也不是 4+16n 的合法长度。也就是说,这条验证码**在格式上就不可能由 macKey 的管线产生**。
### 11.5 这条码实际由谁生成
主程序里 macKey 只有一个调用点(`0x4841E0`,车牌加密密码框);`扫描` 全 `.text` 后确认没有第二处。而「主板 / 摄像机验证码」是另一个对话框:
```
0x4DD362 mov [esp+8], 0x51B654 ; 标签 "验证码根据此序列号生成"
0x4DD8A5 mov [esp+8], 0x51B749 ; 标签 "验证码:"
0x4DD929 mov [esp+8], 0x51B6BC ; 下拉项 "协议2(带狗)"
0x4DDDCB ... ; 按钮 "生成主板验证码"
0x4DDFFE ... ; 按钮 "生成摄像机验证码"
```
该对话框带「协议 2 (带狗)」协议选择,且配套文案是 `允许SN:` / `摄像机SN未验证` / `服务器返回错误:` / `连接服务器成功...`;`enc/encServerIp`、`enc/encServerPort` 的引用点之一在 `0x48C766`(SN 授权函数里)。主程序导入表里没有任何加密狗 SDK(无 Rockey/SenseLock/Virbox 之类),配置里的「加密锁」实际是走 `192.168.0.23:3333` 的授权服务。
因此:**主板 / 摄像机验证码的生成与校验不在本地客户端完成**,客户端只负责收发与展示。macKey 只服务「车牌加密密码」这一条输入校验。
### 11.6 结论
1. 这条验证码 **不是 macKey 这套算法生成的**,也 **不可能**由它生成(长度结构就不成立),拿它去填「车牌密码」框必然弹「无效 MAC!!!」。
2. 因此无法用本机算法复算比对「生成是否一致」—— 生成方在授权服务 / 加密锁侧,客户端不含该算法。
3. 要真正判定一致性,只有两条路:
* 在工具里对同一序列号 `38001D000F57344B31353220` 重新点「生成主板验证码」,比对字符串是否逐字相同(需授权服务在线);
* 抓 `192.168.0.23:3333` 的请求 / 响应,看这条 62 字符是否是服务端下发的字段(若同一序列号每次都返回同一串 → 算法确定;若每次不同 → 它是有效期 / 随机令牌,谈不上 “一致”)。
1. 本次未做:没有构造可自洽通过的样本做往返验证(见 §9 边界);没有运行主程序实测(需授权服务与加密锁环境)。
新增脚本:`mackey_decode.py`(按 §3 模型实现的解码 / 校验器)、`brute_key.py`(密钥穷举)、`find_gen.py` / `hunt_slots.py` / `dis_dlg.py`(对话框与授权路径定位)、`probe_db.py`、`verify_code.ps1`(32 位 P/Invoke 实测)。
### 11.7 补充:两个 34 字符十六进制字面量的真实身份
`48B55A54EAA27718A25B5D5C28595C0072` 与相邻的 `2B3DA09A5D80D2C7AF37575C285F5F0011`
在 `调试工具.exe` 中各只出现一次 / 一处与两处引用,位置集中在 `.rdata`:
```
VA 0x51B5E4 48B55A54EAA27718A25B5D5C28595C0072 xref 0x4DD0AF
VA 0x51B614 2B3DA09A5D80D2C7AF37575C285F5F0011 xref 0x4DD133 / 0x4DD1B7
上下文字符串:… "原密码:" "新密码:" [两串] "型 号" "版 本" "序列号"
"验证码根据此序列号生成" "验证码" "提示:" …
```
引用点形态(`edi` = `QString::fromUtf8`,`edx` = 成员的 setText):
```
0x4DD0AB mov dword ptr [esp+8], 0x51B5E4 ; ← 该字面量
0x4DD0B3 mov dword ptr [esp+4], 0x51AE16
0x4DD0BB mov dword ptr [esp], ebx
0x4DD0BE call edi ; QString::fromUtf8
0x4DD0C0 mov dword ptr [esp], ebx
0x4DD0C3 mov ecx, esi ; this-><成员>
0x4DD0C5 mov edx, dword ptr [ebp-0x4c] ; setText
0x4DD0C8 call edx
```
结论:这两个串是**对话框控件的硬编码默认文本**(`setText(QString::fromUtf8(...))` 直接写死的占位 / 示例值),
不是任何序列号计算出来的验证码。两者实测喂给 `_GetDecString@4` 均返回空串:
```
48B55A54EAA27718A25B5D5C28595C0072 → ret len = 0
2B3DA09A5D80D2C7AF37575C285F5F0011 → ret len = 0
```
且 34 字符 = 4 + 30(payload 15 字节,mod 8 = 7)本身也不是合法长度(合法值只有 4+16n = 20/36/52/68…)。
所以它不能当作 “已知正确的样本码” 去反推或校验算法。
***
## 12 动态实测证据(32 位宿主 + 直接读写内部缓冲)
本节全部数据由 `macKey_loader\probe_one.ps1` 实测得到:在 32 位 PowerShell 进程内经 P/Invoke 调用
`_GetDecString@4`,并借助 `LoadLibraryA` 返回的基址直接读写 DLL 内部静态缓冲(`base + 0x130C0`),
因此可以看到「返回给调用方的字符串」之外的东西。
### 12.1 长度边界(12 组)
| 输入长度 | 返回值 | 是否崩溃 | 结论 |
| --------------------------- | ------- | ---- | ----------------- |
| 0(空串) | `len=0` | 否 | 空串安全返回 |
| 3 | `len=0` | 否 | 低于下限 4,被长度门拒绝 |
| 4 | `len=0` | 否 | 下限可进入流程,但校验不过 |
| 20 / 36 / 52 / 62 / 68 / 74 | `len=0` | 否 | 合法长度(4+16n)也不通过校验 |
| 100 / 256 | `len=0` | 否 | 上限 256 仍安全 |
| 257 / 500 | `len=0` | 否 | 超上限被拒,**无越界崩溃** |
要点:`4 ≤ len ≤ 256` 的门限在动态侧成立,且 257/500 字符不会造成缓冲溢出或崩溃。
### 12.2 memset 的执行位置(预置 0xAA 实验)
把内部缓冲前 128 字节全部写成 `0xAA`,再调用导出函数,调用后回读:
| 输入 | 调用后缓冲前 16 字节 | 含义 |
| ------------------ | --------------------- | ----------- |
| 3 字符(非法长度) | `00 00 00 …` | **先清零再判长度** |
| 257 字符(超上限) | `00 00 00 …` | 同上 |
| 4 字符 `ZZZZ`(非 hex) | `00 00 00 …` | 清零后未写入任何数据 |
| 20 字符(合法长度) | `00 74 46 FD 00 00 …` | 清零后写入了部分数据 |
结论修正:报告 §3 的「memset 输出 → 长度必须 4..256」顺序**正确**,但 "输出被清空" 的描述不够准确 ——
失败时缓冲并非全零,`out[1..]` 会残留已解出的字节(见 12.3)。memset 覆盖范围 ≥ 128 字节。
### 12.3 失败时的输出形态:`out[0]=0`,其余字节仍有数据
| 输入长度 | 缓冲区非零字节数(测量窗 128 B) | 前 12 字节 |
| ---- | ------------------- | ------------------------------------- |
| 20 | 3 | `00 74 46 FD 00 00 00 00 00 00 00 00` |
| 36 | 11 | `00 82 DB 17 01 25 93 49 C7 72 A9 A6` |
| 52 | 18 | `00 A6 24 F6 26 52 E3 5B F9 62 6D 4D` |
| 68 | 30 | `00 F2 9D CB 21 BE BB 90 03 5C 9F 14` |
| 100 | 43 | `00 A5 FA AF 25 18 D0 93 AA A5 FA AF` |
| 256 | 121 | `00 A5 FA AF 25 18 D0 93 AA A5 FA AF` |
要点:**三重校验失败时只把 **`out[0]`** 置 0**,缓冲里从 `[1]` 起仍留着已验证 / 已解出的字节,数量随
输入长度增长。调用方看到 `len=0` 是因为按 `strlen` 计算(首字节为 0),**不是**因为缓冲被清空。
("复制 / 搬出步骤与校验的先后关系" 未逐指令确认,此处理解为观测现象而非机制定论。)
### 12.4 确定性
同一输入 `CE92A842A078CA3F8397` 在两个不同进程中各跑一次,缓冲前 4 字节**完全相同**
(`00 74 46 FD`),基址却分别是 `0x70F50000` / `0x70D40000`。
→ 输出与基址无关,只由输入决定。
### 12.5 TEA 是 ECB 模式(无链式)
用 `AB` 重复构造 100 / 256 字符输入,输出前 12 字节完全相同:
```
00 A5 FA AF 25 18 D0 93 AA A5 FA AF
└──── 8 字节一周期 ────┘
```
重复的明文分组产生重复的密文分组 → **分组之间无链接、无 IV、ECB**。
这与 §4 的结论一致(32 轮 TEA、8 字节分组、每块独立解密)。
### 12.6 基址随机化实测(6 个不同值)
| 进程 / 来源 | macKey.dll 基址 |
| ---------------- | --------------------------- |
| 本机首次 P/Invoke 测试 | `0x6F530000` |
| debug\_run.ps1 | `0x6BE60000` |
| 用户侧一次性运行 | `0x6F653000` |
| 本轮批量(12 次) | `0x6D100000`(12 次全同) |
| 本轮预置实验 | `0x70D40000` / `0x70F50000` |
要点:`DYNAMICBASE` 生效,跨进程会出现不同基址;但**同一批连续启动可能落在同一基址**。
因此 x32dbg 里仍应使用 `mod.base("macKey.dll") + 偏移`,不要写死某一次的绝对地址。
### 12.7 输出缓冲容量
以 128 字节预置做实测,memset 把 128 字节全部清零,写入侧最多到 `[120]` 附近仍未越界,
与 §1 记的「静态缓冲 128 B(0x100130C0)」相符。
***
## 13 目录级样本搜寻(paiChe.DB 与配置文件,只读)
目的:找一条 “已验证正确的验证码” 作为已知明文,用来反向校准解密器 / 校验器。
### 13.1 paiChe.DB(SQLite,159,744 B)
| 表 | 行数 | 字段 |
| ------------------- | ----- | --------------------------------------------------------- |
| `carInfoList` | 2,049 | `plate, operName, stopTime, regTime` |
| `carPassStatements` | 40 | `id, plate, passDirection, eventTime, pass, info, codeNo` |
| `parking` | 15 | `plate, enterTime, live` |
| `sqlite_sequence` | 1 | `name, seq` |
全库按「纯 hex 且长度 ≥16」检索:**命中 0 个**。
实际内容是车牌号(`粤B01936`、`湘L21043`、`无牌车`)、时间戳、`允许通行`、以及
`err: iRet=28 ,msg=` 这类设备返回串,没有任何 MAC 形态字段。
### 13.2 全目录 hex 串搜寻
按合法长度集合(20 / 36 / 52 / 68 / 84 … 4+16n)扫描 `C:\调试工具1.39` 下所有文件,命中 7 处:
| 文件 | 偏移 | 串 |
| ------------------------- | -------- | ---------------------- |
| `D3Dcompiler_47.dll` | 0x2E37EB | `44444444444444444444` |
| `hi_h264dec_w.dll` | 0x040660 | `01233333333333333333` |
| `ice_ipcsdk.dll` | 0x08AF20 | `01233333333333333333` |
| `libmysql.dll` | 0x12BFD8 | `00102030405060708090` |
| `Qt5Widgets.dll` | 0x3C7101 | `caaaaaaaaaaaaaaaaaac` |
| `HCNetSDKCom\HCAlarm.dll` | 0x036ACE | `dddddddddddddddddddd` |
| `sqldrivers\qsqlite.dll` | 0x0E100C | `00112233445566778899` |
全部是第三方库里的**测试数据 / 数字补齐**(重复字符、递增序列),与验证码无关。
### 13.3 配置文件
```
paze.ini [set] okCnt=0 errCnt=0 debug=
[enc] encServerIp=192.168.0.23
encServerPort=3333
user.ini [VzLPRSDKDemoDlg] LastIP=192.168.2.39
```
`paze.ini` 的 `[enc]` 段只有一个 IP 和一个端口,**没有任何预置的验证码或密钥**;
`user.ini` 只记了一个 IP。`lpr.ini`、`whitelist.csv` 在本次扫描中未发现。
### 13.4 结论
1. 这套部署里**不存在**“已验证正确的验证码” 这种样本,因此无法用「已知明文反推算法」这条路径;
2. 也印证了此前的实测结论:所有试过的串(截图码、两个 34 字符字面量、设备 SN)在
`_GetDecString@4` 处一律 `len=0`,且没有第二个可用来校准的参照点;
3. 验证码的签发点在程序外部(`encServerIp:3333` 或持锁设备),客户端只承担「写入 / 校验」角色。
***
## 14. 任务 1+2:按钮槽函数与服务器层(本轮静态分析)
### 14.1 按钮 → 槽 的落点
`生成主板验证码` 的槽函数确定为 **0x0048CAF0**:
* 该函数的字符串引用包含 `"允许SN:"`(0x51E251)、`"请正确输入需要验证的主板序列号"`(0x51E218);
* 全 `.text` 只有 **1 处** 调用它:`0x004AD766`,形态为 `8B 4D 08`(`mov ecx,[ebp+8]`) + `E8 02 69 FD FF`(`call`),即 moc `qt_static_metacall` 的派发序列(`ecx = this`)。所以它确实是以 "按名字反射调用" 方式被按钮触发的槽,不是普通成员函数。
### 14.2 0x48CAF0 的完整流程(逐段)
| 顺序 | 地址 | 动作 | 结论 |
| -- | ----------------- | ----------------------------------------------------------------- | ----------------------------------------------------------------------------- |
| 1 | 0x48CAFE | `call 0x489D10` → 返回 `al` | 前置门。`al != 0` 才继续,否则直接 `ret`(静默返回) |
| 2 | 0x48CB10 | `[edi+0x234]` → `[+0x4C4]` 控件 + `call [0x549BDC]` | 取 **序列号输入框** 文本(QLineEdit) |
| 3 | 0x48CB34 | `call [0x549340]` | `trimmed()` 去空白 |
| 4 | 0x48CB43 | `mov eax,[ebp-0x40]; mov eax,[eax+4]` → `cmp ...,2; jle 0x48CD21` | QString 内部 size,**长度 ≤ 2 就拒绝** |
| 5 | 0x48CD21 | `"请正确输入需要验证的主板序列号"` + `"错误"` + `call [0x5498B0]` | 弹 QMessageBox 后 ret |
| 6 | 0x48CB68 | `call 0x41DE80` | **密钥容器初始化**:`call 0x4169D0` 后 `strcpy_s(this+0x10, 0x18, <常量串>)` |
| 7 | 0x48CB8B | `"xiao22"` → `QString::fromAscii_helper` → `call 0x41D840` | 用一个 QString 覆盖密钥缓冲(`0x41D840` = `toUtf8` + `memcpy` 到 `this+0x10`,长度 0x18=24) |
| 8 | 0x48CBE7 | `call 0x41D930` | **真正的生成调用**:`(outQString, inQString)` |
| 9 | 0x48CCA7/0x48CCB1 | `"SN:"` / `"允许SN:"` + `QDebug` | 仅日志输出(qDebug 的流式 `<<`),不是界面文本 |
| 10 | 0x48CCEC | `[edi+0x234]` → `[+0x4F8]` + `call [0x549B10]` | `QLineEdit::setText` 把结果写进 **验证码框**(偏移 +0x4F8) |
关键点:**整条路径没有建 socket、没有 **`call 0x48C5A0`**、没有任何网络 I/O**。
### 14.3 0x41D930 → 0x41CAA0 的加密核心
`0x41D930`(被 8 处调用,都在生成 / 校验路径上):
```
QString sn_utf8 = sn.toUtf8();
buf = new char[len+1]; memset(buf,0,len+1); memcpy(...);
memset(tmp, 0, 0x100); // 0x40 dword → 256 字节
call 0x41CAA0(buf, tmp, 0x100, keyobj+0x10) // 四参数:输入/输出/最大长度/密钥
return QString::fromAscii(tmp);
```
`0x41CAA0` 的形态与 macKey.dll 的核心**同族**:
```
memset(out, 0, 0x100);
strcpy_s(out, 0x100, in);
循环:0x4B4EC0 / 0x4B4F08 / 0x4B4F28 产生一个字节
sprintf_s(tmp, 3, "%02X", byte) // 0x416610 + "%02X"(0x50AF00)
strcat(out, tmp) // IAT 0x549DF8
直到输入串走完
```
即:**输入串 → 分块变换 → 每字节转 2 位大写十六进制 → 拼成一个纯 hex 串**。输出长度是输入长度的 2 倍(33 字符的 SN → 66 字符正好对得上截图里的 62 字符形状)。
### 14.4 门函数 0x489D10(未完全闭合)
* `0x489D10` 内先 `call 0x419280(obj+0xB0, 0)`;
* 返回 **非 0** 时走弹窗分支:`"未找到加密锁,请插入加密锁后,再进行操作。"`(0x51DF30) + `"错误"`,然后 `mov eax,1; ret`;
* 返回 **0** 时跳到 `0x489E00`,那里再 `call 0x489940` 取一个 `bool` 放进 `[ebp-0x4D]` 作为返回值。
由于调用方判的是 `test al,al; jne 继续`,所以 "al==1(未找到加密锁)→ 仍然继续生成" 这一组合在语义上反直觉。**该门的返回值语义尚未完全确认**(需要动态跟一次才能定论),此处只记录事实,不做断言。
### 14.5 任务 2:服务器层(encServerIp : 3333)
* **0x48C5A0** = 服务器配置 / 连接例程:
* `QCoreApplication::applicationDirPath()` + `"/paze.ini"`(`QString::append`);
* 读 `enc/encServerIp`(0x51E1F4)、`enc/encServerPort`(0x51E204);
* 日志 `"连接服务器成功..."`(0x51E1CA);
* 另有一处 `0x4A2F51 / 0x4A3047` 也读同一对键(设置页 / 回显)。
* **0x4812E0** = 服务器错误处理,输出 `"服务器返回错误:"`(0x51D14C) → 对应截图里那条 `Connection timed out`(字符串由 Qt `errorString()` 回填,不是字面量,所以静态搜不到)。
* 导入侧:`Qt5Network.dll!QTcpSocket::QTcpSocket / ~QTcpSocket`、`QHostAddress::~QHostAddress / protocol / toString` 均在 IAT 中,但 `QAbstractSocket::connectToHost`** 这一导出名未出现在导入表里**,因此实际建连动作可能被放在别的模块或别的调用形态中,**尚未闭合**。
### 14.6 结论修正(重要)
上一轮我基于 `paze.ini` + `Connection timed out` 判断 "验证码由外部授权服务签发",**在「生成主板验证码」这条路径上不成立**:
> 该槽函数的全部行为是:读输入框 → 校验长度 → 用
>
> **硬编码密钥**
>
> 做本地加密 → 把结果 setText 回验证码框。
> 它既不读
>
> `encServerIp`
>
> ,也不建连接,也不解析任何服务器返回。
也就是说,"没有授权服务、也没有加密狗" 仍能点出生成结果 ——**加密锁只影响 0x489D10 这道门以及写入 / 协议页,不影响这个生成函数本身的计算**。
### 14.7 边界(不变)
本条路径的具体密钥常量与 `0x41CAA0` 的逐字节变换,我不写进报告、也不拼成可用生成器,同样不为 `c399211e7921f9ea` 代算验证码。理由与前几轮一致:这是设备授权凭证,代算 / 发工具等于绕过厂商授权体系。结构层面的事实(本地计算、非服务端签发、函数与偏移)已如实在此记录。
---
## 15. 0x489D10 门函数:动态实测 + 分支定论
### 15.1 锁是什么(静态确定)
`0x489D10` → `0x419280` → 信号量 `"ex_sim"`(CreateSemaphoreA 0x549C98) 加锁 → `0x416FC0` → `0x416C40`。
`0x416C40` 是 **USB HID 加密锁识别**,用的是 `hid.dll` / `SetupApi.dll`(这两个 DLL 名在 .rdata 里以 `\SetupApi.dll`(0x50AF05)、`\hid.dll`(0x50AF82) 形式存在,由 `0x416699` / `0x416754` 引用,运行时 LoadLibrary + GetProcAddress,函数指针落在 `.bss` 的 `0x5470F4 / 0x5470F8 / 0x5470FC / 0x54710C / 0x547114 / 0x54711C`)。
识别条件在 `0x416DB4..0x416DD1`:
```
mov eax, [esp+0x3C] ; HIDD_ATTRIBUTES +4 = VendorID(low16) | ProductID(high16)
cmp eax, 0x87623689 ; VID=0x3689, PID=0x8762
cmp eax, 0x20203689 ; VID=0x3689, PID=0x2020
cmp eax, 0x20202020 ; VID=0x2020, PID=0x2020
```
**VID 0x3689 是飞天诚信(Feitian)加密锁的厂商号**。所以这个"加密锁"是一只 HID 接口的飞天锁;`0x489940` 再用 `0x418FF0` 读锁里的数据,用 `sprintf("%X%X")`(0x51AE0A) 拼成锁内容串。
### 15.2 返回值约定(静态确定)
`0x416FC0` 尾部:
```
call 0x416C40
cmp eax, 1
sbb eax, eax ; 内层 >=1 → 0 ; 内层 ==0 → -1
and eax, 0xFFFFFFA4 ; → 0 或 0xFFFFFFA4 (-92)
```
即 **0 = 找到锁/成功,-92 = 没找到/失败**。
`0x489940`:`0x418FF0` 返回非 0 → `xor eax,eax` 直接 `ret 4`(返回 0);返回 0 → 走 `sprintf("%X%X")` 组装串 → 返回 1。
### 15.3 真机实测(本轮动态证据)
`Get-PnpDevice -PresentOnly` 枚举 103 个设备,结果:
- `VID_3689`:**无匹配**
- `PID_8762 / PID_2020 / VID_2020`:**无匹配**
- 现存 HID 设备只有 1 个:`USB\VID_17EF&PID_6019`(联想外设,与本工具无关)
**结论输入已实测确认:本机没有飞天加密锁。**
### 15.4 分支定论
把实测输入代入代码,路径唯一:
| 步骤 | 取值 | 依据 |
|---|---|---|
| `0x416C40` 枚举 HID | 无 VID_3689 → 返回 0 | 15.3 实测 |
| `0x416FC0` | `0xFFFFFFA4`(-92) | 15.2 的 `cmp/sbb/and` |
| `0x489D10` | `eax != 0` → 走弹窗分支 | `0x489D37 test eax,eax; je 0x489E00` 未跳 |
| 弹窗 | `"未找到加密锁,请插入加密锁后,再进行操作。"` + `"错误"` | 0x51DF30 / 0x51D5C6 |
| **返回值** | **`mov eax,1; ret`** | `0x489DEA` 字面量,无其它出口 |
| 调用方 `0x48CAF0` | `test al,al; jne 0x48CB10` → **跳转,继续生成** | `0x48CB03/0x48CB05` |
**定论**:
1. 无锁时点「生成主板验证码」,会先弹一句 `未找到加密锁,请插入加密锁后,再进行操作。`,**然后照旧继续做本地计算并把结果填进验证码框**。那句提示是纯提示,没有阻断作用(`return 1` 是这段代码的字面行为,不是我的推断)。
2. 反向情形:若插了锁但 `0x489940` 读数据失败(返回 0),`0x48CAF0` 会 **静默返回,什么都不生成、也不弹窗** —— 这是唯一真正阻断的组合。
3. 结合 §14 的结论:生成路径不依赖服务器、也不依赖锁,**"没有授权服务也没有加密锁"能出验证码,原因就是码在客户端本地算出来**,与狗和服务器无关。
### 15.5 本轮没做的事
没有在调试器里真的断到 `0x489D10`(那需要点一次按钮触发槽)。本轮的做法是:把"决定分支的那个输入"(有没有飞天锁)用真机枚举实测下来,再代入代码求值——因为返回值是 `mov eax,1` 字面量、分支只有两个出口,所以结论唯一。若要 100% 现场取证,可在 x32dbg 里对 `0x400000+0x489D10` 下断、点一次生成按钮,命中后 `step out` 看 `eax`。
---
## 16. 生成链路解剖:0x48CAF0 → 0x41D930 → 0x41CAA0
> 本节给的是**数据流、缓冲布局、逐步结构**;最后一层变换 `0x41A8A0` 的轮函数、两张 256 字节表的内容、以及密钥常量本身不展开(理由同 §14.7)。
### 16.1 0x41D930:QString 进、C 字符串出
签名 `QString f(QString inQString)`(`ecx` = 返回值的隐藏指针,`[ebp+0xC]` = 输入 QString):
```
QByteArray u8 = inQString.toUtf8(); // IAT 0x54932C toUtf8_helper
src = u8.constData(); len = u8.size();
p = malloc(len + 1); // 0x4AFEE0 (operator new[])
memcpy(p, src, len); p[len] = 0; // 0x4B4F30 memset + 0x4AFF50 memcpy
memset(tmp, 0, 0x100); // rep stosd 0x40 dword = 256 字节
call 0x41CAA0(p, tmp, 0x100, this+0x10); // ← 四参数
*out = QString::fromAscii(tmp, strlen(tmp)); // IAT 0x549348
free(p); // 0x4AFEF0
```
要点:**输入走 UTF-8 字节流**(非 ASCII 的 SN 会按字节参与计算),输出按 **ANSI/ASCII 串** 回读(`fromAscii`)。
### 16.2 0x41CAA0 的栈帧布局
`sub esp, 0x25C`,各块位置(相对该函数的 `esp`):
| 区域 | 偏移 | 大小 | 用途 |
|---|---|---|---|
| 输出主缓冲 | `esp+0x50` | 0x100(256 B) | `memset` 清零 → `strcpy_s` 放 SN → 后续 `strcat` 累加 |
| hex 小缓冲 A | `esp+0x2D` | 3 B | `sprintf_s(_, 3, "%02X", 某字节)` |
| hex 小缓冲 B | `esp+0x36` | 8 B | 第二处 `"%02X"` |
| 变换输出区 | `esp+0x150` | 0x40 dword = 256 B | 交给 `0x41A8A0` |
| `this`(密钥对象) | `esp+0x10` | 4 B | 形参 `ecx`,指向密钥容器(密钥在 `+0x10`,长 0x18=24 字节) |
### 16.3 逐步(本轮实测指令流)
```
1) memset(buf, 0, 0x100) rep stosd ×0x40
2) strcpy_s(buf, 0x100, SN) IAT 0x549E08
3) time(0) → srand(seed) → rand() ← 0x4B4EC0 / 0x4B4F08 / 0x4B4F28
al = (byte)rand()
sprintf_s(tmpA, 3, "%02X", al)
strcat(buf, tmpA) → 串变成 SN + 2 位 hex「时间盐」
4) len = strlen(buf)
ecx ^= buf[i] (逐字节 XOR 累加,取低 8 位)
ebp += buf[i] (逐字节 SUM 累加)
sprintf_s(tmpB, 8, "%02X", (xor8 + sum8) & 0xFF)
strcat(buf, tmpB) → 追加「校验位 1」
5) 表驱动校验(整串再遍历一遍):
edx = 0xFFFFFFFF; ebp = 0xFFFFFFFF; al = 0xFF
dl ^= buf[i]; 索引表1[dl] / 表2[dl] 两级查表
结果 → [esp+0x1C] → 「校验位 2」
6) call 0x41A8A0(out2 @esp+0x150, buf, 0x6E, key) → 最后一层变换(不展开)
7) 变换结果 hex 化 → 作为返回值 → 回到 0x41D930 的 fromAscii
```
关键的三段常量:
- **`0x509220` / `0x509320`**:两张 256 字节的查表,与 macKey.dll 里 `0x10010DE0 / 0x10010EE0`(T1/T2)**属同一家族的自制表**,不是标准 CRC-16/ARC、CCITT、MODBUS。
- **`0x6E`**:传给 `0x41A8A0` 的常量,与 macKey 里"逐字节 XOR 0x6E"的那个常数同值。
- **密钥**:不在代码里现成放着,而是由 `0x41DE80` 先填默认值、再由 `0x41D840` 用传入的 QString 覆盖(长度上限 0x18)。
### 16.4 这一层的两个非直觉点
**① 生成含时间盐。** `time(NULL)` + `srand` + `rand` 取一个字节并 hex 化后**拼进被校验的串**里。所以同一个 SN,在不同秒点生成的结果**可能不同**——这跟 macKey.dll 那条链路的完全确定性(§12.4)是两回事,别把两边混为一谈。
**② 校验覆盖盐自身,所以自洽。** 第 4/5 步的 XOR、SUM、表校验都是**对"SN + 盐"整串**算的,盐自己也在被校验范围内。因此拿到一个现成验证码时,无需知道生成时刻的 `time()` 值,也能按串内自带的盐重算校验——这正是 §6 说的"自引用 MAC"结构在生成侧的对应形态。
### 16.5 输出形态
- 输出是**纯大写十六进制字符串**(全部经 `%02X`);
- 长度由 `0x41A8A0` 的映射比例决定,不是 `4+16n`;
- 这条链与 macKey.dll 的 `_GetDecString@4` **无调用关系**(§2 已证:macKey 的 thunk 全 `.text` 只有 1 个调用点 `0x4841E0`,在车牌密码路径上)。也就是说:**主板验证码不是 macKey 算的**,`CE92A842…` 那串与 macKey 算法不符(§11)也因此讲得通。
### 16.6 边界
`0x41A8A0` 的轮数/轮函数、`0x509220`+`0x509320` 两表的内容、密钥常量字面值,本节都不展开,也不代算任何设备的验证码。要验证本节结构描述是否成立,最直接的办法是在 x32dbg 里对 `0x400000+0x41CAA0` 下断,观察 `esp+0x50` 那 256 字节缓冲在每次 `strcat` 后的增长。
---
## 17. 现场取证(x32dbg 命中 0x41CB09 / 0x41CC52)
SN 取 `1115159753`(10 字符,>2 通过长度检查),程序停在被调试状态,PID 11348。
### 17.1 命中 0x41CB09(`call rand` 返回后)
| 项 | 值 |
|---|---|
| EIP | `0x0041CB09` |
| ESP | `0x0075F620` |
| ESI / EDI | `0x0075F670` = **ESP + 0x50**(与 §16.2 的缓冲布局完全一致) |
| ESI 处内容 | `1115159753`(此时主缓冲里只有纯 SN,盐尚未拼入) |
| EAX | `0x000011A5` → **AL = 0xA5**(rand 取到的盐字节) |
### 17.2 命中 0x41CC52(`mov [esp+0x1C], eax` 之前)
| 项 | 值 |
|---|---|
| ESI / EDI 处内容 | `1115159753A57C` |
| `[esp+8]` → `0x0075F656` | 内容 `7C`(即 `esp+0x36` 那个 8 字节 hex 小缓冲) |
| EAX | `0x00000066`(即将写入 `[esp+0x1C]`) |
由此确定:主缓冲 = **SN + 盐 + 校验位1** = `1115159753` + `A5` + `7C`,共 14 字符。
### 17.3 一处修正(§16.3 第 4 步)
实测值 `校验位1 = 7C` 与两种候选都碰巧对上,但代码指令给的是唯一答案:
```
0x41CB80 循环:movzx edx,[eax]; xor ecx,edx; add ebp,edx ; ecx=XOR累计, ebp=SUM累计
0x41CB8E movzx eax, cl ; eax = XOR8
0x41CB91 add ecx, ebp ; ecx = XOR8 + SUM8
0x41CB93 movzx edi, cl ; → [esp+0x18],存起来,不进 hex 串
0x41CB9A mov [esp+0xC], eax ; ← sprintf 的第 3 个参数是 eax,即 XOR8
```
**所以拼接进串的是纯 `XOR8`,不是 `(XOR8+SUM8)&0xFF`**;`XOR8+SUM8` 只是存到 `[esp+0x18]` 备用(后续交给 `0x41A8A0` 那层,或用于别处)。§16.3 第 4 步"`sprintf("%02X",(xor8+sum8)&0xFF)`"的说法作废。
(本例巧在 `XOR8(1115159753A5) = 0x7C`、`SUM8(1115159753A5) = 0x27C → 0x7C`,两者相等,光看数值分辨不出来,是代码指出的。)
### 17.4 待补的两项
1. `call 0x41A8A0`(out @`esp+0x150`, buf, 0x6E, key) 返回后输出区长什么样 → 断 `0x41CC7E`
2. 隔秒二次生成,`AL` 与 `esp+0x50` 里的盐是否变化 → 验证"时间盐"
### 17.5 生成链的调用方全景(修正"只有按钮一条入口"的印象)
对 `0x41D930` 与 `0x41CAA0` 全 `.text` 扫 E8 rel32,结果如下(实际调用方 12 处,不是 1 处):
| 调用点 | 目标 | 上下文特征 | 推断 |
|---|---|---|---|
| `0x48CBE7` | `0x41D930` | 前一条 `0x48CB8B call 0x41D840`(`"xiao22"` 覆盖密钥),再取 `[edi+0x234]+0x4C4` 的 QLineEdit 文本 | **「生成主板验证码」按钮槽 `0x48CAF0` 本身** |
| `0x48D60B` | `0x41D930` | 位于 `0x48D5xx`,与 `0x48CE50`("xiao11" 用户数据)同一函数族 | 数据/授权读写路径 |
| `0x48EF72` | `0x41D930` | 先 `0x4C5F50/0x4C5F90/0x4D7720`(QString 拷贝/构造),再生成 | 另一个 UI 生成入口 |
| `0x491F5E` | `0x41D930` | 同上三连 QString 调用 | 另一个 UI 生成入口 |
| `0x4A216F` | `0x41D930` | 手写 strlen(`0x80808080` 技巧)后 call 函数指针 `[ebp-0x160]` | 一批相近函数之一 |
| `0x4A235A` | `0x41D930` | 同上 | 同上 |
| `0x4A2560` | `0x41D930` | 同上 | 同上 |
| `0x4A2732` | `0x41D930` | 同上族 | 同上 |
| `0x41DA28` | `0x41CAA0` | 父函数 `0x41D930` 内部:`toUtf8`→`memset`→`call 0x41CAA0` | §16 那条链本体 |
| `0x49191D` | `0x41CAA0` | 函数内先用 `0x6F616978`+`0x3131` 拼出 `"xiao11"` 当密钥,再直接调 `0x41CAA0` | 绕过 `0x41D930` 的旁路 |
| `0x492092` | `0x41CAA0` | `0x4F4E20` 后 `0x4AFF50`(QString→char*)再调 | 旁路之二 |
| `0x4933D7` | `0x41CAA0` | 与 `0x49191D` 结构完全相同(同样 `"xiao11"`) | 旁路之三 |
**结论**:这条生成链在程序内部是一个公共组件,至少 12 处调用。§14 只确认了"按钮槽是其中之一",但"生成码只能由点按钮触发"这个印象是错的——**程序启动阶段也会走进来**(本机自检/授权/序列号显示等)。
这直接解释了动态调试时"还没见窗口就已经命中 `0x41CB09`"的现象:进程被停在初始化阶段的生成调用上,`QApplication` 的主窗口还没建,所以 `EnumWindows` 数出 0 个顶层窗口。
---
## 18. 中文字符串为何在 x32dbg 里是乱码
### 18.1 实测:`.rdata` 里的中文是 UTF-8,不是 GBK
对抽样地址直接读原始字节:
| VA | 前 18 字节 | UTF-8 解码 | GBK 解码 |
|---|---|---|---|
| `0x51B654` | `E9 AA 8C E8 AF 81 E7 A0 81 E6 A0 B9 ...` | `验证码根据此序列号生成` ✅ | 失败 ❌ |
| `0x51B7BE` | `E4 B8 BB E6 9D BF E9 AA 8C ...` | `主板验证码` ✅ | 失败 ❌ |
| `0x51E218` | `E8 AF B7 E6 AD A3 E7 A1 AE E8 BE 93 ...` | `请正确输入需要验证的主板序列号` ✅ | 失败 ❌ |
特征:每个汉字都以 `E4`~`E9` 开头的 **3 字节 UTF-8 序列**存储。这是 MinGW-GCC + Qt 工程的常见形态(源码里 `u8` 字面量,直接进 `.rdata`)。
(`0x51DF30` 那一条因为按 48 字节切片正好切在字符中间,UTF-8 解码报错——不是编码问题,是切片边界问题。)
### 18.2 为什么 x32dbg 显示成乱码、搜不到
- x32dbg 的「字符串」列表与引用面板按**本机 ANSI 代码页(936/GBK)**解码 `.rdata`;
- 文件里是 UTF-8 三字节序列,按 GBK 解 → 每 3 字节被拆成 1 个半汉字 + 半个字节 → 乱码;
- 你在搜索框里敲中文,x32dbg 也按 GBK 转字节,而目标字节是 UTF-8 → **两边永不相等**,所以"搜不到"或搜出乱码;
- 纯 ASCII 串(`"SN:"`、`"验证码:"` 的英文部分)不受影响,能正常显示——截图里 `0051E24D "SN:"` 就是好例子。
### 18.3 三种可用的解法
1. **按 UTF-8 十六进制搜索**(最省事):把中文转换成 `E4B8BB...` 这样的 hex 串,在 x32dbg 内存窗口按字节搜。附脚本 `u8hex.ps1`(UTF-8 带 BOM,须用 `powershell -ExecutionPolicy Bypass -File` 运行):
```
.\u8hex.ps1 -Text "主板验证码" → E4B8BBE69DBFE9AA8CE8AF81E7A081
.\u8hex.ps1 -Hex E4B8BBE69DBF... → 反查是不是你要的串
```
2. **直接用地址清单**:已导出 `字符串_UTF8清单.txt`(**738 条** UTF-8 中文串,`VA + 内容`),拿到 VA 后 `Ctrl+G` 跳转,或看反汇编里的 `push 0x51xxxx` 引用。
3. **在反汇编里找**:本程序引用字符串都是 `push imm32`,直接看操作数地址即可,不必依赖字符串搜索。
### 18.4 清单里的两条新发现
| VA | 内容 | 意义 |
|---|---|---|
| `0x51B850` | `生成摄像机验证码有狗` | 印证 §7 的「有狗/无狗」是**按钮/入口命名**,不是本机是否有锁 |
| `0x51B82C` | `相机验证码` | 与 `摄像机验证码` 并存,说明有两套叫法 |
同族还包括:`0x51B654 验证码根据此序列号生成`、`0x51B676 验证码`、`0x51B749 验证码:`、`0x51B7BE 主板验证码`、`0x51B816 生成主板验证码`、`0x51B888 生成验证码`。
### 18.5 「摄像机SN未验证」定位结果
| 项 | 值 |
|---|---|
| VA | `0x0051E41A` |
| RVA / 节 | `0x11E41A` / `.rdata` |
| 原始字节 | `E6 91 84 E5 83 8F E6 9C BA 53 4E E6 9C AA E9 AA 8C E8 AF 81 00` |
| 字节长度 | **20**(含结尾 00 共 21 字节) |
| 字符数 | 8(`摄像机` 9B + `SN` 2B + `未验证` 9B) |
5 处代码引用,及各自所属函数:
| 引用指令 | 所属函数 | 该函数内其他文案 |
|---|---|---|
| `0x48E80A mov [esp],0x51E41A` | `0x48DFC0`(+0x84A) | `允许SN:`、`非法协议`、`onBtnSj oldchars:`、`xiao11`、`default` |
| `0x48EB11 mov [esp],0x51E41A` | `0x48EA90`(+0x81) | `正在地磅协议...`、`开始地磅协议...`、`开启协议结束...`、`zq2017`、`SZTXSY` |
| `0x48F4B5 mov [esp],0x51E41A` | `0x48ED90`(+0x725) | `正在开启公司协议...`、`用户数据:读取/写入成功`、`L6B7Y9` |
| `0x4914E0 mov [esp],0x51E41A` | `0x490E10`(+0x6D0) | `正在开启带狗协议...`、`A97tx2`、`CAM:`、`正在请求服务器....` |
| `0x492870 mov [esp],0x51E41A` | `0x491CC0`(+0xBB0) | `CAMDEC:`、`正在连接服务器....`、`正在跳过错误,继续`、`用户数据:%1` |
调用形态(以 `0x48EB09` 为例):
```
0048EB09 mov dword ptr [esp+4], 0x14 ; 长度 20
0048EB11 mov dword ptr [esp], 0x51E41A ; 字符指针
0048EB18 call edi ; QString(ptr, len) 构造
```
即 `QString("摄像机SN未验证", 20)`——长度按**字节数 20** 显式传入,不是按字符数 8,这也反证它是 UTF-8 字符串。
**含义**:这条提示出现在「地磅协议 / 公司协议 / 带狗协议 / CAMDEC」几条不同的流程里,说明它是个**前置校验的失败提示**——进入这些协议流程前先检查摄像机 SN 是否已验证,未验证就打这条日志并中止。
---
## 19. 两条「未验证」校验的判断条件
### 19.1 摄像机SN 校验:本地解密 + 前缀比较
判定不是查服务器,而是**本地把输入串解密后做字符串比较**。
调用方(以 `0x48EA90` 为例,进"地磅协议"前):
```
0048EAA5 mov eax,[ecx+0x3c] ; 取某成员指针
0048EAA8 test eax,eax
0048EAAA je 0x48EB41 ; 空 → "摄像机连接失败"
0048EAB3 push 2 / push 0x51E42F ; "02"
0048EAC8 call QString::fromAscii ; QString("02")
0048EACA mov [esp+4], 2 ; 第二个参数 n = 2
0048EAD2 mov [esp], esi ; 第一个参数 = 上面那个 QString
0048EADA call 0x48DFC0 ; ← 校验函数
0048EB01 test al,al
0048EB03 jne 0x48EBD9 ; al≠0 → 通过,继续协议流程
0048EB09 push 0x14 / push 0x51E41A ; "摄像机SN未验证"
0048EB2A call 0x480D00 ; 打日志
0048EB40 ret ; 直接返回,协议流程不执行
```
`0x48DFC0` 内部(`this` 在 ecx,参数 `[ebp+8]`=QString、`[ebp+0xC]`=n):
```
0048DFD8 call 0x41DE80 ; 密钥容器初始化
0048E00E call 0x41D840 ; 用 "xiao22" 覆盖
0048E2AC cmp byte ptr [ecx+0x14],0 ; 输入框/对象的"已填"标志
0048E2D2 就地拼 "xiao11"(0x6F616978+0x3131)
0048E31D call 0x41C590 ; ← 用 "xiao11" 解密输入串
0048E325 strlen → 长度
0048E386 call QString::left(n) ; 取解密结果前 n 个字符
0048E395 call operator== ; 与调用方给的 QString 比
0048E3CA test al,al
0048E3CC jne 0x48E533 ; 相等 → 通过
0048E80A push "摄像机SN未验证" ; 不等 → 日志
```
**判断条件**:`解密(输入串, key="xiao11").left(n) == 调用方给的串`(本例 n=2、串="02")。
返回值走 `ret 8` 交回调用方,调用方按 `test al,al` 决定是否中断协议流程。
### 19.2 关键发现:`0x41C590` 就是 macKey 那条解密管线
反汇编特征与本报告 §3 的 macKey 核心完全同型:
```
0041C5C0 call memset ; 清缓冲
0041C5C8 call strlen
0041C5CD sub eax,4 / cmp 0xFC ; 长度 4..256 校验,超范围 → out[0]=0
0041C619 call strcpy_s(0x104) ; 拷到 0x104 缓冲
… … ; 调 0x41A8A0 变换(与生成侧同一个)
0041C78A 出现 XOR 0x6E 的字节操作
```
它在本程序里是 `0x41A8A0` 的**解码侧调用**(调用点统计:`0x41C590` 内 `call 0x41a8a0` 一次、`0x41A3D0`、`0x41A4C0`、`0x41C4E0` 各一次)。也就是说 **exe 内部自带一份与 macKey.dll 同族的解密实现**,不依赖 DLL,也不需要服务器。
### 19.3 主板未验证:fail-closed(默认失败,只有明确成功才放行)
调用点 `0x498220`:
```
004985EE mov byte ptr [ebp-0x321], 1 ; ← 初值 = 1(默认"未验证")
00498604 call 0x480B00 ; QString 构造
0049862B call 0x4942F0(this, &QString, &[ebp-0x321]) ; 把标志地址传进去
…
00498A35 cmp byte ptr [ebp-0x321], 0
00498A3C jne 0x498EF0 ; 仍为 1 → 走"未验证"分支
```
"未验证"分支(`0x498EF0`)弹框并返回:
```
00498EF6 push 0x51F00C ; "[%1]主板未验证,请先验证..."
00498F6C push 0x51F030 ; "主板未验证,请先验证"
00498F81 push 0x51D5C6 ; "错误" ← QMessageBox 标题
```
第二条同型调用点在 `0x4998D0`(引用 `0x49A3CC`)。
被调用的 `0x4942F0` 是一个"协议帧组装/记录"函数(函数内 `QString::arg("主机发送:%1")` 打日志,调用 `0x4029C0 / 0x402F90 / 0x402FD0 / 0x413AD0 / 0x4941E0`),失败时执行:
```
0049464C mov edx, [ebp+0xc] ; 标志指针
0049467D mov byte ptr [edx], 1 ; 置 1
```
**判断条件**:标志字节初值即 1,只有 `0x4942F0` 内部确认成功才会保持/置 0;否则一律落"主板未验证"。这种写法保证**任何异常路径都判为未验证**。
### 19.4 三处容易踩的字符串细节
| 地址 | 内容 | 说明 |
|---|---|---|
| `0x51F00C` | `[%1]主板未验证,请先验证...` | 带占位符版本,日志用 |
| `0x51F010` | `主板未验证,请先验证...` | **不是独立字符串**——它是 `0x51F00C` 跳掉 4 字节 `[%1]` 后的地址,所以按 `0x51F010` 搜引用会得 0 处 |
| `0x51F030` | `主板未验证,请先验证` | 弹框正文用的版本 |
### 19.5 结论
两条校验都**不含网络调用**:
- 摄像机SN:本地解密(`0x41C590` + `0x41A8A0`,key `xiao11`)后做前缀比较;
- 主板:本地组装协议帧,失败即置位;标志是 fail-closed。
因此"没服务器、没加密狗"并不影响这两条校验执行——它们判定的是**输入串/协议应答是否自洽**,而不是在线授权。
---
## 20. 摄像机SN 校验细化(取数链 + 现场参数映射)
### 20.1 输入从哪来
```
0048E04E eax = [this+0x234] ; 界面对象表
0048E054 eax = [eax+0x410] ; ← 摄像机SN 输入框控件(与主板那路的 +0x4C4 区分开)
0048E05D call QLineEdit::text
0048E06D call QString::trimmed_helper
0048E080 call QString::toUtf8_helper
0048E0AD call 0x480B00 ; Utf8 → char 缓冲
0048E193 debug("onBtnSj oldchars:", 0x11) ; ← 日志里就写着 onBtnSj
```
即:**校验对象就是界面上"摄像机SN"那个输入框的文本**(`+0x410`),trim 后转 UTF-8 字符缓冲。
### 20.2 密钥不是硬编码常量,走容器
```
0048DFD8 call 0x41DE80 ; 密钥容器初始化
0048DFDD eax = QString::fromAscii
0048DFE2 push 6 / push 0x51E25B ("xiao11") ; 6 字节
0048E00E call 0x41D840 ; 把 "xiao11" 灌进容器
```
### 20.3 `0x41C590` 的调用约定(按现场栈核对)
`0x41C590` 是 `this(ecx) + 4 个栈参`,`ret 0x10`:
| 参数 | 位置 | 含义 |
|---|---|---|
| this | `ecx` | 未使用 |
| arg1 | `[esp+0x46C]` | 未使用 |
| arg2 | `[esp+0x470]` | **输入串**(`strlen` 的对象) |
| arg3 | `[esp+0x474]` | **输出缓冲**(`memset(arg3,0,arg4)` 清的就是它) |
| arg4 | `[esp+0x478]` | **长度上限**(`0x100`) |
现场(用户 x32dbg,SN=`1115159753A57C`)实测:`arg2="1115159753A57C"`、`arg3` 指向同内容的 0x100 缓冲、`arg4=&"xiao11"`(显示乱码是 x32dbg 按 GBK 解码 UTF-8 所致,核对字节应为 `78 69 61 6F 31 31`)。
长度检查:`strlen("1115159753A57C")=12`,`12-4=8 ≤ 0xFC` → 通过,进入 `rep stosd` 清 0x104 缓冲 + `strcpy_s(buf,0x104,in)`。
> 注意:输入串 `1115159753A57C` 正是**生成链产物形态**(10 位 SN`1115159753` + 2 位盐`A5` + 2 位校验`7C`),说明程序把"生成结果"回填进了摄像机SN 字段再反解。
### 20.4 判定链(三条,逐级收窄)
```
④ 0048E294 test al,al / jne 0x48E533 ; 第 1 关:operator==(left(n), 目标串 "02")
→ 不等则 0x48E3D2 打 "非法协议"(0x51E3F6) 并返回
⑤ 0048E533 eax = [明文 QString+4] - n ; size - n
0048E552 QString::right(size-n) ; 取明文尾部(去掉前 n 位)
0048E597 debug("允许SN:" + 该尾部) ; 0x51E251
0048E5EE QString("112",3) ; 0x51E403 硬编码
0048E666 QString("413123fsdff3242342",18) ; 0x51E407 硬编码
0048E6xx 依次比较
```
即判定不是一次比较,而是**"前缀对 + 尾部对白名单"**两级:
- 第一级:`解密(SN).left(n) == "02"`(n=2,由调用方传入);
- 第二级:`解密(SN).right(size-n)` 再与 `"112"` / `"413123fsdff3242342"` 两个**写在程序里的固定值**比。
### 20.5 该函数内全部字符串引用(一张表看清语义)
| 引用点 | 字符串 | VA |
|---|---|---|
| 0x48DFED | `xiao11` | 0x51E25B |
| 0x48E18C | `default` | 0x51D13B |
| 0x48E1B4 | `onBtnSj oldchars:` | 0x51E3E4 |
| 0x48E3DD | `非法协议` | 0x51E3F6 |
| 0x48E590 | `允许SN:` | 0x51E251 |
| 0x48E5EE | `112` | 0x51E403 |
| 0x48E666 | `413123fsdff3242342` | 0x51E407 |
| 0x48E80D | `摄像机SN未验证` | 0x51E41A |
`0x51E403 "112"`(3 字节)紧跟 `0x51E407 "413123fsdff3242342"`(18 字节),再紧跟 `0x51E41A "摄像机SN未验证"`(20 字节)——三串首尾相接,`0x51E419` 是空字节(`0x51E407+18`),别当成独立字符串。
### 20.6 本轮结论与仍待现场确认的一点
- 摄像机SN 校验**完全本地**:读输入框 → 用 `xiao11` 解密 → 两级字符串比对,无网络、无狗、无 DLL 依赖。
- 与"非法协议"的区别:`非法协议` 是第一级(前缀对不上)的出口;`摄像机SN未验证` 是第二级/上行比对失败时的出口(另有 4 个调用方各自重打同一句)。
- 仍未定:第一级 `operator==` 的左右身份(`[ebp+8]`=QString 与 `[ebp+0xC]`=n)在 `0x48E386~0x48E395` 处谁是"明文侧"、谁是"目标 `02`"——只能靠现场寄存器定,静态层到此为止。
赞赏
- [求助]分析结果爆破学习不成功 103
- 我都已跳过狗的检测了,结果还是提示找不到 4050
- [求助]这个注册码授权可以控制时间 4111