feat(defender): 运行时防护库 + readoor 接入(检测→分级→数据毒化)+ §7 硬化与二进制完整性探针 #1

Open
4v5u09Z5a4Yuc wants to merge 11 commits from feat/defender-integration into main
110 changed files with 10864 additions and 0 deletions
+2
View File
@@ -8,6 +8,8 @@ ehthumbs.db
Thumbs.db
# Build artifacts
/readoor-test/
/test-results/
build/
bin/
dist/
+8
View File
@@ -1,5 +1,13 @@
# iOSGuard - 企业级 iOS 加固与安全防护系统
> **反 HOOK 正向验证(2026-11-12)**:step11 真机 HOOK 正向验证完成,11/11 用例通过:真实 GOT 重绑定(fishhook 同款)、蹦床序言(B/LDR+BR)、frida 特征线程名、Documents 注入 dylib、ObjC 方法 IMP 基线替换在 iPhone 16 Plus(iOS 27.2,非越狱)全部命中对应 reason;DYLD_INSERT_LIBRARIES 真实 dyld 注入双命中 202+200。同轮新增调试器跟踪探针(reason=300)与 ObjC IMP 基线探针(reason=110)并接入聚合扫描。宿主测试 62 项通过。见 [真机 HOOK 正向验证](docs/17_DEVICE_HOOK_POSITIVE_VERIFICATION.md)。同日完成 readoor-test Swift 策略层整改(110/300 分级、越狱终止改经策略统一处置、debuggerDetected 接入探针证据)与登录/VIP/激活敏感入口门禁推广,构建通过;随后完成业务 App 内 C 探针副本同步(IGObjCBaseline 入副本与聚合接线,IGSyscall/IGAntiDebug 按合规物理排除)、Swift 侧 ObjC 基线登记(模块前缀解析,2/2 登记)与真机双向业务验证:干净启动零误报,DYLD_INSERT 真实注入双命中 202+200 判「加固锁定」且进程按白名单存活(证据 docs/evidence/20261112-readoor-inject-console.log)。强制模式各入口按钮级拦截回归仍待执行。
> **观察包进度(2026-11-11)**:SSZipArchive 动态绑定保护试点已在指定词书真机解压中命中四个文件函数,874 次转发无拒绝,9 个输出文件的聚合摘要与同构建基线一致,页面、正常缓存、返回重进及前后台恢复通过。59 项宿主/工具测试通过;真机攻击正向验证尚未完成。PDF 修复、完整业务回归和报告复测继续暂缓。见 [SSZipArchive 保护试点](docs/16_SSZIPARCHIVE_FRAMEWORK_GUARD_PILOT.md)。
> **当前状态(2026-11-10)**:已完成 ZipZap `write/close` 三层防护试点:链接后定点改写、运行时解析与间接调用、Defender 调度完整性检查。`readoor31` Release 构建、44 项自动化测试及 8 项独立真机诊断通过,本轮两处改写后整包直接调用为 558→556。详见 [三层试点与证据](docs/14_ZIPZAP_RUNTIME_DISPATCH_PILOT.md)。前一轮 v2.199.0 IPA 的 28 项测试与 878→0 仍保留为[独立基线](docs/13_REPRODUCIBLE_BASELINE.md),两轮产物不同。**尚未完成完整 App 真机业务回归和 V4.6.6 复测**;不能宣称报告问题全部解决。下文能力表仍属于规划,不代表各项均已实现或验证。
>
> **当前主线**:面向 iOS App 反 Hook 与安全加固,以 readoor 的 ECNUP 外语安全报告为首个验收案例。报告分析、源码核查、实施顺序及复测标准见 [readoor 漏洞报告分析与加固实施方案](docs/05_READOOR_SECURITY_REMEDIATION_PLAN.md)。当前优先级以该方案为准;既有文档中的审核差异化、VMP、元数据重构等内容保留为远期研究。
[![Platform](https://img.shields.io/badge/Platform-iOS%20%7C%20macOS%20%7C%20Linux-blue.svg)](https://developer.apple.com/ios/)
[![License](https://img.shields.io/badge/License-Proprietary-red.svg)]()
[![Architecture](https://img.shields.io/badge/Arch-ARM64%20%7C%20LLVM-orange.svg)]()
+27
View File
@@ -0,0 +1,27 @@
/*
* IGDefender.c — 运行时防护聚合入口。
*
* 一次性运行 anti_hook + 注入/Frida 全部探针,证据统一经 sink 上报;不做任何处置。
* 典型用法(观察模式):App 启动 / 回前台 / 关键操作前调用 ig_defender_scan,
* 由上层策略根据 reason 组合决定是否限制功能——本库绝不 exit。
*/
#include "IGDefender.h"
#include "anti_hook/IGAntiHook.h"
#include "anti_hook/IGObjCBaseline.h"
#include "anti_frida/IGAntiInject.h"
#include "anti_debug/IGAntiDebug.h"
#include "anti_jailbreak/IGAntiJailbreak.h"
#include "dispatch/IGDispatch.h"
int ig_defender_scan(const char *bundle_path, int probe_port,
IGFindingSink sink, void *ctx) {
int hits = 0;
hits += ig_dispatch_check(sink, ctx);
hits += ig_anti_hook_check_default(sink, ctx);
hits += ig_objc_baseline_check(sink, ctx);
hits += ig_anti_inject_check(bundle_path, sink, ctx);
hits += ig_anti_frida_check(probe_port, sink, ctx);
hits += ig_anti_debug_check(sink, ctx);
hits += ig_anti_jb_check(sink, ctx);
return hits;
}
+33
View File
@@ -0,0 +1,33 @@
/*
* IGAntiDebug.c — 调试器跟踪探针实现。
* 全部逻辑在 syscall 模块(ig_sys_is_debugged,直发 svc + P_TRACED),
* 这里只做三态到 IGFinding 的映射与上报。
*/
#include "IGAntiDebug.h"
#include "syscall/IGSyscall.h"
#include <stdio.h>
int ig_anti_debug_check(IGFindingSink sink, void *ctx) {
int traced = ig_sys_is_debugged();
if (traced == 1) {
IGFinding f;
__builtin_memset(&f, 0, sizeof(f));
f.status = IG_DETECTED;
f.reason = IG_REASON_DEBUGGER_ATTACHED;
snprintf(f.subject, sizeof(f.subject), "kinfo_proc.p_flag&P_TRACED");
snprintf(f.evidence, sizeof(f.evidence), "直发 sysctl 检出进程被调试器跟踪");
if (sink) sink(&f, ctx);
return 1;
}
if (traced < 0) {
IGFinding f;
__builtin_memset(&f, 0, sizeof(f));
f.status = IG_UNAVAILABLE;
f.reason = IG_REASON_DEBUGGER_ATTACHED;
snprintf(f.subject, sizeof(f.subject), "kinfo_proc.p_flag&P_TRACED");
snprintf(f.evidence, sizeof(f.evidence), "sysctl 查询失败,无法判定");
if (sink) sink(&f, ctx);
}
return 0;
}
+25
View File
@@ -0,0 +1,25 @@
/*
* IGAntiDebug.h — 调试器跟踪探针(接入聚合扫描)。
*
* 复用 syscall 模块的 ig_sys_is_debugged():直发 sysctl 读 kinfo_proc 的
* P_TRACED 位(公开 API 语义,docs/12 已在 lldb 下实测命中),此前该能力
* 已实现但未进入 ig_defender_scan 聚合,策略层无从消费——本模块补上接线。
* 三态映射:1 → DETECTED(300),0 → clear,-1 → UNAVAILABLE(300)。
*/
#ifndef IG_ANTI_DEBUG_H
#define IG_ANTI_DEBUG_H
#include "IGDefender.h"
#ifdef __cplusplus
extern "C" {
#endif
/* 调试器跟踪检测:只采集证据不处置(绝不自行 ptrace/exit)。返回 DETECTED 条数。 */
int ig_anti_debug_check(IGFindingSink sink, void *ctx);
#ifdef __cplusplus
}
#endif
#endif /* IG_ANTI_DEBUG_H */
+244
View File
@@ -0,0 +1,244 @@
/*
* IGAntiInject.c — 代码注入与 Frida 运行时检测实现。
*
* 全部公开 API:<mach-o/dyld.h>(镜像枚举)、getenv(dyld 环境变量)、
* task_threads + thread_info(THREAD_EXTENDED_INFO)(线程名)、BSD socket(端口弱探测)。
*
* 边界:
* - 镜像特征按文件名子串匹配,越狱/注入框架会更名规避——命中是强证据,未命中不等于干净。
* - 端口探测仅弱信号(docs/05:不以单一端口判定);默认不启用,需显式传 probe_port。
* - 线程名依赖目标进程把 frida 线程命名为已知值,新版本可能改名——同为组合证据之一。
*/
#include "IGAntiInject.h"
#include "IGInline.h" /* ig_strstr/ig_strcmp/ig_strncmp/ig_strlen:抹除探针自身对 libc 匹配函数的依赖 */
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <strings.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include <crt_externs.h> /* _NSGetEnviron:手工遍历环境表,替代可被 hook 的 getenv */
#include <mach-o/dyld.h>
#include <mach/mach.h>
#include <mach/thread_act.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <netinet/in.h>
#include <arpa/inet.h>
/*
* 经 _NSGetEnviron 手工遍历环境表取变量,规避对 getenv 的 hook/特征。
* 关键:攻击者只需 hook getenv 让其对 "DYLD_INSERT_LIBRARIES" 返回 NULL,
* 即可让下方第 3 步「插入库」检测彻底失明;本函数不经 libc getenv,关闭该盲点。
* 仅用 ig_* 内联原语比较,不引入新的可 hook 导入符号。
*/
static const char *ig_local_getenv(const char *name) {
char ***envp = _NSGetEnviron();
if (!name || !envp || !*envp) return NULL;
size_t nlen = ig_strlen(name);
for (char **e = *envp; *e; ++e) {
const char *entry = *e;
if (ig_strncmp(entry, name, nlen) == 0 && entry[nlen] == '=') {
return entry + nlen + 1;
}
}
return NULL;
}
/*
* §7.1 IG_ENC:注入特征串与 frida 线程名不再明文驻留(避免 `strings` 捞出 frida/substrate/
* gum-js-loop 等,白送检测目标)。混淆表由 tools/gen_jb_paths.py 生成,运行期解码进栈。
*/
#include "IGInjectSignatures.inc"
/* 解码单条混淆串到 out(容量 cap,含结尾 0)。返回长度,失败返回 0。
* k0 取 volatile:阻止 -O2 把「常量 enc + 常量 key」整条折叠回明文存入 __const
* (否则 strings 又能捞出 frida/gum-js-loop)。强制运行期解码。 */
static size_t ig_inj_decode(const unsigned char *enc, size_t n, int idx,
char *out, size_t cap) {
volatile unsigned k0 = IG_INJ_XOR_K0;
if (n + 1 > cap) return 0;
for (size_t j = 0; j < n; ++j) {
unsigned ks = ((unsigned)k0 + (unsigned)idx * IG_INJ_XOR_K1 + j * IG_INJ_XOR_K2) & 0xFFu;
out[j] = (char)(enc[j] ^ ks);
}
out[n] = '\0';
return n;
}
static void ig_emit2(IGFindingSink sink, void *ctx, int *stop, int *hits,
IGStatus st, int reason, const char *subject, const char *evidence) {
if (*stop) return;
IGFinding f;
memset(&f, 0, sizeof(f));
f.status = st;
f.reason = reason;
if (subject) strncpy(f.subject, subject, sizeof(f.subject)-1);
if (evidence) strncpy(f.evidence, evidence, sizeof(f.evidence)-1);
if (st == IG_DETECTED) (*hits)++;
if (sink && sink(&f, ctx) != 0) *stop = 1;
}
/* 小写化到缓冲区,便于大小写无关子串匹配。 */
static void ig_lower(const char *src, char *dst, size_t cap) {
size_t i = 0;
for (; src && src[i] && i + 1 < cap; ++i) {
char c = src[i];
dst[i] = (c >= 'A' && c <= 'Z') ? (char)(c - 'A' + 'a') : c;
}
dst[i] = '\0';
}
static int ig_is_system_path2(const char *path) {
if (!path) return 0;
return ig_strncmp(path, "/usr/lib/", 9) == 0 ||
ig_strncmp(path, "/System/", 8) == 0 ||
/* iOS 16+ 系统库经 Cryptex 挂载(/private/preboot/Cryptexes/OS/...),系统自身非注入。 */
ig_strncmp(path, "/private/preboot/Cryptexes/", 27) == 0;
}
int ig_anti_inject_check(const char *bundle_path, IGFindingSink sink, void *ctx) {
int hits = 0, stop = 0;
/* §7.1:特征串运行期解码进栈,循环内用解码副本;函数退出前擦除。 */
char injsig[IG_INJ_ENC_COUNT][24];
for (int s = 0; s < IG_INJ_ENC_COUNT; ++s)
ig_inj_decode(kIGInjEnc[s].b, kIGInjEnc[s].n, s, injsig[s], sizeof(injsig[s]));
/* 1+2. 镜像扫描。 */
uint32_t imgc = _dyld_image_count();
for (uint32_t i = 0; i < imgc && !stop; ++i) {
const char *name = _dyld_get_image_name(i);
if (!name) continue;
/* Apple 系统镜像(/System、/usr/lib、Cryptex)只读且 Apple 签名,永不作为注入证据先行跳过:
* 否则子串匹配会把 Apple 私有框架(如 RevealCore 命中 "reveal")误判为注入;
* Xcode 调试还会加载 GPUToolsCapture/libViewDebuggerSupport 等系统库。
* 真正的 frida/substrate/gadget 装在 Bundle 内或越狱路径(/Library、/var),不在此列。 */
if (ig_is_system_path2(name)) continue;
char low[1024];
ig_lower(name, low, sizeof(low));
int matched = 0;
for (int s = 0; s < IG_INJ_ENC_COUNT; ++s) {
if (ig_strstr(low, injsig[s])) {
char ev[256];
snprintf(ev, sizeof(ev), "镜像=%s 命中特征=%s", name, injsig[s]);
ig_emit2(sink, ctx, &stop, &hits, IG_DETECTED, IG_REASON_INJECTED_IMAGE, name, ev);
matched = 1;
break;
}
}
if (matched) continue;
/* 非系统、非特征命中:若在 Bundle 外则作为弱信号上报。 */
if (bundle_path && ig_strncmp(name, bundle_path, ig_strlen(bundle_path)) != 0) {
ig_emit2(sink, ctx, &stop, &hits, IG_DETECTED, IG_REASON_FOREIGN_IMAGE, name,
"Bundle 外非系统镜像(弱信号,需结合其它证据)");
}
}
/* 3. DYLD_INSERT_LIBRARIES 逐条解析。 */
const char *dyld = ig_local_getenv("DYLD_INSERT_LIBRARIES");
if (dyld && dyld[0] && !stop) {
char buf[4096];
strncpy(buf, dyld, sizeof(buf)-1); buf[sizeof(buf)-1] = '\0';
char *save = NULL;
for (char *tok = strtok_r(buf, ":", &save); tok && !stop;
tok = strtok_r(NULL, ":", &save)) {
int in_bundle = (bundle_path && ig_strncmp(tok, bundle_path, ig_strlen(bundle_path)) == 0);
/* 排除 Apple 系统路径条目:Xcode 调试经 DYLD_INSERT_LIBRARIES 注入
* /usr/lib/libViewDebuggerSupport.dylib、/System/.../GPUToolsCapture 等,非恶意注入。
* 越狱 frida/substrate 的插入库位于 Bundle 内或非系统路径,仍会命中。 */
if (!in_bundle && !ig_is_system_path2(tok)) {
char ev[256];
snprintf(ev, sizeof(ev), "DYLD_INSERT_LIBRARIES 条目=%s(Bundle 外)", tok);
ig_emit2(sink, ctx, &stop, &hits, IG_DETECTED, IG_REASON_DYLD_INSERT, tok, ev);
}
}
}
__builtin_memset(injsig, 0, sizeof(injsig));
return hits;
}
/* 遍历本进程线程,匹配 frida 线程名。 */
static void ig_scan_threads(IGFindingSink sink, void *ctx, int *stop, int *hits) {
thread_act_array_t threads;
mach_msg_type_number_t count = 0;
if (task_threads(mach_task_self(), &threads, &count) != KERN_SUCCESS) {
ig_emit2(sink, ctx, stop, hits, IG_UNAVAILABLE, IG_REASON_FRIDA_THREAD,
"task_threads", "无法枚举线程");
return;
}
/* §7.1:frida 线程名运行期解码进栈,比对后擦除。 */
char thr[IG_THR_ENC_COUNT][24];
for (int t = 0; t < IG_THR_ENC_COUNT; ++t)
ig_inj_decode(kIGThrEnc[t].b, kIGThrEnc[t].n, t, thr[t], sizeof(thr[t]));
for (mach_msg_type_number_t i = 0; i < count; ++i) {
thread_extended_info_data_t info;
mach_msg_type_number_t icount = THREAD_EXTENDED_INFO_COUNT;
if (thread_info(threads[i], THREAD_EXTENDED_INFO,
(thread_info_t)&info, &icount) != KERN_SUCCESS) continue;
if (info.pth_name[0] == '\0') continue;
for (int t = 0; t < IG_THR_ENC_COUNT; ++t) {
if (ig_strcmp(info.pth_name, thr[t]) == 0) {
char ev[256];
snprintf(ev, sizeof(ev), "线程名=%s 命中注入运行时特征", info.pth_name);
ig_emit2(sink, ctx, stop, hits, IG_DETECTED, IG_REASON_FRIDA_THREAD,
info.pth_name, ev);
break;
}
}
if (*stop) break;
}
__builtin_memset(thr, 0, sizeof(thr));
/* 回收端口。 */
for (mach_msg_type_number_t i = 0; i < count; ++i) {
mach_port_deallocate(mach_task_self(), threads[i]);
}
vm_deallocate(mach_task_self(), (vm_address_t)threads, count * sizeof(thread_act_t));
}
/* 非阻塞 connect 到 127.0.0.1:port,可连通即弱信号。 */
static int ig_port_open(int port) {
int fd = socket(AF_INET, SOCK_STREAM, 0);
if (fd < 0) return 0;
fcntl(fd, F_SETFL, O_NONBLOCK);
struct sockaddr_in sa;
memset(&sa, 0, sizeof(sa));
sa.sin_family = AF_INET;
sa.sin_port = htons((uint16_t)port);
sa.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
int rc = connect(fd, (struct sockaddr *)&sa, sizeof(sa));
int open = 0;
if (rc == 0) {
open = 1;
} else if (errno == EINPROGRESS) {
fd_set wset; FD_ZERO(&wset); FD_SET(fd, &wset);
struct timeval tv = { .tv_sec = 0, .tv_usec = 200000 }; /* 200ms 预算 */
if (select(fd + 1, NULL, &wset, NULL, &tv) > 0) {
int err = 0; socklen_t len = sizeof(err);
getsockopt(fd, SOL_SOCKET, SO_ERROR, &err, &len);
open = (err == 0);
}
}
close(fd);
return open;
}
int ig_anti_frida_check(int probe_port, IGFindingSink sink, void *ctx) {
int hits = 0, stop = 0;
ig_scan_threads(sink, ctx, &stop, &hits);
if (probe_port && !stop) {
if (ig_port_open(probe_port)) {
char ev[128];
snprintf(ev, sizeof(ev), "127.0.0.1:%d 可连接(弱信号)", probe_port);
char sub[32]; snprintf(sub, sizeof(sub), "port:%d", probe_port);
ig_emit2(sink, ctx, &stop, &hits, IG_DETECTED, IG_REASON_FRIDA_PORT, sub, ev);
}
}
return hits;
}
+40
View File
@@ -0,0 +1,40 @@
/*
* IGAntiInject.h — 代码注入与 Frida 运行时检测探针。
*
* 覆盖(docs/05 §5.C「镜像/白名单」「已知工具线索」+ §4 P1 DYLD 逐项解析):
* 1. 镜像扫描:已加载镜像匹配已知注入/调试框架特征(substrate/frida/cycript/reveal…)→ 强证据。
* 2. Bundle 外非系统镜像:弱信号(可能是合法 dylib),作为组合证据上报。
* 3. DYLD_INSERT_LIBRARIES:逐条解析(非整串前缀),任何条目指向 Bundle 外路径即上报。
* 4. Frida 运行时:线程名特征(gum-js-loop/gmain/pool-frida…)+ 默认端口(弱信号)。
*
* 只采集证据,不处置。单一端口/名称命中不作独立判定,交上层组合。
*/
#ifndef IG_ANTI_INJECT_H
#define IG_ANTI_INJECT_H
#include "IGDefender.h"
#ifdef __cplusplus
extern "C" {
#endif
/*
* 注入检测:镜像特征扫描 + Bundle 外镜像 + DYLD_INSERT_LIBRARIES 逐项解析。
* bundle_path:App 主 bundle 路径(.app 目录);用于判定镜像/插入库是否在 Bundle 内。
* 传 NULL 则跳过「Bundle 外」判定,仅做特征匹配与 dyld env。
* 返回 DETECTED 条数。
*/
int ig_anti_inject_check(const char *bundle_path, IGFindingSink sink, void *ctx);
/*
* Frida 运行时检测:线程名特征 + 默认端口探测(弱信号)。
* probe_port 非 0 时才做端口连接探测(默认 27042);0 表示只做线程名扫描。
* 返回 DETECTED 条数。
*/
int ig_anti_frida_check(int probe_port, IGFindingSink sink, void *ctx);
#ifdef __cplusplus
}
#endif
#endif /* IG_ANTI_INJECT_H */
@@ -0,0 +1,34 @@
/* IGInjectSignatures.inc — 由 tools/gen_jb_paths.py 生成,请勿手改。 */
/* 注入/Frida 特征串 XOR 混淆表(§7.1):enc[j]=plain[j]^((K0+idx*K1+j*K2)&0xFF)。 */
#define IG_INJ_XOR_K0 0x3cu
#define IG_INJ_XOR_K1 0x47u
#define IG_INJ_XOR_K2 0x1du
static const unsigned char kIGInjEnc0[] = { 0x5a, 0x2b, 0x1f, 0xf7, 0xd1 }; /* len=5 */
static const unsigned char kIGInjEnc1[] = { 0xe4, 0xc1, 0xd9, 0xbd, 0x92, 0x60 }; /* len=6 */
static const unsigned char kIGInjEnc2[] = { 0xa9, 0x9e, 0x6a, 0x4b, 0x5b, 0x38, 0x0c }; /* len=7 */
static const unsigned char kIGInjEnc3[] = { 0x72, 0x57, 0x28, 0x1a, 0xec, 0xd2, 0xcb }; /* len=7 */
static const unsigned char kIGInjEnc4[] = { 0x34, 0x1c, 0xf0, 0xcc, 0xb5, 0x8a, 0x74, 0x4a, 0x30, 0x29 }; /* len=10 */
static const unsigned char kIGInjEnc5[] = { 0xec, 0xc9, 0xbb, 0x85, 0x67, 0x42, 0x2c, 0x1e, 0xe2 }; /* len=9 */
static const unsigned char kIGInjEnc6[] = { 0x95, 0x76, 0x42, 0x4e, 0x2e, 0x1e, 0xe0, 0xc4, 0xba, 0x8e }; /* len=10 */
static const unsigned char kIGInjEnc7[] = { 0x41, 0x23, 0x05, 0xf7, 0xd4, 0xdc, 0xa8, 0x8c, 0x67, 0x53, 0x3b, 0x09 }; /* len=12 */
static const unsigned char kIGInjEnc8[] = { 0x00, 0xe6, 0xcb, 0xaa, 0x83, 0x6c, 0x4c, 0x55, 0x39, 0x1a, 0xe2 }; /* len=11 */
static const unsigned char kIGInjEnc9[] = { 0xc9, 0xb7, 0x96, 0x79, 0x4a, 0x38, 0x0b, 0xe9, 0xcc, 0xb4, 0xae, 0x8e, 0x65, 0x55, 0x21 }; /* len=15 */
static const unsigned char kIGInjEnc10[] = { 0x70, 0x7a, 0x4a, 0x3c, 0x17, 0xff }; /* len=6 */
static const unsigned char kIGInjEnc11[] = { 0x2f, 0x0a, 0xe6, 0xd8, 0xd1, 0xb5, 0x96, 0x70, 0x54, 0x3c }; /* len=10 */
static const unsigned char kIGInjEnc12[] = { 0xfc, 0xc4, 0xa8, 0x8f, 0x6b, 0x4e, 0x55, 0x3e, 0x0a }; /* len=9 */
static const unsigned char kIGInjEnc13[] = { 0xa4, 0x9c, 0x70, 0x4a, 0x24, 0x1f, 0xed, 0xcd, 0xd0, 0xb7 }; /* len=10 */
static const unsigned char kIGInjEnc14[] = { 0x7a, 0x54, 0x3a, 0x17, 0xeb }; /* len=5 */
static const unsigned char kIGInjEnc15[] = { 0x03, 0xeb, 0xec, 0xd4, 0xb1, 0x99, 0x7c, 0x5b }; /* len=8 */
static const struct { const unsigned char *b; unsigned char n; } kIGInjEnc[] = { { kIGInjEnc0, 5 }, { kIGInjEnc1, 6 }, { kIGInjEnc2, 7 }, { kIGInjEnc3, 7 }, { kIGInjEnc4, 10 }, { kIGInjEnc5, 9 }, { kIGInjEnc6, 10 }, { kIGInjEnc7, 12 }, { kIGInjEnc8, 11 }, { kIGInjEnc9, 15 }, { kIGInjEnc10, 6 }, { kIGInjEnc11, 10 }, { kIGInjEnc12, 9 }, { kIGInjEnc13, 10 }, { kIGInjEnc14, 5 }, { kIGInjEnc15, 8 } };
#define IG_INJ_ENC_COUNT 16
static const unsigned char kIGThrEnc0[] = { 0x5b, 0x2c, 0x1b, 0xbe, 0xda, 0xbe, 0xc7, 0x6b, 0x4b, 0x2e, 0x2e }; /* len=11 */
static const unsigned char kIGThrEnc1[] = { 0xe4, 0xcd, 0xdc, 0xb3, 0x99 }; /* len=5 */
static const unsigned char kIGThrEnc2[] = { 0xad, 0x83, 0x66, 0x54, 0x4d }; /* len=5 */
static const unsigned char kIGThrEnc3[] = { 0x61, 0x41, 0x24, 0x04, 0xa8, 0xc4, 0xcd, 0xb5, 0x9d, 0x77 }; /* len=10 */
static const unsigned char kIGThrEnc4[] = { 0x28, 0x1a, 0xfd, 0xc3, 0xe1, 0x9a, 0x76, 0x42, 0x37, 0x33, 0x1f, 0xe5 }; /* len=12 */
static const unsigned char kIGThrEnc5[] = { 0xf3, 0xd5, 0xb7, 0x9c, 0x76, 0x53, 0x39, 0x05, 0xf5 }; /* len=9 */
static const struct { const unsigned char *b; unsigned char n; } kIGThrEnc[] = { { kIGThrEnc0, 11 }, { kIGThrEnc1, 5 }, { kIGThrEnc2, 5 }, { kIGThrEnc3, 10 }, { kIGThrEnc4, 12 }, { kIGThrEnc5, 9 } };
#define IG_THR_ENC_COUNT 6
+269
View File
@@ -0,0 +1,269 @@
/*
* IGAntiHook.c — 关键函数 HOOK 完整性探针实现。
*
* 全部基于公开 API:<dlfcn.h>(dlsym/dladdr)、<mach-o/dyld.h>(镜像枚举)、
* <mach-o/loader.h>/<nlist.h>(运行时解析自身镜像的 GOT 槽,fishhook 同款走法,用于「校验」而非改写)。
*
* 边界(如实声明,unavailable 不等于安全):
* - 仅支持 arm64 / x86_64(LP64)。非 64 位镜像跳过。
* - arm64e:__auth_got 槽为带签名指针,比较前用 ptrauth_strip 去签名;若工具链无 ptrauth,
* 对认证槽的判定标记为 unavailable,不强行比较。
* - chained fixups:运行时 dyld 绑定完成后,__got 槽持最终(slide 后)地址,本探针读到的即该值;
* 未绑定/惰性未触发的槽会与 trusted 不等——仅对非惰性 __got(S_NON_LAZY_SYMBOL_POINTERS)判 rebind,
* 惰性槽(__la_symbol_ptr)首次调用前可能仍指向 helper,故不判为重绑定,只在 provenance/inline 层兜底。
*/
#include "IGAntiHook.h"
#include "IGInline.h" /* ig_strcmp/ig_strncmp/ig_strlen:抹除探针自身对 libc 匹配函数的依赖 */
#include <string.h>
#include <stdio.h>
#include <dlfcn.h>
#include <mach-o/dyld.h>
#include <mach-o/loader.h>
#include <mach-o/nlist.h>
#include <mach/mach.h>
#if defined(__has_feature)
# if __has_feature(ptrauth_calls)
# include <ptrauth.h>
# define IG_HAS_PTRAUTH 1
# endif
#endif
#ifndef IG_HAS_PTRAUTH
# define IG_HAS_PTRAUTH 0
#endif
/* 报告命中的 12 个关键符号(不带下划线)。 */
static const char *const kIGDefaultSymbols[] = {
"fopen", "dlopen", "dlsym", "write", "read", "open",
"close", "exit", "fork", "syscall", "unlink", "getpid",
};
/* ---- 工具:系统提供方路径白名单 ---- */
/* dli_fname 是否落在系统镜像路径(含 dyld 共享缓存里的系统 dylib)。 */
static int ig_is_system_path(const char *path) {
if (!path) return 0;
static const char *const prefixes[] = {
"/usr/lib/", "/System/", "/usr/lib/system/",
/* iOS 16+ 系统库经 Cryptex 挂载,dladdr 报此前缀(非越狱,系统自身)。 */
"/private/preboot/Cryptexes/",
};
for (size_t i = 0; i < sizeof(prefixes)/sizeof(prefixes[0]); ++i) {
if (ig_strncmp(path, prefixes[i], ig_strlen(prefixes[i])) == 0) return 1;
}
return 0;
}
static void ig_emit(IGFindingSink sink, void *ctx, int *stop, int *hits,
IGStatus st, int reason, const char *subject, const char *evidence) {
if (*stop) return;
IGFinding f;
memset(&f, 0, sizeof(f));
f.status = st;
f.reason = reason;
if (subject) { strncpy(f.subject, subject, sizeof(f.subject)-1); }
if (evidence) { strncpy(f.evidence, evidence, sizeof(f.evidence)-1); }
if (st == IG_DETECTED) (*hits)++;
if (sink && sink(&f, ctx) != 0) *stop = 1;
}
/* 去 PAC(arm64e 认证指针);无 ptrauth 时原样返回。 */
static const void *ig_strip(const void *p) {
#if IG_HAS_PTRAUTH
return ptrauth_strip(p, ptrauth_key_asia);
#else
return p;
#endif
}
/* ---- 1. 符号提供方 ---- */
/* trusted = dlsym(RTLD_DEFAULT,name);其宿主镜像若非系统路径,说明被 interpose/注入抢占。 */
static void *ig_check_provenance(const char *name, IGFindingSink sink, void *ctx,
int *stop, int *hits) {
void *addr = dlsym(RTLD_DEFAULT, name);
if (!addr) {
ig_emit(sink, ctx, stop, hits, IG_UNAVAILABLE, IG_REASON_SYMBOL_UNRESOLVED,
name, "dlsym(RTLD_DEFAULT) 返回 NULL");
return NULL;
}
Dl_info info;
if (!dladdr(addr, &info) || !info.dli_fname) {
ig_emit(sink, ctx, stop, hits, IG_UNAVAILABLE, IG_REASON_VERIFICATION_UNAVAILABLE,
name, "无法确认符号提供方");
return NULL;
}
if (!ig_is_system_path(info.dli_fname)) {
char ev[256];
snprintf(ev, sizeof(ev), "解析地址 %p 提供方=%s(非系统路径)",
addr, info.dli_fname ? info.dli_fname : "?");
ig_emit(sink, ctx, stop, hits, IG_DETECTED, IG_REASON_SYMBOL_PROVENANCE, name, ev);
}
return addr;
}
/* ---- 2. inline hook:序言首指令 ---- */
int ig_arm64_suspicious_prologue(uint32_t first, uint32_t second) {
if ((first & 0xfc000000u)==0x14000000u) return 1;
uint32_t rt=first & 31u, rn=(second>>5)&31u;
return (first & 0xff000000u)==0x58000000u && (rt==16 || rt==17)
&& (second & 0xfffffc1fu)==0xd61f0000u && rn==rt;
}
/* arm64:首指令为无条件 B,或 (LDR-literal → x16/x17) + (BR x16/x17) 蹦床,判为 inline hook。 */
static IGStatus ig_check_prologue(const char *name, void *addr, IGFindingSink sink, void *ctx,
int *stop, int *hits) {
#if defined(__arm64__) || defined(__aarch64__)
uint32_t code[2];
vm_size_t copied=0;
if (vm_read_overwrite(mach_task_self(), (vm_address_t)ig_strip(addr),
sizeof(code), (vm_address_t)code, &copied) != KERN_SUCCESS || copied!=sizeof(code)) {
ig_emit(sink, ctx, stop, hits, IG_UNAVAILABLE, IG_REASON_VERIFICATION_UNAVAILABLE,
name, "无法读取函数代码");
return IG_UNAVAILABLE;
}
const uint32_t *ins = code;
uint32_t w0 = ins[0];
uint32_t w1 = ins[1];
int hook = ig_arm64_suspicious_prologue(w0,w1);
const char *kind = "首指令 B 或 LDR literal + 同寄存器 BR 蹦床";
if (hook) {
char ev[256];
snprintf(ev, sizeof(ev), "%s @%p 指令[%08x %08x]", kind, addr, w0, w1);
ig_emit(sink, ctx, stop, hits, IG_DETECTED, IG_REASON_INLINE_HOOK, name, ev);
return IG_DETECTED;
}
#else
(void)name; (void)addr; (void)sink; (void)ctx; (void)stop; (void)hits;
#endif
return IG_CLEAR;
}
/* ---- 3. GOT 重绑定:扫本进程非系统镜像的非惰性符号指针槽 ---- */
/* trusted_map:name→trusted addr 的平行数组。对每个镜像的 __got 槽,若其绑定符号在集合内
* 且当前值去 PAC 后既不等于 trusted、宿主又非系统路径,则判 GOT 重绑定。 */
static void ig_check_got_one_image(uint32_t img_index,
const char *const *names, void *const *trusted, size_t count,
IGFindingSink sink, void *ctx, int *stop, int *hits) {
const struct mach_header_64 *mh =
(const struct mach_header_64 *)_dyld_get_image_header(img_index);
if (!mh || mh->magic != MH_MAGIC_64) return;
const char *img_path = _dyld_get_image_name(img_index);
if (ig_is_system_path(img_path)) return; /* 只查自有镜像(app/嵌入 framework) */
intptr_t slide = _dyld_get_image_vmaddr_slide(img_index);
/* 先定位 __LINKEDIT、LC_SYMTAB、LC_DYSYMTAB。 */
const struct segment_command_64 *linkedit = NULL;
const struct symtab_command *symtab = NULL;
const struct dysymtab_command *dysymtab = NULL;
const uint8_t *cmd = (const uint8_t *)(mh + 1);
for (uint32_t i = 0; i < mh->ncmds; ++i) {
const struct load_command *lc = (const struct load_command *)cmd;
if (lc->cmd == LC_SEGMENT_64) {
const struct segment_command_64 *seg = (const struct segment_command_64 *)lc;
if (ig_strcmp(seg->segname, SEG_LINKEDIT) == 0) linkedit = seg;
} else if (lc->cmd == LC_SYMTAB) {
symtab = (const struct symtab_command *)lc;
} else if (lc->cmd == LC_DYSYMTAB) {
dysymtab = (const struct dysymtab_command *)lc;
}
cmd += lc->cmdsize;
}
if (!linkedit || !symtab || !dysymtab) return;
uintptr_t linkedit_base = (uintptr_t)slide + linkedit->vmaddr - linkedit->fileoff;
const struct nlist_64 *symtab_list = (const struct nlist_64 *)(linkedit_base + symtab->symoff);
const char *strtab = (const char *)(linkedit_base + symtab->stroff);
const uint32_t *indirect = (const uint32_t *)(linkedit_base + dysymtab->indirectsymoff);
/* 遍历各 section,挑非惰性符号指针段(__got / __auth_got)。 */
cmd = (const uint8_t *)(mh + 1);
for (uint32_t i = 0; i < mh->ncmds; ++i) {
const struct load_command *lc = (const struct load_command *)cmd;
if (lc->cmd == LC_SEGMENT_64) {
const struct segment_command_64 *seg = (const struct segment_command_64 *)lc;
const struct section_64 *sect = (const struct section_64 *)(seg + 1);
for (uint32_t s = 0; s < seg->nsects; ++s) {
uint32_t type = sect[s].flags & SECTION_TYPE;
if (type != S_NON_LAZY_SYMBOL_POINTERS) continue;
size_t n = sect[s].size / sizeof(void *);
const uint32_t *idxs = indirect + sect[s].reserved1;
void **slots = (void **)((uintptr_t)slide + sect[s].addr);
for (size_t k = 0; k < n; ++k) {
uint32_t symi = idxs[k];
if (symi == INDIRECT_SYMBOL_ABS || symi == INDIRECT_SYMBOL_LOCAL) continue;
const char *sym = strtab + symtab_list[symi].n_un.n_strx;
if (sym[0] != '_') continue;
const char *bare = sym + 1;
for (size_t m = 0; m < count; ++m) {
if (ig_strcmp(bare, names[m]) != 0) continue;
const void *cur = ig_strip(slots[k]);
if (!trusted[m] || cur == trusted[m]) break; /* 一致=正常转发 */
Dl_info di;
const char *prov = (dladdr((void*)cur, &di) ? di.dli_fname : NULL);
if (prov && ig_is_system_path(prov)) break; /* 仍指向系统实现,放行 */
char ev[256];
snprintf(ev, sizeof(ev),
"镜像=%s 槽@%p 当前=%p(提供方=%s) 期望=%p",
img_path ? img_path : "?", (void*)&slots[k], (void*)cur,
prov ? prov : "?", trusted[m]);
ig_emit(sink, ctx, stop, hits, IG_DETECTED, IG_REASON_GOT_REBIND, sym, ev);
break;
}
if (*stop) return;
}
}
}
cmd += lc->cmdsize;
}
}
int ig_anti_hook_check(const char *const *names, size_t count,
IGFindingSink sink, void *ctx) {
if (!names || count == 0) return 0;
int hits = 0, stop = 0;
/* 逐符号:provenance + inline-hook,并收集 trusted 地址表供 GOT 检查复用。 */
void *trusted[64];
size_t n = count < 64 ? count : 64;
for (size_t i = 0; i < n; ++i) {
void *addr = ig_check_provenance(names[i], sink, ctx, &stop, &hits);
trusted[i] = addr;
if (addr) ig_check_prologue(names[i], addr, sink, ctx, &stop, &hits);
if (stop) return hits;
}
/* GOT 重绑定:遍历全部镜像,内部只查非系统镜像。 */
uint32_t imgc = _dyld_image_count();
for (uint32_t i = 0; i < imgc && !stop; ++i) {
ig_check_got_one_image(i, names, trusted, n, sink, ctx, &stop, &hits);
}
return hits;
}
IGStatus ig_verify_function(void *addr, const char *name, IGFindingSink sink, void *ctx) {
if (!addr) return IG_UNAVAILABLE;
int hits = 0, stop = 0;
/* provenance:地址提供方须在系统路径白名单内。 */
Dl_info info;
if (!dladdr(addr, &info) || !info.dli_fname) {
ig_emit(sink, ctx, &stop, &hits, IG_UNAVAILABLE, IG_REASON_VERIFICATION_UNAVAILABLE,
name ? name : "?", "无法确认函数提供方");
return IG_UNAVAILABLE;
}
if (!ig_is_system_path(info.dli_fname)) {
char ev[256];
snprintf(ev, sizeof(ev), "解析地址 %p 提供方=%s(非系统路径)",
addr, info.dli_fname ? info.dli_fname : "?");
ig_emit(sink, ctx, &stop, &hits, IG_DETECTED, IG_REASON_SYMBOL_PROVENANCE,
name ? name : "?", ev);
return IG_DETECTED;
}
/* inline-hook 序言。 */
return ig_check_prologue(name ? name : "?", addr, sink, ctx, &stop, &hits);
}
int ig_anti_hook_check_default(IGFindingSink sink, void *ctx) {
return ig_anti_hook_check(kIGDefaultSymbols,
sizeof(kIGDefaultSymbols)/sizeof(kIGDefaultSymbols[0]),
sink, ctx);
}
+48
View File
@@ -0,0 +1,48 @@
/*
* IGAntiHook.h — 关键函数 HOOK 完整性探针。
*
* 覆盖三类 HOOK 形态(docs/05 §5.C「GOT/符号地址」「关键自有代码完整性」):
* 1. 符号提供方异常:dlsym 解析到非系统镜像(dyld interpose / 注入 dylib 抢占定义)。
* 2. inline hook:关键函数序言首指令被改写为无条件跳转或 LDR+BR x16 蹦床。
* 3. GOT 重绑定:本进程镜像的 __got/__la_symbol_ptr 槽被 fishhook 类手法改指到非系统地址。
*
* 只采集证据,不处置。PAC/chained-fixups/arm64e 的边界见 .c 注释。
*/
#ifndef IG_ANTI_HOOK_H
#define IG_ANTI_HOOK_H
#include "IGDefender.h"
#ifdef __cplusplus
extern "C" {
#endif
/*
* 校验一批关键 libc/系统函数的运行时完整性。
* names: 函数名数组(不带前导下划线,如 "write"/"read"/"dlsym")。
* count: 数组长度。
* 对每个符号依次做 provenance / inline-hook / GOT-rebind 检查,命中即经 sink 上报。
* 返回 DETECTED 条数(0 表示本轮全部 clear 或仅 unavailable)。
*/
int ig_anti_hook_check(const char *const *names, size_t count,
IGFindingSink sink, void *ctx);
/* 便捷入口:用内置关键符号集(报告命中的 12 个)执行 ig_anti_hook_check。 */
int ig_anti_hook_check_default(IGFindingSink sink, void *ctx);
/*
* 单点「调用前校验」:对一个**已解析**的函数地址做 provenance(dladdr 提供方须系统路径)
* + inline-hook 序言检查。供 IGResolve 在放行解析结果前复用。
* 命中经 sink 上报(可传 NULL 只取返回值)。
* 返回 IG_CLEAR=干净可用 / IG_DETECTED=疑被挟持应拒用 / IG_UNAVAILABLE=addr 为空无法判定。
*/
IGStatus ig_verify_function(void *addr, const char *name, IGFindingSink sink, void *ctx);
/* ARM64 序言形态分类,可独立测试;命中只是一条证据,不覆盖所有 Hook。 */
int ig_arm64_suspicious_prologue(uint32_t first, uint32_t second);
#ifdef __cplusplus
}
#endif
#endif /* IG_ANTI_HOOK_H */
+146
View File
@@ -0,0 +1,146 @@
/*
* IGObjCBaseline.c — ObjC 关键方法 IMP 基线探针实现。
*
* 全部公开 API:objc_getClass / sel_registerName / class_getMethodImplementation
* (objc/runtime.h,纯 C)、dladdr(提供方)、vm_read_overwrite(代码前缀)。
* method_getImplementation 返回"当前会被实际调用的实现"(已解析 swizzle),
* 与基线不一致即说明方法被交换/替换——这正是要抓的形态。
*
* 线程模型:capture 由策略层在确定时点(如首帧后)调用一次;check 在扫描时点调用。
* 两者并发属策略层误用,本模块不加锁(保持零依赖、可嵌入任意 target)。
*/
#include "IGObjCBaseline.h"
#include "IGInline.h"
#include <stdio.h>
#include <string.h>
#include <dlfcn.h>
#include <mach/mach.h>
#include <objc/objc.h>
#include <objc/runtime.h>
#define IG_OBJC_MAX_WATCH 64
#define IG_PREFIX_BYTES 16
typedef struct {
const char *cls; /* 登记时的类名 */
const char *sel; /* 登记时的选择子 */
void *imp; /* 基线 IMP(去 PAC 后) */
char prov[192]; /* 基线 IMP 提供方镜像路径 */
unsigned char prefix[IG_PREFIX_BYTES];
int have_prefix;
} IGObjCSlot;
static IGObjCSlot g_slots[IG_OBJC_MAX_WATCH];
static size_t g_nslots;
static const void *ig_strip(const void *p) {
#if defined(__has_feature)
# if __has_feature(ptrauth_calls)
return ptrauth_strip(p, ptrauth_key_asia);
# else
return p;
# endif
#else
return p;
#endif
}
static void ig_emit_objc(IGFindingSink sink, void *ctx, int *stop, int *hits,
IGStatus st, const char *subject, const char *evidence) {
if (*stop) return;
IGFinding f;
memset(&f, 0, sizeof(f));
f.status = st;
f.reason = IG_REASON_OBJC_IMP_CHANGED;
strncpy(f.subject, subject, sizeof(f.subject) - 1);
strncpy(f.evidence, evidence, sizeof(f.evidence) - 1);
if (st == IG_DETECTED) (*hits)++;
if (sink && sink(&f, ctx) != 0) *stop = 1;
}
/* 读取函数前 N 字节;失败返回 0(调用方按 unavailable 语义处理)。 */
static int ig_read_prefix(const void *addr, unsigned char *out) {
vm_size_t copied = 0;
if (vm_read_overwrite(mach_task_self(), (vm_address_t)ig_strip(addr),
IG_PREFIX_BYTES, (vm_address_t)out, &copied) != KERN_SUCCESS
|| copied != IG_PREFIX_BYTES)
return 0;
return 1;
}
size_t ig_objc_baseline_capture(const IGObjCWatch *watches, size_t count) {
g_nslots = 0;
if (!watches) return 0;
size_t ok = 0;
for (size_t i = 0; i < count && g_nslots < IG_OBJC_MAX_WATCH; ++i) {
if (!watches[i].class_name || !watches[i].selector) continue;
Class c = objc_getClass(watches[i].class_name);
if (!c) continue;
Method m = class_getInstanceMethod(c, sel_registerName(watches[i].selector));
if (!m) continue; /* 类存在但方法不可解析:不登记(check 语义与登记时一致) */
IMP imp = method_getImplementation(m);
if (!imp) continue;
IGObjCSlot *slot = &g_slots[g_nslots++];
slot->cls = watches[i].class_name;
slot->sel = watches[i].selector;
slot->imp = (void *)imp;
slot->prov[0] = '\0';
Dl_info info;
if (dladdr((void *)imp, &info) && info.dli_fname)
strncpy(slot->prov, info.dli_fname, sizeof(slot->prov) - 1);
slot->have_prefix = ig_read_prefix((void *)imp, slot->prefix);
++ok;
}
return ok;
}
int ig_objc_baseline_check(IGFindingSink sink, void *ctx) {
if (g_nslots == 0) return 0; /* 未接入:clear no-op */
int hits = 0, stop = 0;
char subject[192], ev[256];
for (size_t i = 0; i < g_nslots && !stop; ++i) {
const IGObjCSlot *b = &g_slots[i];
snprintf(subject, sizeof(subject), "-[%s %s]", b->cls, b->sel);
Class c = objc_getClass(b->cls);
if (!c) {
ig_emit_objc(sink, ctx, &stop, &hits, IG_UNAVAILABLE, subject,
"基线登记后类不可解析(被卸载或运行时异常)");
continue;
}
Method m = class_getInstanceMethod(c, sel_registerName(b->sel));
if (!m || !method_getImplementation(m)) {
ig_emit_objc(sink, ctx, &stop, &hits, IG_UNAVAILABLE, subject,
"方法实现不可解析(转发桩或已移除)");
continue;
}
IMP imp = method_getImplementation(m);
const void *cur = ig_strip(imp);
if (cur != b->imp) {
/* IMP 换人:典型 swizzle / class_replaceMethod / exchange。 */
char cur_prov[192] = "?";
Dl_info info;
if (dladdr((void *)cur, &info) && info.dli_fname)
strncpy(cur_prov, info.dli_fname, sizeof(cur_prov) - 1);
snprintf(ev, sizeof(ev), "IMP %p(%s) → %p(%s)(实现被替换)",
b->imp, b->prov[0] ? b->prov : "?", cur, cur_prov);
ig_emit_objc(sink, ctx, &stop, &hits, IG_DETECTED, subject, ev);
continue;
}
/* IMP 未变但代码前缀变:实现函数体被 inline patch。 */
if (b->have_prefix) {
unsigned char now[IG_PREFIX_BYTES];
if (!ig_read_prefix((void *)cur, now)) {
ig_emit_objc(sink, ctx, &stop, &hits, IG_UNAVAILABLE, subject,
"代码前缀不可读");
continue;
}
if (memcmp(now, b->prefix, IG_PREFIX_BYTES) != 0) {
snprintf(ev, sizeof(ev), "IMP %p 不变但代码前缀变化(函数体被改写)", cur);
ig_emit_objc(sink, ctx, &stop, &hits, IG_DETECTED, subject, ev);
}
}
}
return hits;
}
+49
View File
@@ -0,0 +1,49 @@
/*
* IGObjCBaseline.h — ObjC 关键方法 IMP 基线探针(swizzle / 方法替换检测)。
*
* 背景(docs/05 §4 P1):IGAntiHook 只覆盖 C 符号层(序言/GOT/提供方),对 ObjC 层
* method_exchangeImplementations / class_replaceMethod / method_setImplementation
* 等劫持手段此前零覆盖。本模块由策略层指定关键方法清单,启动后采集 IMP 基线
* (实现地址 + 提供方镜像 + 代码前缀),扫描时比对——IMP 换人或函数体被改即上报。
*
* 边界(如实声明):
* - 合法 swizzle(统计/广告 SDK 常见)也会改变 IMP:本探针只给证据,是否处置由
* 策略层决定;基线采集时机本身是策略选择(早采集会把业务自身的合法交换计入)。
* - 只比对策略层显式登记的方法,不做全类扫(误报面不可控)。
* - 纯 C 调 objc runtime API,不引入 ObjC 编译依赖;未 capture 过时 check 为 no-op。
*/
#ifndef IG_OBJC_BASELINE_H
#define IG_OBJC_BASELINE_H
#include "IGDefender.h"
#ifdef __cplusplus
extern "C" {
#endif
/* 观察项:类名 + 选择子(如 { "RDOrderViewController", "payOrder" })。 */
typedef struct {
const char *class_name;
const char *selector;
} IGObjCWatch;
/*
* 采集基线:对每个观察项记录当前 IMP 地址、提供方镜像路径与代码前缀 16 字节。
* 幂等,重复调用以最后一次为准;count==0 清空基线。返回成功登记的条数
* (类/选择子当时不可解析的条目不登记,check 时按 unavailable 上报)。
*/
size_t ig_objc_baseline_capture(const IGObjCWatch *watches, size_t count);
/*
* 扫描:IMP 地址变化,或 IMP 相同但代码前缀变化 → DETECTED(110);
* 类不可解析 / IMP 为转发桩 / 代码页不可读 → UNAVAILABLE(110)。
* 未 capture 过时为 clear no-op(不惩罚未接入的调用方)。
* 返回 DETECTED 条数;只采集证据不处置。
*/
int ig_objc_baseline_check(IGFindingSink sink, void *ctx);
#ifdef __cplusplus
}
#endif
#endif /* IG_OBJC_BASELINE_H */
+103
View File
@@ -0,0 +1,103 @@
/*
* IGAntiJailbreak.c — 越狱检测探针实现。见 .h 的定位与边界。
*
* 全部文件探测经 IGSyscall 直发(access/open/close/unlink),不经 libc——规避 Shadow/Liberty
* 等对 stat/access 的 hook。证据经 sink 上报,不做处置。
*/
#include "IGAntiJailbreak.h"
#include "syscall/IGSyscall.h"
#include <stdio.h>
/* access 的 amode:F_OK=0(仅测存在/可访问)。open 标志(BSD/Darwin 值)。 */
#define IG_F_OK 0
#define IG_O_RDWR 0x0002
#define IG_O_CREAT 0x0200
#define IG_O_EXCL 0x0800
/*
* 内置 iOS 越狱特征(强信号)。沙盒内正常 App 对这些路径 access 应得 -ENOENT/-EPERM;
* 能访问即越狱。rootless 越狱重点在 /var/jb。
*
* §7.1 IG_ENC:路径不再明文驻留——由 tools/gen_jb_paths.py 生成的 XOR 混淆表引入,
* 运行期解码进栈缓冲、用完擦除,`strings` 捞不到 /var/jb、Cydia、substrate 等常量。
*/
#include "IGJailbreakPaths.inc"
/* 解码单条混淆路径到 out(容量 cap,含结尾 0)。返回长度,失败返回 0。
* k0 取 volatile:阻止 -O2 把「常量 enc + 常量 key」整条折叠回明文存入 __const
* (否则混淆被优化器击穿,strings 又能捞出)。强制运行期解码。 */
static size_t ig_jb_decode(const unsigned char *enc, size_t n, int idx,
char *out, size_t cap) {
volatile unsigned k0 = IG_JB_XOR_K0;
if (n + 1 > cap) return 0;
for (size_t j = 0; j < n; ++j) {
unsigned ks = ((unsigned)k0 + (unsigned)idx * IG_JB_XOR_K1 + j * IG_JB_XOR_K2) & 0xFFu;
out[j] = (char)(enc[j] ^ ks);
}
out[n] = '\0';
return n;
}
static void ig_jb_emit(IGFindingSink sink, void *ctx, int *hits,
IGStatus st, int reason, const char *subject, const char *evidence) {
IGFinding f;
__builtin_memset(&f, 0, sizeof(f));
f.status = st;
f.reason = reason;
if (subject) snprintf(f.subject, sizeof(f.subject), "%s", subject);
if (evidence) snprintf(f.evidence, sizeof(f.evidence), "%s", evidence);
if (st == IG_DETECTED) (*hits)++;
if (sink) sink(&f, ctx);
}
int ig_anti_jb_check_paths(const char *const *paths, size_t count,
const char *sandbox_probe_path,
IGFindingSink sink, void *ctx) {
int hits = 0;
/* 1) 越狱特征文件:直发 access(path, F_OK)==0 即可访问。 */
for (size_t i = 0; i < count; ++i) {
if (!paths[i]) continue;
if (ig_sys_access(paths[i], IG_F_OK) == 0) {
char ev[256];
snprintf(ev, sizeof(ev), "直发 access 可访问越狱特征:%s", paths[i]);
ig_jb_emit(sink, ctx, &hits, IG_DETECTED, IG_REASON_JAILBREAK_FILE, paths[i], ev);
}
}
/* 2) 沙盒逃逸:在沙盒外路径直发 open(O_CREAT|O_EXCL) 创建文件,成功=越狱强信号。 */
if (sandbox_probe_path) {
ig_sys_unlink(sandbox_probe_path); /* 清理上次残留(忽略错误) */
int fd = ig_sys_open(sandbox_probe_path, IG_O_RDWR | IG_O_CREAT | IG_O_EXCL, 0600);
if (fd >= 0) {
ig_sys_close(fd);
ig_sys_unlink(sandbox_probe_path); /* 立即清理,不留痕 */
char ev[256];
snprintf(ev, sizeof(ev), "能在沙盒外创建文件:%s", sandbox_probe_path);
ig_jb_emit(sink, ctx, &hits, IG_DETECTED, IG_REASON_JAILBREAK_SANDBOX,
sandbox_probe_path, ev);
}
}
return hits;
}
int ig_anti_jb_check(IGFindingSink sink, void *ctx) {
/* §7.1:把混淆表运行期解码进栈,构建 ptr 数组喂给通用入口,用完擦除,不留明文。 */
char storage[IG_JB_ENC_COUNT][128];
const char *ptrs[IG_JB_ENC_COUNT];
for (int i = 0; i < IG_JB_ENC_COUNT; ++i) {
ig_jb_decode(kIGJbEnc[i].b, kIGJbEnc[i].n, i, storage[i], sizeof(storage[i]));
ptrs[i] = storage[i];
}
char probe[128];
ig_jb_decode(kIGJbProbeEnc, IG_JB_PROBE_LEN, IG_JB_PROBE_IDX, probe, sizeof(probe));
int hits = ig_anti_jb_check_paths(ptrs, IG_JB_ENC_COUNT, probe, sink, ctx);
/* 擦除解码后的明文,缩短其在内存驻留窗口(动态分析仍可抓,但抬高被动 dump 成本)。 */
__builtin_memset(storage, 0, sizeof(storage));
__builtin_memset(probe, 0, sizeof(probe));
return hits;
}
+44
View File
@@ -0,0 +1,44 @@
/*
* IGAntiJailbreak.h — 越狱检测探针(走 IGSyscall 直发 svc,绕过 libc 层 hook)。
*
* 定位:Shadow / Liberty / A-Bypass 这类反越狱检测插件主要 hook 在 libc/ObjC 层
* (stat/access/fopen/NSFileManager)。本探针用 IGSyscall 的 svc #0x80 直发
* access(2)/open(2),那条可被 hook 的 libSystem 入口在此路径上不存在——检测点下沉到
* bypass 够不到的层。这是纯客户端对抗里"抬高绕过成本"的关键一环(非根治)。
*
* 只采集证据、不处置:命中经 sink 上报,是否毒化/降级由策略层([[iosguard-disposition-strategy]]
* 的 ig_poison_mark)按强信号组合决定。本探针绝不自行 exit。
*
* 边界:
* - 路径特征可被 rootless 越狱改位;未命中不等于干净(组合判定原则不变)。
* - 当前骨架路径字符串为明文,静态可见、bypass 可针对——TODO 用 IGResolve 的 XOR 混淆
* (IG_ENC),与 svc 号混淆同理。svc 直发本身已是主要价值,字符串混淆是第二层。
* - 仅 arm64 直发;非 arm64(宿主 x86_64)syscall 退化 unavailable。
*/
#ifndef IG_ANTI_JAILBREAK_H
#define IG_ANTI_JAILBREAK_H
#include "IGDefender.h"
#ifdef __cplusplus
extern "C" {
#endif
/* 默认检测:内置 iOS 越狱特征表 + 沙盒逃逸探测。返回 DETECTED 条数。 */
int ig_anti_jb_check(IGFindingSink sink, void *ctx);
/*
* 可注入版本(供自测/定制)。
* paths/count:要探测可访问性的路径表(access F_OK);命中记 reason=400。
* sandbox_probe_path:非 NULL 时尝试在该(应在沙盒外的)路径创建文件,成功=沙盒逃逸,记 401
* 并立即清理;NULL 跳过逃逸探测。
*/
int ig_anti_jb_check_paths(const char *const *paths, size_t count,
const char *sandbox_probe_path,
IGFindingSink sink, void *ctx);
#ifdef __cplusplus
}
#endif
#endif /* IG_ANTI_JAILBREAK_H */
@@ -0,0 +1,28 @@
/* IGJailbreakPaths.inc — 由 tools/gen_jb_paths.py 生成,请勿手改。 */
/* 越狱路径 XOR 混淆表(§7.1):enc[j]=plain[j]^((K0+idx*K1+j*K2)&0xFF)。 */
#define IG_JB_XOR_K0 0x5au
#define IG_JB_XOR_K1 0x2fu
#define IG_JB_XOR_K2 0x13u
static const unsigned char kIGJbEnc0[] = { 0x75, 0x1b, 0xe1, 0xe1, 0x89, 0xd3, 0xae }; /* len=7 */
static const unsigned char kIGJbEnc1[] = { 0xa6, 0xdd, 0xdf, 0xb2, 0xb9, 0x81, 0x98, 0x6f, 0x55, 0x5d, 0x28, 0x34, 0x1e, 0xaf, 0xd0, 0xdf, 0xdd, 0xa5, 0xbe, 0xdc, 0x64, 0x68, 0x5b }; /* len=23 */
static const unsigned char kIGJbEnc2[] = { 0x97, 0x8a, 0xae, 0x81, 0x68, 0x7e, 0x49, 0x5c, 0x24, 0x0a, 0x19, 0xe7, 0xef, 0x80, 0x91, 0xbc, 0x84, 0x9e, 0x61, 0x0f, 0x55, 0x37, 0x2a }; /* len=23 */
static const unsigned char kIGJbEnc3[] = { 0xc8, 0xbb, 0x7d, 0x50, 0x5f, 0x2f, 0x3a, 0x0d, 0x0b, 0xfb, 0xca, 0xd6, 0xb8, 0xf1, 0xab, 0x61, 0x75, 0x58, 0x5c, 0x7e, 0x02, 0x06, 0xf9 }; /* len=23 */
static const unsigned char kIGJbEnc4[] = { 0x39, 0x5c, 0x4f, 0x3d, 0x4d, 0x06, 0xea, 0xf2, 0xc0, 0xee, 0xa7, 0x94, 0x92, 0x69 }; /* len=14 */
static const unsigned char kIGJbEnc5[] = { 0x6a, 0x2d, 0x18, 0x0c, 0xbe, 0xc6, 0xde, 0xa4, 0xf2, 0x83, 0x70, 0x7e }; /* len=12 */
static const unsigned char kIGJbEnc6[] = { 0x5b, 0xe5, 0xf3, 0xc3, 0xef, 0xb1, 0x87, 0x8a, 0x64 }; /* len=9 */
static const unsigned char kIGJbEnc7[] = { 0x8c, 0xd4, 0xa0, 0xb2, 0xc0, 0x71, 0x7d }; /* len=7 */
static const unsigned char kIGJbEnc8[] = { 0xfd, 0x80, 0x8c, 0x68, 0x31, 0x50, 0x34, 0x23 }; /* len=8 */
static const unsigned char kIGJbEnc9[] = { 0x2e, 0x64, 0x55, 0x53, 0x3b, 0x01, 0x07, 0xe3, 0xb6, 0xda, 0xde, 0xa0, 0xca, 0x94, 0x62, 0x7c, 0x1e, 0x25, 0x27, 0x1e }; /* len=20 */
static const unsigned char kIGJbEnc10[] = { 0x1f, 0x36, 0x25, 0x1b, 0x53, 0xe3, 0xcb, 0xd7, 0xe7, 0xa8, 0x9b, 0x63, 0x67, 0x53, 0x48, 0x2c, 0x14, 0x16 }; /* len=18 */
static const unsigned char kIGJbEnc11[] = { 0x70, 0x3e, 0xec, 0xfa, 0xd9, 0xdf, 0xa3, 0x9d, 0xd8, 0x47, 0x72, 0x52, 0x2a, 0x3a, 0x0c, 0x2f, 0xfa, 0xc0, 0xc6, 0xbc, 0xa9, 0x8f, 0x75, 0x71, 0x08, 0x77, 0x22, 0x02, 0x1a, 0xea, 0xfc, 0xff, 0xca, 0xb0, 0x96, 0x8c, 0x79, 0x7f, 0x45, 0x21, 0x79, 0x0e, 0x04, 0xfc, 0xca, 0xd4 }; /* len=46 */
static const unsigned char kIGJbEnc12[] = { 0xa1, 0xd4, 0xc7, 0xb5, 0xf5, 0x81, 0x69, 0x71, 0x09, 0x6d, 0x3b, 0x3a, 0x13, 0xee, 0xd1, 0xc5, 0xd4, 0xb4, 0x87, 0x83 }; /* len=20 */
static const struct { const unsigned char *b; unsigned char n; } kIGJbEnc[] = { { kIGJbEnc0, 7 }, { kIGJbEnc1, 23 }, { kIGJbEnc2, 23 }, { kIGJbEnc3, 23 }, { kIGJbEnc4, 14 }, { kIGJbEnc5, 12 }, { kIGJbEnc6, 9 }, { kIGJbEnc7, 7 }, { kIGJbEnc8, 8 }, { kIGJbEnc9, 20 }, { kIGJbEnc10, 18 }, { kIGJbEnc11, 46 }, { kIGJbEnc12, 20 } };
#define IG_JB_ENC_COUNT 13
/* 沙盒逃逸探测路径(idx 用一个与上表不冲突的独立下标)。 */
static const unsigned char kIGJbProbeEnc[] = { 0x8a, 0xc8, 0xb9, 0xb7, 0x87, 0x65, 0x63, 0x4f, 0x12, 0x7e, 0x0a, 0x11, 0xd6, 0xf6, 0xcd, 0x9d, 0xa5, 0x9a, 0x94, 0x6c, 0x44 }; /* len=21 */
#define IG_JB_PROBE_LEN 21
#define IG_JB_PROBE_IDX 0xa5
+128
View File
@@ -0,0 +1,128 @@
/*
* IGAntiTamper.c — 二进制完整性 / 防重打包探针实现。见 .h 的定位与误报底线。
*
* 只采集证据经 sink 上报,不处置。两条检查均按 expect_* 构建上下文开关,dev/诊断构建传 0
* → 返回 UNAVAILABLE,绝不在非分发构建上报 DETECTED。
*/
#include "IGAntiTamper.h"
#include <mach-o/dyld.h>
#include <unistd.h>
#include <stdio.h>
/* csops(2):读本进程代码签名状态。手工声明(<sys/codesign.h> 非 SDK 公共头)。 */
#define IG_CS_OPS_STATUS 0
#define IG_CS_VALID 0x00000001u /* 动态有效(代码页签名校验通过) */
#define IG_CS_ADHOC 0x00000002u /* ad-hoc 签名(无开发者证书) */
#define IG_CS_GET_TASK_ALLOW 0x00000004u /* 允许被 task_for_pid/调试器附着 */
extern int csops(pid_t pid, unsigned int ops, void *useraddr, size_t usersize);
static void ig_tamper_emit(IGFindingSink sink, void *ctx, int *hits,
IGStatus st, int reason, const char *subject, const char *evidence) {
IGFinding f;
__builtin_memset(&f, 0, sizeof(f));
f.status = st;
f.reason = reason;
if (subject) snprintf(f.subject, sizeof(f.subject), "%s", subject);
if (evidence) snprintf(f.evidence, sizeof(f.evidence), "%s", evidence);
if (st == IG_DETECTED && hits) (*hits)++;
if (sink) sink(&f, ctx);
}
int ig_tamper_scan_cryptid(const struct mach_header_64 *mh, int expect_encrypted,
IGFindingSink sink, void *ctx) {
int hits = 0;
/* 非分发构建:未 FairPlay 加密是正常的,无法据此断言篡改。 */
if (!expect_encrypted) {
ig_tamper_emit(sink, ctx, &hits, IG_UNAVAILABLE, IG_REASON_BINARY_DECRYPTED,
"cryptid", "非分发构建(expect_encrypted=0),跳过加密校验");
return hits;
}
if (!mh || mh->magic != MH_MAGIC_64) {
ig_tamper_emit(sink, ctx, &hits, IG_UNAVAILABLE, IG_REASON_BINARY_DECRYPTED,
"cryptid", "主镜像 Mach-O 头不可用");
return hits;
}
/* 遍历 load command 找 LC_ENCRYPTION_INFO_64。 */
const struct load_command *lc = (const struct load_command *)(mh + 1);
int found = 0;
uint32_t cryptid = 0;
for (uint32_t i = 0; i < mh->ncmds; ++i) {
if (lc->cmdsize == 0) break; /* 防御畸形头导致的死循环 */
if (lc->cmd == LC_ENCRYPTION_INFO_64) {
const struct encryption_info_command_64 *e =
(const struct encryption_info_command_64 *)lc;
found = 1;
cryptid = e->cryptid;
break;
}
lc = (const struct load_command *)((const uint8_t *)lc + lc->cmdsize);
}
if (!found) {
/* 应加密的分发包却整条没有加密命令:被剥除/重打包的强信号。 */
ig_tamper_emit(sink, ctx, &hits, IG_DETECTED, IG_REASON_BINARY_DECRYPTED,
"cryptid", "应加密分发包无 LC_ENCRYPTION_INFO(加密命令被剥除/重打包)");
} else if (cryptid == 0) {
/* 标准脱壳(Clutch/frida-ios-dump)会把 cryptid 改 0。 */
ig_tamper_emit(sink, ctx, &hits, IG_DETECTED, IG_REASON_BINARY_DECRYPTED,
"cryptid", "cryptid==0:二进制已脱壳解密(dump/重打包)");
}
/* cryptid != 0 → CLEAR,保持安静不上报。 */
return hits;
}
static int ig_tamper_scan_codesign(int expect_distribution,
IGFindingSink sink, void *ctx) {
int hits = 0;
/* 非分发构建:dev/诊断签名本就带 get-task-allow、可能 ad-hoc,不据此断言。 */
if (!expect_distribution) {
ig_tamper_emit(sink, ctx, &hits, IG_UNAVAILABLE, IG_REASON_CODESIGN_INVALID,
"codesign", "非分发构建(expect_distribution=0),跳过签名校验");
return hits;
}
uint32_t status = 0;
if (csops(getpid(), IG_CS_OPS_STATUS, &status, sizeof(status)) != 0) {
ig_tamper_emit(sink, ctx, &hits, IG_UNAVAILABLE, IG_REASON_CODESIGN_INVALID,
"codesign", "csops(CS_OPS_STATUS) 调用失败");
return hits;
}
if (!(status & IG_CS_VALID)) {
ig_tamper_emit(sink, ctx, &hits, IG_DETECTED, IG_REASON_CODESIGN_INVALID,
"codesign", "CS_VALID 失效:代码页签名校验未通过(内存/磁盘被 patch)");
}
if (status & IG_CS_ADHOC) {
ig_tamper_emit(sink, ctx, &hits, IG_DETECTED, IG_REASON_CODESIGN_INVALID,
"codesign", "ad-hoc 签名:无开发者证书的重签(典型破解重打包)");
}
if (status & IG_CS_GET_TASK_ALLOW) {
ig_tamper_emit(sink, ctx, &hits, IG_DETECTED, IG_REASON_CODESIGN_INVALID,
"codesign", "分发包却带 get-task-allow:被重签成可调试");
}
return hits;
}
static const struct mach_header_64 *ig_main_image_header(void) {
uint32_t n = _dyld_image_count();
for (uint32_t i = 0; i < n; ++i) {
const struct mach_header *h = _dyld_get_image_header(i);
if (h && h->magic == MH_MAGIC_64 &&
((const struct mach_header_64 *)h)->filetype == MH_EXECUTE) {
return (const struct mach_header_64 *)h;
}
}
return NULL;
}
int ig_anti_tamper_check(int expect_encrypted, int expect_distribution,
IGFindingSink sink, void *ctx) {
int hits = 0;
hits += ig_tamper_scan_cryptid(ig_main_image_header(), expect_encrypted, sink, ctx);
hits += ig_tamper_scan_codesign(expect_distribution, sink, ctx);
return hits;
}
+55
View File
@@ -0,0 +1,55 @@
/*
* IGAntiTamper.h — 二进制完整性 / 防重打包探针。
*
* 定位:anti_hook 只校验固定一批关键函数的序言/GOT——攻击者 patch 这批之外的任意指令(含
* NOP 掉某条检测/毒化调用边、改业务层比较)它看不见。本模块从「镜像整体」角度补这个空洞,
* 正面反制 App Store 应用的标准破解链:**脱壳解密(Clutch/frida-ios-dump)→ patch → 重签**。
*
* 两条检查(均只采集证据、不处置,经 sink 上报;判级交 policy):
* 1. FairPlay cryptid:App Store 分发包由 Apple 加密(LC_ENCRYPTION_INFO_64.cryptid=1)。
* 脱壳 dump 会把 cryptid 改 0;重打包可能整条剥除加密命令。→ IG_REASON_BINARY_DECRYPTED。
* 2. 代码签名状态(csops CS_OPS_STATUS):ad-hoc 重签、分发包却带 get-task-allow(被重签成
* 可调试)、CS_VALID 失效。→ IG_REASON_CODESIGN_INVALID。
*
* 【误报底线】这两条都**依赖构建上下文**:dev/TestFlight/诊断构建本就未 FairPlay 加密、且带
* get-task-allow——那是正常的,不是篡改。故由调用方按构建类型传 expect_* 开关:只有
* 「本应是 App Store 分发包」时才判 DETECTED;否则返回 UNAVAILABLE(无法断言,不上报 DETECTED)。
* expect 开关应由 Release/App Store 构建配置注入(见 docs/18),绝不在 dev 构建置 1。
*
* 【边界】csops 经 libc 调用,可被 hook 伪造(若攻击者已能 hook csops,说明环境已失陷,
* 届时 anti_hook/anti_inject 会先命中);cryptid 读的是进程内 Mach-O 头,patch 头部也能伪装,
* 但那要求攻击者已定位该检查——与整体「抬成本、非不可破」哲学一致,不作为唯一安全锚点。
*/
#ifndef IG_ANTI_TAMPER_H
#define IG_ANTI_TAMPER_H
#include <mach-o/loader.h>
#include "IGDefender.h"
#ifdef __cplusplus
extern "C" {
#endif
/*
* 真机入口:对当前进程主可执行镜像做 cryptid + 代码签名检查。
* expect_encrypted:本构建是否「本应 FairPlay 加密」(App Store 分发=1,dev/诊断=0)。
* expect_distribution:本构建是否「本应分发签名」(不含 get-task-allow;App Store=1,dev=0)。
* 两者为 0 时对应检查返回 UNAVAILABLE(不误报)。返回 DETECTED 证据条数。
*/
int ig_anti_tamper_check(int expect_encrypted, int expect_distribution,
IGFindingSink sink, void *ctx);
/*
* 可测核心:对给定 Mach-O 头做 cryptid 检查(与真机入口共用逻辑,便于用合成头单测)。
* mh:指向 mach_header_64。expect_encrypted:同上。
* 返回 DETECTED 条数(0=CLEAR 或 UNAVAILABLE)。
*/
int ig_tamper_scan_cryptid(const struct mach_header_64 *mh, int expect_encrypted,
IGFindingSink sink, void *ctx);
#ifdef __cplusplus
}
#endif
#endif /* IG_ANTI_TAMPER_H */
+52
View File
@@ -0,0 +1,52 @@
#include "IGFileBridge.h"
#include <unistd.h>
#if !defined(__clang__)
#error "此验证实现需要 Clang 的 optnone 属性"
#endif
// 仅 SDK 的未定义引用重定向到此函数;本文件不能参与符号重定向。
// 无日志、检测或全局可变状态,直接返回系统 FILE * 并保留 errno。
// 间接调用不代表 GOT/Inline Hook 防护,仍须对最终 Release 单独验收。
__attribute__((optnone, noinline))
FILE *IG_fopen(const char *path, const char *mode) {
FILE *(*function)(const char *, const char *) = fopen;
return function(path, mode);
}
// 各入口单独保持真实类型;不进行自动重试或短读短写补齐。
__attribute__((optnone, noinline))
int IG_fclose(FILE *stream) {
int (*function)(FILE *) = fclose;
return function(stream);
}
__attribute__((optnone, noinline))
size_t IG_fread(void *buffer, size_t size, size_t count, FILE *stream) {
size_t (*function)(void *, size_t, size_t, FILE *) = fread;
return function(buffer, size, count, stream);
}
__attribute__((optnone, noinline))
size_t IG_fwrite(const void *buffer, size_t size, size_t count, FILE *stream) {
size_t (*function)(const void *, size_t, size_t, FILE *) = fwrite;
return function(buffer, size, count, stream);
}
__attribute__((optnone, noinline))
ssize_t IG_read(int descriptor, void *buffer, size_t count) {
ssize_t (*function)(int, void *, size_t) = read;
return function(descriptor, buffer, count);
}
__attribute__((optnone, noinline))
ssize_t IG_write(int descriptor, const void *buffer, size_t count) {
ssize_t (*function)(int, const void *, size_t) = write;
return function(descriptor, buffer, count);
}
__attribute__((optnone, noinline))
int IG_close(int descriptor) {
int (*function)(int) = close;
return function(descriptor);
}
+22
View File
@@ -0,0 +1,22 @@
#ifndef IG_FILE_BRIDGE_H
#define IG_FILE_BRIDGE_H
#include <stdio.h>
#include <sys/types.h>
#ifdef __cplusplus
extern "C" {
#endif
FILE *IG_fopen(const char *path, const char *mode);
int IG_fclose(FILE *stream);
size_t IG_fread(void *buffer, size_t size, size_t count, FILE *stream);
size_t IG_fwrite(const void *buffer, size_t size, size_t count, FILE *stream);
ssize_t IG_read(int descriptor, void *buffer, size_t count);
ssize_t IG_write(int descriptor, const void *buffer, size_t count);
int IG_close(int descriptor);
#ifdef __cplusplus
}
#endif
#endif
+226
View File
@@ -0,0 +1,226 @@
#include "IGArchiveGuard.h"
#include "../resolve/IGResolve.h"
#include "../anti_hook/IGAntiHook.h"
#include "../primitives/IGInline.h"
#include <errno.h>
#include <pthread.h>
#include <stdatomic.h>
#include <string.h>
#include <mach/mach.h>
#include <mach-o/dyld.h>
#include <mach-o/loader.h>
#include <mach-o/nlist.h>
/* 仅混淆常量,不作为秘密。SDK GOT 由 dyld 在独立镜像滑移后绑定。 */
static const unsigned char names[4][6] = {
{0x5a,0x53,0x4c,0x59,0x52}, {0x5a,0x4e,0x59,0x5d,0x58},
{0x5a,0x4b,0x4e,0x55,0x48,0x59}, {0x5a,0x5f,0x50,0x53,0x4f,0x59}
};
static pthread_once_t once = PTHREAD_ONCE_INIT;
static _Thread_local int resolving;
static _Atomic(uintptr_t) targets[4];
static uintptr_t expected[4], bindingSlots[4];
static unsigned char prefixes[4][16];
static IGStatus initial[4];
static int bindingReady;
#ifdef IG_OBSERVATION
static _Atomic(uint64_t) counters[12];
#define COUNT(i, k) atomic_fetch_add_explicit(&counters[(i)*3+(k)], 1, memory_order_relaxed)
#else
#define COUNT(i, k) ((void)0)
#endif
static int read_bytes(uintptr_t address, void *out, size_t size) {
vm_size_t copied = 0;
return vm_read_overwrite(mach_task_self(), address, size, (vm_address_t)out, &copied) == KERN_SUCCESS
&& copied == size;
}
/* 仅支持打包工具已审核的非认证 arm64 GOT;缺槽/重复槽均标为不可验证。 */
static int locate_bindings(void) {
unsigned found = 0, images = 0;
for (uint32_t index = 0; index < _dyld_image_count(); index++) {
const char *path = _dyld_get_image_name(index);
const char *suffix = "/SSZipArchive.framework/SSZipArchive";
size_t length = path ? ig_strlen(path) : 0, tail = ig_strlen(suffix);
if (length < tail || ig_strcmp(path + length - tail, suffix)) continue;
if (++images != 1) return 0;
const struct mach_header_64 *header = (const void *)_dyld_get_image_header(index);
if (!header || header->magic != MH_MAGIC_64 || header->cputype != CPU_TYPE_ARM64
|| (header->cpusubtype & 0xffffff) != 0) return 0;
uintptr_t slide = _dyld_get_image_vmaddr_slide(index);
const struct segment_command_64 *linkedit = NULL;
const struct symtab_command *symtab = NULL;
const struct dysymtab_command *dysymtab = NULL;
const uint8_t *command = (const void *)(header + 1);
const uint8_t *end = command + header->sizeofcmds;
for (uint32_t i = 0; i < header->ncmds; i++) {
if (command + sizeof(struct load_command) > end) return 0;
const struct load_command *lc = (const void *)command;
if (lc->cmdsize < 8 || lc->cmdsize % 8 || lc->cmdsize > (size_t)(end-command)) return 0;
if (lc->cmd == LC_SEGMENT_64) {
if (lc->cmdsize < sizeof(struct segment_command_64)) return 0;
const struct segment_command_64 *seg = (const void *)lc;
if (sizeof(*seg) + (uint64_t)seg->nsects * sizeof(struct section_64) != lc->cmdsize) return 0;
if (!ig_strcmp(seg->segname, SEG_LINKEDIT)) linkedit = seg;
} else if (lc->cmd == LC_SYMTAB && lc->cmdsize == sizeof(*symtab)) symtab = (const void *)lc;
else if (lc->cmd == LC_DYSYMTAB && lc->cmdsize == sizeof(*dysymtab)) dysymtab = (const void *)lc;
command += lc->cmdsize;
}
if (!linkedit || !symtab || !dysymtab || command != end) return 0;
uint64_t lo = linkedit->fileoff, hi = lo + linkedit->filesize;
if (hi < lo || symtab->symoff < lo || (uint64_t)symtab->symoff + (uint64_t)symtab->nsyms*16 > hi
|| symtab->stroff < lo || (uint64_t)symtab->stroff + symtab->strsize > hi
|| dysymtab->indirectsymoff < lo
|| (uint64_t)dysymtab->indirectsymoff + (uint64_t)dysymtab->nindirectsyms*4 > hi) return 0;
uintptr_t base = slide + linkedit->vmaddr - lo;
const struct nlist_64 *symbols = (const void *)(base + symtab->symoff);
const char *strings = (const void *)(base + symtab->stroff);
const uint32_t *indirect = (const void *)(base + dysymtab->indirectsymoff);
command = (const void *)(header + 1);
for (uint32_t i = 0; i < header->ncmds; i++) {
const struct load_command *lc = (const void *)command;
if (lc->cmd == LC_SEGMENT_64) {
const struct segment_command_64 *seg = (const void *)lc;
const struct section_64 *sections = (const void *)(seg + 1);
for (uint32_t j = 0; j < seg->nsects; j++) {
const struct section_64 *s = sections + j;
if ((s->flags & SECTION_TYPE) != S_NON_LAZY_SYMBOL_POINTERS) continue;
if (s->size % 8 || (uint64_t)s->reserved1 + s->size/8 > dysymtab->nindirectsyms) return 0;
for (uint64_t k = 0; k < s->size/8; k++) {
uint32_t symbol = indirect[s->reserved1 + k];
if (symbol & (INDIRECT_SYMBOL_LOCAL | INDIRECT_SYMBOL_ABS)) continue;
if (symbol >= symtab->nsyms) return 0;
uint32_t strx = symbols[symbol].n_un.n_strx;
if (strx >= symtab->strsize) return 0;
const char *name = strings + strx;
if (!memchr(name, 0, symtab->strsize-strx)) return 0;
for (unsigned n = 0; n < 4; n++) {
char expectedName[] = "_ig_a0";
expectedName[5] += n;
if (ig_strcmp(name, expectedName)) continue;
if (found & (1u << n)) return 0;
bindingSlots[n] = slide + s->addr + k*8;
found |= 1u << n;
}
}
}
}
command += lc->cmdsize;
}
}
return found == 15 && images == 1;
}
static void initialize(void) {
bindingReady = locate_bindings();
for (unsigned i = 0; i < 4; i++) {
IGResolveResult result = ig_resolve_verified(NULL, names[i], i < 2 ? 5 : 6, NULL, NULL);
initial[i] = result.status;
if (result.status != IG_CLEAR || !result.address) continue;
if (!read_bytes((uintptr_t)result.address, prefixes[i], 16)) { initial[i] = IG_UNAVAILABLE; continue; }
expected[i] = (uintptr_t)result.address;
atomic_store_explicit(&targets[i], expected[i], memory_order_release);
}
}
static int prepare(void) {
if (resolving) return 0;
resolving = 1;
int result = pthread_once(&once, initialize);
resolving = 0;
return result == 0;
}
static IGStatus validate(unsigned index, uintptr_t *address) {
if (initial[index] != IG_CLEAR) return initial[index];
uintptr_t current = atomic_load_explicit(&targets[index], memory_order_acquire);
if (!current || current != expected[index]) return IG_DETECTED;
IGStatus status = ig_verify_function((void *)current, "archive-target", NULL, NULL);
if (status != IG_CLEAR) return status;
unsigned char bytes[16];
if (!read_bytes(current, bytes, 16)) return IG_UNAVAILABLE;
if (ig_memcmp(bytes, prefixes[index], 16)) return IG_DETECTED;
*address = current;
return IG_CLEAR;
}
static IGStatus check_bindings(void) {
#ifdef IG_ARCHIVE_TESTING
/* 宿主 ABI fixture 不装载 SSZipArchive;此豁免不能编入业务包。 */
return IG_CLEAR;
#else
if (!bindingReady) return IG_UNAVAILABLE;
uintptr_t correct[4] = {(uintptr_t)&ig_a0, (uintptr_t)&ig_a1, (uintptr_t)&ig_a2, (uintptr_t)&ig_a3};
for (unsigned i = 0; i < 4; i++) {
uintptr_t current;
if (!read_bytes(bindingSlots[i], &current, sizeof(current))) return IG_UNAVAILABLE;
if (current != correct[i]) return IG_DETECTED;
}
return IG_CLEAR;
#endif
}
static uintptr_t checked(unsigned index) {
COUNT(index, 0);
if (!prepare()) { COUNT(index, 2); errno = EDEADLK; return 0; }
uintptr_t address = 0;
IGStatus status = check_bindings();
if (status == IG_CLEAR) status = validate(index, &address);
if (status != IG_CLEAR) { COUNT(index, 2); errno = status == IG_DETECTED ? EACCES : ENOSYS; return 0; }
COUNT(index, 1);
return address;
}
__attribute__((noinline)) FILE *ig_a0(const char *path, const char *mode) {
int incoming = errno;
uintptr_t address = checked(0);
if (!address) return NULL;
errno = incoming;
return ((FILE *(*)(const char *, const char *))address)(path, mode);
}
__attribute__((noinline)) size_t ig_a1(void *ptr, size_t size, size_t count, FILE *stream) {
int incoming = errno;
uintptr_t address = checked(1);
if (!address) return 0;
errno = incoming;
return ((size_t (*)(void *, size_t, size_t, FILE *))address)(ptr, size, count, stream);
}
__attribute__((noinline)) size_t ig_a2(const void *ptr, size_t size, size_t count, FILE *stream) {
int incoming = errno;
uintptr_t address = checked(2);
if (!address) return 0;
errno = incoming;
return ((size_t (*)(const void *, size_t, size_t, FILE *))address)(ptr, size, count, stream);
}
__attribute__((noinline)) int ig_a3(FILE *stream) {
int incoming = errno;
uintptr_t address = checked(3);
if (!address) return EOF;
errno = incoming;
return ((int (*)(FILE *))address)(stream);
}
int ig_archive_check(void) {
int incoming = errno;
if (!prepare()) { errno = incoming; return -1; }
IGStatus status = check_bindings();
for (unsigned i = 0; i < 4; i++) {
uintptr_t address;
IGStatus current = validate(i, &address);
if (current == IG_DETECTED || (current == IG_UNAVAILABLE && status == IG_CLEAR)) status = current;
}
errno = incoming;
return status == IG_CLEAR ? 0 : status == IG_DETECTED ? 1 : -1;
}
#ifdef IG_OBSERVATION
uint64_t ig_archive_counter(unsigned index) {
return index < 12 ? atomic_load_explicit(&counters[index], memory_order_relaxed) : 0;
}
#endif
#ifdef IG_ARCHIVE_TESTING
void ig_archive_test_override(unsigned index, void *address) {
if (index < 4 && prepare()) atomic_store_explicit(&targets[index], (uintptr_t)address, memory_order_release);
}
void ig_archive_test_reentry(int enabled) { resolving = enabled; }
#endif
+20
View File
@@ -0,0 +1,20 @@
#ifndef IG_ARCHIVE_GUARD_H
#define IG_ARCHIVE_GUARD_H
#include <stdio.h>
#include <stdint.h>
#define IG_ARCHIVE_EXPORT __attribute__((visibility("default")))
IG_ARCHIVE_EXPORT FILE *ig_a0(const char *path, const char *mode);
IG_ARCHIVE_EXPORT size_t ig_a1(void *ptr, size_t size, size_t count, FILE *stream);
IG_ARCHIVE_EXPORT size_t ig_a2(const void *ptr, size_t size, size_t count, FILE *stream);
IG_ARCHIVE_EXPORT int ig_a3(FILE *stream);
/* 0=正常,1=检测异常,-1=不可验证;保留 errno。 */
IG_ARCHIVE_EXPORT int ig_archive_check(void);
#ifdef IG_OBSERVATION
/* index/3 为函数,index%3 为 attempted/dispatched/rejected。 */
IG_ARCHIVE_EXPORT uint64_t ig_archive_counter(unsigned index);
#endif
#ifdef IG_ARCHIVE_TESTING
void ig_archive_test_override(unsigned index, void *address);
void ig_archive_test_reentry(int enabled);
#endif
#endif
+149
View File
@@ -0,0 +1,149 @@
#include "IGDispatch.h"
#include "../resolve/IGResolve.h"
#include "../anti_hook/IGAntiHook.h"
#include "../primitives/IGInline.h"
#include <pthread.h>
#include <stdatomic.h>
#include <errno.h>
#include <string.h>
#include <mach/mach.h>
/* 编码只减少常量区明文,不作为秘密或强加密。缓存与基线仍可被同进程攻击者修改。 */
static const unsigned char kNames[2][5] = {{0x4b,0x4e,0x55,0x48,0x59},
{0x5f,0x50,0x53,0x4f,0x59}};
static pthread_once_t gOnce=PTHREAD_ONCE_INIT;
static _Atomic(uintptr_t) gSlots[2];
static uintptr_t gExpected[2];
static unsigned char gPrefixes[2][16];
static IGStatus gInitialStatus[2]={IG_UNAVAILABLE,IG_UNAVAILABLE};
static _Thread_local int gResolving;
#ifdef IG_OBSERVATION
static _Atomic(uint64_t) gAttempted[2], gDispatched[2];
#define IG_COUNT(slot,index) atomic_fetch_add_explicit(&(slot)[index],1,memory_order_relaxed)
#else
#define IG_COUNT(slot,index) ((void)0)
#endif
static int read_prefix(uintptr_t address, unsigned char out[16]) {
vm_size_t copied=0;
return vm_read_overwrite(mach_task_self(),address,16,(vm_address_t)out,&copied)==KERN_SUCCESS
&& copied==16;
}
static void initialize(void) {
for (unsigned i=0;i<2;i++) {
IGResolveResult r=ig_resolve_verified(NULL,kNames[i],5,NULL,NULL);
gInitialStatus[i]=r.status;
if (r.status!=IG_CLEAR || !r.address) continue;
uintptr_t address=(uintptr_t)r.address;
if (!read_prefix(address,gPrefixes[i])) { gInitialStatus[i]=IG_UNAVAILABLE; continue; }
gExpected[i]=address;
atomic_store_explicit(&gSlots[i],address,memory_order_release);
}
}
static int prepare(void) {
/* dlsym/装载初始化过程中若重入受保护入口,拒绝而不是等待自身 once 锁。 */
if (gResolving) return 0;
gResolving=1;
int rc=pthread_once(&gOnce,initialize);
gResolving=0;
return rc==0;
}
static IGStatus validate(unsigned i, uintptr_t *address, int *reason) {
if (gInitialStatus[i]!=IG_CLEAR) {
*reason=IG_REASON_DISPATCH_UNAVAILABLE;
return gInitialStatus[i];
}
uintptr_t current=atomic_load_explicit(&gSlots[i],memory_order_acquire);
if (!current || current!=gExpected[i]) {
*reason=IG_REASON_DISPATCH_TAMPER;
return IG_DETECTED;
}
IGStatus status=ig_verify_function((void *)current,"dispatch-target",NULL,NULL);
if (status!=IG_CLEAR) {
*reason=status==IG_DETECTED ? IG_REASON_INLINE_HOOK : IG_REASON_VERIFICATION_UNAVAILABLE;
return status;
}
unsigned char bytes[16];
if (!read_prefix(current,bytes)) {
*reason=IG_REASON_VERIFICATION_UNAVAILABLE;
return IG_UNAVAILABLE;
}
if (ig_memcmp(bytes,gPrefixes[i],16)!=0) {
*reason=IG_REASON_DISPATCH_TAMPER;
return IG_DETECTED;
}
*address=current;
return IG_CLEAR;
}
static uintptr_t checked_address(unsigned i) {
if (!prepare()) { errno=EDEADLK; return 0; }
uintptr_t address=0; int reason=0;
IGStatus status=validate(i,&address,&reason);
if (status!=IG_CLEAR) { errno=status==IG_DETECTED ? EACCES : ENOSYS; return 0; }
return address;
}
__attribute__((used,noinline))
ssize_t IG_dispatch_write(int fd, const void *buffer, size_t count) {
int incoming=errno;
IG_COUNT(gAttempted,0);
uintptr_t address=checked_address(0);
if (!address) return -1;
IG_COUNT(gDispatched,0);
errno=incoming;
ssize_t (*function)(int,const void *,size_t)=(void *)address;
return function(fd,buffer,count);
}
__attribute__((used,noinline))
int IG_dispatch_close(int fd) {
int incoming=errno;
IG_COUNT(gAttempted,1);
uintptr_t address=checked_address(1);
if (!address) return -1;
IG_COUNT(gDispatched,1);
errno=incoming;
int (*function)(int)=(void *)address;
return function(fd);
}
int ig_dispatch_check(IGFindingSink sink, void *ctx) {
int saved=errno, hits=0;
int ready=prepare();
for (unsigned i=0;i<2;i++) {
uintptr_t address=0; int reason=IG_REASON_DISPATCH_UNAVAILABLE;
IGStatus status=ready ? validate(i,&address,&reason) : IG_UNAVAILABLE;
if (status==IG_CLEAR) continue;
IGFinding f={0}; f.status=status; f.reason=reason;
const char *label=i==0 ? "dispatch-write" : "dispatch-close";
strncpy(f.subject,label,sizeof(f.subject)-1);
strncpy(f.evidence,"调度地址、提供方或代码前缀校验未通过",sizeof(f.evidence)-1);
if (status==IG_DETECTED) hits++;
if (sink && sink(&f,ctx)!=0) break;
}
errno=saved;
return hits;
}
#ifdef IG_OBSERVATION
IGDispatchObservation ig_dispatch_observation(void) {
IGDispatchObservation value={
atomic_load_explicit(&gAttempted[0],memory_order_relaxed),
atomic_load_explicit(&gDispatched[0],memory_order_relaxed),
atomic_load_explicit(&gAttempted[1],memory_order_relaxed),
atomic_load_explicit(&gDispatched[1],memory_order_relaxed)
};
return value;
}
#endif
#ifdef IG_DISPATCH_TESTING
void ig_dispatch_test_override(unsigned i, void *address) {
if (i<2 && prepare()) atomic_store_explicit(&gSlots[i],(uintptr_t)address,memory_order_release);
}
void ig_dispatch_test_reentry(int enabled) { gResolving=enabled; }
#endif
+31
View File
@@ -0,0 +1,31 @@
#ifndef IG_DISPATCH_H
#define IG_DISPATCH_H
#include <sys/types.h>
#include "../include/IGDefender.h"
#ifdef __cplusplus
extern "C" {
#endif
/* 固定签名试点:首次按线程安全方式解析;异常时不调用未经校验的地址。 */
ssize_t IG_dispatch_write(int fd, const void *buffer, size_t count);
int IG_dispatch_close(int fd);
int ig_dispatch_check(IGFindingSink sink, void *ctx);
#ifdef IG_OBSERVATION
/* 仅观察构建导出只读计数,不提供地址覆盖或关闭校验的接口。 */
typedef struct {
uint64_t write_attempted, write_dispatched;
uint64_t close_attempted, close_dispatched;
} IGDispatchObservation;
IGDispatchObservation ig_dispatch_observation(void);
#endif
#ifdef IG_DISPATCH_TESTING
/* 只编入宿主测试,不允许在 App 发布包定义此宏。 */
void ig_dispatch_test_override(unsigned index, void *address);
void ig_dispatch_test_reentry(int enabled);
#endif
#ifdef __cplusplus
}
#endif
#endif
+85
View File
@@ -0,0 +1,85 @@
/*
* IGDefender.h — iOSGuard 运行时防护公共结果模型。
*
* 设计遵循 docs/05 §5.C:探针(probe)与处置(policy)分离。
* 探针只采集证据并通过回调上报,绝不自行 exit/中断业务;是否限制功能由上层策略决定(观察模式优先)。
* 状态三态 clear/detected/unavailable——unavailable(平台/架构不支持、数据缺失)不得当作安全。
*
* 纯 C,无 Objective-C / Swift 依赖,可直接编入任意 iOS target(也可在 macOS 宿主上编译自测)。
*/
#ifndef IG_DEFENDER_H
#define IG_DEFENDER_H
#include <stdint.h>
#include <stddef.h>
#include "IGVisibility.h"
#ifdef __cplusplus
extern "C" {
#endif
typedef enum {
IG_CLEAR = 0, /* 未发现异常证据 */
IG_DETECTED = 1, /* 命中威胁证据 */
IG_UNAVAILABLE = 2, /* 无法判定:架构/平台不支持或数据缺失——不得视为安全 */
} IGStatus;
/* 原因码按模块分段:1xx = anti_hook,2xx = 注入/Frida。 */
typedef enum {
IG_REASON_NONE = 0,
/* anti_hook */
IG_REASON_SYMBOL_PROVENANCE = 100, /* 符号解析到非系统提供方(dyld interpose / 注入覆盖) */
IG_REASON_INLINE_HOOK = 101, /* 关键函数序言被改写为跳转蹦床(Frida/Dobby inline hook) */
IG_REASON_GOT_REBIND = 102, /* 自身镜像 GOT/符号指针槽被重绑定到非系统地址(fishhook 类) */
IG_REASON_SYMBOL_UNRESOLVED = 103, /* dlsym 无法解析该符号(unavailable) */
IG_REASON_VERIFICATION_UNAVAILABLE = 104, /* 提供方/代码页无法确认 */
IG_REASON_DISPATCH_TAMPER = 105, /* 私有调度地址或初始化后的代码前缀变化 */
IG_REASON_DISPATCH_UNAVAILABLE = 106, /* 调度入口无法安全使用 */
/* 107 已分配:Swift 观察层 archive-dispatch 不可用(RDRuntimeDefender.swift),C 侧不占用 */
IG_REASON_OBJC_IMP_CHANGED = 110, /* ObjC 关键方法 IMP 相对基线变化(swizzle/替换/函数体改写) */
/* 注入 / Frida */
IG_REASON_INJECTED_IMAGE = 200, /* 加载了已知注入/调试框架镜像(substrate/frida/cycript…) */
IG_REASON_FOREIGN_IMAGE = 201, /* Bundle 外且非系统路径的镜像(弱信号,需结合其它证据) */
IG_REASON_DYLD_INSERT = 202, /* DYLD_INSERT_LIBRARIES 指向 Bundle 外路径 */
IG_REASON_FRIDA_THREAD = 203, /* 线程名命中 frida 运行时特征(gum-js-loop 等) */
IG_REASON_FRIDA_PORT = 204, /* 默认 frida 端口可连接(弱信号) */
/* anti_debug */
IG_REASON_DEBUGGER_ATTACHED = 300, /* 直发 sysctl 检出 P_TRACED:进程被调试器跟踪 */
/* anti_jailbreak(4xx)——均走 IGSyscall 直发 svc,绕过 libc 层对 stat/access 的 hook */
IG_REASON_JAILBREAK_FILE = 400, /* 越狱特征文件/目录可访问(Cydia/Sileo/apt/substrate/var-jb…) */
IG_REASON_JAILBREAK_SANDBOX = 401, /* 能在 App 沙盒外创建文件:沙盒逃逸=越狱强信号 */
/* anti_tamper(5xx)——二进制完整性/防重打包。正面反制「脱壳解密+patch+重签」破解链,
* 补 anti_hook 只盯固定函数之外的空洞。按构建上下文开关,dev/诊断构建不参与(UNAVAILABLE)。 */
IG_REASON_BINARY_DECRYPTED = 500, /* 应加密的 App Store 包 cryptid==0 或 LC_ENCRYPTION_INFO 被剥除:脱壳/重打包强信号 */
IG_REASON_CODESIGN_INVALID = 501, /* 代码签名异常:ad-hoc 重签 / 分发包却带 get-task-allow / CS_VALID 失效 */
} IGReason;
typedef struct {
IGStatus status; /* 本条发现的状态 */
int reason; /* IGReason */
char subject[128]; /* 受检对象:符号名 / 镜像路径 / 线程名 */
char evidence[256];/* 证据详情:地址、提供方路径、端口等人读文本 */
} IGFinding;
/*
* 发现回调。探针对每条 DETECTED/UNAVAILABLE 证据调用一次(CLEAR 不上报,保持安静)。
* sink 返回非 0 表示请求提前停止该探针的后续扫描;返回 0 继续。
* ctx 由调用方透传(可用于计数、聚合、打点)。
*/
typedef int (*IGFindingSink)(const IGFinding *finding, void *ctx);
/*
* 聚合入口:一次性运行 anti_hook(provenance/inline/GOT)+ 注入/Frida 全部探针。
* bundle_path:App 主 bundle(.app)路径,用于 Bundle 外镜像/插入库判定;NULL 则跳过该判定。
* probe_port:非 0 时才做 frida 端口弱探测(典型 27042);0 表示跳过。
* 返回 DETECTED 证据总条数。本函数只采集不处置,绝不 exit。
*/
IG_PUBLIC int ig_defender_scan(const char *bundle_path, int probe_port,
IGFindingSink sink, void *ctx);
#ifdef __cplusplus
}
#endif
#endif /* IG_DEFENDER_H */
+20
View File
@@ -0,0 +1,20 @@
/*
* IGGuard.h — iOSGuard Defender 对外统一公共头(umbrella)。
*
* 接入方(如 readoor)只需在 bridging header 里 `#import "IGGuard.h"`,即可拿到:
* - 结果模型:IGStatus / IGReason / IGFinding / IGFindingSink(见 IGDefender.h)
* - 聚合扫描:ig_defender_scan(只采集证据,绝不处置)
* - 策略层:ig_policy_scan_and_mark(扫描→分级→命中强信号组合则毒化,守误报底线)
* - 毒化原语:ig_poison_init / ig_poison_apply(数据依赖处置,接到解密密钥派生)
*
* Header Search Paths 需同时包含 defender/ 与 defender/include/(IGGuard.h 内部按此相对路径引用)。
* 典型用法见 docs/18_READOOR_DEFENDER_INTEGRATION.md。
*/
#ifndef IG_GUARD_H
#define IG_GUARD_H
#include "IGDefender.h" /* IGStatus/IGReason/IGFinding/IGFindingSink + ig_defender_scan */
#include "poison/IGPoison.h" /* ig_poison_init / ig_poison_mark / ig_poison_apply */
#include "policy/IGPolicy.h" /* ig_policy_scan_and_mark / ig_policy_sink / IGPolicyState */
#endif /* IG_GUARD_H */
+75
View File
@@ -0,0 +1,75 @@
/*
* IGInline.h — 强制内联的自实现 str/mem 原语(落地方案第一优先级)。
*
* 目的:核心校验/鉴权/加解密逻辑里避免直接调用 strcmp/memcmp/memcpy/strstr/getenv 等
* 被攻击者重点监控的 libc 函数——这些调用会在 __la_symbol_ptr/__got 留下符号引用,
* 既是 Fishhook rebind 的靶点,也是静态分析的锚点。
*
* 本头提供 __attribute__((always_inline)) 版本:使用处直接展开为离散汇编指令,
* 不生成 bl 跳转、不产生导入表项,从而从导入表中抹除这些符号。
*
* 用法:在安全逻辑中用 ig_memcmp/ig_strcmp/... 替换 libc 同名函数。纯头文件,零依赖。
* 注意:这是“隐藏特征”,非“更安全的实现”——不做常量时间比较;需防时序侧信道时另行处理。
*/
#ifndef IG_INLINE_H
#define IG_INLINE_H
#include <stddef.h>
#include <stdint.h>
#define IG_AINLINE static inline __attribute__((always_inline))
IG_AINLINE size_t ig_strlen(const char *s) {
const char *p = s;
while (*p) ++p;
return (size_t)(p - s);
}
IG_AINLINE int ig_memcmp(const void *a, const void *b, size_t n) {
const unsigned char *x = (const unsigned char *)a;
const unsigned char *y = (const unsigned char *)b;
for (size_t i = 0; i < n; ++i) {
if (x[i] != y[i]) return (int)x[i] - (int)y[i];
}
return 0;
}
IG_AINLINE void *ig_memcpy(void *dst, const void *src, size_t n) {
unsigned char *d = (unsigned char *)dst;
const unsigned char *s = (const unsigned char *)src;
for (size_t i = 0; i < n; ++i) d[i] = s[i];
return dst;
}
IG_AINLINE void *ig_memset(void *dst, int c, size_t n) {
unsigned char *d = (unsigned char *)dst;
for (size_t i = 0; i < n; ++i) d[i] = (unsigned char)c;
return dst;
}
IG_AINLINE int ig_strcmp(const char *a, const char *b) {
while (*a && (*a == *b)) { ++a; ++b; }
return (int)(unsigned char)*a - (int)(unsigned char)*b;
}
IG_AINLINE int ig_strncmp(const char *a, const char *b, size_t n) {
for (size_t i = 0; i < n; ++i) {
unsigned char ca = (unsigned char)a[i], cb = (unsigned char)b[i];
if (ca != cb) return (int)ca - (int)cb;
if (ca == 0) break;
}
return 0;
}
/* 朴素子串匹配,避免引用 libc strstr。 */
IG_AINLINE const char *ig_strstr(const char *hay, const char *needle) {
if (!needle[0]) return hay;
for (; *hay; ++hay) {
const char *h = hay, *n = needle;
while (*h && *n && (*h == *n)) { ++h; ++n; }
if (!*n) return hay;
}
return (const char *)0;
}
#endif /* IG_INLINE_H */
+40
View File
@@ -0,0 +1,40 @@
/*
* IGVisibility.h — 符号可见性控制(抗静态调用关系分析,§7 硬化)。
*
* 背景:静态库 .a 里所有全局函数默认都是导出符号(nm 显示 T),接入方链进 App 后,
* 若不 strip,_ig_poison_mark / _ig_poison_mask / _ig_policy_* 等**内部**符号名
* 会留在符号表,成为「nm 一把定位 → 找调用点 → NOP」的锚点。
*
* 策略:
* - 整个 defender 库用 -fvisibility=hidden 编译:默认所有符号隐藏(private extern)。
* - 只有接入方跨 bridging header 真正引用的入口用 IG_PUBLIC 显式导出:
* ig_defender_scan / ig_policy_scan_and_mark / ig_poison_init / ig_poison_apply。
* - 其余(mark/mask/sink/reset/evaluate/anti_jb_* 及各探针内部)保持 hidden,
* 最终 App 链接 + strip 后从符号表消失,nm 再也捞不到名字。
*
* 边界(如实声明):
* - 这不消除调用图的「边」(bl 仍在),只抹掉「节点的名字」——把定位成本从
* 「nm 一把」抬到「靠交叉引用 + 语义猜」。真正删边要靠内联(apply 揉进解密)
* 与间接化调用点,见 docs/18 §7。
* - 在 .a 阶段 hidden 符号仍可能以 private-extern 出现在**静态**符号表(nm 无 -g);
* 决定性的一步是最终镜像 strip。故接入方必须保持 Release 的 strip(见 docs/18 §7.0)。
*/
#ifndef IG_VISIBILITY_H
#define IG_VISIBILITY_H
#if defined(__GNUC__) || defined(__clang__)
#define IG_PUBLIC __attribute__((visibility("default")))
#define IG_INTERNAL __attribute__((visibility("hidden")))
/*
* IG_ALWAYS_INLINE:强制内联。用于「删调用图的边」——把毒化读取/应用的核心做成
* always_inline,接入方在解密 TU 内联后反汇编里不留 `bl ig_poison_*` 调用边可 NOP。
* 见 defender/poison/IGPoisonInline.h 与 docs/18 §7。
*/
#define IG_ALWAYS_INLINE static inline __attribute__((always_inline))
#else
#define IG_PUBLIC
#define IG_INTERNAL
#define IG_ALWAYS_INLINE static inline
#endif
#endif /* IG_VISIBILITY_H */
+65
View File
@@ -0,0 +1,65 @@
/*
* IGPoison.c — 毒化状态机实现。见 IGPoison.h 的设计与边界声明。
*
* 本文件只负责:① 定义跨 TU 共享的匿名状态存储 ig_pstate[];② 写入侧(init/mark,
* 由检测线程调用,不在解密热路径);③ out-of-line 公共入口 ig_poison_mask/apply。
* 读取/应用的**算术核心**(baseline / lane_k / spread / mask / apply)统一来自
* IGPoisonInline.h —— **单一真源**,库路径与接入方内联路径永不漂移。
*
* §7 硬化(已落地):
* - §7.4 基线运行期派生(见 IGPoisonInline.h ig_pbaseline_inline,不明文驻留)。
* - §7.2 匿名数组分散存储(无命名 section——命名 section 会留在 load command、strip 抹不掉,
* 等于挂牌毒化副本位置;见 IGPoisonInline.h 顶部说明)。
* - §7「断边」:apply/mask 核心做成 always_inline,接入方在解密 TU 内联后不留
* `bl ig_poison_*` 调用边;推荐用 ig_poison_mix_key_inline 把毒化揉进 key schedule。
*
* §7 硬化(仍 TODO,需额外工具链,见 docs/18 §7.3):
* - mark / mask / apply 用 OLLVM(Fla+BCF) + 常量加密盖住;预留 IG_OBFUSCATOR 钩子。
*/
#include "IGPoison.h"
#include "poison/IGPoisonInline.h"
/*
* §7.2 分散存储:一个看起来普通的匿名状态数组。跨 TU 共享(接入方内联 mask/apply 时直读),
* 故为非 static 的 hidden 全局(中性名、无 poison 字样,strip 后无符号名)。
* 进程级(非 TLS)——毒化态须跨线程一致:检测线程 mark 后解密线程读到的掩码必须同为非零,
* TLS 会各线程各看各的、破坏处置闭环,故**刻意不用 TLS**。下标/长度定义在 IGPoisonInline.h。
*/
volatile uint64_t ig_pstate[IG_PSTATE_N];
void ig_poison_init(void) {
uint64_t b = ig_pbaseline_inline();
/* 全数组都填成「健康值」表示 (b ^ lane_k(i)):真副本、诱饵、陪衬槽写法一致,
* 各槽值互不相同,静态看不出哪几槽是喂掩码的真副本。 */
for (unsigned i = 0; i < IG_PSTATE_N; ++i) {
ig_pstate[i] = b ^ ig_plane_k_inline(i);
}
}
/* 构造期兜底初始化(若宿主未显式调用 ig_poison_init)。 */
__attribute__((constructor))
static void ig_poison_ctor(void) { ig_poison_init(); }
void ig_poison_mark(uint64_t entropy) {
/* entropy 为 0 时仍强制非 0,避免“混入 0 = 不生效”。写入侧不内联:由检测线程调用,
* 不在解密热路径,无需删边。 */
uint64_t e = entropy ? entropy : 0xD1B54A32D192ED03ULL;
/* 三路真副本各自偏离健康值(任一偏离即令掩码非零);诱饵也动,混淆“哪几槽生效”。 */
ig_pstate[IG_PSTATE_L0] ^= ig_pspread_inline(e, 0);
ig_pstate[IG_PSTATE_DECOY] ^= ig_pspread_inline(e, 3);
ig_pstate[IG_PSTATE_L1] ^= ig_pspread_inline(e, 1);
ig_pstate[IG_PSTATE_L2] ^= ig_pspread_inline(e, 2);
}
/*
* out-of-line 公共入口:直接委托给单一真源的内联核心。
* 接入方若想删掉对这两个函数的调用边,改 #include "IGPoisonInline.h" 调用
* ig_poison_mask_inline / ig_poison_mix_key_inline(见 docs/18 §7)。
*/
uint64_t ig_poison_mask(void) {
return ig_poison_mask_inline();
}
void ig_poison_apply(const uint8_t *in, uint8_t *out, size_t n) {
ig_poison_apply_inline(in, out, n);
}
+63
View File
@@ -0,0 +1,63 @@
/*
* IGPoison.h — 毒化状态机(数据依赖处置,纯 C,可编入业务 target)。
*
* 设计核心(对应纯客户端反 Hook 的处置哲学):
* 不写 `if (越狱) exit()`。检测到强信号组合时,只把一段熵混进一个多副本冗余的
* “健康值”,把它破坏掉;之后由业务关键数据的**密钥派生**消费这个健康值——
* 健康 → 掩码为 0 → 密钥不变 → 解密正常;毒化 → 掩码非 0 → 密钥被扰动 → 解出乱码。
* 全程**没有可被 patch 的控制流分支**,攻击者 nop 不掉“判断”,因为判断不存在,
* 只有数据流污染。要绕过得逆向整条密钥推导 + 搞清健康值怎么混入,成本量级抬高。
*
* 天花板(如实声明):纯客户端无法根治。多副本 + 混淆 + VMP 只是把“找到并写回健康值”
* 从几分钟抬到几天;有耐心有能力的定向攻击者最终仍可破。安全锚点不在这。
*
* 处置形态(App Store 上架约束):只做数据污染 / 功能静默降级,不触发随机崩溃。
*
* 误报底线(极重要):处置是隐蔽且体验不可逆的,误伤一个非越狱正常用户=差评卸载且难排查。
* 因此 ig_poison_mark 只允许由**高置信强信号组合**触发(见 IGPoison.c 注释),
* 弱信号(FOREIGN_IMAGE / FRIDA_PORT 等)绝不参与。上线前必须在多机型验证非越狱零毒化。
*/
#ifndef IG_POISON_H
#define IG_POISON_H
#include <stdint.h>
#include <stddef.h>
#include "IGVisibility.h"
#ifdef __cplusplus
extern "C" {
#endif
/* 把多副本健康值置为基线。应在尽早的构造期调用一次(也有构造函数兜底)。 */
IG_PUBLIC void ig_poison_init(void);
/*
* 命中强信号组合时调用:把 entropy(必须非 0)混进所有健康值副本,使其偏离基线。
* 幂等累积——多次调用只会持续偏离,不会“洗白”。此函数只写状态,不产生任何可见后果。
*/
void ig_poison_mark(uint64_t entropy);
/*
* 返回处置掩码:健康=0,毒化=非 0(由多副本交叉推导,无分支)。
* 业务侧不直接判它,而是把它揉进密钥/偏移等数据,见 ig_poison_apply。
*/
uint64_t ig_poison_mask(void);
/*
* 数据依赖处置原语:把 in[0..n) 揉以当前掩码写入 out[0..n)(允许 in==out 原地)。
* 健康时 out 与 in 逐字节相等(掩码 0,异或 0);毒化时每字节被掩码扰动。
* 业务用法:对解密 key 的字节调用本函数后再传给解密器——健康照常、毒化解出乱码。
*
* 【断边】本函数是一条可被 NOP 的调用边(`bl ig_poison_apply`)。要删掉这条边,
* 接入方改 #include "IGPoisonInline.h",在解密 TU 内直接调用 always_inline 的
* ig_poison_mix_key_inline(key, n)——编译器把毒化揉进解密函数自身,反汇编里不留调用边,
* 且毒化落在 key schedule(比后置改输出更难摘)。两条路径共用同一真源,语义等价。见 docs/18 §7。
*/
IG_PUBLIC void ig_poison_apply(const uint8_t *in, uint8_t *out, size_t n);
#ifdef __cplusplus
}
#endif
#endif /* IG_POISON_H */
+107
View File
@@ -0,0 +1,107 @@
/*
* IGPoisonInline.h — 毒化「读取/应用」核心(always_inline,单一真源)。
*
* 为什么存在(docs/18 §7「断边」):
* 符号隐藏只抹掉节点名字,调用图的边(`bl ig_poison_apply` / `bl ig_poison_mask`)
* 仍在——攻击者靠交叉引用定位到这条边,NOP 掉调用、或把被调函数 stub 成恒等,毒化即失效。
* 本头把「读健康值 → 推掩码 → 扰动密钥」整段做成 always_inline:接入方(readoor 解密 TU)
* #include 后在密钥派生处调用 ig_poison_mix_key_inline(),编译器把这段揉进解密函数自身,
* 反汇编里**没有这条调用边**可 NOP,毒化藏进 key schedule,与真实密钥推导混在一起。
*
* 单一真源:库内 IGPoison.c 的 out-of-line 公共入口(ig_poison_mask/apply)也复用本头的
* core,baseline / lane_k / 下标只此一处定义,内联路径与库路径永不漂移。
*
* 跨 TU 唯一共享的是「数据」ig_pstate[](中性名匿名数组,hidden,最终 strip 后无符号名),
* 不是「调用边」——读它是 data 重定位,不是 call。即便漏 strip,名字也不含 poison 字样、不 telegraph。
*
* 注意:写入侧(init / mark)不在本头内联——它们由检测线程调用、不在解密热路径,
* 无需删边,留在 IGPoison.c。本头只内联**读取/应用**侧。
*/
#ifndef IG_POISON_INLINE_H
#define IG_POISON_INLINE_H
#include <stdint.h>
#include <stddef.h>
#include "IGVisibility.h"
#ifdef __cplusplus
extern "C" {
#endif
/* 匿名状态数组长度与真副本/诱饵下标(非相邻)。写入侧(IGPoison.c)须与此一致。 */
#define IG_PSTATE_N 12
#define IG_PSTATE_L0 2u
#define IG_PSTATE_L1 7u
#define IG_PSTATE_L2 11u
#define IG_PSTATE_DECOY 5u
/* 存储定义在 IGPoison.c。hidden + 中性名:最终 strip 后无符号名,漏 strip 也不 telegraph。 */
__attribute__((visibility("hidden")))
extern volatile uint64_t ig_pstate[IG_PSTATE_N];
/* 基线运行期派生(与 IGPoison.c 删除的 IG_POISON_BASELINE 魔数等价,但不明文驻留)。 */
IG_ALWAYS_INLINE uint64_t ig_pbaseline_inline(void) {
volatile uint64_t seed = 0x243F6A88ULL; /* 分片种子,非最终值 */
uint64_t x = (uint64_t)seed;
x ^= 0x85A308D3ULL;
x *= 0xFF51AFD7ED558CCDULL;
x ^= x >> 33;
x += 0x2545F4914F6CDD1DULL;
x ^= x >> 29;
return x | 1ULL; /* 保证非零 */
}
/* per-槽掩码常量:使各槽健康值互不相同,消除「数组里几个相同的字=一组健康值」的 tell。 */
IG_ALWAYS_INLINE uint64_t ig_plane_k_inline(unsigned i) {
return 0x9E3779B97F4A7C15ULL * (uint64_t)(i * 2u + 1u);
}
/* 把 entropy 扩散成每路互不相同、必非 0 的偏移(写入侧用;放这里供单一真源)。 */
IG_ALWAYS_INLINE uint64_t ig_pspread_inline(uint64_t e, unsigned lane) {
e ^= 0x9E3779B97F4A7C15ULL * (lane + 1u);
e ^= e >> 30; e *= 0xBF58476D1CE4E5B9ULL;
e ^= e >> 27; e *= 0x94D049BB133111EBULL;
e ^= e >> 31;
return e | 1ULL;
}
/*
* 掩码核心:健康=0,毒化=非 0,无分支。只读三真副本(诱饵/陪衬槽不读)。
* 健康态每真副本存 (baseline ^ lane_k(i)),解回 ^lane_k ^baseline == 0。
*/
IG_ALWAYS_INLINE uint64_t ig_poison_mask_inline(void) {
uint64_t b = ig_pbaseline_inline();
return (ig_pstate[IG_PSTATE_L0] ^ ig_plane_k_inline(IG_PSTATE_L0) ^ b)
| (ig_pstate[IG_PSTATE_L1] ^ ig_plane_k_inline(IG_PSTATE_L1) ^ b)
| (ig_pstate[IG_PSTATE_L2] ^ ig_plane_k_inline(IG_PSTATE_L2) ^ b);
}
/*
* 应用核心(等价 ig_poison_apply):健康 out==in(异或 0),毒化逐字节被掩码扰动。
* 允许 in==out 原地。
*/
IG_ALWAYS_INLINE void ig_poison_apply_inline(const uint8_t *in, uint8_t *out, size_t n) {
if (!in || !out) return;
uint64_t m = ig_poison_mask_inline();
for (size_t i = 0; i < n; ++i) {
uint8_t d = (uint8_t)((m >> ((i & 7u) * 8u)) & 0xFFu);
out[i] = (uint8_t)(in[i] ^ d);
}
}
/*
* 推荐接入形态:把掩码揉进密钥字节(原地)。健康 → 密钥不变 → 解密正常;
* 毒化 → 密钥被扰动 → 解出乱码。比后置改输出更难摘:毒化落在 key schedule,
* 攻击者要在不破坏正常解密的前提下摘掉它,得先逆清整条密钥推导。
* 用法:在解密 TU 取得明文密钥后、喂给解密器前,对 key 调用一次。
*/
IG_ALWAYS_INLINE void ig_poison_mix_key_inline(uint8_t *key, size_t n) {
ig_poison_apply_inline(key, key, n);
}
#ifdef __cplusplus
}
#endif
#endif /* IG_POISON_INLINE_H */
+99
View File
@@ -0,0 +1,99 @@
/*
* IGPolicy.c — 策略层实现。见 .h 的分级与误报底线。
*/
#include "IGPolicy.h"
#include "poison/IGPoison.h"
typedef enum { IG_TIER_IGNORE = 0, IG_TIER_WEAK, IG_TIER_MEDIUM, IG_TIER_STRONG } IGTier;
/* reason → 档位。未列出的 DETECTED 按 WEAK 处理(保守,不触发毒化)。 */
static IGTier ig_reason_tier(int reason) {
switch (reason) {
/* STRONG:单条即可判定(误报概率极低) */
case IG_REASON_JAILBREAK_SANDBOX: /* 401 沙盒逃逸 */
case IG_REASON_JAILBREAK_FILE: /* 400 越狱特征文件 */
case IG_REASON_GOT_REBIND: /* 102 */
case IG_REASON_INLINE_HOOK: /* 101 */
case IG_REASON_INJECTED_IMAGE: /* 200 */
case IG_REASON_DEBUGGER_ATTACHED: /* 300 */
return IG_TIER_STRONG;
/* MEDIUM:需组合(含合法 swizzling 会误报的 ObjC IMP) */
case IG_REASON_SYMBOL_PROVENANCE: /* 100 */
case IG_REASON_OBJC_IMP_CHANGED: /* 110 */
case IG_REASON_FRIDA_THREAD: /* 203 */
return IG_TIER_MEDIUM;
/* WEAK:仅观察,永不触发毒化 */
case IG_REASON_FOREIGN_IMAGE: /* 201 */
case IG_REASON_FRIDA_PORT: /* 204 */
return IG_TIER_WEAK;
default:
return IG_TIER_WEAK;
}
}
void ig_policy_reset(IGPolicyState *st, IGFindingSink observer, void *observer_ctx) {
if (!st) return;
st->strong_count = 0;
st->medium_bitmap = 0;
st->medium_distinct = 0;
st->entropy = 0;
st->detected_total = 0;
st->observer = observer;
st->observer_ctx = observer_ctx;
}
/* 把 reason 映射到 medium_bitmap 的一个位(三个 MEDIUM reason 分别占位)。 */
static uint32_t ig_medium_bit(int reason) {
switch (reason) {
case IG_REASON_SYMBOL_PROVENANCE: return 1u << 0;
case IG_REASON_OBJC_IMP_CHANGED: return 1u << 1;
case IG_REASON_FRIDA_THREAD: return 1u << 2;
default: return 0u;
}
}
int ig_policy_sink(const IGFinding *f, void *ctx) {
IGPolicyState *st = (IGPolicyState *)ctx;
if (!st || !f) return 0;
/* 先转发观察打点(无论档位),便于量化误报面。 */
if (st->observer) st->observer(f, st->observer_ctx);
/* 误报底线:只有 DETECTED 参与判定;UNAVAILABLE/CLEAR 忽略。 */
if (f->status != IG_DETECTED) return 0;
st->detected_total++;
IGTier tier = ig_reason_tier(f->reason);
if (tier == IG_TIER_STRONG) {
st->strong_count++;
st->entropy ^= 0x100000001b3ULL * (uint64_t)(f->reason + 1);
} else if (tier == IG_TIER_MEDIUM) {
uint32_t bit = ig_medium_bit(f->reason);
if (bit && !(st->medium_bitmap & bit)) {
st->medium_bitmap |= bit;
st->medium_distinct++;
}
st->entropy ^= 0x100000001b3ULL * (uint64_t)(f->reason + 1);
}
/* WEAK/IGNORE:不计入判定,也不进熵。 */
return 0;
}
int ig_policy_evaluate_and_mark(IGPolicyState *st) {
if (!st) return 0;
int trigger = (st->strong_count >= 1) || (st->medium_distinct >= 2);
if (trigger) {
uint64_t e = st->entropy ? st->entropy : 0xA24BAED4963EE407ULL;
ig_poison_mark(e);
return 1;
}
return 0;
}
int ig_policy_scan_and_mark(const char *bundle_path, int probe_port,
IGFindingSink observer, void *observer_ctx) {
IGPolicyState st;
ig_policy_reset(&st, observer, observer_ctx);
ig_defender_scan(bundle_path, probe_port, ig_policy_sink, &st);
return ig_policy_evaluate_and_mark(&st);
}
+59
View File
@@ -0,0 +1,59 @@
/*
* IGPolicy.h — 策略层:把探针证据按强弱分级,组合判定后决定是否毒化(ig_poison_mark)。
*
* 连接 [[iosguard-disposition-strategy]]:ig_defender_scan 流式上报 IGFinding,本层做 sink,
* 累积一次扫描的全部 DETECTED 证据;扫描结束后 evaluate 按组合规则决定是否触发毒化。
*
* 误报底线(最重要):毒化隐蔽且不可逆,误伤非越狱正常用户=差评卸载难排查。故:
* - 只有 DETECTED 参与;UNAVAILABLE(架构/平台不支持)与 CLEAR 一律忽略,绝不当攻击。
* - 信号分三档:
* STRONG(单条即判定):越狱文件/沙盒逃逸、GOT 重绑、inline hook、注入镜像、调试器跟踪。
* MEDIUM(需 ≥2 个不同 MEDIUM,或与任一 STRONG 同现才判定):符号提供方、ObjC IMP 变化、
* frida 线程——其中 ObjC IMP 合法 swizzling 会误报,故不单条定罪。
* WEAK(永不触发毒化,仅观察):Bundle 外镜像、frida 端口等弱证据。
*
* 本层不自行 exit;唯一处置是数据依赖毒化。可选把 finding 转发给观察打点(observer)。
*/
#ifndef IG_POLICY_H
#define IG_POLICY_H
#include "IGDefender.h"
#ifdef __cplusplus
extern "C" {
#endif
typedef struct {
int strong_count; /* STRONG 档命中条数 */
uint32_t medium_bitmap; /* MEDIUM 档已命中的不同 reason(去重用) */
int medium_distinct; /* MEDIUM 档不同 reason 数 */
uint64_t entropy; /* 命中 reason 聚合出的毒化熵(非 0) */
int detected_total; /* 累计 DETECTED 条数(观察用) */
IGFindingSink observer; /* 可选:每条 finding 透传给它做打点;NULL 跳过 */
void *observer_ctx; /* observer 的上下文 */
} IGPolicyState;
/* 重置状态;observer/observer_ctx 可传 NULL。 */
void ig_policy_reset(IGPolicyState *st, IGFindingSink observer, void *observer_ctx);
/* 作为 ig_defender_scan 的 sink:ctx 必须是 IGPolicyState*。只累积、不处置。 */
int ig_policy_sink(const IGFinding *finding, void *ctx);
/*
* 扫描结束后调用:按组合规则判定。满足即 ig_poison_mark(entropy) 并返回 1;否则返回 0。
* 规则:strong_count>=1 || medium_distinct>=2。
*/
int ig_policy_evaluate_and_mark(IGPolicyState *st);
/*
* 便捷封装:reset → ig_defender_scan → evaluate_and_mark 一次完成。
* 返回 1 表示本次触发了毒化。observer/observer_ctx 可 NULL。
*/
IG_PUBLIC int ig_policy_scan_and_mark(const char *bundle_path, int probe_port,
IGFindingSink observer, void *observer_ctx);
#ifdef __cplusplus
}
#endif
#endif /* IG_POLICY_H */
+75
View File
@@ -0,0 +1,75 @@
/*
* IGInline.h — 强制内联的自实现 str/mem 原语(落地方案第一优先级)。
*
* 目的:核心校验/鉴权/加解密逻辑里避免直接调用 strcmp/memcmp/memcpy/strstr/getenv 等
* 被攻击者重点监控的 libc 函数——这些调用会在 __la_symbol_ptr/__got 留下符号引用,
* 既是 Fishhook rebind 的靶点,也是静态分析的锚点。
*
* 本头提供 __attribute__((always_inline)) 版本:使用处直接展开为离散汇编指令,
* 不生成 bl 跳转、不产生导入表项,从而从导入表中抹除这些符号。
*
* 用法:在安全逻辑中用 ig_memcmp/ig_strcmp/... 替换 libc 同名函数。纯头文件,零依赖。
* 注意:这是“隐藏特征”,非“更安全的实现”——不做常量时间比较;需防时序侧信道时另行处理。
*/
#ifndef IG_INLINE_H
#define IG_INLINE_H
#include <stddef.h>
#include <stdint.h>
#define IG_AINLINE static inline __attribute__((always_inline))
IG_AINLINE size_t ig_strlen(const char *s) {
const char *p = s;
while (*p) ++p;
return (size_t)(p - s);
}
IG_AINLINE int ig_memcmp(const void *a, const void *b, size_t n) {
const unsigned char *x = (const unsigned char *)a;
const unsigned char *y = (const unsigned char *)b;
for (size_t i = 0; i < n; ++i) {
if (x[i] != y[i]) return (int)x[i] - (int)y[i];
}
return 0;
}
IG_AINLINE void *ig_memcpy(void *dst, const void *src, size_t n) {
unsigned char *d = (unsigned char *)dst;
const unsigned char *s = (const unsigned char *)src;
for (size_t i = 0; i < n; ++i) d[i] = s[i];
return dst;
}
IG_AINLINE void *ig_memset(void *dst, int c, size_t n) {
unsigned char *d = (unsigned char *)dst;
for (size_t i = 0; i < n; ++i) d[i] = (unsigned char)c;
return dst;
}
IG_AINLINE int ig_strcmp(const char *a, const char *b) {
while (*a && (*a == *b)) { ++a; ++b; }
return (int)(unsigned char)*a - (int)(unsigned char)*b;
}
IG_AINLINE int ig_strncmp(const char *a, const char *b, size_t n) {
for (size_t i = 0; i < n; ++i) {
unsigned char ca = (unsigned char)a[i], cb = (unsigned char)b[i];
if (ca != cb) return (int)ca - (int)cb;
if (ca == 0) break;
}
return 0;
}
/* 朴素子串匹配,避免引用 libc strstr。 */
IG_AINLINE const char *ig_strstr(const char *hay, const char *needle) {
if (!needle[0]) return hay;
for (; *hay; ++hay) {
const char *h = hay, *n = needle;
while (*h && *n && (*h == *n)) { ++h; ++n; }
if (!*n) return hay;
}
return (const char *)0;
}
#endif /* IG_INLINE_H */
+76
View File
@@ -0,0 +1,76 @@
/*
* IGResolve.c — 加密名 + 带校验的符号解析实现。
*
* 复用 IGAntiHook 的 ig_verify_function 做「放行前校验」:dlsym 得到地址后,必须 provenance
* (提供方系统路径)+ 序言(非 inline-hook 蹦床)双过,否则返回 NULL——把「被挟持的实现」挡在调用前。
*/
#include "IGResolve.h"
#include "../anti_hook/IGAntiHook.h"
#include "../primitives/IGInline.h"
#include <dlfcn.h>
#include <crt_externs.h> /* _NSGetEnviron */
char *ig_decrypt(const unsigned char *enc, size_t len, char *out, size_t cap) {
if (!out || cap==0) return NULL;
out[0]='\0';
if (!enc || len==0 || len>=cap) return NULL;
for (size_t i = 0; i < len; ++i) {
out[i] = (char)(enc[i] ^ IG_ENC_KEY);
if (out[i]=='\0') { ig_wipe(out,cap); return NULL; }
}
out[len] = '\0';
return out;
}
void ig_wipe(void *p, size_t n) {
if (!p) return;
volatile unsigned char *v = (volatile unsigned char *)p;
while (n--) *v++ = 0; /* volatile:防编译器把清零 DCE 掉 */
}
IGResolveResult ig_resolve_verified(void *handle, const unsigned char *enc_name, size_t sym_len,
IGFindingSink sink, void *ctx) {
char name[256];
IGResolveResult result={IG_UNAVAILABLE,NULL};
if (!ig_decrypt(enc_name, sym_len, name, sizeof(name))) return result;
void *addr = dlsym(handle ? handle : RTLD_DEFAULT, name);
if (addr) {
/* 放行前校验:provenance + inline-hook。不过即判被挟持,返回 NULL。 */
result.status=ig_verify_function(addr,name,sink,ctx);
if (result.status==IG_CLEAR) result.address=addr;
} else if (sink) {
IGFinding f={0};
f.status=IG_UNAVAILABLE; f.reason=IG_REASON_SYMBOL_UNRESOLVED;
sink(&f,ctx);
}
ig_wipe(name, sizeof(name)); /* 明文符号名用后清零,不驻留栈 */
return result;
}
void *ig_dlsym_verified(void *handle, const unsigned char *enc_name, size_t sym_len) {
return ig_resolve_verified(handle,enc_name,sym_len,NULL,NULL).address;
}
void *ig_dlopen_hidden(const unsigned char *enc_path, size_t path_len, int mode) {
char path[512];
if (!ig_decrypt(enc_path, path_len, path, sizeof(path))) return NULL;
void *h = dlopen(path, mode);
ig_wipe(path, sizeof(path));
return h;
}
const char *ig_getenv(const char *name) {
char ***environment = _NSGetEnviron();
if (!environment || !*environment || !name || !name[0]) return NULL;
char *const *envp = *environment;
size_t nlen = ig_strlen(name);
for (; *envp; ++envp) {
const char *e = *envp;
/* 匹配 "name=" 前缀 */
if (ig_strncmp(e, name, nlen) == 0 && e[nlen] == '=') {
return e + nlen + 1;
}
}
return NULL;
}
+61
View File
@@ -0,0 +1,61 @@
/*
* IGResolve.h — 加密名 + 带校验的自定义符号解析(落地方案第二优先级)。
*
* 问题:核心逻辑直接 dlopen("…")/dlsym(h,"…") 会在 __cstring 留下明文库名/符号名,
* 既暴露意图(攻击者 grep 字符串即知你在找什么),__got 里的 dlopen/dlsym 本身也是 hook 靶点。
*
* 本模块:
* 1) 编译期 XOR 混淆字符串(IG_ENC 宏),运行期在**栈上**解密、用完即清零,明文不驻留常量区。
* 2) 解析后**校验再放行**:dladdr 确认提供方在系统路径白名单内 + 校验函数序言首字节不是
* inline-hook 蹦床(B / LDR-literal+BR x16/x17),命中则返回 NULL(视作被挟持,拒绝使用)。
* 3) ig_getenv 经 _NSGetEnviron 手工遍历,规避对 getenv 的 hook/特征。
*
* 边界:dlopen/dlsym 本身仍会被解析/调用(仅隐藏其**参数**与**对结果验真**);若需连 dlsym 调用
* 也抹除,改走 Export Trie 手工遍历(本头预留 ig_resolve_in_image,当前实现以 dlsym 为主路径)。
* 字符串混淆是“抬高静态分析成本”,非加密强度;密钥在二进制内,决心足够者可还原——与 svc 号混淆同理。
*/
#ifndef IG_RESOLVE_H
#define IG_RESOLVE_H
#include <stddef.h>
#include <stdint.h>
#include "../include/IGDefender.h"
#ifdef __cplusplus
extern "C" {
#endif
/* 单字节 XOR 密钥(与 IGSyscall 的掩码独立)。 */
#define IG_ENC_KEY 0x3Cu
/*
* 栈上解密:把 enc(已 XOR)解到调用方缓冲 out(容量 cap),返回 out。
* 用完务必 ig_wipe 清零,避免解密后的明文在栈/寄存器残留被 dump。
*/
char *ig_decrypt(const unsigned char *enc, size_t len, char *out, size_t cap);
void ig_wipe(void *p, size_t n);
/*
* 带校验的 dlsym:在 handle(NULL=RTLD_DEFAULT)中解析名为 enc_name(XOR 编码) 的符号,
* 成功后对结果做 provenance + 序言校验;任一不过返回 NULL。sym_len 为编码串长度(不含结尾)。
*/
void *ig_dlsym_verified(void *handle, const unsigned char *enc_name, size_t sym_len);
typedef struct { IGStatus status; void *address; } IGResolveResult;
IGResolveResult ig_resolve_verified(void *handle, const unsigned char *enc_name, size_t sym_len,
IGFindingSink sink, void *ctx);
/*
* 带隐藏名的 dlopen:以 enc_path(XOR 编码) 打开库,返回 handle 或 NULL。
* 仅隐藏库路径字符串;是否可信由后续 ig_dlsym_verified 的校验保证。
*/
void *ig_dlopen_hidden(const unsigned char *enc_path, size_t path_len, int mode);
/* 经 _NSGetEnviron 手工查环境变量,规避 getenv 符号。未命中返回 NULL。name 为明文(短、非敏感)。 */
const char *ig_getenv(const char *name);
#ifdef __cplusplus
}
#endif
#endif /* IG_RESOLVE_H */
+143
View File
@@ -0,0 +1,143 @@
/*
* IGSyscall.c — ARM64 混淆直发系统调用实现。
*
* ABI(本会话真机/宿主实测):调用号入 x16(arm64 BSD 调用**不加** 0x2000000 掩码,那是 x86_64 的
* class 位);参数 x0..x5;`svc #0x80`;返回值在 x0,出错时 carry 置位、x0=errno。
* 本封装对出错统一返回 -errno,便于调用方判负。
*/
#include "IGSyscall.h"
/* 运行期密钥,volatile 防止编译器把 enc^key 折叠回明文立即数。构造函数置值,提供默认兜底。 */
volatile long ig_sc_key = IG_SC_CMASK;
__attribute__((constructor))
static void ig_sc_init(void) {
/* 显式再置一次:即使该 TU 的 constructor 被裁剪,静态初值也保证正确。 */
ig_sc_key = IG_SC_CMASK;
}
#if defined(__aarch64__)
/*
* 直发核心。真实调用号 = enc_num ^ ig_sc_key,在运行期于寄存器内还原后载入 x16,
* 二进制里既无 `movz x16,#<真实号>` 立即数,也无该号的明文常量。
* carry 置位(出错)时返回 -x0(errno),否则返回 x0。
*/
long ig_syscall6(long enc_num, long a0, long a1, long a2, long a3, long a4, long a5) {
register long x16 __asm__("x16") = enc_num ^ ig_sc_key;
register long x0 __asm__("x0") = a0;
register long x1 __asm__("x1") = a1;
register long x2 __asm__("x2") = a2;
register long x3 __asm__("x3") = a3;
register long x4 __asm__("x4") = a4;
register long x5 __asm__("x5") = a5;
register long cc __asm__("x8"); /* 承接 carry 标志 */
__asm__ __volatile__(
"svc #0x80\n"
"cset %[cc], cs\n" /* carry set → 出错 */
: "+r"(x0), [cc] "=r"(cc)
: "r"(x16), "r"(x1), "r"(x2), "r"(x3), "r"(x4), "r"(x5)
: "cc", "memory");
return cc ? -x0 : x0;
}
#else
/* 非 arm64(宿主自测可能是 x86_64):退化为 unavailable 语义,返回 -1。 */
long ig_syscall6(long enc_num, long a0, long a1, long a2, long a3, long a4, long a5) {
(void)enc_num; (void)a0; (void)a1; (void)a2; (void)a3; (void)a4; (void)a5;
return -1;
}
#endif
/* BSD 调用号(arm64,无 class 掩码)。本会话实测:getpid=20、write=4 已验证。 */
#define IG_NR_EXIT 1
#define IG_NR_READ 3
#define IG_NR_WRITE 4
#define IG_NR_OPEN 5
#define IG_NR_CLOSE 6
#define IG_NR_UNLINK 10
#define IG_NR_GETPID 20
#define IG_NR_ACCESS 33
#define IG_NR_SYSCTL 202
int ig_sys_getpid(void) {
return (int)ig_syscall6(IG_SC(IG_NR_GETPID), 0, 0, 0, 0, 0, 0);
}
long ig_sys_write(int fd, const void *buf, size_t n) {
return ig_syscall6(IG_SC(IG_NR_WRITE), (long)fd, (long)buf, (long)n, 0, 0, 0);
}
long ig_sys_read(int fd, void *buf, size_t n) {
return ig_syscall6(IG_SC(IG_NR_READ), (long)fd, (long)buf, (long)n, 0, 0, 0);
}
int ig_sys_open(const char *path, int flags, int mode) {
return (int)ig_syscall6(IG_SC(IG_NR_OPEN), (long)path, (long)flags, (long)mode, 0, 0, 0);
}
int ig_sys_close(int fd) {
return (int)ig_syscall6(IG_SC(IG_NR_CLOSE), (long)fd, 0, 0, 0, 0, 0);
}
int ig_sys_access(const char *path, int amode) {
return (int)ig_syscall6(IG_SC(IG_NR_ACCESS), (long)path, (long)amode, 0, 0, 0, 0);
}
int ig_sys_unlink(const char *path) {
return (int)ig_syscall6(IG_SC(IG_NR_UNLINK), (long)path, 0, 0, 0, 0, 0);
}
void ig_sys_exit(int code) {
ig_syscall6(IG_SC(IG_NR_EXIT), (long)code, 0, 0, 0, 0, 0);
for (;;) { } /* 不返回 */
}
/*
* 调试器检测:sysctl(mib={CTL_KERN,KERN_PROC,KERN_PROC_PID,pid}) 读 kinfo_proc.kp_proc.p_flag,
* P_TRACED(0x800) 置位即被调试。直发 svc,不经 libc 的 sysctl(避开对其的 hook)。
* 为避免依赖 <sys/sysctl.h>/<sys/proc.h> 的完整布局,这里用常量与偏移手工构造。
*/
#define IG_CTL_KERN 1
#define IG_KERN_PROC 14
#define IG_KERN_PROC_PID 1
#define IG_P_TRACED 0x00000800
int ig_sys_is_debugged(void) {
#if defined(__aarch64__)
/*
* struct kinfo_proc 在 arm64 iOS/macOS 上,kp_proc.p_flag 为结构体起始处的第一个 int(偏移 0)。
* 该布局自 BSD 以来稳定:extern_proc 以 p_un(union,8B) 起,随后 p_flag。为稳妥,取足够大的缓冲,
* 并从 p_flag 的已知偏移读取。extern_proc:前 8B 为 union 指针/ru,接着 struct timeval(16B? ) —
* 不同平台有差异,故用保守做法:定位 p_flag 偏移为 extern_proc 内 0x10。
*/
unsigned char buf[648]; /* sizeof(struct kinfo_proc)==648(本机 offsetof 实测) */
for (size_t i = 0; i < sizeof(buf); ++i) buf[i] = 0;
int mib[4];
mib[0] = IG_CTL_KERN;
mib[1] = IG_KERN_PROC;
mib[2] = IG_KERN_PROC_PID;
mib[3] = ig_sys_getpid();
size_t len = sizeof(buf);
/* sysctl(name, namelen, oldp, oldlenp, newp, newlen) */
long r = ig_syscall6(IG_SC(IG_NR_SYSCTL), (long)mib, 4, (long)buf, (long)&len, 0, 0);
if (r < 0) return -1; /* unavailable */
/*
* p_flag 在 kinfo_proc 内的字节偏移:kp_proc 位于 kinfo_proc 偏移 0,extern_proc.p_flag 偏移 32——
* 两者均由本机 `offsetof(struct kinfo_proc, kp_proc)==0` + `offsetof(struct extern_proc, p_flag)==32`
* 实测得到(见 scratchpad/off.c)。故 p_flag 偏移 = 0x20。LP64 ABI 稳定。
*/
int p_flag;
const unsigned char *pf = buf + 0x20;
p_flag = (int)((unsigned)pf[0] | ((unsigned)pf[1] << 8) |
((unsigned)pf[2] << 16) | ((unsigned)pf[3] << 24));
return (p_flag & IG_P_TRACED) ? 1 : 0;
#else
return -1;
#endif
}
+61
View File
@@ -0,0 +1,61 @@
/*
* IGSyscall.h — ARM64 混淆直发系统调用(落地方案第一优先级)。
*
* 文件/进程/安全类系统调用若经 libsystem_kernel.dylib 走,libSystem 的函数入口可被 inline hook、
* __got 槽可被 fishhook 重绑定。本模块用内联汇编 `svc #0x80` 直接进内核,绕过 C 库封装层——
* 那条可被 hook 的 libSystem 入口在这条路径上根本不存在。
*
* 反静态特征:IDA 等常搜索 `svc #0x80` 并读 x16 的立即数识别调用号。本模块不把真实调用号写成
* `movz x16,#n` 立即数,而是调用方传入 XOR 编码值(IG_SC 宏),运行期与 ig_sc_key 异或还原后
* 由寄存器载入 x16,使静态扫描读不到真实号。
*
* 边界(如实声明,与 docs/05 §2 一致):
* - 仅 arm64。直发系统调用绕过 libSystem,跨 iOS 版本的调用号/ABI 稳定性由调用方负责;
* Apple 审核对直发 svc 可能关注,非 App Store 主线,用于确需防 hook 的关键路径。
* - 错误语义:返回值 <0 不自动转 errno;错误时内核置 carry、x0=errno,本封装统一返回 -errno。
* - 变参/取消点/EINTR 等 libc 语义不代为处理,调用方按需补。
*/
#ifndef IG_SYSCALL_H
#define IG_SYSCALL_H
#include <stdint.h>
#include <stddef.h>
#ifdef __cplusplus
extern "C" {
#endif
/* 编译期 XOR 编码掩码:调用方用 IG_SC(真实号) 传参,真实号不以明文/立即数进入二进制。 */
#define IG_SC_CMASK 0x5Al
#define IG_SC(n) ((long)((long)(n) ^ IG_SC_CMASK))
/* 运行期密钥(构造函数置为 IG_SC_CMASK,经 volatile 存取避免被常量折叠回立即数)。 */
extern volatile long ig_sc_key;
/*
* 通用直发。enc_num:IG_SC(真实调用号)。a0..a5:参数(不足补 0)。
* 成功返回内核结果(x0);失败返回 -errno。
*/
long ig_syscall6(long enc_num, long a0, long a1, long a2, long a3, long a4, long a5);
/* 常用封装(均走 ig_syscall6,调用号经 IG_SC 编码)。 */
int ig_sys_getpid(void);
long ig_sys_write(int fd, const void *buf, size_t n);
long ig_sys_read(int fd, void *buf, size_t n);
int ig_sys_open(const char *path, int flags, int mode);
int ig_sys_close(int fd);
int ig_sys_access(const char *path, int amode); /* 直发 access(2);0=可访问,<0=-errno */
int ig_sys_unlink(const char *path); /* 直发 unlink(2);0=成功,<0=-errno */
void ig_sys_exit(int code) __attribute__((noreturn));
/*
* 调试器检测:直发 sysctl(KERN_PROC/KERN_PROC_PID) 读 kinfo_proc.p_flag & P_TRACED。
* 返回 1=被跟踪,0=未跟踪,-1=unavailable(sysctl 失败)。不经 libc,规避对 sysctl 的 hook。
*/
int ig_sys_is_debugged(void);
#ifdef __cplusplus
}
#endif
#endif /* IG_SYSCALL_H */
@@ -0,0 +1,190 @@
# readoor 漏洞报告分析与 iOSGuard 加固实施方案
日期:2026-11-10。状态:分析与实施设计,尚未实施修复、接入或完成检测机构复测。
后续进展:已实现独立的 [静态 SDK fopen 重定向 PoC](06_STATIC_SDK_FOPEN_POC.md),并验证讯飞 SDK 副本的符号改写与可重定位链接。[通用重定向工具](07_GENERIC_STATIC_SDK_REDIRECT.md)与 [readoor31 ZipZap 构建试点](08_ZIPZAP_PILOT_BUILD_VERIFICATION.md) 已完成;整改方向结论(检测器判定标准、链接后 Mach-O 改写器选型、升级阶梯)见 [09](09_ECNUP_REMEDIATION_DIRECTION.md)。下文保留最初分析记录;readoor 正式接入、真机业务回归和检测机构复测仍未完成。
## 1. 目标与核查边界
iOSGuard 的首要目标是为 iOS 项目提供反 Hook 与 App 加固能力,并对指定安全报告形成可追踪的整改闭环。readoor 是首个验证项目。本轮仅分析报告、核查代码、制定实施方案,不修改 readoor 源码、工程、依赖或签名产物。
核查输入:
- 报告:`/Users/shenlei/Desktop/1.docx`,通过 DOCX 内的 Word XML 提取文本、表格内容;本轮未进行页面视觉核查。
- iOSGuard:`/Users/shenlei/Work/ReadBook/iOSGuard`,HEAD `ff0aee7`。
- readoor:`/Users/shenlei/Work/ReadBook/readoor`,HEAD `d640290a`,存在用户未提交修改,分析基于当前工作区。
- `AutoPacking/config.json` 中配置 `306` 的名称、Bundle ID 与报告相符。仍需核对当时实际使用的 scheme、target、编译宏、依赖版本及归档产物。
本轮未获得报告对应的原始 IPA、同次构建 dSYM、Link Map 和完整检测规则;在 readoor 的 `build/`、`AutoPacking/` 中未找到 IPA。当前源码与 2026-10-22 被测二进制不能直接视为同一版本。报告中的匿名地址暂不归因到具体源码或 SDK。
本轮尝试在线核验 Apple 与 Clang 官方资料,但检索工具未返回内容。涉及平台 API 可用性、分发政策的实施结论,需在落地时结合目标 SDK 与官方资料再核验;本方案不作上架保证。文中的源码结论以本地证据为依据。
## 2. 报告实际说明了什么
| 字段 | 报告原文信息 |
| --- | --- |
| 应用 | ECNUP外语 |
| 版本 / Bundle ID | `2.197.2` / `com.ecnup.azZVz02` |
| 文件 | `ECNUP外语_2.197.2_AppOnly.ipa` |
| MD5 | `83daa763da5a226b914201d3e31f969e` |
| 检测日期 / 引擎 | `2026-10-22` / `V4.6.6` |
| 报告所列 SDK / 最低系统 | iOS 26.5 / iOS 15.0,尚未用 IPA 核验 |
| 风险 | 外部函数显式调用风险、系统调用暴露风险检测,均被机构标为高危 |
报告汇总写有 7 个检测项目、2 个风险项目,正文只提供这 2 项详情;不能据此推断另外 5 项的具体内容或防护状态。两项各展示 50 条记录,无法确认是否为完整清单或展示上限。
按报告中“调用方描述 + 被调符号”去重后的统计:
| 检测项 | 展示记录 | 去重描述 | 符号分布(按展示记录计数) |
| --- | ---: | ---: | --- |
| 外部函数显式调用 | 50 | 39 | `_dlopen` 1、`_dlsym` 17、`_fopen` 32 |
| 系统调用暴露 | 50 | 47 | `_syscall` 2、`_exit` 23、`_fork` 1、`_read` 2、`_write` 14、`_open` 2、`_close` 1、`_unlink` 4、`_getpid` 1 |
例如 `#0x1013372b4 -> _dlsym` 重复 10 次。去重描述数不等于唯一机器指令数:报告可能以函数入口或内部分析节点表示地址,需向检测机构确认。
报告证据是静态调用关系,未给出成功 Hook、窃取数据或绕过支付权限的动态复现。保留机构原始评级用于整改管理,同时把“可见调用关系”“防护缺口”“已复现攻击”分别记录。
### 对报告修复建议的评估
1. **函数指针 + `optnone`**:可以作为小范围调用隐藏试点,必须检查 Release 机器码和检测机构复测结果。不能直接据此宣称反 Hook 完成。
2. **用 `dlsym` 替换全部调用**:本报告本身命中 `_dlsym`,全局替换可能转移或增加命中;首期不采用这种通用处理。
3. **把 libc 调用改为 SVC 裸系统调用**:不作为 App Store 主线方案。报告示例涉及私有调用、固定系统调用号,且出现 `PT_DENT_ATTACH` 拼写;不能作为可直接复制的工程实现。文件操作还需要保持错误码、取消、变参等语义。
4. **统一包装函数**:只在包装层内部再次直接调用目标函数,可能使扫描命中位置迁移;扫描全 App 时不保证消除命中。
5. **注入一个 Defender 库**:可以增加运行时检测,但不会自动改写原主程序及静态链接 SDK 内的现存调用点。
### 本机编译验证
环境:Xcode 27.1,Build `27A9275`;iPhoneOS SDK 27.1;目标 ARM64、iOS 15.0。使用显式声明的 `getenv` 做最小实验,不依赖 App 业务代码。
```c
extern char *getenv(const char *);
char *direct_call(const char *name) { return getenv(name); }
char *pointer_optimized(const char *name) {
char *(*fn)(const char *) = getenv;
return fn(name);
}
__attribute__((optnone, noinline))
char *pointer_optnone(const char *name) {
char *(*fn)(const char *) = getenv;
return fn(name);
}
```
复现命令(先将以上源码保存为 `call_probe.c`):
```sh
xcrun --sdk iphoneos clang -target arm64-apple-ios15.0 -O2 -S call_probe.c -o call_probe.s
```
观察结果:前两者均为 `b _getenv`;第三者通过 `_getenv@GOTPAGE`、`_getenv@GOTPAGEOFF` 加载地址,再执行 `blr x8`。这证明该工具链下 `optnone` 能保留间接调用,也证明外部符号和 GOT 引用仍存在。该实验仅验证汇编形态,未验证最终链接、LTO、原检测引擎判定或抵御 Hook 的效果。
## 3. 报告调用点与当前代码的对应关系
本节路径相对 readoor 根目录;行号为本次核查位置。确认的是当前代码/库存在对应行为,不是所有报告地址已经完成符号化。
| 报告线索 | 当前证据 | 处理方向 |
| --- | --- | --- |
| `-[STSCommonUtil convertPcmToWav:wavFilePath:] -> _fopen` | `readoor/BookShelf/Classes/Util/STSCommonUtil.m:1427` 显式 `fopen`,随后 `fwrite/fclose` | 自有源码,选为首个调用隐藏与业务回归试点;属于旧架构,要显式纳入实施范围 |
| `GCDWebServerFileRequest writeData:error:` / `dealloc` | `readoor/BookShelf/Classes/Factorys/GCDWebServer/Requests/GCDWebServerFileRequest.m:46,50,61,71` 调用 `unlink/open/write/close` | 源码随仓库提供;维护可重放补丁,回归上传、临时文件与错误路径 |
| `GCDWebServerMIMEStreamParser` / `GCDWebServerMultiPartFile` | 同目录 `GCDWebServerMultiPartFormRequest.m:95,155,211,246,288` 对应 `unlink/open/write` | 覆盖流式 multipart 和清理路径,不能仅处理单一入口 |
| `IFlySpeechSynthesizerImp`、`IFlyISVMSCHandler`、`IFlyPcmRecorder` | `readoor/BookShelf/Classes/Factorys/XunFei/iflyMSC.framework/iflyMSC` 是多架构静态归档;arm64 未定义符号中确认有 `_fopen`、`_syscall`、`_exit` | 优先供应商升级/重新构建;当前不能仅修改头文件解决库内部调用 |
| `ZZFileChannelOutput writeData:error:` | `readoor/BookShelf/Classes/Factorys/ZipZap/libZipZap.a`;`nm -arch arm64 -u` 在 `ZZFileChannelOutput.o` 下确认 `_write/_close` | 取得匹配版本源码重编或升级;需验证现有业务接口和压缩文件行为 |
| 匿名 `_dlopen/_dlsym/_syscall/_fork/_exit` 地址及 google 日志函数 | 未取得同次构建产物,未完成归属定位 | 使用原始 IPA、UUID 匹配的 dSYM、Link Map 归因;不按相近名称推测属于某 SDK |
| 当前安全守卫的 `exit(0)` | `readoor/3.0/Base/Security/RDSecurityGuard.swift:114` | 当前源码确定存在;尚不能对应报告中某个匿名 `_exit` 地址 |
静态 SDK 最终可能进入主可执行文件,因此“扫描主程序”与“仅扫描自有业务代码”不是同一个范围。不可默认 LLVM Pass 或源码包装能处理无源码预编译归档。
## 4. 当前反 Hook 防护的代码核查
以下为此次额外发现,未声称来自原报告。优先级按修复依赖和防护效果排序,不替代机构的漏洞评级。
| 优先级 | 代码证据 | 问题及建议 |
| --- | --- | --- |
| P0 | `RDInjectionDetector.swift:112–116` | 白名单缺失、损坏或 HMAC 不匹配时 `detect()` 返回 `false`,且跳过后续检测。应返回 `unavailable/integrityFailure`,继续执行独立探针,由策略层区分构建缺陷和风险 |
| P0 | `RDInjectionDetector.swift:173–176` | Bundle 外非系统镜像被无条件跳过,形成注入检测盲区。改为采集来源、归类和明确例外策略;未知镜像先输出证据,避免将任何未知状态直接升级为退出 |
| P0 | `RDInjectionDetector.swift:150–154` | 新格式路径不匹配仍回退 basename 放行,削弱精确路径约束。新格式要求精确匹配,旧格式迁移独立处理;同名不同路径不能相互覆盖 |
| P1 | `RDInjectionDetector.swift:128–138` | `DYLD_INSERT_LIBRARIES` 整串前缀检查,未逐项解析。对每个条目单独验证;路径校验需要目录边界和规范化,不能仅靠 `hasPrefix(bundlePath)` |
| P1 | `RDSecurityGuard.swift:69,85` | 调试器状态始终为 `false`。增加独立探针,返回 detected/clear/unavailable,Debug、模拟器和 Release 策略分离 |
| P1 | `RDSecurityGuard.swift` 与两个 Detector 全文 | 未见 GOT 槽位、关键函数代码完整性、Objective-C IMP 基线检测。镜像名和越狱路径不能覆盖这些 Hook 形式;作为 iOSGuard 后续能力单独验收 |
| P1 | `RDAppDelegate.swift:49–52` → `STSAppStartupProcess.m:26–27` → `startForegroundObserver()` | 同一启动链两次检测、两次注册观察者;`observer` 被覆盖,只能移除最后一个 token。统一启动入口,注册幂等,多 Scene 同样处理 |
| P1 | `RDSecurityGuard.swift:76,83–89` | 调用线程和后台队列都写 `cachedContext`,缺少统一隔离;后台又执行包含 UIKit 查询的检测。状态通过串行队列/actor 隔离,UI 查询回主线程,避免重复扫描 |
| P1 | `RDSecurityGuard.swift:17–20,122–125` | 登录/支付/VIP/激活事件仅见枚举与日志分支,未在当前检索范围发现相应调用点。需在关键操作入口接入实际策略并验证,不能把声明当成已保护 |
| P1 | `RDSecurityGuard.swift:79,112–114` | 当前高风险立即 `exit(0)`,既是显式调用点,也让误判变成直接退出。改为风险状态及受限操作策略,确保订单/交易恢复路径完整 |
| P2 | `RDJailbreakDetector.swift:132–147` | 同步 `connect` 无显式超时,启动/前台同步扫描可能产生等待。移至有预算的异步检测,默认端口只作弱信号 |
`AutoPacking/obfuscation/generate_image_whitelist.py` 已有构建期白名单和 HMAC 生成流程。后续优先沿用并修复产物生成时机、路径规则、格式验证,不再并行维护第二套名单。App 内置 HMAC 密钥的设计不应承担服务端信任根职责。
现有安全守卫注释写“仅输出风险日志”,实现却会退出,实施时须同步代码注释和行为文档。
## 5. iOSGuard 的实施架构
### A. 构建期分析与证据链
优先实现只读 `audit`:解析 `.app/.ipa` 的主程序、嵌入 Framework、dylib 和扩展;记录架构、UUID、哈希、依赖、导入符号、直接调用候选及加密状态。IPA 解包须校验路径、软链接和解压体积;解析失败、加密代码、未知架构输出“不支持/无法验证”,不能输出“通过”。
每个结果至少包含:binary 相对路径、架构、UUID、调用地址、目标符号、调用方、归属对象/SDK、证据等级、规则版本、整改状态。未定义符号只是导入证据;实际调用点需要反汇编和 stub/绑定关联。使用 Link Map 判断静态对象归属,并通过 UUID 匹配 dSYM;不同构建比较按调用方/符号/所属对象归一化,不按绝对地址比较。
交付 JSON 明细与 Markdown 汇总,支持基线差异和失败退出码。先覆盖报告中的符号集,保留扩展规则接口。
### B. 源码调用保护
第一阶段以少量 C/Objective-C 包装和编译产物检查试点。仅保护确定需要保护的调用,保持函数签名、ABI、错误码、变参和线程语义。`open` 的 mode 参数、`read/write` 的短读短写、`EINTR` 等必须有行为测试;不能批量正则替换。
Release 必须检查最终机器码;评估 LTO、dead strip 和实际发布参数。包装可改变调用形态,但不能作为 GOT/Inline Hook 的替代防护。第三方源码补丁要有版本锁定与升级检查;无源码 SDK 独立列为供应商依赖。
LLVM Pass 放在手工试点有效之后,先验证所用 Xcode/LLVM 工具链兼容性;Swift、预编译 SDK 不默认拥有同等覆盖。
### C. 运行时 Defender
推荐首期通过源码或静态库接入,输出结构化风险结果。探针与处置分离:
- 镜像、白名单完整性与调试状态:优先实现,支持启动、前台和关键操作前检查。
- GOT/符号地址:记录允许的提供方和镜像范围,区分合法转发、懒绑定与非预期重绑定;明确 PAC、chained fixups、共享缓存及架构支持范围,未支持状态不能算安全。
- 关键自有代码完整性:选定小范围、稳定函数,建立与构建产物绑定的基线。运行后才采集的基线可能已经被篡改,不能作为唯一可信基线。
- Objective-C 关键 IMP:仅保护明确的业务方法,显式容纳合法 swizzling;不能将所有方法实现变化判为攻击。
- 已知工具/越狱线索:作为组合证据,不能只靠固定名称、端口或少量文件判定安全。
设计返回 `clear / detected / unavailable` 与 reason code、证据和检查时间。耗时检测有预算,异步刷新有有效期,关键交易不能无限使用旧缓存。Debug 和测试模式单独配置,Release 不允许残留测试绕过开关。
先采用观察模式验证正常用户误判,再启用明确的能力限制。支付授权、权益和订单状态仍由服务端验证;若后续增加设备证明,需作为单独的客户端/服务端工作流设计,不能声称当前项目已经支持。
### D. 二进制后处理与签名
待源码路径和 SDK 覆盖边界明确后再启动。首期不做全局段平移、Objective-C 元数据清空或自动改写所有系统调用。此类变更须逐项解决重定位、chained fixups、异常展开、指针认证、签名和 dSYM 对应关系。
如确需无源码方案,先限制输入架构、未加密二进制和可验证的加载空间,明确拒绝不支持的输入,产物始终另存。Defender 注入完成只代表库加载成功;原报告调用点是否减少仍需单独验证。
## 6. 分阶段实施与完成条件
| 阶段 | 主要产物 | 完成条件 |
| --- | --- | --- |
| M0 基线闭环 | 原报告记录清单、原 IPA/dSYM/Link Map、目标构建配置及 SDK 清单 | 核对 MD5/UUID;每条报告记录有确定归属或明确“待定位”;确认机构扫描范围、判定规则及完整命中清单 |
| M1 只读审计 | `core/macho` 解析、`cli` audit、JSON/Markdown 差异报告、测试样本 | 正常/损坏/加密/多架构输入均有明确结果;导入符号与调用指令分开统计;可重现原报告的一部分并解释差异 |
| M2 防护修复与接入 | Defender 基础探针、readoor 检测状态与策略、白名单修复、启动去重 | 白名单损坏不再等同安全;重复启动无重复观察者;并发、线程及超时测试通过;正常真机关键流程通过 |
| M3 调用保护与依赖整改 | `STSCommonUtil`/GCDWebServer 试点、第三方版本/重编方案、Release 反汇编证据 | 同引擎验证试点是否减少命中;音频、上传、解压行为无回归;无源码剩余项明确列出,不以主工程修改代替 |
| M4 深入反 Hook 与验收 | GOT/IMP/关键代码检测、受控动态测试记录、最终 IPA 与复测报告 | 已定义的 Hook 场景被检测并按策略处置;正常样本无已知误拦截;报告两项逐条复测闭环;残余项获得明确结论 |
依赖:M0 → M1;M2 可在目标构建确认后与审计开发交错推进;M3 依赖 M1 和机构试点反馈;M4 依赖实际 SDK、机器码与运行时验证结果。首个 PoC 不需要先完成 VMP、资源加密或 Class-Dump 改造。
建议实施时创建以下模块(目前均未实现):`core/macho` 只读解析、`cli` 审计入口、`defender` 探针与结果模型、`tests` 格式及运行时测试、`examples/readoor` 接入说明。readoor 修改遵守其 `AGENTS.md` 和对应开发 Skill;旧架构及第三方源码变更在任务中显式列出。
## 7. 验收矩阵
| 维度 | 必测场景 | 通过标准 |
| --- | --- | --- |
| 报告复测 | 原始与整改 IPA、同引擎/同规则,覆盖主程序和依赖 | 逐条定位与复测;两项按机构标准关闭,或保留正式残余风险;本地审计零命中不替代机构报告 |
| 编译产物 | 实际 Release 优化、LTO 配置及各发布架构 | 预期间接调用保留;新包装层及 Defender 自身亦纳入扫描;无新增不允许的系统调用依赖 |
| 白名单 | 缺失、格式错、摘要错、同名不同路径、Bundle 外镜像、多条环境变量 | 返回明确状态并执行对应策略;可重复回归,不只检查正常样本 |
| Hook | 受控测试中的动态库注入、GOT 重绑定、指定自有函数补丁、关键 IMP 替换 | 各场景独立记录覆盖结果、延迟和策略行为;不以 Frida 端口命中代替所有测试 |
| 正常环境 | 真机冷启/前台、多 Scene、测试设备、允许的 SDK swizzling、无网 | 无已知误退出或误拦截;不破坏合法调试配置 |
| 核心功能 | 登录、购买、支付回调、激活、录音/语音合成、PCM/WAV、文件上传/解压 | 功能正确,失败可恢复,订单状态一致;测试与报告对应的 SDK 路径 |
| 并发与性能 | 重复启动、并发检查、探针超时、后台刷新、生命周期 | 无状态数据竞争和重复 observer;测量首屏/回前台耗时及 p95 后确定预算,不预设未经测量的保证值 |
| 分发 | 最终签名、安装、升级、崩溃符号化 | 实际目标配置真机验证通过;构建和签名成功本身不等于安全检测通过 |
后续 Swift/Objective-C/工程修改按 readoor 规则先执行其规定的 `readoor31` 构建;ECNUP 最终验收仍需使用配置 `306` 对应的实际归档流水线,不能以默认 scheme 的通过代替产品包验证。
## 8. 本轮交付与待补输入
已完成:报告文本提取与去重统计、指定源码调用核查、第三方静态库符号核查、现有防护调用链审查、ARM64 优化实验、实施路线与验收矩阵。只新增本文并更新 iOSGuard README 的实现状态和入口;未修改 readoor,也未运行完整 App 构建或真机安全测试。
进入 M0 时需要补齐:原始被测 IPA;对应 dSYM、Link Map(如当时未保留,须说明不能精确还原);原构建配置与依赖版本;检测机构完整条目和规则口径、是否接受间接调用的试点复测。无源码 SDK 获取受限或检测规则不接受公开 API 路径时,应明确记录阻塞项和替代路线,不能承诺仅注入防护库即可消除全部报告问题。
+90
View File
@@ -0,0 +1,90 @@
# 静态 SDK fopen 重定向 PoC
日期:2026-11-10。用途:验证无 SDK 源码时的调用转发链路;不代表已经具备完整反 Hook 能力或通过报告复测。
后续扩展:核心实现现已移至 `redirect_symbols.py`,支持 JSON 多符号映射,桥接扩展至 7 个固定签名函数。本文记录初始 fopen 验证;原 `redirect_fopen.py` 命令保留兼容,最新用法和范围见 [通用重定向工具](07_GENERIC_STATIC_SDK_REDIRECT.md)。
## 1. 已实现的调用链
```text
SDK 对象的 _fopen 未定义符号
→ 改写为 _IG_fopen(保持符号索引和重定位记录不变)
→ App 链接 IGFileBridge.c
→ IG_fopen 原样传递 path/mode
→ 通过函数指针调用系统 fopen
→ 原样返回 FILE * 或 NULL
```
`defender/call_bridge/IGFileBridge.c` 不记录日志、不扫描环境、不分配额外业务状态、不主动拦截。正常系统调用后的返回路径不调用其他函数,因此不主动改写其 errno。签名和返回的 FILE 指针保持与系统接口一致,可交给系统 `fread/fwrite/fclose`。这只是透明转发实现,不保护系统函数实现或 GOT 不被 Hook。
`optnone/noinline` 用于在当前 Clang 下保留独立入口和间接调用;最终 Release 的优化、LTO、链接行为仍须重新验收。不能承诺符号不可见或任意检测引擎都不命中。
## 2. 工具边界与工作方式
入口:`tools/static_sdk_redirect/redirect_fopen.py`。环境:macOS、Python 3、Xcode 的 `lipo/ranlib`;不依赖本机未安装的 `llvm-objcopy`。
1. 接受 BSD ar 静态归档,或从 fat 文件提取 arm64 静态归档。
2. 检查成员为 little-endian ARM64 `MH_OBJECT`,遍历 `LC_SYMTAB`。
3. 仅将普通外部未定义符号 `_fopen` 的字符串索引改为新增的 `_IG_fopen` 名称。保留其他符号索引、section、机器码和重定位数据;更新字符串表长度。
4. 重新组装归档,用 `ranlib` 重建索引。输出 JSON 记录成员及输入/输出 SHA-256。
5. 写入新文件;拒绝原地覆盖、覆盖已有输出、目标符号冲突或重复处理。任何成员不支持则整个操作失败。
只支持已验证的有限布局:字符串表在对象末尾,允许不超过 7 字节的全零或全换行归档填充。允许 `__LLVM,__bitcode/__cmdline` 中单字节零值的占位标记并原样保留;拒绝实际 LLVM IR/bitcode、未知 LLVM section、arm64e、32 位、动态库、对象签名、GNU 长名称归档及其他未知格式。该工具是小范围 PoC,不是通用 Mach-O 重写器。
输出是 **arm64 真机 `.a`**,不包含原库的 armv7/x86_64,也不构成可直接替换全部目标的完整 Framework/XCFramework。模拟器必须独立处理;不能把真机归档用于 ARM64 模拟器。
## 3. 复现方式
以下命令只写入新建临时目录;保留原讯飞库。命令需整体在同一 shell 中执行,脚本失败即停止。
```sh
set -e
cd /Users/shenlei/Work/ReadBook/iOSGuard
IG_POC_DIR="$(mktemp -d /private/tmp/iosguard-fopen.XXXXXX)"
python3 tools/static_sdk_redirect/redirect_fopen.py \
/Users/shenlei/Work/ReadBook/readoor/readoor/BookShelf/Classes/Factorys/XunFei/iflyMSC.framework/iflyMSC \
"$IG_POC_DIR/iflyMSC.redirected.a" > "$IG_POC_DIR/report.json"
xcrun --sdk iphoneos clang -arch arm64 -miphoneos-version-min=15.0 \
-O2 -Wall -Wextra -Werror -c defender/call_bridge/IGFileBridge.c \
-o "$IG_POC_DIR/IGFileBridge.ios.o"
xcrun ld -r -arch arm64 -platform_version ios 15.0 27.1 \
-all_load "$IG_POC_DIR/iflyMSC.redirected.a" "$IG_POC_DIR/IGFileBridge.ios.o" \
-o "$IG_POC_DIR/iflyMSC.combined.o"
python3 -m unittest discover -s tests -v
```
`ld` 示例的 SDK 版本 `27.1` 是本次实际环境;更换 Xcode 后按实际 SDK 调整。`ld -r` 是可重定位链接检查,保留其他未解析的系统/依赖符号,不等于最终 App 完整链接或运行通过。
## 4. 已完成验证
环境:ARM64 Mac,Xcode 27.1,iPhoneOS SDK 27.1。
| 验证 | 实际结果 | 限制 |
| --- | --- | --- |
| 测试静态归档 + 原始系统调用 | 文件写入、读取、追加、截断、中文路径、ENOENT、4 线程各 20 轮均通过 | Mac 上的自建 SDK 替身,不是讯飞业务 |
| 同一归档重定向 + IGFileBridge | 同样的行为测试通过;原始输入不变;重复处理/覆盖被拒绝 | 未模拟磁盘满、真实设备权限等所有失败条件 |
| 格式和拒绝路径 | 截断、符号冲突、定义符号、动态库、实际 bitcode、异常尾部等测试通过 | 测试集不等于完整解析器安全审计 |
| 讯飞实际 arm64 归档副本 | 检查 380 个对象成员;25 条 `_fopen` 未定义符号引用改为 `_IG_fopen` | 25 是对象符号引用数,不是机器指令调用次数,也不代表最终 App 会链接全部对象 |
| 讯飞符号前后对比 | SDK 副本 `_fopen` 25 → 0,`_IG_fopen` 0 → 25;`_syscall` 13、`_exit` 1 保留 | 最终 App 的桥接实现仍引用系统 `_fopen` |
| 讯飞副本 + iOS bridge 对象 | `ld -r -all_load` 成功 | 未完整链接 readoor、未执行 SDK、未完成真机回归 |
| iOS ARM64 优化汇编 | bridge 保留 `fopen@GOTPAGE` 加载和 `blr` 间接调用 | 存在 GOT 引用,不能声称防止重绑定或 Inline Hook |
| 原始 SDK | SHA-256 前后相同 | 未改 readoor 工程和依赖 |
原始讯飞 SDK SHA-256:`b368fa4866d274da0c6e89607e9d5b95b4a59d49c183eb68c947ac2b50ff3c2c`。归档索引元数据可能受工具影响,重建后不要求整个输出文件哈希跨构建相同;每次记录本次输入和输出即可。
## 5. 后续 readoor 接入方式
本次没有修改 readoor。真正接入需要单独的目标配置或隔离分支,遵守该仓库开发流程:
1. 保留原 iflyMSC 头文件与必要资源,将 arm64 真机配置的链接输入切换为改写归档。
2. 将 `IGFileBridge.c/.h` 加入相同 target;桥接文件不参与符号改写,不定义同名系统 `fopen`。
3. 同一 target 不同时链接原始 iflyMSC 二进制和改写归档;检查 `-framework iflyMSC`、Link Binary With Libraries、其他静态依赖及 `-ObjC/-force_load` 实际设置,避免重复定义或误链接原版本。
4. 检查生成的 Link Map,确认实际选中的归档,以及 `_IG_fopen` 正好由桥接实现提供。仅依赖源码中“已配置”不算接入成功。
5. 构建实际 ECNUP Release,回归讯飞录音、语音合成、文件保存及错误恢复,并比较加固前后性能。
6. 送同引擎复测。若扫描仍识别包装层的系统引用,应记录失败并调整路线,不能把静态库内 `_fopen` 数量变成零当作整个 App 风险已关闭。
首轮只验证 `fopen`。`syscall` 的变参/调用号、`exit` 的不返回语义均需要独立设计,不能套用当前实现。GOT、IMP、Inline Hook 的实际防护也不包含在本 PoC 中。
+80
View File
@@ -0,0 +1,80 @@
# 通用静态 SDK 符号重定向
日期:2026-11-10。当前是有限格式下可复用的构建工具,不是任意 IPA 的通用加固器。
## 实现范围
将此前硬编码 `_fopen → _IG_fopen` 的解析逻辑改为 JSON 映射驱动。对不同 SDK 使用不同映射,同一次处理可重定向多个外部 C 符号。核心 `redirect_symbols.py` 不包含讯飞对象名或业务特例,旧 `redirect_fopen.py` 作为仅处理 fopen 的兼容命令保留。
通用的是**归档与符号处理**;调用转发仍须按真实函数签名实现。不能通过一个 `void *` 或任意变参入口安全地承接所有函数。符号改写工具无法从名字验证参数、返回值、可变参数、错误状态、线程取消或不返回语义。
| 层 | 当前能力 | 扩展方式 |
| --- | --- | --- |
| 重定向引擎 | 映射驱动,精确匹配外部未定义 C 符号;重建归档索引;报告每个符号、每个成员的改写量 | 新 SDK 先检查二进制格式,再选择映射 |
| 映射配置 | 标准 I/O 与 POSIX I/O 两组;支持自定义 JSON | 配置使用实际 Mach-O 名称,含前导下划线 |
| C 桥接 | `fopen/fclose/fread/fwrite/read/write/close` | 新函数需新增准确声明、实现和行为测试 |
| 业务接入 | 独立输出归档,原文件不变 | target 切换链接输入并添加桥接代码;检查 Link Map |
所有桥接均为直接参数转发、局部函数指针、`optnone/noinline`。不加日志、自动重试、短读短写补齐、策略拦截。`syscall`、`open` 变参、`exit`、ObjC 方法、C++ 符号不在自带桥接覆盖范围内;自定义映射不能代替桥接实现和 ABI 审查。
## 配置与命令
`tools/static_sdk_redirect/mappings/stdio.json`:
```json
{
"_fopen": "_IG_fopen",
"_fclose": "_IG_fclose",
"_fread": "_IG_fread",
"_fwrite": "_IG_fwrite"
}
```
`mappings/posix_io.json` 提供 `_read/_write/_close`。若需同时处理两组,将各键合并到一个 JSON,**一次处理原始库**,不要把已改写库当作重复处理输入。
下面使用新建临时目录处理当前讯飞静态 SDK 副本:
```sh
set -e
cd /Users/shenlei/Work/ReadBook/iOSGuard
IG_GENERIC_DIR="$(mktemp -d /private/tmp/iosguard-generic.XXXXXX)"
python3 tools/static_sdk_redirect/redirect_symbols.py \
/Users/shenlei/Work/ReadBook/readoor/readoor/BookShelf/Classes/Factorys/XunFei/iflyMSC.framework/iflyMSC \
"$IG_GENERIC_DIR/iflyMSC.stdio.a" \
--mapping tools/static_sdk_redirect/mappings/stdio.json \
--require-all > "$IG_GENERIC_DIR/report.json"
```
默认允许某些配置项在该 SDK 中不存在,但 JSON 报告明确列入 `unmatched_symbols`;所有项均未命中时失败。`--require-all` 要求每项至少命中一次,否则不生成输出,适合已知版本 SDK 的 CI 检查。
遇到空配置、非法 C 符号名、重复 JSON 键、自映射、链式映射、循环映射、多个源共用一个目标、归档已含目标符号、源符号有定义、格式不支持或已有输出文件均失败。报告的 `symbol_counts` 统计对象符号表条目,不是指令调用次数。
工具只输出改写后的静态库,不自动链接或嵌入桥接。target 必须链接 `defender/call_bridge/IGFileBridge.c`,或提供自定义映射对应的兼容实现。桥接代码不能参与重定向,否则可能造成自调用递归。同一 target 不要同时链接 SDK 原二进制与其改写副本。
## 已验证与未覆盖
15 项自动化测试通过:
- 原 fopen 行为与旧 CLI 保持可用。
- 同一对象中 7 个符号同时重定向,链接运行正确,逐符号计数符合预期。
- 同一行为测试分别链接原始库与改写库;二进制文件读写、追加、截断、中文路径、4 线程各 20 轮通过。
- POSIX 管道短读、零字节读写、EOF、无效描述符 EBADF、非阻塞管道满时 EAGAIN/EWOULDBLOCK 保持行为。
- 配置错误、重复键、冲突、严格模式缺项、全部未命中、已有输出、重复处理及格式拒绝路径得到验证。
当前真实讯飞 SDK 检查 380 个对象成员,标准 I/O 四符号配置共改写 95 条符号引用:`_fopen` 25、`_fclose` 30、`_fread` 17、`_fwrite` 23;`nm` 对照及 iOS ARM64 `ld -r -all_load` 可重定位链接验证通过。该检查不等于 readoor 完整链接、SDK 真机运行或报告复测。
不支持动态 Framework、IPA 中最终可执行文件、arm64e、32 位、GNU 长名称归档和实际 bitcode;fat 静态库只提取 arm64,输出不包含其他架构。保留初始 PoC 对 Mach-O 布局的限制,详见 [初始实现](06_STATIC_SDK_FOPEN_POC.md)。当前 SDK 验证是 iPhoneOS 真机切片;ARM64 Mac 测试不等于 iOS 模拟器支持声明。
基础行为测试未覆盖全部函数语义,例如磁盘满、EINTR、线程取消、全部短写模式、目标 App 优化/LTO 组合及 SDK 自校验。正式接入仍需各 SDK 的业务回归。
桥接的间接调用仍可保留 GOT 引用。多符号改写仅扩大调用转发覆盖面,不自动提供 GOT/Inline Hook 防护,也不保证原检测报告清零。新增映射应按“实现桥接 → 行为测试 → SDK 副本改写 → 真机业务回归 → 同引擎复测”逐步验收。
## 本地验证命令
```sh
cd /Users/shenlei/Work/ReadBook/iOSGuard
python3 -m unittest discover -s tests -v
```
本机 ARM64 Mac 原生编译和运行测试需要 Xcode;其他平台会跳过原生测试,不能把跳过结果当作链接或运行通过。此次未修改 readoor、替换其 SDK 或改变签名产物。
@@ -0,0 +1,84 @@
# 08 · readoor31 ZipZap 重定向接入试点验证
日期:2026-11-10
范围:`readoor-test` 副本(原工程未动)。readoor31 target,Release / iphoneos / arm64,Xcode iPhoneOS 27.1 SDK。
## 1. 结论
**链接前重定向在真实 App 构建中打通**:改写后的 libZipZapGuard.a + 桥接代码已编入 readoor31 最终二进制,ZipZap 对 `_write`/`_close` 的直接调用全部改道为 `bl _IG_write` / `bl _IG_close`,桥接内部为 GOT 取址 + `blr` 间接调用。构建成功,导入符号表与基线完全一致。
这不是"隐藏系统调用":`_write`/`_close` 仍是导入符号(桥接自身引用),扫描导入表/GOT 的检测器仍可见。边界见 §5。
## 2. 事实修正
- readoor31 **确实链接 ZipZap**:链接命令为 `-lZipZap`(经 LIBRARY_SEARCH_PATHS 解析到 `readoor/BookShelf/Classes/Factorys/ZipZap/libZipZap.a`)。早期用完整文件名 grep 日志导致误判。
- 讯飞 iflyMSC 未被 readoor31 链接(仅旧 readoor target 使用,且该 target 打包失败),故本试点改用 ZipZap。
- 原库为 **fat armv7+arm64**;重定向工具仅支持 arm64,armv7 切片原样保留。
## 3. 接入方式(零 pbxproj 改动)
```
IGFileBridge.c ──clang -arch arm64 -miphoneos-version-min=15.0──▶ IGFileBridge.o
IGFileBridge.o ──ar r──▶ libZipZapGuard.a # 桥接随库分发,App 无需加编译源
原库 armv7 切片 + 改写库(arm64) ──lipo -create──▶ fat
cp fat ──▶ readoor-test/.../ZipZap/libZipZap.a # 原位替换,工程引用不变
```
- 原库备份:`test-results/baseline/libZipZap.a`(sha256 `5caa6101…`,与 redirect-report 的 source_sha256 一致)。
- 回退:把备份拷回原路径重新构建即可。
## 4. 验证证据(基线 vs 加固)
| 项 | 基线(BUILD SUCCEEDED) | 加固(BUILD SUCCEEDED) |
| --- | --- | --- |
| `writeData:error:` 内调用 | `bl 0x100e7add8 ; stub for: _write` | `bl _IG_write` |
| `ZZFileChannelOutput close` 内调用 | `bl 0x100e7989c ; stub for: _close` | `bl _IG_close` |
| `_IG_write` / `_IG_close` 定义 | — | `T` @ 0x100c21d60 / 0x100c21da4 |
| 桥接函数体 | — | `adrp+ldr`(GOT/literal pool 取 `_write`/`_close` 地址)→ 栈存 → `blr x8`;`optnone` 生效,未被直连化 |
| 导入符号表 | 3586 项 | 3586 项,diff 为空 |
| dead_strip | `ZZFileChannelOutput` 方法保留 | 同左,另有 `_IG_*` 两个新本地符号 |
关键机器码(加固版 `_IG_close`):
```
adrp x8, … ; ldr x8, [x8, #0xc10] ; literal pool symbol address: _close
str x8, [sp] ; ldr x8, [sp] ; … ; blr x8
```
资产:
- 基线:`test-results/baseline/`(原库、undefined 列表、44M Link Map、构建日志、metadata)
- 加固:`test-results/guarded/`(undefined 列表、链接命令、构建日志 `test-results/guarded-build.log`)
- 改写报告:`readoor-test/iOSGuardIntegration/redirect-report.json`(19 成员中 1 个改动,2 处引用)
## 5. 边界与风险
1. `_write`/`_close` 仍为导入符号:桥接 GOT 引用 + App 其他代码使用;跟踪间接调用的检测器可还原调用链。
2. armv7 切片原样保留,仍引用原系统符号,不享有本次重定向效果;当前构建只验证 arm64,未验证 armv7 构建。
3. 模拟器切片未覆盖(原库本就无 simulator 架构,行为不变)。
4. 未做真机功能回归(书籍解压/下载流程依赖 ZipZap 写文件);未提交检测引擎复测。
5. 本试点只覆盖 `_write`/`_close` 两个符号;fopen 系列在 readoor31 链接路径上的候选库(如 StsPDF 系列内核库,基线中有 401 个符号入库)尚未处理。
## 6. 复现命令
```bash
# 从未改写的备份抽取 arm64,输出新库;不要重复重定向已替换的库。
lipo test-results/baseline/libZipZap.a -thin arm64 -output /tmp/ig-zipzap-original-arm64.a
python3 tools/static_sdk_redirect/redirect_symbols.py \
/tmp/ig-zipzap-original-arm64.a /tmp/ig-zipzap-redirected-arm64.a \
--mapping tools/static_sdk_redirect/mappings/zipzap.json
# 桥接注入 + fat 合并 + 原位替换(见 §3)
xcrun --sdk iphoneos clang -arch arm64 -miphoneos-version-min=15.0 -Os \
-c readoor-test/iOSGuardIntegration/IGFileBridge.c -o IGFileBridge.o
# … ar r / lipo -create / cp(工作目录产物在 test-results/.work/)
# 构建
cd readoor-test && xcodebuild build -workspace readoor.xcworkspace -scheme readoor31 \
-configuration Release -sdk iphoneos \
-derivedDataPath ../test-results/DerivedData
```
## 7. 下一步
1. 真机安装加固版 readoor31.app,回归书籍下载/解压/阅读流程。
2. 用原检测引擎复测,确认 ZipZap 对应命中变化。
3. 视结果扩大映射(StsPDF 内核库的 fopen 系列是下一个候选)。
+95
View File
@@ -0,0 +1,95 @@
# 09 · ECNUP 报告整改方向结论
日期:2026-11-10。状态:方向判断与架构设计。**尚未向 V4.6.6 提交任何加固包复测**,下文"能过检"均为待验证假设,不是已验证结果。
> 进展:本文 §5 收敛的改写引擎已建成,并在真实目标上**自测第 1 层清零(336 → 0)**、结构合法可签——见 [10](10_MACHO_GUARD_SELFTEST.md)。送检 V4.6.6 仍未做。
关联:报告分析见 [05](05_READOOR_SECURITY_REMEDIATION_PLAN.md),重定向工具见 [07](07_GENERIC_STATIC_SDK_REDIRECT.md),试点验证见 [08](08_ZIPZAP_PILOT_BUILD_VERIFICATION.md)。
## 1. 从报告修复示例推导的检测假设
报告(ECNUP外语 2.197.2,引擎 V4.6.6)两个高危项——"外部函数显式调用风险"(`_fopen/_dlopen/_dlsym`)与"系统调用暴露风险"(`_write/_read/_open/_close/_exit/_fork/_syscall/_unlink/_getpid`)——**其官方修复示例是函数指针方式**:
```c
typedef char* (*GET_ENV_TYPE)(const char *);
static inline int __attribute__((optnone)) IJMCheckInsertLib() {
GET_ENV_TYPE get_env = getenv; // ← 仍然引用 getenv 符号
char *env = get_env("DYLD_INSERT_LIBRARIES");
}
```
**关键推论**:该示例修复后,`getenv` 仍是导入符号(导入表里还在),消失的只是"直接调用关系"(调用点不再是 `bl stub(getenv)`,而是取函数指针后 `blr`)。
据此提出假设:**V4.6.6 可能关注调用点的直接分支关系**,因此优先验证消除第 1 层(见 §3)的方案。报告示例不足以证明引擎的完整规则,也不能排除其跟踪桥接、间接调用或导入表的能力。
> 证据强度:这是从报告自带示例 + `optnone` 提示反推的结论,与 docs/08 试点一致(桥接后调用点变 `bl _IG_write`,而 `_write` 仍在导入表且导入表 diff 为空,构建通过)。最终仍以 V4.6.6 复测为准。
## 2. 方向结论:链接后 Mach-O 调用点改写器
报告展示 100 条记录(50 外部函数 + 50 系统调用),涉及讯飞、GCDWebServer、glog、Sts PDF 内核、ZipZap 及匿名地址。源码可用性需逐库确认,例如工程中有 GCDWebServer 源码,不能一概认定第三方库均无法重编译。
由此排除与选定:
| 方向 | 能否覆盖报告 | 结论 |
| --- | --- | --- |
| 源码改函数指针(报告示例) | 部分 | 适用于可以修改并重编译的源码;各库情况需单独确认 |
| 链接前静态库重定向(07/08) | 部分 | 仅限能拿到 `.a` 且格式受支持的库;动态 framework、已编入 Pods 的二进制覆盖不到 |
| **链接后 Mach-O 调用点改写(自研核心)** | **待复测** | 可统一处理受支持 arm64 格式中的目标直接分支;不覆盖全部架构和调用形态 |
**选定链接后改写器**(规划 `tools/macho_guard`),形态即"类易盾":输入 `.app`/IPA → 遍历每个 Mach-O 的 arm64 切片 → 定位命中符号的 `bl → __stubs` 调用点 → 改写为 `bl IG_*`(桥接蹦床注入新段)→ 逐级重签名。桥接仍按真实签名实现(07 已覆盖 7 个,需补 `open`变参/`unlink/exit/getpid/fork` 与 `syscall` 专用蹦床)。
## 2.5 实测:appstore.ipa 改写面(2026-11-10)
项目根目录 `appstore.ipa`(readoor31OtherPay **v2.199.0**,`com.ecnup.aSCLdl2`,arm64 单切片)经解包核查:
- **`cryptid 0`**:导出的 archive 包,`__TEXT` 明文未加密——链接后改写器可直接操作(App Store 下载包才会被 Apple 加 FairPlay,那种需先脱壳)。这是整个方向可行的硬前提,已在真实包上确认。
- 自研扫描脚本按上述假设运行直接分支规则:扫 `__text` 全部 `bl/b → __stubs` 分支,主二进制命中报告涉及的 12 个符号共 **336 处直接调用点**:
| 符号 | 数 | 符号 | 数 | 符号 | 数 |
| --- | --- | --- | --- | --- | --- |
| `_exit` | 96 | `_open` | 21 | `_unlink` | 8 |
| `_fopen` | 86 | `_dlsym` | 18 | `_read` | 7 |
| `_close` | 67 | `_write` | 16 | `_dlopen`/`_syscall` | 2/2 |
| | | `_getpid` | 12 | `_fork` | 1 |
报告每类展示 50 条,是否截断及完整记录数尚未确认。当前 IPA 的版本及 Bundle ID 与报告不同;336 是当前样本的本地统计,不能据此证明复现了 V4.6.6 的规则。
- 逐点清单(site 地址 / 符号 / 分支类型):`test-results/appstore-callsites.csv`(336 行)。注意该 release 包已 strip(仅 594 函数符号),无法从符号表还原 ObjC 方法名;报告的方法名来自解析 ObjC 元数据,改写任务不需要名字,用 site 地址即可。
## 3. 检测面分层与升级阶梯
| 层 | 检测方式 | 本次是否需要处理 |
| --- | --- | --- |
| 1. 调用点直接分支 `bl stub` | 调用点模式匹配 | **优先验证**——是否足以解决报告仍待 V4.6.6 复测 |
| 2. 导入表/GOT 条目 | `nm -u`、imports 扫描 | 否(报告示例自身不消除此层) |
| 3. 符号名字符串 | strings 扫描 | 否 |
| 4. 间接调用可追踪性 | 交叉引用、轻量模拟 | 否 |
对应升级阶梯(仅当复测仍命中才向下走,不预先加码):
```
桥接改写(消除第1层)──送检 V4.6.6──┬─ 过 → 收工,成本最低【当前判断落点】
└─ 仍命中 → A: dlsym表+名字加密(消第2、3层)
└─ 仍命中 → B: raw svc 内联(消第4层进 libSystem)
└─ 仍命中 → C: 桥接 VMP/控制流平坦化
```
A/B/C 的代价与边界(变参、errno 手工处理、arm64 调用号锁定、`svc` 字节本身不可消除等)见本轮讨论,**在验证桥接即过之前不实现**。
## 4. 必须如实说明
1. **未复测**:readoor ZipZap 试点(08)与任何 ECNUP 加固包都未提交 V4.6.6。"桥接即过"是假设。
2. **过检 ≠ 安全**:消除静态调用关系不防 Frida 等运行时 Hook;GOT 完整性校验、反调试等运行时防护(05 计划)与此正交,两层都要。
3. **自研规模**:验收标准是本报告 V4.6.6 清零 + 业务回归,不是对齐易盾全家桶(字符串加密/VMP/反调试套件属季度级,暂不做)。
4. **发行验证**:结构解析和 ad-hoc 签名检查不足以证明可安装、运行或满足发行要求;当前只完成本地静态验证,后续需正式配置签名和真机回归。
## 5. 下一步
现有真实目标 `appstore.ipa`(未加密、336 个调用点已定位),实验路径收敛为:
1. 建 `tools/macho_guard` 改写引擎:桥接段注入(arm64 位置无关蹦床,补齐 `open`变参/`exit/getpid/fork/unlink/syscall`)+ 336 个 `bl` 改写为 `bl IG_*` + 重建代码签名段。
2. 对 patch 后的 `appstore.ipa` **重跑本目录扫描脚本**,期望 336 → 0(客观、无需送检即可自测第 1 层是否消除)。
3. **ad-hoc 重签**(`codesign -f -s -`)即可满足 V4.6.6 静态复测——静态扫描器一般不校验签名有效性,故不需要正式证书;仅真机安装/提审才需开发者身份与 entitlements。
4. 送检 V4.6.6 验证第 1 节核心假设:过 → 收工;仍命中 → §3 阶梯 A。
> 风险:段注入涉及 LC_SEGMENT_64 插入与 LC_CODE_SIGNATURE/__LINKEDIT 偏移修正,是本引擎最易出错处,需逐步验证(先注入可用桥接段并能正常加载,再做批量改写)。
+104
View File
@@ -0,0 +1,104 @@
# 10 · macho_guard 链接后改写器:自测通过
日期:2026-11-10。状态:**第 1 层检测自测清零**——单二进制 336 → 0(§1-6),整包 31 个 Mach-O 共 878 → 0(§7),结构合法可签。**仍未向 V4.6.6 送检**——"桥接即过"依旧是待验证假设(见 [09](09_ECNUP_REMEDIATION_DIRECTION.md) §4)。
关联:方向与改写面实测见 [09](09_ECNUP_REMEDIATION_DIRECTION.md),检测器判定标准推断见 09 §1。
> 后续已从根目录 IPA 重新运行整包验证并保存在 `test-results/verification/20261110-step1-final/`,含源码快照、前后包、逐二进制 UUID/哈希、逐调用点 CSV、逐指令校验和签名日志;复现入口见 [13](13_REPRODUCIBLE_BASELINE.md)。下文 scratchpad 为早期记录,不再是唯一证据来源。
## 1. 结论
按 09 §5 收敛的路径,`tools/macho_guard` 链接后改写引擎已建成并在真实目标 `appstore.ipa`(readoor31OtherPay v2.199.0,`com.ecnup.aSCLdl2`,arm64 单切片,`cryptid 0`)上跑通:
- **注入** `__IGUARD` 段(RX,一页 0x4000),内含 12 个与系统 stub 字节同构的桥接蹦床;
- **改写** `__text` 内全部 336 个命中调用点 `bl/b → __stubs` 为 `bl/b → IG_*`;
- **ad-hoc 重签**(`codesign -f -s -`)通过,`codesign -v` exit 0。
对 patch 后二进制重跑本目录扫描脚本:**命中 12 个符号的直接调用点 336 → 0**。重新打包成 IPA 后再解包复扫,同样为 0——独立复现,非内存产物假象。
## 2. 改写面与结果(逐符号)
| 符号 | 改写数 | 符号 | 改写数 | 符号 | 改写数 |
| --- | --- | --- | --- | --- | --- |
| `_exit` | 96 | `_open` | 21 | `_unlink` | 8 |
| `_fopen` | 86 | `_dlsym` | 18 | `_read` | 7 |
| `_close` | 67 | `_write` | 16 | `_dlopen` | 2 |
| `_getpid` | 12 | `_fork` | 1 | `_syscall` | 2 |
合计 336,与注入前实测(09 §2.5)逐符号完全吻合。
## 3. 桥接蹦床原理
每个桥接函数 3 指令 12 字节,与系统 `__stubs` 条目**字节同构**,从同一 GOT 槽取址尾调用:
```
adrp x16, GOT@page ; 与系统 stub 相同的页基址
ldr x16, [x16, #off] ; 取同一 GOT 槽(dyld 已填真实函数地址)
br x16 ; 尾调用,ABI 透明,变参/errno 原样透传
```
关键差异:桥接函数**不登记进间接符号表**。因此静态扫描器遍历 `__stubs`→间接符号表还原"这个分支目标对应哪个导入符号"时,`IG_*` 无法被归为 `_write/_fopen/...`,调用点不再被判为对应系统符号。`_write` 等仍是导入符号(GOT 槽、桥接自身引用),第 2/3 层未动——与 09 §1 推断的 V4.6.6 判定口径(调用点直接分支关系,非符号存在性)一致。
尾调用正确性:`b IG_sym`(tail call)改写后,`IG_sym` 末尾 `br x16` 跳真实实现,返回地址仍是原调用者,ABI 透明;`bl IG_sym` 同理,桥接返回后回到调用点。变参 `open`/`syscall` 因纯尾调用、参数寄存器/栈原样透传,字节同构蹦床即足够(不需签名精确的 C 桥接)。
## 4. 段注入与偏移修正(最易错处)
在 `__DATA` 与 `__LINKEDIT` 之间插入 `__IGUARD`:
1. 文件在 `__LINKEDIT` fileoff(0x3458000)处插入一页段数据;
2. header 区(0..16384,含 load commands)在 `__LINKEDIT` 命令前插入 72 字节 `LC_SEGMENT_64`,header 区总长保持 16384(原 load commands 结束于 15088,余量充足);
3. `ncmds += 1`,`sizeofcmds += 72`;
4. `__LINKEDIT` 段命令 vmaddr/fileoff `+= PAGE`;
5. **所有指向 __LINKEDIT 的偏移 `+= PAGE`**:chained_fixups、exports_trie、symtab(symoff/stroff)、dysymtab(indirectsym)、function_starts、data_in_code、code_signature——漏一个即加载失败或签名区错位。命令本身也因插入右移 72 字节。
验证:`otool -l` exit 0 解析干净;段序 `__PAGEZERO,__TEXT,__DATA,__IGUARD,__LINKEDIT` 正确;`codesign -v` PASSED。
## 5. 工具与产物
- `tools/macho_guard/machox.py`:Mach-O 解析(`Macho` 类、`linkedit_pointers()`)。
- `tools/macho_guard/macho_guard.py`:注入+改写+重签。CLI:`inject`(仅注入校验)、`harden`(注入→改写→重签一条龙)。因读取未信任二进制,须 `python3 -I` 运行。
- 自测扫描脚本复现 V4.6.6 判定(扫 `__text` 全部 `bl/b → __stubs`,经间接符号表映射到 12 个命中符号)。
- 加固后 IPA、逐点 CSV 等产物当前在会话 scratchpad,未入库(113M 二进制不宜提交);需长期留存可按需拷入 `test-results/`。
## 6. 复现命令
```bash
cd tools/macho_guard
python3 -I macho_guard.py harden <原始二进制> <输出二进制>
# [1/3] 注入 __IGUARD;[2/3] 改写 336 处;[3/3] ad-hoc 重签 exit=0
# 复扫期望 336 → 0
```
## 7. 多 Mach-O 整包批处理(2026-11-10 自测通过)
单二进制验证后,把改写器推广到**整个 `.app` 包**。工程化要点:
- **base 泛化**:主程序 `__TEXT` vmaddr=0x1_0000_0000(`__PAGEZERO` 在前),framework/dylib vmaddr=0(无 `__PAGEZERO`)。原 `inject`/`find_stub_got_slots` 硬编码的 `BASE=0x100000000` 与 header 区 `16384` 均改为按 `__TEXT` 段实测值与首节文件偏移动态计算(`_text_mapping` / `_first_section_fileoff`)。扫描逻辑本就纯在 vmaddr 空间匹配,天然 base 无关。
- **fat 容器**:`AliyunPlayer`/`alivcffmpeg`/`AliyunMediaDownloader` 为 `cafebabe` fat 壳包单 arm64 切片。用 `lipo -thin arm64` 抽出 → 加固 thin → `lipo -replace arm64` 回填,保持 fat 结构与原签名壳。
- **逐级签名**:改写后自底向上 `codesign -f -s -` 各 `.framework`,再签主 `.app` bundle。
- **注入前体检**:`batch.py` 先扫全包,报告每个 Mach-O 的命中数、注入余量(首节偏移−load command 末尾)、`cryptid`。本包 30 个 framework + 主二进制共命中,余量全部 >8KB(所需 72B),`cryptid` 全 0——无一受阻。
真实目标 `appstore.ipa` 整包结果(43 个 Mach-O/切片):
| 范围 | 命中 | 结果 |
| --- | --- | --- |
| 主二进制 readoor31OtherPay | 336 | → 0 |
| 30 个 framework(含 3 个 fat) | 542 | → 0 |
| **全包合计** | **878** | **→ 0** |
命中最多:AliyunPlayer 103、TTNetworkManager 56、ATAuthSDK_D 39、WCDBSwift 27。全包 `_dlsym` 312 居首(媒体/网络 SDK 动态加载)。改写后:整包复扫 0 命中;fat 容器仍 `cafebabe`+arm64;主二进制与各 framework `codesign -v` 全 PASSED;`otool -l` 干净;重打包成 IPA 再解包复扫仍 0——独立复现。
命令:
```bash
cd tools/macho_guard
python3 -I batch.py <App.app> # 全包命中/余量体检
python3 -I macho_guard.py harden-bundle <App.app> # 整包加固 + 逐级重签
```
## 8. 下一步(未完成项,如实列出)
1. **送检 V4.6.6**:验证 09 §1 核心假设。过 → 收工;仍命中 → 09 §3 阶梯 A(dlsym 表 + 名字加密)。这是唯一能证实"桥接即过"的步骤,尚未做。
2. **真机功能回归**:讯飞语音、书籍下载/解压(ZipZap/ZIPFoundation/SSZipArchive)、AliyunPlayer 播放、GCDWebServer——878 处改写后未验证运行时行为。改写只动调用目标(桥接 ABI 透明尾调用),风险低但需实测确认。
3. **正式签名**:ad-hoc 仅够静态扫描;真机安装/提审需开发者身份 + entitlements + Provisioning 保留(整包重签需 `--entitlements` 逐包传递)。
4. **arm64e / __auth_stubs**:本包全为 arm64(常规 `__stubs`+`__got`)。若后续样本含 arm64e 切片,需处理认证指针桩(`__auth_stubs`/`__auth_got`)——当前未覆盖。
5. **运行时防护正交项**(05 计划):GOT 完整性校验、反调试——静态改写不覆盖,Frida 等运行时 Hook 仍需单独处理。
+90
View File
@@ -0,0 +1,90 @@
# 11 · 运行时防 HOOK Defender C 模块
日期:2026-11-10。状态:**模块实现 + iphoneos 交叉编译 + 宿主正向自测通过**。按 docs/05 §5.C 设计原则落地;真机接入与业务回归未做。
关联:报告威胁与运行时防护设计见 [05](05_READOOR_SECURITY_REMEDIATION_PLAN.md) §4/§5.C;与静态改写器([10](10_MACHO_GUARD_SELFTEST.md))正交——改写器改变自研规则下的直接分支形态,本模块防运行时 HOOK 导致的信息泄露,两层都要。
> 后续已将宿主测试固化为 `tests/test_defender_host.py` 和 `tests/fixtures/defender_host.c`,覆盖正常环境、符号不可用、提供方异常、环境变量、镜像特征及真实 GOT 槽重绑定,并交叉编译三个模块。本轮 7 项通过,日志随 [13](13_REPRODUCIBLE_BASELINE.md) 归档。inline Hook 真机正向测试仍未完成。
## 1. 定位
报告描述的"HOOK 关键系统函数 → 信息泄露"是**运行时威胁**,静态改写(`macho_guard`,桥接仍走同一 GOT 槽、ABI 透明)**防不住**。本模块是独立的运行时完整性探针,纯 C、无 Swift/OC 依赖,可直接编入任意 iOS target。
遵循 docs/05 §5.C 原则:**探针与处置分离**——只采集证据经回调上报,返回 `clear/detected/unavailable`(unavailable 不等于安全),**绝不自行 `exit`**,是否限制功能由上层策略决定(观察模式优先)。
## 2. 覆盖的 HOOK 形态
| 探针 | reason | 检测手段 | 对应攻击 |
| --- | --- | --- | --- |
| 符号提供方 | 100 `SYMBOL_PROVENANCE` | `dlsym`→`dladdr`,宿主镜像须系统路径 | dyld interpose / 注入 dylib 抢占符号定义 |
| inline hook | 101 `INLINE_HOOK` | 关键函数序言首指令为无条件 B,或 LDR-literal+BR x16/x17 蹦床 | Frida Interceptor / Dobby inline patch |
| **GOT 重绑定** | 102 `GOT_REBIND` | 运行时遍历自有镜像非惰性 `__got` 槽(fishhook 同款 loader 走法,用于**校验**),当前值去 PAC 后≠trusted 且提供方非系统 | fishhook 类 GOT/符号指针改写 |
| 注入镜像 | 200 `INJECTED_IMAGE` | 已加载镜像名匹配 frida/substrate/cycript/dobby… 特征 | 越狱注入框架加载 |
| Bundle 外镜像 | 201 `FOREIGN_IMAGE` | 非系统且不在 `.app` 内的镜像(弱信号) | 未知 dylib 载入 |
| DYLD 插入 | 202 `DYLD_INSERT` | `DYLD_INSERT_LIBRARIES` **逐条**解析(非整串前缀,对应 05 §4 P1),条目在 Bundle 外即报 | `DYLD_INSERT_LIBRARIES` 注入 |
| Frida 线程 | 203 `FRIDA_THREAD` | `task_threads`+`THREAD_EXTENDED_INFO` 线程名匹配 gum-js-loop/gmain/pool-frida… | Frida 运行时驻留 |
| Frida 端口 | 204 `FRIDA_PORT` | 非阻塞 connect 127.0.0.1:27042(默认关,弱信号) | Frida 默认监听 |
全部基于公开 API:`<dlfcn.h>`、`<mach-o/dyld.h>`、`<mach-o/loader.h>`/`<nlist.h>`、`task_threads`/`thread_info`、BSD socket。
## 3. 文件与接口
```
defender/
include/IGDefender.h 结果模型(IGStatus/IGReason/IGFinding/IGFindingSink)+ ig_defender_scan
anti_hook/IGAntiHook.{h,c} ig_anti_hook_check(names,count,sink,ctx) / _default
anti_frida/IGAntiInject.{h,c} ig_anti_inject_check(bundle,sink,ctx) / ig_anti_frida_check(port,sink,ctx)
IGDefender.c ig_defender_scan 聚合
```
结果模型(`IGFinding`):`status` + `reason` + `subject`(符号/镜像/线程名)+ `evidence`(地址/提供方/端口人读文本)。探针对每条 DETECTED/UNAVAILABLE 调 `sink` 一次,CLEAR 不上报。
接入(观察模式,启动/回前台/关键操作前):
```c
static int sink(const IGFinding *f, void *ctx) {
// 上报打点;按 f->reason 组合决定策略,勿在此直接 exit
return 0;
}
int hits = ig_defender_scan(bundle_path, /*probe_port=*/0, sink, ctx);
```
## 4. 验证证据
**iphoneos arm64 交叉编译**(可编入 App 的证明):三个 `.c` 以 `-arch arm64 -miphoneos-version-min=15.0 -O2 -Wall -Wextra` 全部 OK,`ar` 打包 `libIGDefender.a`(arm64),导出 `_ig_anti_hook_check / _ig_anti_hook_check_default / _ig_anti_inject_check / _ig_anti_frida_check / _ig_defender_scan`。
**宿主 arm64 行为自测**:
| 场景 | 期望 | 实测 |
| --- | --- | --- |
| 干净环境 anti_hook(12 符号 provenance+inline+GOT) | 0 命中 | 0(无误报) |
| 干净环境注入扫描 | 0 | 0 |
| 正向:`DYLD_INSERT_LIBRARIES=/tmp/evil:/var/x/hook` | 逐条报 DYLD_INSERT | 2 条 DYLD_INSERT(+1 FOREIGN,均正确) |
| 正向:`dlopen` 名含 frida 的 dylib | INJECTED_IMAGE | 命中,证据含匹配特征 |
| 正向:fishhook 式篡改 `getpid` 的 `__got` 槽指向本程序函数 | GOT_REBIND | DETECTED reason=102,证据含槽址/当前值/非系统提供方/期望值 |
| Frida 线程扫描(无 frida) | 0 | 0 |
GOT 重绑定——即用户点名的"GOT 完整性校验"——以真实篡改正向验证抓得到,且篡改前零误报。
## 5. 边界(如实声明)
1. **架构**:仅 arm64/x86_64(LP64)。**arm64e `__auth_got`** 槽为认证指针,比较前 `ptrauth_strip`;若工具链无 ptrauth 则对认证槽判 unavailable,不强行比较。本包 appstore.ipa 全 arm64,无此问题。
2. **惰性槽**:只对非惰性 `__got`(`S_NON_LAZY_SYMBOL_POINTERS`)判 rebind;`__la_symbol_ptr` 首次调用前可能仍指 helper,不误判,由 provenance/inline 层兜底。
3. **inline hook 正向未测**:序言检测仅验证了 12 个真实系统函数的零误报路径;正向 patch 需改写共享缓存代码页(真机受保护),宿主不可行,留真机验证。检测逻辑本身保守(仅 B / LDR+BR 蹦床),低误报。
4. **特征可规避**:镜像名/线程名/端口均为可改写特征,命中是强/弱证据,未命中不等于干净——故 05 §5.C 要求组合判定,本模块只给证据不下结论。
5. **只检测不处置**:绝不 exit;策略层须区分构建缺陷/误报/真实攻击,支付/权益仍由服务端校验。
6. **真机接入与回归未做**:启动链接入、冷启/回前台/多 Scene、正常 SDK 合法 swizzling 的误报面均未在真机验证。
## 6. 复现
```bash
# 在 iOSGuard 根目录运行,隔离编译宿主测试并执行正反例,另做 iphoneos/arm64 交叉编译。
python3 -m unittest discover -s tests -p 'test_defender_host.py' -v
```
## 7. 下一步
1. **真机接入**:编入 readoor31(遵守其 AGENTS.md / Skill),启动链调用 `ig_defender_scan`,观察模式跑正常业务,量化误报面(合法 swizzling、调试配置)。
2. **inline-hook 正向测**:真机用 Frida/Dobby 实挂关键函数,确认 reason=101 命中。
3. **策略层**:把 reason 组合映射到受限操作(而非 exit),与 05 §4 指出的 `RDSecurityGuard` 立即 exit 缺陷一并整改。
4. **arm64e 支持**:若后续样本含 arm64e 切片,补 `__auth_got` 认证槽校验。
5. 与静态层串联:`macho_guard`(静态改写,厂商复测待完成)+ 本模块(防 HOOK)+ 可选 Plan A(dlsym+名字加密,消静态调用关系)。
@@ -0,0 +1,83 @@
# 12 · 内联原语 + 混淆直发系统调用 + 带校验的符号解析
日期:2026-11-10。状态:**优先级 1、2 实现 + iphoneos 交叉编译 + 宿主正向/反向自测通过**。优先级 3(LLVM/OLLVM/Hikari 混淆、控制流平坦化、字符串/段加密)**不在本轮**。
关联:威胁与运行时防护原则见 [05](05_READOOR_SECURITY_REMEDIATION_PLAN.md) §5.C;运行时探针(provenance/inline/GOT/注入)见 [11](11_RUNTIME_ANTIHOOK_MODULE.md)——本轮复用其 `ig_verify_function` 做「调用前校验」。静态过检见 [10](10_MACHO_GUARD_SELFTEST.md)。本模块与前两者正交:改写器过扫描、探针抓 HOOK、本模块让**核心逻辑自身**不给攻击者可挂的符号点。
## 1. 定位
用户落地方案四维度中的前两级:
- **优先级 1 — 核心逻辑自包含**:关键校验/鉴权/取数据不调用被监控的 libc/系统函数,改用强制内联原语 + 直发 `svc #0x80`,使 `__got`/`__la_symbol_ptr` 里**根本没有**这些符号条目可供 Fishhook 重绑、也没有 libSystem 函数入口可供 inline hook。
- **优先级 2 — 隐藏意图 + 结果验真**:确需 `dlopen/dlsym` 时,库名/符号名编译期 XOR 编码、栈上解密即用即清;解析结果**放行前**过 provenance + 序言校验,把被挟持的实现挡在调用前。
方案 §4「导入表/指针完整性自检」已由 [11](11_RUNTIME_ANTIHOOK_MODULE.md) 的 GOT/provenance 探针覆盖,本轮不重复。
## 2. 交付物
```
defender/
primitives/IGInline.h 纯头,IG_AINLINE 原语:ig_strlen/memcmp/memcpy/memset/strcmp/strncmp/strstr
syscall/IGSyscall.{h,c} 混淆直发 svc:ig_syscall6 + getpid/write/read/open/close/exit/is_debugged
resolve/IGResolve.{h,c} 加密名 dlopen/dlsym + 放行前校验 + ig_getenv(_NSGetEnviron)
anti_hook/IGAntiHook.{h,c} 新增公开 ig_verify_function(addr,name,sink,ctx)(复用 provenance+序言逻辑)
```
### 2.1 内联原语(IGInline.h)
`IG_AINLINE = static inline __attribute__((always_inline))`。使用处直接展开为离散指令,不生成 `bl`、不产生导入表项,从导入表抹除 strcmp/memcmp/memcpy/strstr/strlen 等特征。**定位是「隐藏特征」非「更安全实现」**——不做常量时间比较,防时序侧信道需另行处理。
### 2.2 混淆直发系统调用(IGSyscall)
- **ABI(本会话真机/宿主实测)**:调用号入 `x16`,arm64 BSD 调用**不加** `0x2000000`(那是 x86_64 的 class 位);参数 `x0..x5`;`svc #0x80`;返回 `x0`,出错时 carry 置位、`x0=errno`。封装对出错统一返回 `-errno`。
- **号混淆**:调用号不以 `movz x16,#n` 立即数出现。调用方传 `IG_SC(n)=n^0x5a`,运行期与 `volatile long ig_sc_key` 异或还原后入 `x16`。反汇编 `ig_sys_getpid` 实证:`eor x16, <mem>, #0x4e`(`0x4e=20^0x5a`),真实号 20 不出现;`ig_syscall6` 连立即数都没有(`eor x16, x9(mem), x0`)。还原真实号需运行期取 `ig_sc_key`。
- **调试器检测** `ig_sys_is_debugged()`:直发 `sysctl({CTL_KERN,KERN_PROC,KERN_PROC_PID,pid})` 读 `kinfo_proc` 内 `extern_proc.p_flag & P_TRACED(0x800)`。偏移 `0x20` 由本机 `offsetof(struct kinfo_proc,kp_proc)==0` + `offsetof(struct extern_proc,p_flag)==32` 实测确定(非猜测,见 scratchpad/off.c)。不经 libc sysctl,规避对其 hook。**按 05 决定不含非公开 ptrace(PT_DENY_ATTACH)**,仅做公开 API 检测,处置交策略层。
### 2.3 加密名 + 带校验解析(IGResolve)
- 库名/符号名编译期 XOR(`IG_ENC_KEY=0x3C`),运行期 `ig_decrypt` 栈上解密、`ig_wipe`(volatile 防 DCE)即用即清,明文不驻留 `__cstring`。
- `ig_dlsym_verified`:解析后调 `ig_verify_function`,provenance(提供方须系统路径)+ 序言(非 inline-hook 蹦床)双过才返回地址,否则返回 NULL(视作被挟持拒用)。
- `ig_getenv`:经 `_NSGetEnviron()` 手工遍历,规避 getenv 符号/hook。
## 3. 验证证据
全部 arm64。iphoneos:五个 `.c` 以 `-O2 -Wall -Wextra` 编译 OK,`ar` 成 `libIGDefender.a`,导出 `ig_syscall6 / ig_sys_{getpid,write,read,open,close,exit,is_debugged} / ig_decrypt / ig_wipe / ig_dlsym_verified / ig_dlopen_hidden / ig_getenv / ig_verify_function` 及 [11] 原有符号。
宿主 arm64 行为自测:
| 场景 | 期望 | 实测 |
| --- | --- | --- |
| `ig_sys_getpid` vs libc getpid | 相等 | 相等 |
| `ig_sys_write(1,…)` 直发 | 写出、返回字节数 | OK(27/27) |
| `ig_sys_open`/`read`/`close` 正常文件 | 成功 | fd=3、读 8B、close=0 |
| `ig_sys_open` 不存在路径 | 返回 `-errno` | -2(-ENOENT) |
| `ig_sys_is_debugged` 普通运行 | 0 | 0 |
| `ig_sys_is_debugged` lldb 下 | 1 | 1(P_TRACED 命中) |
| 反汇编 `ig_sys_getpid` 查立即数 | 不含真实号 20 | 仅见 `#0x4e`(编码值),真实号运行期还原 |
| `ig_decrypt` XOR 往返 | 还原明文 | "getpid" 一致 |
| `ig_dlsym_verified` 干净 libc 符号 | 非 NULL | getpid/dlsym/fopen 均解析 |
| `ig_dlsym_verified` 自身二进制符号(非系统提供方) | **NULL(拒用)** | **REJECTED**(provenance 挡住) |
| `ig_getenv(PATH)` / 缺失变量 | 命中值 / NULL | 正确 |
## 4. 边界(如实声明)
1. **仅 arm64**。直发 svc 绕过 libSystem,跨 iOS 版本调用号/ABI 稳定性由调用方负责;Apple 审核可能关注直发 svc,非 App Store 主线,用于确需防 hook 的关键路径。
2. **混淆非加密**:svc 号掩码、字符串 XOR 密钥均在二进制内,决心足够的逆向者可还原——目标是**抬高静态分析成本**,不是密码学强度。与 svc 号混淆、[10] 桥接同理。
3. **dlopen/dlsym 仍被调用**:仅隐藏其**参数**并对**结果验真**;若需连调用点也抹除,走 Export Trie 手工遍历(IGResolve 预留方向,当前以 dlsym 为主路径)。
4. **原语是隐藏特征非更安全实现**:不做常量时间比较。
5. **is_debugged 只检测不处置**:返回三态(1/0/-1),是否限制由策略层决定;不含非公开反调试手段。
6. **真机接入与业务回归未做**:关键路径替换为 `ig_sys_*`/`ig_dlsym_verified` 后的功能正确性(讯飞语音、下载解包、AliyunPlayer、GCDWebServer)需真机验证。
## 5. 复现
```bash
cd defender
for f in anti_hook/IGAntiHook.c anti_frida/IGAntiInject.c IGDefender.c syscall/IGSyscall.c resolve/IGResolve.c; do
xcrun --sdk iphoneos clang -arch arm64 -miphoneos-version-min=15.0 -O2 -Wall -Wextra -I . -I include -c "$f" -o "/tmp/$(basename ${f%.c}).o"; done
xcrun --sdk iphoneos ar rcs /tmp/libIGDefender.a /tmp/*.o
# 宿主自测:scratchpad sctest.c(svc)、rtest.c(resolve)、ntest.c(拒用负例)、off.c(p_flag 偏移)
```
## 6. 下一步
1. **真机接入**:把关键校验/取数路径改用 `ig_sys_*` + `ig_dlsym_verified`,跑正常业务量化功能/性能影响。
2. **调用点进一步隐藏**:对最敏感路径以 Export Trie 遍历替换 dlsym 调用点。
3. 与 [11] 串联:启动链先 `ig_defender_scan`(观察模式),核心逻辑用本轮原语/直发/验真解析;策略层按 reason 组合限制功能(而非 exit)。
4. 优先级 3(控制流平坦化 / 字符串段加密 / 商用壳)为后续独立评估项,不在本轮。
+91
View File
@@ -0,0 +1,91 @@
# 13 · 基线固化与可复现验证
日期:2026-11-10。本轮完成基线、自动化测试与静态证据归档,没有修改原 readoor 工程或副本业务代码,也未执行真机测试或向外部检测平台送检。
## 1. 本轮结果
| 检查 | 结果 |
| --- | --- |
| 输入 | 根目录 `appstore.ipa`,v2.199.0 / build 2.199.0.3 / `com.ecnup.aSCLdl2` |
| 主可执行文件 | `readoor31OtherPay` |
| 输入 SHA-256 | `ddb89e30c2259b45d3f09dbc825e70c4e84c682a3c23510ceb3aa6f93d891771` |
| 自研直接分支扫描 | 43 个 Mach-O,31 个发生改写,878→0 |
| 逐指令校验 | 878 个目标分支保留 BL/B 类型,桥接指向原 GOT 槽;其余 `__text` 指令保持一致 |
| UUID / 结构 | 前后 UUID 一致,已记录每个文件及切片;LINKEDIT 偏移检查及 `otool -l` 解析通过 |
| 签名 | 嵌套 bundle / dylib 从内向外 ad-hoc 签名,逐个 `codesign --verify --strict` 通过 |
| 重打包验证 | 新 IPA 解包后重新扫描为 0,Mach-O 哈希与打包前一致 |
| 自动化测试 | 28 项通过,未跳过:静态库重定向 15 项、Mach-O 6 项、运行时宿主/交叉编译 7 项 |
| 原始输入 | 归档前后哈希一致 |
当前输入**不是原漏洞报告的同一个包**。报告为 v2.197.2 / `com.ecnup.azZVz02`,其对应 IPA 尚未确认取得。本轮只证明当前 v2.199.0 同版本前后比较成立,不得表述为原报告已通过。
核对最初复制时保存的原工程指纹:讯飞库和 `Podfile.lock` 一致,原工程 `project.pbxproj` 已有 SJTU OAuth 业务引用差异。本轮没有写入或回退原工程;差异及观测哈希记录在结果索引中。当前验证以冻结的 IPA 为准,不把持续开发中的原工程当作静止基线。
## 2. 复现入口
在工程根目录运行(macOS、Xcode、Python 3.11;无需安装 Python 第三方依赖):
```bash
python3 tools/macho_guard/verify_baseline.py appstore.ipa \
--output test-results/verification/new-run
```
输出目录必须不存在,避免覆盖既有证据。工具会复制输入、冻结相关源码、运行冻结源码的全部测试、解包扫描、仅改写命中文件、逐级签名、逐指令校验及重新打包复扫。遇到命令失败、加密输入、未覆盖架构、空间不足或不一致时中止,已创建目录内记录 `status=failed`,不能作为通过证据。
复现指相同源码和输入下得到一致的调用点统计及检查结论;ZIP 时间戳、签名和运行地址可能变化,不要求每次输出 IPA 逐字节一致。
## 3. 证据位置
本次有效归档:`test-results/verification/20261110-step1-final/`。先前 `20261110-appstore-step1/` 是初次运行,仅保留作为过程记录;引用本轮结论以 `step1-final` 为准。
| 文件 | 用途 |
| --- | --- |
| `manifest.json` | 输入版本/哈希、工具哈希、环境、统计及未完成的验收项 |
| `source-snapshot/`、`source-files.json` | 当次改写器、静态库工具、Defender、测试及 fixture 的源码快照和哈希;不依赖未提交的 Git 状态 |
| `baseline/input.ipa`、`baseline/unpacked/` | 同一个原始输入及解包内容 |
| `guarded/guarded.ipa`、`guarded/unpacked/` | 加固输出及打包前内容,供后续静态复测准备使用 |
| `before-binaries.json`、`after-binaries.json` | 每个 Mach-O 的 SHA-256、切片大小、UUID、段结构、各符号命中数 |
| `before-callsites.csv`、`after-callsites.csv` | 逐调用点地址、分支类型及符号;加固后为空清单(保留表头) |
| `rewrites.json` | 每个被改写文件的改写数及符号明细 |
| `before-files.json`、`after-files.json` | 完整 Payload 文件哈希清单,符号链接单独记录 |
| `repacked-binaries.json`、`repacked-callsites.csv` | 新 IPA 重新解包后的验证记录 |
| `commands.log` | 实际执行命令、输出及退出码,包括 28 项测试、签名和结构检查 |
| `evidence-hashes.json` | 全部归档文件的校验清单,不含自身 |
大文件位于 Git 忽略的 `test-results/`,已保存在本地,不会自动随源码提交。迁移或长期保存应复制整个有效归档目录。小型结果索引保存在 `docs/evidence/20261110-step1-summary.json`。
校验归档完整性(工程根目录):
```bash
python3 - <<'PY'
import hashlib, json, os
from pathlib import Path
root = Path('test-results/verification/20261110-step1-final')
for record in json.loads((root / 'evidence-hashes.json').read_text()):
path = root / record['path']
if 'symlink' in record:
assert path.is_symlink() and os.readlink(path) == record['symlink'], path
else:
h = hashlib.sha256()
with path.open('rb') as f:
for block in iter(lambda: f.read(1024 * 1024), b''):
h.update(block)
assert path.stat().st_size == record['size'] and h.hexdigest() == record['sha256'], path
print('归档校验通过')
PY
```
## 4. 新增的测试与拒绝条件
Mach-O 测试由 Apple 链接器生成 iOS arm64 样本,覆盖真实分支改写、原 GOT 地址保留、UUID、重复注入、输入覆盖、架构不支持、截断、加密、header 空间不足及 ZIP 路径逃逸。修正了 LINKEDIT 字段所在命令位于新插入命令前方时,不应统一将字段位置右移 72 字节的问题。
运行时测试只在独立宿主进程中运行:正常环境零告警、缺失符号上报 unavailable、本地函数提供方异常、两个环境变量条目分别上报、加载无害的特征名测试 dylib、真实 GOT 槽改指测试函数后命中 reason=102。另对三个 Defender 模块做 iphoneos/arm64 交叉编译。没有修改系统函数代码,也没有进行 inline Hook 真机验证。
## 5. 尚未完成的验收
1. V4.6.6 外部复测:自研扫描规则来自报告示例的推断,878→0 不等于厂商扫描清零。
2. 开发者身份、entitlements、Provisioning 下的真机安装与业务回归:当前 ad-hoc 结果只用于本地静态验证。
3. Defender 在 App 启动、回前台的实际调用与正常 SDK 误报检查,以及受控 inline Hook 正向验证。
4. 原报告对应包及同版本前后厂商复测对照。
后续进入第二步:在 `readoor-test` 的 `readoor31` 上核实接入并制作真机观察包,继续使用 ZipZap;不切回已知打包失败的旧 `readoor` target。
+123
View File
@@ -0,0 +1,123 @@
# 14 · ZipZap 三层防护试点与验收记录
日期:2026-11-10。范围为 iOSGuard 和工程内 `readoor-test` 副本;原工程 `/Users/shenlei/Work/ReadBook/readoor` 未写入。沿用 `readoor31` target 和 ZipZap,不切回构建失败的旧 target。
后续观察构建、45 项当前测试和独立业务包状态见 [观察包业务回归](15_OBSERVATION_BUSINESS_REGRESSION.md);下文 44 项是第二步冻结证据,不覆盖业务回归。
## 1. 本次完成范围
| 层次 | 已实现 | 验证边界 |
| --- | --- | --- |
| 直接调用关系 | 使用同次 Release Link Map,把 ZipZap 两处 BL 改指向已链接的调度入口 | 精确核对调用者/入口符号地址、改写次数、分支范围,其他指令字节不变 |
| 桥接后的目标追踪 | 符号名编码、首次运行时解析、校验、缓存、间接调用 | 最终 Release 为 `br x3` / `br x1`;不是原来的 GOT 转接;不能据此认定静态分析无法恢复目标 |
| 运行时 Hook | 接入 Defender;保留提供方、GOT、序言探针,新增缓存指针和初始代码前缀检查 | 宿主真实 GOT 改指、真机独立诊断私有缓存篡改拒绝等通过;受控真机 inline Hook 与完整业务回归仍待完成 |
仅覆盖两个调用点:
```text
-[ZZFileChannelOutput writeData:error:] → IG_dispatch_write → 校验后的 write 地址
-[ZZFileChannelOutput close] → IG_dispatch_close → 校验后的 close 地址
```
这是一轮试点,尚未推广至讯飞、AliyunPlayer 或全部报告函数。没有在同一产物上叠加旧的整包 GOT 桥接改写。副本中的 ZipZap 已恢复原始静态库,避免先重定向成 `IG_write/IG_close` 后又重复改写;其之前状态保存在 `test-results/step2/before/`。
## 2. 实现位置与顺序
- `tools/macho_guard/redirect_to_runtime.py`:链接后定点改写与有界追踪。
- `tools/macho_guard/profiles/zipzap.json`:调用者、原符号、目标入口及预期次数。
- `defender/dispatch/IGDispatch.{c,h}`:固定 C 签名入口、`pthread_once`、线程重入防护、原子缓存。
- `defender/resolve/IGResolve.{c,h}`:解析结果区分 CLEAR / DETECTED / UNAVAILABLE,拒绝无效或截断的符号名。
- `defender/anti_hook/IGAntiHook.{c,h}`:提供方、GOT、arm64 序言检查;代码读取使用 `vm_read_overwrite`,读失败不冒充正常。
- `defender/IGDefender.c`:聚合调度完整性检查。
- 副本的 `Base/Security/IGDefender/`:同步上述模块,通过 `scripts/add_igdefender.rb` 加入现有 target。
执行顺序为:先编译并链接运行时入口 → 保存同次 Link Map → 在可执行文件副本上改写指定分支 → 从内到外签名 → 打包与复核。实际签名发布时,必须在改写后使用匹配的开发者身份、profile 和 entitlements;下一次 Xcode 构建会生成新的未改写文件,需重新执行改写。当前尚未自动接入每次 Archive。
`dlsym/dlopen` 等解析器启动依赖保留原调用,不能把启动依赖再重定向回依赖自身的解析器。新增函数必须逐个适配 ABI、错误返回和所有权语义,不能把可变参数、结构体返回或 C++ 调用一律转换为通用 `void *` 函数。
## 3. 运行语义与处置
首次解析地址必须通过提供方和序言检查;初始化后保存地址及前 16 字节。每次 `write/close` 前复核缓存、提供方、序言和代码前缀。正常调用恢复进入时的 `errno`,保留系统函数返回值;不重试 `EINTR`,不补齐短写,不重复 `close`。
调度入口本身拒绝不可信调用:篡改返回 `-1/EACCES`;校验不可用返回 `-1/ENOSYS`;解析重入返回 `-1/EDEADLK`。**这部分不受 Swift 观察模式控制**,可能使解包写入或关闭失败,必须真机覆盖 ZipZap 下载、解包、取消和错误路径后再发布。
Swift 策略单独保留 `unavailableReasons`,观察模式记录,强制模式拒绝不可用或强信号对应的已接入新支付入口。`RDOrderViewController.payOrder()` 新增 `allowsSensitiveOperation(.beforePayment)`;已有 Apple 待处理交易的验证/补单沿现有分支继续,避免阻断交易收尾。其余支付、VIP、登录和激活入口尚未逐一接入。`applyDecision` 的日志本身不会限制所有入口。
启动重复调用共用一次评估,回前台与选定支付入口重新扫描;前台观察者只注册一次,评估状态统一到主线程。扫描目前同步执行,尚未完成启动、支付前扫描及高频文件写入的真机耗时测量。
## 4. Release 与静态证据
有效归档:`test-results/step2/zipzap-runtime-final-v3/`。`test-results/step2/zipzap-runtime-final/` 是 Link Map 编码问题导致的失败记录,不作通过依据;`-v2` 为之前的通过记录,本轮以 `-v3` 为准。
| 检查 | 结果 |
| --- | --- |
| 构建 | `readoor31` / Release / iphoneos arm64,通过;OtherPay 同步接线但未单独构建 |
| 本次产物版本 | `2.156.0` / `2.156.0.1` / `com.ecnup.aSCLdl2` |
| 自动化测试 | 44 项通过,无跳过,执行冻结源码 |
| 本次整包直接分支规则 | 558→556,仅定点减少 2 处 |
| write 调用点 | `0x100c1f604` → `_IG_dispatch_write` `0x100485924` |
| close 调用点 | `0x100c1f800` → `_IG_dispatch_close` `0x100485a5c` |
| 调度对象导入 | 无 `_write` / `_close` / `_memcmp` |
| Release 测试后门 | 最终 App 无 `ig_dispatch_test_*` 符号 |
| 静态追踪 | 两处原目标 stub 路径消失;两个调度入口存在未解析间接分支 |
| 结构/打包 | 原构建文件不变、UUID 不变、嵌套 ad-hoc 签名及严格验证、重打包后扫描和哈希一致 |
测试包括:文件调用语义/errno、短写/EAGAIN、EINTR 不重试、并发、构造阶段调用、初始化失败、解析重入、缓存篡改拒绝、解析失败、arm64 序言指令分类、真实宿主 GOT 改指、Swift 观察/强制策略,以及改写工具的拒绝路径。arm64 指令分类测试不等于真机实际修改系统代码后的检测。
主要证据:`manifest.json`、`redirect-report.json`(逐调用点及前后追踪)、三个 `.asm`、`IGDispatch-imports.txt`、`source-snapshot/`、`source-files.json`、`commands.log`、`build-release.log`、`guarded.ipa`、`evidence-hashes.json`。大文件由 Git 忽略,需单独备份。
第一步 `test-results/verification/20261110-step1-final/` 的 v2.199.0 / OtherPay / 878→0 归档保持独立,不与本次新构建的 558→556 混用。原漏洞报告为 v2.197.2 / `com.ecnup.azZVz02`,本轮仍不是原报告同一二进制。
## 5. 复现命令
在 iOSGuard 根目录,先构建:
```bash
xcodebuild build -workspace readoor-test/readoor.xcworkspace \
-scheme readoor31 -configuration Release -sdk iphoneos \
-destination 'generic/platform=iOS' -derivedDataPath test-results/DerivedData \
-jobs 4 CODE_SIGNING_ALLOWED=NO CODE_SIGNING_REQUIRED=NO \
COMPILER_INDEX_STORE_ENABLE=NO LD_GENERATE_MAP_FILE=YES
```
保存构建日志后验证(输出目录必须不存在):
```bash
python3 tools/macho_guard/verify_runtime_pilot.py \
--app test-results/DerivedData/Build/Products/Release-iphoneos/readoor31.app \
--link-map test-results/DerivedData/Build/Intermediates.noindex/readoor.build/Release-iphoneos/readoor31.build/readoor31-LinkMap-normal-arm64.txt \
--dispatch-object test-results/DerivedData/Build/Intermediates.noindex/readoor.build/Release-iphoneos/readoor31.build/Objects-normal/arm64/IGDispatch.o \
--build-log test-results/step2/build-release.log \
--output test-results/step2/new-runtime-run
```
构建日志、Link Map、对象文件必须来自同一次构建;更换日志路径时同步参数。Link Map 符号地址与实际二进制不一致会拒绝,不能用旧 Map 套新包。
## 6. 仍能被恢复或绕过的路径
1. 入口名仍提示用途;编码名可以解码;`dlsym/dladdr` 仍可识别。本轮提高简单调用图追踪成本,没有实现不可静态分析。
2. 自研追踪只对本地 BL/B、有界深度、报告的 12 类系统 stub 和经典 GOT 桥接做检查,不解析所有寄存器数据流、TLS、初始化回调或符号解码。未解析间接调用不构成安全证明。
3. 提供方路径白名单不是签名身份验证;`dlsym/dladdr/vm_read_overwrite` 自身也可能被攻击者干扰。现有 GOT 检查仍允许部分系统内转发,不能覆盖全部重绑定方式。
4. 初始代码快照可能在攻击后建立;同进程攻击者可同时修改缓存、期望值或校验函数。前缀之后的改写及校验与调用之间的竞态仍存在。
5. 当前序言只覆盖部分 arm64 蹦床,不能识别所有 Hook,也可能把合法的系统转发判成异常;arm64e/PAC 及不同系统版本需要独立验证。
6. 未完成完整 App 业务回归、受控真机 inline Hook、所有正常 SDK 误报与性能统计、原报告同版本及 V4.6.6 厂商复测,不能宣称报告问题全部解决。
## 7. 回滚与后续验收
`test-results/step2/before-state.json` 记录改动前哈希,`before/` 保存工程、安全入口、ZipZap 和既有 Defender 文件。回滚应恢复相互匹配的工程配置与整套模块,并移除本轮新增源引用;不要只恢复一个静态库或仅删除调度模块。订单控制器仅撤销本轮 `payOrder()` 安全门禁插入,保留其他既有修改。
只需取消链接后改写时,使用归档 `baseline/Payload/readoor31.app` 或重新构建未改写 App;仍需按分发方式重新签名。默认观察模式仅控制 Swift 业务门禁,不是调度层回滚开关。
独立诊断真机验证已完成,见下一节。下一验收顺序:合法签名的 App 观察包执行下载/解包及支付收尾回归 → 受控真机提供方/GOT/inline Hook 正向验证与性能测量 → 固定同版本输入向 V4.6.6 复测。通过后再按 ABI 分类推广到其他调用者。
## 8. 独立诊断真机结果
设备:iPhone 16 Plus,设备工具报告 iOS `27.2`。使用现有通配开发 profile 签名,测试专用 Bundle ID 为 `cn.touchv.iosguard.dispatchpilot.20261110`;安装前确认不存在同名应用,测试后已卸载。没有安装覆盖现有 readoor。
有效记录:`test-results/step2/device-dispatch-v5/`。`console.log` 包含明确的 8 个逐项 PASS 与最终 PASS,`launch.json` 记录 exitCode=0;Defender 正常环境扫描 `detected=0 / unavailable=0`。通过项为:errno/返回值和文件语义、短写/EAGAIN、EINTR 不重试、8 线程并发、解析重入、解析失败、序言指令分类、私有缓存改指后拒绝调用。构造阶段调用由共用 fixture 一并执行。
该程序直接执行共用测试 fixture,再退出诊断进程;没有业务 UI,也不执行真实支付或网络请求。早期使用界面启动回调的诊断尝试未取得逐项结果,不计为通过;`v5` 改为直接执行测试并使用系统日志确认。短写测试的大缓冲区改为堆分配,避免依赖真机线程栈大小。
源码入口为 `tests/fixtures/dispatch_device.m` 和 `tools/macho_guard/build_dispatch_device.py`。构建脚本只接受专用 Bundle ID 前缀和匹配的有效通配开发 profile,不修改开发者门户;安装、运行与卸载单独执行。诊断程序使用 `IG_DISPATCH_TESTING` 允许改自身测试缓存,**不作为业务 App 发布包**。其冻结源码以该诊断目录的 `source-snapshot/` 为准;Release 静态归档独立保存同次构建与宿主测试输入。
此结果不包含实际修改系统函数代码的 inline Hook,也未在完整 App 中执行 ZipZap 解包。44 项自动化测试与 8 项真机诊断分开统计,不合并宣称整包验收通过。
@@ -0,0 +1,88 @@
# 15 · 观察包业务回归
日期:2026-11-10。用户授权使用提供的测试账号,打开首页任意资源;凭证不写入源码、文档或测试日志,不自动提交真实支付。
## 当前进度
2026-11-11 续测:设备恢复连接,独立观察包已安装并启动;用户完成协议确认、图片验证码及真实账号登录。首页 `[pdf]MW书籍测试读` 的详情及前后台恢复用例通过。首页 `【epub】会员免费书籍` 可进入 EPUB 内容(显示封面/正文和 `1/69`),前后台恢复和冷启动检查通过。业务回归结果为**部分通过**,受保护路径尚未验收。
PDF 试读进入旧阅读器并显示“已下载 100%”后发生 `NSRangeException`:`RBCoreCurlTurningViewController.pageViewController:viewControllerAfterViewController:` 访问索引 2,数组范围为 0…1。未改写同构建基线也复现相同异常和回调,说明该故障并非两处分支改写独有;不据此排除所有加固兼容风险。此次未修改旧阅读器业务代码。
对照基线使用同 Bundle ID/签名/源码构建,保留观察包登录和数据容器,仅撤销 ZipZap 两处分支改写;两包 `__text` 的差异恰为这两条指令所在 8 字节,见 `baseline-comparison-20261111.json`。两份崩溃报告为 `trial-crash-20261111.ips` 和 `pdf-baseline-crash-20261111.ips`,应用标识均已核对为观察包;摘要在 `pdf-ab-comparison-20261111.json`。对照后已恢复加固观察包。自动化用例启动或截图完成不代表阅读内容已成功渲染。
此前 `readoor31` Release 观察构建、45 项宿主/工具测试、独立 Runner 构建通过。观察包完成两处改写、开发签名及嵌套严格验证,IPA 内二进制哈希一致。2026-11-10 安装曾受 CoreDevice 4016/设备离线阻塞,原日志保留;2026-11-11 已解除。宿主/工具测试与业务测试不合并计算。
`security-final-20261111.jsonl` 共 14 条快照,覆盖本轮启动/前台事件(包含加固包与对照阶段),检测及不可用原因均为空;扫描耗时约 4.26–29.87 ms,中位数 14.21 ms。这只是单台设备的小样本,不是性能基准。四个 ZipZap 计数的最大值均为零,故当前业务没有证明命中其受保护文件输出。本轮未扩大保护范围,也未执行支付、异常网络/取消、实际 inline Hook 或厂商复测。
## 观察包
- Bundle ID:`cn.touchv.iosguard.observe.20261110`,显示名:`教育汇·观察`。
- 来源:工程内 `readoor-test` 副本,源码版本 `2.156.0 / 2.156.0.1`;原工程不修改。
- 使用真实登录及网络请求,不启用 `--UITesting` 或项目内假 token 注入。
- 独立数据容器和 Keychain,移除五组 URL scheme,避免与原 App 争用回调。
- 独立 Bundle ID 下的 Apple 登录、关联域、共享 Keychain、外部支付回调和绑定 Bundle ID 的第三方 SDK 授权需要另行验证。
- Swift 安全策略保持观察模式,C 调度入口仍会拒绝篡改、不可验证及解析重入。
## 可观测性
只有定义 `IG_OBSERVATION` 的构建包含只读原子计数:`write_attempted/write_dispatched/close_attempted/close_dispatched`。`dispatched` 表示已调用系统函数,不能解释为 I/O 成功。新增宿主测试验证系统错误仍计入 dispatched、校验拒绝不计入 dispatched,以及普通构建不导出观察接口。
专用 Bundle ID 在既有安全评估事件后写入 `Documents/IGObservation/security.jsonl`,包含事件、模式、扫描耗时、检测/不可用原因编号和调用计数,不包含用户资料、凭证、资源 URL 或原始地址。计数为进程内累计,冷启动重置。记录是事件快照;完成资源操作后需触发前后台评估再读取。
## 已确认的业务调用链
当前两个保护点为 ZipZap 的 `ZZFileChannelOutput.writeData:error:` 和 `close`。新版 PDF/单词书下载解压链为:
```text
RDWordBookHandler → RDPDFDownloadAPIService.downloadAndUnzip → SSZipArchive.unzipFile
```
源码:`readoor-test/readoor/3.0/Features/ReadView/PDF/Network/RDPDFDownloadAPIService.swift` 和 `readoor-test/readoor/3.0/Features/ReadView/MemorizeWords/Handler/RDWordBookHandler.swift`。旧版 `STSCourseCardLearnHandler.m` 的 ZipZap 调用从 NSData 读取首个条目,不能据此认为执行了受保护的文件输出。
本轮实际 EPUB 的源码解包链为 `BookView/EPUB/Core/Classes/newEpub/epub/EpubParser.extractEpub → STSFileManagerStorage.unzipFileAtPath`。`STSStorage.framework` 的导入和依赖均指向 `SSZipArchive.framework`;已保存 `stsstorage-unzip-import-20261111.txt`。这属于源码及二进制依赖证据,尚未逐调用点采集运行时命中。
包内 `SSZipArchive.framework/SSZipArchive` 为 `MH_DYLIB`,导入 `fopen/fread/fwrite/fclose`。当前定点工具要求入口已链接在同一 Mach-O,不能直接把跨镜像分支写到主程序里的调度入口。扩大保护前需补独立 Framework 内的入口/绑定方案及签名验证,或在可重建 SDK 中编入入口,再按固定 ABI 验证;不能只增加主程序规则并声称已覆盖此 SDK。
因此首页资源运行正常且计数为零时,只能记录业务链未命中 ZipZap 文件输出。下一轮应按实际资源类型确定 SSZipArchive/minizip 调用者、固定 ABI 和预期调用次数,建立基线,再定点扩大保护和对照回归。
## 工具与证据
- `tools/business_regression/prepare_observation_app.py`:校验通配开发 profile、证书和有效期;复制、改写、独立化、签名、打包和生成哈希。`--baseline` 仍核对 Link Map 和预期调用点,但丢弃分支改写,用于同构建对照。
- `tools/business_regression/create_ui_runner.rb`:生成独立 UI 测试工程,不修改业务工程。
- `tests/business_regression/IGBusinessRegressionTests.swift`:启动、首页资源、试读、EPUB、前后台、冷启动及 PDF 复现用例。当前截图遮盖输入框,文本树删除输入值;初次登录诊断原始 xcresult 已删除,只保留已脱敏附件。
- 证据目录:`test-results/step3/`;构建目录:`test-results/ObservationDerivedData/`。
- 安装包:`test-results/step3/observation-package/observation.ipa`;签名 App 在同目录 `Payload/readoor31.app`。
- 包内 `manifest.json`、`redirect-report.json`、`source-snapshot/`、`commands.log` 和 `evidence-hashes.json` 保留打包当时快照;其中业务 `not_run` 不追写,实际业务结果另见 `docs/evidence/20261111-step3-business-summary.json`。
- `build-observation.log`、`build-ui-runner.log`、`host-tests.log`;安装失败和设备详情日志保留连接问题证据。
观察构建在既有标志上增加 `OTHER_CFLAGS='$(inherited) -DIG_OBSERVATION=1'` 和 `OTHER_SWIFT_FLAGS='$(inherited) -D COCOAPODS -D TARGETTYPE_7 -D IG_OBSERVATION -Xcc -DIG_OBSERVATION=1'`,使用 Release、iphoneos 和同次 Link Map。打包脚本的身份/profile 参数来自本机合法开发签名配置,输出目录必须不存在。
有效 UI 结果包:`home-resource-20261111.xcresult`、`epub-guard-20261111.xcresult`、`cold-restart-20261111.xcresult`。`trial-resource-20261111.xcresult` 只证明试读入口截图完成,其后发生崩溃,不记为阅读通过。`pdf-baseline-20261111.xcresult` 为同构建对照的实际失败记录。每项对应日志和导出附件在同级目录,最终驱动源码及哈希在 `business-run-20261111/`。
用户 2026-11-11 明确暂缓 PDF 越界修复、完整业务回归及报告复测。本轮改用首页 `31单词书(稳操胜券)-勿动` 建立 SSZipArchive 运行时命中证据;ZipZap 原试点仍需能命中文件输出的业务样例。协议确认及验证码均由用户完成。
## 回滚与验收边界
本轮改动前文件及哈希在 `test-results/step3/before/`。只取消观察能力时移除观察编译宏即可;完整恢复时逐个恢复备份对应文件,保留其他改动。观察包可单独卸载。前两轮冻结证据不修改,原报告同版本和厂商 V4.6.6 复测仍待完成。
## 单词书解包观察(2026-11-11)
仅在 `IG_OBSERVATION` 编译时,在 `RDPDFDownloadAPIService.unzip` 紧邻真实 `SSZipArchive.unzipFile` 调用前后记录 `unzip_begin/unzip_end`;单词书正式目录命中记录 `wordbook_cache_hit`。写入独立观察包 `Documents/IGObservation/archive.jsonl`,以随机 call_id 配对,结果包含 success 和耗时,不记录路径、下载地址、用户标识或凭证。串行锁保护并发写入,记录失败不改变原业务返回值。普通构建不包含这些记录。
该记录证明 SDK 边界被调用及其返回结果,不能用于证明 SDK 内部 fopen/fwrite 已被保护。此轮代码、Release 构建和新签名包在 `test-results/step4-wordbook/`,不覆盖此前冻结证据。关闭观察宏即可移除此项能力。
### 单词书实测结果
`read-v2.xcresult` 与 `reentry.xcresult` 两项真机用例通过:从详情的“稳操胜券”课件卡片进入,单词书显示已学 0 词、未学 7502 词,前后台恢复、返回重进均正常。未点击学习/复习或完成学习任务。
`archive-final.jsonl` 记录 1 对真实 `unzip_begin/unzip_end`,SDK 返回 success=true,耗时 12015.24 ms。首次进入时 style/dict 已命中缓存;SDK 边界事件未携带资源类型,因此不将该次调用标成已确认的具体包类型,也不声称覆盖了样式、词库的首次解压。重进时 style/dict/sound 均命中缓存,没有新增解压。未清理用户缓存,未修改服务端资源配置。SDK 成功返回及后续缓存发布可观测,未逐文件校验解压内容。
两次新增前台安全快照均无检测/不可用项,扫描约 17.28/15.07 ms;ZipZap 四项计数均为零。本轮只增加观察能力,没有扩大 SDK 内部函数的保护。下一步需为动态 `SSZipArchive.framework` 制定并验证 Framework 内入口/绑定或可重建 SDK 的保护方案,再对同一单词书进行改写前后对照;不得把本次调用证据当作 fopen/fwrite 保护验收。
Release 构建、Runner 构建、两处既有分支改写、开发签名及严格验证通过,新包 599 个文件哈希核对通过。过程中的失败保留:`detail.xcresult` 被营销弹窗阻挡,`read.xcresult` 因假定存在“开始阅读”按钮失败;已据实际页面调整驱动。`detail-v2.xcresult` 只证明详情壳可达,其截图尚在骨架加载,不单独记为完整详情通过。
最终证据和驱动快照归档到 `test-results/step4-wordbook/business-run/`(39 个文件及哈希清单);摘要为 `docs/evidence/20261111-wordbook-ssziparchive-summary.json`。新包为 `test-results/step4-wordbook/observation-package/observation.ipa`,可执行文件 SHA256 为 `e43f8990acefd09754db275504a15359a87bc05ea2eb5044c3839c67dede731c`。PDF 修复、完整业务回归、报告复测继续按用户要求暂缓。
## 后续 SDK 保护试点
2026-11-11 已继续实现 SSZipArchive 动态绑定保护,新增保护 Framework,覆盖 fopen/fread/fwrite/fclose 四个导入。以相同 Release 主程序进行指定词书样式包解压对照,两包输出 9 文件 / 1,890,776 字节,聚合摘要一致;保护包四个入口实际命中 10 / 388 / 466 / 10 次,均放行且无拒绝。该结果不追写本页此前冻结的业务归档,独立记录见 [SSZipArchive 动态 Framework 保护试点](16_SSZIPARCHIVE_FRAMEWORK_GUARD_PILOT.md),证据在 `test-results/step5-ssziparchive/`。PDF 修复、完整回归和报告复测仍暂缓。
@@ -0,0 +1,63 @@
# SSZipArchive 动态 Framework 保护试点
日期:2026-11-11。范围:工程内 `readoor-test` 副本的独立观察包,以及已审核 SSZipArchive 的四个文件函数导入。PDF 越界修复、完整业务回归和检测报告复测继续暂缓。
## 实施机制
```text
SSZipArchive 原函数调用 → SDK 内原 stub/GOT
→ dyld 绑定至 IGArchiveGuard.framework 的 ig_a0…ig_a3
→ 校验系统提供方、代码前缀、缓存地址和 SDK GOT
→ 间接调用 fopen / fread / fwrite / fclose
```
这里由 dyld 处理镜像间绑定,不把 SDK 的 BL 指令写成主程序地址。SDK 的 `__text` 保持不变,变化在绑定表、符号表、加载命令和重新生成的签名中。不同签名不能用整文件相等代替运行代码相同:最终两包主程序及保护库排除签名后相同,SDK 的 `__text` 相同,见 `package-v2-comparison.json`。
`tools/macho_guard/redirect_framework_imports.py` 同步更新 `LC_DYLD_CHAINED_FIXUPS` 的符号名称/库序号及 `LC_SYMTAB` 的名称/库序号,再在已验证的零填充中增加 `LC_LOAD_DYLIB`。导入索引、指针链、SDK 段地址及机器码不移动。映射为 `_fopen → _ig_a0`、`_fread → _ig_a1`、`_fwrite → _ig_a2`、`_fclose → _ig_a3`;不是运行中全进程 interpose。
当前只接受 thin arm64、two-level 动态库、无压缩且格式为 `DYLD_CHAINED_IMPORT` 的绑定。四个函数必须各有唯一且来自 libSystem 的非 weak 导入;缺失、重复、名称重叠、头部空间不足、格式或摘要变化均拒绝输出。已审核 SDK SHA256:`485c0c95b4701a4e51625e16b6c2a9781c1a8a6f6c9b9cbe392709ecfc95191a`。不支持 arm64e/PAC、其他 chained 格式或任意 SDK 无条件处理。
## 运行时与错误语义
`defender/dispatch/IGArchiveGuard.{c,h}` 固定四种函数签名,以线程安全 once 解析和缓存地址,复用 `IGResolve` 和 `IGAntiHook` 的提供方/序言检查。每次转发校验对应缓存及 16 字节代码基线,同时核对 SDK 四个非惰性 GOT 槽是否仍指向保护入口。缺槽、重复镜像、不可读等标记不可验证。普通转发保留原返回值、系统错误、FILE*、元素计数和 errno,不增加重试。
异常时拒绝:`fopen` 返回 NULL,`fread/fwrite` 返回 0,`fclose` 返回 EOF;errno 分别使用 EACCES(异常)、ENOSYS(不可验证)、EDEADLK(解析重入)。拒绝路径不能移植地设置 FILE 内部 ferror 标志,拒绝 fclose 也可能保留未关闭流。因此该异常状态不能被称为完整 stdio 兼容;业务错误传播、取消和恢复仍需覆盖。保护入口拒绝机制不受 Swift observe 开关控制。
导出的 `ig_archive_check()` 返回 0/1/-1(正常/检测异常/不可验证),仅观察构建导出只读计数 `ig_archive_counter()`。业务库不含地址覆盖和测试豁免;`IG_ARCHIVE_TESTING` 只用于宿主 ABI fixture。主程序在现有安全事件和 SDK 边界读取库状态及计数,记录到独立观察日志,不替换既有 Defender 的原因码和业务策略。普通构建不包含此观察记录;本轮未把新 SDK 状态接入生产强制业务门禁。
## 对照方法
新观察参数 `--IGArchiveReplayStyle` 只在 `IG_OBSERVATION` 且 Bundle ID 为 `cn.touchv.iosguard.observe.*` 时生效。进入指定词书时,将同一样式包重新下载并解压到现有临时目录;正式目录已发布时仍沿原 publish 分支保留正式目录。它不伪造账号、不跳过鉴权、不改服务器数据;无参数时沿原缓存逻辑。
服务在成功解压后记录文件数、总字节及聚合 SHA256,不记录路径、URL、账号、文件名。两包使用同一来源的 Release 主程序和 Link Map;两包均保留既有 ZipZap 两处改写。基线嵌入相同保护库,但 SDK 不依赖它,保留原系统绑定;保护包增加 SDK 依赖和四处导入重定向。聚合摘要只用于两次新解压的对照,不代表远程资源签名校验或可信发布。
阶段中曾尝试备份后通过设备文件服务重置样式缓存,返回 CoreDevice 7000/ActionError 3。此后观察包 Documents 出现重新初始化;现有证据不能区分发生在安装还是目录重置阶段,故停止该清理方式。仅样式缓存此前已有 9 个文件备份,未建立全观察容器备份,不声称所有观察数据已恢复原状。随后真实账号仍可打开词书,页面显示已学 0、未学 7502,词库和音频重新取得;最终有效对照使用不清目录的样式重放。设备操作始终指定独立观察 Bundle ID,未针对原业务 App。原始日志保留,不将该失败尝试当成成功的定点清理。
## 当前验证
- `readoor31` Release 及独立 UI Runner 构建通过;两包嵌套签名严格验证通过,各 615 个文件哈希核对通过。
- 59 项宿主/工具测试通过,其中本轮 14 项:真实 SDK 格式和拒绝路径、stdio 语义、并发、重入、缓存篡改拒绝、普通构建排除测试/观察接口,以及 Apple Silicon 上真实动态 SDK chained binding/GOT 篡改检测、拒绝与恢复。测试 fixture 的可写 GOT 操作只存在于测试源码,未编入业务库。
- 最终 Release 的四个入口均保留间接分支,未发现对原四个系统函数的直接/GOT 导入链;见 `guard-v2-static-traces.json`、`guard-v2-disassembly.txt` 和 `guard-v2-imports.txt`。
- `baseline-v2-wordbook.xcresult` 与 `guard-v2-wordbook.xcresult` 均通过:首页指定资源 → 稳操胜券课件 → 样式下载解压 → 词书页面 → 前后台恢复;显示已学 0 / 未学 7502。
- 基线样式解压约 38.53 ms,保护包约 43.02 ms(增加约 4.48 ms)。单次、单机、不同运行时刻的小样本,不推导总体性能或稳定性指标;记录区间包含开始事件的观察开销,未单独扣除观测成本,不包括网络下载耗时和自动化动画等待。
- 保护包实际 dispatched:fopen 10、fread 388、fwrite 466、fclose 10;与 attempted 一致,rejected 全为零,库完整性状态为 0。四入口共 874 次调用。基线日志 `archive_guard_loaded=false`,保护包为 true。
- 两包输出均为 9 个文件 / 1,890,776 字节,聚合 SHA256 一致:`7043dfcd54c6ce47154feb48b8ff2a19834c5f8cd4c28dabaa012fc96537ed79`。这份对照针对本轮新解压的内容,不据此声称此前缓存备份与远程资源完全一致。
- 保护解压阶段两次既有 Defender 快照无检测/不可用项;SDK 完整性状态单独记录。ZipZap 计数仍为零,不混作 SDK 命中。
`guard-v2-cache-v2.xcresult` 验证无重放参数的正常缓存及返回重进、前后台恢复通过;最新进程 9 条库观察事件均为状态 0,style/dict/sound 命中缓存,没有解压调用,四个函数计数均零(冷启动重置)。此前 `guard-v2-cache.xcresult` 因营销弹窗在自动化等待期间消失而失败,尚未进入资源;失败日志保留。最终保护阶段既有 Defender 共 5 次快照,检测/不可用项均为零;观察状态不等于攻击测试。
## 打包与回滚
在既有 `tools/business_regression/prepare_observation_app.py` 命令上追加 `--archive-guard`,构建嵌入库、改写 SDK,再按从内到外签名和生成 IPA;对照追加 `--archive-baseline`。不能同时加主程序 `--baseline`,避免对照同时改变 ZipZap。输出必须新目录,原 SDK 不写回工程。
最终包位于 `test-results/step5-ssziparchive/{guard-v2-package,baseline-v2-package}/`。取消本轮 SDK 保护可安装已签名基线包或用相同源构建取消 `--archive-guard`;不要在已签名 App 中只删除保护库。取消观察能力时移除宏和专用运行参数,普通构建中观察代码被剔除。备份在 `test-results/step5-ssziparchive/before/`,恢复时仅逐个撤销本轮修改并保留已有工作。
SDK 更新必须重新审查摘要及格式后才更新允许的输入,随后构建、绑定改写和签名步骤可自动执行;此试点不自动信任新版本。
## 验收边界与下一步
当前只覆盖该 SDK 的四个导入,其他 I/O、其他动态库、内部绕过这些导入的路径不在范围。入口名、导入依赖、解析器、地址缓存和混淆常量仍可被静态分析;同进程攻击者可能同时修改校验代码和基线、直接绕过入口。代码前缀检查只覆盖部分常见蹦床,不代表所有 inline Hook 均能拦截。
本轮真机证明正常业务可进入保护路径、输出与同构建基线一致;GOT 篡改正向测试在宿主完成,iPhone 上受控 GOT/实际系统代码 inline Hook、失败/取消和大包性能尚未完成。下一阶段应先补这些验证,再推广库与 ABI 范围;不能把此试点等同于原报告复测通过。
最终摘要:`docs/evidence/20261111-ssziparchive-framework-summary.json`。源码、测试、日志和关键包记录冻结到 `test-results/step5-ssziparchive/final-evidence/`,哈希清单不含自身。
@@ -0,0 +1,68 @@
# 17 · 真机 HOOK 正向验证(step11)
日期:2026-11-12。状态:**已完成,11/11 用例通过**。补齐 [11](11_RUNTIME_ANTIHOOK_MODULE.md) §5.3、[14](14_ZIPZAP_RUNTIME_DISPATCH_PILOT.md) §6、[16](16_SSZIPARCHIVE_FRAMEWORK_GUARD_PILOT.md) 验收边界中反复挂账的"受控真机正向验证":此前所有真机证据只有干净环境零误报,攻击形态能否命中从未在真机证明。同轮新增两个探针并接入聚合:**调试器跟踪**(reason=300,复用 docs/12 的 `ig_sys_is_debugged`)与 **ObjC 方法 IMP 基线**(reason=110,docs/05 P1 点名的 swizzle 检测空洞),随 `ig_defender_scan` 在真机逐例执行。
设备:iPhone 16 Plus(iPhone17,4),iOS 27.2,非越狱,开发签名(TouchLinked_dev 通配 profile,专用 Bundle ID `cn.touchv.iosguard.hookpilot.20261112`,测试后已卸载)。
## 1. 验证方式
独立诊断进程 `tests/fixtures/hook_device.m`(模式沿用 step2 `dispatch_device.m`),在**自身进程内**构造攻击形态后运行真实探针链。构建器 `tools/macho_guard/build_hook_device.py`,执行器 `tools/macho_guard/run_hook_device.py`(安装→两相位→卸载→证据哈希)。攻击构造(可写 GOT、装载模拟 dylib、特征线程名、方法替换)只存在于诊断源码,绝不编入业务库。
两相位:
- **相位 A(干净启动)**:10 个用例,覆盖 5 类攻击形态 + 基线 + 恢复检查。
- **相位 B(DYLD_INSERT_LIBRARIES 启动)**:宿主以 `devicectl -e` 注入环境变量启动,**dyld 在非越狱设备上真实装载** Documents 下的模拟 dylib——这是越狱外可行的真实注入路径(等同 Frida gadget 的加载形态)。
## 2. 用例与结果(`20261112-v1`,全部 PASS)
| 用例 | 攻击形态 | 期望 | 实测 |
| --- | --- | --- | --- |
| baseline_clean | 无(聚合含新调试器探针) | 0 DETECTED | PASS(零误报;直发 sysctl 真机 clear) |
| got_rebind | fishhook 同款:`vm_protect(VM_PROT_COPY)` 改写自身 `__got` 的 getpid 槽 → 本进程函数 | reason=102 | PASS,证据含槽址/当前值/提供方 |
| got_restore_clean | 恢复原始指针 | 0 DETECTED | PASS(恢复有效、无粘滞) |
| prologue_b_branch | 导出符号首指令 `b .+64`(经 dlsym→dladdr→vm_read_overwrite 完整链) | reason=100+101 | PASS |
| prologue_ldr_br | `ldr x16,#8; br x16` 蹦床 | reason=100+101 | PASS |
| frida_thread | 子线程 `pthread_setname_np("gum-js-loop")` | reason=203 | PASS |
| frida_thread_gone | join 后重扫(2s 轮询容忍内核回收延迟) | 0 DETECTED | PASS |
| injected_image | Documents 下 dlopen 特征名 `libfrida-sim.dylib` | reason=200 | PASS |
| foreign_image | Documents 下 dlopen 无特征名 `libiosutil-sim.dylib` | reason=201(弱信号) | PASS |
| objc_imp_baseline | 运行期类采集基线后 `class_replaceMethod` 换实现 | reason=110 | PASS |
| dyld_insert(相位 B) | `DYLD_INSERT_LIBRARIES` 指向 Documents dylib,dyld 真实装载 | reason=202(+200) | PASS,**202 与 200 双命中** |
探针行为澄清(本轮实证):命中注入特征名(200)的镜像**不再重复上报** Bundle 外(201);200 与 201 是互斥的两种形态,分别用两个用例验证。
## 3. 性能小样本
真机整包聚合扫描(anti_hook 12 符号 + ObjC 基线 + 注入 + 线程 + 调试器探针)5 次:avg 0.55 ms / min 0.53 ms。单机单次小样本,不推导总体性能结论;此前观察包业务内 17~30ms 的量级主要来自 Swift 策略层与观察日志开销,C 探针本身远低于该值。
## 3.5 同轮新增的探针模块
- `defender/anti_debug/IGAntiDebug.{h,c}`:把 docs/12 已实测的 `ig_sys_is_debugged()`(直发 sysctl 查 P_TRACED)接入 `ig_defender_scan` 聚合,reason=300(1→DETECTED / -1→UNAVAILABLE)。此前该能力存在但策略层无从消费。
- `defender/anti_hook/IGObjCBaseline.{h,c}`:ObjC 关键方法 IMP 基线探针,reason=110。策略层用 `ig_objc_baseline_capture()` 登记关键方法(类名+选择子,≤64 条),check 时 `method_getImplementation` 与基线比较:IMP 换人(swizzle/replace/exchange)或 IMP 不变但代码前缀变化(函数体改写)即 DETECTED;类/方法不可解析 UNAVAILABLE;未 capture 时 no-op。填补 docs/05 §4 P1 指出的"IMP 基线检测"空洞。
- 原因码补充:107 显式标注为 Swift 观察层 archive-dispatch 保留;新增 110(ObjC IMP)与 300(调试器跟踪)。
- 两个设备构建器(dispatch/hook)模块清单同步更新(+IGObjCBaseline/IGAntiDebug/IGSyscall,链接 +lobjc)。
宿主测试新增 3 项(`tests/test_defender_host.py`):调试器探针干净环境、ObjC 基线干净路径、ObjC 基线 replace 正向;全套件回归通过。
## 4. 复现
```bash
python3 tools/macho_guard/build_hook_device.py \
--profile <TouchLinked_dev.mobileprovision> --identity <SHA1> \
--bundle-id cn.touchv.iosguard.hookpilot.<date> \
--output test-results/step11-device-hook/build-<date>
python3 tools/macho_guard/run_hook_device.py \
--device <UDID> --app test-results/step11-device-hook/build-<date>/IGHookPilot.app \
--bundle-id cn.touchv.iosguard.hookpilot.<date> \
--output test-results/step11-device-hook/<date>-v1
```
输出目录必须不存在;证据:`device-verification.json`(用例/结论/边界)、`console-clean.log`、`console-insert.log`、`launch-*.json`、`install/uninstall.json`、`evidence-hashes.json`;构建侧 `build-*/manifest.json` 含源码快照哈希。宿主侧另有同一 fixture 的 9 用例冒烟(/tmp,未归档);既有 59 项宿主/工具测试重跑通过,无回归。
## 5. 边界(如实声明)
1. **inline-hook 仍非"真实系统函数 patch"**:非越狱无法改写共享缓存代码页。本用例针对受控导出符号的**真实代码字节**验证"解析→读取→分类"全链,序言分类逻辑与真实 patch 场景相同;对系统函数的实际 inline Hook 检测仍需越狱设备(后续可选)。
2. **特征可规避**:镜像名/线程名改写即绕过 200/203;本验证证明"命中抓得住",未命中不等于干净(组合判定原则不变)。
3. **诊断进程 ≠ 业务 App**:独立进程、无业务代码;业务 App 内的攻击面(ObjC 方法、业务函数)不受本轮覆盖——ObjC IMP/swizzle 检测仍是空洞,见 README 差距清单。
4. `frida_thread_gone` 依赖内核线程回收延迟(2s 轮询窗口);极端缓慢环境下可能仍残留,属环境噪声。
5. 相位 B 的 dylib 路径来自相位 A 回显(Documents 容器路径),两次运行间重装会变化,不可硬编码。
+321
View File
@@ -0,0 +1,321 @@
# 18 · readoor 接入 iOSGuard Defender 方案
> 目标:把 iOSGuard 的「检测 → 分级 → 数据依赖毒化」闭环接到 readoor 业务工程。
> 边界:**纯客户端**,不引入服务端;分发渠道=**App Store 上架**,故处置**只用数据污染 + 功能静默降级,不随机崩溃**。
> 本文件只在 iOSGuard 侧产出「可集成产物 + 接入步骤」,**不修改 readoor 代码**。真正落地到 readoor 时须走 readoor 的 Skill 流程 + xcodebuild。
---
## 0. TL;DR —— 接入只有「两处调用」
1. **启动链 / 回前台 / 关键操作前** 调一次策略扫描:
```swift
ig_policy_scan_and_mark(bundlePath, 0, observerSink, nil)
```
命中高置信越狱/Hook 组合时,它**不 exit、不弹窗**,只在内部把毒化态置脏。
2. **epub 解密前**,对密钥字节过一遍毒化掩码:
```swift
ig_poison_apply(keyIn, keyOut, keyLen) // 健康:原样;毒化:逐字节异或掩码
```
健康设备 `keyOut == keyIn`,解密正常;毒化设备 key 被打乱,`sfc_SimpleDeCrypt` 解出乱码,书读不了——**没有可 patch 的 `if` 分支**。
其余都是工程接线(静态库 + bridging header + Header Search Paths)。
---
## 1. 产物(iOSGuard 侧已就绪)
用构建脚本一键产出可集成件:
```sh
sh tools/build_defender_lib.sh /path/to/out
```
产物结构:
```
out/
├── lib/
│ └── libIGDefender.a # arm64 iphoneos 静态库(-O2),只采集 + 毒化,无网络、无 UI、无 exit
└── include/
├── IGGuard.h # 统一公共头(umbrella)—— bridging 只 import 这一个
├── IGDefender.h # IGStatus/IGReason/IGFinding/IGFindingSink + ig_defender_scan
├── poison/IGPoison.h # ig_poison_init / ig_poison_mark / ig_poison_apply
├── policy/IGPolicy.h # ig_policy_scan_and_mark / ig_policy_sink / IGPolicyState
└── … # 其余子模块头,保持相对目录供 umbrella 引用
```
脚本已校验:单一 `-Iout/include` 即可编译 `IGGuard.h`(自洽),且导出符号包含
`ig_policy_scan_and_mark / ig_poison_apply / ig_poison_init / ig_defender_scan`。
> 产物是**纯 C**,不依赖 Foundation/UIKit,无动态加载,无第三方。App Store 合规面只有:静态库里有直发 `svc`(反 libc hook)与越狱特征文件路径常量——均为被动只读探测,不触发拒审项(无私有 API 符号、无越狱必备 entitlement)。
---
## 2. 工程接线(Xcode / readoor31 target)
> 以下是 readoor 侧要做的配置,列出以便一次到位;**本仓不替 readoor 改**。
1. **放置产物**:把 `libIGDefender.a` 与 `include/` 纳入 readoor 工程(建议 `readoor/3.0/Base/Security/IGDefender/`)。
2. **Link**:target → Build Phases → Link Binary With Libraries 加入 `libIGDefender.a`;因含 ObjC runtime 读取,Other Linker Flags 补 `-lobjc`。
3. **Header Search Paths**:加 `$(SRCROOT)/…/IGDefender/include`(非 recursive 即可,umbrella 内部按相对目录引用)。
4. **Bridging Header**:在 readoor 既有 bridging header 里加一行
```objc
#import "IGGuard.h"
```
之后 Swift 侧即可直接调用 `ig_policy_scan_and_mark` / `ig_poison_apply` 等 C 符号。
5. **构建验证**(readoor 默认命令):
```sh
xcodebuild build -workspace readoor.xcworkspace -scheme readoor31 \
-sdk iphoneos -derivedDataPath /private/tmp/readoor-derived
```
---
## 3. 接入点一:处置触发(替换 `RDSecurityGuard.forceExit()`)
**现状**:`readoor/3.0/Base/Security/RDSecurityGuard.swift` 的 `evaluate(event:)` 在 highRisk 时走 `forceExit() → exit(0)`。
`exit/_exit/abort` 都是**单点、显式、可被 hook** 的控制流,Shadow/Liberty 一个断点就废掉。
**改法**:把 `exit(0)` 这条路换成策略扫描 + 毒化(**不 exit**)。在原来调用 `evaluate` 的事件点
(launch / foreground / beforeLogin / beforePayment / beforeVipPurchase / beforeActivation)改为:
```swift
// RDSecurityGuard 内部,原 forceExit() 调用点替换为:
let bundlePath = Bundle.main.bundlePath
_ = bundlePath.withCString { cBundle in
ig_policy_scan_and_mark(cBundle, 0) { finding, _ -> Int32 in
// observer:仅打点,不含敏感信息(不打 Token/手机号/用户ID/订单号)
// 可转发到 RDOSLogManager 记 reason/status 计数,用于灰度观测误报面
return 0
} as IGFindingSink, nil)
}
// 返回后不做任何可见动作:命中与否对 UI 完全透明。
// 真正的「拒服务」在接入点二随解密自然发生。
```
要点:
- **一次扫描即判**:`ig_policy_scan_and_mark` 内部 reset → `ig_defender_scan` → 按档位组合判定 → 命中则 `ig_poison_mark`。
- **检测与处置解耦**:这里**只置脏**,书打不开发生在接入点二,时空分离,攻击者难把「检测」和「后果」对上。
- **observer 打点合规**:遵守 readoor AGENTS — 日志不输出 Token / 手机号 / 用户 ID / 订单号 / 支付结果 / 完整请求参数,只记 `reason` 枚举与计数。
- **保留 Swift 既有探针**:`RDJailbreakDetector`(public API:canOpenURL / FileManager)可留作**观察打点**,但判定权交给 C 侧 svc 直发(绕过 bypass 对 libc/公开 API 的 hook)。即 Swift 层量化误报面,C 层定罪。
---
## 4. 接入点二:数据依赖毒化(epub 解密)
**现状**:`readoor/3.0/Features/ReadView/Epub/RDEncryptedEpubResourceProvider.swift`
`decrypt(path:key:)` 调 `StsSimpleCrypt.sfc_SimpleDeCrypt(path, pass: key)`;
`bookKey = doubled("startiasoft" + bookIdentifier)`,imageKey 走 MD5。
**改法**:在把 key 交给 `sfc_SimpleDeCrypt` **之前**,对 key 字节过 `ig_poison_apply`:
```swift
// decrypt(path:key:) 内,调用 sfc_SimpleDeCrypt 之前:
func poisonedKey(_ key: String) -> String {
var inBuf = Array(key.utf8)
var outBuf = [UInt8](repeating: 0, count: inBuf.count)
ig_poison_apply(&inBuf, &outBuf, inBuf.count)
return String(decoding: outBuf, as: UTF8.self) // 若 key 是二进制,改用 Data 承载,勿走 UTF8
}
// let realKey = poisonedKey(key); StsSimpleCrypt.sfc_SimpleDeCrypt(path, pass: realKey)
```
语义:
- **健康设备**:`ig_poison_mask() == 0` → `ig_poison_apply` 是**恒等变换**,`outBuf == inBuf`,解密与现状完全一致,零影响。
- **毒化设备**:mask ≠ 0 → key 每字节被 `(mask >> ((i&7)*8)) & 0xFF` 异或打乱 → `sfc_SimpleDeCrypt` 解出乱码 → 书页/图片无法渲染。
- **无分支可 patch**:这里没有 `if(越狱)`,毒化靠数据流(mask)天然传播;要绕得逆向整条密钥推导并还原 mask=0 的恒等性,成本从「分钟级断点」抬到「天级逆向」。
> 若 key 实际是二进制(非可打印字符串),**不要**经 `String(UTF8)` 往返(会丢字节)。改成对承载 key 的 `Data`/`[UInt8]` 原地 `ig_poison_apply`,再按 `sfc_SimpleDeCrypt` 需要的类型传入。
---
## 5. 误报底线(上线前提)
毒化**隐蔽且不可逆**:误伤非越狱正常用户=「书打不开」的差评 + 难排查退款。故策略层(`IGPolicy.c`)已内建底线,接入时**不要放宽**:
| 档位 | reason | 触发规则 |
|---|---|---|
| **STRONG**(单条即判) | 400 越狱文件 / 401 沙盒逃逸 / 102 GOT 重绑 / 101 inline hook / 200 注入镜像 / 300 调试器 | `strong_count ≥ 1` |
| **MEDIUM**(需组合) | 100 符号提供方 / 110 ObjC IMP / 203 frida 线程 | `≥2 个不同 MEDIUM`,或与任一 STRONG 同现 |
| **WEAK**(永不毒化) | 201 Bundle 外镜像 / 204 frida 端口 | 仅观察打点 |
- `IG_UNAVAILABLE`(架构/平台不支持、数据缺失)与 `IG_CLEAR` **一律忽略**,绝不当攻击。
- 110 ObjC IMP 合法 swizzling 会误报,故**不单条定罪**,归 MEDIUM。
- **灰度上线**:先让 observer 只打点、**接入点二先不接**(或 `ig_poison_apply` 旁路),用线上 `reason` 分布确认「非越狱设备零 STRONG、MEDIUM 不成对」后,再开毒化。**可直接贴的 observer 打点骨架 + 判读标准见 [附录 A](#附录-a--灰度第一步observer-打点骨架只观察绝不处置)**。
---
## 6. 能力边界(务必对齐预期)
- **纯客户端无法根治 bypass**:Shadow/Liberty 等能把越狱检测 hook 成「干净」。本方案**不锚定「客户端准确判越狱」**,而是:① svc 直发抬高 hook 成本;② 数据污染比 exit 强一个量级;③ 检测-处置解耦 + 延迟分散后果,让「绕过一次」≠「永久绕过」。目标是把破解成本从分钟级抬到天级,不是不可破。
- **App Store 合规**:处置只有数据污染 + 静默降级,**不随机崩溃**,不触发拒审。
---
## 7. 后续硬化 TODO(接入后迭代,不阻塞首版)
> 状态截至 2026-11-13。回归守在 `tests/test_static_hardening.py`(6 条,gate 于 darwin+iphoneos SDK),防以下几条被后续改动悄悄打回。
**0. ✅ 符号隐藏 + strip(本轮新增,针对「抗静态分析」最高性价比项)。**
`defender/include/IGVisibility.h` 定义 `IG_INTERNAL=hidden`;全库 `-fvisibility=hidden`(见 `tools/build_defender_lib.sh`)。只有 readoor 实际调用的四入口标 `IG_PUBLIC`(`ig_defender_scan / ig_poison_init / ig_poison_apply / ig_policy_scan_and_mark`)保持导出,其余 `ig_*` 在 `.a` 里是 private external,链接进可执行文件后 `strip -x` 即彻底消失——攻击者 `nm` 不再能按名定位 `ig_poison_mark/mask` 去 NOP 调用点。
> **对抗自验结论(2026-11-13,对链接+strip 的宿主实测 `nm`/`otool -l`/`-tV`/`strings`)**:
> - 内部 `ig_*`、旧魔数、越狱/注入明文串 **strip -x 后全部消失** ✓。
> - **但四个 public 入口名 `_ig_poison_init/apply` 等 `strip -x` 抹不掉**(global external),而名字本身就写着 "poison",等于告诉攻击者毒化入口在哪。**完整 `strip`(style=all,非 `-x`)实测连这四个名也抹掉** ✓。故 **readoor Release 必须用完整 strip(`STRIP_INSTALLED_PRODUCT=YES` 且 `STRIP_STYLE=all`,Xcode app target 默认即 all;切勿配成 `-x`/`non-global`)**。更稳的做法:接入层给这四个入口包一层中性名(如 `rd_blob_init/transform`),别让 "poison" 字样进最终符号表。
1. ✅ 越狱路径字符串 `IG_ENC` 混淆。`tools/gen_jb_paths.py`(唯一真源)生成 `IGJailbreakPaths.inc` / `IGInjectSignatures.inc`(XOR keystream,两表不共享 key);运行期解码进栈、用完 `memset` 擦除。`ig_jb_decode/ig_inj_decode` 内 `volatile` key 屏障,阻止 `-O2` 把「常量 enc+常量 key」折叠回 `__const` 明文。`strings` 已捞不到 `/var/jb`、`Cydia`、`substrate`、`gum-js-loop` 等。CI 用 `gen_jb_paths.py --check` 守 .inc 与清单同步。
2. ✅ `IGPoison` 分散存储。**对抗自验揪出并修掉了上一版的反效果设计**:原用自定义命名段 `__DATA,__ig_p0/p1/p2/pd`——命名段会原样留在 Mach-O load command 里、`strip` 也抹不掉,`otool -l | grep __ig_p` 一把定位毒化副本,比匿名 BSS 更糟。现改为:三路真副本 + 诱饵散在**一个匿名数组 `g_state[12]`** 的非相邻下标(`IG_LANE={2,7,11}`、`IG_DECOY=5`,其余为陪衬槽),全进匿名 `__bss/__data`;每槽存 `baseline ^ lane_k(i)` 使各槽值互不相同,消除「数组里几个相同的字=一组健康值」这种可一眼框定的 tell;`mask` 只读三真副本。回归守在 `test_no_telegraphing_sections`。**刻意不用 TLS**——会破坏跨线程毒化一致性。
3. ⚠️ OLLVM/VMP 覆盖 `ig_poison_mark / mask / apply` 与策略分级表。**仅留 hook 未落地**:`build_defender_lib.sh` 的 `IG_OBFUSCATOR` 环境变量在指向 OLLVM-clang 时对 `IGPoison.c`/`IGPolicy.c` 启 `-mllvm -fla -bcf -sub`;stock Xcode clang 无此能力,需另备 obfuscator-llvm/商业 VMP 工具链才算真正完成。
4. ✅ 毒化基线魔数运行期派生。删除硬编码 `0xA5C3F10E7B2D4968`,改 `ig_poison_baseline()` 由拆分种子经 `volatile` 屏障派生(阻止常量折叠回单一魔数);值本身不影响行为,只需进程内自洽。`otool -tV` 已无旧魔数立即数。
5. ⛔ 越狱探针真机正向验证:越狱设备实测命中 400/401,且非越狱设备零 STRONG。**仍阻塞**(无越狱设备)。D8 `svc_access_live` 已在非越狱 iPhone 证了 svc 直发探针活性,残留缺口=真越狱文件 400 + 沙盒逃逸 401 的正向命中。
**6. ✅ 断边原语(C 侧已就绪,留 readoor 接入时挂点)。** 符号隐藏只去掉「按名定位」,调用图的边(`bl ig_poison_apply/mask`)仍在、可被 NOP。本轮提供 `defender/poison/IGPoisonInline.h`:把「读健康值→推掩码→扰动密钥」做成 `always_inline` 核心,接入方在**解密 TU 内联**后反汇编**不留 `bl ig_poison_*` 调用边**(已用 `tests/test_poison_inline.py` 的 `test_no_call_edge_after_inline` 对 arm64 `-O2` 产物断言:`rd_derive_key` 内零 `bl`,对 `ig_pstate` 仅 data 引用)。库内 `IGPoison.c` 的 out-of-line 入口复用同一真源,内联路径与库路径语义等价(`test_inline_equals_outofline` 逐例校验),不会漂移。
### 7.6 断边接入形态(readoor 解密 TU)
推荐把毒化揉进 **key 派生**(落在 key schedule,比后置改输出更难摘),而不是改解密输出:
```c
#include "poison/IGPoisonInline.h" // dist/include/poison/IGPoisonInline.h
// readoor 取得明文 epub 解密 key 后、喂给解密器之前:
ig_poison_mix_key_inline(key, key_len); // 健康→key 不变→正常解密;毒化→key 被扰动→乱码
// 随后照常 AES/chacha 解密(key, …)
```
编译后 `ig_poison_mix_key_inline` 整段内联进 readoor 的解密函数:没有可 NOP 的调用边,基线派生+三副本读取+异或全部化进解密函数自身的指令流,与真实 key schedule 混在一起。唯一跨 TU 符号是**数据** `ig_pstate`(中性名、hidden、strip 后无名),非调用边。
> **仍未做**:调用点级别的间接跳转(`blr` + 运行期解析目标)——内联已消除热路径的调用边,间接跳转是针对「仍保留 out-of-line 入口」场景的额外一层,价值低于内联,按需再做。
### 7.7 二进制完整性 / 防重打包探针(`IGAntiTamper`,本轮新增)
**补的空洞**:`IGAntiHook` 只校验固定一批关键函数(~12 个 libc/系统符号)的序言/GOT——攻击者 patch 这批**之外**的任意指令(NOP 掉某条毒化调用边、改业务层比较)它看不见。`IGAntiTamper` 从「镜像整体」角度补位,正面反制 App Store 应用的标准破解链:**脱壳解密(Clutch/frida-ios-dump)→ patch → 重签**。
两条检查(`defender/anti_tamper/IGAntiTamper.{c,h}`,只采集证据经 sink 上报、不处置,判级交 policy):
1. **FairPlay `cryptid`**(reason=500 `IG_REASON_BINARY_DECRYPTED`):App Store 分发包由 Apple 加密(`LC_ENCRYPTION_INFO_64.cryptid=1`)。脱壳 dump 会把 `cryptid` 改 0;重打包可能整条剥除加密命令。两种都判 DETECTED。
2. **代码签名状态 `csops(CS_OPS_STATUS)`**(reason=501 `IG_REASON_CODESIGN_INVALID`):`CS_VALID` 失效(代码页被 patch)、`CS_ADHOC`(无开发者证书的重签)、分发包却带 `CS_GET_TASK_ALLOW`(被重签成可调试)。
**误报底线(关键)**:这两条都**依赖构建上下文**——dev/TestFlight/诊断构建本就未 FairPlay 加密、且带 get-task-allow,那是正常的、不是篡改。故入口 `ig_anti_tamper_check(int expect_encrypted, int expect_distribution, sink, ctx)` 由调用方按构建类型传 `expect_*` 开关:
- **只有 App Store Release 构建传 `expect_encrypted=1, expect_distribution=1`**;
- dev/诊断/TestFlight 传 `0` → 对应检查返回 `UNAVAILABLE`(无法断言,不上报 DETECTED),**绝不在非分发构建误报**。
- `expect_*` 应由 Release 构建配置(`#if` 宏或 xcconfig 注入),**绝不在 dev 构建硬编码为 1**。
**接线决策**:`IGAntiTamper` **不并入 `ig_defender_scan`**(那会改签名、破坏现有调用方),而作为**独立探针**由 Swift 策略层/observer 在带构建上下文开关处单独调用——与「灰度先 observer 打点」一致。首版建议只在 observer 阶段观察 500/501 的线上分布,确认 Release 包零 `UNAVAILABLE` 误触后再纳入处置。
**边界**:`csops` 经 libc,可被 hook 伪造(但攻击者若已能 hook csops,环境已失陷,anti_hook/anti_inject 会先命中);`cryptid` 读进程内 Mach-O 头,patch 头部也能伪装——与整体「抬成本、非不可破」哲学一致,不作唯一安全锚点。
回归:`tests/test_anti_tamper.py`(合成 Mach-O 头跑 cryptid 核心:加密正常/脱壳/剥除/非分发跳过/NULL 五例)。
**真机验证已达标(2026-11-13,iPhone 16 Plus 非越狱,dev 包 `poison_device.m` D9a–d)**:`expect_*=0` 零 DETECTED(误报底线);`expect_*=1` cryptid 命中 500、csops 读到 get-task-allow 命中 501;`csops_status rc=0 status=0x22003305 valid=1 get_task_allow=1` 坐实 csops 在真机 arm64 活着。详见 docs/19 §6。**残留缺口**:cryptid==1 正向 CLEAR 与分发签名零误触只能在真 App Store/TestFlight 包验(dev profile 无法复现 FairPlay 加密)。
---
## 附录 A · 灰度第一步:observer 打点骨架(只观察,绝不处置)
> **用途**:开接入点二毒化**之前**的线上体检。实验室 2 台真机证了「不误报」,但线上是几十万台各机型/各 iOS 版本的真实设备——先只打点、不毒化,用真实用户群把误报率量出来,确认「非越狱用户里 STRONG 出现率≈0、MEDIUM 不成对」后,再按 §4 开毒化。
>
> **本阶段铁律**:此处只记日志,**不调用 `ig_poison_apply`、不 `exit`、不改任何业务行为**。上线风险≈0(纯增日志)。
>
> 下面是可直接贴的 Swift 骨架;真正落地改 readoor 须走其 Skill 流程 + xcodebuild,贴入时对一下 `RDSecurityGuard` / `RDOSLogManager` 的实际签名(本骨架基于现版本 `evaluate(event:)` 与 `RDOSLogManager.logStat/logInfo`)。
### A.1 C→Swift observer 桥接要点
`ig_policy_scan_and_mark(bundle, port, observer, observer_ctx)` 的 `observer` 是 C 函数指针
`int (*)(const IGFinding*, void*)`。Swift 侧用 **`@convention(c)` 闭包**,它**不能捕获上下文**,故计数器等状态必须经 `observer_ctx`(`void*`)传入——用 `Unmanaged` 把一个 Swift 聚合器对象的指针传进去,在回调里取回。
**只读 `status` 与 `reason`(都是 Int)做打点;不碰 `subject`/`evidence` 字符串**——既省去 C 定长 char 数组的桥接麻烦,也天然满足 readoor 日志合规(不输出路径等可能敏感的细节)。
### A.2 骨架代码(新建 `RDDefenderObserver.swift`,放 `3.0/Base/Security/`)
```swift
import Foundation
/// 灰度打点聚合器:单次扫描内累计各 reason 的 DETECTED 计数。只观察、不处置。
/// 经 observer_ctx 传给 C 回调;回调里只读 finding.status / finding.reason。
final class RDDefenderObserver {
// reason(Int) -> 命中次数;只记 IG_DETECTED。
private(set) var detectedByReason: [Int32: Int] = [:]
private(set) var detectedTotal = 0
/// 非捕获的 C 回调:ctx 还原为 self,累计计数。返回 0=继续扫描。
static let sink: @convention(c) (UnsafePointer<IGFinding>?, UnsafeMutableRawPointer?) -> Int32 = { f, ctx in
guard let f = f, let ctx = ctx else { return 0 }
// IG_DETECTED == 1(见 IGDefender.h 的 IGStatus);UNAVAILABLE/CLEAR 不计。
if f.pointee.status.rawValue == IG_DETECTED.rawValue {
let obs = Unmanaged<RDDefenderObserver>.fromOpaque(ctx).takeUnretainedValue()
let reason = f.pointee.reason
obs.detectedByReason[reason, default: 0] += 1
obs.detectedTotal += 1
}
return 0
}
/// 单行埋点:只含 reason 枚举与计数,**不含 Token/手机号/用户ID/订单号/路径**。
func statLine(event: String, triggered: Bool) -> String {
// 形如:reasons=400:1,110:2(按 reason 升序,稳定可聚合)
let reasons = detectedByReason.sorted { $0.key < $1.key }
.map { "\($0.key):\($0.value)" }.joined(separator: ",")
return "[DefenderObserve] event=\(event) triggered=\(triggered) "
+ "detected=\(detectedTotal) reasons=[\(reasons)]"
}
}
```
### A.3 接到 `RDSecurityGuard`(灰度阶段:与现逻辑并行,不替换 forceExit)
```swift
// RDSecurityGuard.evaluate(event:) 内,与现有 Swift 检测并行加一段观察扫描。
// 灰度阶段只打点;forceExit() 暂保留原样(或已按业务决定停用 exit——见下方注释)。
private func observeWithDefender(event: RDSecurityEvent) {
let bundlePath = Bundle.main.bundlePath
let observer = RDDefenderObserver()
let ctx = Unmanaged.passUnretained(observer).toOpaque()
// 返回值 triggered:若现在就开毒化,这里会命中;灰度阶段仅记录,不据此处置。
let triggered = bundlePath.withCString { cBundle in
ig_policy_scan_and_mark(cBundle, 0, RDDefenderObserver.sink, ctx)
}
// 仅埋点。logStat 走统计通道;合规:不输出任何敏感字段。
RDOSLogManager.logStat(observer.statLine(event: eventName(event), triggered: triggered != 0))
// ⚠️ 灰度第一步到此为止:
// - 不调用 ig_poison_apply(接入点二,§4)——那是数据达标后才开。
// - 不因 triggered 做任何 UI/exit/降级。
// triggered 只进日志,用于线上量化误报面。
}
// 复用现有 eventName 文案(启动/回前台/…);若 logRisk 里的 switch 已有,可抽成函数共用。
private func eventName(_ event: RDSecurityEvent) -> String {
switch event {
case .launch: return "launch"
case .foreground: return "foreground"
case .beforeLogin: return "beforeLogin"
case .beforePayment: return "beforePayment"
case .beforeVipPurchase: return "beforeVipPurchase"
case .beforeActivation: return "beforeActivation"
}
}
```
调用点:在 `evaluate(event:)` 里、现有 `logRisk(...)` 之后加 `observeWithDefender(event: event)` 一行即可(launch/foreground 等所有事件都会带出一条打点)。
### A.4 灰度判读与退出条件
收一段线上数据后,看 `[DefenderObserve]` 这条 stat:
| 指标 | 期望(可开毒化) | 不达标说明 |
| --- | --- | --- |
| STRONG reason(400/401/101/102/200/300)在**非越狱机型**出现率 | ≈ 0 | 若某机型/系统版本批量出现 → 有误报源,排查该 reason 再说 |
| MEDIUM reason(100/110/203)成对(≥2 不同)出现率 | 极低 | 合法 swizzling 多发 → 调 §5 分级或把该 reason 降级 |
| `triggered=true` 占比 | 贴近真实越狱盘踞率,且集中在可解释来源 | 明显偏高 → 先别开毒化 |
三项达标 → 按 §4 在 `RDEncryptedEpubResourceProvider.decrypt` 接 `ig_poison_apply`,并把 `observeWithDefender` 里「不据 triggered 处置」的注释解除、改为真正消费(或让毒化在解密侧随 mask 自然生效,二选一,推荐后者=解耦)。
> **为什么并行而非立刻替换 `forceExit`**:灰度期保留现有 Swift 检测路径(哪怕已停用 exit),让新旧两套检测的 reason 分布能在同一批设备上对照,确认 C 侧探针不是凭空多报。待毒化开启、稳定后,再按 §3 用策略扫描收口、下线 `forceExit`。
@@ -0,0 +1,135 @@
# 19 · 处置链真机验证协议(poison / policy / 越狱)
> 承接 [17](17_DEVICE_HOOK_POSITIVE_VERIFICATION.md)(hook 探针真机正向已完成)与 [18](18_READOOR_DEFENDER_INTEGRATION.md)(接入方案)。
> docs/17 只验了 anti_hook 探针**能否命中**;本轮补验**新增的处置链**——越狱探针(400/401)、策略分级、以及最关键的 **mask→key 毒化闭环**,并把**非越狱真机反向零误报**作为开毒化的硬门槛。
> 状态:**宿主基线已绿(19/19,`tests/test_poison_policy.py`);真机两组待跑**(需设备 UDID + 开发签名)。
---
## 0. 为什么必须真机,且反向比正向重要
- 宿主(macOS)能验分级逻辑与 mask/apply 算术,但**证不了真机**上的两件事:① 越狱 svc 直发在 iOS arm64 的真实行为;② `__attribute__((constructor))` + BSS 三副本在真机启动早期的时序(毒化态初始化是否干净)。
- **反向(非越狱设备零毒化)是上线前提**:毒化隐蔽且不可逆,误伤正常付费用户=「书打不开」的差评+退款+难排查。所以验收顺序是**先反向达标,再谈正向**。正向只证「抓得住」,反向证「不误伤」——后者才决定敢不敢在接入点二开毒化。
---
## 1. 两组设备
| 组 | 设备 | 目的 | 判定 |
| --- | --- | --- | --- |
| **R(反向)** | 非越狱真机(同 docs/17:iPhone,开发签名,专用 Bundle ID,测后卸载) | 证明干净环境**零毒化** | `strong_count==0` 且 `medium_distinct<2` 且 `ig_poison_mask()==0`,全程无 400/401 |
| **J(正向)** | 越狱设备(rootful 或 rootless 均可,标注越狱方案与 bypass 是否安装) | 证明越狱特征**抓得住** | 命中 400(特征文件)与/或 401(沙盒逃逸),`ig_policy_scan_and_mark==1`,`ig_poison_mask()!=0` |
> R 组无越狱设备也能先跑(它本就是非越狱);J 组需要一台越狱机。两组用**同一个诊断进程**,只是环境不同。
---
## 2. 诊断进程(复用 docs/17 harness 模式)
诊断进程 `tests/fixtures/poison_device.m`(**已建**,模式沿用 `hook_device.m`),在自身进程内按用例运行**真实探针链**,逐条 `NSLog` 证据 + 汇总。构建/执行器为 `tools/macho_guard/build_poison_device.py` / `run_poison_device.py`,复用 docs/17 的「安装→运行→卸载→证据哈希」骨架;已交叉编译通过(iphoneos arm64,符号全解析),待真机执行。
输出分两类(见下表):
- **`IG_POISON_CASE`**:环境无关不变量(D4–D7),构成套件 PASS/FAIL 门槛,两组都必须过。
- **`IG_POISON_OBS` / `IG_POISON_ENV`**:环境相关观察(D1–D3 + 越狱判定),不写死 PASS/FAIL;由 runner 的 `--expect clean|jailbroken` 按 R/J 组校验(R 应 `jailbroken=no`、J 应 `jailbroken=yes`)。
**关键:攻击/构造代码只存在于诊断源码,绝不编入业务库。** 越狱特征文件的「存在性」在 J 组由设备本身提供(真有 `/var/jb`、Cydia 等),诊断进程只做被动探测,不自己造越狱文件。
### 用例表
| # | 用例 | 构造 | 期望(R 非越狱 / J 越狱) |
| --- | --- | --- | --- |
| D1 | baseline_clean | 直接 `ig_policy_scan_and_mark(bundle,0,obs,_)` | R: 返回 0,mask==0,无 400/401 / J: 返回 1(命中越狱),mask!=0 |
| D2 | jb_file | 默认 `ig_anti_jb_check` 跑内置越狱特征表 | R: 0 命中 / J: ≥1 条 400,证据含命中路径 |
| D3 | jb_sandbox | `ig_anti_jb_check_paths(…, probe=/private/.ig_jb_probe)` | R: 0 命中(沙盒内创建失败)/ J: 401(能在沙盒外建文件) |
| D4 | poison_identity | 健康态 `ig_poison_apply(key,out,n)` | 两组同:mask==0 → `out==key`(恒等,证不误伤解密) |
| D5 | poison_mark_corrupt | 手动 `ig_poison_mark(e)` 后 apply | 两组同:mask!=0 → `out!=key`(证毒化真的坏 key) |
| D6 | ctor_clean_start | 进程启动后**未** mark 时读 `ig_poison_mask()` | 两组同:==0(证构造期三副本初始化干净,无启动即毒化) |
| D7 | policy_grades | 喂合成 finding(弱/单 MEDIUM/双 MEDIUM/单 STRONG) | 两组同:弱&单 MEDIUM 不触发,双 MEDIUM&单 STRONG 触发(真机复核分级) |
| D8 | svc_access_live | 自身沙盒 Documents 建真实可访问文件,喂 `ig_anti_jb_check_paths` | 两组同:命中 400(证 svc 直发 access 在真机 iOS arm64 能命中,**无需越狱**即排除「探针静默失败」假阴性) |
| D9a | at_cryptid_expect0_clean | `ig_tamper_scan_cryptid(mh, expect_encrypted=0)` | 两组同:零 DETECTED(非分发构建跳过=误报底线,dev 包不误触) |
| D9b | at_cryptid_expect1_detects | `ig_tamper_scan_cryptid(mh, expect_encrypted=1)` | 两组同:命中 500(dev 包无 FairPlay 加密 cryptid==0;**证探针真读到进程主镜像头**,非空转) |
| D9c | at_tamper_gated_off | `ig_anti_tamper_check(0,0)` 整入口 | 两组同:零 DETECTED(两检查都 expect=0 → 全 UNAVAILABLE,误报底线贯整入口) |
| D9d | at_tamper_on_detects | `ig_anti_tamper_check(1,1)` 整入口 | 两组同:≥1 DETECTED 且含 500(整入口真机贯通;dev 包另命中 501 get-task-allow,见观察 csops_status) |
> D4–D7 与宿主自测同构,但要在真机二进制里再跑一遍,排除交叉编译/优化差异。D1–D3 是真机独有(依赖真实 svc + 真实文件系统)。
>
> **D8 的价值(无越狱设备时尤其关键)**:R 组 D2 的 `400=0` 单看无法区分「没有越狱文件」与「svc 直发在 iOS 上静默失败、永远返回 0」两种情况——后者是致命假阴性。D8 用自身沙盒内一个**真实可访问**的文件喂同一条 svc-access 路径,命中即证明检测机制在真机 iOS arm64 上是活的。它不能替代 J 组(证不了真实越狱文件/401 沙盒逃逸),但把「探针是否工作」这一层从 J 组依赖里剥离出来,**在没有越狱设备时仍可闭合**。
---
## 3. 复现命令(待 fixture 建好后对齐 docs/17)
```bash
# 构建(专用 Bundle ID,测后卸载)
python3 tools/macho_guard/build_poison_device.py \
--profile <TouchLinked_dev.mobileprovision> --identity <SHA1> \
--bundle-id cn.touchv.iosguard.poisonpilot.<date> \
--output test-results/step12-device-poison/build-<date>
# R 组(非越狱真机):--expect clean 自动校验 jailbroken=no
python3 tools/macho_guard/run_poison_device.py \
--device <UDID_非越狱> --expect clean \
--app test-results/step12-device-poison/build-<date>/IGPoisonPilot.app \
--bundle-id cn.touchv.iosguard.poisonpilot.<date> \
--output test-results/step12-device-poison/<date>-R
# J 组(越狱设备):--expect jailbroken 自动校验命中 400/401
python3 tools/macho_guard/run_poison_device.py \
--device <UDID_越狱> --expect jailbroken \
--app test-results/step12-device-poison/build-<date>/IGPoisonPilot.app \
--bundle-id cn.touchv.iosguard.poisonpilot.<date> \
--output test-results/step12-device-poison/<date>-J
```
runner 退出码:D4–D7 不变量全过 **且** 环境判定与 `--expect` 一致 → 0,否则 1。证据:
`device-verification.json`(verdict/不变量用例/观察/环境判定/边界)、`console.log`(逐条 finding)、
`install/launch/uninstall.json`、`evidence-hashes.json`;构建侧 `manifest.json` 含源码快照哈希。
证据产物(对齐 docs/17 口径):`device-verification.json`(用例/结论/边界)、`console-*.log`(逐条 finding)、`evidence-hashes.json`、构建侧 `manifest.json`(源码快照哈希)。
---
## 4. 验收门槛(硬性)
**开接入点二毒化(docs/18 §4)的前提,全部满足方可:**
1. **R 组反向**:D1 返回 0、`mask==0`、全程无 400/401;D6 启动即 `mask==0`。——证非越狱设备零毒化。
2. **J 组正向**:D2/D3 至少一条命中,D1 返回 1 且 `mask!=0`。——证越狱抓得住。
3. **两组一致**:D4(恒等)、D5(坏 key)、D6(启动干净)、D7(分级)在两组行为一致。
4. **灰度**:满足 1–3 后,先按 docs/18 §5 只开 observer 打点收线上 `reason` 分布(确认真实用户群非越狱设备零 STRONG、MEDIUM 不成对),再开毒化。
任一条不过 → **不开毒化**,回查探针/分级或环境噪声。
---
## 5. 边界(如实声明)
1. **bypass 可规避**:Shadow/Liberty 把 svc 之上的 libc hook 掉对本探针无效(已下沉到 svc),但 rootless 越狱改越狱文件位置、或直接 hook svc 返回值仍可能绕过——J 组若装了 bypass 未命中,**不代表探针失效**,需分别记录「裸越狱命中率」与「带 bypass 命中率」两档。
2. **诊断进程 ≠ 业务 App**:真正的毒化在 readoor epub 解密路径(docs/18 §4),本轮只验探针+毒化原语,业务密钥派生的端到端效果需接入后在 readoor 验。
3. **mask 全 0 概率**:毒化熵经 `ig_spread` 保证非 0,但基线魔数当前明文驻留(硬化 TODO),J 组应顺带确认 `strings` 能否捞出 `0xA5C3F10E7B2D4968`,为后续运行期派生留基线。
4. 真机小样本不推导总体性能;如测扫描耗时,标注单机单次。
---
## 6. 当前进度
- [x] 宿主闭环基线固化并绿灯:`tests/fixtures/poison_host.c` + `tests/test_poison_policy.py`(19/19:poison 7 + policy 8 + jailbreak 4)。
- [x] `poison_device.m` + `build_poison_device.py` + `run_poison_device.py`(复用 docs/17 harness);交叉编译通过(iphoneos arm64),待真机执行。
- [x] **R 组达标(2026-11-13)**:iPhone 16 Plus(iPhone17,4,非越狱,TouchLinked_dev 通配 profile,专用 BID `cn.touchv.iosguard.poisonpilot.20261113c`,测后卸载)。`run_poison_device.py --expect clean` → **verdict PASS,不变量 5/5**。
- D6 ctor_clean_start:`mask=0x0`(启动即健康)✓
- D4 poison_identity ✓;D5 poison_mark_corrupt ✓
- D7 policy_grades:`weak=0 single_medium=0 two_medium=1 single_strong=1`(真机分级一致)✓
- **D8 svc_access_live:`accessible_file_hits=1`**(**svc 直发 access 在真机 iOS arm64 实测能命中 400**,排除 D2 假阴性)✓
- D1 baseline_scan:`triggered=0 mask=0x0`(**非越狱聚合扫描零毒化** — §4.1 核心反向门槛)✓
- D2/D3:`reason400=0 reason401=0`,`jailbroken=no` ✓
- 证据:`test-results/step12-device-poison/20261113-R-final/`(gitignore,不进库)。
- [x] **IGAntiTamper 真机正反双向达标(2026-11-13)**:同机(iPhone 16 Plus,非越狱,专用 BID `cn.touchv.iosguard.poisonpilot.antitamper`,测后卸载)。`run_poison_device.py --expect clean` → **verdict PASS,不变量 9/9**(原 5 + 新 D9a–d 4)。
- D9a/D9c(误报底线):`expect_*=0` → 零 DETECTED,对应 finding 为 UNAVAILABLE(dev 包不误触)✓
- **D9b:`hits=1 reason500=1 mh=0x104390000`**(cryptid 探针真读进程主镜像头,dev 包 `cryptid==0` 命中 500;证非空转)✓
- **D9d:`hits=2 reason500=1 reason501=1`**(整入口贯通:cryptid 500 + csops get-task-allow 501)✓
- **csops_status 观察:`rc=0 status=0x22003305 valid=1 adhoc=0 get_task_allow=1`**——**坐实 csops 在真机 iOS arm64 活着**(CS_VALID 置位、非 ad-hoc、dev 包带 get-task-allow),排除「csops 静默失败=501 假阴性」。
- 证据:`test-results/step12-device-poison/20261113-antitamper-R/`(gitignore,不进库)。
- **残留缺口(分发包侧,只能在真 App Store 包验)**:cryptid==1 的正向 CLEAR、分发签名下 501 零误触——dev profile 无法复现 FairPlay 加密/分发签名,待 TestFlight/App Store 构建侧补验。
- [ ] **J 组无法执行(环境天花板:无越狱设备)**。残留缺口仅剩两项,均只能在越狱机证:① 真实越狱特征文件命中 400;② 沙盒逃逸 401。
**已有替代证据把缺口收窄到最小**:D8 已证 svc-access 检测机制在真机活跃(命中逻辑真机可工作),R 组已证反向零误报。即「机制能命中 + 非越狱不误报」在真机成立,唯独缺「真越狱环境里的端到端正向」——补一台越狱机 `--expect jailbroken` 即可闭合,harness 现成。
- [ ] 达标后进入 docs/18 §5 灰度(observer 打点 → 开毒化)。
+98
View File
@@ -0,0 +1,98 @@
{
"schema_version": 1,
"status": "passed_local_checks",
"created_utc": "2026-11-10T07:29:55.370792+00:00",
"scope": "自研直接分支规则与静态结构;不代表 V4.6.6/真机验收",
"app": {
"CFBundleIdentifier": "com.ecnup.aSCLdl2",
"CFBundleShortVersionString": "2.199.0",
"CFBundleVersion": "2.199.0.3",
"CFBundleExecutable": "readoor31OtherPay"
},
"input": {
"path": "/Users/shenlei/Work/ReadBook/iOSGuard/appstore.ipa",
"size": 128271168,
"sha256": "ddb89e30c2259b45d3f09dbc825e70c4e84c682a3c23510ceb3aa6f93d891771"
},
"original_report": {
"version": "2.197.2",
"bundle_id": "com.ecnup.azZVz02",
"exact_report_binary_available": false,
"note": "当前输入单独建基线,不视为原漏洞报告二进制"
},
"environment": {
"platform": "macOS-26.7.1-arm64-arm-64bit",
"python": "3.11.3 (v3.11.3:f3909b8bc8, Apr 4 2023, 20:12:10) [Clang 13.0.0 (clang-1300.0.29.30)]",
"xcode": "Xcode 27.1\nBuild version 27A9275",
"clang": "Apple clang version 21.0.0 (clang-2100.3.34.2)\nTarget: arm64-apple-darwin25.6.0\nThread model: posix\nInstalledDir: /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin"
},
"tools": {
"tools/macho_guard/batch.py": "aa9cb201a32c35367ab2d7cefb02f1c51676b4d8fbf19eeeef110f472db51d59",
"tools/macho_guard/macho_guard.py": "cb33515f0a76686727450e99378a6a144aeaeaee8146713ff9c46a012940b108",
"tools/macho_guard/machox.py": "616dff961618cb52e9000b55dda21da75edaeaf1c2a2a822265273b1ef2d8522",
"tools/macho_guard/verify_baseline.py": "4fa9e85e8bc7a7860e69acf1a055a5eee7448091b525a65e9c6d6d7beb0179c1"
},
"automated_tests": "passed; 详见 commands.log",
"before_total": 878,
"after_total": 0,
"macho_files": 43,
"changed_macho_files": 31,
"instruction_and_bridge_validation": "passed",
"guarded_ipa": {
"path": "guarded/guarded.ipa",
"sha256": "74c878fb64008e56dbdc10cea470e34113ee5e84abb8e105e7a52d4919327cb6"
},
"vendor_retest": "not_run",
"device_regression": "not_run",
"signing": "ad-hoc,仅用于本地静态验证",
"archive": "test-results/verification/20261110-step1-final",
"before_symbol_counts": {
"_close": 138,
"_dlopen": 2,
"_dlsym": 312,
"_exit": 99,
"_fopen": 163,
"_fork": 1,
"_getpid": 34,
"_open": 42,
"_read": 24,
"_syscall": 2,
"_unlink": 22,
"_write": 39
},
"test_counts": {
"total": 28,
"static_sdk": 15,
"macho": 6,
"defender": 7,
"skipped": 0
},
"archive_integrity_verified": true,
"evidence_hash_index_sha256": "ab1ef4f8e4a3c87d97798c18fe4a57e0086124780a1eb1792349e4b6c5057f08",
"original_source_observation": {
"note": "本轮未写入原工程;历史指纹存在 pbxproj 业务引用差异,保留现状,不将原工程视为静止基线。当前验证以冻结 IPA 为准。",
"files": [
{
"path": "readoor.xcodeproj/project.pbxproj",
"initial_sha256": "686e9eaf12b4b533d6a8c6dac0ca0aaa3996ffa3080fad70ae04433b1c8caa08",
"observed_sha256": "b4a013c87bd0888c36fc0f7da8d73066a6010693d59c6525760f6879696a4c8d",
"matches_initial": false,
"mtime_utc": "2026-11-10T06:21:19.967065+00:00"
},
{
"path": "readoor/BookShelf/Classes/Factorys/XunFei/iflyMSC.framework/iflyMSC",
"initial_sha256": "b368fa4866d274da0c6e89607e9d5b95b4a59d49c183eb68c947ac2b50ff3c2c",
"observed_sha256": "b368fa4866d274da0c6e89607e9d5b95b4a59d49c183eb68c947ac2b50ff3c2c",
"matches_initial": true,
"mtime_utc": "2026-11-09T02:35:30.281591+00:00"
},
{
"path": "Podfile.lock",
"initial_sha256": "6f8c57990b2a277236145d2e84fb9634e3049f544da70346cbc7a536b0f929ec",
"observed_sha256": "6f8c57990b2a277236145d2e84fb9634e3049f544da70346cbc7a536b0f929ec",
"matches_initial": true,
"mtime_utc": "2026-11-09T02:39:06.704381+00:00"
}
]
}
}
@@ -0,0 +1,66 @@
{
"status": "passed_local_checks",
"app": {
"CFBundleIdentifier": "com.ecnup.aSCLdl2",
"CFBundleShortVersionString": "2.156.0",
"CFBundleVersion": "2.156.0.1",
"CFBundleExecutable": "readoor31"
},
"device_regression": "not_run",
"vendor_retest": "not_run",
"signing": "ad-hoc, static checks only",
"tests": "passed (详见 commands.log)",
"environment": "Xcode 27.1\nBuild version 27A9275",
"total_redirected": 2,
"before_total": 558,
"after_total": 556,
"input_sha256": "f730cb5f0a22fd20e5032c7cf808a195732a7d7107a5fd7498671c83c63d02f7",
"output_sha256": "3bf610eac5f5d6e3b21c80418afc9b3faa12dfc59e04a485b670dbc5e8f58bf9",
"ipa_sha256": "85ae4b064d8416a19f0cc60568cac151b3afc73dcc5fd30dabc91221424c22ef",
"static_tracking_limitations": [
"保留本地调度函数名,名称仍提示用途",
"目标函数名编码可由静态分析还原",
"解析器仍依赖 dlsym/dladdr;不代表调用关系完全不可恢复",
"其他调用者的系统导入/GOT 保留,本次只覆盖指定调用点"
],
"archive": "test-results/step2/zipzap-runtime-final-v3",
"test_counts": {
"automated": 44,
"isolated_device": 8,
"skipped": 0
},
"isolated_device": {
"status": "passed_isolated_diagnostic_only",
"archive": "test-results/step2/device-dispatch-v5",
"device": {
"model": "iPhone 16 Plus",
"os_version": "27.2"
},
"baseline_detected": 0,
"baseline_unavailable": 0,
"cleanup": "uninstalled diagnostic app; existing business apps untouched"
},
"business_app_regression": "not_run",
"actual_inline_hook": "not_run",
"archive_integrity_verified": true,
"step1_archive_integrity_verified": true,
"static_evidence_hash_index_sha256": "81645f9bb7f4e95c99a810569386a97de290346190016eafa90b659dc5632eb9",
"device_evidence_hash_index_sha256": "7045c25b3a284b67fa5b39813958b4b9f2056d7514da20a212f8aef798328e21",
"original_source_observation": [
{
"path": "readoor.xcodeproj/project.pbxproj",
"matches_step1_observation": true,
"observed_sha256": "b4a013c87bd0888c36fc0f7da8d73066a6010693d59c6525760f6879696a4c8d"
},
{
"path": "readoor/BookShelf/Classes/Factorys/XunFei/iflyMSC.framework/iflyMSC",
"matches_step1_observation": true,
"observed_sha256": "b368fa4866d274da0c6e89607e9d5b95b4a59d49c183eb68c947ac2b50ff3c2c"
},
{
"path": "Podfile.lock",
"matches_step1_observation": true,
"observed_sha256": "6f8c57990b2a277236145d2e84fb9634e3049f544da70346cbc7a536b0f929ec"
}
]
}
@@ -0,0 +1,17 @@
{
"date": "2026-11-10",
"stage": "observation_business_regression",
"release_build": "passed",
"host_tests": 45,
"host_tests_result": "passed",
"ui_runner_build": "passed",
"package_signature": "verified",
"package_hash_inventory_files": 594,
"business_regression": "not_run",
"blocker": "physical_device_offline_coredevice_4016",
"bundle_id": "cn.touchv.iosguard.observe.20261110",
"protected_zipzap_calls": 2,
"protection_expanded": false,
"actual_modern_unzip": "SSZipArchive",
"credentials_saved": false
}
@@ -0,0 +1,138 @@
{
"date": "2026-11-11",
"resource": "31单词书(稳操胜券)-勿动",
"bundle_id": "cn.touchv.iosguard.observe.20261110",
"source_version": "2.156.0",
"status": "framework_binding_pilot_and_same_build_wordbook_comparison_passed",
"protection_scope": [
"SSZipArchive: fopen",
"SSZipArchive: fread",
"SSZipArchive: fwrite",
"SSZipArchive: fclose"
],
"host_tool_tests": {
"total": 59,
"this_round": 14,
"passed": true,
"real_dyld_binding_and_got_tamper_test": "Apple Silicon macOS host; not iPhone attack validation"
},
"business_checks": {
"same_build_baseline_style_replay": "passed",
"guarded_style_replay": "passed",
"no_replay_normal_cache_and_reentry": "passed",
"foreground_recovery": "passed",
"learned_words": 0,
"unlearned_words": 7502
},
"comparison": {
"baseline_event": {
"archive_guard_loaded": false,
"call_id": "E69F522F-50ED-43F8-AE03-8898BF80EBB8",
"elapsed_ms": 38.530333345988765,
"event": "unzip_end",
"output_bytes": 1890776,
"output_files": 9,
"output_fingerprint_available": true,
"output_sha256": "7043dfcd54c6ce47154feb48b8ff2a19834c5f8cd4c28dabaa012fc96537ed79",
"sdk": "SSZipArchive",
"success": true,
"time": 1794363370.44353
},
"guard_event": {
"archive_guard_counters": {
"fclose_attempted": 10,
"fclose_dispatched": 10,
"fclose_rejected": 0,
"fopen_attempted": 10,
"fopen_dispatched": 10,
"fopen_rejected": 0,
"fread_attempted": 388,
"fread_dispatched": 388,
"fread_rejected": 0,
"fwrite_attempted": 466,
"fwrite_dispatched": 466,
"fwrite_rejected": 0
},
"archive_guard_loaded": true,
"archive_guard_status": 0,
"call_id": "E5F4CD08-4809-4FED-AF68-CF01D407E112",
"elapsed_ms": 43.01520832814276,
"event": "unzip_end",
"output_bytes": 1890776,
"output_files": 9,
"output_fingerprint_available": true,
"output_sha256": "7043dfcd54c6ce47154feb48b8ff2a19834c5f8cd4c28dabaa012fc96537ed79",
"sdk": "SSZipArchive",
"success": true,
"time": 1794363764.835278
},
"output_digest_equal": true,
"elapsed_delta_ms": 4.484874982153997,
"timing_scope": "单次单机样式解压记录区间,含开始事件观察开销,不含网络及自动化等待,非性能基准"
},
"normal_cache": {
"events": 9,
"cache_hit_types": [
"dict",
"sound",
"style"
],
"unzip_count": 0,
"guard_statuses": [
0
],
"counter_maxima": {
"fclose_attempted": 0,
"fclose_dispatched": 0,
"fclose_rejected": 0,
"fopen_attempted": 0,
"fopen_dispatched": 0,
"fopen_rejected": 0,
"fread_attempted": 0,
"fread_dispatched": 0,
"fread_rejected": 0,
"fwrite_attempted": 0,
"fwrite_dispatched": 0,
"fwrite_rejected": 0
}
},
"existing_defender_during_guard": {
"events": 5,
"detected_events": 0,
"unavailable_events": 0,
"zipzap_counter_maxima": {
"write_attempted": 0,
"write_dispatched": 0,
"close_attempted": 0,
"close_dispatched": 0
}
},
"original_vendor_sdk_unchanged": true,
"observation_container_incident": {
"target": "independent observation bundle only",
"style_backup_files": 9,
"reset_attempt_result": "CoreDevice7000/ActionError3",
"observed": "Documents reinitialized after install/reset sequence; exact trigger not isolated; full container restoration not established",
"subsequent_method": "no directory clearing; observation-only style replay",
"login_and_resource_after_incident": "wordbook UI passed with 0 learned / 7502 unlearned"
},
"automation_failure_record": "guard-v2-cache.xcresult: popup disappeared while XCTest waited; no resource entered; subsequent guard-v2-cache-v2.xcresult passed",
"uncovered": [
"iPhone 受控 GOT 篡改",
"实际系统代码 inline Hook",
"SDK 下载取消及失败传播",
"大包/长时间性能",
"arm64e/PAC 和其他 chained 格式",
"其他 SDK 或非四目标的 I/O",
"生产强制业务门禁",
"完整业务回归及原报告同版本复测"
],
"deferred_by_user": [
"PDF 越界修复",
"完整业务回归",
"报告复测"
],
"guard_package": "test-results/step5-ssziparchive/guard-v2-package",
"baseline_package": "test-results/step5-ssziparchive/baseline-v2-package",
"evidence_directory": "test-results/step5-ssziparchive/final-evidence"
}
@@ -0,0 +1,44 @@
{
"date": "2026-11-11",
"timezone": "Asia/Tokyo",
"status": "business_regression_partially_passed",
"bundle_id": "cn.touchv.iosguard.observe.20261110",
"source_version": "2.156.0",
"user_completed_real_login": true,
"fake_login": false,
"functional_checks": {
"home_resource_detail_and_foreground": "passed",
"epub_content_and_foreground": "passed",
"cold_restart": "passed"
},
"pdf_trial": "failed_existing_array_bounds_exception_reproduced_in_same_build_baseline",
"pdf_exception": "NSRangeException: index 2 beyond bounds [0 .. 1]",
"guard_restored_after_baseline": true,
"zipzap_protected_path_business_coverage": "not_hit",
"protection_expanded": false,
"observation": {
"events": 14,
"detected_event_count": 0,
"unavailable_event_count": 0,
"scan_ms_min": 4.2584583279676735,
"scan_ms_median": 14.205458341166377,
"scan_ms_max": 29.871833336073905,
"counter_maxima": {
"write_attempted": 0,
"write_dispatched": 0,
"close_attempted": 0,
"close_dispatched": 0
},
"scope": "单机小样本,含加固与基线阶段的启动/前台事件,非性能基准"
},
"uncovered": [
"ZipZap 文件输出实际业务命中",
"PDF 正常阅读/翻页",
"下载取消及失败路径",
"支付及第三方 Bundle ID 绑定能力",
"实际 inline Hook",
"原报告同版本厂商复测"
],
"credentials_in_driver_source": false,
"evidence_directory": "test-results/step3/business-run-20261111"
}
@@ -0,0 +1,65 @@
{
"date": "2026-11-11",
"resource": "31单词书(稳操胜券)-勿动",
"bundle_id": "cn.touchv.iosguard.observe.20261110",
"source_version": "2.156.0",
"status": "ssziparchive_boundary_invocation_and_wordbook_smoke_passed",
"checks": {
"home_to_detail": "passed",
"wordbook_ready": "passed",
"learned_words": 0,
"unlearned_words": 7502,
"background_foreground": "passed",
"reentry": "passed",
"reentry_cache_types": [
"style",
"dict",
"sound"
]
},
"archive": {
"begin_count": 1,
"end_count": 1,
"successful_count": 1,
"elapsed_ms": [
12015.23712501512
],
"initial_cached_types": [
"style",
"dict"
],
"fresh_style_dict_extraction": "not_covered",
"initial_unzip_resource_type": "not_recorded_at_sdk_boundary"
},
"security": {
"new_events": 2,
"detected_events": 0,
"unavailable_events": 0,
"counter_maxima": {
"write_attempted": 0,
"write_dispatched": 0,
"close_attempted": 0,
"close_dispatched": 0
}
},
"protection_expanded": false,
"sdk_internal_libc_protection_verified": false,
"deferred_by_user": [
"PDF 数组越界修复",
"完整业务回归",
"报告复测"
],
"driver_adjustments": [
"detail.xcresult: 首页营销弹窗导致不可点击",
"detail-v2.xcresult: 进入详情壳;截图尚在骨架加载",
"read.xcresult: 该商品无开始阅读按钮,入口为稳操胜券课件卡片",
"read-v2.xcresult: 课件卡片进入、就绪及前后台通过",
"reentry.xcresult: 返回重进、缓存及前后台通过"
],
"evidence_directory": "test-results/step4-wordbook/business-run",
"limitations": [
"SDK 调用成功是 SDK 返回值,未逐文件校验输出内容",
"未进入学习/复习或完成学习任务",
"未做故障注入及 SDK 内部 fopen/fwrite 调度加固"
]
}
@@ -0,0 +1,231 @@
import XCTest
import UIKit
/// 访问真实观察包;不使用 --UITesting,不注入 token,不调用购买接口。
final class IGBusinessRegressionTests: XCTestCase {
private let bundleID = "cn.touchv.iosguard.observe.20261110"
override func setUpWithError() throws { continueAfterFailure = false }
private func capture(_ app: XCUIApplication, _ name: String) {
// 截图遮盖输入框,文本树移除输入值,避免登录排查留存凭证。
let source = app.screenshot().image
let fields = app.textFields.allElementsBoundByIndex + app.secureTextFields.allElementsBoundByIndex
let screenshotImage = UIGraphicsImageRenderer(size: source.size).image { context in
source.draw(at: .zero)
UIColor.lightGray.setFill()
let sx = source.size.width / app.frame.width
let sy = source.size.height / app.frame.height
for field in fields {
let frame = field.frame
context.fill(CGRect(x: frame.minX * sx, y: frame.minY * sy,
width: frame.width * sx, height: frame.height * sy))
}
}
let screenshot = XCTAttachment(image: screenshotImage)
screenshot.name = name
screenshot.lifetime = .keepAlways
add(screenshot)
let redactedTree = app.debugDescription.components(separatedBy: "\n").map { line in
guard line.contains("TextField"), let value = line.range(of: ", value:") else { return line }
return String(line[..<value.lowerBound]) + ", value: [redacted]"
}.joined(separator: "\n")
let tree = XCTAttachment(string: redactedTree)
tree.name = name + "-accessibility"
tree.lifetime = .keepAlways
add(tree)
}
func testInspectLaunch() {
let app = XCUIApplication(bundleIdentifier: bundleID)
app.launch()
XCTAssertTrue(app.wait(for: .runningForeground, timeout: 30))
capture(app, "observation-launch")
}
func testInspectCurrentPage() {
let app = XCUIApplication(bundleIdentifier: bundleID)
app.activate()
capture(app, "observation-current")
}
func testAllowWifiAndInspect() {
let app = XCUIApplication(bundleIdentifier: bundleID)
let springboard = XCUIApplication(bundleIdentifier: "com.apple.springboard")
let wifi = springboard.buttons["仅限无线局域网"]
if wifi.waitForExistence(timeout: 5) { wifi.tap() }
app.activate()
_ = app.images["splash"].waitForNonExistence(timeout: 20)
capture(app, "after-network-permission")
}
func testHomeResourceAndForeground() throws {
let app = XCUIApplication(bundleIdentifier: bundleID)
app.activate()
let home = app.otherElements["home_page_anchor"]
XCTAssertTrue(home.waitForExistence(timeout: 30), "需先完成真实登录与启动流程")
// 实际首页资源由 TableCell 内自绘卡片承载,使用已观察到的资源标题。
let resource = app.staticTexts["[pdf]MW书籍测试读"].firstMatch
XCTAssertTrue(resource.waitForExistence(timeout: 20))
capture(app, "home-before-resource")
resource.tap()
let detail = app.otherElements["detail_page_anchor"]
XCTAssertTrue(detail.waitForExistence(timeout: 20), "首个首页卡片未进入商品详情")
capture(app, "resource-detail")
XCUIDevice.shared.press(.home)
XCTAssertTrue(app.wait(for: .runningBackground, timeout: 10))
app.activate()
XCTAssertTrue(app.wait(for: .runningForeground, timeout: 10))
XCTAssertTrue(detail.waitForExistence(timeout: 10))
capture(app, "resource-after-foreground")
}
func testTrialResourceAndInspect() {
let app = XCUIApplication(bundleIdentifier: bundleID)
app.activate()
let trial = app.buttons["试读"].firstMatch
XCTAssertTrue(trial.waitForExistence(timeout: 15))
trial.tap()
// 入口可能先展示课件/规格选择,先留存真实页面再决定下一步。
capture(app, "after-trial-entry")
}
func testColdRestartAndInspect() {
let app = XCUIApplication(bundleIdentifier: bundleID)
app.terminate()
app.launch()
XCTAssertTrue(app.wait(for: .runningForeground, timeout: 30))
XCTAssertTrue(app.otherElements["home_page_anchor"].waitForExistence(timeout: 30))
capture(app, "after-cold-restart")
}
func testPDFTrialAndPageTurn() {
let app = XCUIApplication(bundleIdentifier: bundleID)
app.terminate()
app.launch()
XCTAssertTrue(app.otherElements["home_page_anchor"].waitForExistence(timeout: 30))
let resource = app.staticTexts["[pdf]MW书籍测试读"].firstMatch
XCTAssertTrue(resource.waitForExistence(timeout: 15))
resource.tap()
XCTAssertTrue(app.otherElements["detail_page_anchor"].waitForExistence(timeout: 20))
let trial = app.buttons["试读"].firstMatch
XCTAssertTrue(trial.waitForExistence(timeout: 15))
trial.tap()
XCTAssertTrue(app.buttons["titlebar return phone"].waitForExistence(timeout: 20))
_ = app.progressIndicators["进度"].waitForNonExistence(timeout: 30)
XCTAssertTrue(app.wait(for: .runningForeground, timeout: 5))
capture(app, "pdf-before-page-turn")
app.swipeLeft()
XCTAssertTrue(app.wait(for: .runningForeground, timeout: 5), "PDF 翻页后进程退出")
capture(app, "pdf-after-page-turn")
}
func testEPUBResourceAndForeground() {
let app = XCUIApplication(bundleIdentifier: bundleID)
app.terminate()
app.launch()
XCTAssertTrue(app.otherElements["home_page_anchor"].waitForExistence(timeout: 30))
let resource = app.staticTexts["【epub】会员免费书籍"].firstMatch
XCTAssertTrue(resource.waitForExistence(timeout: 15))
resource.tap()
XCTAssertTrue(app.otherElements["detail_page_anchor"].waitForExistence(timeout: 20))
capture(app, "epub-detail")
let read = app.buttons["开始阅读"].firstMatch
let trial = app.buttons["试读"].firstMatch
if read.exists { read.tap() }
else {
XCTAssertTrue(trial.waitForExistence(timeout: 10), "本账号没有可用阅读入口")
trial.tap()
}
capture(app, "epub-entry")
XCTAssertTrue(app.webViews.firstMatch.waitForExistence(timeout: 30), "尚未出现 EPUB 内容视图")
capture(app, "epub-content")
XCUIDevice.shared.press(.home)
XCTAssertTrue(app.wait(for: .runningBackground, timeout: 10))
app.activate()
XCTAssertTrue(app.wait(for: .runningForeground, timeout: 10))
XCTAssertTrue(app.webViews.firstMatch.waitForExistence(timeout: 15))
capture(app, "epub-after-foreground")
}
func testWordbookOpenAndInspect() {
openWordbook(replayStyle: true)
}
private func openWordbook(replayStyle: Bool) {
let app = XCUIApplication(bundleIdentifier: bundleID)
app.launchArguments = replayStyle ? ["--IGArchiveReplayStyle"] : []
app.terminate()
app.launch()
XCTAssertTrue(app.otherElements["home_page_anchor"].waitForExistence(timeout: 30))
let popupClose = app.buttons["rd pop close"]
if popupClose.waitForExistence(timeout: 5) { popupClose.tap() }
capture(app, "wordbook-home")
let resource = app.staticTexts["31单词书(稳操胜券)-勿动"].firstMatch
XCTAssertTrue(resource.waitForExistence(timeout: 20))
resource.tap()
XCTAssertTrue(app.otherElements["detail_page_anchor"].waitForExistence(timeout: 20))
capture(app, "wordbook-detail")
}
func testWordbookReadAndForeground() {
let app = XCUIApplication(bundleIdentifier: bundleID)
app.activate()
let read = app.buttons["开始阅读"].firstMatch
let section = app.staticTexts["稳操胜券"].firstMatch
XCTAssertTrue(section.waitForExistence(timeout: 20), "需先打开指定单词书详情")
capture(app, "wordbook-loaded-detail")
if read.exists { read.tap() } else { section.tap() }
capture(app, "wordbook-after-read-entry")
let ready = app.staticTexts["今日学习单词了吗?"].firstMatch
XCTAssertTrue(ready.waitForExistence(timeout: 120), "单词书未准备完成")
XCTAssertTrue(ready.isHittable, "单词书就绪内容不可见")
capture(app, "wordbook-ready")
XCUIDevice.shared.press(.home)
XCTAssertTrue(app.wait(for: .runningBackground, timeout: 10))
app.activate()
XCTAssertTrue(app.wait(for: .runningForeground, timeout: 10))
XCTAssertTrue(ready.waitForExistence(timeout: 15))
capture(app, "wordbook-after-foreground")
}
func testWordbookReentryAndCache() {
let app = XCUIApplication(bundleIdentifier: bundleID)
app.activate()
let back = app.buttons["mw backBar img"].firstMatch
XCTAssertTrue(back.waitForExistence(timeout: 10))
back.tap()
let section = app.staticTexts["稳操胜券"].firstMatch
XCTAssertTrue(section.waitForExistence(timeout: 15))
section.tap()
let ready = app.staticTexts["今日学习单词了吗?"].firstMatch
XCTAssertTrue(ready.waitForExistence(timeout: 60))
XCTAssertTrue(ready.isHittable)
capture(app, "wordbook-reentry-cache")
XCUIDevice.shared.press(.home)
XCTAssertTrue(app.wait(for: .runningBackground, timeout: 10))
app.activate()
XCTAssertTrue(app.wait(for: .runningForeground, timeout: 10))
XCTAssertTrue(ready.waitForExistence(timeout: 15))
capture(app, "wordbook-reentry-foreground")
}
func testWordbookFreshExtraction() {
testWordbookOpenAndInspect()
testWordbookReadAndForeground()
}
func testWordbookCachedEntryAndReentry() {
// 由单独无参数启动步骤进入首页,避免将短暂营销弹窗的自动消失误记为业务失败。
let app = XCUIApplication(bundleIdentifier: bundleID)
app.activate()
XCTAssertTrue(app.otherElements["home_page_anchor"].waitForExistence(timeout: 20))
let resource = app.staticTexts["31单词书(稳操胜券)-勿动"].firstMatch
XCTAssertTrue(resource.waitForExistence(timeout: 15))
XCTAssertTrue(resource.isHittable)
resource.tap()
XCTAssertTrue(app.otherElements["detail_page_anchor"].waitForExistence(timeout: 20))
testWordbookReadAndForeground()
testWordbookReentryAndCache()
}
}
@@ -0,0 +1,436 @@
import XCTest
import UIKit
/// 反 Hook 门禁按钮级回归(强制模式 dev 包 cn.touchv.a4YX061)。
///
/// 相位(按方法名字典序执行):
/// A1 干净启动勘察;A2 登出到登录页(个人中心 退出登录);
/// B1 注入启动·密码登录门禁;B2 注入启动·第三方登录门禁;
/// C1 干净启动·密码登录放行(DEBUG 预填测试账号真实登录);
/// D1 注入启动·VIP 购买门禁(会员页);E1 注入启动·激活码门禁(我的页探测入口)。
///
/// 注入:编排器(run_gate_regression.sh)以 devicectl `-e DYLD_INSERT_LIBRARIES`
/// 调试启动通道预先注入启动(空壳 libfrida-sim.dylib),注入相位测试仅 activate()
/// attach 到该进程——v4 教训:XCUITest launchEnvironment 的 DYLD_INSERT 经
/// SpringBoard 启动链被剥离,门禁不触发。各相位以 -only-testing 分批执行(v6 序,
/// XCUITest↔devicectl 切换仅 2 次):干净批 A1/A2(游客态)→ 注入批 B1/B2(游客)
/// → 干净批 C1(放行证明)→ 注入批 D1/E1(登录态,未登成则游客守卫跳过)。
/// v5e 教训:devicectl `--console` 通道在连续会话后整体卡死(零输出+进程即死),
/// 注入启动不用 console,注入生效由测试内门禁 toast 端到端自证。
/// 教训(B2 首版崩溃):营销弹窗自动消失瞬间盲点「rd pop close」会落到其下方的
/// 首页搜索按钮,触发路由重复注册 assertion 崩溃(业务既有 bug)——先等自然消失再点,
/// 且点击前复核存在与可点性。
/// 凭证不入日志:截图遮盖输入框、文本树脱敏(沿用业务观察 Runner 做法)。
final class IGGateRegressionTests: XCTestCase {
private let bundleID = "cn.touchv.a4YX061"
private var injectLib: String? { ProcessInfo.processInfo.environment["INJECT_LIB"] }
private let blockLoginToast = "当前环境暂时无法登录,请稍后重试"
private let blockVipToast = "当前环境暂时无法购买,请稍后重试"
private let blockActivationToast = "当前环境暂时无法激活,请稍后重试"
override func setUpWithError() throws { continueAfterFailure = false }
// MARK: - 工具
/// 脱敏截图(遮盖输入框)+ 脱敏文本树,全部 keepAlways 留证。
private func capture(_ app: XCUIApplication, _ name: String) {
let source = app.screenshot().image
let fields = app.textFields.allElementsBoundByIndex + app.secureTextFields.allElementsBoundByIndex
let screenshotImage = UIGraphicsImageRenderer(size: source.size).image { context in
source.draw(at: .zero)
UIColor.lightGray.setFill()
let sx = source.size.width / app.frame.width
let sy = source.size.height / app.frame.height
for field in fields {
let frame = field.frame
context.fill(CGRect(x: frame.minX * sx, y: frame.minY * sy,
width: frame.width * sx, height: frame.height * sy))
}
}
let screenshot = XCTAttachment(image: screenshotImage)
screenshot.name = name
screenshot.lifetime = .keepAlways
add(screenshot)
let redactedTree = app.debugDescription.components(separatedBy: "\n").map { line in
guard line.contains("TextField"), let value = line.range(of: ", value:") else { return line }
return String(line[..<value.lowerBound]) + ", value: [redacted]"
}.joined(separator: "\n")
let tree = XCTAttachment(string: redactedTree)
tree.name = name + "-accessibility"
tree.lifetime = .keepAlways
add(tree)
}
private func step(_ message: String) {
NSLog("[GateRegression] %@", message)
}
private func launchApp(_ app: XCUIApplication, injected: Bool) throws {
if injected {
// v4 教训:XCUITest launchEnvironment 的 DYLD_INSERT_LIBRARIES 经 SpringBoard
// 启动链被剥离(B1 门禁 toast 不出现)——注入进程由编排器以 devicectl
// `-e` 调试启动通道预先启动,测试只 attach(activate 不重启,注入保持)。
guard app.state == .runningForeground || app.state == .runningBackground else {
try skipAndCapture("注入进程未运行(编排器须先 devicectl 注入启动本 App)")
}
app.activate()
XCTAssertTrue(app.wait(for: .runningForeground, timeout: 30), "注入进程未进前台")
return
}
app.terminate()
app.launch()
XCTAssertTrue(app.wait(for: .runningForeground, timeout: 40), "应用未进入前台")
}
private func skipAndCapture(_ reason: String) throws -> Never {
step("SKIP: \(reason)")
throw XCTSkip(reason)
}
/// 等待登录页或首页锚点,返回 "login" / "home" / "unknown"。
private func waitLoginOrHome(_ app: XCUIApplication, timeout: TimeInterval = 25) -> String {
if app.otherElements["login_page_anchor"].waitForExistence(timeout: timeout) { return "login" }
if app.otherElements["home_page_anchor"].waitForExistence(timeout: 10) { return "home" }
return "unknown"
}
/// 关闭可能遮挡的营销弹窗:先等自然消失(约 6 秒),仍在且可点才点关闭。
/// 不盲点:弹窗消失瞬间点击会落到其下方控件(首版曾误触首页搜索引发路由崩溃)。
private func dismissPopups(_ app: XCUIApplication) {
let popupClose = app.buttons["rd pop close"]
if popupClose.waitForNonExistence(timeout: 6) { return }
if popupClose.exists && popupClose.isHittable {
popupClose.tap()
_ = popupClose.waitForNonExistence(timeout: 3)
}
}
/// 勾选登录协议(v3 登录页树:勾选框暴露 identifier login_agreement_checkbox)。
private func selectAgreementIfNeeded(_ app: XCUIApplication) {
let agreement = app.otherElements["login_agreement_view"]
_ = agreement.waitForExistence(timeout: 10)
let checkbox = app.buttons["login_agreement_checkbox"].firstMatch
if checkbox.exists {
if checkbox.isHittable { checkbox.tap() }
step("已点击协议勾选框")
} else {
let fallback = agreement.buttons.firstMatch
if fallback.exists, fallback.isHittable {
fallback.tap()
step("勾选框无 identifier,已点协议视图内按钮")
} else {
step("协议勾选框未暴露,跳过勾选")
}
}
}
/// 断言门禁 toast 出现并等其消失。
private func assertToast(_ app: XCUIApplication, text: String, label: String) {
let toast = app.staticTexts[text].firstMatch
XCTAssertTrue(toast.waitForExistence(timeout: 6), "\(label):未出现门禁 toast「\(text)」")
capture(app, label + "-toast")
_ = toast.waitForNonExistence(timeout: 8)
}
/// 首页就绪并稳定(弹窗处理完成)。
private func waitHomeStable(_ app: XCUIApplication, timeout: TimeInterval = 30) throws {
XCTAssertTrue(app.otherElements["home_page_anchor"].waitForExistence(timeout: timeout), "未进入首页")
dismissPopups(app)
}
/// 游客态从首页导航到登录页:「我的」页「登录/注册」按钮(v2 勘察树确认)。
/// 返回 false 表示入口不可达(多为已登录态),由调用方决定跳过或走既有会话判定。
/// v3 教训:启动偶发落在无 tab bar 的推广落地页(AllTypes 书城页)——
/// 先等待/返回自救,仍无 tab 则重启一次重抽落地页。
private func navigateToLoginFromHome(_ app: XCUIApplication, allowRelaunch: Bool = true) -> Bool {
func attempt() -> Bool {
let mineTab = app.tabBars.buttons["我的"].firstMatch
if !mineTab.waitForExistence(timeout: 12) {
// 落地页自救:点导航返回键(若在二级页)后再等 tab。
let back = app.buttons["nav black goback"].firstMatch
if back.exists, back.isHittable {
back.tap()
step("落地页无 tab,已点返回")
}
if !mineTab.waitForExistence(timeout: 12) { return false }
}
mineTab.tap()
_ = app.otherElements["personal_center_page_anchor"].waitForExistence(timeout: 10)
dismissPopups(app)
let guestEntry = app.buttons["登录/注册"].firstMatch
guard guestEntry.waitForExistence(timeout: 8), guestEntry.isHittable else { return false }
guestEntry.tap()
return app.otherElements["login_page_anchor"].waitForExistence(timeout: 20)
}
if attempt() { return true }
guard allowRelaunch else { return false }
step("首轮导航失败,重启重抽落地页")
app.terminate()
app.launch()
guard app.wait(for: .runningForeground, timeout: 40) else { return false }
_ = app.otherElements["home_page_anchor"].waitForExistence(timeout: 25)
dismissPopups(app)
return attempt()
}
// MARK: - A 勘察与登出
func testA1InspectCleanState() throws {
let app = XCUIApplication(bundleIdentifier: bundleID)
step("A1 干净启动勘察开始,INJECT_LIB=\(injectLib ?? "未传入")")
try launchApp(app, injected: false)
let state = waitLoginOrHome(app)
step("A1 启动状态=\(state)")
if state == "home" { dismissPopups(app) }
capture(app, "a1-clean-\(state)")
}
func testA2LogoutIfNeeded() throws {
let app = XCUIApplication(bundleIdentifier: bundleID)
step("A2 确保登录页可达(游客直进;登录态经设置页登出)")
try launchApp(app, injected: false)
let state = waitLoginOrHome(app)
if state == "login" {
step("A2 已在登录页")
capture(app, "a2-already-login")
return
}
guard state == "home" else { try skipAndCapture("A2 首页不可达(状态 \(state))") }
dismissPopups(app)
let mineTab = app.tabBars.buttons["我的"].firstMatch
XCTAssertTrue(mineTab.waitForExistence(timeout: 10), "未找到「我的」页签")
mineTab.tap()
_ = app.otherElements["personal_center_page_anchor"].waitForExistence(timeout: 10)
sleep(2)
dismissPopups(app)
capture(app, "a2-mine-page")
// 游客态(v2 树:登录/注册按钮)直接进登录页,B 阶段即可测登录门禁。
let guestEntry = app.buttons["登录/注册"].firstMatch
if guestEntry.exists, guestEntry.isHittable {
guestEntry.tap()
XCTAssertTrue(app.otherElements["login_page_anchor"].waitForExistence(timeout: 20), "游客点「登录/注册」未进入登录页")
step("A2 游客态进入登录页")
capture(app, "a2-guest-login-page")
return
}
// 登录态:右上角设置图标(v2 树:personalCenter setting)→ 设置页底部「退出登录」。
let settingIcon = app.buttons["personalCenter setting"].firstMatch
XCTAssertTrue(settingIcon.exists && settingIcon.isHittable, "未找到设置入口(见 a2 勘察树)")
settingIcon.tap()
sleep(2)
capture(app, "a2-settings-page")
// 退出登录在设置列表尾部,滚动查找(cell 标签为文本)。
var confirmedLogout = false
for _ in 0..<4 where !confirmedLogout {
let logoutBtn = app.buttons.containing(NSPredicate(format: "label CONTAINS '退出登录'")).firstMatch
let logoutText = app.staticTexts.containing(NSPredicate(format: "label CONTAINS '退出登录'")).firstMatch
if logoutBtn.exists { logoutBtn.tap(); confirmedLogout = true }
else if logoutText.exists { logoutText.tap(); confirmedLogout = true }
else { app.swipeUp() }
}
XCTAssertTrue(confirmedLogout, "设置页未找到退出登录入口(见 a2-settings-page 树)")
sleep(1)
capture(app, "a2-logout-confirm")
// 确认弹窗(自定义两键弹窗,右侧确认键常见文案逐个尝试)。
for confirm in ["确定", "退出", "确认", "退出登录"] {
let button = app.buttons[confirm].firstMatch
if button.waitForExistence(timeout: 2) && button.isHittable {
button.tap()
step("A2 确认退出(「\(confirm)」)")
break
}
}
let back = waitLoginOrHome(app, timeout: 30)
step("A2 登出后状态=\(back)")
capture(app, "a2-after-logout-\(back)")
XCTAssertEqual(back, "login", "登出后未回到登录页")
}
// MARK: - B 拦截相位(注入启动·登录入口)
func testB1BlockPasswordLogin() throws {
let app = XCUIApplication(bundleIdentifier: bundleID)
step("B1 注入启动·密码登录门禁")
try launchApp(app, injected: true)
// 注入相位严禁 clean 重启(activate 之外的 launch 会丢 DYLD 注入),
// navigate 不带 relaunch 自救;导航失败即跳过留证。
var state = waitLoginOrHome(app)
if state == "home", navigateToLoginFromHome(app, allowRelaunch: false) { state = "login" }
capture(app, "b1-inject-\(state)")
guard state == "login" else {
try skipAndCapture("B1 登录页不可达(状态 \(state),游客入口缺失)")
}
capture(app, "b1-login-page")
// 门禁在输入校验之前:空输入点击提交也必须先命中门禁 toast。
let submit = app.buttons["login_submit_button"]
XCTAssertTrue(submit.waitForExistence(timeout: 10), "未找到登录提交按钮")
submit.tap()
assertToast(app, text: blockLoginToast, label: "b1-block-password-login")
// 门禁 toast 之外不应出现协议弹窗(出现说明执行越过了门禁)。
let agreementAlert = app.alerts["请先阅读并同意协议"]
XCTAssertFalse(agreementAlert.waitForExistence(timeout: 2), "点击越过了门禁(出现协议弹窗)")
capture(app, "b1-block-after")
}
func testB2BlockOtherLogins() throws {
let app = XCUIApplication(bundleIdentifier: bundleID)
step("B2 注入启动·第三方登录门禁(微信/QQ/Apple/Weread)")
try launchApp(app, injected: true)
var state = waitLoginOrHome(app)
if state == "home", navigateToLoginFromHome(app, allowRelaunch: false) { state = "login" }
guard state == "login" else {
try skipAndCapture("B2 登录页不可达(状态 \(state),游客入口缺失)")
}
selectAgreementIfNeeded(app)
capture(app, "b2-login-page")
// v3 登录页树:第三方按钮为纯图片,label 即图片名(rd login wechat/qq/apple/wjOauth2)。
var tapped = 0
for label in ["rd login wechat", "rd login qq", "rd login apple", "rd login wjOauth2"] {
let entry = app.buttons[label].firstMatch
guard entry.waitForExistence(timeout: 3), entry.isHittable else { continue }
entry.tap()
tapped += 1
step("B2 点击第三方入口「\(label)」")
assertToast(app, text: blockLoginToast, label: "b2-block-\(label)")
}
if tapped == 0 {
capture(app, "b2-no-third-party-buttons")
try skipAndCapture("登录页未暴露可识别的第三方登录按钮(见 b2-login-page 树)")
}
step("B2 完成,拦截入口数=\(tapped)")
}
// MARK: - C 放行相位(干净启动·真实登录)
func testC1AllowPasswordLogin() throws {
let app = XCUIApplication(bundleIdentifier: bundleID)
step("C1 干净启动·密码登录放行")
try launchApp(app, injected: false)
let bootState = waitLoginOrHome(app)
var loginReached = bootState == "login"
if !loginReached, bootState == "home" {
// 游客态(home ≠ 已登录)也从「我的」页进入登录页做真实登录。
loginReached = navigateToLoginFromHome(app)
}
if !loginReached {
step("C1 登录页不可达且我的页无「登录/注册」(已登录态),放行以启动期零拦截与既有会话为证")
capture(app, "c1-already-home")
return
}
capture(app, "c1-login-page")
selectAgreementIfNeeded(app)
let submit = app.buttons["login_submit_button"]
XCTAssertTrue(submit.waitForExistence(timeout: 10), "未找到登录提交按钮")
if !submit.isEnabled {
// 提交钮不可用才尝试补输入(v5d 教训:验证码框存在不代表必填,
// 盲填占位值反而制造服务端拒绝)。先补图形验证码占位值,再退化到账号框刷新。
let captcha = app.textFields.containing(NSPredicate(format: "placeholderValue CONTAINS '验证码'")).firstMatch
if captcha.exists {
captcha.tap()
captcha.typeText("1111")
step("C1 提交钮不可用,已补图形验证码占位值 isEnabled=\(submit.isEnabled)")
}
if !submit.isEnabled {
let account = app.textFields["login_phone_input"].firstMatch
if account.exists { account.tap(); account.typeText("1") }
step("C1 仍不可用,已触发账号输入刷新 isEnabled=\(submit.isEnabled)")
}
}
capture(app, "c1-before-submit")
submit.tap()
// 放行判定(v6 修订):核心断言 = 门禁 toast 不出现(门禁放行)。
// 业务进展尽力而为留证:DEBUG 预填账号的图形验证码无法自动识别,服务端
// 拒绝时停留登录页属业务侧限制而非门禁问题(v5e 留证:干净提交后门禁
// toast 与协议弹窗均未出现)。登录态若未建立,D1/E1 以游客守卫跳过。
let gateToast = app.staticTexts[blockLoginToast].firstMatch
XCTAssertFalse(gateToast.waitForExistence(timeout: 6), "干净环境出现门禁 toast(误拦截)")
let home = app.otherElements["home_page_anchor"]
let agreementAlert = app.alerts["请先阅读并同意协议"]
let progress = home.waitForExistence(timeout: 45)
|| agreementAlert.waitForExistence(timeout: 5)
step("C1 门禁放行成立;业务进展标记=\(progress)(验证码服务端拒绝属业务侧限制)")
capture(app, "c1-after-login-attempt")
}
// MARK: - D/E 拦截相位(注入启动·VIP 与激活入口)
func testD1BlockVipPurchase() throws {
let app = XCUIApplication(bundleIdentifier: bundleID)
step("D1 注入启动·VIP 购买门禁")
try launchApp(app, injected: true)
try waitHomeStable(app, timeout: 90)
let vipTab = app.tabBars.buttons["会员"].firstMatch
XCTAssertTrue(vipTab.waitForExistence(timeout: 10), "未找到「会员」页签")
vipTab.tap()
// v3 树:会员页用户区游客显示「游客」——登录态缺失时购买被业务游客检查
// 拦在 sendPayVip 门禁之前,skip 留证而不误判门禁失效。
_ = app.staticTexts["游客"].waitForExistence(timeout: 5)
if app.staticTexts["游客"].firstMatch.exists {
capture(app, "d1-guest-state")
try skipAndCapture("会员页为游客态(C1 未建立登录态),VIP 门禁需登录后重跑")
}
// v2 树:购买按钮为富文本 label(如「立即购买 · ¥6.00 100.00」),已会员时为「立即续费 …」。
let buyPred = NSPredicate(format: "label BEGINSWITH '立即购买' OR label BEGINSWITH '立即续费'")
let buyBtn = app.buttons.containing(buyPred).firstMatch
XCTAssertTrue(buyBtn.waitForExistence(timeout: 15), "会员页未出现购买按钮(见 d1 勘察树)")
sleep(2)
dismissPopups(app)
capture(app, "d1-vip-page")
// 先勾选 VIP 协议(未勾选时点购买先弹协议提示,越不过门禁汇合点)。
let checkbox = app.buttons["rd vip checkbox unselect"].firstMatch
if checkbox.exists, checkbox.isHittable {
checkbox.tap()
step("D1 已勾选 VIP 协议")
} else {
capture(app, "d1-checkbox-missing")
}
buyBtn.tap()
step("D1 点击购买按钮「\(buyBtn.label)」")
assertToast(app, text: blockVipToast, label: "d1-block-vip")
}
func testE1BlockActivation() throws {
let app = XCUIApplication(bundleIdentifier: bundleID)
step("E1 注入启动·激活码门禁")
try launchApp(app, injected: true)
try waitHomeStable(app, timeout: 90)
let mineTab = app.tabBars.buttons["我的"].firstMatch
XCTAssertTrue(mineTab.waitForExistence(timeout: 10), "未找到「我的」页签")
mineTab.tap()
sleep(2)
dismissPopups(app)
capture(app, "e1-mine-page")
// 激活入口探测(标签以勘察树为准)。
var activationEntered = false
for keyword in ["激活码", "激活"] {
let entryBtn = app.buttons.containing(NSPredicate(format: "label CONTAINS %@", keyword)).firstMatch
let entryText = app.staticTexts.containing(NSPredicate(format: "label CONTAINS %@", keyword)).firstMatch
if entryBtn.exists { entryBtn.tap(); activationEntered = true; step("E1 点击「\(keyword)」按钮入口"); break }
if entryText.exists { entryText.tap(); activationEntered = true; step("E1 点击「\(keyword)」文本入口"); break }
}
guard activationEntered else {
capture(app, "e1-no-activation-entry")
try skipAndCapture("「我的」页未找到激活入口,需按勘察树修正导航")
}
sleep(2)
// v3 教训:游客点「激活码」被带到登录页(激活需登录态)——先判定落点。
if app.otherElements["login_page_anchor"].waitForExistence(timeout: 5) {
capture(app, "e1-guest-to-login")
try skipAndCapture("激活入口要求登录态(C1 未建立登录会话),激活门禁需登录后重跑")
}
capture(app, "e1-activation-page")
// 激活码输入(被拦截环境填占位值即可,请求不会发出)。
let codeField = (app.textFields.firstMatch.exists ? app.textFields : app.secureTextFields).firstMatch
if codeField.exists {
codeField.tap()
codeField.typeText("1")
}
var activated = false
for label in ["立即激活", "激活", "确定"] {
let button = app.buttons[label].firstMatch
if button.exists, button.isHittable { button.tap(); activated = true; step("E1 点击激活按钮「\(label)」"); break }
}
XCTAssertTrue(activated, "激活页未找到激活按钮(见 e1-activation-page 树)")
assertToast(app, text: blockActivationToast, label: "e1-block-activation")
}
}
+111
View File
@@ -0,0 +1,111 @@
/*
* anti_tamper_host.c — IGAntiTamper cryptid 核心的宿主自测。
*
* 用合成 Mach-O 头(header + 可选 LC_ENCRYPTION_INFO_64)驱动 ig_tamper_scan_cryptid,
* 覆盖四种情形:加密正常(cryptid=1)、脱壳(cryptid=0)、加密命令被剥除、非分发构建跳过。
* 退出码 0 = 全部用例通过。不依赖真机(csops/真实镜像那部分由设备测试覆盖)。
*/
#include "anti_tamper/IGAntiTamper.h"
#include <mach-o/loader.h>
#include <stdio.h>
#include <string.h>
typedef struct {
int detected; /* DETECTED 条数 */
int unavailable; /* UNAVAILABLE 条数 */
int last_reason; /* 最后一条 DETECTED 的 reason */
} Counter;
static int sink(const IGFinding *f, void *ctx) {
Counter *c = (Counter *)ctx;
if (f->status == IG_DETECTED) { c->detected++; c->last_reason = f->reason; }
if (f->status == IG_UNAVAILABLE) { c->unavailable++; }
return 0;
}
/* 构造一个带 ncmds 的最小 mach_header_64;commands 由调用方填好拼在后面。 */
typedef struct {
struct mach_header_64 mh;
union {
struct encryption_info_command_64 enc;
unsigned char raw[256];
} cmds;
} FakeImage;
static void init_header(FakeImage *img, uint32_t ncmds, uint32_t sizeofcmds) {
memset(img, 0, sizeof(*img));
img->mh.magic = MH_MAGIC_64;
img->mh.cputype = CPU_TYPE_ARM64;
img->mh.filetype = MH_EXECUTE;
img->mh.ncmds = ncmds;
img->mh.sizeofcmds = sizeofcmds;
}
static int failures = 0;
static void check(const char *name, int cond) {
if (!cond) { printf("FAIL: %s\n", name); failures++; }
else { printf("ok: %s\n", name); }
}
int main(void) {
/* 1) cryptid=1:正常加密分发包 → CLEAR,不上报 DETECTED。 */
{
FakeImage img;
init_header(&img, 1, sizeof(struct encryption_info_command_64));
img.cmds.enc.cmd = LC_ENCRYPTION_INFO_64;
img.cmds.enc.cmdsize = sizeof(struct encryption_info_command_64);
img.cmds.enc.cryptid = 1;
Counter c = {0, 0, 0};
int hits = ig_tamper_scan_cryptid(&img.mh, /*expect_encrypted=*/1, sink, &c);
check("cryptid=1 → 0 detected", hits == 0 && c.detected == 0);
}
/* 2) cryptid=0:已脱壳 dump → DETECTED reason=500。 */
{
FakeImage img;
init_header(&img, 1, sizeof(struct encryption_info_command_64));
img.cmds.enc.cmd = LC_ENCRYPTION_INFO_64;
img.cmds.enc.cmdsize = sizeof(struct encryption_info_command_64);
img.cmds.enc.cryptid = 0;
Counter c = {0, 0, 0};
int hits = ig_tamper_scan_cryptid(&img.mh, 1, sink, &c);
check("cryptid=0 → detected 500",
hits == 1 && c.detected == 1 && c.last_reason == IG_REASON_BINARY_DECRYPTED);
}
/* 3) 无 LC_ENCRYPTION_INFO(加密命令被剥除)→ DETECTED reason=500。 */
{
FakeImage img;
init_header(&img, 0, 0); /* 零条 load command */
Counter c = {0, 0, 0};
int hits = ig_tamper_scan_cryptid(&img.mh, 1, sink, &c);
check("no-enc-cmd → detected 500",
hits == 1 && c.detected == 1 && c.last_reason == IG_REASON_BINARY_DECRYPTED);
}
/* 4) expect_encrypted=0:dev/诊断构建跳过 → UNAVAILABLE,无 DETECTED。 */
{
FakeImage img;
init_header(&img, 1, sizeof(struct encryption_info_command_64));
img.cmds.enc.cmd = LC_ENCRYPTION_INFO_64;
img.cmds.enc.cmdsize = sizeof(struct encryption_info_command_64);
img.cmds.enc.cryptid = 0; /* 即便 0,非分发构建也不判篡改 */
Counter c = {0, 0, 0};
int hits = ig_tamper_scan_cryptid(&img.mh, /*expect_encrypted=*/0, sink, &c);
check("expect_encrypted=0 → unavailable, 0 detected",
hits == 0 && c.detected == 0 && c.unavailable == 1);
}
/* 5) NULL 头 + expect=1 → UNAVAILABLE(不崩、不误报)。 */
{
Counter c = {0, 0, 0};
int hits = ig_tamper_scan_cryptid(NULL, 1, sink, &c);
check("null header → unavailable, 0 detected",
hits == 0 && c.detected == 0 && c.unavailable == 1);
}
printf("%s (%d failures)\n", failures ? "FAILED" : "PASSED", failures);
return failures ? 1 : 0;
}
+81
View File
@@ -0,0 +1,81 @@
#include <assert.h>
#include <dlfcn.h>
#include <errno.h>
#include <mach/mach.h>
#include <mach-o/dyld.h>
#include <mach-o/loader.h>
#include <mach-o/nlist.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
int main(int argc, char **argv) {
assert(argc == 3);
void *sdk = dlopen(argv[1], RTLD_NOW); if (!sdk) { puts(dlerror()); return 1; }
int (*io)(const char *,const char *,size_t) = dlsym(sdk,"archive_fixture_io");
int (*check)(void) = dlsym(sdk,"ig_archive_check");
uint64_t (*counter)(unsigned) = dlsym(sdk,"ig_archive_counter");
assert(io && check && counter && check() == 0);
assert(!io(argv[2],"abcdef",6));
for (unsigned i=0;i<4;i++) assert(counter(i*3)>0 && counter(i*3)==counter(i*3+1) && !counter(i*3+2));
const struct mach_header_64 *header = NULL;
intptr_t slide = 0;
for (uint32_t i=0;i<_dyld_image_count();i++) {
const char *name = _dyld_get_image_name(i);
if (name && strstr(name,"/SSZipArchive.framework/SSZipArchive")) {
header=(const void *)_dyld_get_image_header(i); slide=_dyld_get_image_vmaddr_slide(i); break;
}
}
assert(header);
const struct symtab_command *symtab=NULL;
const struct dysymtab_command *dysymtab=NULL;
uintptr_t base=0;
const uint8_t *command=(const void *)(header+1);
for (uint32_t i=0;i<header->ncmds;i++) {
const struct load_command *lc=(const void *)command;
if (lc->cmd==LC_SYMTAB) symtab=(const void *)lc;
if (lc->cmd==LC_DYSYMTAB) dysymtab=(const void *)lc;
if (lc->cmd==LC_SEGMENT_64) {
const struct segment_command_64 *seg=(const void *)lc;
if (!strcmp(seg->segname,SEG_LINKEDIT)) base=slide+seg->vmaddr-seg->fileoff;
}
command+=lc->cmdsize;
}
assert(base && symtab && dysymtab);
const struct nlist_64 *symbols=(const void *)(base+symtab->symoff);
const char *strings=(const void *)(base+symtab->stroff);
const uint32_t *indirect=(const void *)(base+dysymtab->indirectsymoff);
uintptr_t *slot=NULL;
command=(const void *)(header+1);
for (uint32_t i=0;i<header->ncmds;i++) {
const struct load_command *lc=(const void *)command;
if (lc->cmd==LC_SEGMENT_64) {
const struct segment_command_64 *seg=(const void *)lc;
const struct section_64 *sections=(const void *)(seg+1);
for (uint32_t j=0;j<seg->nsects;j++) {
const struct section_64 *s=sections+j;
if ((s->flags&SECTION_TYPE)!=S_NON_LAZY_SYMBOL_POINTERS) continue;
for (uint64_t k=0;k<s->size/8;k++) {
uint32_t n=indirect[s->reserved1+k];
if (n&(INDIRECT_SYMBOL_LOCAL|INDIRECT_SYMBOL_ABS)) continue;
if (!strcmp(strings+symbols[n].n_un.n_strx,"_ig_a0")) slot=(void *)(slide+s->addr+k*8);
}
}
}
command+=lc->cmdsize;
}
assert(slot);
uintptr_t original=*slot;
vm_address_t page=(uintptr_t)slot & ~((uintptr_t)vm_page_size-1);
assert(vm_protect(mach_task_self(),page,vm_page_size,0,VM_PROT_READ|VM_PROT_WRITE|VM_PROT_COPY)==KERN_SUCCESS);
*slot=(uintptr_t)dlsym(RTLD_DEFAULT,"fopen");
assert(check()==1);
FILE *(*close_entry)(const char *,const char *) = dlsym(sdk,"ig_a0");
assert(close_entry && !close_entry("unused","rb") && errno==EACCES);
*slot=original;
assert(check()==0);
assert(!io(argv[2],"ghijkl",6)); unlink(argv[2]);
puts("真实 chained binding 转发、GOT 篡改检测及拒绝、恢复均通过");
return 0;
}
+59
View File
@@ -0,0 +1,59 @@
#include "dispatch/IGArchiveGuard.h"
#include <assert.h>
#include <errno.h>
#include <pthread.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
static unsigned fake_calls;
static FILE *fake_open(const char *a, const char *b) { (void)a; (void)b; fake_calls++; return NULL; }
static void semantics(void) {
char path[] = "/tmp/ig-archive-XXXXXX";
int fd = mkstemp(path); assert(fd >= 0); close(fd);
errno = EDOM;
FILE *out = ig_a0(path, "wb"); assert(out && errno == EDOM);
assert(ig_a2("abcdef", 2, 3, out) == 3);
assert(ig_a2("", 0, 4, out) == 0);
assert(ig_a3(out) == 0);
FILE *in = ig_a0(path, "rb"); assert(in);
char buffer[16] = {0};
assert(ig_a1(buffer, 2, 4, in) == 3);
assert(!memcmp(buffer, "abcdef", 6) && feof(in) && !ferror(in));
assert(ig_a1(buffer, 1, 1, in) == 0);
assert(ig_a3(in) == 0); unlink(path);
errno = 0; assert(!ig_a0(path, "rb") && errno == ENOENT);
FILE *system = tmpfile(); assert(system);
assert(ig_a2("abc", 1, 3, system) == 3);
rewind(system); assert(ig_a1(buffer, 1, 3, system) == 3); assert(ig_a3(system) == 0);
assert(ig_archive_check() == 0);
}
static void *thread_run(void *ctx) { (void)ctx; semantics(); return NULL; }
int main(int argc, char **argv) {
assert(argc == 2);
if (!strcmp(argv[1], "semantics")) semantics();
else if (!strcmp(argv[1], "threads")) {
pthread_t t[6];
for (unsigned i=0;i<6;i++) assert(!pthread_create(t+i,NULL,thread_run,NULL));
for (unsigned i=0;i<6;i++) assert(!pthread_join(t[i],NULL));
} else if (!strcmp(argv[1], "tamper")) {
ig_archive_test_override(0, (void *)fake_open);
assert(ig_a0("unused", "rb") == NULL && errno == EACCES && !fake_calls);
errno = EDOM; assert(ig_archive_check() == 1 && errno == EDOM);
assert(ig_archive_counter(0) == 1 && ig_archive_counter(1) == 0 && ig_archive_counter(2) == 1);
} else if (!strcmp(argv[1], "reentry")) {
ig_archive_test_reentry(1);
assert(!ig_a0("unused", "rb") && errno == EDEADLK);
assert(ig_archive_check() == -1);
ig_archive_test_reentry(0); semantics();
} else if (!strcmp(argv[1], "rejection")) {
FILE *f = tmpfile(); assert(f);
char b;
for (unsigned i=1;i<4;i++) ig_archive_test_override(i, (void *)fake_open);
assert(ig_a1(&b,1,1,f)==0 && errno==EACCES);
assert(ig_a2(&b,1,1,f)==0 && errno==EACCES);
assert(ig_a3(f)==EOF && errno==EACCES);
assert(!fake_calls); fclose(f);
} else assert(0);
return 0;
}
+15
View File
@@ -0,0 +1,15 @@
#include <stdio.h>
#include <string.h>
/* 动态 SDK fixture:必须通过真实的四个导入完成一次 stdio 往返。 */
int archive_fixture_io(const char *path, const char *bytes, size_t count) {
FILE *file = fopen(path, "wb");
if (!file) return 1;
size_t written = fwrite(bytes, 1, count, file);
if (fclose(file) || written != count) return 2;
file = fopen(path, "rb");
if (!file) return 3;
char buffer[64] = {0};
size_t read = fread(buffer, 1, sizeof(buffer), file);
int closed = fclose(file);
return closed || read != count || memcmp(bytes, buffer, count) ? 4 : 0;
}
+165
View File
@@ -0,0 +1,165 @@
/* 仅宿主测试进程内操作;不修改系统函数代码。 */
#include "IGDefender.h"
#include "anti_hook/IGAntiHook.h"
#include "anti_hook/IGObjCBaseline.h"
#include "anti_debug/IGAntiDebug.h"
#include "anti_frida/IGAntiInject.h"
#include <dlfcn.h>
#include <objc/objc.h>
#include <objc/runtime.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <mach/mach.h>
#include <mach-o/dyld.h>
#include <mach-o/loader.h>
#include <mach-o/nlist.h>
typedef struct { int reasons[512]; int detected; int unavailable; } Findings;
static int collect(const IGFinding *f, void *context) {
Findings *out = context;
if (f->reason >= 0 && f->reason < 512) out->reasons[f->reason]++;
if (f->status == IG_DETECTED) out->detected++;
if (f->status == IG_UNAVAILABLE) out->unavailable++;
printf("status=%d reason=%d subject=%s evidence=%s\n",
f->status, f->reason, f->subject, f->evidence);
return 0;
}
static int fake_getpid(void) { return 123; }
/* 函数地址表达式确保本测试镜像包含 getpid 的 GOT 引用。 */
__attribute__((noinline)) static void *getpid_address(void) { return (void *)getpid; }
/* ---- ObjC IMP 基线 fixture:运行期创建类,两条实现可互换 ---- */
static int imp_original(void *self, SEL _cmd) { (void)self; (void)_cmd; return 1; }
static int imp_replaced(void *self, SEL _cmd) { (void)self; (void)_cmd; return 2; }
static Class make_fixture_class(void) {
Class c = objc_allocateClassPair(objc_getClass("NSObject"), "IGFixtureHookTarget", 0);
if (!c) return NULL;
if (!class_addMethod(c, sel_registerName("value"), (IMP)imp_original, "i16@0:8")) {
objc_disposeClassPair(c);
return NULL;
}
objc_registerClassPair(c);
return c;
}
static void **getpid_slot(void) {
const struct mach_header_64 *h = (const void *)_dyld_get_image_header(0);
intptr_t slide = _dyld_get_image_vmaddr_slide(0);
const struct segment_command_64 *le = NULL;
const struct symtab_command *sy = NULL;
const struct dysymtab_command *dy = NULL;
const unsigned char *p = (const void *)(h+1);
for (unsigned i=0; i<h->ncmds; i++) {
const struct load_command *lc=(const void *)p;
if (lc->cmd==LC_SEGMENT_64 && !strcmp(((const struct segment_command_64 *)p)->segname,"__LINKEDIT")) le=(const void *)p;
if (lc->cmd==LC_SYMTAB) sy=(const void *)p;
if (lc->cmd==LC_DYSYMTAB) dy=(const void *)p;
p+=lc->cmdsize;
}
if (!le || !sy || !dy) return NULL;
uintptr_t base=slide+le->vmaddr-le->fileoff;
const struct nlist_64 *symbols=(const void *)(base+sy->symoff);
const char *strings=(const void *)(base+sy->stroff);
const uint32_t *indirect=(const void *)(base+dy->indirectsymoff);
p=(const void *)(h+1);
for (unsigned i=0; i<h->ncmds; i++) {
const struct load_command *lc=(const void *)p;
if (lc->cmd==LC_SEGMENT_64) {
const struct segment_command_64 *seg=(const void *)p;
const struct section_64 *s=(const void *)(seg+1);
for (unsigned j=0; j<seg->nsects; j++) {
if ((s[j].flags & SECTION_TYPE)!=S_NON_LAZY_SYMBOL_POINTERS) continue;
for (unsigned k=0; k<s[j].size/sizeof(void *); k++) {
uint32_t n=indirect[s[j].reserved1+k];
if (n & (INDIRECT_SYMBOL_LOCAL|INDIRECT_SYMBOL_ABS)) continue;
if (!strcmp(strings+symbols[n].n_un.n_strx,"_getpid"))
return (void **)(slide+s[j].addr)+k;
}
}
}
p+=lc->cmdsize;
}
return NULL;
}
int main(int argc, char **argv) {
if (argc<2) return 2;
Findings f={0};
if (!strcmp(argv[1],"clean")) {
int hits=ig_defender_scan(NULL,0,collect,&f);
/* 越狱文件探针(400/401)在 macOS 宿主必然命中:mac 自带完整 Unix userland
* (/usr/sbin/sshd、/bin/bash、/bin/sh…),按 iOS 标准宿主本身即“越狱”。
* 这是宿主/iOS 环境差异,非真实误报——iOS 非越狱设备上这些路径不存在/沙盒不可达,
* 其反向零命中由真机 R 组验证(docs/19)。故宿主 clean 只对非越狱探针断言零 DETECTED。 */
int jb = f.reasons[IG_REASON_JAILBREAK_FILE] + f.reasons[IG_REASON_JAILBREAK_SANDBOX];
int non_jb_detected = f.detected - jb;
return hits!=f.detected || non_jb_detected || f.unavailable;
}
if (!strcmp(argv[1],"unresolved")) {
const char *names[]={"IG_fixture_symbol_that_does_not_exist_123"};
int hits=ig_anti_hook_check(names,1,collect,&f);
return hits || f.unavailable!=1 || f.reasons[IG_REASON_SYMBOL_UNRESOLVED]!=1;
}
if (!strcmp(argv[1],"verify")) {
if (ig_verify_function(NULL,"null",collect,&f)!=IG_UNAVAILABLE) return 3;
if (ig_verify_function(getpid_address(),"getpid",collect,&f)!=IG_CLEAR) return 4;
return ig_verify_function((void *)fake_getpid,"local_fixture",collect,&f)!=IG_DETECTED
|| f.reasons[IG_REASON_SYMBOL_PROVENANCE]!=1;
}
if (!strcmp(argv[1],"env")) {
setenv("DYLD_INSERT_LIBRARIES","/tmp/ig_fixture_a:/tmp/ig_fixture_b",1);
ig_anti_inject_check(NULL,collect,&f);
unsetenv("DYLD_INSERT_LIBRARIES");
return f.reasons[IG_REASON_DYLD_INSERT]!=2;
}
if (!strcmp(argv[1],"image")) {
if (argc<3 || !dlopen(argv[2],RTLD_NOW)) return 5;
ig_anti_inject_check(NULL,collect,&f);
return f.reasons[IG_REASON_INJECTED_IMAGE]!=1;
}
if (!strcmp(argv[1],"got")) {
const char *names[]={"getpid"};
if (!getpid_address() || ig_anti_hook_check(names,1,collect,&f)!=0) return 6;
void **slot=getpid_slot();
if (!slot) { fprintf(stderr,"未找到测试 GOT 槽\n"); return 7; }
void *original=*slot;
vm_size_t size=getpagesize();
vm_address_t page=(uintptr_t)slot & ~(size-1);
if (vm_protect(mach_task_self(),page,size,0,VM_PROT_READ|VM_PROT_WRITE|VM_PROT_COPY)!=KERN_SUCCESS) return 8;
*slot=(void *)fake_getpid;
int hits=ig_anti_hook_check(names,1,collect,&f);
*slot=original;
return hits!=1 || f.reasons[IG_REASON_GOT_REBIND]!=1;
}
if (!strcmp(argv[1],"debugger")) {
/* 正常(无调试器)环境:clear 且 sysctl 可判定。
* 正向(P_TRACED 命中)由 lldb 场景验证,docs/12 已实测。 */
ig_anti_debug_check(collect,&f);
return f.detected || f.unavailable;
}
if (!strcmp(argv[1],"objc-clean")) {
if (!make_fixture_class()) return 9;
const IGObjCWatch watch[] = { { "IGFixtureHookTarget", "value" } };
if (ig_objc_baseline_capture(watch,1)!=1) return 10;
/* 未登记的方法在 check 中不产生条目;登记方法未变 → 0 detected。 */
const IGObjCWatch none[] = { { "IGClassThatNeverExists123", "x" } };
ig_objc_baseline_capture(none,1);
if (ig_objc_baseline_check(collect,&f)!=0) return 11; /* 类不可解析不登记 → 仍 no-op */
ig_objc_baseline_capture(watch,1);
int hits=ig_objc_baseline_check(collect,&f);
return hits!=0 || f.detected || f.unavailable;
}
if (!strcmp(argv[1],"objc-swap")) {
Class c=make_fixture_class();
if (!c) return 9;
const IGObjCWatch watch[] = { { "IGFixtureHookTarget", "value" } };
if (ig_objc_baseline_capture(watch,1)!=1) return 10;
/* class_replaceMethod:IMP 换人(等价 swizzle 效果)→ 期望 DETECTED(110)。 */
class_replaceMethod(c, sel_registerName("value"), (IMP)imp_replaced, "i16@0:8");
int hits=ig_objc_baseline_check(collect,&f);
return hits!=1 || f.reasons[IG_REASON_OBJC_IMP_CHANGED]!=1;
}
return 2;
}
+34
View File
@@ -0,0 +1,34 @@
/* 独立诊断进程:只在自身进程测试,不连接业务、不改系统代码。 */
#import <Foundation/Foundation.h>
#include "IGDefender.h"
#include <stdio.h>
int ig_dispatch_fixture_main(int argc, char **argv);
static int findings, unavailable;
static int collect(const IGFinding *f, void *ctx) {
(void)ctx;
if (f->status==IG_DETECTED) findings++;
if (f->status==IG_UNAVAILABLE) unavailable++;
NSLog(@"IG_DEVICE_FINDING status=%d reason=%d subject=%s evidence=%s",
f->status,f->reason,f->subject,f->evidence);
return 0;
}
int main(int argc,char **argv) {
(void)argc;(void)argv;
@autoreleasepool {
NSLog(@"IG_DEVICE_MAIN");
const char *modes[]={"semantics","short-write","eintr","threads","reentry","resolver","prologue","tamper"};
int hits=ig_defender_scan(NSBundle.mainBundle.bundlePath.UTF8String,0,collect,NULL);
NSLog(@"IG_DEVICE_BASELINE detected=%d unavailable=%d hits=%d",findings,unavailable,hits);
for (unsigned i=0;i<sizeof(modes)/sizeof(modes[0]);i++) {
char *args[]={"dispatch-device",(char *)modes[i],NULL};
int rc=ig_dispatch_fixture_main(2,args);
NSLog(@"IG_DEVICE_CASE %s %s",modes[i],rc==0 ? "PASS" : "FAIL");
if (rc) return rc;
}
NSLog(@"IG_DEVICE_SUITE PASS cases=8 baseline_detected=%d baseline_unavailable=%d",findings,unavailable);
/* 诊断进程退出便于 console 收集退出码;不编入业务 App。 */
return findings || unavailable ? 3 : 0;
}
}
+131
View File
@@ -0,0 +1,131 @@
#include "dispatch/IGDispatch.h"
#include "resolve/IGResolve.h"
#include "anti_hook/IGAntiHook.h"
#include <assert.h>
#include <dlfcn.h>
#include <errno.h>
#include <fcntl.h>
#include <pthread.h>
#include <signal.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
static int early_ok;
__attribute__((constructor)) static void early(void) {
#ifdef IG_EXPECT_INIT_FAILURE
early_ok=1;
#else
int fd=open("/dev/null",O_WRONLY);
early_ok=fd>=0 && IG_dispatch_write(fd,"early",5)==5 && IG_dispatch_close(fd)==0;
#endif
}
void *ig_fixture_missing_resolve(void *handle, const char *name) { (void)handle; (void)name; return NULL; }
static int reasons[256], unavailable;
static int collect(const IGFinding *f,void *ctx) {
(void)ctx;
if (f->reason>=0 && f->reason<256) reasons[f->reason]++;
if (f->status==IG_UNAVAILABLE) unavailable++;
return 0;
}
static int fake_close(int fd) { (void)fd; abort(); }
static void *writer(void *ctx) {
(void)ctx;
int fd=open("/dev/null",O_WRONLY);
assert(fd>=0);
for (int i=0;i<100;i++) assert(IG_dispatch_write(fd,"abc",3)==3);
assert(IG_dispatch_close(fd)==0);
return NULL;
}
static void signal_handler(int sig) { (void)sig; }
static pthread_t main_thread;
static void *interruptor(void *ctx) { (void)ctx; usleep(30000); pthread_kill(main_thread,SIGUSR1); return NULL; }
int main(int argc,char **argv) {
assert(argc==2 && early_ok);
if (!strcmp(argv[1],"observation")) {
#ifdef IG_OBSERVATION
IGDispatchObservation before=ig_dispatch_observation();
errno=0; assert(IG_dispatch_write(-1,"x",1)==-1 && errno==EBADF);
errno=0; assert(IG_dispatch_close(-1)==-1 && errno==EBADF);
IGDispatchObservation after=ig_dispatch_observation();
assert(after.write_attempted==before.write_attempted+1);
assert(after.write_dispatched==before.write_dispatched+1);
assert(after.close_attempted==before.close_attempted+1);
assert(after.close_dispatched==before.close_dispatched+1);
ig_dispatch_test_override(1,(void *)fake_close);
assert(IG_dispatch_close(-1)==-1 && errno==EACCES);
IGDispatchObservation rejected=ig_dispatch_observation();
assert(rejected.close_attempted==after.close_attempted+1);
assert(rejected.close_dispatched==after.close_dispatched);
#else
return 2;
#endif
} else if (!strcmp(argv[1],"init-failure")) {
assert(IG_dispatch_write(-1,"x",1)==-1 && errno==ENOSYS);
assert(IG_dispatch_close(-1)==-1 && errno==ENOSYS);
assert(ig_dispatch_check(collect,NULL)==0 && unavailable==2);
assert(reasons[IG_REASON_DISPATCH_UNAVAILABLE]==2);
} else if (!strcmp(argv[1],"semantics")) {
assert(ig_dispatch_check(collect,NULL)==0 && unavailable==0);
errno=0; assert(IG_dispatch_write(-1,"x",1)==-1 && errno==EBADF);
errno=0; assert(IG_dispatch_close(-1)==-1 && errno==EBADF);
int p[2]; assert(pipe(p)==0);
errno=EDOM; assert(IG_dispatch_write(p[1],"abc",3)==3 && errno==EDOM);
char b[4]={0}; assert(read(p[0],b,3)==3 && !memcmp(b,"abc",3));
assert(IG_dispatch_close(p[1])==0 && IG_dispatch_close(p[0])==0);
} else if (!strcmp(argv[1],"short-write")) {
int p[2]; assert(pipe(p)==0);
assert(fcntl(p[1],F_SETFL,O_NONBLOCK)==0);
const size_t count=1024*1024;
char *bytes=calloc(count,1);assert(bytes);
ssize_t n=IG_dispatch_write(p[1],bytes,count);
assert(n>0 && n<(ssize_t)count);
while (IG_dispatch_write(p[1],bytes,count)>0) {}
assert(errno==EAGAIN);
IG_dispatch_close(p[1]); IG_dispatch_close(p[0]);
free(bytes);
} else if (!strcmp(argv[1],"eintr")) {
int p[2]; assert(pipe(p)==0);
assert(fcntl(p[1],F_SETFL,O_NONBLOCK)==0);
char bytes[4096]={0}; while (write(p[1],bytes,sizeof(bytes))>0) {}
assert(errno==EAGAIN && fcntl(p[1],F_SETFL,0)==0);
struct sigaction action={0};action.sa_handler=signal_handler;sigemptyset(&action.sa_mask);
assert(sigaction(SIGUSR1,&action,NULL)==0);
main_thread=pthread_self();pthread_t thread;
assert(pthread_create(&thread,NULL,interruptor,NULL)==0);
assert(IG_dispatch_write(p[1],bytes,sizeof(bytes))==-1 && errno==EINTR);
pthread_join(thread,NULL);IG_dispatch_close(p[1]);IG_dispatch_close(p[0]);
} else if (!strcmp(argv[1],"threads")) {
pthread_t threads[8];
for (unsigned i=0;i<8;i++) assert(pthread_create(&threads[i],NULL,writer,NULL)==0);
for (unsigned i=0;i<8;i++) pthread_join(threads[i],NULL);
} else if (!strcmp(argv[1],"tamper")) {
ig_dispatch_test_override(1,(void *)fake_close);
errno=0; assert(IG_dispatch_close(-1)==-1 && errno==EACCES);
assert(ig_dispatch_check(collect,NULL)==1 && reasons[IG_REASON_DISPATCH_TAMPER]==1);
} else if (!strcmp(argv[1],"reentry")) {
ig_dispatch_test_reentry(1);
assert(IG_dispatch_close(-1)==-1 && errno==EDEADLK);
ig_dispatch_test_reentry(0);
} else if (!strcmp(argv[1],"resolver")) {
unsigned char encoded[300];memset(encoded,'x',sizeof(encoded));char out[4];
assert(!ig_decrypt(encoded,1,out,0));assert(!ig_decrypt(NULL,1,out,sizeof(out)));
assert(!ig_decrypt(encoded,4,out,sizeof(out)) && out[0]==0);
encoded[0]=IG_ENC_KEY;assert(!ig_decrypt(encoded,1,out,sizeof(out)));
assert(ig_resolve_verified(NULL,encoded,300,NULL,NULL).status==IG_UNAVAILABLE);
const char *name="IG_missing_symbol_774444";
for (unsigned i=0;i<strlen(name);i++) encoded[i]=name[i]^IG_ENC_KEY;
assert(ig_resolve_verified(NULL,encoded,strlen(name),collect,NULL).status==IG_UNAVAILABLE);
assert(reasons[IG_REASON_SYMBOL_UNRESOLVED]==1);
assert(ig_verify_function((void *)1,"invalid",collect,NULL)==IG_UNAVAILABLE);
assert(reasons[IG_REASON_VERIFICATION_UNAVAILABLE]==1);
} else if (!strcmp(argv[1],"prologue")) {
assert(ig_arm64_suspicious_prologue(0x14000001,0));
assert(ig_arm64_suspicious_prologue(0x58000050,0xd61f0200));
assert(!ig_arm64_suspicious_prologue(0x58000050,0xd61f0220));
assert(!ig_arm64_suspicious_prologue(0x18000050,0xd61f0200));
assert(!ig_arm64_suspicious_prologue(0xd503245f,0xd65f03c0));
} else return 2;
return 0;
}
+112
View File
@@ -0,0 +1,112 @@
#include <assert.h>
#include <errno.h>
#include <fcntl.h>
#include <pthread.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
extern FILE *sdk_open(const char *path, const char *mode);
#ifdef IG_TEST_ALL_BRIDGES
extern int sdk_fclose(FILE *);
extern size_t sdk_fread(void *, size_t, size_t, FILE *);
extern size_t sdk_fwrite(const void *, size_t, size_t, FILE *);
extern ssize_t sdk_read(int, void *, size_t);
extern ssize_t sdk_write(int, const void *, size_t);
extern int sdk_close(int);
#define fclose sdk_fclose
#define fread sdk_fread
#define fwrite sdk_fwrite
static void exercise_posix(void) {
int descriptors[2];
char buffer[4096] = {0};
assert(pipe(descriptors) == 0);
assert(sdk_write(descriptors[1], "X", 1) == 1);
assert(sdk_read(descriptors[0], buffer, sizeof(buffer)) == 1);
assert(buffer[0] == 'X');
assert(sdk_write(descriptors[1], buffer, 0) == 0);
assert(sdk_read(descriptors[0], buffer, 0) == 0);
assert(sdk_close(descriptors[1]) == 0);
assert(sdk_read(descriptors[0], buffer, sizeof(buffer)) == 0);
assert(sdk_close(descriptors[0]) == 0);
assert(sdk_close(-1) == -1 && errno == EBADF);
assert(sdk_read(-1, buffer, 1) == -1 && errno == EBADF);
assert(sdk_write(-1, buffer, 1) == -1 && errno == EBADF);
assert(pipe(descriptors) == 0);
int flags = fcntl(descriptors[1], F_GETFL);
assert(flags >= 0 && fcntl(descriptors[1], F_SETFL, flags | O_NONBLOCK) == 0);
ssize_t result = 0;
for (int i = 0; i < 1024; ++i) {
result = sdk_write(descriptors[1], buffer, sizeof(buffer));
if (result < 0) break;
}
assert(result == -1 && (errno == EAGAIN || errno == EWOULDBLOCK));
assert(sdk_close(descriptors[0]) == 0);
assert(sdk_close(descriptors[1]) == 0);
}
#endif
static void exercise(const char *path) {
FILE *file = sdk_open(path, "wb");
assert(file != NULL);
const unsigned char payload[] = {0, 1, 255, 10};
assert(fwrite(payload, 1, sizeof(payload), file) == sizeof(payload));
assert(fclose(file) == 0);
file = sdk_open(path, "ab");
assert(file != NULL);
assert(fwrite("X", 1, 1, file) == 1);
assert(fclose(file) == 0);
file = sdk_open(path, "rb");
assert(file != NULL);
unsigned char result[8] = {0};
assert(fread(result, 1, sizeof(result), file) == 5);
assert(memcmp(result, payload, sizeof(payload)) == 0);
assert(result[4] == 'X');
assert(feof(file));
assert(fclose(file) == 0);
file = sdk_open(path, "wb");
assert(file != NULL);
assert(fclose(file) == 0);
file = sdk_open(path, "rb");
assert(file != NULL);
assert(fgetc(file) == EOF);
assert(fclose(file) == 0);
assert(unlink(path) == 0);
FILE *system_result = fopen(path, "rb");
int system_error = errno;
assert(system_result == NULL);
errno = 0;
FILE *bridge_result = sdk_open(path, "rb");
int bridge_error = errno;
assert(bridge_result == NULL);
assert(bridge_error == system_error && bridge_error == ENOENT);
}
static void *thread_test(void *path) {
for (int i = 0; i < 20; ++i) exercise(path);
return NULL;
}
int main(int argc, char **argv) {
assert(argc == 2);
#ifdef IG_TEST_ALL_BRIDGES
exercise_posix();
#endif
pthread_t threads[4];
char paths[4][4096];
for (int i = 0; i < 4; ++i) {
int length = snprintf(paths[i], sizeof(paths[i]), "%s/文件-%d.bin", argv[1], i);
assert(length > 0 && (size_t)length < sizeof(paths[i]));
assert(pthread_create(&threads[i], NULL, thread_test, paths[i]) == 0);
}
for (int i = 0; i < 4; ++i) assert(pthread_join(threads[i], NULL) == 0);
puts("file semantics: passed");
return 0;
}
+393
View File
@@ -0,0 +1,393 @@
/*
* hook_device.m — 真机 HOOK 正向验证诊断进程(step11)。
*
* 目的:在非越狱真机的自身进程内构造四种受控攻击形态,验证 Defender 探针
* 在真机环境(真实 dyld、真实内存权限、真实线程/镜像枚举)下能命中对应 reason:
* 1. GOT 重绑定(fishhook 同款页权限改写自身 __got 槽)→ 期望 reason=102
* 2. 蹦床序言(导出符号首指令为 B / LDR-literal+BR x16)→ 期望 reason=100+101
* 3. frida 特征线程名(gum-js-loop)→ 期望 reason=203
* 4. 容器外注入 dylib(Documents 下 dlopen;或宿主以 DYLD_INSERT_LIBRARIES 启动)
* → 期望 reason=200(+201)(dlopen 路径)/ reason=202(插入库路径)
*
* 边界(如实声明):
* - 不修改任何系统代码页(非越狱不可行):inline-hook 用例针对受控导出符号的
* 真实代码字节验证「读取+分类」,不等同于对系统函数的真实 patch。
* - 攻击操作(可写 GOT、装载模拟 dylib、特征线程名)只存在于本诊断源码,
* 绝不编入业务库;诊断进程结束即退出,不触碰业务 App。
*/
#import <Foundation/Foundation.h>
#include "IGDefender.h"
#include "anti_hook/IGAntiHook.h"
#include "anti_hook/IGObjCBaseline.h"
#include "anti_frida/IGAntiInject.h"
#include <dlfcn.h>
#include <errno.h>
#include <mach-o/dyld.h>
#include <mach-o/loader.h>
#include <mach-o/nlist.h>
#include <mach/mach.h>
#include <mach/mach_time.h>
#include <objc/objc.h>
#include <objc/runtime.h>
#include <pthread.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
/* ---------- 发现收集:只记 DETECTED,逐条打日志 ---------- */
#define IG_MAXF 64
static IGFinding g_findings[IG_MAXF];
static int g_nfindings;
static int collect(const IGFinding *f, void *ctx) {
(void)ctx;
if (f->status == IG_DETECTED && g_nfindings < IG_MAXF)
g_findings[g_nfindings++] = *f;
NSLog(@"IG_HOOK_FINDING status=%d reason=%d subject=%s evidence=%s",
f->status, f->reason, f->subject, f->evidence);
return 0;
}
static void reset_findings(void) { g_nfindings = 0; }
static const IGFinding *first_reason(int reason) {
for (int i = 0; i < g_nfindings; ++i)
if (g_findings[i].reason == reason) return &g_findings[i];
return NULL;
}
static const char *g_bundle; /* 主 bundle 路径,供各探针使用 */
/* 完整聚合扫描(anti_hook + 注入 + frida 线程)。 */
static int scan_all(void) {
reset_findings();
return ig_defender_scan(g_bundle, 0, collect, NULL);
}
/* ---------- 用例 1:GOT 重绑定(102)----------
* fishhook 同款走法:定位主可执行文件 __got 中绑定 getpid 的槽,
* 临时以 VM_PROT_COPY 改页为可写,写入本进程函数地址,恢复只读。
* 只写自身进程数据页,不改任何代码。 */
static int ig_rebind_stub(void) { return 4242; } /* 指给 GOT 的假实现 */
static void **find_main_got_slot(const char *bare_name) {
const struct mach_header_64 *mh =
(const struct mach_header_64 *)_dyld_get_image_header(0);
if (!mh || mh->magic != MH_MAGIC_64) return NULL;
intptr_t slide = _dyld_get_image_vmaddr_slide(0);
const struct segment_command_64 *linkedit = NULL;
const struct symtab_command *symtab = NULL;
const struct dysymtab_command *dysymtab = NULL;
const uint8_t *cmd = (const uint8_t *)(mh + 1);
for (uint32_t i = 0; i < mh->ncmds; ++i, cmd += ((const struct load_command *)cmd)->cmdsize) {
const struct load_command *lc = (const struct load_command *)cmd;
if (lc->cmd == LC_SEGMENT_64) {
const struct segment_command_64 *seg = (const struct segment_command_64 *)lc;
if (strcmp(seg->segname, SEG_LINKEDIT) == 0) linkedit = seg;
} else if (lc->cmd == LC_SYMTAB) {
symtab = (const struct symtab_command *)lc;
} else if (lc->cmd == LC_DYSYMTAB) {
dysymtab = (const struct dysymtab_command *)lc;
}
}
if (!linkedit || !symtab || !dysymtab) return NULL;
uintptr_t le_base = (uintptr_t)slide + linkedit->vmaddr - linkedit->fileoff;
const struct nlist_64 *syms = (const struct nlist_64 *)(le_base + symtab->symoff);
const char *strtab = (const char *)(le_base + symtab->stroff);
const uint32_t *indirect = (const uint32_t *)(le_base + dysymtab->indirectsymoff);
size_t nlen = strlen(bare_name);
cmd = (const uint8_t *)(mh + 1);
for (uint32_t i = 0; i < mh->ncmds; ++i, cmd += ((const struct load_command *)cmd)->cmdsize) {
const struct load_command *lc = (const struct load_command *)cmd;
if (lc->cmd != LC_SEGMENT_64) continue;
const struct segment_command_64 *seg = (const struct segment_command_64 *)lc;
const struct section_64 *sect = (const struct section_64 *)(seg + 1);
for (uint32_t s = 0; s < seg->nsects; ++s) {
if ((sect[s].flags & SECTION_TYPE) != S_NON_LAZY_SYMBOL_POINTERS) continue;
size_t n = sect[s].size / sizeof(void *);
const uint32_t *idxs = indirect + sect[s].reserved1;
void **slots = (void **)((uintptr_t)slide + sect[s].addr);
for (size_t k = 0; k < n; ++k) {
uint32_t si = idxs[k];
if (si == INDIRECT_SYMBOL_ABS || si == INDIRECT_SYMBOL_LOCAL) continue;
const char *sym = strtab + syms[si].n_un.n_strx;
/* sym 形如 "_getpid":比较去下划线后的部分 */
if (sym[0] == '_' && strncmp(sym + 1, bare_name, nlen) == 0 &&
sym[1 + nlen] == '\0')
return &slots[k];
}
}
}
return NULL;
}
/* 改写自身 GOT 槽:VM_PROT_COPY 写副本页,写完恢复只读。返回 0 成功。 */
static int rebind_got_slot(void **slot, void *to) {
vm_address_t page = (vm_address_t)(uintptr_t)slot & ~0xfffull;
if (vm_protect(mach_task_self(), page, 0x1000, 0,
VM_PROT_READ | VM_PROT_WRITE | VM_PROT_COPY) != KERN_SUCCESS)
return -1;
*slot = to;
vm_protect(mach_task_self(), page, 0x1000, 0, VM_PROT_READ);
return 0;
}
/* ---------- 用例 2:蹦床序言导出符号(100+101)----------
* 两个文件级汇编符号,首指令分别是「无条件 B」与「LDR-literal x16 + BR x16」,
* 与 Frida/Dobby 蹦床形态一致。仅被 dlsym 解析和字节读取,从不执行。 */
asm(".globl _ig_hook_target_b\n"
".align 2\n"
"_ig_hook_target_b:\n"
" b .+64\n"
" ret\n");
asm(".globl _ig_hook_target_lb\n"
".align 2\n"
"_ig_hook_target_lb:\n"
" ldr x16, #8\n"
" br x16\n"
" .quad 0\n");
/* ---------- 用例 3:frida 特征线程名(203)---------- */
static void *gum_thread(void *arg) {
(void)arg;
pthread_setname_np("gum-js-loop");
usleep(600000); /* 确保扫描期间线程存活 */
return NULL;
}
/* ---------- 用例 6:ObjC 方法 IMP 基线(110)----------
* 运行期创建类并采集基线,class_replaceMethod 换实现后扫描 → 期望 110。 */
static int ig_objc_imp_original(void *self, SEL _cmd) { (void)self; (void)_cmd; return 1; }
static int ig_objc_imp_swapped(void *self, SEL _cmd) { (void)self; (void)_cmd; return 2; }
static Class make_objc_fixture_class(void) {
Class c = objc_allocateClassPair(objc_getClass("NSObject"), "IGHookFixtureTarget", 0);
if (!c) return NULL;
if (!class_addMethod(c, sel_registerName("value"), (IMP)ig_objc_imp_original, "i16@0:8")) {
objc_disposeClassPair(c);
return NULL;
}
objc_registerClassPair(c);
return c;
}
/* ---------- 输出协议(宿主 run_hook_device.py 解析)---------- */
static int g_pass = 0, g_fail = 0;
static void mark(const char *name, int pass, const char *detail) {
NSLog(@"IG_HOOK_CASE %s %s%s%s", name, pass ? "PASS" : "FAIL",
detail && *detail ? " detail=" : "", detail ? detail : "");
if (pass) ++g_pass; else ++g_fail;
}
int main(int argc, char **argv) {
(void)argc; (void)argv;
@autoreleasepool {
NSLog(@"IG_HOOK_MAIN");
g_bundle = NSBundle.mainBundle.bundlePath.UTF8String;
const char *insert = getenv("DYLD_INSERT_LIBRARIES");
if (insert && insert[0]) {
/* 相位 B:宿主经 DYLD_INSERT_LIBRARIES 启动本进程 → 真实 dyld 注入。 */
NSLog(@"IG_HOOK_INSERT_MODE value=%s", insert);
int hits = scan_all();
int r202 = first_reason(IG_REASON_DYLD_INSERT) != NULL;
int r200 = first_reason(IG_REASON_INJECTED_IMAGE) != NULL;
NSLog(@"IG_HOOK_INSERT_SUMMARY detected=%d hits=%d reason202=%d reason200=%d",
g_nfindings, hits, r202, r200);
mark("dyld_insert", r202 || r200,
r202 ? "202+环境注入命中" : (r200 ? "200(插入镜像命中特征名)" : "未命中"));
NSLog(@"IG_HOOK_SUITE %s cases=1", g_fail ? "FAIL" : "PASS");
return g_fail ? 4 : 0;
}
/* ---- 相位 A:干净进程内的受控攻击形态 ---- */
/* 0. 基线:干净环境 0 命中。 */
int base = scan_all();
int base_unavail = 0; /* unavailable 已在 sink 日志逐条体现,不判失败 */
NSLog(@"IG_HOOK_BASELINE detected=%d", base);
mark("baseline_clean", g_nfindings == 0,
g_nfindings ? "干净环境出现 DETECTED(误报)" : "");
/* 1. 耗时小样本(5 次完整聚合扫描)。 */
{
mach_timebase_info_data_t tb;
mach_timebase_info(&tb);
double scale = (double)tb.numer / (double)tb.denom / 1e6; /* → ms */
double total = 0, best = 1e9;
for (int i = 0; i < 5; ++i) {
uint64_t t0 = mach_absolute_time();
scan_all();
double ms = (mach_absolute_time() - t0) * scale;
total += ms;
if (ms < best) best = ms;
}
NSLog(@"IG_HOOK_TIMING n=5 avg_ms=%.2f min_ms=%.2f", total / 5.0, best);
}
/* 2. GOT 重绑定 → 102;恢复 → 干净。 */
{
/* 确保可执行文件真实导入 getpid(否则 __got 无该槽)。 */
if (getpid() == -7) NSLog(@"unreachable");
void **slot = find_main_got_slot("getpid");
if (!slot) {
mark("got_rebind", 0, "未找到主程序 getpid 的 __got 槽(构建异常)");
} else {
void *orig = *slot;
NSLog(@"IG_HOOK_GOT slot=%p orig=%p", (void *)slot, orig);
if (rebind_got_slot(slot, (void *)ig_rebind_stub) != 0) {
mark("got_rebind", 0, "vm_protect 改写失败");
} else {
scan_all();
const IGFinding *f = first_reason(IG_REASON_GOT_REBIND);
int hit = f && strstr(f->subject, "getpid") != NULL;
mark("got_rebind", hit, f ? f->evidence : "未命中 102");
rebind_got_slot(slot, orig); /* 恢复,双写均经同一权限路径 */
int again = scan_all();
int clean = g_nfindings == 0;
NSLog(@"IG_HOOK_GOT_RESTORE detected=%d hits=%d", g_nfindings, again);
if (!clean)
mark("got_restore_clean", 0, "恢复后仍有 DETECTED");
else
mark("got_restore_clean", 1, "");
}
}
}
/* 3. 蹦床序言(经 dlsym+vm_read_overwrite 的完整探针链)→ 100+101。 */
{
const char *const names[] = {"ig_hook_target_b", "ig_hook_target_lb"};
reset_findings();
ig_anti_hook_check(names, 2, collect, NULL);
int b100 = 0, b101 = 0, lb100 = 0, lb101 = 0;
for (int i = 0; i < g_nfindings; ++i) {
const char *subj = g_findings[i].subject;
if (strstr(subj, "ig_hook_target_b")) {
b100 |= g_findings[i].reason == IG_REASON_SYMBOL_PROVENANCE;
b101 |= g_findings[i].reason == IG_REASON_INLINE_HOOK;
} else if (strstr(subj, "ig_hook_target_lb")) {
lb100 |= g_findings[i].reason == IG_REASON_SYMBOL_PROVENANCE;
lb101 |= g_findings[i].reason == IG_REASON_INLINE_HOOK;
}
}
mark("prologue_b_branch", b100 && b101, b101 ? "首指令 B 被识别" : "未命中 101");
mark("prologue_ldr_br", lb100 && lb101, lb101 ? "LDR+BR 蹦床被识别" : "未命中 101");
}
/* 4. frida 特征线程名 → 203;join 后 → 干净。
* join 后内核回收线程对象存在延迟(task_threads 短期内仍可能列出已终止
* 线程),在 2s 窗口内轮询重扫:既能容忍回收延迟,又验证探针无粘滞缓存。 */
{
pthread_t t;
pthread_create(&t, NULL, gum_thread, NULL);
usleep(200000); /* 等线程命名完成 */
reset_findings();
ig_anti_frida_check(0, collect, NULL);
mark("frida_thread", first_reason(IG_REASON_FRIDA_THREAD) != NULL, "");
pthread_join(t, NULL);
int clean = 0;
for (int i = 0; i < 10 && !clean; ++i) {
usleep(200000);
reset_findings();
ig_anti_frida_check(0, collect, NULL);
clean = (g_nfindings == 0);
}
mark("frida_thread_gone", clean,
clean ? "join 后 2s 内恢复干净" : "join 后 2s 仍残留线程名(回收异常缓慢)");
}
/* 5. 注入证据两种形态:
* a) Documents/libfrida-sim.dylib —— 文件名命中注入特征 → 期望 200;
* (探针对命中特征的镜像即上报 200,不再重复报 Bundle 外,故不期望 201)
* b) Documents/libiosutil-sim.dylib —— 无特征命名的 Bundle 外镜像 → 期望 201。
* 相位 A 成功路径回显给宿主,供相位 B 的 DYLD_INSERT 使用。 */
{
NSString *res = [[NSBundle mainBundle] pathForResource:@"libfrida-sim"
ofType:@"dylib"];
NSString *docs = [NSHomeDirectory()
stringByAppendingPathComponent:@"Documents"];
NSString *dstA = [docs stringByAppendingPathComponent:@"libfrida-sim.dylib"];
NSString *dstB = [docs stringByAppendingPathComponent:@"libiosutil-sim.dylib"];
const char *chosen = NULL;
NSFileManager *fm = [NSFileManager defaultManager];
if (res) {
[fm removeItemAtPath:dstA error:nil];
[fm removeItemAtPath:dstB error:nil];
if ([fm copyItemAtPath:res toPath:dstA error:nil] &&
[fm copyItemAtPath:res toPath:dstB error:nil]) {
void *ha = dlopen(dstA.fileSystemRepresentation, RTLD_LOCAL);
if (ha) {
chosen = dstA.fileSystemRepresentation;
reset_findings();
ig_anti_inject_check(g_bundle, collect, NULL);
mark("injected_image",
first_reason(IG_REASON_INJECTED_IMAGE) != NULL,
"Documents 特征名装载命中 200");
} else {
const char *e = dlerror();
NSLog(@"IG_HOOK_DLOPEN_DOC_FAIL %s", e ? e : "?");
}
void *hb = dlopen(dstB.fileSystemRepresentation, RTLD_LOCAL);
if (hb) {
reset_findings();
ig_anti_inject_check(g_bundle, collect, NULL);
mark("foreign_image",
first_reason(IG_REASON_FOREIGN_IMAGE) != NULL,
"Documents 无特征名装载命中 201(弱信号)");
}
} else {
NSLog(@"IG_HOOK_COPY_FAIL %@", docs);
}
}
if (!chosen) {
/* 回退:从 .app 内 dlopen(Bundle 内只应命中 200)。 */
void *h = dlopen(res.fileSystemRepresentation, RTLD_LOCAL);
if (h) {
chosen = res.fileSystemRepresentation;
reset_findings();
ig_anti_inject_check(g_bundle, collect, NULL);
int r200 = first_reason(IG_REASON_INJECTED_IMAGE) != NULL;
int r201 = first_reason(IG_REASON_FOREIGN_IMAGE) != NULL;
mark("injected_image", r200 && !r201,
"容器外装载不可用,回退 Bundle 内(200 命中、201 不应命中)");
} else {
const char *e = dlerror();
mark("injected_image", 0, e ? e : "装载失败");
}
}
NSLog(@"IG_HOOK_DYLIB_PATH %s", chosen ? chosen : "none");
}
/* 6. ObjC IMP 基线:采集 → class_replaceMethod → 期望 110;未接入时聚合为 no-op。 */
{
Class c = make_objc_fixture_class();
if (!c) {
mark("objc_imp_baseline", 0, "运行期建类失败");
} else {
const IGObjCWatch watch[] = { { "IGHookFixtureTarget", "value" } };
size_t n = ig_objc_baseline_capture(watch, 1);
reset_findings();
int before = ig_objc_baseline_check(collect, NULL);
class_replaceMethod(c, sel_registerName("value"),
(IMP)ig_objc_imp_swapped, "i16@0:8");
reset_findings();
int after = ig_objc_baseline_check(collect, NULL);
mark("objc_imp_baseline", n == 1 && before == 0 && after == 1 &&
first_reason(IG_REASON_OBJC_IMP_CHANGED) != NULL,
after == 1 ? "替换后命中 110" : "未命中 110");
}
}
NSLog(@"IG_HOOK_SUITE %s cases=%d baseline_unavailable_logged=%d",
g_fail ? "FAIL" : "PASS", g_pass + g_fail, base_unavail);
/* 诊断进程退出便于 console 收集退出码;不编入业务 App。 */
return g_fail ? 4 : 0;
}
}
+11
View File
@@ -0,0 +1,11 @@
/*
* hook_sim_dylib.c — 空壳模拟 dylib(step11 诊断专用)。
*
* 唯一用途:被诊断进程 dlopen / 被 DYLD_INSERT_LIBRARIES 加载,构成
* 「注入镜像 / Bundle 外镜像 / 插入库」探针的受控证据源。不实现任何业务功能,
* 不导出会被业务引用的符号。仅用于诊断 App,绝不编入业务库。
*/
#include <stddef.h>
__attribute__((visibility("default")))
int ig_frida_sim_marker(void) { return 0x46726461; /* "Frda" */ }
+5
View File
@@ -0,0 +1,5 @@
/* 无 SDK 头依赖的 iOS 链接样本:两个外部调用和一个本地改写目标。 */
extern int getpid(void);
extern long write(int, const void *, unsigned long);
int fixture_calls(void) { return getpid() + (int)write(-1, "x", 1); }
int fixture_redirect(void) { return 123; }
+289
View File
@@ -0,0 +1,289 @@
/*
* poison_device.m — 处置链真机验证诊断进程(step12,见 docs/19)。
*
* 在真机自身进程内运行真实的「检测→分级→数据毒化」链,分两类用例:
*
* A. 环境无关不变量(两组设备都必须 PASS,构成套件门槛):
* D4 poison_identity 健康态 apply 恒等(out==key)——证不误伤解密
* D5 poison_mark_corrupt mark 后 apply 坏 key(out!=key)——证毒化真的生效
* D6 ctor_clean_start 进程启动未 mark 时 mask==0——证构造期初始化干净、无启动即毒化
* D7 policy_grades 合成 finding 复核分级(弱/单MEDIUM不触发;双MEDIUM/单STRONG触发)
* D8 svc_access_live 在自身沙盒建真实可访问文件,证 svc 直发 access(2) 在真机能命中
* reason=400——坐实 D2 的 0 命中是「无越狱文件」而非「探针静默失败」,
* 无需越狱设备即可验证检测机制在 iOS arm64 上是活的。
*
* B. 环境相关观察(不写死 PASS/FAIL,输出命中供人按 R/J 组判定,见 docs/19 §4):
* D1 baseline_scan ig_policy_scan_and_mark(bundle) 的返回/mask
* D2 jb_file 内置越狱特征表 access 直发命中数(reason=400)
* D3 jb_sandbox 默认沙盒逃逸探测(reason=401)
* 并据 D2/D3 是否命中输出环境判定 IG_POISON_ENV jailbroken=yes|no。
*
* 边界:攻击/构造代码只存在于本诊断源码,绝不编入业务库;越狱特征文件的“存在性”
* 在 J 组由设备本身提供,诊断进程只做被动 access/open 探测,不自己造越狱文件。
* 每例结束前调 ig_poison_init() 复位,避免跨例污染。
*/
#import <Foundation/Foundation.h>
#include "IGDefender.h"
#include "poison/IGPoison.h"
#include "policy/IGPolicy.h"
#include "anti_jailbreak/IGAntiJailbreak.h"
#include "anti_tamper/IGAntiTamper.h"
#include <string.h>
#include <unistd.h>
#include <mach-o/dyld.h>
#include <mach-o/loader.h>
/* 原始 csops(与 IGAntiTamper 同,供 .m 直读状态字作真机观察,坐实 csops 活性) */
#ifndef CS_OPS_STATUS
#define CS_OPS_STATUS 0
#endif
#define IG_CS_VALID 0x00000001u
#define IG_CS_ADHOC 0x00000002u
#define IG_CS_GET_TASK_ALLOW 0x00000004u
extern int csops(pid_t pid, unsigned int ops, void *useraddr, size_t usersize);
/* 进程主可执行镜像头(与 IGAntiTamper 内部同逻辑,便于直接喂给可测核心) */
static const struct mach_header_64 *dev_main_image_header(void) {
uint32_t n = _dyld_image_count();
for (uint32_t i = 0; i < n; ++i) {
const struct mach_header *h = _dyld_get_image_header(i);
if (h && h->magic == MH_MAGIC_64 &&
((const struct mach_header_64 *)h)->filetype == MH_EXECUTE) {
return (const struct mach_header_64 *)h;
}
}
return NULL;
}
/* ---------- 发现收集 ---------- */
#define IG_MAXF 64
static IGFinding g_f[IG_MAXF];
static int g_nf;
static int g_detected;
static int collect(const IGFinding *f, void *ctx) {
(void)ctx;
if (f->status == IG_DETECTED) {
if (g_nf < IG_MAXF) g_f[g_nf++] = *f;
g_detected++;
}
NSLog(@"IG_POISON_FINDING status=%d reason=%d subject=%s evidence=%s",
f->status, f->reason, f->subject, f->evidence);
return 0;
}
static void reset_findings(void) { g_nf = 0; g_detected = 0; }
static int count_reason(int reason) {
int n = 0;
for (int i = 0; i < g_nf; ++i) if (g_f[i].reason == reason) n++;
return n;
}
/* ---------- PASS/FAIL 汇总 ---------- */
static int g_pass = 0, g_fail = 0;
static void mark_case(const char *name, int pass, const char *detail) {
if (pass) g_pass++; else g_fail++;
NSLog(@"IG_POISON_CASE %s %s detail=%s", name, pass ? "PASS" : "FAIL", detail ? detail : "");
}
static void observe(const char *name, const char *detail) {
NSLog(@"IG_POISON_OBS %s %s", name, detail ? detail : "");
}
/* ---------- policy 合成输入 ---------- */
static void feed(IGPolicyState *st, IGStatus status, int reason) {
IGFinding f; memset(&f, 0, sizeof(f));
f.status = status; f.reason = reason;
ig_policy_sink(&f, st);
}
static int run_policy_weak(void) {
ig_poison_init();
IGPolicyState st; ig_policy_reset(&st, NULL, NULL);
feed(&st, IG_DETECTED, IG_REASON_FOREIGN_IMAGE);
feed(&st, IG_DETECTED, IG_REASON_FRIDA_PORT);
return ig_policy_evaluate_and_mark(&st);
}
static int run_policy_single_medium(void) {
ig_poison_init();
IGPolicyState st; ig_policy_reset(&st, NULL, NULL);
feed(&st, IG_DETECTED, IG_REASON_OBJC_IMP_CHANGED);
return ig_policy_evaluate_and_mark(&st);
}
static int run_policy_two_medium(void) {
ig_poison_init();
IGPolicyState st; ig_policy_reset(&st, NULL, NULL);
feed(&st, IG_DETECTED, IG_REASON_OBJC_IMP_CHANGED);
feed(&st, IG_DETECTED, IG_REASON_SYMBOL_PROVENANCE);
return ig_policy_evaluate_and_mark(&st);
}
static int run_policy_single_strong(void) {
ig_poison_init();
IGPolicyState st; ig_policy_reset(&st, NULL, NULL);
feed(&st, IG_DETECTED, IG_REASON_JAILBREAK_SANDBOX);
return ig_policy_evaluate_and_mark(&st);
}
int main(int argc, char **argv) {
(void)argc; (void)argv;
@autoreleasepool {
const char *bundle = [[[NSBundle mainBundle] bundlePath] fileSystemRepresentation];
/* ===== D6 ctor_clean_start:进程启动早期、任何 mark 之前,mask 必须为 0 =====
* 放最前,尽量贴近启动态(构造器已跑,但本进程尚未触发任何检测/mark)。 */
{
uint64_t m = ig_poison_mask();
char d[64]; snprintf(d, sizeof(d), "mask=0x%llx", (unsigned long long)m);
mark_case("ctor_clean_start", m == 0, d);
}
/* ===== D4 poison_identity:健康态 apply 恒等 ===== */
{
ig_poison_init();
const uint8_t key[] = { 's','t','a','r','t','i','a','s','o','f','t',0x11,0x22 };
size_t n = sizeof(key); uint8_t out[sizeof(key)];
memset(out, 0xAB, n);
ig_poison_apply(key, out, n);
mark_case("poison_identity", memcmp(out, key, n) == 0, "healthy apply must be identity");
}
/* ===== D5 poison_mark_corrupt:mark 后 apply 坏 key ===== */
{
ig_poison_init();
const uint8_t key[] = { 's','t','a','r','t','i','a','s','o','f','t',0x11,0x22 };
size_t n = sizeof(key); uint8_t out[sizeof(key)];
ig_poison_mark(0xC0FFEE);
int nonzero = (ig_poison_mask() != 0);
ig_poison_apply(key, out, n);
int corrupted = (memcmp(out, key, n) != 0);
mark_case("poison_mark_corrupt", nonzero && corrupted, "marked apply must differ");
ig_poison_init();
}
/* ===== D7 policy_grades:真机复核分级 ===== */
{
int weak = run_policy_weak(); /* 期望 0 */
int med1 = run_policy_single_medium(); /* 期望 0 */
int med2 = run_policy_two_medium(); /* 期望 1 */
int strong = run_policy_single_strong(); /* 期望 1 */
int ok = (weak == 0 && med1 == 0 && med2 == 1 && strong == 1);
char d[96];
snprintf(d, sizeof(d), "weak=%d single_medium=%d two_medium=%d single_strong=%d",
weak, med1, med2, strong);
mark_case("policy_grades", ok, d);
ig_poison_init();
}
/* ===== D8 svc_access_live:合成正向,不依赖越狱 =====
* 非越狱设备上内置越狱表必然 0 命中——但那可能是「svc 直发在 iOS 上静默失败、
* 永远返回 0」的假阴性。此例在自身沙盒 Documents 建一个真实可访问文件,喂给
* ig_anti_jb_check_paths,确认 svc #0x80 access(2) 在真机 iOS arm64 上能真正命中
* (reason=400)。坐实 D2 的 0 命中是「无越狱文件」而非「探针坏了」。环境无关不变量。 */
{
reset_findings();
NSString *docs = NSSearchPathForDirectoriesInDomains(
NSDocumentDirectory, NSUserDomainMask, YES).firstObject;
NSString *probe = [docs stringByAppendingPathComponent:@".ig_svc_live_probe"];
[@"x" writeToFile:probe atomically:YES encoding:NSUTF8StringEncoding error:nil];
const char *cpath = [probe fileSystemRepresentation];
const char *paths[] = { cpath };
ig_anti_jb_check_paths(paths, 1, NULL, collect, NULL);
int live = count_reason(IG_REASON_JAILBREAK_FILE);
[[NSFileManager defaultManager] removeItemAtPath:probe error:nil];
char d[96]; snprintf(d, sizeof(d), "accessible_file_hits=%d svc_access_fires_on_device", live);
mark_case("svc_access_live", live >= 1, d);
reset_findings();
}
/* ===== D9 anti_tamper:二进制完整性探针真机验证 =====
* dev 签名包是环境无关不变量:本地编译=无 FairPlay 加密(无 LC_ENCRYPTION_INFO
* 或 cryptid=0)、且带 get-task-allow。据此双向验证 IGAntiTamper:
* expect=0(dev 正确配置)→ 全 UNAVAILABLE、零 DETECTED(误报底线);
* expect=1(假装分发)→ cryptid 命中 500、csops 读到 get-task-allow 命中 501
* (坐实探针真读到真实镜像头/签名状态,逻辑正确)。 */
const struct mach_header_64 *mh = dev_main_image_header();
/* D9a cryptid_expect0_clean:非分发构建跳过,零 DETECTED(误报底线) */
{
reset_findings();
int hits = ig_tamper_scan_cryptid(mh, /*expect_encrypted=*/0, collect, NULL);
mark_case("at_cryptid_expect0_clean", hits == 0 && g_detected == 0,
"dev build, expect_encrypted=0 must not flag");
reset_findings();
}
/* D9b cryptid_expect1_detects:dev 包无 FairPlay 加密 → 命中 500(探针真读主镜像头) */
{
reset_findings();
int hits = ig_tamper_scan_cryptid(mh, /*expect_encrypted=*/1, collect, NULL);
int r500 = count_reason(IG_REASON_BINARY_DECRYPTED);
char d[96]; snprintf(d, sizeof(d), "hits=%d reason500=%d mh=%p", hits, r500, (void *)mh);
mark_case("at_cryptid_expect1_detects", hits >= 1 && r500 >= 1, d);
reset_findings();
}
/* D9c tamper_gated_off:两检查都 expect=0 → 零 DETECTED(误报底线整入口) */
{
reset_findings();
int hits = ig_anti_tamper_check(/*expect_encrypted=*/0, /*expect_distribution=*/0,
collect, NULL);
mark_case("at_tamper_gated_off", hits == 0 && g_detected == 0,
"dev build, expect_*=0 whole-entry must not flag");
reset_findings();
}
/* D9d tamper_on_detects:expect_*=1 → 至少 cryptid 500 命中(整入口贯通真机) */
{
reset_findings();
int hits = ig_anti_tamper_check(/*expect_encrypted=*/1, /*expect_distribution=*/1,
collect, NULL);
int r500 = count_reason(IG_REASON_BINARY_DECRYPTED);
int r501 = count_reason(IG_REASON_CODESIGN_INVALID);
char d[112]; snprintf(d, sizeof(d), "hits=%d reason500=%d reason501=%d", hits, r500, r501);
mark_case("at_tamper_on_detects", hits >= 1 && r500 >= 1, d);
/* 501(csops 代码签名)作观察:dev 包带 get-task-allow 应命中,但 csops 语义真机坐实为准 */
char o[64]; snprintf(o, sizeof(o), "reason501_codesign_hits=%d", r501);
observe("at_codesign_501", o);
reset_findings();
}
/* D9e csops_status(观察):直读 csops 状态字,坐实 csops 在真机 iOS arm64 活着 */
{
uint32_t st = 0;
int rc = csops(getpid(), CS_OPS_STATUS, &st, sizeof(st));
char o[128];
snprintf(o, sizeof(o), "rc=%d status=0x%x valid=%d adhoc=%d get_task_allow=%d",
rc, st, (st & IG_CS_VALID) != 0, (st & IG_CS_ADHOC) != 0,
(st & IG_CS_GET_TASK_ALLOW) != 0);
observe("csops_status", o);
}
/* ===== D2 jb_file(观察):内置越狱特征表直发 access ===== */
reset_findings();
ig_anti_jb_check(collect, NULL);
int hit400 = count_reason(IG_REASON_JAILBREAK_FILE);
int hit401_default = count_reason(IG_REASON_JAILBREAK_SANDBOX);
{
char d[96]; snprintf(d, sizeof(d), "reason400=%d reason401=%d", hit400, hit401_default);
observe("jb_file", d);
}
/* ===== D1 baseline_scan(观察):聚合策略扫描的返回与 mask ===== */
{
ig_poison_init();
int triggered = ig_policy_scan_and_mark(bundle, 0, NULL, NULL);
uint64_t m = ig_poison_mask();
char d[96]; snprintf(d, sizeof(d), "triggered=%d mask=0x%llx",
triggered, (unsigned long long)m);
observe("baseline_scan", d);
ig_poison_init();
}
/* ===== 环境判定:D2/D3 任一命中即视作越狱环境(J 组)===== */
int jailbroken = (hit400 > 0) || (hit401_default > 0);
NSLog(@"IG_POISON_ENV jailbroken=%s reason400=%d reason401=%d",
jailbroken ? "yes" : "no", hit400, hit401_default);
/* 套件判定只看环境无关不变量(D4–D7)。 */
NSLog(@"IG_POISON_SUITE %s pass=%d fail=%d", g_fail ? "FAIL" : "PASS", g_pass, g_fail);
}
return 0;
}
+169
View File
@@ -0,0 +1,169 @@
/*
* poison_host.c — 处置链宿主自测(poison + policy + anti_jailbreak)。
*
* 固化此前只在 /tmp 临时跑过的「检测→分级→数据毒化」闭环为可复现基线,
* 作为真机验证(docs/19)之前的宿主绿灯。覆盖:
* A. poison:健康恒等、毒化破坏 key、mask 非分支语义、apply 逐字节扩散。
* B. policy:弱信号/UNAVAILABLE/CLEAR 不触发、单 MEDIUM 不触发、双 MEDIUM 去重后触发、
* 单 STRONG 触发——且触发后 mask 必非 0(真正接到了毒化)。
* C. anti_jailbreak:可注入路径版本——不存在路径零命中(反向零误报)、
* 存在路径命中 400、沙盒逃逸探测命中 401。
*
* 只用 ig_anti_jb_check_paths 的可注入入口,不依赖真机越狱特征文件,故宿主可跑。
* 退出码 0=全绿;非 0=有用例失败(stderr 打印失败项)。
*/
#include "IGDefender.h"
#include "poison/IGPoison.h"
#include "policy/IGPolicy.h"
#include "anti_jailbreak/IGAntiJailbreak.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
static int g_pass = 0, g_fail = 0;
static void ok(const char *name, int cond) {
if (cond) { g_pass++; printf(" PASS %s\n", name); }
else { g_fail++; fprintf(stderr, " FAIL %s\n", name); }
}
/* ---- 构造 policy sink 的输入:手工喂 finding 走 ig_policy_sink ---- */
static void feed(IGPolicyState *st, IGStatus status, int reason) {
IGFinding f;
memset(&f, 0, sizeof(f));
f.status = status;
f.reason = reason;
ig_policy_sink(&f, st);
}
/* 跑一组 finding,返回 evaluate 是否触发毒化(并断言 mask 的一致性)。 */
static int run_policy(void (*feeder)(IGPolicyState *)) {
ig_poison_init(); /* 每例从健康态起 */
IGPolicyState st;
ig_policy_reset(&st, NULL, NULL);
feeder(&st);
int triggered = ig_policy_evaluate_and_mark(&st);
return triggered;
}
/* ---- A. poison ---- */
static void test_poison(void) {
printf("[A] poison\n");
const uint8_t key[] = { 's','t','a','r','t','i','a','s','o','f','t', 0x11, 0x22 };
const size_t n = sizeof(key);
uint8_t out[sizeof(key)];
/* A1 健康:mask==0,apply 恒等 */
ig_poison_init();
ok("healthy_mask_zero", ig_poison_mask() == 0);
memset(out, 0xAB, n);
ig_poison_apply(key, out, n);
ok("healthy_apply_identity", memcmp(out, key, n) == 0);
/* A2 毒化:mask!=0,apply 破坏 key(至少一字节不同) */
ig_poison_mark(0xC0FFEE);
ok("poisoned_mask_nonzero", ig_poison_mask() != 0);
ig_poison_apply(key, out, n);
ok("poisoned_key_corrupted", memcmp(out, key, n) != 0);
/* A3 毒化不可逆回健康(再 mark 不会抵消;只有 init 能清) */
ig_poison_mark(0x1234);
ok("poisoned_still_nonzero_after_second_mark", ig_poison_mask() != 0);
ig_poison_init();
ok("init_restores_healthy", ig_poison_mask() == 0);
/* A4 entropy==0 仍生效(防“混 0 = 不生效”) */
ig_poison_init();
ig_poison_mark(0);
ok("zero_entropy_still_poisons", ig_poison_mask() != 0);
}
/* ---- B. policy 分级 ---- */
static void f_weak_only(IGPolicyState *st) {
feed(st, IG_DETECTED, IG_REASON_FOREIGN_IMAGE); /* 201 WEAK */
feed(st, IG_DETECTED, IG_REASON_FRIDA_PORT); /* 204 WEAK */
}
static void f_unavailable_clear(IGPolicyState *st) {
feed(st, IG_UNAVAILABLE, IG_REASON_INLINE_HOOK); /* STRONG reason 但 UNAVAILABLE→忽略 */
feed(st, IG_CLEAR, IG_REASON_GOT_REBIND); /* CLEAR→忽略 */
}
static void f_single_medium(IGPolicyState *st) {
feed(st, IG_DETECTED, IG_REASON_OBJC_IMP_CHANGED); /* 110 单 MEDIUM */
}
static void f_medium_dup(IGPolicyState *st) {
feed(st, IG_DETECTED, IG_REASON_OBJC_IMP_CHANGED); /* 110 */
feed(st, IG_DETECTED, IG_REASON_OBJC_IMP_CHANGED); /* 110 重复 → 去重后仍算 1 */
}
static void f_two_medium(IGPolicyState *st) {
feed(st, IG_DETECTED, IG_REASON_OBJC_IMP_CHANGED); /* 110 */
feed(st, IG_DETECTED, IG_REASON_SYMBOL_PROVENANCE); /* 100 → 2 个不同 MEDIUM */
}
static void f_single_strong(IGPolicyState *st) {
feed(st, IG_DETECTED, IG_REASON_JAILBREAK_SANDBOX); /* 401 STRONG */
}
static void test_policy(void) {
printf("[B] policy\n");
ok("weak_only_no_trigger", run_policy(f_weak_only) == 0);
ok("unavailable_clear_no_trigger",run_policy(f_unavailable_clear) == 0);
ok("single_medium_no_trigger", run_policy(f_single_medium) == 0);
ok("medium_dup_no_trigger", run_policy(f_medium_dup) == 0); /* 去重:同 reason×2 ≠ 2 distinct */
ok("two_distinct_medium_trigger", run_policy(f_two_medium) == 1);
ok("single_strong_trigger", run_policy(f_single_strong) == 1);
/* 触发后 mask 必非 0(策略真的接到了毒化,不只是返回值) */
run_policy(f_single_strong);
ok("strong_trigger_sets_mask", ig_poison_mask() != 0);
ig_poison_init();
run_policy(f_weak_only);
ok("weak_leaves_mask_zero", ig_poison_mask() == 0);
}
/* ---- C. anti_jailbreak(可注入) ---- */
static int g_jb_hits;
static int jb_sink(const IGFinding *f, void *ctx) {
(void)ctx;
if (f->status == IG_DETECTED) g_jb_hits++;
return 0;
}
static void test_jailbreak(void) {
printf("[C] anti_jailbreak\n");
/* C1 反向:全是不存在的路径 + 不做逃逸探测 → 零命中(守误报底线) */
const char *absent[] = {
"/var/jb/__ig_absent_a", "/Applications/__ig_absent.app", "/usr/bin/__ig_absent"
};
g_jb_hits = 0;
ig_anti_jb_check_paths(absent, sizeof(absent)/sizeof(absent[0]), NULL, jb_sink, NULL);
ok("absent_paths_zero_hit", g_jb_hits == 0);
/* C2 正向 400:构造一个真实存在的临时文件冒充越狱特征文件 → 命中 */
char tmpl[] = "/tmp/ig_jb_fileXXXXXX";
int fd = mkstemp(tmpl);
ok("tmpfile_created", fd >= 0);
if (fd >= 0) close(fd);
const char *present[] = { tmpl };
g_jb_hits = 0;
ig_anti_jb_check_paths(present, 1, NULL, jb_sink, NULL);
ok("present_path_hits_400", g_jb_hits >= 1);
unlink(tmpl);
/* C3 正向 401:宿主上 /tmp 可写,沙盒逃逸探测应成功创建→命中(真机非越狱则失败=反向) */
char probe[] = "/tmp/ig_jb_probeXXXXXX";
int pfd = mkstemp(probe); if (pfd >= 0) { close(pfd); unlink(probe); } /* 腾出路径给探测自建 */
g_jb_hits = 0;
ig_anti_jb_check_paths(absent, sizeof(absent)/sizeof(absent[0]), probe, jb_sink, NULL);
ok("sandbox_probe_hits_401_on_host", g_jb_hits >= 1);
unlink(probe);
}
int main(void) {
printf("== poison_host self-test ==\n");
test_poison();
test_policy();
test_jailbreak();
printf("== %d pass, %d fail ==\n", g_pass, g_fail);
return g_fail == 0 ? 0 : 1;
}
+17
View File
@@ -0,0 +1,17 @@
/*
* poison_inline_caller.c — 模拟接入方(readoor)解密 TU 的「断边」验证夹具。
*
* rd_derive_key 代表解密前取得明文密钥、喂给解密器前揉入毒化的那一步。它 #include
* IGPoisonInline.h 并调用 always_inline 的 ig_poison_mix_key_inline——编译后反汇编本函数
* 应**不含任何 `bl ig_poison_*` 调用边**(原语已内联进来),只有对数据 ig_pstate 的读取。
* 由 tests/test_poison_inline.py 反汇编断言。
*/
#include <stdint.h>
#include <stddef.h>
#include "poison/IGPoisonInline.h"
/* 非 static extern:保证不被优化掉,反汇编里能定位到本函数。 */
void rd_derive_key(uint8_t *key, size_t n) {
ig_poison_mix_key_inline(key, n);
}
+58
View File
@@ -0,0 +1,58 @@
/*
* poison_inline_host.c — 验证 IGPoisonInline.h 内联核心与 IGPoison.c out-of-line 公共入口
* 语义等价(单一真源不漂移),且推荐接入形态 ig_poison_mix_key_inline 行为正确:
* 健康→密钥不变(解密正常),毒化→密钥被扰动(解出乱码)。
* 退出码 0=全部用例通过。由 tests/test_poison_inline.py 编译运行。
*/
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include "poison/IGPoison.h"
#include "poison/IGPoisonInline.h"
static int fails = 0;
static void check(int cond, const char *msg) {
printf("%s: %s\n", cond ? "ok" : "FAIL", msg);
if (!cond) fails++;
}
int main(void) {
ig_poison_init();
/* —— 健康态 —— */
check(ig_poison_mask() == 0, "healthy: public mask==0");
check(ig_poison_mask_inline() == 0, "healthy: inline mask==0");
check(ig_poison_mask_inline() == ig_poison_mask(), "healthy: inline mask==public mask");
uint8_t ref[16];
for (int i = 0; i < 16; ++i) ref[i] = (uint8_t)(i * 7 + 1);
uint8_t key[16];
memcpy(key, ref, 16);
ig_poison_mix_key_inline(key, 16);
check(memcmp(key, ref, 16) == 0, "healthy: mix_key 恒等(密钥不变→解密正常)");
uint8_t o1[16], o2[16];
ig_poison_apply(ref, o1, 16);
ig_poison_apply_inline(ref, o2, 16);
check(memcmp(o1, o2, 16) == 0, "healthy: inline apply == public apply");
check(memcmp(o1, ref, 16) == 0, "healthy: apply 恒等");
/* —— 毒化态 —— */
ig_poison_mark(0xDEADBEEF12345678ULL);
check(ig_poison_mask() != 0, "poisoned: public mask!=0");
check(ig_poison_mask_inline() == ig_poison_mask(), "poisoned: inline mask==public mask");
memcpy(key, ref, 16);
ig_poison_mix_key_inline(key, 16);
check(memcmp(key, ref, 16) != 0, "poisoned: mix_key 扰动密钥(→解出乱码)");
ig_poison_apply(ref, o1, 16);
ig_poison_apply_inline(ref, o2, 16);
check(memcmp(o1, o2, 16) == 0, "poisoned: inline apply == public apply");
check(memcmp(o1, ref, 16) != 0, "poisoned: apply 扰动输出");
printf("%d fail\n", fails);
return fails ? 1 : 0;
}
+14
View File
@@ -0,0 +1,14 @@
#include <stdio.h>
#include <unistd.h>
FILE *sdk_open(const char *path, const char *mode) { return fopen(path, mode); }
int sdk_fclose(FILE *stream) { return fclose(stream); }
size_t sdk_fread(void *buffer, size_t size, size_t count, FILE *stream) {
return fread(buffer, size, count, stream);
}
size_t sdk_fwrite(const void *buffer, size_t size, size_t count, FILE *stream) {
return fwrite(buffer, size, count, stream);
}
ssize_t sdk_read(int fd, void *buffer, size_t count) { return read(fd, buffer, count); }
ssize_t sdk_write(int fd, const void *buffer, size_t count) { return write(fd, buffer, count); }
int sdk_close(int fd) { return close(fd); }
+38
View File
@@ -0,0 +1,38 @@
"""IGAntiTamper 宿主自测:cryptid 核心逻辑(合成 Mach-O 头)。
真机的 csops 代码签名检查与真实主镜像 cryptid 由设备测试覆盖;此处固化可复现的
cryptid 判定基线(加密正常/脱壳/剥除/非分发跳过/NULL),退出码 0 = 全过。
"""
from pathlib import Path
import os
import shutil
import subprocess
import sys
import tempfile
import unittest
ROOT = Path(__file__).resolve().parents[1]
SOURCES = ['anti_tamper/IGAntiTamper.c']
@unittest.skipUnless(sys.platform == 'darwin' and shutil.which('xcrun'), '需要 Xcode/macOS')
class AntiTamperCryptidTests(unittest.TestCase):
def test_cryptid_core(self):
with tempfile.TemporaryDirectory() as d:
exe = Path(d) / 'anti-tamper-host'
env = dict(os.environ)
env.pop('DYLD_INSERT_LIBRARIES', None)
args = ['xcrun', '--sdk', 'macosx', 'clang', '-O2',
'-I', str(ROOT / 'defender/include'), '-I', str(ROOT / 'defender'),
str(ROOT / 'tests/fixtures/anti_tamper_host.c'),
*(str(ROOT / 'defender' / p) for p in SOURCES),
'-o', str(exe)]
build = subprocess.run(args, capture_output=True, text=True, env=env)
self.assertEqual(build.returncode, 0, build.stdout + build.stderr)
run = subprocess.run([str(exe)], capture_output=True, text=True, env=env)
self.assertEqual(run.returncode, 0, run.stdout + run.stderr)
self.assertIn('PASSED', run.stdout)
if __name__ == '__main__':
unittest.main()
+125
View File
@@ -0,0 +1,125 @@
import hashlib
from pathlib import Path
import os
import platform
import struct
import subprocess
import sys
import tempfile
import unittest
ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT/'tools/macho_guard'))
from redirect_framework_imports import rewrite, DEPENDENCY
from machox import Macho, LC_DYLD_CHAINED_FIXUPS
SDK = ROOT/'readoor-test/readoor/BookShelf/Classes/Factorys/SSZipArchive/SSZipArchive.framework/SSZipArchive'
SHA = '485c0c95b4701a4e51625e16b6c2a9781c1a8a6f6c9b9cbe392709ecfc95191a'
@unittest.skipUnless(SDK.exists(), '需要已审核 SDK 副本')
class FrameworkRewriteTests(unittest.TestCase):
def setUp(self): self.data = SDK.read_bytes()
def rejected(self, data):
with self.assertRaises((ValueError, struct.error)):
rewrite(data, hashlib.sha256(data).hexdigest())
def test_real_sdk(self):
data, report = rewrite(self.data, SHA)
self.assertEqual(len(data), len(self.data))
self.assertEqual(len(report['changes']), 8)
self.assertTrue(report['machine_code_unchanged'])
self.assertIn(DEPENDENCY.encode(), data[:32768])
m = Macho(data)
self.assertEqual(m.ncmds, Macho(self.data).ncmds+1)
self.assertEqual(data[32768:212992], self.data[32768:212992])
def test_wrong_hash(self):
with self.assertRaises(ValueError): rewrite(self.data, '0'*64)
def test_repeat_rejected(self):
data, _ = rewrite(self.data, SHA); self.rejected(data)
def test_no_padding(self):
data = bytearray(self.data); data[32+Macho(data).sizeofcmds] = 1; self.rejected(data)
def test_unsupported_import_format(self):
data = bytearray(self.data); m = Macho(data)
off = next(o for c,_,o in m.cmds if c == LC_DYLD_CHAINED_FIXUPS)
fixoff = struct.unpack_from('<I',data,off+8)[0]
struct.pack_into('<I',data,fixoff+20,3); self.rejected(data)
def test_wrong_provider_and_weak(self):
m = Macho(self.data); off = next(o for c,_,o in m.cmds if c == LC_DYLD_CHAINED_FIXUPS)
fixoff = struct.unpack_from('<I',self.data,off+8)[0]
imports = struct.unpack_from('<I',self.data,fixoff+8)[0]
for mask in (0x100, 1):
with self.subTest(mask=mask):
data = bytearray(self.data); pos = fixoff+imports+43*4
word = struct.unpack_from('<I',data,pos)[0]
struct.pack_into('<I',data,pos,word^mask); self.rejected(data)
def test_truncated(self): self.rejected(self.data[:3000])
@unittest.skipUnless(sys.platform == 'darwin', '需要 Apple 工具链')
class ArchiveABITests(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.tmp = tempfile.TemporaryDirectory(); cls.exe = Path(cls.tmp.name)/'archive-host'
cls.env = dict(os.environ); cls.env.pop('DYLD_INSERT_LIBRARIES',None)
cls.sources = [str(ROOT/'defender'/s) for s in
('dispatch/IGArchiveGuard.c','resolve/IGResolve.c','anti_hook/IGAntiHook.c')]
command = ['xcrun','--sdk','macosx','clang','-O2','-Wall','-Wextra','-Werror',
'-DIG_ARCHIVE_TESTING','-DIG_OBSERVATION','-I',str(ROOT/'defender'),
'-I',str(ROOT/'defender/include'),str(ROOT/'tests/fixtures/archive_host.c'),
*cls.sources,'-o',str(cls.exe)]
r = subprocess.run(command,capture_output=True,text=True,env=cls.env)
if r.returncode: raise RuntimeError(r.stderr)
@classmethod
def tearDownClass(cls): cls.tmp.cleanup()
def run_mode(self,mode):
r = subprocess.run([self.exe,mode],capture_output=True,text=True,env=self.env,timeout=30)
self.assertEqual(r.returncode,0,r.stdout+r.stderr)
def test_stdio_semantics(self): self.run_mode('semantics')
def test_concurrent_initialization(self): self.run_mode('threads')
def test_tamper_refuses_before_call(self): self.run_mode('tamper')
def test_reentry(self): self.run_mode('reentry')
def test_read_write_close_reject(self): self.run_mode('rejection')
def test_release_has_no_test_or_observation_api(self):
output = Path(self.tmp.name)/'release.dylib'
r = subprocess.run(['xcrun','--sdk','iphoneos','clang','-arch','arm64',
'-miphoneos-version-min=15.0','-O2','-fvisibility=hidden','-dynamiclib',
'-I',str(ROOT/'defender'),'-I',str(ROOT/'defender/include'),*self.sources,
'-o',str(output)],capture_output=True,text=True)
self.assertEqual(r.returncode,0,r.stderr)
nm = subprocess.run(['xcrun','nm','-g',output],capture_output=True,text=True,check=True).stdout
self.assertNotIn('ig_archive_test_',nm); self.assertNotIn('_ig_archive_counter',nm)
@unittest.skipUnless(sys.platform == 'darwin' and platform.machine() == 'arm64', '需要 Apple Silicon')
class ArchiveBindingIntegrationTests(unittest.TestCase):
def test_real_dyld_binding_and_got_tamper(self):
with tempfile.TemporaryDirectory() as folder:
root = Path(folder)
guard = root/'IGArchiveGuard.framework/IGArchiveGuard'
sdk = root/'SSZipArchive.framework/SSZipArchive'
guard.parent.mkdir(); sdk.parent.mkdir()
common = ['xcrun','--sdk','macosx','clang','-arch','arm64','-mmacosx-version-min=13.0','-O2']
env = dict(os.environ); env.pop('DYLD_INSERT_LIBRARIES',None)
def command(args):
r = subprocess.run(args,capture_output=True,text=True,env=env,timeout=40)
self.assertEqual(r.returncode,0,r.stdout+r.stderr)
return r
command(common+['-dynamiclib','-DIG_OBSERVATION','-fvisibility=hidden',
'-I',str(ROOT/'defender'),'-I',str(ROOT/'defender/include'),
*(str(ROOT/'defender'/s) for s in
('dispatch/IGArchiveGuard.c','resolve/IGResolve.c','anti_hook/IGAntiHook.c')),
'-Wl,-install_name,'+DEPENDENCY,'-o',str(guard)])
command(common+['-dynamiclib',str(ROOT/'tests/fixtures/archive_sdk.c'),
'-Wl,-install_name,@rpath/SSZipArchive.framework/SSZipArchive',
'-Wl,-headerpad,0x4000','-Wl,-rpath,@loader_path/..','-o',str(sdk)])
data = sdk.read_bytes(); changed, _ = rewrite(data,hashlib.sha256(data).hexdigest())
sdk.write_bytes(changed)
command(['codesign','--force','--sign','-',str(guard)])
command(['codesign','--force','--sign','-',str(sdk)])
exe = root/'binding-test'
command(common+[str(ROOT/'tests/fixtures/archive_binding_host.c'),'-o',str(exe)])
result = command([str(exe),str(sdk),str(root/'stdio.bin')])
self.assertIn('均通过',result.stdout)
if __name__ == '__main__': unittest.main()
+72
View File
@@ -0,0 +1,72 @@
"""宿主探针正反例与 iOS 编译验证;不替代真机 inline Hook 测试。"""
from pathlib import Path
import os
import platform
import shutil
import subprocess
import sys
import tempfile
import unittest
ROOT = Path(__file__).resolve().parents[1]
SOURCES = ['IGDefender.c','anti_hook/IGAntiHook.c','anti_hook/IGObjCBaseline.c',
'anti_frida/IGAntiInject.c','anti_debug/IGAntiDebug.c',
'anti_jailbreak/IGAntiJailbreak.c',
'syscall/IGSyscall.c','resolve/IGResolve.c','dispatch/IGDispatch.c']
@unittest.skipUnless(sys.platform=='darwin' and shutil.which('xcrun'), '需要 Xcode/macOS')
class DefenderTests(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.tmp = tempfile.TemporaryDirectory()
cls.folder = Path(cls.tmp.name)
cls.exe = cls.folder/'defender-host'
cls.env = dict(os.environ)
cls.env.pop('DYLD_INSERT_LIBRARIES', None)
cls.compile(['xcrun','--sdk','macosx','clang','-O2',
'-I',str(ROOT/'defender/include'),'-I',str(ROOT/'defender'),
str(ROOT/'tests/fixtures/defender_host.c'),
*(str(ROOT/'defender'/p) for p in SOURCES),
'-lobjc','-o',str(cls.exe)])
fixture = cls.folder/'empty.c'
fixture.write_text('int ig_fixture_marker(void) { return 1; }\n')
cls.image = cls.folder/'fixture_frida.dylib'
cls.compile(['xcrun','--sdk','macosx','clang','-dynamiclib',str(fixture),'-o',str(cls.image)])
@classmethod
def compile(cls, args):
p = subprocess.run(args,capture_output=True,text=True,env=cls.env)
if p.returncode:
raise RuntimeError(p.stdout+p.stderr)
@classmethod
def tearDownClass(cls):
cls.tmp.cleanup()
def check_mode(self, mode, *args):
p = subprocess.run([str(self.exe),mode,*map(str,args)],
capture_output=True,text=True,env=self.env)
self.assertEqual(p.returncode,0,p.stdout+p.stderr)
# 保留各探针证据到 unittest 日志。
print(mode+': '+p.stdout.strip(), flush=True)
def test_clean(self): self.check_mode('clean')
def test_unavailable(self): self.check_mode('unresolved')
def test_function_provenance(self): self.check_mode('verify')
def test_environment_entries(self): self.check_mode('env')
def test_loaded_image(self): self.check_mode('image',self.image)
def test_got_rebinding(self): self.check_mode('got')
def test_debugger_clean(self): self.check_mode('debugger')
def test_objc_baseline_clean(self): self.check_mode('objc-clean')
def test_objc_baseline_swap(self): self.check_mode('objc-swap')
def test_iphoneos_cross_compile(self):
for i, source in enumerate(SOURCES):
self.compile(['xcrun','--sdk','iphoneos','clang','-arch','arm64',
'-miphoneos-version-min=15.0','-O2',
'-I',str(ROOT/'defender/include'),'-I',str(ROOT/'defender'),
'-c',str(ROOT/'defender'/source),'-o',str(self.folder/f'{i}.o')])
if __name__ == '__main__': unittest.main()
+70
View File
@@ -0,0 +1,70 @@
from pathlib import Path
import os
import subprocess
import sys
import tempfile
import unittest
ROOT=Path(__file__).resolve().parents[1]
SOURCES=['dispatch/IGDispatch.c','resolve/IGResolve.c','anti_hook/IGAntiHook.c']
@unittest.skipUnless(sys.platform=='darwin','需要 Apple 工具链')
class DispatchTests(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.tmp=tempfile.TemporaryDirectory()
cls.exe=Path(cls.tmp.name)/'dispatch-test'
cls.env=dict(os.environ);cls.env.pop('DYLD_INSERT_LIBRARIES',None)
p=subprocess.run(['xcrun','--sdk','macosx','clang','-O2','-Wall','-Wextra','-Werror',
'-DIG_DISPATCH_TESTING','-I',str(ROOT/'defender'),'-I',str(ROOT/'defender/include'),
str(ROOT/'tests/fixtures/dispatch_host.c'),*(str(ROOT/'defender'/p) for p in SOURCES),
'-o',str(cls.exe)],capture_output=True,text=True,env=cls.env)
if p.returncode:raise RuntimeError(p.stderr)
@classmethod
def tearDownClass(cls):cls.tmp.cleanup()
def run_mode(self,mode):
p=subprocess.run([str(self.exe),mode],capture_output=True,text=True,env=self.env,timeout=30)
self.assertEqual(p.returncode,0,p.stdout+p.stderr)
def test_semantics(self):self.run_mode('semantics')
def test_short_write(self):self.run_mode('short-write')
def test_eintr(self):self.run_mode('eintr')
def test_concurrency(self):self.run_mode('threads')
def test_tamper_rejected(self):self.run_mode('tamper')
def test_reentry(self):self.run_mode('reentry')
def test_resolver_errors(self):self.run_mode('resolver')
def test_prologue_patterns(self):self.run_mode('prologue')
def test_observation_counters_and_release_exclusion(self):
exe=Path(self.tmp.name)/'observation'
r=subprocess.run(['xcrun','--sdk','macosx','clang','-O2','-Wall','-Wextra','-Werror',
'-DIG_DISPATCH_TESTING','-DIG_OBSERVATION',
'-I',str(ROOT/'defender'),'-I',str(ROOT/'defender/include'),
str(ROOT/'tests/fixtures/dispatch_host.c'),*(str(ROOT/'defender'/p) for p in SOURCES),
'-o',str(exe)],capture_output=True,text=True,env=self.env)
self.assertEqual(r.returncode,0,r.stderr)
r=subprocess.run([str(exe),'observation'],capture_output=True,text=True,env=self.env,timeout=30)
self.assertEqual(r.returncode,0,r.stdout+r.stderr)
r=subprocess.run(['xcrun','nm',str(self.exe)],capture_output=True,text=True,check=True)
self.assertNotIn('_ig_dispatch_observation',r.stdout)
def test_ios_compile(self):
for i,p in enumerate(SOURCES):
r=subprocess.run(['xcrun','--sdk','iphoneos','clang','-arch','arm64',
'-miphoneos-version-min=15.0','-O2','-I',str(ROOT/'defender/include'),
'-c',str(ROOT/'defender'/p),'-o',str(Path(self.tmp.name)/f'{i}.o')],
capture_output=True,text=True)
self.assertEqual(r.returncode,0,r.stderr)
def test_initialization_failure(self):
obj=Path(self.tmp.name)/'missing-resolver.o'
exe=Path(self.tmp.name)/'init-failure'
r=subprocess.run(['xcrun','--sdk','macosx','clang','-O2','-Ddlsym=ig_fixture_missing_resolve',
'-I',str(ROOT/'defender/include'),
'-c',str(ROOT/'defender/resolve/IGResolve.c'),'-o',str(obj)],capture_output=True,text=True)
self.assertEqual(r.returncode,0,r.stderr)
r=subprocess.run(['xcrun','--sdk','macosx','clang','-O2','-DIG_DISPATCH_TESTING','-DIG_EXPECT_INIT_FAILURE',
'-I',str(ROOT/'defender'),'-I',str(ROOT/'defender/include'),
str(ROOT/'tests/fixtures/dispatch_host.c'),str(ROOT/'defender/dispatch/IGDispatch.c'),
str(ROOT/'defender/anti_hook/IGAntiHook.c'),str(obj),'-o',str(exe)],capture_output=True,text=True)
self.assertEqual(r.returncode,0,r.stderr)
r=subprocess.run([str(exe),'init-failure'],capture_output=True,text=True,timeout=30)
self.assertEqual(r.returncode,0,r.stdout+r.stderr)
if __name__=='__main__':unittest.main()
+168
View File
@@ -0,0 +1,168 @@
"""用真实 Apple 链接器生成样本,验证注入、指令及拒绝路径。"""
from pathlib import Path
import shutil
import struct
import subprocess
import sys
import tempfile
import unittest
ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT/'tools/macho_guard'))
import batch
import macho_guard as guard
from machox import Macho
from verify_baseline import inspect_binary, validate_zip
from redirect_to_runtime import patch, trace_calls
@unittest.skipUnless(sys.platform == 'darwin' and shutil.which('xcrun'), '需要 Xcode')
class MachoTests(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.tmp = tempfile.TemporaryDirectory()
cls.src = Path(cls.tmp.name)/'fixture.dylib'
cls.linkmap = Path(cls.tmp.name)/'fixture.map'
subprocess.run(['xcrun','--sdk','iphoneos','clang','-arch','arm64',
'-miphoneos-version-min=15.0','-dynamiclib',
'-Wl,-headerpad,0x1000',
'-Wl,-map,'+str(cls.linkmap),
str(ROOT/'tests/fixtures/macho_calls.c'),'-o',str(cls.src)],
check=True, capture_output=True)
cls.original = cls.src.read_bytes()
@classmethod
def tearDownClass(cls):
cls.tmp.cleanup()
def test_rewrite_preserves_got_and_branch_targets(self):
with tempfile.TemporaryDirectory() as td:
dst = Path(td)/'guarded'
before, sites = inspect_binary(self.src)
self.assertEqual({s['symbol'] for s in sites}, {'_getpid','_write'})
count, n, _, va = guard.harden_thin(self.src, dst)
after, remaining = inspect_binary(dst)
self.assertEqual(sum(count.values()),len(sites))
self.assertEqual(remaining, [])
m = Macho(dst.read_bytes())
self.assertEqual(m.segs['__IGUARD']['initprot'],5)
self.assertEqual(guard.find_stub_got_slots(m),
guard.find_stub_got_slots(Macho(self.original)))
view = batch.Slice(dst.read_bytes(),0)
old_view = batch.Slice(self.original,0)
addr, length, off = view.text
old_off = old_view.text[2]
changes = []
for i in range(0,length,4):
old, = struct.unpack_from('<I',self.original,old_off+i)
new, = struct.unpack_from('<I',m.d,off+i)
if old==new:
continue
changes.append(i)
self.assertEqual(old & 0xfc000000,new & 0xfc000000)
imm = new & 0x3ffffff
if imm & (1<<25): imm -= 1<<26
self.assertTrue(va <= addr+i+imm*4 < va+n*12)
self.assertEqual(len(changes),len(sites))
self.assertEqual(self.src.read_bytes(),self.original)
self.assertEqual(before['slices'][0]['uuid'],after['slices'][0]['uuid'])
def test_reject_duplicate_injection_and_input_overwrite(self):
with tempfile.TemporaryDirectory() as td:
dst = Path(td)/'out'
guard.inject(self.src,dst)
with self.assertRaisesRegex(ValueError,'重复'):
guard.inject(dst,Path(td)/'again')
with self.assertRaisesRegex(ValueError,'覆盖'):
guard.inject(self.src,self.src)
def test_reject_unsupported_architecture_and_truncation(self):
for offset, value in [(4,0x01000007),(8,2)]:
data = bytearray(self.original)
struct.pack_into('<I',data,offset,value)
with self.assertRaises(ValueError): Macho(data)
for size in (0,4,31,64,len(self.original)-1):
with self.subTest(size=size), self.assertRaises(ValueError):
Macho(self.original[:size])
def test_reject_encrypted_image(self):
data = bytearray(self.original)
m = Macho(data)
# 在已有 padding 中追加 encryption_info_command_64。
end = 32+m.sizeofcmds
data[end:end+24] = struct.pack('<6I',0x2c,24,0,0,1,0)
struct.pack_into('<II',data,16,m.ncmds+1,m.sizeofcmds+24)
with self.assertRaisesRegex(ValueError,'加密'): Macho(data)
def test_reject_insufficient_header_space(self):
with tempfile.TemporaryDirectory() as td:
data = bytearray(self.original)
m = Macho(data)
# 保留现有命令,用合法空命令填满 padding,只剩不足 72B。
end = 32+m.sizeofcmds
first = guard._first_section_fileoff(m)
size = (first-end)//8*8
struct.pack_into('<II',data,end,0x7777,size)
struct.pack_into('<II',data,16,m.ncmds+1,m.sizeofcmds+size)
src,dst = Path(td)/'src',Path(td)/'dst'
src.write_bytes(data)
with self.assertRaisesRegex(AssertionError,'空间不足'):
guard.inject(src,dst)
self.assertFalse(dst.exists())
def test_targeted_rewrite_and_trace(self):
profile={'rules':[dict(caller='_fixture_calls',symbol='_getpid',
destination='_fixture_redirect',expected_count=1)]}
with tempfile.TemporaryDirectory() as td:
dst=Path(td)/'patched'
report=patch(self.src,dst,self.linkmap,profile)
self.assertEqual(report['total'],1)
rows=trace_calls(dst,self.linkmap,['_fixture_calls'])
self.assertNotIn('_getpid',{r.get('symbol') for r in rows})
self.assertIn('_write',{r.get('symbol') for r in rows})
with self.assertRaises(ValueError):patch(self.src,dst,self.linkmap,profile)
def test_targeted_reject_stale_map(self):
with tempfile.TemporaryDirectory() as td:
lm=Path(td)/'bad.map'
lm.write_text('0x1 0x4 [1] _fixture_calls\n0x2 0x4 [1] _fixture_redirect\n')
profile={'rules':[dict(caller='_fixture_calls',symbol='_getpid',
destination='_fixture_redirect',expected_count=1)]}
with self.assertRaisesRegex(ValueError,'不匹配'):
patch(self.src,Path(td)/'out',lm,profile)
def test_map_with_non_utf8_sdk_symbol(self):
with tempfile.TemporaryDirectory() as td:
lm=Path(td)/'sdk.map'
lm.write_bytes(b'0x1 0x4 [1] sdk_\xf0\xff\n'+self.linkmap.read_bytes())
profile={'rules':[dict(caller='_fixture_calls',symbol='_getpid',
destination='_fixture_redirect',expected_count=1)]}
report=patch(self.src,Path(td)/'out',lm,profile)
self.assertEqual(report['total'],1)
def test_targeted_reject_wrong_count(self):
with tempfile.TemporaryDirectory() as td:
profile={'rules':[dict(caller='_fixture_calls',symbol='_getpid',
destination='_fixture_redirect',expected_count=2)]}
with self.assertRaises(ValueError):patch(self.src,Path(td)/'out',self.linkmap,profile)
def test_trace_recovers_injected_got_bridge(self):
with tempfile.TemporaryDirectory() as td:
dst=Path(td)/'bridge'
guard.harden_thin(self.src,dst)
rows=trace_calls(dst,self.linkmap,['_fixture_calls'])
self.assertEqual({r.get('symbol') for r in rows if r['kind']=='got_bridge'},
{'_getpid','_write'})
class ArchiveTests(unittest.TestCase):
def test_reject_zip_escape(self):
import zipfile
with tempfile.TemporaryDirectory() as td:
path = Path(td)/'bad.ipa'
with zipfile.ZipFile(path,'w') as z: z.writestr('../escape','bad')
with self.assertRaises(ValueError): validate_zip(path)
if __name__ == '__main__':
unittest.main()
+81
View File
@@ -0,0 +1,81 @@
"""断边原语(docs/18 §7「断边」):IGPoisonInline.h 的 always_inline 核心。
两条验收:
1. 语义等价(host/macosx):内联 mask/apply 与 IGPoison.c 的 out-of-line 公共入口逐例一致,
推荐接入形态 ig_poison_mix_key_inline 健康恒等、毒化扰动。证「单一真源不漂移」。
2. 断边(iphoneos,gate 于 SDK):模拟解密 TU 调用 ig_poison_mix_key_inline,-O2 编译后
反汇编**不含任何 `bl ig_poison_*` 调用边**(原语已内联进调用者),对 ig_pstate 只是
data 引用而非 call——攻击者没有可 NOP 的调用边,毒化揉进 key schedule。
"""
from pathlib import Path
import os
import shutil
import subprocess
import sys
import tempfile
import unittest
ROOT = Path(__file__).resolve().parents[1]
@unittest.skipUnless(sys.platform == 'darwin' and shutil.which('xcrun'), '需要 Xcode/macOS')
class PoisonInlineEquivalenceTests(unittest.TestCase):
"""语义等价:内联核心 == 库入口(单一真源)。host 原生跑,不需设备。"""
def test_inline_equals_outofline(self):
env = dict(os.environ)
env.pop('DYLD_INSERT_LIBRARIES', None)
with tempfile.TemporaryDirectory() as d:
exe = Path(d) / 'poison-inline-host'
# 内联核心只依赖 IGPoison.c(定义 ig_pstate + init/mark),无其它 TU 依赖。
args = ['xcrun', '--sdk', 'macosx', 'clang', '-O2', '-Wall', '-Wextra',
'-I', str(ROOT / 'defender/include'), '-I', str(ROOT / 'defender'),
str(ROOT / 'tests/fixtures/poison_inline_host.c'),
str(ROOT / 'defender/poison/IGPoison.c'),
'-o', str(exe)]
b = subprocess.run(args, capture_output=True, text=True, env=env)
self.assertEqual(b.returncode, 0, b.stdout + b.stderr)
r = subprocess.run([str(exe)], capture_output=True, text=True, env=env)
print(r.stdout.strip(), flush=True)
self.assertEqual(r.returncode, 0, r.stdout + r.stderr)
self.assertIn('0 fail', r.stdout)
def have_ios_sdk():
if sys.platform != 'darwin' or not shutil.which('xcrun'):
return False
r = subprocess.run(['xcrun', '--sdk', 'iphoneos', '--show-sdk-path'],
capture_output=True, text=True)
return r.returncode == 0 and r.stdout.strip() != ''
@unittest.skipUnless(have_ios_sdk(), '需要 Xcode + iphoneos SDK')
class PoisonInlineEdgeDeletionTests(unittest.TestCase):
"""断边:接入方内联后反汇编无 `bl ig_poison_*` 调用边。"""
def test_no_call_edge_after_inline(self):
with tempfile.TemporaryDirectory() as d:
obj = Path(d) / 'caller.o'
b = subprocess.run(
['xcrun', '--sdk', 'iphoneos', 'clang', '-arch', 'arm64',
'-miphoneos-version-min=15.0', '-O2',
'-I', str(ROOT / 'defender'), '-I', str(ROOT / 'defender/include'),
'-c', str(ROOT / 'tests/fixtures/poison_inline_caller.c'), '-o', str(obj)],
capture_output=True, text=True)
self.assertEqual(b.returncode, 0, b.stdout + b.stderr)
dis = subprocess.run(['xcrun', '--sdk', 'iphoneos', 'otool', '-tV', str(obj)],
capture_output=True, text=True).stdout
# rd_derive_key 内不得有任何 bl 调用边(原语已 always_inline)。
calls = [ln.strip() for ln in dis.splitlines() if '\tbl\t' in ln]
self.assertEqual(calls, [], f'内联后仍残留调用边:{calls}')
# 且应以 data 引用(非 call)触达 ig_pstate:undefined 符号里有 _ig_pstate。
syms = subprocess.run(['xcrun', '--sdk', 'iphoneos', 'nm', str(obj)],
capture_output=True, text=True).stdout
self.assertIn('_ig_pstate', syms, '未见对 ig_pstate 的数据引用,内联读取可能未生效')
# 符号表里不应把 ig_poison_mask/apply 作为被调用符号引入(无调用边的佐证)。
self.assertNotIn('_ig_poison_mask', syms, '残留对 ig_poison_mask 的符号引用')
self.assertNotIn('_ig_poison_apply', syms, '残留对 ig_poison_apply 的符号引用')
if __name__ == '__main__':
unittest.main()
+57
View File
@@ -0,0 +1,57 @@
"""处置链宿主自测:poison + policy + anti_jailbreak 闭环(检测→分级→数据毒化)。
固化此前只在临时目录跑过的闭环为可复现基线,作为真机验证(docs/19)前的宿主绿灯。
编译 tests/fixtures/poison_host.c 并运行,退出码 0=全部用例通过。
"""
from pathlib import Path
import os
import shutil
import subprocess
import sys
import tempfile
import unittest
ROOT = Path(__file__).resolve().parents[1]
SOURCES = [
'poison/IGPoison.c', 'policy/IGPolicy.c',
'anti_jailbreak/IGAntiJailbreak.c', 'syscall/IGSyscall.c',
'IGDefender.c', 'anti_hook/IGAntiHook.c', 'anti_hook/IGObjCBaseline.c',
'anti_frida/IGAntiInject.c', 'anti_debug/IGAntiDebug.c',
'resolve/IGResolve.c', 'dispatch/IGDispatch.c',
'dispatch/IGArchiveGuard.c', 'call_bridge/IGFileBridge.c',
'anti_tamper/IGAntiTamper.c',
]
@unittest.skipUnless(sys.platform == 'darwin' and shutil.which('xcrun'), '需要 Xcode/macOS')
class PoisonPolicyTests(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.tmp = tempfile.TemporaryDirectory()
folder = Path(cls.tmp.name)
cls.exe = folder / 'poison-host'
cls.env = dict(os.environ)
cls.env.pop('DYLD_INSERT_LIBRARIES', None)
args = ['xcrun', '--sdk', 'macosx', 'clang', '-O2',
'-I', str(ROOT / 'defender/include'), '-I', str(ROOT / 'defender'),
str(ROOT / 'tests/fixtures/poison_host.c'),
*(str(ROOT / 'defender' / p) for p in SOURCES),
'-framework', 'Foundation', '-lobjc', '-o', str(cls.exe)]
p = subprocess.run(args, capture_output=True, text=True, env=cls.env)
if p.returncode:
raise RuntimeError(p.stdout + p.stderr)
@classmethod
def tearDownClass(cls):
cls.tmp.cleanup()
def test_chain(self):
p = subprocess.run([str(self.exe)], capture_output=True, text=True, env=self.env)
# 保留逐例证据到 unittest 日志。
print(p.stdout.strip(), flush=True)
self.assertEqual(p.returncode, 0, p.stdout + p.stderr)
self.assertIn('0 fail', p.stdout)
if __name__ == '__main__':
unittest.main()
+42
View File
@@ -0,0 +1,42 @@
"""用真实策略源码做宿主测试,覆盖观察/强制模式和 unavailable。"""
from pathlib import Path
import subprocess
import tempfile
import unittest
ROOT=Path(__file__).resolve().parents[1]
POLICY=ROOT/'readoor-test/readoor/3.0/Base/Security/RDSecurityPolicy.swift'
@unittest.skipUnless(POLICY.exists(),'需要 App 副本中的策略源码')
class SecurityPolicyTests(unittest.TestCase):
def test_decisions(self):
with tempfile.TemporaryDirectory() as td:
main=Path(td)/'main.swift';exe=Path(td)/'policy'
main.write_text('''
import Foundation
struct RDDefenderFinding {
let status: Int32; let reason: Int32
var isDetected: Bool { status == 1 }
var isUnavailable: Bool { status == 2 }
}
struct RDSecurityRiskContext {
let debuggerDetected: Bool; let injectedDylibDetected: Bool; let jailbreakDetected: Bool
}
let legacy=RDSecurityRiskContext(debuggerDetected:false,injectedDylibDetected:false,jailbreakDetected:false)
let policy=RDSecurityPolicy.shared
let clean=policy.evaluate(findings:[],legacy:legacy)
assert(clean.action == .none && !clean.shouldRestrict(in:.enforce))
let unknown=policy.evaluate(findings:[RDDefenderFinding(status:2,reason:104)],legacy:legacy)
assert(unknown.action == .monitor && unknown.unavailableReasons == [104])
assert(!unknown.shouldRestrict(in:.observe) && unknown.shouldRestrict(in:.enforce))
let tamper=policy.evaluate(findings:[RDDefenderFinding(status:1,reason:105)],legacy:legacy)
assert(tamper.action == .restrictSensitive && tamper.shouldRestrict(in:.enforce))
assert(!tamper.shouldRestrict(in:.observe))
let weak=policy.evaluate(findings:[RDDefenderFinding(status:1,reason:201)],legacy:legacy)
assert(weak.action == .monitor && !weak.shouldRestrict(in:.enforce))
''')
p=subprocess.run(['xcrun','--sdk','macosx','swiftc','-module-cache-path',str(Path(td)/'module-cache'),str(main),str(POLICY),'-o',str(exe)],capture_output=True,text=True)
self.assertEqual(p.returncode,0,p.stderr)
subprocess.run([str(exe)],check=True,capture_output=True)
if __name__=='__main__':unittest.main()
+143
View File
@@ -0,0 +1,143 @@
"""静态硬化回归(docs/18 §7):守住「抗静态分析」几条不被后续改动悄悄打回。
验收(对 iphoneos 产物):
1. §7.1 strings 捞不到越狱路径 / 注入特征串 / frida 线程名等明文常量。
2. 符号可见性:只有 IG_PUBLIC 四入口导出(T);内部 ig_* 不以外部符号导出,
且链接进可执行文件 strip 后彻底消失。
3. §7.4 旧基线魔数 0xA5C3F10E7B2D4968 不以明文/立即数出现在反汇编。
4. 混淆表 .inc 与 gen_jb_paths.py 清单一致(防手改 .inc 或漏重生成)。
需 Xcode + iphoneos SDK;缺则跳过。
"""
from pathlib import Path
import shutil
import subprocess
import sys
import tempfile
import unittest
ROOT = Path(__file__).resolve().parents[1]
# strings 里绝不应出现的明文特征(越狱路径 + 注入/frida 特征 + 线程名)。
FORBIDDEN = [
'cydia', '/var/jb', '/bin/bash', 'tweakinject', 'sileo', 'mobilesubstrate',
'ig_jb_probe', 'gum-js-loop', 'pool-frida', 'pool-spawner', 'gmain', 'gdbus',
'linjector', 'cynject', 'cycript', 'libhooker', 'rocketbootstrap', 'flexloader',
'shadowhook', 'substitute', 'gadget', 'dobby', 'fishhook',
]
PUBLIC = {'_ig_defender_scan', '_ig_poison_init', '_ig_poison_apply', '_ig_policy_scan_and_mark'}
INTERNAL = ['_ig_poison_mark', '_ig_poison_mask', '_ig_policy_sink',
'_ig_policy_evaluate_and_mark', '_ig_anti_jb_check', '_ig_anti_inject_check']
OLD_MAGIC = ['a5c3f10e', '7b2d4968']
def have_sdk():
if sys.platform != 'darwin' or not shutil.which('xcrun'):
return False
r = subprocess.run(['xcrun', '--sdk', 'iphoneos', '--show-sdk-path'],
capture_output=True, text=True)
return r.returncode == 0 and r.stdout.strip() != ''
@unittest.skipUnless(have_sdk(), '需要 Xcode + iphoneos SDK')
class StaticHardeningTests(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.tmp = tempfile.TemporaryDirectory()
cls.dist = Path(cls.tmp.name) / 'dist'
r = subprocess.run(['sh', str(ROOT / 'tools/build_defender_lib.sh'), str(cls.dist)],
capture_output=True, text=True)
if r.returncode:
raise RuntimeError(r.stdout + r.stderr)
cls.lib = cls.dist / 'lib/libIGDefender.a'
cls.inc = cls.dist / 'include'
@classmethod
def tearDownClass(cls):
cls.tmp.cleanup()
def _nm(self, path, *extra):
return subprocess.run(['xcrun', '--sdk', 'iphoneos', 'nm', *extra, str(path)],
capture_output=True, text=True).stdout
def test_no_plaintext_needles(self):
"""§7.1:strings 不含任何越狱/注入/frida 明文特征。"""
out = subprocess.run(['strings', '-a', str(self.lib)],
capture_output=True, text=True).stdout.lower()
hit = [w for w in FORBIDDEN if w in out]
self.assertEqual(hit, [], f'明文特征泄漏:{hit}')
def test_gen_table_in_sync(self):
"""混淆表 .inc 与清单一致。"""
r = subprocess.run([sys.executable, str(ROOT / 'tools/gen_jb_paths.py'), '--check'],
capture_output=True, text=True)
self.assertEqual(r.returncode, 0, r.stdout + r.stderr)
def _defined_class(self):
"""解析 nm -m,返回 {symbol: 'private external'|'external'}(只取已定义符号)。
.a 阶段 nm -g 无法区分 private-extern(仍显示 T),须用 nm -m 看 N_PEXT 位。"""
cls = {}
for line in self._nm(self.lib, '-m').splitlines():
if '(undefined)' in line or ') ' not in line:
continue
sym = line.rsplit(' ', 1)[-1]
if 'private external' in line:
cls[sym] = 'private external'
elif 'external' in line:
cls[sym] = 'external'
return cls
def test_internal_symbols_private(self):
"""内部符号为 private external(-fvisibility=hidden 生效),最终 strip 即消失。"""
cls = self._defined_class()
for sym in INTERNAL:
if sym in cls: # 已定义者必须是 private external,不能是普通 external
self.assertEqual(cls[sym], 'private external', f'{sym} 未私有化:{cls[sym]}')
def test_public_entries_exported(self):
"""四个 IG_PUBLIC 入口为普通 external(保持导出,供接入方引用)。"""
cls = self._defined_class()
for sym in PUBLIC:
self.assertEqual(cls.get(sym), 'external', f'{sym} 非导出 external:{cls.get(sym)}')
def test_strip_removes_internal(self):
"""链接进可执行文件 + strip -x 后,内部 ig_* 名彻底消失。"""
w = Path(self.tmp.name)
src = w / 'main.c'
src.write_text('#include "IGGuard.h"\n'
'int main(){ ig_poison_init(); uint8_t k[4]={1,2,3,4},o[4];\n'
' ig_policy_scan_and_mark("/x",0,0,0); ig_poison_apply(k,o,4); return o[0]; }\n')
app = w / 'app'
r = subprocess.run(['xcrun', '--sdk', 'iphoneos', 'clang', '-arch', 'arm64',
'-miphoneos-version-min=15.0', '-O2', '-I', str(self.inc),
str(src), str(self.lib), '-lobjc', '-framework', 'Foundation',
'-o', str(app)], capture_output=True, text=True)
self.assertEqual(r.returncode, 0, r.stdout + r.stderr)
subprocess.run(['xcrun', '--sdk', 'iphoneos', 'strip', '-x', str(app)], check=True)
out = self._nm(app)
for sym in INTERNAL:
self.assertNotIn(sym, out, f'strip 后仍残留 {sym}')
def test_baseline_magic_absent(self):
"""§7.4:旧基线魔数不以明文/立即数出现在反汇编。"""
dis = subprocess.run(['xcrun', '--sdk', 'iphoneos', 'otool', '-tV', str(self.lib)],
capture_output=True, text=True).stdout.lower()
hit = [m for m in OLD_MAGIC if m in dis]
self.assertEqual(hit, [], f'旧基线魔数残留:{hit}')
def test_no_telegraphing_sections(self):
"""§7.2:不得用会「挂牌」的自定义命名 section。
命名 section(如旧实现的 __ig_p0/p1/p2/pd)会原样留在 Mach-O load command 里,
strip 也抹不掉,等于把毒化副本位置写进 header 供 otool -l 一把定位——比匿名 BSS 更糟。
毒化状态须存进匿名 __bss/__data。本测试守 .a 不出现 __ig_/__poison 等泄漏性节名。"""
out = subprocess.run(['xcrun', '--sdk', 'iphoneos', 'otool', '-l', str(self.lib)],
capture_output=True, text=True).stdout.lower()
leak = [ln.split('sectname', 1)[1].strip()
for ln in out.splitlines() if 'sectname' in ln
and ('__ig' in ln or '__poison' in ln or '__ig_p' in ln)]
self.assertEqual(leak, [], f'泄漏性命名 section(strip 抹不掉,会挂牌毒化副本位置):{leak}')
if __name__ == '__main__':
unittest.main()
+188
View File
@@ -0,0 +1,188 @@
import importlib.util
import json
from pathlib import Path
import platform
import struct
import subprocess
import sys
import tempfile
import unittest
ROOT = Path(__file__).resolve().parents[1]
spec = importlib.util.spec_from_file_location("redirect_symbols", ROOT / "tools/static_sdk_redirect/redirect_symbols.py")
redirect = importlib.util.module_from_spec(spec)
spec.loader.exec_module(redirect)
def object_bytes(name=b"_fopen", ntype=1):
strings = b"\0" + name + b"\0"
header = struct.pack("<8I", 0xFEEDFACF, redirect.CPU_ARM64, 0, 1, 1, 24, 0, 0)
command = struct.pack("<6I", 2, 24, 56, 1, 72, len(strings))
symbol = struct.pack("<IBBHQ", 1, ntype, 0, 0, 0)
return header + command + symbol + strings
def llvm_object(payload):
segment = bytearray(152)
struct.pack_into("<II", segment, 0, 0x19, 152)
struct.pack_into("<I", segment, 64, 1)
segment[72:88] = b"__bitcode".ljust(16, b"\0")
segment[88:104] = b"__LLVM".ljust(16, b"\0")
struct.pack_into("<QI", segment, 112, len(payload), 208)
strings = b"\0_fopen\0"
header = struct.pack("<8I", 0xFEEDFACF, redirect.CPU_ARM64, 0, 1, 2, 176, 0, 0)
command = struct.pack("<6I", 2, 24, 216, 1, 232, len(strings))
symbol = struct.pack("<IBBHQ", 1, 1, 0, 0, 0)
return header + segment + command + payload.ljust(8, b"\0") + symbol + strings
class FormatTests(unittest.TestCase):
def test_invalid_mappings(self):
invalid = [{}, [], {"fopen": "_IG_fopen"}, {"_a": "_a"},
{"_a": "_b", "_b": "_c"}, {"_a": "_x", "_b": "_x"},
{"_a": 3}, {"_a": "_x\u0000"}]
for mapping in invalid:
with self.subTest(mapping=mapping), self.assertRaises(ValueError):
redirect.validate_mapping(mapping)
def test_duplicate_json_key(self):
with tempfile.TemporaryDirectory() as folder:
path = Path(folder) / "mapping.json"
path.write_text('{"_a":"_x", "_a":"_y"}')
with self.assertRaises(ValueError):
redirect.load_mapping(path)
def test_custom_mapping(self):
result, count = redirect.redirect_object(object_bytes(b"_my_function"),
{"_my_function": "_custom_bridge"})
self.assertEqual(count, 1)
self.assertIn(b"_custom_bridge\0", result)
def test_relocation_index_unchanged(self):
original = object_bytes()
result, count = redirect.redirect_object(original)
self.assertEqual(count, 1)
self.assertEqual(result[:52], original[:52])
self.assertEqual(result[60:72], original[60:72])
index = struct.unpack_from("<I", result, 56)[0]
self.assertEqual(result[72 + index:].split(b"\0")[0], b"_IG_fopen")
def test_unrelated_symbol_unchanged(self):
data = object_bytes(b"_fclose")
self.assertEqual(redirect.redirect_object(data), (data, 0))
def test_reject_defined_source(self):
with self.assertRaises(ValueError):
redirect.redirect_object(object_bytes(ntype=0x0F))
def test_reject_existing_destination(self):
with self.assertRaises(ValueError):
redirect.redirect_object(object_bytes(b"_IG_fopen"))
def test_reject_truncation(self):
data = object_bytes()
for size in (0, 4, 31, 40, 60, len(data) - 1):
with self.subTest(size=size), self.assertRaises(ValueError):
redirect.redirect_object(data[:size])
def test_archive_padding(self):
data = object_bytes()
self.assertEqual(redirect.redirect_object(data + b"\n" * 4)[1], 1)
with self.assertRaises(ValueError):
redirect.redirect_object(data + b"ABCD")
def test_reject_malformed_archive(self):
with self.assertRaises(ValueError):
redirect.redirect_archive(b"!<arch>\ntruncated")
def test_preserve_empty_bitcode_marker(self):
data = llvm_object(b"\0")
result, count = redirect.redirect_object(data)
self.assertEqual(count, 1)
self.assertEqual(result[208:216], data[208:216])
def test_reject_real_bitcode(self):
with self.assertRaises(ValueError):
redirect.redirect_object(llvm_object(b"BC\xc0\xde"))
def test_reject_dylib(self):
data = bytearray(object_bytes())
struct.pack_into("<I", data, 12, 6)
with self.assertRaises(ValueError):
redirect.redirect_object(data)
@unittest.skipUnless(platform.system() == "Darwin" and platform.machine() == "arm64", "需要 ARM64 Mac + Xcode")
class NativeTests(unittest.TestCase):
def test_multiple_symbols_and_cli(self):
with tempfile.TemporaryDirectory(prefix="iosguard-multi-") as folder:
root = Path(folder)
obj, library, output = root / "sdk.o", root / "sdk.a", root / "protected.a"
subprocess.run(["xcrun", "clang", "-O2", "-c", str(ROOT / "tests/fixtures/sdk_io.c"),
"-o", str(obj)], check=True)
subprocess.run(["xcrun", "ar", "rcs", str(library), str(obj)], check=True)
mapping = redirect.load_mapping(ROOT / "tools/static_sdk_redirect/mappings/stdio.json")
mapping.update(redirect.load_mapping(ROOT / "tools/static_sdk_redirect/mappings/posix_io.json"))
config = root / "mapping.json"
config.write_text(json.dumps(mapping))
command = [sys.executable, str(ROOT / "tools/static_sdk_redirect/redirect_symbols.py"),
str(library), str(output), "--mapping", str(config), "--require-all"]
report = json.loads(subprocess.check_output(command, text=True))
self.assertEqual(report["references_redirected"], 7)
self.assertEqual(report["symbol_counts"], {name: 1 for name in mapping})
self.assertEqual(report["unmatched_symbols"], [])
symbols = {s.strip() for s in subprocess.check_output(["xcrun", "nm", "-u", str(output)], text=True).splitlines()}
self.assertTrue(set(mapping.values()) <= symbols)
self.assertFalse(set(mapping) & symbols)
for name, archive, extra in (("baseline", library, []),
("redirected", output, [str(ROOT / "defender/call_bridge/IGFileBridge.c")])):
binary = root / name
subprocess.run(["xcrun", "clang", "-O2", "-Wall", "-Wextra", "-Werror", "-DIG_TEST_ALL_BRIDGES",
str(ROOT / "tests/fixtures/file_semantics.c"), str(archive), *extra,
"-o", str(binary)], check=True)
subprocess.run([str(binary), str(root)], check=True)
missing = {**mapping, "_absent": "_IG_absent"}
with self.assertRaises(ValueError):
redirect.run(library, root / "strict.a", missing, require_all=True)
self.assertFalse((root / "strict.a").exists())
partial = redirect.run(library, root / "partial.a", missing)
self.assertEqual(partial["unmatched_symbols"], ["_absent"])
with self.assertRaises(ValueError):
redirect.run(library, root / "none.a", {"_absent": "_IG_absent"})
self.assertFalse((root / "none.a").exists())
legacy = json.loads(subprocess.check_output([sys.executable,
str(ROOT / "tools/static_sdk_redirect/redirect_fopen.py"),
str(library), str(root / "legacy.a")], text=True))
self.assertEqual(legacy["references_redirected"], 1)
def test_link_and_file_semantics(self):
with tempfile.TemporaryDirectory(prefix="iosguard-test-") as folder:
root = Path(folder)
source = root / "sdk.c"
source.write_text('#include <stdio.h>\nFILE *sdk_open(const char *p, const char *m) { return fopen(p,m); }\n')
obj, library, output = root / "sdk.o", root / "sdk.a", root / "protected.a"
subprocess.run(["xcrun", "clang", "-O2", "-c", str(source), "-o", str(obj)], check=True)
subprocess.run(["xcrun", "ar", "rcs", str(library), str(obj)], check=True)
original = library.read_bytes()
report = redirect.run(library, output)
self.assertEqual(report["references_redirected"], 1)
self.assertEqual(library.read_bytes(), original)
symbols = subprocess.check_output(["xcrun", "nm", "-u", str(output)], text=True).splitlines()
self.assertIn("_IG_fopen", [s.strip() for s in symbols])
self.assertNotIn("_fopen", [s.strip() for s in symbols])
with self.assertRaises(ValueError):
redirect.run(library, output)
with self.assertRaises(ValueError):
redirect.run(output, root / "twice.a")
# 同一行为测试分别链接原始归档和改写后的归档。
for name, archive, extra in (("baseline", library, []),
("redirected", output, [str(ROOT / "defender/call_bridge/IGFileBridge.c")])):
binary = root / name
subprocess.run(["xcrun", "clang", "-O2", "-Wall", "-Wextra", "-Werror",
str(ROOT / "tests/fixtures/file_semantics.c"), str(archive),
*extra, "-o", str(binary)], check=True)
subprocess.run([str(binary), str(root)], check=True)
if __name__ == "__main__":
unittest.main()
+80
View File
@@ -0,0 +1,80 @@
#!/bin/sh
# build_defender_lib.sh — 把 defender/ 全部 C 源交叉编译并打包成可集成静态库。
#
# 产物(默认输出到 dist/):
# dist/lib/libIGDefender.a arm64 iphoneos 静态库
# dist/include/IGGuard.h 统一公共头(umbrella)
# dist/include/... 随附的全部公共头(保持相对目录,供 IGGuard.h 相对引用)
#
# 用法:
# sh tools/build_defender_lib.sh [输出目录]
# sh tools/build_defender_lib.sh # → ./dist
# sh tools/build_defender_lib.sh /path/to/out # → 指定目录
#
# 接入方式见 docs/18_READOOR_DEFENDER_INTEGRATION.md。
set -eu
ROOT=$(cd "$(dirname "$0")/.." && pwd)
OUT=${1:-"$ROOT/dist"}
SDK=iphoneos
ARCH=arm64
MINVER=15.0
# -fvisibility=hidden(§7 抗静态调用关系):默认隐藏所有符号,只有头里标 IG_PUBLIC 的
# 入口导出;内部的 ig_poison_mark/mask、ig_policy_* 等成为 private extern,接入方最终
# 链接 + strip 后从符号表消失,nm 再也捞不到名字。
CFLAGS="-arch $ARCH -miphoneos-version-min=$MINVER -O2 -Wall -Wextra -fvisibility=hidden -I$ROOT/defender -I$ROOT/defender/include"
# §7.3 OLLVM/VMP 钩子(默认不启用):设 IG_OBFUSCATOR=/path/to/ollvm-clang 时,用它编译
# 毒化/策略两个敏感 TU 并附加 Fla/BCF/Sub 混淆;未设则用 stock clang,不做混淆(如实)。
OBF_CC=${IG_OBFUSCATOR:-}
OBF_FILES="defender/poison/IGPoison.c defender/policy/IGPolicy.c"
OBF_FLAGS="-mllvm -fla -mllvm -bcf -mllvm -sub"
# 先让 §7.1 混淆表与路径清单保持同步(CI 口径:不一致即失败)。
python3 "$ROOT/tools/gen_jb_paths.py" --check
OBJDIR=$(mktemp -d)
trap 'rm -rf "$OBJDIR"' EXIT
echo "[1/4] 交叉编译 ($SDK/$ARCH)…"
find "$ROOT/defender" -name '*.c' | while read -r f; do
o="$OBJDIR/$(echo "$f" | sed "s|$ROOT/||; s|/|_|g").o"
rel=${f#"$ROOT/"}
if [ -n "$OBF_CC" ] && echo "$OBF_FILES" | grep -qw "$rel"; then
echo " [obf] $rel"
xcrun -sdk "$SDK" "$OBF_CC" $CFLAGS $OBF_FLAGS -c "$f" -o "$o"
else
xcrun -sdk "$SDK" clang $CFLAGS -c "$f" -o "$o"
fi
done
echo "[2/4] 打包 libIGDefender.a…"
mkdir -p "$OUT/lib" "$OUT/include"
xcrun -sdk "$SDK" ar rcs "$OUT/lib/libIGDefender.a" "$OBJDIR"/*.o
xcrun -sdk "$SDK" ranlib "$OUT/lib/libIGDefender.a"
echo "[3/4] 拷贝公共头…"
# 单一 HEADER_SEARCH_PATH=<out>/include 即自洽:
# - defender/include/ 下的头(IGGuard.h / IGDefender.h …)平移到 include 根
# - 其余子目录头(poison/ policy/ syscall/ …)保持相对目录,供 umbrella 相对引用
( cd "$ROOT/defender" && \
find . -name '*.h' | sed 's|^\./||' | sort -u | while read -r h; do
case "$h" in
include/*) dst="${h#include/}" ;; # include/ 下平移到根
*) dst="$h" ;;
esac
mkdir -p "$OUT/include/$(dirname "$dst")"
cp "$ROOT/defender/$h" "$OUT/include/$dst"
done )
echo "[4/4] 校验可见性(§7):公共入口导出(T)、内部符号已私有化…"
echo " — 导出入口(应为 IG_PUBLIC 四个):"
xcrun -sdk "$SDK" nm -g "$OUT/lib/libIGDefender.a" 2>/dev/null \
| grep -E ' T _ig_(policy_scan_and_mark|poison_apply|poison_init|defender_scan)$' | sort -u || true
echo " — 内部符号可见性(应标 private external,最终 strip 后消失):"
xcrun -sdk "$SDK" nm -m "$OUT/lib/libIGDefender.a" 2>/dev/null \
| grep -E '_ig_(poison_mark|poison_mask|policy_sink|policy_evaluate_and_mark|anti_jb_check)$' \
| sed 's/^/ /' | sort -u | head -20 || true
echo "完成:$OUT/lib/libIGDefender.a ($(lipo -archs "$OUT/lib/libIGDefender.a"))"
echo "公共头:$OUT/include/IGGuard.h"
@@ -0,0 +1,30 @@
#!/usr/bin/env ruby
# 为门禁按钮级回归生成独立 XCUITest Runner,不修改 readoor 工程。
# 与 create_ui_runner.rb 同构;目标 App 为强制模式 dev 包(cn.touchv.a4YX061),
# 测试源为 IGGateRegressionTests.swift。诊断专用 Bundle ID,测试后卸载。
require 'xcodeproj'
require 'fileutils'
root = File.expand_path('../..', __dir__)
output = ARGV.fetch(0)
abort('输出目录必须不存在') if File.exist?(output)
FileUtils.mkdir_p(output)
project = Xcodeproj::Project.new(File.join(output, 'IGGateRegression.xcodeproj'))
target = project.new_target(:ui_test_bundle, 'IGGateRegression', :ios, '15.0')
ref = project.main_group.new_file(File.join(root, 'tests/business_regression/IGGateRegressionTests.swift'))
target.add_file_references([ref])
target.build_configurations.each do |config|
config.build_settings.merge!({
'PRODUCT_BUNDLE_IDENTIFIER' => 'cn.touchv.iosguard.gateregression',
'GENERATE_INFOPLIST_FILE' => 'YES', 'SWIFT_VERSION' => '5.0',
'CODE_SIGN_STYLE' => 'Manual', 'DEVELOPMENT_TEAM' => 'MG4Z7FU83W',
'CODE_SIGN_IDENTITY' => '784502FA7C65D2D524D6D20DAFD2F0A83E01B6C8',
'PROVISIONING_PROFILE_SPECIFIER' => 'e0f18495-668f-4fb1-87e1-4e048fb48d11',
'TARGETED_DEVICE_FAMILY' => '1,2'
})
end
project.save
scheme = Xcodeproj::XCScheme.new
scheme.add_build_target(target)
scheme.add_test_target(target)
scheme.save_as(project.path, 'IGGateRegression', true)
puts project.path
@@ -0,0 +1,28 @@
#!/usr/bin/env ruby
# 为已安装的独立观察包生成独立 XCTest Runner,不修改 readoor 工程。
require 'xcodeproj'
require 'fileutils'
root = File.expand_path('../..', __dir__)
output = ARGV.fetch(0)
abort('输出目录必须不存在') if File.exist?(output)
FileUtils.mkdir_p(output)
project = Xcodeproj::Project.new(File.join(output, 'IGBusinessRegression.xcodeproj'))
target = project.new_target(:ui_test_bundle, 'IGBusinessRegression', :ios, '15.0')
ref = project.main_group.new_file(File.join(root, 'tests/business_regression/IGBusinessRegressionTests.swift'))
target.add_file_references([ref])
target.build_configurations.each do |config|
config.build_settings.merge!({
'PRODUCT_BUNDLE_IDENTIFIER' => 'cn.touchv.iosguard.businessuitests',
'GENERATE_INFOPLIST_FILE' => 'YES', 'SWIFT_VERSION' => '5.0',
'CODE_SIGN_STYLE' => 'Manual', 'DEVELOPMENT_TEAM' => 'MG4Z7FU83W',
'CODE_SIGN_IDENTITY' => '784502FA7C65D2D524D6D20DAFD2F0A83E01B6C8',
'PROVISIONING_PROFILE_SPECIFIER' => 'e0f18495-668f-4fb1-87e1-4e048fb48d11',
'TARGETED_DEVICE_FAMILY' => '1,2'
})
end
project.save
scheme = Xcodeproj::XCScheme.new
scheme.add_build_target(target)
scheme.add_test_target(target)
scheme.save_as(project.path, 'IGBusinessRegression', true)
puts project.path
@@ -0,0 +1,128 @@
#!/usr/bin/env python3
"""定点加固并签名独立业务观察包;保留真实网络,禁用与原 App 冲突的 URL scheme。"""
import argparse
import datetime
import hashlib
import json
from pathlib import Path
import plistlib
import shutil
import subprocess
import sys
ROOT=Path(__file__).resolve().parents[2]
sys.path.insert(0,str(ROOT/'tools/macho_guard'))
from redirect_to_runtime import patch,sha,trace_calls
from verify_baseline import inventory,save
from redirect_framework_imports import patch as patch_framework
ARCHIVE_SHA='485c0c95b4701a4e51625e16b6c2a9781c1a8a6f6c9b9cbe392709ecfc95191a'
def prepare_archive(guarded,output,command,baseline):
sdk=guarded/'Frameworks/SSZipArchive.framework/SSZipArchive'
if sha(sdk)!=ARCHIVE_SHA:raise ValueError('SSZipArchive 版本变化,须重新审核绑定规则')
folder=guarded/'Frameworks/IGArchiveGuard.framework'
if folder.exists():raise ValueError('保护 Framework 已存在')
folder.mkdir()
(folder/'Info.plist').write_bytes(plistlib.dumps(dict(
CFBundleExecutable='IGArchiveGuard',CFBundleIdentifier='cn.touchv.iosguard.archiveguard',
CFBundleName='IGArchiveGuard',CFBundlePackageType='FMWK',CFBundleVersion='1',
CFBundleShortVersionString='1.0',MinimumOSVersion='15.0',CFBundleSupportedPlatforms=['iPhoneOS'])))
sources=['dispatch/IGArchiveGuard.c','resolve/IGResolve.c','anti_hook/IGAntiHook.c']
command(['xcrun','--sdk','iphoneos','clang','-arch','arm64','-miphoneos-version-min=15.0',
'-O2','-Wall','-Wextra','-Werror','-fvisibility=hidden','-DIG_OBSERVATION',
'-I',ROOT/'defender','-I',ROOT/'defender/include','-dynamiclib',
*(ROOT/'defender'/p for p in sources),
'-Wl,-install_name,@rpath/IGArchiveGuard.framework/IGArchiveGuard',
'-Wl,-map,'+str(output/'archive-guard-link.map'),
*(f'-Wl,-exported_symbol,_{n}' for n in
['ig_a0','ig_a1','ig_a2','ig_a3','ig_archive_check','ig_archive_counter']),
'-o',folder/'IGArchiveGuard'])
symbols=command(['xcrun','nm','-g',folder/'IGArchiveGuard'])
if 'ig_archive_test_' in symbols:raise ValueError('业务保护 Framework 含测试接口')
# 基线仍执行完整格式审核,但不保留 SDK 改写;两包主程序完全相同。
temp=output/'ssziparchive-rewritten'
report=patch_framework(sdk,temp,ARCHIVE_SHA)
if baseline:temp.unlink()
else:shutil.move(temp,sdk)
report.update(baseline=baseline,applied=not baseline)
save(output/'archive-redirect-report.json',report)
(output/'archive-guard-exports.txt').write_text(symbols)
def prepare(app,linkmap,profile,identity,output,baseline=False,archive_guard=False,archive_baseline=False):
if archive_baseline and not archive_guard:raise ValueError('archive-baseline 需要 archive-guard')
if archive_guard and baseline:raise ValueError('SDK 对照不能同时改变主程序基线')
if output.exists():raise ValueError('输出目录必须不存在')
p=subprocess.run(['openssl','smime','-inform','der','-verify','-noverify','-in',str(profile)],capture_output=True,check=True)
provision=plistlib.loads(p.stdout);prefix=provision['ApplicationIdentifierPrefix'][0]
ent=provision['Entitlements']
if ent['application-identifier']!=prefix+'.*' or not ent.get('get-task-allow'):raise ValueError('需要通配开发 profile')
if provision['ExpirationDate']<=datetime.datetime.now(datetime.timezone.utc).replace(tzinfo=None):raise ValueError('profile 已过期')
if identity.upper() not in {hashlib.sha1(c).hexdigest().upper() for c in provision['DeveloperCertificates']}:raise ValueError('签名身份不匹配')
bundle='cn.touchv.iosguard.observe.20261110'
output.mkdir(parents=True)
def command(args):
r=subprocess.run(list(map(str,args)),capture_output=True,text=True)
with (output/'commands.log').open('a') as log:log.write(json.dumps(list(map(str,args)))+'\n'+r.stdout+r.stderr+f'\nexit={r.returncode}\n')
if r.returncode:raise RuntimeError('命令失败,详见 commands.log')
return r.stdout
guarded=output/'Payload'/app.name
command(['ditto',app,guarded])
info=plistlib.loads((guarded/'Info.plist').read_bytes());exe=guarded/info['CFBundleExecutable']
symbols=subprocess.run(['xcrun','nm',exe],capture_output=True,text=True,check=True).stdout
if '_ig_dispatch_observation' not in symbols:raise ValueError('输入不是观察构建')
if 'ig_dispatch_test_' in symbols:raise ValueError('业务包不得包含测试覆盖地址接口')
rules=json.loads((ROOT/'tools/macho_guard/profiles/zipzap.json').read_text())
patched=output/'patched-binary';report=patch(exe,patched,linkmap,rules)
report['trace_before']=trace_calls(exe,linkmap,[r['caller'] for r in rules['rules']])
if baseline:
# 仍验证同次 Link Map 和预期调用点,但基线不保留任何分支改写。
patched.unlink()
report=dict(input_sha256=sha(exe),output_sha256=sha(exe),total=0,changes=[],
validated_guard_changes=report['changes'],trace_before=report['trace_before'],
trace_after=report['trace_before'],baseline=True)
else:
report['trace_after']=trace_calls(patched,linkmap,[r['caller'] for r in rules['rules']])
if any(r.get('symbol') in ('_write','_close') for r in report['trace_after']):raise ValueError('原目标直接/GOT 路径仍存在')
shutil.move(patched,exe)
original_bundle=info['CFBundleIdentifier'];info['CFBundleIdentifier']=bundle
info['CFBundleDisplayName']='教育汇·观察'
removed={k:info.pop(k) for k in ('CFBundleURLTypes',) if k in info}
(guarded/'Info.plist').write_bytes(plistlib.dumps(info))
shutil.copy2(profile,guarded/'embedded.mobileprovision')
allowed={k:v for k,v in ent.items() if k not in ('application-identifier','keychain-access-groups')}
allowed.update({'application-identifier':prefix+'.'+bundle,'keychain-access-groups':[prefix+'.'+bundle]})
(output/'entitlements.plist').write_bytes(plistlib.dumps(allowed))
if archive_guard:prepare_archive(guarded,output,command,archive_baseline)
# 独立 sandbox 不复用原 keychain/关联域/Apple 登录权限;相关功能单独验收。
nested={p for p in guarded.rglob('*') if not p.is_symlink() and p.suffix in ('.framework','.dylib')}
if any(guarded.rglob('*.appex')):raise ValueError('含扩展时需分别匹配 profile,拒绝自动套通配签名')
for p in sorted(nested,key=lambda p:(-len(p.parts),str(p))):command(['codesign','--force','--sign',identity,p])
command(['codesign','--force','--sign',identity,'--entitlements',output/'entitlements.plist',guarded])
for p in sorted(nested|{guarded}):command(['codesign','--verify','--strict','--verbose=2',p])
shutil.copy2(linkmap,output/'link.map')
report['signed_output_sha256']=sha(exe);save(output/'redirect-report.json',report)
snapshot=output/'source-snapshot'
for folder in ('defender','tools/macho_guard','tools/business_regression','tests/business_regression','readoor-test/readoor/3.0/Base/Security','readoor-test/readoor/3.0/Features/ReadView/PDF/Network','readoor-test/readoor/3.0/Features/ReadView/MemorizeWords/Handler'):
for src in (ROOT/folder).rglob('*'):
if src.is_file() and src.suffix in ('.c','.h','.swift','.py','.rb') and '__pycache__' not in src.parts:
dest=snapshot/src.relative_to(ROOT);dest.parent.mkdir(parents=True,exist_ok=True);shutil.copy2(src,dest)
command(['ditto','-c','-k','--sequesterRsrc','--keepParent',guarded.parent,output/'observation.ipa'])
save(output/'manifest.json',dict(status='ready_for_device_regression',bundle_id=bundle,original_bundle_id=original_bundle,
source_version=info.get('CFBundleShortVersionString'),redirected=report['total'],signing='development',
fake_login=False,mode='observe',baseline=baseline,archive_guard=archive_guard,
archive_baseline=archive_baseline,device_business_regression='not_run',
limitations=['独立 Bundle ID;不覆盖既有 App','未接入原 App Apple 登录、关联域、共享 Keychain 和 URL 回调',
'检测观察模式不关闭 C 调度拒绝机制'],removed_url_scheme_count=len(removed.get('CFBundleURLTypes',[])),
executable_sha256=sha(exe),ipa_sha256=sha(output/'observation.ipa')))
save(output/'evidence-hashes.json',inventory(output))
print(guarded)
if __name__=='__main__':
p=argparse.ArgumentParser(description=__doc__)
for name in ('app','link-map','profile','output'):p.add_argument('--'+name,type=Path,required=True)
p.add_argument('--identity',required=True)
p.add_argument('--baseline',action='store_true',help='不保留分支改写,用同构建和独立 Bundle ID 做对照')
p.add_argument('--archive-guard',action='store_true',help='嵌入并定点改写 SSZipArchive 文件函数绑定')
p.add_argument('--archive-baseline',action='store_true',help='嵌入相同保护库但保留 SDK 原绑定,用于同构建对照')
a=p.parse_args();prepare(a.app.resolve(),a.link_map.resolve(),a.profile.resolve(),a.identity,a.output.resolve(),a.baseline,a.archive_guard,a.archive_baseline)
+100
View File
@@ -0,0 +1,100 @@
#!/bin/bash
# 门禁按钮级回归编排(dev 包 cn.touchv.a4YX061,iPhone 16 Plus)。
#
# v6 要点(v5d/v5e 教训):
# 1. XCUITest launchEnvironment 的 DYLD_INSERT 被 SpringBoard 剥离——注入相位必须
# devicectl `-e` 调试启动通道预先启动,测试仅 activate() attach。
# 2. devicectl `--console` 通道在连续会话后不可靠(console 零输出、进程即死、命令卡
# 超时;v5e 相位 2/4 三次重试全失败,且连无注入的干净 console 启动也卡死)——
# v6 改为无 console 启动:注入生效的证明 = 进程存活 + 测试内门禁 toast 端到端
# 命中(toast 只可能由 Defender 证据触发,链条自证)。console 仅在进程死亡时作
# 诊断回退。
# 3. 相位重排,XCUITest↔devicectl 切换从 4 次降到 2 次:
# ① 干净批 A1 勘察 + A2 确保游客态·登录页 → ② 注入批(游客)B1+B2
# ③ 干净批 C1 放行证明(真实登录尝试,断言只要求无门禁 toast)→ ④ 注入批(登录
# 态,若 C1 未登成则 D1/E1 以游客守卫跳过留证)D1+E1
#
# 用法:run_gate_regression.sh <runner目录> <输出目录>
set -uo pipefail
UDID=00008140-000960811493001C
BUNDLE=cn.touchv.a4YX061
DYLIB=/private/var/mobile/Containers/Data/Application/ED2D2D55-FBA5-4106-BEFD-87A7D40A42B9/Documents/libfrida-sim.dylib
RUNNER=${1:?用法: run_gate_regression.sh <runner目录> <输出目录>}
OUT=${2:?用法: run_gate_regression.sh <runner目录> <输出目录>}
mkdir -p "$OUT"
# 子 shell 会 cd 进 runner,全部转绝对路径避免相对路径错位(v5 首跑教训)
OUT=$(cd "$OUT" && pwd)
RUNNER=$(cd "$RUNNER" && pwd)
launch_injected() { # $1=相位名:终止现进程→devicectl 无 console 注入启动→
# 轮询进程存活确认(debug 通道坏时进程即死,v5e 教训),最多 3 次重试;
# 死亡时追加一次 --console 诊断启动留取 Defender 决策行/报错。成功后等 UI 稳定。
local phase=$1 alive=1
for attempt in 1 2 3; do
xcrun devicectl device process terminate --device "$UDID" "$BUNDLE" >/dev/null 2>&1
sleep 2
xcrun devicectl device process launch --device "$UDID" \
-e "{\"DYLD_INSERT_LIBRARIES\":\"$DYLIB\"}" "$BUNDLE" \
> "$OUT/launch-$phase-$attempt.log" 2>&1
local launched_rc=$? alive_now=0
for _ in $(seq 1 10); do # 30s 内确认进程存活
sleep 3
if [ "$(xcrun devicectl device info processes --device "$UDID" 2>/dev/null | grep -c "$BUNDLE")" -ge 1 ]; then
alive_now=1; break
fi
done
if [ "$alive_now" = 1 ]; then
echo "注入进程存活(第 $attempt 次尝试,rc=$launched_rc)——注入生效由测试内门禁 toast 端到端自证"
sleep 90 # 冷启动到首页稳定(A1 实测 ~158s 首页,90s 后 D1/E1 各自再等首页锚点)
alive=0; return 0
fi
echo "第 $attempt 次注入启动进程死亡,重试"
done
# 诊断回退:console 模式抓一次输出(若 debug 通道可用可拿到 Defender 决策行)
xcrun devicectl device process launch --device "$UDID" --console --timeout 60 \
-e "{\"DYLD_INSERT_LIBRARIES\":\"$DYLIB\"}" "$BUNDLE" \
> "$OUT/console-diag-$phase.log" 2>&1 &
echo "$!" > "$OUT/console-diag-$phase.pid"
echo "警告:$phase 三次注入启动进程均死亡;已发起 console 诊断启动(见 console-diag-$phase.log)"
return 1
}
run_tests() { # $1=结果包名, 其余=-only-testing 参数
local result=$1; shift
rm -rf "$OUT/$result" # xcodebuild 拒绝覆盖已存在结果包
(cd "$RUNNER" && xcodebuild test-without-building \
-project IGGateRegression.xcodeproj -scheme IGGateRegression \
-destination "id=$UDID" -resultBundlePath "$OUT/$result" "$@" \
> "$OUT/xcodebuild-$result.log" 2>&1)
echo "EXIT_$result=$?"
}
echo "== 相位1 干净批:A1 勘察 + A2 确保游客态(登录页)"
run_tests results-clean1.xcresult \
-only-testing:IGGateRegression/IGGateRegressionTests/testA1InspectCleanState \
-only-testing:IGGateRegression/IGGateRegressionTests/testA2LogoutIfNeeded
echo "== 相位2 注入批(游客态):B1 密码 + B2 第三方"
launch_injected b12 || true
run_tests results-inject-guest.xcresult \
-only-testing:IGGateRegression/IGGateRegressionTests/testB1BlockPasswordLogin \
-only-testing:IGGateRegression/IGGateRegressionTests/testB2BlockOtherLogins
echo "== 相位3 干净批:C1 放行证明(真实登录尝试)"
run_tests results-clean2.xcresult \
-only-testing:IGGateRegression/IGGateRegressionTests/testC1AllowPasswordLogin
echo "== 相位4 注入批(登录态):D1 VIP + E1 激活"
launch_injected de1 || true
run_tests results-inject-login.xcresult \
-only-testing:IGGateRegression/IGGateRegressionTests/testD1BlockVipPurchase \
-only-testing:IGGateRegression/IGGateRegressionTests/testE1BlockActivation
# 收尾:先终止应用(让 console 诊断会话自然收口),再清残留进程
xcrun devicectl device process terminate --device "$UDID" "$BUNDLE" >/dev/null 2>&1
for pidf in "$OUT"/console-diag-*.pid; do kill "$(cat "$pidf")" 2>/dev/null; done
echo "== 完成。诊断 console 中的 Defender 决策行(若有):"
grep -h "Defender\|证据" "$OUT"/console-diag-*.log 2>/dev/null | tail -8
+137
View File
@@ -0,0 +1,137 @@
#!/usr/bin/env python3
"""gen_jb_paths.py — 生成越狱特征路径的 XOR 混淆表(docs/18 §7.1 IG_ENC)。
越狱路径常量(/var/jb、Cydia、substrate…)若明文入二进制,`strings` 一把捞出,
等于把检测目标白送。本脚本把每条路径按位置相关的 keystream 异或编码,产出
defender/anti_jailbreak/IGJailbreakPaths.inc;运行期由 IGAntiJailbreak.c 解码进
栈缓冲、用完擦除,二进制里不再驻留明文。
路径清单以本脚本为唯一真源;改清单后重跑本脚本重生成 .inc(可复现)。
python3 tools/gen_jb_paths.py # 写回 .inc
python3 tools/gen_jb_paths.py --check # 只校验 .inc 与当前清单一致(CI 用)
"""
import argparse
from pathlib import Path
import sys
ROOT = Path(__file__).resolve().parents[1]
INC = ROOT / 'defender/anti_jailbreak/IGJailbreakPaths.inc'
INC_INJ = ROOT / 'defender/anti_frida/IGInjectSignatures.inc'
# keystream: enc[j] = plain[j] ^ ((K0 + idx*K1 + j*K2) & 0xFF)。解码端须完全一致。
K0, K1, K2 = 0x5A, 0x2F, 0x13
# anti_frida 用一组不同常量(defense in depth,两表不共享 keystream)。
IK0, IK1, IK2 = 0x3C, 0x47, 0x1D
# 已知注入/调试/越狱增强框架镜像名子串(小写,ig_strstr 子串匹配)。
INJECT = [
"frida", "gadget", "cynject", "cycript", "libcycript",
"substrate", "substitute", "libsubstrate", "tweakinject",
"rocketbootstrap", "reveal", "flexloader", "libhooker",
"shadowhook", "dobby", "fishhook",
]
# 已知 frida 线程名(精确匹配)。
THREADS = [
"gum-js-loop", "gmain", "gdbus", "pool-frida", "pool-spawner", "linjector",
]
# 内置 iOS 越狱特征(强信号)。rootless 越狱重点在 /var/jb。
PATHS = [
"/var/jb",
"/Applications/Cydia.app",
"/Applications/Sileo.app",
"/Applications/Zebra.app",
"/usr/sbin/sshd",
"/usr/bin/ssh",
"/bin/bash",
"/bin/sh",
"/etc/apt",
"/private/var/lib/apt",
"/usr/lib/substrate",
"/Library/MobileSubstrate/MobileSubstrate.dylib",
"/usr/lib/TweakInject",
]
# 沙盒外探测路径(能创建即沙盒逃逸)。
PROBE = "/private/.ig_jb_probe"
def encode(s: str, idx: int, k0=K0, k1=K1, k2=K2) -> list:
return [(ord(c) ^ ((k0 + idx * k1 + j * k2) & 0xFF)) & 0xFF for j, c in enumerate(s)]
def arr(name: str, data: list) -> str:
body = ', '.join('0x%02x' % b for b in data)
return f'static const unsigned char {name}[] = {{ {body} }};'
def render() -> str:
out = []
out.append('/* IGJailbreakPaths.inc — 由 tools/gen_jb_paths.py 生成,请勿手改。 */')
out.append('/* 越狱路径 XOR 混淆表(§7.1):enc[j]=plain[j]^((K0+idx*K1+j*K2)&0xFF)。 */')
out.append(f'#define IG_JB_XOR_K0 0x{K0:02x}u')
out.append(f'#define IG_JB_XOR_K1 0x{K1:02x}u')
out.append(f'#define IG_JB_XOR_K2 0x{K2:02x}u')
out.append('')
for i, p in enumerate(PATHS):
out.append(arr(f'kIGJbEnc{i}', encode(p, i)) + f' /* len={len(p)} */')
out.append('')
rows = ', '.join(f'{{ kIGJbEnc{i}, {len(p)} }}' for i, p in enumerate(PATHS))
out.append('static const struct { const unsigned char *b; unsigned char n; } '
f'kIGJbEnc[] = {{ {rows} }};')
out.append(f'#define IG_JB_ENC_COUNT {len(PATHS)}')
out.append('')
out.append('/* 沙盒逃逸探测路径(idx 用一个与上表不冲突的独立下标)。 */')
probe_idx = 0xA5
out.append(arr('kIGJbProbeEnc', encode(PROBE, probe_idx)) + f' /* len={len(PROBE)} */')
out.append(f'#define IG_JB_PROBE_LEN {len(PROBE)}')
out.append(f'#define IG_JB_PROBE_IDX 0x{probe_idx:02x}')
out.append('')
return '\n'.join(out) + '\n'
def render_inject() -> str:
out = []
out.append('/* IGInjectSignatures.inc — 由 tools/gen_jb_paths.py 生成,请勿手改。 */')
out.append('/* 注入/Frida 特征串 XOR 混淆表(§7.1):enc[j]=plain[j]^((K0+idx*K1+j*K2)&0xFF)。 */')
out.append(f'#define IG_INJ_XOR_K0 0x{IK0:02x}u')
out.append(f'#define IG_INJ_XOR_K1 0x{IK1:02x}u')
out.append(f'#define IG_INJ_XOR_K2 0x{IK2:02x}u')
out.append('')
for i, s in enumerate(INJECT):
out.append(arr(f'kIGInjEnc{i}', encode(s, i, IK0, IK1, IK2)) + f' /* len={len(s)} */')
rows = ', '.join(f'{{ kIGInjEnc{i}, {len(s)} }}' for i, s in enumerate(INJECT))
out.append('static const struct { const unsigned char *b; unsigned char n; } '
f'kIGInjEnc[] = {{ {rows} }};')
out.append(f'#define IG_INJ_ENC_COUNT {len(INJECT)}')
out.append('')
for i, s in enumerate(THREADS):
out.append(arr(f'kIGThrEnc{i}', encode(s, i, IK0, IK1, IK2)) + f' /* len={len(s)} */')
rows = ', '.join(f'{{ kIGThrEnc{i}, {len(s)} }}' for i, s in enumerate(THREADS))
out.append('static const struct { const unsigned char *b; unsigned char n; } '
f'kIGThrEnc[] = {{ {rows} }};')
out.append(f'#define IG_THR_ENC_COUNT {len(THREADS)}')
out.append('')
return '\n'.join(out) + '\n'
def main():
ap = argparse.ArgumentParser(description=__doc__)
ap.add_argument('--check', action='store_true', help='只校验,不写回')
a = ap.parse_args()
outputs = [(INC, render(), f'{len(PATHS)} 条路径 + probe'),
(INC_INJ, render_inject(), f'{len(INJECT)} 注入特征 + {len(THREADS)} 线程名')]
if a.check:
for path, text, _ in outputs:
cur = path.read_text() if path.exists() else ''
if cur != text:
print(f'{path.name} 与当前清单不一致,请重跑 gen_jb_paths.py', file=sys.stderr)
sys.exit(1)
print('ok: 混淆表 .inc 与清单一致')
return
for path, text, note in outputs:
path.write_text(text)
print(f'已写 {path.relative_to(ROOT)}({note})')
if __name__ == '__main__':
main()
+165
View File
@@ -0,0 +1,165 @@
"""批处理:遍历 .app 包内所有 Mach-O(thin / fat 单 arm64 切片),
对每个 arm64 切片运行自研直接分支规则(扫 __text 全部 bl/b → __stubs,
经间接符号表映射到 12 个命中符号),统计命中数与注入余量。
scan 模式只读不改;harden 模式见 macho_guard.harden_bundle。
"""
import struct, sys, os
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
SYMBOLS = ["_fopen","_dlopen","_dlsym","_write","_read","_open",
"_close","_exit","_fork","_syscall","_unlink","_getpid"]
WANT = set(SYMBOLS)
FAT_MAGIC = 0xBEBAFECA # fat_header magic, big-endian on disk (cafebabe 按大端读)
FAT_MAGIC_LE = 0xCAFEBABE
MH64 = 0xFEEDFACF
LC_SEGMENT_64=0x19; LC_SYMTAB=0x2; LC_DYSYMTAB=0xb
LC_ENCRYPTION_INFO_64=0x2C
def arm64_slices(data):
"""返回 [(slice_offset, slice_size)];thin 返回单个 (0,len),fat 挑 arm64(非 arm64e)。"""
magic,=struct.unpack_from(">I",data,0)
if magic==FAT_MAGIC_LE: # fat:字段大端
nfat,=struct.unpack_from(">I",data,4)
out=[]
for i in range(nfat):
cputype,cpusub,off,size,align=struct.unpack_from(">IIIII",data,8+i*20)
# CPU_TYPE_ARM64=0x0100000C;cpusub 低 24 位:0=ARM64_ALL,1=ARM64E(2)
if cputype==0x0100000C and (cpusub & 0x00FFFFFF) in (0,1):
out.append((off,size))
return out
m,=struct.unpack_from("<I",data,0)
if m==MH64:
cpu, sub=struct.unpack_from("<II",data,4)
return [(0,len(data))] if cpu==0x0100000c and (sub & 0xffffff) in (0,1) else []
return [] # 非 arm64 Mach-O
class Slice:
"""一个 thin arm64 Mach-O 切片的只读分析视图(偏移均相对 base)。"""
def __init__(self, data, base):
self.d=data; self.base=base
magic,=struct.unpack_from("<I",data,base)
assert magic==MH64
self.ncmds,=struct.unpack_from("<I",data,base+16)
self.text=self.stubs=self.symtab=self.dysym=None
self.cryptid=0; self.first_sect_foff=None; self.sizeofcmds=0
self.text_vmaddr=0
off=base+32
self.sizeofcmds,=struct.unpack_from("<I",data,base+20)
for _ in range(self.ncmds):
cmd,cmdsize=struct.unpack_from("<II",data,off)
if cmd==LC_SEGMENT_64:
segname=data[off+8:off+24].split(b"\0")[0].decode()
vmaddr,=struct.unpack_from("<Q",data,off+24)
nsects,=struct.unpack_from("<I",data,off+64)
if segname=="__TEXT": self.text_vmaddr=vmaddr
so=off+72
for _ in range(nsects):
sn=data[so:so+16].split(b"\0")[0].decode()
addr,size=struct.unpack_from("<QQ",data,so+32)
foff,=struct.unpack_from("<I",data,so+48)
r1,r2=struct.unpack_from("<II",data,so+68)
if foff>0 and (self.first_sect_foff is None or foff<self.first_sect_foff):
self.first_sect_foff=foff
if sn=="__text": self.text=(addr,size,foff)
if sn=="__stubs": self.stubs=(addr,size,foff,r1,r2)
so+=80
elif cmd==LC_SYMTAB: self.symtab=struct.unpack_from("<IIII",data,off+8)
elif cmd==LC_DYSYMTAB: self.dysym=struct.unpack_from("<"+"I"*18,data,off+8)
elif cmd==LC_ENCRYPTION_INFO_64: self.cryptid=struct.unpack_from("<I",data,off+16)[0]
off+=cmdsize
def foff(self, slice_rel):
"""切片内相对偏移 → 文件绝对偏移。"""
return self.base+slice_rel
def stub_symbol_map(self):
"""{stub_vmaddr: symbol_name} 仅限 WANT 中符号。"""
if not (self.stubs and self.symtab and self.dysym): return {}
symoff,nsyms,stroff,strsize=self.symtab
indoff=self.dysym[12]
saddr,ssize,sfoff,sr1,sr2=self.stubs
out={}
for i in range(ssize//sr2):
idx,=struct.unpack_from("<I",self.d,self.base+indoff+(sr1+i)*4)
strx,=struct.unpack_from("<I",self.d,self.base+symoff+idx*16)
end=self.d.index(b"\0",self.base+stroff+strx)
name=self.d[self.base+stroff+strx:end].decode()
if name in WANT: out[saddr+i*sr2]=name
return out
def scan(self):
"""Counter{符号:命中数}。__text 内所有 bl/b 目标落到 WANT stub 的计数。"""
from collections import Counter
cnt=Counter()
if not self.text: return cnt
stub_sym=self.stub_symbol_map()
if not stub_sym: return cnt
taddr,tsize,tfoff=self.text
for i in range(0,tsize,4):
w,=struct.unpack_from("<I",self.d,self.base+tfoff+i)
opc=w&0xFC000000
if opc in (0x94000000,0x14000000):
imm=w&0x3FFFFFF
if imm&(1<<25): imm-=1<<26
nm=stub_sym.get(taddr+i+imm*4)
if nm: cnt[nm]+=1
return cnt
def inject_headroom(self):
"""注入一条 72 字节 LC_SEGMENT_64 所需余量:首节 foff - (header+sizeofcmds)。"""
if self.first_sect_foff is None: return None
return self.first_sect_foff-(32+self.sizeofcmds)
def iter_macho_files(app_dir):
for root,_,files in os.walk(app_dir):
for fn in files:
p=os.path.join(root,fn)
if os.path.islink(p): continue
try:
with open(p,"rb") as f: head=f.read(8)
except Exception: continue
if len(head)<4: continue
m_le,=struct.unpack_from("<I",head,0)
m_be,=struct.unpack_from(">I",head,0)
if m_le==MH64 or m_be==FAT_MAGIC_LE:
yield p
def scan_bundle(app_dir):
rows=[] # (relpath, is_fat, total, cnt, headroom, cryptid)
for p in sorted(iter_macho_files(app_dir)):
data=open(p,"rb").read()
slices=arm64_slices(data)
is_fat = struct.unpack_from(">I",data,0)[0]==FAT_MAGIC_LE
for (soff,ssize) in slices:
s=Slice(data,soff)
cnt=s.scan()
rows.append((os.path.relpath(p,app_dir),is_fat,sum(cnt.values()),
dict(cnt),s.inject_headroom(),s.cryptid))
return rows
if __name__=="__main__":
app=sys.argv[1]
rows=scan_bundle(app)
hit=[r for r in rows if r[2]>0]
from collections import Counter
grand=Counter()
print(f"Mach-O 文件/切片总数: {len(rows)};命中(>0): {len(hit)}")
print(f"{'命中':>5} {'余量':>6} {'enc':>3} 文件")
for rel,fat,tot,cnt,room,crypt in sorted(rows,key=lambda r:-r[2]):
if tot==0: continue
for k,v in cnt.items(): grand[k]+=v
tag=" FAT" if fat else ""
print(f"{tot:>5} {str(room):>6} {crypt:>3} {rel}{tag}")
print(f"\n命中总计: {sum(grand.values())}")
for k,v in sorted(grand.items(),key=lambda x:-x[1]):
print(f" {k:10} {v}")
nz=[r for r in rows if r[2]>0 and (r[4] is None or r[4]<72)]
if nz:
print("\n注入余量不足(<72B)或未知的命中文件:")
for rel,fat,tot,cnt,room,crypt in nz: print(f" room={room} {rel}")
enc=[r for r in rows if r[2]>0 and r[5]!=0]
if enc:
print("\n加密(cryptid≠0)的命中文件:")
for rel,fat,tot,cnt,room,crypt in enc: print(f" cryptid={crypt} {rel}")
@@ -0,0 +1,69 @@
#!/usr/bin/env python3
"""构建独立诊断 App;只支持匹配的 wildcard 开发 profile,不安装、不更新开发者门户。"""
import argparse
import datetime
import hashlib
import json
from pathlib import Path
import plistlib
import shutil
import subprocess
ROOT=Path(__file__).resolve().parents[2]
def build(profile,identity,bundle,output):
output=output.resolve()
if output.exists():raise ValueError('输出目录必须不存在')
r=subprocess.run(['openssl','smime','-inform','der','-verify','-noverify','-in',str(profile)],capture_output=True,check=True)
data=plistlib.loads(r.stdout);ent=data['Entitlements'];team=data['TeamIdentifier'][0]
prefix=data['ApplicationIdentifierPrefix'][0]
if ent['application-identifier']!=prefix+'.*' or not ent.get('get-task-allow'):
raise ValueError('需要通配开发 profile,避免复用现有业务 Bundle ID')
if data['ExpirationDate']<=datetime.datetime.now(datetime.timezone.utc).replace(tzinfo=None):raise ValueError('profile 已过期')
if identity.upper() not in {hashlib.sha1(c).hexdigest().upper() for c in data['DeveloperCertificates']}:
raise ValueError('identity 不属于指定 profile')
if not bundle.startswith('cn.touchv.iosguard.dispatchpilot.'):
raise ValueError('诊断 Bundle ID 必须使用专用前缀')
output.mkdir(parents=True)
def command(args):
r=subprocess.run(list(map(str,args)),capture_output=True,text=True)
with (output/'build.log').open('a') as f:f.write(json.dumps(list(map(str,args)))+'\n'+r.stdout+r.stderr+f'\nexit={r.returncode}\n')
if r.returncode:raise RuntimeError('命令失败,详见 build.log')
source=output/'source-snapshot'
inputs=[*list((ROOT/'defender').rglob('*.c')),*list((ROOT/'defender').rglob('*.h')),
ROOT/'tests/fixtures/dispatch_host.c',ROOT/'tests/fixtures/dispatch_device.m',Path(__file__)]
hashes={}
for p in inputs:
dest=source/p.relative_to(ROOT);dest.parent.mkdir(parents=True,exist_ok=True);shutil.copy2(p,dest)
hashes[str(p.relative_to(ROOT))]=hashlib.sha256(p.read_bytes()).hexdigest()
app=output/'IGDispatchPilot.app';app.mkdir()
info=dict(CFBundleExecutable='IGDispatchPilot',CFBundleIdentifier=bundle,CFBundleName='IGDispatchPilot',
CFBundleDisplayName='IG Dispatch Test',CFBundlePackageType='APPL',CFBundleVersion='1',
CFBundleShortVersionString='1.0',MinimumOSVersion='15.0',LSRequiresIPhoneOS=True,
UIDeviceFamily=[1,2],UILaunchScreen={})
(app/'Info.plist').write_bytes(plistlib.dumps(info))
common=['xcrun','--sdk','iphoneos','clang','-arch','arm64','-miphoneos-version-min=15.0',
'-O2','-DIG_DISPATCH_TESTING','-I',source/'defender','-I',source/'defender/include']
command(common+['-Dmain=ig_dispatch_fixture_main','-c',source/'tests/fixtures/dispatch_host.c','-o',output/'fixture.o'])
modules=['IGDefender.c','dispatch/IGDispatch.c','resolve/IGResolve.c',
'anti_hook/IGAntiHook.c','anti_hook/IGObjCBaseline.c',
'anti_frida/IGAntiInject.c','anti_debug/IGAntiDebug.c','syscall/IGSyscall.c']
objects=[output/'fixture.o']
for i,module in enumerate(modules):
obj=output/f'{i}.o';command(common+['-c',source/'defender'/module,'-o',obj]);objects.append(obj)
command(common+['-fobjc-arc',source/'tests/fixtures/dispatch_device.m',*objects,'-framework','UIKit','-framework','Foundation','-lobjc','-o',app/'IGDispatchPilot'])
shutil.copy2(profile,app/'embedded.mobileprovision')
allowed={k:v for k,v in ent.items() if k not in ('application-identifier','keychain-access-groups')}
allowed.update({'application-identifier':prefix+'.'+bundle,'keychain-access-groups':[prefix+'.'+bundle]})
(output/'entitlements.plist').write_bytes(plistlib.dumps(allowed))
command(['codesign','--force','--sign',identity,'--entitlements',output/'entitlements.plist',app])
command(['codesign','--verify','--strict','--verbose=2',app])
(output/'manifest.json').write_text(json.dumps(dict(bundle_id=bundle,team=team,profile_name=data['Name'],
source_hashes=hashes,signing='development',device_validation='not_run'),ensure_ascii=False,indent=2)+'\n')
print(app)
if __name__=='__main__':
p=argparse.ArgumentParser(description=__doc__)
p.add_argument('--profile',type=Path,required=True);p.add_argument('--identity',required=True)
p.add_argument('--bundle-id',required=True);p.add_argument('--output',type=Path,required=True)
a=p.parse_args();build(a.profile,a.identity,a.bundle_id,a.output)
+122
View File
@@ -0,0 +1,122 @@
#!/usr/bin/env python3
"""构建真机 HOOK 正向验证诊断 App(step11)。
只支持匹配的 wildcard 开发 profile,专用 Bundle ID 前缀避免复用业务标识;
构建后不安装、不更新开发者门户。诊断 App 附带空壳模拟 dylib(libfrida-sim.dylib),
运行时拷贝到容器外构成注入证据。攻击构造只存在于诊断源码,业务库不含。
"""
import argparse
import datetime
import hashlib
import json
from pathlib import Path
import plistlib
import shutil
import subprocess
ROOT = Path(__file__).resolve().parents[2]
BUNDLE_PREFIX = 'cn.touchv.iosguard.hookpilot.'
def command(args, log: Path, label: str):
r = subprocess.run(list(map(str, args)), capture_output=True, text=True)
with log.open('a') as f:
f.write(f'== {label} ==\n' + json.dumps(list(map(str, args))) + '\n'
+ r.stdout + r.stderr + f'\nexit={r.returncode}\n')
if r.returncode:
raise RuntimeError(f'{label} 失败,详见 build.log')
return r
def build(profile, identity, bundle, output):
output = output.resolve()
if output.exists():
raise ValueError('输出目录必须不存在')
r = subprocess.run(['openssl', 'smime', '-inform', 'der', '-verify', '-noverify',
'-in', str(profile)], capture_output=True, check=True)
data = plistlib.loads(r.stdout)
ent = data['Entitlements']
team = data['TeamIdentifier'][0]
prefix = data['ApplicationIdentifierPrefix'][0]
if ent['application-identifier'] != prefix + '.*' or not ent.get('get-task-allow'):
raise ValueError('需要通配开发 profile,避免复用现有业务 Bundle ID')
if data['ExpirationDate'] <= datetime.datetime.now(datetime.timezone.utc).replace(tzinfo=None):
raise ValueError('profile 已过期')
if identity.upper() not in {hashlib.sha1(c).hexdigest().upper()
for c in data['DeveloperCertificates']}:
raise ValueError('identity 不属于指定 profile')
if not bundle.startswith(BUNDLE_PREFIX):
raise ValueError(f'诊断 Bundle ID 必须使用专用前缀 {BUNDLE_PREFIX}')
output.mkdir(parents=True)
blog = output / 'build.log'
source = output / 'source-snapshot'
inputs = [*list((ROOT / 'defender').rglob('*.c')),
*list((ROOT / 'defender').rglob('*.h')),
ROOT / 'tests/fixtures/hook_device.m',
ROOT / 'tests/fixtures/hook_sim_dylib.c',
Path(__file__)]
hashes = {}
for p in inputs:
dest = source / p.relative_to(ROOT)
dest.parent.mkdir(parents=True, exist_ok=True)
shutil.copy2(p, dest)
hashes[str(p.relative_to(ROOT))] = hashlib.sha256(p.read_bytes()).hexdigest()
app = output / 'IGHookPilot.app'
app.mkdir()
info = dict(CFBundleExecutable='IGHookPilot', CFBundleIdentifier=bundle,
CFBundleName='IGHookPilot', CFBundleDisplayName='IG Hook Test',
CFBundlePackageType='APPL', CFBundleVersion='1',
CFBundleShortVersionString='1.0', MinimumOSVersion='15.0',
LSRequiresIPhoneOS=True, UIDeviceFamily=[1, 2], UILaunchScreen={})
(app / 'Info.plist').write_bytes(plistlib.dumps(info))
common = ['xcrun', '--sdk', 'iphoneos', 'clang', '-arch', 'arm64',
'-miphoneos-version-min=15.0', '-O2',
'-I', source / 'defender', '-I', source / 'defender/include']
modules = ['IGDefender.c', 'dispatch/IGDispatch.c', 'resolve/IGResolve.c',
'anti_hook/IGAntiHook.c', 'anti_hook/IGObjCBaseline.c',
'anti_frida/IGAntiInject.c', 'anti_debug/IGAntiDebug.c',
'syscall/IGSyscall.c']
objects = []
for i, module in enumerate(modules):
obj = output / f'{i}.o'
command(common + ['-c', source / 'defender' / module, '-o', obj], blog, f'compile {module}')
objects.append(obj)
# 主诊断:export_dynamic 使 dlsym(RTLD_DEFAULT) 能解析主程序导出的蹦床符号。
command(common + ['-fobjc-arc', source / 'tests/fixtures/hook_device.m', *objects,
'-framework', 'UIKit', '-framework', 'Foundation',
'-lobjc', '-Wl,-export_dynamic', '-o', app / 'IGHookPilot'],
blog, 'link app')
# 模拟注入 dylib:空壳、开发签名、随包作为资源分发。
sim = app / 'libfrida-sim.dylib'
command(common + ['-dynamiclib', source / 'tests/fixtures/hook_sim_dylib.c',
'-o', sim], blog, 'build sim dylib')
command(['codesign', '--force', '--sign', identity, sim], blog, 'sign sim dylib')
shutil.copy2(profile, app / 'embedded.mobileprovision')
allowed = {k: v for k, v in ent.items()
if k not in ('application-identifier', 'keychain-access-groups')}
allowed.update({'application-identifier': prefix + '.' + bundle,
'keychain-access-groups': [prefix + '.' + bundle]})
(output / 'entitlements.plist').write_bytes(plistlib.dumps(allowed))
command(['codesign', '--force', '--sign', identity,
'--entitlements', output / 'entitlements.plist', app], blog, 'sign app')
command(['codesign', '--verify', '--strict', '--verbose=2', app], blog, 'verify app')
(output / 'manifest.json').write_text(json.dumps(
dict(bundle_id=bundle, team=team, profile_name=data['Name'],
source_hashes=hashes, signing='development',
device_validation='not_run'), ensure_ascii=False, indent=2) + '\n')
print(app)
if __name__ == '__main__':
p = argparse.ArgumentParser(description=__doc__)
p.add_argument('--profile', type=Path, required=True)
p.add_argument('--identity', required=True)
p.add_argument('--bundle-id', required=True)
p.add_argument('--output', type=Path, required=True)
a = p.parse_args()
build(a.profile, a.identity, a.bundle_id, a.output)
+120
View File
@@ -0,0 +1,120 @@
#!/usr/bin/env python3
"""构建处置链真机验证诊断 App(step12,见 docs/19)。
验证 poison/policy/anti_jailbreak 这条「检测→分级→数据毒化」链在真机的行为。
只支持匹配的 wildcard 开发 profile,专用 Bundle ID 前缀避免复用业务标识;
构建后不安装、不更新开发者门户。诊断进程只被动探测,不含注入/攻击构造 dylib。
"""
import argparse
import datetime
import hashlib
import json
from pathlib import Path
import plistlib
import shutil
import subprocess
ROOT = Path(__file__).resolve().parents[2]
BUNDLE_PREFIX = 'cn.touchv.iosguard.poisonpilot.'
def command(args, log: Path, label: str):
r = subprocess.run(list(map(str, args)), capture_output=True, text=True)
with log.open('a') as f:
f.write(f'== {label} ==\n' + json.dumps(list(map(str, args))) + '\n'
+ r.stdout + r.stderr + f'\nexit={r.returncode}\n')
if r.returncode:
raise RuntimeError(f'{label} 失败,详见 build.log')
return r
def build(profile, identity, bundle, output):
output = output.resolve()
if output.exists():
raise ValueError('输出目录必须不存在')
r = subprocess.run(['openssl', 'smime', '-inform', 'der', '-verify', '-noverify',
'-in', str(profile)], capture_output=True, check=True)
data = plistlib.loads(r.stdout)
ent = data['Entitlements']
team = data['TeamIdentifier'][0]
prefix = data['ApplicationIdentifierPrefix'][0]
if ent['application-identifier'] != prefix + '.*' or not ent.get('get-task-allow'):
raise ValueError('需要通配开发 profile,避免复用现有业务 Bundle ID')
if data['ExpirationDate'] <= datetime.datetime.now(datetime.timezone.utc).replace(tzinfo=None):
raise ValueError('profile 已过期')
if identity.upper() not in {hashlib.sha1(c).hexdigest().upper()
for c in data['DeveloperCertificates']}:
raise ValueError('identity 不属于指定 profile')
if not bundle.startswith(BUNDLE_PREFIX):
raise ValueError(f'诊断 Bundle ID 必须使用专用前缀 {BUNDLE_PREFIX}')
output.mkdir(parents=True)
blog = output / 'build.log'
source = output / 'source-snapshot'
inputs = [*list((ROOT / 'defender').rglob('*.c')),
*list((ROOT / 'defender').rglob('*.h')),
*list((ROOT / 'defender').rglob('*.inc')), # §7.1 混淆表(.inc),否则快照编译缺头
ROOT / 'tests/fixtures/poison_device.m',
Path(__file__)]
hashes = {}
for p in inputs:
dest = source / p.relative_to(ROOT)
dest.parent.mkdir(parents=True, exist_ok=True)
shutil.copy2(p, dest)
hashes[str(p.relative_to(ROOT))] = hashlib.sha256(p.read_bytes()).hexdigest()
app = output / 'IGPoisonPilot.app'
app.mkdir()
info = dict(CFBundleExecutable='IGPoisonPilot', CFBundleIdentifier=bundle,
CFBundleName='IGPoisonPilot', CFBundleDisplayName='IG Poison Test',
CFBundlePackageType='APPL', CFBundleVersion='1',
CFBundleShortVersionString='1.0', MinimumOSVersion='15.0',
LSRequiresIPhoneOS=True, UIDeviceFamily=[1, 2], UILaunchScreen={})
(app / 'Info.plist').write_bytes(plistlib.dumps(info))
common = ['xcrun', '--sdk', 'iphoneos', 'clang', '-arch', 'arm64',
'-miphoneos-version-min=15.0', '-O2',
'-I', source / 'defender', '-I', source / 'defender/include']
# 处置链 + 其依赖的聚合扫描全套模块(ig_policy_scan_and_mark → ig_defender_scan)。
modules = ['poison/IGPoison.c', 'policy/IGPolicy.c',
'anti_jailbreak/IGAntiJailbreak.c', 'syscall/IGSyscall.c',
'IGDefender.c', 'anti_hook/IGAntiHook.c', 'anti_hook/IGObjCBaseline.c',
'anti_frida/IGAntiInject.c', 'anti_debug/IGAntiDebug.c',
'resolve/IGResolve.c', 'dispatch/IGDispatch.c',
'dispatch/IGArchiveGuard.c', 'call_bridge/IGFileBridge.c',
'anti_tamper/IGAntiTamper.c']
objects = []
for i, module in enumerate(modules):
obj = output / f'{i}.o'
command(common + ['-c', source / 'defender' / module, '-o', obj], blog, f'compile {module}')
objects.append(obj)
command(common + ['-fobjc-arc', source / 'tests/fixtures/poison_device.m', *objects,
'-framework', 'UIKit', '-framework', 'Foundation',
'-lobjc', '-o', app / 'IGPoisonPilot'],
blog, 'link app')
shutil.copy2(profile, app / 'embedded.mobileprovision')
allowed = {k: v for k, v in ent.items()
if k not in ('application-identifier', 'keychain-access-groups')}
allowed.update({'application-identifier': prefix + '.' + bundle,
'keychain-access-groups': [prefix + '.' + bundle]})
(output / 'entitlements.plist').write_bytes(plistlib.dumps(allowed))
command(['codesign', '--force', '--sign', identity,
'--entitlements', output / 'entitlements.plist', app], blog, 'sign app')
command(['codesign', '--verify', '--strict', '--verbose=2', app], blog, 'verify app')
(output / 'manifest.json').write_text(json.dumps(
dict(bundle_id=bundle, team=team, profile_name=data['Name'],
source_hashes=hashes, signing='development',
device_validation='not_run'), ensure_ascii=False, indent=2) + '\n')
print(app)
if __name__ == '__main__':
p = argparse.ArgumentParser(description=__doc__)
p.add_argument('--profile', type=Path, required=True)
p.add_argument('--identity', required=True)
p.add_argument('--bundle-id', required=True)
p.add_argument('--output', type=Path, required=True)
a = p.parse_args()
build(a.profile, a.identity, a.bundle_id, a.output)
+294
View File
@@ -0,0 +1,294 @@
"""macho_guard 注入器:向未加密 thin arm64 可执行文件注入 __IGUARD 桥接段。
桥接函数与系统 stub 字节同构(adrp x16,GOT@page; ldr x16,[x16,off]; br x16),
从同一 GOT 槽取址尾调用,但不登记进间接符号表——因此调用点改写为 bl IG_* 后,
静态扫描器无法再把调用点标记为对应系统符号。
本阶段(step 1)只注入段并校验结构;调用点改写在 rewrite 子命令中进行。
"""
import struct, sys, subprocess, os
from pathlib import Path
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
from machox import Macho, LC_SEGMENT_64, LC_CODE_SIGNATURE
PAGE = 0x4000 # iOS arm64 16KB 页
# 报告命中的 12 个符号
SYMBOLS = ["_fopen","_dlopen","_dlsym","_write","_read","_open",
"_close","_exit","_fork","_syscall","_unlink","_getpid"]
def _text_mapping(m: Macho):
"""返回 (__TEXT vmaddr, __TEXT fileoff),用于 vmaddr→fileoff 换算。
主程序 __TEXT vmaddr=0x1_0000_0000/fileoff=0;framework/dylib vmaddr=0/fileoff=0。"""
t=m.segs["__TEXT"]
return t["vmaddr"], t["fileoff"]
def _first_section_fileoff(m: Macho):
"""首个非零 section 文件偏移=load command 区可用上界(主程序 0x4000)。"""
best=None
for cmd,cmdsize,off in m.cmds:
if cmd!=LC_SEGMENT_64: continue
nsects,=struct.unpack_from("<I",m.d,off+64); so=off+72
for _ in range(nsects):
foff,=struct.unpack_from("<I",m.d,so+48)
if foff>0 and (best is None or foff<best): best=foff
so+=80
return best
def enc_adrp(rd, page_delta):
"""adrp rd, #page_delta(已右移12的页差由调用方给未移的字节差)."""
imm = page_delta >> 12
immlo = imm & 3; immhi = (imm >> 2) & 0x7FFFF
return 0x90000000 | (immlo<<29) | (immhi<<5) | rd
def enc_ldr_uimm(rt, rn, byte_off):
"""ldr xt,[xn,#byte_off] 64位无符号偏移."""
assert byte_off % 8 == 0
imm12 = byte_off // 8
return 0xF9400000 | (imm12<<10) | (rn<<5) | rt
def enc_br(rn):
return 0xD61F0000 | (rn<<5)
def find_stub_got_slots(m: Macho):
"""解析间接符号表,得到 {符号名: GOT槽vmaddr}(通过 stub 反解)。"""
# 定位 __stubs、symtab、dysymtab
import machox as X
stubs=symtab=dysym=None
for cmd,cmdsize,off in m.cmds:
if cmd==LC_SEGMENT_64:
nsects,=struct.unpack_from("<I",m.d,off+64)
so=off+72
for _ in range(nsects):
sn=m.d[so:so+16].split(b"\0")[0].decode()
if sn=="__stubs":
addr,size=struct.unpack_from("<QQ",m.d,so+32)
r1,r2=struct.unpack_from("<II",m.d,so+68)
stubs=(addr,size,r1,r2)
so+=80
elif cmd==X.LC_SYMTAB: symtab=struct.unpack_from("<IIII",m.d,off+8)
elif cmd==X.LC_DYSYMTAB: dysym=struct.unpack_from("<"+"I"*18,m.d,off+8)
symoff,nsyms,stroff,strsize=symtab
indoff=dysym[12]
saddr,ssize,sr1,sr2=stubs
tvm,tfo=_text_mapping(m) # vmaddr→fileoff: fo = va - tvm + tfo
out={}
for i in range(ssize//sr2):
idx,=struct.unpack_from("<I",m.d,indoff+(sr1+i)*4)
strx,=struct.unpack_from("<I",m.d,symoff+idx*16)
name=m.d[stroff+strx:m.d.index(b"\0",stroff+strx)].decode()
if name in SYMBOLS:
stub_va=saddr+i*sr2; fo=stub_va-tvm+tfo
w0,w1=struct.unpack_from("<II",m.d,fo)
immlo=(w0>>29)&3; immhi=(w0>>5)&0x7FFFF
imm=(immhi<<2)|immlo
if imm&(1<<20): imm-=1<<21
page=(stub_va & ~0xFFF)+(imm<<12)
imm12=(w1>>10)&0xFFF
out[name]=page+imm12*8
return out
def build_bridge(got_slots, ig_vmaddr):
"""生成桥接段字节与 {符号:IG函数vmaddr}。每函数 3 指令 12 字节。"""
code=bytearray(); addrs={}
order=[s for s in SYMBOLS if s in got_slots]
for i,sym in enumerate(order):
fn_va=ig_vmaddr+i*12
slot=got_slots[sym]
page_delta=(slot & ~0xFFF)-(fn_va & ~0xFFF)
off=slot & 0xFFF
code+=struct.pack("<III",enc_adrp(16,page_delta),
enc_ldr_uimm(16,16,off),enc_br(16))
addrs[sym]=fn_va
return bytes(code),addrs
def inject(path, out_path):
if os.path.realpath(path)==os.path.realpath(out_path):
raise ValueError("注入输出不得覆盖输入")
m=Macho(Path(path).read_bytes())
if "__IGUARD" in m.segs:
raise ValueError("已存在 __IGUARD,拒绝重复注入")
le=m.segs["__LINKEDIT"]
ig_fileoff=le["fileoff"]; ig_vmaddr=le["vmaddr"]
got=find_stub_got_slots(m)
missing=[s for s in SYMBOLS if s not in got]
bridge,addrs=build_bridge(got,ig_vmaddr)
seg_filesize=PAGE # 一页足够
hdr_region=_first_section_fileoff(m) # load command 区上界(主程序 0x4000,framework 各异)
assert ig_fileoff>hdr_region, "插入点须在 header 区之后"
# 1) 段数据:桥接 + 补零到一页
segdata=bytearray(bridge)+b"\0"*(seg_filesize-len(bridge))
# 2) 文件插入:在 __LINKEDIT fileoff 处插入一页
d=m.d
body=bytearray(d)
body[ig_fileoff:ig_fileoff]=segdata # 插入
# 3) 构造 __IGUARD 段命令(0 section, RX)
segcmd=struct.pack("<II16sQQQQiiII",LC_SEGMENT_64,72,b"__IGUARD",
ig_vmaddr,PAGE,ig_fileoff,seg_filesize,5,5,0,0)
# 4) 在 __LINKEDIT 命令前插入该段命令,保持 header 区总长不变
le_cmdoff=m.segs["__LINKEDIT"]["off"]
# header 区(0..hdr_region)未受段数据插入影响(插入点 ig_fileoff>hdr_region),直接在其中插命令
hdr=bytearray(body[:hdr_region])
newhdr=hdr[:le_cmdoff]+segcmd+hdr[le_cmdoff:m.hdr_size+m.sizeofcmds]
pad=hdr_region-len(newhdr)
assert pad>=0, f"load command 空间不足: 需要 {len(newhdr)} > {hdr_region}"
newhdr+=b"\0"*pad
body[:hdr_region]=newhdr
# 5) 修 header ncmds/sizeofcmds
struct.pack_into("<II",body,16,m.ncmds+1,m.sizeofcmds+72)
# 6) 修 __LINKEDIT 段命令:命令已右移 72 字节
le_newoff=le_cmdoff+72
struct.pack_into("<Q",body,le_newoff+24,le["vmaddr"]+PAGE) # vmaddr
struct.pack_into("<Q",body,le_newoff+40,le["fileoff"]+PAGE) # fileoff
# 7) 修所有指向 __LINKEDIT 的偏移 += PAGE(命令偏移也右移 72)
for lab,fo,v in m.linkedit_pointers():
struct.pack_into("<I",body,fo+(72 if fo>=le_cmdoff else 0),v+PAGE)
Path(out_path).write_bytes(body)
return addrs, missing, ig_vmaddr
def rewrite_callsites(path, out_path, bridge_addrs):
"""把 __text 里所有 bl/b -> 命中符号 stub 的调用点改写为 bl/b -> IG_*。
返回 {符号: 改写数}。调用点文件偏移在 ig 插入点之前,不受注入影响。"""
m=Macho(Path(path).read_bytes())
got=find_stub_got_slots(m) # 复用:也给出每个符号的 stub
# 需要 stub_va: 重新建 符号->stub_va
import machox as X
stubs=symtab=dysym=text=None
for cmd,cmdsize,off in m.cmds:
if cmd==LC_SEGMENT_64:
nsects,=struct.unpack_from("<I",m.d,off+64); so=off+72
for _ in range(nsects):
sn=m.d[so:so+16].split(b"\0")[0].decode()
addr,size=struct.unpack_from("<QQ",m.d,so+32)
foff,=struct.unpack_from("<I",m.d,so+48)
r1,r2=struct.unpack_from("<II",m.d,so+68)
if sn=="__stubs": stubs=(addr,size,foff,r1,r2)
if sn=="__text": text=(addr,size,foff)
so+=80
elif cmd==X.LC_SYMTAB: symtab=struct.unpack_from("<IIII",m.d,off+8)
elif cmd==X.LC_DYSYMTAB: dysym=struct.unpack_from("<"+"I"*18,m.d,off+8)
symoff,nsyms,stroff,strsize=symtab; indoff=dysym[12]
saddr,ssize,sfoff,sr1,sr2=stubs
stub_sym={}
for i in range(ssize//sr2):
idx,=struct.unpack_from("<I",m.d,indoff+(sr1+i)*4)
strx,=struct.unpack_from("<I",m.d,symoff+idx*16)
name=m.d[stroff+strx:m.d.index(b"\0",stroff+strx)].decode()
if name in bridge_addrs: stub_sym[saddr+i*sr2]=name
taddr,tsize,tfoff=text
d=bytearray(Path(path).read_bytes())
from collections import Counter
cnt=Counter()
for i in range(0,tsize,4):
w,=struct.unpack_from("<I",d,tfoff+i)
opc=w&0xFC000000
if opc in (0x94000000,0x14000000):
imm=w&0x3FFFFFF
if imm&(1<<25): imm-=1<<26
tgt=taddr+i+imm*4
sym=stub_sym.get(tgt)
if sym:
site=taddr+i; dest=bridge_addrs[sym]; delta=dest-site
assert -(1<<27)<=delta<(1<<27) and delta%4==0, f"越界 {site:#x}->{dest:#x}"
neww=opc | ((delta>>2)&0x3FFFFFF)
struct.pack_into("<I",d,tfoff+i,neww)
cnt[sym]+=1
Path(out_path).write_bytes(d)
return dict(cnt)
def codesign_adhoc(path):
r=subprocess.run(["codesign","-f","-s","-",path],capture_output=True,text=True)
return r.returncode,r.stderr.strip()
# ---- 批处理:fat 感知的单文件处理 + 整包遍历 ----
import tempfile, shutil
def harden_thin(src, dst):
"""thin arm64:注入 __IGUARD + 改写调用点(不签名)。返回 (改写计数dict, 桥接数, missing)。"""
addrs,missing,igva=inject(src,dst)
cnt=rewrite_callsites(dst,dst,addrs)
return cnt, len(addrs), missing, igva
def _fat_arm64_arch(path):
"""fat 容器里 arm64 切片的 lipo arch 名(arm64 或 arm64 的子型)。返回首个匹配。"""
r=subprocess.run(["lipo","-archs",path],capture_output=True,text=True)
archs=r.stdout.split()
for a in archs:
if a=="arm64": return a
for a in archs:
if a.startswith("arm64") and a!="arm64e": return a
return None
def harden_macho_file(path, verbose=True):
"""就地加固一个 Mach-O 文件(thin 或含单 arm64 切片的 fat)。签名在上层统一做。
返回 (改写总数, 细目dict) 或 None(无命中/跳过)。"""
data=Path(path).read_bytes()
is_fat = struct.unpack_from(">I",data,0)[0]==0xCAFEBABE
if is_fat:
arch=_fat_arm64_arch(path)
if not arch: return None
with tempfile.TemporaryDirectory() as td:
thin=os.path.join(td,"thin"); hard=os.path.join(td,"hard")
subprocess.run(["lipo",path,"-thin",arch,"-output",thin],check=True)
# 加密检查
mm=Macho(Path(thin).read_bytes())
cnt,nbr,missing,igva=harden_thin(thin,hard)
if sum(cnt.values())==0: return None
# 替换回 fat
subprocess.run(["lipo",path,"-replace",arch,hard,"-output",path],check=True)
return sum(cnt.values()), dict(cnt)
else:
with tempfile.TemporaryDirectory() as td:
hard=os.path.join(td,"hard")
cnt,nbr,missing,igva=harden_thin(path,hard)
if sum(cnt.values())==0: return None
shutil.copymode(path,hard); shutil.move(hard,path)
return sum(cnt.values()), dict(cnt)
def _sign_targets(app_dir):
"""返回自底向上的签名目标:各 .framework/.app 包 + 主可执行文件。"""
fws=[]
fwdir=os.path.join(app_dir,"Frameworks")
if os.path.isdir(fwdir):
for n in sorted(os.listdir(fwdir)):
p=os.path.join(fwdir,n)
if p.endswith((".framework",".dylib")): fws.append(p)
return fws
def harden_bundle(app_dir, resign=True):
"""遍历 .app 内全部 Mach-O,逐个加固有命中者;可选统一重签。"""
import batch
results=[] # (relpath, total, cnt)
for p in sorted(batch.iter_macho_files(app_dir)):
r=harden_macho_file(p)
if r:
results.append((os.path.relpath(p,app_dir),r[0],r[1]))
print(f" [改写] {r[0]:>4} 处 {os.path.relpath(p,app_dir)}")
if resign:
# 先签 Frameworks(含被改写的),再签主 app
for fw in _sign_targets(app_dir):
subprocess.run(["codesign","-f","-s","-",fw],capture_output=True)
rc,err=codesign_adhoc(app_dir) # 签主 app bundle
print(f" [重签] 主 app exit={rc} {err}")
return results
if __name__=="__main__":
mode=sys.argv[1]
if mode=="inject":
src,dst=sys.argv[2],sys.argv[3]
addrs,missing,igva=inject(src,dst)
print(f"注入完成 -> {dst} __IGUARD={igva:#x} 桥接 {len(addrs)} 个")
if missing: print("缺失:",missing)
elif mode=="harden":
src,dst=sys.argv[2],sys.argv[3]
addrs,missing,igva=inject(src,dst)
print(f"[1/3] 注入 __IGUARD @{igva:#x},桥接 {len(addrs)} 个" + (f" 缺失={missing}" if missing else ""))
cnt=rewrite_callsites(dst,dst,addrs)
print(f"[2/3] 改写调用点 共 {sum(cnt.values())} 处: "+", ".join(f"{k}={v}" for k,v in sorted(cnt.items(),key=lambda x:-x[1])))
rc,err=codesign_adhoc(dst)
print(f"[3/3] ad-hoc 重签 exit={rc} {err}")
elif mode=="harden-bundle":
app=sys.argv[2]
print(f"遍历加固 .app: {app}")
res=harden_bundle(app, resign=(len(sys.argv)<4 or sys.argv[3]!="--no-sign"))
print(f"共加固 {len(res)} 个 Mach-O,改写 {sum(t for _,t,_ in res)} 处")
+91
View File
@@ -0,0 +1,91 @@
"""Mach-O thin arm64 结构分析/改写基础库(macho_guard)。
只处理单切片 arm64、未加密(cryptid 0)可执行文件。"""
import struct
LC_SEGMENT_64=0x19; LC_SYMTAB=0x2; LC_DYSYMTAB=0xb
LC_DYLD_INFO=0x22; LC_DYLD_INFO_ONLY=0x80000022
LC_FUNCTION_STARTS=0x26; LC_DATA_IN_CODE=0x29
LC_CODE_SIGNATURE=0x1d; LC_DYLD_CHAINED_FIXUPS=0x80000034; LC_DYLD_EXPORTS_TRIE=0x80000033
LC_SEGMENT_SPLIT_INFO=0x1e
class Macho:
def __init__(self, data: bytearray):
self.d=bytearray(data)
if len(self.d) < 32:
raise ValueError("Mach-O header 截断")
magic,=struct.unpack_from("<I",self.d,0)
if magic!=0xFEEDFACF:
raise ValueError(f"需要 thin mach-o 64: {magic:#x}")
(self.cputype,self.cpusub,self.filetype,self.ncmds,
self.sizeofcmds,self.flags)=struct.unpack_from("<iiIIII",self.d,4)
if self.cputype != 0x0100000c or (self.cpusub & 0xffffff) not in (0, 1):
raise ValueError("仅支持 arm64/arm64v8,暂不支持 arm64e 或其它架构")
if self.filetype not in (2, 6, 8):
raise ValueError("仅支持已链接 executable/dylib/bundle")
if self.sizeofcmds > len(self.d)-32 or self.ncmds > self.sizeofcmds//8:
raise ValueError("load command 区截断")
self.hdr_size=32
self._parse()
def _parse(self):
self.cmds=[]; self.segs={}; off=self.hdr_size
for _ in range(self.ncmds):
if off+8 > self.hdr_size+self.sizeofcmds:
raise ValueError("load command header 截断")
cmd,cmdsize=struct.unpack_from("<II",self.d,off)
if cmdsize < 8 or cmdsize % 8 or off+cmdsize > self.hdr_size+self.sizeofcmds:
raise ValueError("非法 load command 长度")
self.cmds.append((cmd,cmdsize,off))
if cmd==LC_SEGMENT_64:
if cmdsize < 72:
raise ValueError("segment command 截断")
segname=self.d[off+8:off+24].split(b"\0")[0].decode()
vmaddr,vmsize,fileoff,filesize=struct.unpack_from("<QQQQ",self.d,off+24)
maxprot,initprot,nsects,fl=struct.unpack_from("<iiII",self.d,off+56)
if 72+nsects*80 != cmdsize or fileoff+filesize > len(self.d):
raise ValueError("segment/section 越界")
if segname in self.segs:
raise ValueError("重复 segment")
self.segs[segname]=dict(off=off,vmaddr=vmaddr,vmsize=vmsize,
fileoff=fileoff,filesize=filesize,nsects=nsects,
maxprot=maxprot,initprot=initprot)
elif cmd==0x2c:
if cmdsize < 24 or struct.unpack_from("<I",self.d,off+16)[0] != 0:
raise ValueError("加密 Mach-O 不支持改写或扫描")
off+=cmdsize
if off != self.hdr_size+self.sizeofcmds:
raise ValueError("load command 总长不一致")
def linkedit_pointers(self):
"""返回所有指向 __LINKEDIT 的 (命令名, 字段偏移绝对值, 当前值) 列表。"""
res=[]
for cmd,cmdsize,off in self.cmds:
def add(fieldoff,label):
v,=struct.unpack_from("<I",self.d,off+fieldoff)
if v: res.append((label,off+fieldoff,v))
if cmd in (LC_DYLD_INFO,LC_DYLD_INFO_ONLY):
for i,lab in enumerate(["rebase","bind","weak_bind","lazy_bind","export"]):
add(8+i*8,"dyld_info."+lab) # each has off(4)+size(4)
elif cmd==LC_SYMTAB:
add(8,"symtab.symoff"); add(16,"symtab.stroff")
elif cmd==LC_DYSYMTAB:
for fo,lab in [(32,"toc"),(40,"modtab"),(48,"extrefsym"),
(56,"indirectsym"),(64,"extrel"),(72,"locrel")]:
add(fo,"dysymtab."+lab)
elif cmd in (LC_FUNCTION_STARTS,LC_DATA_IN_CODE,LC_CODE_SIGNATURE,
LC_DYLD_CHAINED_FIXUPS,LC_DYLD_EXPORTS_TRIE,LC_SEGMENT_SPLIT_INFO):
add(8,{LC_FUNCTION_STARTS:"function_starts",LC_DATA_IN_CODE:"data_in_code",
LC_CODE_SIGNATURE:"code_signature",LC_DYLD_CHAINED_FIXUPS:"chained_fixups",
LC_DYLD_EXPORTS_TRIE:"exports_trie",LC_SEGMENT_SPLIT_INFO:"split_info"}[cmd])
return res
if __name__=="__main__":
import sys
m=Macho(bytearray(open(sys.argv[1],"rb").read()))
print(f"cputype={m.cputype:#x} ncmds={m.ncmds} sizeofcmds={m.sizeofcmds}")
print("padding for new LC =", min(s['fileoff'] for s in m.segs.values() if s['fileoff']>0 and s['nsects']>0) - (m.hdr_size+m.sizeofcmds))
for name,s in m.segs.items():
print(f" {name:14} vmaddr={s['vmaddr']:#012x} vmsize={s['vmsize']:#x} fileoff={s['fileoff']:#x} filesize={s['filesize']:#x} prot={s['initprot']}")
print("--- __LINKEDIT 指针 ---")
le=m.segs["__LINKEDIT"]
for lab,fo,v in m.linkedit_pointers():
inside = le['fileoff']<=v<le['fileoff']+le['filesize']
print(f" {lab:24} @{fo:#x} = {v:#x} {'(in LINKEDIT)' if inside else '!!OUTSIDE'}")
+6
View File
@@ -0,0 +1,6 @@
{
"rules": [
{"caller": "-[ZZFileChannelOutput writeData:error:]", "symbol": "_write", "destination": "_IG_dispatch_write", "expected_count": 1},
{"caller": "-[ZZFileChannelOutput close]", "symbol": "_close", "destination": "_IG_dispatch_close", "expected_count": 1}
]
}
@@ -0,0 +1,141 @@
#!/usr/bin/env python3
"""严格限定的 arm64 chained-import 试点;新文件输出,不改 SDK 机器码。"""
import argparse
import hashlib
import json
from pathlib import Path
import struct
from machox import Macho, LC_SEGMENT_64, LC_SYMTAB, LC_DYLD_CHAINED_FIXUPS
DEPENDENCY = '@rpath/IGArchiveGuard.framework/IGArchiveGuard'
MAPPING = {'_fopen': '_ig_a0', '_fread': '_ig_a1', '_fwrite': '_ig_a2', '_fclose': '_ig_a3'}
LOADS = (0xc, 0x80000018, 0x8000001f, 0x80000023, 0x20)
def require(value, message):
if not value:
raise ValueError(message)
def rewrite(data, expected_sha256):
require(hashlib.sha256(data).hexdigest() == expected_sha256, 'SDK 哈希不匹配,须重新审核版本')
m = Macho(data)
require(m.filetype == 6 and m.flags & 0x80, '需要 two-level MH_DYLIB')
require(not any(c in (0x22, 0x80000022) for c, _, _ in m.cmds), '不支持混合传统 dyld 绑定')
deps = []
sections = []
for cmd, size, off in m.cmds:
if cmd in LOADS:
n = struct.unpack_from('<I', m.d, off + 8)[0]
require(24 <= n < size, '依赖名偏移无效')
end = m.d.index(0, off + n, off + size)
deps.append(bytes(m.d[off + n:end]).decode())
if cmd == LC_SEGMENT_64:
count = struct.unpack_from('<I', m.d, off + 64)[0]
for i in range(count):
s = off + 72 + 80 * i
length, fileoff = struct.unpack_from('<QI', m.d, s + 40)
flags = struct.unpack_from('<I', m.d, s + 64)[0]
if length and flags & 0xff not in (1, 0xc, 0x12):
require(fileoff > 0 and fileoff + length <= len(data), 'section 文件范围无效')
sections.append((fileoff, length))
require(DEPENDENCY not in deps and len(deps) < 0x7e, '依赖冲突或 ordinal 超范围')
old_ordinal = deps.index('/usr/lib/libSystem.B.dylib') + 1
ordinal = len(deps) + 1
commands = [o for c, _, o in m.cmds if c == LC_DYLD_CHAINED_FIXUPS]
require(len(commands) == 1, '需要唯一 chained fixups')
fixoff, fixsize = struct.unpack_from('<II', m.d, commands[0] + 8)
require(28 <= fixsize and fixoff + fixsize <= len(data), 'fixups 越界')
version, starts, imports, symbols, count, fmt, compression = struct.unpack_from('<7I', m.d, fixoff)
require(version == 0 and fmt == 1 and compression == 0, '仅支持无压缩 DYLD_CHAINED_IMPORT')
require(28 <= starts < imports <= symbols < fixsize and imports + count * 4 <= symbols,
'fixups 结构不支持')
# 两套字符串池均先审查,拒绝别名字符串重叠和重复条目。
changes = []
allowed = set()
def write(off, value):
require(off >= 0 and off + len(value) <= len(m.d), '写入越界')
m.d[off:off + len(value)] = value
allowed.update(range(off, off + len(value)))
def rename_pool(entries, pool_start, pool_end, kind):
selected = {}
intervals = []
for entry, strx, ordinal_value in entries:
start = pool_start + strx
require(pool_start <= start < pool_end, '字符串索引越界')
end = m.d.index(0, start, pool_end)
name = bytes(m.d[start:end]).decode('utf-8')
require(name not in MAPPING.values(), '已改写或目标冲突')
intervals.append((start, end + 1, name))
if name in MAPPING:
require(name not in selected and ordinal_value == old_ordinal,
'重复导入或提供方不匹配')
selected[name] = (entry, start, end)
require(set(selected) == set(MAPPING), '缺少预期四个文件函数')
for name, (entry, start, end) in selected.items():
require(all(other == name or finish <= start or begin >= end + 1
for begin, finish, other in intervals), '共享后缀字符串,拒绝原地改名')
encoded = MAPPING[name].encode()
require(len(encoded) <= end - start, '新名称超出原字符串空间')
write(start, encoded + bytes(end - start + 1 - len(encoded)))
if kind == 'chained':
word = struct.unpack_from('<I', m.d, entry)[0]
require(not word & 0x100, '不支持 weak 目标导入')
write(entry, struct.pack('<I', (word & ~255) | ordinal))
else:
desc = struct.unpack_from('<H', m.d, entry + 6)[0]
require(not desc & 0x40, '不支持 weak 符号')
write(entry + 6, struct.pack('<H', (desc & 255) | (ordinal << 8)))
changes.append({'table': kind, 'source': name, 'destination': MAPPING[name],
'old_ordinal': old_ordinal, 'ordinal': ordinal})
entries = []
for i in range(count):
pos = fixoff + imports + 4 * i
word = struct.unpack_from('<I', m.d, pos)[0]
entries.append((pos, word >> 9, word & 255))
rename_pool(entries, fixoff + symbols, fixoff + fixsize, 'chained')
tabs = [o for c, _, o in m.cmds if c == LC_SYMTAB]
require(len(tabs) == 1, '需要唯一符号表')
symoff, nsyms, stroff, strsize = struct.unpack_from('<4I', m.d, tabs[0] + 8)
require(symoff + nsyms * 16 <= len(data) and stroff + strsize <= len(data), '符号表越界')
entries = []
for i in range(nsyms):
pos = symoff + i * 16
strx, typ, sect, desc, value = struct.unpack_from('<IBBHQ', m.d, pos)
entries.append((pos, strx, desc >> 8 if typ == 1 and sect == 0 and value == 0 else -1))
rename_pool(entries, stroff, stroff + strsize, 'nlist')
name = DEPENDENCY.encode() + b'\0'
size = (24 + len(name) + 7) & ~7
end = 32 + m.sizeofcmds
require(end + size <= min(o for o, _ in sections), 'header padding 不足')
require(not any(m.d[end:end + size]), 'header padding 非零')
command = struct.pack('<6I', 0xc, size, 24, 0, 0x10000, 0x10000) + name
write(end, command + bytes(size - len(command)))
write(16, struct.pack('<II', m.ncmds + 1, m.sizeofcmds + size))
result = bytes(m.d)
require(all(a == b or i in allowed for i, (a, b) in enumerate(zip(data, result))), '非预期字节变化')
require(all(data[o:o+n] == result[o:o+n] for o, n in sections), 'section 内容变化')
Macho(result)
return result, {'input_sha256': hashlib.sha256(data).hexdigest(),
'output_sha256': hashlib.sha256(result).hexdigest(), 'dependency': DEPENDENCY,
'changes': changes, 'machine_code_unchanged': True, 'total_symbols': 4}
def patch(source, destination, expected_sha256):
source, destination = Path(source), Path(destination)
require(not destination.exists() and source.resolve() != destination.resolve(), '输出必须为新文件')
output, report = rewrite(source.read_bytes(), expected_sha256)
destination.write_bytes(output)
destination.chmod(source.stat().st_mode)
return report
if __name__ == '__main__':
p = argparse.ArgumentParser(description=__doc__)
p.add_argument('source', type=Path)
p.add_argument('destination', type=Path)
p.add_argument('--expected-sha256', required=True)
p.add_argument('--report', type=Path, required=True)
a = p.parse_args()
a.report.write_text(json.dumps(patch(a.source, a.destination, a.expected_sha256), indent=2) + '\n')

Some files were not shown because too many files have changed in this diff Show More