769 lines
31 KiB
Markdown
769 lines
31 KiB
Markdown
# 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
|
||
```
|