Android中通過進程注入技術修改系統返回的Mac地址

問題

Android中通過注入技術修改系統返回的Mac地址

技術准備

下面來看一下這個技術需要哪些知識點

1、如何將非native方法變成native方法

2、如何將native方法直接注冊(不需要jni這樣的頭文件了)

3、Android中的類加載器相關知識

4、如何編譯Android系統引用系統頭文件的NDK項目

雖然這裡有這四個知識點，但是其中有兩個我在之前的blog中已經介紹了：

Android中的類加載器：http://blog.csdn.net/jiangwei0910410003/article/details/41384667

如何編譯Android系統引用系統頭文件的NDK項目：http://blog.csdn.net/jiangwei0910410003/article/details/40949475

不過在這篇文章中，我們在介紹一種新的編譯方式

項目測試

第一、Android項目

package com.example.testar;

import android.net.wifi.WifiInfo;
import android.net.wifi.WifiManager;
import android.os.Bundle;
import android.app.Activity;
import android.content.Context;
import android.util.Log;
import android.view.Menu;
import android.view.View;
import android.widget.Button;

public class MainActivity extends Activity {

	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_main);

		Button btn = (Button) findViewById(R.id.button1);
		btn.setOnClickListener(new View.OnClickListener() {

			@Override
			public void onClick(View v) {
				WifiManager wifi = (WifiManager) getSystemService(Context.WIFI_SERVICE);
				WifiInfo info = wifi.getConnectionInfo();
				System.out.println("Wifi mac :" + info.getMacAddress());
				Log.d("DEMO", "Wifi mac:"+info.getMacAddress());
			}
		});
	}

}

我們看到，這裡的代碼很簡單，就是打印一下設備的Mac地址，現在我們要做的就是：注入這個Demo進程，然後修改Mac的值。

第二、底層的實現

首先來看一下inject.c

這個是注入進程的核心文件，由於代碼比較多，這裡只看核心的部分：

int main(int argc, char** argv) {
	char *pn = "com.example.testar";
	char *is = "/data/local/libso.so";
	printf("%s\n",pn);
	printf("%s\n",is);

	pid_t target_pid;
	target_pid = find_pid_of(pn);
	printf("pid: %d\n",target_pid);
	int ret = inject_remote_process(target_pid, is, "InjectInterface", (void*)"I'm parameter!", strlen("I'm parameter!") );
	printf("result: %d\n",ret);
}

就是他的主函數代碼

我們看到有一個重要的函數：

inject_remote_process

第一個參數：注入進程的id

第二個參數：需要注入到目標進程的so文件

第三個參數：so文件中需要執行的函數名

第四個參數：執行函數的參數

第五個參數：執行函數的參數的長度

 

主要還是前面三個參數。

這裡我們通過find_pid_of(pn)函數來獲取進程id

傳遞進去的是進程名

Android中應用的進程名就是包名

char *pn = "com.example.testar";

看到上面注入到目標進程的so文件

char *is = "/data/local/libso.so";

下面再來看一下這個so文件的源代碼

so.cpp

#include "jni.h"
#include <android_runtime/AndroidRuntime.h>
#include "android/log.h"
#include "stdio.h"
#include "stdlib.h"
#include "MethodHooker.h"
#include <utils/CallStack.h>
#define log(a,b) __android_log_write(ANDROID_LOG_INFO,a,b); // LOGÀàÐÍ:info
#define log_(b) __android_log_write(ANDROID_LOG_INFO,"JNI_LOG_INFO",b); // LOGÀàÐÍ:info

extern "C" void InjectInterface(char*arg){
	log_("*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*");
	log_("*-*-*-*-*-* Injected so *-*-*-*-*-*-*-*");
	log_("*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*");
	Hook();
	log_("*-*-*-*-*-*-*- End -*-*-*-*-*-*-*-*-*-*");
}

extern "C" JNIEXPORT jstring JNICALL Java_com_example_testar_InjectApplication_test(JNIEnv *env, jclass clazz)
{
    return env->NewStringUTF("haha ");
}

在這個文件中，我們看到了函數InjectInterface了，因為so是C++程序，但是inject是C程序，為了兼容，就有這種方式了

 

extern “C”  函數{

//do something

}

這個代碼沒什麼難度和復雜性

這個函數中調用了Hook函數，下面在來看一下Hook函數的定義

MethodHooker.cpp的實現

#include "MethodHooker.h"
#include "jni.h"
#include "android_runtime/AndroidRuntime.h"
#include "android/log.h"
#include "stdio.h"
#include "stdlib.h"
#include "native.h"
#include <dlfcn.h>
#define ANDROID_SMP 0
#include "Dalvik.h"
#include "alloc/Alloc.h"

#define ALOG(...) __android_log_print(ANDROID_LOG_VERBOSE, __VA_ARGS__)

static bool g_bAttatedT;
static JavaVM *g_JavaVM;

void init()
{
	g_bAttatedT = false;
	g_JavaVM = android::AndroidRuntime::getJavaVM();
}

static JNIEnv *GetEnv()
{
	int status;
	JNIEnv *envnow = NULL;
	status = g_JavaVM->GetEnv((void **)&envnow, JNI_VERSION_1_4);
	if(status < 0)
	{
		status = g_JavaVM->AttachCurrentThread(&envnow, NULL);
		if(status < 0)
		{
			return NULL;
		}
		g_bAttatedT = true;
	}
	return envnow;
}

static void DetachCurrent()
{
	if(g_bAttatedT)
	{
		g_JavaVM->DetachCurrentThread();
	}
}

static int computeJniArgInfo(const DexProto* proto)
{
    const char* sig = dexProtoGetShorty(proto);
    int returnType, jniArgInfo;
    u4 hints;

    /* The first shorty character is the return type. */
    switch (*(sig++)) {
    case 'V':
        returnType = DALVIK_JNI_RETURN_VOID;
        break;
    case 'F':
        returnType = DALVIK_JNI_RETURN_FLOAT;
        break;
    case 'D':
        returnType = DALVIK_JNI_RETURN_DOUBLE;
        break;
    case 'J':
        returnType = DALVIK_JNI_RETURN_S8;
        break;
    case 'Z':
    case 'B':
        returnType = DALVIK_JNI_RETURN_S1;
        break;
    case 'C':
        returnType = DALVIK_JNI_RETURN_U2;
        break;
    case 'S':
        returnType = DALVIK_JNI_RETURN_S2;
        break;
    default:
        returnType = DALVIK_JNI_RETURN_S4;
        break;
    }

    jniArgInfo = returnType << DALVIK_JNI_RETURN_SHIFT;

    hints = dvmPlatformInvokeHints(proto);

    if (hints & DALVIK_JNI_NO_ARG_INFO) {
        jniArgInfo |= DALVIK_JNI_NO_ARG_INFO;
    } else {
        assert((hints & DALVIK_JNI_RETURN_MASK) == 0);
        jniArgInfo |= hints;
    }

    return jniArgInfo;
}

int ClearException(JNIEnv *jenv){
	jthrowable exception = jenv->ExceptionOccurred();
	if (exception != NULL) {
		jenv->ExceptionDescribe();
		jenv->ExceptionClear();
		return true;
	}
	return false;
}

bool isArt(){
	return true;
}

static jclass findAppClass(JNIEnv *jenv,const char *apn){
	jclass clazzApplicationLoaders = jenv->FindClass("android/app/ApplicationLoaders");
	jthrowable exception = jenv->ExceptionOccurred();
	if (ClearException(jenv)) {
		ALOG("Exception","No class : %s", "android/app/ApplicationLoaders");
		return NULL;
	}
	jfieldID fieldApplicationLoaders = jenv->GetStaticFieldID(clazzApplicationLoaders,"gApplicationLoaders","Landroid/app/ApplicationLoaders;");
	if (ClearException(jenv)) {
		ALOG("Exception","No Static Field :%s","gApplicationLoaders");
		return NULL;
	}
	jobject objApplicationLoaders = jenv->GetStaticObjectField(clazzApplicationLoaders,fieldApplicationLoaders);
	if (ClearException(jenv)) {
		ALOG("Exception","GetStaticObjectField is failed [%s","gApplicationLoaders");
		return NULL;
	}
	jfieldID fieldLoaders = jenv->GetFieldID(clazzApplicationLoaders,"mLoaders","Ljava/util/Map;");
	if (ClearException(jenv)) {
		ALOG("Exception","No Field :%s","mLoaders");
		return NULL;
	}
	jobject objLoaders = jenv->GetObjectField(objApplicationLoaders,fieldLoaders);
	if (ClearException(jenv)) {
		ALOG("Exception","No object :%s","mLoaders");
		return NULL;
	}
	jclass clazzHashMap = jenv->GetObjectClass(objLoaders);
	jmethodID methodValues = jenv->GetMethodID(clazzHashMap,"values","()Ljava/util/Collection;");
	jobject values = jenv->CallObjectMethod(objLoaders,methodValues);

	jclass clazzValues = jenv->GetObjectClass(values);
	jmethodID methodToArray = jenv->GetMethodID(clazzValues,"toArray","()[Ljava/lang/Object;");
	if (ClearException(jenv)) {
		ALOG("Exception","No Method:%s","toArray");
		return NULL;
	}

	jobjectArray classLoaders = (jobjectArray)jenv->CallObjectMethod(values,methodToArray);
	if (ClearException(jenv)) {
		ALOG("Exception","CallObjectMethod failed :%s","toArray");
		return NULL;
	}

		int size = jenv->GetArrayLength(classLoaders);

		for(int i = 0 ; i < size ; i ++){
			jobject classLoader = jenv->GetObjectArrayElement(classLoaders,i);
			jclass clazzCL = jenv->GetObjectClass(classLoader);
			jmethodID loadClass = jenv->GetMethodID(clazzCL,"loadClass","(Ljava/lang/String;)Ljava/lang/Class;");
			jstring param = jenv->NewStringUTF(apn);
			jclass tClazz = (jclass)jenv->CallObjectMethod(classLoader,loadClass,param);
			if (ClearException(jenv)) {
				ALOG("Exception","No");
				continue;
			}
			return tClazz;
		}
	ALOG("Exception","No");
	return NULL;
}

bool HookDalvikMethod(jmethodID jmethod){
	Method *method = (Method*)jmethod;
	SET_METHOD_FLAG(method, ACC_NATIVE);

	int argsSize = dvmComputeMethodArgsSize(method);
    if (!dvmIsStaticMethod(method))
        argsSize++;

    method->registersSize = method->insSize = argsSize;

    if (dvmIsNativeMethod(method)) {
        method->nativeFunc = dvmResolveNativeMethod;
        method->jniArgInfo = computeJniArgInfo(&method->prototype);
    }
}

bool ClassMethodHook(HookInfo info){

	JNIEnv *jenv = GetEnv();

	jclass clazzTarget = jenv->FindClass(info.tClazz);
	if (ClearException(jenv)) {
		ALOG("Exception","ClassMethodHook[Can't find class:%s in bootclassloader",info.tClazz);

	    clazzTarget = findAppClass(jenv,info.tClazz);
	    if(clazzTarget == NULL){
	    	ALOG("Exception","%s","Error in findAppClass");
	    	return false;
	    }
	}

	jmethodID method = jenv->GetMethodID(clazzTarget,info.tMethod,info.tMeihodSig);
	if(method==NULL){
		ALOG("Exception","ClassMethodHook[Can't find method:%s",info.tMethod);
		return false;
	}

	/*
	if(isArt()){
		HookArtMethod(jenv,method);
	}else{
		HookDalvikMethod(method);
	}
	*/

	HookDalvikMethod(method);

    JNINativeMethod gMethod[] = {
        {info.tMethod, info.tMeihodSig, info.handleFunc},
    };

    if(info.handleFunc != NULL){
		if (jenv->RegisterNatives(clazzTarget, gMethod, 1) < 0) {
			ALOG("RegisterNatives","err");
			return false;
		}
    }

	DetachCurrent();
	return true;
}

int Hook(){
	init();
	void* handle = dlopen("/data/local/libTest.so",RTLD_NOW);
	const char *dlopen_error = dlerror();
	if(!handle){
		ALOG("Error","cannt load plugin :%s",dlopen_error);
		return -1;
	}
	SetupFunc setup = (SetupFunc)dlsym(handle,"getpHookInfo");
	const char *dlsym_error = dlerror();
	if (dlsym_error) {
		ALOG("Error","Cannot load symbol 'getpHookInfo' :%s" , dlsym_error);
		dlclose(handle);
		return 1;
	}

	HookInfo *hookInfo;
	setup(&hookInfo);

	ALOG("LOG","Target Class:%s",hookInfo[0].tClazz);
	ALOG("LOG","Target Method:%s",hookInfo[0].tMethod);

	ClassMethodHook(hookInfo[0]);
}

這個代碼就有點多了，而且核心功能的代碼都是在這裡實現的。

首先來看一下Hook函數：

int Hook(){
	init();
	void* handle = dlopen("/data/local/libTest.so",RTLD_NOW);
	const char *dlopen_error = dlerror();
	if(!handle){
		ALOG("Error","cannt load plugin :%s",dlopen_error);
		return -1;
	}
	SetupFunc setup = (SetupFunc)dlsym(handle,"getpHookInfo");
	const char *dlsym_error = dlerror();
	if (dlsym_error) {
		ALOG("Error","Cannot load symbol 'getpHookInfo' :%s" , dlsym_error);
		dlclose(handle);
		return 1;
	}

	HookInfo *hookInfo;
	setup(&hookInfo);

	ALOG("LOG","Target Class:%s",hookInfo[0].tClazz);
	ALOG("LOG","Target Method:%s",hookInfo[0].tMethod);

	ClassMethodHook(hookInfo[0]);
}

這個函數中，我們看到使用了dlopen系列的函數，主要是用來打開so文件，然後執行文件中的指定函數

我們看到主要還是執行getpHookInfo函數，我們就去看一下這個函數的定義

Test.c

#include "native.h"
#include <android/log.h>
#include "stdio.h"
#include "stdlib.h"
#include "MethodHooker.h"

#define log(a,b) __android_log_print(ANDROID_LOG_VERBOSE,a,b); 
#define log_(b) __android_log_print(ANDROID_LOG_VERBOSE,"JNI_LOG_INFO",b); 

int getpHookInfo(HookInfo** pInfo);

JNIEXPORT void JNICALL Java_com_example_testar_InjectClassloader_hookMethodNative
  (JNIEnv * jenv, jobject jboj, jobject jobj, jclass jclazz, jint slot)
{
	//log("TestAE","start Inject other process");
}

JNIEXPORT jstring JNICALL test(JNIEnv *env, jclass clazz)  
{  
    //__android_log_print(ANDROID_LOG_VERBOSE, "tag", "call <native_printf> in java");
    return (*env)->NewStringUTF(env,"haha ");;
}

HookInfo hookInfos[] = {
		{"android/net/wifi/WifiInfo","getMacAddress","()Ljava/lang/String;",(void*)test},
		//{"com/example/testar/MainActivity","test","()Ljava/lang/String;",(void*)test},
		//{"android/app/ApplicationLoaders","getText","()Ljava/lang/CharSequence;",(void*)test},
};

int getpHookInfo(HookInfo** pInfo){
	*pInfo = hookInfos;
	return sizeof(hookInfos) / sizeof(hookInfos[0]);
}

看一下getHookInfo函數

int getpHookInfo(HookInfo** pInfo){
	*pInfo = hookInfos;
	return sizeof(hookInfos) / sizeof(hookInfos[0]);
}

傳遞的參數是HookInfo的二級指針類型，我們在看一下HookInfo類型的定義

MethodHooker.h

typedef struct{
	const char *tClazz;
	const char *tMethod;
	const char *tMeihodSig;
	void *handleFunc;
} HookInfo;

typedef int(*SetupFunc)(HookInfo**);

int Hook();

HookInfo是一個結構體

有四個成員字段

tClazz：類的全稱

tMethod：方法名

tMethodSig：方法簽名

handleFounc：函數的指針

關於這四個字段的作用，我們來看一下HookInfo的內容：

Test.c

HookInfo hookInfos[] = {
		{"android/net/wifi/WifiInfo","getMacAddress","()Ljava/lang/String;",(void*)test},
		//{"com/example/testar/MainActivity","test","()Ljava/lang/String;",(void*)test},
		//{"android/app/ApplicationLoaders","getText","()Ljava/lang/CharSequence;",(void*)test},
};

這裡看到了，我們現在需要修改Mac地址，Android中提供給我的的接口是WifiInfo這個類中的getMacAddress方法

第一個字段類的名稱：android/net/wifi/WifiInfo，是全稱

第二個字段方法名：getMacAddress

第三個字段方法的簽名：()Ljava/lang/String;

第四個字段函數指針：test函數

因為我們是通過WifiInfo這個類中的getMacAddress方法來獲取Mac地址的

看一下test函數

JNIEXPORT jstring JNICALL test(JNIEnv *env, jclass clazz)  
{  
    //__android_log_print(ANDROID_LOG_VERBOSE, "tag", "call <native_printf> in java");
    return (*env)->NewStringUTF(env,"haha ");
}

這個函數直接返回一個字符串：“haha “

再回到MethodHooker.cpp中的Hook函數

int Hook(){
	init();
	void* handle = dlopen("/data/local/libTest.so",RTLD_NOW);
	const char *dlopen_error = dlerror();
	if(!handle){
		ALOG("Error","cannt load plugin :%s",dlopen_error);
		return -1;
	}
	SetupFunc setup = (SetupFunc)dlsym(handle,"getpHookInfo");
	const char *dlsym_error = dlerror();
	if (dlsym_error) {
		ALOG("Error","Cannot load symbol 'getpHookInfo' :%s" , dlsym_error);
		dlclose(handle);
		return 1;
	}

	HookInfo *hookInfo;
	setup(&hookInfo);

	ALOG("LOG","Target Class:%s",hookInfo[0].tClazz);
	ALOG("LOG","Target Method:%s",hookInfo[0].tMethod);

	ClassMethodHook(hookInfo[0]);
}

使用dlsym來獲取函數指針：

SetupFunc是一個函數指針類型的，在MethodHooker.h中定義的

typedef int(*SetupFunc)(HookInfo**);

然後我們就開始執行函數了

HookInfo *hookInfo;  
setup(&hookInfo);

因為我們之前看了getpHookInfo函數，他的參數是一個HookInfo的二級指針，所以可以進行值傳遞的。

執行完這個函數之後，hookInfo就有值了

其實上面的那段代碼的功能就是：

獲取HookInfo類型的內容

下面在來看一下ClassMethodHook函數

我們傳遞進去的是hookInfo[0]，在Test.c代碼中，我們定義了HookInfo數組，大小就是1，所以這裡就直接傳遞第一個元素值。

HookInfo hookInfos[] = {  
        {"android/net/wifi/WifiInfo","getMacAddress","()Ljava/lang/String;",(void*)test},  
        //{"com/example/testar/MainActivity","test","()Ljava/lang/String;",(void*)test},  
        //{"android/app/ApplicationLoaders","getText","()Ljava/lang/CharSequence;",(void*)test},  
};

看一下ClassMethodHook函數的定義

bool ClassMethodHook(HookInfo info){

	//獲取JNIEnv對象
	JNIEnv *jenv = GetEnv();

	//查找類
	jclass clazzTarget = jenv->FindClass(info.tClazz);
	if (ClearException(jenv)) {
		ALOG("Exception","ClassMethodHook[Can't find class:%s in bootclassloader",info.tClazz);

	    clazzTarget = findAppClass(jenv,info.tClazz);
	    if(clazzTarget == NULL){
	    	ALOG("Exception","%s","Error in findAppClass");
	    	return false;
	    }
	}

	//在類中查找方法
	jmethodID method = jenv->GetMethodID(clazzTarget,info.tMethod,info.tMeihodSig);
	if(method==NULL){
		ALOG("Exception","ClassMethodHook[Can't find method:%s",info.tMethod);
		return false;
	}

	//將這個方法變成native
	HookDalvikMethod(method);

    JNINativeMethod gMethod[] = {
        {info.tMethod, info.tMeihodSig, info.handleFunc},
    };

    //注冊native方法
    if(info.handleFunc != NULL){
		if (jenv->RegisterNatives(clazzTarget, gMethod, 1) < 0) {
			ALOG("RegisterNatives","err");
			return false;
		}
    }

	DetachCurrent();
	return true;
}

這個函數中有其他的函數調用，我們先來看看他們是怎麼定義的

1、GetEnv()

static JNIEnv *GetEnv()  
{  
    int status;  
    JNIEnv *envnow = NULL;  
    status = g_JavaVM->GetEnv((void **)&envnow, JNI_VERSION_1_4);  
    if(status < 0)  
    {  
        status = g_JavaVM->AttachCurrentThread(&envnow, NULL);  
        if(status < 0)  
        {  
            return NULL;  
        }  
        g_bAttatedT = true;  
    }  
    return envnow;  
}

這個函數的功能是通過JVM來獲取當前線程的JNIEnv對象，我們知道JVM是進程級的，一個進程對應一個JVM，JNIEnv是線程級的，一個線程對應一個JNIEnv，因為這裡沒有使用上層Java中的native方法，所以無法得到JNIEnv對象，但是我們可以通過另外的一種方式：引入AndroidRuntime.h(這個系統頭文件)，通過其中系統定義的函數來獲取JVM對象，有了JVM對象，就可以得到當前線程的JNIEnv對象了：

static JavaVM *g_JavaVM;

void init()
{
	g_bAttatedT = false;
	g_JavaVM = android::AndroidRuntime::getJavaVM();
}

所以這裡就介紹了，以後如果在底層沒有和上層打交道，但是又想得到JNIEnv對象，這就是一種方法。

2、findClass函數

static jclass findAppClass(JNIEnv *jenv,const char *apn){  
    //通過類的全稱來查找這個類，返回jclass對象  
    jclass clazzApplicationLoaders = jenv->FindClass("android/app/ApplicationLoaders");  
    jthrowable exception = jenv->ExceptionOccurred();  
    if (ClearException(jenv)) {  
        ALOG("Exception","No class : %s", "android/app/ApplicationLoaders");  
        return NULL;  
    }  
    jfieldID fieldApplicationLoaders =   
            jenv->GetStaticFieldID(clazzApplicationLoaders,"gApplicationLoaders","Landroid/app/ApplicationLoaders;");  
    if (ClearException(jenv)) {  
        ALOG("Exception","No Static Field :%s","gApplicationLoaders");  
        return NULL;  
    }  
    jobject objApplicationLoaders = jenv->GetStaticObjectField(clazzApplicationLoaders,fieldApplicationLoaders);  
    if (ClearException(jenv)) {  
        ALOG("Exception","GetStaticObjectField is failed [%s","gApplicationLoaders");  
        return NULL;  
    }  
    jfieldID fieldLoaders = jenv->GetFieldID(clazzApplicationLoaders,"mLoaders","Ljava/util/Map;");  
    if (ClearException(jenv)) {  
        ALOG("Exception","No Field :%s","mLoaders");  
        return NULL;  
    }  
    jobject objLoaders = jenv->GetObjectField(objApplicationLoaders,fieldLoaders);  
    if (ClearException(jenv)) {  
        ALOG("Exception","No object :%s","mLoaders");  
        return NULL;  
    }  

    jclass clazzHashMap = jenv->GetObjectClass(objLoaders);  
    jmethodID methodValues = jenv->GetMethodID(clazzHashMap,"values","()Ljava/util/Collection;");  
    jobject values = jenv->CallObjectMethod(objLoaders,methodValues);  

    jclass clazzValues = jenv->GetObjectClass(values);  
    jmethodID methodToArray = jenv->GetMethodID(clazzValues,"toArray","()[Ljava/lang/Object;");  
    if (ClearException(jenv)) {  
        ALOG("Exception","No Method:%s","toArray");  
        return NULL;  
    }  

    jobjectArray classLoaders = (jobjectArray)jenv->CallObjectMethod(values,methodToArray);  
    if (ClearException(jenv)) {  
        ALOG("Exception","CallObjectMethod failed :%s","toArray");  
        return NULL;  
    }  

        int size = jenv->GetArrayLength(classLoaders);  

        for(int i = 0 ; i < size ; i ++){  
            jobject classLoader = jenv->GetObjectArrayElement(classLoaders,i);  
            jclass clazzCL = jenv->GetObjectClass(classLoader);  
            jmethodID loadClass = jenv->GetMethodID(clazzCL,"loadClass","(Ljava/lang/String;)Ljava/lang/Class;");  
            jstring param = jenv->NewStringUTF(apn);  
            jclass tClazz = (jclass)jenv->CallObjectMethod(classLoader,loadClass,param);  
            if (ClearException(jenv)) {  
                ALOG("Exception","No");  
                continue;  
            }  
            return tClazz;  
        }  
    ALOG("Exception","No");  
    return NULL;  
}

這個函數的主要功能就是通過傳遞進來的類的全稱字符串，然後進行查找這個類，返回jclass.

這裡的原理是通過Android中的類加載器中來獲取這個類對象

其他就沒什麼難度了，就是JNIEnv的操作，這個就和Java中反射機制很類似。

我們看到函數中有一個這樣的類：

jclass clazzApplicationLoaders = jenv->FindClass("android/app/ApplicationLoaders");

我們去看一下這個類的源碼(android/app/ApplicationLoaders)：

/* 
 * Copyright (C) 2006 The Android Open Source Project 
 * 
 * Licensed under the Apache License, Version 2.0 (the "License"); 
 * you may not use this file except in compliance with the License. 
 * You may obtain a copy of the License at 
 * 
 *      http://www.apache.org/licenses/LICENSE-2.0 
 * 
 * Unless required by applicable law or agreed to in writing, software 
 * distributed under the License is distributed on an "AS IS" BASIS, 
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
 * See the License for the specific language governing permissions and 
 * limitations under the License. 
 */  

package android.app;  

import android.os.Trace;  
import android.util.ArrayMap;  
import dalvik.system.PathClassLoader;  

class ApplicationLoaders  
{  
    public static ApplicationLoaders getDefault()  
    {  
        return gApplicationLoaders;  
    }  

    public ClassLoader getClassLoader(String zip, String libPath, ClassLoader parent)  
    {  
        /* 
         * This is the parent we use if they pass "null" in.  In theory 
         * this should be the "system" class loader; in practice we 
         * don't use that and can happily (and more efficiently) use the 
         * bootstrap class loader. 
         */  
        ClassLoader baseParent = ClassLoader.getSystemClassLoader().getParent();  

        synchronized (mLoaders) {  
            if (parent == null) {  
                parent = baseParent;  
            }  

            /* 
             * If we're one step up from the base class loader, find 
             * something in our cache.  Otherwise, we create a whole 
             * new ClassLoader for the zip archive. 
             */  
            if (parent == baseParent) {  
                ClassLoader loader = mLoaders.get(zip);  
                if (loader != null) {  
                    return loader;  
                }  

                Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, zip);  
                PathClassLoader pathClassloader =  
                    new PathClassLoader(zip, libPath, parent);  
                Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);  

                mLoaders.put(zip, pathClassloader);  
                return pathClassloader;  
            }  

            Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, zip);  
            PathClassLoader pathClassloader = new PathClassLoader(zip, parent);  
            Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);  
            return pathClassloader;  
        }  
    }  

    private final ArrayMap<String, ClassLoader> mLoaders = new ArrayMap<String, ClassLoader>();  

    private static final ApplicationLoaders gApplicationLoaders  
        = new ApplicationLoaders();  
}

這個類的作用就是用來維護應用中的類加載器

看到他有一個私有的變量mLoaders.是ArrayMap類型的

ArrayMap類型就把他看成是ArrayList和Map的結合體。具體使用自行研究。

這個mLoaders變量中維護了ClassLoader對象，現在我們就需要獲取這個ClassLoader對象

其中key是類的全稱，value就是類加載器

因為這個類是包訪問權限，又是單例模式，我們只能去調用他的getDefault方法，得到其對象，然後在獲取他的mLoaders變量值

好了關於findClass函數的後續代碼我就不解讀了，因為沒什麼難度，說白了就是反射機制

1)、通過反射獲取ApplicationLoaders對象中的mLoaders值

2)、通過反射去獲取mLoaders中指定key的類加載器ClassLoader對象

3)、然後通過反射去調用類加載器中的loadClass方法，返回一個jclass對象，最後返回即可

3、HookDalvikMethod函數

bool HookDalvikMethod(jmethodID jmethod){  
    Method *method = (Method*)jmethod;  
    //將方法method設置變成native  
    SET_METHOD_FLAG(method, ACC_NATIVE);  

    //計算這個native方法需要的空間大小  
    int argsSize = dvmComputeMethodArgsSize(method);  
    if (!dvmIsStaticMethod(method))  
        argsSize++;  

    method->registersSize = method->insSize = argsSize;  

    if (dvmIsNativeMethod(method)) {  
        method->nativeFunc = dvmResolveNativeMethod;  
        method->jniArgInfo = computeJniArgInfo(&method->prototype);  
    }  
}

這個函數代碼不多，但是他的功能是最關鍵的。

將傳遞進來的jmethodID方法變成native方法

這個就是可以將一個非native方法變成一個native方法

其實這段代碼中有幾個重要的函數：

SET_METHOD_FLAG

dvmComputeMethodArgsSize

dvmIsStaticMethod

dvmIsNativeMethos

devResolveNativeMethod

這些函數都是在系統中定義的，我們需要引入這個頭文件：Dalvik.h

 

看完了，這些函數，我們還是需要回到我們開始的地方ClassMethosHook函數：

bool ClassMethodHook(HookInfo info){  

    //獲取JNIEnv對象  
    JNIEnv *jenv = GetEnv();  

    //查找類  
    jclass clazzTarget = jenv->FindClass(info.tClazz);  
    if (ClearException(jenv)) {  
        ALOG("Exception","ClassMethodHook[Can't find class:%s in bootclassloader",info.tClazz);  

        clazzTarget = findAppClass(jenv,info.tClazz);  
        if(clazzTarget == NULL){  
            ALOG("Exception","%s","Error in findAppClass");  
            return false;  
        }  
    }  

    //在類中查找方法  
    jmethodID method = jenv->GetMethodID(clazzTarget,info.tMethod,info.tMeihodSig);  
    if(method==NULL){  
        ALOG("Exception","ClassMethodHook[Can't find method:%s",info.tMethod);  
        return false;  
    }  

    //將這個方法變成native  
    HookDalvikMethod(method);  

    JNINativeMethod gMethod[] = {  
        {info.tMethod, info.tMeihodSig, info.handleFunc},  
    };  

    //注冊native方法  
    if(info.handleFunc != NULL){  
        if (jenv->RegisterNatives(clazzTarget, gMethod, 1) < 0) {  
            ALOG("RegisterNatives","err");  
            return false;  
        }  
    }  

    DetachCurrent();  
    return true;  
}

還有一部分，調用JNIEnv對象中的RegisterNatives方法，進行注冊native方法。

上面的代碼我們就看完了

下面來總結一下流程吧

1、首先執行inject.c中的main函數，在這個函數中我們將我們自己的libso.so文件注入到目標進程中，然後執行InjectInterface函數

2、在InjectInterface函數中，我們在執行MethodHooker.cpp中的Hook函數

3、在Hook函數中，我們通過dlopen函數打開libTest.so文件，然後執行其中的getpHookInfo函數，獲取HookInfo結構體類型的內容

4、在getpHookInfo函數中主要的功能是將初始化好的HookInfo結構體返回給Hook函數中

5、在Hook函數中拿到getpHookInfo函數返回的HookInfo結構體內容，然後開始做兩部分內容

A：將結構體中的字段tMethod標示的方法變成native的

      在這個過程中，我們首先需要獲取到這個方法所在的類，然後通過這個類來得到jmethod對象，然後進行操作

B：將結構體中的字段tMethod標示的方法和字段handleFunc進行關聯注冊,調用JNIEnv對象中的RegisterNatives函數

現在我們會想一下為什麼我們要這麼做呢？先把方法變成native的，然後在進行注冊

這個就需要了解一下Dalvik在執行指定方法的流程了

Dalvik在執行函數時會先調用dvmIsNativeMethod來判斷一個method是否是native方法。如果是native函數的話，那麼它所指向的一個Method對象的成員變量nativeFunc就指向該JNI方法的地址，因此就可以直接對它進行調用。否則的話，就說明參數method描述的是一個Java函數，這時候就需要繼續調用函數dvmInterpret來執行它的代碼。因此我們可以把一個非native的java函數變成native method，讓Dalvik執行我們的native方法而達到hook的目的。

在來看一下loadMethodFromDex源碼：

if (pDexCode != NULL) {  
        /* integer constants, copy over for faster access */  
        meth->registersSize = pDexCode->registersSize;  
        meth->insSize = pDexCode->insSize;  
        meth->outsSize = pDexCode->outsSize;  

        /* pointer to code area */  
        meth->insns = pDexCode->insns;  
    } else {  
        /* 
         * We don't have a DexCode block, but we still want to know how 
         * much space is needed for the arguments (so we don't have to 
         * compute it later).  We also take this opportunity to compute 
         * JNI argument info. 
         * 
         * We do this for abstract methods as well, because we want to 
         * be able to substitute our exception-throwing "stub" in. 
         */  
        int argsSize = dvmComputeMethodArgsSize(meth);  
        if (!dvmIsStaticMethod(meth))  
            argsSize++;  
        meth->registersSize = meth->insSize = argsSize;  
        assert(meth->outsSize == 0);  
        assert(meth->insns == NULL);  

        if (dvmIsNativeMethod(meth)) {  
            meth->nativeFunc = dvmResolveNativeMethod;  
            meth->jniArgInfo = computeJniArgInfo(&meth->prototype);  
       }  
    }

我們直接看else中的代碼：

該函數會從dex 文件中解析DexMethod 成dalvik中執行的method,if(pDexCode != NULL) 判斷是否存在dex代碼，看else部分說明,可以知道該部分是dalvik對java native method處理過程。
其中dvmResolveNativeMethod調用了dvmLookupInternalNativeMethod和lookupSharedLibMethod來查找jni中注冊的native函數。 dalvik最後將執行得到的java native函數.

通過上面的代碼片段，我們了解到要對一個java函數進行hook需要步驟有
[1] 把修改method的屬性修改成native
[2] 修改method的registersSize、insSize、nativeFunc、computeJniArgInfo
[3] RegisterNatives注冊目標method的native函數

測試運行

好了，到這裡我們就把代碼都分析完了，原理也說清楚了，下面就開始動手測試了。

從上面我們可以看到在源文件中我們引入了很多系統的頭文件，所以在這裡編譯會報錯的，所以我們需要將這些頭文件拷貝到編譯工程中來，但是在次編譯還是有問題，因為只有頭文件，沒有實現還是報錯的，所以我們需要把頭文件的實現也導入進來，這時候我們就需要去Android系統中拷貝這些so文件了(是對這些頭文件的實現，然後編譯成動態庫so,我們任然可以使用的)。這些so文件是很多的，但是有一個規律的，就是每個so文件的名字是：lib+頭文件名.so。比如AndroidRuntime.h頭文件對應的實現文件：

libandroid_runtime.so，簡單吧，那麼這些so文件我們從哪裡進行拷貝呢？我們可以啟動一個Android模擬器，然後從模擬器的

/system/lib/目錄下進行拷貝：

這裡為了防止出錯，把lib文件夾都拷貝過來了。

下面就可以進行編譯了

看一下Android.mk文件

LOCAL_PATH := $(call my-dir)  

include $(CLEAR_VARS)  

LOCAL_MODULE:= so  

LOCAL_SRC_FILES := so.cpp MethodHooker.cpp  

LOCAL_LDLIBS+=   

LOCAL_CFLAGS    := -I./include/ -I./dalvik/vm/ -I./dalvik -DHAVE_LITTLE_ENDIAN  

LOCAL_LDFLAGS   :=  -L./lib/  -L$(SYSROOT)/usr/lib -llog -ldvm -landroid_runtime  -lart  

LOCAL_STATIC_LIBRARIES := hookart  

LOCAL_SHARED_LIBRARIES :=  
include $(BUILD_SHARED_LIBRARY)  

#------------------------------------------------------------------------  

include $(CLEAR_VARS)  

LOCAL_MODULE:= Test  

LOCAL_SRC_FILES := Test.c  

LOCAL_LDLIBS+= -L./lib -llog  

LOCAL_CFLAGS    := -I./include/ -I./dalvik/vm/ -I./dalvik -fPIC -shared  

LOCAL_SHARED_LIBRARIES :=   

include $(BUILD_SHARED_LIBRARY)  

#------------------------------------------------------------------------  

include $(CLEAR_VARS)  

LOCAL_MODULE:= inject  

LOCAL_SRC_FILES := inject.c shellcode.s  

LOCAL_LDLIBS :=   

LOCAL_CFLAGS :=    

include $(BUILD_EXECUTABLE)

這裡對so.cpp，Test.c，inject.c進行編譯。

看一下so.cpp的編譯模塊

LOCAL_PATH := $(call my-dir)  

include $(CLEAR_VARS)  

LOCAL_MODULE:= so  

LOCAL_SRC_FILES := so.cpp MethodHooker.cpp  

LOCAL_LDLIBS+=   

LOCAL_CFLAGS    := -I./include/ -I./dalvik/vm/ -I./dalvik -DHAVE_LITTLE_ENDIAN  

LOCAL_LDFLAGS   :=  -L./lib/  -L$(SYSROOT)/usr/lib -llog -ldvm -landroid_runtime  -lart  

LOCAL_STATIC_LIBRARIES := hookart  

LOCAL_SHARED_LIBRARIES :=  
include $(BUILD_SHARED_LIBRARY)

我們需要用到的源文件為：so.cpp、MethodHooker.cpp

編譯的過程中我們需要引入的頭文件我們都放到了include文件夾下：

所以寫法很簡單：

LOCAL_CFLAGS    := -I./include/ -I./dalvik/vm/ -I./dalvik -DHAVE_LITTLE_ENDIAN

還有一些頭文件放在dalvik文件夾下

這樣就引入了需要的頭文件

還需要導入so文件路徑：

這裡我把模擬器中的整個lib文件夾都拷貝過來了

LOCAL_LDFLAGS   :=  -L./lib/  -L$(SYSROOT)/usr/lib -llog -ldvm -landroid_runtime  -lart

這樣就可以編譯so.cpp了

後面的Test.c和inject.c編譯方法類似，這裡就不解釋了。

注：這裡其實說到了一種引入系統頭文件的編譯方式，之前在我的另外一篇文章中：

http://blog.csdn.net/jiangwei0910410003/article/details/40949475

在這篇文章中，我用的方式是將so文件拷貝到NDK的目錄中的。

但是這個方式貌似更方便點，而且移植性比較好。本身就是一個項目了，不需要額外的工作就可以編譯這個項目了。

編譯：

項目的下載地址：http://download.csdn.net/detail/jiangwei0910410003/8263113

因為每個人的編譯環境都是不一樣的，所以如果在編譯過程中遇到什麼問題，請給我留言，我盡量幫助解決一下。

編譯工作完成之後，我們應該有三個文件：

inject
libTest.so
libso.so

下面我們需要將這三個文件拷貝到設備的/data/local/目錄下，為什麼要拷貝到這個目錄呢？因為上面代碼中寫的是這個目錄呀。不記得的同學在回過頭去看一下代碼：inject.c中的main函數中以及so.cpp中的Hook函數中

我們先將這三個文件拷貝到指定的磁盤中(這裡我是Q盤)

開始拷貝：

adb push inject /data/local/

adb push libso.so /data/local/

adb push libTest.so /data/local/

在修改一下他們的權限

chmod 777 inject

chmod 777 libso.so

chmod 777 libTest.so

當然我們還可以寫一個簡單的腳本文件一步到位

adb push ..\libs\armeabi\libTest.so  /data/local/  
adb push ..\libs\armeabi\libso.so  /data/local/  
adb push ..\libs\armeabi\inject /data/local/  
adb shell chmod 777 /data/local/inject  
adb shell chmod 777 /data/local/libso.so  
adb shell chmod 777 /data/local/libTest.so  
adb shell su -c /data/local/inject  
pause

保存.bat文件，然後放到編譯項目的目錄下，直接運行即可。

拷貝工作完成了，下面來運行一下Android項目

注意應用的包名為：com.example.testar

這個在inject.c中的main函數中我們寫死了這個，因為這個包名就是進程名，我們需要通過進程名來獲取進程id的。

運行結果：

這時候我們開啟三個終端：

第一個終端：執行inject程序進行注入

./inject

第二個終端：監聽log信息

adb logcat -s LOG

這個log信息是底層打印的結果的

第三個終端：監聽log信息

adb logcat -s DEMO

這時候我們會發現，打印的結果是“haha “，那麼我們就成功了修改了系統返回的Mac地址了。

這個結果其實是底層test函數返回的結果。說明系統在執行getMacAddress()方法的時候，其實調用了我們在底層定義的test函數。

感覺很爽，我們既然可以修改系統返回的一些設備信息了。哈哈！！

同樣的我們可以修改系統返回的IMEI等信息。

我們是將WifiInfo類中的getMacAddress()方法首先變成native方法，然後再將底層的test函數和這個方法進行一一對應進行注冊。

系統在執行這個getMacAddress()方法的時候，發現他是一個native方法，就會去執行其對應的jni函數，所以這裡就做到了通過進程注入來修改系統方法返回的結果。

拓展

上面的例子算是結束了，也達到了我們的需求了，下面在繼續看

上面我們將系統調用的getMacAddress()方法執行的過程轉化成執行test函數了，但是這個test是在底層實現的，現在假如我們想在上層去修改這個具體的返回值，那不能修改一次，就去重新編譯底層項目，然後還有拷貝工作，同時還需要重新注入。這個操作就太復雜了，所以我們需要將這些工作移動到上層應用來。所以我們可以這麼做：

因為在上面的代碼中我們看到即使上層沒有native方法，也可以獲取到JNIEnv對象的，那麼我們還是用這個JNIEnv對象通過反射機制，去獲取調用上層的方法來獲取值。

這裡由於篇幅的原因就不在演示了，代碼實現起來不難。

總結

終於說完了，其實這個問題我早就接觸到了，只是一直沒有時間去解決，今天就有點時間，爭取把他搞定，我之所以說這個問題。原因是現在網上有兩個流行的框架：Xposed和Cydia,他們的作用就是注入到各種進程：

注入到系統進程修改系統的各種api值

注入到用戶進程修改特定方法的返回值，從而做到破解的效果：比如現在又一個游戲金幣的游戲，那麼我只要知道這個游戲金幣的獲取方法，比如是：getMoney()類似的方法，那麼我就可以用這個方法進行注入到這個游戲進程，然後修改這個方法的返回值。那麼就可以獲取到用不完的金幣了，當然這個說起來很容易，當用這個框架去操作的時候，會發現有很多問題的。這個我在後面的文章中會用這個框架進行操作的。

那麼我現在想說的是：其實這兩個框架的實現原理就是我今天講的這種方式實現的，只是上面的兩個框架在效率上比我這個好多了，優化工作也做的很好。我說了這篇文章就是想去解析他的原理。

如果你想去替換一個進程中運行的api：

將這個api方法變成native的，然後在用一個方法將其進行注冊

原因就是虛擬機在運行的時候，發現這個api方法如果是native的話，就去執行它注冊之後的那個jni方法了。

在這篇文章中我們學習到了幾個知識點：

1、如何將一個非native方法變成一個native方法

2、如何手動的去注冊一個native方法

3、學會了使用另外的一種編譯項目的方式(引入頭文件)

4、注入進程的相關知識