Cocos2d-x iOS游戏逆向分析实战：基于Frida与JavaScriptCore的Hook与数据监控

在移动游戏开发中，Cocos2d-x凭借其成熟和开源特性，成为许多手游开发者的首选引擎。但随着游戏安全日益受到重视，对Cocos2d-x游戏进行深入的逆向分析也成为了安全研究和开发者测试的重要环节。本文将以一个实际的棋牌类游戏为案例，完整分享从目标分析、工具开发到原生Tweak实现的整个逆向实战流程，剖析其中的技术细节与解决方案。

一、目标分析：好友赛游戏

1.1 应用基本信息

• 应用名称：好友赛 (haoyousai)
• Bundle ID：com.oedere.lid23
• 版本号：1.0 (Build 59)
• 目标平台：iOS 15.0+
• CPU架构：arm64
• 游戏类型：棋牌类游戏

1.2 技术栈识别

通过静态和动态分析，我们识别出该应用采用了以下技术栈：

graph TD
A[Cocos2d-x游戏引擎] --> B[JavaScriptCore脚本引擎]
A --> C[OpenGL ES图形渲染]
B --> D[JSC字节码预编译]
B --> E[明文JS脚本]
    F[游戏逻辑] --> G[房间管理]
    F --> H[牌局处理]
    F --> I[用户交互]

1.3 应用结构分析

应用包结构揭示了其基于Cocos2d-x的典型特征：

haoyousai.app/
├── haoyousai              # 主可执行文件 (15.9MB)
├── Frameworks/           # 依赖框架
├── script/              # 游戏脚本目录
├── src/                 # 源代码目录
├── res/                 # 资源文件
├── project.json         # Cocos项目配置
├── project.manifest     # 资源清单
└── main.js             # 入口JS文件

二、逆向工具开发

为了高效地进行动态分析，我们专门开发了一个名为 cocos2dx_frida_toolkit.js 的Frida工具包。

2.1 工具架构设计

工具采用模块化设计，整体架构清晰，便于扩展和维护：

// 工具架构示意图
class Cocos2dxFridaToolkit {
// 1. 基础模块
    - Helper Functions
    - Configuration Manager
    - Logger System

// 2. 检测模块
    - Cocos2dxDetector
    - ScriptEngineDetector

// 3. 分析模块
    - LuaScriptAnalyzer
    - JSScriptAnalyzer
    - CocosGameAnalyzer

// 4. 监控模块
    - InputOutputMonitor
    - PerformanceProfiler

// 5. 控制模块
    - ToolkitController
    - RPC Exports
}

2.2 关键技术实现

2.2.1 脚本引擎检测

Cocos2d-x支持多种脚本引擎，检测模块能自动识别当前游戏使用的引擎类型。

class Cocos2dxDetector {
// 检测Lua引擎
detectLuaEngine() {
const exports = ['luaL_loadbuffer', 'lua_pcall', 'lua_getglobal'];
return this.findExportsInMainModule(exports);
    }

// 检测JavaScriptCore
detectJavaScriptCore() {
const exports = ['JSEvaluateScript', 'JSObjectCallAsFunction'];
return this.findExportsInMainModule(exports);
    }

// 检测SpiderMonkey
detectSpiderMonkey() {
const exports = ['JS_EvaluateScript', 'JS_ExecuteScript'];
return this.findExportsInMainModule(exports);
    }

// 检测Cocos JS绑定
detectCocosBindings() {
const patterns = ['jsb_', 'cocos2d::', 'ScriptingCore::'];
return this.searchExportsByPattern(patterns);
    }
}

2.2.2 脚本拦截与解密

Lua脚本拦截：
核心是Hook luaL_loadbuffer 函数，在脚本加载到解释器之前将其捕获。

class LuaScriptAnalyzer {
    hookLuaFunctions() {
// Hook luaL_loadbuffer 拦截Lua脚本加载
        Interceptor.attach(Module.findExportByName(null, 'luaL_loadbuffer'), {
            onEnter: function(args) {
const buffer = args[1];  // 脚本缓冲区
const size = args[2];    // 脚本大小
const chunkname = args[3]; // 脚本名称

// 提取并保存脚本
this.scriptData = Memory.readByteArray(buffer, size);
this.scriptName = Memory.readUtf8String(chunkname);
            },
            onLeave: function(retval) {
if (this.scriptData) {
this.saveLuaScript(this.scriptName, this.scriptData);
                }
            }
        });
    }
}

JavaScript脚本拦截：
对于使用JavaScriptCore的游戏，我们Hook JSEvaluateScript 来捕获执行的JS代码。

class JSScriptAnalyzer {
    hookJavaScriptCore() {
// Hook JSEvaluateScript 拦截JS执行
        Interceptor.attach(Module.findExportByName('JavaScriptCore', 'JSEvaluateScript'), {
            onEnter: function(args) {
const script = args[1];  // JS脚本字符串
const sourceURL = args[3]; // 源URL

// 读取脚本内容
const scriptStr = this.readJSString(script);
const urlStr = this.readJSString(sourceURL);

// 分析脚本内容
this.analyzeJSScript(scriptStr, urlStr);
            }
        });
    }

// 读取JS字符串的辅助函数
    readJSString(jsStringRef) {
const size = this.JSStringGetMaximumUTF8CStringSize(jsStringRef);
const buffer = Memory.alloc(size);
this.JSStringGetUTF8CString(jsStringRef, buffer, size);
return buffer.readUtf8String();
    }
}

2.3 性能优化与稳定性修复

在开发工具的过程中，我们遇到了几个典型问题并找到了优化方案。

2.3.1 超时崩溃问题修复

问题：早期版本中遍历所有模块导出和ObjC类的操作，极易导致Frida脚本执行超时。
解决方案：限制扫描范围，只关注主模块，并对ObjC类的遍历数量设限。

// 优化前：遍历所有模块
Process.enumerateModules().forEach(
module => {
module.enumerateExports().forEach(
export => {
// 处理每个导出
    });
});

// 优化后：只扫描主模块
const mainModule = Process.enumerateModules()[0];
mainModule.enumerateExports().forEach(
export => {
// 只处理主模块导出
});

// 限制ObjC类遍历数量
const maxHooksPerCategory = CONFIG.maxHooksPerCategory || 50;
let hookCount = 0;
for (let className in ObjC.classes) {
if (hookCount >= maxHooksPerCategory) break;
// 处理ObjC类
    hookCount++;
}

2.3.2 Hook稳定性修复

问题：盲目Hook数据段地址会导致应用崩溃。
解决方案：在Hook前检查目标地址是否位于可执行的内存区域。

function isExecutableAddress(address) {
const range = Process.findRangeByAddress(address);
return range && range.protection.includes('x');
}

function safeAttach(address, callbacks) {
if (!isExecutableAddress(address)) {
        logger.warn(`地址 ${address} 不可执行，跳过Hook`);
return null;
    }
return Interceptor.attach(address, callbacks);
}

2.3.3 ObjC桥接修复

问题：直接将JavaScript字符串传递给ObjC方法会引起类型错误。
解决方案：使用 NSString 类对字符串进行正确包装。

function nsStr(jsString) {
// 使用NSString包装JS字符串
return ObjC.classes.NSString.stringWithUTF8String_(jsString);
}

function createDir(path) {
const fileManager = ObjC.classes.NSFileManager.defaultManager();
const nsPath = nsStr(path);
const errorPtr = Memory.alloc(Process.pointerSize);

// 正确传递参数
return fileManager.createDirectoryAtPath_withIntermediateDirectories_attributes_error_(
        nsPath,
1,  // YES
NULL,
        errorPtr
    );
}

三、原生Tweak开发：CardRecorder

为了提供更稳定、性能开销更低的持久化数据监控，我们将核心功能从Frida脚本迁移到了原生iOS Tweak中，开发了名为 CardRecorder 的工具。

3.1 设计思路

原生Tweak直接注入游戏进程，在应用启动早期即进行Hook，避免了Frida注入时机和稳定性的问题，并能实现后台持续的数据记录。

3.2 核心实现

主要代码使用 Objective-C++ 编写，核心是Hook JSEvaluateScript 函数，并在合适的时机向游戏的JavaScript上下文注入监控代码。

// CardRecorder.mm 核心代码分析

// 1. JavaScriptCore C-API Hook
__attribute__((constructor))
staticvoidCardRecorderInit(void) {
// 加载JavaScriptCore框架
void *jscHandle = dlopen("/System/Library/Frameworks/JavaScriptCore.framework/JavaScriptCore", RTLD_NOW);

// 获取JSEvaluateScript函数指针
    JSEvaluateScript_t orig_JSEvaluateScript = 
        (JSEvaluateScript_t)dlsym(jscHandle, "JSEvaluateScript");

// 使用MSHookFunction进行Hook
    MSHookFunction(
        (void *)orig_JSEvaluateScript,
        (void *)hook_JSEvaluateScript,
        (void **)&orig_JSEvaluateScript
    );
}

// 2. Hook函数实现
static JSValueRef hook_JSEvaluateScript(
    JSContextRef ctx,
    JSStringRef script,
    JSObjectRef thisObject,
    JSStringRef sourceURL,
int startingLineNumber,
    JSValueRef *exception){
// 捕获JSContext
if (ctx && !g_jsCtx) {
        g_jsCtx = ctx;
        NSLog(@"[CardRecorder] 捕获JSContext: %p", ctx);
    }

// 检测游戏脚本
if (!g_injected && script) {
size_t maxSize = JSStringGetMaximumUTF8CStringSize(script);
if (maxSize > 5000) {  // 只处理大型脚本
char *buffer = (char *)malloc(maxSize);
        JSStringGetUTF8CString(script, buffer, maxSize);

// 检测关键词"setRoomData"
if (strstr(buffer, "setRoomData") != NULL) {
            NSLog(@"[CardRecorder] 检测到游戏脚本，准备注入监控代码");
            injectCardMonitor(ctx);
            }
        free(buffer);
        }
    }

// 调用原始函数
return orig_JSEvaluateScript(ctx, script, thisObject, sourceURL, startingLineNumber, exception);
}

// 3. 监控代码注入
staticvoidinjectCardMonitor(JSContextRef ctx) {
constchar *monitorJS = 
"(function(){"
"  if(window.__cardHookInstalled) return;"
"  window.__cardHookInstalled = true;"
"  setInterval(function(){"
"    try {"
"      if(!iGame || !iGame.Data || !iGame.Data.roomData) return;"
"      var selfSeat = iGame.Data.getSelfSeatNo ? iGame.Data.getSelfSeatNo() : 0;"
"      var players = iGame.Data.roomData.players;"
"      var result = {self_seat: selfSeat, my_hold: [], players: []};"
"      players.forEach(function(p){"
"        if(p.seat_no === selfSeat){"
"          result.my_hold = (p.hold || []).filter(c => c > 0);"
"        }"
"        result.players.push({"
"          seat: p.seat_no,"
"          out: p.out || [],"
"          kou: p.kou || []"
"        });"
"      });"
"      window.__cardData = JSON.stringify(result);"
"    } catch(e){}"
"  }, 1000);"
"})();";

// 在游戏JSContext中执行监控代码
    JSStringRef jsStr = JSStringCreateWithUTF8CString(monitorJS);
    JSValueRef exception = NULL;
    JSEvaluateScript(ctx, jsStr, NULL, NULL, 0, &exception);
    JSStringRelease(jsStr);
}

3.3 数据采集与存储

注入监控代码后，Tweak会定时轮询游戏全局对象中暴露的数据，并将其保存到本地文件中。

// 定时数据采集
static void startCardPolling(void) {
    dispatch_source_t timer = dispatch_source_create(
        DISPATCH_SOURCE_TYPE_TIMER, 0, 0, g_queue);

    dispatch_source_set_timer(timer,
        dispatch_time(DISPATCH_TIME_NOW, 1 * NSEC_PER_SEC),
1 * NSEC_PER_SEC, 0);

    dispatch_source_set_event_handler(timer, ^{
if (!g_jsCtx || !g_injected) return;

// 读取游戏数据
        NSString *cardData = evalInGameJS(g_jsCtx, @"window.__cardData || @"");

if (cardData && ![cardData isEqualToString:g_lastCardData]) {
            g_lastCardData = cardData;

// 保存到文件
            [self appendCardLog:cardData];
        }
    });

    dispatch_resume(timer);
}

// 文件存储
- (void)appendCardLog:(NSString *)json {
    NSString *docPath = NSSearchPathForDirectoriesInDomains(
        NSDocumentDirectory, NSUserDomainMask, YES).firstObject;
    NSString *logPath = [docPath stringByAppendingPathComponent:@"card_log.json"];

    NSFileManager *fm = [NSFileManager defaultManager];
if (![fm fileExistsAtPath:logPath]) {
        [fm createFileAtPath:logPath contents:nil attributes:nil];
    }

    NSFileHandle *fh = [NSFileHandle fileHandleForWritingAtPath:logPath];
    [fh seekToEndOfFile];
    [fh writeData:[[json stringByAppendingString:@"\n"] dataUsingEncoding:NSUTF8StringEncoding]];
    [fh closeFile];
}

四、动态分析结果

4.1 脚本捕获与分析

通过工具成功捕获了游戏运行时加载的关键脚本文件，包括预编译的JSC字节码和明文JS文件。

4.1.1 JSC字节码文件

scripts/
├── G212.jsc_1774770976633.bin   # 游戏模块212 (101KB)
├── G30.jsc_1774770909867.bin     # 游戏模块30 (29KB)
├── SYG30.jsc_1774770968778.bin   # 系统模块30 (49KB)
└── SYHall.jsc_1774770963515.bin  # 大厅模块 (584KB)

4.1.2 明文JS脚本

scripts/
├── js_1774770963709.js          # 主游戏逻辑 (1.7MB)
├── js_1774770976843.js          # 游戏模块 (302KB)
├── js_1774770968967.js          # 系统模块 (147KB)
└── 多个小型配置脚本 (88B-2KB)

4.2 游戏架构解析

分析捕获的脚本后，我们还原出了游戏的核心数据模型和全局对象结构。

// 游戏全局对象结构
window.iGame = {
Data: {
roomData: {
players: [{
seat_no: number,      // 座位号
hold: number[],       // 手牌
out: number[],        // 出牌
kou: number[]         // 扣牌
            }],
room_id: string,          // 房间ID
game_type: number         // 游戏类型
        },
getSelfSeatNo: function() {   // 获取自己座位号
return number;
        },
setRoomData: function(data) { // 设置房间数据
// 游戏状态更新
        }
    },

UI: {
// UI相关方法
    },

    Network: {
// 网络通信方法
    }
};

4.3 游戏状态监控

CardRecorder Tweak能够实时输出结构化的游戏状态数据，例如：

{
"timestamp": "2026-03-29T21:00:00Z",
"self_seat": 1,
"my_hold": [11,12,13,14,15],
"players": [
{
"seat": 1,
"out": [21,22],
"kou": []
},
{
"seat": 2,
"out": [31],
"kou": [41,42]
},
{
"seat": 3,
"out": [],
"kou": [51]
},
{
"seat": 4,
"out": [61,62,63],
"kou": []
}
]
}

五、技术难点与解决方案

5.1 多脚本引擎支持

难点：不同Cocos2d-x游戏可能使用Lua、JavaScriptCore或SpiderMonkey中的任何一种引擎，工具需要能自动识别并适配。
解决方案：实现通用的脚本引擎检测模块，通过特征函数导出来判断当前活跃的引擎。

class ScriptEngineDetector {
    detectAllEngines() {
const engines = [];

// 检测Lua
if (this.detectLuaEngine()) {
            engines.push({ type: 'lua', version: this.getLuaVersion() });
        }

// 检测JavaScriptCore
if (this.detectJavaScriptCore()) {
            engines.push({ type: 'javascriptcore', version: this.getJSCVersion() });
        }

// 检测SpiderMonkey
if (this.detectSpiderMonkey()) {
            engines.push({ type: 'spidermonkey', version: this.getSMVersion() });
        }

return engines;
    }
}

5.2 脚本加密与混淆

难点：商业游戏常对脚本进行加密或混淆，增加逆向难度。
解决方案：在脚本拦截点实现简单的解密器，尝试常见算法（如XOR、Base64），并通过动态分析或模式匹配来寻找密钥。

class ScriptDecryptor {
    decryptScript(encryptedData, encryptionType) {
        switch (encryptionType) {
            case 'xor':
return this.xorDecrypt(encryptedData, this.findXorKey());
            case 'base64':
return this.base64Decode(encryptedData);
            case 'custom':
return this.customDecrypt(encryptedData);
            default:
return encryptedData; // 可能未加密
        }
    }

    xorDecrypt(data, key) {
const decrypted = [];
for (let i = 0; i < data.length; i++) {
            decrypted.push(data[i] ^ key[i % key.length]);
        }
return Buffer.from(decrypted);
    }

    findXorKey() {
// 通过模式识别或动态分析查找XOR密钥
const commonPatterns = [
            [0x73, 0x63, 0x72, 0x69, 0x70, 0x74], // "script"
            [0x67, 0x61, 0x6D, 0x65],             // "game"
            [0x63, 0x6F, 0x63, 0x6F, 0x73]        // "cocos"
        ];

// 尝试常见密钥
for (const pattern of commonPatterns) {
if (this.testXorKey(pattern)) {
return pattern;
            }
        }

// 动态分析查找
return this.dynamicFindXorKey();
    }
}

5.3 性能与稳定性平衡

难点：Hook过多函数会严重影响游戏性能甚至导致崩溃，Hook太少则无法获取足够信息。
解决方案：引入智能Hook管理策略，包括设置Hook数量上限、采样率控制以及“延迟Hook”机制，只在需要时激活非关键函数的监控。

class PerformanceOptimizer {
    constructor() {
this.hookStats = {
            totalHooks: 0,
            activeHooks: 0,
            performanceImpact: 0
        };

this.config = {
            maxHooks: 200,
            samplingRate: 0.1, // 10%采样率
            enableLazyHook: true
        };
    }

    shouldHookFunction(funcName, importance) {
// 根据重要性决定是否Hook
if (importance >= 0.8) return true; // 高重要性函数

if (this.hookStats.totalHooks >= this.config.maxHooks) {
return false; // 达到Hook上限
        }

// 使用采样率控制Hook数量
if (Math.random() < this.config.samplingRate) {
return true;
        }

return false;
    }

    lazyHook(address, callbacks, options = {}) {
if (this.config.enableLazyHook && options.lazy) {
// 延迟Hook，只在需要时激活
return new LazyHook(address, callbacks);
        } else {
return Interceptor.attach(address, callbacks);
        }
    }
}

class LazyHook {
    constructor(address, callbacks) {
this.address = address;
this.callbacks = callbacks;
this.active = false;
this.interceptor = null;
    }

    activate() {
if (!this.active) {
this.interceptor = Interceptor.attach(this.address, this.callbacks);
this.active = true;
        }
    }

    deactivate() {
if (this.active && this.interceptor) {
this.interceptor.detach();
this.active = false;
        }
    }
}

六、实战应用场景

6.1 游戏逻辑分析

逆向工具可用于自动分析游戏的状态机、核心规则和业务流程，为自动化测试或外挂检测提供基础。

// 分析游戏状态机
class GameStateAnalyzer {
    analyzeStateMachine() {
const states = new Set();
const transitions = [];

// Hook状态切换函数
        Interceptor.attach(this.findFunction('changeGameState'), {
onEnter: function(args) {
const oldState = args[0];
const newState = args[1];

                states.add(oldState.toString());
                states.add(newState.toString());
                transitions.push({
from: oldState.toString(),
to: newState.toString(),
timestamp: Date.now()
                });
            }
        });

return {
states: Array.from(states),
transitions: transitions,
graph: this.generateStateGraph(transitions)
        };
    }
}

6.2 网络协议分析

通过Hook底层的 send 和 recv 等网络函数，可以截获并解析游戏客户端与服务器的通信协议，用于安全审计或协议还原。

class NetworkProtocolAnalyzer {
    analyzeNetworkProtocol() {
// Hook网络发送函数
        Interceptor.attach(Module.findExportByName(null, 'send'), {
            onEnter: function(args) {
const socket = args[0];
const buffer = args[1];
const length = args[2];

const data = Memory.readByteArray(buffer, length);
this.packet = {
                    type: 'send',
                    socket: socket,
                    data: data,
                    length: length,
                    timestamp: Date.now()
                };
            },
            onLeave: function(retval) {
this.analyzePacket(this.packet);
            }
        });

// Hook网络接收函数
        Interceptor.attach(Module.findExportByName(null, 'recv'), {
            onEnter: function(args) {
const socket = args[0];
const buffer = args[1];
const length = args[2];

this.socket = socket;
this.buffer = buffer;
this.length = length;
            },
            onLeave: function(retval) {
if (retval > 0) {
const data = Memory.readByteArray(this.buffer, retval);
const packet = {
                        type: 'recv',
                        socket: this.socket,
                        data: data,
                        length: retval,
                        timestamp: Date.now()
                    };
this.analyzePacket(packet);
                }
            }
        });
    }
}

七、安全防护建议

基于本次逆向经验，我们为使用Cocos2d-x的游戏开发者提供以下几点安全加固建议：

7.1 针对逆向分析的防护措施

1. 代码混淆：对JavaScript/Lua脚本进行变量名混淆、控制流扁平化、字符串加密和插入死代码，增加静态分析难度。
2. 反调试检测：在游戏中集成反调试逻辑，检测Frida、ptrace等调试工具的存在，并采取相应的反制措施（如退出游戏或触发垃圾数据）。
3. 运行时完整性校验：对关键代码段或函数进行哈希校验，防止内存被篡改或Hook。

7.2 数据加密建议

对客户端与服务器之间传输的敏感数据（如牌局状态、用户操作）使用强加密算法（如AES-GCM）进行保护，避免明文传输。

// 使用强加密保护敏感数据
class DataProtector {
    encryptGameData(data, key) {
// 使用AES-GCM加密
const iv = crypto.randomBytes(12);
const cipher = crypto.createCipheriv('aes-256-gcm', key, iv);

const encrypted = Buffer.concat([
            cipher.update(data),
            cipher.final()
        ]);

const authTag = cipher.getAuthTag();

return {
            iv: iv.toString('hex'),
            data: encrypted.toString('hex'),
            tag: authTag.toString('hex')
        };
    }
}

八、总结与展望

8.1 技术总结

本次实战构建了一套针对Cocos2d-x iOS游戏的完整逆向分析体系：

1. 工具链完备：涵盖了从动态插桩（Frida）到原生注入（Tweak）的完整工具链。
2. 深度解析：成功解析了基于JavaScriptCore的游戏脚本架构与数据流。
3. 稳定可用：通过多项性能与稳定性优化，使工具能够应对真实复杂的游戏环境。
4. 实战价值：所开发的工具和方法可直接应用于游戏安全评估、自动化测试、竞品分析等场景。

8.2 未来展望

1. AI辅助分析：探索利用机器学习模型自动识别游戏逻辑模式和关键函数。
2. 跨平台扩展：将工具链适配到Android平台以及其他游戏引擎（如Unity、Unreal）。
3. 协议自动化还原：结合网络流量分析，实现游戏通信协议的自动化逆向与文档生成。

8.3 开源计划

我们计划将本次实战中开发的核心工具进行开源，以促进移动游戏安全领域的技术交流，包括：

• cocos2dx_frida_toolkit.js：完整的Frida逆向分析工具包。
• CardRecorder：原生iOS Tweak的实现代码。
• 详细的配置文档和常见游戏的分析案例。

希望本文详实的Cocos2d-x逆向案例分析，能为从事移动安全、游戏开发或对底层技术感兴趣的开发者提供有价值的参考。技术的深入理解既可用于防御加固，也能推动整个生态向更安全、更健康的方向发展。欢迎在云栈社区交流更多技术细节与实践心得。

---

版权声明：本文涉及的技术细节仅用于安全学习与研究，请勿用于任何非法用途。任何商业使用需获得相关授权。