2019-03-05 09:22:20 +01:00
|
|
|
#include <sys/types.h>
|
|
|
|
#include <sys/stat.h>
|
|
|
|
#include <sys/mount.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>
|
2018-10-13 03:46:09 +02:00
|
|
|
#include <libgen.h>
|
2017-04-20 16:45:56 +02:00
|
|
|
|
2019-02-10 07:05:19 +01: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;
|
|
|
|
|
2019-03-09 05:53:53 +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() {
|
2018-07-03 19:52:23 +02:00
|
|
|
char val;
|
2017-07-02 18:57:20 +02:00
|
|
|
int fd = xopen(SELINUX_ENFORCE, O_RDONLY);
|
2018-07-03 19:52:23 +02:00
|
|
|
xxread(fd, &val, sizeof(val));
|
2017-07-02 18:57:20 +02:00
|
|
|
close(fd);
|
|
|
|
// Permissive
|
2018-07-03 19:52:23 +02:00
|
|
|
if (val == '0') {
|
2017-07-02 18:57:20 +02:00
|
|
|
chmod(SELINUX_ENFORCE, 0640);
|
|
|
|
chmod(SELINUX_POLICY, 0440);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-02-14 02:16:26 +01:00
|
|
|
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
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-02-14 02:16:26 +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
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-03-01 23:08:08 +01:00
|
|
|
bool proc_name_match(int pid, const char *name) {
|
2018-11-08 04:46:56 +01:00
|
|
|
char buf[4019];
|
2018-10-13 03:46:09 +02:00
|
|
|
FILE *f;
|
2019-03-02 00:13:41 +01:00
|
|
|
#if 0
|
2018-10-13 03:46:09 +02:00
|
|
|
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);
|
2019-02-14 02:16:26 +01:00
|
|
|
fclose(f);
|
2018-10-13 03:46:09 +02:00
|
|
|
if (strcmp(buf, name) == 0)
|
2018-11-08 04:46:56 +01:00
|
|
|
return true;
|
2018-10-13 03:46:09 +02:00
|
|
|
} else {
|
|
|
|
// The PID is already killed
|
2018-11-08 04:46:56 +01:00
|
|
|
return false;
|
2018-10-13 03:46:09 +02:00
|
|
|
}
|
2019-03-02 00:13:41 +01:00
|
|
|
#endif
|
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"))) {
|
2018-11-08 04:46:56 +01:00
|
|
|
fgets(buf, sizeof(buf), f);
|
2019-02-14 02:16:26 +01:00
|
|
|
fclose(f);
|
2018-11-08 04:46:56 +01:00
|
|
|
if (strcmp(basename(buf), name) == 0)
|
|
|
|
return true;
|
|
|
|
}
|
2019-03-02 00:13:41 +01:00
|
|
|
return false;
|
2018-10-13 03:46:09 +02:00
|
|
|
|
2019-03-02 00:13:41 +01:00
|
|
|
#if 0
|
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)
|
2018-11-08 04:46:56 +01:00
|
|
|
return false;
|
2018-11-27 07:21:59 +01:00
|
|
|
buf[len] = '\0';
|
2018-11-08 04:46:56 +01:00
|
|
|
return strcmp(basename(buf), name) == 0;
|
2019-03-02 00:13:41 +01:00
|
|
|
#endif
|
2018-10-13 03:46:09 +02:00
|
|
|
}
|
|
|
|
|
2019-02-14 02:16:26 +01:00
|
|
|
static void kill_process(const char *name) {
|
|
|
|
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;
|
|
|
|
});
|
2018-08-07 23:47:58 +02:00
|
|
|
}
|
|
|
|
|
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
|
|
|
}
|
|
|
|
|
2019-03-01 23:08:08 +01:00
|
|
|
static int add_list(const char *pkg, const char *proc = "") {
|
|
|
|
if (proc[0] == '\0')
|
|
|
|
proc = pkg;
|
|
|
|
|
2019-03-06 11:40:52 +01:00
|
|
|
for (auto &hide : hide_set)
|
|
|
|
if (hide.first == pkg && hide.second == proc)
|
|
|
|
return HIDE_ITEM_EXIST;
|
2017-04-20 16:45:56 +02:00
|
|
|
|
2018-11-16 09:20:30 +01:00
|
|
|
// Add to database
|
|
|
|
char sql[4096];
|
2019-03-01 23:08:08 +01:00
|
|
|
snprintf(sql, sizeof(sql),
|
|
|
|
"INSERT INTO hidelist (package_name, process) VALUES('%s', '%s')", pkg, proc);
|
2018-11-16 09:20:30 +01:00
|
|
|
char *err = db_exec(sql);
|
|
|
|
db_err_cmd(err, return DAEMON_ERROR);
|
|
|
|
|
2019-03-06 11:40:52 +01:00
|
|
|
LOGI("hide_list add: [%s/%s]\n", pkg, proc);
|
2019-02-13 12:16:26 +01:00
|
|
|
|
2017-04-20 16:45:56 +02:00
|
|
|
// Critical region
|
2019-02-16 08:24:35 +01:00
|
|
|
{
|
2019-03-05 09:22:20 +01:00
|
|
|
MutexGuard lock(monitor_lock);
|
2019-03-06 11:40:52 +01:00
|
|
|
hide_set.emplace(pkg, proc);
|
2019-02-16 08:24:35 +01:00
|
|
|
}
|
2018-11-01 18:23:12 +01:00
|
|
|
|
2019-03-01 23:08:08 +01:00
|
|
|
kill_process(proc);
|
2017-05-05 10:13:26 +02:00
|
|
|
return DAEMON_SUCCESS;
|
2017-04-20 16:45:56 +02:00
|
|
|
}
|
|
|
|
|
2018-11-01 19:08:33 +01:00
|
|
|
int add_list(int client) {
|
2019-02-14 02:16:26 +01:00
|
|
|
char *pkg = read_string(client);
|
2019-03-01 23:08:08 +01:00
|
|
|
char *proc = read_string(client);
|
|
|
|
int ret = add_list(pkg, proc);
|
2019-02-14 02:16:26 +01:00
|
|
|
free(pkg);
|
2019-03-01 23:08:08 +01:00
|
|
|
free(proc);
|
2019-03-05 09:22:20 +01:00
|
|
|
update_uid_map();
|
2018-11-07 08:10:38 +01:00
|
|
|
return ret;
|
2018-11-01 19:08:33 +01:00
|
|
|
}
|
2017-04-20 16:45:56 +02:00
|
|
|
|
2019-03-01 23:08:08 +01:00
|
|
|
static int rm_list(const char *pkg, const char *proc = "") {
|
2019-02-16 08:24:35 +01:00
|
|
|
{
|
2019-03-01 23:08:08 +01:00
|
|
|
// Critical region
|
2019-03-05 09:22:20 +01:00
|
|
|
MutexGuard lock(monitor_lock);
|
2019-02-16 08:24:35 +01:00
|
|
|
bool remove = false;
|
2019-03-06 11:40:52 +01:00
|
|
|
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)) {
|
2019-02-16 08:24:35 +01:00
|
|
|
remove = true;
|
2019-03-06 11:40:52 +01:00
|
|
|
LOGI("hide_list rm: [%s]\n", cur->second.data());
|
|
|
|
hide_set.erase(cur);
|
2019-02-16 08:24:35 +01:00
|
|
|
}
|
2017-04-20 16:45:56 +02:00
|
|
|
}
|
2019-02-16 08:24:35 +01:00
|
|
|
if (!remove)
|
|
|
|
return HIDE_ITEM_NOT_EXIST;
|
2017-04-20 16:45:56 +02:00
|
|
|
}
|
2019-03-01 23:08:08 +01:00
|
|
|
|
2019-02-16 08:24:35 +01:00
|
|
|
char sql[4096];
|
2019-03-01 23:08:08 +01:00
|
|
|
if (proc[0] == '\0')
|
|
|
|
snprintf(sql, sizeof(sql), "DELETE FROM hidelist WHERE package_name='%s'", pkg);
|
|
|
|
else
|
2019-03-06 11:40:52 +01:00
|
|
|
snprintf(sql, sizeof(sql),
|
|
|
|
"DELETE FROM hidelist WHERE package_name='%s' AND process='%s'", pkg, proc);
|
2019-02-16 08:24:35 +01:00
|
|
|
char *err = db_exec(sql);
|
|
|
|
db_err(err);
|
|
|
|
return DAEMON_SUCCESS;
|
2017-04-20 16:45:56 +02:00
|
|
|
}
|
|
|
|
|
2018-11-01 19:08:33 +01:00
|
|
|
int rm_list(int client) {
|
2019-02-14 02:16:26 +01:00
|
|
|
char *pkg = read_string(client);
|
2019-03-01 23:08:08 +01:00
|
|
|
char *proc = read_string(client);
|
|
|
|
int ret = rm_list(pkg, proc);
|
2019-02-14 02:16:26 +01:00
|
|
|
free(pkg);
|
2019-03-01 23:08:08 +01:00
|
|
|
free(proc);
|
2019-02-16 08:24:35 +01:00
|
|
|
if (ret == DAEMON_SUCCESS)
|
2019-03-05 09:22:20 +01:00
|
|
|
update_uid_map();
|
2018-11-07 08:10:38 +01:00
|
|
|
return ret;
|
2018-11-01 19:08:33 +01:00
|
|
|
}
|
|
|
|
|
2019-03-01 23:08:08 +01:00
|
|
|
static void init_list(const char *pkg, const char *proc) {
|
2019-03-06 11:40:52 +01:00
|
|
|
LOGI("hide_list init: [%s/%s]\n", pkg, proc);
|
|
|
|
hide_set.emplace(pkg, proc);
|
2019-03-01 23:08:08 +01:00
|
|
|
kill_process(proc);
|
2018-11-16 09:20:30 +01:00
|
|
|
}
|
|
|
|
|
2019-02-13 12:16:26 +01:00
|
|
|
#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;
|
|
|
|
});
|
2018-11-16 09:20:30 +01:00
|
|
|
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-03-06 02:27:09 +01:00
|
|
|
file_readline(LEGACY_LIST, [](string_view s) -> bool {
|
2019-02-18 04:30:23 +01:00
|
|
|
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
|
|
|
|
2019-02-13 12:16:26 +01:00
|
|
|
// Add SafetyNet by default
|
|
|
|
rm_list(SAFETYNET_COMPONENT);
|
2019-03-06 11:40:52 +01:00
|
|
|
rm_list(SAFETYNET_PROCESS);
|
2019-03-01 23:08:08 +01:00
|
|
|
init_list(SAFETYNET_PKG, SAFETYNET_PROCESS);
|
2019-03-06 11:43:52 +01:00
|
|
|
init_list(MICROG_SAFETYNET, SAFETYNET_PROCESS);
|
2019-02-13 12:16:26 +01:00
|
|
|
|
2019-03-05 09:22:20 +01:00
|
|
|
update_uid_map();
|
2018-11-07 08:10:38 +01:00
|
|
|
return true;
|
2017-04-20 16:45:56 +02:00
|
|
|
}
|
|
|
|
|
2018-11-01 19:08:33 +01:00
|
|
|
void ls_list(int client) {
|
2018-11-16 07:49:15 +01:00
|
|
|
FILE *out = fdopen(recv_fd(client), "a");
|
2019-03-06 11:40:52 +01:00
|
|
|
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);
|
2017-09-05 20:25:40 +02:00
|
|
|
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);
|
2018-11-16 09:20:30 +01:00
|
|
|
char *err = db_exec(sql);
|
|
|
|
db_err(err);
|
2018-11-16 07:15:34 +01:00
|
|
|
}
|
|
|
|
|
2019-02-14 02:16:26 +01:00
|
|
|
static inline void launch_err(int client, int code = DAEMON_ERROR) {
|
2019-02-14 10:08:05 +01:00
|
|
|
if (code != HIDE_IS_ENABLED)
|
2019-02-14 02:16:26 +01:00
|
|
|
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)
|
2019-02-14 02:16:26 +01:00
|
|
|
LAUNCH_ERR;
|
2019-01-20 23:52:19 +01:00
|
|
|
|
2018-11-16 07:15:34 +01:00
|
|
|
if (hide_enabled)
|
2019-02-14 02:16:26 +01:00
|
|
|
launch_err(client, HIDE_IS_ENABLED);
|
2018-11-16 07:15:34 +01:00
|
|
|
|
2019-02-14 10:08:05 +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");
|
|
|
|
|
2019-02-14 02:16:26 +01:00
|
|
|
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
|
2019-03-05 09:22:20 +01:00
|
|
|
pthread_mutex_init(&monitor_lock, nullptr);
|
2018-11-16 07:15:34 +01:00
|
|
|
|
|
|
|
// Initialize the hide list
|
|
|
|
if (!init_list())
|
2019-02-14 02:16:26 +01:00
|
|
|
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);
|
2019-02-14 02:16:26 +01:00
|
|
|
client = -1;
|
2018-11-16 07:15:34 +01:00
|
|
|
}
|
|
|
|
// Start monitoring
|
|
|
|
proc_monitor();
|
|
|
|
|
2019-02-14 02:16:26 +01:00
|
|
|
// 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();
|
2019-03-05 09:22:20 +01:00
|
|
|
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-02-14 23:36:18 +01:00
|
|
|
new_daemon_thread([](auto) -> void* {
|
2018-11-16 07:15:34 +01:00
|
|
|
launch_magiskhide(-1);
|
|
|
|
return nullptr;
|
2019-02-14 23:36:18 +01:00
|
|
|
});
|
2018-11-16 07:15:34 +01:00
|
|
|
}
|
|
|
|
}
|