Magisk/native/jni/magiskhide/hide_utils.cpp

253 lines
5.4 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"
2018-11-03 08:06:01 +01:00
#include "utils.h"
2017-07-02 18:57:20 +02:00
#include "resetprop.h"
2017-04-20 16:45:56 +02:00
#include "magiskhide.h"
2017-07-02 18:57:20 +02:00
#include "daemon.h"
2018-11-01 18:23:12 +01:00
#include "db.h"
Vector<CharArray> hide_list;
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
struct ps_arg {
const char *name;
uid_t uid;
};
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);
}
}
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) {
2018-11-07 08:10:38 +01:00
CharArray value = getprop(prop_key[i]);
if (!value.empty() && value != prop_value[i])
setprop(prop_key[i], prop_value[i], false);
2017-07-02 18:57:20 +02:00
}
}
static void ps(void (*cb)(int, void*), void *arg) {
2018-10-13 03:46:09 +02:00
DIR *dir;
struct dirent *entry;
if (!(dir = xopendir("/proc")))
return;
while ((entry = xreaddir(dir))) {
if (entry->d_type == DT_DIR && is_num(entry->d_name))
cb(atoi(entry->d_name), arg);
2018-10-13 03:46:09 +02:00
}
closedir(dir);
}
static bool check_proc_name(int pid, const char *name) {
char buf[4019];
2018-10-13 03:46:09 +02:00
FILE *f;
sprintf(buf, "/proc/%d/comm", pid);
if ((f = fopen(buf, "r"))) {
fgets(buf, sizeof(buf), f);
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
}
fclose(f);
sprintf(buf, "/proc/%d/cmdline", pid);
if ((f = fopen(buf, "r"))) {
fgets(buf, sizeof(buf), 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
fclose(f);
sprintf(buf, "/proc/%d/exe", pid);
if (access(buf, F_OK) != 0)
return false;
2018-10-13 03:46:09 +02:00
xreadlink(buf, buf, sizeof(buf));
return strcmp(basename(buf), name) == 0;
2018-10-13 03:46:09 +02:00
}
static void kill_proc_cb(int pid, void *v) {
ps_arg *args = static_cast<ps_arg *>(v);
if (check_proc_name(pid, args->name))
kill(pid, SIGTERM);
else if (args->uid > 0) {
char buf[64];
struct stat st;
sprintf(buf, "/proc/%d", pid);
stat(buf, &st);
if (args->uid == st.st_uid)
kill(pid, SIGTERM);
}
}
static void kill_process(const char *name) {
ps_arg args = { .name = name };
struct stat st;
int fd = xopen("/data/data", O_RDONLY | O_CLOEXEC);
if (fstatat(fd, name, &st, 0) == 0)
args.uid = st.st_uid;
else
args.uid = 0;
close(fd);
ps(kill_proc_cb, &args);
}
2017-07-18 06:26:23 +02:00
void clean_magisk_props() {
LOGD("hide_utils: Cleaning magisk props\n");
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
}
2018-11-07 08:10:38 +01:00
static int add_list(sqlite3 *db, const char *proc) {
2018-11-01 18:23:12 +01:00
for (auto &s : hide_list) {
2017-04-20 16:45:56 +02:00
// They should be unique
2018-11-07 08:10:38 +01:00
if (s == proc)
2017-04-21 19:40:07 +02:00
return HIDE_ITEM_EXIST;
2017-04-20 16:45:56 +02:00
}
LOGI("hide_list add: [%s]\n", proc);
// Critical region
2018-11-01 18:23:12 +01:00
pthread_mutex_lock(&list_lock);
hide_list.push_back(proc);
kill_process(proc);
2018-11-01 18:23:12 +01:00
pthread_mutex_unlock(&list_lock);
// Add to database
char sql[4096];
snprintf(sql, sizeof(sql), "INSERT INTO hidelist (process) VALUES('%s')", proc);
2018-11-01 18:23:12 +01:00
sqlite3_exec(db, sql, nullptr, nullptr, nullptr);
2017-05-05 10:13:26 +02:00
return DAEMON_SUCCESS;
2017-04-20 16:45:56 +02:00
}
2018-11-07 08:10:38 +01:00
int add_list(const char *proc) {
2018-11-01 18:23:12 +01:00
sqlite3 *db = get_magiskdb();
if (db) {
int ret = add_list(db, proc);
sqlite3_close_v2(db);
return ret;
}
return DAEMON_ERROR;
}
int add_list(int client) {
2018-11-07 08:10:38 +01:00
char *proc = read_string(client);
int ret = add_list(proc);
free(proc);
return ret;
}
2017-04-20 16:45:56 +02:00
2018-11-07 08:10:38 +01:00
static int rm_list(const char *proc) {
2018-11-01 18:23:12 +01:00
// Update list in critical region
bool do_rm = false;
pthread_mutex_lock(&list_lock);
for (auto it = hide_list.begin(); it != hide_list.end(); ++it) {
2018-11-07 08:10:38 +01:00
if (*it == proc) {
2018-11-01 18:23:12 +01:00
do_rm = true;
LOGI("hide_list rm: [%s]\n", proc);
hide_list.erase(it);
kill_process(proc);
2018-11-01 18:23:12 +01:00
break;
2017-04-20 16:45:56 +02:00
}
}
2018-11-01 18:23:12 +01:00
pthread_mutex_unlock(&list_lock);
2017-04-20 16:45:56 +02:00
2017-05-03 20:58:37 +02:00
if (do_rm) {
2018-11-01 18:23:12 +01:00
sqlite3 *db = get_magiskdb();
if (db == nullptr)
2018-11-07 08:10:38 +01:00
return DAEMON_ERROR;
char sql[4096];
snprintf(sql, sizeof(sql), "DELETE FROM hidelist WHERE process='%s'", proc);
2018-11-01 18:23:12 +01:00
sqlite3_exec(db, sql, nullptr, nullptr, nullptr);
sqlite3_close_v2(db);
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) {
2018-11-07 08:10:38 +01:00
char *proc = read_string(client);
int ret = rm_list(proc);
free(proc);
return ret;
}
2018-11-01 18:23:12 +01:00
#define LEGACY_LIST MOUNTPOINT "/.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
2018-11-01 18:23:12 +01:00
sqlite3 *db = get_magiskdb();
if (db == nullptr)
2018-11-07 08:10:38 +01:00
return false;
2017-04-20 16:45:56 +02:00
2018-11-01 18:23:12 +01:00
sqlite3_exec(db, "SELECT process FROM hidelist",
[] (auto, auto, char **data, auto) -> int
{
LOGI("hide_list: [%s]\n", data[0]);
2018-11-07 08:10:38 +01:00
hide_list.push_back(data[0]);
2018-11-01 18:23:12 +01:00
return 0;
}, nullptr, nullptr);
// Migrate old hide list into database
if (access(LEGACY_LIST, R_OK) == 0) {
Vector<CharArray> tmp;
file_to_vector(LEGACY_LIST, tmp);
2018-11-01 18:23:12 +01:00
for (auto &s : tmp)
add_list(db, s);
unlink(LEGACY_LIST);
2017-04-20 16:45:56 +02:00
}
2018-11-01 18:23:12 +01:00
sqlite3_close_v2(db);
2018-11-07 08:10:38 +01:00
return true;
2017-04-20 16:45:56 +02:00
}
void ls_list(int client) {
write_int(client, DAEMON_SUCCESS);
2018-11-01 18:23:12 +01:00
write_int(client, hide_list.size());
for (auto &s : hide_list)
write_string(client, s);
close(client);
}