Magisk/native/jni/magiskhide/hide_utils.cpp

375 lines
8.0 KiB
C++
Raw Normal View History

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>
2018-10-13 03:46:09 +02:00
#include <libgen.h>
2017-07-02 18:57:20 +02:00
#include <sys/types.h>
#include <sys/stat.h>
2017-04-20 16:45:56 +02:00
#include <magisk.h>
#include <utils.h>
#include <resetprop.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;
// Protect access to both hide_list and hide_uid
2018-11-16 07:15:34 +01:00
pthread_mutex_t list_lock;
vector<string> hide_list;
set<int> hide_uid;
// Treat GMS separately as we're only interested in one component
int gms_uid = -1;
2018-11-16 07:15:34 +01:00
static pthread_t proc_monitor_thread;
2017-07-02 18:57:20 +02:00
2018-11-01 18:23:12 +01:00
static const char *prop_key[] =
{ "ro.boot.vbmeta.device_state", "ro.boot.verifiedbootstate", "ro.boot.flash.locked",
"ro.boot.veritymode", "ro.boot.warranty_bit", "ro.warranty_bit", "ro.debuggable",
"ro.secure", "ro.build.type", "ro.build.tags", "ro.build.selinux", nullptr };
2017-07-02 18:57:20 +02:00
2018-11-01 18:23:12 +01:00
static const char *prop_value[] =
{ "locked", "green", "1",
"enforcing", "0", "0", "0",
"1", "user", "release-keys", "0", nullptr };
2017-07-02 18:57:20 +02:00
void manage_selinux() {
char val;
2017-07-02 18:57:20 +02:00
int fd = xopen(SELINUX_ENFORCE, O_RDONLY);
xxread(fd, &val, sizeof(val));
2017-07-02 18:57:20 +02:00
close(fd);
// Permissive
if (val == '0') {
2017-07-02 18:57:20 +02:00
chmod(SELINUX_ENFORCE, 0640);
chmod(SELINUX_POLICY, 0440);
}
}
static void hide_sensitive_props() {
2017-07-10 17:39:33 +02:00
LOGI("hide_utils: Hiding sensitive props\n");
2017-07-02 18:57:20 +02:00
// Hide all sensitive props
for (int i = 0; prop_key[i]; ++i) {
2019-01-20 05:59:37 +01:00
auto value = getprop(prop_key[i]);
2018-11-07 08:10:38 +01:00
if (!value.empty() && value != prop_value[i])
setprop(prop_key[i], prop_value[i], false);
2017-07-02 18:57:20 +02:00
}
}
/*
* Bionic's atoi runs through strtol().
* Use our own implementation for faster conversion.
*/
static inline int parse_int(const char *s) {
int val = 0;
char c;
while ((c = *(s++))) {
if (c > '9' || c < '0')
return -1;
val = val * 10 + c - '0';
2018-11-27 07:21:59 +01:00
}
return val;
2018-11-27 07:21:59 +01: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) {
struct dirent *dp;
int pid;
rewinddir(procfp);
while ((dp = readdir(procfp))) {
pid = parse_int(dp->d_name);
if (pid > 0 && !fn(pid))
break;
2018-10-13 03:46:09 +02:00
}
}
2018-11-27 07:21:59 +01:00
static bool proc_name_match(int pid, const char *name) {
char buf[4019];
2018-10-13 03:46:09 +02:00
FILE *f;
sprintf(buf, "/proc/%d/comm", pid);
2018-11-27 07:21:59 +01:00
if ((f = fopen(buf, "re"))) {
2018-10-13 03:46:09 +02:00
fgets(buf, sizeof(buf), f);
fclose(f);
2018-10-13 03:46:09 +02:00
if (strcmp(buf, name) == 0)
return true;
2018-10-13 03:46:09 +02:00
} else {
// The PID is already killed
return false;
2018-10-13 03:46:09 +02:00
}
sprintf(buf, "/proc/%d/cmdline", pid);
2018-11-27 07:21:59 +01:00
if ((f = fopen(buf, "re"))) {
fgets(buf, sizeof(buf), f);
fclose(f);
if (strcmp(basename(buf), name) == 0)
return true;
} else {
// The PID is already killed
return false;
}
2018-10-13 03:46:09 +02:00
sprintf(buf, "/proc/%d/exe", pid);
2018-11-27 07:21:59 +01:00
ssize_t len;
if ((len = readlink(buf, buf, sizeof(buf))) < 0)
return false;
2018-11-27 07:21:59 +01:00
buf[len] = '\0';
return strcmp(basename(buf), name) == 0;
2018-10-13 03:46:09 +02:00
}
static void kill_process(const char *name) {
// We do NOT want to kill GMS itself
if (strcmp(name, SAFETYNET_PKG) == 0)
name = SAFETYNET_PROCESS;
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 false;
}
return true;
});
}
static void kill_process(int uid) {
// We do NOT want to kill all GMS processes
if (uid == gms_uid) {
kill_process(SAFETYNET_PROCESS);
return;
2018-11-27 07:21:59 +01:00
}
crawl_procfs([=](int pid) -> bool {
if (get_uid(pid) == uid && kill(pid, SIGTERM) == 0)
LOGD("hide_utils: killed PID=[%d]\n", pid);
return true;
});
}
2017-07-18 06:26:23 +02:00
static int add_pkg_uid(const char *pkg) {
char path[4096];
struct stat st;
const char *data = SDK_INT >= 24 ? "/data/user_de/0" : "/data/data";
sprintf(path, "%s/%s", data, pkg);
if (xstat(path, &st) == 0) {
hide_uid.insert(st.st_uid);
return st.st_uid;
}
return -1;
}
void refresh_uid() {
hide_uid.clear();
for (auto &s : hide_list)
add_pkg_uid(s.c_str());
}
2017-07-18 06:26:23 +02:00
void clean_magisk_props() {
2018-11-04 09:38:06 +01:00
getprop([](const char *name, auto, auto) -> void {
2018-11-03 05:15:21 +01:00
if (strstr(name, "magisk"))
2018-11-04 09:38:06 +01:00
deleteprop(name);
}, nullptr, false);
2017-07-18 06:26:23 +02:00
}
int add_list(const char *pkg) {
2018-11-01 18:23:12 +01:00
for (auto &s : hide_list) {
if (s == pkg)
2017-04-21 19:40:07 +02:00
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 (process) VALUES('%s')", pkg);
char *err = db_exec(sql);
db_err_cmd(err, return DAEMON_ERROR);
LOGI("hide_list add: [%s]\n", pkg);
2017-04-20 16:45:56 +02:00
// Critical region
2018-11-01 18:23:12 +01:00
pthread_mutex_lock(&list_lock);
hide_list.emplace_back(pkg);
int uid = add_pkg_uid(pkg);
2018-11-01 18:23:12 +01:00
pthread_mutex_unlock(&list_lock);
kill_process(uid);
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);
int ret = add_list(pkg);
free(pkg);
update_inotify_mask();
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) {
// Critical region
bool remove = false;
2018-11-01 18:23:12 +01:00
pthread_mutex_lock(&list_lock);
for (auto it = hide_list.begin(); it != hide_list.end(); ++it) {
if (*it == pkg) {
remove = true;
LOGI("hide_list rm: [%s]\n", pkg);
2018-11-01 18:23:12 +01:00
hide_list.erase(it);
break;
2017-04-20 16:45:56 +02:00
}
}
if (remove)
refresh_uid();
2018-11-01 18:23:12 +01:00
pthread_mutex_unlock(&list_lock);
2017-04-20 16:45:56 +02:00
if (remove) {
char sql[4096];
snprintf(sql, sizeof(sql), "DELETE FROM hidelist WHERE process='%s'", pkg);
char *err = db_exec(sql);
db_err(err);
2018-11-07 08:10:38 +01:00
return DAEMON_SUCCESS;
2017-04-21 19:40:07 +02:00
} else {
2018-11-07 08:10:38 +01:00
return HIDE_ITEM_NOT_EXIST;
2017-04-20 16:45:56 +02:00
}
}
int rm_list(int client) {
char *pkg = read_string(client);
int ret = rm_list(pkg);
free(pkg);
update_inotify_mask();
2018-11-07 08:10:38 +01:00
return ret;
}
static int init_list(void *, int, char **data, char**) {
LOGI("hide_list init: [%s]\n", *data);
hide_list.emplace_back(*data);
kill_process(*data);
int uid = add_pkg_uid(*data);
if (strcmp(*data, SAFETYNET_PKG) == 0)
gms_uid = uid;
return 0;
}
static void init_list(const char *pkg) {
init_list(nullptr, 0, (char **) &pkg, nullptr);
}
#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
char *err = db_exec("SELECT process FROM hidelist", init_list);
db_err_cmd(err, return false);
2018-11-01 18:23:12 +01:00
// Migrate old hide list into database
if (access(LEGACY_LIST, R_OK) == 0) {
2019-01-20 05:59:37 +01:00
auto tmp = file_to_vector(LEGACY_LIST);
2018-11-01 18:23:12 +01:00
for (auto &s : tmp)
2019-01-20 05:59:37 +01:00
add_list(s.c_str());
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_PROCESS);
rm_list(SAFETYNET_COMPONENT);
init_list(SAFETYNET_PKG);
update_inotify_mask();
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");
2018-11-01 18:23:12 +01:00
for (auto &s : hide_list)
2018-11-16 07:49:15 +01:00
fprintf(out, "%s\n", s.c_str());
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) {
int fd = xopen("/proc", O_RDONLY | O_CLOEXEC);
if (fd < 0)
LAUNCH_ERR;
procfp = fdopendir(fd);
}
2018-11-16 07:15:34 +01:00
hide_sensitive_props();
// Initialize the mutex lock
pthread_mutex_init(&list_lock, nullptr);
// 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, TERM_THREAD);
return DAEMON_SUCCESS;
}
void auto_start_magiskhide() {
db_settings dbs;
get_db_settings(&dbs, HIDE_CONFIG);
2018-11-16 07:15:34 +01:00
if (dbs[HIDE_CONFIG]) {
new_daemon_thread([](auto) -> void* {
2018-11-16 07:15:34 +01:00
launch_magiskhide(-1);
return nullptr;
});
2018-11-16 07:15:34 +01:00
}
}