Android 逆向/反编译/Hook修改应用行为基础实现

前言：本文通过一个简单的情景案例实现安卓逆向的基本操作

一、情景描述

本文通过一个简单的情景案例来实现安卓逆向的基本操作。在这个案例中所使用的项目程序是我自己的Demo程序，不会造成任何的财产侵害，本文仅作为日常记录及案例分享。
实现步骤大致如下：
反编译APK获取源码 → 源码分析 → 目标设备运行Frida服务(需要root权限) → 使用Python编写hook注入程序 / 编写hook脚本 → 执行程序

二、前置准备

整个流程中需要做的准备工作大致有以下几点：

1. 反编译工具

当前流行的反编译工具有许多种，例如：APKTool、JADX、JD-GUI 等等。反编译的主要目的是查看app的源码分析app的运作流程从而快速制定出所需的hook脚本，因此挑选一款适合自己的即可。不过需要注意的是：并非所有的apk包都能够反编译成功，虽然技术上大多数 APK 文件都能被反编译，但反编译的难度和完整性可能会因应用的保护措施而有所不同。具体来说，有些 APK 文件通过加固、混淆、加密等手段提高了反编译的难度，甚至可能在某些情况下完全避免了反编译的效果，由于我的案例使用的是自己的源码所以不需要考虑这一步，那就以 JADX 作为案例吧。

安装JADX

直接到github仓库下载打好的包即可，可以直接下载带UI的版本，简单易用，不过要注意系统已经有了JRE环境，如果没有的话也可以下载下方的带jre版本 https://github.com/skylot/jadx/releases

反编译APK包

直接把文件拖拽到框内即可

2. Python环境

需要用到 Python 进行脚本程序编写及运行
Python 环境安装：直接官网下载傻瓜式一键安装即可 https://www.python.org/downloads/
PyCharm 编辑器安装：同上，下载社区版(Community)就够了 https://www.jetbrains.com.cn/en-us/pycharm/download/?section=windows

3. 安装 Frida

Frida 有两部分，frida-tools以python程序为载体运行在本地并执行hook脚本，frida-server则需要在目标设备端运行并进行动态分析和hook操作
安装 frida-tools：安装frida-tools需要用到pip因此先确保python环境安装成功并设置好环境变量。在命令提示符中直接输入以下指令等待安装完成即可：pip install frida-tools
下载完成后输入指令判断是否安装成功：frida --version
如果成功返回了版本号则表示安装成功了，记住这个版本号后续还要用到

下载 frida-server：直接到github仓库下载打好的包即可 https://github.com/frida/frida/releases
注意下载的版本要frida-tools相匹配，另外还需要注意的是server的系统平台和cpu架构版本也要选对，他的命名规则是：frida-server-版本号-支持系统-CPU架构.扩展名，我需要在用到Android系统上使用因此我把对应的所有android server包都下载下来

4. 具有 root 权限的设备

由于现在的厂商真机获取 root 权限越来越困难，使用真机调试的成本较高因此选择模拟器作为android端设备载体，我在案例中使用的是夜神模拟器，直接官网安装即可 https://www.yeshen.com/ 安装完成后在设置中开启root权限即可

三、运行 hook 程序，修改应用行为

1. 启动 frida-server

启动frida-server前要先将server文件导入目标设备的 /data/local/tmp/ 目录中，执行命令修改可执行权限并运行，这里需要注意的一点是要确保目标设备的cpu架构与server文件相对应，夜神模拟器的cpu架构是x86_64因此我们选用这个即可

解压server文件

选择之前下载好的server压缩包文件并解压

导入/启动 server 文件

直接在路径栏中输入"cmd"回车进入当前命令提示符

依次执行以下指令：
输入 "adb devices" 指令查询当前已连接设备确定模拟器设备已经连接成功
输入 "adb push frida-server-16.5.7-android-x86_64 /data/local/tmp/" 指令将 frida-server 导入tmp目录，注意这里的要根据你的server文件名修改一下
等待导入完成，输入 "adb shell" 进入设备指令操作
输入 "su" 切换root权限
输入 "cd /data/local/tmp/" 进入tmp目录
输入 "ls -l" 查询当前目录下的文件信息，此时我们可以看到刚才导入进去的server文件，他的特征为rw-并没有可执行权限
输入 "chmod 777 frida-server-16.5.7-android-x86_64" 设置用户权限开启可执行
再次输入 "ls -l" 查询当前目录下的文件信息，此时我们可以看到文件特征变为rwx，可以执行
输入 "./frida-server-16.5.7-android-x86_64" 启动 frida-server，启动后光标换行没有任何提升，表示已经启动成功 server 正在运行中，注意不要关闭提示符窗口

2. 验证 frida 连接

打开 PyCharm，新建py文件，导入frida包，根据app包名启动指定进程，这一步先做连接验证，不注入hook脚本

import frida
import sys


def on_message(message, data):
    """
    回调函数，处理 Frida 发回的消息。
    """
    if message['type'] == 'send':
        print(f"[+] {message['payload']}")
    elif message['type'] == 'error':
        print(f"[!] {message['stack']}")

def main():
    print("执行任务")
    try:
        print(f"[!] {frida.__version__}")
        # 连接到 Android 设备
        device = frida.get_usb_device(timeout=5)

        # 查找目标进程
        pid = device.spawn(["com.lxt.single_module"]) # 注意，这里要改为你需要hook的程序包名
        session = device.attach(pid)

        # 加载 Hook 脚本
        # script = session.create_script(HOOK_SCRIPT_1)
        # script.on('message', on_message)  # 设置消息回调
        # script.load()

        # 恢复进程
        device.resume(pid)
        print("[*] Hook 脚本已加载，应用正在运行...")

        # 保持脚本运行状态
        sys.stdin.read()
    except Exception as e:
        print(f"[!] 错误: {e}")

if __name__ == "__main__":
    main()

运行程序观察日志及模拟器，程序运行之后模拟器会自动调起对应的程序，如果日志中没有报错或退出则表示连接成功

3. hook 改变方法执行效果

改变一个简单的方法返回数据

假设我在 MainActivity 中有个简单的方法，该方法固定返回一个boolean类型数据"true"

fun testBool():Boolean{return true}

设置某个测试按键的点击事件为log这个方法返回的结果

viewBinding.test5.onClick {
    Log.e(TAG, "click result:${testBool()}")
}

点击结果

那么这时我们可以编写一个简单的hook脚本去注入修改这个方法的返回数据

创建Java.perform方法并在作用域中实现需要执行的脚本细节，Java.perform 是 Frida 提供的一个用于在 Java 虚拟机中执行代码的方法。它确保在 Java 环境完全加载并且可以安全地访问 Java 类和方法后执行给定的回调函数。所有的 Java hooking 操作都需要在这个回调内进行

Java.perform(function() {

}

我们需要hook的方法是在MainActivity中，因此我们要做的第一个操作就是获取到这个对象的引用，我们可以使用Java.use()方法来获取。通过Java.use()拿到的引用你可以访问该类的方法和字段或者修改这些方法的实现，但前提是必须要知道这个需要加载的类的完整路径，这个路径我们可以通过反编译的源码中获取

var MainActivity = Java.use("com.lxt.single_module.Activity.MainActivity");

拿到 MainActivity 中 testBool 方法的引用，强制其返回一个"false"

MainActivity.testBool.implementation = function() {
    console.log("testBool 被 Hook，强制返回 false");
    // 强制返回 false
    return false;
};

完整代码

import frida
import sys

HOOK_SCRIPT_1 = """
Java.perform(function() {
    var MainActivity = Java.use("com.lxt.single_module.Activity.MainActivity");
    
    // Hook MainActivity 中的 testBool 方法
    MainActivity.testBool.implementation = function() {
        console.log("testBool 被 Hook，强制返回 false");
        
        // 强制返回 false
        return false;
    };
    
});
"""

# Python 代码
def on_message(message, data):
    """
    回调函数，处理 Frida 发回的消息。
    """
    if message['type'] == 'send':
        print(f"[+] {message['payload']}")
    elif message['type'] == 'error':
        print(f"[!] {message['stack']}")

def main():
    print("执行任务1")
    try:
        print(f"[!] {frida.__version__}")
        # 连接到 Android 设备
        device = frida.get_usb_device(timeout=5)

        # 查找目标进程
        pid = device.spawn(["com.lxt.single_module"])
        session = device.attach(pid)

        # 加载 Hook 脚本
        script = session.create_script(HOOK_SCRIPT_1)
        script.on('message', on_message)  # 设置消息回调
        script.load()

        # 恢复进程
        device.resume(pid)
        print("[*] Hook 脚本已加载，应用正在运行...")

        # 保持脚本运行状态
        sys.stdin.read()
    except Exception as e:
        print(f"[!] 错误: {e}")


if __name__ == "__main__":
    main()

执行程序注入hook脚本，此时再次点击测试按键就会触发hook方法
观察日志hook方法被触发，app中的testBool方法返回结果为false

改变应用行为

这里我们用一个相对较接近实际应用的情景作为案例吧
假设：我们需要在MainActivity中请求某个api再根据api的结果决定是否需要跳转到另一个指定页面
如果：我们需要绕过这个api，让程序无需根据api的请求结果而必定跳转到这个指定的页面
那么：我们可以直接hook这个请求api的方法让它必定返回一个可以让页面跳转的结果

代码情景：
点击测试按键后使用ViewModel调取请求方法，再根据请求方法返回的结果判断是否需要执行页面跳转

viewBinding.test4.onClick {
    lifecycleScope.launch {
        var login_result = viewModel.testLogin()
        Log.e(TAG,"request result:${login_result}")
        if(login_result){
            Log.e(TAG, "登陆成功")
            startActivity(Intent(this@MainActivity, SucceedActivity::class.java))
        }else{
            Log.e(TAG, "登陆失败")
        }
    }
}

正常执行结果

根据方法的执行流程去编写 hook 脚本

在这个流程中最为关键的一步就是需要根据ViewModel请求方法的结果判断是否需要进行页面跳转，那么我们只要在ViewModel对象初始化之后拿到它的引用再hook它的请求方法，让这个方法的返回结果必定为true就好了
在我的Activity框架中ViewModel是在名为"initData"的抽象方法中初始化，并且在子类实现时必须要调用super.initData()在基类中执行反射自动初始化

override fun initData() {
    super.initData()  // 在父类初始化 viewModel
    // 执行其它任务
    rxPermissions = RxPermissions(this)
    check_permission()
    registerScreenListen()
}

由此可知：我们只需要获取到MainActivity的initData方法引用，并在执行它原本的super.initData()方法之后拿到已经初始化的ViewModel对象引用并修改请求api的方法让它必定返回一个true

拿到initData方法引用并执行它的的super方法

MainActivity.initData.implementation = function() {
    console.log("initData 被 Hook");
    // 调用原始的 initData 方法
    this.initData();
};

在执行完super方法后通过 Java.choose() 方法来获取已实例化的ViewModel对象，Java.choose 方法可以用于遍历已加载的类的所有实例，并执行指定的回调函数。

Java.choose("com.lxt.single_module.Activity.MainActivity", {
    onMatch: function(instance) {
        var viewModel = instance.viewModel.value;
    },
    onComplete: function() {}
});

获取到ViewModel对象之后修改 testLogin 方法为必定返回 true

if (viewModel) {
    console.log("成功获取到 viewModel");
    // 检查 viewModel 是否为 MainVM 的实例
    if (viewModel.$className === "com.lxt.single_module.ViewModel.MainVM") {
        console.log("viewModel 是 MainVM 的实例");
        // Hook testLogin 方法
        MainVM.testLogin.implementation = function() {
            console.log("testLogin 被 Hook，返回 true");
            return Java.use("java.lang.Boolean").valueOf(true);;
        };
    } else {
    console.log("viewModel 不是 MainVM 的实例");
    }
} else {
    console.log("viewModel 为 null");
}

完整代码

import frida
import sys

HOOK_SCRIPT_1 = """
Java.perform(function() {

    var MainActivity = Java.use("com.lxt.single_module.Activity.MainActivity");
    var MainVM = Java.use("com.lxt.single_module.ViewModel.MainVM");  // 请确保这是正确的包名和类名
    
    MainActivity.initData.implementation = function() {
        console.log("initData 被 Hook");
        
        // 调用原始的 initData 方法
        this.initData();
        
        Java.choose("com.lxt.single_module.Activity.MainActivity", {
                onMatch: function(instance) {
                    var viewModel = instance.viewModel.value;
                    if (viewModel) {
                        console.log("成功获取到 viewModel");
                        
                        // 检查 viewModel 是否为 MainVM 的实例
                        if (viewModel.$className === "com.lxt.single_module.ViewModel.MainVM") {
                            console.log("viewModel 是 MainVM 的实例");
                            
                            // Hook testLogin 方法
                            MainVM.testLogin.implementation = function() {
                                console.log("testLogin 被 Hook，返回 true");
                                return Java.use("java.lang.Boolean").valueOf(true);;
                            };
                        } else {
                            console.log("viewModel 不是 MainVM 的实例");
                        }
                    } else {
                        console.log("viewModel 为 null");
                    }
                },
                onComplete: function() {}
            });
    };
    
    // Hook MainActivity 中的 testBool 方法
    MainActivity.testBool.implementation = function() {
        console.log("testBool 被 Hook，强制返回 false");
        // 强制返回 false
        return false;
    };
    
});
"""

# Python 代码
def on_message(message, data):
    """
    回调函数，处理 Frida 发回的消息。
    """
    if message['type'] == 'send':
        print(f"[+] {message['payload']}")
    elif message['type'] == 'error':
        print(f"[!] {message['stack']}")

def main():
    print("执行任务")
    try:
        print(f"[!] {frida.__version__}")
        # 连接到 Android 设备
        device = frida.get_usb_device(timeout=5)

        # 查找目标进程
        pid = device.spawn(["com.lxt.single_module"])
        session = device.attach(pid)

        # 加载 Hook 脚本
        script = session.create_script(HOOK_SCRIPT_1)
        script.on('message', on_message)  # 设置消息回调
        script.load()

        # 恢复进程
        device.resume(pid)
        print("[*] Hook 脚本已加载，应用正在运行...")

        # 保持脚本运行状态
        sys.stdin.read()
    except Exception as e:
        print(f"[!] 错误: {e}")


if __name__ == "__main__":
    main()

再次运行脚本并点击测试按键

触发脚本，绕过api请求步骤执行页面跳转