diff --git a/kernel/Makefile b/kernel/Makefile index fb7b1120..82b2bbff 100644 --- a/kernel/Makefile +++ b/kernel/Makefile @@ -1,5 +1,6 @@ kernelsu-objs := ksu.o kernelsu-objs += allowlist.o +kernelsu-objs += dynamic_sign.o kernelsu-objs += apk_sign.o kernelsu-objs += sucompat.o kernelsu-objs += throne_tracker.o @@ -71,9 +72,9 @@ ccflags-y += -DKSU_VERSION_FULL=\"$(KSU_VERSION_FULL)\" # Checks hooks state ifeq ($(strip $(CONFIG_KSU_MANUAL_HOOK)),y) -$(info -- KernelSU: Manually-patched hook.) +$(info -- KernelSU: CONFIG_KSU_MANUAL_HOOK) else -$(info -- KernelSU: Kernel-probe hook.) +$(info -- KernelSU: CONFIG_KSU_KPROBES_HOOK) ccflags-y += -DCONFIG_KSU_KPROBES_HOOK endif @@ -109,12 +110,15 @@ ifeq ($(shell grep -q "SEC_SELINUX_PORTING_COMMON" $(srctree)/security/selinux/a ccflags-y += -DSAMSUNG_SELINUX_PORTING endif -ifndef KSU_EXPECTED_SIZE -KSU_EXPECTED_SIZE := 0x35c +# Custom Signs +ifdef KSU_EXPECTED_SIZE +ccflags-y += -DEXPECTED_SIZE=$(KSU_EXPECTED_SIZE) +$(info -- Custom KernelSU Manager signature size: $(KSU_EXPECTED_SIZE)) endif -ifndef KSU_EXPECTED_HASH -KSU_EXPECTED_HASH := 947ae944f3de4ed4c21a7e4f7953ecf351bfa2b36239da37a34111ad29993eef +ifdef KSU_EXPECTED_HASH +ccflags-y += -DEXPECTED_HASH=\"$(KSU_EXPECTED_HASH)\" +$(info -- Custom KernelSU Manager signature hash: $(KSU_EXPECTED_HASH)) endif ifdef KSU_MANAGER_PACKAGE @@ -122,8 +126,6 @@ ccflags-y += -DKSU_MANAGER_PACKAGE=\"$(KSU_MANAGER_PACKAGE)\" $(info -- SukiSU Manager package name: $(KSU_MANAGER_PACKAGE)) endif -$(info -- SukiSU Manager signature size: $(KSU_EXPECTED_SIZE)) -$(info -- SukiSU Manager signature hash: $(KSU_EXPECTED_HASH)) $(info -- Supported Unofficial Manager: 5ec1cff (GKI) ShirkNeko udochina (GKI and KPM)) KERNEL_VERSION := $(VERSION).$(PATCHLEVEL) KERNEL_TYPE := Non-GKI @@ -146,10 +148,6 @@ else $(info -- KPM is disabled) endif - -ccflags-y += -DEXPECTED_SIZE=$(KSU_EXPECTED_SIZE) -ccflags-y += -DEXPECTED_HASH=\"$(KSU_EXPECTED_HASH)\" - ccflags-y += -Wno-implicit-function-declaration -Wno-strict-prototypes -Wno-int-conversion -Wno-gcc-compat ccflags-y += -Wno-declaration-after-statement -Wno-unused-function diff --git a/kernel/apk_sign.c b/kernel/apk_sign.c index 20c2b35e..f58b1133 100644 --- a/kernel/apk_sign.c +++ b/kernel/apk_sign.c @@ -16,470 +16,11 @@ #endif #include "apk_sign.h" +#include "dynamic_sign.h" #include "klog.h" // IWYU pragma: keep #include "kernel_compat.h" #include "manager_sign.h" -// Expected sizes and hashes for various APK signatures -#define DYNAMIC_SIGN_FILE_MAGIC 0x7f445347 // 'DSG', u32 -#define DYNAMIC_SIGN_FILE_VERSION 1 // u32 -#define KERNEL_SU_DYNAMIC_SIGN "/data/adb/ksu/.dynamic_sign" - -#define MAX_MANAGERS 2 -static struct manager_info active_managers[MAX_MANAGERS]; -static DEFINE_SPINLOCK(managers_lock); - -static struct dynamic_sign_config dynamic_sign = { - .size = 0x300, - .hash = "0000000000000000000000000000000000000000000000000000000000000000", - .is_set = 0 -}; - -static DEFINE_SPINLOCK(dynamic_sign_lock); -static struct work_struct ksu_save_dynamic_sign_work; -static struct work_struct ksu_load_dynamic_sign_work; -static struct work_struct ksu_clear_dynamic_sign_work; - -static inline bool is_dynamic_sign_enabled(void) -{ - unsigned long flags; - bool enabled; - - spin_lock_irqsave(&dynamic_sign_lock, flags); - enabled = dynamic_sign.is_set; - spin_unlock_irqrestore(&dynamic_sign_lock, flags); - - return enabled; -} - -void ksu_add_manager(uid_t uid, int signature_index) -{ - unsigned long flags; - int i; - - if (!is_dynamic_sign_enabled()) { - pr_info("Dynamic sign not enabled, skipping multi-manager add\n"); - return; - } - - spin_lock_irqsave(&managers_lock, flags); - - for (i = 0; i < MAX_MANAGERS; i++) { - if (active_managers[i].is_active && active_managers[i].uid == uid) { - active_managers[i].signature_index = signature_index; - spin_unlock_irqrestore(&managers_lock, flags); - pr_info("Updated manager uid=%d, signature_index=%d\n", uid, signature_index); - return; - } - } - - for (i = 0; i < MAX_MANAGERS; i++) { - if (!active_managers[i].is_active) { - active_managers[i].uid = uid; - active_managers[i].signature_index = signature_index; - active_managers[i].is_active = true; - spin_unlock_irqrestore(&managers_lock, flags); - pr_info("Added manager uid=%d, signature_index=%d\n", uid, signature_index); - return; - } - } - - spin_unlock_irqrestore(&managers_lock, flags); - pr_warn("Failed to add manager, no free slots\n"); -} - -void ksu_remove_manager(uid_t uid) -{ - unsigned long flags; - int i; - - if (!is_dynamic_sign_enabled()) { - return; - } - - spin_lock_irqsave(&managers_lock, flags); - - for (i = 0; i < MAX_MANAGERS; i++) { - if (active_managers[i].is_active && active_managers[i].uid == uid) { - active_managers[i].is_active = false; - pr_info("Removed manager uid=%d\n", uid); - break; - } - } - - spin_unlock_irqrestore(&managers_lock, flags); -} - -bool ksu_is_any_manager(uid_t uid) -{ - unsigned long flags; - bool is_manager = false; - int i; - - if (!is_dynamic_sign_enabled()) { - return false; - } - - spin_lock_irqsave(&managers_lock, flags); - - for (i = 0; i < MAX_MANAGERS; i++) { - if (active_managers[i].is_active && active_managers[i].uid == uid) { - is_manager = true; - break; - } - } - - spin_unlock_irqrestore(&managers_lock, flags); - return is_manager; -} - -int ksu_get_manager_signature_index(uid_t uid) -{ - unsigned long flags; - int signature_index = -1; - int i; - - if (ksu_manager_uid != KSU_INVALID_UID && uid == ksu_manager_uid) { - return 1; - } - - if (!is_dynamic_sign_enabled()) { - return -1; - } - - spin_lock_irqsave(&managers_lock, flags); - - for (i = 0; i < MAX_MANAGERS; i++) { - if (active_managers[i].is_active && active_managers[i].uid == uid) { - signature_index = active_managers[i].signature_index; - break; - } - } - - spin_unlock_irqrestore(&managers_lock, flags); - return signature_index; -} - -static void clear_all_managers(void) -{ - unsigned long flags; - int i; - - spin_lock_irqsave(&managers_lock, flags); - - for (i = 0; i < MAX_MANAGERS; i++) { - if (active_managers[i].is_active) { - pr_info("Clearing manager uid=%d due to dynamic_sign disable\n", - active_managers[i].uid); - active_managers[i].is_active = false; - } - } - - spin_unlock_irqrestore(&managers_lock, flags); -} - -static void do_save_dynamic_sign(struct work_struct *work) -{ - u32 magic = DYNAMIC_SIGN_FILE_MAGIC; - u32 version = DYNAMIC_SIGN_FILE_VERSION; - struct dynamic_sign_config config_to_save; - loff_t off = 0; - unsigned long flags; - struct file *fp; - - spin_lock_irqsave(&dynamic_sign_lock, flags); - config_to_save = dynamic_sign; - spin_unlock_irqrestore(&dynamic_sign_lock, flags); - - if (!config_to_save.is_set) { - pr_info("Dynamic sign config not set, skipping save\n"); - return; - } - - fp = ksu_filp_open_compat(KERNEL_SU_DYNAMIC_SIGN, O_WRONLY | O_CREAT | O_TRUNC, 0644); - if (IS_ERR(fp)) { - pr_err("save_dynamic_sign create file failed: %ld\n", PTR_ERR(fp)); - return; - } - - if (ksu_kernel_write_compat(fp, &magic, sizeof(magic), &off) != sizeof(magic)) { - pr_err("save_dynamic_sign write magic failed.\n"); - goto exit; - } - - if (ksu_kernel_write_compat(fp, &version, sizeof(version), &off) != sizeof(version)) { - pr_err("save_dynamic_sign write version failed.\n"); - goto exit; - } - - if (ksu_kernel_write_compat(fp, &config_to_save, sizeof(config_to_save), &off) != sizeof(config_to_save)) { - pr_err("save_dynamic_sign write config failed.\n"); - goto exit; - } - - pr_info("Dynamic sign config saved successfully\n"); - -exit: - filp_close(fp, 0); -} - -// Loading dynamic signatures from persistent storage -static void do_load_dynamic_sign(struct work_struct *work) -{ - loff_t off = 0; - ssize_t ret = 0; - struct file *fp = NULL; - u32 magic; - u32 version; - struct dynamic_sign_config loaded_config; - unsigned long flags; - int i; - - fp = ksu_filp_open_compat(KERNEL_SU_DYNAMIC_SIGN, O_RDONLY, 0); - if (IS_ERR(fp)) { - if (PTR_ERR(fp) == -ENOENT) { - pr_info("No saved dynamic sign config found\n"); - } else { - pr_err("load_dynamic_sign open file failed: %ld\n", PTR_ERR(fp)); - } - return; - } - - if (ksu_kernel_read_compat(fp, &magic, sizeof(magic), &off) != sizeof(magic) || - magic != DYNAMIC_SIGN_FILE_MAGIC) { - pr_err("dynamic sign file invalid magic: %x!\n", magic); - goto exit; - } - - if (ksu_kernel_read_compat(fp, &version, sizeof(version), &off) != sizeof(version)) { - pr_err("dynamic sign read version failed\n"); - goto exit; - } - - pr_info("dynamic sign file version: %d\n", version); - - ret = ksu_kernel_read_compat(fp, &loaded_config, sizeof(loaded_config), &off); - if (ret <= 0) { - pr_info("load_dynamic_sign read err: %zd\n", ret); - goto exit; - } - - if (ret != sizeof(loaded_config)) { - pr_err("load_dynamic_sign read incomplete config: %zd/%zu\n", ret, sizeof(loaded_config)); - goto exit; - } - - if (loaded_config.size < 0x100 || loaded_config.size > 0x1000) { - pr_err("Invalid saved config size: 0x%x\n", loaded_config.size); - goto exit; - } - - if (strlen(loaded_config.hash) != 64) { - pr_err("Invalid saved config hash length: %zu\n", strlen(loaded_config.hash)); - goto exit; - } - - for (i = 0; i < 64; i++) { - char c = loaded_config.hash[i]; - if (!((c >= '0' && c <= '9') || (c >= 'a' && c <= 'f'))) { - pr_err("Invalid saved config hash character at position %d: %c\n", i, c); - goto exit; - } - } - - spin_lock_irqsave(&dynamic_sign_lock, flags); - dynamic_sign = loaded_config; - spin_unlock_irqrestore(&dynamic_sign_lock, flags); - - pr_info("Dynamic sign config loaded: size=0x%x, hash=%.16s...\n", - loaded_config.size, loaded_config.hash); - -exit: - filp_close(fp, 0); -} - -static bool persistent_dynamic_sign(void) -{ - return ksu_queue_work(&ksu_save_dynamic_sign_work); -} - -// Clear dynamic sign config file using the same method as do_save_dynamic_sign -static void do_clear_dynamic_sign_file(struct work_struct *work) -{ - loff_t off = 0; - struct file *fp; - char zero_buffer[512]; - - memset(zero_buffer, 0, sizeof(zero_buffer)); - - fp = ksu_filp_open_compat(KERNEL_SU_DYNAMIC_SIGN, O_WRONLY | O_CREAT | O_TRUNC, 0644); - if (IS_ERR(fp)) { - pr_err("clear_dynamic_sign create file failed: %ld\n", PTR_ERR(fp)); - return; - } - - // Write null bytes to overwrite the file content - if (ksu_kernel_write_compat(fp, zero_buffer, sizeof(zero_buffer), &off) != sizeof(zero_buffer)) { - pr_err("clear_dynamic_sign write null bytes failed.\n"); - } else { - pr_info("Dynamic sign config file cleared successfully\n"); - } - - filp_close(fp, 0); -} - -static bool clear_dynamic_sign_file(void) -{ - return ksu_queue_work(&ksu_clear_dynamic_sign_work); -} - -int ksu_handle_dynamic_sign(struct dynamic_sign_user_config *config) -{ - unsigned long flags; - int ret = 0; - int i; - - if (!config) { - return -EINVAL; - } - - switch (config->operation) { - case DYNAMIC_SIGN_OP_SET: - if (config->size < 0x100 || config->size > 0x1000) { - pr_err("invalid size: 0x%x\n", config->size); - return -EINVAL; - } - - if (strlen(config->hash) != 64) { - pr_err("invalid hash length: %zu\n", strlen(config->hash)); - return -EINVAL; - } - - for (i = 0; i < 64; i++) { - char c = config->hash[i]; - if (!((c >= '0' && c <= '9') || (c >= 'a' && c <= 'f'))) { - pr_err("invalid hash character at position %d: %c\n", i, c); - return -EINVAL; - } - } - - spin_lock_irqsave(&dynamic_sign_lock, flags); - dynamic_sign.size = config->size; -#if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 13, 0) - strscpy(dynamic_sign.hash, config->hash, sizeof(dynamic_sign.hash)); -#else - strlcpy(dynamic_sign.hash, config->hash, sizeof(dynamic_sign.hash)); -#endif - dynamic_sign.is_set = 1; - spin_unlock_irqrestore(&dynamic_sign_lock, flags); - - persistent_dynamic_sign(); - pr_info("dynamic sign updated: size=0x%x, hash=%.16s... (multi-manager enabled)\n", - config->size, config->hash); - break; - - case DYNAMIC_SIGN_OP_GET: - // Getting Dynamic Signatures - spin_lock_irqsave(&dynamic_sign_lock, flags); - if (dynamic_sign.is_set) { - config->size = dynamic_sign.size; -#if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 13, 0) - strscpy(config->hash, dynamic_sign.hash, sizeof(config->hash)); -#else - strlcpy(config->hash, dynamic_sign.hash, sizeof(config->hash)); -#endif - ret = 0; - } else { - ret = -ENODATA; - } - spin_unlock_irqrestore(&dynamic_sign_lock, flags); - break; - - case DYNAMIC_SIGN_OP_CLEAR: - // Clearing dynamic signatures - spin_lock_irqsave(&dynamic_sign_lock, flags); - dynamic_sign.size = 0x300; - strcpy(dynamic_sign.hash, "0000000000000000000000000000000000000000000000000000000000000000"); - dynamic_sign.is_set = 0; - spin_unlock_irqrestore(&dynamic_sign_lock, flags); - clear_all_managers(); - - // Clear file using the same method as save - clear_dynamic_sign_file(); - - pr_info("Dynamic sign config cleared (multi-manager disabled)\n"); - break; - - default: - pr_err("Invalid dynamic sign operation: %d\n", config->operation); - return -EINVAL; - } - - return ret; -} - -bool ksu_load_dynamic_sign(void) -{ - return ksu_queue_work(&ksu_load_dynamic_sign_work); -} - -void ksu_dynamic_sign_init(void) -{ - int i; - - INIT_WORK(&ksu_save_dynamic_sign_work, do_save_dynamic_sign); - INIT_WORK(&ksu_load_dynamic_sign_work, do_load_dynamic_sign); - INIT_WORK(&ksu_clear_dynamic_sign_work, do_clear_dynamic_sign_file); - - for (i = 0; i < MAX_MANAGERS; i++) { - active_managers[i].is_active = false; - } - - pr_info("Dynamic sign initialized with conditional multi-manager support\n"); -} - -void ksu_dynamic_sign_exit(void) -{ - clear_all_managers(); - - do_save_dynamic_sign(NULL); - pr_info("Dynamic sign exited with persistent storage\n"); -} - -// Get active managers for multi-manager APKs -int ksu_get_active_managers(struct manager_list_info *info) -{ - unsigned long flags; - int i, count = 0; - - if (!info) { - return -EINVAL; - } - - if (ksu_manager_uid != KSU_INVALID_UID && count < 2) { - info->managers[count].uid = ksu_manager_uid; - info->managers[count].signature_index = 1; - count++; - } - - if (is_dynamic_sign_enabled()) { - spin_lock_irqsave(&managers_lock, flags); - - for (i = 0; i < MAX_MANAGERS && count < 2; i++) { - if (active_managers[i].is_active) { - info->managers[count].uid = active_managers[i].uid; - info->managers[count].signature_index = active_managers[i].signature_index; - count++; - } - } - - spin_unlock_irqrestore(&managers_lock, flags); - } - - info->count = count; - return 0; -} - struct sdesc { struct shash_desc shash; char ctx[]; @@ -489,9 +30,11 @@ static struct apk_sign_key { unsigned size; const char *sha256; } apk_sign_keys[] = { - {EXPECTED_SIZE, EXPECTED_HASH}, {EXPECTED_SIZE_SHIRKNEKO, EXPECTED_HASH_SHIRKNEKO}, // SukiSU {EXPECTED_SIZE_OTHER, EXPECTED_HASH_OTHER}, // Dynamic Sign +#ifdef EXPECTED_SIZE + {EXPECTED_SIZE, EXPECTED_HASH}, // Custom +#endif }; static struct sdesc *init_sdesc(struct crypto_shash *alg) @@ -619,14 +162,13 @@ static int verify_signature_block(struct file *fp, u32 *size4, loff_t *pos, u32 for (i = 0; i < ARRAY_SIZE(apk_sign_keys); i++) { sign_key = apk_sign_keys[i]; - if (i == 2) { - unsigned long flags; - spin_lock_irqsave(&dynamic_sign_lock, flags); - if (dynamic_sign.is_set) { - sign_key.size = dynamic_sign.size; - sign_key.sha256 = dynamic_sign.hash; + if (i == 1) { // Dynamic Sign indexing + unsigned int size; + const char *hash; + if (ksu_get_dynamic_sign_config(&size, &hash)) { + sign_key.size = size; + sign_key.sha256 = hash; } - spin_unlock_irqrestore(&dynamic_sign_lock, flags); } if (*size4 != sign_key.size) @@ -687,8 +229,8 @@ static int parse_apk_signature(char *path, bool check_multi_manager, int *signat return -1; } - // If you want to check for multi-manager APK signing, but dynamic signing is not enabled, skip the - if (check_multi_manager && !is_dynamic_sign_enabled()) { + // If you want to check for multi-manager APK signing, but dynamic signing is not enabled, skip + if (check_multi_manager && !ksu_is_dynamic_sign_enabled()) { filp_close(fp, 0); return 0; } @@ -795,8 +337,8 @@ clean: } if (check_multi_manager) { - // 1: ShirkNeko/SukiSU, 2: Dynamic Sign - if (matched_index == 1 || matched_index == 2) { + // 0: ShirkNeko/SukiSU, 1: Dynamic Sign + if (matched_index == 0 || matched_index == 1) { pr_info("Multi-manager APK detected (dynamic_sign enabled): signature_index=%d\n", matched_index); return 1; } @@ -816,12 +358,6 @@ bool ksu_is_multi_manager_apk(char *path, int *signature_index) return result == 1; } -static bool check_block(struct file *fp, u32 *size4, loff_t *pos, u32 *offset) -{ - int result = verify_signature_block(fp, size4, pos, offset, NULL); - return result == 1; -} - static __always_inline bool check_v2_signature(char *path) { int result = parse_apk_signature(path, false, NULL); diff --git a/kernel/apk_sign.h b/kernel/apk_sign.h index f2c16905..a7147639 100644 --- a/kernel/apk_sign.h +++ b/kernel/apk_sign.h @@ -3,32 +3,7 @@ #include #include "ksu.h" -#include "manager.h" bool is_manager_apk(char *path); -struct dynamic_sign_config { - unsigned int size; - char hash[65]; - int is_set; -}; - -struct manager_info { - uid_t uid; - int signature_index; - bool is_active; -}; - -bool ksu_is_multi_manager_apk(char *path, int *signature_index); -void ksu_add_manager(uid_t uid, int signature_index); -void ksu_remove_manager(uid_t uid); -bool ksu_is_any_manager(uid_t uid); -int ksu_get_manager_signature_index(uid_t uid); -int ksu_get_active_managers(struct manager_list_info *info); - -int ksu_handle_dynamic_sign(struct dynamic_sign_user_config *config); -void ksu_dynamic_sign_init(void); -void ksu_dynamic_sign_exit(void); -bool ksu_load_dynamic_sign(void); - #endif \ No newline at end of file diff --git a/kernel/core_hook.c b/kernel/core_hook.c index 570efed5..59b8633c 100644 --- a/kernel/core_hook.c +++ b/kernel/core_hook.c @@ -46,7 +46,6 @@ #include "manager.h" #include "selinux/selinux.h" #include "throne_tracker.h" -#include "throne_tracker.h" #include "kernel_compat.h" #include "kpm/kpm.h" @@ -406,7 +405,6 @@ int ksu_handle_prctl(int option, unsigned long arg2, unsigned long arg3, on_post_fs_data(); // Initializing Dynamic Signatures ksu_dynamic_sign_init(); - ksu_load_dynamic_sign(); pr_info("Dynamic sign config loaded during post-fs-data\n"); } break; diff --git a/kernel/dynamic_sign.c b/kernel/dynamic_sign.c new file mode 100644 index 00000000..56c9b9e1 --- /dev/null +++ b/kernel/dynamic_sign.c @@ -0,0 +1,505 @@ +#include +#include +#include +#include +#include +#include +#include +#ifdef CONFIG_KSU_DEBUG +#include +#endif +#include +#if LINUX_VERSION_CODE >= KERNEL_VERSION(5, 11, 0) +#include +#else +#include +#endif + +#include "dynamic_sign.h" +#include "klog.h" // IWYU pragma: keep +#include "kernel_compat.h" +#include "manager.h" + +#define MAX_MANAGERS 2 + +// Dynamic sign configuration +static struct dynamic_sign_config dynamic_sign = { + .size = 0x300, + .hash = "0000000000000000000000000000000000000000000000000000000000000000", + .is_set = 0 +}; + +// Multi-manager state +static struct manager_info active_managers[MAX_MANAGERS]; +static DEFINE_SPINLOCK(managers_lock); +static DEFINE_SPINLOCK(dynamic_sign_lock); + +// Work queues for persistent storage +static struct work_struct ksu_save_dynamic_sign_work; +static struct work_struct ksu_load_dynamic_sign_work; +static struct work_struct ksu_clear_dynamic_sign_work; + +bool ksu_is_dynamic_sign_enabled(void) +{ + unsigned long flags; + bool enabled; + + spin_lock_irqsave(&dynamic_sign_lock, flags); + enabled = dynamic_sign.is_set; + spin_unlock_irqrestore(&dynamic_sign_lock, flags); + + return enabled; +} + +void ksu_add_manager(uid_t uid, int signature_index) +{ + unsigned long flags; + int i; + + if (!ksu_is_dynamic_sign_enabled()) { + pr_info("Dynamic sign not enabled, skipping multi-manager add\n"); + return; + } + + spin_lock_irqsave(&managers_lock, flags); + + // Check if manager already exists and update + for (i = 0; i < MAX_MANAGERS; i++) { + if (active_managers[i].is_active && active_managers[i].uid == uid) { + active_managers[i].signature_index = signature_index; + spin_unlock_irqrestore(&managers_lock, flags); + pr_info("Updated manager uid=%d, signature_index=%d\n", uid, signature_index); + return; + } + } + + // Find free slot for new manager + for (i = 0; i < MAX_MANAGERS; i++) { + if (!active_managers[i].is_active) { + active_managers[i].uid = uid; + active_managers[i].signature_index = signature_index; + active_managers[i].is_active = true; + spin_unlock_irqrestore(&managers_lock, flags); + pr_info("Added manager uid=%d, signature_index=%d\n", uid, signature_index); + return; + } + } + + spin_unlock_irqrestore(&managers_lock, flags); + pr_warn("Failed to add manager, no free slots\n"); +} + +void ksu_remove_manager(uid_t uid) +{ + unsigned long flags; + int i; + + if (!ksu_is_dynamic_sign_enabled()) { + return; + } + + spin_lock_irqsave(&managers_lock, flags); + + for (i = 0; i < MAX_MANAGERS; i++) { + if (active_managers[i].is_active && active_managers[i].uid == uid) { + active_managers[i].is_active = false; + pr_info("Removed manager uid=%d\n", uid); + break; + } + } + + spin_unlock_irqrestore(&managers_lock, flags); +} + +bool ksu_is_any_manager(uid_t uid) +{ + unsigned long flags; + bool is_manager = false; + int i; + + if (!ksu_is_dynamic_sign_enabled()) { + return false; + } + + spin_lock_irqsave(&managers_lock, flags); + + for (i = 0; i < MAX_MANAGERS; i++) { + if (active_managers[i].is_active && active_managers[i].uid == uid) { + is_manager = true; + break; + } + } + + spin_unlock_irqrestore(&managers_lock, flags); + return is_manager; +} + +int ksu_get_manager_signature_index(uid_t uid) +{ + unsigned long flags; + int signature_index = -1; + int i; + + // Check traditional manager first + if (ksu_manager_uid != KSU_INVALID_UID && uid == ksu_manager_uid) { + return 1; + } + + if (!ksu_is_dynamic_sign_enabled()) { + return -1; + } + + spin_lock_irqsave(&managers_lock, flags); + + for (i = 0; i < MAX_MANAGERS; i++) { + if (active_managers[i].is_active && active_managers[i].uid == uid) { + signature_index = active_managers[i].signature_index; + break; + } + } + + spin_unlock_irqrestore(&managers_lock, flags); + return signature_index; +} + +static void clear_dynamic_manager(void) +{ + unsigned long flags; + int i; + + spin_lock_irqsave(&managers_lock, flags); + + for (i = 0; i < MAX_MANAGERS; i++) { + if (active_managers[i].is_active) { + pr_info("Clearing dynamic manager uid=%d (signature_index=%d) for rescan\n", + active_managers[i].uid, active_managers[i].signature_index); + active_managers[i].is_active = false; + } + } + + spin_unlock_irqrestore(&managers_lock, flags); +} + +int ksu_get_active_managers(struct manager_list_info *info) +{ + unsigned long flags; + int i, count = 0; + + if (!info) { + return -EINVAL; + } + + // Add traditional manager first + if (ksu_manager_uid != KSU_INVALID_UID && count < 2) { + info->managers[count].uid = ksu_manager_uid; + info->managers[count].signature_index = 0; + count++; + } + + // Add dynamic managers + if (ksu_is_dynamic_sign_enabled()) { + spin_lock_irqsave(&managers_lock, flags); + + for (i = 0; i < MAX_MANAGERS && count < 2; i++) { + if (active_managers[i].is_active) { + info->managers[count].uid = active_managers[i].uid; + info->managers[count].signature_index = active_managers[i].signature_index; + count++; + } + } + + spin_unlock_irqrestore(&managers_lock, flags); + } + + info->count = count; + return 0; +} + +static void do_save_dynamic_sign(struct work_struct *work) +{ + u32 magic = DYNAMIC_SIGN_FILE_MAGIC; + u32 version = DYNAMIC_SIGN_FILE_VERSION; + struct dynamic_sign_config config_to_save; + loff_t off = 0; + unsigned long flags; + struct file *fp; + + spin_lock_irqsave(&dynamic_sign_lock, flags); + config_to_save = dynamic_sign; + spin_unlock_irqrestore(&dynamic_sign_lock, flags); + + if (!config_to_save.is_set) { + pr_info("Dynamic sign config not set, skipping save\n"); + return; + } + + fp = ksu_filp_open_compat(KERNEL_SU_DYNAMIC_SIGN, O_WRONLY | O_CREAT | O_TRUNC, 0644); + if (IS_ERR(fp)) { + pr_err("save_dynamic_sign create file failed: %ld\n", PTR_ERR(fp)); + return; + } + + if (ksu_kernel_write_compat(fp, &magic, sizeof(magic), &off) != sizeof(magic)) { + pr_err("save_dynamic_sign write magic failed.\n"); + goto exit; + } + + if (ksu_kernel_write_compat(fp, &version, sizeof(version), &off) != sizeof(version)) { + pr_err("save_dynamic_sign write version failed.\n"); + goto exit; + } + + if (ksu_kernel_write_compat(fp, &config_to_save, sizeof(config_to_save), &off) != sizeof(config_to_save)) { + pr_err("save_dynamic_sign write config failed.\n"); + goto exit; + } + + pr_info("Dynamic sign config saved successfully\n"); + +exit: + filp_close(fp, 0); +} + +static void do_load_dynamic_sign(struct work_struct *work) +{ + loff_t off = 0; + ssize_t ret = 0; + struct file *fp = NULL; + u32 magic; + u32 version; + struct dynamic_sign_config loaded_config; + unsigned long flags; + int i; + + fp = ksu_filp_open_compat(KERNEL_SU_DYNAMIC_SIGN, O_RDONLY, 0); + if (IS_ERR(fp)) { + if (PTR_ERR(fp) == -ENOENT) { + pr_info("No saved dynamic sign config found\n"); + } else { + pr_err("load_dynamic_sign open file failed: %ld\n", PTR_ERR(fp)); + } + return; + } + + if (ksu_kernel_read_compat(fp, &magic, sizeof(magic), &off) != sizeof(magic) || + magic != DYNAMIC_SIGN_FILE_MAGIC) { + pr_err("dynamic sign file invalid magic: %x!\n", magic); + goto exit; + } + + if (ksu_kernel_read_compat(fp, &version, sizeof(version), &off) != sizeof(version)) { + pr_err("dynamic sign read version failed\n"); + goto exit; + } + + pr_info("dynamic sign file version: %d\n", version); + + ret = ksu_kernel_read_compat(fp, &loaded_config, sizeof(loaded_config), &off); + if (ret <= 0) { + pr_info("load_dynamic_sign read err: %zd\n", ret); + goto exit; + } + + if (ret != sizeof(loaded_config)) { + pr_err("load_dynamic_sign read incomplete config: %zd/%zu\n", ret, sizeof(loaded_config)); + goto exit; + } + + if (loaded_config.size < 0x100 || loaded_config.size > 0x1000) { + pr_err("Invalid saved config size: 0x%x\n", loaded_config.size); + goto exit; + } + + if (strlen(loaded_config.hash) != 64) { + pr_err("Invalid saved config hash length: %zu\n", strlen(loaded_config.hash)); + goto exit; + } + + // Validate hash format + for (i = 0; i < 64; i++) { + char c = loaded_config.hash[i]; + if (!((c >= '0' && c <= '9') || (c >= 'a' && c <= 'f'))) { + pr_err("Invalid saved config hash character at position %d: %c\n", i, c); + goto exit; + } + } + + spin_lock_irqsave(&dynamic_sign_lock, flags); + dynamic_sign = loaded_config; + spin_unlock_irqrestore(&dynamic_sign_lock, flags); + + pr_info("Dynamic sign config loaded: size=0x%x, hash=%.16s...\n", + loaded_config.size, loaded_config.hash); + +exit: + filp_close(fp, 0); +} + +static bool persistent_dynamic_sign(void) +{ + return ksu_queue_work(&ksu_save_dynamic_sign_work); +} + +static void do_clear_dynamic_sign(struct work_struct *work) +{ + loff_t off = 0; + struct file *fp; + char zero_buffer[512]; + + memset(zero_buffer, 0, sizeof(zero_buffer)); + + fp = ksu_filp_open_compat(KERNEL_SU_DYNAMIC_SIGN, O_WRONLY | O_CREAT | O_TRUNC, 0644); + if (IS_ERR(fp)) { + pr_err("clear_dynamic_sign create file failed: %ld\n", PTR_ERR(fp)); + return; + } + + // Write null bytes to overwrite the file content + if (ksu_kernel_write_compat(fp, zero_buffer, sizeof(zero_buffer), &off) != sizeof(zero_buffer)) { + pr_err("clear_dynamic_sign write null bytes failed.\n"); + } else { + pr_info("Dynamic sign config file cleared successfully\n"); + } + + filp_close(fp, 0); +} + +static bool clear_dynamic_sign_file(void) +{ + return ksu_queue_work(&ksu_clear_dynamic_sign_work); +} + +int ksu_handle_dynamic_sign(struct dynamic_sign_user_config *config) +{ + unsigned long flags; + int ret = 0; + int i; + + if (!config) { + return -EINVAL; + } + + switch (config->operation) { + case DYNAMIC_SIGN_OP_SET: + if (config->size < 0x100 || config->size > 0x1000) { + pr_err("invalid size: 0x%x\n", config->size); + return -EINVAL; + } + + if (strlen(config->hash) != 64) { + pr_err("invalid hash length: %zu\n", strlen(config->hash)); + return -EINVAL; + } + + // Validate hash format + for (i = 0; i < 64; i++) { + char c = config->hash[i]; + if (!((c >= '0' && c <= '9') || (c >= 'a' && c <= 'f'))) { + pr_err("invalid hash character at position %d: %c\n", i, c); + return -EINVAL; + } + } + + spin_lock_irqsave(&dynamic_sign_lock, flags); + dynamic_sign.size = config->size; +#if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 13, 0) + strscpy(dynamic_sign.hash, config->hash, sizeof(dynamic_sign.hash)); +#else + strlcpy(dynamic_sign.hash, config->hash, sizeof(dynamic_sign.hash)); +#endif + dynamic_sign.is_set = 1; + spin_unlock_irqrestore(&dynamic_sign_lock, flags); + + persistent_dynamic_sign(); + pr_info("dynamic sign updated: size=0x%x, hash=%.16s... (multi-manager enabled)\n", + config->size, config->hash); + break; + + case DYNAMIC_SIGN_OP_GET: + spin_lock_irqsave(&dynamic_sign_lock, flags); + if (dynamic_sign.is_set) { + config->size = dynamic_sign.size; +#if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 13, 0) + strscpy(config->hash, dynamic_sign.hash, sizeof(config->hash)); +#else + strlcpy(config->hash, dynamic_sign.hash, sizeof(config->hash)); +#endif + ret = 0; + } else { + ret = -ENODATA; + } + spin_unlock_irqrestore(&dynamic_sign_lock, flags); + break; + + case DYNAMIC_SIGN_OP_CLEAR: + spin_lock_irqsave(&dynamic_sign_lock, flags); + dynamic_sign.size = 0x300; + strcpy(dynamic_sign.hash, "0000000000000000000000000000000000000000000000000000000000000000"); + dynamic_sign.is_set = 0; + spin_unlock_irqrestore(&dynamic_sign_lock, flags); + + // Clear only dynamic managers, preserve default manager + clear_dynamic_manager(); + + // Clear file using the same method as save + clear_dynamic_sign_file(); + + pr_info("Dynamic sign config cleared (multi-manager disabled)\n"); + break; + + default: + pr_err("Invalid dynamic sign operation: %d\n", config->operation); + return -EINVAL; + } + + return ret; +} + +bool ksu_load_dynamic_sign(void) +{ + return ksu_queue_work(&ksu_load_dynamic_sign_work); +} + +void ksu_dynamic_sign_init(void) +{ + int i; + + INIT_WORK(&ksu_save_dynamic_sign_work, do_save_dynamic_sign); + INIT_WORK(&ksu_load_dynamic_sign_work, do_load_dynamic_sign); + INIT_WORK(&ksu_clear_dynamic_sign_work, do_clear_dynamic_sign); + + // Initialize manager slots + for (i = 0; i < MAX_MANAGERS; i++) { + active_managers[i].is_active = false; + } + + ksu_load_dynamic_sign(); + + pr_info("Dynamic sign initialized with conditional multi-manager support\n"); +} + +void ksu_dynamic_sign_exit(void) +{ + clear_dynamic_manager(); + + // Save current config before exit + do_save_dynamic_sign(NULL); + pr_info("Dynamic sign exited with persistent storage\n"); +} + +// Get dynamic sign configuration for signature verification +bool ksu_get_dynamic_sign_config(unsigned int *size, const char **hash) +{ + unsigned long flags; + bool valid = false; + + spin_lock_irqsave(&dynamic_sign_lock, flags); + if (dynamic_sign.is_set) { + if (size) *size = dynamic_sign.size; + if (hash) *hash = dynamic_sign.hash; + valid = true; + } + spin_unlock_irqrestore(&dynamic_sign_lock, flags); + + return valid; +} \ No newline at end of file diff --git a/kernel/dynamic_sign.h b/kernel/dynamic_sign.h new file mode 100644 index 00000000..e0f93272 --- /dev/null +++ b/kernel/dynamic_sign.h @@ -0,0 +1,43 @@ +#ifndef __KSU_H_DYNAMIC_SIGN +#define __KSU_H_DYNAMIC_SIGN + +#include +#include "ksu.h" + +#define DYNAMIC_SIGN_FILE_MAGIC 0x7f445347 // 'DSG', u32 +#define DYNAMIC_SIGN_FILE_VERSION 1 // u32 +#define KERNEL_SU_DYNAMIC_SIGN "/data/adb/ksu/.dynamic_sign" + +struct dynamic_sign_config { + unsigned int size; + char hash[65]; + int is_set; +}; + +struct manager_info { + uid_t uid; + int signature_index; + bool is_active; +}; + +// Dynamic sign operations +int ksu_handle_dynamic_sign(struct dynamic_sign_user_config *config); +void ksu_dynamic_sign_init(void); +void ksu_dynamic_sign_exit(void); +bool ksu_load_dynamic_sign(void); +bool ksu_is_dynamic_sign_enabled(void); + +// Multi-manager operations +void ksu_add_manager(uid_t uid, int signature_index); +void ksu_remove_manager(uid_t uid); +bool ksu_is_any_manager(uid_t uid); +int ksu_get_manager_signature_index(uid_t uid); +int ksu_get_active_managers(struct manager_list_info *info); + +// Multi-manager APK verification +bool ksu_is_multi_manager_apk(char *path, int *signature_index); + +// Get dynamic sign configuration for signature verification +bool ksu_get_dynamic_sign_config(unsigned int *size, const char **hash); + +#endif \ No newline at end of file diff --git a/kernel/throne_tracker.c b/kernel/throne_tracker.c index 380e4bad..1f3f9605 100644 --- a/kernel/throne_tracker.c +++ b/kernel/throne_tracker.c @@ -12,6 +12,7 @@ #include "manager.h" #include "throne_tracker.h" #include "kernel_compat.h" +#include "dynamic_sign.h" uid_t ksu_manager_uid = KSU_INVALID_UID; @@ -388,8 +389,10 @@ void track_throne() struct uid_data *np; struct uid_data *n; - // first, check if manager_uid exist! + // Check if any manager exists (traditional or dynamic) bool manager_exist = false; + + // Check for traditional manager list_for_each_entry (np, &uid_list, list) { // if manager is installed in work profile, the uid in packages.list is still equals main profile // don't delete it in this case! @@ -398,9 +401,15 @@ void track_throne() manager_exist = true; break; } - - if (ksu_is_any_manager(np->uid)) { - manager_exist = true; + } + + // Check for dynamic managers + if (!manager_exist && ksu_is_dynamic_sign_enabled()) { + list_for_each_entry (np, &uid_list, list) { + if (ksu_is_any_manager(np->uid)) { + manager_exist = true; + break; + } } } @@ -413,6 +422,11 @@ void track_throne() pr_info("Searching manager...\n"); search_manager("/data/app", 2, &uid_list); pr_info("Search manager finished\n"); + } else { + // Always perform search when called from dynamic sign rescan + pr_info("Performing manager search (may be from dynamic sign rescan)\n"); + search_manager("/data/app", 2, &uid_list); + pr_info("Manager search completed\n"); } prune: