KernelSu Root 方案分析

 1int __init kernelsu_init(void)
 2{
 3    // 1. 检测是否为延迟加载（late load）
 4    ksu_late_loaded = (current->pid != 1);
 5
 6    // 2. 准备 root 凭证结构
 7    ksu_cred = prepare_creds();
 8
 9    // 3. 初始化各子系统
10    ksu_feature_init();           // 功能开关系统
11    ksu_supercalls_init();        // IOCTL 接口
12    ksu_syscall_hook_manager_init(); // 系统调用 hook
13    ksu_allowlist_init();         // 白名单
14    ksu_throne_tracker_init();    // Manager 验证
15
16    if (ksu_late_loaded) {
17        // 延迟加载模式：立即应用 SELinux 规则
18        apply_kernelsu_rules();
19        escape_to_root_for_init();  // 授予当前进程（ksud）root
20        ksu_load_allow_list();      // 加载持久化白名单
21    } else {
22        // 正常启动：注册 kprobe hook
23        ksu_ksud_init();
24    }
25
26    return 0;
27}

 1int ksu_install_fd(void)
 2{
 3    // 1. 获取未使用的 fd
 4    fd = get_unused_fd_flags(O_CLOEXEC);
 5
 6    // 2. 创建匿名 inode，名称为 "[ksu_driver]"
 7    filp = anon_inode_getfile("[ksu_driver]", &anon_ksu_fops, NULL,
 8                              O_RDWR | O_CLOEXEC);
 9
10    // 3. 安装 fd 到进程
11    fd_install(fd, filp);
12
13    return fd;
14}

 1bool allowed_for_su(void)
 2{
 3    // Manager 或白名单内的 UID
 4    return is_manager() || ksu_is_allow_uid_for_current(current_uid().val);
 5}
 6
 7bool manager_or_root(void)
 8{
 9    return current_uid().val == 0 || is_manager();
10}

 1void escape_with_root_profile(void)
 2{
 3    struct cred *cred;
 4    struct root_profile profile;
 5
 6    // 1. 准备新的凭证结构（COW - Copy on Write）
 7    cred = prepare_creds();
 8
 9    // 2. 获取该 UID 的 root profile 配置
10    ksu_get_root_profile(cred->uid.val, &profile);
11
12    // 3. 修改 UID/GID 为 profile 指定值（通常是 0）
13    cred->uid.val = profile.uid;
14    cred->suid.val = profile.uid;
15    cred->euid.val = profile.uid;
16    cred->fsuid.val = profile.uid;
17
18    cred->gid.val = profile.gid;
19    cred->fsgid.val = profile.gid;
20    cred->sgid.val = profile.gid;
21    cred->egid.val = profile.gid;
22
23    // 4. 更新 user_struct（进程计数）
24    new_user = alloc_uid(cred->uid);
25    free_uid(cred->user);
26    cred->user = new_user;
27
28    // 5. 设置 capabilities（全权限）
29    u64 cap_for_ksud = profile.capabilities.effective | CAP_DAC_READ_SEARCH;
30    memcpy(&cred->cap_effective, &cap_for_ksud, sizeof(cred->cap_effective));
31    memcpy(&cred->cap_permitted, &profile.capabilities.effective,
32           sizeof(cred->cap_permitted));
33
34    // 6. 设置附加组
35    setup_groups(&profile, cred);
36
37    // 7. 切换 SELinux domain 到 "u:r:su:s0"
38    setup_selinux(profile.selinux_domain, cred);
39
40    // 8. 提交凭证（原子操作）
41    commit_creds(cred);
42
43    // 9. 禁用 seccomp 过滤器
44    disable_seccomp();
45
46    // 10. 标记所有线程启用 syscall tracepoint
47    for_each_thread (p, t) {
48        ksu_set_task_tracepoint_flag(t);
49    }
50
51    // 11. 设置 mount namespace
52    setup_mount_ns(profile.namespaces);
53}

1struct root_profile {
2    uid_t uid;                      // 目标 UID（通常是 0）
3    gid_t gid;                      // 目标 GID
4    u32 groups_count;               // 附加组数量
5    gid_t groups[KSU_MAX_GROUPS];   // 附加组列表
6    struct kernel_cap_struct capabilities; // Capability 集合
7    char selinux_domain[64];        // SELinux context
8    u32 namespaces;                 // 命名空间选项
9};

1void ksu_set_task_tracepoint_flag(struct task_struct *t)
2{
3#if LINUX_VERSION_CODE >= KERNEL_VERSION(5, 11, 0)
4    set_task_syscall_work(t, SYSCALL_TRACEPOINT);
5#else
6    set_tsk_thread_flag(t, TIF_SYSCALL_TRACEPOINT);
7#endif
8}

 1int ksu_handle_execve_sucompat(const char __user **filename_user, ...)
 2{
 3    char path[32];
 4
 5    // 1. 检查是否为白名单 UID
 6    if (!ksu_is_allow_uid_for_current(current_uid().val))
 7        return 0;
 8
 9    // 2. 读取要执行的文件路径
10    strncpy_from_user_nofault(path, *filename_user, sizeof(path));
11
12    // 3. 检测是否为 "/system/bin/su"
13    if (memcmp(path, "/system/bin/su", 15) == 0) {
14        pr_info("sys_execve su found\n");
15
16        // 4. 重定向到 ksud
17        *filename_user = ksud_user_path();  // "/data/adb/ksud"
18
19        // 5. 立即提权！
20        escape_with_root_profile();
21    }
22
23    return 0;
24}

 1int ksu_handle_stat(int *dfd, const char __user **filename_user, int *flags)
 2{
 3    if (!ksu_is_allow_uid_for_current(current_uid().val))
 4        return 0;
 5
 6    char path[32];
 7    strncpy_from_user_nofault(path, *filename_user, sizeof(path));
 8
 9    // 将 stat("/system/bin/su") 重定向到 stat("/system/bin/sh")
10    if (memcmp(path, "/system/bin/su", 15) == 0) {
11        *filename_user = sh_user_path();  // "/system/bin/sh"
12    }
13
14    return 0;
15}

 1// 1. Bitmap（快速查询，UID ≤ 65535）
 2static uint8_t allow_list_bitmap[PAGE_SIZE] __read_mostly;
 3#define BITMAP_UID_MAX ((sizeof(allow_list_bitmap) * 8) - 1)  // 32767
 4
 5// 2. 数组（大 UID 备用，> 65535）
 6static int allow_list_arr[PAGE_SIZE / sizeof(int)] __read_mostly;
 7
 8// 3. 链表（完整配置信息）
 9struct perm_data {
10    struct list_head list;
11    struct rcu_head rcu;
12    struct app_profile profile;  // 包含 root_profile 或 non_root_profile
13};
14static struct list_head allow_list;

 1bool __ksu_is_allow_uid(uid_t uid)
 2{
 3    // 1. 拒绝系统 UID（< 2000 且 != 1000）
 4    if (forbid_system_uid(uid))
 5        return false;
 6
 7    // 2. Manager 总是允许
 8    if (ksu_get_manager_appid() == uid % PER_USER_RANGE)
 9        return true;
10
11    // 3. Bitmap 快速查询（O(1)）
12    if (likely(uid <= BITMAP_UID_MAX)) {
13        return !!(allow_list_bitmap[uid / 8] & (1 << (uid % 8)));
14    }
15
16    // 4. 数组线性查询（大 UID）
17    for (i = 0; i < allow_list_pointer; i++) {
18        if (allow_list_arr[i] == uid)
19            return true;
20    }
21
22    return false;
23}

1#define KERNEL_SU_ALLOWLIST "/data/adb/ksu/.allowlist"
2
3// 文件格式：
4// [u32: MAGIC=0x7f4b5355] [u32: VERSION=3] [app_profile] [app_profile] ...

 1#define KERNEL_SU_DOMAIN "su"
 2
 3void setup_selinux(const char *domain, struct cred *cred)
 4{
 5    u32 sid;
 6
 7    // 1. 查询 domain 对应的 SID（Security ID）
 8    int err = ksu_security_secctx_to_secid(domain, strlen(domain), &sid);
 9
10    // 2. 设置进程的 SELinux context
11    struct task_security_struct *tsec = cred->security;
12    tsec->sid = sid;
13    tsec->osid = sid;
14    tsec->exec_sid = 0;
15    tsec->create_sid = 0;
16    tsec->keycreate_sid = 0;
17    tsec->sockcreate_sid = 0;
18}

 1pub fn run() -> Result<()> {
 2    let args: Vec<String> = env::args().collect();
 3    let program = &args[0];
 4
 5    match program.as_str() {
 6        // Root shell 模式
 7        "su" | "/system/bin/su" => {
 8            grant_root(false)?;  // 调用 ksucalls::grant_root()
 9        },
10
11        // ksud 守护模式
12        _ => {
13            let cmd = args.get(1).map(|s| s.as_str());
14            match cmd {
15                Some("post-fs-data") => init_event::on_post_fs_data(),
16                Some("services") => init_event::on_services(),
17                Some("boot-completed") => init_event::on_boot_completed(),
18                Some("install") => module::install_module(&args[2]),
19                Some("module") => module::handle_module_action(&args[2..]),
20                _ => print_usage(),
21            }
22        }
23    }
24}

 1// 全局 FD 缓存
 2static DRIVER_FD: OnceLock<RawFd> = OnceLock::new();
 3
 4// 初始化 FD
 5fn init_driver_fd() -> Option<RawFd> {
 6    // 1. 扫描 /proc/self/fd 查找 [ksu_driver]
 7    let fd = scan_driver_fd();
 8    if fd.is_none() {
 9        // 2. 使用魔数调用 reboot syscall
10        let mut fd = -1;
11        unsafe {
12            libc::syscall(
13                libc::SYS_reboot,
14                0xDEADBEEF,  // KSU_INSTALL_MAGIC1
15                0xCAFEBABE,  // KSU_INSTALL_MAGIC2
16                0,
17                &mut fd,     // 内核通过这个指针返回 fd
18            );
19        };
20        if fd >= 0 { Some(fd) } else { None }
21    } else {
22        fd
23    }
24}
25
26// IOCTL 封装
27fn ksuctl<T>(request: i32, arg: *mut T) -> std::io::Result<i32> {
28    let fd = *DRIVER_FD.get_or_init(|| init_driver_fd().unwrap_or(-1));
29    unsafe {
30        let ret = libc::ioctl(fd, request, arg);
31        if ret < 0 {
32            Err(io::Error::last_os_error())
33        } else {
34            Ok(ret)
35        }
36    }
37}
38
39// 授予 root
40pub fn grant_root() -> std::io::Result<()> {
41    ksuctl(KSU_IOCTL_GRANT_ROOT, std::ptr::null_mut::<u8>())?;
42    Ok(())
43}

 1// 1. post-fs-data：数据分区挂载后
 2pub fn on_post_fs_data() {
 3    ksucalls::report_post_fs_data();  // 通知内核
 4
 5    // 挂载 metamodule
 6    metamodule::mount_metamodule();
 7
 8    // 挂载普通模块
 9    module::mount_modules();
10
11    // 执行模块脚本
12    module::exec_stage_script("post-fs-data.sh");
13}
14
15// 2. services：系统服务启动时
16pub fn on_services() {
17    module::exec_stage_script("service.sh");
18}
19
20// 3. boot-completed：启动完成
21pub fn on_boot_completed() {
22    ksucalls::report_boot_complete();
23
24    // 启动 Manager 的 throne tracker
25    throne_tracker::track_throne();
26
27    // 启动 package observer（监控应用安装/卸载）
28    package_observer::start();
29}

 1struct app_profile {
 2    u32 version;                // 配置版本
 3    char key[128];              // 包名或特殊标识（"$", "#"）
 4    uid_t current_uid;          // 当前 UID
 5    bool allow_su;              // 是否允许 root
 6
 7    union {
 8        // Root 配置
 9        struct {
10            bool use_default;
11            struct root_profile profile;
12        } rp_config;
13
14        // Non-root 配置
15        struct {
16            bool use_default;
17            struct non_root_profile profile;
18        } nrp_config;
19    };
20};
21
22struct root_profile {
23    uid_t uid;                  // 目标 UID（0=root）
24    gid_t gid;                  // 目标 GID
25    u32 groups_count;
26    gid_t groups[KSU_MAX_GROUPS];
27    struct kernel_cap_struct capabilities;
28    char selinux_domain[64];    // 默认 "u:r:su:s0"
29    u32 namespaces;             // KSU_NS_INHERITED / KSU_NS_ISOLATED
30};
31
32struct non_root_profile {
33    bool umount_modules;        // 是否卸载模块（隐藏 KernelSU）
34};

 1bool ksu_uid_should_umount(uid_t uid)
 2{
 3    struct app_profile profile = { .current_uid = uid };
 4
 5    // Manager 不卸载
 6    if (ksu_get_manager_appid() == uid % PER_USER_RANGE)
 7        return false;
 8
 9    // 查询 app profile
10    bool found = ksu_get_app_profile(&profile);
11    if (!found) {
12        // 使用默认 non-root profile
13        return default_non_root_profile.umount_modules;
14    }
15
16    if (profile.allow_su) {
17        return false;  // Root 应用不卸载
18    } else {
19        return profile.nrp_config.use_default
20            ? default_non_root_profile.umount_modules
21            : profile.nrp_config.profile.umount_modules;
22    }
23}

 1static uid_t throne_uid = -1;  // 记录真实 Manager 的 UID
 2
 3void track_throne(bool force_refresh)
 4{
 5    // 1. 扫描所有进程
 6    for_each_process(p) {
 7        // 2. 检查签名（通过 /proc/[pid]/maps 验证 APK 哈希）
 8        if (verify_manager_signature(p)) {
 9            throne_uid = task_uid(p).val;
10            pr_info("throne_tracker: found manager at UID %d\n", throne_uid);
11            break;
12        }
13    }
14}
15
16bool is_manager(void)
17{
18    return current_uid().val == throne_uid;
19}

 1// 监听 /data/system/packages.list 文件变化
 2static void on_packages_list_changed(void)
 3{
 4    // 调用 ksud 的 prune 命令
 5    ksu_prune_allowlist(is_uid_still_valid, NULL);
 6}
 7
 8// 验证 UID 是否仍然有效
 9static bool is_uid_still_valid(uid_t uid, char *package, void *data)
10{
11    // 查询 PackageManager 检查包名是否存在
12    return package_exists(package, uid);
13}

1// Termux 代码
2Process process = Runtime.getRuntime().exec("su");
3OutputStream os = process.getOutputStream();
4os.write("id\n".getBytes());
5os.flush();

 1struct cred {
 2    kuid_t uid;         // 真实 UID
 3    kgid_t gid;         // 真实 GID
 4    kuid_t suid;        // Saved UID
 5    kgid_t sgid;        // Saved GID
 6    kuid_t euid;        // 有效 UID（权限检查使用）
 7    kgid_t egid;        // 有效 GID
 8    kuid_t fsuid;       // 文件系统 UID
 9    kgid_t fsgid;       // 文件系统 GID
10
11    kernel_cap_t cap_inheritable;  // 可继承 capabilities
12    kernel_cap_t cap_permitted;    // 允许的 capabilities
13    kernel_cap_t cap_effective;    // 有效的 capabilities
14    kernel_cap_t cap_bset;         // Capability bounding set
15    kernel_cap_t cap_ambient;      // Ambient capabilities
16
17    unsigned securebits;           // 安全位标志
18    struct user_struct *user;      // 用户结构（进程计数）
19    struct user_namespace *user_ns; // 用户命名空间
20    struct group_info *group_info; // 附加组信息
21
22    void *security;  // SELinux 使用 (task_security_struct)
23};

1struct task_security_struct {
2    u32 osid;           // 原始 SID
3    u32 sid;            // 当前 SID
4    u32 exec_sid;       // execve 后的 SID
5    u32 create_sid;     // 创建对象的 SID
6    u32 keycreate_sid;  // 创建密钥的 SID
7    u32 sockcreate_sid; // 创建 socket 的 SID
8};

1# 查看 KernelSU 日志
2dmesg | grep -E "ksu|KernelSU"
3
4# 实时监控
5watch -n 1 'dmesg | tail -20 | grep ksu'

1# 查看 ksud 的 ksu_driver fd
2ls -l /proc/$(pidof ksud)/fd/ | grep ksu_driver
3
4# 输出示例:
5# lrwx------ 1 root root 64 ... 3 -> anon_inode:[ksu_driver]

1# 通过 ksud 命令
2/data/adb/ksud profile list
3
4# 直接读取持久化文件（需要 root）
5xxd /data/adb/ksu/.allowlist | head

1# 查看当前进程 context
2id -Z
3
4# Root 进程应该显示:
5# u:r:su:s0