(JNIEnv * jenv, jclass cls, jstring path)

{

const char* data_file_path = jenv->GetStringUTFChars(path, NULL);

g_data_file_path = dupstr(data_file_path); // never delete, ok with only one

jenv->ReleaseStringUTFChars(path, data_file_path);

MY_INFO("data file path:%s", g_data_file_path);

bootstrap();

{

pid_t pid = getpid();

char bundle_id_filename[256] = {0};

snprintf(bundle_id_filename, sizeof(bundle_id_filename), "/proc/%d/cmdline", pid);

std::fstream bundle_id_file(bundle_id_filename, std::fstream::in);

if (!bundle_id_file.is_open())

{

MY_ERROR("failed to open %s ", bundle_id_filename);

exit(-1);

return "";

}

char bundle_id[256] = {0};

bundle_id_file.getline(bundle_id, sizeof(bundle_id));

bundle_id_file.close();

return std::string(bundle_id);

{

MY_LOG("copy %s to %s", from_path, to_path);

int fd_to, fd_from;

char buf[4096];

ssize_t nread;

int saved_errno;

fd_from = open(from_path, O_RDONLY);

if (fd_from < 0){

MY_ERROR("can't access to %s.", from_path);

return false;

}

fd_to = open(to_path, O_WRONLY | O_CREAT | O_EXCL, 0755);

if (fd_to < 0){

MY_ERROR("can't access to %s.", to_path);

close( fd_from );

return false;

}

while ((nread = read(fd_from, buf, sizeof buf))> 0) {

char *out_ptr = buf;

ssize_t nwritten;

do {

nwritten = write(fd_to, out_ptr, nread);

if (nwritten >= 0) {

nread -= nwritten;

out_ptr += nwritten;

}

else if (errno != EINTR) {

MY_ERROR("can't write to %s. errno:%d", to_path, errno);

close( fd_from );

close( fd_to );

return false;

}

} while (nread > 0);

}

close( fd_from );

close( fd_to );

return true;

{

DIR* dir = opendir(data_path);

if (dir == NULL)

{

MY_ERROR("can't access data path:%s", data_path);

return false;

}

const char* NEW_SO_POSTFIX = ".new";

int new_file_postfix_len = strlen(NEW_SO_POSTFIX);

struct dirent *ent = NULL;

while((ent = readdir(dir)) != NULL)

{

if(ent->d_type & DT_DIR) { continue; }

const char* filename = ent->d_name;

int len = strlen(filename);

if (len > new_file_postfix_len && memcmp(filename + len - new_file_postfix_len, NEW_SO_POSTFIX, new_file_postfix_len) == 0)

{

// copy patch_dir/xxx.new -> data/files/xxx.new

char from_filepath[256] = {0};

snprintf(from_filepath, sizeof(from_filepath), "%s/%s", data_path, filename);

char to_filepath[256] = {0};

snprintf(to_filepath, sizeof(to_filepath), "%s/%s", g_data_file_path, filename);

copy_file(from_filepath, to_filepath);

// rename patch_dir/xxx.new -> data/files/xxx

// if rollback, rename back before prepare_so_lib

char new_filepath[256] = {0};

strncpy(new_filepath, from_filepath, sizeof(new_filepath));

new_filepath[strlen(from_filepath) - new_file_postfix_len] = '\0';

unlink(new_filepath);

rename(from_filepath, new_filepath);

continue;

}

}

closedir(dir);

return true;

{

DIR* dir = opendir(g_data_file_path);

if (dir == NULL)

{

MY_ERROR("can't access data path:%s", g_data_file_path);

return false;

}

const char* NEW_SO_POSTFIX = ".new";

int new_file_postfix_len = strlen(NEW_SO_POSTFIX);

char filepath_buffer[256] = {0};

struct dirent *ent = NULL;

while((ent = readdir(dir)) != NULL)

{

if(ent->d_type & DT_DIR) { continue; }

const char* filename = ent->d_name;

int len = strlen(filename);

snprintf(filepath_buffer, sizeof(filepath_buffer), "%s/%s", g_data_file_path, filename);

if (len > new_file_postfix_len && memcmp(filename + len - new_file_postfix_len, NEW_SO_POSTFIX, new_file_postfix_len) == 0)

{

std::string so_name = std::string(filename).substr(0, len - new_file_postfix_len);

std::string new_filepath = filepath_buffer;

std::string old_filepath = new_filepath.substr( 0, new_filepath.length() - new_file_postfix_len );

unlink(old_filepath.c_str());

rename(new_filepath.c_str(), old_filepath.c_str());

chmod(old_filepath.c_str(), 0755);

MY_LOG("rename %s to %s", new_filepath.c_str(), old_filepath.c_str());

continue;

}

}

closedir(dir);

return true;

{

char default_il2cpp_path[256] = {0};

snprintf(default_il2cpp_path, sizeof(default_il2cpp_path), "%s/../lib/libil2cpp.so", g_data_file_path);

default_path = std::string(default_il2cpp_path);

patch_path.clear();

char patch_info_path[256] = {0};

snprintf(patch_info_path, sizeof(patch_info_path), "%s/user.db", g_data_file_path);

//get patch date

struct stat user_stat;

memset(&user_stat, 0, sizeof(struct stat));

if (stat(patch_info_path, &user_stat) != 0) {

MY_LOG("can't read file:%d[%s]", errno, patch_info_path);

return false;

}

FILE* fp = ::fopen(patch_info_path, "rb");

if (fp == NULL)

{

MY_ERROR("can't open:%s, errno:%d", patch_info_path, errno);

return false;

}

uint32_t magic = unserial_uint32(fp);

if (magic != 5460){

MY_ERROR("wrong user.db format");

return false;

}

std::string data_path_string = unserial_string(fp);

MY_INFO("cached data path:%s", data_path_string.c_str());

std::string apk_path_string = unserial_string(fp);

MY_INFO("cached apk_path_string:%s", apk_path_string.c_str());

std::string bundle_id = unserial_string(fp);

MY_INFO("cached bundle_id:%s", bundle_id.c_str());

LeakSingleton<ShadowZipGlobalData, 0>::init();

unserial_string_vector(fp, g_shadowzip_global_data->all_files_);

unserial_partition_vector(fp, g_shadowzip_global_data->patch_partitions_);

g_shadowzip_global_data->end_of_file_ = unserial_uint64(fp);

::fclose(fp);

ShadowZip::log(g_shadowzip_global_data);

const char* data_path = data_path_string.c_str();

DIR* dir = opendir(data_path);

if (dir == NULL)

{

MY_ERROR("can't access data path:%s", data_path);

return false;

}

closedir(dir);

//get and save apk file id

const char* apk_path = apk_path_string.c_str();

struct stat apk_stat;

memset(&apk_stat, 0, sizeof(struct stat));

if (stat(apk_path, &apk_stat) != 0) {

MY_ERROR("can't read file:%d[%s]", errno, apk_path);

return false;

}

g_apk_device_id = apk_stat.st_dev;

g_apk_ino = apk_stat.st_ino;

//if we have newer apk file, then no need to load patch

if (apk_stat.st_mtime > user_stat.st_mtime){

MY_ERROR("newer apk file:%s, no need to patch", apk_path);

unlink(patch_info_path);

return false;

}

if (!pre_process_all_so_lib(bundle_id))

{

MY_ERROR("can't pre_process_all_so_lib");

return false;

}

char link_file[256] = {0};

snprintf(link_file, sizeof(link_file), "%s/libil2cpp.so", g_data_file_path);

std::string il2cpp_path(link_file);

FILE *fi = fopen (il2cpp_path.c_str(), "r");

if (fi == NULL)

{

MY_ERROR("can't libil2cpp:%s", il2cpp_path.c_str());

return false;

}

fclose (fi);

if (g_use_data_path != NULL){delete[] g_use_data_path;}

g_use_data_path = dupstr(data_path);

if (g_apk_file_path != NULL){delete[] g_apk_file_path;}

g_apk_file_path = dupstr(apk_path);

if (g_bundle_id != NULL){delete[] g_bundle_id;}

g_bundle_id = dupstr(bundle_id.c_str());

patch_path = il2cpp_path;

return true;

{

FILE *fp;

size_t addr = 0;

char *pch;

char filename[32];

char line[1024];

fp = fopen( "/proc/self/maps", "r" );

if ( fp != NULL ){

while ( fgets( line, sizeof(line), fp ) ){

MY_ERROR("%s", line);

}

fclose( fp ) ;

}

{

FILE *fp;

char *found_path = NULL;

char filename[32];

char line[1024];

const char* TAIL = ".apk";

int TAIL_LEN = strlen(TAIL);

std::string ret;

fp = fopen( "/proc/self/maps", "r" );

if ( fp != NULL ){

while ( fgets( line, sizeof(line), fp ) ){

int line_len = strlen(line);

while(line[line_len - 1] == ' ' || line[line_len - 1] == '\r' || line[line_len - 1] == '\n' || line[line_len - 1] == '\t') {line[line_len - 1] = '\0'; line_len--;}

if ( strstr( line, bundle_id.c_str()) && (memcmp(line + strlen(line) - TAIL_LEN, TAIL, TAIL_LEN) == 0) ){

found_path = strchr( line, '/' );

if (ShadowZip::contains_path(found_path, "assets/bin/Data/"))

{

ret = std::string(found_path);

break;

}

}

}

fclose( fp ) ;

}

return ret;

{

memset(file_stat, 0, sizeof(struct stat));

int ret = stat(path, file_stat);

if (ret != 0) {

return ret;

}

if (g_apk_device_id == file_stat->st_dev && g_apk_ino == file_stat->st_ino)

{

uint64_t size = ShadowZip::get_eof_pos();

if (size > 0){

file_stat->st_size = (off_t)size;

}

return ret;

}

return ret;

{

ShadowZip* shadow_zip = get_cached_shadowzip(stream);

if (shadow_zip == NULL){

return fseek(stream, offset, whence);

}else{

return shadow_zip->fseek(stream, offset, whence);

}

{

ShadowZip* shadow_zip = get_cached_shadowzip(stream);

if (shadow_zip == NULL){

return ftell(stream);

}else{

return shadow_zip->ftell(stream);

}

{

ShadowZip* shadow_zip = get_cached_shadowzip(stream);

if (shadow_zip == NULL){

rewind(stream);

}else{

shadow_zip->rewind(stream);

}

{

ShadowZip* shadow_zip = get_cached_shadowzip(stream);

if (shadow_zip == NULL){

return fread(ptr, size, nmemb, stream);

}else{

return shadow_zip->fread(ptr, size, nmemb, stream);

}

{

MY_METHOD("my_fclose: file*: 0x%08llx", (unsigned long long)stream);

FileExtraData* file_extra_data = get_mapping(stream);

if (file_extra_data != NULL)

{

clean_mapping_data(file_extra_data);

return 0;

}

else

{

return fclose(stream);

}

{

mode_t mode = -1;

int has_mode = ((flags & O_CREAT) == O_CREAT) || ((flags & 020000000) == 020000000);

if (has_mode)

{

va_list args;

va_start(args, flags);

mode = static_cast<mode_t>(va_arg(args, int));

va_end(args);

}

struct stat file_stat;

memset(&file_stat, 0, sizeof(struct stat));

if (stat(path, &file_stat) != 0) {

int ret = has_mode ? open(path, flags, mode) : open(path, flags);

MY_METHOD("open(can't access): %s -> fd:0x%08x", path, ret);

return ret;

}

if (g_apk_device_id == file_stat.st_dev && g_apk_ino == file_stat.st_ino)

{

ShadowZip* shadow_zip = new ShadowZip();

FILE* fp = shadow_zip->fopen();

if (fp == NULL){

MY_ERROR("something bad happens!");

delete shadow_zip;

int ret = has_mode ? open(path, flags, mode) : open(path, flags);

MY_METHOD("open(rollback): %s -> fd:0x%08x", path, ret);

return ret;

}

FileExtraData* file_extra_data = save_mapping(shadow_zip);

MY_LOG("shadow apk in open: %s, fd:0x%08x, file*: 0x%08llx", path, file_extra_data->fd, (unsigned long long)file_extra_data->file);

return file_extra_data->fd;

}

int ret = has_mode ? open(path, flags, mode) : open(path, flags);

MY_METHOD("not apk open: %s -> fd:0x%08x", path, ret);

return ret;

{

MY_METHOD("read: 0x%08x, %zu", fd, nbyte);

ssize_t ret = 0;

ShadowZip* shadow_zip = get_cached_shadowzip(fd);

if (shadow_zip == NULL){

ret = read(fd, buf, nbyte);

}else{

ret = shadow_zip->fread(buf, 1, nbyte, (FILE*)(size_t)fd);

}

MY_METHOD("readed: 0x%08x, %zd", fd, ret);

return ret;

{

MY_METHOD("lseek: 0x%08x, offset: 0x%08lx, whence: %d", fd, offset, whence);

off_t ret = 0;

ShadowZip* shadow_zip = get_cached_shadowzip(fd);

if (shadow_zip == NULL){

ret = lseek(fd, offset, whence);

}else{

ret = shadow_zip->fseek((FILE*)(size_t)fd, offset, whence);

if (ret == 0){ret = shadow_zip->ftell((FILE*)(size_t)fd);}

}

MY_METHOD("lseek: 0x%08x, return: %ld", fd, ret);

return ret;

{

MY_METHOD("lseek64: 0x%08x, offset: 0x%08llx, whence: %d", fd, (unsigned long long)offset, whence);

off64_t ret = 0;

ShadowZip* shadow_zip = get_cached_shadowzip(fd);

if (shadow_zip == NULL){

ret = lseek64(fd, offset, whence);

}else{

ret = shadow_zip->fseek((FILE*)(size_t)fd, offset, whence);

if (ret == 0){ret = shadow_zip->ftell((FILE*)(size_t)fd);}

}

MY_METHOD("lseek64: 0x%08x, return: %lld", fd, (unsigned long long)ret);

return ret;

{

MY_METHOD("my_close: 0x%08x", fd);

FileExtraData* file_extra_data = get_mapping(fd);

if (file_extra_data != NULL)

{

clean_mapping_data(file_extra_data);

return 0;

}

else

{

return close(fd);

}

{

#define HOOK(lib, symbol) \

if(0 != xhook_register(lib, #symbol, (void*)my_##symbol, NULL)){ \

MY_ERROR("failed to find function:%s in %s", #symbol, lib); \

return -1; \

}

//xhook_enable_debug(1);

HOOK("libunity.so", fopen);

HOOK("libunity.so", fseek);

HOOK("libunity.so", ftell);

HOOK("libunity.so", fread);

HOOK("libunity.so", fgets);

HOOK("libunity.so", fclose);

HOOK("libunity.so", stat);

HOOK("libunity.so", dlopen);

HOOK("libunity.so", open);

HOOK("libunity.so", read);

HOOK("libunity.so", lseek);

HOOK("libunity.so", lseek64);

HOOK("libunity.so", close);

if(0 != xhook_refresh(1)){

MY_ERROR("failed to find replace function");

return -1;

}

return 0;

{

return 0;

{

std::string default_il2cpp_path;

std::string patch_il2cpp_path;

bool use_patch = extract_patch_info(default_il2cpp_path, patch_il2cpp_path);

if (use_patch){

MY_INFO("bootstrap running %s with apk_path:[%s], patch_so:[%s], patch_dir:[%s]", TARGET_ARCH_ABI,

g_apk_file_path, patch_il2cpp_path.c_str(), g_use_data_path);

bool success = (0 == init_hook()) && (0 == init_mapping_data());

if (success)

{

MY_INFO("bootstrap running with patch:%s", patch_il2cpp_path.c_str());

//ShadowZip::output_apk(g_use_data_path);

}// else we still do so hook

else

{

MY_INFO("bootstrap running failed with patch");

}

}

else

{

MY_INFO("bootstrap running without patch");

}