Lightemerald/TrickyStore
1
0
Fork 0
mirror of https://github.com/chiteroman/TrickyStore.git synced 2025-07-17 15:29:32 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Downgrade to Zygisk api v2

Browse Source
This commit is contained in:
chiteroman
2024-08-12 02:43:44 +02:00
parent 1e7c98b389
commit bf87ea42b8
1 changed files with 209 additions and 244 deletions
Download Patch File Download Diff File Expand all files Collapse all files

155
module/src/main/cpp/zygisk/zygisk.hpp
View File

@@ -19,7 +19,7 @@
#include <jni.h> #include <jni.h>
#define ZYGISK_API_VERSION 4 #define ZYGISK_API_VERSION 2
/* /*
@@ -97,12 +97,12 @@ REGISTER_ZYGISK_COMPANION(example_handler)
namespace zygisk { namespace zygisk {
struct Api; struct Api;
struct AppSpecializeArgs; struct AppSpecializeArgs;
struct ServerSpecializeArgs; struct ServerSpecializeArgs;
class ModuleBase { class ModuleBase {
public: public:
// This method is called as soon as the module is loaded into the target process. // This method is called as soon as the module is loaded into the target process.
// A Zygisk API handle will be passed as an argument. // A Zygisk API handle will be passed as an argument.
@@ -134,15 +134,14 @@ namespace zygisk {
// This method is called after the system server process is specialized. // This method is called after the system server process is specialized.
// At this point, the process runs with the privilege of system_server. // At this point, the process runs with the privilege of system_server.
virtual void postServerSpecialize([[maybe_unused]] const ServerSpecializeArgs *args) {} virtual void postServerSpecialize([[maybe_unused]] const ServerSpecializeArgs *args) {}
}; };
struct AppSpecializeArgs { struct AppSpecializeArgs {
// Required arguments. These arguments are guaranteed to exist on all Android versions. // Required arguments. These arguments are guaranteed to exist on all Android versions.
jint &uid; jint &uid;
jint &gid; jint &gid;
jintArray &gids; jintArray &gids;
jint &runtime_flags; jint &runtime_flags;
jobjectArray &rlimits;
jint &mount_external; jint &mount_external;
jstring &se_info; jstring &se_info;
jstring &nice_name; jstring &nice_name;
@@ -150,7 +149,6 @@ namespace zygisk {
jstring &app_data_dir; jstring &app_data_dir;
// Optional arguments. Please check whether the pointer is null before de-referencing // Optional arguments. Please check whether the pointer is null before de-referencing
jintArray *const fds_to_ignore;
jboolean *const is_child_zygote; jboolean *const is_child_zygote;
jboolean *const is_top_app; jboolean *const is_top_app;
jobjectArray *const pkg_data_info_list; jobjectArray *const pkg_data_info_list;
@@ -159,9 +157,9 @@ namespace zygisk {
jboolean *const mount_storage_dirs; jboolean *const mount_storage_dirs;
AppSpecializeArgs() = delete; AppSpecializeArgs() = delete;
}; };
struct ServerSpecializeArgs { struct ServerSpecializeArgs {
jint &uid; jint &uid;
jint &gid; jint &gid;
jintArray &gids; jintArray &gids;
@@ -170,17 +168,15 @@ namespace zygisk {
jlong &effective_capabilities; jlong &effective_capabilities;
ServerSpecializeArgs() = delete; ServerSpecializeArgs() = delete;
}; };
namespace internal { namespace internal {
struct api_table; struct api_table;
template <class T> void entry_impl(api_table *, JNIEnv *);
template<class T> }
void entry_impl(api_table *, JNIEnv *);
}
// These values are used in Api::setOption(Option) // These values are used in Api::setOption(Option)
enum Option : int { enum Option : int {
// Force Magisk's denylist unmount routines to run on this process. // Force Magisk's denylist unmount routines to run on this process.
// //
// Setting this option only makes sense in preAppSpecialize. // Setting this option only makes sense in preAppSpecialize.
@@ -194,20 +190,20 @@ namespace zygisk {
// Be aware that after dlclose-ing your module, all of your code will be unmapped from memory. // Be aware that after dlclose-ing your module, all of your code will be unmapped from memory.
// YOU MUST NOT ENABLE THIS OPTION AFTER HOOKING ANY FUNCTIONS IN THE PROCESS. // YOU MUST NOT ENABLE THIS OPTION AFTER HOOKING ANY FUNCTIONS IN THE PROCESS.
DLCLOSE_MODULE_LIBRARY = 1, DLCLOSE_MODULE_LIBRARY = 1,
}; };
// Bit masks of the return value of Api::getFlags() // Bit masks of the return value of Api::getFlags()
enum StateFlag : uint32_t { enum StateFlag : uint32_t {
// The user has granted root access to the current process // The user has granted root access to the current process
PROCESS_GRANTED_ROOT = (1u << 0), PROCESS_GRANTED_ROOT = (1u << 0),
// The current process was added on the denylist // The current process was added on the denylist
PROCESS_ON_DENYLIST = (1u << 1), PROCESS_ON_DENYLIST = (1u << 1),
}; };
// All API methods will stop working after post[XXX]Specialize as Zygisk will be unloaded // All API methods will stop working after post[XXX]Specialize as Zygisk will be unloaded
// from the specialized process afterwards. // from the specialized process afterwards.
struct Api { struct Api {
// Connect to a root companion process and get a Unix domain socket for IPC. // Connect to a root companion process and get a Unix domain socket for IPC.
// //
@@ -245,22 +241,13 @@ namespace zygisk {
// Returns bitwise-or'd zygisk::StateFlag values. // Returns bitwise-or'd zygisk::StateFlag values.
uint32_t getFlags(); uint32_t getFlags();
// Exempt the provided file descriptor from being automatically closed.
//
// This API only make sense in preAppSpecialize; calling this method in any other situation
// is either a no-op (returns true) or an error (returns false).
//
// When false is returned, the provided file descriptor will eventually be closed by zygote.
bool exemptFd(int fd);
// Hook JNI native methods for a class // Hook JNI native methods for a class
// //
// Lookup all registered JNI native methods and replace it with your own methods. // Lookup all registered JNI native methods and replace it with your own methods.
// The original function pointer will be saved in each JNINativeMethod's fnPtr. // The original function pointer will be saved in each JNINativeMethod's fnPtr.
// If no matching class, method name, or signature is found, that specific JNINativeMethod.fnPtr // If no matching class, method name, or signature is found, that specific JNINativeMethod.fnPtr
// will be set to nullptr. // will be set to nullptr.
void hookJniNativeMethods(JNIEnv *env, const char *className, JNINativeMethod *methods, void hookJniNativeMethods(JNIEnv *env, const char *className, JNINativeMethod *methods, int numMethods);
int numMethods);
// Hook functions in the PLT (Procedure Linkage Table) of ELFs loaded in memory. // Hook functions in the PLT (Procedure Linkage Table) of ELFs loaded in memory.
// //
@@ -270,22 +257,22 @@ namespace zygisk {
// 56b4346000-56b4347000 r-xp 00002000 fe:00 235 /system/bin/app_process64 // 56b4346000-56b4347000 r-xp 00002000 fe:00 235 /system/bin/app_process64
// (More details: https://man7.org/linux/man-pages/man5/proc.5.html) // (More details: https://man7.org/linux/man-pages/man5/proc.5.html)
// //
// The `dev` and `inode` pair uniquely identifies a file being mapped into memory. // For ELFs loaded in memory with pathname matching `regex`, replace function `symbol` with `newFunc`.
// For matching ELFs loaded in memory, replace function `symbol` with `newFunc`.
// If `oldFunc` is not nullptr, the original function pointer will be saved to `oldFunc`. // If `oldFunc` is not nullptr, the original function pointer will be saved to `oldFunc`.
void void pltHookRegister(const char *regex, const char *symbol, void *newFunc, void **oldFunc);
pltHookRegister(dev_t dev, ino_t inode, const char *symbol, void *newFunc, void **oldFunc);
// For ELFs loaded in memory with pathname matching `regex`, exclude hooks registered for `symbol`.
// If `symbol` is nullptr, then all symbols will be excluded.
void pltHookExclude(const char *regex, const char *symbol);
// Commit all the hooks that was previously registered. // Commit all the hooks that was previously registered.
// Returns false if an error occurred. // Returns false if an error occurred.
bool pltHookCommit(); bool pltHookCommit();
private: private:
internal::api_table *tbl; internal::api_table *tbl;
template <class T> friend void internal::entry_impl(internal::api_table *, JNIEnv *);
template<class T> };
friend void internal::entry_impl(internal::api_table *, JNIEnv *);
};
// Register a class as a Zygisk module // Register a class as a Zygisk module
@@ -312,18 +299,15 @@ void zygisk_companion_entry(int client) { func(client); }
* You do not have to understand what it is doing. * You do not have to understand what it is doing.
*********************************************************/ *********************************************************/
namespace internal { namespace internal {
struct module_abi { struct module_abi {
long api_version; long api_version;
ModuleBase *impl; ModuleBase *impl;
void (*preAppSpecialize)(ModuleBase *, AppSpecializeArgs *); void (*preAppSpecialize)(ModuleBase *, AppSpecializeArgs *);
void (*postAppSpecialize)(ModuleBase *, const AppSpecializeArgs *); void (*postAppSpecialize)(ModuleBase *, const AppSpecializeArgs *);
void (*preServerSpecialize)(ModuleBase *, ServerSpecializeArgs *); void (*preServerSpecialize)(ModuleBase *, ServerSpecializeArgs *);
void (*postServerSpecialize)(ModuleBase *, const ServerSpecializeArgs *); void (*postServerSpecialize)(ModuleBase *, const ServerSpecializeArgs *);
module_abi(ModuleBase *module) : api_version(ZYGISK_API_VERSION), impl(module) { module_abi(ModuleBase *module) : api_version(ZYGISK_API_VERSION), impl(module) {
@@ -332,33 +316,25 @@ void zygisk_companion_entry(int client) { func(client); }
preServerSpecialize = [](auto m, auto args) { m->preServerSpecialize(args); }; preServerSpecialize = [](auto m, auto args) { m->preServerSpecialize(args); };
postServerSpecialize = [](auto m, auto args) { m->postServerSpecialize(args); }; postServerSpecialize = [](auto m, auto args) { m->postServerSpecialize(args); };
} }
}; };
struct api_table { struct api_table {
// Base // Base
void *impl; void *impl;
bool (*registerModule)(api_table *, module_abi *); bool (*registerModule)(api_table *, module_abi *);
void (*hookJniNativeMethods)(JNIEnv *, const char *, JNINativeMethod *, int); void (*hookJniNativeMethods)(JNIEnv *, const char *, JNINativeMethod *, int);
void (*pltHookRegister)(const char *, const char *, void *, void **);
void (*pltHookRegister)(dev_t, ino_t, const char *, void *, void **); void (*pltHookExclude)(const char *, const char *);
bool (*exemptFd)(int);
bool (*pltHookCommit)(); bool (*pltHookCommit)();
int (*connectCompanion)(void * /* impl */); int (*connectCompanion)(void * /* impl */);
void (*setOption)(void * /* impl */, Option); void (*setOption)(void * /* impl */, Option);
int (*getModuleDir)(void * /* impl */); int (*getModuleDir)(void * /* impl */);
uint32_t (*getFlags)(void * /* impl */); uint32_t (*getFlags)(void * /* impl */);
}; };
template<class T> template <class T>
void entry_impl(api_table *table, JNIEnv *env) { void entry_impl(api_table *table, JNIEnv *env) {
static Api api; static Api api;
api.tbl = table; api.tbl = table;
static T module; static T module;
@@ -366,45 +342,34 @@ void zygisk_companion_entry(int client) { func(client); }
static module_abi abi(m); static module_abi abi(m);
if (!table->registerModule(table, &abi)) return; if (!table->registerModule(table, &abi)) return;
m->onLoad(&api, env); m->onLoad(&api, env);
} }
} // namespace internal } // namespace internal
inline int Api::connectCompanion() { inline int Api::connectCompanion() {
return tbl->connectCompanion ? tbl->connectCompanion(tbl->impl) : -1; return tbl->connectCompanion ? tbl->connectCompanion(tbl->impl) : -1;
} }
inline int Api::getModuleDir() {
inline int Api::getModuleDir() {
return tbl->getModuleDir ? tbl->getModuleDir(tbl->impl) : -1; return tbl->getModuleDir ? tbl->getModuleDir(tbl->impl) : -1;
} }
inline void Api::setOption(Option opt) {
inline void Api::setOption(Option opt) {
if (tbl->setOption) tbl->setOption(tbl->impl, opt); if (tbl->setOption) tbl->setOption(tbl->impl, opt);
} }
inline uint32_t Api::getFlags() {
inline uint32_t Api::getFlags() {
return tbl->getFlags ? tbl->getFlags(tbl->impl) : 0; return tbl->getFlags ? tbl->getFlags(tbl->impl) : 0;
} }
inline void Api::hookJniNativeMethods(JNIEnv *env, const char *className, JNINativeMethod *methods, int numMethods) {
inline bool Api::exemptFd(int fd) { if (tbl->hookJniNativeMethods) tbl->hookJniNativeMethods(env, className, methods, numMethods);
return tbl->exemptFd != nullptr && tbl->exemptFd(fd); }
} inline void Api::pltHookRegister(const char *regex, const char *symbol, void *newFunc, void **oldFunc) {
if (tbl->pltHookRegister) tbl->pltHookRegister(regex, symbol, newFunc, oldFunc);
inline void }
Api::hookJniNativeMethods(JNIEnv *env, const char *className, JNINativeMethod *methods, inline void Api::pltHookExclude(const char *regex, const char *symbol) {
int numMethods) { if (tbl->pltHookExclude) tbl->pltHookExclude(regex, symbol);
if (tbl->hookJniNativeMethods) }
tbl->hookJniNativeMethods(env, className, methods, numMethods); inline bool Api::pltHookCommit() {
}
inline void Api::pltHookRegister(dev_t dev, ino_t inode, const char *symbol, void *newFunc,
void **oldFunc) {
if (tbl->pltHookRegister) tbl->pltHookRegister(dev, inode, symbol, newFunc, oldFunc);
}
inline bool Api::pltHookCommit() {
return tbl->pltHookCommit != nullptr && tbl->pltHookCommit(); return tbl->pltHookCommit != nullptr && tbl->pltHookCommit();
} }
} // namespace zygisk } // namespace zygisk