《安卓逆向这档事》第二十四课、Unidbg之补完环境我就睡(上)-Android安全-看雪安全社区

![|600](upload/attach/202509/905183_CNRFCMR7EMPDQBF.png)
# 一、课程目标
1.了解unidbg_trace，精准控制追踪，提升逆向分析效率  
2.配置 mcp 服务，利用AI辅助逆向，加速关键算法分析  
3.unidbg 之补 jni，模拟各类Java层调用

# 二、工具
1.教程Demo  
2.IDEA  
3.IDA  
4.Cursor  
# 三、课程内容

## 一.Unidbg_Trace
### 1.Trace 的分类

|**Trace 类型**|**描述**|
|---|---|
|**函数 Trace**|包括无差别的函数 Trace、导出函数 Trace、库函数 Trace、系统调用 Trace 等，用于分析算法执行流、应对 OLLVM 混淆与动态跳转。|
|**基本块 Trace**|也叫 Block Trace，用于控制流分析与反混淆。|
|**汇编 Trace**|包括指令级 Trace、特定指令 Trace 等，尤其适用于分析自定义算法、花指令；它也是最重要的 Trace 类型，基于它可实现其他类型 Trace。|
### 2.Unidbg Trace 的优劣

| **维度** | **表现** |
| -------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **易用性** | 必须掌握 Unidbg 的使用，但一旦会用，就能得到目标函数完整执行的 Trace。开启指令追踪十分简单，只需 `emulator.traceCode(begin, end)` 一句码。 对比：Frida Stalker、IDA Instruction trace 的启动更复杂。 |
| **效率** | 速度中等：测试环境下约可达 **40w 行执行流/分钟**（2400w/小时）。 简单样本约 10 分钟即可完成 Trace，中等样本则需 2 小时，复杂、混淆严重的样本可能长达 12 小时甚至更多。 与 **IDA trace** 相比快很多，但比 **Stalker** 等动态重编译方慢。 实际速度会因范围过滤等处理而折减至理论值的 1/4 或更低。 |
| **稳定性** | 稳定性好：基于 Unicorn，引发崩溃或异常 Trace 的情况较少。 对比：IDA Trace 容易中断或导致应用崩溃，Stalker 对某些指令支持有 Bug。 |
| **兼容性** | 支持 **ARM32** 与 **ARM64**。 比多数指令追踪方案（如 Stalker 不完全支持 ARM32）更全面。 相比 IDA Trace 对 X86、MIPS 等架构的支持仍有不足。 |
| **展示效果** | 信息维度丰富：包括时间、绝对地址、模块、相对偏移、机器码、汇编代码、执行前后寄存器变化等。 信息处理也很出色，细节优化多。 |
### 3.Trace实例

**1. 基础用法**
在调用目标函数前，只需简单地调用 `emulator.traceCode()` 即可开启对后续所有指令的追踪。
```java
// 在调用目标函数前开启指令追踪
emulator.traceCode();
boolean result = security.callStaticJniMethodBoolean(emulator, "check", "123456");
```
**2. 约束追踪范围**
通常我们只关心目标 SO 的执行流，而非 libc 等系统库的内部执行。`traceCode` 的重载方法 `traceCode(long begin, long end)` 允许我们精确设定追踪的内存地址范围。
```java
// 获取目标模块对象
Module module = dm.getModule();
// 仅追踪目标模块地址范围内的指令
emulator.traceCode(module.base, module.base + module.size); 
// 注意：第二个参数是结束地址，不是长度！这是一个常见误区。
```
**3. 精确控制追踪时机**
 * **追踪 JNI\_OnLoad**: 将 `traceCode` 放在 `dm.callJNI_OnLoad(emulator)` 之前。
 * **追踪初始化函数 (init\_array)**: `JNI_OnLoad` 之前还有初始化函数。要追踪它们，需要在加载模块的第一时间开启 Trace。最佳实践是使用 `ModuleListener`。
```java
memory.addModuleListener(new ModuleListener() {
 @Override
 public void onLoaded(Emulator<?> emulator, Module module) {
 // 当我们关心的模块被加载时，立即开启trace
 if("lib52pojie.so".equals(module.name)){
 emulator.traceCode(module.base, module.base + module.size);
 }
 }
});
// 这之后再加载模块
DalvikModule dm = vm.loadLibrary(new File("unidbg-android/src/test/java/com/zj/wuaipojie/util/lib52pojie.so"), true);
```
**4. 预估追踪耗时**
等待一个未知的 Trace 过程是痛苦的。我们可以通过一个轻量级的 `CodeHook` 快速统计指令总数，从而预估总耗时。这基本不含反汇编和寄存器打印的开销，所以速度极快。
```java
private long instructionCount = 0; // 用于指令计数
emulator.getBackend().hook_add_new(new CodeHook() { 
 @Override 
 public void hook(Backend backend, long address, int size, Object user) { 
 instructionCount++; 
 } 
 @Override 
 public void onAttach(UnHook unHook) {} 
 @Override 
 public void detach() {} 
}, module.base, module.base + module.size, null);
System.out.println("总共执行ARM指令数: " + test.instructionCount);
```
**PS:**：在较好的测试条件下，unidbg 每分钟约可追踪 40 万行执行流。你可以根据统计出的总行数来判断是泡杯咖啡等几分钟，还是需要去睡一觉等几个小时。
**5. 限定特定函数**
结合断点，可以实现对单个函数内部的精确追踪。
 * **场景一：只关心某次特定调用**
 在函数调用指令处下断点开启 Trace，在调用指令的下一条指令处下断点关闭 Trace。
```java
long callAddr = module.base + 0xE53C; // 假设这是BL指令的地址
final TraceHook[] traceHook = new TraceHook[1];
// 在调用处开启追踪
emulator.attach().addBreakPoint(callAddr, new BreakPointCallback() {
 @Override
 public boolean onHit(Emulator<?> emulator, long address) {
 traceHook[0] = emulator.traceCode(module.base, module.base + module.size);
 return true;
 }
});
// 在调用返回后关闭追踪
emulator.attach().addBreakPoint(callAddr + 4, new BreakPointCallback() {
 @Override
 public boolean onHit(Emulator<?> emulator, long address) {
 if (traceHook[0] != null) {
 traceHook[0].stopTrace();
 }
 return true;
 }
});
```

**6.函数调用追踪 (`debugger.traceFunctionCall`) 详解**
`traceFunctionCall` 是 unidbg 0.9.6 版本后新增的强大功能，用于追踪函数粒度的调用关系，对理清高层逻辑和对抗 OLLVM 等混淆有奇效。
**1. 基础用法**
它属于 `Debugger` 的一部分，使用时需要先 `attach()` 到模拟器。
```java
// 获取调试器实例
Debugger debugger = emulator.attach();
// 追踪目标模块内的所有函数调用
debugger.traceFunctionCall(module, new FunctionCallListener() {
 @Override
 public void onCall(Emulator<?> emulator, long callerAddress, long functionAddress) {
 // 函数调用前（相当于Frida onEnter）
 System.out.println("onCall: " + UnidbgPointer.pointer(emulator, callerAddress) + " -> " + UnidbgPointer.pointer(emulator, functionAddress));
 }
 @Override
 public void postCall(Emulator<?> emulator, long callerAddress, long functionAddress, Number[] args) {
 // 函数调用后（相当于Frida onLeave）
 // 注意：这里的args是寄存器R0-R7(x0-x7)的值，不完全等同于函数参数
 }
});
```
**2. 构建函数调用树**
通过获取栈回溯深度，我们可以格式化输出，形成一个清晰的函数调用树，这对于分析复杂的调用逻辑极其有用。 
首先修改一下源码，路径：unidbg-api\src\main\java\com\github\unidbg\unwind 
添加以下方法：
```java
/** 
 * 将给定的内存地址格式化为包含详细信息、可读的字符串。 
 * 这个方法会尝试解析地址，并提供尽可能多的上下文信息，如模块名、函数名（符号）、偏移量等。 
 * 
 * @param address 要格式化的绝对内存地址。 
 * @return 一个包含地址详细信息的格式化字符串。 
 */ 
public String formatAddressDetails(long address) { 
 // 1. 尝试根据地址查找其所属的模块（例如，一个 .so 文件）。 
 Module module = emulator.getMemory().findModuleByAddress(address); 
 
 // 2. 如果地址位于一个已加载的模块内： 
 if (module != null) { 
 // 2.1. 在模块中查找离该地址最近的符号（即函数或全局变量的名称）。 
 // `true` 参数表示也查找非导出的内部符号。 
 Symbol symbol = module.findClosestSymbolByAddress(address, true); 
 
 // 2.2. 如果找到了一个符号： 
 if (symbol != null) { 
 // 2.2.1. 创建一个 demangler 实例，用于将 C++ "mangled"（混淆）的符号名还原为可读的函数签名。 
 GccDemangler demangler = DemanglerFactory.createDemangler(); 
 // 2.2.2. 对符号名进行 demangle 操作。 
 String demangledName = demangler.demangle(symbol.getName()); 
 // 2.2.3. 计算当前地址相对于符号起始地址的偏移量。 
 long offset = address - symbol.getAddress(); 
 // 2.2.4. 返回最详细的格式化字符串，例如："[libnative.so] JNI_OnLoad + 0x10 (at 0x...)" 
 return String.format("[%s] %s + 0x%x (at 0x%x)", module.name, demangledName, offset, address); 
 } else { 
 // 2.3. 如果在模块内但没有找到具体的符号，则将其视为一个未命名的子程序（subroutine）。 
 // 计算地址相对于模块基地址的偏移量。 
 long offset = address - module.base; 
 // 2.3.1. 返回一个通用的子程序格式，例如："[libnative.so] sub_c80 (at 0x...)" 
 return String.format("[%s] sub_%x (at 0x%x)", module.name, offset, address); 
 } 
 } 
 
 // 3. 如果地址不属于任何模块，则尝试查找它是否位于一个已知的内存区域中（例如，栈或堆）。 
 MemRegion region = emulator.getSvcMemory().findRegion(address); 
 if (region != null) { 
 // 3.1. 如果找到了，返回区域名称，例如："[stack] (at 0x...)" 
 return String.format("[%s] (at 0x%x)", region.getName(), address); 
 } 
 
 // 4. 如果以上所有尝试都失败了，返回一个表示“未知”的通用格式。 
 return String.format("[unknown] (at 0x%x)", address); 
}

```
调用实例:
```java
Debugger debugger = emulator.attach(); 
System.out.println("函数调用关系追踪器已附加，结果将输出到日志文件。"); 
debugger.traceFunctionCall(null, new FunctionCallListener() { 
 private int depth = 0; 
 private String getPrefix(int currentDepth) { 
 if (currentDepth <= 0) { 
 return ""; 
 } 
 StringBuilder sb = new StringBuilder(); 
 for (int i = 0; i < currentDepth - 1; i++) { 
 sb.append("│ "); 
 } 
 sb.append("├─ "); 
 return sb.toString(); 
 } 
 @Override 
 public void onCall(Emulator<?> emulator, long callerAddress, long functionAddress) { 
 String prefix = getPrefix(depth + 1); 
 String details = emulator.getUnwinder().formatAddressDetails(functionAddress); 
 traceStream.printf("%sCALL -> %s%n", prefix, details); 
 depth++; 
 } 
 @Override 
 public void postCall(Emulator<?> emulator, long callerAddress, long functionAddress, Number[] args) { 
 depth--; 
 String prefix = getPrefix(depth + 1); 
 String details = emulator.getUnwinder().formatAddressDetails(functionAddress); 
 Backend backend = emulator.getBackend(); 
 Number retVal = emulator.is64Bit() ? backend.reg_read(Arm64Const.UC_ARM64_REG_X0) : backend.reg_read(ArmConst.UC_ARM_REG_R0); 
 long retValLong = retVal.longValue(); 
 // 尝试将返回值作为指针解析 
 String retValFormatted = String.format("0x%x", retValLong); 
 UnidbgPointer pointer = UnidbgPointer.pointer(emulator, retValLong); 
 if (pointer != null) { 
 String cstring = safeReadCString(pointer); 
 // 如果是一个可打印的字符串，则附加到日志中 
 if (isPrintable(cstring)) { 
 retValFormatted += String.format(" -> \"%s\"", cstring); 
 } 
 } 
 traceStream.printf("%sRET <- %s, ret=%s%n", prefix, details, retValFormatted); 
 } 
});
```

完整代码: 
```java
package com.example.ndkdemo; 
 
import com.github.unidbg.*; 
import com.github.unidbg.arm.backend.Backend; 
import com.github.unidbg.arm.backend.CodeHook; 
import com.github.unidbg.arm.backend.UnHook; 
import com.github.unidbg.arm.backend.Unicorn2Factory; 
import com.github.unidbg.arm.context.Arm64RegisterContext; 
import com.github.unidbg.debugger.BreakPointCallback; 
import com.github.unidbg.debugger.Debugger; 
import com.github.unidbg.debugger.FunctionCallListener; 
import com.github.unidbg.linux.android.AndroidEmulatorBuilder; 
import com.github.unidbg.linux.android.AndroidResolver; 
import com.github.unidbg.linux.android.dvm.DalvikModule; 
import com.github.unidbg.linux.android.dvm.DvmClass; 
import com.github.unidbg.linux.android.dvm.VM; 
import com.github.unidbg.memory.Memory; 
import com.github.unidbg.pointer.UnidbgPointer; 
import unicorn.Arm64Const; 
import unicorn.ArmConst; 
 
import java.io.*; 
 
public class MainActivity { 
 private final AndroidEmulator emulator; 
 private final VM vm; 
 private final Module module; 
 private final DvmClass security; 
 private final boolean logging; 
 private long instructionCount = 0; // 用于指令计数 
 
 MainActivity(boolean logging) { 
 this.logging = logging; 
 
 // 1. 创建模拟器实例 
 emulator = AndroidEmulatorBuilder.for64Bit() 
 .setProcessName("com.example.ndkdemo") 
 .addBackendFactory(new Unicorn2Factory(true)) 
 .build(); 
 
 // 2. 设置内存和系统库解析 
 final Memory memory = emulator.getMemory(); 
 memory.setLibraryResolver(new AndroidResolver(23)); 
 
 // 3. 创建Dalvik虚拟机并加载SO文件 
 vm = emulator.createDalvikVM(); 
 vm.setVerbose(logging); 
 DalvikModule dm = vm.loadLibrary(new File("unidbg-android/src/test/java/com/zj/wuaipojie/util/libndkdemo.so"), false); 
 dm.callJNI_OnLoad(emulator); 
 module = dm.getModule(); 
 
 // 4. 获取DVM类 
 security = vm.resolveClass("com/example/ndkdemo/MainActivity"); 
 
 // 5. 设置指令计数钩子 (可选) 
 emulator.getBackend().hook_add_new(new CodeHook() { 
 @Override 
 public void hook(Backend backend, long address, int size, Object user) { 
 instructionCount++; 
 } 
 @Override 
 public void onAttach(UnHook unHook) {} 
 @Override 
 public void detach() {} 
 }, module.base, module.base + module.size, null); 
 
 
 // 6.设置函数追踪与x0寄存器检查 
 attachTraceAndInspectX0(module.base + 0x15F8); 
 } 
 
 /** 
 * 【模块化功能】: 附加一个函数调用追踪器 (traceFunctionCall)。 
 * 此功能会监听所有的函数调用，并以树状结构打印出调用关系。 
 * @param traceStream 日志输出流 
 */ 
 public void attachFunctionCallTracer(final PrintStream traceStream) { 
 Debugger debugger = emulator.attach(); 
 System.out.println("函数调用关系追踪器已附加，结果将输出到日志文件。"); 
 
 debugger.traceFunctionCall(null, new FunctionCallListener() { 
 private int depth = 0; 
 
 private String getPrefix(int currentDepth) { 
 if (currentDepth <= 0) { 
 return ""; 
 } 
 StringBuilder sb = new StringBuilder(); 
 for (int i = 0; i < currentDepth - 1; i++) { 
 sb.append("│ "); 
 } 
 sb.append("├─ "); 
 return sb.toString(); 
 } 
 
 @Override 
 public void onCall(Emulator<?> emulator, long callerAddress, long functionAddress) { 
 String prefix = getPrefix(depth + 1); 
 String details = emulator.getUnwinder().formatAddressDetails(functionAddress); 
 traceStream.printf("%sCALL -> %s%n", prefix, details); 
 depth++; 
 } 
 
 @Override 
 public void postCall(Emulator<?> emulator, long callerAddress, long functionAddress, Number[] args) { 
 depth--; 
 String prefix = getPrefix(depth + 1); 
 String details = emulator.getUnwinder().formatAddressDetails(functionAddress); 
 
 Backend backend = emulator.getBackend(); 
 Number retVal = emulator.is64Bit() ? backend.reg_read(Arm64Const.UC_ARM64_REG_X0) : backend.reg_read(ArmConst.UC_ARM_REG_R0); 
 long retValLong = retVal.longValue(); 
 
 // 尝试将返回值作为指针解析 
 String retValFormatted = String.format("0x%x", retValLong); 
 UnidbgPointer pointer = UnidbgPointer.pointer(emulator, retValLong); 
 if (pointer != null) { 
 String cstring = safeReadCString(pointer); 
 // 如果是一个可打印的字符串，则附加到日志中 
 if (isPrintable(cstring)) { 
 retValFormatted += String.format(" -> \"%s\"", cstring); 
 } 
 } 
 
 traceStream.printf("%sRET <- %s, ret=%s%n", prefix, details, retValFormatted); 
 } 
 }); 
 } 
 
 /** 
 * 在指定地址设置断点，实现对一个函数调用的追踪，并在函数返回后检查 x0 寄存器的内容。 
 * 
 * @param callAddress 函数调用指令（例如 BL, B）的绝对地址 
 */ 
 private void attachTraceAndInspectX0(long callAddress) { 
 final TraceHook[] traceHook = new TraceHook[1]; 
 
 emulator.attach().addBreakPoint(callAddress, (emu, address) -> { 
 traceHook[0] = emu.traceCode(module.base, module.base + module.size); 
 return true; 
 }); 
 
 long returnAddress = callAddress + 4; 
 emulator.attach().addBreakPoint(returnAddress, new BreakPointCallback() { 
 @Override 
 public boolean onHit(Emulator<?> emu, long address) { 
 if (traceHook[0] != null) { 
 traceHook[0].stopTrace(); 
 System.out.println(); 
 } 
 
 Arm64RegisterContext ctx = emu.getContext(); 
 long x0 = ctx.getXLong(0); 
 System.out.printf("[+] 检查地址: 0x%x, x0寄存器值: 0x%x\n", address, x0); 
 
 UnidbgPointer pointer = UnidbgPointer.pointer(emu, x0); 
 if (pointer == null) { 
 System.out.println("[-] x0的值不是一个有效的指针或指向未映射的内存"); 
 return true; 
 } 
 
 String cstring = safeReadCString(pointer); 
 if (cstring != null && isPrintable(cstring)) { 
 System.out.println("[+] x0指向的字符串: " + cstring); 
 } else { 
 System.out.println("[-] x0指向的内容不是一个可打印的字符串"); 
 } 
 
 int dumpSize = 256; 
 byte[] data = pointer.getByteArray(0, dumpSize); 
 System.out.println("[+] x0指向内存的HexDump (前" + dumpSize + "字节):"); 
 System.out.println(prettyHexDump(data, x0)); 
 System.out.println("--- x0寄存器检查结束 ---\n"); 
 
 return true; 
 } 
 }); 
 } 
 
 private static String safeReadCString(UnidbgPointer p) { 
 try { 
 return p.getString(0); 
 } catch (Exception e) { 
 return null; 
 } 
 } 
 
 private static boolean isPrintable(String s) { 
 if (s == null || s.isEmpty()) { 
 return false; 
 } 
 int printableChars = 0; 
 for (int i = 0; i < s.length(); i++) { 
 char c = s.charAt(i); 
 if ((c >= 32 && c <= 126) || Character.isWhitespace(c)) { 
 printableChars++; 
 } 
 } 
 return s.length() >= 2 && (double) printableChars / s.length() > 0.8; 
 } 
 
 private static String prettyHexDump(byte[] data, long baseAddr) { 
 StringBuilder sb = new StringBuilder(); 
 for (int i = 0; i < data.length; i += 16) { 
 sb.append(String.format("%016x: ", baseAddr + i)); 
 StringBuilder hexPart = new StringBuilder(); 
 StringBuilder asciiPart = new StringBuilder(); 
 for (int j = 0; j < 16; j++) { 
 if (i + j < data.length) { 
 byte b = data[i + j]; 
 hexPart.append(String.format("%02x ", b)); 
 char c = (b >= 32 && b <= 126) ? (char) b : '.'; 
 asciiPart.append(c); 
 } else { 
 hexPart.append(" "); 
 } 
 if (j == 7) { 
 hexPart.append(" "); 
 } 
 } 
 sb.append(hexPart).append(" |").append(asciiPart).append("|\n"); 
 } 
 return sb.toString(); 
 } 
 
 private void crack() { 
 emulator.traceCode(); 
 boolean result = security.callStaticJniMethodBoolean(emulator, "check", "1234567"); 
 System.out.println("函数调用结束，返回结果: " + result); 
 } 
 
 void destroy() { 
 try { 
 emulator.close(); 
 if (logging) { 
 System.out.println("模拟器已成功关闭"); 
 } 
 } catch (IOException e) { 
 e.printStackTrace(); 
 } 
 } 
 
 public static void main(String[] args) { 
 MainActivity test = new MainActivity(false); 
 String traceFile = "unidbg-android/src/test/resources/traceFunctions.txt"; 
 try (PrintStream traceStream = new PrintStream(new FileOutputStream(traceFile), true)) { 
 // 在调用 crack 之前附加追踪器，持久化日志 
 test.attachFunctionCallTracer(traceStream); 
 // 执行会触发函数调用的模拟代码 
 test.crack(); 
 } catch (IOException e) { 
 e.printStackTrace(); 
 } finally { 
 // 确保模拟器资源被释放 
 test.destroy(); 
 System.out.println("总共执行ARM指令数: " + test.instructionCount); 
 } 
 } 
}
```

## 二. Mcp 配置  
`MCP概念:`  
MCP（Model Context Protocol，模型上下文协议）是什么？  
**MCP是一种标准化协议，旨在为人工智能模型（如大语言模型）与外部工具、数据源之间的交互提供统一接口。(为 AI 装上了手脚)**
MCP是AI智能体与外部工具的"USB接口"，定义了AI模型与外部工具（如API、数据库、文档编辑器等）的交互标准，开发者无需为每个工具单独开发适配代码。  
MCP协议旨在实现大型语言模型（LLM）与外部数据源和工具之间的无缝集成，通过提供标准化的接口，使AI应用程序能够安全、可控地与本地或远程资源进行交互。  
![image.png](upload/attach/202509/905183_RDH4PA9XVXC8PN2.png)

<a href="elink@4b0K9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6Y4K9i4c8Z5N6h3u0Q4x3X3g2U0L8$3#2Q4x3V1k6E0M7X3g2^5L8$3c8A6j5g2)9J5c8X3W2V1j5g2)9J5k6s2m8J5L8#2)9J5k6r3#2U0M7l9`.`.">项目地址</a> 
要求: 
1.IDA Pro 8.3 以上，最好是 9 
2.python3.11 或更高版本，使用`idapyswitch`切换到Python 版本 
3.支持 Mcp 的客户端，这里以 Cursor 为例

`环境配置:`
```
pip install git+https://github.com/mrexodia/ida-pro-mcp
```
Ps: 如果你现有的 python 版本低于十一，可以单独下载一个版本然后安装到 ida 的目录下  
![image.png](upload/attach/202509/905183_MDDFMZR3MGQUMWA.png)
接着打开 `idapyswitch` 切换 3.11 的版本  
![image.png](upload/attach/202509/905183_A2A3BX3AG466X2N.png)
然后 cmd 窗口打开新安装的 python.exe 再运行 pip 命令  
```
D:\IDA\IDA9.0\python311\python.exe -m pip install --upgrade git+https://github.com/mrexodia/ida-pro-mcp
```
接下来，再运行命令：
```
ida-pro-mcp --install
```
这步如果报错，可以打开 11 版本 python 目录下的 Scripts 文件夹，找到 ida-pro-mcp.exe
Cmd 窗口运行：  
```
这里需要你自己拖动exe文件到cmd窗口
D:\IDA\IDA9.0\python311\Scripts\ida-pro-mcp.exe --install
```
最后运行：  
```
ida-pro-mcp --config
报错则运行下面这个:
D:\IDA\IDA9.0\python311\Scripts\ida-pro-mcp.exe --config
```
![image.png](upload/attach/202509/905183_5DN7E39HUE7GN96.png)
接下来打开 cursor，发现 ida_pro_mcp 已经亮绿灯了，说明 mcp 服务正常了。如果没有你就复制 ida-pro-mcp --config 输出的那串 json 到 mcp.json  
![image.png](upload/attach/202509/905183_3566DK5BUEQ9EFM.png)
![image.png](upload/attach/202509/905183_X2J7DTZTWTSNQ7X.png)
最后在 IDA 中将 server 端开启即可。
![image.png](upload/attach/202509/905183_2NXDKKDFHA2P65J.png)

## 三.Unidbg补环境
`定义:`  
“Unidbg 补环境”是指在使用 Unidbg 模拟执行 Android 原生 (Native) 代码时，为了使程序能够正常运行并获得与真实设备一致的结果，对 Unidbg 模拟器**环境中的缺失或不完善部分进行补充和调整**的过程

### 一. 补 Jni 环境

#### 一、 JNI 补环境的核心概念
JNI (Java Native Interface) 补环境是 Unidbg 应用中的核心环节。当 Unidbg 模拟执行的原生库（. So 文件）尝试通过 JNI 调用 Java 层的代码时，Unidbg 必须能够提供这些 Java 方法的模拟实现。如果 Unidbg 缺少某个方法的实现，或者默认实现不符合预期，程序就会抛出 `UnsupportedOperationException` 异常，导致模拟中断。因此，JNI 补环境的目的就是拦截这些 JNI 调用，并提供一个符合目标 SO 文件逻辑预期的返回值或行为，从而“欺骗”SO 文件，使其认为自己运行在真实的 Android 环境中。(本质就是缺啥补啥)
#### 二、 Java 层函数补全：继承 `AbstractJni`
这是最主要的 Java 层补环境方式。通过创建一个继承自`com.github.unidbg.linux.android.dvm.AbstractJni` 的自定义类，并重写其关键方法，可以模拟任意 JNI 调用。
**具体步骤：**
1. **extends AbstractJni**：
 ```java
 public class ChallengeTenUnidbg extends AbstractJni {
 }
 ```
2. **关联 Jni 类与虚拟机 (VM)** ：
 - 在创建了 `DalvikVM` 实例后，将 AbstractJni的实例设置给它。
 - **强烈建议开启详细日志** (`vm.setVerbose(true)`)，这会在控制台打印出所有 JNI 调用的详细信息（包括方法签名），是定位哪个方法需要补全的关键。
 ```java
 VM vm = emulator.createDalvikVM();
 vm.setJni(this); 
 vm.setVerbose(true); // 开启详细日志
 ```
3. **重写关键方法以拦截 JNI 调用**：
 - 根据 SO 文件调用的 Java 方法类型（静态/实例、返回类型），重写 `AbstractJni` 中对应的方法。
 - **方法命名规律**：`call[Static]XXXMethodV`，其中 `Static` 表示静态方法，`XXX` 表示返回类型（如 `Object`, `Boolean`, `Int`, `Void` 等）。
 - **核心参数**：
 - `signature`: 完整的方法签名字符串，如 `"com/example/MyClass->getAppContext()Landroid/content/Context;"`，用于 `switch` 或 `if` 判断具体是哪个方法被调用。
 - `vaList`: 包含了调用时传递的所有参数。
 
| JNI 原型 | `AbstractJni` 覆写方法 | 典型用途 |
| --------------------------------- | ---------------------------------- | ----------------------------- |
| `jobject CallStaticObjectMethodV` | `callStaticObjectMethodV` | 返回 `Context`, `Application` 等 |
| `jint CallIntMethodV` | `callIntMethodV` | 返回版本号、随机数 |
| `jobject NewObjectV` | `newObjectV` | 构造 `ZipFile`, `Cipher` |
| `void Set<Object>Field` | `setObjectField` 等 | SO 写回 Java 字段 |
| `jint RegisterNatives` | `invokeRegisterNatives` | 动态注册补环境 |
| `jint NewGlobalRef` | `newGlobalRef` / `deleteGlobalRef` | 线程间对象共享 |

4. **方法实现示例**：

- **模拟静态方法 (`callStaticObjectMethodV`)** ：
 ```java
 @Override
 public DvmObject<?> callStaticObjectMethodV(BaseVM vm, DvmClass dvmClass, String signature, VaList vaList) {
 switch (signature) {
 case "com/example/MyClass->getAppContext()Landroid/content/Context;":
 // 返回一个模拟的 Context 对象
 return vm.resolveClass("android/content/Context").newObject(null);
 // 可以添加更多 case 来处理其他需要补全的 Java 方法
 default:
 // 对于未处理的方法，务必调用父类的默认实现
 return super.callStaticObjectMethodV(vm, dvmClass, signature, vaList);
 }
 }
 ```
 - **模拟构造方法 (`newObjectV`)** ：
 ```java
 @Override 
public DvmObject<?> newObjectV(BaseVM vm, DvmClass dvmClass, String signature, VaList vaList) { 
 switch (signature) { 
 case "java/util/HashMap-><init>()V": { 
 return ProxyDvmObject.createObject(vm, new HashMap<>()); 
 } 
 
 case "com/zj/wuaipojie/ui/ChallengeTen$UserInfo-><init>(Ljava/lang/String;Ljava/lang/String;JLjava/lang/String;Lcom/zj/wuaipojie/ui/ChallengeTen$AccountStatus;Ljava/util/Map;)V": { 
 System.out.println("【补环境 Level 3】拦截到 UserInfo 构造方法"); 
 Map<String, DvmObject<?>> userInfoData = new HashMap<>(); 
 userInfoData.put("status", vaList.getObjectArg(4)); 
 userInfoData.put("properties", vaList.getObjectArg(5)); 
 return dvmClass.newObject(userInfoData); 
 } 
 } 
 return super.newObjectV(vm, dvmClass, signature, vaList); 
}
 ```
 - **模拟字段访问 (`Get/Set<Type>Field`)** ：
```java
@Override 
public DvmObject<?> getStaticObjectField(BaseVM vm, DvmClass dvmClass, String signature) { 
 // 匹配枚举类的 PREMIUM 静态字段 
 if ("com/zj/wuaipojie/ui/ChallengeTen$AccountStatus->PREMIUM:Lcom/zj/wuaipojie/ui/ChallengeTen$AccountStatus;".equals(signature)) { 
 System.out.println("【补环境】拦截到获取 AccountStatus.PREMIUM 静态字段"); 
 // 创建一个枚举实例（用字符串"PREMIUM"作为其值，方便后续name()方法返回正确结果） 
 DvmObject<?> premium = dvmClass.newObject("PREMIUM"); 
 return premium; 
 } 
 return super.getStaticObjectField(vm, dvmClass, signature); 
}

@Override
public void setIntField(BaseVM vm, DvmObject<?> dvmObject, String signature, int value) {
 // signature的格式是：com/example/User->age:I
 if ("com/example/User->age:I".equals(signature)) {
 System.out.println("SO 正在设置 User 对象的 age 字段，值为: " + value);
 // 你可以在这里记录值，或者什么都不做
 return; // 注意set方法是void返回
 }
 super.setIntField(vm, dvmObject, signature, value);
}
```
5. **处理不同类型的对象**：
 - **Android 特有类** (如 `Context`, `Application`): 使用 `vm.resolveClass(className).newObject(value)` 创建模拟对象。
 - **JDK 标准库类** (如 `HashMap`): 使用 `ProxyDvmObject.createObject(vm, realJavaObject)` 来包装一个真实的 Java 对象进行模拟。这在处理集合类（如 `Map`）时非常有用。
	- 对于 JNI 来说，继承和多态是非常重要的概念。当 Native 代码通过一个父类或接口的引用来调用子类实例的方法时（例如通过 `Map` 引用调用 `HashMap` 实例的 `put` 方法），JNI 的运行时必须能够顺着继承链向上查找，才能找到正确的方法定义和 ID。

#### 三、处理复杂 JNI 数据结构
处理复杂的数据结构（如结构体、数组）是 JNI 补环境的难点和重点。
**1. 数组 `byte[]`、`String[]`、 `int[]`**
- 在加密、解密等协议分析场景中非常常见。
- Unidbg 的 `DvmObject` 和 `ArrayObject` 类可以帮助在 Java 的数组 和 Native 层的内存指针之间进行转换。
```java
@Override
public DvmObject<?> callStaticObjectMethodV(BaseVM vm, DvmClass dvmClass, String signature, VaList vaList) {
 if ("com/example/Utils->getSignKeys()[Ljava/lang/String;".equals(signature)) {
 // 伪造的Key列表
 StringObject key1 = new StringObject(vm, "key_alpha");
 StringObject key2 = new StringObject(vm, "key_beta");
 // 创建一个包含这些DvmObject的ArrayObject
 return new ArrayObject(key1, key2);
 }
 return super.callStaticObjectMethodV(vm, dvmClass, signature, vaList);
}
```
**2.结构体 (Struct)**
- **通过 `jobject` 传递**：如果 Java 层有一个类与 C/C++ 结构体对应，Native 代码会通过 JNI 的 `Get/Set<Type>Field` 系列函数访问字段。在 Unidbg 中，需要模拟这些 JNI 调用，使用`DvmObject` 提供的 `setValue` 和 `getValue` 方法来操作模拟对象的字段。
- **通过指针传递**：Native 函数有时直接接收或返回一个指向结构体内存的指针（通常是 `long` 类型）。
 - **补全逻辑**：
 1. 使用`emulator.getMemory().malloc(size, true)` 在 Unidbg 的模拟内存中分配空间。
 2. 使用返回的`UnidbgPointer` 对象，通过 `pointer.setInt(offset, value)`、`pointer.setString(offset, value)` 等方法填充结构体的各个成员。
 3. 将这个指针的地址（一个`long` 值）返回给调用方。
**3.`Map` 等集合对象**
- 在 JNI 调用时，可以通过`ProxyDvmObject.createObject(vm, realJavaMap)` 将一个真实的 Java `HashMap` 对象包装成 `DvmObject` 传给 Native 层 。
- 当 Native 代码通过 JNI 调用`Map.get`、`Map.keySet` 等方法时，Unidbg 会拦截到这些调用。你需要在自定义的 `AbstractJni` 子类中实现这些方法的逻辑，直接操作那个真实的 `realJavaMap` 对象来返回正确的值。

# 四. 小结  
在本次课程中，我们系统性地学习了 Unidbg 逆向分析中的两项核心技术和 mcp 的配置与辅助分析：
1. **`unidbg_trace` 精准追踪技术**：我们掌握了如何运用指令与函数追踪，对目标算法的执行流程进行深度分析，从而有效应对代码混淆与动态跳转等复杂场景。
2. **MCP 服务与 AI 辅助分析**：通过配置 MCP 服务，我们实现了逆向工具与人工智能模型的联动。这项技术代表了逆向工程领域的发展方向，能够显著加速对复杂算法的理解与重构，从而提升分析效率。
3. **Unidbg 的 JNI 环境补全**：我们深入探讨了 JNI 补环境的原理与实践，掌握了通过继承 `AbstractJni` 模拟 Java 层调用的关键方法。这是确保原生库在 Unidbg 中稳定运行的技术基础，也是高级应用场景中必须具备的核心能力。

本节完整代码：

```
package com.zj.wuaipojie.util;

import com.github.unidbg.AndroidEmulator;
import com.github.unidbg.Module;
import com.github.unidbg.linux.android.AndroidEmulatorBuilder;
import com.github.unidbg.linux.android.AndroidResolver;
import com.github.unidbg.linux.android.dvm.*;
import com.github.unidbg.linux.android.dvm.jni.ProxyDvmObject;
import com.github.unidbg.memory.Memory;

import java.io.File;
import java.io.FileNotFoundException;
import java.util.HashMap;
import java.util.Map;

import com.github.unidbg.linux.android.dvm.DvmClass;
import com.github.unidbg.linux.android.dvm.DvmObject;

public class ChallengeTenOne extends AbstractJni {

private final AndroidEmulator emulator;
    private final VM vm;
    private final Module module;

public ChallengeTenOne() {
        emulator = AndroidEmulatorBuilder.for64Bit().build();
        final Memory memory = emulator.getMemory();
        memory.setLibraryResolver(new AndroidResolver(23));
        vm = emulator.createDalvikVM();
        vm.setJni(this);
        vm.setVerbose(true);

File soFile = new File("unidbg-android/src/test/java/com/zj/wuaipojie/util/lib52pojie.so");
        DalvikModule dm = vm.loadLibrary(soFile, true);
        module = dm.getModule();
        dm.callJNI_OnLoad(emulator);
    }

public void callUnidbgLevel1() {
 System.out.println("====== 开始执行 unidbg_level1 函数 ======");
 DvmClass securityUtilClass = vm.resolveClass("com/zj/wuaipojie/util/SecurityUtil");
 DvmObject<?> configObject = vm.resolveClass("com/zj/wuaipojie/util/SecurityUtil$Config").newObject(null);
 //注册Map和HashMap，并声明二者的关系
 DvmClass mapClass=vm.resolveClass("java/util/Map");
 DvmClass hashMapClass= vm.resolveClass("java/util/HashMap",mapClass);
 StringObject result = securityUtilClass.callStaticJniMethodObject(emulator,
 "unidbg_level1(Lcom/zj/wuaipojie/util/SecurityUtil$Config;)Ljava/lang/String;",
 configObject);
 System.out.println("====== 函数执行完毕 ======");
 System.out.println("JNI 函数返回结果: " + result);

}

public static void main(String[] args) throws FileNotFoundException {
        ChallengeTenOne challenge = new ChallengeTenOne();
        challenge.callUnidbgLevel1();
    }

/**
 * 拦截静态方法调用 (对应 C++ 关卡 1)
 */
 @Override
 public DvmObject<?> callStaticObjectMethodV(BaseVM vm, DvmClass dvmClass, String signature, VaList vaList) {
 if ("com/zj/wuaipojie/ui/ChallengeTen->getLevel1Key()Ljava/lang/String;".equals(signature)) {
 System.out.println("【补环境 Level 1】拦截到静态方法调用: " + signature);
 // C++ 代码期望得到 "InitialKey_From_Kotlin"
 return new StringObject(vm, "InitialKey_From_Kotlin");
 }
 return super.callStaticObjectMethodV(vm, dvmClass, signature, vaList);
 }

/**
 * 拦截实例字段读取 (对应 C++ 关卡 2 和 4)
 */
 @Override
 public DvmObject<?> getObjectField(BaseVM vm, DvmObject<?> dvmObject, String signature) {
 switch (signature) {
 case "com/zj/wuaipojie/util/SecurityUtil$Config->deviceId:Ljava/lang/String;": {
 System.out.println("【补环境 Level 2】拦截到获取实例字段: " + signature);
 // C++ 代码期望得到 "unidbg_patched_device"
 return new StringObject(vm, "unidbg_patched_device");
 }
 // 将 UserInfo 的字段处理逻辑合并，使其更优雅和可扩展
 case "com/zj/wuaipojie/ui/ChallengeTen$UserInfo->status:Lcom/zj/wuaipojie/ui/ChallengeTen$AccountStatus;":
 case "com/zj/wuaipojie/ui/ChallengeTen$UserInfo->properties:Ljava/util/Map;": {
 // 这是我们为 UserInfo 对象设计的核心：从其后端存储 (一个Map) 中获取字段
 Map<String, DvmObject<?>> userInfoData = (Map<String, DvmObject<?>>) dvmObject.getValue();

// 从签名中动态解析字段名 ("status" 或 "properties")
                String fieldName = signature.substring(signature.indexOf("->") + 2, signature.indexOf(":"));
                System.out.println("【补环境 Level 4】获取 UserInfo." + fieldName + " 字段 (从内部Map中)");

return userInfoData.get(fieldName);
            }
        }
        return super.getObjectField(vm, dvmObject, signature);
    }

/**
 * 拦截静态对象字段获取（对应 C++ 中获取 AccountStatus.PREMIUM 枚举实例）
 */
 @Override
 public DvmObject<?> getStaticObjectField(BaseVM vm, DvmClass dvmClass, String signature) {
 // 匹配枚举类的 PREMIUM 静态字段
 if ("com/zj/wuaipojie/ui/ChallengeTen$AccountStatus->PREMIUM:Lcom/zj/wuaipojie/ui/ChallengeTen$AccountStatus;".equals(signature)) {
 System.out.println("【补环境】拦截到获取 AccountStatus.PREMIUM 静态字段");
 // 创建一个枚举实例（用字符串"PREMIUM"作为其值，方便后续name()方法返回正确结果）
 DvmObject<?> premium = dvmClass.newObject("PREMIUM");
 return premium;
 }
 return super.getStaticObjectField(vm, dvmClass, signature);
 }

/**
 * 拦截对象创建 (对应 C++ 关卡 3 中 new HashMap 和 new UserInfo)
 */
 @Override
 public DvmObject<?> newObjectV(BaseVM vm, DvmClass dvmClass, String signature, VaList vaList) {
 switch (signature) {
 case "java/util/HashMap-><init>()V": {
 return ProxyDvmObject.createObject(vm, new HashMap<>());
 }

case "com/zj/wuaipojie/ui/ChallengeTen$UserInfo-><init>(Ljava/lang/String;Ljava/lang/String;JLjava/lang/String;Lcom/zj/wuaipojie/ui/ChallengeTen$AccountStatus;Ljava/util/Map;)V": {
 System.out.println("【补环境 Level 3】拦截到 UserInfo 构造方法");
 Map<String, DvmObject<?>> userInfoData = new HashMap<>();
 userInfoData.put("status", vaList.getObjectArg(4));
 userInfoData.put("properties", vaList.getObjectArg(5));
 return dvmClass.newObject(userInfoData);
 }
 }
 return super.newObjectV(vm, dvmClass, signature, vaList);
 }

/**
 * 拦截实例方法调用 (对应 C++ 关卡 3 和 4 中 map.put/get 和 status.name)
 */
 @Override
 public DvmObject<?> callObjectMethodV(BaseVM vm, DvmObject<?> dvmObject, String signature, VaList vaList) {

switch (signature) {
            // 处理自定义Map的put方法
            case "java/util/Map->put(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;":{
                Map map = (Map) dvmObject.getValue();
                Object key = vaList.getObjectArg(0).getValue();
                Object value = vaList.getObjectArg(1).getValue();
                return ProxyDvmObject.createObject(vm, map.put(key, value));
            }

case "java/util/Map->get(Ljava/lang/Object;)Ljava/lang/Object;": {
                Map map = (Map) dvmObject.getValue();
                Object key = vaList.getObjectArg(0).getValue();
                Object val = map.get(key);
                return ProxyDvmObject.createObject(vm, val);
            }

// 处理 AccountStatus.name()
            case "com/zj/wuaipojie/ui/ChallengeTen$AccountStatus->name()Ljava/lang/String;": {
                System.out.println("【补环境 Level 4】拦截到 AccountStatus.name() 调用");
                return new StringObject(vm, dvmObject.getValue().toString());
            }
        }
        return super.callObjectMethodV(vm, dvmObject, signature, vaList);
    }

}

```

# 六、视频及课件地址

<a href="elink@80bK9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6H3j5h3&6Q4x3X3g2T1j5h3W2V1N6g2)9J5k6h3y4G2L8g2)9J5c8Y4y4Q4x3V1j5I4j5@1k6i4g2p5I4F1x3e0c8B7k6g2N6X3M7q4S2^5L8s2R3K6M7%4W2k6N6#2)9K6c8Y4m8%4k6q4)9K6c8r3&6I4N6e0V1`.">百度云</a>
<a href="elink@975K9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6%4N6%4N6Q4x3X3g2S2L8r3W2&6N6h3&6V1M7X3W2$3k6g2)9J5k6h3y4G2L8g2)9J5c8Y4y4Q4x3V1k6f1d9X3!0w2e0f1D9$3k6s2f1$3P5l9`.`.">阿里云</a>
<a href="elink@1fbK9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6%4N6%4N6Q4x3X3g2T1K9h3I4A6j5X3W2D9K9g2)9J5k6h3y4G2L8g2)9J5c8Y4k6A6k6r3g2G2i4K6u0r3b7W2j5I4N6#2b7@1x3e0q4z5y4%4y4h3i4K6u0r3i4K6y4r3M7%4m8E0i4K6g2X3K9h3c8Q4y4h3k6X3M7X3!0E0i4K6y4p5x3K6x3K6i4K6u0W2y4K6R3^5i4K6t1$3N6X3c8Q4y4h3k6K6L8%4g2J5j5$3g2Q4x3@1b7$3k6r3c8W2x3e0k6V1j5K6j5@1y4K6W2X3x3o6l9$3z5e0c8T1j5h3q4X3y4K6y4S2x3U0t1J5y4e0b7#2x3R3`.`.">哔哩哔哩</a>
<a href="elink@8efK9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6Y4K9i4c8Z5N6h3u0Q4x3X3g2U0L8$3#2Q4x3V1k6K9d9U0f1&6y4g2)9J5c8V1q4F1k6s2u0G2K9h3c8d9k6i4k6W2M7Y4y4W2">教程开源地址</a>
PS:解压密码都是52pj，阿里云由于不能分享压缩包，所以下载exe文件，双击自解压

# 八、参考文档
<a href="elink@237K9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6T1L8r3!0Y4i4K6u0W2j5%4y4V1L8W2)9J5k6h3&6W2N6q4)9J5c8Y4q4I4i4K6g2X3x3K6R3^5y4e0p5#2x3K6k6Q4x3V1k6U0j5i4c8W2k6$3!0J5P5g2)9#2k6U0p5I4x3e0l9J5y4o6l9@1i4K6u0W2K9s2c8E0L8l9`.`.">白龙unidbg教程</a>

回复或点赞可查看完整内容

冰与火的战歌：Windows内核攻防实战高级班！从零到实战，融合AI与Windows内核攻防全技术栈，打造具备自动化能力的内核开发高手。

#逆向分析 #NDK分析 #混淆加固 #源码框架

最新回复 (58) 1 2 3 ▶
我不是卷王雪币： 547 能力值： ( LV1，RANK：0 ) 在线值：发帖 5 回帖 123 粉丝 36 关注私信	我不是卷王 2 楼 666 膜拜大佬 2025-9-8 09:55 0
mb_elqwyvnm 雪币： 2742 活跃值： (3475) 能力值： ( LV2，RANK：10 ) 在线值：发帖 0 回帖 170 粉丝 0 关注私信	mb_elqwyvnm 3 楼学习新知识 2025-9-8 09:56 0
Ram98 雪币： 282 活跃值： (1641) 能力值： ( LV2，RANK：10 ) 在线值：发帖 0 回帖 73 粉丝 1 关注私信	Ram98 4 楼 666 2025-9-8 09:57 0
TreeHole 雪币： 18 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 5 粉丝 0 关注私信	TreeHole 5 楼学习学习 2025-9-8 10:06 0
mb_qimctavn 雪币： 5327 活跃值： (6780) 能力值： ( LV2，RANK：10 ) 在线值：发帖 0 回帖 401 粉丝 1 关注私信	mb_qimctavn 6 楼 6 2025-9-8 10:12 0
Snowman_Liam 雪币： 2 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 142 粉丝 1 关注私信	Snowman_Liam 7 楼 6666 2025-9-8 10:34 0
method 雪币： 1972 活跃值： (8178) 能力值： ( LV5，RANK：70 ) 在线值：发帖 13 回帖 268 粉丝 134 关注私信	method 1 8 楼 1 2025-9-8 11:14 0
铭天星雪币： 387 活跃值： (1876) 能力值： ( LV3，RANK：20 ) 在线值：发帖 4 回帖 98 粉丝 22 关注私信	铭天星 9 楼 2025-9-8 17:02 0
baitongling 雪币： 200 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 52 粉丝 0 关注私信	baitongling 10 楼 666 2025-9-8 18:14 0
XCicada 雪币： 3103 活跃值： (2705) 能力值： ( LV6，RANK：80 ) 在线值：发帖 3 回帖 324 粉丝 101 关注私信	XCicada 2 11 楼学习 2025-9-9 10:25 0
wx_DWJ 雪币： 7 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 11 粉丝 0 关注私信	wx_DWJ 12 楼学习 2025-9-9 11:37 0
mb_vvpfwjte 雪币： 76 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 12 粉丝 0 关注私信	mb_vvpfwjte 13 楼 66666666 2025-9-10 09:04 0
Thehepta 雪币： 3601 活跃值： (7420) 能力值： ( LV11，RANK：185 ) 在线值：发帖 23 回帖 240 粉丝 283 关注私信	Thehepta 3 14 楼我想知道，你睡了吗 2025-9-10 16:17 0
正己雪币： 6643 活跃值： (5313) 能力值： ( LV7，RANK：110 ) 在线值：发帖 18 回帖 61 粉丝 501 关注私信	正己 15 楼 Thehepta 我想知道，你睡了吗[em_065] 月亮不睡，我不睡 2025-9-10 18:19 0
linix 雪币： 2043 活跃值： (2281) 能力值： ( LV3，RANK：20 ) 在线值：发帖 2 回帖 66 粉丝 1 关注私信	linix 16 楼感谢分享，干货很多 2025-9-11 09:28 0
ha0 雪币： 226 活跃值： (485) 能力值： ( LV2，RANK：10 ) 在线值：发帖 0 回帖 9 粉丝 0 关注私信	ha0 17 楼感谢分享，干货很多 2025-9-11 16:28 0
温泉划水鱼雪币： 94 能力值： ( LV1，RANK：0 ) 在线值：发帖 6 回帖 226 粉丝 28 关注私信	温泉划水鱼 18 楼 ok 2025-9-12 12:49 0
mb_lfwgtxdb 雪币： 8 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 68 粉丝 0 关注私信	mb_lfwgtxdb 19 楼感谢分享 2025-9-12 17:41 0
wx_插曲雪币： 411 活跃值： (991) 能力值： ( LV2，RANK：10 ) 在线值：发帖 2 回帖 323 粉丝 24 关注私信	wx_插曲 20 楼 ok 2025-9-14 18:54 0
mb_fbgwdcrp 雪币： 228 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 21 粉丝 0 关注私信	mb_fbgwdcrp 21 楼 123 2025-9-15 11:08 0
wx_yodfailn 雪币： 5 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 14 粉丝 0 关注私信	wx_yodfailn 22 楼 666 2025-9-17 23:28 0
mb_pnyyaazf 雪币： 527 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 35 粉丝 0 关注私信	mb_pnyyaazf 23 楼 666 2025-9-17 23:56 0
ZACSN12 雪币： 268 活跃值： (1185) 能力值： ( LV2，RANK：15 ) 在线值：发帖 0 回帖 43 粉丝 0 关注私信	ZACSN12 24 楼 666 2025-9-18 09:22 0
吃饭去2 雪币： 0 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 10 粉丝 0 关注私信	吃饭去2 25 楼 111 2025-9-22 14:41 0
	游客登录 \| 注册方可回帖回帖表情雪币赚取及消费高级回复