Magisk/native/jni/magiskhide/hide_utils.c

241 lines
4.9 KiB
C
Raw Normal View History

2017-07-02 18:57:20 +02:00
/* hide_utils.c - Some utility functions for MagiskHide
2017-04-20 16:45:56 +02:00
*/
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>
#include <sys/types.h>
#include <sys/stat.h>
#include <selinux/selinux.h>
2017-04-20 16:45:56 +02:00
#include "magisk.h"
#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"
static 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", NULL };
2017-07-02 18:57:20 +02:00
static char *prop_value[] =
{ "locked", "green", "1", "enforcing",
"0", "0", "0", "1",
"user", "release-keys", "0", NULL };
2017-07-02 18:57:20 +02:00
static const char *proc_name;
static gid_t proc_gid;
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
char *value;
for (int i = 0; prop_key[i]; ++i) {
value = getprop(prop_key[i]);
if (value) {
if (strcmp(value, prop_value[i]) != 0)
setprop2(prop_key[i], prop_value[i], 0);
free(value);
}
}
}
2018-04-28 14:22:42 +02:00
static void rm_magisk_prop(const char *name, const char *value, void *v) {
2017-07-18 06:26:23 +02:00
if (strstr(name, "magisk")) {
2017-10-09 20:04:50 +02:00
deleteprop2(name, 0);
2017-07-18 06:26:23 +02:00
}
}
static void kill_proc_cb(int pid) {
if (check_proc_name(pid, proc_name))
kill(pid, SIGTERM);
else if (proc_gid > 0) {
char buf[128];
struct stat st;
sprintf(buf, "/proc/%d", pid);
stat(buf, &st);
if (proc_gid == st.st_gid)
kill(pid, SIGTERM);
}
}
static void kill_process(const char *name) {
proc_name = name;
char buf[128];
struct stat st;
sprintf(buf, "/data/data/%s", name);
if (stat(buf, &st) == 0)
proc_gid = st.st_gid;
else
proc_gid = 0;
ps(kill_proc_cb);
}
2017-07-18 06:26:23 +02:00
void clean_magisk_props() {
LOGD("hide_utils: Cleaning magisk props\n");
2018-04-28 14:22:42 +02:00
getprop_all(rm_magisk_prop, NULL);
2017-07-18 06:26:23 +02:00
}
2017-04-20 16:45:56 +02:00
int add_list(char *proc) {
2017-04-21 19:40:07 +02:00
if (!hideEnabled) {
free(proc);
return HIDE_NOT_ENABLED;
}
2017-04-20 16:45:56 +02:00
char *line;
2017-05-03 20:58:37 +02:00
struct vector *new_list = xmalloc(sizeof(*new_list));
2017-04-20 16:45:56 +02:00
if (new_list == NULL)
2017-05-05 10:13:26 +02:00
return DAEMON_ERROR;
2017-04-20 16:45:56 +02:00
vec_init(new_list);
vec_for_each(hide_list, line) {
// They should be unique
if (strcmp(line, proc) == 0) {
free(proc);
vec_destroy(new_list);
free(new_list);
2017-04-21 19:40:07 +02:00
return HIDE_ITEM_EXIST;
2017-04-20 16:45:56 +02:00
}
vec_push_back(new_list, line);
}
vec_push_back(new_list, proc);
LOGI("hide_list add: [%s]\n", proc);
kill_process(proc);
2017-04-20 16:45:56 +02:00
// Critical region
2017-04-21 18:54:08 +02:00
pthread_mutex_lock(&hide_lock);
2017-05-03 20:58:37 +02:00
vec_destroy(hide_list);
free(hide_list);
2017-04-20 16:45:56 +02:00
hide_list = new_list;
2017-04-21 18:54:08 +02:00
pthread_mutex_unlock(&hide_lock);
2017-04-20 16:45:56 +02:00
2017-05-03 20:58:37 +02:00
pthread_mutex_lock(&file_lock);
vector_to_file(HIDELIST, hide_list); // Do not complain if file not found
2017-05-03 20:58:37 +02:00
pthread_mutex_unlock(&file_lock);
2017-05-05 10:13:26 +02:00
return DAEMON_SUCCESS;
2017-04-20 16:45:56 +02:00
}
int rm_list(char *proc) {
2017-04-21 19:40:07 +02:00
if (!hideEnabled) {
free(proc);
return HIDE_NOT_ENABLED;
}
2017-04-20 16:45:56 +02:00
2018-02-11 10:23:36 +01:00
int ret = DAEMON_ERROR;
2017-04-20 16:45:56 +02:00
char *line;
2017-05-03 20:58:37 +02:00
int do_rm = 0;
struct vector *new_list = xmalloc(sizeof(*new_list));
2017-04-20 16:45:56 +02:00
if (new_list == NULL)
2017-04-21 19:40:07 +02:00
goto error;
2017-04-20 16:45:56 +02:00
vec_init(new_list);
vec_for_each(hide_list, line) {
if (strcmp(line, proc) == 0) {
free(proc);
proc = line;
2017-05-03 20:58:37 +02:00
do_rm = 1;
2017-04-20 16:45:56 +02:00
continue;
}
vec_push_back(new_list, line);
}
2017-05-03 20:58:37 +02:00
if (do_rm) {
2017-04-20 16:45:56 +02:00
LOGI("hide_list rm: [%s]\n", proc);
kill_process(proc);
2017-04-20 16:45:56 +02:00
// Critical region
2017-04-21 18:54:08 +02:00
pthread_mutex_lock(&hide_lock);
2017-05-03 20:58:37 +02:00
vec_destroy(hide_list);
free(hide_list);
2017-04-20 16:45:56 +02:00
hide_list = new_list;
2017-04-21 18:54:08 +02:00
pthread_mutex_unlock(&hide_lock);
2017-05-03 20:58:37 +02:00
2017-05-05 10:13:26 +02:00
ret = DAEMON_SUCCESS;
2017-05-03 20:58:37 +02:00
pthread_mutex_lock(&file_lock);
vector_to_file(HIDELIST, hide_list); // Do not complain if file not found
2017-05-03 20:58:37 +02:00
pthread_mutex_unlock(&file_lock);
2017-04-21 19:40:07 +02:00
} else {
ret = HIDE_ITEM_NOT_EXIST;
2017-05-03 20:58:37 +02:00
vec_destroy(new_list);
free(new_list);
2017-04-20 16:45:56 +02:00
}
2017-04-21 19:40:07 +02:00
error:
2017-04-20 16:45:56 +02:00
free(proc);
2017-04-21 19:40:07 +02:00
return ret;
2017-04-20 16:45:56 +02:00
}
int init_list() {
LOGD("hide_list: initialize...\n");
if ((hide_list = xmalloc(sizeof(*hide_list))) == NULL)
return 1;
vec_init(hide_list);
2017-04-24 15:43:30 +02:00
// Might error if file doesn't exist, no need to report
2017-04-20 16:45:56 +02:00
file_to_vector(HIDELIST, hide_list);
char *line;
vec_for_each(hide_list, line) {
LOGI("hide_list: [%s]\n", line);
kill_process(line);
2017-04-20 16:45:56 +02:00
}
return 0;
}
int destroy_list() {
char *line;
vec_for_each(hide_list, line) {
kill_process(line);
2017-04-20 16:45:56 +02:00
}
vec_deep_destroy(hide_list);
free(hide_list);
hide_list = NULL;
return 0;
}
void add_hide_list(int client) {
char *proc = read_string(client);
// ack
write_int(client, add_list(proc));
close(client);
}
void rm_hide_list(int client) {
char *proc = read_string(client);
// ack
write_int(client, rm_list(proc));
close(client);
}
void ls_hide_list(int client) {
if (!hideEnabled) {
write_int(client, HIDE_NOT_ENABLED);
return;
}
write_int(client, DAEMON_SUCCESS);
write_int(client, vec_size(hide_list));
char *s;
vec_for_each(hide_list, s) {
write_string(client, s);
}
close(client);
}