文章总结： 本文记录了UnityIL2CPP安卓端加固的实现与探索。详细分析了libil2cpp.so与global-metadata.dat加载流程，利用Unity编辑器脚本实现构建时Metadata加密；针对SO文件，采用DobbyHook拦截dlopen并结合memfd_create技术实现不落地内存解密加载，提升防逆向能力。文中还包含代码混淆建议及完整的CTF逆向解题过程，涵盖RC4与TEA算法解密。
综合评分： 92
文章分类： 逆向分析,移动安全,CTF,安全开发,应用安全
安卓逆向 — 记录一次Unity加固的探索与实现
Shangwendada
逆向有你
2026年1月5日 09:25
河南
前言
正值某比赛出题，一道困难题不知道要怎么出才好，突然想起了il2cpp在安卓平台的加密，但是本人又不太会这方面，只好从学习一下il2cpp的原理并且尝试进行加固，本文记录我的出题过程。
整体启动与 libil2cpp.so 被载入的流程
要直到如何保护libil2cpp.so首先需要知道这个so文件是在什么时候被载入的，根据il2cpp安卓端的启动流程，我们可以发现载入位置，其流程图如下：
在此处我们可以看到libunity.so通过dlopen加载libil2cpp.so
global-metadata.dat 的加载时机与分支流程
光保护il2cpp.so大抵是不够的，很多加固方案肯定都会选择加密global-metadata.dat，接下来我们看看il2cpp.so中负责加载global-metadata.dat的代码位置吧，如下是加载metadata的流程图
源码分析可知加载global-metadata.dat的代码位置在
复制代码 隐藏代码
E:\Unity Edit\2020.3.48f1c1\Editor\Data\il2cpp\libil2cpp\vm\MetadataLoader.cpp
具体代码如下：
复制代码 隐藏代码
os::FileHandle* handle = os::File::Open(resourceFilePath, kFileModeOpen, kFileAccessRead, kFileShareRead, kFileOptionsNone, &error);
if (error != 0)
{
utils::Logging::Write("ERROR: Could not open %s", resourceFilePath.c_str());
returnNULL;
}
void* fileBuffer = utils::MemoryMappedFile::Map(handle);
加固global-metadata.dat
一些小问题
正如上文所提到的，加固global-metadata.dat主要是在
复制代码 隐藏代码
E:\Unity Edit\2020.3.48f1c1\Editor\Data\il2cpp\libil2cpp\vm\MetadataLoader.cpp
，理论上修改了此处的代码之后，再写一个脚本去加密metadata再打包回去，就可以运行了，但是如果直接修改MetadataLoader.cpp会导致后面如果不需要加固的项目每一次编译都需要加密global-metadata.dat才能运行，这样的话岂不是非常的不方便
项目构建时自动加固global-metadata.dat
自然，这里先说一下一个可能的解决方案，也是我在NSSCTF 4th中出过的一个pyinstaller打包项目加固的原理，我们可以通过设置一个标记，比如MHY0，我们再魔改MetadataLoader的时候通过识别是否存在MHY0这个标识符来确定是否需要解密，这样就不会影响后续打包的项目直接运行。
当然，还有更加优秀的办法，我们看到如下GitHub项目：
https://github.com/badApple001/Il2cppEncrtypt
我们在Unity Hub编写完主体代码之后就可以开始考虑加固了，接下来讲述一下Il2cppEncrtypt 这个项目构建时加固的原理。
Unity有一个很有意思的机制叫做Editor Scripting （Unity 编辑器扩展系统）暨所有放在 Assets/Editor/ 或任何以 Editor 命名的文件夹里的脚本，都会被编译进一个 编辑器专用的程序集（Editor Assembly），不会进入打包的游戏。
与此同时，Unity还存在IPostprocessBuildWithReport这个接口有什么用呢，来看一下介绍
IPostprocessBuildWithReport：Unity 的构建管线接口，OnPostprocessBuild 会在构建完成后自动被调用，参数是 BuildReport，包含构建结果、输出路径、平台等信息。
（上面的字那么多看的怪枯燥的吧，让GPT生成了一张图，润色一下，看个乐呵
同时在这个接口的上下文中，我们可以获取到打包的路径，从而进行对global-metadata.dat的加固
那么其实我们就可以扩展这个接口，并且重写OnPostprocessBuild，就可以实现在构建项目的时候一并完成对global-metadata.dat加固了。
以下代码摘自Il2cppEncrtypt：
复制代码 隐藏代码
void IPostprocessBuildWithReport.OnPostprocessBuild( BuildReport report )
{
SetDisplayLog( LogMessageFromCpp );
if ( report.summary.platform == UnityEditor.BuildTarget.Android )
{
Debug.Log(report.summary.outputPath);
EncryptionCode( Marshal.StringToHGlobalAnsi( report.summary.outputPath ) );
OverrideLoader( Marshal.StringToHGlobalAnsi( report.summary.outputPath ) );
}
elseif ( report.summary.platform == UnityEditor.BuildTarget.iOS )
{
}
Debug.Log( "执行扩展程序完成" );
}
导出项目并覆盖项目内global-metadata.dat，编译魔改的il2cpp.so
诚然，如果我们直接使用Unity Hub编译一个可以直接运行的unity app的话默认使用的是Unity Editor中的代码，这个十分坑爹，也许是我不知道如何修改，反正最后试了很久也是没招了。
导出Unity 项目之后通过Android Studio直接编译：
导出项目在装好安卓的SDK之后，Build Setting界面，直接就可以看到导出了。
导出之后在导出目录下可以看到两个包launcher和unityLibrary，其中unityLibrary主要加载il2cpp的内容
同时我们检查一下Metadata是否加密
其位置在于
复制代码 隐藏代码
unityLibrary\src\main\assets\bin\Data\Managed\Metadata
可以看到这里原本应该是有意义的symbol，但此刻变成了乱码，即Metadata成功被加密
接下来我们需要在项目中的loader写入解密代码，但你会发现Android studio 好像无法完美识别到关于il2cpp.so的代码，我们需要手动在
复制代码 隐藏代码
unityLibrary\src\main\Il2CppOutputProject\IL2CPP\libil2cpp\vm\MetadataLoader.cpp
中修改，这里需要注意的是确保和我们加密代码一致，不然会导致崩溃。
如下代码中所示，主要的点也就是在拿到fileBuffer 之后做解密即可。
复制代码 隐藏代码
void *il2cpp::vm::MetadataLoader::LoadMetadataFile(constchar *fileName)
{
#if IL2CPP_TARGET_ANDROID && IL2CPP_TINY_DEBUGGER && !IL2CPP_TINY_FROM_IL2CPP_BUILDER
std::string resourcesDirectory = utils::PathUtils::Combine(utils::StringView<char>("Data"), utils::StringView<char>("Metadata"));
std::string resourceFilePath = utils::PathUtils::Combine(resourcesDirectory, utils::StringView<char>(fileName, strlen(fileName)));
int size = 0;
returnloadAsset(resourceFilePath.c_str(), &size, malloc);
#elif IL2CPP_TARGET_JAVASCRIPT && IL2CPP_TINY_DEBUGGER && !IL2CPP_TINY_FROM_IL2CPP_BUILDER
return g_MetadataForWebTinyDebugger;
#else
std::string resourcesDirectory = utils::PathUtils::Combine(utils::Runtime::GetDataDir(), utils::StringView<char>("Metadata"));
std::string resourceFilePath = utils::PathUtils::Combine(resourcesDirectory, utils::StringView<char>(fileName, strlen(fileName)));
int error = 0;
os::FileHandle *handle = os::File::Open(resourceFilePath, kFileModeOpen, kFileAccessRead, kFileShareRead, kFileOptionsNone, &error);
if (error != 0)
{
utils::Logging::Write("ERROR: Could not open %s", resourceFilePath.c_str());
returnNULL;
}
void *fileBuffer = g_cacheFileHeader = utils::MemoryMappedFile::Map(handle);
int ero;
int64_t length = os::File::GetLength(handle, &ero);
void *decBuffer = g_cacheDecodeHeader = PromiseAntiencryption(fileBuffer, length);
os::File::Close(handle, &error);
if (error != 0)
{
utils::MemoryMappedFile::Unmap(fileBuffer);
fileBuffer = NULL;
returnNULL;
}
return decBuffer;
#endif
}
至此成功的完成了Metadata的加密，但是这够吗，显然远远不够，我们准备开始下一步探索，加密libil2cpp.so
加固il2cpp.so
一些小小问题
在上文中提到了，libil2cpp.so 是被libunity.so加载的，但是我们在libUnity的编译脚本中可以看见似乎build.gradle是没有编译libunity.so的逻辑的，代码如下
复制代码 隐藏代码
def BuildIl2Cpp(String workingDir, String targetDirectory, String architecture, String abi, String configuration) {
exec {
commandLine(workingDir + "/src/main/Il2CppOutputProject/IL2CPP/build/deploy/netcoreapp3.1/il2cpp.exe",
"--compile-cpp",
"--incremental-g-c-time-slice=3",
"--avoid-dynamic-library-copy",
"--profiler-report",
"--libil2cpp-static",
"--platform=Android",
"--architecture=" + architecture,
"--configuration=" + configuration,
"--outputpath=" + workingDir + targetDirectory + abi + "/libil2cpp.so",
"--cachedirectory=" + workingDir + "/build/il2cpp_"+ abi + "_" + configuration + "/il2cpp_cache",
"--additional-include-directories=" + workingDir + "/src/main/Il2CppOutputProject/IL2CPP/external/bdwgc/include",
"--additional-include-directories=" + workingDir + "/src/main/Il2CppOutputProject/IL2CPP/libil2cpp/include",
"--tool-chain-path=" + android.ndkDirectory,
"--map-file-parser=" + workingDir + "/src/main/Il2CppOutputProject/IL2CPP/MapFileParser/MapFileParser.exe",
"--generatedcppdir=" + workingDir + "/src/main/Il2CppOutputProject/Source/il2cppOutput",
"--baselib-directory=" + workingDir + "/src/main/jniStaticLibs/" + abi,
"--dotnetprofile=unityaot")
environment "ANDROID_SDK_ROOT", getSdkDir()
}
delete workingDir + targetDirectory + abi + "/libil2cpp.sym.so"
ant.move(file: workingDir + targetDirectory + abi + "/libil2cpp.dbg.so", tofile: workingDir + "/symbols/" + abi + "/libil2cpp.so")
}
同时我们编译一次项目也会发现JniLibs的目录出现了时间差
种种迹象也说明了libunity.so似乎不再我们可控范围内，经过搜索得知这个unity.so是核心引擎，属于Unity的闭源部分，因此我们没有办法通过修改unity.so来拦截il2cpp的加载从而实现动态解密。
通过Hook拦截il2cpp.so加载流程
既然无法从代码层面进行修改ilbunity.so，那么根据上文提到的il2cpp.so被加载流程，最后加载libunity.so肯定是要走dlopen的，那么是不是说我们只需要在这之前注册一个hook，但dlopen打开的是libil2cpp的时候我们进行加密呢，接下来我们开始尝试
这里的Hook有很多方法，Github已经开源了很多好用的Hook框架，我这里使用dobby hook
https://github.com/jmpews/Dobby?tab=readme-ov-file
dobby hook编译好后使用非常的简单啊
我的建议是编译成静态链接库
libdobby.a，dobby.h
静态链接库编译之后会直接融入到编译出来的so中，这样不容易被看出来用了hook框架。
如何在项目中使用dobby hook呢？
首先将libdobby.a放到Jnilibs中，然后把dobby.h放到include中
接下来给一份我的Cmakelist.txt 自行理解一下，其中加入了对静态链接库符号的去除
复制代码 隐藏代码
cmake_minimum_required(VERSION 3.10.2)
project("just")
# ========================
# 源文件
# ========================
add_library(${CMAKE_PROJECT_NAME} SHARED
just.cpp
detectFrida.cpp
)
# ========================
# 包含路径
# ========================
include_directories(
dobby
)
# ========================
# 导入静态库 libdobby.a
# ========================
add_library(local_dobby STATIC IMPORTED)
set_target_properties(local_dobby PROPERTIES
IMPORTED_LOCATION ${CMAKE_CURRENT_SOURCE_DIR}/../jniLibs/arm64-v8a/libdobby.a
)
# ========================
# 编译优化与符号隐藏
# ========================
target_compile_options(${CMAKE_PROJECT_NAME} PRIVATE
-fvisibility=hidden
-fvisibility-inlines-hidden
-fdata-sections
-ffunction-sections
-O3
)
# 宏：可用于标记显式导出的函数
target_compile_definitions(${CMAKE_PROJECT_NAME} PRIVATE EXPORT_SYMBOLS)
# 控制符号可见性
set_target_properties(${CMAKE_PROJECT_NAME} PROPERTIES
CXX_VISIBILITY_PRESET hidden
VISIBILITY_INLINES_HIDDEN ON
POSITION_INDEPENDENT_CODE ON
)
# ========================
# 生成 version script (控制导出符号)
# ========================
set(EXPORTS_FILE "${CMAKE_CURRENT_BINARY_DIR}/exports.map")
file(WRITE ${EXPORTS_FILE}"{
global:
Java_*;
JNI_OnLoad;
JNI_OnUnload;
local:
*;
};
")
# ========================
# 修正后的链接参数（去掉分号问题）
# ========================
set(MY_EXTRA_LINKER_FLAGS
"-Wl,--version-script=${EXPORTS_FILE}"
"-Wl,--exclude-libs,ALL"
"-Wl,--gc-sections"
"-s"
)
# 把列表转换为空格分隔字符串（防止 CMake 用 ;）
string(REPLACE ";"" " MY_EXTRA_LINKER_FLAGS_STR "${MY_EXTRA_LINKER_FLAGS}")
# 追加到共享库链接参数
set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS}${MY_EXTRA_LINKER_FLAGS_STR}")
message(STATUS "CMAKE_SHARED_LINKER_FLAGS = ${CMAKE_SHARED_LINKER_FLAGS}")
# ========================
# 链接阶段
# ========================
target_link_libraries(${CMAKE_PROJECT_NAME}
android
local_dobby
log
)
编译完dobby hook之后我们会发现导出来的项目是没有自己的cpp代码的，我们需要自己添加
这一步Android Studio 会帮我们完成
但是 到了这一步 ，如果用Unity Editor目录里的NDK的话，编译的时候会各种报错，这个就非常离谱了，应为路径中带空格，并且Java 版本 以及ndk版本种种问题，导致在这一步卡了很久，但最后还是成功的编译出来了，(也许你不会出现这个BUG)
另外Cmake的版本也会影响，我在用高版本的Cmake的时候一直在报错，奇奇怪怪的，这里把launcher的build.gradle分享出来，大家遇到奇奇怪怪的报错也可以参考参考
复制代码 隐藏代码
// GENERATED BY UNITY. REMOVE THIS COMMENT TO PREVENT OVERWRITING WHEN EXPORTING AGAIN
apply plugin: 'com.android.application'
dependencies {
implementation project(':unityLibrary')
}
android {
compileSdkVersion 33
buildToolsVersion '30.0.2'
compileOptions {
sourceCompatibility JavaVersion.VERSION_1_8
targetCompatibility JavaVersion.VERSION_1_8
}
defaultConfig {
minSdkVersion 28
targetSdkVersion 33
applicationId 'com.DefaultCompany.just'
ndk {
abiFilters 'arm64-v8a'
}
versionCode 1
versionName '1.0'
}
externalNativeBuild {
cmake {
version "3.10.2"
path = "src/main/cpp/CMakeLists.txt"
}
}
aaptOptions {
noCompress = ['.ress', '.resource', '.obb'] + unityStreamingAssets.tokenize(', ')
ignoreAssetsPattern = "!.svn:!.git:!.ds_store:!*.scc:.*:!CVS:!thumbs.db:!picasa.ini:!*~"
}
lintOptions {
abortOnError false
}
buildTypes {
debug {
minifyEnabled false
proguardFiles getDefaultProguardFile('proguard-android.txt')
signingConfig signingConfigs.debug
jniDebuggable true
}
release {
minifyEnabled false
proguardFiles getDefaultProguardFile('proguard-android.txt')
signingConfig signingConfigs.debug
}
}
packagingOptions {
doNotStrip '*/arm64-v8a/*.so'
}
bundle {
language {
enableSplit = false
}
density {
enableSplit = false
}
abi {
enableSplit = true
}
}
}
接下来就是正式开始写Hook 代码了
我们在Unity palyer中需要加载我们用于加固的lib库，后通过JNI_Onload 或者 init_array 都可以，但JNI_Onload只有System.loadLibary才有效，如果是so中dlopen 比如自定义linker的话是需要自己给JNI_Onload传递JVM并且自己调用的，其实最推荐的还是卸载init_array，给我们的加载函数修饰成构造函数即可。
UnityPlayerActivity 中载入加固SO文件：
通过构造函数来调用Init_Hook：
复制代码 隐藏代码
__attribute__((constructor))
staticvoidOnLoad(){
LOGI("libjust.so loaded — initializing hook...");
InitHook();
}
使用 dobby hook 来 hook lib库的导出符号我们首先可以通过dlopen 这个lib库，然后通过dlsym来通过符号获取我们需要hook的导入函数的地址，随后初始化hook即可，这里展示一下我们hook libdl.so 获取dlopen 地址的办法。
Init_Hook 实现代码：
复制代码 隐藏代码
void* libdl = dlopen("libdl.so", RTLD_NOW);
if (!libdl) {
LOGE("InitHook: dlopen(libdl.so) failed");
return;
}
void* sym_dlopen = dlsym(libdl, "dlopen");
if (sym_dlopen) {
if (DobbyHook(sym_dlopen, (void*)my_dlopen, (void**)&orig_dlopen) == 0) {
LOGI("InitHook: Hooked dlopen");
} else {
LOGE("InitHook: DobbyHook dlopen failed");
}
} else {
LOGE("InitHook: dlsym dlopen failed");
}
这里我们知道dlopen的参数格式：dlopen(“path/to/libX.so”, flags)，似乎我们这样Hook只能够获取到加载so的路径，如果我们读取路径动态解密的话，解密的so就落地了，这并不是一种好方法，接下来我们思考解决这个问题的办法。
另外提一嘴，大多数加固厂商在此处可能就替换成自己的linker了，要写一个稳定的linker对于我目前的实力来说还是差点意思，所以这次时间我采用整体加密的方案，而不是用难度更高的linker。
言归正传我们要采用的技术为memfd（memfd 是内核提供的一种特殊文件描述符机制，它创建的文件不在磁盘上，而是在内存中。）
换句话说，这个文件是“存在于内存里的临时文件”，但是对系统来说它依然是一个合法的文件对象，可以被 dlopen 或 android_dlopen_ext 识别并加载。
memfd_create 返回的是一个文件描述符（fd），你可以对它 write 写数据、lseek、甚至 mmap。
当我们把解密后的 ELF 数据写进这个 memfd 之后，就等价于往一个真实文件里写入了一份 so。
而内核又在 /proc/self/fd/ 下提供了一个伪路径映射，比如 /proc/self/fd/37，指向这个 fd。
所以当我们在 dlopen 中传入这个路径时，loader 实际上是去读我们内存中的 ELF 数据，这样整个加载过程完全脱离了磁盘。
因此我们能在 Hook 的时候“偷梁换柱”——先拦截住目标 so 的加载，再把它替换成从 memfd 中加载。
在这个过程中，动态链接器完全不会察觉到区别，因为对它来说，只要能读到符合 ELF 格式的内容，它就能照常加载。
（老规矩，GPT来一张，方便理解
接下来是我的完整代码实现
复制代码 隐藏代码
// 用于表示我们是否把解密数据写进了 memfd
structPreparedMem {
int fd;
bool used_memfd;
PreparedMem(): fd(-1), used_memfd(false) {}
};
// 当且仅当 filename 可直接 open（包含 '/' 或 access 可读）时，读取文件、RC4 解密并写入 memfd（不落地）
static PreparedMem prepare_memfd_if_local_path(constchar* filename){
PreparedMem ret;
if (!filename) return ret;
bool has_slash = strchr(filename, '/') != nullptr;
if (!has_slash) {
if (access(filename, R_OK) != 0) {
// basename 且不可直接访问 — 放过 loader 去寻找实际路径
return ret;
}
}
int fd = open(filename, O_RDONLY);
if (fd < 0) {
// LOGE("prepare_memfd_if_local_path: open(%s) failed: %s", filename, strerror(errno));
return ret;
}
uint8_t header[4] = {0};
ssize_t rn = pread(fd, header, sizeof(header), 0);
if (rn == (ssize_t)sizeof(header) && is_elf_header(header, sizeof(header))) {
close(fd);
// LOGI("prepare_memfd_if_local_path: %s is already ELF", filename);
return ret;
}
structstat st;
if (fstat(fd, &st) != 0 || st.st_size <= 0) {
// LOGE("prepare_memfd_if_local_path: fstat failed or zero-size for %s", filename);
close(fd);
return ret;
}
size_t size = (size_t)st.st_size;
std::vector<uint8_t> buf(size);
ssize_t got = pread(fd, buf.data(), size, 0);
close(fd);
if (got != (ssize_t)size) {
// LOGE("prepare_memfd_if_local_path: read failed %zd/%zu", got, size);
return ret;
}
// LOGI("prepare_memfd_if_local_path: %s appears encrypted (len=%zu), decrypting to memfd...", filename, size);
// 用纯 RC4 解密（与你 Python 脚本一致）
rc4_crypt(buf.data(), buf.size(), (constuint8_t*)RC4_KEY, strlen(RC4_KEY));
int memfd = try_memfd_create("dec_il2cpp");
if (memfd < 0) {
// LOGE("prepare_memfd_if_local_path: memfd_create failed");
return ret;
}
ssize_t wrote = write(memfd, buf.data(), buf.size());
if (wrote != (ssize_t)buf.size()) {
// LOGE("prepare_memfd_if_local_path: write memfd failed %zd/%zu", wrote, buf.size());
close(memfd);
return ret;
}
lseek(memfd, 0, SEEK_SET);
// 验证 memfd 首 4 字节是 ELF（仅作 debug 保证）
uint8_t check_head[4] = {0};
ssize_t rn2 = pread(memfd, check_head, sizeof(check_head), 0);
if (rn2 == (ssize_t)sizeof(check_head)) {
if (is_elf_header(check_head, 4)) {
// LOGI("prepare_memfd_if_local_path: memfd contains valid ELF header");
} else {
// LOGE("prepare_memfd_if_local_path: memfd header NOT ELF: %02x %02x %02x %02x",
// check_head[0], check_head[1], check_head[2], check_head[3]);
// 但仍继续让 loader尝试（以便打印错误），不立即关闭 memfd here.
}
}
ret.fd = memfd;
ret.used_memfd = true;
LOGI("prepare_memfd_if_local_path: decrypted content written to memfd fd=%d", memfd);
return ret;
}
// 使用 memfd 加载：优先使用 android_dlopen_ext + ANDROID_DLEXT_USE_LIBRARY_FD。
// 注意：不要在 loader 调用前关闭 fd，loader 返回后再 close。
staticvoid* load_from_memfd(constchar* orig_path, int flag, PreparedMem &pm){
if (!pm.used_memfd || pm.fd < 0) returnnullptr;
void* handle = nullptr;
if (orig_android_dlopen_ext) {
android_dlextinfo info;
memset(&info, 0, sizeof(info));
// 设置 flags 为请求从 fd 加载
info.flags = ANDROID_DLEXT_USE_LIBRARY_FD;
// 将 memfd 放进正确字段
#if defined(HAVE_ANDROID_DLEXT_H)
// 当系统头已包含时字段布局与系统一致
info.library_fd = pm.fd;
#else
// 当使用我们的兼容 typedef 时同样写入 library_fd
info.library_fd = pm.fd;
#endif
handle = orig_android_dlopen_ext(orig_path, flag, &info);
if (handle) {
LOGI("load_from_memfd: loaded via android_dlopen_ext (fd=%d)", pm.fd);
} else {
LOGE("load_from_memfd: android_dlopen_ext failed: %s", dlerror());
}
} elseif (orig_dlopen) {
// fallback: dlopen("/proc/self/fd/N")
char procpath[64];
snprintf(procpath, sizeof(procpath), "/proc/self/fd/%d", pm.fd);
handle = orig_dlopen(procpath, flag);
if (handle) {
LOGI("load_from_memfd: loaded via dlopen(procfd) (fd=%d)", pm.fd);
} else {
LOGE("load_from_memfd: dlopen(procfd) failed: %s", dlerror());
}
} else {
LOGE("load_from_memfd: no original loader available");
}
return handle;
}
// Hooked dlopen
extern"C"void* my_dlopen(constchar* filename, int flag){
LOGI("my_dlopen intercept: %s", filename ? filename : "NULL");
PreparedMem pm = prepare_memfd_if_local_path(filename);
void* handle = nullptr;
if (pm.used_memfd && pm.fd >= 0) {
handle = load_from_memfd(filename, flag, pm);
// loader 返回后才 close fd
close(pm.fd);
pm.fd = -1;
pm.used_memfd = false;
if (handle) return handle;
}
if (orig_dlopen) {
handle = orig_dlopen(filename, flag);
} else {
LOGE("my_dlopen: orig_dlopen is null");
}
return handle;
}
至此，我们实现了一个简单的加密lib2cpp.so的功能，正如我如上代码，我们还加入了ELF头校验，这样我们在debug的时候一样可以运行。
对Unity IL转出来的CPP代码做混淆
这一步的话完全可以使用ollvm来编译，但是有没有更简单的呢，显然是有的
我们可以利用现成的项目
https://github.com/ac3ss0r/obfusheader.h
通过头文件来对项目代码进行混淆
项目生成的源代码的位置在
复制代码 隐藏代码
unityLibrary\src\main\Il2CppOutputProject\Source\il2cppOutput\Assembly-CSharp.cpp
我们直接导入obfusheader.h即可，但是这里可能obfusheader.h的部分写法会与你的编译版本冲突，需要人为修改的情况，这里你结合AI和报错看看哪些语法需要修改即可，多尝试几次。
结尾（附逆向过程
至此也就完成了一个简单的Unity加固，从萌生这个想法到实现前前后后花了几天，上班连续时间比较短，但现在AI发展趋势感觉学习的成本越来越低了，中途也各种编译报错给我整的犯恶心过，但好在都解决了。
最后附上这道题的逆向过程吧
逆向过程
il2cpp的app尝试il2cpp dumper
直接报错
发现libil2cpp.so是被加密的
在just.so 中发现了是hook了dlpen
找到dobbyhook真实函数并给他命名
注册的hook在这里
逆向发现是rc4^0x33
密钥是这个
解密Libil2cpp.so
复制代码 隐藏代码
#!/usr/bin/env python3
"""
rc4_encrypt.py
Usage:
python rc4_encrypt.py encrypt input.so output.so.enc
python rc4_encrypt.py decrypt input.so.enc output.so.dec
This script performs RC4 encryption/decryption (same operation).
Key: "nihaounity" by default (you can change or pass your own key).
"""
import sys
import os
DEFAULT_KEY = b"nihaounity"
defrc4(data: bytes, key: bytes) -> bytes:
"""Simple RC4 implementation (KSA + PRGA)."""
# Key-scheduling algorithm (KSA)
S = list(range(256))
j = 0
key_len = len(key)
if key_len == 0:
raise ValueError("Key must not be empty")
for i inrange(256):
j = (j + S[i] + key[i % key_len]) & 0xFF
S[i], S[j] = S[j], S[i]
# Pseudo-random generation algorithm (PRGA)
i = 0
j = 0
out = bytearray(len(data))
for n inrange(len(data)):
i = (i + 1) & 0xFF
j = (j + S[i]) & 0xFF
S[i], S[j] = S[j], S[i]
K = S[(S[i] + S[j]) & 0xFF]^ 0x33
out[n] = data[n] ^ K
returnbytes(out)
defprocess_file(mode: str, in_path: str, out_path: str, key: bytes):
ifnot os.path.isfile(in_path):
print(f"Input file not found: {in_path}")
sys.exit(2)
# Read input file
withopen(in_path, "rb") as f:
data = f.read()
# RC4 transform
transformed = rc4(data, key)
# Write output file (mode preserved with 0o644)
tmp_out = out_path + ".tmp"
withopen(tmp_out, "wb") as f:
f.write(transformed)
os.replace(tmp_out, out_path)
os.chmod(out_path, 0o644)
print(f"{mode.title()} finished: {in_path} -> {out_path}")
defprint_usage_and_exit():
print("Usage:")
print(" python rc4_encrypt.py encrypt input.so output.so.enc")
print(" python rc4_encrypt.py decrypt input.so.enc output.so.dec")
print("Optional: set RC4 key via environment variable RC4_KEY (bytes), or edit DEFAULT_KEY in script.")
sys.exit(1)
defmain():
iflen(sys.argv) != 4:
print_usage_and_exit()
mode = sys.argv[1].lower()
input_path = sys.argv[2]
output_path = sys.argv[3]
if mode notin ("encrypt", "decrypt"):
print_usage_and_exit()
# Allow overriding key via env var (as hex or raw). If RC4_KEY_HEX set, use hex decode.
env_key_hex = os.environ.get("RC4_KEY_HEX")
env_key_raw = os.environ.get("RC4_KEY")
if env_key_hex:
try:
key = bytes.fromhex(env_key_hex)
except Exception as e:
print("Invalid RC4_KEY_HEX:", e)
sys.exit(3)
elif env_key_raw:
key = env_key_raw.encode("utf-8")
else:
key = DEFAULT_KEY
process_file(mode, input_path, output_path, key)
if __name__ == "__main__":
main()
检查metadata可以发现是加密的
那么只能去il2cpp里面看了，那么metadata-loader（il2cpp官方源代码）中有一个字符串可以帮助我们定位逻辑
所以直接可以看到else后面的逻辑就是开始载入metadata了
看到解密逻辑，直接写解密脚本
复制代码 隐藏代码
#!/usr/bin/env python3
"""
il2cpp-style file "decryption" script that mirrors PromiseAntiencryption in C.
Usage:
python il2cpp_decrypt.py input_encrypted_file output_decrypted_file
"""
import sys
import struct
from pathlib import Path
SAFE_SIZE = 1024# 与 C 里一致
defdecrypt_file(in_path: str, out_path: str, little_endian: bool = True):
data = Path(in_path).read_bytes()
total_len = len(data)
if total_len < SAFE_SIZE + 4:
raise ValueError("文件过短，无法包含安全区和 mask header")
endian = "<"if little_endian else">"
u32 = endian + "I"
# 在 safe_size 偏移处读取 header uint32，低 16 位为 kl
header_val = struct.unpack_from(u32, data, SAFE_SIZE)[0]
kl = header_val & 0xffff
if kl <= 0:
raise ValueError(f"非法的 kl: {kl}")
# 计算偏移
mask_header_offset = SAFE_SIZE # header 在这里
mask_array_offset = mask_header_offset + 4# 紧跟 header
enc_data_offset = SAFE_SIZE + 4 * (kl + 1) # header + kl 个 uint32 后面就是加密数据
if total_len < enc_data_offset:
raise ValueError("文件太短，无法包含声明的 mask 数组和加密数据")
# 读取 mask 数组（kl 个 uint32）
mask = []
for i inrange(kl):
off = mask_array_offset + 4 * i
mask.append(struct.unpack_from(u32, data, off)[0])
# 加密数据长度（字节）
enc_len = total_len - enc_data_offset
# C 代码以 4 字节为单位处理 => 如果不是 4 的倍数，按可用长度处理（与 C 代码一致性依赖于源文件）
enc_len_trunc = enc_len - (enc_len % 4)
# 构造输出：先写 safe 区（原样 copy），然后写解密后的数据
out_bytes = bytearray()
out_bytes += data[0:SAFE_SIZE]
# 解密循环（每 4 字节）
# i 表示相对于 enc_data_offset 的字节偏移（0,4,8,...）
for i inrange(0, enc_len_trunc, 4):
# index = (i + (i // kl)) % kl （注意 C 中 i/kl 为整除）
idx = (i + (i // kl)) % kl
mask_word = mask[idx]
enc_word = struct.unpack_from(u32, data, enc_data_offset + i)[0]
plain_word = mask_word ^ enc_word
out_bytes += struct.pack(u32, plain_word)
# 如果 enc_len 不是 4 的倍数，C 版本实际上不会处理末尾不足 4 字节的部分（因为它步长为4）
# 为了安全，这里把原始残余字节忽略（与 C 行为一致）。如需保留未处理尾部，可取消下面注释。
# if enc_len % 4 != 0:
# out_bytes += data[enc_data_offset + enc_len_trunc : enc_data_offset + enc_len]
# 输出到文件
Path(out_path).write_bytes(bytes(out_bytes))
print(f"已写出解密结果: {out_path} (输出大小 {len(out_bytes)} 字节)")
defmain():
iflen(sys.argv) != 3:
print("用法: python il2cpp_decrypt.py input_encrypted_file output_decrypted_file")
sys.exit(2)
in_f = sys.argv[1]
out_f = sys.argv[2]
try:
decrypt_file(in_f, out_f, little_endian=True)
except Exception as e:
print("解密失败:", e)
sys.exit(1)
if __name__ == "__main__":
main()
解密后的改名回global-metadata.dat
然后使用il2cppdumper
dump成功载入符号,然后找到flagcheck，直接看逻辑
密文在这里下断点获取
自然Tea的key也需要调试获取或者frida Hook
但需要过Frida check
或者根据il2cpp特性
数据在这里初始化
4个int是tea key
40个byte是密文
C8E4E9E3F34C25560172B0D40B6DF4823260AA87EC6866054AA4691711E5D7BF
找到哈希
在il2cppdumper生成的dump.cs中查找
找到offset，然后直接静态dump
复制代码 隐藏代码
#!/usr/bin/env python3
import argparse
import os
import sys
from pathlib import Path
import textwrap
import binascii
DEFAULTS = [
# (offset, size, shortname)
(0xF901D, 40, "29FC2CC7_40"), # your __StaticArrayInitTypeSize=40 29FC2...
(0xF9045, 16, "C8E4E9E3_16"), # your __StaticArrayInitTypeSize=16 C8E4...
]
defparse_extra(s):
# format: offset:size:name (offset can be hex with 0x)
parts = s.split(":")
iflen(parts) < 2:
raise ValueError("extra must be offset:size[:name]")
off = int(parts[0], 0)
size = int(parts[1], 0)
name = parts[2] iflen(parts) >= 3elsef"blob_{off:X}"
return (off, size, name)
defto_csharp_byte_array(b: bytes, per_line=16):
hexs = [f"0x{c:02X}"for c in b]
lines = []
for i inrange(0, len(hexs), per_line):
lines.append(", ".join(hexs[i:i+per_line]))
joined = (",\n ").join(lines)
return"new byte[] {\n " + joined + "\n};"
defmain():
p = argparse.ArgumentParser(description="Extract raw blobs from global-metadata.dat by offset+size.")
p.add_argument("--meta", "-m", required=True, help="Path to global-metadata.dat")
p.add_argument("--outdir", "-o", default="extracted_private_impl", help="Output directory")
p.add_argument("--extra", "-e", action="append", help="Extra offset:size[:name] (hex allowed), repeatable")
p.add_argument("--defaults", action="store_true", help="Also extract script's built-in defaults")
args = p.parse_args()
meta_path = Path(args.meta)
ifnot meta_path.is_file():
print("Error: metadata file not found:", meta_path)
sys.exit(2)
outdir = Path(args.outdir)
outdir.mkdir(parents=True, exist_ok=True)
targets = []
if args.defaults ornot args.extra:
# Add defaults if requested or if no extras provided
targets.extend(DEFAULTS)
if args.extra:
for s in args.extra:
try:
t = parse_extra(s)
except Exception as ex:
print("Failed to parse extra:", s, ex)
sys.exit(2)
targets.append(t)
print(f"Reading metadata: {meta_path}")
withopen(meta_path, "rb") as f:
metadata = f.read()
meta_len = len(metadata)
print(f"Metadata length: {meta_len} bytes\n")
for off, size, name in targets:
if off < 0or off >= meta_len:
print(f"[!] Offset 0x{off:X} out of range (file size {meta_len}): skipping {name}")
continue
# defensive: don't read past EOF
read_size = min(size, meta_len - off)
if read_size <= 0:
print(f"[!] Nothing to read at 0x{off:X} for {name}")
continue
blob = metadata[off:off+read_size]
binfname = outdir / f"{name}_0x{off:X}_len{read_size}.bin"
withopen(binfname, "wb") as out:
out.write(blob)
print(f"[+] Extracted {name}: offset=0x{off:X}, size={read_size} -> {binfname}")
# print hex preview (first 256 bytes)
preview = binascii.hexlify(blob[:256]).decode()
spaced = " ".join(preview[i:i+2] for i inrange(0, len(preview), 2))
print(" preview:", spaced if spaced else"(empty)")
# print as C# initializer
cs = to_csharp_byte_array(blob)
print("\n C# byte[] initializer:\n")
print(textwrap.indent(cs, " "))
print("\n" + ("-"*60) + "\n")
print("Done. Files saved under:", outdir.resolve())
if __name__ == "__main__":
main()
还原出来的加密逻辑就如下
复制代码 隐藏代码
#include<cstdio>
#include<cmath>
#include<map>
#include<vector>
#include<queue>
#include<stack>
#include<set>
#include<string>
#include<cstring>
#include<list>
#include<stdlib.h>
using namespace std;
typedefint status;
typedefint selemtype;
unsignedint Key[7] = {0x12345678, 0x09101112, 0x13141516, 0x15161718};
voidtea_encrypt(uint32_t *v, uint32_t *k) {
printf("%X %X\n",v[0],v[1]);
uint32_t v0 = v[0], v1 = v[1], sum = 0, i;
uint32_t delta = 0x61C88647;
for (i = 0; i < 16; i++) {
v0 += ((v1 << 4) + k[0]) ^ (v1 + sum) ^ ((v1 >> 5) + k[1]);
v1 += ((v0 << 4) + k[2]) ^ (v0 + sum) ^ ((v0 >> 5) + k[3]);
sum -= delta;
}
v[0] = v0;
v[1] = v1;
}
unsignedchar Cipher[256] = "flag{unitygame_I5S0ooFunny_Isnotit?????}";
unsignedint Tmp[4] = {0};
intmain() {
unsignedint *p1 = (unsignedint *)(Cipher);
unsignedint *p2 = (unsignedint *)(Cipher + 4);
printf("%s\n", Cipher);
Tmp[0] = *p1, Tmp[1] = *p2;
tea_encrypt(Tmp, Key);
printf("%X %X\n", *p1, *p2);
*p1 = Tmp[0];
*p2 = Tmp[1];
for (int i = 2 ; i < strlen((char*) Cipher) / 4 ; i += 2 ) {
tea_encrypt(Tmp, Key);
*p1 = Tmp[0];
*p2 = Tmp[1];
// printf("%X %X\n", *p1, *p2);
unsignedint *p3 = (unsignedint *)(Cipher + i * 4);
unsignedint *p4 = (unsignedint *)(Cipher + i * 4 + 4);
*p3 ^= *p1;
*p4 ^= *p2;
};
for (int i = 0 ; i < 40 ; i ++ ) {
printf("0x%X,", Cipher[i]);
}
}
写解密逻辑如下：
复制代码 隐藏代码
#include<cstdio>
#include<cstring>
#include<cstdint>
#include<iostream>
using namespace std;
unsignedint Key[6] = {0x12345678, 0x09101112, 0x13141516, 0x15161718};
voidtea_decrypt(uint32_t *v, uint32_t *k) {
// printf("%X %X\n",v[0],v[1]);
uint32_t v0 = v[0], v1 = v[1], sum = 0, i;
uint32_t delta = 0x61C88647;
for (int i = 0 ; i < 16 ; i ++ ) sum -= 0x61C88647;
for (i = 0; i < 16; i++) {
sum += delta;
v1 -= ((v0 << 4) + k[2]) ^ (v0 + sum) ^ ((v0 >> 5) + k[3]);
v0 -= ((v1 << 4) + k[0]) ^ (v1 + sum) ^ ((v1 >> 5) + k[1]);
}
v[0] = v0;
v[1] = v1;
}
unsignedint Tmp[4] = {0};
intmain() {
unsignedchar EncryptedCipher[45] = {
0xAF,0x58,0x64,0x40,0x9D,0xB9,0x21,0x67,0xAE,0xB5,0x29,0x4,0x9E,0x86,0xC5,0x43,0x23,0xF,0xBF,0xA6,0xB2,0xAE,0x4A,0xB5,0xC5,0x69,0xB7,0xA8,0x3,0xD1,0xAE,0xCF,0xC6,0x2C,0x5B,0x7F,0xA2,0x86,0x1E,0x1A, };
unsignedint *p1 = (unsignedint *)(EncryptedCipher);
unsignedint *p2 = (unsignedint *)(EncryptedCipher + 4);
for (int i = 8 ; i >= 2 ; i -= 2) {
unsignedint *p3 = (unsignedint *)(EncryptedCipher + i * 4);
unsignedint *p4 = (unsignedint *)(EncryptedCipher + i * 4 + 4);
*p3 ^= *p1;
*p4 ^= *p2;
puts((char*)EncryptedCipher);
Tmp[0] = *p1, Tmp[1] = *p2;
tea_decrypt(Tmp, Key);
*p1 = Tmp[0], *p2 = Tmp[1];
}
Tmp[0] = *p1, Tmp[1] = *p2;
tea_decrypt(Tmp, Key);
*p1 = Tmp[0], *p2 = Tmp[1];
puts((char*)EncryptedCipher);
}
拿到flag：flag{unitygame_I5S0ooFunny_Isnotit?????}
至此全文完。
·今 日 推 荐·
本文内容来自网络，如有侵权请联系删除
免责声明：
本文所载程序、技术方法仅面向合法合规的安全研究与教学场景，旨在提升网络安全防护能力，具有明确的技术研究属性。
任何单位或个人未经授权，将本文内容用于攻击、破坏等非法用途的，由此引发的全部法律责任、民事赔偿及连带责任，均由行为人独立承担，本站不承担任何连带责任。
本站内容均为技术交流与知识分享目的发布，若存在版权侵权或其他异议，请通过邮件联系处理，具体联系方式可点击页面上方的联系我。
本文转载自：逆向有你 Shangwendada《安卓逆向 — 记录一次Unity加固的探索与实现》