Magisk/native/jni/magiskhide/hide_utils.cpp

296 lines
6.3 KiB
C++
Raw Normal View History

#include <sys/types.h>
#include <sys/stat.h>
2017-07-02 18:57:20 +02:00
#include <stdio.h>
#include <stdlib.h>
2017-04-20 16:45:56 +02:00
#include <unistd.h>
2018-07-13 16:14:32 +02:00
#include <fcntl.h>
2017-07-02 18:57:20 +02:00
#include <dirent.h>
#include <string.h>
2017-04-20 16:45:56 +02:00
#include <magisk.h>
#include <utils.h>
#include <db.h>
2017-04-20 16:45:56 +02:00
#include "magiskhide.h"
2018-11-01 18:23:12 +01:00
2019-01-20 05:59:37 +01:00
using namespace std;
2019-03-09 05:53:53 +01:00
static pthread_t proc_monitor_thread;
2017-07-02 18:57:20 +02:00
// Leave /proc fd opened as we're going to read from it repeatedly
static DIR *procfp;
void crawl_procfs(const function<bool (int)> &fn) {
rewinddir(procfp);
crawl_procfs(procfp, fn);
}
void crawl_procfs(DIR *dir, const function<bool (int)> &fn) {
struct dirent *dp;
int pid;
while ((dp = readdir(dir))) {
pid = parse_int(dp->d_name);
if (pid > 0 && !fn(pid))
break;
2018-10-13 03:46:09 +02:00
}
}
static bool proc_name_match(int pid, const char *name) {
char buf[4019];
2018-10-13 03:46:09 +02:00
sprintf(buf, "/proc/%d/cmdline", pid);
if (FILE *f; (f = fopen(buf, "re"))) {
fgets(buf, sizeof(buf), f);
fclose(f);
if (strcmp(buf, name) == 0)
return true;
}
return false;
2018-10-13 03:46:09 +02:00
}
static void kill_process(const char *name, bool multi = false) {
crawl_procfs([=](int pid) -> bool {
if (proc_name_match(pid, name)) {
if (kill(pid, SIGTERM) == 0)
LOGD("hide_utils: killed PID=[%d] (%s)\n", pid, name);
return multi;
}
return true;
});
}
2019-09-01 08:16:12 +02:00
static bool validate(const char *s) {
bool dot = false;
for (char c; (c = *s); ++s) {
if ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') ||
(c >= '0' && c <= '9') || c == '_' || c == ':') {
2019-09-01 08:16:12 +02:00
dot = false;
continue;
}
if (c == '.') {
if (dot) // No consecutive dots
return false;
dot = true;
continue;
}
return false;
}
return true;
}
static int add_list(const char *pkg, const char *proc = "") {
if (proc[0] == '\0')
proc = pkg;
2019-09-01 08:16:12 +02:00
if (!validate(pkg) || !validate(proc))
return HIDE_INVALID_PKG;
for (auto &hide : hide_set)
if (hide.first == pkg && hide.second == proc)
return HIDE_ITEM_EXIST;
2017-04-20 16:45:56 +02:00
// Add to database
char sql[4096];
snprintf(sql, sizeof(sql),
"INSERT INTO hidelist (package_name, process) VALUES('%s', '%s')", pkg, proc);
char *err = db_exec(sql);
db_err_cmd(err, return DAEMON_ERROR);
LOGI("hide_list add: [%s/%s]\n", pkg, proc);
2017-04-20 16:45:56 +02:00
// Critical region
{
2019-09-26 05:55:39 +02:00
mutex_guard lock(monitor_lock);
hide_set.emplace(pkg, proc);
}
2018-11-01 18:23:12 +01:00
kill_process(proc);
2017-05-05 10:13:26 +02:00
return DAEMON_SUCCESS;
2017-04-20 16:45:56 +02:00
}
int add_list(int client) {
char *pkg = read_string(client);
char *proc = read_string(client);
int ret = add_list(pkg, proc);
free(pkg);
free(proc);
update_uid_map();
2018-11-07 08:10:38 +01:00
return ret;
}
2017-04-20 16:45:56 +02:00
static int rm_list(const char *pkg, const char *proc = "") {
{
// Critical region
2019-09-26 05:55:39 +02:00
mutex_guard lock(monitor_lock);
bool remove = false;
auto next = hide_set.begin();
decltype(next) cur;
while (next != hide_set.end()) {
cur = next;
++next;
if (cur->first == pkg && (proc[0] == '\0' || cur->second == proc)) {
remove = true;
LOGI("hide_list rm: [%s]\n", cur->second.data());
hide_set.erase(cur);
}
2017-04-20 16:45:56 +02:00
}
if (!remove)
return HIDE_ITEM_NOT_EXIST;
2017-04-20 16:45:56 +02:00
}
char sql[4096];
if (proc[0] == '\0')
snprintf(sql, sizeof(sql), "DELETE FROM hidelist WHERE package_name='%s'", pkg);
else
snprintf(sql, sizeof(sql),
"DELETE FROM hidelist WHERE package_name='%s' AND process='%s'", pkg, proc);
char *err = db_exec(sql);
db_err(err);
return DAEMON_SUCCESS;
2017-04-20 16:45:56 +02:00
}
int rm_list(int client) {
char *pkg = read_string(client);
char *proc = read_string(client);
int ret = rm_list(pkg, proc);
free(pkg);
free(proc);
if (ret == DAEMON_SUCCESS)
update_uid_map();
2018-11-07 08:10:38 +01:00
return ret;
}
static void init_list(const char *pkg, const char *proc) {
LOGI("hide_list init: [%s/%s]\n", pkg, proc);
hide_set.emplace(pkg, proc);
kill_process(proc);
}
#define LEGACY_LIST MODULEROOT "/.core/hidelist"
2018-11-07 08:10:38 +01:00
bool init_list() {
2018-11-01 18:23:12 +01:00
LOGD("hide_list: initialize\n");
2017-04-20 16:45:56 +02:00
2019-03-06 14:16:12 +01:00
char *err = db_exec("SELECT * FROM hidelist", [](db_row &row) -> bool {
init_list(row["package_name"].data(), row["process"].data());
return true;
});
db_err_cmd(err, return false);
2018-11-01 18:23:12 +01:00
// If Android Q+, also kill blastula pool
if (SDK_INT >= 29) {
kill_process("usap32", true);
kill_process("usap64", true);
}
2018-11-01 18:23:12 +01:00
// Migrate old hide list into database
if (access(LEGACY_LIST, R_OK) == 0) {
2019-03-06 02:27:09 +01:00
file_readline(LEGACY_LIST, [](string_view s) -> bool {
add_list(s.data());
return true;
});
2018-11-01 18:23:12 +01:00
unlink(LEGACY_LIST);
2017-04-20 16:45:56 +02:00
}
2018-11-01 18:23:12 +01:00
// Add SafetyNet by default
rm_list(SAFETYNET_COMPONENT);
rm_list(SAFETYNET_PROCESS);
init_list(SAFETYNET_PKG, SAFETYNET_PROCESS);
init_list(MICROG_SAFETYNET, SAFETYNET_PROCESS);
update_uid_map();
2018-11-07 08:10:38 +01:00
return true;
2017-04-20 16:45:56 +02:00
}
void ls_list(int client) {
2018-11-16 07:49:15 +01:00
FILE *out = fdopen(recv_fd(client), "a");
for (auto &hide : hide_set)
fprintf(out, "%s|%s\n", hide.first.data(), hide.second.data());
2018-11-16 07:49:15 +01:00
fclose(out);
write_int(client, DAEMON_SUCCESS);
close(client);
}
2018-11-16 07:15:34 +01:00
static void set_hide_config() {
char sql[64];
sprintf(sql, "REPLACE INTO settings (key,value) VALUES('%s',%d)",
DB_SETTING_KEYS[HIDE_CONFIG], hide_enabled);
char *err = db_exec(sql);
db_err(err);
2018-11-16 07:15:34 +01:00
}
static inline void launch_err(int client, int code = DAEMON_ERROR) {
if (code != HIDE_IS_ENABLED)
hide_enabled = false;
if (client >= 0) {
write_int(client, code);
close(client);
}
pthread_exit(nullptr);
}
#define LAUNCH_ERR launch_err(client)
void launch_magiskhide(int client) {
2019-01-20 23:52:19 +01:00
if (SDK_INT < 19)
LAUNCH_ERR;
2019-01-20 23:52:19 +01:00
2018-11-16 07:15:34 +01:00
if (hide_enabled)
launch_err(client, HIDE_IS_ENABLED);
2018-11-16 07:15:34 +01:00
if (access("/proc/1/ns/mnt", F_OK) != 0)
launch_err(client, HIDE_NO_NS);
2018-11-16 07:15:34 +01:00
hide_enabled = true;
set_hide_config();
LOGI("* Starting MagiskHide\n");
if (procfp == nullptr && (procfp = opendir("/proc")) == nullptr)
LAUNCH_ERR;
2018-11-16 07:15:34 +01:00
hide_sensitive_props();
// Initialize the mutex lock
pthread_mutex_init(&monitor_lock, nullptr);
2018-11-16 07:15:34 +01:00
// Initialize the hide list
if (!init_list())
LAUNCH_ERR;
2018-11-16 07:15:34 +01:00
// Get thread reference
proc_monitor_thread = pthread_self();
if (client >= 0) {
write_int(client, DAEMON_SUCCESS);
close(client);
client = -1;
2018-11-16 07:15:34 +01:00
}
// Start monitoring
proc_monitor();
// proc_monitor should not return
LAUNCH_ERR;
2018-11-16 07:15:34 +01:00
}
int stop_magiskhide() {
LOGI("* Stopping MagiskHide\n");
hide_enabled = false;
set_hide_config();
pthread_kill(proc_monitor_thread, SIGTERMTHRD);
2018-11-16 07:15:34 +01:00
return DAEMON_SUCCESS;
}
void auto_start_magiskhide() {
db_settings dbs;
2019-03-06 14:16:12 +01:00
get_db_settings(dbs, HIDE_CONFIG);
2018-11-16 07:15:34 +01:00
if (dbs[HIDE_CONFIG]) {
2019-05-26 06:42:51 +02:00
new_daemon_thread([]() -> void { launch_magiskhide(-1); });
2018-11-16 07:15:34 +01:00
}
}
void test_proc_monitor() {
if (procfp == nullptr && (procfp = opendir("/proc")) == nullptr)
exit(1);
proc_monitor();
exit(0);
}