Frida-Labs-Java层操作指南
Frida-labs 1到7,在Java层的操作大全,记录自己的操作以及遇到的一些坑
最近在学习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)是很麻烦的,甚至是不可行的。
原因是这样的:
- Activity 需要上下文(Context)才能正常工作:就像你造房子要有地基一样,Activity 这种组件运行的时候,需要依赖应用程序提供的运行环境(就是 Context)。在 Frida 里,你是“旁观者”,而不是“房子的主人”,所以没法轻松提供这个环境。
- UI 相关的代码必须在主线程(带 Looper 的线程)里跑:Android 要求所有跟界面有关的操作都得在“主线程”里运行,这个线程有个叫 Looper 的消息循环系统。在 Frida 里,如果你随便在哪个线程里跑 UI 代码,程序很可能直接崩掉。
- Activity 的生命周期很复杂:系统会自动帮 Activity 调用一系列方法,比如 onCreate、onStart、onResume 等。这一整套流程是系统控制的。如果你自己用 Frida 去“强行”创建一个 Activity 实例,系统其实并不知道它存在,所以它无法正常工作。
那么应该怎么办呢
SWDD说
当Android应用程序启动时,系统会创建MainActivity的一个实例(或AndroidManifest.xml文件中指定的启动器活动)。创建MainActivity实例是Android应用程序生命周期的一部分。因此,我们可以使用frida获取MainActivity的实例,然后调用flag()方法来获取我们的标志。
让我们看看GPT怎么说
📱 正常来说,Android 应用是怎么启动的?
- 当你点击某个 App 图标时,
- Android 系统就会去看这个 App 的 AndroidManifest.xml 文件,
- 找到标注为「启动入口」的 Activity(比如 MainActivity),
- 然后系统会自动创建这个 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);