android Hook 技术剖析

本代码实现的功能：

如何不在清单文件中注册activity就可直接运行使用。

其原理就是使用HOOK技术。

先看清单文件代码：

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.test_hook"
    android:versionCode="1"
    android:versionName="1.0" >

    <uses-sdk
        android:minSdkVersion="19"
        android:targetSdkVersion="21" />

    <application
        android:allowBackup="true"
        android:icon="@drawable/ic_launcher"
        android:label="@string/app_name"
        android:name=".MyApplication"
        android:theme="@style/AppTheme" >
        <activity
            android:name=".MainActivity"
            android:label="@string/app_name" >
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
        <activity android:name=".ProxyActivity" />
    </application>

</manifest>

其中 ProxyActivity是代理类，我们实现的功能是从MainActivity通过intent跳转到OtherActivity

内部代码为：

public class ProxyActivity extends Activity {}

再来看一下MainActivity代码：

public class MainActivity extends Activity {

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

	
	public void startOther(View v){
		Toast.makeText(this, "onclick", 0).show();
		Intent intent = new Intent(this, OtherActivity.class);
		startActivity(intent);
	}
}

工具类HookAmsUtil用来实现具体功能（简单做了一些注释）：

package com.example.test_hook;
/**
 * 原理：
 * 当从MainActivity通过intent启动OtherActivity时，会先通过ActivityManagerService调用StartActivity方法来执行，然后会通过PackageManagerService
   来检测intent是否有效，有效则通过ActivityThread继续执行，无效则抛出异常,我们要做的就是启动Activity时绕过PackageManagerService的检测.
 * 
 * */

import java.lang.reflect.Field;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.os.Handler;
import android.os.Message;
import android.util.Log;

public class HookAmsUtil {
	
	private Class<?> proxyActivity;
	private Context context;
	
	public HookAmsUtil	(Class<?> proxyActivity, Context context) {
		this.proxyActivity = proxyActivity;
		this.context = context;
	}
	
	public void hookAms() throws Exception {
		Log.d("qcdd", "start hook");
		Class<?> forname = Class.forName("android.app.ActivityManagerNative");
		Field defaultField = forname.getDeclaredField("gDefault");
		defaultField.setAccessible(true);
		//dDefault 变量值
		Object degaultValue = defaultField.get(null);  //拿到ActivityManagerNative类的gDefault属性
		//反射SingleTon
		Class<?> forname2 = Class.forName("android.util.Singleton");
		Field instanceField = forname2.getDeclaredField("mInstance");
		instanceField.setAccessible(true);
		//获取系统的iActivityManager对象
		Object iActivityManagerObject = instanceField.get(degaultValue); //获取IActivityManager对象
		//hook
		Class<?> iActivityManagerInercept = Class.forName("android.app.IActivityManager"); //IActivityManager接口
		AmsInvocationHandler handler = new AmsInvocationHandler(iActivityManagerObject); //将IActivityManager对象传代理handler
		
		/**
		 * newProxyInstance参数解析
		 * classLoader:　 一个ClassLoader对象，定义了由哪个ClassLoader对象来对生成的代理对象进行加载
           interfaces:　  一个Interface对象的数组，表示的是我将要给我需要代理的对象提供一组什么接口，如果我提供了一组接口给它，那么这个代理对象就宣
           　　　　　　　　　称实现了该接口(多态)，这样我就能调用这组接口中的方法了
           invocationHandler:　一个InvocationHandler对象，表示的是当我这个动态代理对象在调用方法的时候，会关联到哪一个InvocationHandler对象上
		 * */
		Object proxy = Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(),
				new Class<?>[]{iActivityManagerInercept}, handler);  //创建代理
		instanceField.set(degaultValue, proxy); //将原iActivityManager,替换成代理的proxy，它也属于IActivityManager类型．
		
	}
	
	class AmsInvocationHandler implements InvocationHandler{
		/**
		 * InvocationHandler类
		 * 每一个动态代理类都必须要实现InvocationHandler这个接口，并且每个代理类的实例都关联到了一个handler，当我们通过代理对象调用一个方法的时候，
		 * 这个方法的调用就会被转发为由InvocationHandler这个接口的 invoke 方法来进行调用。
		 * */
		private Object iActivityManagerObject;
		public AmsInvocationHandler(Object iActivityManagerObject) {
			this.iActivityManagerObject = iActivityManagerObject;
		}
		
		@Override
		public Object invoke(Object proxy, Method method, Object[] args)
				throws Throwable {
			Log.d("qcdd", "methodName: "+ method.getName());
			//当ActivityManagerService调用方法时先会掉此invoke方法．
			if("startActivity".contains(method.getName())){
				Intent intent = null;
				int index = 0;
				for (int i = 0; i < args.length; i++) {
					if (args[i] instanceof Intent) {
						//说明找到了startActivity方法的intnet参数
						intent = (Intent) args[i];//原意图，过不了安检
						index = i;
						break;
					}
				}
				Intent proxyIntent = new Intent();
				ComponentName componentName = new ComponentName(context, proxyActivity);
				proxyIntent.setComponent(componentName);
				proxyIntent.putExtra("oldIntent", intent);
				args[index] = proxyIntent;
				return method.invoke(iActivityManagerObject, args); //替换后继续向下执行
			}
			return method.invoke(iActivityManagerObject, args);
		}
	}
	
	public void hookSystemHandler() throws Exception {
		
		/**
		 * ActivityThread 代表了Android的主线程,具体启动Activity、service，接收广播等等工作就在此类中
		 * final H mH = new H()
		 * 这个H是继承自Handler的,它是个私有的内部类，其实就是主线程的Handler，通过这个Handler就可以往主线程的消息队列发消息,(所以我们要hook此类)
		 * 具体处理动作是在，public void handleMessage(Message msg) {}方法中
		 * 
		 * public void handleMessage(Message msg) {
            switch (msg.what) {
                case LAUNCH_ACTIVITY: {　//启动activity
                    Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityStart");
                    final ActivityClientRecord r = (ActivityClientRecord) msg.obj;
                    r.packageInfo = getPackageInfoNoCheck(r.activityInfo.applicationInfo, r.compatInfo);
                    handleLaunchActivity(r, null, "LAUNCH_ACTIVITY");
                    Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
                } break;
		 * 
		 * */
		Class<?> forName = Class.forName("android.app.ActivityThread");
		Field currentActivityThreadField = forName.getDeclaredField("sCurrentActivityThread");
		currentActivityThreadField.setAccessible(true);
		Object activityThreadValue = currentActivityThreadField.get(null); //sCurrentActivityThread 当前的进程
		
		Field handlerField = forName.getDeclaredField("mH");
		handlerField.setAccessible(true);
		//mH的变量值
		Handler handlerObject = (Handler) handlerField.get(activityThreadValue); //当前的进程handler
		Field callbackField = Handler.class.getDeclaredField("mCallback");
		callbackField.setAccessible(true);
		callbackField.set(handlerObject, new ActivityThreadHandlerCallback(handlerObject)); //将当前进程handler替换成代理ActivityThreadHandlerCallback
		
	}
	
	class ActivityThreadHandlerCallback implements Handler.Callback {
		
        Handler handler;
        public ActivityThreadHandlerCallback (Handler handler) {
        	super();
        	this.handler = handler;
        }
		@Override
		public boolean handleMessage(Message msg) {
			//当ActivityThread的handler发送消息时会先调用此handleMessage方法．
			Object obj = msg.obj; 
			/**
			 * 此obj对象是ActivityClientRecord类型
			 * ActivityClientRecord是ActivityThread的内部类，用来记录activity的相关属性
			 * 
			 * IBinder token;
        	　　int ident;
       　　　　　Intent intent;　//我们用到的就是这个属性
        	　　String referrer;
        	　　IVoiceInteractor voiceInteractor;
        	　　Bundle state;
        	　　PersistableBundle persistentState;
        	　　Activity activity;
        	　　Window window;
        	　　Activity parent;
        	　　String embeddedID;
        	　　Activity.NonConfigurationInstances lastNonConfigurationInstances;
        	　　boolean paused;
        	　　boolean stopped;
        	　　boolean hideForNow;
        	　　.........
			 * 
			 * */
			try {
				Field intentField = obj.getClass().getDeclaredField("intent");
				intentField.setAccessible(true);
				Intent proxyIntent = (Intent) intentField.get(obj); //proxyIntent
				Intent realIntent = proxyIntent.getParcelableExtra("oldIntent");
				if (realIntent != null) {
					proxyIntent.setComponent(realIntent.getComponent()); //将真正要启动的intent替换过来
				}
			} catch (Exception e) {
				e.printStackTrace();
			}
			return false;
		}
		
	}
	
}

具体的调用来看一下MyApplication的调用：

public class MyApplication extends Application {
    private static AmsInvocationHandler handler;
    private Object activityThreadValueObject;
	@Override
	public void onCreate() {
		// TODO Auto-generated method stub
		super.onCreate();
		HookAmsUtil mHookAmsUtil = new HookAmsUtil (ProxyActivity.class,this);
		try {
			mHookAmsUtil.hookAms();
			mHookAmsUtil.hookSystemHandler();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

}

OK，功能已实现。