应用安全 --- frida脚本 之 dump 自动化动脱 so
为什么我要动态在内存中查找so并下载修复一个so，因为这个so文件被安全软件进行了加固处理使得代码大面积加密，用ida打开后会发现代码是红色的报错
用到的脱壳so的工具：
https://github.com/lasting-yang/frida_dump/tree/master/android
原版不好用，存在的问题有不支持远程连接，不支持延迟加载so导致有些so文件无法获取。我进行了脚本优化，支持多个adb设备指定。
前提是已经有一个root手机，安装了magisk，并安装好了frida，并且app没有检测root和frida。
整体功能：这是一个用于从Android应用中dump（提取）SO库文件的工具
主要流程：
设备连接：自动检测并选择连接的Android设备
进程附加：使用Frida连接到目标应用（得物App）
模块查找：在应用的内存中查找指定的SO库
内存dump：将SO库从内存中提取出来
文件修复：使用SoFixer工具修复dump出来的文件，让它能正常使用
清理工作：删除临时文件
关键技术点：
使用Frida进行动态分析和内存操作
通过ADB与Android设备通信
处理ARM32和ARM64两种架构
包含重试机制确保模块加载完成
1. 动态内存分析原理 Frida Hook技术： Frida是一个动态插桩框架，可以在运行时注入JavaScript代码到目标进程 通过Hook系统调用和内存操作，获取进程的内存布局信息 不需要root权限就能访问应用的内存空间 内存映射获取： # 通过Frida脚本获取所有已加载的模块信息 allmodule = script.exports_sync.allmodule() # 每个模块包含：名称、基址、大小、路径等信息 2. SO文件在内存中的存储原理 ELF文件加载过程： Android系统加载SO文件时，会将其映射到进程的虚拟内存空间 系统会记录每个SO文件的基址（base address）和大小 文件在内存中可能被分散存储，但逻辑上是连续的 内存布局： 进程内存空间: [0x7000000000] - libc.so [0x7001000000] - libssl.so [0x7002000000] - 目标SO文件 ← 我们要提取的 [0x7003000000] - 其他库文件 3. 内存Dump的核心机制 直接内存读取： // 在dump_so.js中（Frida脚本） function dumpmodule(module_name) { var module = Process.findModuleByName(module_name); if (module) { // 直接从内存基址读取指定大小的数据 var buffer = Memory.readByteArray(module.base, module.size); return buffer; } } 关键步骤： 通过Process.findModuleByName()定位模块 获取模块的基址和大小信息 使用Memory.readByteArray()直接读取内存数据 将二进制数据传回Python端保存为文件 4. 文件修复的必要性 为什么需要修复： 从内存dump出来的SO文件可能缺少某些段信息 内存中的地址是虚拟地址，需要转换为文件偏移 某些重定位信息可能已被修改 SoFixer工具原理： # SoFixer的作用 /data/local/tmp/SoFixer -m 基址 -s 源文件 -o 输出文件 -m：指定原始内存基址，用于地址重定位 重建ELF文件头和段表 修复符号表和重定位表 确保文件可以被IDA、Ghidra等工具正确解析
脚本如下：
# 导入系统相关模块，用于处理命令行参数和系统操作
import sys
# 导入frida模块，这是一个动态分析工具，用于hook和调试应用程序
import frida
# 导入操作系统模块，用于执行系统命令
import os
# 导入时间模块，用于延时等操作
import time
# 导入命令行参数解析模块
import argparse
# 导入subprocess模块，用于更好的进程控制和编码处理
import subprocess
# 安全执行系统命令，处理编码问题
def safe_system_call(cmd):
try:
result = subprocess.run(cmd, shell=True, capture_output=True, text=True, encoding='utf-8', errors='ignore')
return result.returncode == 0
except Exception as e:
print(f"命令执行失败: {cmd}, 错误: {e}")
return False
# 定义修复SO文件的函数，用于修复从内存中dump出来的SO文件
def fix_so(arch, origin_so_name, so_name, base, size, device_id=None):
# 设置adb命令，如果没有指定设备ID就用默认的adb
adb_cmd = "adb"
# 如果指定了设备ID，就在adb命令中加上设备选择参数
if device_id:
adb_cmd = f"adb -s {device_id}"
# 根据设备架构选择对应的SoFixer工具
# 如果是32位ARM架构，推送32位的修复工具
if arch == "arm":
safe_system_call(f"{adb_cmd} push android/SoFixer32 /data/local/tmp/SoFixer")
# 如果是64位ARM架构，推送64位的修复工具
elif arch == "arm64":
safe_system_call(f"{adb_cmd} push android/SoFixer64 /data/local/tmp/SoFixer")
# 给SoFixer工具添加执行权限
safe_system_call(f"{adb_cmd} shell chmod +x /data/local/tmp/SoFixer")
# 将需要修复的SO文件推送到手机的临时目录
safe_system_call(f"{adb_cmd} push {so_name} /data/local/tmp/{so_name}")
# 构建修复命令：-m指定内存基址，-s指定源文件，-o指定输出文件
fix_cmd = f"{adb_cmd} shell /data/local/tmp/SoFixer -m {base} -s /data/local/tmp/{so_name} -o /data/local/tmp/{so_name}.fix.so"
# 打印修复命令，方便调试
print(fix_cmd)
# 执行修复命令
safe_system_call(fix_cmd)
# 生成输出文件名，包含原始名称、基址和大小信息
output_file = f"{origin_so_name}_{base}_{str(size)}_fix.so"
# 将修复后的文件从手机拉取到电脑
safe_system_call(f"{adb_cmd} pull /data/local/tmp/{so_name}.fix.so {output_file}")
# 清理手机上的临时文件：原始dump文件
safe_system_call(f"{adb_cmd} shell rm /data/local/tmp/{so_name}")
# 清理手机上的临时文件：修复后的文件
safe_system_call(f"{adb_cmd} shell rm /data/local/tmp/{so_name}.fix.so")
# 清理手机上的临时文件：修复工具
safe_system_call(f"{adb_cmd} shell rm /data/local/tmp/SoFixer")
# 返回修复后的文件名
return output_file
# 读取Frida JavaScript脚本文件的内容
def read_frida_js_source():
# 打开dump_so.js文件并读取全部内容，使用UTF-8编码
with open("dump_so.js", "r", encoding='utf-8') as f:
return f.read()
# Frida消息回调函数，当JavaScript脚本发送消息时会调用这个函数
def on_message(message, data):
# 这里暂时不处理任何消息，只是一个空函数
pass
# 获取连接的Android设备ID
def get_device_id(specified_device=None):
# 如果指定了设备ID，直接返回
if specified_device:
return specified_device
# 执行adb devices命令获取连接的设备列表，使用UTF-8编码处理输出
try:
result = os.popen("adb devices").read()
devices = result.splitlines()
except UnicodeDecodeError:
# 如果UTF-8解码失败，尝试使用系统默认编码
import subprocess
result = subprocess.check_output("adb devices", shell=True, encoding='utf-8', errors='ignore')
devices = result.splitlines()
# 创建空列表存储设备ID
device_list = []
# 遍历设备列表（跳过第一行标题）
for line in devices[1:]:
# 如果这一行不为空且包含"device"字样，说明是一个有效设备
if line.strip() and "device" in line:
# 提取设备ID（用制表符分割，取第一部分）
device_list.append(line.split('\t')[0])
# 如果没有连接任何设备
if len(device_list) == 0:
print("No devices connected")
return None
# 如果只连接了一个设备，直接返回这个设备ID
elif len(device_list) == 1:
return device_list[0]
# 如果连接了多个设备，让用户选择
else:
print("Multiple devices found:")
# 显示所有设备供用户选择
for i, dev in enumerate(device_list, 1):
print(f"{i}. {dev}")
# 让用户输入选择
choice = input("Select device (1-{}): ".format(len(device_list)))
try:
# 返回用户选择的设备（索引从0开始，所以要减1）
return device_list[int(choice)-1]
except:
# 如果输入无效，使用第一个设备
print("Invalid selection, using first device")
return device_list[0]
# 解析命令行参数
def parse_arguments():
parser = argparse.ArgumentParser(
description='Android SO文件内存dump和修复工具',
formatter_class=argparse.RawDescriptionHelpFormatter,
epilog='''
使用示例:
# 列出所有已加载的模块
python dump_so.py -p com.example.app
# dump指定的SO文件
python dump_so.py -p com.example.app -s libnative.so
# 指定设备ID
python dump_so.py -d emulator-5554 -p com.example.app -s libnative.so
# 完整命令
python dump_so.py --device emulator-5554 --package com.example.app --so libnative.so
''')
parser.add_argument('-d', '--device',
help='指定Android设备ID (可通过adb devices查看)')
parser.add_argument('-p', '--package',
required=True,
help='目标应用包名 (必需参数)')
parser.add_argument('-s', '--so',
help='要dump的SO文件名 (不指定则列出所有模块)')
parser.add_argument('--timeout',
type=int,
default=10,
help='查找模块的超时时间(秒) (默认: 10)')
parser.add_argument('--no-fix',
action='store_true',
help='只dump不修复SO文件')
return parser.parse_args()
# 验证设备连接
def validate_device(device_id):
if not device_id:
return False
# 检查设备是否真的存在，使用安全的编码处理
try:
devices = os.popen("adb devices").read()
except UnicodeDecodeError:
import subprocess
devices = subprocess.check_output("adb devices", shell=True, encoding='utf-8', errors='ignore')
if device_id not in devices:
print(f"错误: 设备 {device_id} 未连接")
print("可用设备:")
safe_system_call("adb devices")
return False
return True
# 主要的dump逻辑函数
def dump_so_module(script, so_name, device_id, no_fix=False, timeout=10):
print(f"Looking for module: {so_name}")
# 添加重试逻辑，因为模块可能还没有加载完成
module_info = None
# 最多重试指定次数查找模块
for attempt in range(timeout):
# 调用JavaScript脚本的findmodule函数查找指定模块
module_info = script.exports_sync.findmodule(so_name)
if module_info:
break
print(f"Module not found, retry {attempt+1}/{timeout}...")
# 等待1秒后重试
time.sleep(1)
# 如果最终还是没找到模块，显示错误信息并退出
if not module_info:
print(f"错误: 找不到模块 {so_name}")
print("当前已加载的模块:")
# 显示当前所有已加载的模块供参考
for m in script.exports_sync.allmodule():
print(f" {m['name']}")
return False
# 找到模块后，显示模块信息
print("找到模块信息:")
print(f" 名称: {module_info['name']}")
print(f" 基址: {module_info['base']}")
print(f" 大小: {module_info['size']}")
print(f" 路径: {module_info.get('path', 'N/A')}")
# 获取模块的内存基址和大小
base = module_info["base"]
size = module_info["size"]
print(f"开始dump模块: base={base}, size={size}")
# 调用JavaScript脚本的dumpmodule函数dump模块内容
module_buffer = script.exports_sync.dumpmodule(so_name)
# 如果dump成功（返回值不是-1）
if module_buffer != -1:
# 生成dump文件名
dump_so_name = so_name + ".dump.so"
# 将dump的二进制数据写入文件
with open(dump_so_name, "wb") as f:
f.write(module_buffer)
print(f"保存dump文件: {dump_so_name}")
# 如果不需要修复，直接返回
if no_fix:
print("跳过修复步骤")
return True
# 获取设备架构信息
arch = script.exports_sync.arch()
print(f"设备架构: {arch}")
# 调用修复函数修复dump出来的SO文件
try:
fix_so_name = fix_so(arch, so_name, dump_so_name, base, size, device_id)
print(f"修复后的SO文件: {fix_so_name}")
# 删除临时的dump文件
os.remove(dump_so_name)
print("清理临时文件完成")
return True
except Exception as e:
print(f"修复过程出错: {e}")
print(f"原始dump文件保留: {dump_so_name}")
return False
else:
print("dump失败")
return False
# 程序主入口，只有直接运行这个脚本时才会执行
def main():
# 解析命令行参数
args = parse_arguments()
print("=" * 50)
print("Android SO文件内存dump工具")
print("=" * 50)
# 获取要使用的Android设备ID
device_id = get_device_id(args.device)
# 验证设备连接
if not validate_device(device_id):
sys.exit(1)
print(f"使用设备: {device_id}")
print(f"目标包名: {args.package}")
try:
# 连接到USB设备（通过Frida）
device = frida.get_usb_device()
# 尝试附加到正在运行的进程
try:
session = device.attach(args.package)
print(f"已附加到运行中的进程: {args.package}")
except frida.ProcessNotFoundError:
print(f"进程未运行，正在启动: {args.package}")
# 如果进程没有运行，就启动它
pid = device.spawn([args.package])
# 附加到新启动的进程
session = device.attach(pid)
# 恢复进程执行
device.resume(pid)
print(f"已启动并附加到进程: {args.package} (PID: {pid})")
# 创建Frida脚本，加载JavaScript代码
script = session.create_script(read_frida_js_source())
# 设置消息回调函数
script.on('message', on_message)
# 加载并执行脚本
script.load()
print("Frida脚本已加载")
# 等待一下让应用完全启动
print("等待应用完全启动...")
time.sleep(3)
# 如果没有指定SO文件名，就列出所有已加载的模块
if not args.so:
print("\n已加载的模块:")
print("-" * 40)
# 调用JavaScript脚本的allmodule函数获取所有已加载的模块
allmodule = script.exports_sync.allmodule()
# 遍历并打印每个模块的名称
for i, module in enumerate(allmodule, 1):
print(f"{i:3d}. {module['name']}")
if 'path' in module:
print(f" 路径: {module['path']}")
print(f"\n总共找到 {len(allmodule)} 个模块")
else:
# dump指定的SO文件
print(f"\n开始dump SO文件: {args.so}")
print("-" * 40)
success = dump_so_module(script, args.so, device_id, args.no_fix, args.timeout)
if success:
print("\n✓ dump完成!")
else:
print("\n✗ dump失败!")
sys.exit(1)
except frida.ServerNotRunningError:
print("错误: Frida服务未运行，请确保设备已root并安装frida-server")
sys.exit(1)
except frida.ProcessNotFoundError:
print(f"错误: 找不到进程 {args.package}")
print("请确保包名正确且应用已安装")
sys.exit(1)
except Exception as e:
print(f"发生错误: {e}")
sys.exit(1)
if __name__ == "__main__":
main()
我希望用aya工具箱进行远程连接手机，手机打开远程调试功能，输入ip和端口就可以远程adb了。
注意要将adb命令配置为环境变量，这样这个脚本就可以进行使用adb进行远程拉取脱壳后的so了。我们会发现目录下多了一个修复好的so文件。
注意过掉frida检测。我这个app过检测的方法是在/data/app的/lib下删除libmasaosec.so这个验证文件，如果不删除在执行脚本时会发现应用闪退。
我执行的命令如下
# 指定设备
python dump_so.py -d 192.168.1.164:41309 -p com.shizhuanxxxxx.duapp -s libGameVMP.so
Multiple devices found: 1. 192.168.1.164:41309 2. adb-KCAIKN05L048ZAF-ovuptT._adb-tls-connect._tcp Select device (1-2): 1 Started and attached to process: com.shizhuanxxxx.duapp (PID: 5913) Frida script loaded Looking for module: libGameVMP.so Module not found, retry 1/10... Found module info: {'name': 'libGameVMP.so', 'version': None, 'base': '0x725d4cf000', 'size': 454656, 'path': '/data/app/~~HP4rmsQIdDjYodK-wFzpgg==/com.shizhuanxxxxx.duapp-53DwSEmI6IWzTVKI_jTzYg==/lib/arm64/libGameVMP.so'} Starting dump of module: base=0x725d4cf000, size=454656 Saved dump file: libGameVMP.so.dump.so Device architecture: arm64 android/SoFixer64: 1 file pushed, 0 skipped. 4.8 MB/s (2672240 bytes in 0.536s) libGameVMP.so.dump.so: 1 file pushed, 0 skipped. 23.0 MB/s (454656 bytes in 0.019s) adb -s 192.168.1.164:41309 shell /data/local/tmp/SoFixer -m 0x725d4cf000 -s /data/local/tmp/libGameVMP.so.dump.so -o /data/local/tmp/libGameVMP.so.dump.so.fix.so [main_loop:87]start to rebuild elf file [Load:69]dynamic segment have been found in loadable segment, argument baseso will be ignored. [RebuildPhdr:25]=============LoadDynamicSectionFromBaseSource==========RebuildPhdr========================= [RebuildPhdr:37]=====================RebuildPhdr End====================== [ReadSoInfo:552]=======================ReadSoInfo========================= [ReadSoInfo:699]soname [ReadSoInfo:624] constructors (DT_INIT) found at 20230 [ReadSoInfo:632] constructors (DT_INIT_ARRAY) found at 6b8e0 [ReadSoInfo:636] constructors (DT_INIT_ARRAYSZ) 35 [ReadSoInfo:640] destructors (DT_FINI_ARRAY) found at 6b9f8 [ReadSoInfo:644] destructors (DT_FINI_ARRAYSZ) 2 [ReadSoInfo:583]string table found at 10f0 [ReadSoInfo:587]symbol table found at 568 [ReadSoInfo:598] plt_rel_count (DT_PLTRELSZ) 123 [ReadSoInfo:594] plt_rel (DT_JMPREL) found at 2110 [ReadSoInfo:702]Unused DT entry: type 0x00000009 arg 0x00000018 [ReadSoInfo:702]Unused DT entry: type 0x00000018 arg 0x00000000 [ReadSoInfo:702]Unused DT entry: type 0x6ffffffb arg 0x00000001 [ReadSoInfo:702]Unused DT entry: type 0x6ffffffe arg 0x000015e8 [ReadSoInfo:702]Unused DT entry: type 0x6fffffff arg 0x00000003 [ReadSoInfo:702]Unused DT entry: type 0x6ffffff0 arg 0x000014ee [ReadSoInfo:702]Unused DT entry: type 0x6ffffff9 arg 0x00000059 [ReadSoInfo:706]=======================ReadSoInfo End========================= [RebuildShdr:42]=======================RebuildShdr========================= [RebuildShdr:539]=====================RebuildShdr End====================== [RebuildRelocs:786]=======================RebuildRelocs========================= [RebuildRelocs:812]=======================RebuildRelocs End======================= [RebuildFin:712]=======================try to finish file rebuild ========================= [RebuildFin:736]=======================End========================= [main:123]Done!!! /data/local/tmp/libGameVMP.so.dump.so.fix....skipped. 4.3 MB/s (455601 bytes in 0.100s) Fixed SO file: libGameVMP.so_0x725d4cf000_454656_fix.so Cleaned up temporary files PS C:\Users\21558\Downloads\frida_dump-master>
最后我们分析一下js关键代码
dump_so.js // 定义RPC导出对象，这些函数可以被Python端调用 rpc.exports = { // 查找指定名称的模块函数 findmodule: function (so_name) { // 使用Process.findModuleByName()在当前进程中查找指定名称的模块 // so_name: 要查找的SO文件名，如"libnative.so" var libso = Process.findModuleByName(so_name); // 返回模块对象，包含name、base、size、path等信息 // 如果找不到模块则返回null return libso; }, // dump指定模块的内存数据函数 dumpmodule: function (so_name) { // 首先查找指定名称的模块 var libso = Process.findModuleByName(so_name); // 如果模块不存在，返回-1表示失败 if (libso == null) { return -1; } // 修改内存保护属性为可读写执行(rwx) // 这是为了确保我们能够读取模块的所有内存区域 // ptr(libso.base): 将基址转换为指针对象 // libso.size: 模块的大小 // 'rwx': 读(r)写(w)执行(x)权限 Memory.protect(ptr(libso.base), libso.size, 'rwx'); // 从模块基址开始读取整个模块的字节数据 // ptr(libso.base): 模块在内存中的起始地址 // readByteArray(libso.size): 读取指定大小的字节数组 var libso_buffer = ptr(libso.base).readByteArray(libso.size); // 将读取的缓冲区数据附加到模块对象上（可选，用于调试） libso.buffer = libso_buffer; // 返回读取到的字节数组，这就是SO文件的完整内存映像 return libso_buffer; }, // 获取所有已加载模块的函数 allmodule: function () { // Process.enumerateModules()返回当前进程中所有已加载模块的数组 // 每个模块对象包含：name(名称)、base(基址)、size(大小)、path(路径) return Process.enumerateModules() }, // 获取当前设备架构的函数 arch: function () { // Process.arch返回当前进程的CPU架构 // 可能的值：'arm', 'arm64', 'ia32', 'x64' // 这个信息用于选择正确的SoFixer工具版本 return Process.arch; } }
dump_dex.js
// 获取当前进程名称的函数 function get_self_process_name() { // 找到open导出函数 var openPtr = Module.getExportByName('libc.so', 'open'); // NativeFunction是c和js函数的桥梁。创建open函数的NativeFunction包装，参数：返回类型int，参数类型[pointer, int]。将一个已知地址的原生 C 函数 open，包装成一个可以被 JavaScript 直接、安全调用的 JavaScript 函数 open。它定义了如何转换参数和返回值，使得两个不同语言的世界能够无缝通信。 var open = new NativeFunction(openPtr, 'int', ['pointer', 'int']); // 找到read导出函数 var readPtr = Module.getExportByName("libc.so", "read"); // 创建read函数的NativeFunction包装，参数：返回类型int，参数类型[int, pointer, int] var read = new NativeFunction(readPtr, "int", ["int", "pointer", "int"]); // 获取libc.so中close函数的地址 var closePtr = Module.getExportByName('libc.so', 'close'); // 创建close函数的NativeFunction包装，参数：返回类型int，参数类型[int] var close = new NativeFunction(closePtr, 'int', ['int']); // Memory.allocUtf8String() 的作用就是充当 js和 C串指针之间的桥梁。 // 这个文件包含当前进程的命令行参数，第一个参数就是进程名 var path = Memory.allocUtf8String("/proc/self/cmdline"); // 打开文件，参数0表示只读模式 var fd = open(path, 0); // 如果文件打开成功（文件描述符不等于-1） if (fd != -1) { // 分配4KB内存用于读取文件内容 var buffer = Memory.alloc(0x1000); // 从文件中读取数据到缓冲区 var result = read(fd, buffer, 0x1000); // 关闭文件 close(fd); // 将缓冲区内容转换为C字符串并返回 result = ptr(buffer).readCString(); return result; } // 如果获取失败，返回"-1" return "-1"; } // 创建目录 function mkdir(path) { // 获取libc.so中mkdir函数的地址 var mkdirPtr = Module.getExportByName('libc.so', 'mkdir'); // 创建mkdir函数的NativeFunction包装 var mkdir = new NativeFunction(mkdirPtr, 'int', ['pointer', 'int']); // 获取libc.so中opendir函数的地址，用于检查目录是否存在 var opendirPtr = Module.getExportByName('libc.so', 'opendir'); // 创建opendir函数的NativeFunction包装 var opendir = new NativeFunction(opendirPtr, 'pointer', ['pointer']); // 获取libc.so中closedir函数的地址 var closedirPtr = Module.getExportByName('libc.so', 'closedir'); // 创建closedir函数的NativeFunction包装 var closedir = new NativeFunction(closedirPtr, 'int', ['pointer']); // 将js路径字符串转换为C字符串 var cPath = Memory.allocUtf8String(path); // 尝试打开目录，检查是否存在 var dir = opendir(cPath); // 如果目录存在（opendir返回非0值） if (dir != 0) { // 关闭目录句柄 closedir(dir); // 目录已存在，直接返回 return 0; } // 目录不存在，创建目录，权限设置为755（rwxr-xr-x） mkdir(cPath, 755); // 设置目录权限 chmod(path); } // 修改文件/目录权限的函数 function chmod(path) { // 获取libc.so中chmod函数的地址 var chmodPtr = Module.getExportByName('libc.so', 'chmod'); // 创建chmod函数的NativeFunction包装 var chmod = new NativeFunction(chmodPtr, 'int', ['pointer', 'int']); // 将路径字符串转换为C字符串 var cPath = Memory.allocUtf8String(path); // 设置权限为755（rwxr-xr-x） chmod(cPath, 755); } // DEX文件dump的核心函数 function dump_dex() { // 查找libart.so模块，这是Android Runtime的核心库 var libart = Process.findModuleByName("libart.so"); // 初始化DefineClass函数地址为null var addr_DefineClass = null; // 枚举libart.so中的所有符号 var symbols = libart.enumerateSymbols(); // 遍历所有符号，查找DefineClass函数 for (var index = 0; index < symbols.length; index++) { var symbol = symbols[index]; var symbol_name = symbol.name; // 这个DefineClass的函数签名是Android9的 // _ZN3art11ClassLinker11DefineClassEPNS_6ThreadEPKcmNS_6HandleINS_6mirror11ClassLoaderEEERKNS_7DexFileERKNS9_8ClassDefE // 通过符号名称特征匹配DefineClass函数 // _ZN3art11ClassLinker11DefineClassEPNS_6ThreadEPKcmNS_6HandleINS_6mirror11ClassLoaderEEERKNS_7DexFileERKNS9_8ClassDefE // 拆解后就是： // 符号部分 含义（“地址”组成部分） 通俗解释 // _ZN ... E 开始和结束标记 这是一个“修饰名”的包裹。 // 3art 命名空间 (Namespace) art。Android Runtime，就是安卓的系统核心。 // 11ClassLinker 类名 (Class) ClassLinker 类。这是ART里一个负责加载和链接类的“管理员”。 // 11DefineClass 函数名 (Function) DefineClass 方法。这是这个“管理员”的核心工作：定义一个类。 // EPNS_6ThreadE 参数1 (Parameter 1) art::Thread*。需要一个线程指针。就像办事要指明是哪个“工作人员”在处理。 // PKc 参数2 (Parameter 2) const char*。一个字符串，通常是类的描述符（如 "java/lang/String"）。 // m 参数3 (Parameter 3) size_t。一个数字，表示上面字符串的长度。 // PNS_6HandleINS_6mirror11ClassLoaderEEE 参数4 (Parameter 4) art::Handle<art::mirror::ClassLoader>。一个类加载器对象的句柄。告诉系统用哪个“工具箱”（比如App自己的还是系统的）来加载这个类。 // RKNS_7DexFileE 参数5 (Parameter 5) const art::DexFile&。一个Dex文件的常量引用。这是最重要的参数！它告诉管理员：“请从这个DEX文件包裹里”取出类来。 // RKNS9_8ClassDefE 参数6 (Parameter 6) const art::DexFile::ClassDef&。一个类定义的常量引用。它进一步指明：“就取这个包裹里特定的那一份文件（类定义）”。 // 所以，这个函数到底是干嘛的？ // 它的核心工作就一件事： // 当一个Android App运行时，系统需要把DEX文件（打包好的Java代码）里的类加载到内存中才能执行。 // 这个 DefineClass 函数就是ART虚拟机里负责这项工作的“首席加载官”。 // 调用它的过程，就像是下指令： // “喂！ART系统的ClassLinker管理员！(3art11ClassLinker) // 现在请你 (11DefineClass)： // 在当前这个线程 (EPNS_6ThreadE) 上， // 根据这个名字叫"com/example/MyClass" (PKc) 长度是XX (m) 的类， // 使用App提供的这个类加载器 (PNS_6HandleINS_6mirror11ClassLoaderEEE)， // 从这个DEX文件里 (RKNS_7DexFileE)， // 找到这个类的具体定义数据 (RKNS9_8ClassDefE)， // 然后把它在内存里创建出来！” // 为什么Dump Dex的脚本要Hook它？ // 这正是脚本聪明的地方！ // 时机完美：这个函数被调用时，意味着系统正在主动地读取并加载一个DEX文件中的类。此时，整个DEX文件肯定已经完整地映射到内存中了。 // 信息齐全：这个函数的参数就像一个“情报包”，直接包含了两个关键情报： // RKNS_7DexFileE： DexFile对象的内存地址。通过这个对象，脚本就能顺藤摸瓜找到DEX文件在内存中的起始地址 (begin_) 和大小 (size_)。 // 这样，脚本就不需要漫无目的地搜索内存，而是在这个函数被调用时，直接“领取”了DEX文件的地址和大小，然后把它 dump 到磁盘上。 // 总结一下：这个奇怪的字符串就是ART虚拟机里“加载类”这个核心功能员的完整身份证。Hook它，就能在最合适的时机、用最直接的方式，拿到我们想要dump的DEX文件的内存地址。 if (symbol_name.indexOf("ClassLinker") >= 0 && symbol_name.indexOf("DefineClass") >= 0 && symbol_name.indexOf("Thread") >= 0 && symbol_name.indexOf("DexFile") >= 0) { console.log(symbol_name, symbol.address); // 保存找到的DefineClass函数地址 addr_DefineClass = symbol.address; } } // 用于存储已发现的DEX文件映射（基址->大小） var dex_maps = {}; // DEX文件计数器，用于生成文件名 var dex_count = 1; console.log("[DefineClass:]", addr_DefineClass); // 如果找到了DefineClass函数 if (addr_DefineClass) { // hook DefineClass函数 Interceptor.attach(addr_DefineClass, { // 函数调用前的回调 onEnter: function (args) { // _ZN3art11ClassLinker11DefineClassEPNS_6ThreadEPKcmNS_6HandleINS_6mirror11ClassLoaderEEERKNS_7DexFileERKNS9_8ClassDefE //真实的参数列表是这样的： // 序号 参数 对应 args[] // 0 this (指向 ClassLinker 对象的指针) args[0] // 1 art::Thread* thread args[1] // 2 const char* descriptor args[2] // 3 size_t hash args[3] // 4 art::Handle... class_loader args[4] // 5 const art::DexFile& dex_file <-- 目标 args[5] // 6 const art::DexFile::ClassDef& class_def args[6] // 结论： // dex_file 参数在函数的正式参数列表中排在第5位（从0开始数），是因为它前面还有一个看不见的“第0号”参数——this 指针。 // 所以，args[5] 取到的就是传递给 DefineClass 函数的 dex_file 参数。 var dex_file = args[5]; // 这是DEX文件在内存中的起始地址 var base = ptr(dex_file).add(Process.pointerSize).readPointer(); // 这是DEX文件的大小 var size = ptr(dex_file).add(Process.pointerSize + Process.pointerSize).readUInt(); // 如果这个DEX文件还没有被记录过 if (dex_maps[base] == undefined) { // 记录DEX文件的基址和大小 dex_maps[base] = size; // 读取DEX文件的魔数（前几个字节） var magic = ptr(base).readCString(); // 检查是否是有效的DEX文件（以"dex"开头） if (magic.indexOf("dex") == 0) { // 获取当前进程名 var process_name = get_self_process_name(); if (process_name != "-1") { // 构建dump目录路径 var dex_dir_path = "/data/data/" + process_name + "/files/dump_dex_" + process_name; // 创建dump目录 mkdir(dex_dir_path); // 构建DEX文件路径，第一个文件名为class.dex，后续为class2.dex, class3.dex... var dex_path = dex_dir_path + "/class" + (dex_count == 1 ? "" : dex_count) + ".dex"; console.log("[find dex]:", dex_path); // 创建文件用于写入 var fd = new File(dex_path, "wb"); if (fd && fd != null) { // 增加DEX文件计数 dex_count++; // 从内存中读取完整的DEX文件数据 var dex_buffer = ptr(base).readByteArray(size); // 写入文件 fd.write(dex_buffer); // 刷新缓冲区 fd.flush(); // 关闭文件 fd.close(); console.log("[dump dex]:", dex_path); } } } } }, // 函数调用后的回调（这里为空） onLeave: function (retval) { } }); } } // 标记是否已经hook了libart.so var is_hook_libart = false; // hook动态库加载函数的函数 function hook_dlopen() { // hook标准的dlopen函数 在较老版本的Android，或者一些非常规的、直接调用标准C库的场景中使用。 Interceptor.attach(Module.findExportByName(null, "dlopen"), { // dlopen调用前的回调 onEnter: function (args) { // args[0]是库文件路径参数 var pathptr = args[0]; if (pathptr !== undefined && pathptr != null) { // 读取库文件路径字符串 var path = ptr(pathptr).readCString(); //console.log("dlopen:", path); // 如果正在加载libart.so if (path.indexOf("libart.so") >= 0) { // 标记可以hook libart this.can_hook_libart = true; console.log("[dlopen:]", path); } } }, // dlopen调用后的回调 onLeave: function (retval) { // 如果可以hook libart且还没有hook过 if (this.can_hook_libart && !is_hook_libart) { // 开始dump DEX文件 dump_dex(); // 标记已经hook过了 is_hook_libart = true; } } }) // hook Android特有的android_dlopen_ext函数 //例如 Java 代码中加载原生库 // static { // System.loadLibrary("my-native-lib"); // 这会触发 dlopen 或 android_dlopen_ext // } 在现代Android版本中，系统内部加载核心库（如 libart.so）时，更倾向于使用这个功能更强的函数。 Interceptor.attach(Module.findExportByName(null, "android_dlopen_ext"), { // 调用前的回调 onEnter: function (args) { // args[0]是库文件路径参数 var pathptr = args[0]; if (pathptr !== undefined && pathptr != null) { // 读取库文件路径字符串 var path = ptr(pathptr).readCString(); //console.log("android_dlopen_ext:", path); // 如果正在加载libart.so if (path.indexOf("libart.so") >= 0) { // 标记可以hook libart this.can_hook_libart = true; console.log("[android_dlopen_ext:]", path); } } }, // android_dlopen_ext调用后的回调 onLeave: function (retval) { // 如果可以hook libart且还没有hook过 if (this.can_hook_libart && !is_hook_libart) { // 开始dump DEX文件 dump_dex(); // 标记已经hook过了 is_hook_libart = true; } } }); } // 立即执行dump_dex函数（如果libart.so已经加载） setImmediate(dump_dex);
脱出所有dex和so的测试脚本
https://gitee.com/null_465_7266/dump-all-so/tree/master
使用方法
PS C:\Users\21558\Documents\dumpallso\dump-all-so> python dump_so.py -p com.shizhuang.duapp --app-path "/data/app/~~YxjKiMfU5GhbqDTDhPhhpw==/com.shizhuang.duapp-f6V4lziH2H4ySLWwb1S4_A==/lib/arm64
浙公网安备 33010602011771号