Merge remote-tracking branch 'upstream/main'

Author: mrmathematica

.gitignore

@@ -1,4 +1,5 @@
 .idea
 .vscode
 CLAUDE.md
-AGENTS.md
+AGENTS.md
+.DS_Store

docs/README_PT-BR.md

@@ -24,7 +24,10 @@ O KernelSU oferece suporte oficial a dispositivos Android GKI 2.0 (kernel 5.10+)
 
 Com isso, WSA, ChromeOS e Android baseado em contêiner são todos suportados.
 
-Atualmente, apenas as arquiteturas `arm64-v8a` e `x86_64` são compatíveis.
+Atualmente, as arquiteturas `arm64-v8a` e `x86_64` são suportadas.
+
+> [!CAUTION]
+> Versões recentes do kernel implementaram uma mudança que quebra a compatibilidade, fazendo com que o KernelSU falhe e potencialmente cause um kernel panic no `x86_64`! Verifique o site para mais informações!
 
 ## Uso
 

kernel/.clang-format

@@ -52,7 +52,7 @@ BreakConstructorInitializersBeforeComma: false
 #BreakConstructorInitializers: BeforeComma # Unknown to clang-format-4.0
 BreakAfterJavaFieldAnnotations: false
 BreakStringLiterals: false
-ColumnLimit: 80
+ColumnLimit: 120
 CommentPragmas: '^ IWYU pragma:'
 #CompactNamespaces: false # Unknown to clang-format-4.0
 ConstructorInitializerAllOnOneLineOrOnePerLine: false

kernel/.gitignore

@@ -12,7 +12,7 @@ compile_commands.json
 *.mod.c
 *.symvers*
 *.order
-.*.ko.cmd
+.*.cmd
 .tmp_versions/
 libs/
 obj/

kernel/Kbuild

@@ -4,6 +4,7 @@ kernelsu-objs += app_profile.o
 kernelsu-objs += apk_sign.o
 kernelsu-objs += sucompat.o
 kernelsu-objs += syscall_hook_manager.o
+kernelsu-objs += tp_marker.o
 kernelsu-objs += throne_tracker.o
 kernelsu-objs += pkg_observer.o
 kernelsu-objs += setuid_hook.o
@@ -14,7 +15,13 @@ kernelsu-objs += feature.o
 kernelsu-objs += ksud.o
 kernelsu-objs += seccomp_cache.o
 kernelsu-objs += file_wrapper.o
-kernelsu-objs += util.o
+ifeq ($(CONFIG_ARM64),y)
+kernelsu-objs += hook/arm64/patch_memory.o
+kernelsu-objs += hook/arm64/syscall_hook.o
+else ifeq ($(CONFIG_X86_64),y)
+kernelsu-objs += hook/x86_64/patch_memory.o
+kernelsu-objs += hook/x86_64/syscall_hook.o
+endif
 
 kernelsu-objs += selinux/selinux.o
 kernelsu-objs += selinux/sepolicy.o
@@ -60,6 +67,10 @@ $(warning "KSU_GIT_VERSION not defined! It is better to make KernelSU a git repo
 ccflags-y += -DKSU_VERSION=16
 endif
 
+KSU_NEW_DCACHE_FLUSH := $(shell grep -q __flush_dcache_area $(srctree)/arch/arm64/include/asm/cacheflush.h ; echo $$?)
+$(info -- KSU_NEW_DCACHE_FLUSH: $(KSU_NEW_DCACHE_FLUSH))
+
+
 ifndef KSU_EXPECTED_SIZE
 KSU_EXPECTED_SIZE := 0x033b
 endif
@@ -79,6 +90,18 @@ $(info -- KernelSU Manager signature hash: $(KSU_EXPECTED_HASH))
 ccflags-y += -DEXPECTED_SIZE=$(KSU_EXPECTED_SIZE)
 ccflags-y += -DEXPECTED_HASH=\"$(KSU_EXPECTED_HASH)\"
 
+ifdef KSU_EXPECTED_SIZE2
+ifndef KSU_EXPECTED_HASH2
+$(error KSU_EXPECTED_HASH2 must be set when KSU_EXPECTED_SIZE2 is set)
+endif
+ccflags-y += -DEXPECTED_SIZE2=$(KSU_EXPECTED_SIZE2)
+ccflags-y += -DEXPECTED_HASH2=\"$(KSU_EXPECTED_HASH2)\"
+$(info -- KernelSU Manager signature size2: $(KSU_EXPECTED_SIZE2))
+$(info -- KernelSU Manager signature hash2: $(KSU_EXPECTED_HASH2))
+endif
+
+ccflags-y += -DKSU_NEW_DCACHE_FLUSH=$(KSU_NEW_DCACHE_FLUSH)
+
 ccflags-y += -Wno-strict-prototypes -Wno-int-conversion -Wno-gcc-compat -Wno-missing-prototypes
 ccflags-y += -Wno-declaration-after-statement -Wno-unused-function
 

kernel/Kconfig

@@ -2,11 +2,12 @@ menu "KernelSU"
 
 config KSU
 	tristate "KernelSU function support"
-	depends on KPROBES
+	depends on KPROBES && EXT4_FS
 	default y
 	help
 	  Enable kernel-level root privileges on Android System.
 	  Requires CONFIG_KPROBES for kernel hooking support.
+	  Requires CONFIG_EXT4_FS for `ext4_unregister_sysfs`.
 	  To compile as a module, choose M here: the
 	  module will be called kernelsu.
 

kernel/allowlist.c

@@ -35,8 +35,7 @@ static DEFINE_MUTEX(allowlist_mutex);
 static struct root_profile default_root_profile;
 static struct non_root_profile default_non_root_profile;
 
-static int allow_list_arr[PAGE_SIZE / sizeof(int)] __read_mostly
-    __aligned(PAGE_SIZE);
+static int allow_list_arr[PAGE_SIZE / sizeof(int)] __read_mostly __aligned(PAGE_SIZE);
 static int allow_list_pointer __read_mostly = 0;
 
 static void remove_uid_from_arr(uid_t uid)
@@ -46,8 +45,7 @@ static void remove_uid_from_arr(uid_t uid)
         if (allow_list_arr[i] == uid) {
             int remaining = allow_list_pointer - 1 - i;
             if (remaining > 0) {
-                memmove(&allow_list_arr[i], &allow_list_arr[i + 1],
-                        remaining * sizeof(allow_list_arr[0]));
+                memmove(&allow_list_arr[i], &allow_list_arr[i + 1], remaining * sizeof(allow_list_arr[0]));
             }
             allow_list_pointer--;
             allow_list_arr[allow_list_pointer] = -1;
@@ -94,27 +92,11 @@ void ksu_show_allow_list(void)
     pr_info("ksu_show_allow_list\n");
     rcu_read_lock();
     list_for_each_entry_rcu (p, &allow_list, list) {
-        pr_info("uid :%d, allow: %d\n", p->profile.current_uid,
-                p->profile.allow_su);
+        pr_info("uid :%d, allow: %d\n", p->profile.current_uid, p->profile.allow_su);
     }
     rcu_read_unlock();
 }
 
-#ifdef CONFIG_KSU_DEBUG
-static void ksu_grant_root_to_shell()
-{
-    struct app_profile profile = {
-        .version = KSU_APP_PROFILE_VER,
-        .allow_su = true,
-        .current_uid = 2000,
-    };
-    strcpy(profile.key, "com.android.shell");
-    strcpy(profile.rp_config.profile.selinux_domain,
-           KSU_DEFAULT_SELINUX_DOMAIN);
-    ksu_set_app_profile(&profile);
-}
-#endif
-
 bool ksu_get_app_profile(struct app_profile *profile)
 {
     struct perm_data *p = NULL;
@@ -183,11 +165,9 @@ int ksu_set_app_profile(struct app_profile *profile)
     list_for_each_entry (p, &allow_list, list) {
         ++count;
         // both uid and package must match, otherwise it will break multiple package with different user id
-        if (profile->current_uid == p->profile.current_uid &&
-            !strcmp(profile->key, p->profile.key)) {
+        if (profile->current_uid == p->profile.current_uid && !strcmp(profile->key, p->profile.key)) {
             // found it, just override it all!
-            np = (struct perm_data *)kzalloc(sizeof(struct perm_data),
-                                             GFP_KERNEL);
+            np = (struct perm_data *)kzalloc(sizeof(struct perm_data), GFP_KERNEL);
             if (!np) {
                 result = -ENOMEM;
                 goto out_unlock;
@@ -215,13 +195,10 @@ int ksu_set_app_profile(struct app_profile *profile)
 
     memcpy(&p->profile, profile, sizeof(*profile));
     if (profile->allow_su) {
-        pr_info("set root profile, key: %s, uid: %d, gid: %d, context: %s\n",
-                profile->key, profile->current_uid,
-                profile->rp_config.profile.gid,
-                profile->rp_config.profile.selinux_domain);
+        pr_info("set root profile, key: %s, uid: %d, gid: %d, context: %s\n", profile->key, profile->current_uid,
+                profile->rp_config.profile.gid, profile->rp_config.profile.selinux_domain);
     } else {
-        pr_info("set app profile, key: %s, uid: %d, umount modules: %d\n",
-                profile->key, profile->current_uid,
+        pr_info("set app profile, key: %s, uid: %d, umount modules: %d\n", profile->key, profile->current_uid,
                 profile->nrp_config.profile.umount_modules);
     }
 
@@ -233,20 +210,16 @@ int ksu_set_app_profile(struct app_profile *profile)
     // check if the default profiles is changed, cache it to a single struct to accelerate access.
     if (unlikely(!strcmp(profile->key, "$"))) {
         // set default non root profile
-        memcpy(&default_non_root_profile, &profile->nrp_config.profile,
-               sizeof(default_non_root_profile));
+        memcpy(&default_non_root_profile, &profile->nrp_config.profile, sizeof(default_non_root_profile));
     } else if (unlikely(!strcmp(profile->key, "#"))) {
         // set default root profile
         // TODO: Do we really need this?
-        memcpy(&default_root_profile, &profile->rp_config.profile,
-               sizeof(default_root_profile));
+        memcpy(&default_root_profile, &profile->rp_config.profile, sizeof(default_root_profile));
     } else if (profile->current_uid <= BITMAP_UID_MAX) {
         if (profile->allow_su)
-            allow_list_bitmap[profile->current_uid / BITS_PER_BYTE] |=
-                1 << (profile->current_uid % BITS_PER_BYTE);
+            allow_list_bitmap[profile->current_uid / BITS_PER_BYTE] |= 1 << (profile->current_uid % BITS_PER_BYTE);
         else
-            allow_list_bitmap[profile->current_uid / BITS_PER_BYTE] &=
-                ~(1 << (profile->current_uid % BITS_PER_BYTE));
+            allow_list_bitmap[profile->current_uid / BITS_PER_BYTE] &= ~(1 << (profile->current_uid % BITS_PER_BYTE));
     } else {
         if (profile->allow_su) {
             /*
@@ -278,15 +251,17 @@ bool __ksu_is_allow_uid(uid_t uid)
         return false;
     }
 
-    if (likely(ksu_is_manager_appid_valid()) &&
-        unlikely(ksu_get_manager_appid() == uid % PER_USER_RANGE)) {
+    if (likely(ksu_is_manager_appid_valid()) && unlikely(ksu_get_manager_appid() == uid % PER_USER_RANGE)) {
         // manager is always allowed!
         return true;
     }
 
+    if (unlikely(allow_shell) && uid == SHELL_UID) {
+        return true;
+    }
+
     if (likely(uid <= BITMAP_UID_MAX)) {
-        return !!(allow_list_bitmap[uid / BITS_PER_BYTE] &
-                  (1 << (uid % BITS_PER_BYTE)));
+        return !!(allow_list_bitmap[uid / BITS_PER_BYTE] & (1 << (uid % BITS_PER_BYTE)));
     } else {
         for (i = 0; i < allow_list_pointer; i++) {
             if (allow_list_arr[i] == uid)
@@ -309,8 +284,7 @@ bool __ksu_is_allow_uid_for_current(uid_t uid)
 bool ksu_uid_should_umount(uid_t uid)
 {
     struct app_profile profile = { .current_uid = uid };
-    if (likely(ksu_is_manager_appid_valid()) &&
-        unlikely(ksu_get_manager_appid() == uid % PER_USER_RANGE)) {
+    if (likely(ksu_is_manager_appid_valid()) && unlikely(ksu_get_manager_appid() == uid % PER_USER_RANGE)) {
         // we should not umount on manager!
         return false;
     }
@@ -340,12 +314,15 @@ void ksu_get_root_profile(uid_t uid, struct root_profile *profile)
         goto use_default;
     }
 
+    if (unlikely(allow_shell && uid == SHELL_UID)) {
+        goto use_default;
+    }
+
     rcu_read_lock();
     list_for_each_entry_rcu (p, &allow_list, list) {
         if (uid == p->profile.current_uid && p->profile.allow_su) {
             if (!p->profile.rp_config.use_default) {
-                memcpy(profile, &p->profile.rp_config.profile,
-                       sizeof(*profile));
+                memcpy(profile, &p->profile.rp_config.profile, sizeof(*profile));
                 rcu_read_unlock();
                 return;
             }
@@ -358,16 +335,14 @@ void ksu_get_root_profile(uid_t uid, struct root_profile *profile)
     memcpy(profile, &default_root_profile, sizeof(*profile));
 }
 
-bool ksu_get_allow_list(int *array, u16 length, u16 *out_length, u16 *out_total,
-                        bool allow)
+bool ksu_get_allow_list(int *array, u16 length, u16 *out_length, u16 *out_total, bool allow)
 {
     struct perm_data *p = NULL;
     u16 i = 0, j = 0;
     rcu_read_lock();
     list_for_each_entry_rcu (p, &allow_list, list) {
         // pr_info("get_allow_list uid: %d allow: %d\n", p->uid, p->allow);
-        if (p->profile.allow_su == allow &&
-            !is_uid_manager(p->profile.current_uid)) {
+        if (p->profile.allow_su == allow && !is_uid_manager(p->profile.current_uid)) {
             if (j < length) {
                 array[j++] = p->profile.current_uid;
             }
@@ -394,8 +369,7 @@ static void do_persistent_allow_list(struct callback_head *_cb)
     loff_t off = 0;
 
     const struct cred *saved = override_creds(ksu_cred);
-    struct file *fp =
-        filp_open(KERNEL_SU_ALLOWLIST, O_WRONLY | O_CREAT | O_TRUNC, 0644);
+    struct file *fp = filp_open(KERNEL_SU_ALLOWLIST, O_WRONLY | O_CREAT | O_TRUNC, 0644);
     if (IS_ERR(fp)) {
         pr_err("save_allow_list create file failed: %ld\n", PTR_ERR(fp));
         goto out;
@@ -414,8 +388,8 @@ static void do_persistent_allow_list(struct callback_head *_cb)
 
     mutex_lock(&allowlist_mutex);
     list_for_each_entry (p, &allow_list, list) {
-        pr_info("save allow list, name: %s uid :%d, allow: %d\n",
-                p->profile.key, p->profile.current_uid, p->profile.allow_su);
+        pr_info("save allow list, name: %s uid :%d, allow: %d\n", p->profile.key, p->profile.current_uid,
+                p->profile.allow_su);
 
         kernel_write(fp, &p->profile, sizeof(p->profile), &off);
     }
@@ -438,8 +412,7 @@ void ksu_persistent_allow_list()
         return;
     }
 
-    struct callback_head *cb =
-        kzalloc(sizeof(struct callback_head), GFP_KERNEL);
+    struct callback_head *cb = kzalloc(sizeof(struct callback_head), GFP_KERNEL);
     if (!cb) {
         pr_err("save_allow_list alloc cb err\b");
         goto put_task;
@@ -462,11 +435,6 @@ void ksu_load_allow_list()
     u32 magic;
     u32 version;
 
-#ifdef CONFIG_KSU_DEBUG
-    // always allow adb shell by default
-    ksu_grant_root_to_shell();
-#endif
-
     // load allowlist now!
     fp = filp_open(KERNEL_SU_ALLOWLIST, O_RDONLY, 0);
     if (IS_ERR(fp)) {
@@ -475,8 +443,7 @@ void ksu_load_allow_list()
     }
 
     // verify magic
-    if (kernel_read(fp, &magic, sizeof(magic), &off) != sizeof(magic) ||
-        magic != FILE_MAGIC) {
+    if (kernel_read(fp, &magic, sizeof(magic), &off) != sizeof(magic) || magic != FILE_MAGIC) {
         pr_err("allowlist file invalid: %d!\n", magic);
         goto exit;
     }
@@ -498,8 +465,7 @@ void ksu_load_allow_list()
             break;
         }
 
-        pr_info("load_allow_uid, name: %s, uid: %d, allow: %d\n", profile.key,
-                profile.current_uid, profile.allow_su);
+        pr_info("load_allow_uid, name: %s, uid: %d, allow: %d\n", profile.key, profile.current_uid, profile.allow_su);
         ksu_set_app_profile(&profile);
     }
 
@@ -508,8 +474,7 @@ void ksu_load_allow_list()
     filp_close(fp, 0);
 }
 
-void ksu_prune_allowlist(bool (*is_uid_valid)(uid_t, char *, void *),
-                         void *data)
+void ksu_prune_allowlist(bool (*is_uid_valid)(uid_t, char *, void *), void *data)
 {
     struct perm_data *np = NULL;
     struct perm_data *n = NULL;
@@ -532,8 +497,7 @@ void ksu_prune_allowlist(bool (*is_uid_valid)(uid_t, char *, void *),
             list_del_rcu(&np->list);
             kfree_rcu(np, rcu);
             if (likely(uid <= BITMAP_UID_MAX)) {
-                allow_list_bitmap[uid / BITS_PER_BYTE] &=
-                    ~(1 << (uid % BITS_PER_BYTE));
+                allow_list_bitmap[uid / BITS_PER_BYTE] &= ~(1 << (uid % BITS_PER_BYTE));
             }
             remove_uid_from_arr(uid);
         }

kernel/allowlist.h

@@ -25,14 +25,11 @@ bool __ksu_is_allow_uid(uid_t uid);
 
 // Check if the uid is in allow list, or current is ksu domain root
 bool __ksu_is_allow_uid_for_current(uid_t uid);
-#define ksu_is_allow_uid_for_current(uid)                                      \
-    unlikely(__ksu_is_allow_uid_for_current(uid))
+#define ksu_is_allow_uid_for_current(uid) unlikely(__ksu_is_allow_uid_for_current(uid))
 
-bool ksu_get_allow_list(int *array, u16 length, u16 *out_length, u16 *out_total,
-                        bool allow);
+bool ksu_get_allow_list(int *array, u16 length, u16 *out_length, u16 *out_total, bool allow);
 
-void ksu_prune_allowlist(bool (*is_uid_exist)(uid_t, char *, void *),
-                         void *data);
+void ksu_prune_allowlist(bool (*is_uid_exist)(uid_t, char *, void *), void *data);
 void ksu_persistent_allow_list();
 
 bool ksu_get_app_profile(struct app_profile *);
@@ -53,3 +50,5 @@ static inline bool is_isolated_process(uid_t uid)
     return appid >= FIRST_ISOLATED_UID && appid <= LAST_ISOLATED_UID;
 }
 #endif
+
+extern bool allow_shell;