a

RFID智能卡

Mifare Classic智能卡的加密算法：[proxmark.nl/files/Documents/13.56 MHz - MIFARE Classic/The_MIFARE_Hack.pdf](http://proxmark.nl/files/Documents/13.56 MHz - MIFARE Classic/The_MIFARE_Hack.pdf)

s是

UART接口

通过约定比特率进行通信，通常包含如下比特

• 起始位：用于指示基于UART协议通信的起始位置
• 数据位：需要传输的实际数据

遗传算法

常用步骤

变异、交叉、适应度计算、选择

变异（基因突变）

设置变异率，判断当前个体是否可以变异

1
2
3

mutation_rate = 0.1
if random.random() < mutation_rate:
	....

设置个体变异比例，判断当前个体能够变异的bits在哪里

1
2
3
4

mutate_point = random.sample(range(1, len(chromosome)), int(len(chromosome) * mutation_point_rate))
mutate_point.sort()
for i in mutate_point:
    chromosome[i] = chromosome[i] ^ 1

交叉（染色体交换）

可以设置一个交叉点，也可以设置多个交叉点，通常是百分之五十交叉

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

# 交叉操作
def crossover(parent1, parent2):
    if random.random() < crossover_rate:
        # 随机选择50个不同的交叉点
        crossover_points = random.sample(range(1, len(parent1)), 50)
        crossover_points.sort()  # 将交叉点按顺序排列
        child1 = []
        child2 = []
        parent_switch = True  # 用于交替选择父代
        for i in range(len(parent1)):
            if i in crossover_points:
                # 如果当前位置是交叉点，则切换到另一个父代
                #print("test")
                parent_switch = not parent_switch
            if parent_switch:
                child1.append(parent1[i])
                child2.append(parent2[i])
            else:
                child1.append(parent2[i])
                child2.append(parent1[i])
        return child1, child2
    else:
        return parent1, parent2

适应度计算

即将生成的后代个体与期望达到的目标进行对比，计算差距，即适应度。

• 二进制测试：与能够触发crash的目标进行适应度计算
• CANID测试：与能够响应车机的CANID进行适应度计算

1
2
3
4
5
6
7
8
9
10

# 计算适应度函数
def fitness(chromosome):
    data = []
    for i in range(num_targets):
        target_value = input_data[i]
        binary_str = ''.join(map(str, chromosome[i * num_bits:(i + 1) * num_bits]))
        decimal_value = int(binary_str, 2)
        data.append(decimal_value)
    fitness_value = sum(abs(data[i] - input_data[i]) for i in range(num_targets))
    return fitness_value

这里的input_data即为期望达到的目标

选择

当种群达到一定规模后，需要控制种群数量，留下更多的优质基因，那么这时候就需要进行自然选择了，也就是选择那些和期望目标差距更小，适应度更小的后代。

1
2
3
4
5
6
7
8

# 选择操作
def selection(population):
    fitness_values = [fitness(chromosome) for chromosome in population]
    total_fitness = sum(fitness_values)
    probabilities = [fitness_value / total_fitness for fitness_value in fitness_values]
    selected_indices = random.choices(range(population_size), probabilities, k=population_size)
    selected_population = [population[i] for i in selected_indices]
    return selected_population

去世

按理说应该要加入这个算法的，即当繁殖几代之后，那些老一代就应该死去，不管是不是最优的

主要遗传算法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

# 主要遗传算法循环
def genetic_algorithm():
    # print("aaaa")
    population = initialize_population()
    for generation in range(num_generations):
        population = selection(population)
        new_population = []
        while len(new_population) < population_size:
            parent1, parent2 = random.sample(population, 2)
            child1, child2 = crossover(parent1, parent2)
            child1 = mutate(child1)
            child2 = mutate(child2)
            new_population.extend([child1, child2])
        population = new_population
        best_chromosome = min(population, key=fitness)
        best_data = []
        for i in range(num_targets):
            binary_str = ''.join(map(str, best_chromosome[i * num_bits:(i + 1) * num_bits]))
            decimal_value = hex(int(binary_str, 2))
            best_data.append(decimal_value)
        print(f"Generation {generation + 1}: Fitness = {fitness(best_chromosome)}, Data = {best_data}")

依据设定最大种群数量，不断进行繁殖，直到种群数量已满，再进行下一轮的繁殖得到的后代应该进行自然选择。

模拟退火

主要就是降温和计算概率是否替换新的一代。

以旅行商TSP问题为例子

总的代码

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
31
32
33
34

def simulated_annealing_tsp(cities, initial_temperature=1000.0, cooling_rate=0.95, min_temperature=0.1):
    # 生成一个初始路径
    current_path = list(range(len(cities)))
    random.shuffle(current_path)
    current_distance = total_distance(current_path)

    temperature = initial_temperature

    while temperature > min_temperature:
        # 生成一个新路径
        new_path = current_path.copy()
        index1, index2 = random.sample(range(len(new_path)), 2)
        new_path[index1], new_path[index2] = new_path[index2], new_path[index1]
        new_distance = total_distance(new_path)

        # 判断新路径是否被接受
        if new_distance < current_distance:
            current_path, current_distance = new_path, new_distance
        else:
            delta = new_distance - current_distance
            probability = math.exp(-delta / temperature)
            if random.random() < probability:
                current_path, current_distance = new_path, new_distance

        # 降低温度
        temperature *= cooling_rate

    return current_path, current_distance

# 执行模拟退火算法
sa_best_path, sa_best_distance = simulated_annealing_tsp(cities)
print("最优路径:", sa_best_path)
print("最优距离:", total_distance(sa_best_path))

• 设定初始温度，降温比例，最小温度，初代路径

  1 2 3 4 5 6 7 8 9 10 11 12

  #初始温度 initial_temperature=1000.0 #降温率 cooling_rate=0.95 #最小温度 min_temperature=0.1 #初代路径 current_path = list(range(len(cities))) random.shuffle(current_path) current_distance = total_distance(current_path) temperature = initial_temperature

• 判断是否达到最低温度

  1	while temperature > min_temperature:

  • 生成新的路径

    • 如果新的路径更优秀，距离更短，那么就直接替换

      1 2 3 4 5 6 7 8 9

      #生成新的路径 new_path = current_path.copy() index1, index2 = random.sample(range(len(new_path)), 2) new_path[index1], new_path[index2] = new_path[index2], new_path[index1] new_distance = total_distance(new_path) # 判断新路径是否被接受，如果距离更短，无条件接收 if new_distance < current_distance: current_path, current_distance = new_path, new_distance

    • 如果新的一代更差，那么就依据当前温度，计算替换概率，（温度越高，概率越大），概率越大的，新的替换旧的概率就越大，然后降低问题。

      这个计算概率不知道怎么个计算法

      1 2 3 4 5 6 7

      else: #计算概率 delta = new_distance - current_distance probability = math.exp(-delta / temperature) #依据概率判断是否进行距离路径替换 if random.random() < probability: current_path, current_distance = new_path, new_distance

    • 降低温度

      1 2	# 降低温度 temperature *= cooling_rate

• 依次类推，直到达到最低温度跳出循环

教我兄弟学Android逆向

03 破解第一个Android游戏

切水果大作战

方法一

《新人贴》初次尝试破解内购小游戏：切水果大作战 - 『移动安全区』 - 吾爱破解 - LCG - LSG |安卓破解|病毒分析|www.52pojie.cn

正常打开搜索失败字符串即可

定位到找到对应的三个函数payResultSuccess和payResultFalse，payResultCancel

可以用jd-gui打开分析代码

同样搜索可以定位到对应的函数

然后在AndroidKill的smali代码窗口中将payResultSuccess的代码原封不动复制到payResultFalse和payResultCancel即可，最后编译即可。

方法二

可以通过修改跳转来使得任意点击均可跳转到payResultSuccess。

全局搜索payResultFalse，在MiGuSdkPay$1.smali中有对应的switch跳转语句

这里的

1
2

.line 54
packed-switch p1, :pswitch_data_0

即为声明switch语句，跳转至pswitch_data_0，在这个结构语句里面具体进行跳转

1
2
3
4
5
6

.line 54
:pswitch_data_0
.packed-switch 0x1
    :pswitch_0
    :pswitch_1
.end packed-switch

那么就是值为0则跳转pswitch_0，为1则跳转pswitch_1

查看对应的java源代码

可以看到对应的一些跳转，依据选择不同，那么就在smali代码中修改对应的跳转即可，即将pswitch_0修改为pswitch_1即可。

08 IDA爆破签名验证

主要获取到可以导入jni.h的知识，在TIPS

09 IDA动态破解登陆验证

主要获取到IDA动态调试.so的知识，在TIPS

10 静态分析反调试apk

init_array和JNI_OnLoad会在so加载的时候就开始执行，所以程序也有可能会在这里开启线程进行反调试。

反调试点

• checkport

  在MainActivity中调用了

  

  如果存在结果，即0x5d8a=23946端口被占用，那么就会exit，否则就挑战成功。

  可以通过android_server -p23947设置端口来绕过

• init_array

  在.so文件加载时就会被运行，比JNI_OnLoad早

  

  对应函数

  

  跳转函数

  

  即fget按行读取，总共6次遍历，获取/proc/xx/status的第六行，即TracePid，查看里面的数据是否大于0，大于0则代表程序正在被调试，即退出。

  

  可以刷机改内核，使得TracerPid永远为0

  逆向修改内核，绕过TracerPID反调试 - 『移动安全区』 - 吾爱破解 - LCG - LSG |安卓破解|病毒分析|www.52pojie.cn

• JNI_OnLoad函数

  在执行System.loadLibrary("xxx.so")时被调用

  

  进入SearchObjProcess函数

  

  查看是否有这些进程，有就退出

  可以将android_server修改为其他名称

11 动态调试init_array

没成功，寄

不过调试最开始的需要在手机中这样运行才行，在Frida中好像也讲过

1

am start -D -n demo2.jni.com.myapplication/.MainActivity

安卓逆向这档事

课程二、初识APK文件结构、双开、汉化、基础修改

参考基础知识中的汉化知识块。

汉化未知语言

同时MT管理器还有一键翻译的功能，下载对应的翻译插件即可。

课后作业

汉化

可以先进行通用搜索

查找到resources.arsc，这个也是汉化大头

然后可以直接点击翻译模式

点击[DEFAULT]

找到对应字符串即可修改

应用双开

MT管理器就可以

替换图片

通过图片资源ID，在XML搜索中查找到的XML，一般是用来定义图片布局大小和加载路径的，可以通过修改这个布局达到去除图片和替换图片的目的

MT不显示资源ID时，可以点击如下设置，取消ID转名称，这样好查找

然后找到app:srcCompat即可，复制这个7f0d000b资源ID

随后到resources.arsc中的编辑器

通过ID定位资源

即可查看到对应的资源路径，然后替换图片即可

课程三、初识smali、VIP终结者

有些字符串是一个资源，不是写在代码里面，使用开发者助手查找时通常为0x7xxxxx这样的类型，那么就在MT管理器里面反编译classes.dex用整型的16进制进行搜索

找到修改即可

课程四、恭喜获得广告&弹窗静默卡

获取Activity记录

可以用MT管理器来获取一个APK启动的Activity的记录，在MT主界面左上角点击三横线图标展开，启动Activity记录服务

然后打开对应的APK，切换回MT管理器即可查看到

去除广告

对于广告来说，去除的方法通常有如下几种

• 第一种：修改加载时间，把广告的显示时间修改为0秒即可

  获取广告Activity的名称，反编译classes.dex进行类名搜索

  

  然后找到类的smali路径进行搜索

  

  再进行代码搜索

  

  进入到如下的AdActivity类中代码进行分析

  

  即在主函数onCreate中调用了广告代码loadAd，随后启动广告，持续3000ms

  1 2 3 4 5 6 7 8 9 10

  protected void onCreate(Bundle bundle) { super.onCreate(bundle); setContentView(2131427362); loadAd(); } //.... private final void loadAd() { this.timeoutHandler.removeMessages(MSG_AD_TIMEOUT); this.timeoutHandler.sendEmptyMessageDelayed(MSG_AD_TIMEOUT, 3000); }

  那么将3000ms调成0ms即可跳过广告。

• 第二种：修改Activity执行顺序，跳过广告的Activity

  这个最好还是不用，只需要在AndroidManifest.xml中将主Activity修改为自己需要的就行，比如这里就直接将主Activity修改为第三关的Activity。但是很多的Activity都会加载资源，直接跳转到后面的Acitivity容易导致应用GG。

• 第三种：修改切换Activity的代码

  即找到调用Activity的代码，将调用广告Activity处的代码直接修改为调用第三关的Acitvity

  首先还是查找一下广告Activity，然后需要排查一下，本身的Activity去除一下，查找调用到广告的Activity，排查找到com.zj.wuaipojie.ui.Adapter中有调用

  

  进入查看定位关键代码

  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

  private static final void m0onCreateViewHolder$lambda-0(ViewHolder viewHolder, View view) { int adapterPosition = viewHolder.getAdapterPosition(); Intent intent; if (adapterPosition == 0) { intent = new Intent(); intent.setClass(view.getContext(), ChallengeFirst.class); view.getContext().startActivity(intent); } else if (adapterPosition == 1) { intent = new Intent(); intent.setClass(view.getContext(), ChallengeSecond.class); view.getContext().startActivity(intent); } else if (adapterPosition == 2) { intent = new Intent(); intent.setClass(view.getContext(), AdActivity.class); view.getContext().startActivity(intent); } else if (adapterPosition == 3) { intent = new Intent(); intent.setClass(view.getContext(), ChallengeFourth.class); view.getContext().startActivity(intent); } else if (adapterPosition == 4) { intent = new Intent(); intent.setClass(view.getContext(), ChallengeFifth.class); view.getContext().startActivity(intent); } }

  可以看到这里进入第三关时会先加载广告Acitivity，那么这里把进入第三关的代码修改为直接进入第三关的Activity即可，在smali代码中进行修改，将Lcom/zj/wuaipojie/ui/AdActivity修改为Lcom/zj/wuaipojie/ui/ChallengeSecond即可。

  

  然后保存重新安装即可。

弹窗修改

最主要的是定位弹窗在哪。

针对更新弹窗而言，一般都是在代码逻辑里判断新版本和当前版本是否版本号一致，那么可以直接修改XML中的versiocode为最新版本即可

还有的可以用算法助手工具进行直接Hook，有弹窗定位，关键词屏蔽功能等，这样就可以把某些返回键禁止的弹窗给hook了。

• 修改dex代码

  使用开发助手的日志功能对弹窗进行定位，找到对应的代码，注释掉show方法修改即可。

  

• 抓包修改响应体

  使用开发助手->布局查看功能找到横幅广告图片的view Id在哪，修改高度宽度即可

  

  

  随后进行XML搜索即可，修改长宽。

  

  另外也可以加入一段代码

  1	android:visibility="gone"

课后作业

使用算法助手的弹窗定位功能，定位到关键函数，这个函数是被混淆过的函数。

复制这个方法名称，在MT中搜索

定位之后，里面有三个函数都会有弹窗调用

都把那个show给注释掉即可，或者查找调用点，在调用点处注释即可

或者使用关键字”弹窗”来定位代码也是一样的。

课程五、1000-7=？&动态调试&Log插桩

动态调试

• 首先需要将AndroidManifest.xml中加入调试权限

  

  然后重新安装，再把安装包放入JEB进行分析，在需要下断点的地方按ctrl + b即可下断点。

• 随后使用adb连上手机，输入如下命令开启调试功能

  1	adb shell am start -D -n com.zj.wuaipojie/.ui.MainActivity

  命令解析为

  adb shell am start -D -n
  adb shell am start -D -n 包名/类名
  am start -n 表示启动一个activity
  am start -D 表示将应用设置为可调试模式

  这个类名为主类名才行。

  输入命令后，在手机中会显示如下弹窗

  

• 之后点击JEB上的调试即可

  

其他的调试方法有点麻烦，不研究了。

Log插桩

• 将插桩的.dex文件添加到apk中，长按出现添加按钮

• 随后在需要获取的寄存器值的位置，加入如下代码

  1	invoke-static {对应寄存器}, Lcom/mtools/LogUtils;->v(Ljava/lang/Object;)V

  如下图所示

  

  获取v0的值

课后作业

算法助手启用onClick监听，分析到是在MainActivity中，或者通过字符串搜索定位资源ID，然后定位资源ID调用的代码

那么在该类中查找一下onClick，可以找到对应的函数

直接让checkSN永远返回1即可，在MT管理器中查找修改，添加如下即可

动态调试的话，也还是有点麻烦，拉到把。

课程六、校验的N次方-签名校验对抗、PM代{过}{滤}理、IO重定向

检测校验

签名校验

通常就是校验包的hash值是否被修改

• 普通签名校验

  系统将应用的签名信息封装在 PackageInfo 中，调用 PackageManager 的 getPackageInfo(String packageName, int flags) 即可获取指定包名的签名信息

  1 2 3 4 5 6 7 8 9 10 11 12 13 14

  private boolean SignCheck() { String trueSignMD5 = "d0add9987c7c84aeb7198c3ff26ca152"; String nowSignMD5 = ""; try { // 得到签名的MD5 PackageInfo packageInfo = getPackageManager().getPackageInfo(getPackageName(),PackageManager.GET_SIGNATURES); Signature[] signs = packageInfo.signatures; String signBase64 = Base64Util.encodeToString(signs[0].toByteArray()); nowSignMD5 = MD5Utils.MD5(signBase64); } catch (PackageManager.NameNotFoundException e) { e.printStackTrace(); } return trueSignMD5.equals(nowSignMD5); }

  这种签名一般在签名校验的部分，注释掉签名校验错误的代码，或者将那个trueSignMD5签名修改为实际签名即可。

• 校验Application

• CRC校验

  获取dex的crc的值，即当修改了dex，它的值必定会发生改变

  1 2	ZipEntry entry = new ZipFile(getPackageCodePath()).getEntry("classes.dex"); Log.e("zj2595", "dexCrc:" + entry.getCrc());

• hash校验

  获取整个APK的hash值，然后进行比对

root检测

检测方式

• 检查设备的 build tags 是否包含 test-keys。这通常是用于测试的设备，因此如果检测到这个标记，则可以认为设备已被 root。

• 检查设备是否存在一些特定的文件，这些文件通常被用于执行 root 操作。如果检测到这些文件，则可以认为设备已被 root。比如如下一些常见的

  1	"/system/app/Superuser.apk", "/sbin/su", "/system/bin/su", "/system/xbin/su", "/data/local/xbin/su", "/data/local/bin/su", "/system/sd/xbin/su","/system/bin/failsafe/su", "/data/local/su", "/su/bin/su

• 执行which su，来查看是否有输出

对抗手段

• IO重定向使文件不可读
• 修改Android源码，去除常见指纹
• 算法助手等Hook

模拟器检测

检测方式

通过检测系统的 Build 对象来判断当前设备是否为模拟器。具体方法是检测 Build.FINGERPRINT 属性是否包含字符串 "generic"。

对抗手段

模拟器检测对抗 (notion.site)

签名定位

• 一般通过算法助手定位闪退的日志

签名校验对抗

• 一键过签名工具：

  MT、NP、ARMPro、CNFIX、Modex

• PM代理

  来源于：https://github.com/fourbrother/HookPmsSignature

  使用PM手撕没成功，不是很会

  smali.jar：从smali转为dex

  1	java -jar smali.jar assemble -o 输出目录 输入目录

  baksmali.jar：从dex转为smali

  1	java -jar baksmali.jar d classes.dex

• IO重定向

• 不签名安装

签名对抗还是手撕签名好一点，可以用一些hook助手来查找签名

PM代理有点过时，但是对于某些应用签名还是可以搞定的。

普通签名

可以用算法助手进行拦截

PM代理

• 首先PmsHookBinderInvocationHandler.smali和ServiceManagerWraper.smali

• 修改ServiceManagerWraper.smali中的内容，将签名信息和包名修改为指定安装包信息

  签名信息为如下原始数据内容

  

• 然后将两个smali文件放到一个文件夹，使用命令

  1	java -jar smali.jar assemble -o HookPMS.dex .\zhengji\Hook\

  生成得到HookPMS.dex

• 随后将HookPMS.dex导入安装包，重新命名classes2.dex，重新打包

  

• 随后搜索attachBaseContext方法，在MainApplication中

  

  加入如下代码

  1	invoke-static {p1}, Lzhengji/Hook/ServiceManagerWraper;->hookPMS(Landroid/content/Context;)V

  注意要和HookPMS.dex中的路径一致

• Pixel4不行，用模拟器可以跑通

  

IO重定向

功能

• 让文件只读不可写
• 禁止访问文件
• 路径替换

用处

• 过签名校验，当校验时让它读取原包
• 风控对抗，某些APP会记录启动次数
• 过Root检测、Xposed检测

原理

hook了底层打开文件的一些路径

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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172

using namespace std;  
string packname;  
string origpath;  
string fakepath;  

int (*orig_open)(const char *pathname, int flags, ...);  
int (*orig_openat)(int,const char *pathname, int flags, ...);  
FILE *(*orig_fopen)(const char *filename, const char *mode);  
static long (*orig_syscall)(long number, ...);  
int (*orig__NR_openat)(int,const char *pathname, int flags, ...);  

void* (*orig_dlopen_CI)(const char *filename, int flag);  
void* (*orig_dlopen_CIV)(const char *filename, int flag, const void *extinfo);  
void* (*orig_dlopen_CIVV)(const char *name, int flags, const void *extinfo, void *caller_addr);  

static inline bool needs_mode(int flags) {  
    return ((flags & O_CREAT) == O_CREAT) || ((flags & O_TMPFILE) == O_TMPFILE);  
}  
bool startsWith(string str, string sub){  
    return str.find(sub)==0;  
}  

bool endsWith(string s,string sub){  
    return s.rfind(sub)==(s.length()-sub.length());  
}  
bool isOrigAPK(string  path){  

    if(path==origpath){  
        return true;  
    }  
    return false;  
}  
//该函数的功能是在打开一个文件时进行拦截，并在满足特定条件时将文件路径替换为另一个路径  

//fake_open 函数有三个参数：  
//pathname：一个字符串，表示要打开的文件的路径。  
//flags：一个整数，表示打开文件的方式，例如只读、只写、读写等。  
//mode（可选参数）：一个整数，表示打开文件时应用的权限模式。  
int fake_open(const char *pathname, int flags, ...) {  
    mode_t mode = 0;  
    if (needs_mode(flags)) {  
        va_list args;  
        va_start(args, flags);  
        mode = static_cast<mode_t>(va_arg(args, int));  
        va_end(args);  
    }  
    //LOGI("open,  path: %s, flags: %d, mode: %d",pathname, flags ,mode);  
    //这里被写死了，只能在这个路径下放入原包
    string cpp_path= pathname;  
    if(isOrigAPK(cpp_path)){  
        LOGI("libc_open, redirect: %s, --->: %s",pathname, fakepath.data());  
        return orig_open("/data/user/0/com.zj.wuaipojie/files/base.apk", flags, mode);  
    }  
    return  orig_open(pathname, flags, mode);  

}  

//该函数的功能是在打开一个文件时进行拦截，并在满足特定条件时将文件路径替换为另一个路径  

//fake_openat 函数有四个参数：  
//fd：一个整数，表示要打开的文件的文件描述符。  
//pathname：一个字符串，表示要打开的文件的路径。  
//flags：一个整数，表示打开文件的方式，例如只读、只写、读写等。  
//mode（可选参数）：一个整数，表示打开文件时应用的权限模式。  
//openat 函数的作用类似于 open 函数，但是它使用文件描述符来指定文件路径，而不是使用文件路径本身。这样，就可以在打开文件时使用相对路径，而不必提供完整的文件路径。  
//例如，如果要打开相对于当前目录的文件，可以使用 openat 函数，而不是 open 函数，因为 open 函数只能使用绝对路径。  
//  
int fake_openat(int fd, const char *pathname, int flags, ...) {  
    mode_t mode = 0;  
    if (needs_mode(flags)) {  
        va_list args;  
        va_start(args, flags);  
        mode = static_cast<mode_t>(va_arg(args, int));  
        va_end(args);  
    }  
    LOGI("openat, fd: %d, path: %s, flags: %d, mode: %d",fd ,pathname, flags ,mode);  
    string cpp_path= pathname;  
    if(isOrigAPK(cpp_path)){  
        LOGI("libc_openat, redirect: %s, --->: %s",pathname, fakepath.data());  
        return  orig_openat(fd,fakepath.data(), flags, mode);  
    }  
    return orig_openat(fd,pathname, flags, mode);  

}  
FILE *fake_fopen(const char *filename, const char *mode) {  

    string cpp_path= filename;  
    if(isOrigAPK(cpp_path)){  
        return  orig_fopen(fakepath.data(), mode);  
    }  
    return orig_fopen(filename, mode);  
}  
//该函数的功能是在执行系统调用时进行拦截，并在满足特定条件时修改系统调用的参数。  
//syscall 函数是一个系统调用，是程序访问内核功能的方法之一。使用 syscall 函数可以调用大量的系统调用，它们用于实现操作系统的各种功能，例如打开文件、创建进程、分配内存等。  
//  
static long fake_syscall(long number, ...) {  
    void *arg[7];  
    va_list list;  

    va_start(list, number);  
    for (int i = 0; i < 7; ++i) {  
        arg[i] = va_arg(list, void *);  
    }  
    va_end(list);  
    if (number == __NR_openat){  
        const char *cpp_path = static_cast<const char *>(arg[1]);  
        LOGI("syscall __NR_openat, fd: %d, path: %s, flags: %d, mode: %d",arg[0] ,arg[1], arg[2], arg[3]);  
        if (isOrigAPK(cpp_path)){  
            LOGI("syscall __NR_openat, redirect: %s, --->: %s",arg[1], fakepath.data());  
            return orig_syscall(number,arg[0], fakepath.data() ,arg[2],arg[3]);  
        }  
    }  
    return orig_syscall(number, arg[0], arg[1], arg[2], arg[3], arg[4], arg[5], arg[6]);  

}  

//函数的功能是获取当前应用的包名、APK 文件路径以及库文件路径，并将这些信息保存在全局变量中  
//函数调用 GetObjectClass 和 GetMethodID 函数来获取 context 对象的类型以及 getPackageName 方法的 ID。然后，函数调用 CallObjectMethod 函数来调用 getPackageName 方法，获取当前应用的包名。最后，函数使用 GetStringUTFChars 函数将包名转换为 C 字符串，并将包名保存在 packname 全局变量中  
//接着，函数使用 fakepath 全局变量保存了 /data/user/0/<packname>/files/base.apk 这样的路径，其中 <packname> 是当前应用的包名。  
//然后，函数再次调用 GetObjectClass 和 GetMethodID 函数来获取 context 对象的类型以及 getApplicationInfo 方法的 ID。然后，函数调用 CallObjectMethod 函数来调用 getApplicationInfo 方法，获取当前应用的 ApplicationInfo 对象。  
//它先调用 GetObjectClass 函数获取 ApplicationInfo 对象的类型，然后调用 GetFieldID 函数获取 sourceDir 字段的 ID。接着，函数使用 GetObjectField 函数获取 sourceDir 字段的值，并使用 GetStringUTFChars 函数将其转换为 C 字符串。最后，函数将 C 字符串保存在 origpath 全局变量中，表示当前应用的 APK 文件路径。  
//最后，函数使用 GetFieldID 和 GetObjectField 函数获取 nativeLibraryDir 字段的值，并使用 GetStringUTFChars 函数将其转换为 C 字符串。函数最后调用 LOGI 函数打印库文件路径，但是并没有将其保存在全局变量中。  

extern "C" JNIEXPORT void JNICALL  
Java_com_zj_wuaipojie_util_SecurityUtil_hook(JNIEnv *env, jclass clazz, jobject context) {  
    jclass conext_class = env->GetObjectClass(context);  
    jmethodID methodId_pack = env->GetMethodID(conext_class, "getPackageName",  
                                               "()Ljava/lang/String;");  
    auto packname_js = reinterpret_cast<jstring>(env->CallObjectMethod(context, methodId_pack));  
    const char *pn = env->GetStringUTFChars(packname_js, 0);  
    packname = string(pn);  

    env->ReleaseStringUTFChars(packname_js, pn);  
    //LOGI("packname: %s", packname.data());  
    fakepath= "/data/user/0/"+ packname +"/files/base.apk";  

    jclass conext_class2 = env->GetObjectClass(context);  
    jmethodID methodId_pack2 = env->GetMethodID(conext_class2,"getApplicationInfo","()Landroid/content/pm/ApplicationInfo;");  
    jobject application_info = env->CallObjectMethod(context,methodId_pack2);  
    jclass pm_clazz = env->GetObjectClass(application_info);  

    jfieldID package_info_id = env->GetFieldID(pm_clazz,"sourceDir","Ljava/lang/String;");  
    auto sourceDir_js = reinterpret_cast<jstring>(env->GetObjectField(application_info,package_info_id));  
    const char *sourceDir = env->GetStringUTFChars(sourceDir_js, 0);  
    origpath = string(sourceDir);  
    LOGI("sourceDir: %s", sourceDir);  

    jfieldID package_info_id2 = env->GetFieldID(pm_clazz,"nativeLibraryDir","Ljava/lang/String;");  
    auto nativeLibraryDir_js = reinterpret_cast<jstring>(env->GetObjectField(application_info,package_info_id2));  
    const char *nativeLibraryDir = env->GetStringUTFChars(nativeLibraryDir_js, 0);  
    LOGI("nativeLibraryDir: %s", nativeLibraryDir);  
    //LOGI("%s", "Start Hook");  

    //启动hook  
    void *handle = dlopen("libc.so",RTLD_NOW);  
    auto pagesize = sysconf(_SC_PAGE_SIZE);  
    auto addr = ((uintptr_t)dlsym(handle,"open") & (-pagesize));  
    auto addr2 = ((uintptr_t)dlsym(handle,"openat") & (-pagesize));  
    auto addr3 = ((uintptr_t)fopen) & (-pagesize);  
    auto addr4 = ((uintptr_t)syscall) & (-pagesize);  

    //解除部分机型open被保护  
    mprotect((void*)addr, pagesize, PROT_READ | PROT_WRITE | PROT_EXEC);  
    mprotect((void*)addr2, pagesize, PROT_READ | PROT_WRITE | PROT_EXEC);  
    mprotect((void*)addr3, pagesize, PROT_READ | PROT_WRITE | PROT_EXEC);  
    mprotect((void*)addr4, pagesize, PROT_READ | PROT_WRITE | PROT_EXEC);  

    DobbyHook((void *)dlsym(handle,"open"), (void *)fake_open, (void **)&orig_open);  
    DobbyHook((void *)dlsym(handle,"openat"), (void *)fake_openat, (void **)&orig_openat);  
    DobbyHook((void *)fopen, (void *)fake_fopen, (void**)&orig_fopen);  
    DobbyHook((void *)syscall, (void *)fake_syscall, (void **)&orig_syscall);  
}

具体实现

查找到check_crc的调用地方

点击罗盘

长按check_crc

即可找到目的方法

然后在开头写入如下代码，注意这个只是调用代码，实际的重定向的代码是一个so中的代码，作者已经写入到安装包了，我们只需要调用即可，后续需要自己将so打入apk

1
2
3
4
5
6
7

sget-object p10, Lcom/zj/wuaipojie/util/ContextUtils;->INSTANCE:Lcom/zj/wuaipojie/util/ContextUtils;  

invoke-virtual {p10}, Lcom/zj/wuaipojie/util/ContextUtils;->getContext()Landroid/content/Context;  

move-result-object p10  

invoke-static {p10}, Lcom/zj/wuaipojie/util/SecurityUtil;->hook(Landroid/content/Context;)V

随后在软件数据目录中新建files文件夹，放入原安装包

重新命名为base.apk

在我的测试中，hash可以过，crc过不了

反调试

反调试方法

• 安卓自带的

  1 2 3 4 5 6

  fun checkForDebugger() { if (Debug.isDebuggerConnected()) { // 如果调试器已连接，则终止应用程序 System.exit(0) } }

• debuggable属性

  先检测手机的debuggable属性，没有检测到再检测APK内部的xml的那个debuggable属性

• ptrace检测

  1 2 3 4

  int ptrace_protect()//ptrace附加自身线程 会导致此进程TracerPid 变为父进程的TracerPid 即zygote { return ptrace(PTRACE_TRACEME,0,0,0);;//返回-1即为已经被调试 }

• 调试进程名称检测

  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 31 32 33 34

  int SearchObjProcess() { FILE* pfile=NULL; char buf[0x1000]={0}; pfile=popen("ps","r"); if(NULL==pfile) { //LOGA("SearchObjProcess popen打开命令失败!\n"); return -1; } // 获取结果 //LOGA("popen方案:\n"); while(fgets(buf,sizeof(buf),pfile)) { char* strA=NULL; char* strB=NULL; char* strC=NULL; char* strD=NULL; strA=strstr(buf,"android_server");//通过查找匹配子串判断 strB=strstr(buf,"gdbserver"); strC=strstr(buf,"gdb"); strD=strstr(buf,"fuwu"); if(strA || strB ||strC || strD) { return 1; // 执行到这里，判定为调试状态 } } pclose(pfile); return 0; }

反调试对抗

https://bbs.pediy.com/thread-268155.htm

frida检测

https://github.com/xxr0ss/AntiFrida

课后作业

• 普通签名校验：

  重新签名安装，检测到应用退出，开启算法助手退出拦截和日志捕获，定位到com.zj.wuaipojie.ui.ChallengeFifth.onCreate

  

  然后分析onCreate，存在checkSign和root检测

  

  剩下的分析一下，把checkSign返回为True即可，即在return之前始终赋值返回值为1

  

  root检测部分也是一样的，返回值赋值为0即可

• API校验：

  即获取包的签名信息，转换为字符串之后进行base64编码，然后md5输出

  

  如下所示

  

  要么可以重定向，要么进行PM代理，或者直接改代码，返回值修改为1即可

• CRC校验：

  详见代码

  

  即校验classes.dex文件，这里通用可以返回值赋值为1解决。

  但是这里有个try-catch，并且catch始终返回为true。那么可以尝试让try中出错，进而跳转到catch，这里让classes.dex字符串修改为classes2.dex，这样找不到这个文件自然会出错，跳转到catch。

• PM校验：详见PM代理部分

• Hash校验：

  

  直接用返回1解决

• SO层校验

  

  修改if条件语句即可，if-eqz修改为if-nez

  

  整体通过

课程七/八、Sorry，会Hook真的可以为所欲为-Xposed快速上手

环境配置

创建空白的android项目，使用java和android7作为目标

复制xposed的jar包到项目的libs目录

修改xml文件配置，src->main->AndroidManifest.xml，修改如下

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

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools">

    <application
        android:allowBackup="true"
        android:dataExtractionRules="@xml/data_extraction_rules"
        android:fullBackupContent="@xml/backup_rules"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
        android:theme="@style/Theme.XposedPro"
        tools:targetApi="31">
        <!-- 是否是xposed模块，xposed根据这个来判断是否是模块 -->
        <meta-data
            android:name="xposedmodule"
            android:value="true" />
        <!-- 模块描述，显示在xposed模块列表那里第二行 -->
        <meta-data
            android:name="xposeddescription"
            android:value="这是一个Xposed模块" />
        <!-- 最低xposed版本号(lib文件名可知) -->
        <meta-data
            android:name="xposedminversion"
            android:value="89" />
    </application>

</manifest>

修改build.gradle.kts

1
2
3

implementation(files("libs\\XposedBridgeAPI-89.jar"))
修改为
compileOnly(files("libs\\XposedBridgeAPI-89.jar"))

区别在于implementation 使用该方式依赖的库将会参与编译和打包 compileOnly 只在编译时有效，不会参与打包

然后app新建目录，new->Folder->Assets Folder

assets目录下创建文件，为模块入口

app->src->java->com下新建hook类

然后需要在xposed_init中指定hook类入口

继承了IXposedHookLoadPackag便拥有了hook的能力，然后在Hook.java里面写代码就行

HOOK代码

hook指定包

首先指定需要hook的包

1
2
3
4
5
6
7
8

public class Hook implements IXposedHookLoadPackage {
    @Override
    public void handleLoadPackage(XC_LoadPackage.LoadPackageParam loadPackageParam) throws Throwable {
        if(!loadPackageParam.packageName.equals("com.zj.wuaipojie")){
            return;
        }
    }
}

添加了if语句代表只hook掉com.zj.wuaipojie这个apk

hook指定函数

在jadx中可以选定某个方法，复制为xposed片段，比如这里选择hook掉a方法

复制之后放入if语句后面即可，需要导入包，然后在修改classLoader，添加前缀loadPackageParam.classLoader

1
2
3
4
5
6
7
8
9
10

XposedHelpers.findAndHookMethod("com.zj.wuaipojie.Demo", loadPackageParam.classLoader, "a", java.lang.String.class, new XC_MethodHook() {
    @Override
    protected void beforeHookedMethod(MethodHookParam param) throws Throwable {
        super.beforeHookedMethod(param);
    }
    @Override
    protected void afterHookedMethod(MethodHookParam param) throws Throwable {
        super.afterHookedMethod(param);
    }
});

即传入类，classLoader，方法名称，参数类型，然后重写beforeHookedMethod和afterHookedMethod回调函数即可

或者直接用反射来获取，通常可以用来hook自定义或者复杂函数

1
2
3
4
5
6
7
8

Class a = loadPackageParam.classLoader.loadClass("类名");
XposedBridge.hookAllMethods(a, "方法名", new XC_MethodHook() {
    @Override
    protected void beforeHookedMethod(MethodHookParam param) throws Throwable {
        super.beforeHookedMethod(param);

        }
});

参数处理

在beforeHookedMethod中处理参数

1
2
3

String a = "aaaaaaaa";
XposedBridge.log(param.args[0].toString()); //打印参数
param.args[0] = a; //修改参数

在afterHookedMethod中处理返回值

1
2

Log.d("zj2595",param.getResult().toString()); //获取返回值
param.setResult("123456"); //设置返回值

替换函数

类似的

1
2
3
4
5
6
7

Class a = classLoader.loadClass("类名")
XposedBridge.hookAllMethods(a,"方法名",new XC_MethodReplacement() {  
    home.php?mod=space&uid=1892347  
    protected Object replaceHookedMethod(MethodHookParam methodHookParam) throws Throwable {  
        return "";  
    }  
});

通杀大部分免费加壳

针对一些加固的APP，需要先获取到classloader才能接着hook

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

XposedHelpers.findAndHookMethod(Application.class, "attach", Context.class, new XC_MethodHook() {
    @Override
    protected void afterHookedMethod(MethodHookParam param) throws Throwable {
        Context context = (Context) param.args[0];
        ClassLoader classLoader = context.getClassLoader();

        //hook逻辑在这里面写
        XposedHelpers.findAndHookMethod("com.zj.wuaipojie.Demo", loadPackageParam.classLoader, "a", java.lang.String.class, new XC_MethodHook() {
            @Override
            protected void beforeHookedMethod(MethodHookParam param) throws Throwable {
                super.beforeHookedMethod(param);
            }
            @Override
            protected void afterHookedMethod(MethodHookParam param) throws Throwable {
                super.afterHookedMethod(param);
            }
        });
    }
});

处理变量

没有的就用Object

string->Object

• 静态变量

  static的，类被初始化，同步进行初始化

  1 2	final Class clazz = XposedHelpers.findClass("类名", loadPackageParam.classLoader); XposedHelpers.setStaticIntField(clazz, "变量名", 999);

• 实例变量

  类被实例化（产生一个对象的时候），进行初始化

  1 2 3 4 5 6 7 8 9 10

  final Class clazz = XposedHelpers.findClass("类名", classLoader); XposedBridge.hookAllConstructors(clazz, new XC_MethodHook() { //先hook构造函数 @Override protected void afterHookedMethod(MethodHookParam param) throws Throwable { //在构造函数初始化变量之后 super.afterHookedMethod(param); //param.thisObject获取当前所属的对象 Object ob = param.thisObject; XposedHelpers.setIntField(ob,"变量名",9999); } });

处理构造函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

//无参构造函数，没有传入参数
XposedHelpers.findAndHookConstructor("com.zj.wuaipojie.Demo", loadPackageParam.classLoader, new XC_MethodHook() {
    @Override
    protected void beforeHookedMethod(MethodHookParam param) throws Throwable {
        super.beforeHookedMethod(param);
    }
    @Override
    protected void afterHookedMethod(MethodHookParam param) throws Throwable {
        super.afterHookedMethod(param);
    }
});

//有参构造函数，传入了参数string.class
XposedHelpers.findAndHookConstructor("com.zj.wuaipojie.Demo", loadPackageParam.classLoader, String.class, new XC_MethodHook() {
    @Override
    protected void beforeHookedMethod(MethodHookParam param) throws Throwable {
        super.beforeHookedMethod(param);
    }
    @Override
    protected void afterHookedMethod(MethodHookParam param) throws Throwable {
        super.afterHookedMethod(param);
    }
});

处理Dex文件

一个dex中最多只能存在65535个方法，如果超过这个数，就会重新生成dex文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

XposedHelpers.findAndHookMethod(Application.class, "attach", Context.class, new XC_MethodHook() {  
    @Override  
    protected void afterHookedMethod(MethodHookParam param) throws Throwable {  
        ClassLoader cl= ((Context)param.args[0]).getClassLoader();  
        Class<?> hookclass=null;  
        try {  
            hookclass=cl.loadClass("类名");  
        }catch (Exception e){  
            Log.e("zj2595","未找到类",e);  
            return;        
        }  
        XposedHelpers.findAndHookMethod(hookclass, "方法名", new XC_MethodHook() {  
            @Override  
            protected void afterHookedMethod(MethodHookParam param) throws Throwable {  
            }        
        });  
    }  
});

函数主动调用

• 静态函数

  1 2	Class clazz = XposedHelpers.findClass("类名",loadPackageParam.classLoader); XposedHelpers.callStaticMethod(clazz,"方法名",参数(非必须));

• 实例函数

  1 2	Class clazz = XposedHelpers.findClass("类名",loadPackageParam.classLoader); XposedHelpers.callMethod(clazz.newInstance(),"方法名",参数(非必须));

内部类

类中还有一个class，其实就是加入$符号来寻找类

1
2
3
4
5
6
7
8

XposedHelpers.findAndHookMethod("com.zj.wuaipojie.Demo$InnerClass", loadPackageParam.classLoader, "innerFunc",String.class,  new XC_MethodHook() {
    @Override
    protected void beforeHookedMethod(MethodHookParam param) throws Throwable {
        super.beforeHookedMethod(param);
        param.args[0] = "111111";

    }
});

反射调用

即先hook住某个函数，然后找到类之后对应调用即可

1
2
3
4
5
6
7
8
9
10
11
12
13
14

Class clazz = XposedHelpers.findClass("com.zj.wuaipojie.Demo", loadPackageParam.classLoader);
XposedHelpers.findAndHookMethod("com.zj.wuaipojie.Demo$InnerClass", loadPackageParam.classLoader, "innerFunc",String.class,  new XC_MethodHook() {  
    @Override 
    protected void beforeHookedMethod(MethodHookParam param) throws Throwable {  
        super.beforeHookedMethod(param);  
        //第一步找到类
        //找到方法，如果是私有方法就要setAccessible设置访问权限
        //invoke主动调用或者set修改值(变量)
        Class democlass = Class.forName("com.zj.wuaipojie.Demo",false,loadPackageParam.classLoader);  
        Method demomethod = democlass.getDeclaredMethod("refl");  
        demomethod.setAccessible(true);
        demomethod.invoke(clazz.newInstance());  
    }  
});

遍历包中所有类下所有方法

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

XposedHelpers.findAndHookMethod(ClassLoader.class, "loadClass", String.class, new XC_MethodHook() {  
    @Override  
    protected void afterHookedMethod(MethodHookParam param) throws Throwable {  
        super.afterHookedMethod(param);  
        Class clazz = (Class) param.getResult();  
        String clazzName = clazz.getName();  
        //排除非包名的类  
        if(clazzName.contains("com.zj.wuaipojie")){  
            Method[] mds = clazz.getDeclaredMethods();  
            for(int i =0;i<mds.length;i++){  
                final Method md = mds[i];  
                int mod = mds[i].getModifiers();  
                //去除抽象、native、接口方法  
                if(!Modifier.isAbstract(mod)  
                    && !Modifier.isNative(mod)  
                    &&!Modifier.isAbstract(mod)){  
                    XposedBridge.hookMethod(mds[i], new XC_MethodHook() {  
                        @Override  
                        protected void beforeHookedMethod(MethodHookParam param) throws Throwable {  
                            super.beforeHookedMethod(param);  
                            Log.d("zj2595",md.toString());  
                        }  
                    });  
                }  

           }  
        }  

    }  
});

堆栈查询

定位”已过期”字符串赋值部分的堆栈

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

XposedHelpers.findAndHookMethod("android.widget.TextView", loadPackageParam.classLoader, "setText", CharSequence.class, new XC_MethodHook() {  
    @Override  
    protected void beforeHookedMethod(MethodHookParam param) throws Throwable {  
        super.beforeHookedMethod(param);  
        Log.d("zj2595",param.args[0].toString());  
                if(param.args[0].equals("已过期")){  
                    printStackTrace();  
                }
    }  
});
private static void printStackTrace() {  
    Throwable ex = new Throwable();  
    StackTraceElement[] stackElements = ex.getStackTrace();  
    for (int i = 0; i < stackElements.length; i++) {  
        StackTraceElement element = stackElements[i];  
        Log.d("zj2595","at " + element.getClassName() + "." + element.getMethodName() + "(" + element.getFileName() + ":" + element.getLineNumber() + ")");  
    }  
}

事件监听

检测点击事件对应的方法

1
2
3
4
5
6
7
8
9
10
11

Class clazz = XposedHelpers.findClass("android.view.View", loadPackageParam.classLoader);
XposedBridge.hookAllMethods(clazz, "performClick", new XC_MethodHook() {  
    @Override  
    protected void afterHookedMethod(MethodHookParam param) throws Throwable {  
        super.afterHookedMethod(param);  
        Object listenerInfoObject = XposedHelpers.getObjectField(param.thisObject, "mListenerInfo");  
        Object mOnClickListenerObject = XposedHelpers.getObjectField(listenerInfoObject, "mOnClickListener");  
        String callbackType = mOnClickListenerObject.getClass().getName();  
        Log.d("zj2595",callbackType);  
    }  
});

布局改写

1
2
3
4
5
6
7
8
9
10
11

XposedHelpers.findAndHookMethod("com.zj.wuaipojie.ui.ChallengeSixth", loadPackageParam.classLoader,  
        "onCreate", Bundle.class, new XC_MethodHook() {  
    @Override  
    protected void afterHookedMethod(MethodHookParam param) throws Throwable {  
        super.afterHookedMethod(param);  
        View img = (View)XposedHelpers.callMethod(param.thisObject,  
                "findViewById", 0x7f0800de);  
        img.setVisibility(View.GONE);  

    }  
});

LSPosed免root

使用https://github.com/LSPosed/LSPatch即可

先安装模块，然后打开LPatch，在应用栏添加应用

选择已安装的APK，或者存储目录都行

• 本地模式：只能在本地设备运行，相当于还是hook

• 集成模式：将模块嵌入到APP中，可以在其他手机运行，这个其实也会修改签名

  

  点击嵌入模块，然后选择对应的模块即可

  

  覆写版本号，选择签名强度开始修补即可

  

  修补后会在之前选定的存储目录中生成对应的APP，此时安装即可。

简单HOOK

有一些简单hook的教程，还有Xposed的源码解析

GitHub - littleWhiteDuck/SimpleHook: SimpleHook hook部分代码

十、不是我说，有了IDA还要什么女朋友？

ELF就不介绍了

NDK开发

在Frida逆向与抓包实战有介绍

课后作业

如之前所分析的，调用的是so里面的getSercet函数，打开IDA分析，修改函数如下返回值

修改为MOV W0,1即可，再用MT导入apk包重新安装即可。

十二、大佬帮我分析一下

so文件加载流程

下断点时机

应用级别的：java_com_XXX；
外壳级别的：JNI_Onload，.init，.init_array(反调试);
系统级别的：fopen，fget，dvmdexfileopen(脱壳)；

调试步骤

1
2
3
4

adb shell am start -D -n com.zj.wuaipojie/.ui.ChallengeEight （去掉-D 则表示不以debug模式启动app）
adb forward tcp:23946 tcp:23946 (端口转发)
adb forward tcp:8700 jdwp:PID (pid监听)
jdb -connect com.sun.jdi.SocketAttach:hostname=127.0.0.1,port=8700 (jdb挂起)

PS：若不是以debug启动则不需要输入后两条命令

有时候so文件是在apk点击登录或者什么操作之后才会加载调用，这时候就不需要adb shell am start进行启动，在手机启动apk然后开启端口转发，附加就行，比较不容易出错。

SO防护手段

常见防护手段:

OLLVM具体分析相关部分放在IDA逆向技巧了，包括交叉引用、Trace等等

十三、是时候学习一下Frida一把梭了(上)

Frida原理

frida注入的原理就是找到目标进程,使用ptrace跟踪目标进程获取mmap，dlpoen，dlsym等函数库的偏移获取mmap在目标进程申请一段内存空间将在目标进程中找到存放frida-agent-32/64.so的空间启动执行各种操作由agent去实现

环境配置参考《Frida逆向与抓包实战》

操作模式

即CLI命令行和RPC使用js代码注入两种模式

注入模式

spawn主动启动模式和attach附加模式

基础语法

日志输出语法

Hook代码

通过logcat |grep "D.zj2595"日志捕获

框架模板

1
2
3
4
5
6

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

hook类普通方法

如下即重新实现com.zj.wuaipojie.Demo.a函数，打印参数和返回值

1
2
3
4
5
6
7
8
9
10
11
12
13

//定义一个名为hookTest1的函数
function hookTest1(){
    //获取一个名为"类名"的Java类，并将其实例赋值给JavaScript变量utils
    var utils = Java.use("com.zj.wuaipojie.Demo");
    //修改"类名"的"method"方法的实现。这个新的实现会接收两个参数（a和b）
    utils.a.implementation = function(str){
        var retval = this.a(str);
        //在控制台上打印参数a，b的值以及"method"方法的返回值
        console.log(str,retval);
        //返回"method"方法的返回值
        return retval;
    }
}

在这里面修改参数，return返回值就可以修改这个函数了。

hook重载函数

如果方法是重载的，那么需要设置一下具体的参数，比如上面的函数a是重载的，那么需要设定如下

1
2
3
4
5
6
7
8
9
10
11

function hookTest1(){
    //获取一个名为"类名"的Java类，并将其实例赋值给JavaScript变量utils
    var utils = Java.use("com.zj.wuaipojie.Demo");
    //修改"类名"的"method"方法的实现。这个新的实现会接收两个参数（a和b）
    utils.a.overload("java.lang.String").implementation = function(str){
        var retval = this.a(str);
        console.log(str,retval);
        //返回"method"方法的返回值
        return retval;
    }
}

即添加overload指定对应重载函数的参数来确定该函数

hook重载自定义参数类型的函数

借助smali代码来查看，比如如下Inner函数中的Animal参数类型

切换为smali代码，第一个参数类型即为com.zj.wuaipojie.Demo$Animal

对应hook代码如下，修改第二个参数为”aaaaaaaaaa”

1
2
3
4
5
6
7
8
9

function hookTest1(){
    var utils = Java.use("com.zj.wuaipojie.Demo");
    //overload定义重载函数，根据函数的参数类型填
    utils.Inner.overload('com.zj.wuaipojie.Demo$Animal','java.lang.String').implementation = function(a，b){
        b = "aaaaaaaaaa";
        this.Inner(a,b);
        console.log(b);
    }
}

hook构造函数

用$init来表示构造函数，同样重载的构造函数也是类似的

1
2
3
4
5
6
7
8
9

function hookTest3(){
    var utils = Java.use("com.zj.wuaipojie.Demo");
    //修改类的构造函数的实现，$init表示构造函数
    utils.$init.overload('java.lang.String').implementation = function(str){
        console.log(str);
        str = "52";
        this.$init(str);
    }
}

hook变量

• 静态变量

1
2

utils.staticField.value = "我是被修改的静态变量";
console.log(utils.staticField.value);

• 实际变量

注意字段名与函数名相同 前面加个下划线

1
2
3
4
5
6
7
8
9

Java.choose("com.zj.wuaipojie.Demo", {
    onMatch: function(obj){
        //修改实例的非静态字段"_privateInt"的值为"123456"，并修改非静态字段"privateInt"的值为9999。
        //obj._privateInt.value = "123456"; //字段名与函数名相同 前面加个下划线
        obj.privateInt.value = 9999;
    },
    onComplete: function(){
    }
});

实际上在这个例子里面，大佬说hoos是发生在obj.test()函数调用之后的，但是也很奇怪啊，如果是真的，那么应该是obj.test()函数之前的所有数据均无法被更改，反正很奇怪。

hook内部类

一样的，就是获取到目标类就行

1
2
3
4
5
6
7
8
9
10
11

function hookTest6(){
    Java.perform(function(){
        //内部类
        var innerClass = Java.use("com.zj.wuaipojie.Demo$innerClass");
        console.log(innerClass);
        innerClass.$init.implementation = function(){
            console.log("eeeeeeee");
        }

    });
}

枚举所有类与所有方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

function hookTest7(){
    Java.perform(function(){
        //枚举所有的类与类的所有方法,异步枚举
        Java.enumerateLoadedClasses({
            onMatch: function(name,handle){
                    //过滤类名
                if(name.indexOf("com.zj.wuaipojie.Demo") !=-1){
                    console.log(name);
                    var clazz =Java.use(name);
                    console.log(clazz);
                    var methods = clazz.class.getDeclaredMethods();
                    console.log(methods);
                }
            },
            onComplete: function(){}
        })
    })
}

枚举所有方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

function hookTest8(){
    Java.perform(function(){
        var Demo = Java.use("com.zj.wuaipojie.Demo");
        //getDeclaredMethods枚举所有方法
        var methods =Demo.class.getDeclaredMethods();
        for(var j=0; j < methods.length; j++){
            var methodName = methods[j].getName();
            console.log(methodName);
            for(var k=0; k<Demo[methodName].overloads.length;k++){
                Demo[methodName].overloads[k].implementation = function(){
                    for(var i=0;i<arguments.length;i++){
                        console.log(arguments[i]);
                    }
                    return this[methodName].apply(this,arguments);
                }
            }
        }
    })
}

主动调用

• 静态方法

  1 2	var ClassName=Java.use("com.zj.wuaipojie.Demo"); ClassName.privateFunc("传参");

• 非静态方法

  和变量类似，都是要获取对应类的对象

  1 2 3 4 5 6 7 8 9 10 11 12

  var ret = null; Java.perform(function () { Java.choose("com.zj.wuaipojie.Demo",{ //要hook的类 onMatch:function(instance){ ret=instance.privateFunc("aaaaaaa"); //要hook的方法 }, onComplete:function(){ //console.log("result: " + ret); } }); }) //return ret;

十四、是时候学习一下Frida一把梭了(中)

Objection用法

objection是基于frida的命令行hook集合工具, 可以让你不写代码, 敲几句命令就可以对java函数的高颗粒度hook, 还支持RPC调用。可以实现诸如内存搜索、类和模块搜索、方法hook打印参数返回值调用栈等常用功能，是一个非常方便的，逆向必备、内存漫游神器。

常用API

• objection -g 包名 explore：即开始探索，会直接启动应用

  

  objection -g 进程名 explore –startup-command “android hooking watch class 路径.类名” ：代表启动应用前就开始Hook，命令为后面的那个

  

• memory list modules -查看内存中加载的库

  

  memory list exports so名称 - 查看库的导出函数

  

• android hooking list activities -查看内存中加载的activity /android

  

  android hooking list services -查看内存中加载的services，好像不太兼容

  

• android intent launch_activity activity名称：可以直接拉起某个activity

  

• 关闭ssl校验：android sslpinning disable

  

• 关闭root校验：android root disable

  

Objection内存漫游

从内存中查看数据

• android heap search instances 类名(命令)：查看某个类对象

  这是内存中没加载的情况

  

  有加载的是如下情况

  

• android heap execute [hashcode] getPublicInt(实例的hashcode+方法名) ：调用实例的方法

  • 无参函数

    

  • 有参函数

    进入evaluate编辑界面，clazz.a(“ssss”)，即调用clazz这个实例中的a方法，传入参数为”ssss”，然后按照提示按ESC，然后Enter即可

    

• android hooking list classes -列出内存中所有的类(结果比静态分析的更准确)，用的不多

  

• android hooking search classes 关键类名 -在内存中所有已加载的类中搜索包含特定关键词的类，以wuaipojie为关键词

  

• android hooking search methods 关键方法名 -在内存中所有已加载的类的方法中搜索包含特定关键词的方法(一般不建议使用，特别耗时，还可能崩溃)

• android hooking list class_methods 类名 -内存漫游类中的所有方法

  

Objection的HOOK

这个HOOK并不会使得这些方法失效，相当于只是查看

• android hooking watch class 类名 ：hook类的所有方法

  

• android hooking watch class_method 类名.方法名 –dump-args –dump-return –dump-backtrace ：hook方法的参数、返回值和调用栈

  

• android hooking watch class_method 类名.$init ：hook构造函数

  

十五、是时候学习一下Frida一把梭了(下)

打印导入表/导出表

貌似需要frida14，frida16可能写法有点出入

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

function hookTest1(){
    Java.perform(function(){
        //打印导入表
        var imports = Module.enumerateImports("lib52pojie.so");
        for(var i =0; i < imports.length;i++){
            if(imports[i].name == "vip"){
                console.log(JSON.stringify(imports[i])); //通过JSON.stringify打印object数据
                console.log(imports[i].address);
            }
        }
        //打印导出表
        var exports = Module.enumerateExports("lib52pojie.so");
        for(var i =0; i < exports.length;i++){
            console.log(JSON.stringify(exports[i]));
        }

    })
}

静态注册JNI函数HOOK

• JAVA层，同样也是获取到类之后重新实现一下函数就行

  1 2 3 4 5 6 7 8 9

  function hookTest1(){ let SecurityUtil = Java.use("com.zj.wuaipojie.util.SecurityUtil"); SecurityUtil["checkVip"].implementation = function(){ console.log("checkVip is called!"); let ret = this.checkVip(); console.log("checkVip ret value is " + ret); return true; }; }

• SO层，即需要通过函数名称获取

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

  function hookTest2(){ Java.perform(function(){ //根据导出函数名打印地址 var helloAddr = Module.findExportByName("lib52pojie.so","Java_com_zj_wuaipojie_util_SecurityUtil_checkVip"); console.log(helloAddr); if(helloAddr != null){ //Interceptor.attach是Frida里的一个拦截器 Interceptor.attach(helloAddr,{ //onEnter里可以打印和修改参数 onEnter: function(args){ //args传入参数 console.log(args[0]); //打印第一个参数的值 }, //onLeave里可以打印和修改返回值 onLeave: function(retval){ //retval返回值 console.log(retval); console.log("retval",retval.toInt32()); retval.replace(1); } }) } }) }

SO层HOOK打印

• 寄存器

  1	console.log(this.context.x1); // 打印寄存器内容

• 整数

  1	console.log(args[1].toInt32()); //toInt32()转十进制

• Char字符形式

  1	console.log(args[2].readCString()); //读取字符串 char类型

• 字符串形式

  1 2 3 4 5 6 7 8

  // 方法一 var jString = Java.cast(args[2], Java.use('java.lang.String')); console.log("参数:", jString.toString()); //方法二 var JNIEnv = Java.vm.getEnv(); var originalStrPtr = JNIEnv.getStringUtfChars(args[2], null).readCString(); console.log("参数:", originalStrPtr);

• 内存DUMP

  1	console.log(hexdump(args[2])); //内存dump

  

SO层HOOK修改

• 整数

  1 2 3 4 5

  //修改参数 args[0] = ptr(1000); //第一个参数修改为整数 1000，先转为指针再赋值 //修改返回值 retval.replace(20000); //返回值修改

• 字符串修改

  1 2 3 4 5 6 7 8 9

  //修改参数 var modifiedContent = "至尊"; var newJString = JNIEnv.newStringUtf(modifiedContent); args[2] = newJString; //修改返回值 var modifiedContent = "无敌"; var newJString = JNIEnv.newStringUtf(modifiedContent); retval.replace(newJString);

SO基地址获取

1
2
3

var moduleAddr1 = Process.findModuleByName("lib52pojie.so").base;  
var moduleAddr2 = Process.getModuleByName("lib52pojie.so").base;  
var moduleAddr3 = Module.findBaseAddress("lib52pojie.so");

SO未导出函数与函数地址计算

可能存在函数运行，但是没有设置JNI静态导出类型的，只是在SO层内部使用，这时候可以通过加载地址来调用，同样对于JNI动态注册类型也适用。

1. 安卓里一般32 位的 so 中都是thumb指令，64 位的 so 中都是arm指令

2. 通过IDA里的opcode bytes来判断

   arm 指令为 4 个字节(options -> general -> Number of opcode bytes (non-graph) 输入4)

   thumb指令不确定的，有的4字节，有的2字节

3. 地址计算：

   thumb 指令，函数地址计算方式： so 基址 + 函数在 so 中的偏移 +1

   arm 指令，函数地址计算方式： so 基址 + 函数在 so 中的偏移

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

function hookTest6(){
    Java.perform(function(){
        //根据导出函数名打印基址
        var soAddr = Module.findBaseAddress("lib52pojie.so");
        console.log(soAddr);
        var funcaddr = soAddr.add(0x1071C);  
        console.log(funcaddr);
        if(funcaddr != null){
            Interceptor.attach(funcaddr,{
                onEnter: function(args){  //args参数

                },
                onLeave: function(retval){  //retval返回值
                    console.log(retval.toInt32());
                }
            })
        }
    })
}

Hook掉dlopen

dlopen是用来加载so文件的

即可以通过hook时判断参数filename是否为我们想要的.so文件，来指定Hook到.so文件加载时运行的函数逻辑，这里即为关注hook加载lib52pojie.so文件的函数逻辑

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

function hook_dlopen() {
    //这是低版本的android
    var dlopen = Module.findExportByName(null, "dlopen");
    Interceptor.attach(dlopen, {
        onEnter: function (args) {
            var so_name = args[0].readCString();
            if (so_name.indexOf("lib52pojie.so") >= 0) this.call_hook = true;
        }, onLeave: function (retval) {
            if (this.call_hook) hookTest2();
        }
    });
    
    // 高版本Android系统使用android_dlopen_ext
    var android_dlopen_ext = Module.findExportByName(null, "android_dlopen_ext");
    Interceptor.attach(android_dlopen_ext, {
        onEnter: function (args) {
            var so_name = args[0].readCString();
            if (so_name.indexOf("lib52pojie.so") >= 0) this.call_hook = true;
        }, onLeave: function (retval) {
            if (this.call_hook) 
                //这里实际hook在加载lib52pojie.so时候的逻辑为hookTest2();
                hookTest2();
        }
    });
}

十六、是时候学习一下Frida一把梭了(终)

Frida写数据

一般用在脱壳当中

1
2
3
4
5
6
7
8

//一般写在app的私有目录里，不然会报错:failed to open file (Permission denied)(实际上就是权限不足)
var file_path = "/data/user/0/com.zj.wuaipojie/test.txt";
var file_handle = new File(file_path, "wb");
if (file_handle && file_handle != null) {
        file_handle.write(data); //写入数据
        file_handle.flush(); //刷新
        file_handle.close(); //关闭
}

inlinehook内联

写法和函数地址计算时的写法一样的，其实就是定位到某条汇编，然后进行Hook。

我感觉函数层面的原理就是基于这个的，只是当检测为函数时，就可以操作args了。而且这个onLeave，可能检测的是汇编 RET指令，然后修改返回的X0寄存器作为返回值，因为在这个例子里面，onLeave也能修改适用。

这里Hook的是check函数中的如下位置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

function inline_hook(){
    Java.perform(function(){
        //根据导出函数名打印基址
        var soAddr = Module.findBaseAddress("lib52pojie.so");
        console.log(soAddr);
        var funcaddr = soAddr.add(0x010428);  
        console.log(funcaddr);
        if(funcaddr != null){
            console.log("get");
            Interceptor.attach(funcaddr,{
                onEnter: function(args){  //args参数
                    console.log(this.context.x22); //注意此时就没有args概念了
                    this.context.x22 = ptr(1); //赋值方法参考上一节课
                },
                onLeave: function(retval){  //retval返回值
                    console.log(retval.toInt32());
                    retval.replace(1);
                }
            })
        }
    })
}

这里Hook到1042C，然后给X0赋值为1也是一样的。那么其实对于Frida针对So层的Hook，其实具有更加细腻的汇编层面，那这个可以修改汇编代码吗？

汇编层面

[Online ARM to HEX Converter (armconverter.com)](https://armconverter.com/?code=mov w0,1)

• 读取

  1 2 3

  var soAddr = Module.findBaseAddress("lib52pojie.so"); var codeAddr = Instruction.parse(soAddr.add(0x10428)); console.log(codeAddr.toString());

• 写入

  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

  function hexToBytes(str) { var pos = 0; var len = str.length; if (len % 2 != 0) { return null; } len /= 2; var hexA = new Array(); for (var i = 0; i < len; i++) { var s = str.substr(pos, 2); var v = parseInt(s, 16); hexA.push(v); pos += 2; } return hexA; } function compile(){ var soAddr = Module.findBaseAddress("lib52pojie.so"); var codeAddr = Instruction.parse(soAddr.add(0x10428)); console.log(codeAddr.toString()); Memory.patchCode(codeAddr, 4, function(code) { const writer = new Arm64Writer(code, { pc: codeAddr }); writer.putBytes(hexToBytes("20008052")); writer.flush(); }); }

  会报错

  1 2 3 4 5 6 7 8 9 10 11 12 13

  Error: expected a pointer at value (frida/runtime/core.js:207) at compile (/root/Desktop/CTF/AndroidRevFrida/test.js:161) at <anonymous> (/root/Desktop/CTF/AndroidRevFrida/test.js:166) at <anonymous> (frida/node_modules/frida-java-bridge/lib/vm.js:12) at _performPendingVmOps (frida/node_modules/frida-java-bridge/index.js:250) at <anonymous> (frida/node_modules/frida-java-bridge/index.js:225) at <anonymous> (frida/node_modules/frida-java-bridge/lib/vm.js:12) at _performPendingVmOpsWhenReady (frida/node_modules/frida-java-bridge/index.js:244) at perform (frida/node_modules/frida-java-bridge/index.js:204) at main (/root/Desktop/CTF/AndroidRevFrida/test.js:169) at apply (native) at <anonymous> (frida/runtime/core.js:51)

SO层函数主动调用

这里即主动调用AES加密，参数和返回值均为字符串指针，那么就写pointer

1
2
3
4
5
6
7

var funcAddr = Module.findBaseAddress("lib52pojie.so").add(0xe85c);
//声明函数指针
//NativeFunction的第一个参数是地址，第二个参数是返回值类型，第三个[]里的是传入的参数类型(有几个就填几个)
var aesAddr = new NativeFunction(funcAddr , 'pointer', ['pointer', 'pointer']);
var encry_text = Memory.allocUtf8String("OOmGYpk6s0qPSXEPp4X31g==");    //开辟一个指针存放字符串       
var key = Memory.allocUtf8String('wuaipojie0123456'); 
console.log(aesAddr(encry_text ,key).readCString());

对应的数据类型如下

参考JavaScript API | Frida • A world-class dynamic instrumentation toolkit

番外

去除签名校验

手动去除，搜索app kill，找到第一个，进入查找f函数，修改f函数后保存

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

.method public static f()Ljava/util/List;
    .registers 2
    .annotation build Landroidx/annotation/NonNull;
    .end annotation

    .annotation system Ldalvik/annotation/Signature;
        value = {
            "()",
            "Ljava/util/List<",
            "Ljava/lang/String;",
            ">;"
        }
    .end annotation

    .line 1
    new-instance v0, Ljava/util/ArrayList;

    invoke-direct {v0}, Ljava/util/ArrayList;-><init>()V

    const-string v1, "F9:6C:E9:5F:D5:47:BE:DF:81:15:E3:71:8A:10:54:45" 
    #创建了一个新的 ArrayList 实例，然后向列表中添加了一个字符串常量 "F9:6C:E9:5F:D5:47:BE:DF:81:15:E3:71:8A:10:54:45"

    invoke-virtual {v0, v1}, Ljava/util/ArrayList;->add(Ljava/lang/Object;)Z

    return-object v0
.end method

去除更新弹窗

安卓逆向入门笔记

https://www.52pojie.cn/thread-1781093-1-1.html

1.修改默认Activity

a)解包

使用apktool进行反编译，apktool d xxx.apk。将class.dex从apk中解包出来，用d2j-dex2jar class.dex转换为class-dex2jar.jar包

b)添加Activity/布局文件

手写Activity，保存为myActivity.smali

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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80