首页
社区
课程
招聘
[求助]分析结果爆破学习不成功
发表于: 2026-11-15 14:56 103

[求助]分析结果爆破学习不成功

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` |


要点:**三重校验失败时只把&#x20;**`out[0]`**&#x20;置 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、没有&#x20;**`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`**&#x20;这一导出名未出现在导入表里**,因此实际建连动作可能被放在别的模块或别的调用形态中,**尚未闭合**。


### 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`"——只能靠现场寄存器定,静态层到此为止。



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

收藏
点赞 ・0
打赏
分享
最新回复 (0)
游客
登录 | 注册 方可回帖
返回