Frida使用 – Ben涧の芽衣子

基础语法

API名称	描述
`Java.use(className)`	获取指定的Java类并使其在JavaScript代码中可用。
`Java.perform(callback)`	确保回调函数在Java的主线程上执行。
`Java.choose(className, callbacks)`	枚举指定类的所有实例。
`Java.cast(obj, cls)`	将一个Java对象转换成另一个Java类的实例。
`Java.enumerateLoadedClasses(callbacks)`	枚举进程中已经加载的所有Java类。
`Java.enumerateClassLoaders(callbacks)`	枚举进程中存在的所有Java类加载器。
`Java.enumerateMethods(targetClassMethod)`	枚举指定类的所有方法。

日志方法	描述	区别
`console.log()`	使用JavaScript直接进行日志打印	多用于在CLI模式中，`console.log()`直接输出到命令行界面，使用户可以实时查看。在RPC模式中，`console.log()`同样输出在命令行，但可能被Python脚本的输出内容掩盖。
`send()`	Frida的专有方法，用于发送数据或日志到外部Python脚本	多用于RPC模式中，它允许JavaScript脚本发送数据到Python脚本，Python脚本可以进一步处理或记录这些数据

基本使用

列出运行的APP：frida-ps -Ua

列表所有的APP：frida-ps -Uai

查看进程：frida-ps -U

杀死进程：frida-kill -U 包名

检测frida端口

解决：端口转发

1.移动端frida-server自定义端口启动./frida-server -l 0.0.0.0:6666

2.端口转发到本地adb forward tcp:6666 tcp:6666

3.通过frida命令行执行脚本frida -H 127.0.0.1:6666 packageName（包名） -l xxx.js

4.python脚本中使用自定义端口进行连接

#-*- coding: utf-8 -*-

import frida
import sys

PACKAGE = 'com.xxx.xxx.xxx'
HOST = '127.0.0.1:6666'

def on_message(message,data):
    if message['type'] == 'send':
        print(message['payload'])
    elif message['type'] == 'error':
        print(message['stack'])

if __name__ == '__main__':
    try:
        manager = frida.get_device_manager()
        device = manager.add_remote_device(HOST)
        jscode = open('script.js','r',encoding='UTF-8').read()
        pid = device.spawn([PACKAGE])
        session = device.attach(pid)

        script = session.create_script(jscode)
        script.on('message',on_message)
        script.load()
        device.resume(pid)

        sys.stdin.read()
    except Exception as e:
        print('frida hook error')

启动脚本

常用命令：frida -U -l myhook.js -f com.xxx.xxxx --no-paus

-U 指定对USB设备操作
-l 指定加载一个Javascript脚本
-f 指定一个进程，重启它并注入脚本，不加-f则不会重启
–no-pause 自动运行程序

脚本编写

关键词解析

Java.use():该方法用于获取 Java 类对象，以便于在 JavaScript 中对其进行操作。例如：Java.use(‘java.util.ArrayList’) 会返回访问和修改该类的属性和方法。
Java.perform():该方法用于在 Frida 的 JavaScript 环境中执行代码块。这个代码块中可以包含对 Java 类的修改、Hook 方法的实现等操作。
implementation:属性：用于指定要 Hook 的方法的新实现。通过设置可以在方法执行前后添加自定义的逻辑。
this和arguments：在自定义的方法实现中，可以使用this 关键字表示原始方法的调用和属性访问。

变量类型区别

Hook

启动main

function main() {
    Java.perform(function () {
        demo()
    })
}
setImmediate(main)

静态方法

function demo() {
    var Utils = Java.use(包名.类名);
    // 应用 hook 函数到静态方法
    Utils.方法名.implementation = function () {
        // 调用原始方法
        var result = this.方法名(方法参数);
        return result;
    }
}

重载方法

function demo() {
    var Utils = Java.use(包名.类名);
    Utils.getOver.overload('int').implementation = function (arg) {
        console.log(arg)
        var res = this.getOver(arg)
        return res
    }
}

构造方法

function demo() {
    var money = Java.use(包名.类名);
    money.$init.overload('java.lang.String', 'int').implementation =
        function (str, num) {
            console.log(str, num);
            this.$init(str, num);
        }
}

主动调用静态方法

function demo() {
    var Utils = Java.use(包名.类名);
    // 应用 hook 函数到静态方法
    Utils.方法(参数)
}

主动调用实例方法

function demo() {
    // 新建对象调用
    var res = Java.use(包名.类名).$new(初始化参数).方法名称(参数);
    console.log(res)

    // 获取已有对象调用 一般在rpc会经常使用
    Java.choose(包名.类名, {
        onMatch: function (obj) {
            console.log(obj.方法名称(参数))
        },
        onComplete: function () {
            console.log('内存中Money操作完毕')
        }
    });
}

Java类-获取和修改类的字段

function demo() {
    var money = Java.use(包名.类名);
    money.字段名称.value = "111";
    console.log(money.字段名称.value, '修改之后的结果');
    //获取已有对象的方法，非静态字段的修改
    Java.choose(包名.类名, {
        onMatch: function (obj) {
            obj._字段名称.value = "222"; // 字段名与方法名相同时 前面需要加个下划线
            console.log(obj._字段名称.value)
        },
        onComplete: function () {
        }
    });
}

Java类-内部类

function demo() {
    var InnerClass = Java.use('包名.类目$内部类名');
    // 优化构造函数的 hook
    InnerClass.$init.overload(初始化参数类型).implementation =
        function (参数) {
            // 调用原始构造函数
            return this.$init(参数);
        };
}

Java类-枚举类的方法

function demo() {
    // 下面这行是枚举所有类
    // console.log(Java.enumerateLoadedClassesSync().join('\n'))
    var money = Java.use(包名.类名);
    // 获取该类下所有的方法
    var methods = money.class.getDeclaredMethods()
    console.log(methods)
    for (var i = 0; i < methods.length; i++) {
        // 获取当前方法的名称
        console.log(methods[i].getName())
    }
    // 获取该类下的构造函数
    var contructors = money.class.getDeclaredConstructors();
    console.log(contructors)
    // 获取该类下的字段
    var field = money.class.getDeclaredFields();
    console.log(field)
    // 后去内部类
    var classes = money.class.getDeclaredClasses();
    console.log(classes)
}

BufferMap

function demo() {
    var BufferMap = Java.use("com.xxx.com.BufferMap");
    BufferMap.show.implementation = function (map) {
        console.log(map);
        // map的遍历
        var key = map.keySet(); // 返回所有建的集合
        var it = key.iterator();
        while (it.hasNext()) {
            var keystr = it.next();
            var valuestr = map.get(keystr);
            console.log(keystr, valuestr)
        }
        // 添加数据返回
        map.put("name", "xialuo");
        map.put("age", "18");
        var result = this.show(map);
        // 在这里可以对原始方法的返回值进行修改或者额外的操作
        return result;
    }
}

HashMap

function demo() {
    var hashMap = Java.use("java.util.HashMap");
    hashMap.put.implementation = function (a, b) {
        console.log('输出--》', a, b)
        return this.put(a, b)
    }
}

判断用户输入是否为空

function demo() {
    var TextUtils = Java.use("android.text.TextUtils");
    TextUtils.isEmpty.implementation = function (aa) {
        console.log('TextUtils--》', aa)
        return this.isEmpty(aa)
    }
}

json.put

function demo() {
    var JSONObject = Java.use('org.json.JSONObject');
    // Hook JSONObject.put() 方法
    JSONObject.put.overload('java.lang.String', 'java.lang.Object').implementation =
        function (key, value) {
            console.log('Hooked JSONObject.put()');
            console.log('Key: ' + key.toString());
            console.log('Value: ' + value.toString());
            // 调用原始的put()方法
            return this.put(key, value);
        };
}

json.get

function demo() {
    var JSONObject = Java.use('org.json.JSONObject');
    // Hook JSONObject.getString() 方法
    JSONObject.getString.overload('java.lang.String').implementation = function (key) {
        console.log('Hooked JSONObject.getString()');
        console.log('Key: ' + key.toString());
        // 调用原始的getString()方法
        var result = this.getString(key);
        return result;
    };
}

排序算法

function demo() {
    var Collections = Java.use('java.util.Collections');
    // Hook sort() 方法
    Collections.sort.overload("java.util.List").implementation = function (list) {
        console.log('Hooked Collections.sort()');
        console.log('List: ' + list.toString());
        // 使用 Java.cast 进行类型转换 将list转换成ArrayList类型
        var res = Java.cast(list, Java.use("java.util.ArrayList"))
        console.log('List list-->', res)
        // 调用原始的 sort() 方法
        return this.sort(list);
    };
    
    Collections.sort.overload("java.util.List", "java.util.Comparator").implementation = function (a, b) {
        console.log('Hooked Collections.sort()');
        var res = Java.cast(a, Java.use("java.util.ArrayList"))
        console.log('Comparator list-->', res)
        return this.sort(a, b);
    };
}

字符串转换

function demo() {
    var StringClass = Java.use('java.lang.String');
    // Hook String 类的构造函数
    StringClass.getBytes.overload().implementation = function () {
        console.log('Original Value');
        // 可在此处修改传入的字符串参数
        var res = this.getBytes();
        var newString = StringClass.$new(res)
        // 输出修改后的值
        console.log('Modified Value: ' + newString);
        return res;
    };
    // Hook String 类的静态方法
    StringClass.getBytes.overload('java.lang.String').implementation = function (obj) {
        console.log('Hooked String.valueOf()');
        // 可在此处修改传入的对象参数
        var res = this.getBytes(obj);
        var newString = StringClass.$new(res, obj)
        // 输出修改后的结果
        console.log('getBytes: ' + newString)
        return res
    }
}

StringBuilder的tostring

function demo() {
    // 获取 StringBuilder 类并定义需要 Hook 的方法名
    var stringBuilderClass = Java.use("java.lang.StringBuilder");
    stringBuilderClass.toString.implementation = function () {
        console.log(arguments)
        var res = this.toString.apply(this, arguments)
        return res
    }
}

Arrays.toString()

Java.use("java.util.Arrays").toString.overload('[Ljava.lang.Object;').implementation = function (x) {
            var result = this.toString(x);
            console.log("params=", x);
            console.log("result=", result)
            return result
        }

点击按钮

找到SDK文件，在sdk\tools\bin目录下有一个uiautomatorviewer ，可以使用他进行查看id

function demo() {
    var btn_login_id = Java.use("com.dodonew.online.R$id").btn_login.value;
    var View = Java.use('android.view.View');
    View.setOnClickListener.implementation = function (listener) {
        console.log(this.getId(), "22222222222")
        // 调用原始的setOnClickListener方法
        return this.setOnClickListener(listener);
    };
}

算法hook-未完成

function bytesToHex(arr) {
    var str = "";
    for (var i = 0; i < arr.length; i++) {
        var tmp = arr[i];
        if (tmp < 0) {
            tmp = (255 + tmp + 1).toString(16);
        } else {
            tmp = tmp.toString(16);
        }
        if (tmp.length == 1) {
            tmp = "0" + tmp;
        }
        str += tmp;
    }
    return str;
}

function bytesToBase64(e) {
    var base64EncodeChars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
    var r, a, c, h, o, t;
    for (c = e.length, a = 0, r = ''; a < c;) {
        if (h = 255 & e[a++], a == c) {
            r += base64EncodeChars.charAt(h >> 2),
                r += base64EncodeChars.charAt((3 & h) << 4),
                r += '==';
            break
        }
        if (o = e[a++], a == c) {
            r += base64EncodeChars.charAt(h >> 2),
                r += base64EncodeChars.charAt((3 & h) << 4 | (240 & o) >> 4),
                r += base64EncodeChars.charAt((15 & o) << 2),
                r += '=';
            break
        }
        t = e[a++],
            r += base64EncodeChars.charAt(h >> 2),
            r += base64EncodeChars.charAt((3 & h) << 4 | (240 & o) >> 4),
            r += base64EncodeChars.charAt((15 & o) << 2 | (192 & t) >> 6),
            r += base64EncodeChars.charAt(63 & t)
    }
    return r
}

function bytesToString(arr) {
    if (typeof arr === 'string') {
        return arr;
    }
    var str = '',
        _arr = arr;
    for (var i = 0; i < _arr.length; i++) {
        var one = _arr[i].toString(2),
            v = one.match(/^1+?(?=0)/);
        if (v && one.length == 8) {
            var bytesLength = v[0].length;
            var store = _arr[i].toString(2).slice(7 - bytesLength);
            for (var st = 1; st < bytesLength; st++) {
                store += _arr[st + i].toString(2).slice(2);
            }
            str += String.fromCharCode(parseInt(store, 2));
            i += bytesLength - 1;
        } else {
            str += String.fromCharCode(_arr[i]);
        }
    }
    return str;
}

function bytesToUtf8(arr) {
    const utf8Bytes = new Uint8Array(arr);
    const decoder = new TextDecoder('utf-8');
    const decodedString = decoder.decode(utf8Bytes);
    return decodedString
}

function MD5() {
    console.log("==============MD5==============")
    var MessageDigest = Java.use("java.security.MessageDigest");
    MessageDigest.getInstance.overload('java.lang.String').implementation = function (a) {
        send("[*]算法是:" + a)
        return this.getInstance(a)
    }
    MessageDigest.update.overload('byte').implementation = function (a) {
        send("[*]update传入类型byte:" + a)
        return this.update(a)
    }
    MessageDigest.update.overload('java.nio.ByteBuffer').implementation = function (a) {
        send("[*]update传入类型ByteBuffer:" + a)
        return this.update(a)
    }
    MessageDigest.update.overload('[B').implementation = function (a) {
        send("[*]update传入类型Bytes:" + a)
        send("update Bytes To String:" + bytesToString(a))
        return this.update(a)
    }
    MessageDigest.update.overload('[B', 'int', 'int').implementation = function (a, b, c) {
        send("[*]update传入类型Bytes,int,int:" + a + "|" + b + "|" + c)
        send("update Bytes To String:" + bytesToString(a))
        return this.update(a)
    }
    MessageDigest.digest.overload().implementation = function () {
        var result = this.digest()
        send("digest结果(hex):" + bytesToHex(result))
        send("digest结果(base64):" + bytesToBase64(result))
        send("digest结果(string):" + bytesToString(result))
        return result;
    }
    MessageDigest.digest.overload('[B').implementation = function (arg) {
        send("digest Bytes To String:" + bytesToString(arg))
        var result = this.digest(arg)
        send("digest结果(hex）:" + bytesToHex(result))
        send("digest结果(base64）:" + bytesToBase64(result))
        send("digest结果(string）:" + bytesToString(result))
        return result;
    }
}

function DES() {
    console.log("==============DES/AES==============")
    var Cipher = Java.use("javax.crypto.Cipher")
    Cipher.getInstance.overload('java.lang.String').implementation = function (a) {
        var result = this.getInstance(a)
        send("[*]算法是:" + a)
        return result
    }
    Cipher.getInstance.overload('java.lang.String', 'java.lang.String').implementation = function (a, b) {
        var result = this.getInstance(a, b)
        send("[*]算法是:" + a + "|" + b)
        return result
    }

    var SecretKeySpec = Java.use("javax.crypto.spec.SecretKeySpec");
    SecretKeySpec.$init.overload('[B', 'java.lang.String').implementation = function (a, b) {
        send("算法名:" + b + ",密钥文件(String):" + bytesToString(a))
        send("算法名:" + b + ",密钥文件(Hex):" + bytesToHex(a))
        send("算法名:" + b + ",密钥文件(Base64):" + bytesToBase64(a))
        return this.$init(a, b)
    }
    // 操作 iv 偏移量
    var IvParameterSpec = Java.use("javax.crypto.spec.IvParameterSpec")
    IvParameterSpec.$init.overload('[B').implementation = function (arg) {
        send("IV偏移量(String):" + bytesToString(arg))
        send("IV偏移量(HEX):" + bytesToHex(arg))
        send("IV偏移量(Base64):" + bytesToBase64(arg))
        var result = this.$init(arg)
        return result
    }
    Cipher.update.overload('[B').implementation = function (arg) {
        send("update Bytes To String:" + bytesToString(arg))
        var result = this.update(arg)
        return result
    }
    Cipher.update.overload('[B', 'int', 'int').implementation = function (arg, b, c) {
        send("[*]update传入类型Bytes,int,int:" + arg + "|" + b + "|" + c)
        send("update Bytes To String:" + bytesToString(arg))
        var result = this.update(arg, b, c)
        return result
    }
    Cipher.doFinal.overload().implementation = function () {
        var result = this.doFinal()
        send("doFinal加密结果(String):" + result)
        send("doFinal加密结果(hex):" + bytesToHex(result))
        send("doFinal加密结果(base64):" + bytesToBase64(result))
        return result
    }
    Cipher.doFinal.overload('[B').implementation = function (arg) {
        send("doFinal入参:" + bytesToString(arg))
        // 获取算法名称
        // var alg = this.getAlgorithm();
        // console.log(alg)
        var result = this.doFinal(arg)
        send("doFinal结果(hex):" + bytesToHex(result))
        send("doFinal结果(base64):" + bytesToBase64(result))
        return result
    }
}


function HMAC() {
    console.log("==============HMAC==============")
    var mac = Java.use("javax.crypto.Mac")
    mac.update.overload('[B').implementation = function (arg) {
        send("[*]update传入类型ByteBuffer:" + arg)
        send("update Bytes To String:" + bytesToString(arg))
        var result = this.update(arg)
        return result
    }
    mac.update.overload('[B', 'int', 'int').implementation = function (arg, b, c) {
        send("[*]update传入类型ByteBuffer,int,int:" + arg + "|" + b + "|" + c)
        send("update Bytes To String:" + bytesToString(arg))
        var result = this.update(arg, b, c)
        return result
    }
    mac.doFinal.overload().implementation = function () {
        var alg = this.getAlgorithm();
        var result = this.doFinal()
        send(alg + "-doFinal加密结果(hex):" + bytesToHex(result))
        send(alg + "-doFinal加密结果(base64):" + bytesToBase64(result))
        return result
    }
    mac.doFinal.overload('[B').implementation = function (arg) {
        var alg = this.getAlgorithm();
        send("doFinal入参:" + bytesToString(arg))
        var result = this.doFinal(arg)
        send(alg + "-doFinal结果(hex):" + bytesToHex(result))
        send(alg + "-doFinal结果(base64):" + bytesToBase64(result))
        return result
    }
}

function BASE64() {
    var b64 = Java.use("android.util.Base64")
    b64.decode.overload('java.lang.String', 'int').implementation = function (a, b) {
        send("b64接受入参:" + a + "|" + b)
        return this.decode(a, b)
    }

    var X509EncodedKeySpec = Java.use("java.security.spec.X509EncodedKeySpec")
    X509EncodedKeySpec.$init.overload('[B').implementation = function (a) {
        var res = this.$init(a)
        send("RSA密钥：" + bytesToBase64(a))
        return res
    }
}

function main() {
    Java.perform(function () {
        MD5()
        DES()
        HMAC()
        BASE64()
    })
}

setImmediate(main)

打印堆栈信息

在上面的hook方法中通过特定的参数进行判断，并添加下面的代码，来打印堆栈然后再进行分析。

function showStacks() {
    Java.perform(function () {
        console.log(Java.use("android.util.Log").getStackTraceString(
            Java.use("java.lang.Throwable").$new()
        ));
    })
}

showStacks()

Python调用

使用Python注入Frida主要有以下几种模式：

Spawn 模式：在目标设备上启动一个新的应用程序进程，并在该进程中运行Frida脚本。这种模式非常适用于对未安装的应用程序进行注入。
Attach 模式：在目标设备上附加到已经运行的应用程序进程，并在该进程中运行Frida脚本。这种模式非常适用于对已经运行的应用程序进行调试和分析。
USB 模式：将目标设备通过USB连接到计算机上，并使用Frida通过USB进行通信。这种模式比较适用于对物理上可访问的设备进行注入，但需要确保设备已经打开了USB调试模式。
Remote 模式：在远程设备上运行Frida，并使用Frida提供的远程API进行通信。这种模式适用于需要对无法直接访问的设备进行注入，例如云服务器、虚拟机等。在使用Python注入Frida时，需要根据具体的情况选择合适的注入模式

代码样例

Spawn

import frida
js_code = '''
 Java.perform(function () {
  console.log(Java.use("android.util.Log").getStackTraceString(
 Java.use("java.lang.Throwable").$new()
 ));
 })
 '''
# 通过Spawn模式启动一个新的应用程序进程，并在该进程中加载Frida脚本
device = frida.get_usb_device()
pid = device.spawn(["包名"])
session = device.attach(pid)
script = session.create_script(js_code)
script.load()
# 恢复应用程序的执行
device.resume(pid)
# 阻塞主线程，以保持脚本运行
sys.stdin.read()

Attach

import sys
import frida
# 通过Attach模式附加到已经运行的应用程序进程，并在该进程中加载Frida脚本
device = frida.get_usb_device()
# 获取目标应用程序的PID
pid = device.get_process("包名").pid
# 附加到目标进程
session = device.attach(pid)
# 读取Frida脚本
js_cpde = '''
 Java.perform(function () {
 console.log(Java.use("android.util.Log").getStackTraceString(
 Java.use("java.lang.Throwable").$new()
 ));
 })
 '''
# 创建Frida脚本并加载
script = session.create_script(js_cpde)
script.load()
# 阻塞主线程，以保持脚本运行
sys.stdin.read()

USB

import frida

# 通过USB连接将设备连接到计算机上，并在该设备上加载Frida脚本
device = frida.get_usb_device()
session = device.attach("包名")
# 读取Frida脚本
js_cpde = '''
 Java.perform(function () {
 console.log(Java.use("android.util.Log").getStackTraceString(
 Java.use("java.lang.Throwable").$new()
 ));
 })
 '''
# 创建Frida脚本并加载
script = session.create_script(js_cpde)
script.load()
sys.stdin.read()  # 阻塞主线程，以保持脚本运行

Remote

import frida

# 在远程设备上启动Frida Server，并将其连接到计算机上
device = frida.get_device_manager().add_remote_device("192.168.0.1:1234")
pid = device.spawn(["包名"])
session = device.attach(pid)
# 读取Frida脚本
js_cpde = '''
 Java.perform(function () {
 console.log(Java.use("android.util.Log").getStackTraceString(
 Java.use("java.lang.Throwable").$new()
 ));
 })
 '''
# 创建Frida脚本并加载
script = session.create_script(js_cpde)
script.load()
device.resume(pid)

监听脚本

其实就是获取到脚本输出的内容。

hook代码中添加send，python代码中添加script.on

import frida


def on_message(message, data):
    if message['type'] == 'send':
        print("[*] {0}".format(message['payload']))
    else:
        print(message)


js_code = '''
Java.perform(function () {
    var Utils = Java.use(包名.类名);
    // 应用 hook 函数到静态方法
    Utils.方法名.implementation = function () {
        // 调用原始方法
        var result = this.方法名(方法参数);
        send("11111");
        return result;
    }
})
'''

device = frida.get_usb_device()
session = device.attach("包名")
script = session.create_script(js_code)
script.on('message', on_message)
script.load()
sys.stdin.read()

一	二	三	四	五	六	日
1	2	3	4	5	6	7
8	9	10	11	12	13	14
15	16	17	18	19	20	21
22	23	24	25	26	27	28
29	30