简述
要启动未注册的Activity主要是要逃避AMS的检测，思路是，检测前要启动的Activity换成注册的，检测通过了，再在启动前换回来。这里主要是两个点。检测前，hookAMS。检测后hookHandler。hook点有很多尽量找静态变量、单例和public
hookAMS
1、android 11举例，启动acitivty是在ATMS中（11之前是AMS，这个自己可以去适配）
2、拿到ATMS的代理。
3、然后ATMS整个动态代理在startActivity之前将Intent 偷梁换柱
4、换成已经注册的Activity之后记得原目标Acitivty存起来，在骗完AMS之后换回来
public static void hookAMS() {
// 10之前
try {
Class<?> clazz = Class.forName("android.app.ActivityTaskManager");
Field singletonField = clazz.getDeclaredField("IActivityTaskManagerSingleton");
singletonField.setAccessible(true);
Object singleton = singletonField.get(null);
Class<?> singletonClass = Class.forName("android.util.Singleton");
Field mInstanceField = singletonClass.getDeclaredField("mInstance");
mInstanceField.setAccessible(true);
Method getMethod = singletonClass.getMethod("get");
Object mInstance = getMethod.invoke(singleton);
Class IActivityTaskManagerClass = Class.forName("android.app.IActivityTaskManager");
Object mInstanceProxy = Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(),
new Class[]{IActivityTaskManagerClass}, new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
if ("startActivity".equals(method.getName())) {
int index = -1;
// 获取 Intent 参数在 args 数组中的index值
for (int i = 0; i < args.length; i++) {
if (args[i] instanceof Intent) {
index = i;
break;
}
}
// 生成代理proxyIntent -- 孙悟空（代理）的Intent
Intent proxyIntent = new Intent();
// 这个包名是宿主的
proxyIntent.setClassName("com.leo.amsplugin",
ProxyActivity.class.getName());
// 原始Intent能丢掉吗？保存原始的Intent对象
Intent intent = (Intent) args[index];
proxyIntent.putExtra(TARGET_INTENT, intent);
// 使用proxyIntent替换数组中的Intent
args[index] = proxyIntent;
}
// 原来流程
return method.invoke(mInstance, args);
}
});
// 用代理的对象替换系统的对象
mInstanceField.set(singleton, mInstanceProxy);
} catch (Exception e) {
e.printStackTrace();
}
}
hookHandler
hookAMS完成，欺骗了AMS，接下来要把Intent中的原目标扶起回正位，
启动Activity要用handler，我们从这里hook吧
1、Activtiy thread 中的handler用来启动activity class H extends Handler
2、handlerMessage中的EXECUTE_TRANSACTION(159)来启动activity
3、
final ClientTransaction transaction = (ClientTransaction) msg.obj;–包含Intent
mTransactionExecutor.execute(transaction);–执行启动
launchActivityItem中有Intent，而ta继承于ClientTransactionItem，而ClientTransaction中包含List<ClientTransactionItem>
4、所以我只要拿到msg就可以拿到Intent。
msg.obj –> ClientTransaction –> List mActivityCallbacks(LaunchActivityItem)
–> private Intent mIntent 替换
5、handlerMessage(MSG)之前有个callback也可以拿到msg。则会callback是一个接口，如果重写这个接口可就可重新handlerMessage这个方法，然后操作msg。
6、ActivityThread当中，Handler的构建没有传参数。
...//去ActivityThread.java里看
@UnsupportedAppUsage
final H mH = new H();
...
class H extends Handler //也没写构造方法
...//去Handler.java里看
@Deprecated
public Handler() {
this(null, false);
}
7、实际上callback是看，那么我自己替换系统的call就可以啦
8、那我通过反射拿Handler中的mCallback，
public void hoodHandler() {
try {
Class<?> clazz = Class.forName("android.app.ActivityThread");
Field activityThreadField = clazz.getDeclaredField("sCurrentActivityThread");
activityThreadField.setAccessible(true);
Object activityThread = activityThreadField.get(null);
Field mHField = clazz.getDeclaredField("mH");
mHField.setAccessible(true);
final Handler mH = (Handler) mHField.get(activityThread);
Field mCallbackField = Handler.class.getDeclaredField("mCallback");
mCallbackField.setAccessible(true);
mCallbackField.set(mH, new Handler.Callback() {
@Override
public boolean handleMessage(Message msg) {
switch (msg.what) {
case 159:
// msg.obj = ClientTransaction
try {
// 获取 List<ClientTransactionItem> mActivityCallbacks 对象
Field mActivityCallbacksField = msg.obj.getClass()
.getDeclaredField("mActivityCallbacks");
mActivityCallbacksField.setAccessible(true);
List mActivityCallbacks = (List) mActivityCallbacksField.get(msg.obj);
for (int i = 0; i < mActivityCallbacks.size(); i++) {
// 打印 mActivityCallbacks 的所有item:
//android.app.servertransaction.WindowVisibilityItem
//android.app.servertransaction.LaunchActivityItem
// 如果是 LaunchActivityItem，则获取该类中的 mIntent 值，即 proxyIntent
if (mActivityCallbacks.get(i).getClass().getName()
.equals("android.app.servertransaction.LaunchActivityItem")) {
Object launchActivityItem = mActivityCallbacks.get(i);
Field mIntentField = launchActivityItem.getClass()
.getDeclaredField("mIntent");
mIntentField.setAccessible(true);
Intent proxyIntent = (Intent) mIntentField.get(launchActivityItem);
// 获取启动插件的 Intent，并替换回来
Intent intent = proxyIntent.getParcelableExtra(TARGET_INTENT);
if (intent != null) {
mIntentField.set(launchActivityItem, intent);
}
}
}
} catch (Exception e) {
e.printStackTrace();
}
break;
}
return false;
}
});
} catch (Exception e) {
e.printStackTrace();
}
}
总结
一个分为两步
1、hookAMS主要就是逃避ams检测,让ams检测的是一个已经注册了的activity。
2、hookHandler在生成activity之前再把activity换回来。
所以一定要熟悉动态代理，反射和Activity的启动流程。
主要通过hook，核心在于hook点
插桩
1、尽量找 静态变量 单利
2、public
动态代理
AMS检测之前我改下
