br0kenpixel/ReZygisk
1
0
Fork 0
mirror of https://github.com/PerformanC/ReZygisk.git synced 2025-09-06 06:37:01 +00:00
Code Issues Packages Projects Releases 1 Wiki Activity

Drop 32 bit support

Browse Source
This commit is contained in:
Nullptr
2023-10-20 19:23:40 +08:00
parent 9051f59bf6
commit 8c0d5b5395
11 changed files with 35 additions and 112 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
zygiskd/build.gradle.kts
View File

@@ -18,7 +18,7 @@ cargo {
module = "."
libname = "zygiskd"
targetIncludes = arrayOf("zygiskd")
targets = listOf("arm64", "arm", "x86", "x86_64")
targets = listOf("arm64", "x86_64")
targetDirectory = "build/intermediates/rust"
val isDebug = gradle.startParameter.taskNames.any { it.toLowerCase().contains("debug") }
profile = if (isDebug) "debug" else "release"

11
zygiskd/src/constants.rs
View File

@@ -21,21 +21,16 @@ pub const PROP_CTL_RESTART: &str = "ctl.restart";
pub const ZYGISK_LIBRARY: &str = "libzygisk.so";
pub const PATH_PCL: &str = "/system/etc/preloaded-classes";
pub const PATH_SYSTEM_LIB32: &str = "/system/lib";
pub const PATH_SYSTEM_LIB64: &str = "/system/lib64";
pub const PATH_SYSTEM_LIB: &str = "/system/lib64";
pub const PATH_WORK_DIR: &str = "/dev/zygisk"; // TODO: Replace with /debug_ramdisk/zygisk
pub const PATH_PROP_OVERLAY: &str = concatcp!(PATH_WORK_DIR, "/module.prop");
#[cfg(target_pointer_width = "64")]
pub const PATH_CP_SOCKET: &str = concatcp!(PATH_WORK_DIR, "/cp64.sock");
#[cfg(target_pointer_width = "32")]
pub const PATH_CP_SOCKET: &str = concatcp!(PATH_WORK_DIR, "/cp32.sock");
pub const PATH_CP_SOCKET: &str = concatcp!(PATH_WORK_DIR, "/cp.sock");
pub const PATH_FUSE_DIR: &str = concatcp!(PATH_WORK_DIR, "/fuse");
pub const PATH_FUSE_PCL: &str = concatcp!(PATH_FUSE_DIR, "/preloaded-classes");
pub const PATH_MODULES_DIR: &str = "..";
pub const PATH_MODULE_PROP: &str = "module.prop";
pub const PATH_CP32_BIN: &str = "bin/zygisk-cp32";
pub const PATH_CP64_BIN: &str = "bin/zygisk-cp64";
pub const PATH_CP_BIN: &str = "bin/zygisk-cp";
pub const STATUS_LOADED: &str = "😋 Zygisksu is loaded";
pub const STATUS_CRASHED: &str = "❌ Zygiskd has crashed";

26
zygiskd/src/fuse.rs
View File

@@ -83,10 +83,8 @@ impl Filesystem for DelegateFilesystem {
let process = fs::read_to_string(process).unwrap();
let process = &process[..process.find('\0').unwrap()];
info!("Process {} is reading preloaded-classes", process);
match process {
// "zygote" => ptrace_zygote(pid, false).unwrap(),
"zygote64" => ptrace_zygote(pid, true).unwrap(),
_ => (),
if process == "zygote64" {
ptrace_zygote(pid).unwrap()
}
}
reply.opened(0, 0);
@@ -156,14 +154,10 @@ fn find_remote_procedure(
Ok(local_addr - local_module.start() + remote_module.start())
}
fn ptrace_zygote(pid: u32, is64: bool) -> Result<()> {
static LAST_32: Mutex<u32> = Mutex::new(0);
static LAST_64: Mutex<u32> = Mutex::new(0);
fn ptrace_zygote(pid: u32) -> Result<()> {
static LAST: Mutex<u32> = Mutex::new(0);
let mut last = match is64 {
true => LAST_64.lock().unwrap(),
false => LAST_32.lock().unwrap(),
};
let mut last = LAST.lock().unwrap();
if *last == pid {
return Ok(());
}
@@ -171,13 +165,9 @@ fn ptrace_zygote(pid: u32, is64: bool) -> Result<()> {
let (sender, receiver) = mpsc::channel::<()>();
let worker = move || -> Result<()> {
info!("Injecting into pid {}, is64 = {}", pid, is64);
let lib_dir = match is64 {
true => constants::PATH_SYSTEM_LIB64,
false => constants::PATH_SYSTEM_LIB32,
};
let zygisk_lib = format!("{}/{}", lib_dir, constants::ZYGISK_LIBRARY);
let lib_dir = CString::new(lib_dir)?;
info!("Injecting into pid {}", pid);
let zygisk_lib = format!("{}/{}", constants::PATH_SYSTEM_LIB, constants::ZYGISK_LIBRARY);
let lib_dir = CString::new(constants::PATH_SYSTEM_LIB)?;
let zygisk_lib = CString::new(zygisk_lib)?;
let libc_base = find_module_for_pid(pid as i32, ANDROID_LIBC)?.start();
let mmap_remote = find_remote_procedure(

3
zygiskd/src/main.rs
View File

@@ -25,8 +25,7 @@ async fn start(name: &str) -> Result<()> {
match name.trim_start_matches("zygisk-") {
"wd" => watchdog::main().await?,
"fuse" => fuse::main()?,
"cp32" => zygiskd::main()?,
"cp64" => zygiskd::main()?,
"cp" => zygiskd::main()?,
_ => println!("Available commands: wd, fuse, cp"),
}
Ok(())

11
zygiskd/src/utils.rs
View File

@@ -7,17 +7,6 @@ use std::sync::OnceLock;
use rustix::net::{AddressFamily, bind_unix, listen, socket, SocketAddrUnix, SocketType};
use rustix::thread::gettid;
#[cfg(target_pointer_width = "64")]
#[macro_export]
macro_rules! lp_select {
($lp32:expr, $lp64:expr) => { $lp64 };
}
#[cfg(target_pointer_width = "32")]
#[macro_export]
macro_rules! lp_select {
($lp32:expr, $lp64:expr) => { $lp32 };
}
#[cfg(debug_assertions)]
#[macro_export]
macro_rules! debug_select {

34
zygiskd/src/watchdog.rs
View File

@@ -8,7 +8,7 @@ use std::time::Duration;
use binder::IBinder;
use futures::stream::FuturesUnordered;
use futures::StreamExt;
use log::info;
use log::{debug, error, info};
use rustix::mount::mount_bind;
use rustix::process::{getgid, getuid, kill_process, Pid, Signal};
use tokio::process::{Child, Command};
@@ -124,23 +124,14 @@ async fn spawn_daemon() -> Result<()> {
let mut lives = 5;
loop {
let mut futures = FuturesUnordered::<Pin<Box<dyn Future<Output=Result<()>>>>>::new();
let mut child_ids = vec![];
let daemon = Command::new(constants::PATH_CP_BIN).spawn()?;
let daemon_pid = daemon.id().unwrap();
let daemon32 = Command::new(constants::PATH_CP32_BIN).spawn();
let daemon64 = Command::new(constants::PATH_CP64_BIN).spawn();
async fn spawn_daemon(mut daemon: Child) -> Result<()> {
async fn daemon_holder(mut daemon: Child) -> Result<()> {
let result = daemon.wait().await?;
log::error!("Daemon process {} died: {}", daemon.id().unwrap(), result);
Ok(())
}
if let Ok(it) = daemon32 {
child_ids.push(it.id().unwrap());
futures.push(Box::pin(spawn_daemon(it)));
}
if let Ok(it) = daemon64 {
child_ids.push(it.id().unwrap());
futures.push(Box::pin(spawn_daemon(it)));
bail!("Daemon process {} died: {}", daemon.id().unwrap(), result);
}
futures.push(Box::pin(daemon_holder(daemon)));
async fn binder_listener() -> Result<()> {
let mut binder = loop {
@@ -159,26 +150,23 @@ async fn spawn_daemon() -> Result<()> {
if binder.ping_binder().is_err() { break; }
tokio::time::sleep(Duration::from_secs(1)).await;
}
log::error!("System server died");
Ok(())
bail!("System server died");
}
futures.push(Box::pin(binder_listener()));
if let Err(e) = futures.next().await.unwrap() {
log::error!("{}", e);
error!("{}", e);
}
for child in child_ids {
log::debug!("Killing child process {}", child);
let _ = kill_process(Pid::from_raw(child as i32).unwrap(), Signal::Kill);
}
debug!("Killing child process {}", daemon_pid);
let _ = kill_process(Pid::from_raw(daemon_pid as i32).unwrap(), Signal::Kill);
lives -= 1;
if lives == 0 {
bail!("Too many crashes, abort");
}
log::error!("Restarting zygote...");
error!("Restarting zygote...");
utils::set_property(constants::PROP_CTL_RESTART, "zygote")?;
}
}

19
zygiskd/src/zygiskd.rs
View File

@@ -1,8 +1,8 @@
use std::ffi::c_void;
use crate::constants::{DaemonSocketAction, ProcessFlags};
use crate::utils::UnixStreamExt;
use crate::{constants, dl, lp_select, root_impl, utils};
use anyhow::{bail, Result};
use crate::{constants, dl, root_impl, utils};
use anyhow::Result;
use passfd::FdPassingExt;
use std::sync::Arc;
use std::thread;
@@ -31,11 +31,11 @@ struct Context {
pub fn main() -> Result<()> {
set_parent_process_death_signal(Some(Signal::Kill))?;
let arch = get_arch()?;
let arch = utils::get_property("ro.product.cpu.abi")?;
log::debug!("Daemon architecture: {arch}");
log::info!("Load modules");
let modules = load_modules(arch)?;
let modules = load_modules(&arch)?;
let context = Context {
modules,
@@ -59,17 +59,6 @@ pub fn main() -> Result<()> {
Ok(())
}
fn get_arch() -> Result<&'static str> {
let system_arch = utils::get_property("ro.product.cpu.abi")?;
if system_arch.contains("arm") {
return Ok(lp_select!("armeabi-v7a", "arm64-v8a"));
}
if system_arch.contains("x86") {
return Ok(lp_select!("x86", "x86_64"));
}
bail!("Unsupported system architecture: {}", system_arch);
}
fn load_modules(arch: &str) -> Result<Vec<Module>> {
let mut modules = Vec::new();
let dir = match fs::read_dir(constants::PATH_MODULES_DIR) {