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>
|
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[] =
|
2018-06-19 19:50:05 +02:00
|
|
|
{ "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[] =
|
2018-06-19 19:50:05 +02:00
|
|
|
{ "locked", "green", "1", "enforcing",
|
|
|
|
"0", "0", "0", "1",
|
|
|
|
"user", "release-keys", "0", NULL };
|
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);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
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
|
|
|
}
|
|
|
|
}
|
2018-07-03 19:52:23 +02:00
|
|
|
|
|
|
|
static void kill_proc(int pid) {
|
|
|
|
kill(pid, SIGTERM);
|
|
|
|
}
|
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);
|
|
|
|
ps_filter_proc_name(proc, kill_proc);
|
|
|
|
|
|
|
|
// 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);
|
2017-09-05 20:25:40 +02:00
|
|
|
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);
|
|
|
|
ps_filter_proc_name(proc, kill_proc);
|
|
|
|
// 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);
|
2017-09-05 20:25:40 +02:00
|
|
|
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);
|
|
|
|
ps_filter_proc_name(line, kill_proc);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int destroy_list() {
|
|
|
|
char *line;
|
|
|
|
vec_for_each(hide_list, line) {
|
|
|
|
ps_filter_proc_name(line, kill_proc);
|
|
|
|
}
|
|
|
|
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);
|
|
|
|
}
|
2017-09-05 20:25:40 +02:00
|
|
|
|
|
|
|
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);
|
|
|
|
}
|