Files
iOSGuard/docs/04_DETAILED_SUBSYSTEMS_DESIGN.md
T

769 lines
31 KiB
Markdown
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
# iOSGuard 八大核心子系统详细设计与实现方案
本文档为 **iOSGuard** 企业级加固系统的八大核心子系统技术白皮书。每个子系统均提供:**设计目标、核心数据结构与接口、底层算法与实现流程、汇编与代码原型、技术陷阱与规避策略**。
---
## 目录
1. [子系统 1:Mach-O 深度重构与二进制引擎 (Mach-O Rewriter)](#1-mach-o-深度重构与二进制引擎-mach-o-rewriter)
2. [子系统 2:Class-Dump 彻底防御与动态重映射 (Metadata Protector)](#2-class-dump-彻底防御与动态重映射-metadata-protector)
3. [子系统 3:原生代码虚拟化 (VMP) 引擎 (Code Virtualization)](#3-原生代码虚拟化-vmp-引擎-code-virtualization)
4. [子系统 4:全维度内核级主动防御对抗矩阵 (Defender Core)](#4-全维度内核级主动防御对抗矩阵-defender-core)
5. [子系统 5:双符号表体系与 dSYM 崩溃逆向还原 (Dual-Symbol & Crash Restorer)](#5-双符号表体系与-dsym-崩溃逆向还原-dual-symbol--crash-restorer)
6. [子系统 6:资产保护与无感透明解密 (Virtual File System & Assets Protector)](#6-资产保护与无感透明解密-virtual-file-system--assets-protector)
7. [子系统 7:跨平台自动化重签名流水线 (Cross-Platform Signer Engine)](#7-跨平台自动化重签名流水线-cross-platform-signer-engine)
8. [子系统 8:IPA 相似度预检中心 (App Store 4.3 预检器)](#8-ipa-相似度预检中心-app-store-43-预检器)
---
## 1. Mach-O 深度重构与二进制引擎 (Mach-O Rewriter)
### 1.1 设计目标
在无源码条件下解析 IPA 中的主 Mach-O 与 Dynamic Frameworks,完成:
1. 安全注入 `LC_LOAD_DYLIB` 加载加固守护动态库 `libDefender.dylib`;
2. 新增私有加密段 `__PROTECT`(存放抽取函数、加密元数据、白盒查找表);
3. 严格遵循 ARM64 `0x4000`(16KB)页面对齐规范,保证重签名后 AMFI 校验通过。
### 1.2 核心数据结构
```cpp
#include <mach-o/loader.h>
#include <mach-o/nlist.h>
#include <vector>
#include <string>
struct MachOBinary {
mach_header_64 header;
std::vector<uint8_t> raw_data;
std::vector<load_command*> load_commands;
segment_command_64* text_segment;
segment_command_64* linkedit_segment;
linkedit_data_command* code_signature_cmd;
uint32_t header_padding_size;
};
```
### 1.3 底层算法与平移逻辑
```mermaid
flowchart TD
A["读取 mach_header_64 & load_commands"] --> B{"检测 Header Padding\n安全检查: first_section_offset >= header_size_with_cmds"}
B -- "不满足安全检查" --> B1["异常防御: 退出,防止无符号溢出"]
B -- "满足" --> C{"计算可用 Padding 空间\nfirst_section_offset - header_size_with_cmds"}
C -- "Padding >= sizeof(dylib_command)" --> D["直接就地追加 LC_LOAD_DYLIB\n递增 ncmds & sizeofcmds (M1 MVP 路径)"]
C -- "Padding 不足" --> E["触发全局段平移 (Segment Shift, 进阶阶段)\n平移增量 Delta = 0x4000 (16KB)"]
E --> F["更新所有 Segment fileoff >= Delta\n修复 LC_DYLD_CHAINED_FIXUPS、Rebase、Binding、Export Trie"]
D --> G["追加 __PROTECT Segment (0x4000对齐)"]
F --> G
G --> H["重设 LC_CODE_SIGNATURE 指向文件末尾"]
```
#### 代码实现原型:Header 扩容与 LC_LOAD_DYLIB 注入 (含边界防御)
```cpp
bool InjectDylib(std::vector<uint8_t>& binary, const std::string& dylib_path) {
auto* header = reinterpret_cast<mach_header_64*>(binary.data());
if (header->magic != MH_MAGIC_64) return false;
// 1. 计算对齐后的 dylib_command 大小 (8 字节对齐)
uint32_t cmd_size = sizeof(dylib_command) + dylib_path.length() + 1;
cmd_size = (cmd_size + 7) & ~7;
// 2. 检测 Header Padding 与首个 Section 偏移
uint8_t* cmds_start = binary.data() + sizeof(mach_header_64);
uint32_t header_and_cmds = sizeof(mach_header_64) + header->sizeofcmds;
uint32_t first_section_offset = UINT32_MAX;
uint8_t* cur_cmd = cmds_start;
for (uint32_t i = 0; i < header->ncmds; i++) {
auto* sc = reinterpret_cast<segment_command_64*>(cur_cmd);
if (sc->cmd == LC_SEGMENT_64) {
auto* sec = reinterpret_cast<section_64*>(cur_cmd + sizeof(segment_command_64));
for (uint32_t j = 0; j < sc->nsects; j++) {
// 仅统计实际存在于文件中的非零偏移 Section
if (sec[j].offset > 0 && sec[j].offset < first_section_offset) {
first_section_offset = sec[j].offset;
}
}
}
cur_cmd += sc->cmdsize;
}
// 边界安全防御:防止异常 Mach-O 导致无符号减法下溢 (Underflow)
if (first_section_offset < header_and_cmds) {
// 首个节偏移异常或已被篡改,直接拒绝处理
return false;
}
uint32_t available_padding = first_section_offset - header_and_cmds;
if (available_padding >= cmd_size) {
// Padding 充足:原地写入新指令 (M1 MVP 推荐路径)
auto* new_cmd = reinterpret_cast<dylib_command*>(cmds_start + header->sizeofcmds);
memset(new_cmd, 0, cmd_size);
new_cmd->cmd = LC_LOAD_DYLIB;
new_cmd->cmdsize = cmd_size;
new_cmd->dylib.name.offset = sizeof(dylib_command);
new_cmd->dylib.timestamp = 2;
new_cmd->dylib.current_version = 0x10000;
new_cmd->dylib.compatibility_version = 0x10000;
memcpy(reinterpret_cast<char*>(new_cmd) + sizeof(dylib_command), dylib_path.c_str(), dylib_path.length() + 1);
header->ncmds += 1;
header->sizeofcmds += cmd_size;
return true;
} else {
// Padding 不足:触发进阶的段平移与重定位链重构
return ShiftAndInjectDylibWithChainedFixups(binary, dylib_path, cmd_size);
}
}
```
### 1.4 进阶重定位机制:LC_DYLD_CHAINED_FIXUPS 修复挑战
> [!WARNING]
> **现代 iOS (iOS 14+ / Xcode 13+) 段平移技术风险**:
> 现代二进制广泛采用 `LC_DYLD_CHAINED_FIXUPS` 替代传统的 `LC_DYLD_INFO_ONLY` 重定位表。指针以链表形式编码在 `__DATA` 段内部(如 `dyld_chained_starts_in_segment` 和 `dyld_chained_ptr_arm64e`)。
> 一旦段发生物理平移或虚拟地址变动,必须同步重构:
> 1. 每个段链表头部结构体 `dyld_chained_starts_in_segment` 中的 `page_start` 偏移数组;
> 2. `LC_DYLD_EXPORTS_TRIE` 导出树中的 ULEB128 符号偏移;
> 3. 所有指针重定位链的目标 offset。
> **工程策略**:在 M1 MVP 阶段,限定处理 Xcode 预留有足够 Padding 的二进制包,将段平移与 Fixup 重构作为独立里程碑隔离攻关。
---
## 2. Class-Dump 彻底防御与动态重映射 (Metadata Protector)
### 2.1 设计目标
消除 Mach-O 静态暴露的所有 Objective-C 类名、分类、选择器和属性元数据,使 `class-dump`、`dscli`、Hopper、IDA 彻底无法还原符号;同时通过运行时受控动态注册,确保 `objc_msgSend` 与 KVC 正常运作。
### 2.2 Objective-C 64位运行时结构体解构
```c
struct objc_class_64 {
uint64_t isa;
uint64_t superclass;
uint64_t cache;
uint64_t vtable;
uint64_t data; // 指向 class_rw_t 或 class_ro_t
};
struct class_ro_t_64 {
uint32_t flags;
uint32_t instanceStart;
uint32_t instanceSize;
uint32_t reserved;
uint64_t ivarLayout;
uint64_t name; // 指向 __objc_classname 字符串
uint64_t baseMethods; // 指向 method_list_t
uint64_t baseProtocols;
uint64_t ivars;
uint64_t weakIvarLayout;
uint64_t baseProperties;
};
struct method_t_64 {
uint64_t name; // 指向 __objc_methname
uint64_t types; // 指向 __objc_methtype (真实类型编码,如 "@16@0:8")
uint64_t imp; // 函数虚拟地址 (相对Mach-O vmaddr基地址)
};
// iOS 14+ 广泛采用的小方法列表 (Relative Method List)
struct method_list_t_relative {
uint32_t entsizeAndFlags; // 包含 0x80000000 相对寻址标记
uint32_t count;
// 相对偏移结构体: 每个字段为相对于字段自身地址的 int32_t 偏移
struct method_relative_t {
int32_t name_offset;
int32_t types_offset;
int32_t imp_offset;
} methods[];
};
```
### 2.3 加固与还原流程
```
[编译加固期 (Mach-O 离线重写)]
1. 扫描 __DATA,__objc_classlist 提取 class_ro_t 与元类 (Meta-Class)
2. 序列化 {ClassName, [is_meta, Selector, ImpVMAddr, TypeEncoding]} 为私有二进制
3. 使用 ChaCha20-Poly1305 加密存入 __PROTECT,__meta 节
4. 清空非白名单的 __TEXT,__objc_methname (填 '\0'),将 class_ro_t->baseMethods 置空
│
▼
[运行时阶段 (libDefender 早期构造器 __mod_init_func)]
1. 获取目标 Mach-O 的 ASLR 偏移 (Slide = _dyld_get_image_vmaddr_slide(index))
2. 解密元数据,准确按类型注回:
- 实例方法注回目标类 cls
- 类方法注回元类 object_getClass(cls)
3. 使用真实 TypeEncoding 与 (ImpVMAddr + Slide) 动态注册
4. 对 +load、KVC 敏感类与系统协议建立白名单豁免机制
```
#### 运行时动态重映射 Hook 原型 (语义保持与 ASLR 修复版)
```objc
#import <Foundation/Foundation.h>
#import <objc/runtime.h>
#import <mach-o/dyld.h>
void RestoreObjcMetadata(const uint8_t *decrypted_meta, size_t size, intptr_t slide) {
size_t offset = 0;
while (offset < size) {
// 1. 读取类名
uint16_t name_len = *(uint16_t*)(decrypted_meta + offset);
offset += 2;
char class_name[256] = {0};
memcpy(class_name, decrypted_meta + offset, name_len);
offset += name_len;
Class cls = objc_getClass(class_name);
if (!cls) continue;
Class meta_cls = object_getClass(cls);
// 2. 读取方法列表
uint32_t method_count = *(uint32_t*)(decrypted_meta + offset);
offset += 4;
for (uint32_t i = 0; i < method_count; i++) {
uint8_t is_meta = *(uint8_t*)(decrypted_meta + offset++);
// 读取 Selector 名字
uint16_t sel_len = *(uint16_t*)(decrypted_meta + offset);
offset += 2;
char sel_name[256] = {0};
memcpy(sel_name, decrypted_meta + offset, sel_len);
offset += sel_len;
// 读取真实类型编码 (如 "@16@0:8" 或 "i24@0:8@16"),严禁写死 "v@:"
uint16_t type_len = *(uint16_t*)(decrypted_meta + offset);
offset += 2;
char type_encoding[128] = {0};
memcpy(type_encoding, decrypted_meta + offset, type_len);
offset += type_len;
// 读取静态 VM 地址并结合 ASLR Slide 计算真实函数入口
uint64_t imp_vmaddr = *(uint64_t*)(decrypted_meta + offset);
offset += 8;
IMP real_imp = (IMP)(imp_vmaddr + slide);
SEL sel = sel_registerName(sel_name);
Class target_cls = is_meta ? meta_cls : cls;
// 保持方法调用 ABI 语义完整,不破坏消息转发与参数传递
class_addMethod(target_cls, sel, real_imp, type_encoding);
}
}
}
```
### 2.4 语义保持与边界防线
> [!IMPORTANT]
> **Objective-C 元数据加固边界约束**:
> 1. **`+load` 时序限制**:`+load` 在 dyld 加载镜像时由 `libobjc` 的 `prepare_load_methods` 内部直接读取并调用,早于 C++ 动态库构造器。因此**带有 `+load` 的类方法必须保留在静态结构中或采用动态桥接白名单**,不可盲目抹除。
> 2. **JSON 反序列化与 KVC**:`YYModel` / `MJExtension` 依赖 `class_copyPropertyList` 和 `class_copyIvarList` 进行属性映射。加固系统必须建立基于类的排除规则,对 Model 数据模型对象豁免元数据抹除。
---
## 3. 原生代码虚拟化 (VMP) 引擎 (Code Virtualization)
### 3.1 设计目标
针对高敏感函数(如充值校验、密钥派生、核心通信协议),将其 ARM64 指令编译或抽取为私有字节码,通过纯解释型虚拟机(Interpreter-based VM)执行。**绝对不使用 `mprotect(PROT_EXEC)`,100% 遵从苹果 AMFI 与 W^X 规范**。
### 3.2 私有指令集 (Custom ISA) 规范设计
指令格式采用 4 字节定长指令:`[Opcode 8bit] [Dest_Reg 8bit] [Src_Reg 8bit] [Immediate / Offset 8bit]`。
| Opcode | 汇编助记符 | 描述 | 操作数含义 |
| :--- | :--- | :--- | :--- |
| `0x11` | `VM_MOV_IMM` | 将立即数写入虚拟寄存器 | `dst = imm` |
| `0x12` | `VM_MOV_REG` | 寄存器传值 | `dst = src` |
| `0x21` | `VM_ADD` | 虚拟寄存器加法 | `dst = dst + src` |
| `0x22` | `VM_SUB` | 虚拟寄存器减法 | `dst = dst - src` |
| `0x25` | `VM_XOR` | 异或运算 | `dst = dst ^ src` |
| `0x31` | `VM_LOAD64` | 内存加载 64 位值 | `dst = *(uint64_t*)(src + imm)` |
| `0x32` | `VM_STORE64`| 写入内存 64 位值 | `*(uint64_t*)(dst + imm) = src` |
| `0x41` | `VM_CMP` | 比较并更新标志位 | `flags = cmp(dst, src)` |
| `0x51` | `VM_JMP` | 无条件跳转 | `pc += imm` |
| `0x52` | `VM_JZ` | 为零跳转 | `if (flags.Z) pc += imm` |
| `0x61` | `VM_CALL` | 调用原生 C 函数 | 调度真实函数指针 |
| `0xFF` | `VM_RET` | 退出虚拟机并还原上下文 | 返回上层原生栈 |
### 3.3 解释器 Direct-Threaded 跳转循环实现原型 (含边界防御)
```c
#include <stdint.h>
#include <stdlib.h>
#include <stdbool.h>
typedef struct {
uint64_t r[31]; // 对应 ARM64 x0 - x30 通用寄存器
uint64_t sp; // 虚拟栈指针
uint64_t flags; // 标志位 NZCV
uint64_t ret_val; // 返回值
} VMContext;
uint64_t VMP_Execute(const uint8_t *bytecode, size_t bytecode_len, uint64_t arg0, uint64_t arg1) {
if (!bytecode || bytecode_len < 4) return 0;
VMContext ctx = {0};
ctx.r[0] = arg0;
ctx.r[1] = arg1;
ctx.sp = (uint64_t)malloc(4096) + 4096; // 分配独立虚拟栈
const uint8_t *pc = bytecode;
const uint8_t *pc_end = bytecode + bytecode_len;
// 静态直接线程标签跳转表 (极致性能且无分支预测惩罚)
static const void *dispatch_table[256] = {
[0x11] = &&op_mov_imm,
[0x12] = &&op_mov_reg,
[0x21] = &&op_add,
[0x25] = &&op_xor,
[0x31] = &&op_load64,
[0x32] = &&op_store64,
[0x41] = &&op_cmp,
[0x52] = &&op_jz,
[0xFF] = &&op_ret
};
#define DISPATCH() \
do { \
if (pc + 4 > pc_end) goto op_ret; \
void *target = (void*)dispatch_table[*pc]; \
if (!target) goto op_ret; \
goto *target; \
} while(0)
DISPATCH();
op_mov_imm: {
uint8_t dst = pc[1];
uint8_t imm = pc[3];
if (dst < 31) ctx.r[dst] = imm;
pc += 4;
DISPATCH();
}
op_mov_reg: {
uint8_t dst = pc[1];
uint8_t src = pc[2];
if (dst < 31 && src < 31) ctx.r[dst] = ctx.r[src];
pc += 4;
DISPATCH();
}
op_add: {
uint8_t dst = pc[1];
uint8_t src = pc[2];
if (dst < 31 && src < 31) ctx.r[dst] += ctx.r[src];
pc += 4;
DISPATCH();
}
op_xor: {
uint8_t dst = pc[1];
uint8_t src = pc[2];
if (dst < 31 && src < 31) ctx.r[dst] ^= ctx.r[src];
pc += 4;
DISPATCH();
}
op_load64: {
uint8_t dst = pc[1];
uint8_t src = pc[2];
if (dst < 31 && src < 31 && ctx.r[src] != 0) {
ctx.r[dst] = *(uint64_t*)(ctx.r[src]);
}
pc += 4;
DISPATCH();
}
op_store64: {
uint8_t dst = pc[1];
uint8_t src = pc[2];
if (dst < 31 && src < 31 && ctx.r[dst] != 0) {
*(uint64_t*)(ctx.r[dst]) = ctx.r[src];
}
pc += 4;
DISPATCH();
}
op_cmp: {
uint8_t dst = pc[1];
uint8_t src = pc[2];
if (dst < 31 && src < 31) {
ctx.flags = (ctx.r[dst] == ctx.r[src]) ? 1 : 0;
}
pc += 4;
DISPATCH();
}
op_jz: {
int8_t offset = (int8_t)pc[3];
if (ctx.flags == 1) {
const uint8_t *next_pc = pc + offset * 4;
if (next_pc >= bytecode && next_pc + 4 <= pc_end) {
pc = next_pc;
} else {
goto op_ret; // 跳转越界防御
}
} else {
pc += 4;
}
DISPATCH();
}
op_ret: {
uint64_t result = ctx.r[0];
free((void*)(ctx.sp - 4096));
return result;
}
}
```
### 3.4 虚拟化适用范围与验收边界
> [!NOTE]
> **VMP 研发边界与验收范围**:
> 当前原型用于验证自定义字节码指令调度与寄存器映射机制。通用 C/C++/Swift 函数若包含浮点/SIMD(NEON `Q0~Q31`)、C++ 异常栈解退(`eh_frame`)、动态栈分配(`alloca`)或变长参数(`va_list`),需要完备的编译器后端支持。
> **工程策略**:VMP 首期仅用于保护加固关键的算法、鉴权校验与密钥派生纯整型逻辑函数,不作为通用全量函数虚拟化方案。
---
## 4. 全维度内核级主动防御对抗矩阵 (Defender Core)
### 4.1 内联汇编 SVC 0x80 反调试与 App Store 2.5.1 合规双模设计
不使用易被 Hook 的 libc `ptrace`,直接使用内联汇编触发 XNU 26 号中断(`SYS_ptrace`)。
但需注意:Apple 审核指南 2.5.1 规定“App 只能以规定方式使用公开 API”。直接裸汇编 `svc 0x80` 在企业签/Ad-Hoc 场景无阻碍,但在 App Store 审核期存在静态特征扫描风险。系统设计为**双模开关**:
```c
#include <dlfcn.h>
#include <stdbool.h>
typedef int (*ptrace_ptr_t)(int _request, pid_t _pid, caddr_t _addr, int _data);
__attribute__((always_inline)) static inline void anti_debug(bool is_appstore_build) {
if (!is_appstore_build) {
// 企业版/对抗模式:裸汇编软中断,彻底免疫 libc 层 Hook
#if defined(__arm64__) || defined(__aarch64__)
__asm__ volatile(
"mov x0, #31\n" // PT_DENY_ATTACH (0x1f)
"mov x1, #0\n"
"mov x2, #0\n"
"mov x3, #0\n"
"mov x16, #26\n" // SYS_ptrace = 26
"svc #0x80\n"
:
:
: "x0", "x1", "x2", "x3", "x16"
);
#endif
} else {
// App Store 提审模式:动态混淆字符解析公开系统 API,规避 2.5.1 静态扫描
char enc_sym[] = { 'p'^0x5A, 't'^0x5A, 'r'^0x5A, 'a'^0x5A, 'c'^0x5A, 'e'^0x5A, 0 };
for (int i = 0; i < 6; i++) enc_sym[i] ^= 0x5A;
ptrace_ptr_t ptrace_func = (ptrace_ptr_t)dlsym(RTLD_DEFAULT, enc_sym);
if (ptrace_func) {
ptrace_func(31, 0, 0, 0); // PT_DENY_ATTACH
}
}
}
```
### 4.2 硬件断点 (DR0-DR7) 探测
攻击者在 LLDB 或调试器中下硬件断点时,会写入 ARM64 调试寄存器。通过 `thread_get_state` 轮询检查:
```c
#include <mach/mach.h>
#include <stdbool.h>
bool check_hardware_breakpoints() {
mach_port_t this_thread = mach_thread_self();
arm_debug_state64_t state;
mach_msg_type_number_t count = ARM_DEBUG_STATE64_COUNT;
kern_return_t kr = thread_get_state(this_thread, ARM_DEBUG_STATE64,
(thread_state_t)&state, &count);
mach_port_deallocate(mach_task_self(), this_thread);
if (kr == KERN_SUCCESS) {
for (int i = 0; i < 16; i++) {
// bvr 为断点地址寄存器,bcr 为控制寄存器 (bit 0 为启用位)
if (state.__bcr[i] & 1) {
return true; // 发现硬件执行断点!
}
if (state.__wcr[i] & 1) {
return true; // 发现硬件观察点 (Watchpoint)!
}
}
}
return false;
}
```
### 4.3 关键函数头 Inline Hook 探测 (Anti-Dobby / Anti-Substrate)
Dobby / CydiaSubstrate 对 ARM64 函数 Hook 时,会在前 16 字节写入跳板指令(如 `LDR X16, #8; BR X16` 机器码 `0x58000050, 0xd61f0200`):
```c
#include <stdint.h>
#include <stdbool.h>
bool is_function_inline_hooked(void *func_ptr) {
uint32_t *instructions = (uint32_t *)func_ptr;
// 检查是否为 LDR X16, [PC, #8] (0x58000050) 紧跟 BR X16 (0xd61f0200)
if (instructions[0] == 0x58000050 && instructions[1] == 0xd61f0200) {
return true;
}
// 检查直接 B / BL 跳转 (0x14000000 掩码)
if ((instructions[0] & 0xFC000000) == 0x14000000) {
return true;
}
return false;
}
```
---
## 5. 双符号表体系与 dSYM 崩溃逆向还原 (Dual-Symbol & Crash Restorer)
### 5.1 设计目标
解决代码混淆后 Bugly、Sentry 堆栈崩溃无法定位代码行号的问题。
加固期生成 `mapping.db`,离线重写 Release 产生的 `App.app.dSYM`,将 DWARF 调试符号批量恢复为原始符号。
### 5.2 DWARF 调试格式解析与重写流程
Mach-O dSYM 文件包含三个关键调试 Section:
1. `__DWARF,__debug_info`:树状结构的 DIE(Debugging Information Entries),包含 `DW_TAG_subprogram`(函数)和属性 `DW_AT_name`、`DW_AT_linkage_name`。
2. `__DWARF,__debug_str`:字符串常量池(以 `\0` 分隔)。DIE 中的 `DW_FORM_strp` 属性存储指向该池的文件偏移。
3. `__DWARF,__debug_line`:行号状态机字节码,映射机器指令地址与源码行号。
```mermaid
flowchart LR
A["读取原始 dSYM DWARF"] --> B["解析 __debug_str 字符串池"]
B --> C["查询 mapping.sqlite\nObfuscated -> Original"]
C --> D{"新字符串长度 <= 原始混淆名?"}
D -- 是 --> E["就地改写字符串并补 \\0 填充"]
D -- 否 --> F["重建 __debug_str 并在末尾追加\n更新 __debug_info 中对应 DW_FORM_strp 偏移"]
E --> G["输出 Restored.dSYM (上传至 Sentry/Bugly)"]
F --> G
```
#### DWARF 重构伪代码原型
```python
def restore_dsym(dsym_path, mapping_dict, output_path):
# 1. 打开 DWARF 调试文件
with open(dsym_path, "r+b") as f:
macho = MachO(f)
debug_str_section = macho.get_section("__DWARF", "__debug_str")
debug_info_section = macho.get_section("__DWARF", "__debug_info")
# 2. 扫描并替换符号
str_data = bytearray(debug_str_section.data)
for obfuscated, original in mapping_dict.items():
obf_bytes = obfuscated.encode('utf-8')
orig_bytes = original.encode('utf-8')
# 若等长替换直接原位覆写
if len(orig_bytes) <= len(obf_bytes):
padded_orig = orig_bytes.ljust(len(obf_bytes), b'\x00')
str_data = str_data.replace(obf_bytes, padded_orig)
else:
# 不等长则需调整 .debug_str 长度并修复 DIE 偏移
str_data = append_and_fix_die_offsets(debug_info_section, str_data, obf_bytes, orig_bytes)
debug_str_section.write(str_data)
macho.save(output_path)
```
### 5.3 崩溃符号化适用边界与限制说明
> [!IMPORTANT]
> **dSYM 还原的适用边界**:
> 1. **符号混淆 (Symbol Renaming) 场景**:若仅对类名、方法名进行字符替换,函数体机器指令与行号映射保持未动,重写 `__debug_str` 可实现 100% 精确的行号与符号还原。此时必须保证重写后的 dSYM 与主二进制的 `LC_UUID` 严格一致。
> 2. **代码虚拟化 (VMP) / 函数抽取场景**:一旦函数体被抽离为私有字节码或替换为跳板(Trampoline),原机器指令在二进制中已不复存在。崩溃发生时,系统捕获的堆栈顶帧将必然是 `VMP_Execute`。
> * **解决路径**:对此类函数,无法仅靠静态 dSYM 还原;必须在 `VMPContext` 中维护虚拟 PC,并在崩溃捕获回调中输出虚拟栈帧,结合离线的 `vmp_pc_mapping.json` 完成混合回溯还原。
---
## 6. 资产保护与无感透明解密 (Virtual File System & Assets Protector)
### 6.1 PNG 免解密 Hash 扰动(应对 2.3.1 / 4.3 静态排查)
在不破坏图片展示的前提下修改图片 MD5/SHA256。PNG 格式由固定 8 字节签名加上多个 Chunk 组成。规范允许插入合规私有辅助 Chunk(如 `tEXt`):
```cpp
void PerturbPNGHash(std::vector<uint8_t>& png_data) {
// PNG Header: 89 50 4E 47 0D 0A 1A 0A
std::string key = "Comment";
std::string value = GenerateRandomUUID(); // 随机特征串
// 构造 tEXt Chunk: [Length 4B] [ChunkType 4B "tEXt"] [Data] [CRC 4B]
std::vector<uint8_t> chunk;
uint32_t data_len = key.length() + 1 + value.length();
AppendBigEndian(chunk, data_len);
chunk.insert(chunk.end(), {'t', 'E', 'X', 't'});
chunk.insert(chunk.end(), key.begin(), key.end());
chunk.push_back(0); // 分隔符
chunk.insert(chunk.end(), value.begin(), value.end());
uint32_t crc = CalculateCRC32(chunk.data() + 4, data_len + 4);
AppendBigEndian(chunk, crc);
// 插入在 IHDR Chunk (偏移 8 + 25 字节) 之后
png_data.insert(png_data.begin() + 33, chunk.begin(), chunk.end());
}
```
### 6.2 深度加密与底层 POSIX 透明内存解密
* 加密格式:`[Magic 4B: 'G','U','A','D'] [Nonce 12B] [Tag 16B] [Ciphertext]`
* 拦截 API:使用 `fishhook` 拦截 `fopen`、`open`、`stat`。
```c
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
static FILE *(*orig_fopen)(const char *path, const char *mode);
FILE *hook_fopen(const char *path, const char *mode) {
FILE *fp = orig_fopen(path, mode);
if (!fp) return NULL;
// 读取前 4 字节判断是否为加密资产
char magic[4];
if (fread(magic, 1, 4, fp) == 4 && memcmp(magic, "GUAD", 4) == 0) {
// 读取密文长度并在内存解密
fseek(fp, 0, SEEK_END);
long sz = ftell(fp) - 32;
fseek(fp, 32, SEEK_SET);
uint8_t *decrypted_buf = malloc(sz);
// 执行 ChaCha20-Poly1305 解密 ...
// 创建内存文件句柄 (fmemopen) 使得上层读取无感
FILE *mem_fp = fmemopen(decrypted_buf, sz, mode);
fclose(fp);
return mem_fp;
}
fseek(fp, 0, SEEK_SET); // 非加固资源重置指针
return fp;
}
```
---
## 7. 跨平台自动化重签名流水线 (Cross-Platform Signer Engine)
### 7.1 签名核心数据结构:Apple SuperBlob 与 CodeDirectory
```cpp
#include <stdint.h>
#define CSMAGIC_CODEDIRECTORY 0xfade0c02
#define CSMAGIC_EMBEDDED_SIGNATURE 0xfade0cc0
#define CSMAGIC_REQUIREMENTS 0xfade0c01
#define CSMAGIC_ENTITLEMENTS 0xfade7171
#define CSMAGIC_DER_ENTITLEMENTS 0xfade7172
// CodeDirectory 特殊负数槽位定义 (Special Slots)
#define CSSLOT_CODEDIRECTORY 0
#define CSSLOT_INFOPLIST -1 // Info.plist 哈希
#define CSSLOT_REQUIREMENTS -2 // Requirements 需求规则哈希
#define CSSLOT_RESOURCEDIR -3 // _CodeSignature/CodeResources 资源清单哈希 (极度关键!)
#define CSSLOT_APPLICATION -4 // 预留
#define CSSLOT_ENTITLEMENTS -5 // XML Entitlements 哈希
#define CSSLOT_DER_ENTITLEMENTS -7 // DER Entitlements 哈希
#define CSSLOT_SIGNATURESLOT 0x10000 // CMS 签名块
struct BlobIndex {
uint32_t type; // 对应上述 CSSLOT_*
uint32_t offset; // 指向 Blob 距离 SuperBlob 起始处的偏移
};
struct SuperBlob {
uint32_t magic; // CSMAGIC_EMBEDDED_SIGNATURE
uint32_t length; // 整个 SuperBlob 大小
uint32_t count; // 包含的 Blob 数量
BlobIndex index[];
};
struct CodeDirectory {
uint32_t magic; // CSMAGIC_CODEDIRECTORY
uint32_t length; // 本结构体大小
uint32_t version; // 0x20400 (支持 SHA256 与负数槽)
uint32_t flags; // 0
uint32_t hashOffset; // 正数哈希数组起始偏移 (负数槽在其左侧)
uint32_t identOffset; // Bundle Identifier 字符串偏移
uint32_t nSpecialSlots; // 负数槽位数量 (通常为 7)
uint32_t nCodeSlots; // 页面正数槽位数量 (ceil(codeLimit / 16384))
uint32_t codeLimit; // 签名覆盖的文件大小 (排除 LC_CODE_SIGNATURE 自身)
uint8_t hashSize; // 32 (SHA256)
uint8_t hashType; // 2 (CS_HASHTYPE_SHA256)
uint8_t platform; // 0
uint8_t pageSize; // 14 (表示 1 << 14 = 16384 = 16KB)
uint32_t spare2;
};
```
### 7.2 严格合规的重签名流水线算法时序 (Correct Order)
> [!CAUTION]
> **特殊槽依赖约束**:
> `CodeDirectory` 的 Slot -3 (`CSSLOT_RESOURCEDIR`) 必须包含最终 `_CodeSignature/CodeResources` 文件的 SHA256。
> 因此,**必须先生成 `CodeResources` 资源清单,再计算 `CodeDirectory` 的特殊槽并生成主二进制签名**。若颠倒顺序,系统校验必崩。
```mermaid
sequenceDiagram
autonumber
participant Runner as 签名调度器
participant Prov as Mobileprovision 与 Entitlements 协调
participant Dylibs as Frameworks/PlugIns (内部组件)
participant Res as CodeResources 资源哈希
participant MachO as 主可执行文件 CodeDirectory
participant CMS as OpenSSL 签名核
Runner->>Prov: 解析 embedded.mobileprovision 提取授权白名单
Runner->>Prov: 协调并生成目标实际需要的 Entitlements (XML + DER 编码)
Runner->>Dylibs: 由内向外先行签名 Frameworks/*.dylib 与 *.framework
Runner->>Dylibs: 先行签名 PlugIns/*.appex (使用插件独立的 bundle_id 与 entitlements)
Runner->>Res: 扫描全部 Bundle 资源文件生成 _CodeSignature/CodeResources
Runner->>MachO: 将 CodeResources 的 SHA256 填入 CodeDirectory Slot -3
Runner->>MachO: 将 Info.plist、Entitlements 哈希填入 Slot -1, -5, -7
Runner->>MachO: 按 16KB 页面计算 Mach-O 代码页 SHA256,填入 Slot 0..N
Runner->>CMS: 计算 CodeDirectory 整体哈希 (CDHash),使用私钥生成 PKCS#7 签名
Runner->>MachO: 组装 SuperBlob 回写至主 Mach-O 尾部,更新 LC_CODE_SIGNATURE
Runner->>Runner: 重新打包压缩为 .ipa
```
---
## 8. IPA 相似度预检中心 (App Store 4.3 预检器)
### 8.1 算法模型设计与免责边界
App Store 4.3 审核(Design: Spam)属于苹果人工审核与机审结合的行为规范策略,旨在遏制重复马甲包与克隆 App。**任何静态相似度工具均无法保证 100% 过审**。
iOSGuard 的相似度模型定位于**企业内部风控与差异化基准度量工具**:
$$\text{InternalRiskScore} = 0.45 \cdot \text{Sim}_{\text{Code}} + 0.35 \cdot \text{Sim}_{\text{Symbol}} + 0.20 \cdot \text{Sim}_{\text{Asset}}$$
```mermaid
graph TD
A["待测 IPA vs 基线母包 IPA"] --> B["Mach-O __text 提取\nSSDEEP (CTPH) 模糊哈希"]
A --> C["符号表导出\nJaccard 集合交并比计算"]
A --> D["图片媒体提取\n感知哈希 (pHash) 汉明距离计算"]
B --> E["加权综合评分算法"]
C --> E
D --> E
E --> F{"内部风控基准评分"}
F -- "< 35%" --> G["内部低相似度 (特征分化充分)"]
F -- "35% ~ 50%" --> H["内部中度相似 (建议调换混淆特征库)"]
F -- "> 50%" --> I["内部高相似度风险 (建议阻断提审)"]
```
### 8.2 核心算法实现:基于 SSDEEP 的机器码片段比对
```python
import ssdeep
def calculate_macho_code_similarity(macho_path_a, macho_path_b):
# 提取 __TEXT, __text 机器指令二进制段
bytes_a = extract_text_section(macho_path_a)
bytes_b = extract_text_section(macho_path_b)
# 计算 CTPH 模糊哈希
hash_a = ssdeep.hash(bytes_a)
hash_b = ssdeep.hash(bytes_b)
# 计算相似度 (0 ~ 100)
score = ssdeep.compare(hash_a, hash_b)
return score
```
### 8.3 符号表 Jaccard 系数计算
```python
def calculate_symbol_similarity(symbols_a: set, symbols_b: set) -> float:
intersection = len(symbols_a.intersection(symbols_b))
union = len(symbols_a.union(symbols_b))
if union == 0:
return 0.0
return (intersection / union) * 100.0
```