add: zygiskd C99 APatch support

This commit adds support for zygiskd C99 to recognize APatch rooted devices.

Author: ThePedroo

zygiskd/build.gradle.kts

@@ -14,7 +14,8 @@ fun getLatestNDKPath(): String {
     throw Exception("NDK not found at $ndkPath")
   }
 
-  val ndkVersion = ndkDir.toFile().listFiles().filter { it.isDirectory }.map { it.name }.sorted().last()
+  // get 2nd latest version
+  val ndkVersion = ndkDir.toFile().listFiles().filter { it.isDirectory }.map { it.name }.sorted().reversed().getOrNull(1)
   return ndkPath + "/" + ndkVersion
 }
 
@@ -26,6 +27,14 @@ val verCode: Int by rootProject.extra
 val verName: String by rootProject.extra
 val commitHash: String by rootProject.extra
 
+val CStandardFlags = arrayOf(
+  "-DMIN_APATCH_VERSION=$minAPatchVersion",
+  "-DMIN_KSU_VERSION=$minKsuVersion",
+  "-DMAX_KSU_VERSION=$maxKsuVersion",
+  "-DMIN_MAGISK_VERSION=$minMagiskVersion",
+  "-DZKSU_VERSION=\"$verName\""
+)
+
 val CFlagsRelease = arrayOf(
   "-D_GNU_SOURCE", "-std=c99", "-Wpedantic", "-Wall", "-Wextra", "-Werror",
   "-Wformat", "-Wuninitialized", "-Wshadow", "-Wno-zero-length-array", 
@@ -41,6 +50,7 @@ val CFlagsDebug = arrayOf(
 )
 
 val Files = arrayOf(
+  "root_impl/apatch.c",
   "root_impl/common.c",
   "root_impl/kernelsu.c",
   "companion.c",
@@ -94,7 +104,7 @@ task("buildAndStrip") {
     x86OutputDir.mkdirs()
     x86_64OutputDir.mkdirs()
 
-    val compileArgs = if (isDebug) CFlagsDebug else CFlagsRelease
+    val compileArgs = (if (isDebug) CFlagsDebug else CFlagsRelease) + CStandardFlags
 
     exec {
       commandLine(aarch64Compiler, "-o", Paths.get(aarch64OutputDir.toString(), "zygiskd").toString(), *compileArgs, *Files)

zygiskd/src/companion.c

@@ -17,20 +17,20 @@
 #include "dl.h"
 #include "utils.h"
 
-typedef void (*ZygiskCompanionEntryFn)(int);
+typedef void (*zygisk_companion_entry_func)(int);
 
-ZygiskCompanionEntryFn load_module(int fd) {
+zygisk_companion_entry_func load_module(int fd) {
   char path[PATH_MAX];
   snprintf(path, sizeof(path), "/proc/self/fd/%d", fd);
 
   void *handle = android_dlopen(path, RTLD_NOW);
   void *entry = dlsym(handle, "zygisk_companion_entry");
   if (entry == NULL) return NULL;
 
-  return (ZygiskCompanionEntryFn)entry;
+  return (zygisk_companion_entry_func)entry;
 }
 
-void *ExecuteNew(void *arg) {
+void *call_entry(void *arg) {
   int fd = *((int *)arg);
 
   struct stat st0;
@@ -65,13 +65,10 @@ void *ExecuteNew(void *arg) {
   return NULL;
 }
 
-
 void entry(int fd) {
   LOGI("companion entry fd: |%d|\n", fd);
 
   char name[256 + 1];
-
-  /* INFO: Getting stuck here */
   ssize_t ret = read_string(fd, name, sizeof(name) - 1);
   if (ret == -1) return;
 
@@ -84,7 +81,7 @@ void entry(int fd) {
 
   LOGI("Library fd: %d\n", library_fd);
 
-  ZygiskCompanionEntryFn entry = load_module(library_fd);
+  zygisk_companion_entry_func entry = load_module(library_fd);
 
   LOGI("Library loaded\n");
 
@@ -95,31 +92,43 @@ void entry(int fd) {
   if (entry == NULL) {
     LOGI("No companion entry for: %s\n", name);
 
-    write(fd, (void *)0, 1);
+    uint8_t response[1] = { 0 };
+    write(fd, &response, sizeof(response));
+
+    exit(0);
 
     return;
   }
 
   LOGI("Companion process created for: %s\n", name);
 
-  uint8_t response = 1;
+  uint8_t response[1] = { 1 };
   write(fd, &response, sizeof(response));
 
   while (1) {
+    if (!check_unix_socket(fd, true)) {
+      LOGI("Something went wrong. Bye!\n");
+
+      exit(0);
+
+      break;
+    }
+
     int client_fd;
     recv_fd(fd, &client_fd);
 
     LOGI("New companion request from module \"%s\" with fd \"%d\"\n", name, client_fd);
 
     write(fd, &response, sizeof(response));
 
+    /* TODO: Do we really need to allocate this..? */
     int *client_fd_ptr = malloc(sizeof(int));
     *client_fd_ptr = client_fd;
 
     LOGI("Creating new thread for companion request\n");
 
     pthread_t thread;
-    pthread_create(&thread, NULL, ExecuteNew, (void *)client_fd_ptr);
+    pthread_create(&thread, NULL, call_entry, (void *)client_fd_ptr);
     pthread_detach(thread);
   }
 }

zygiskd/src/constants.h

@@ -7,20 +7,6 @@
 #define true 1
 #define false 0
 
-// #define MIN_APATCH_VERSION (atoi(getenv("MIN_APATCH_VERSION")))
-// #define MIN_KSU_VERSION (atoi(getenv("MIN_KSU_VERSION")))
-// #define MAX_KSU_VERSION (atoi(getenv("MAX_KSU_VERSION")))
-// #define MIN_MAGISK_VERSION (atoi(getenv("MIN_MAGISK_VERSION")))
-// #define ZKSU_VERSION (getenv("ZKSU_VERSION"))
-
-#define MIN_APATCH_VERSION 0
-// val minKsudVersion by extra(11425)
-// val maxKsuVersion by extra(20000)
-#define MIN_KSU_VERSION 11425
-#define MAX_KSU_VERSION 20000
-#define MIN_MAGISK_VERSION 0
-#define ZKSU_VERSION "1.0.0"
-
 #if DEBUG == false
   #define MAX_LOG_LEVEL ANDROID_LOG_VERBOSE
 #else
@@ -64,6 +50,7 @@ enum ProcessFlags: uint32_t {
 enum RootImplState {
   Supported,
   TooOld,
+  Inexistent,
   Abnormal
 };
 

zygiskd/src/main.c

@@ -14,14 +14,7 @@
 int __android_log_print(int prio, const char *tag,  const char *fmt, ...);
 
 int main(int argc, char *argv[]) {
-  errno = 0;
-  /* Initialize android logger */
-  LOGI("Initializing zygiskd\n");
-
-  LOGI("Argc: %d\n", argc);
-  for (int i = 0; i < argc; i++) {
-    LOGI("argv[%d] = %s\n", i, argv[i]);
-  }
+  LOGI("Initializing zygiskd: %s\n", argv[0]);
 
   if (argc > 1) {
     if (strcmp(argv[1], "companion") == 0) {
@@ -63,10 +56,14 @@ int main(int argc, char *argv[]) {
         case KernelSU: {
           LOGI("KernelSU root implementation found.\n");
 
+          return 0;
+        }
+        case APatch: {
+          LOGI("APatch root implementation found.\n");
+
           return 0;
         }
       }
-      
 
       return 0;
     }

zygiskd/src/root_impl/apatch.c

@@ -0,0 +1,144 @@
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <errno.h>
+
+#include "../constants.h"
+#include "../utils.h"
+
+#include "apatch.h"
+
+enum RootImplState apatch_get_existence(void) {
+  struct stat s;
+  if (stat("/data/adb/apd", &s) != 0) {
+    LOGE("APATCH | Failed to stat /data/adb/apd: %s\n", strerror(errno));
+
+    return Inexistent;
+  }
+
+  char apatch_version[32];
+  char *const argv[] = { "apd", "-V", NULL };
+
+  LOGI("APATCH | Checking for apd existence\n");
+  if (!exec_command(apatch_version, sizeof(apatch_version), "/data/adb/apd", argv)) {
+    LOGE("APATCH | Failed to execute apd binary: %s\n", strerror(errno));
+    errno = 0;
+
+    return Inexistent;
+  }
+
+  int version = atoi(apatch_version + strlen("apd "));
+  LOGI("APATCH | apd version: %d\n", version);
+  if (version == 0) return Abnormal;
+
+  if (version >= MIN_APATCH_VERSION && version <= 999999) return Supported;
+  if (version >= 1 && version <= MIN_APATCH_VERSION - 1) return TooOld;
+
+  return Inexistent;
+}
+
+struct package_config {
+  uid_t uid;
+  bool root_granted;
+  bool umount_needed;
+};
+
+struct packages_config {
+  struct package_config *configs;
+  size_t size;
+};
+
+bool _apatch_get_package_config(struct packages_config *config) {
+  FILE *fp = fopen("/data/adb/ap/package_config", "r");
+  if (fp == NULL) {
+    LOGE("APATCH | Failed to open package_config: %s\n", strerror(errno));
+
+    return false;
+  }
+
+  char line[256];
+  /* INFO: Skip the CSV header */
+  fgets(line, sizeof(line), fp);
+
+  while (fgets(line, sizeof(line), fp) != NULL) {
+    config->configs = realloc(config, (config->size + 1) * sizeof(struct package_config));
+    if (config->configs == NULL) {
+      LOGE("APATCH | Failed to realloc package config: %s\n", strerror(errno));
+
+      fclose(fp);
+
+      return false;
+    }
+
+    strtok(line, ",");
+
+    char *exclude_str = strtok(NULL, ",");
+    if (exclude_str == NULL) continue;
+
+    char *allow_str = strtok(NULL, ",");
+    if (allow_str == NULL) continue;
+
+    char *uid_str = strtok(NULL, ",");
+    if (uid_str == NULL) continue;    
+
+    config->configs[config->size].uid = atoi(uid_str);
+    config->configs[config->size].root_granted = strcmp(allow_str, "1") == 0;
+    config->configs[config->size].umount_needed = strcmp(exclude_str, "1") == 0;
+
+    config->size++;
+  }
+
+  fclose(fp);
+
+  return true;
+}
+
+bool apatch_uid_granted_root(uid_t uid) {
+  struct packages_config *config = NULL;
+  if (!_apatch_get_package_config(config)) {
+    free(config);
+
+    return false;
+  }
+
+  for (size_t i = 0; i < config->size; i++) {
+    if (config->configs[i].uid == uid) {
+      free(config);
+
+      return config->configs[i].root_granted;
+    }
+  }
+
+  free(config);
+
+  return false;
+}
+
+bool apatch_uid_should_umount(uid_t uid) {
+  struct packages_config *config = NULL;
+  if (!_apatch_get_package_config(config)) {
+    free(config);
+
+    return false;
+  }
+
+  for (size_t i = 0; i < config->size; i++) {
+    if (config->configs[i].uid == uid) {
+      free(config);
+
+      return config->configs[i].umount_needed;
+    }
+  }
+
+  free(config);
+
+  return false;
+}
+
+bool apatch_uid_is_manager(uid_t uid) {
+  struct stat s;
+  if (stat("/data/user_de/0/me.bmax.apatch", &s) == -1) return false;
+
+  return s.st_uid == uid;
+}

zygiskd/src/root_impl/apatch.h

@@ -0,0 +1,14 @@
+#ifndef APATCH_H
+#define APATCH_H
+
+#include "../constants.h"
+
+enum RootImplState apatch_get_existence(void);
+
+bool apatch_uid_granted_root(uid_t uid);
+
+bool apatch_uid_should_umount(uid_t uid);
+
+bool apatch_uid_is_manager(uid_t uid);
+
+#endif