安卓逆向工具书: 主要用于协议破解 ...... 逆向的尽头是摆摊 | 毕业后摆个烧烤摊吧 :D 此工具书仅作技术交流分享使用，请勿用于非法用途禁止用于商业用途

[TOC]

整理不易，请支持一下！

# 常用基础

## adb命令

### frida, 启动!

```
如果报错 {"type":"error","description":"Error: invalid address","stack":"Error: invalid address\n    at Object.value [as patchCode] (frida/runtime/core.js:170:.....}
>>> setenforce 0
```

```
>>> adb shell
>>> su
>>> cd /data/local/tmp
>>> ./frida    ./fd14
```

```
>>> adb forward tcp:27042 tcp:27042
>>> adb forward tcp:27043 tcp:27043
```
### 操作app

**启动app到某个activity**

`am start 包名/活动名`

eg. `am start com.jamcz.test/com.jamcz.test.MainActivity`

如果活动中含有包名，包名可以用 `.` 替代

eg. `am start com.jamcz.test/.MainActivity`

**提取apk**

1. 获取apk路径`pm path com.xx.xx`  `exit`
2. 推送  `adb pull /phone_path window_path`

### 输入

`adb shell input text "......"`

`input text ......`

## 关于版本

`安卓78/frida12`	`安卓10/frida14`	`安卓12/frida16`

## :red_circle:frida, 启动！

```
  >>> -o xx.txt  hook保存日志到本地txt
```
```
    ①运行ps查看手机端进程列表
    frida-ps -R

②附加某个进程
    frida -R com.demo.fridahook

③-> 写脚本
```
```
    这种模式重启app, 停在了开头 需要输入 %resume 继续
    frida -U -f com.gdufs.xman -l hook_saveSN.js
```
```
    命令行附加应用进程然后敲代码进程注入
    frida -U -f com.demo.fridahook
```
```
    附加模式 (attach)
    应用不会重启 从执行命令起注入
    frida -U -l hook.js 15.2.2版不要写包名 要写应用名称
    frida -UF -l hook.js  这就可以了 后面不用写名称
```
```
    重启一个Android进程并注入脚本
    frida -U -l hook.js -f com.xxx.xxxx --no-pause
```
```
    spawn 模式 15.2.2版本不可以这样写
    frida -Uf com.xxx.xxxx -l hook.js
```
```
    ①查看现在的进程
    frida-ps -R
    
    ②用pid附加上去  可以实时在js文件中修改脚本 控制台会输出错误语法的日志 不用管
    frida -U -p [PID] -l hook_saveSN.js
```
adb无线连接手机 校园网(内网隔离)无效 开热点解决
```
>>> adb tcpip 5555
>>> adb connect 192.168.100.20

>>> ./frida -l 0.0.0.0:6666  
>>> frida -H 192.168.2.102:6666 -f com.wangtietou.test_activity -l C:\\Users\\wangtietou\\Desktop\\hook_activity.js --no-pause
```

多个frida脚本同时运行

```
其中一个从一开始就hook上，用于过检测
>>> frida -U -f com.hupu.shihuo -l load_so.js --no-pause  14.2.18版
```

```
另一个以附加的形式hook
>>> frida -UF -l hook.js --no-pause
```

## 过frida检测

*详见另一个md文件*

### 更改端口

服务端

```
cd /data/local/tmp
./frida -l 0.0.0.0:9999
```

转发端口 `adb forward tcp:9999 tcp:9999`

> 更改端口 `frida-ps -H 127.0.0.1:9999`

加载脚本 `frida -H 127.0.0.1:9999 com.xxx.xxx -l hook.js`

### 修改服务器进程名

`frida-server` -> `ns`

### 使用hluda

```
cd /data/local/tmp
./hluda
```

其它一样

### D-Bus通信协议检测

> App向每一个端口都发送了D-Bus认证消息，那肯定会利用strcmp( )或者strstr( )函数进行检测回复的消息

```javascript
function hook_strcmp() {
    var strcmp = Module.findExportByName('libc.so', "strcmp");
    Interceptor.attach(strcmp, {
        onEnter : function (args) {
            if (args[1].readCString().indexOf("REJECT")!=-1){
            console.log(args[0].readCString());
            console.log(args[1].readCString());
            }
        }, onLeave : function(retval) {
        }
    })
}
```

>有的app检测非常恶心，只要是maps和fd中存在/data/local/tmp/，甚至只有tmp的字段，app就给kill掉。因为这个目录对于安卓逆向工作来说，是一个比较敏感的目录。hluda-server和frida-server都会在/data/local/tmp/目录下生成一个包含frida所需要的so库等文件。所以当app一旦发现了加载了/data/local/tmp下的任何东西，直接就挂掉。
>————————————————
>版权声明：本文为CSDN博主「octopus_father」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
>原文链接：https://blog.csdn.net/weixin_43889136/article/details/127713563

```javascript
function main() {
    const openPtr = Module.getExportByName('libc.so', 'open');
    const open = new NativeFunction(openPtr, 'int', ['pointer', 'int']);
    var readPtr = Module.findExportByName("libc.so", "read");
    var read = new NativeFunction(readPtr, 'int', ['int', 'pointer', "int"]);
    var fakePath = "/data/data/******/maps";
    var file = new File(fakePath, "w");
    var buffer = Memory.alloc(512);
    Interceptor.replace(openPtr, new NativeCallback(function (pathnameptr, flag) {
        var pathname = Memory.readUtf8String(pathnameptr);
        var realFd = open(pathnameptr, flag);
        if (pathname.indexOf("maps") != 0) {
            while (parseInt(read(realFd, buffer, 512)) !== 0) {
                var oneLine = Memory.readCString(buffer);
                if (oneLine.indexOf("tmp") === -1) {
                    file.write(oneLine);
                }
            }
            var filename = Memory.allocUtf8String(fakePath);
            return open(filename, flag);
        }
        var fd = open(pathnameptr, flag);
        return fd;
    }, 'int', ['pointer', 'int']));
}
setImmediate(main)
```

### frida反调试

**P-trace占坑**

查看手机上正在运行的进程 `ps -A`

过滤关键字 `ps -A | grep [app包名]` app包名不用写全，有一点就行

只要看到有两个进程的，其中之一就是用了p-trace占坑，另一个是主进程

注意，包名后面有`:`的不算

![image-20240420223737249](README.assets/image-20240420223737249.png)

**解决方案**

1. 尝试把占坑的进程杀掉，但不一定成功 `kill -9 [进程id]`
2. 使用`spawn`方法启动frida，让hook脚本早于占坑的进程
3. aosp刷机改源码，让app自己附加的进程都启动失败 :laughing:
4. 输出用到的so文件（代码见“打印用到的so文件”），看执行到哪里程序终端，把那个so删了逝世。系统so不需要管。

## 找进程名和pid

```python
# 枚举所有的进程
processes = rdev.enumerate_processes()
for process in processes:
    print(process)

# 获取在前台运行的APP
# Application(identifier="com.che168.autotradercloud", name="车智赢+", pid=3539, parameters={})
front_app = rdev.get_frontmost_application()
print(front_app)
```

## 搜索tips

**看Node, 如果不是该app相关包可以无视**
**treeMap.put(xxx)**

**search**

`sign`  `"sign" `  `&sign=`  `&sign`  `sign=`

**搜索同一请求的其它有个性的关键字**
**搜索独有信息**
网址 拿后缀搜       retrofit发送的请求，找reportClick 查找用例，或直接搜索"reportClick"

当不同网址，使用很多相同的参数时，可能会用拦截器。搜索的时候优先查看带有`Interceptor`的

**搜不到：如果这个字符串是在so中生成，可以去Hook内部：NewStringUTF 方法，该方法将C中的字符串转换为jstring，再返回给Java。hook脚本见下 `hookNewStringUTF`**

**hook拦截器/TreeMap/StringBuilder定位**

**猜**

如果是加密的数据，看它长得像哪种加密方式，hook验证，打印调用栈追踪

有些app（如B站心跳请求）封装了请求的类，在发请求.xxx()后面这样子添加了东西，这时就像上面那样搜索关键字，hook验证是不是走了某个位置

**如果jadx搜不到**：在app首次启动时注册设备`reg`/`register`，将设备指纹信息发送给后端，后端生成设备ID

## 有用的网址

https://1024tools.com/hash 各种加密 方便查看

https://curlconverter.com/  curl转其它语言

安卓逆向开发11期  https://www.aliyundrive.com/s/kyWMLGcVte3 
【看雪论坛】Unicorn高级逆向与反混淆 https://www.aliyundrive.com/s/yFMEJtGERt9
各大网课教程合集    https://www.aliyundrive.com/s/xatt4pVJFDp -1.30 TB

## 配置自动补全

进入项目文件

```
npm i  @types/frida-gum
```

```
npm i module_name 　# 安装模块到项目目录下
npm i module_name -g 　　# -g 的意思是将模块安装到全局，具体安装到磁盘哪个位置，要看 npm config prefix的位置。 
npm i module_name -S(-save) 　# --save 的意思是将模块安装到项目目录下，并在package文件的dependencies节点写入依赖。 
npm i module_name -D(--save-dev)　 # --save-dev 的意思是将模块安装到项目目录下，并在package文件的devDependencies节点写入依赖。
```

## so寻找函数方法

静态注册 -> `Java_包名_类型_方法名()`

动态注册 -> `JNI_OnLoad` -> `RegisterNatives(Jni对象, 类, 对应关系, 数量)`

如果遇到嵌套了很多层函数找不到RegisterNatives的解决方法：**hook系统底层函数 libart.so**

得到输出的十六进制地址后，`ida` -> `Jump` -> `Jump to address`

## 分析tips

### 构造方法 遇到this.x

```java
public final class SignedQuery {
    ...    
	// 搜索sign= 或&sign 找到 
     // hook它看是谁创建了这个对象
    public String toString() {
        String str = this.a;
        if (str == null) {
            return "";
        }
        if (this.b == null) {
            return str;
        }
        return this.a + "&sign=" + this.b; // 生成sign的地方
                                            // aid=xxx&... + "&sign=" + ths.b
    }
}
```

目标：找`this.b`，也就是生成`sign`的地方

注意到该类构造方法

```java
public final class SignedQuery {
    ...
// 有地方实例化了这个对象 传入了这两个参数 或者hook这个构造方法 $init
    public SignedQuery(String str, String str2) {
        this.a = str;
        this.b = str2; // sign
    }
    ...
}
```

**方法：输出调用栈** -> 找到上一层，谁调用了`toString()`

```java
aVar.s(h).l(c0.create(w.d("application/x-www-form-urlencoded; charset=utf-8"), h(hashMap).toString()));
```

`请求体 = h(hashMap).toString()`相当于`请求体 =SignedQuery对象.toString() `，前面肯定有new`SignedQuery`对象的地方

```java
    // 返回了SignedQuery 传入了map
    public SignedQuery h(Map<String, String> map) {
        return LibBili.g(map); // 看看是怎么生成SignedQuery的 关注实例化它的时候第二个参数 即是sign
    }
```

```java
    // 相当于把原来的map转成Treemap(有序的) 然后调用s
    public static SignedQuery g(Map<String, String> map) {
        return s(map == null ? new TreeMap() : new TreeMap(map));
    }
```

```java
static native SignedQuery s(SortedMap<String, String> sortedMap);
```

是在so层创建的对象，返回SignedQuery对象

参考正向开发-静态方法

### 抽象方法/接口

开发角度 https://youtu.be/HvPlEJ3LHgE?si=v-h88b1bsKmSv6i0 看完就会

`public abstract a_func();`

首先往上滑，找到`a_func`是哪个类(假设是`BClass`)，然后查找类的用例或者全局搜索

同时，看看调用这个函数的时候创建的是什么类（由什么类调用这个函数的）可以为之前的查找作为借鉴

格式应该是 `public class AClass extends BClass(){}` 进入这里面后 查询`a_func`方法就能找到它的具体代码

### 反射

```java
clazz = KeyInfo.class; // 类
object = KeyInfo.class.newInstance();  // 实例化
method = clazz.getMethod("getInfo", Context.class, String.class);
return (String) method.invoke(object, context, str);
```

双击进入类`KeyInfo`去寻找`getInfo`方法

### so

1. ida
2. hook看看返回值是否固定 清除数据
3. 抓包看是否固定

### :blue_heart:so实例化对象相关:green_heart:

```c
  v22 = a1->functions->FindClass(a1, "javax/crypto/Cipher");
  v23 = a1->functions->GetStaticMethodID(a1, v22, "getInstance", "(Ljava/lang/String;)Ljavax/crypto/Cipher;");
  v24 = a1->functions->NewStringUTF(a1, "AES/CBC/PKCS5Padding");
  v58 = a1->functions->CallStaticObjectMethod((JNIEnv *)a1, v22, v23, v24);
```

这个方法签名表示getInstance()方法接受一个java.lang.String类型的参数，并且返回一个javax.crypto.Cipher类型的对象

相当于 `Cipher obj = Cipher.getInstance("AES/CBC/PKCS5Padding")`

```c
    v25 = a1->functions->NewStringUTF(a1, "AES");
    v26 = a1->functions->FindClass(a1, "javax/crypto/spec/SecretKeySpec");
    v27 = a1->functions->GetMethodID(a1, v26, "<init>", "([BLjava/lang/String;)V");
    v21 = a1->functions->NewObject((JNIEnv *)a1, v26, v27, v20, v25);
    a1->functions->DeleteLocalRef((JNIEnv *)a1, v20);
```

相当于 `SecretKeySpec secretKeySpec = new SecretKeySpec(字节数组"key", string "AES")`

```c
  v19 = (const jbyte *)j_getMD516(v60, s, v18);
  v20 = a1->functions->NewByteArray(a1, 16);
  v21 = 0;
//使用JNI中的SetByteArrayRegion()方法，设置Java中一个byte[]数组的值。具体来说，此函数将v19数组的前16个字节复制到Java中v20所代表的byte数组的前16个字节处。其中，v20是一个byte[]数组对象的引用，a1是一个JNIEnv对象的指针，v19是一个指针，指向一个长度至少为16个字节的缓冲区，该缓冲区保存了将作为初始化向量使用的字节序列。
  a1->functions->SetByteArrayRegion((JNIEnv *)a1, v20, 0, 16, v19);
  v59[0] = 0LL;
  v59[1] = 0LL;
  v59[2] = 0LL;
  v59[3] = 0LL;
  j_rand16Str();
  v22 = a1->functions->FindClass(a1, "javax/crypto/Cipher");
  v23 = a1->functions->GetStaticMethodID(a1, v22, "getInstance", "(Ljava/lang/String;)Ljavax/crypto/Cipher;");
  v24 = a1->functions->NewStringUTF(a1, "AES/CBC/PKCS5Padding");
  v58 = a1->functions->CallStaticObjectMethod((JNIEnv *)a1, v22, v23, v24);
  if ( v20 )
  {
    v25 = a1->functions->NewStringUTF(a1, "AES");
    v26 = a1->functions->FindClass(a1, "javax/crypto/spec/SecretKeySpec");
    v27 = a1->functions->GetMethodID(a1, v26, "<init>", "([BLjava/lang/String;)V");
    v21 = a1->functions->NewObject((JNIEnv *)a1, v26, v27, v20, v25);
    a1->functions->DeleteLocalRef((JNIEnv *)a1, v20);
  }
```

分析可知，`v20`是key.获取key有两种方法.用hook java的方法，和hook`getMD516`的返回值:

hook指定长度的方法，见下面类型转换输出-控制长度输出

### 遇到了动态的iv

有时可能遇到动态的iv，服务器需要解密就要知道key和iv，如何让服务器解密？可能会把iv添加在密文的前面，随着请求一起发送过去。可以hook base64，看看传入的参数里有没有出现iv. 也有可能把变化的key或iv放到请求头的某个参数中去

### 不要完全相信反编译出来的结果

ida有时候会漏参数，或者有函数没传值进去<-没显示出来 be like :

```c
// function(v26) vs function() 这里是空的
```

### 输出太多

```java
package com.yoloho.controller.api;

import java.security.MessageDigest;

public class PeriodAPIV2 extends NetAPI {
    ...
    public void setDeviceCode() {
        ...
        MessageDigest messageDigest = MessageDigest.getInstance("sha-1");
        messageDigest.update(str6.getBytes());
        byte[] digest = messageDigest.digest();
        ...
    }
}
```

```javascript
var PeriodAPIV2 = Java.use("com.yoloho.controller.api.PeriodAPIV2");
var flag = false;  //防止输出太多东西

PeriodAPIV2.setDeviceCode.implementation = function () {
    console.log("-------------------------setDeviceCode-------------------------")
    flag = true;  //防止输出太多东西
    return this.setDeviceCode();
}

var MessageDigest = Java.use("java.security.MessageDigest");
var ByteString = Java.use("com.android.okhttp.okio.ByteString");
MessageDigest.update.overload("[B").implementation = function (data) {
    if (flag) {
        console.log(ByteString.of(data).utf8(), '\n' );
        console.log("---------------")
    }
    return this.update(data);
}
```

### 打印log

```
adb logcat -s ActivityThread
```

很好用，可惜不能在运行时分析package，只能退出后再把结果导入wireshark

### interface

某个方法在interface里

```java
public interrface c {
    // ...
    String f(Context context, Long l);
}
```

法一：**查找用例`c`** 搜索方法名`f`

**找到形如 `public class u implements c{}` 的代码。进入后寻找f的具体实现即可。**

通常实现方法的两种代码如下

```java
class Info implements ab {
    Info Obj = new Info;
}
// usage
obj.getColorStatParamStr();
```

or 类似于匿名

```java
Ab obj = new ab() {
    Map<String, String> getColorStatParamStr(boolean z, boolean z2, boolean z3) {
        ...
    }
}
// usage
obj.getColorStatParamStr();
```

法二： hook输出类型

```java
Map<String, String> colorStatParamStr = a.WV().getStatInfoConfigImpl().getColorStatParamStr(true, true, z);
```

```java
public interface ab {
    Map<String, String> getColorStatParamStr(boolean z, boolean z2, boolean z3);
}
```

hook `getStatInfoConfigImpl` 方法, 获取返回值 `Json.stringify(对象)`

eg.

```java
@Override // com.bilibili.api.a.b
public String getSessionId() {
    return com.bilibili.lib.foundation.e.b().getSessionId(); // 看e.b()是哪个类实现的
}
```

点入 `getSessionId()` 是接口

```java
public interface a {
    // 又是一个接口 不看它了
    String getSessionId();
}
```

点 `getSessionId`前面的`b()`

```java
public final class e {
    public static final Application a() {
        return d.g.b().c();
    }

// a 表示返回值的类型
    public static final a b() {
        return d.g.b().d(); // hook返回值看看是哪个类的对象
    }

public static final d.b c() {
        return d.g.b().e();
    }

public static final c d() {
        return d.g.b().f();
    }

// 读取xml文件
    public static final SharedPreferences e() {
        return d.g.b().g();
    }
}
```

```javascript
Java.perform(function() {
    var e = Java.use("com.xx.x.e");
    e.b.implementation = function() {
        var res = this.b();
        console.log("obj = ", JSON.stringify(res));
        return res;
    }
})
```

输出的`$className`就是它真正的类，就去这个类里面找`getSessionId()`方法

法三：hook输出调用栈

## 抓包问题

### 客户端校验

![image-20240420225823031](README.assets/image-20240420225823031.png)

很可能用了客户端校验之类的东西，如果`justtrustme` 和 frida 脚本依然抓不到包，就有可能是混淆的代码。

校验的触发位置是在：`okhttp3.internal.connection.RealConnection`类中的`connectTls`方法

有执行顺序，可能只hook掉第三个就能抓到包，也可能需要全部hook掉才行

![image-20221007160903732](README.assets/image-20221007160903732.png)

#### pinner校验混淆

**调用栈分析**

1. 使用 frida/java/客户端校验的js脚本，根据输出的调用栈，对比寻找 `connectTls` 方法

![image-20221007161218948](README.assets/image-20221007161218948.png)

![image-20221007161358236](README.assets/image-20221007161358236.png)

![image-20221007161430339](README.assets/image-20221007161430339.png)

2. 反编译app看代码，和源码对比着看。源码可参考NetDemo3
3. 根据未混淆前的hook脚本，换成混淆的

![image-20231020114236347](README.assets/image-20231020114236347.png)

主要改的是 `Java.use` 和 方法名

#### 证书校验

如果继续寻找证书校验的相关代码，可以搜索：

- `checkServerTrusted`方法 或 `X509Certificate[] chain参数`
- `SSLContext.getInstance`  或 `new TrustManager[]` 或 hook `sslContext.init`

混淆的可用hook系统源码方法

https://github.com/google/conscrypt/blob/86ff4e3fd4b6b3bb76a7ec0e91290384401ccbf3/android/src/main/java/org/conscrypt/Platform.java#L396

![image-20221008165421397](README.assets/image-20221008165421397.png)

```javascript
Java.perform(function () {
    var Platform = Java.use('com.android.org.conscrypt.Platform');
    Platform.checkServerTrusted.overload('javax.net.ssl.X509TrustManager', '[Ljava.security.cert.X509Certificate;', 'java.lang.String', 'com.android.org.conscrypt.AbstractConscryptSocket').implementation = function (x509tm, chain, authType, socket) {
        console.log('\n[+] checkServer  ',x509tm,JSON.stringify(x509tm) );//输出tm可定位到真实的使用位置

//return this.checkServerTrusted(x509tm, chain, authType, socket);
    };
});

// frida -U -f 包名 -l 6.hook_check.js --no-pause
// frida -UF -l 6.hook_check.js
```

此方法有风险，可能导致其它方法执行错误

更好的方法是：

先用这个脚本输出它执行的地方，然后再hook这个地方

#### 主机校验

`HostnameVerifier`属于是`javax.net.ssl` 中的接口不会被混淆。

所以，可以直接搜索 `HostnameVerifier`  或 `new HostnameVerifier` 或 `实现HostnameVerifier接口的类` 或 `verify` 关键字等。此方法不推荐

非通用脚本，混淆失效，需要改动

```javascript
Java.perform(function () {
    function getFieldValue(obj, fieldName) {
        var cls = obj.getClass();
        var field = cls.getDeclaredField(fieldName);
        field.setAccessible(true);
        var name = field.getName();
        var value = field.get(obj);
        return value;
    }

function getMethodValue(obj, methodName) {
        var res;
        var cls = obj.getClass();
        var methods = cls.getDeclaredMethods();

methods.forEach(function (method) {
            var method_name = method.getName();
            console.log(method_name, method);
            if (method_name === methodName) {
                method.setAccessible(true);
                res = method;
                return;
            }
        })
        return res;
    }

// frida -U -f 包名 -l 7.hook_verify.js
// frida -UF -l 7.hook_verify.js
// frida -U -f cn.ticktick.task -l 7.hook_verify.js
```

法三 r0yse的抓包工具

### TCP hook抓包

tcp通用脚本

#### HTTP

**请求写入**

![image-20240416172831657](README.assets/image-20240416172831657.png)

抽象类，抽象方法，没有具体实现，是在某个具体的类继承这个方法，在方法的子类里才有具体实现

```java
// java.net.SocketOutputStream
OutputStream outputStream = socket.getOutputStream();
outputStream.write(sb.toString().getBytes());
```

```java
private void doRequest() {
    new Thread() {
        @Override
        public void run() {
            try {
                // http://wiki.mikecrm.com/index?ajax=1&page=2
                Socket socket = new Socket("wiki.mikecrm.com", 80);

// 1.构造请求头
                StringBuilder sb = new StringBuilder();
                sb.append("GET /index?ajax=1&page=2 HTTP/1.1\r\n");
                sb.append("host: wiki.mikecrm.com\r\n");
                sb.append("user-Agent: test\r\n");
                sb.append("\r\n");

// 2.写入数据（发送数据）
                // java.net.SocketOutputStream
                OutputStream outputStream = socket.getOutputStream();
                outputStream.write(sb.toString().getBytes());
                Log.e("outputStream的类 => ", outputStream.getClass().getName());

// 3.读取数据（获取数据）
                // java.net.SocketInputStream
                InputStream inputStream = socket.getInputStream();
                Log.e("inputStream的类 => ", inputStream.getClass().getName());

while (true) {
                    byte[] buffer = new byte[1024];
                    int len = inputStream.read(buffer, 0, buffer.length);
                    if (len == -1) {
                        break;
                    }
                    Log.e("读取相应内容 =>", new String(Arrays.copyOf(buffer, len)));
                }
                socket.close();
            } catch (Exception ex) {
                Log.e("Main", "网络请求异常" + ex);
            }
        }
    }.start();
}
```

使用`outputStream.getClass().getName()`获取到真正定义它的类

获取到所有http请求的数据

```javascript
Java.perform(function () {
    var SocketOutputStream = Java.use('java.net.SocketOutputStream');
    var HexDump = Java.use("com.android.internal.util.HexDump");
    var ByteString = Java.use("com.android.okhttp.okio.ByteString");

SocketOutputStream.socketWrite0.overload('java.io.FileDescriptor', '[B', 'int', 'int').implementation = function (fd, b, off, len) {
        console.log("参数：", fd, b, off, len);
        console.log(HexDump.dumpHexString(b, off, len), "\n");
        console.log(ByteString.of(b).utf8(), "\n"); // 字节->字符串
        console.log(ByteString.of(b).utf8());

return this.socketWrite0(fd, b, off, len);
    };
});

// frida -UF -l  1.hook.js
// console.log(Java.use("android.util.Log").getStackTraceString(Java.use("java.lang.Throwable").$new()));
```

```javascript
Java.perform(function () {
    var SocketOutputStream = Java.use('java.net.SocketOutputStream');
    var ByteString = Java.use("com.android.okhttp.okio.ByteString");

SocketOutputStream.write.overload('[B').implementation = function (arr) {
        console.log(arr); // byte 104,101,108,,..
        console.log(ByteString.of(arr).utf8(), "\n"); // 字节->字符串
        console.log(ByteString.of(arr).hex()); // 68656c...
        // 只写这一行也可以 打印类似wireshark里的格式
        console.log(HexDump.dumpHexString(arr), "\n");
        return this.write(arr);
    };
});

// frida -UF -l  1.hook.js
// console.log(Java.use("android.util.Log").getStackTraceString(Java.use("java.lang.Throwable").$new()));
```

**获取相应**

java开发代码

```java
// java.net.SocketInputStream
InputStream inputStream = socket.getInputStream();
Log.e("inputStream的类 => ", inputStream.getClass().getName());
while (true) {
    byte[] buffer = new byte[1024];
    int len = inputStream.read(buffer, 0, buffer.length);
    if (len == -1) {
        break;
    }
    Log.e("读取相应内容 =>", new String(Arrays.copyOf(buffer, len)));
}
```

hook脚本

```javascript
Java.perform(function () {
    var SocketInputStream = Java.use('java.net.SocketInputStream');
    var ByteString = Java.use("com.android.okhttp.okio.ByteString");

SocketInputStream.read.overload('[B','int','int').implementation = function (b,off,len) {
        var res = this.read(b,off,len);
        console.log(HexDump.dumpHexString(b, off, len));
        return res;
    };
});

// frida -UF -l  1.hook.js
// console.log(Java.use("android.util.Log").getStackTraceString(Java.use("java.lang.Throwable").$new()));
```

有时上面的方法会有重载overload，需要修改。我们可以深♂入分析，hook更深层

**Deeper♂**

其实可以用任意一个地方hook，不用这么深♂

寻找`socketRead0`和`socketWrite0`的hook的脚本：

```javascript
Java.perform(function() {
    const apiResolver = new ApiResolver('module');
    apiResolver.enumerateMatches('exports:*!*socket*0*').forEach(function (v) {
        console.log(v.name);
    });
});
```

```javascript
Java.perform(function () {
    const NET_Send = Module.getExportByName('libopenjdk.so', 'NET_Send');
    const NET_Read = Module.getExportByName('libopenjdk.so', 'NET_Read');
    Interceptor.attach(NET_Send, {
        onEnter(args) {
            console.log('write call'); // jni,jobj,data,off,len
            //console.log(hexdump(args[1], {length: args[2].toInt32()}));
            console.log(Memory.readByteArray(args[1], args[2].toInt32()));
        }
    });
    Interceptor.attach(NET_Read, {
        onEnter(args) {
            console.log('read call');
            this.buf = args[1];
        }, onLeave: function (retval) {
            retval |= 0; // Cast retval to 32-bit integer.
            if (retval <= 0) {
                return;
            }
            console.log(Memory.readByteArray(this.buf, retval));
        }
    });
});

// frida -UF -l hook.js
```

#### HTTPS

**请求写入**

```javascript
Java.perform(function () {
    var NativeCrypto = Java.use('com.android.org.conscrypt.NativeCrypto');
    var HexDump = Java.use("com.android.internal.util.HexDump");
    var ByteString = Java.use("com.android.okhttp.okio.ByteString");

NativeCrypto.SSL_write.implementation = function (ssl, ssl_holder, fd, shc, b, off, len, timeout) {
        //console.log(HexDump.dumpHexString(b, off, len), "\n")
        console.log(ByteString.of(b).utf8(), "\n");

return this.SSL_write(ssl, ssl_holder, fd, shc, b, off, len, timeout);
    };
});

// frida -UF -l  3.hook.js
// console.log(Java.use("android.util.Log").getStackTraceString(Java.use("java.lang.Throwable").$new()));
```

**请求获取**

```javascript
Java.perform(function () {
    var NativeCrypto = Java.use('com.android.org.conscrypt.NativeCrypto');
    var HexDump = Java.use("com.android.internal.util.HexDump");
    var ByteString = Java.use("com.android.okhttp.okio.ByteString");

NativeCrypto.SSL_read.implementation = function (ssl, ssl_holder, fd, shc, b, off, len, timeout) {
        var res = this.SSL_read(ssl, ssl_holder, fd, shc, b, off, len, timeout);
        //console.log(HexDump.dumpHexString(b, off, len), "\n")
        console.log(ByteString.of(b).utf8(), "\n");
        return res;
    };
});

// frida -UF -l  4.hook.js
// console.log(Java.use("android.util.Log").getStackTraceString(Java.use("java.lang.Throwable").$new()));
```

**hook so**

寻找`SSL_write`和`SSL_read`的hook的脚本：

```javascript
Java.perform(function () {
    const apiResolver = new ApiResolver('module');
    // 包含：libttboringssl.so 或 libssl.so
    // 'exports:*lib*ssl*!SSL_*'
    apiResolver.enumerateMatches('exports:*lib*ssl*!SSL_*').forEach(function (v) {
        if (v.name.indexOf('SSL_write') > 0) {
            // SSL_write = v.address;
            console.log(v.name);
        } else if (v.name.indexOf('SSL_read') > 0) {
            // SSL_read = v.address;
            console.log(v.name);
        }
    });
});
```

**hook 请求和响应**

```javascript
Java.perform(function () {
    const SSL_write = Module.getExportByName('libssl.so', 'SSL_write');
    const SSL_read = Module.getExportByName('libssl.so', 'SSL_read');

Interceptor.attach(SSL_write, {
        onEnter(args) {
            console.log('write call');
            //console.log(args[0]); // ssl
            //console.log(args[1]); // buffer
            //console.log(args[2]); // len
            //console.log(hexdump(args[1], {length: args[2].toInt32()}));
            console.log(Memory.readByteArray(args[1], parseInt(args[2])));
        }
    });

Interceptor.attach(SSL_read, {
        onEnter(args) {
            console.log('read call');
            this.buf = args[1];
        }, onLeave: function (retval) {
            retval |= 0; // Cast retval to 32-bit integer.
            if (retval <= 0) {
                return;
            }
            console.log(Memory.readByteArray(this.buf, retval));
        }
    });
});

// frida -UF -l  7.hook.js
// frida -U -f com.nb.ssldemo2 -l 7.hook.js --no-pause
```

### 抓不到有用的包

在安卓开发时，OkHttp发送请求，设置 `Proxy.NO_PROXY`，基于系统代理都是抓不到包。

```java
OkHttpClient client = new OkHttpClient.Builder().proxy(Proxy.NO_PROXY).build();
FormBody form = new FormBody.Builder()
    .add("user", dataMap.get("username"))
    .add("pwd", dataMap.get("password"))
    .add("sign", dataMap.get("sign")).build();

Request req = new Request.Builder().url("http://192.168.0.6:9999/login").post(form).build();
```

`proxydroid`，`SocketDroid`, `drony`启动！

`drony`有时加载不出wifi

`SocksDroid` 切记：在使用前**删除**手机上设置的系统代理。

`ProxyDroid` 切记：在使用前**删除**手机上设置的系统代理。

### 抓包显示:negative_squared_cross_mark: :x:

使用SocketDroid转发

### :question: 其它协议

实时显示：弹幕

但是https会断开连接

猜想：基于TCP协议，不断开连接，实时显示

#### WebSocket

https不支持服务端主动向客户端推送消息

WebSocket可以实现相互的收发消息，服务端可以主动推送消息，支持长连接

使用场景：

1. web聊天室
1. 弹幕

### mitmproxy

用来抓包的，和Charles类似，可配置代理抓国外包。可写脚本。详见抓包文件夹

## 推荐阅读

[frida hook AES DES RSA 自吐算法]: https://www.codenong.com/jsecbee028022b/
[r0ysue大佬的课程目录]: http://www.dtasecurity.cn:20080/androidsenior/readme2.html

[FART教程]: https://www.anquanke.com/post/id/199898
[FART github]: https://github.com/hanbinglengyue/FART
[手机投到电脑上]: https://github.com/Genymobile/scrcpy

## ida使用

### 修改汇编指令

1. 把鼠标定位到要修改的指令(函数图上的就行)
2. 调出16进制的窗口 `View` -> `Open subviews` ->`Hex dump` （这步可以不做）
3. 修改 `Edit` -> `Patch program` -> `Change byte...`
4. 改完后，记得保存 `Edit` -> `Patch program` -> `Apply patches to input file`

### 快捷键

`Shift + F12` 调出字符串窗口

`Alt + T` 搜索字符串

## 花指令(junk code)

- 花指令根本不会影响x32dbg的动态调试
- jeb 高版本5.0自带控制流混淆还原

# python TOOLS

## 端口转发一键运行

```python
import subprocess
# 重新连接手机需要运行
subprocess.getoutput("adb forward tcp:27042 tcp:27042")
subprocess.getoutput("adb forward tcp:27043 tcp:27043")
```

## 切割?后的东西

形如 aa=11&bb=22&cc=33...xx=xx&xxx=xxx

```python
param_string = input(">>>")

import json
data_dict = {item.split('=')[0]: item.split('=')[1] for item in param_string.split('&')}
data_string = json.dumps(data_dict, indent=4)
print(data_string)

with open("output.txt", mode="w") as f:
    f.write(data_string)
```

## java字节数组(有符号) -> python字节数组(无符号)

```python
byte_list = [47,-38,-99,34,-13,44,-43,-119,3,76,8,32,47,-115,105,61,-91,-46 ...]

bs = []
for item in byte_list:
    if item < 0:
        item = item + 256
    bs.append(item)

print(bs)
```

## java字节数组(byte)转字符串

```python
byte_list = [97,110,99,104,111,114,82,101,112,108,121,73,100,48,99,111,110,116,101,110]
def byte2str(byte_list):
    data = bytearray()
    for i in byte_list:
        data.append(i)
    data_string = data.decode('utf-8')
    print(data_string)

byte2str(byte_list)
```

## 字节 -> 十六进制(Hex)字符串

```python
bytes_data = b'\x9f\x1bVbf\x12\xa73\x91\xe5\x90\xb3fN\xe6\xfb'
#       去除前面的0x 不满两位补0
result = "".join([hex(item)[2:].rjust(2, "0") for item in bytes_data])
print(result)
```

## 字节数组 -> 十六进制(Hex)字符串

```python
byte_list = [47, 218, 157, 34, 243, 44, 213, 137, 3, 76, 8, 32, 47, 141, 105, 61, 165, 210]  # 注意java的要先处理成python的
print([hex(ele)[2:] for ele in byte_list])
```

## 随机生成mac地址

```python
def create_random_mac(sep=":"):
    """ 随机生成mac地址 """
    data_list = []
    for i in range(1, 7):
        part = "".join(random.sample("0123456789ABCDEF", 2))
        data_list.append(part)
    mac = sep.join(data_list)
    return mac
```

## 字符串 -> 字节

```python
data_string = "啊吧啊吧"
data_string.encode('utf-8')
```

## 字典排序后拼接成x=x&xx=xx

```python
data_dict = {'x':'x', "xx":"xx"}
ordered_string = "&".join(["{}={}".format(key, data_dict[key]) for key in sorted(data_dict.keys())])
```

## 字典url转义

```python
puote_plus(
    json.dumps({"appid":1, "platform":3}, separators=(',', ":"))
)
```

### url转回来

```python
import json
from urllib.parse import quote_plus, unquote_plus

dinfo = "%7B%22ah1%22%3A%22%22%2C%22ah2%22%3A%22%22%2C%22ah3%22%3A%22%22%2C%22ah4%22%3A%22wifi%22%2C%22ah5%22%3A%221080_2236%22%2C%22ah6%22%3A1785600%2C%22ah7%22%3A8%2C%22ah8%22%3A5732413440%2C%22ah9%22%3A%22Pixel+4%22%2C%22ah10%22%3A%22%22%2C%22ah11%22%3A%22%22%2C%22ah12%22%3A%22%22%2C%22ah13%22%3A%22%22%2C%22as1%22%3A%2210%22%2C%22as2%22%3A%22%22%2C%22as3%22%3A%22%22%2C%22as4%22%3A%22b9ab99eb4438fddd%22%2C%22as5%22%3A%22%22%2C%22as6%22%3A%22%22%2C%22as7%22%3A%2229%22%2C%22ac1%22%3A%22ac791f31-66b8-301e-837d-539d4c0c39c8%22%7D"

result = unquote_plus(dinfo)
print(result)
data_dict = json.loads(result)
print(json.dumps(data_dict, indent=4))
```

## >>>

java的  `>>>` 在python里实现

```python
    def int_overflow(val):
        maxint = 2147483647
        if not -maxint - 1 <= val <= maxint:
            val = (val + (maxint + 1)) % (2 * (maxint + 1)) - maxint - 1
        return val
    
    def unsigned_right_shitf(n, i):
        # 数字小于0，则转为32位无符号uint
        if n < 0:
            n = ctypes.c_uint32(n).value
        # 正常位移位数是为正数，但是为了兼容js之类的，负数就右移变成左移好了
        if i < 0:
            return -int_overflow(n << abs(i))
        # print(n)
        return int_overflow(n >> i)
```

## 字典->符串

```python
cipher_dict = {
    'area': 'DV8nDNrpCzO4D18zDNSnCK==',
     'd_model': 'UwVubWu4GG==',
     'wifiBssid': 'dW5hbw93bq==',
     'osVersion': 'CJK=',
     'd_brand': 'WQvrb21f',
     'screen': 'CJC2EIe3CtK=',
     'uuid': 'DNS5DzCnYwU1EQVuDQVwYzq4YwDwCWCyCJYyCzGyYzS=',
     'aid': 'DNS5DzCnYwU1EQVuDQVwYzq4YwDwCWCyCJYyCzGyYzS=',
     'openudid': 'DNS5DzCnYwU1EQVuDQVwYzq4YwDwCWCyCJYyCzGyYzS='
}

data_dict = {
    "hdid": "JM9F1ywUPwflvMIpYPok0tt5k9kW4ArJEU3lfLhxBqw=",
    "ts": "1689560145797",
    'ridx': -1,
    'cipher': cipher_dict,
    'ciphertype': 5,
    "version": "1.2.0",
    'appname': "com.jingdong.app.mall",
}
```

```python
# 字符串中间没有空格
ep = json.dumps(data_dict, separators=(',', ':'))
```

输出的字符串为：

```
'{"hdid":"JM9F1ywUPwflvMIpYPok0tt5k9kW4ArJEU3lfLhxBqw=","ts":1689560145797,"ridx":-1,"cipher":{"area":"DV8nDNrpCzO4D18zDNSnCK==","d_model":"UwVubWu4GG==","wifiBssid":"dW5hbw93bq==","osVersion":"CJK=","d_brand":"WQvrb21f","screen":"CJC2EIe3CtK=","uuid":"DNS5DzCnYwU1EQVuDQVwYzq4YwDwCWCyCJYyCzGyYzS=","aid":"DNS5DzCnYwU1EQVuDQVwYzq4YwDwCWCyCJYyCzGyYzS=","openudid":"DNS5DzCnYwU1EQVuDQVwYzq4YwDwCWCyCJYyCzGyYzS="},"ciphertype":5,"version":"1.2.0","appname":"com.jingdong.app.mall"}'
```

# python连接frida-server的方式

## usb连接
```python
# 获取设备信息-----------------------
rdev = frida.get_remote_device()
session = rdev.attach("抖音短视频")
# ---------------------------------
```
## 端口连接
```
>>> ./frida -l 0.0.0.0:8888
```
```python
device = frida.get_device_manager().add_remote_device("192.168.x.x:8888") # 手机ip
session = device.attach("抖音短视频")  # 包名或名字  attach附加模式 不用重启app
```

```python
pid = device.spawn(["com.xx.xx"])  # 包名或名字  spawn模式 重启app
session = device.attach(pid)
```
## wifi连接

先连着usb线 连接完后可以断开

```
>>> adb tcpip 5555
>>> adb connect 192.168.100.20 手机ip
```

## :red_circle:模板

### spawn 重启应用

```python
import frida
import sys
# ---------------------------------
rdev = frida.get_remote_device()
pid = rdev.spawn(["com.xx.xx"])
session = rdev.attach(pid)
# ---------------------------------
scr = """
Java.perform(function () {
	var ClassName = Java.use('com.xxx.xx.ClassName');
	ClassName.Method.implementation = function(arg1, arg2, ...) {
		result = this.Method(arg1, arg2, ...);
		return result;
	}
})
"""
script = session.create_script(scr)

def on_message(message, data):
    print(message, data)
    
script.on("message", on_message)
script.load()
rdev.resume(pid)  # spawn
sys.stdin.read()  # 程序阻塞 不让停止
```

### attach 直接附加

```python
import frida
import sys

rdev = frida.get_remote_device()
session = rdev.attach("中文名")  # 14y

scr = """
Java.perform(function () {
   ...
});
"""
script = session.create_script(scr)

def on_message(message, data):
    print(message, data)

script.on("message", on_message)
script.load()
sys.stdin.read()
```

# frida rpc 主动调用

## 在"""里加载

### 格式一

```python
import frida

def get_frida_rpc_script():
    rdev = frida.get_remote_device()
    session = rdev.attach("猿人学2022")

scr = """
    function invokeSign(data){
    var result;
        Java.perform(function () {
            Java.choose("com.yuanrenxue.match2022.security.Sign",{
                onMatch:function(ins){  // 实例化对象 可能需要刷新一下手机页面加载对象
                    console.log("ins=>",ins);
                    result = ins.sign(stringToByte(data));
                },onComplete(){}
            });
        })
        return result;
    }
    
    rpc.exports = {
        invokesignn:invokeSign,
    }
    """
    script = session.create_script(scr)
    script.load()
    return script

# 调用
script = get_frida_rpc_script()
sign = script.exports.invokesignn(sb)  # exports.后面的名字必须和上面exports{}键的一样 不支持下划线_
```

### 格式二

```python
import frida

def get_frida_rpc_script():
    rdev = frida.get_remote_device()
    session = rdev.attach("抖音短视频")
    scr = """
    rpc.exports = {   
        ttencrypt:function(bArr,len){
             var res;
             Java.perform(function () {
                 ......
             return res;
        },
        execandleviathan: function (i2,str){
            var result;
            Java.perform(function () {
				......
            });
            return result;
        }
    }
    """
    script = session.create_script(scr)
    script.load()
    return script

# 调用
script = get_frida_rpc_script()
gorgon_byte_list = script.exports.execandleviathan(khronos, un_sign_string)
```

## 读取文件加载

```python
import frida
# 不知道干什么用的
def my_message_handler(message, payload):
    print("message=>", message)
    print("payloa=>d", payload)

# connect wifiadb
device = frida.get_device_manager().add_remote_device("192.168.43.71:8888") # 手机ip
print('设备=>', device)
session = device.attach("com.yuanrenxue.match2022")
print('session=>', session)
# load script
with open("app.js") as f:  # app.js见格式一的s
    script = session.create_script(f.read())
script.on("message", my_message_handler)  # 调用错误处理
script.load()

print(script.exports.invokesign('page=' + data['page'] + data['t']))  # 调用
```

## 传参

- 字符串/整型/浮点型等直接传递。

```python
import frida