最近在学习Frida的操作,记录一下自己的学习笔记以及踩过的一些坑

Frida常用的参数解释

-U 指定USB设备
-f 指定app包名,通过spawn方式启动(就是重新启动的意思)
-P 指定APP的pid
--no-pause 不暂停
-l 加载hook脚本

先来看一个基础的脚本

Java.perform(function() {
 
  var <class_reference> = Java.use("<package_name>.<class>");
  <class_reference>.<method_to_hook>.implementation = function(<args>) { 
    /*
      我们自己的方法实现
    */
  }
 
})

Java.perform(function() {

  • 这行代码是 Frida 的固定写法,用于确保我们注入的脚本在 Java 虚拟机准备好之后再运行。
  • 否则可能会遇到“Java is not available”的错误。

Java.perform 是 Frida 中用于创建一个特殊上下文的函数,让你的脚本能够与 Android 应用程序中的 Java 代码进行交互

​

var <class_reference> = Java.use("<package_name>.<class>");

  • 这行代码的作用是:获取你想 Hook 的 Java 类的引用。
  • "<package_name>.<class>" 是完整的类名,比如 com.example.app.LoginManager。
  • 获取后赋值给 <class_reference> 变量,后续可以通过它访问类中的方法和属性。


<class_reference>.<method_to_hook>.implementation = function(<args>) {

  • 这行是核心,它的作用是:重写类中的某个方法的实现。
  • <method_to_hook> 是你要 Hook 的方法名,比如 checkPassword。
  • <args> 是这个方法的参数列表,比如你要 hook 一个接收 username 和 password 的方法,你可以写成 function(username, password)。
  • 你写在这个函数体中的内容,就是你自己的逻辑,Frida 会用它来替换原来的方法实现。


接下来让我们看Frida labs中的例题

0x1 Hook修改被调用的方法的逻辑,返回值,传入参数

使用随机数,对输入进行判断,如果输入数的满足一个表达式,就会打印出flag

于是这里就有两种思路了。第一种是 hook get_random 函数,让该函数的返回值变成一个固定的值,从而计算表达式的值

第二种思路是 hook check 函数,直接将我们自己定义的值传入进去

function hook() {

    var MainActivity = Java.use("com.ad2001.frida0x1.MainActivity"); //使用 Frida 的 Java.use() 方法获取目标类 MainActivity 的引用。
    MainActivity.get_random.implementation = function () { //implementation 在 Frida 中是一个关键属性,用于覆盖原始 Java 方法的实现
        return 0;
    }
}


function hook2() {
    var MainActivity = Java.use("com.ad2001.frida0x1.MainActivity");
    MainActivity.check.overload('int', 'int').implementation = function (a, b) { //overload用于指定参数,由于Java的方法可以重载,所以需要指定
        console.log("Origin i and i2 = ", a, b); //console.log打印
        return this.check(3, b); //我们自己将 i 的值定为 3 传入进去
    }
}

function main() {

    Java.perform(function () {
        hook2();
    })
}

setImmediate(main);

注入

frida -U -f com.ad2001.frida0x1 -l hook.js

-U -f 缺一不可

为什么

缺少 -f

C:\Users\29660\Desktop\Frida\Frida-Labs-main\Frida-Labs-main\Frida 0x1>frida -U com.ad2001.frida0x1 -l hook.js
     ____
    / _  |   Frida 16.4.10 - A world-class dynamic instrumentation toolkit
   | (_| |
    > _  |   Commands:
   /_/ |_|       help      -> Displays the help system
   . . . .       object?   -> Display information about 'object'
   . . . .       exit/quit -> Exit
   . . . .
   . . . .   More info at https://frida.re/docs/home/
   . . . .
   . . . .   Connected to Android Emulator 5554 (id=emulator-5554)
Failed to spawn: unable to find process with name 'com.ad2001.frida0x1'

Failed to spawn: unable to find process with name 'com.ad2001.frida0x1'表示没有Frida 找不到名为com.ad2001.frida0x1的进程,详见lab02

缺少-U

C:\Users\29660\Desktop\Frida\Frida-Labs-main\Frida-Labs-main\Frida 0x1>frida -f com.ad2001.frida0x1 -l hook.js
     ____
    / _  |   Frida 16.4.10 - A world-class dynamic instrumentation toolkit
   | (_| |
    > _  |   Commands:
   /_/ |_|       help      -> Displays the help system
   . . . .       object?   -> Display information about 'object'
   . . . .       exit/quit -> Exit
   . . . .
   . . . .   More info at https://frida.re/docs/home/
   . . . .
   . . . .   Connected to Local System (id=local)
Failed to spawn: unable to find executable at 'com.ad2001.frida0x1'

说明 Frida 没有连接到 Android 模拟器,而是连接到了你本地电脑(Windows),所以它以为是要在本地运行一个叫 com.ad2001.frida0x1 的可执行文件。

0x2 Hook调用静态的未被调用的方法

可以看到这里定义了一个 get_flag 方法,但是并没有在主函数中被调用

使用 frida 直接调用未被调用的静态方法

setImmediate(function () {

    Java.perform(function () {

        var a = Java.use("com.ad2001.frida0x2.MainActivity")
        a.get_flag(4919);

    })

})



function hook() {
    var MainActivity = Java.use("com.ad2001.frida0x2.MainActivity");
    MainActivity.get_flag(4919);
}

function main() {
    Java.perform(function () {
        hook();
    })
}

setImmediate(main);

hook的时候使用如下命令有可能会hook不上

frida -U -f com.ad2001.frida0x2 -l hook.js

原因是setImmediate(main);是程序启动后立即注入,可能会导致程序还没完全启动就注入了,所以hook不上

解决办法是使用

frida -U 'frida 0x2' -l hook.js

那么,为什么将frida 0x2写成包名com.ad2001.frida0x2就不行呢

frida -U com.ad2001.frida0x2 -l hook.js

这个命令尝试的是:根据包名注入,默认是 spawn(启动)模式。

实际上这条命令是尝试 spawn(启动)包名对应的 app,但没写 -f,它又不是 attach 模式,就会失败。

或者将hook代码中的

setImmediate(main);改成

setTimeout(main,1000);延迟启动

function hook() {
    var MainActivity = Java.use("com.ad2001.frida0x2.MainActivity");
    MainActivity.get_flag(4919);
}

function main() {
    Java.perform(function () {
        hook();
    })
}

// setImmediate(main);
setTimeout(main, 1000);

0x3 更改类中的静态变量

hook code的值

function hook() {
    
    var a = Java.use("com.ad2001.frida0x3.Checker") //code的值在Checker类里
    a.code.value = 512; //使用这一句修改静态变量的值
}

function main() {
    
    Java.perform(function () {
        hook();
    })
}

setImmediate(main);

思考:

a是什么

a.code.value具体是什么意思

以下内容来自GPT

在这段 Frida 脚本中:

var a = Java.use("com.ad2001.frida0x3.Checker")

a 是什么?

👉 a是一个 Frida 创建的 Java 类代理对象(Java class wrapper),你可以把它当成是一个“控制器”或者“代理”,用来访问和操作 Java 中的类 com.ad2001.frida0x3.Checker 的静态字段、静态方法、实例方法,甚至可以 hook 它的方法。

类比一下:

在 Java 代码中你可能会这样用一个类:

Checker.code = 512;

在 Frida 中,为了达到类似的效果,我们写:

var a = Java.use("com.ad2001.frida0x3.Checker")
a.code.value = 512;

更具体地说:

  • Java.use("...") 会返回一个 Frida 的 Java 类接口(wrapper)
  • 这个对象不是类的一个实例,而是一个可以操作 类本身(静态成员)或创建实例 的对象。
  • 如果你需要创建类的实例,你可以这样写:
var instance = a.$new();  // 等于 Java 里的 new Checker()

所以总结一下:

名称

解释

a

Frida 中的类包装对象,表示Checker类

a.code.value

表示访问并修改类中code这个静态字段的值

a.$new()

(可选)表示创建这个类的一个新实例

0x4 调用非MainActivity,非静态方法

MainActivity里没有任何东西

定义了一个Check类,里面有get_flag方法

想调用这个get_flag方法,必须实例化一个check类对象,在frida中可以用以下脚本实现

function hook() {
    
    var c = Java.use("com.ad2001.frida0x4.Check");
    var c_check = c.$new();   //实例化check类对象 相当于Java里写 c c_check = new c();
 
    var flag = c_check.get_flag(1337);
    console.log(flag);
}

function main() {
    
    Java.perform(function () {
        
        hook();
    })
}

setImmediate(main);

运行结果如下

0x5 调用MainActivity中的非静态方法

在 0x2 中,我们使用frida调用了静态方法

但在本次,这是一个非静态方法

Java中静态方法可以直接调用,而非静态方法必须实例化一个对象之后才能调用

public class Hello {

    // 静态方法
    public static void sayStatic() {
        System.out.println("我是静态方法");
    }

    // 非静态方法
    public void sayInstance() {
        System.out.println("我是非静态方法");
    }

    public static void main(String[] args) {
        // 调用静态方法:不需要创建对象
        Hello.sayStatic();

        // 调用非静态方法:必须先创建对象
        Hello h = new Hello();
        h.sayInstance();
    }
}

我们直接用 0x2 的脚本hook一下

function hook() {
    var MainActivity = Java.use("com.ad2001.frida0x5.MainActivity");
    MainActivity.flag(1337);
}

function main() {
    Java.perform(function () {
        hook();
    })
}

setImmediate(main);

哦豁,报错了

以下解释来自SWDD师傅

直接使用Frida创建MainActivity或任何Android组件可能会很棘手,因为Android的生命周期和线程规则。Android组件,如Activity子类,依赖于应用程序上下文进行正确运行。在Frida中,您可能缺少必要的上下文。Android UI组件通常需要具有关联Looper的特定线程。如果涉及UI任务,请确保在具有活动Looper的主线程上执行。活动是较大的Android应用程序生命周期的一部分。创建MainActivity的实例可能需要应用处于特定状态,并且通过Frida管理整个生命周期可能并不直接。总之,为MainActivity创建实例并不是一个好主意。

通俗点来说就是,

用Frida直接创建 MainActivity 或其他 Android 组件(比如 Activity)是很麻烦的,甚至是不可行的。

原因是这样的:

  1. Activity 需要上下文(Context)才能正常工作:就像你造房子要有地基一样,Activity 这种组件运行的时候,需要依赖应用程序提供的运行环境(就是 Context)。在 Frida 里,你是“旁观者”,而不是“房子的主人”,所以没法轻松提供这个环境。
  2. UI 相关的代码必须在主线程(带 Looper 的线程)里跑:Android 要求所有跟界面有关的操作都得在“主线程”里运行,这个线程有个叫 Looper 的消息循环系统。在 Frida 里,如果你随便在哪个线程里跑 UI 代码,程序很可能直接崩掉。
  3. Activity 的生命周期很复杂:系统会自动帮 Activity 调用一系列方法,比如 onCreate、onStart、onResume 等。这一整套流程是系统控制的。如果你自己用 Frida 去“强行”创建一个 Activity 实例,系统其实并不知道它存在,所以它无法正常工作。

那么应该怎么办呢

SWDD说

当Android应用程序启动时,系统会创建MainActivity的一个实例(或AndroidManifest.xml文件中指定的启动器活动)。创建MainActivity实例是Android应用程序生命周期的一部分。因此,我们可以使用frida获取MainActivity的实例,然后调用flag()方法来获取我们的标志。

让我们看看GPT怎么说

📱 正常来说,Android 应用是怎么启动的?

  1. 当你点击某个 App 图标时,
  2. Android 系统就会去看这个 App 的 AndroidManifest.xml 文件,
  3. 找到标注为「启动入口」的 Activity(比如 MainActivity),
  4. 然后系统会自动创建这个 Activity 的实例,并调用它的一系列生命周期方法(比如 onCreate()、onResume() 等)。

🧠 那这段话的核心意思就是:

你自己不用 new 一个 MainActivity,系统已经帮你创建好了!

所以与其自己创建一个可能不完整的实例(会有很多问题),不如直接去“拿到”系统已经创建的那个实例,然后调用你想要的函数,比如flag()。

✅ 总结一下,通俗点说就是:

“Android 系统会自动帮你创建 MainActivity 的实例,所以你不需要自己造一个。用 Frida 可以直接找到这个已经存在的实例,然后调用你想要的方法(比如flag())来拿 flag。”

有这样一个模板

Java.performNow(function() {
  Java.choose('<包名>.<类名>', {
    onMatch: function(instance) {
      // 待办事项
    },
    onComplete: function() {}
  });
});
  • onMatch
  • onMatch回调函数在Java.choose操作期间找到指定类的每个实例时执行。
  • 这个回调函数接收当前实例作为它的参数。
  • 您可以在onMatch回调中定义自定义操作,以在每个实例上执行。
  • function(instance) {},instance参数表示目标类的每个匹配实例。您可以使用任何其他名称。参数 instance 就是这个 MainActivity 的对象,你可以在这里调用它的函数,比如 instance.flag()
  • onComplete
  • onComplete回调在Java.choose操作完成后执行操作或清理任务。此块是可选的,如果您在搜索完成后不需要执行任何特定操作,则可以选择将其留空。

尝试使用该模板寻找MainActivity实例

function hook() {

    Java.choose('com.ad2001.frida0x5.MainActivity', {
        
        onMatch: function (instance) {
            console.log("Sucess found!!!");
        },
        onComplete: function () {
            console.log("end");
        }
    });
}

function main() {
    Java.perform(function () {
        hook();
    })
}

setImmediate(main);

在这里还发现个问题,当使用如下命令启动frida时,只会打印一个 end ,hook不上,需要重新修改一下脚本(例如注释掉某一行再加上)

frida -U -f com.ad2001.frida0x5 -l lab05.js

原因其实跟 0x2 一样,由于脚本是立即注入,app还来不及创建MainActivity实例,自然就没找到

解决办法也跟 0x2 一样,这里就不再赘述

0x6 MainActivity中的非静态方法且参数通过非MainActivity非静态方法传递

MainActivity中的非静态方法 get_flag ,并且参数是通过 Checker 类对象 A 来传递的

Checker类如下

所以这题就是0x5 0x4 0x3的结合,但是在 0x3 中,变量为静态变量,所以需要这里需要创建一个类的对象来对变量进行更改

function hook() {

    Java.choose("com.ad2001.frida0x6.MainActivity", {
        
        onMatch: function (MainActivity) {
            
            var c = Java.use("com.ad2001.frida0x6.Checker")
            var A = c.$new();

            A.num1.value = 1234;
            A.num2.value = 4321;

            console.log("success");
            MainActivity.get_flag(A);
        },
        onComplete: function () {
            console.log("end");
        }
    });

}

function main() {

    Java.perform(function () {
        hook();
    })
}

// setImmediate(main);
setTimeout(main, 1000);

0x7 hook构造函数

构造函数是 Java 类中的一种特殊方法,它的作用是:在创建对象的时候用来初始化对象的属性。

先举个例子来了解一下森莫是Java中的构造函数

public class Dog {
    String name;
    int age;

    // 构造函数
    public Dog(String n, int a) {
        name = n;
        age = a;
    }

    // 普通方法
    public void bark() {
        System.out.println(name + " 汪汪叫!");
    }

    public void showInfo() {
        System.out.println("这只狗叫 " + name + ",它 " + age + " 岁了。");
    }

    public static void main(String[] args) {
        Dog d = new Dog("小黑", 3);  // 调用构造函数,初始化对象       Dog(第一个)👉 表示变量 d 的 类型,也就是类名,说明 d 是一个 Dog 类型的对象。
                                    //new Dog("小黑", 3)(后面这个)👉 是 调用构造函数,创建一个新的 Dog 对象,并传入两个参数。
        d.bark();                   // 调用普通方法
        d.showInfo();               // 调用普通方法
    }
}

来看本题,调用了flag方法,并且通过Checker构造函数对 num1 和 num2 赋值为 123 和 321

在Frida中使用 $init 关键字来 hook 构造函数

function hook() {

    var Checker = Java.use("com.ad2001.frida0x7.Checker");
    Checker.$init.implementation = function (a, b) {

    //  Checker.$init 是这个类的 构造函数(constructor)。
    //  .implementation = function (a, b) 表示你要“劫持”这个构造函数,用你自己的实现来替代原来的。
    //  a, b 就是原本传给构造函数的两个参数。

        console.log("Origin num", a, b);
        this.$init(666, 666);    //this.$init(...) 表示“用原本的方式继续初始化对象,但用我给的参数”
        console.log("success");  
    }
}

function main() {
    Java.perform(function () {
        hook();
    })
}
setImmediate(main);

写到这我有点好奇如果使用 0x1 的方法直接去 hook 构造函数会怎样

来吧,实践出真知

function hook() {
    var Ch = Java.use("com.ad2001.frida0x7.Checker");
    Ch.Checker.overload('int', 'int').implementation = function (a, b) { 
        console.log("Origin num", a, b); //console.log打印
        return this.Checker(666, 666);
    }
}

function main() {
    Java.perform(function () {
        hook();
    })
}
setImmediate(main);

哈哈,报错了,cannot read property 'overload' of undefined 说明试图 hook 的 Java 方法并没有找到

然后我又好奇,如果使用 0x3 的方法直接改变 num1 和 num2 会怎样

function hook() {

    var Checker = Java.use("com.ad2001.frida0x7.Checker");
    Checker.$init.implementation = function (a, b) {

    //  Checker.$init 是这个类的 构造函数(constructor)。
    //  .implementation = function (a, b) 表示你要“劫持”这个构造函数,用你自己的实现来替代原来的。
    //  a, b 就是原本传给构造函数的两个参数。

        console.log("Origin num", a, b);
        // this.$init(666, 666);    //this.$init(...) 表示“用原本的方式继续初始化对象,但用我给的参数”
        Checker.num1.value = 666;
        Checker.num2.value = 666;
        console.log("success");
    }
}

function main() {
    Java.perform(function () {
        hook();
    })
}
setImmediate(main);

哈哈,果然又报错了 Error: Cannot access an instance field without an instance 表示试图访问 Checker.num1,但这是 实例字段(成员变量),你必须通过一个具体对象(也就是 this)来访问它

改成这样或许会比初代脚本好理解一些,跟 0x1 也更像

function hook() {

    var Checker = Java.use("com.ad2001.frida0x7.Checker");
    Checker.$init.overload('int', 'int').implementation = function (a, b) {
        console.log("Origin num:", a, b);

        // 调用原始构造函数初始化对象
        this.$init(a, b);

        // 修改成员变量
        this.num1.value = 666;
        this.num2.value = 666;

        console.log("Success: num1 and num2 changed to 666");
    };
}

function main() {
    Java.perform(function () {
        hook();
    })
}
setImmediate(main);