文章总结： 本文详细解析了MagiskRoot隐藏方案Shamiko模块的技术原理与实现机制。该模块基于Zygisk框架开发，通过Hook系统调用、伪造系统属性、隐藏Root相关文件和进程等方式绕过各类检测。文章提供了完整的安装配置指南，包括白名单模式设置方法，并深入分析了其核心代码实现逻辑，展示了文件系统隐藏、属性伪造和进程隐藏的具体技术细节。 综合评分： 85 文章分类： 免杀,移动安全,红队,内网渗透,安全工具
Magisk Root隐藏方案：Shamiko模块原理解析
哆啦安全
2025年11月1日 10:23 四川
在小说阅读器读本章
去阅读
以下文章来源于一枚酸心果子 ，作者果子
一枚酸心果子 .
不定期的分享和记录，授人以鱼也可以授人以渔，有想看的case欢迎私聊果子
“
在Magisk Root隐藏技术中，Shamiko模块是最强大的隐藏方案之一。本篇会简单说明他的安装方法以及深入分析Shamiko模块的技术原理，再说明他的反检测机制。
Shamiko模块概述
模块基本信息
开发团队：LSPosed团队
技术基础：基于Zygisk框架
主要功能：绕过各种Root检测
核心特性
- 绕过SafetyNet检测
- 绕过银行APP检测
- 绕过游戏反作弊检测
- 支持多种检测方法绕过
- 基于Zygisk框架实现
Shamiko安装方法：
1. 下载Shamiko模块
- github地址：https://github.com/LSPosed/Shamiko
- 从LSPosed团队官方渠道下载最新版本的Shamiko模块。
2. 安装Shamiko模块 地址：https://magiskcn.com/shamiko-install.html
-
打开Magisk Manager应用。
-
打开 Magisk – 设置 – 开启 Zygisk
-
模块 – 从本地安装
-
选择下载的Shamiko模块文件。
-
安装好 Shamiko 模块，选择隐藏模式（推荐白名单模式）
3. 推荐使用白名单模式 地址：https://magiskcn.com/shamiko-whitelist.html
- 打开目录 /data/adb/shamiko （推荐使用MT管理器）
- 创建 whitelist 文件（是文件，不是文件夹。不要搞错了哦）
- 重启手机，确认已切换成功
Shamiko技术原理
核心隐藏机制
应用检测Root → Shamiko拦截 → 伪造系统信息 → 返回正常结果
↓
检测su命令 → 隐藏su文件 → 返回不存在
↓
检测Root属性 → 伪造属性值 → 返回正常值
↓
检测Root进程 → 隐藏进程信息 → 返回空列表
技术架构
Zygote进程启动 → 加载Shamiko模块 → Hook系统调用 → 隐藏Root特征
↓
应用进程启动 → 继承Shamiko Hook → 自动隐藏Root → 绕过检测
↓
API调用拦截 → 伪造返回值 → 应用无法检测到Root
Shamiko核心实现
1. 模块初始化
// Shamiko模块初始化
int shamiko_init() {
// 初始化Shamiko环境
if (init_shamiko_env() != 0) {
return-1;
}
// 注册系统调用Hook
if (register_syscall_hooks() != 0) {
return-1;
}
// 启用API Hook
if (enable_api_hooks() != 0) {
return-1;
}
// 启用属性伪造
if (enable_prop_fake() != 0) {
return-1;
}
return0;
}
// 初始化Shamiko环境
int init_shamiko_env() {
// 创建Shamiko工作目录
mkdir("/data/adb/shamiko", 0755);
// 加载配置文件
if (load_shamiko_config() != 0) {
return-1;
}
// 初始化隐藏规则
if (init_hide_rules() != 0) {
return-1;
}
return0;
}
2. 系统调用Hook
// 注册系统调用Hook
int register_syscall_hooks() {
// Hook文件系统相关系统调用
hook_syscall(__NR_openat, shamiko_openat);
hook_syscall(__NR_faccessat, shamiko_faccessat);
hook_syscall(__NR_stat, shamiko_stat);
hook_syscall(__NR_newfstatat, shamiko_newfstatat);
hook_syscall(__NR_readlinkat, shamiko_readlinkat);
// Hook进程相关系统调用
hook_syscall(__NR_kill, shamiko_kill);
hook_syscall(__NR_tgkill, shamiko_tgkill);
hook_syscall(__NR_tkill, shamiko_tkill);
// Hook属性相关系统调用
hook_syscall(__NR_getprop, shamiko_getprop);
hook_syscall(__NR_setprop, shamiko_setprop);
return0;
}
3. 文件系统隐藏
// Shamiko文件系统隐藏实现
long shamiko_openat(struct pt_regs *regs) {
int dirfd = regs->di;
constchar *pathname = (constchar *)regs->si;
int flags = regs->dx;
mode_t mode = regs->r10;
// 检查是否为Root相关文件
if (is_root_file(pathname)) {
// 返回文件不存在
regs->ax = -ENOENT;
return0;
}
// 检查是否为su命令
if (strstr(pathname, "su") != NULL) {
// 重定向到不存在的文件
regs->ax = -ENOENT;
return0;
}
// 检查是否为Magisk相关文件
if (strstr(pathname, "magisk") != NULL) {
// 重定向到不存在的文件
regs->ax = -ENOENT;
return0;
}
// 正常文件访问
return original_openat(regs);
}
// 判断是否为Root相关文件
bool is_root_file(const char *pathname) {
constchar *root_files[] = {
"/system/app/Superuser.apk",
"/sbin/su",
"/system/bin/su",
"/system/xbin/su",
"/data/local/xbin/su",
"/data/local/bin/su",
"/system/etc/init.d/99SuperSUDaemon",
"/dev/com.koushikdutta.superuser.daemon/",
"/system/app/Kinguser.apk",
"/system/app/KingRoot.apk",
"/system/app/360Root.apk",
"/data/local/tmp/su",
"/data/local/tmp/daemonsu",
"/system/bin/.ext/.su",
"/system/usr/we-need-root/su-backup",
"/system/xbin/busybox",
"/system/bin/busybox"
};
for (int i = 0; i < sizeof(root_files)/sizeof(root_files[0]); i++) {
if (strcmp(pathname, root_files[i]) == 0) {
returntrue;
}
}
// 检查路径模式
if (strstr(pathname, "su") != NULL) {
returntrue;
}
if (strstr(pathname, "magisk") != NULL) {
returntrue;
}
if (strstr(pathname, "superuser") != NULL) {
returntrue;
}
returnfalse;
}
4. 系统属性伪造
// Shamiko系统属性伪造实现
long shamiko_getprop(struct pt_regs *regs) {
constchar *name = (constchar *)regs->di;
char *value = (char *)regs->si;
constchar *default_value = (constchar *)regs->dx;
// 检查是否为Root相关属性
if (is_root_prop(name)) {
// 返回伪造的属性值
strcpy(value, get_fake_prop_value(name));
regs->ax = 0;
return0;
}
// 正常属性获取
return original_getprop(regs);
}
// 判断是否为Root相关属性
bool is_root_prop(const char *name) {
constchar *root_props[] = {
"ro.debuggable",
"ro.secure",
"ro.build.selinux",
"ro.magisk.version",
"ro.boot.magisk",
"persist.magisk.version",
"ro.zygisk.version",
"ro.boot.zygisk",
"persist.zygisk.version",
"ro.build.tags",
"ro.build.type",
"ro.kernel.qemu",
"ro.hardware",
"ro.product.cpu.abi",
"ro.product.cpu.abilist",
"ro.product.cpu.abilist32",
"ro.product.cpu.abilist64"
};
for (int i = 0; i < sizeof(root_props)/sizeof(root_props[0]); i++) {
if (strcmp(name, root_props[i]) == 0) {
returntrue;
}
}
// 检查属性名模式
if (strstr(name, "magisk") != NULL) {
returntrue;
}
if (strstr(name, "zygisk") != NULL) {
returntrue;
}
if (strstr(name, "su") != NULL) {
returntrue;
}
returnfalse;
}
// 获取伪造的属性值
const char* get_fake_prop_value(const char *name) {
if (strcmp(name, "ro.debuggable") == 0) {
return"0";
} elseif (strcmp(name, "ro.secure") == 0) {
return"1";
} elseif (strcmp(name, "ro.build.selinux") == 0) {
return"1";
} elseif (strcmp(name, "ro.build.tags") == 0) {
return"release-keys";
} elseif (strcmp(name, "ro.build.type") == 0) {
return"user";
} elseif (strcmp(name, "ro.kernel.qemu") == 0) {
return"0";
} elseif (strstr(name, "magisk") != NULL) {
return"";
} elseif (strstr(name, "zygisk") != NULL) {
return"";
} elseif (strstr(name, "su") != NULL) {
return"";
}
return"1";
}
5. 进程隐藏
// Shamiko进程隐藏实现
long shamiko_kill(struct pt_regs *regs) {
pid_t pid = regs->di;
int sig = regs->si;
// 检查是否为Root相关进程
if (is_root_process(pid)) {
// 隐藏进程，不执行kill操作
regs->ax = 0;
return0;
}
// 正常进程操作
return original_kill(regs);
}
// 判断是否为Root相关进程
bool is_root_process(pid_t pid) {
char path[256];
char cmdline[256];
snprintf(path, sizeof(path), "/proc/%d/cmdline", pid);
FILE *fp = fopen(path, "r");
if (fp == NULL) returnfalse;
fgets(cmdline, sizeof(cmdline), fp);
fclose(fp);
// 检查进程名
constchar *root_processes[] = {
"su",
"daemonsu",
"magisk",
"magiskd",
"magiskhide",
"zygisk",
"shamiko",
"kinguser",
"kingroot",
"360root",
"rootmaster"
};
for (int i = 0; i < sizeof(root_processes)/sizeof(root_processes[0]); i++) {
if (strstr(cmdline, root_processes[i]) != NULL) {
returntrue;
}
}
returnfalse;
}
6. API Hook实现
// Shamiko API Hook实现
int enable_api_hooks() {
// Hook Java层API
if (hook_java_apis() != 0) {
return-1;
}
// Hook Native层API
if (hook_native_apis() != 0) {
return-1;
}
return0;
}
// Hook Java层API
int hook_java_apis() {
// Hook SystemProperties.get
if (hook_java_method("android.os.SystemProperties", "get",
"(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;",
(void*)shamiko_system_properties_get) != 0) {
return-1;
}
// Hook File.exists
if (hook_java_method("java.io.File", "exists", "()Z",
(void*)shamiko_file_exists) != 0) {
return-1;
}
// Hook ProcessBuilder
if (hook_java_method("java.lang.ProcessBuilder", "start", "()Ljava/lang/Process;",
(void*)shamiko_process_builder_start) != 0) {
return-1;
}
return0;
}
// Hook SystemProperties.get
jstring shamiko_system_properties_get(JNIEnv *env, jclass clazz, jstring key, jstring def) {
constchar *key_str = (*env)->GetStringUTFChars(env, key, NULL);
constchar *def_str = (*env)->GetStringUTFChars(env, def, NULL);
// 检查是否为Root相关属性
if (is_root_prop(key_str)) {
// 返回伪造的属性值
constchar *fake_value = get_fake_prop_value(key_str);
jstring result = (*env)->NewStringUTF(env, fake_value);
(*env)->ReleaseStringUTFChars(env, key, key_str);
(*env)->ReleaseStringUTFChars(env, def, def_str);
return result;
}
// 正常属性获取
jstring result = original_system_properties_get(env, clazz, key, def);
(*env)->ReleaseStringUTFChars(env, key, key_str);
(*env)->ReleaseStringUTFChars(env, def, def_str);
return result;
}
// Hook File.exists
jboolean shamiko_file_exists(JNIEnv *env, jobject thiz) {
// 获取文件路径
jclass file_class = (*env)->GetObjectClass(env, thiz);
jfieldID path_field = (*env)->GetFieldID(env, file_class, "path", "Ljava/lang/String;");
jstring path_obj = (jstring)(*env)->GetObjectField(env, thiz, path_field);
constchar *path_str = (*env)->GetStringUTFChars(env, path_obj, NULL);
// 检查是否为Root相关文件
if (is_root_file(path_str)) {
(*env)->ReleaseStringUTFChars(env, path_obj, path_str);
return JNI_FALSE;
}
// 正常文件检查
jboolean result = original_file_exists(env, thiz);
(*env)->ReleaseStringUTFChars(env, path_obj, path_str);
return result;
}
Shamiko检测绕过
1. 传统检测绕过
// 传统Root检测绕过
publicclass TraditionalRootDetector {
public boolean isRooted() {
return checkRootFiles() ||
checkRootProps() ||
checkRootProcesses();
}
private boolean checkRootFiles() {
String[] rootFiles = {
"/system/app/Superuser.apk",
"/sbin/su",
"/system/bin/su",
"/system/xbin/su"
};
for (String file : rootFiles) {
if (new File(file).exists()) {
returntrue;
}
}
returnfalse;
}
private boolean checkRootProps() {
String[] rootProps = {
"ro.debuggable",
"ro.secure",
"ro.build.selinux"
};
for (String prop : rootProps) {
String value = SystemProperties.get(prop, "1");
if ("0".equals(value)) {
returntrue;
}
}
returnfalse;
}
}
2. 现代检测绕过
// 现代Root检测绕过
publicclass ModernRootDetector {
public boolean isRooted() {
return checkMagisk() ||
checkZygisk() ||
checkShamiko() ||
checkRuntimeDetection();
}
private boolean checkMagisk() {
// 检测Magisk特征
if (checkMagiskProps()) returntrue;
if (checkMagiskFiles()) returntrue;
if (checkMagiskModules()) returntrue;
returnfalse;
}
private boolean checkZygisk() {
// 检测Zygisk特征
if (checkZygiskProps()) returntrue;
if (checkZygiskFiles()) returntrue;
if (checkZygiskModules()) returntrue;
returnfalse;
}
private boolean checkShamiko() {
// 检测Shamiko特征
if (checkShamikoProps()) returntrue;
if (checkShamikoFiles()) returntrue;
if (checkShamikoModules()) returntrue;
returnfalse;
}
}
3. 反检测绕过
// 反检测绕过
publicclass AntiDetection {
// Hook系统属性获取
public static String getSystemProperty(String key, String defaultValue) {
// 返回伪造的属性值
if (isRootProp(key)) {
return getFakePropValue(key);
}
return SystemProperties.get(key, defaultValue);
}
// Hook文件存在检查
public static boolean fileExists(String path) {
// 隐藏Root相关文件
if (isRootFile(path)) {
returnfalse;
}
returnnew File(path).exists();
}
// Hook进程检查
public static boolean isProcessRunning(String processName) {
// 隐藏Root相关进程
if (isRootProcess(processName)) {
returnfalse;
}
return checkProcessRunning(processName);
}
}
结语
Shamiko模块是很强大的Root隐藏方案，通过全面的系统调用Hook和API拦截，几乎可以绕过所有常见的Root检测。其技术原理基于Zygisk框架，在Zygote进程启动时加载，影响所有应用进程。
它的核心实现原理机制：基于Zygisk框架的系统调用Hook
免责声明：
本文所载程序、技术方法仅面向合法合规的安全研究与教学场景，旨在提升网络安全防护能力，具有明确的技术研究属性。
任何单位或个人未经授权，将本文内容用于攻击、破坏等非法用途的，由此引发的全部法律责任、民事赔偿及连带责任，均由行为人独立承担，本站不承担任何连带责任。
本站内容均为技术交流与知识分享目的发布，若存在版权侵权或其他异议，请通过邮件联系处理，具体联系方式可点击页面上方的联系我。
本文转载自：哆啦安全 《Magisk Root隐藏方案：Shamiko模块原理解析》
版权声明
本站仅做备份收录，仅供研究与教学参考之用。
读者将信息用于其他用途的，全部法律及连带责任由读者自行承担，本站不承担任何责任。
评论