Android 逆向Android 进程注入工具开发 ( 远程进程注入动态库文件操作 | 注入动态库 加载 业务动态库 | 业务动态库启动 | pthread_create 线程开发 )

前言

libbridge.so 动态库是 注入工具 使用 ptrace 函数强行向远程进程 注入的 动态库 , 这种方法侵入性极大 , 会破坏远程进程的运行环境 , 因此该动态库越简洁越好 ;

注入动态库 就执行一个操作 , 就是加载 包含真正的逆向业务逻辑的 libnattive.so 动态库 , 然后启动该动态库即可 , 执行完毕后 , 马上在远程进程中销毁注入的 libbridge.so 动态库 ;

一、加载 libnattive.so 动态库

---

通过 注入工具 , 将 libbridge.so 注入到远程进程 后 , 远程进程中 , 会 为 libbridge.so 动态库分配一块内存 , 并将其运行起来 ;

libbridge.so 动态库的主要操作是 加载 libnattive.so 动态库 , 并执行该动态库的 invoke 方法 ;

libbridge.so 动态库对应的 bridge.c 源码如下 :

#include <unistd.h>
#include <jni.h>
#include <dlfcn.h>

#include <android/log.h>  
#define LOG_TAG		"DongNao"
#define LOGD(...) ((void)__android_log_print(ANDROID_LOG_DEBUG, LOG_TAG, __VA_ARGS__))
#define LOGI(...) ((void)__android_log_print(ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__))
#define LOGW(...) ((void)__android_log_print(ANDROID_LOG_WARN, LOG_TAG, __VA_ARGS__))
#define LOGE(...) ((void)__android_log_print(ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__))

/* 主要任务是加载 /data/system/debug/libnative.so 动态库 , 
		加载完成后调用动态库的 invoke 方法 */
int load() {
	LOGW("%s(%d):%s\n", __FILE__, __LINE__, __FUNCTION__);
	void* handle = dlopen("/data/system/debug/libnative.so", RTLD_GLOBAL);
	LOGW("%s(%d):%s handle=%p\n", __FILE__, __LINE__, __FUNCTION__, handle);
	/* 获取启动函数 invoke 的地址 */
	void* invoke = dlsym(handle, "invoke");
	LOGW("%s(%d):%s invoke=%p\n", __FILE__, __LINE__, __FUNCTION__, invoke);
	/* 调用 invoke 启动函数 */
	((void(*)())invoke)();
	return 0;
}

二、 libnattive.so 动态库启动

---

在 libnattive.so 动态库中 , 不能长时间维持 , 因为 注入工具 还要 获取到远程进程的控制权 , 退出 ptrace 函数调试状态 , detach 解除注入工具对远程进行的附着操作 , 之后 令远程进程正常运行 , 才能开始针对远程进行的调试 ;

因此在 libnattive.so 动态库的 invoke 方法中 , 不能执行循环操作 , 该方法最好能立即返回 ;

在 libnattive.so 动态库的 invoke 方法中 , 开启了一个线程 , 该线程不断地进行循环 , 并且每次循环都获取一次 调试工具 发送过来的指令 , 根据执行执行相应操作 , 如修改内存 , 查找内存等操作 ;

	/* 开启了一个线程 , 立刻返回 , 返回后注入工具会获得远程进程控制权 */
	void invoke(/*const char* args*/)
	{
		LOGW("native::invoke called!\n");
		/* 开启线程执行后续操作 */
		pthread_t tid_t;
		int ret = pthread_create(&tid_t, NULL, (pthread_func)thread_entry, NULL/*(void*)args*/);
		if (ret != 0) {
			LOGW("thread create failed!\n");
			return;
		}
	}

在 Linux C 中 , 启动线程很简单 , 准备一个线程函数 , 然后调用 pthread_create 系统接口 , 即可启动一个线程 , 线程中执行 线程函数 ;

三、 pthread_create 线程开发

---

关于 Linux C 中线程开发 , 参考 【Android NDK 开发】JNI 线程 ( JNI 线程创建 | 线程执行函数 | 非 JNI 方法获取 JNIEnv 与 Java 对象 | 线程获取 JNIEnv | 全局变量设置 ) 博客 ;

线程创建方法函数原型 :

int pthread_create(pthread_t *tidp, const pthread_attr_t *attr, (void*)(*start_rtn)(void*), void *arg)`;

pthread_create 方法的 4 个参数 ;

• 参数 1 ( pthread_t *tidp ) : 线程标识符指针 , 该指针指向线程标识符 ;
• 参数 2 ( const pthread_attr_t *attr ) : 线程属性指针 ;
• 参数 3 ( (void*)(*start_rtn)(void*) ) : 线程运行函数指针 , start_rtn 是一个函数指针 , 其参数和返回值类型是 void* 类型 ;
• 参数 4 ( void *arg ) : 参数 3 中的线程运行函数的参数 ;

pthread_create 方法返回值说明 :

• 线程创建成功 , 返回 0 ;
• 线程创建失败 , 返回 错误代码 ;

四、 线程执行函数

---

下面是线程中执行的线程函数 , 该函数中进行了无限循环 , 每隔 333 毫秒循环一次 ;

调试工具 将指令写出到 /data/system/debug/command.json 文件中 , 线程函数每次循环读取该文件 , 查询是否有新的指令到达 , 如果有新的指令 , 则执行该指令 , 如果没有 , 则执行下一次循环 ;

该线程函数开启后 , 基本 无法终止 , 也没有必要终止 ;

	void* thread_entry(const char*args) {
		const size_t nsize = 64 * 1024;
		char* data = new char[nsize];
		LOGW("native start!\n");
		while (true) {
			usleep(1000 * 333);//333ms检测一次文件
			//FILE* pFile = fopen(args, "r");
			FILE* pFile = fopen("/data/system/debug/command.json", "r");
			if (pFile != NULL) {
				memset(data, 0, nsize);
				fread(data, nsize, 1, pFile);
				fclose(pFile);
				try {
					deal_command(data);
				}
				catch (std::exception& e) {
					LOGW("execute command error!%s\n", e.what());
				}
			}
			else {
				LOGW("read failed!\n");
			}
		}
		delete[]data;
	}

这篇好文章是转载于：学新通技术网