Root原理及反制手段

2020-12-20

什么是root

拥有最高权限的账户就叫root。

获取root的方式

提权
利用Linux漏洞：adbd提权

全root: 有权限修改系统文件
半root（需解锁systemloac）:没有权限修改系统文件

半root直接刷magisk可实现全root

将su文件放到/system/bin或者/system/xbin目录
执行su命令时，系统会去判断当前的uid、pid是否是管理员用户，如果是的话直接给true。
执行

检测root

检测su文件是否在/system/bin 或者 /system/xbin目录下存在

检测设备是否启动debugger模式

public static boolean checkDeviceDebugger(){
	String buildTags = android.os.Build.TAGS;
	if(buildTest != null && buildTags.contains("test-keys")){
		return true;
	}
	return false;
}

通过读取特征文件来判断是否存在root
比如下面这段代码是用来判断是否安装了supersu的,因为该app会获取root权限，获取完成之后会把其自身变成系统级的apk，故可以检测出来相应的特征文件
1
2
3
4
5
6
7
8
9
10
11
public static boolean checkSuperuserApk(){
try{
File file = new File("/system/app/Superuser.apk");
if(file.exists()){
return true;
}
}catch(Exeception e){

}
return false;
}
检测data的读写权限
1

对抗检测root

把su文件进行编译，编译成其他文件比如msu等，执行时执行msu。

Stra1234

展开全文 >>

Root原理

2020-12-20

展开全文 >>

2W直播课

2020-12-20

在手机上跑frida脚本，并开启服务

第一种方法，在termux直接跑frida

托Mac M1芯片的福，frida也支持了在ARM下直接运行，当然frida的版本必须在14以上，意味着可以在手机上直接跑frida 脚本和objection等等。frida的rpc暴露出相应的端口，可以直接跑。

termux里把python装上，然后装上adb，adb连127.0.0.1接口（记得打开wifiadb），然后找个窗口启动frida，之后即可按正常流程跑python 把rpc的接口暴露出来。

frida-net和frida

git clone

Ghidra

Ghidra是一款跟IDA一样用来进行逆向分析的软件，同样可以用来静态分析so，免费软件，新潮且受到大家追捧。

Ghidra官网:https://ghidra-sre.org/

可以到官网下载。下载之前，需要先装好高版本的openjdk,在Terminal处输入apt search openjdk来寻找openjdk的相应源

这里我们选择jdk14。

省略apt install。。。。

git clone https://github.com/Ayrx/JNIAnalyzer.git下载这个项目，用来辅助我们在Ghidra上分析so。
我们先运行我们的Ghidra。

第一次创建先创建一个新的项目。

之后来到这个页面，即可拖入so来进行分析。

效果还挺不错的，起码颜色我喜欢~

JNI Helper

该库是evilpan大神写的也是辅助我们在Ghidra上静态分析so的。

该库地址：https://github.com/evilpan/jni_helper

使用方法：
除了需要clone该库之外还要额外下载该库的Jadx的插件jar

直接.zip下下来。

解压之后，先调用该jar包

-ps : /root/apk/fulao2.apk是路径， fulao.json是出参。

运行完该条命令马上开始疯狂解析so。

然后还要安装Ghidra的插件，这个直接在我们的clone下来的项目里面找。
到该项目的ghidra项目下make install

然后到ghidra下的这个位置

点击，然后找到这个界面，随便找个灰色的地方右键

打钩

出现打钩不了，像我截图这样，请重新启动ghidra!

可以打钩了~

然后就可以搜到我们的脚本了~

右键run script

打开刚才生成的json文件。

当当，有效果了~

-ps : 没有动态调试，说明缺乏第三方工具，反编译效果跟IDA还是差了点，不过是新鲜事物，多个工具多个路子了~

jnitrace

https://github.com/chame1eon/jnitrace

该库可以hook所有jni函数。hook到之后会打印其参数返回值。

展开全文 >>

接口：https://openapi.boc.cn/unlogin/trade/query_pcts_batch_info

数据来源页：

请求头：

POST /unlogin/trade/query_pcts_batch_info HTTP/1.1
Host: openapi.boc.cn
Content-Length: 43
Pragma: no-cache
Cache-Control: no-cache
Origin: https://openapi.boc.cn
clentid: 540
Content-Type: application/json;charset=UTF-8
Accept: application/json, text/plain, */*
Referer: https://openapi.boc.cn/erh/sxbbank/dist/index.html
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,en-US;q=0.8
X-Requested-With: com.chinamworld.bocmbci
Connection: keep-alive

请求参数：

{
	"productCode": "SXDGJS,FXSSXB",
	"isAll": "N"
}

需要的响应参数：

changeRate: 涨跌幅
contractCode：来源页中的FXSSXB_XX这个部分
custOffer: 客户买入价 (除10万就够了)
costOffer: 客户卖出价 (除10万就够了)

分时数据（每分钟更新一次）

招行双向外汇
接口: https://jyt.cmbchina.com/ivrouter/queryMarginPrice.action

请求头：

GET /ivrouter/queryMarginPrice.action HTTP/1.1
Host: jyt.cmbchina.com
Accept: */*
Cache-Control: no-cache
X-Requested-With: XMLHttpRequest
User-Agent: Mozilla/5.0 (Linux; Android 8.1.0; Pixel XL Build/OPM1.171019.011; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/61.0.3163.98 Mobile Safari/537.36 MPBank/9.0.0 Android/8.1.0 AID/GAGgi5Vux1PXmSg/1XSk4GlorM8= SID/K51u8SPE5+6Qge0rLKndhrJqRxM= APPTag/1.0(N;24;LIGHT;321)
Referer: https://jyt.cmbchina.com/index.html?DeviceType=E&Version=9.0.0&SystemVersion=8.1.0&ATraceID=0e29e6b1902e44289553661e5ef7f985
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,en-US;q=0.8
Connection: keep-alive

展开全文 >>

objection源码阅读

2020-12-04

objection源码阅读

前言

本人学Android逆向也就短短数月，对Frida的开发还很稚嫩遂决定通过阅读优秀源码的方式去提升自己的Frida水平，内容并不一定很干，但是纯原创哈~

objection的Java.perform封装

所在文件objection/agent/src/android/lib/libjava.ts
objection是基于Frida进行开发的，Frida中需要在Java.perform()函数当中进行Java的Hook操作。objection对该函数进行了其的进一步封装。

// all Java calls need to be wrapped in a Java.perform().
// this helper just wraps that into a Promise that the
// rpc export will sniff and resolve before returning
// the result when its ready.
export const wrapJavaPerform = (fn: any): Promise<any> => {
	return new Promise((resolve, reject) => {
		Java.perform(() => {
			try {
				resolve(fn());
			} catch (e) {
				reject(e);
			}
		});
	});
};

resolve，reject，分别表示异步操作执行成功后的回调函数和异步操作执行失败后的回调函数。
通过Promise进行异步回调操作我们的Hook操作并进行了异常捕获。实际上，只是原封不动的执行我们的Hook，但是加上了异步操作，和异常捕获。

获取R class

在Android开发当中，我们通过R.id.xx获取那些按钮等等数据来创建按钮等等，而这个R，在objection竟然也有对其的操作。

// A helper method to access the R class for the app.
// Typical usage within an app would be something like:
//  R.id.content_frame.
//
// Using this method, the above example would be:
//  R("content_frame", "id")
export const R = (name: string, type: string): any => {
  const context = getApplicationContext();
  // https://github.com/bitpay/android-sdk/issues/14#issue-202495610
  return context.getResources().getIdentifier(name, type, context.getPackageName());
};

获取Context对象

这里的getApplicationContext(),objection也对这个全局Context对象进行了Hook。

export const getApplicationContext = (): any => {
	const ActivityThread = Java.use("android.app.ActivityThread");
	const currentApplication = ActivityThread.currentApplication();

	return currentApplication.getApplicationContext();
};

可以看到其本质上还是通过ActivityThread来拿到Context对象。

通过Android源码得知，currentApplication()是一个静态函数，所以可以直接调用获取到Application,由于Application实际上是继承与ContextWrapper,该类直接继承Context类，并提供了多种使用的方法

-ps : Broadcast类的收发，service的启动停止也在这里！看来四大组件跟它无法分离！

其中就包裹了我们需要的getApplicationContext()

其实我们获取Application其实也就是需要其继承的这个函数。通过该函数拿到Context这个对象。

ps: 这个对象有些APP拿来用来传递参数等等，以前有碰到但是没解决，现在可以了。感谢objection教学。感谢毛子。

获取当前Activity

export const getCurrentActivity = (): Promise<ICurrentActivityFragment> => {
  return wrapJavaPerform(() => {
const activityThread: ActivityThread = Java.use("android.app.ActivityThread");
const activity: Activity = Java.use("android.app.Activity");
const activityClientRecord: ActivityClientRecord = Java.use("android.app.ActivityThread$ActivityClientRecord");

const currentActivityThread = activityThread.currentActivityThread();
const activityRecords = currentActivityThread.mActivities.value.values().toArray();
let currentActivity;

for (const i of activityRecords) {
	const activityRecord = Java.cast(i, activityClientRecord);
	if (!activityRecord.paused.value) {
	currentActivity = Java.cast(Java.cast(activityRecord, activityClientRecord).activity.value, activity);
	break;
	}
}

if (currentActivity) {
	// Discover an active fragment
	const fm = currentActivity.getFragmentManager();
	const fragment = fm.findFragmentById(R("content_frame", "id"));

	return {
	activity: currentActivity.$className,
	fragment: fragment.$className,
	};
}

return {
	activity: null,
	fragment: null,
};
  });
};

展开全文 >>

抓包全解

2020-12-01

抓包全解

抓包核心原理

抓住数据包在明文状态下的一切的时机。数据包通过HTTP框架发送出去->系统框架发送出去（即Java层到Native层），最终到内核调用把包发出去，这个过程就是所说的一切时机。内核发出去之后又到了中间路由器->各种网关->服务器。（然后又返回，在系统中作为文件（网卡也是一种文件），然后再作为流返回->然后到Native->Java层->HTTP框架层）

HTTP + SSL + 认证 + 完整性保护 = HTTPS

ps :认证和完整性保护由SSL提供

抓包的方案

hook
中间人抓包（原理：把一段通信切割成两段通信）

虚拟机网络适配器浅析

NAT

让虚拟机成为当前电脑的子网。在子网内要设置手机的流量流经虚拟机，所以抓包时不可以设置为NAT，因为他是在电脑的子网中，虚拟机可以访问到手机，而手机不能访问到虚拟机（有去无回），要设置在虚拟机里面的抓包，首先需要把手机设置为虚拟机里面才行，此时虚拟机里面需要作为服务器。那如何使得虚拟机成为一个服务器——设置为桥接模式。

桥接模式

桥接模式就是将主机网卡与虚拟机虚拟的网卡利用虚拟网桥进行通信。在桥接的作用下，类似于把物理主机虚拟为一个交换机，所有桥接设置的虚拟机连接到这个交换机的一个接口上，物理主机也同样插在这个交换机当中，所以所有桥接下的网卡与网卡都是交换模式的，相互可以访问而不干扰。在桥接模式下，虚拟机ip地址需要与主机在同一个网段，如果需要联网，则网关与DNS需要与主机网卡一致。

如何设置虚拟机为桥接模式

这里设置为桥接模式，这样就可以了嘛？还不行！！！

再打开这个

选择当前网卡。这样就算设置完成了。如何验证？

可以看到此时当前的IP和物理机的IP处于相同的级别就是设置成功了~

ps：windows如何查看当前网卡
右键当前使用的网络，我这里使用wifi就点wifi的图标

点击属性

下拉即可找到

客户端校验服务器

HTTPS链接当中，客户端是一定会校验HTTPS的。

hook证书校验

function hook_KeyStore_load() {
    Java.perform(function () {
        var ByteString = Java.use("com.android.okhttp.okio.ByteString");
        var myArray=new Array(1024);
        var i = 0
        for (i = 0; i < myArray.length; i++) {
            myArray[i]= 0x0;
         }
        var buffer = Java.array('byte',myArray);
        
        var StringClass = Java.use("java.lang.String");
        var KeyStore = Java.use("java.security.KeyStore");
        KeyStore.load.overload('java.security.KeyStore$LoadStoreParameter').implementation = function (arg0) {
            console.log(Java.use("android.util.Log").getStackTraceString(Java.use("java.lang.Throwable").$new()));

            console.log("KeyStore.load1:", arg0);
            this.load(arg0);
        };
        KeyStore.load.overload('java.io.InputStream', '[C').implementation = function (arg0, arg1) {
            console.log(Java.use("android.util.Log").getStackTraceString(Java.use("java.lang.Throwable").$new()));

            console.log("KeyStore.load2:", arg0, arg1 ? StringClass.$new(arg1) : null);

            if (arg0){
                var file =  Java.use("java.io.File").$new("/sdcard/Download/"+ String(arg0)+".p12");
                var out = Java.use("java.io.FileOutputStream").$new(file);
                var r;
                while( (r = arg0.read(buffer)) > 0){
                    out.write(buffer,0,r)
                }
                console.log("save success!")
                out.close()
            }
            this.load(arg0, arg1);
        };

        console.log("hook_KeyStore_load...");

// android.content.res.AssetManager$AssetInputStream@9b10ad6 bxMAFPL9gc@ntKTqmV@A

// android.content.res.AssetManager$AssetInputStream@41ce8f6 }%2R+\OSsjpP!w%X

// android.content.res.AssetManager$AssetInputStream@54858e6 cods.org.cn

    });
}

证书转换工具： http://keystore-explorer.org/

服务器校验客户端

是可选项。一般对APP的版本有做要求，对版本的迭代要求比较高时会有做校验。对安全性考虑特别到位的APP才会考虑。

VPN抓包

VPN抓包，系统上会开启一个新的网卡，导致流量会流经到VPN这个网卡上，网卡属于网络层，也就多了一个IP选址及路由选址。由于Burpsuite不支持Socks抓包（Socks属于传输层，该层用于建立、管理和维护端到端的连接），所以我们可以通过VPN把流量导入到Charles当中。

VPN的检测

VPN检测多种多样，肉师傅有介绍了两种：

java.net.NetworkInterface.getName()是否等于”tun0”或”ppp0”。
android.net.ConnectivityManager.getNetworkCapabilities也可检测到，可通过返回为Null解决。

还可以通过查看当前的路由表等等来检测

导出APP证书，但是还是网络异常(SSL pinning)

此时说明在APP里有进行证书的校验，即客户端校验服务器（SSL pinning）

现象：告诉你证书没有配好，其实你已经配好了
原因：在代码中进行了二轮校验->bypass 进行hook代码

要hook解决ssl pinning的问题时，首先需要知道怎么开发ssl pinning。

SSL pinning（证书固定）的概念

通过名称为证书固定的技术，应用可以更好地保护自己，免受以欺诈方式颁发的证书的攻击。这里基本上使用上面未知 CA 案例中提供的示例，将应用的可信 CA 限制在一个很小的 CA 集范围内，应用的服务器将使用该集合。这样可以防止因泄露系统中其他 100 多个 CA 中的某个 CA 而破坏应用安全通道。

总结：将可信的证书的范围缩小，使得APP只信任一小部分的证书。

该篇文章有进行详细介绍Android Security: SSL Pinning (可能需要FQ)

ssl最常见的开发用法就是这个API造成的。

Okhttp上是这样写以此进行证书的绑定。

其实具体的内容都在刚才的文章里面（我就不copy了）
其实Hook ssl pinning的代码在objection里也有啊，不过不一定管用

肉丝后面有推了这个项目:
https://github.com/WooyunDota/DroidSSLUnpinning瘦蛟舞大佬的

当我们使用objection的解ssl和瘦蛟舞大佬的库都没有用的时候，我们有理由相信其使用了一些代码混淆技术使我们没办法Hook到SSL pinning。

混淆后的证书解绑定

此时我们该:

确认该APP使用了什么网络框架
诸如okhttp3这样要进行SSL pinning绑定时，需要对证书文件进行hash计算，然后才能进行绑定，从系统的角度来说，此时我们需要HOOK打开文件的函数，查看有没有打开证书。例如下图
肉丝在课上进行了File的构造函数进行Hook之后，可以看到APP打开了这个证书进行证书的读取。

我们看到框出来的部分，可以看到其是来自于Okhttp3框架的实现SSL pinning，我们通过wallbreaker在内存当中去查看这个函数，然后试着去hook它，如果成功即可，不成功则继续往上或往下hook，要hook的范围就图上的那几个~

核心：反混淆，从绕不过的底层出发，比如上面就是从java.io.File出发

确定它用的哪个框架
过那个框架的hook源码->自己写一个

实战滴答清单

其实上面的截图就是滴答清单的，但是是肉师傅的流程，和我们无关，我们需要老老实实的去分析之后转换成自己的东西。

抓包

抓包没抓到，按经验来说就是证书问题，好的，那我们用代码把证书导出来。

哎！结果啥都没有。这估计是比较高级的证书校验了，我们看看objection能不能帮助我们hook到。

此时Hook肯定晚了，因为证书的绑定都在启动的时候了，把进程都杀掉之后，发现还是没有用。

我们来使用更强的与objection的ssl pinning互补的DroidSSLUnpinning,该库刚才有介绍但是还没用过，我们用来试试，万一能hook上呢？

唉，还是不行，跟objection一样，有hook到相应函数但是没有用，现在基本可以断定是有混淆了。

我们用jadx打开apk

发现该apk果然被混淆了，有可能使用了okhttp3

要从那么多代码当中快速找到我们需要hook到的证书校验。从系统本身出发。

要校验证书，肯定会校验证书的hash值，那要校验hash值，肯定需要打开证书进行校验，那我们可以hook那些Java层库，原生的Java是无法被混淆的。打开文件，那想到的肯定是java.io.File。

我们通过objection来hook File这个类，这样就不用写代码了~

可以看到这里开始打开系统证书校验hash了，我们看看相应的调用栈。

略过系统等等栈，我们先看到被混淆的地方，CertificatePinner这个可以几乎断定是使用okhttp来进行网络通信了。我们可以先看看这个类。

这个a函数返回值为void，我们盲猜使用的是okhttp，我们可以看看瘦舞蛟的Hook okhttp ssl pinning是怎么写的我们跟着hook看看。
代码如下：

结果：

挑战成功~

Socket通信抓包：TCP/IP之应用层Hook

Socket的本质：收发包的接口；可以理解为高速公里，负责承载车辆通行（负责承担信息的传输和接收），具体是什么车（不论什么包，加密和解密都无关），都与其无关，纯粹的通道（即很纯粹的收发包的作用）。Socket上跑的都是RAW DATA，纯binary。

Socket分两种：

TCP，能保证包不丢失，因为TCP需要先进行五次握手，包丢失之后还会断点重传，包发送的顺序不一样时还会进行包的重排等等
UDP，不能保证包不丢失，因为UDP只管发，不管是否有接收到。
两者的区别可以看这篇文章：cnblogs.com/fundebug/p/differences-of-tcp-and-udp.html

Socket抓包：本质不是中间人抓包->网卡流量的dump(只要流经网卡的，不论明文密文都dump下来)

SSL可以搭配很多种协议： SSL + HTTP;SSL + SMTP/POP/IMAP/protobuf等等

转储的内容已经不是Socket，而是SSL的接口（关键）

TCP/IP之应用层：HTTP+SSL
HOOK SSL框架直接得到明文
SSL Framework中有哪些有趣的API
HOOK native层直接得到明文
ssl logger源码解析

TCP/IP之网络层抓包

手机刷入Kali、获得诸多Linux实用网络层工具
在Kali Linux中，直接抓取4G卡流量
使用VNC viewer，远程连接手机上的Kali Nethunter
自制路由器，dump所有经过流量，彻底解决抓不到包
r0capture基本操作和注意点

路由器抓包

在kali的Terminal输入nm-connection-editor
把买的网卡添加进去

Mode选择Hotspot即热点

添加网卡地址

该地址随意填写就好。Save。

添加之后系统会自动进行配置，等待其配置状态为now。

此时手机就可以找到该网卡的wifi了。

连接进去，所有流量便会流经这个网卡，直接jnettop或者tcpdump、wiresharke即可。

Socket协议分析与字段溯源

逆向分析思想

堆栈回溯思想
典型的：使用java语言，发送了逐层的函数调用，最后到达socket发送的API，然后向上追溯。
APP使用JNI函数进行数据发送：堆栈回溯此时在so当中，与Java层不同，倘若两者相结合就更加复杂，如何使用libc当中的标准函数来逐层追溯到是哪个Java函数最终调用。——JNI堆栈是连通java堆栈的一个桥梁
控制流分析与数据流分析相结合思想
对字段溯源还有参数的处理的过程当中，还要有控制流分析和数字流分析相结合的思想。通过控制流分析可以获取到是通过哪个函数获取到输入的参数。数字流分析：通过关键的API得到发送网络的数据包，然后向上找，通过参数的流向向上找也是可以得到参数的处理逻辑。
关键字符串、关键API定位思想

adb shell里获取tcp/ip数据包

tcpdump -i any // 获取所有的网络端口 -s 0 // 抓所有的数据包 -w /sdcard/01.pcap // 保存到sdcard的01.pcap文件当中

完整命令如下（方便复制）：
tcpdump -i any -s 0 -w /sdcard/01.pcap

frida打印异常问题

当用frida打印不可见字符时会造成frida的异常，所以需要避免frida去打印不可见字符，不可见字符的范围对于ASCII码来说是32~126，所以当输出前需要判断当前字节是否在这范围之内，倘若在则可以进行输出，不在则跳过该字节输出。

funtion isPrintByte(byte){
    if(byte > 32 && byte < 126){
        return true;
    }
    return false;
}

堆栈回溯时最上层是线程run函数的解决办法

回溯到run()方法是因为java的所有线程的产生都来自于Thread.run()这个方法，我们要找到对应的调用这个run方法的堆栈，必须要了解线程的构成。

jmethodID:当JNI与Java层进行交互的时候，首先要获取其jmethodID,然后再通过jni的Call开头的一系列接口来完成对一系列函数的调用，同时传递给它相应的参数。当然也并不是必须是Call开头的，比如

Call开头的一系列函数实际上也是通过Invoke开头的函数来完成对一系列函数的调用。

对于一个Java线程来说，最先执行的就是Java_lang_Thread_run函数，这也是平时为什么打印堆栈时会最先打印java.lang.Thread.run的原因。因为其是所有Java函数新创建的线程的入口函数，它不会追溯到最先运行的C函数void* Thread::CreateCallback(void* arg),该函数是当前创建线程的入口C函数。因为是通过JNI调用java.lang.Thread类中的run函数，此时新线程会进入到run函数当中，然后会判断target!=null,当我们通过new Runnable的形式创建线程时，其target就对应于这个匿名内部类当中的run方法的实例。

JNI Socket通信抓包

TCP使用send发送，recv接收。

JNI层的socket通信可以直接使用原生的OpenSSL以及谷歌的BoringSSL（基于OpenSSL）来进行通信，也还可以使用JNI层的SSL服务器来建立安全的通信方式。

展开全文 >>

Xposed学习笔记

2020-11-23

与Frida的原理不同

Frida: 基于Ptrace对每个进程进行attach。
Xposed: 替换/system/bin/app_process程序，进而控制孵化器Zygote,使得app_process在启动过程中会加载XposedBridge.jar这个jar包，从而完成对Zygote进程及其创建的Dalvik/Art虚拟机的劫持。也使得我们可以不修改APK源码的情况下，通过自己编写的模块来影响程序运行的框架服务。

学习资料

入门看这篇文章：
新手不要再被误导！这是一篇最新的Xposed模块编写教程

Xposed插件编写

拷贝XposedBridgeApi.jar到新建工程的libs目录
修改app目录下的build.gradle文件，在AndroidManifest.xml中增加Xposed相关内容
新建hook类，编写hook代码
新建assets文件夹，然后再assets目录下新建文件xposed_init,在里面写上hook类的完整路径

展开全文 >>

加密与解密算法秘钥分析

2020-11-18

密码学初步认识

加解密算法基本原理和分类

加密的概念

将明文变换为密文的过程。把可懂的语言变换成不可懂的语言，这里的语言指的是人类能懂的语言和机器能懂的语言。

解密的概念

加密的逆过程。即由密文恢复出原明文的过程。把不可懂的语言变换成可懂的语言。

加密与解密通常是在一组密钥控制下进行的，分别称为加密密钥(Encryption Key)**和解密密钥(Decryption Key)**。

加解密算法的基本分类

简单分类

对称密码：即加密与解密使用相同密钥，典型的有RC4、DES、AES等。
非对称密码：即加密与解密时使用不同密钥，典型的有RSA、ECC椭圆曲线等。该种加解密是为了解决密钥的分发。当使用对称密码进行加密时，因为对称密码使用相同的密钥进行加解密，所以一旦密钥被第三方获取则会造成信息的泄露。
散列算法：又称哈希函数，对不同长度的输入消息，产生固定长度的输出。这个固定长度的输出称为原消息的“散列”或“消息摘要”(Message digest)。

对称密码分类

序列密码（流密码）：将明文消息按字符逐位进行加密。典型的有：RC4。
分组密码：将明文消息分组（每组有多个字符），逐组进行加密。

如何区分这两种分类
分组密码是按照分组进行处理，如果最后一组的字节数不够一组需要进行填充从而导致最后的密文要比明文要长一些，而且密文的长度是明文的整数倍。

不是密码的密码之——BASE64

严格意义上来说BASE64不是一种密码算法，它是一种编码。
历史背景：将任意不可见的字符编码为可见的字符，从而在超文本传输协议上进行传输。

BASE后面的数字代表什么

代表着用多少种字符去编码原有的128字节的内容。

BASE64算不上加密的原因是其不涉及加密密钥，因此，只要得到了对应的编码算法，也就是拿到了对应的密钥。

BASE64编码原理

BASE64编码是网络上最常见的用于传输字节信息的编码方式之一，BASE64就是一种基于64个可打印字符来表示二进制数据的方法。其他BASE家族的原理也是相同的。

基本原理

用64个可见字符来表示8bit为二进制，下图为BASE64中的64个可见字符（还有’=’用于填充符也算在内）。即用2^6=64,6位来表示8位的字节。

ps: 当BASE64编码之后没有出现=号时，说明其长度为3的整数倍。

示例解释：
用6位表示8位的内容，这两个的最小公倍数是24，如果想用BASE64恰好完整表示，则需要3个字节的内容，因为3个字节是24位，刚好能对应BASE64当中的4单元，此时不会出现填充。

后面是一个“=”，则说明它填充了一个单元才凑成6的整数倍，原有的有多少个字节呢？假如是三个字节3*8=24位，4个字节4*8=32位，则5*6=30还需要填充两个“=”才能凑成3的倍数，也就是说编码前的长度为3x + 2,如果是两个“=”，则说明其填充了两个字节,也就是3x+1个字节的长度。

举例说明

ps: 字符串转二进制的网站: http://www.txttool.com/wenben_strbinary.asp

BASE64是用6位来替代8位，这里的6位为010000,对应的编码表的码值为0 * 2 ^ 0 + 0 * 2 ^ 1 + 0 * 2 ^ 2 + 0 * 2 ^ 3 + 1 * 2 ^ 4 + 0 * 2 ^ 5 = 16,即从右往左计算，16对应BASE64的编码表的Q

此时后面还剩下2位，不足6位，则我们需要补0，最后为010000,同上的计算方式，此时又可以得到一个Q，然后**由于‘A’只占1个字节，不是3的倍数，所以需要补上2个=来凑，即最后的结果为QQ==**。长度计算，按刚才得出的结论，由于有两个等号，对应公式为3x+1的编码内容长度。

推测原内容长度倍数的过程

上面原本我听课程的时候还是有点模糊的，后面看到寒冰老师的实战之后突然悟了，寒冰老师牛逼！
先通过两个==号，可以推出原内容长度的公式是3X+1，然后，具体如何计算X这个倍数，我是这么去理解的，首先，3个字节对应4个单元，如上面的计算结果QQ==,长度为4，也就是1个字节，但是其是通过靠补充两个=号之后形成的，我是这么理解的，4个单元等于3个字节，也就是4个单元为一组BASE64有效编码长度，则这里不补充等号的情况下为QQ,即两个单元，不足以凑成1个有效的BASE64长度，所以倍数为0，即长度=3 * 0 + 1，而原字符为，’A’。这样就可以证明我的理论还是对的。

再证明一个，原字符串ab,BASE64之后的结果为YWI=，按上面的理论来看，1个等号，其对应的公式为3X+2,由于其长度不足一个BASE64长度（YWI为长度为3，而有效长度为4），即X = 0，则其的原长度 = 3 * 0 + 2。所以长度的倍数是这么去推导的。

这里我给出我的X倍数的公式：
**X = 补位符前的数字长度 / 4**,如果没有补位，则之前用输出的结果的长度 / 4即可。

下面这个例子也是一样的，就不展开说了。最后只有1个等号是因为BC已经是两个字节了还差1个字节那就需要补1个=号即可。

Android自带的BASE64类库

正向开发的用法：

import android.util.Base64;

class xxx{

	public static String base64encode(String content){
		// 字符串content先转成字节数组
		String result = Base64.encodeToString(content.getBytes(), 0);
		return result;
	}
}

上面的这个函数就实现了Base64的编码。

BASE64快速识别

输出字符串的内容
输入输出字符串的长度
逆向分析时明显的编码表以及查表的过程

不管啥加密，通过重放攻击，即主动调用加解密，观察输入输出来判断加解密算法十分重要。

Frida Hook动态加载Dex的apk的注意事项及相应的应对措施

当一个APP可能使用动态加载技术去加载插件中的dex时，frida hook使用的classLoader很可能不是Frida正在使用的ClassLoader,此时Java choose，或者use都无法获得到相应的结果。

解决方法：
通过遍历当前的ClassLoader,对于所有的ClassLoader，都可以尝试去加载我们需要Hook的类或者函数。

findcrypt-yara

github: https://github.com/polymorf/findcrypt-yara
该库为IDA插件，通过判断so层当中诸如s盒等加密特征来快速判断该so使用了什么加密算法，便于快速定位和加解密。

其基于一定的规则在so当中进行查询加密算法，其规则的定义是在findcrypt3.rules文件当中。

比如我们在这个文件里面添加了标准DES的S盒检测和E_Table的检测

// 标准DES SBOX
rule StandardDES_sboc
{	meta:
		author = "juziss"
		date = "2021-01"
		description = "Standard DES [sbox]"
	strings:
		$c0 = { 0E 00 00 00 04 00 00 00 0D 00 00 00 01 00 00 00 }
	condition:
		$c0
}

// E_Table
rule StandardDES_sboc
{	meta:
		author = "juziss"
		date = "2021-01"
		description = "DES [E_Table]"
	strings:
		$c0 = { 20 00 00 00 01 00 00 00 02 00 00 00 03 00 00 00 }
	condition:
		$c0
}

序列密码之RC4理论篇

序列密码（流密码）的体制模型

RC4的概念

RC4（来自Rivest Cipher 4的缩写）是一种流加密算法，密钥长度可变。在给定一密钥时，会生成一固定序列的字节流，用于和明文进行异或。它加解密使用相同的密钥，因此属于对称加密算法。RC4已经成为一些常用的协议和标准的一部分。如，1997年的WEP和2003/2004年的WPA;和1995年的SSL，以及后来1999年的TLS。让它如此广泛分布和使用的主要因素是它不可思议的简单和速度，不管是软件还是硬件，实现起来都十分容易

RC4的原理主要包括初始化算法（KSA）和伪随机子密码生成算法（PRGA）两个部分。用户输入一个指定长度的Key(具体长度由用户决定)，然后通过KSA以及PRGA之后生成秘钥流（用于加密和解密数据），加解密的原理都是通过对这个秘钥流进行XOR（异或）生成密文或者明文。

目前对RC4加密算法，只能是用暴力破解，安全性可以保证。

KSA（初始化）算法

ps: 参数1是一个char型的数组，定义为unsigned char sBox[256] ; 参数2是密钥；参数3为密钥的长度。

密钥的主要功能是将S-box（一般用来存储状态向量）搅乱。

该函数return 一个特定密钥长度的状态向量S-box

RC4的密钥长度由上可知为：1~256个字节。

伪随机子密码生成算法（PRGA）

ps: 参数1是被搅乱的S-box；参数2是需要加密的数据data。

经过了PRGA算法，可以确保任一给定密钥key都可以得到一个确定的用于和明文异或的字节流序列进行加密。明文长度是多少，密文长度就是多少。

RC4原理总结

在KSA阶段，需要有长度为256的状态向量即S盒的参与，并会有两轮256大小的循环，对状态向量s盒进行扰乱;
在PRGA阶段，会有循环次数为加密内容字节数的循环体，每一次循环中都会有状态向量即s盒的参与，并会重新扰乱s盒生成新的状态向量
RC4作为对称密码中的序列密码，没有特别的常量的存在，256算是多次出现的数字;

RC4加密算法在逆向分析过程中的快速识别方法

首先判断明文和密文长度是否相等，等长则代表是序列密码。（可以通过编写frida脚本或xposed插件完成对相应函数的主动调用，判断当输入明文为任意长度时的密文长度)
接下来判断是否是RC4。RC4算法中的初始化算法（KSA）中有两轮非常显著的长度为256的循环体，用于根据给定的key生成s盒;伪随机子密码生成算法（PRGA)会根据上一步得到的扰乱的s盒，进一步生成子密钥流，最终和给定的明文进行逐字节的异或;

分组密码之DES

分组密码的缺点：当分组的长度不足一组，则需要进行填充。这会导致分组密码当中其密文长度是明文的整数倍。有可能会导致密文长度比明文长度要长，除非密文的长度是分组长度的整数倍时，不需要填充，此时将导致明文和密文的长度相等。

DES定义

DES算法为对称密码当中的分组密码。为IBM公司于1972年研制。其加密的规则为明文按64位(8个字节为1组)进行分组，密钥长64位。而事实上是56位参与DES运算（第8、16、24、32、40、48、56、64为校验位即每个字节的最高位作为校验位，使得每个密钥都有奇数个1），分组后的明文组和56位的密钥按位替代或交换的方法形成密文组的加密方法。

DES（数据加密标准）算法主要采用替换和移位的方式进行加密，它用56位（64位密钥只有56位有效）对64位二进制数据块进行加密，每次加密对64位的输入数据进行16轮编码,经过一系列替换和移位后，输入的64位原数据转换成完全不同的64位输出数据。DES作为分组密码，主要的实现过程由两部分组成，分别是密钥的生成以及明文的处理。其中每一个分组的明文的处理分为16轮进行，而对于每一轮都需要使用密钥编排部分生成的子密钥参与运算。

Android Java层使用DES

Android本身提供了用于加解密的类:javax.crypto.Cipher类，直接使用即可，其中的DES代表使用DES加密算法,CBC代表分组加密的工作模式，PKCS5Padding代表分组的填充方式;在加解密的过程中，主要的密钥和IV是在Cipher类中的init函数进行传递的，因此，只需要hook该函数即可获取到密钥和IV;

DES明文处理流程

明文处理流程中的常量表

在针对每一个明文分组即64位数据进行处理的流程中，需要有大量的常量表的参与，从而完成对明文的混淆、扩散处理。那么，都有哪些常量表呢?主要有:初始置换IP(8x8)，即与之对应的逆初始置换表（8x8);同时，还有在f函数中的扩展置换E表（8x6），用于将32位的输入，扩展成48位;加下来还有s-盒的参与，共计有8个s-盒(4x16)。这些常量都是快速判断DES加密算法的标志。

双重DES和三重DES

双重DES

中间相遇攻击：
构造一个表，左边是明文，右边是密文，先尝试对最终的密文C（对应上图）进行查询，然后在表中查到一个明文，再根据这个明文查到对应左侧的明文。

三重DES

分组加密之AES

AES分三种实现

以AES-128为例，会对明文分组进行10轮迭代运算，加密的第1轮到第9轮的轮函数一样，包括4个操作:字节替换、行位移、列混合和轮密钥加。最后一轮迭代不执行列混合。另外，在第一轮迭代之前，先将明文和原始密钥进行一次异或加密操作。

每16个字节为一组，密钥也需要达到16个字节。

AES实现

AES加密后特征

不管明文的长度为多少，其最后得出来的密文的长度都为分组大小的整数倍。

AES加密原理

与DES一样由两部分组成，左边是对明文进行10轮的迭代处理，右边是对密钥（即16字节的明文密钥）进行一个密钥编排，然后生成对应的每一轮的子密钥。

DES会对64位进行分组，分成左右两个部分32个字节分别进行处理，而AES不同，其每一次都是128位一个分组一块进行处理。因此，其轮密钥也是128位的。

字节替换:

字节替换的主要功能是通过s盒完成一个字节到另外一个字节的映射。本质上就是一个查表操作。这里直接给出构造好的结果，右图上方为S盒，右图下方为S-1(S盒的逆）。S盒用于提供密码算法的混淆性。可以说，S盒是快速判断AES加密算法的最有效的特征。

行位移

行位移是一个4x4的矩阵内部字节之间的置换，用于提供算法的扩散性。

正向行位移
正向行位移用于加密，其原理图如才图。其中:第一行保持不变，第二行循打左移8比特，第三行循环左移16比特，第四行循环左移24比特。
逆向行位移
逆向行位移即是相反的操作，即:第一行保持不变，第二行循环右移8比特,第三行循环右移16比特，第四行循环右移24比特。

列混淆

列混淆:主要用于提供AES算法的扩散性。在具体计算时，对列混淆矩阵（常量表）相乘得到结果。

轮密钥加

加密过程中，每轮的输入与轮密钥异或一次（当前分组和扩展密钥的一部分进行按位异或）;因为二进制数连续异或一个数结果是不变的，所以在解密时再异或上该轮的密钥即可恢复输入。

密钥扩展

密钥扩展的复杂性是确保算法安全性的重要部分。当分组长度和密钥长度都是128位时, AES的加密算法共迭代10轮，每一轮最后要与一个子密钥进行轮密钥加，再加上最开始的一次轮密钥加，即一个分绒共需要扩展为11个128的轮密钥。AES的密钥扩展算法是以字为一个基本单位（一个字为4个字节），刚好是密钥矩阵的一列。因此4个字（128位）密钥需要扩展成11个子密钥，共44个字。

ECB模式不需要IV

分组密码的填充和工作模式

分组密码对每一个固定大小的明文分组进行加密处理。

分组密码首先会面临两个问题。如下标题

明文长度不够一个分组怎么办

对原文进行填充。对不够一个分组大小时，制定一定的标准进行填充，使加密内容的长度到达一个分组大小即可。

在解密时，按照相同的标准再将填充部分删掉即可。

分组密码的填充标准

常见的填充标准以PKCS5PADDING和PKCS7PADDING

PKCS5PADDING的块大小应为8个字节，而PKCS7PADDING的块大小可以在1~255的范围内。当原始数据正好就是16长度时，因为PKCS#7规定Padding必须存在，因此即使原始数据是16的整数倍，也需要在末尾追加16字节的Padding,即正好追加一个块，这个块每个字节都是0x10

ANSI X.923
该字节填充方式以00字节填充并在最后一个字节处定义填充的字节数。

ISO 10126
该字节填充方式规定填充的字节应当为随机数，并在最后一个字节处定义填充的字节数。

ISO7816-4PADDING
填充至符合块大小的整数倍，填充值第一个字节为0x80，其他字节填0

ZEROBYTEPADDING
填充至符合块大小的整数倍，填充值为0

X923PADDING
填充至符合块大小的整数倍，填充值最后一个字节为填充的数量数，其他字节填0

TBCPADDING(Trailing-Bit-Compliment)
填充至符合块大小的整数倍，原文最后一位为“1”时填充0x00，最后一位为“0”时填充“0xFF”

NOPADDING
不填充，在此填充下原始数据必须是分组长度大小的整数倍，非整数倍时无法使用该模式，在Java当中的报错如下。

需要加密的明文过长时怎么办

对需要加密的所有明文进行分片，按照每个片的长度为一个分组进行处理即可。
此时又会引申出一个问题，每一片明文甚至每一片明文加密得到的密文之间的关系的问题，以及IV（初始矩阵，初始向量）的概念。
可以通过下面的内容来解决。

IV 初始矩阵

作用：当两个明文相同，密钥也相同的情况下，IV的作用是使得这两个明文和相同的密钥能分别生成出不同的密文。

分组密码的工作模式

ECB（电子密码本）
英文全称：Electronic Code Book,用相同的密钥分别对明文分组独立加密。
典型应用：单个数据的安全传输（例如一个加密密钥）
缺陷：一串待加密的明文里面有两组明文是相同的，此时会产生出两组相同的密文。即相同的明文会产生相同的密文。
优点：效率高，可以并行计算
CBC（密码分组链接）
英文全称：Cipher Block Chaining, 加密算法的输入时上一个密文组合与下一个明文组的异或。
典型应用：面向分组的通用传输或者认证

明文先跟IV进行异或，然后再用密钥进行加密，如果没有引进IV，还是会导致像ECB的缺点一样相同的明文产生相同的密文，引入IV则因为IV可以变换以至于产生的密文不同。然后第一组产生的密文又跟下一组的明文进行异或，所以相同的明文与密钥因为IV的不同产生的结果也不同。
OFB（输出反馈）
英文全称：Output Feed Back,与CFB类似，只是加密算法的输入时上一次加密的输出，并且使用整个分组
典型应用：噪声信道上的数据流的传输（如卫星通信）
优点：可转换为流密码

密钥对初始向量IV进行加密生成子秘钥Key,用Key对明文进行异或，产生密文。接着子秘钥Key又被密钥进行加密，生成第二个子秘钥Key2，然后再用这个子秘钥在跟分组明文进行异或生成密文，以此类推。
CFB（密文反馈）
英文全称：Cipher Feed Back, 一次处理s位，上一块密文作为加密算法的输入，产生的伪随机数输出与明文异或作为下一单元的密文
典型应用：面向分组的通用传输或者认证
优点：可转换为流密码

与OFB相似，不同点在于CFB会用分组加密得到的密文作为下一组的加密的IV进行加密，以此类推。
CTR（计数器）
英文全称：Counter,每个明文分组都与一个经过加密的计数器相异或。对每一个后续分组计数器递增。
典型应用：面向分组的通用传输或者用于高速需求
优点：因为其每一个产生的子秘钥IV与明文无关，所以可并行计算，可转换为流密码
GCM（伽罗瓦计数器模式）
上述的5种分组加密的工作模式只是提供了机密性，但并没有提供消息认证，即不保证消息不被意外或者恶意篡改。此时需要采用分离的消息验证码，例如CBC-MAC。GCM提供了提供了机密性以外还增加了消息验证。简称AE（Authenticated Encryption）。

非对称密码之RSA

RSA一般用于密钥的分发。

RSA密码算法当中加密和解密使用的是不同的密钥，因此被称之为非对称密码。RSA原理来自数论相关知识。

RSA公开密钥密码体制原理

根据数论，寻求两个大素数比较简单，而将他们的乘积进行因式分解却极其困难，因此可以将乘积公开作为加密密钥。

RSA中的填充

为什么RSA的Padding总是让人绞尽脑汁呢?因为RSA的Padding不只是Padding。为什么这么说呢?我们上面提到过，Padding最初只是用来填充数据到指定长度，而RSA通常不会加密特别长的数据，因此没有分组模式的概念，对于RSA来说Padding是既有分组模式的概念，又有随机数的概念。即RSA的Padding包含了将数据填充到RSA密钥位数的长度的方法，还有填充随机数到RSA原文的方法。

PKCS1-v1.5 Padding: 根据RFC 3447描述PKCS1-V1.5 PaddingEM= Ox00 | |Ox02 || PS | | Ox00|| M，其中EM是填充过的消息，M是原文，PS是随机数长度为RSA len - 3 - M len方法很简单也很直观。如果也和对称加密一样大家都用这个Padding方案，那也就不会有各种各样RSA的Padding问题了，然而PKCS1Padding却存在漏洞。

2.RSA-OAEP和RSASSA-PSS: 为了解决PKCS1 Padding的各种问题人们又针对签名和加密场景分别提出了RSA-OAEP和RSASSA-PSS这两种Padding方案。根据RFC 8017描述Padding的生成过程相当复杂，有12步。其中包含了生成hash并填充到原文中。

Java代码中使用RSA

密码学中的HASH算法

Hash，一般翻译做散列、杂凑，或音译为哈希，是把任意长度的输入（又叫做预映射pre-image）通过散列算法变换成固定长度的输出，该输出就是散列值。这种转换是一种压缩映射，也就是，散列值的空间通常远小于输入的空间，不同的输入可能会散列成相同的输出，所以不可能从散列值来确定唯一的输入值。简单的说就是一种将任意长度的消息压缩到某一固定长度的消息摘要的函数。

HASH算法之CRC32

CRC检验原理实际上就是在一个p位二进制数据序列之后附加一个r位二进制检验码(序列)，从而构成一个总长为n=p+r位的二进制序列;附加在数据序列之后的这个检验码与数据序列的内容之间存在着某种特定的关系。如果因干扰等原因使数据序列中的某一位或某些位发生错误,这种特定关系就会被破坏。因此，通过检查这一关系，就可以实现对数据正确性的检验。

优点:检错能力极强，开销小，易于用编码器及检测电路实现。从其检错能力来看，它所不能发现的错误的几率仅为0.0047%以下。从性能上和开销上考虑,均远远优于奇偶校验及算术和校验等方式。

CRC本质

是模-2除法的余数，采用的除数不同，CRC的类型也就不一样。通常，CRC的除数用生成多项式来表示。最常用的CRC码及生成多项式名称有CRC-12、CRC-16、CRC-32，对应的输出即hashvalue分别为12位、16位和32位。

Java当中使用CRC32
Java类：java.util.zip.CRC32

SHA家族特点

展开全文 >>

Frida日常使用总结

2020-11-14

Frida逆向与利用自动化

动静态hook

动态函数：需要得到其实例（$new或Java.choose）,如果是Java.choose则在onMatch进行具体操作；
静态函数：直接用Java.use出来的类来调用具体的静态函数即可。

逆向三段

hook
打印函数的参数、调用栈、返回值
invoke
方法重载、参数构造、动静态处理
rpc
主动调用、忽略内部细节，直接返回结果。

打印调用栈(Java)

1
2
3

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

打印byte数组

function printByteArray(byteArray){
    var content = '';
    for(var i = 0;i < byteArray.length; i++){
        if(byteArray[i] > 32 && byteArray[i] < 126){
            content += String.fromCharCode(byteArray[i])
        }
    }
    console.log(content);
}

构造参数

数组/（字符串）对象数组/gson/Java.array

gson:

/**
 * 通过肉丝姐编译的gson转换Object成json对象,需要用时需要把函数体内的代码迁移到相应位置即可
 */
function objectToGson(obj){
    Java.openClassFile('/data/local/tmp/r0gson.dex').load();
    const gson = Java.use('com.r0ysue.gson.Gson');
    var result = gson.$new().toJson(obj);
    return result;
}

Java.array示例：

1 2	// 构建一个byte[] var byte = Java.array('byte', [1, 2, 3, 9]);

数组示例：

/**
 * hook Arrays toString(char)
 */
function ArraysToString(){
    var arrays = Java.use('java.util.Arrays');
    Java.openClassFile('/data/local/tmp/r0gson.dex').load();
    const gson = Java.use('com.r0ysue.gson.Gson');
    arrays.toString.overload('[C').implementation = function(x) {
        var result = this.toString(x);
        var x = gson.$new().toJson(x);
        console.log('data, result', x, result);
        return result;
    }
}

查看hook到的类的类名

$className
例如：

xxx.$init.implementation = function(){
    var result = this.$init();
    console.log(result.$ClassName);
    return result;
}

对象/多态、强转Java.cast

向下转型（多态）：
相当于
Water w2 = new Juice();
((Juice) w2).fillEnergy();

function castSon(){
	// 创建一个Juice实例
    var juiceHandle = Java.use('com.r0ysue.a0526printout.Juice').$new();
	// Water w2 = new Juice();
    var water = Java.cast(juiceHandle, Java.use("com.r0ysue.a0526printout.Water"));
    console.log(water.flow(water));
}

接口interface、Java.register

自定义实现接口:


/**
 * 通过现有接口实现一个类
 */
function implementClass(){
    var beer = Java.registerClass({
        // 我们要实现的类将要在位置
        name: 'com.r0ysue.a0526printout.Beer',
        implements: [Java.use('com.r0ysue.a0526printout.liquid')],
        methods: {
            // 要实现的接口的函数,注意，接口的话一定要实现全部哦
            flow() {
                console.log('hello beer!');
            return Java.use('java.lang.String').$new("beer");
          },
        }
      });
      console.log(beer.$new().flow());
}

枚举、泛型、List、Map、Set迭代打印

枚举的打印跟寻常的打印一样，用之前可以搜一下枚举有啥常用的自带函数，然后Java.choose搜一下相应枚举实例，再调用这些函数来进行操作即可。

其他的打印方法和Map相似

/**
 * 打印map,方法1：通过iterator()来打印
 * @param {} obj 
 */
function printMap1(){
    Java.choose('java.util.HashMap', {
        onMatch: function(instance){
            var keySet = instance.keySet();
            var iterator = keySet.iterator();
			var result = "";
            while(iterator.hasNext()){
				var keystr = iterator.next().toString();
				var valuestr = instance.get(keystr).toString();
				var map = keystr + ':' + valuestr + '||';
				result += map;
            }
                console.log('HashMap instance is:', instance, ', it args:', result);
        },onComplete:function(){console.log('search complete!');}
    })
}

/**
 * 打印Map，通过toString
 */
function printMap2(){
    Java.choose('java.util.HashMap', {
        onMatch: function(instance){
            console.log('find the Map instance', instance);
            console.log('it args:', instance.toString());
        }
    })
}

non-ascii 方法名hook

这里直接抄一下智姐姐的博客里的代码，原理是先打印原始的编码，然后再通过这个编码去hook

function x() {

          var targetClass = "com.example.hooktest.MainActivity";

          var hookCls = Java.use(targetClass);
          var methods = hookCls.class.getDeclaredMethods();

          for (var i in methods) {
              console.log(methods[i].toString());
              console.log(encodeURIComponent(methods[i].toString().replace(/^.*?\.([^\s\.\(\)]+)\(.*?$/, "$1")));
          }

          hookCls[decodeURIComponent("%D6%8F")]
              .implementation = function (x) {
                  console.log("original call: fun(" + x + ")");
                  var result = this[decodeURIComponent("%D6%8F")](900);
                  return result;
              }
      }

枚举所有的类

Java.enumerateLoadedClasses({
    onMatch:function(name, handle){
        console.log('name:', name);
    },onComplete(){}
})

查找接口的实现类

Java.enumerateLoadedClasses({
    onMatch: function(className){
        if (className.indexOf(包名) < 0){
            return;
        }
        var hookCls = Java.use(className);
        // getInterfaces()可以把当前加载的类，类所实现的interface全都打印出来。
        var interFaces = hookCls.class.getInterfaces();
        if (interFaces.length > 0){
            console.log(className);
            for (var i in interFaces){
                console.log('\t', interFaces[i].toString())
            }
        }
    }
})

Frida遍历查找API

Java.perform(()=>{
    const groups = Java.enumerateMethods("*youtube*!on*")
    console.log(JSON.stringify(groups, null, 2));
})

重要思路

开发时如何打印，frida中也是如何打印

逆向第三段——RPC

frida(rpc) 多主机多手机多端口混连

frida精髓③：互联互通

frida精髓③：动态修改

写rpc可能会用到的三个函数：

send():
用于通过frida发送信息给python
recv():
用于接收一个python传过frida这边的信息。
wait():
用于等待，直到等待到结果才会执行到代码下面。

实例：

Frida hook大全

局部变量能不能被Hook

分情况

能Hook的情况

局部变量是对象，例如String、枚举等等。

不能Hook的情况

局部变量是基本类型的时候不能被Hook

基本类型不能被构造

解决方案是构造其包装类型。

构造方法的Hook

主动调用（调用构造方法创建对象）：

1	Java.use(xxx).$new();

常规HOOK构造方法

1	Java.use(xxx).$init.implementation = function(){}

objection 源码浅析

获取当前App的所有Activity

通过Hook安卓自带的包管理类PackageManager的GET_ACTIVITIES属性来获取所有的Activity.

然后通过getApplicationContext来获取当前APP的Context,然后通过与系统函数衔接的方式获得当前APP的所有Activity。

获取当前APP所有的Service

启动一个Intent

Hook Intent

完整代码：

Java.perform(function () {
    var Activity = Java.use("android.app.Activity");
    //console.log(Object.getOwnPropertyNames(Activity));
    Activity.startActivity.overload('android.content.Intent').implementation=function(p1){
        console.log("Hooking android.app.Activity.startActivity(p1) successfully,p1="+p1);
        //console.log(Java.use("android.util.Log").getStackTraceString(Java.use("java.lang.Throwable").$new()));
        console.log(decodeURIComponent(p1.toUri(256)));
        this.startActivity(p1);
    }
    Activity.startActivity.overload('android.content.Intent', 'android.os.Bundle').implementation=function(p1,p2){
        console.log("Hooking android.app.Activity.startActivity(p1,p2) successfully,p1="+p1+",p2="+p2);
        //console.log(Java.use("android.util.Log").getStackTraceString(Java.use("java.lang.Throwable").$new()));
        console.log(decodeURIComponent(p1.toUri(256)));
        this.startActivity(p1,p2);
    }
    Activity.startService.overload('android.content.Intent').implementation=function(p1){
        console.log("Hooking android.app.Activity.startService(p1) successfully,p1="+p1);
        //console.log(Java.use("android.util.Log").getStackTraceString(Java.use("java.lang.Throwable").$new()));
        console.log(decodeURIComponent(p1.toUri(256)));
        this.startService(p1);
    }
})

肉丝收集的Frida方法

Hook startActivity和startService

通过hook这两个API来查看在页面跳转或调用服务的过程当中所携带的内容。

为啥使用toUri，因为单纯的查看Intent是无法查看其里面的内容的，需要用到toUri来对里面的内容进行转成字符串。

Hook onClick的两种方式

完整代码：

var jclazz = null;
var jobj = null;

function getObjClassName(obj) {
    if (!jclazz) {
        var jclazz = Java.use("java.lang.Class");
    }
    if (!jobj) {
        var jobj = Java.use("java.lang.Object");
    }
    return jclazz.getName.call(jobj.getClass.call(obj));
}

function watch(obj, mtdName) {
    var listener_name = getObjClassName(obj);
    var target = Java.use(listener_name);
    if (!target || !mtdName in target) {
        return;
    }
    // send("[WatchEvent] hooking " + mtdName + ": " + listener_name);
    target[mtdName].overloads.forEach(function (overload) {
        overload.implementation = function () {
            //send("[WatchEvent] " + mtdName + ": " + getObjClassName(this));
            console.log("[WatchEvent] " + mtdName + ": " + getObjClassName(this))
            return this[mtdName].apply(this, arguments);
        };
    })
}

function OnClickListener() {
    Java.perform(function () {

        //以spawn启动进程的模式来attach的话
        Java.use("android.view.View").setOnClickListener.implementation = function (listener) {
            if (listener != null) {
                watch(listener, 'onClick');
            }
            return this.setOnClickListener(listener);
        };

        //如果frida以attach的模式进行attch的话
        Java.choose("android.view.View$ListenerInfo", {
            onMatch: function (instance) {
                instance = instance.mOnClickListener.value;
                if (instance) {
                    console.log("mOnClickListener name is :" + getObjClassName(instance));
                    watch(instance, 'onClick');
                }
            },
            onComplete: function () {
            }
        })
    })
}
setImmediate(OnClickListener);

Java.use的是第一种方法，是以spwan的方式Hook所有的View，假如是以attach的方式使用attach进行hook,第一种方法，是以attach的方式进行attach，这种方式有一些View已经无法更改了（有些View的onClickListener已经获取不到了）
Java.choose是第二种方法，这种方法用来弥补第一种方法的不足的。

开源库——android-file-system-access-hook

该库的hook Java.io.File类非常的全面，甚至还Hook了libc的读写方法。当需要的时候可以看看。

Frida使用时的一些注意事项

Frida Hook动态加载Dex的apk的注意事项及相应的应对措施

当一个APP可能使用动态加载技术去加载插件中的dex时，frida hook使用的classLoader很可能不是Frida正在使用的ClassLoader,此时Java choose，或者use都无法获得到相应的结果。

解决方法：
通过遍历当前的ClassLoader,对于所有的ClassLoader，都可以尝试去加载我们需要Hook的类或者函数。

ps: 这里的catch部分应该改成catch (e)

Frida Hook Native

注意：Hook Native函数不需要再Java.perform当中进行，因为其运行已经不在Java虚拟机当中

静态注册的Hook：
与Java层思路一致，找到相应的函数名然后Hook.

首先通过Module.findBaseAddress找到要Hook的相应SO，该函数返回相应的so基地址。
通过Module.findExportByName，通过要Hook的Native的JNI层的名字（符号）来Hook。

3.通过Interceptor,插装器对Navtive函数进行Hook。

// 相当于Java.use的作用
Interceptor.attach(第二步获取到的地址， {
    onEnter: function(args){
        // 参数是一个数组，具体要获取啥参数跟传入的顺序一致。第三个参数起才是从Java层传入的参数。
        console.log("Interceptor attach function args", args[0], args[1])
    },
    onLeave: function(){}
})

主动调用Native

new NativeFunction(函数地址, 返回值类型， [参数列表类型])

替换Native函数

var replaceFunction = new NativeFunction(函数地址,  返回值类型， [参数列表类型])
Interceptor.replace(replaceFunction,  new NativeCallback(function(arg0, arg1, arg2){
    replaceFunction(arg0, arg1, arg2);
}, 返回值类型, [参数列表]))

动态注册的Hook思路

动态注册100%会走RegisterNatives,一般直接HOOK这个API即可直接拿到JNINativeMethod,然后对这个对象进行解析，解析之后可以得到Java层Native的函数名

用户代码 native hook

Module.enumerateImports()

导入表：列出所有导入的函数，即这个so里使用到的函数。

Module.enumerateSymbols()

枚举符号

Module.enumerateExports()

枚举所有导出符号，在安卓上一般用这个就可以，但是如果是系统级别的就不一定有效，此时可能会出现在符号中，因为系统的和ndk的不一样。

Memory.alloc

申请一串内存空间，返回这串空间的NativePointer

ModuleMap

创建模块快照，根据一个函数的地址来判断其属于哪个Module(即在哪个so中)。

系统框架native hook

JNI函数符号hook
示例，这里是要找NewStringUTF

// 这个是用来保存需要被HOOK的JNI函数的地址
var NewStringUTF_addr = null;
// 获取所有的符号
var symbols = Process.findModuleByName("libart.so").enumerateSymbols();
for (var i = 0; i < symbols.length; i++){
    // 获取当前遍历到的符号名
    var symbol = symbols[i].name;   
    // 符号当中可能存在CheckJNI，里面也可能掺杂着我们需要HOOK的函数符号，故这里去掉保存JNI的
    if ((symbol.indexOf("CheckJNI") == -1) && (symbol.indexOf("JNI") >= 0)){
        // 当遍历到我们需要的JNI函数时赋值
        if (symbol.indexOf("NewStringUTF")>=0){
            console.log("finally find NewStringUTF name: ", symbol);
            NewStringUTF_addr = symbols[i].address;
            console.log("finally find NewStringUTF address: ", NewStringUTF_addr);
        }
    }
}

课程示例：
用以替换NewStringUTF的返回值

JNI函数参数、返回值打印和替换
打印char*
直接在char*实例的后面.readCString();

替换char*

var temp = Memory.allocUtf8String(“要替换的字符串”);
return temp;

打印jstring (使用getStringUtfChars)

Java.vm.getEnv().getStringUtfChars(要打印参数,null).readCString();

getStringUtfChars的JNI源码：

1
2
3

const char* GetStringUTFChars(jstring, jboolean* isCopy){
    return functions->GetStringUTFChars(this, string, isCopy);
}

创建jstring

使用NewStringUTF

动态注册JNI_Onload

hook RegisterNatives

// 这个是用来保存需要被HOOK的JNI函数的地址
var RegisterNatives_addr = null;
// 获取所有的符号
var symbols = Process.findModuleByName("libart.so").enumerateSymbols();
for (var i = 0; i < symbols.length; i++){
    // 获取当前遍历到的符号名
    var symbol = symbols[i].name;   
    // 符号当中可能存在CheckJNI，里面也可能掺杂着我们需要HOOK的函数符号，故这里去掉保存JNI的
    if ((symbol.indexOf("CheckJNI") == -1) && (symbol.indexOf("JNI") >= 0)){
        // 当遍历到我们需要的JNI函数时赋值
        if (symbol.indexOf("RegisterNatives")>=0){
            console.log("finally find RegisterNatives name: ", symbol);
            RegisterNatives_addr = symbols[i].address;
            console.log("finally find RegisterNatives address: ", RegisterNatives_addr);
        }
    }
}
if (RegisterNatives_addr != null){
   Interceptor.attach(RegisterNatives_addr, {
       onEnter: function(args){
           console.log("[RegisterNatives]method counts:", args[3]);
           var env = args[0];
           var jclass = args[1];
           // 这里使用tryGetEnv()的原因是其里面有一个getClassName()函数，用来获取函数的名字,参数是jclass
           var class_name = Java.vm.tryGetEnv().getClassName(jclass);
           var methods_ptr = ptr(args[2]);
           var method_count = parseInt(args[3]);
           for (var i =0;i < method_count; i++){
               var name_ptr = Memory.readPointer(methods_ptr.add(i * Process.pointerSize * 3));
               var sig_ptr = Memory.readPointer(methods_ptr.add(i * Process.pointerSize * 3 + Process.pointerSize));
               var fnPtr_ptr = Memory.readPointer(methods_ptr.add(i * Process.pointerSize * 3 + Process.pointerSize * 2));

               var name = Memory.readCString(name_ptr);
               var sig = Memory.readCString(sig_ptr);
               var find_module = Process.findModuleByAddress(fnPtr_ptr);
               console.log("[RegisterNatives] java_class:", class_name, " name: ", name, " sig: ", sig, " fnPtr: ", fnPtr_ptr, " module_name: ", find_module);
           }

       },onLeave: function(retval){
           
       }
   })
}else{
    console.log("no find RegisterNatives address");
}

frida hook socket

function hook(){
    Java.perform(function(){
        Java.use("java.net.SocketOutputStream").socketWrite0.overload('java.io.FileDescriptor', '[B', 'int', 'int').implementation = function (fd, bytearry, offset, byteCount) {
            var result = this.socketWrite0(fd, bytearry, offset, byteCount);
            printByteArray(bytearry);
            console.log(Java.use("android.util.Log").getStackTraceString(Java.use("java.lang.Throwable").$new()).toString());
            return result;
          }
          Java.use("java.net.SocketInputStream").socketRead0.overload('java.io.FileDescriptor', '[B', 'int', 'int', 'int').implementation = function (fd, bytearry, offset, byteCount, timeout) {
            var result = this.socketRead0(fd, bytearry, offset, byteCount, timeout);
            printByteArray(bytearry);
            console.log(Java.use("android.util.Log").getStackTraceString(Java.use("java.lang.Throwable").$new()).toString());
            return result;
          }
          Java.use("com.android.org.conscrypt.ConscryptFileDescriptorSocket$SSLOutputStream").write.overload('[B', 'int', 'int').implementation = function (bytearry, int1, int2) {
            var result = this.write(bytearry, int1, int2);
            printByteArray(bytearry);
            console.log(Java.use("android.util.Log").getStackTraceString(Java.use("java.lang.Throwable").$new()).toString());
    
            return result;
          }
          Java.use("com.android.org.conscrypt.ConscryptFileDescriptorSocket$SSLInputStream").read.overload('[B', 'int', 'int').implementation = function (bytearry, int1, int2) {
            var result = this.read(bytearry, int1, int2);
            printByteArray(bytearry);
            console.log(Java.use("android.util.Log").getStackTraceString(Java.use("java.lang.Throwable").$new()).toString());
            return result;
          }
          // hook udp
          var LinuxClass = Java.use('libcore.io.Linux');
          LinuxClass.recvfromBytes.implementation = function (arg0, arg1, arg2, arg3, arg4, arg5) {
              var size = this.recvfromBytes(arg0, arg1, arg2, arg3, arg4, arg5);
              var bytearray = Java.array('byte', arg1);
              var content = "";
              printByteArray(bytearray);
              console.log("address:" + arg5 + " [" + Process.getCurrentThreadId() + "]recvfromBytes:size:" + size + ",content:" + JSON.stringify(arg1) + "---content," + content);
              console.log(Java.use("android.util.Log").getStackTraceString(Java.use("java.lang.Throwable").$new()).toString());
              return size;
          }
          LinuxClass.sendtoBytes.overload('java.io.FileDescriptor', 'java.lang.Object', 'int', 'int', 'int', 'java.net.InetAddress', 'int').implementation = function (arg0, arg1, arg2, arg3, arg4, arg5, arg6) {
              var size = this.sendtoBytes(arg0, arg1, arg2, arg3, arg4, arg5, arg6);
              var bytearray = Java.array('byte', arg1);
              var content = "";
              printByteArray(bytearray);
              console.log("address:" + arg5 + ",port" + arg6 + " [" + Process.getCurrentThreadId() + "]LinuxClass11.sendtoBytes:len:" + size + "--content:" + JSON.stringify(arg1) + "--content:" + content);
              console.log(Java.use("android.util.Log").getStackTraceString(Java.use("java.lang.Throwable").$new()).toString());
              return size;
          }
          LinuxClass.sendtoBytes.overload('java.io.FileDescriptor', 'java.lang.Object', 'int', 'int', 'int', 'java.net.SocketAddress').implementation = function (arg0, arg1, arg2, arg3, arg4, arg5) {
              var size = this.sendtoBytes(arg0, arg1, arg2, arg3, arg4, arg5);
              var bytearray = Java.array('byte', arg1);
              var content = "";
              printByteArray(bytearray);
              console.log("address:" + arg5 + " [" + Process.getCurrentThreadId() + "]LinuxClass22.sendtoBytes:len:" + size + "--content:" + JSON.stringify(arg1) + ",content:" + content);
              console.log(Java.use("android.util.Log").getStackTraceString(Java.use("java.lang.Throwable").$new()).toString());
              return size;
          }
  
    });
}

function printByteArray(byteArray){
    var content = '';
    for(var i = 0;i < byteArray.length; i++){
        if(byteArray[i] > 32 && byteArray[i] < 126){
            content += String.fromCharCode(byteArray[i])
        }
    }
    console.log(content);
}

function main(){
    hook();
}

setImmediate(main);

jnitrace

libc hook

libc函数符号hook

function hook_pthread(){
    // 1. 先打印符号或导出函数两者打印一个，存在我们想HOOK的符号即可,如果有Export存在直接通过符号拿到相应的函数，否则就继续用Symbol来拿函数
   //  var symbols = Process.findModuleByName("libc.so").enumerateSymbols();
   var symbols = Process.findModuleByName("libc.so").enumerateExport();
   // libc函数永远存在内存当中的进程里，只要进程没有被关掉，将不会被卸载
   var pthread_create_addr = Module.findExportByName("libc.so", "pthread_create");
   console.log("pthread_create_addr =>", pthread_create_addr);
   Interceptor.attach(pthread_create_addr, {
       onEnter: function(args){
           console.log("args =>", args[0], args[1], args[2], args[4]);
       },onLeave: function(retval){
           console.log(retval);
       }
   })
}

libc函数参数、返回值打印和替换

hook linker dlopen

主动调用libc读写文件

function write_content_txt(path, content){
     var fopen_addr = Module.findExportByName("libc.so", "fopen");
     var fclose_addr = Module.findExportByName("libc.so", "fclose");
     var fputs_addr = Module.findExportByName("libc.so", "fputs");

     var fopen = new NativeFunction(fopen_addr, 'pointer', ['pointer', 'pointer']);
     var fclose = new NativeFunction(fclose_addr, 'pointer', ['pointer', 'pointer']);
     var fputs = new NativeFunction(fputs_addr, 'pointer', ['pointer', 'pointer']);

     var fileName = Memory.allocUtf8String(path);
     var mode = Memory.allocUtf8String("w+");

     var fp = fopen(fileName, mode);
     var content = Memory.allocUtf8String(content);
     fputs(content, fp);
     fclose(fp);
}

frida-trace

function EnumerateAllExports(){
    var modules = Process.enumerateModules();
    for (var i = 0; i < modules.length; i++){
        var module = modules[i];
        var module_name = modules[i].name;
        var exports = module.enumerateExports();
        console.log("module_name:", module_name," module.enumerateExports => ", JSON.stringfy(exports));
        for (var m = 0;m < exports.length;m++)}{
            console.log("m==>", m);
            write_content_txt("/sdcard/somthing_apk_modules/" + module_name + ".txt", "type:"+exports[m].type + "name:"+exports[m].name + " address:",exports[m].address + "\n");
        }
    }

}

.init_array

这篇文章讲的非常好：
点我
一般，如果APP存在反调试，会把反调试的内容放在.init_array里执行，**.init_array**是一个APP加载so第一个执行的地方。各种Android加固基于ELF文件的特性，很多加固厂商在进行Android逆向的对抗的时候都会在Android的so文件中进行动态的对抗，对抗的点一般在so文件的.init段和JNI_OnLoad（该函数是JNI用于加载so，一般会在其里面进行动态注册）处。很强的加固会在.init里放一些函数，这样可以直接让这个函数跑起来，在里面对函数体进行解密。比如ollvm就是利用这样的特性，在.init函数里进行混淆。

.init段和.init_array段函数的定义方式

linker

linker64位导出符号里无法直接搜出call_function,而linker可以，区别就是一个是32位的so，一个是64位的so。要想跑32位的APP，可以在adb install时使用以下命令：
adb install --abi armeabi-v7a app_path

合并Dex

import os, sys

# python3.7 merge_dex.py ./file/ livedex


if __name__ == "__main__":
    if len(sys.argv) < 3 :
        print("start error")
        sys.exit()

    print(sys.argv[1], sys.argv[2])
    
    path = sys.argv[1] #文件夹目录
    files= os.listdir(path) #得到文件夹下的所有文件名称
    s = []
    for file in files: #遍历文件夹
        if file.find("dex") > 0: ## 查找dex 文件
            sh = 'jadx -j 1 -r -d ' + sys.argv[2] + " " + path + file
            print(sh)
            os.system(sh)

替换classloader

一些app会通过自定义classloader的方式进行调用函数，这就会导致，我们没办法在当前的classloader当中找到我们需要的类，此时Java.use(…)会报错找不到类。此时需要替换classloader;

fart使用hook ActivityThread的performLaunchActivity来获取classloader的
具体原话:

众所周知，对于一个正常的应用来说，最终都要由一个个的Activity来展示应用的界面并和用户完成交互，那么我们就可以选择在ActivityThread中的performLaunchActivity函数作为时机，来获取最终的应用的Classloader。选择该函数还有一个好处在于该函数和应用的最终的application同在ActivityThread类中，可以很方便获取到该类的成员。

原文主要讲的是fart，不过这段给我启发了，建议大家都把寒冰老师的文章都反复看多遍，每一遍都有惊喜！
https://bbs.pediy.com/thread-252630.htm#msg_header_h2_4

我这边手动实现了这个函数的classloader的替换

var InstrumentationClass = Java.use("android.app.Instrumentation");
//public Activity newActivity(ClassLoader cl, String className, Intent intent)
InstrumentationClass.newActivity.overload('java.lang.ClassLoader', 'java.lang.String', 'android.content.Intent').implementation = function(arg1, arg2, arg3){
    Java.classFactory.loader = arg1;
    console.log(arg1);
    var result = this.newActivity(arg1, arg2, arg3);
    return result;
}

后来frida_fart下又有了一个不同的点
java.lang.Runtime的loadLibrary0
直接给出代码

var RuntimeClass = Java.use("java.lang.Runtime");
// private synchronized void loadLibrary0(ClassLoader loader, Class<?> callerClass, String libname)
RuntimeClass.loadLibrary0.implementation = function(classloader,clazz,  libname){
    console.log("libname: ", libname);
    var result = this.loadLibrary0(classloader, clazz, libname);
    console.log("libname=", libname);
    Java.classFactory.loader = classloader;
}

使用该点的一大好处在于可以看到加载的so的名字。也就意味着so的加载时机可以洞察出来。

VPN检测

// 检测是否开启vpn
// 如果开启了vpn 那么会存在 名称为 tun0的网卡

function checkvpn(){
    var NetworkInterfaces = Java.use("java.net.NetworkInterface").getAll();
    var is_vpn = false;
    for (var i=0; i<NetworkInterfaces.length; i++){
        var NetworkInterface = NetworkInterfaces[i];
        if (NetworkInterface.getName() === "tun0"){
            is_vpn = true;
            break;
        }
    }
    if (is_vpn){
        console.log("检测到开启了vpn!");
    }else {
        console.log("未检测到vpn!");
    }
}


function hook_vpn(){
    var vpn = Java.use("android.net.ConnectivityManager");
    vpn.getNetworkCapabilities.implementation = function (arg){
    // 不行就return  null
    return "wifi";
    }
}

Frida Instruction模块

如上图可以看出，Instruction模块是frida的反汇编器。

创建jstring对象

var jstring = Java.vm.getEnv().newStringUtf(string);

开发的视角获取Application、Context、Log

Log

public void printLogAndStock(){
    Class logClass = null;
    long threadId = Thread.currentThread().getId();
    try {
        logClass = this.getClass().getClassLoader().loadClass("android.util.Log");
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    }
    Method loge = null;
    try {
        loge = logClass.getMethod("e",String.class,String.class);
        loge.invoke(null, "juzissStoreP12", "[Thread: " + threadId + " ]");
        Exception e = new Exception("juzissStoreP12");
        e.printStackTrace();
    } catch (NoSuchMethodException e) {
        e.printStackTrace();
    } catch (IllegalAccessException e) {
        e.printStackTrace();
    } catch (InvocationTargetException e) {
        e.printStackTrace();
    }
}

ActivityThread、ContextWrapper、包名、Application

public PrivateKey getPrivateKey() {
            /*
                  var result = this.getPrivateKey()
                  var packageName = Java.use("android.app.ActivityThread").currentApplication().getApplicationContext().getPackageName();
                  storeP12(this.getPrivateKey(), this.getCertificate(), '/sdcard/Download/' + packageName + uuid(10, 16) + '.p12', 'r0ysue');
                  var message = {};
                  message["function"] = "dumpClinetCertificate=>" + '/sdcard/Download/' + packageName + uuid(10, 16) + '.p12' + '   pwd: r0ysue';
                  message["stack"] = Java.use("android.util.Log").getStackTraceString(Java.use("java.lang.Throwable").$new());
                  var data = Memory.alloc(1);
                  send(message, Memory.readByteArray(data, 1))
                  return result;
             */
            printLogAndStock();
            Class<?> clazz = null;
            Method method= null;
            Object context = null;
            Object application = null;
            String packageName = null;
            Method getApplicationContext = null;
            Class<?> contextWrapperClass = null;
            Method getPackageName = null;
            try {
                // 拿到Application
                clazz = Class.forName("android.app.ActivityThread");
                method = clazz.getDeclaredMethod("currentApplication");
                application = method.invoke(null);

                // 拿到Context
                contextWrapperClass = Class.forName("android.content.ContextWrapper");
                getApplicationContext = contextWrapperClass.getDeclaredMethod("getApplicationContext");
                context = getApplicationContext.invoke(application, null);

                // 获取包名
                getPackageName = contextWrapperClass.getDeclaredMethod("getPackageName");
                packageName = (String) getPackageName.invoke(context, null);

            } catch (NoSuchMethodException e) {
                e.printStackTrace();
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                e.printStackTrace();
            }
            String uuid = UUID.randomUUID().toString().replaceAll("-","");
            storeP12(privKey, (X509Certificate) this.getCertificate(), "/sdcard/Download/" + packageName + uuid + ".p12", "juziss");
            return privKey;
        }

编译一个dex并让frida加载使用

写好代码，并编译好该要编译成dex的项目
找到相应的class文件
通过jar命令编译class
jar -cvf 生成的.jar 待编译的.class
通过dx命令把jar转换成dex文件
/root/Android/Sdk/build-tools/28.0.3/dx --dex --output==ddex.dex ddex.jar
（路径以实际为主）
adb push该dex到手机，并chmod赋权
frida加载即可使用

hook JNIEnv函数

例子

function hook_NewStringUTF(){
    var addr_NewStringUTF = null;
    //console.log( JSON.stringify(Process.enumerateModules()));
    var symbols = Process.findModuleByName("libart.so").enumerateSymbols();
    for(var i = 0;i<symbols.length;i++){
        var symbol = symbols[i].name;
        if((symbol.indexOf("CheckJNI")==-1)&&(symbol.indexOf("JNI")>=0)){
            // console.log(symbol)
            if(symbol.indexOf("NewStringUTF")>=0){
                // console.log(symbols[i].name);
                // console.log(symbols[i].address);
                addr_NewStringUTF = symbols[i].address;
            }
        }
    }
    // console.log("addr_NewStringUTF:", addr_NewStringUTF);
    Java.perform(function (){
        Interceptor.attach(addr_NewStringUTF, {
            onEnter: function (args) {
                var content = args[1].readCString();
                // if(content.length >= 20){

                    console.log("addr_NewStringUTF OnEnter args[0]",content);
                    // console.log(Thread.backtrace(this.context, Backtracer.ACCURATE)
                    // .map(DebugSymbol.fromAddress).join('\n') + '\n');
                // }
                // console.log(hexdump(args[0].readPointer()));
                // console.log(Java.vm.tryGetEnv().NewStringUTF(args[0])); 
            }, onLeave: function (retval) {
                // console.log("addr_NewStringUTF OnLeave: ",retval);
            }
        })
    })
}

ollvm典型特征

开头是这种.datadiv_随机字符串这种形式的字符串就是典型的ollvm混淆。这种属于最基础的防护等级，高的是搜索不到的。如果出现这种情况还是需要在.init_array当中找到相应的解密函数进行分析。

一个字符串和一个常量进行亦或，这个是ollvm的默认加密方案。即把一个字符串里的每一个字符与一个常量进行亦或。

.ab备份文件的复原

在对安卓手机进行取证时，经常需要备份手机的应用程序数据，备份后得到的数据文件为ab格式。虽然大部分的取证软件都可以对ab文件进行分析，但是，有时候你可能需要解析ab文件的文件系统，然后对应用程序数据进行手动分析。ab文件一般分两种，一种是没有加密，这种文件前面有24字节的文件头，文件头包含none标志，文件头之后就是数据；一种是加密的备份文件，它的文件头就比较复杂了，文件头包含AES-256标志。

具体看这篇文章
https://blog.csdn.net/qq_33356474/article/details/92188491

采用这个项目
https://github.com/nelenkov/android-backup-extractor

展开全文 >>

主动调用RPC的配置和开发姿势

2020-11-14

frida的内存漫游方法

enumerateLoadedClassesSync

用来枚举所有已经加载过的类

展开全文 >>