android逆向开发之Frida逆向基础_android逆向 frida

Frida是一款功能强大的动态分析和逆向工程工具，可用于在运行时修改和监控应用程序。它支持多个平台，包括Android、iOS、Windows、macOS等，提供了JavaScript API，使用户能够在目标应用程序中直接执行自定义的脚本代码。

基础知识

1. 安装Frida：首先，你需要安装Frida框架。你可以在Frida官方网站（https://frida.re）上找到安装指南和相关文档。安装过程根据不同的操作系统和平台有所不同。
2. 连接Frida：在逆向工程之前，你需要将Frida连接到目标设备或模拟器上的应用程序。Frida提供了多种连接方式，如USB、网络、本地进程等。你可以使用Frida提供的命令行工具或编写自定义脚本来与目标应用程序建立连接。
3. 编写脚本：使用Frida时，你需要编写JavaScript脚本来执行特定的逆向操作。Frida的JavaScript API提供了一系列函数和方法，用于与目标应用程序进行交互、修改和监控其行为。你可以使用脚本来修改函数参数、替换函数实现、修改内存数据等。

脚本示例：以下是一个简单的Frida脚本示例，用于替换目标应用程序中的特定函数：
Java.perform(function() {
    var targetClass = Java.use('com.example.TargetClass');
 
    targetClass.targetFunction.implementation = function() {
        // 在这里写入你想要替换的自定义代码逻辑
        console.log('调用了目标函数');
        return this.targetFunction();
    }
});
1
2
3
4
5
6
7
8
9
10

上述脚本使用了Frida的Java.perform方法来获取目标类和函数，然后使用implementation属性替换了目标函数的实现。在替换的代码逻辑中，你可以执行自定义的操作。

1. 运行脚本：当你编写好脚本后，可以使用Frida提供的命令行工具或编写一个运行脚本的主机程序来执行脚本。执行脚本后，Frida会与目标应用程序建立连接，并在运行时执行你编写的逆向操作。

Frida逆向基础内容

构造函数

在Frida中，构造函数通常与目标应用程序中的特定类相关联。通过修改构造函数，你可以在对象实例化的时候修改其行为或属性。下面是一些在Frida中使用构造函数的基础知识：

1. 获取构造函数：首先，你需要使用Frida的相关API来获取目标应用程序中特定类的构造函数。可以使用Java.use(className)方法获取对应类的引用，并使用$init属性获取构造函数。
2. 修改构造函数：一旦获得了构造函数，你可以使用implementation属性修改其实现。通过替换构造函数的实现，你可以在对象实例化时执行自定义的操作或修改属性。
3. 调用原始构造函数：在修改构造函数的实现时，你通常会希望调用原始构造函数来确保对象的正常初始化。可以使用this.$init(…arguments)来调用原始构造函数，并传递正确的参数。

下面是一个示例，展示了在Frida中修改构造函数的操作：

Java.perform(function() {
    var targetClass = Java.use('com.example.TargetClass');
​
    targetClass.$init.implementation = function(param1, param2) {
        // 执行自定义操作
        console.log('自定义构造函数');
​
        // 调用原始构造函数
        this.$init(param1, param2);
    }
});
1
2
3
4
5
6
7
8
9
10
11

在上述示例中，我们获取了com.example.TargetClass的构造函数$init。然后，使用implementation属性替换了构造函数的实现。在修改的实现中，我们执行自定义的操作，然后调用了原始构造函数来确保对象的正常初始化。

数组

在Frida中，对数组进行逆向工程的基础操作包括获取数组长度、访问数组元素和修改数组元素。下面是一些示例代码，展示了在Frida中对数组进行操作的方法：

获取数组长度：

Java.perform(function() {
    var targetArray = Java.use('[Ljava.lang.String;'); // 替换为目标数组类型
​
    // 打印数组长度
    var arrayLength = targetArray.length;
    console.log('数组长度:', arrayLength);
});
1
2
3
4
5
6
7

在上面的示例中，我们获取了一个名为targetArray的数组的引用，并使用length属性获取了数组的长度。

访问数组元素：

Java.perform(function() {
    var targetArray = Java.use('[Ljava.lang.String;'); // 替换为目标数组类型
​
    // 访问数组元素
    var element = targetArray[0]; // 获取索引为0的元素
    console.log('数组元素:', element);
});
1
2
3
4
5
6
7

在上面的示例中，我们获取了一个名为targetArray的数组的引用，并使用索引操作符[]访问了数组中的元素。

修改数组元素：

Java.perform(function() {
    var targetArray = Java.use('[Ljava.lang.String;'); // 替换为目标数组类型
​
    // 修改数组元素
    targetArray[0] = 'Modified element'; // 修改索引为0的元素
    console.log('修改后的数组元素:', targetArray[0]);
});
1
2
3
4
5
6
7

在上面的示例中，我们获取了一个名为targetArray的数组的引用，并使用索引操作符[]修改了数组中的元素。

请注意，上述示例代码中的数组类型为[Ljava.lang.String;，你需要根据目标应用程序中实际的数组类型进行替换。

通过上述操作，你可以在Frida中对数组进行基本的访问和修改。你还可以根据具体需求使用数组相关的方法，如push()、pop()、slice()等。

对象

在Frida中进行逆向工程时，我们经常需要处理对象。下面是一些基本的操作示例，展示了如何在Frida中获取和修改对象的属性、调用对象的方法以及创建新的对象。

获取对象属性：

Java.perform(function() {
    var targetObject = Java.use('com.example.TargetObject'); // 替换为目标对象的类名
​
    // 获取对象属性值
    var propertyValue = targetObject.propertyName.value; // 替换为目标属性的名称
    console.log('属性值:', propertyValue);
});
1
2
3
4
5
6
7

在上面的示例中，我们获取了一个名为targetObject的对象的引用，并使用.操作符获取了对象的属性值。

修改对象属性：

Java.perform(function() {
    var targetObject = Java.use('com.example.TargetObject'); // 替换为目标对象的类名
​
    // 修改对象属性值
    targetObject.propertyName.value = 'Modified value'; // 替换为目标属性的名称和修改后的值
    console.log('修改后的属性值:', targetObject.propertyName.value);
});
1
2
3
4
5
6
7

在上面的示例中，我们获取了一个名为targetObject的对象的引用，并使用.操作符修改了对象的属性值。

调用对象方法：

Java.perform(function() {
    var targetObject = Java.use('com.example.TargetObject'); // 替换为目标对象的类名
​
    // 调用对象方法
    var result = targetObject.methodName(arguments); // 替换为目标方法的名称和参数
    console.log('方法返回值:', result);
});
1
2
3
4
5
6
7

在上面的示例中，我们获取了一个名为targetObject的对象的引用，并使用.操作符调用了对象的方法。

创建新对象：

Java.perform(function() {
    var targetClass = Java.use('com.example.TargetClass'); // 替换为目标类名
​
    // 创建新对象
    var newObj = targetClass.$new();
    console.log('新对象:', newObj);
});
1
2
3
4
5
6
7

在上面的示例中，我们使用$new()方法创建了一个名为newObj的新对象。

请注意，在上述示例代码中，你需要将com.example.TargetObject、propertyName、methodName等替换为目标应用程序中实际的类和属性/方法名称。

Map

在Frida中逆向基础中，Map是一种常用的数据结构，用于在键值对之间进行映射。在逆向工程中，我们可以使用Frida来获取、修改和操作Map对象。下面是一些基本操作示例：

获取Map对象中的键值对：

Java.perform(function() {
    var targetMap = Java.use('java.util.Map'); // 替换为目标Map对象的类名
​
    // 获取Map对象中的键值对
    var entrySet = targetMap.entrySet();
    var iterator = entrySet.iterator();
    while (iterator.hasNext()) {
        var entry = iterator.next();
        var key = entry.getKey();
        var value = entry.getValue();
        console.log('键:', key, ' 值:', value);
    }
});
1
2
3
4
5
6
7
8
9
10
11
12
13

在上面的示例中，我们获取了一个名为targetMap的Map对象的引用，并使用.entrySet()方法获取所有键值对的集合。然后，我们使用迭代器遍历集合，并分别获取每个键值对的键和值。

修改Map对象中的键值对：

Java.perform(function() {
    var targetMap = Java.use('java.util.Map'); // 替换为目标Map对象的类名
​
    // 修改Map对象中的键值对
    targetMap.put('key', 'new value'); // 替换为目标键和修改后的值
    console.log('键值对修改后:', targetMap.get('key')); // 替换为目标键来获取修改后的值
});
1
2
3
4
5
6
7

在上面的示例中，我们获取了一个名为targetMap的Map对象的引用，并使用.put()方法来修改指定键的值。然后，我们使用.get()方法来获取修改后的值并打印输出。

创建新的Map对象：

Java.perform(function() {
    var HashMap = Java.use('java.util.HashMap'); // 替换为目标Map对象的类名
​
    // 创建新的Map对象
    var newMap = HashMap.$new();
    newMap.put('key1', 'value1');
    newMap.put('key2', 'value2');
    console.log('新的Map对象:', newMap);
});
1
2
3
4
5
6
7
8
9

在上面的示例中，我们使用java.util.HashMap类创建了一个新的Map对象newMap，并使用.put()方法向其中添加键值对。然后，我们打印输出新的Map对象。

请注意，在上述示例代码中，你需要将java.util.Map、java.util.HashMap等替换为目标应用程序中实际的Map类名。

类参数

在Frida中进行逆向工程时，我们通常需要了解和使用一些类参数，以便正确地获取和操作目标类的实例、方法和字段。以下是一些常用的Frida逆向基础类参数的示例：

类名参数：

在使用Frida时，我们需要指定目标类的类名。类名参数通常是一个字符串，表示我们要操作的目标类。例如，如果要操作Android应用中的com.example.app.MainActivity类，我们可以使用以下代码：

var targetClass = Java.use('com.example.app.MainActivity');
1

方法名参数：

要访问和调用目标类的方法，我们需要知道方法的名称。方法名参数通常是一个字符串，表示我们要操作的目标方法。例如，如果要调用com.example.app.MainActivity类中的doSomething()方法，我们可以使用以下代码：

targetClass.doSomething.implementation = function() {
    // 在这里添加我们想要执行的代码
    // ...
    // 调用原始方法
    this.doSomething();
};
1
2
3
4
5
6

字段名参数：

要访问和修改目标类中的字段，我们需要知道字段的名称。字段名参数通常是一个字符串，表示我们要操作的目标字段。例如，如果要修改com.example.app.MainActivity类中的count字段的值，我们可以使用以下代码：

var targetField = targetClass.class.getDeclaredField('count');
targetField.setAccessible(true);
targetField.setInt(targetClass, 10);
1
2
3

在上面的示例中，我们使用targetClass.class.getDeclaredField(‘count’)来获取count字段的引用。然后，我们将字段设置为可访问状态，并使用setInt()方法将字段的值设置为10。

本文主要针对在Android逆向开发中的，Frida的基础进行了解析，想要对Android逆向的更深层学习了解，可以参考《Android核心 技术手册》这个记录文档点击可查看详细类容。

学习注意

Frida使用JavaScript作为脚本语言进行逆向工程操作，因此对JavaScript语法和基本的编程概念要有一定了解。了解Frida的安装和配置过程，以及如何在目标应用程序中注入Frida脚本和进行基本的Hook操作。

Frida主要用于Android应用程序的逆向工程，因此熟悉Java和Android的基本概念、类结构和应用程序组成部分对于理解和使用Frida非常重要。 Frida提供了丰富的API，用于访问和操作目标应用程序的类、方法、字段等。要熟练使用Frida，需要仔细阅读和理解Frida的API文档，了解API的功能和使用方法。