Smali编程完全指南
一、Smali概述
1.1 什么是Smali
Smali是Android Dalvik虚拟机(以及ART运行时)的汇编语言,是Android应用程序(APK)编译后的中间代码形式。Smali代码由.dex(Dalvik Executable)文件反编译而来,是Android逆向工程中理解和修改应用逻辑的核心语言。
核心特性:
| 特性 | 说明 |
|---|---|
| 基于寄存器 | 使用虚拟寄存器而非操作数栈,与Java字节码不同 |
| 类型精确 | 使用单字母表示基本类型,完整包名表示对象类型 |
| 方法调用多样 | 5种invoke指令对应不同的调用场景 |
| 静态单赋值 | 每个寄存器在一次方法中可被多次赋值 |
| 32位指令集 | 每条指令通常占用2字节(部分为4字节) |
| 与Java对应 | 每个.smali文件对应一个Java类 |
1.2 Smali与Android架构
MERMAID
115%
Ctrl + 滚轮缩放 · 拖动查看完整流程图
| 步骤 | 输入 | 工具 | 输出 |
|---|---|---|---|
| 1 | Java / Kotlin 源码 | javac / kotlinc |
.class 字节码文件 |
| 2 | .class 字节码 |
dx / d8 |
classes.dex Dalvik 字节码 |
| 3 | classes.dex |
baksmali(反编译器) |
.smali 可读汇编代码 |
| 4 | .smali 代码 |
smali(编译器) |
新的 classes.dex → 打包为 APK |
1.3 DEX文件结构
| 区域 | 说明 |
|---|---|
| Header | 文件头:magic、checksum、文件大小等 |
| String Table | 所有字符串的常量池 |
| Type Table | 所有类型描述符的索引 |
| Proto Table | 方法原型(参数+返回值) |
| Field Table | 字段定义列表 |
| Method Table | 方法定义列表 |
| Class Table | 类定义列表 |
| Data Section | 字节码指令数据 |
1.4 常用工具链
| 工具 | 用途 | 关键命令 |
|---|---|---|
| baksmali | 将dex反编译为Smali | baksmali d classes.dex -o smali_dir |
| smali | 将Smali编译为dex | smali a smali_dir -o classes.dex |
| Apktool | 反编译/重打包完整APK | apktool d app.apk / apktool b app_dir |
| jadx | 反编译为Java源码 | jadx-gui app.apk |
| dex2jar | dex转jar | d2j-dex2jar classes.dex |
| JD-GUI | 查看jar中的Java源码 | 图形界面打开jar |
| Frida | 动态插桩/Hook | frida -U -l script.js com.example.app |
| Xposed/LSPosed | 系统级Hook框架 | 模块化修改应用行为 |
| Android Studio | 官方IDE,可查看Smali | 安装Smali插件 |
| IDA Pro / Ghidra | 专业逆向工具 | 支持ARM和Smali分析 |
1.5 环境搭建
BASH
# 安装 smali/baksmali
# 下载最新jar: https://github.com/JesusFreke/smali/releases
java -jar baksmali.jar d classes.dex -o smali_out
java -jar smali.jar a smali_out -o new_classes.dex
# 安装 apktool
# Linux
sudo apt install apktool
# macOS
brew install apktool
# 反编译APK
apktool d target.apk -o target_dir
# 目录结构:
# target_dir/
# ├── smali/ # 主代码
# ├── smali_classes2/ # 多dex的额外代码
# ├── res/ # 资源文件
# ├── AndroidManifest.xml # 清单文件
# └── apktool.yml # 框架信息
# 重新打包
apktool b target_dir -o modified.apk
# 签名(必须)
keytool -genkey -v -keystore debug.keystore -alias debug -keyalg RSA -keysize 2048 -validity 10000
jarsigner -sigalg SHA256withRSA -digestalg SHA-256 -keystore debug.keystore modified.apk debug
# 对齐优化
zipalign -v 4 modified.apk aligned.apk
# 安装测试
adb install aligned.apk
二、Smali基础语法详解
2.1 数据类型系统
Smali使用紧凑的类型描述符,每个基本类型用一个字母表示:
SMALI
# ========== 基本类型(Primitive Types)==========
V → void # 无返回值,仅用于返回值类型
Z → boolean # 布尔值,true=1, false=0
B → byte # 8位有符号整数 (-128 ~ 127)
S → short # 16位有符号整数 (-32768 ~ 32767)
C → char # 16位无符号字符 (0 ~ 65535)
I → int # 32位有符号整数
J → long # 64位有符号整数(占用2个寄存器)
F → float # 32位单精度浮点数
D → double # 64位双精度浮点数(占用2个寄存器)
# ========== 对象类型(Object Types)==========
Lpackage/name/ClassName; # 对象引用
# 例如:
Ljava/lang/String; # String类型
Ljava/lang/Object; # Object类型(所有类的根)
Landroid/app/Activity; # Activity类型
Lcom/example/MyClass; # 自定义类
Lcom/example/MyClass$Inner; # 内部类(用$分隔)
# ========== 数组类型(Array Types)==========
[I # int[] 一维整型数组
[[I # int[][] 二维整型数组
[[[I # int[][][] 三维整型数组
[B # byte[] 字节数组
[C # char[] 字符数组
[Z # boolean[] 布尔数组
[Ljava/lang/String; # String[] 对象数组
[Lcom/example/MyClass; # 自定义对象数组
# ========== 类型转换指令 ==========
# 基本类型之间转换
int-to-byte v0, v1 # v0 = (byte) v1
int-to-char v0, v1 # v0 = (char) v1
int-to-short v0, v1 # v0 = (short) v1
int-to-long v0, v1 # v0,v1 = (long) v1(占用两个寄存器)
int-to-float v0, v1 # v0 = (float) v1
int-to-double v0, v1 # v0,v1 = (double) v1
long-to-int v0, v1 # v0 = (int) v1(v1,v2为long)
float-to-int v0, v1 # v0 = (int) v1
double-to-int v0, v1 # v0 = (int) v1(v1,v2为double)
# 对象类型检查
check-cast v0, Lcom/example/MyClass; # v0 = (MyClass) v0
instance-of v0, v1, Lcom/example/MyClass; # v0 = (v1 instanceof MyClass)
# ========== 类型与寄存器的关系 ==========
# 32位类型(Z,B,S,C,I,F,对象引用):占用1个寄存器
# 64位类型(J,D):占用2个连续寄存器
# 例如:const-wide v0, 0x123456789ABCDEFL # 使用v0和v1
2.2 寄存器模型详解
Smali使用基于寄存器的虚拟机模型,每个方法有独立的寄存器空间:
SMALI
# ========== 寄存器声明 ==========
.method public static main([Ljava/lang/String;)V
.registers 5 # 声明方法使用5个寄存器(v0-v4)
.locals 3 # 声明局部变量寄存器数量(v0-v2)
.param p0, "args" # 参数寄存器p0
# 寄存器数量 = .locals + 参数数量
# 如果 .locals = 3, 参数有2个
# 则 v0-v2 是局部寄存器,v3=p0, v4=p1
# 总计 .registers 5
.prologue # 方法开始标记
# ... 方法体 ...
.epilogue # 方法结束标记(可选)
return-void
.end method
# ========== 寄存器命名规则 ==========
# v0, v1, v2 ... vN → 局部寄存器
# p0, p1, p2 ... pN → 参数寄存器
# 对于实例方法,p0 = this
# 对于静态方法,p0 = 第一个参数
# 示例:实例方法
.method public setName(Ljava/lang/String;)V
.registers 2
# v0 = p0 = this
# v1 = p1 = 参数 (String)
iput-object p1, p0, Lcom/example/MyClass;->name:Ljava/lang/String;
return-void
.end method
# 示例:静态方法
.method public static add(II)I
.registers 3
# v0 = p0 = 第一个int参数
# v1 = p1 = 第二个int参数
add-int v2, p0, p1
return v2
.end method
# ========== 寄存器赋值指令 ==========
# 常量加载
const/4 v0, 0x5 # v0 = 5 (范围:-8 ~ 7,4位)
const/16 v0, 0x64 # v0 = 100 (范围:-32768 ~ 32767,16位)
const v0, 0x10000000 # v0 = 268435456 (32位)
const/high16 v0, 0x3F800000 # v0 = 1.0f (高16位)
# 宽常量(64位)
const-wide/16 v0, 0x64L # v0,v1 = 100L
const-wide v0, 0x123456789ABCDEFL # v0,v1 = 大整数
const-wide/high16 v0, 0x3FF0000000000000L # v0,v1 = 1.0(double)
# 字符串常量
const-string v0, "Hello, Smali!"
const-string/jumbo v0, "很长的字符串..." # 用于长字符串
# 类常量
const-class v0, Lcom/example/MyClass; # v0 = MyClass.class(Class对象)
# 寄存器间移动
move v0, v1 # v0 = v1(32位)
move-wide v0, v2 # v0,v1 = v2,v3(64位)
move-object v0, v1 # v0 = v1(对象引用)
move-result v0 # 获取上一条invoke指令的返回值(32位)
move-result-object v0 # 获取上一条invoke指令的返回值(对象)
move-result-wide v0 # 获取上一条invoke指令的返回值(64位)
move-exception v0 # 在catch块中获取异常对象
# 空值
const/4 v0, 0x0 # v0 = 0(用于int/boolean等)
const-string v0, "" # v0 = ""(空字符串)
# NULL常量
# 直接使用 const/4 v0, 0x0 表示 null
2.3 算术与逻辑运算指令
SMALI
# ========== 算术运算 ==========
# 格式:op dest, src1, src2
# 结果:dest = src1 op src2
# 加法
add-int v0, v1, v2 # v0 = v1 + v2
add-int/2addr v0, v1 # v0 = v0 + v1
add-int/lit8 v0, v1, 0x5 # v0 = v1 + 5(8位常量)
add-int/lit16 v0, v1, 0x100 # v0 = v1 + 256(16位常量)
# 64位加法
add-long v0, v2, v4 # v0,v1 = v2,v3 + v4,v5
add-long/2addr v0, v2 # v0,v1 = v0,v1 + v2,v3
# 浮点加法
add-float v0, v1, v2 # v0 = v1 + v2
add-double v0, v2, v4 # v0,v1 = v2,v3 + v4,v5
# 减法
sub-int v0, v1, v2 # v0 = v1 - v2
sub-int/2addr v0, v1 # v0 = v0 - v1
sub-int/lit8 v0, v1, 0x5 # v0 = v1 - 5
sub-long v0, v2, v4 # v0,v1 = v2,v3 - v4,v5
sub-float v0, v1, v2 # v0 = v1 - v2
sub-double v0, v2, v4 # v0,v1 = v2,v3 - v4,v5
# 乘法
mul-int v0, v1, v2 # v0 = v1 * v2
mul-int/2addr v0, v1 # v0 = v0 * v1
mul-int/lit8 v0, v1, 0x5 # v0 = v1 * 5
mul-long v0, v2, v4 # v0,v1 = v2,v3 * v4,v5
mul-float v0, v1, v2 # v0 = v1 * v2
mul-double v0, v2, v4 # v0,v1 = v2,v3 * v4,v5
# 除法
div-int v0, v1, v2 # v0 = v1 / v2(整数除法,向零取整)
div-int/2addr v0, v1 # v0 = v0 / v1
div-int/lit8 v0, v1, 0x5 # v0 = v1 / 5
div-long v0, v2, v4 # v0,v1 = v2,v3 / v4,v5
div-float v0, v1, v2 # v0 = v1 / v2
div-double v0, v2, v4 # v0,v1 = v2,v3 / v4,v5
# 取余
rem-int v0, v1, v2 # v0 = v1 % v2
rem-int/2addr v0, v1 # v0 = v0 % v1
rem-int/lit8 v0, v1, 0x5 # v0 = v1 % 5
rem-long v0, v2, v4 # v0,v1 = v2,v3 % v4,v5
rem-float v0, v1, v2 # v0 = v1 % v2
rem-double v0, v2, v4 # v0,v1 = v2,v3 % v4,v5
# 取负
neg-int v0, v1 # v0 = -v1
neg-long v0, v2 # v0,v1 = -(v2,v3)
neg-float v0, v1 # v0 = -v1
neg-double v0, v2 # v0,v1 = -(v2,v3)
# ========== 位运算 ==========
# 按位与
and-int v0, v1, v2 # v0 = v1 & v2
and-int/2addr v0, v1 # v0 = v0 & v1
and-int/lit8 v0, v1, 0x0F # v0 = v1 & 0x0F
and-long v0, v2, v4 # v0,v1 = v2,v3 & v4,v5
# 按位或
or-int v0, v1, v2 # v0 = v1 | v2
or-int/2addr v0, v1 # v0 = v0 | v1
or-int/lit8 v0, v1, 0x0F # v0 = v1 | 0x0F
or-long v0, v2, v4 # v0,v1 = v2,v3 | v4,v5
# 按位异或
xor-int v0, v1, v2 # v0 = v1 ^ v2
xor-int/2addr v0, v1 # v0 = v0 ^ v1
xor-int/lit8 v0, v1, 0x0F # v0 = v1 ^ 0x0F
xor-long v0, v2, v4 # v0,v1 = v2,v3 ^ v4,v5
# 左移
shl-int v0, v1, v2 # v0 = v1 << v2
shl-int/2addr v0, v1 # v0 = v0 << v1
shl-int/lit8 v0, v1, 0x3 # v0 = v1 << 3
shl-long v0, v2, v4 # v0,v1 = v2,v3 << v4
# 右移(算术右移,符号扩展)
shr-int v0, v1, v2 # v0 = v1 >> v2
shr-int/2addr v0, v1 # v0 = v0 >> v1
shr-int/lit8 v0, v1, 0x3 # v0 = v1 >> 3
shr-long v0, v2, v4 # v0,v1 = v2,v3 >> v4
# 无符号右移(逻辑右移,零扩展)
ushr-int v0, v1, v2 # v0 = v1 >>> v2
ushr-int/2addr v0, v1 # v0 = v0 >>> v1
ushr-int/lit8 v0, v1, 0x3 # v0 = v1 >>> 3
ushr-long v0, v2, v4 # v0,v1 = v2,v3 >>> v4
# 反转位
not-int v0, v1 # v0 = ~v1
not-long v0, v2 # v0,v1 = ~(v2,v3)
2.4 方法定义与调用
SMALI
# ========== 方法声明语法 ==========
# .method [访问修饰符] [static] 方法名(参数类型)返回值类型
# 访问修饰符:public, private, protected
# 参数类型:连续的类型描述符,无分隔符
# 返回值类型:单个类型描述符
# 构造方法
.method public constructor <init>(Ljava/lang/String;I)V
.registers 4
.param p1, "name" # String name
.param p2, "age" # int age
invoke-direct {p0}, Ljava/lang/Object;-><init>()V
iput-object p1, p0, Lcom/example/Person;->name:Ljava/lang/String;
iput p2, p0, Lcom/example/Person;->age:I
return-void
.end method
# 实例方法
.method public getName()Ljava/lang/String;
.registers 2
iget-object v0, p0, Lcom/example/Person;->name:Ljava/lang/String;
return-object v0
.end method
.method public setAge(I)V
.registers 2
.param p1, "age"
iput p1, p0, Lcom/example/Person;->age:I
return-void
.end method
# 静态方法
.method public static createPerson(Ljava/lang/String;I)Lcom/example/Person;
.registers 5
.param p0, "name"
.param p1, "age"
new-instance v0, Lcom/example/Person;
invoke-direct {v0, p0, p1}, Lcom/example/Person;-><init>(Ljava/lang/String;I)V
return-object v0
.end method
# ========== 五种方法调用指令 ==========
# 1. invoke-virtual:调用公有实例方法(虚方法)
invoke-virtual {p0}, Lcom/example/Person;->getName()Ljava/lang/String;
move-result-object v0
invoke-virtual {p0, v1}, Lcom/example/View;->setVisibility(I)V
# 2. invoke-direct:调用私有方法、构造方法、父类方法
invoke-direct {p0}, Ljava/lang/Object;-><init>()V
invoke-direct {p0, p1}, Lcom/example/MyClass;->privateMethod(Ljava/lang/String;)V
# 3. invoke-static:调用静态方法
invoke-static {p0, p1}, Lcom/example/Utils;->add(II)I
move-result v0
invoke-static {}, Ljava/lang/System;->currentTimeMillis()J
move-result-wide v0
# 4. invoke-super:调用父类方法
invoke-super {p0, p1}, Lcom/example/BaseActivity;->onCreate(Landroid/os/Bundle;)V
# 5. invoke-interface:调用接口方法
invoke-interface {p0, p1}, Ljava/util/List;->add(Ljava/lang/Object;)Z
# ========== 方法调用参数传递 ==========
# 寄存器列表格式:{寄存器1, 寄存器2, ...}
# 第一个寄存器始终是this(对于实例方法调用)
# 单参数调用
invoke-virtual {p0, v0}, Lcom/example/Person;->setName(Ljava/lang/String;)V
# 多参数调用
invoke-virtual {p0, v0, v1, v2}, Lcom/example/Person;->setInfo(Ljava/lang/String;II)V
# 返回值获取
invoke-virtual {p0}, Lcom/example/Person;->getName()Ljava/lang/String;
move-result-object v0 # 获取对象返回值
invoke-virtual {p0}, Lcom/example/Person;->getAge()I
move-result v0 # 获取32位返回值
invoke-virtual {p0}, Lcom/example/Person;->getBalance()J
move-result-wide v0 # 获取64位返回值
# ========== 返回值指令 ==========
return-void # 无返回值
return v0 # 返回32位值(int/float/boolean/char等)
return-wide v0 # 返回64位值(long/double)
return-object v0 # 返回对象引用
# ========== 方法注解 ==========
.annotation runtime Landroid/annotation/Nullable;
.end annotation
.annotation system Ldalvik/annotation/Throws;
value = {
Ljava/io/IOException;
}
.end annotation
2.5 字段定义与访问
SMALI
# ========== 字段声明语法 ==========
# .field [访问修饰符] [static] [final] 字段名:类型 [= 初始值]
# 实例字段
.field public name:Ljava/lang/String;
.field private age:I
.field protected score:F
.field private isActive:Z
.field public email:Ljava/lang/String; = "unknown@example.com"
# 静态字段(类变量)
.field public static TAG:Ljava/lang/String; = "MyClass"
.field private static counter:I = 0x0
.field public static final MAX_SIZE:I = 0x64
# 特殊字段类型
.field private mHandler:Landroid/os/Handler;
.field private mDataList:Ljava/util/ArrayList;
.annotation system Ldalvik/annotation/Signature;
value = "Ljava/util/ArrayList<Ljava/lang/String;>;"
.end annotation
.end field
# volatile字段
.field private volatile mRunning:Z
# transient字段
.field private transient mCache:Ljava/lang/Object;
# ========== 字段访问指令 ==========
# 实例字段读取(iget = instance get)
iget v0, p0, Lcom/example/Person;->age:I # int
iget-object v0, p0, Lcom/example/Person;->name:Ljava/lang/String; # 对象
iget-wide v0, p0, Lcom/example/Person;->balance:J # long/double
iget-boolean v0, p0, Lcom/example/Person;->isActive:Z
iget-byte v0, p0, Lcom/example/Person;->flags:B
iget-char v0, p0, Lcom/example/Person;->grade:C
iget-short v0, p0, Lcom/example/Person;->code:S
# 实例字段设置(iput = instance put)
iput v0, p0, Lcom/example/Person;->age:I
iput-object v0, p0, Lcom/example/Person;->name:Ljava/lang/String;
iput-wide v0, p0, Lcom/example/Person;->balance:J
iput-boolean v0, p0, Lcom/example/Person;->isActive:Z
iput-byte v0, p0, Lcom/example/Person;->flags:B
iput-char v0, p0, Lcom/example/Person;->grade:C
iput-short v0, p0, Lcom/example/Person;->code:S
# 静态字段读取(sget = static get)
sget v0, Lcom/example/Person;->counter:I
sget-object v0, Lcom/example/Person;->TAG:Ljava/lang/String;
sget-wide v0, Lcom/example/Config;->TIMEOUT:J
sget-boolean v0, Lcom/example/Config;->DEBUG:Z
# 静态字段设置(sput = static put)
sput v0, Lcom/example/Person;->counter:I
sput-object v0, Lcom/example/Person;->TAG:Ljava/lang/String;
sput-wide v0, Lcom/example/Config;->TIMEOUT:J
sput-boolean v0, Lcom/example/Config;->DEBUG:Z
# ========== 静态初始化块 ==========
.method static constructor <clinit>()V
.registers 2
const-string v0, "MyClass"
sput-object v0, Lcom/example/MyClass;->TAG:Ljava/lang/String;
const/16 v0, 0x100
sput v0, Lcom/example/MyClass;->MAX_SIZE:I
return-void
.end method
三、控制流详解
3.1 条件分支指令
SMALI
# ========== 零值比较(if-eqz / if-nez)==========
# 判断寄存器是否为0/null/false
if-eqz v0, :label # if (v0 == 0) goto label
if-nez v0, :label # if (v0 != 0) goto label
# 示例:空值检查
iget-object v0, p0, Lcom/example/Person;->name:Ljava/lang/String;
if-nez v0, :name_not_null
const-string v0, "Unknown"
iput-object v0, p0, Lcom/example/Person;->name:Ljava/lang/String;
:name_not_null
# 示例:布尔值判断
iget-boolean v0, p0, Lcom/example/Person;->isActive:Z
if-eqz v0, :not_active
# 活跃状态的处理
goto :end_check
:not_active
# 非活跃状态的处理
:end_check
# ========== 两寄存器比较 ==========
if-eq v0, v1, :label # if (v0 == v1) goto label
if-ne v0, v1, :label # if (v0 != v1) goto label
if-lt v0, v1, :label # if (v0 < v1) goto label
if-ge v0, v1, :label # if (v0 >= v1) goto label
if-gt v0, v1, :label # if (v0 > v1) goto label
if-le v0, v1, :label # if (v0 <= v1) goto label
# 示例:年龄判断
.method public checkAge(I)Z
.registers 3
.param p0, "this"
.param p1, "age"
const/16 v0, 0x12 # 18
if-lt p1, v0, :underage # if age < 18
if-ge p1, v0, :exact_18 # if age >= 18 (已被第一条过滤,实为==18)
const/16 v0, 0x41 # 65
if-ge p1, v0, :senior # if age >= 65
const/4 v0, 0x1 # 成年
return v0
:underage
const/4 v0, 0x0
return v0
:exact_18
const/4 v0, 0x1
return v0
:senior
const/4 v0, 0x1
return v0
.end method
# ========== 跳转指令 ==========
goto :label # 无条件跳转
goto/16 :label # 16位偏移跳转(更大范围)
goto/32 :label # 32位偏移跳转(最大范围)
# ========== switch 分支 ==========
# packed-switch:连续的case值
# 适用于 case 0,1,2,3,4... 这种连续值
.method public getDayName(I)Ljava/lang/String;
.registers 3
.param p0, "this"
.param p1, "day"
packed-switch p1, :pswitch_data
:pswitch_0 # day == 0
const-string v0, "Sunday"
return-object v0
:pswitch_1 # day == 1
const-string v0, "Monday"
return-object v0
:pswitch_2 # day == 2
const-string v0, "Tuesday"
return-object v0
:pswitch_3 # day == 3
const-string v0, "Wednesday"
return-object v0
:pswitch_4 # day == 4
const-string v0, "Thursday"
return-object v0
:pswitch_5 # day == 5
const-string v0, "Friday"
return-object v0
:pswitch_6 # day == 6
const-string v0, "Saturday"
return-object v0
:pswitch_default
const-string v0, "Invalid day"
return-object v0
:pswitch_data
.packed-switch 0x0 # 起始值
:pswitch_0
:pswitch_1
:pswitch_2
:pswitch_3
:pswitch_4
:pswitch_5
:pswitch_6
.end packed-switch
.end method
# sparse-switch:非连续的case值
# 适用于 case 1, 100, 200, 404... 这种非连续值
.method public getStatusCodeMessage(I)Ljava/lang/String;
.registers 3
.param p0, "this"
.param p1, "code"
sparse-switch p1, :sswitch_data
:sswitch_200
const-string v0, "OK"
return-object v0
:sswitch_301
const-string v0, "Moved Permanently"
return-object v0
:sswitch_404
const-string v0, "Not Found"
return-object v0
:sswitch_500
const-string v0, "Internal Server Error"
return-object v0
:sswitch_default
const-string v0, "Unknown Status"
return-object v0
:sswitch_data
.sparse-switch
0xc8 -> :sswitch_200 # 200
0x12d -> :sswitch_301 # 301
0x194 -> :sswitch_404 # 404
0x1f4 -> :sswitch_500 # 500
.end sparse-switch
.end method
3.2 循环结构实现
SMALI
# ========== for循环 ==========
# for (int i = 0; i < 10; i++) { ... }
.method public forLoopExample()V
.registers 3
const/4 v0, 0x0 # int i = 0
:loop_start
const/16 v1, 0xa # 10
if-ge v0, v1, :loop_end # if (i >= 10) break
# 循环体代码
# ...
add-int/lit8 v0, v0, 0x1 # i++
goto :loop_start
:loop_end
return-void
.end method
# ========== 倒序for循环 ==========
# for (int i = 10; i > 0; i--) { ... }
.method public reverseForLoop()V
.registers 3
const/16 v0, 0xa # int i = 10
:loop_start
if-lez v0, :loop_end # if (i <= 0) break
# 循环体代码
# ...
add-int/lit8 v0, v0, -0x1 # i--
goto :loop_start
:loop_end
return-void
.end method
# ========== while循环 ==========
# while (condition) { ... }
.method public whileLoopExample()V
.registers 3
const/4 v0, 0x0 # int i = 0
:while_start
const/16 v1, 0xa
if-ge v0, v1, :while_end # if (i >= 10) break
# 循环体代码
# ...
add-int/lit8 v0, v0, 0x1 # i++
goto :while_start
:while_end
return-void
.end method
# ========== do-while循环 ==========
# do { ... } while (condition);
.method public doWhileExample()V
.registers 3
const/4 v0, 0x0 # int i = 0
:do_body
# 循环体代码(至少执行一次)
# ...
add-int/lit8 v0, v0, 0x1 # i++
const/16 v1, 0xa
if-lt v0, v1, :do_body # if (i < 10) continue
return-void
.end method
# ========== 遍历数组 ==========
# for (int i = 0; i < array.length; i++) { ... }
.method public iterateArray([I)V
.registers 5
.param p0, "this"
.param p1, "array"
array-length v0, p1 # 获取数组长度
const/4 v1, 0x0 # int i = 0
:loop_start
if-ge v1, v0, :loop_end # if (i >= length) break
aget v2, p1, v1 # v2 = array[i]
# 处理 v2
# ...
add-int/lit8 v1, v1, 0x1 # i++
goto :loop_start
:loop_end
return-void
.end method
# ========== 遍历集合 ==========
# for (Object item : list) { ... } 使用Iterator
.method public iterateList(Ljava/util/List;)V
.registers 5
.param p0, "this"
.param p1, "list"
invoke-interface {p1}, Ljava/util/List;->iterator()Ljava/util/Iterator;
move-result-object v0
:loop_start
invoke-interface {v0}, Ljava/util/Iterator;->hasNext()Z
move-result v1
if-eqz v1, :loop_end
invoke-interface {v0}, Ljava/util/Iterator;->next()Ljava/lang/Object;
move-result-object v2
# 处理 v2
# ...
goto :loop_start
:loop_end
return-void
.end method
3.3 三元运算符与复杂逻辑
SMALI
# ========== 三元运算符:condition ? value1 : value2 ==========
.method public getDiscount(Z)I
.registers 3
.param p0, "this"
.param p1, "isVip"
if-eqz p1, :not_vip
const/16 v0, 0x14 # 20% discount
goto :end
:not_vip
const/16 v0, 0x0 # 0% discount
:end
return v0
.end method
# ========== 逻辑与 (&&) ==========
# if (a && b) { ... }
.method public checkAndCondition(ZZ)V
.registers 4
.param p0, "this"
.param p1, "a"
.param p2, "b"
if-eqz p1, :fail # 短路:a为false直接跳转
if-eqz p2, :fail # 短路:b为false直接跳转
# 两个条件都为true
# ...
return-void
:fail
# 条件不满足
return-void
.end method
# ========== 逻辑或 (||) ==========
# if (a || b) { ... }
.method public checkOrCondition(ZZ)V
.registers 4
.param p0, "this"
.param p1, "a"
.param p2, "b"
if-nez p1, :success # 短路:a为true直接成功
if-eqz p2, :fail # b为false才失败
:success
# 至少一个条件为true
# ...
return-void
:fail
# 两个条件都为false
return-void
.end method
# ========== 复杂条件组合 ==========
# if ((a && b) || c) { ... }
.method public complexCondition(ZZZ)V
.registers 5
.param p0, "this"
.param p1, "a"
.param p2, "b"
.param p3, "c"
if-nez p3, :check_ab # 先检查c(短路)
:success
# 条件满足:c为true,或(a && b)为true
# ...
return-void
:check_ab
if-eqz p1, :fail
if-eqz p2, :fail
goto :success
:fail
# 条件不满足
return-void
.end method
四、对象操作详解
4.1 对象创建与初始化
SMALI
# ========== 创建对象 ==========
.method public createObject()Lcom/example/Person;
.registers 5
# 步骤1:分配内存(不调用构造方法)
new-instance v0, Lcom/example/Person;
# 步骤2:准备参数
const-string v1, "Alice"
const/16 v2, 0x19 # 25
# 步骤3:调用构造方法
invoke-direct {v0, v1, v2}, Lcom/example/Person;-><init>(Ljava/lang/String;I)V
return-object v0
.end method
# ========== 创建数组对象 ==========
.method public createArray()V
.registers 4
# 创建基本类型数组
const/16 v0, 0xa # 10个元素
new-array v0, v0, [I # int[10]
# 创建对象数组
const/16 v1, 0x5
new-array v1, v1, [Ljava/lang/String; # String[5]
# 创建多维数组
const/4 v2, 0x3
const/4 v3, 0x4
filled-new-array {v2, v3}, [I # 维度:[3, 4]
move-result-object v2
new-array v2, v2, I # int[3][4]
return-void
.end method
# ========== 创建内部类对象 ==========
.method public createInnerClass()V
.registers 4
# 创建非静态内部类(需要外部类引用)
new-instance v0, Lcom/example/OuterClass$InnerClass;
invoke-direct {v0, p0}, Lcom/example/OuterClass$InnerClass;-><init>(Lcom/example/OuterClass;)V
# 创建静态内部类(不需要外部类引用)
new-instance v1, Lcom/example/OuterClass$StaticInnerClass;
invoke-direct {v1}, Lcom/example/OuterClass$StaticInnerClass;-><init>()V
return-void
.end method
# ========== 匿名内部类 ==========
.method public createAnonymousClass()V
.registers 4
new-instance v0, Lcom/example/MainActivity$1;
invoke-direct {v0, p0}, Lcom/example/MainActivity$1;-><init>(Lcom/example/MainActivity;)V
return-void
.end method
4.2 类型检查与转换
SMALI
# ========== instance-of:类型检查 ==========
.method public processObject(Ljava/lang/Object;)V
.registers 4
.param p0, "this"
.param p1, "obj"
# 检查是否为String类型
instance-of v0, p1, Ljava/lang/String;
if-eqz v0, :not_string
# 是String类型
check-cast p1, Ljava/lang/String;
# 使用p1作为String
goto :end
:not_string
# 检查是否为Integer类型
instance-of v0, p1, Ljava/lang/Integer;
if-eqz v0, :unknown
# 是Integer类型
check-cast p1, Ljava/lang/Integer;
invoke-virtual {p1}, Ljava/lang/Integer;->intValue()I
move-result v0
# 使用v0
goto :end
:unknown
const-string v0, "Unknown type"
# 处理未知类型
:end
return-void
.end method
# ========== check-cast:强制类型转换 ==========
.method public castExample(Ljava/lang/Object;)Lcom/example/Person;
.registers 3
.param p0, "this"
.param p1, "obj"
# 强制转换为Person类型(如果类型不匹配会抛出ClassCastException)
check-cast p1, Lcom/example/Person;
return-object p1
.end method
# ========== null检查 ==========
.method public safeOperation(Ljava/lang/Object;)V
.registers 3
.param p0, "this"
.param p1, "obj"
if-nez p1, :null_handler
# obj不为null,正常处理
invoke-virtual {p1}, Ljava/lang/Object;->toString()Ljava/lang/String;
move-result-object v0
# ...
return-void
:null_handler
const-string v0, "Object is null"
# 处理null情况
return-void
.end method
4.3 同步块
SMALI
# ========== monitor-enter / monitor-exit ==========
# synchronized (lock) { ... }
.method public synchronizedBlock(Ljava/lang/Object;)V
.registers 4
.param p0, "this"
.param p1, "lock"
# 获取锁
monitor-enter p1
# try块
:try_start
# 临界区代码
# ...
:try_end
# 释放锁
monitor-exit p1
return-void
# catch块(处理锁释放失败)
:catch
move-exception v0
monitor-exit p1
throw v0
.end method
# ========== synchronized 方法 ==========
# 直接在方法声明中使用 synchronized 修饰符
.method public declared-synchronized syncMethod()V
.registers 2
# 方法体(自动加锁/解锁)
# 等价于 synchronized(this) { ... }
return-void
.end method
五、数组操作
5.1 数组创建与填充
SMALI
# ========== 创建数组 ==========
.method public createArrays()V
.registers 5
# 创建基本类型数组
const/16 v0, 0x5
new-array v0, v0, [I # int[5]
# 创建对象数组
const/16 v1, 0x3
new-array v1, v1, [Ljava/lang/String; # String[3]
# 创建多维数组
const/4 v2, 0x2
const/4 v3, 0x3
filled-new-array {v2, v3}, [I # 维度:[2, 3]
move-result-object v2
new-array v2, v2, I # int[2][3]
# 创建字节数组
const/16 v0, 0x10
new-array v0, v0, [B # byte[16]
return-void
.end method
# ========== fill-array-data:填充数组 ==========
.method public fillArray()[I
.registers 3
const/4 v0, 0x5
new-array v0, v0, [I # int[5]
# 填充数组(使用fill-array-data)
fill-array-data v0, :array_data
return-object v0
:array_data
.array-data 4
0xa # 10
0x14 # 20
0x1e # 30
0x28 # 40
0x32 # 50
.end array-data
.end method
# ========== filled-new-array:创建并填充数组 ==========
.method public filledNewArray()[I
.registers 5
# 同时创建并填充数组
const/4 v0, 0x1
const/4 v1, 0x2
const/4 v2, 0x3
const/4 v3, 0x4
filled-new-array {v0, v1, v2, v3}, [I
move-result-object v0 # v0 = int[]{1, 2, 3, 4}
return-object v0
.end method
# 创建对象数组
.method public filledNewStringArray()[Ljava/lang/String;
.registers 4
const-string v0, "Apple"
const-string v1, "Banana"
const-string v2, "Cherry"
filled-new-array {v0, v1, v2}, [Ljava/lang/String;
move-result-object v0 # String[]{"Apple", "Banana", "Cherry"}
return-object v0
.end method
# ========== 使用fill-array-data填充大数组 ==========
.method public getLookupTable()[I
.registers 2
const/16 v0, 0x100 # 256个元素
new-array v0, v0, [I
fill-array-data v0, :table_data
return-object v0
:table_data
.array-data 4
0x00000001 0x00000002 0x00000004 0x00000008
0x00000010 0x00000020 0x00000040 0x00000080
# ... 更多数据
.end array-data
.end method
5.2 数组元素访问
SMALI
# ========== aget / aput:数组元素读写 ==========
.method public arrayAccess([I)V
.registers 5
.param p0, "this"
.param p1, "array"
# 读取元素
const/4 v0, 0x2
aget v1, p1, v0 # v1 = array[2]
# 写入元素
const/16 v2, 0x64 # 100
const/4 v0, 0x0
aput v2, p1, v0 # array[0] = 100
# 对象数组读取
# aget-object v0, p1, v1 # v0 = stringArray[index]
# 对象数组写入
# aput-object v0, p1, v1 # stringArray[index] = v0
# 宽类型读取
# aget-wide v0, p1, v1 # v0,v1 = longArray[index]
# 宽类型写入
# aput-wide v0, p1, v1 # longArray[index] = v0,v1
# 布尔/字节/字符/短整型读取
# aget-boolean v0, p1, v1
# aget-byte v0, p1, v1
# aget-char v0, p1, v1
# aget-short v0, p1, v1
# 布尔/字节/字符/短整型写入
# aput-boolean v0, p1, v1
# aput-byte v0, p1, v1
# aput-char v0, p1, v1
# aput-short v0, p1, v1
return-void
.end method
# ========== array-length:获取数组长度 ==========
.method public getArrayLength([Ljava/lang/Object;)I
.registers 3
.param p0, "this"
.param p1, "array"
array-length v0, p1 # v0 = array.length
return v0
.end method
# ========== 数组求和示例 ==========
.method public sumArray([I)I
.registers 5
.param p0, "this"
.param p1, "array"
array-length v0, p1 # 获取数组长度
const/4 v1, 0x0 # int sum = 0
const/4 v2, 0x0 # int i = 0
:loop_start
if-ge v2, v0, :loop_end # if (i >= len) break
aget v3, p1, v2 # v3 = array[i]
add-int/2addr v1, v3 # sum += v3
add-int/lit8 v2, v2, 0x1 # i++
goto :loop_start
:loop_end
return v1
.end method
六、异常处理
6.1 try-catch 结构
SMALI
# ========== 基本 try-catch ==========
.method public divide(II)I
.registers 5
.param p0, "this"
.param p1, "a"
.param p2, "b"
:try_start
div-int v0, p1, p2 # 可能抛出ArithmeticException
:try_end
return v0
.catch Ljava/lang/ArithmeticException; {:try_start .. :try_end} :catch_div_zero
:catch_div_zero
move-exception v0
# 捕获除零异常
const/4 v0, 0x0
return v0
.end method
# ========== 多个 catch 块 ==========
.method public multiCatch(Ljava/lang/String;)I
.registers 4
.param p0, "this"
.param p1, "str"
:try_start
invoke-static {p1}, Ljava/lang/Integer;->parseInt(Ljava/lang/String;)I
move-result v0
:try_end
return v0
.catch Ljava/lang/NumberFormatException; {:try_start .. :try_end} :catch_nfe
.catch Ljava/lang/NullPointerException; {:try_start .. :try_end} :catch_npe
:catch_nfe
move-exception v0
const/4 v0, -0x1
return v0
:catch_npe
move-exception v0
const/4 v0, -0x2
return v0
.end method
# ========== try-catch-finally ==========
.method public readFile(Ljava/lang/String;)Ljava/lang/String;
.registers 6
.param p0, "this"
.param p1, "filename"
const/4 v0, 0x0 # FileInputStream fis = null
:try_start
new-instance v1, Ljava/io/FileInputStream;
invoke-direct {v1, p1}, Ljava/io/FileInputStream;-><init>(Ljava/lang/String;)V
move-object v0, v1
# 读取文件内容
# ...
:try_end
# finally块
if-eqz v0, :close_end
invoke-virtual {v0}, Ljava/io/FileInputStream;->close()V
:close_end
return-object v2
.catch Ljava/io/IOException; {:try_start .. :try_end} :catch_io
:catch_io
move-exception v1
# finally块(在catch后也要执行)
if-eqz v0, :close_end2
invoke-virtual {v0}, Ljava/io/FileInputStream;->close()V
:close_end2
const/4 v2, 0x0
return-object v2
.end method
# ========== catchall(捕获所有异常)==========
.method public catchAllExample()V
.registers 3
:try_start
invoke-static {}, Lcom/example/Risky;->operation()V
:try_end
return-void
.catchall {:try_start .. :try_end} :catchall
:catchall
move-exception v0
# 处理所有异常
invoke-virtual {v0}, Ljava/lang/Throwable;->printStackTrace()V
return-void
.end method
# ========== throw 抛出异常 ==========
.method public validateAge(I)V
.registers 5
.param p0, "this"
.param p1, "age"
if-ltz p1, :throw_invalid # if (age < 0)
# 正常情况
return-void
:throw_invalid
new-instance v0, Ljava/lang/IllegalArgumentException;
const-string v1, "Age must be non-negative"
invoke-direct {v0, v1}, Ljava/lang/IllegalArgumentException;-><init>(Ljava/lang/String;)V
throw v0
.end method
6.2 异常处理器结构
SMALI
# ========== .catch 指令详解 ==========
# .catch 异常类型 {try_start_label .. try_end_label} :catch_handler_label
# try范围可以使用多个标签
.method public tryRangeExample()V
.registers 3
:try_block_start
# try块第一部分
invoke-static {}, Lcom/example/Utils;->init()V
:try_block_mid
# try块第二部分
invoke-static {}, Lcom/example/Utils;->process()V
:try_block_end
return-void
# 同一个catch可以覆盖多个try范围
.catch Ljava/lang/Exception; {:try_block_start .. :try_block_end} :handler
:handler
move-exception v0
invoke-virtual {v0}, Ljava/lang/Exception;->printStackTrace()V
return-void
.end method
# ========== 嵌套 try-catch ==========
.method public nestedTryCatch()V
.registers 4
:outer_try_start
# 外层try代码
invoke-static {}, Lcom/example/Utils;->outerOperation()V
:inner_try_start
# 内层try代码
invoke-static {}, Lcom/example/Utils;->innerOperation()V
:inner_try_end
:outer_try_end
return-void
.catch Ljava/io/IOException; {:inner_try_start .. :inner_try_end} :inner_catch
.catch Ljava/lang/RuntimeException; {:outer_try_start .. :outer_try_end} :outer_catch
:inner_catch
move-exception v0
# 处理内层IOException
goto :outer_try_end
:outer_catch
move-exception v0
# 处理外层RuntimeException
return-void
.end method
七、实用代码模式
7.1 方法Hook模式
SMALI
# ========== 模式1:替换整个方法体 ==========
# 原始方法
.method public isPremium()Z
.registers 2
# 原始代码被替换,直接返回true
const/4 v0, 0x1
return v0
.end method
# ========== 模式2:在方法前添加Hook代码 ==========
.method public onCreate(Landroid/os/Bundle;)V
.registers 4
.param p0, "this"
.param p1, "savedInstanceState"
# Hook代码:记录日志
const-string v0, "Hook"
const-string v1, "onCreate called"
invoke-static {v0, v1}, Landroid/util/Log;->d(Ljava/lang/String;Ljava/lang/String;)I
# 调用原始方法
invoke-super {p0, p1}, Landroid/app/Activity;->onCreate(Landroid/os/Bundle;)V
# Hook代码:修改行为
const-string v0, "Hook"
const-string v1, "onCreate finished"
invoke-static {v0, v1}, Landroid/util/Log;->d(Ljava/lang/String;Ljava/lang/String;)I
return-void
.end method
# ========== 模式3:条件Hook ==========
.method public checkLicense()Z
.registers 4
# 获取包名
invoke-virtual {p0}, Landroid/content/Context;->getPackageName()Ljava/lang/String;
move-result-object v0
const-string v1, "com.example.premium"
invoke-virtual {v0, v1}, Ljava/lang/String;->equals(Ljava/lang/Object;)Z
move-result v0
if-eqz v0, :normal_check
# Hook:特定包名直接返回true
const/4 v0, 0x1
return v0
:normal_check
# 原始验证逻辑
# ...
return v0
.end method
# ========== 模式4:返回值Hook ==========
.method public getExpireDate()Ljava/util/Date;
.registers 4
# 调用原始方法
invoke-virtual {p0}, Lcom/example/License;->getExpireDate()Ljava/util/Date;
move-result-object v0
if-nez v0, :return_hooked
return-object v0
:return_hooked
# 返回一个很远的未来日期
new-instance v0, Ljava/util/Date;
const-wide v1, 0x7fffffffffffffffL # 最大long值
invoke-direct {v0, v1, v2}, Ljava/util/Date;-><init>(J)V
return-object v0
.end method
7.2 字符串处理模式
SMALI
# ========== 字符串拼接 ==========
.method public concatStrings(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;
.registers 6
.param p0, "this"
.param p1, "str1"
.param p2, "str2"
# 使用StringBuilder拼接
new-instance v0, Ljava/lang/StringBuilder;
invoke-direct {v0}, Ljava/lang/StringBuilder;-><init>()V
invoke-virtual {v0, p1}, Ljava/lang/StringBuilder;->append(Ljava/lang/String;)Ljava/lang/StringBuilder;
move-result-object v0
const-string v1, " - "
invoke-virtual {v0, v1}, Ljava/lang/StringBuilder;->append(Ljava/lang/String;)Ljava/lang/StringBuilder;
move-result-object v0
invoke-virtual {v0, p2}, Ljava/lang/StringBuilder;->append(Ljava/lang/String;)Ljava/lang/StringBuilder;
move-result-object v0
invoke-virtual {v0}, Ljava/lang/StringBuilder;->toString()Ljava/lang/String;
move-result-object v0
return-object v0
.end method
# ========== 字符串比较 ==========
.method public compareStrings(Ljava/lang/String;Ljava/lang/String;)Z
.registers 4
.param p0, "this"
.param p1, "str1"
.param p2, "str2"
# 第1步:null检查
if-nez p1, :check_both_null
if-nez p2, :not_equal
# 第2步:equals比较
invoke-virtual {p1, p2}, Ljava/lang/String;->equals(Ljava/lang/Object;)Z
move-result v0
return v0
:check_both_null
if-nez p2, :not_equal
const/4 v0, 0x1
return v0
:not_equal
const/4 v0, 0x0
return v0
.end method
# ========== 字符串格式化 ==========
.method public formatString(Ljava/lang/String;[Ljava/lang/Object;)Ljava/lang/String;
.registers 4
.param p0, "this"
.param p1, "format"
.param p2, "args"
invoke-static {p1, p2}, Ljava/lang/String;->format(Ljava/lang/String;[Ljava/lang/Object;)Ljava/lang/String;
move-result-object v0
return-object v0
.end method
# ========== Base64编解码 ==========
.method public encodeBase64([B)Ljava/lang/String;
.registers 3
.param p0, "this"
.param p1, "data"
# Android SDK 26+ 使用 java.util.Base64
const/4 v0, 0x0 # Base64.DEFAULT
invoke-static {p1, v0}, Ljava/util/Base64;->encodeToString([BI)Ljava/lang/String;
move-result-object v0
return-object v0
.end method
.method public decodeBase64(Ljava/lang/String;)[B
.registers 3
.param p0, "this"
.param p1, "base64Str"
const/4 v0, 0x0 # Base64.DEFAULT
invoke-static {p1, v0}, Ljava/util/Base64;->decode(Ljava/lang/String;I)[B
move-result-object v0
return-object v0
.end method
# ========== 字符串加密解密(XOR)==========
.method public xorEncrypt([B[B)[B
.registers 7
.param p0, "this"
.param p1, "data"
.param p2, "key"
array-length v0, p1
new-array v1, v0, [B
const/4 v2, 0x0 # int i = 0
:loop
if-ge v2, v0, :end
aget-byte v3, p1, v2
aget-byte v4, p2, v2
xor-int/2addr v3, v4
int-to-byte v3, v3
aput-byte v3, v1, v2
add-int/lit8 v2, v2, 0x1
goto :loop
:end
return-object v1
.end method
7.3 反射调用模式
SMALI
# ========== 通过反射获取类 ==========
.method public getClassByName(Ljava/lang/String;)Ljava/lang/Class;
.registers 3
.param p0, "this"
.param p1, "className"
# Class.forName(className)
invoke-static {p1}, Ljava/lang/Class;->forName(Ljava/lang/String;)Ljava/lang/Class;
move-result-object v0
return-object v0
.end method
# ========== 通过反射调用方法 ==========
.method public reflectCall(Ljava/lang/Object;Ljava/lang/String;[Ljava/lang/Object;[Ljava/lang/Class;)Ljava/lang/Object;
.registers 7
.param p0, "this"
.param p1, "target"
.param p2, "methodName"
.param p3, "args"
.param p4, "paramTypes"
# 获取Class对象
invoke-virtual {p1}, Ljava/lang/Object;->getClass()Ljava/lang/Class;
move-result-object v0
# 获取Method对象
invoke-virtual {v0, p2, p4}, Ljava/lang/Class;->getDeclaredMethod(Ljava/lang/String;[Ljava/lang/Class;)Ljava/lang/reflect/Method;
move-result-object v1
# 设置可访问(绕过私有访问限制)
const/4 v2, 0x1
invoke-virtual {v1, v2}, Ljava/lang/reflect/Method;->setAccessible(Z)V
# 调用方法
invoke-virtual {v1, p1, p3}, Ljava/lang/reflect/Method;->invoke(Ljava/lang/Object;[Ljava/lang/Object;)Ljava/lang/Object;
move-result-object v0
return-object v0
.end method
# ========== 通过反射获取/设置字段 ==========
.method public reflectGetField(Ljava/lang/Object;Ljava/lang/String;)Ljava/lang/Object;
.registers 5
.param p0, "this"
.param p1, "target"
.param p2, "fieldName"
# 获取Class对象
invoke-virtual {p1}, Ljava/lang/Object;->getClass()Ljava/lang/Class;
move-result-object v0
# 获取Field对象
invoke-virtual {v0, p2}, Ljava/lang/Class;->getDeclaredField(Ljava/lang/String;)Ljava/lang/reflect/Field;
move-result-object v1
# 设置可访问
const/4 v2, 0x1
invoke-virtual {v1, v2}, Ljava/lang/reflect/Field;->setAccessible(Z)V
# 获取字段值
invoke-virtual {v1, p1}, Ljava/lang/reflect/Field;->get(Ljava/lang/Object;)Ljava/lang/Object;
move-result-object v0
return-object v0
.end method
.method public reflectSetField(Ljava/lang/Object;Ljava/lang/String;Ljava/lang/Object;)V
.registers 6
.param p0, "this"
.param p1, "target"
.param p2, "fieldName"
.param p3, "value"
invoke-virtual {p1}, Ljava/lang/Object;->getClass()Ljava/lang/Class;
move-result-object v0
invoke-virtual {v0, p2}, Ljava/lang/Class;->getDeclaredField(Ljava/lang/String;)Ljava/lang/reflect/Field;
move-result-object v1
const/4 v2, 0x1
invoke-virtual {v1, v2}, Ljava/lang/reflect/Field;->setAccessible(Z)V
invoke-virtual {v1, p1, p3}, Ljava/lang/reflect/Field;->set(Ljava/lang/Object;Ljava/lang/Object;)V
return-void
.end method
7.4 常用API调用模式
SMALI
# ========== Log日志 ==========
.method public logExample()V
.registers 4
const-string v0, "TAG"
const-string v1, "Debug message"
# Log.d(TAG, message)
invoke-static {v0, v1}, Landroid/util/Log;->d(Ljava/lang/String;Ljava/lang/String;)I
# Log.e(TAG, message, exception)
const-string v2, "Error message"
move-object v1, v0
const/4 v0, 0x0 # exception = null
invoke-static {v1, v2, v0}, Landroid/util/Log;->e(Ljava/lang/String;Ljava/lang/String;Ljava/lang/Throwable;)I
return-void
.end method
# ========== Toast提示 ==========
.method public showToast(Ljava/lang/String;)V
.registers 5
.param p0, "this"
.param p1, "message"
# 获取Context(this是Activity)
const/4 v0, 0x0 # Toast.LENGTH_SHORT = 0
invoke-static {p0, p1, v0}, Landroid/widget/Toast;->makeText(Landroid/content/Context;Ljava/lang/CharSequence;I)Landroid/widget/Toast;
move-result-object v1
invoke-virtual {v1}, Landroid/widget/Toast;->show()V
return-void
.end method
# ========== SharedPreferences存储 ==========
.method public savePreference(Ljava/lang/String;Ljava/lang/String;)V
.registers 6
.param p0, "this"
.param p1, "key"
.param p2, "value"
# 获取SharedPreferences
const-string v0, "my_prefs"
const/4 v1, 0x0 # Context.MODE_PRIVATE = 0
invoke-virtual {p0, v0, v1}, Landroid/content/Context;->getSharedPreferences(Ljava/lang/String;I)Landroid/content/SharedPreferences;
move-result-object v0
# 获取Editor
invoke-interface {v0}, Landroid/content/SharedPreferences;->edit()Landroid/content/SharedPreferences$Editor;
move-result-object v1
# 保存数据
invoke-interface {v1, p1, p2}, Landroid/content/SharedPreferences$Editor;->putString(Ljava/lang/String;Ljava/lang/String;)Landroid/content/SharedPreferences$Editor;
# 提交
invoke-interface {v1}, Landroid/content/SharedPreferences$Editor;->apply()V
return-void
.end method
# ========== Intent跳转 ==========
.method public startActivity(Ljava/lang/String;)V
.registers 5
.param p0, "this"
.param p1, "className"
# 创建Intent
new-instance v0, Landroid/content/Intent;
invoke-direct {v0, p0, p1}, Landroid/content/Intent;-><init>(Landroid/content/Context;Ljava/lang/String;)V
# 添加额外数据
const-string v1, "extra_key"
const-string v2, "extra_value"
invoke-virtual {v0, v1, v2}, Landroid/content/Intent;->putExtra(Ljava/lang/String;Ljava/lang/String;)Landroid/content/Intent;
# 启动Activity
invoke-virtual {p0, v0}, Landroid/content/Context;->startActivity(Landroid/content/Intent;)V
return-void
.end method
# ========== Handler消息处理 ==========
.method public sendDelayedMessage(IJ)V
.registers 7
.param p0, "this"
.param p1, "what"
.param p2, "delayMillis"
# 获取Handler
iget-object v0, p0, Lcom/example/MainActivity;->mHandler:Landroid/os/Handler;
if-nez v0, :create_handler
:handler_ready
# 发送延迟消息
invoke-virtual {v0, p1, p2, p3}, Landroid/os/Handler;->sendEmptyMessageDelayed(IJ)Z
return-void
:create_handler
new-instance v0, Landroid/os/Handler;
invoke-static {}, Landroid/os/Looper;->getMainLooper()Landroid/os/Looper;
move-result-object v1
invoke-direct {v0, v1}, Landroid/os/Handler;-><init>(Landroid/os/Looper;)V
iput-object v0, p0, Lcom/example/MainActivity;->mHandler:Landroid/os/Handler;
goto :handler_ready
.end method
八、实战技巧
8.1 完整APK修改流程
BASH
# ========== 步骤1:反编译APK ==========
apktool d target.apk -o target_mod
# 如果遇到资源解码问题
apktool d -r target.apk -o target_mod # 跳过资源解码
apktool d -s target.apk -o target_mod # 跳过dex解码(只解资源)
# ========== 步骤2:定位目标代码 ==========
# 方法1:通过包名结构查找
# target_mod/smali/com/example/package/ClassName.smali
# 方法2:使用grep搜索关键词
grep -r "checkLicense" target_mod/smali/
grep -r "const-string" target_mod/smali/ | grep "需要修改的字符串"
# 方法3:使用jadx对照查看
jadx-gui target.apk
# 在jadx中找到目标类,查看对应的Smali文件路径
# ========== 步骤3:修改Smali代码 ==========
# 编辑 target_mod/smali/com/example/TargetClass.smali
# 步骤4:重新打包
apktool b target_mod -o modified.apk
# 步骤5:生成签名
keytool -genkey -v -keystore debug.keystore \
-alias debug \
-keyalg RSA \
-keysize 2048 \
-validity 10000 \
-storepass android \
-keypass android \
-dname "CN=Debug, OU=Dev, O=Test, L=City, S=State, C=CN"
# 步骤6:签名APK
jarsigner -sigalg SHA256withRSA \
-digestalg SHA-256 \
-keystore debug.keystore \
-storepass android \
-keypass android \
modified.apk debug
# 步骤7:对齐优化
zipalign -v 4 modified.apk aligned.apk
# 步骤8:安装测试
adb install -r aligned.apk
# 步骤9:查看日志
adb logcat -s "Hook:*" "*:E"
8.2 常见修改场景
SMALI
# ========== 场景1:绕过登录验证 ==========
# 修改前
.method public isLoggedIn()Z
.registers 3
iget-object v0, p0, Lcom/example/App;->mUser:Lcom/example/User;
if-eqz v0, :logged_in
const/4 v0, 0x0
return v0
:logged_in
const/4 v0, 0x1
return v0
.end method
# 修改后:直接返回true
.method public isLoggedIn()Z
.registers 2
const/4 v0, 0x1
return v0
.end method
# ========== 场景2:去除广告 ==========
# 修改前:显示广告
.method public showAd()V
.registers 3
iget-object v0, p0, Lcom/example/App;->mAdView:Lcom/google/ads/AdView;
invoke-virtual {v0}, Lcom/google/ads/AdView;->loadAd()V
return-void
.end method
# 修改后:空方法体
.method public showAd()V
.registers 1
return-void
.end method
# ========== 场景3:修改字符串资源 ==========
# 方式1:修改资源文件 res/values/strings.xml
# 方式2:修改代码中的硬编码字符串
# 修改前
const-string v0, "免费版"
# 修改后
const-string v0, "专业版"
# ========== 场景4:解锁VIP功能 ==========
# 修改前
.method public isVipUser()Z
.registers 3
iget v0, p0, Lcom/example/User;->userType:I
const/4 v1, 0x1
if-ne v0, v1, :is_vip
const/4 v0, 0x0
return v0
:is_vip
const/4 v0, 0x1
return v0
.end method
# 修改后
.method public isVipUser()Z
.registers 2
const/4 v0, 0x1
return v0
.end method
# ========== 场景5:修改返回值 ==========
# 修改前:返回服务器时间
.method public getServerTime()J
.registers 3
# ... 网络请求获取时间 ...
return-wide v0
.end method
# 修改后:返回固定时间
.method public getServerTime()J
.registers 3
const-wide v0, 0x18f9b3d800L # 2025-01-01 00:00:00 UTC
return-wide v0
.end method
# ========== 场景6:添加日志输出 ==========
.method public onCreate(Landroid/os/Bundle;)V
.registers 4
.param p0, "this"
.param p1, "savedInstanceState"
# 添加调试日志
const-string v0, "DEBUG_PATCH"
const-string v1, "onCreate invoked"
invoke-static {v0, v1}, Landroid/util/Log;->d(Ljava/lang/String;Ljava/lang/String;)I
# 打印参数
invoke-static {p1}, Ljava/lang/String;->valueOf(Ljava/lang/Object;)Ljava/lang/String;
move-result-object v1
invoke-static {v0, v1}, Landroid/util/Log;->d(Ljava/lang/String;Ljava/lang/String;)I
# 调用原始方法
invoke-super {p0, p1}, Landroid/app/Activity;->onCreate(Landroid/os/Bundle;)V
return-void
.end method
# ========== 场景7:禁用网络检测 ==========
.method public isNetworkAvailable()Z
.registers 2
const/4 v0, 0x1
return v0
.end method
# ========== 场景8:修改方法参数 ==========
.method public sendRequest(Ljava/lang/String;)V
.registers 3
.param p0, "this"
.param p1, "url"
# 修改参数:替换URL
const-string p1, "https://modified-server.com/api"
# 继续原始逻辑
# ...
return-void
.end method
8.3 寄存器使用技巧
SMALI
# ========== 技巧1:减少寄存器数量 ==========
# 不好的写法(使用过多寄存器)
.method public badExample()V
.registers 6
const/4 v0, 0x1
const/4 v1, 0x2
const/4 v2, 0x3
const/4 v3, 0x4
add-int v4, v0, v1
add-int/2addr v4, v2
add-int/2addr v4, v3
return-void
.end method
# 好的写法(复用寄存器)
.method public goodExample()V
.registers 3
const/4 v0, 0x1
const/4 v1, 0x2
add-int/2addr v0, v1
const/16 v1, 0x3
add-int/2addr v0, v1
const/16 v1, 0x4
add-int/2addr v0, v1
return-void
.end method
# ========== 技巧2:使用高效指令 ==========
# 使用 const/4 代替 const/16(当值在-8~7范围内)
const/4 v0, 0x5 # 2字节指令,高效
# 而不是
const/16 v0, 0x5 # 4字节指令,低效
# 使用 add-int/lit8 代替 add-int(当加数在-128~127范围内)
add-int/lit8 v0, v1, 0x5 # 2字节指令
# 而不是
const/16 v2, 0x5 # 4字节
add-int v0, v1, v2 # 2字节
# ========== 技巧3:避免不必要的move ==========
# 不好的写法
move-object v0, p0
invoke-virtual {v0}, Lcom/example/MyClass;->method()V
# 好的写法(直接使用p0)
invoke-virtual {p0}, Lcom/example/MyClass;->method()V
# ========== 技巧4:理解64位寄存器占用 ==========
# long/double 占用两个寄存器
const-wide v0, 0x100L # 使用 v0 和 v1
# 下一个可用寄存器是 v2,不能使用 v1
const/4 v2, 0xa # 正确:使用 v2
# const/4 v1, 0xa # 错误:v1已被占用
九、调试与分析
9.1 ADB调试命令
BASH
# ========== 基本命令 ==========
# 查看连接的设备
adb devices
# 安装APK
adb install app.apk
adb install -r app.apk # 覆盖安装
adb install -d app.apk # 允许降级安装
# 卸载应用
adb uninstall com.example.app
# 启动应用
adb shell am start -n com.example.app/.MainActivity
# 停止应用
adb shell am force-stop com.example.app
# ========== 日志查看 ==========
# 查看所有日志
adb logcat
# 过滤特定TAG
adb logcat -s TAG_NAME
adb logcat -s "Hook:*" "DEBUG:*"
# 过滤级别
adb logcat *:E # 只显示Error级别
adb logcat *:W # 只显示Warning及以上
# 清空日志
adb logcat -c
# 输出到文件
adb logcat -d > logcat.txt
# ========== 进程信息 ==========
# 查看所有进程
adb shell ps
# 查看特定应用进程
adb shell ps | grep com.example
# 查看进程内存
adb shell dumpsys meminfo com.example.app
# ========== 文件操作 ==========
# 拉取文件
adb pull /data/data/com.example.app/shared_prefs/config.xml
# 推送文件
adb push config.xml /data/data/com.example.app/shared_prefs/
# 查看应用数据目录
adb shell ls -la /data/data/com.example.app/
# ========== 调试相关 ==========
# 查看等待调试的进程
adb jdwp
# 转发调试端口
adb forward tcp:8700 jdwp:12345
# 捕获ANR trace
adb shell cat /data/anr/traces.txt
9.2 静态分析工具链
BASH
# ========== jadx:查看Java源码 ==========
# 图形界面
jadx-gui app.apk
# 命令行反编译
jadx -d output_dir app.apk
# 反编译指定类
jadx -d output_dir --no-res app.apk
# ========== dex2jar + JD-GUI ==========
# dex转jar
d2j-dex2jar.sh classes.dex -o output.jar
# 使用JD-GUI查看
jd-gui output.jar
# ========== apktool 高级用法 ==========
# 只解资源
apktool d -r app.apk -o res_only
# 只解代码
apktool d -s app.apk -o code_only
# 强制解码
apktool d -f app.apk -o force_dir
# 不反编译dex(保留原dex)
apktool d -s app.apk -o raw_dir
# ========== 使用grep高效搜索 ==========
# 搜索所有Smali文件中的字符串
grep -r "const-string" smali/ | grep "关键词"
# 搜索特定包名
grep -r "Lcom/example/target" smali/
# 搜索方法调用
grep -r "invoke-" smali/ | grep "checkLicense"
# 搜索字段访问
grep -r "iget\|iput\|sget\|sput" smali/
# 搜索异常处理
grep -r "\.catch\|throw" smali/
# 统计方法数量
grep -r "\.method " smali/ | wc -l
9.3 动态调试技巧
SMALI
# ========== 插入调试代码 ==========
.method public debugMethod()V
.registers 4
# 方式1:打印日志
const-string v0, "DEBUG"
const-string v1, "Entering debugMethod"
invoke-static {v0, v1}, Landroid/util/Log;->d(Ljava/lang/String;Ljava/lang/String;)I
# 方式2:打印调用栈
new-instance v0, Ljava/lang/Exception;
const-string v1, "Stack trace"
invoke-direct {v0, v1}, Ljava/lang/Exception;-><init>(Ljava/lang/String;)V
invoke-virtual {v0}, Ljava/lang/Exception;->printStackTrace()V
# 方式3:写入文件
new-instance v0, Ljava/io/File;
const-string v1, "/sdcard/debug.txt"
invoke-direct {v0, v1}, Ljava/io/File;-><init>(Ljava/lang/String;)V
# 方式4:使用Toast
const-string v0, "Method called"
const/4 v1, 0x0
invoke-static {p0, v0, v1}, Landroid/widget/Toast;->makeText(Landroid/content/Context;Ljava/lang/CharSequence;I)Landroid/widget/Toast;
move-result-object v0
invoke-virtual {v0}, Landroid/widget/Toast;->show()V
return-void
.end method
# ========== 寄存器值打印 ==========
.method public printRegisterValue(I)V
.registers 5
.param p0, "this"
.param p1, "value"
const-string v0, "REGISTER_DUMP"
# 打印int值
invoke-static {p1}, Ljava/lang/Integer;->toString(I)Ljava/lang/String;
move-result-object v1
invoke-static {v0, v1}, Landroid/util/Log;->d(Ljava/lang/String;Ljava/lang/String;)I
# 打印十六进制
invoke-static {p1}, Ljava/lang/Integer;->toHexString(I)Ljava/lang/String;
move-result-object v1
invoke-static {v0, v1}, Landroid/util/Log;->d(Ljava/lang/String;Ljava/lang/String;)I
return-void
.end method
十、安全与防护
10.1 防篡改检测
SMALI
# ========== 签名校验 ==========
.method public checkSignature()Z
.registers 8
.param p0, "this"
# 获取当前签名
invoke-virtual {p0}, Landroid/content/Context;->getPackageManager()Landroid/content/pm/PackageManager;
move-result-object v0
invoke-virtual {p0}, Landroid/content/Context;->getPackageName()Ljava/lang/String;
move-result-object v1
const/16 v2, 0x40 # GET_SIGNATURES
invoke-virtual {v0, v1, v2}, Landroid/content/pm/PackageManager;->getPackageInfo(Ljava/lang/String;I)Landroid/content/pm/PackageInfo;
move-result-object v0
iget-object v0, v0, Landroid/content/pm/PackageInfo;->signatures[Landroid/content/pm/Signature;
const/4 v1, 0x0
aget-object v0, v0, v1
# 获取签名哈希
invoke-virtual {v0}, Landroid/content/pm/Signature;->toByteArray()[B
move-result-object v0
const-string v1, "SHA-256"
invoke-static {v1}, Ljava/security/MessageDigest;->getInstance(Ljava/lang/String;)Ljava/security/MessageDigest;
move-result-object v1
invoke-virtual {v1, v0}, Ljava/security/MessageDigest;->digest([B)[B
move-result-object v0
# 转十六进制字符串
const/4 v2, 0x0
new-instance v3, Ljava/lang/StringBuilder;
invoke-direct {v3}, Ljava/lang/StringBuilder;-><init>()V
array-length v4, v0
:loop
if-ge v2, v4, :done
aget-byte v5, v0, v2
invoke-static {v5}, Ljava/lang/Integer;->toHexString(I)Ljava/lang/String;
move-result-object v5
invoke-virtual {v3, v5}, Ljava/lang/StringBuilder;->append(Ljava/lang/String;)Ljava/lang/StringBuilder;
add-int/lit8 v2, v2, 0x1
goto :loop
:done
invoke-virtual {v3}, Ljava/lang/StringBuilder;->toString()Ljava/lang/String;
move-result-object v1
# 与预期签名比较
const-string v2, "EXPECTED_SIGNATURE_HASH"
invoke-virtual {v1, v2}, Ljava/lang/String;->equals(Ljava/lang/Object;)Z
move-result v0
if-nez v0, :valid
# 签名不匹配,退出应用
invoke-static {}, Landroid/os/Process;->myPid()I
move-result v0
invoke-static {v0}, Landroid/os/Process;->killProcess(I)V
:valid
return v0
.end method
# ========== APK完整性校验 ==========
.method public checkApkIntegrity()Z
.registers 6
.param p0, "this"
# 获取APK路径
invoke-virtual {p0}, Landroid/content/Context;->getPackageCodePath()Ljava/lang/String;
move-result-object v0
# 计算CRC32
new-instance v1, Ljava/io/FileInputStream;
invoke-direct {v1, v0}, Ljava/io/FileInputStream;-><init>(Ljava/lang/String;)V
new-instance v2, Ljava/util/zip/CRC32;
invoke-direct {v2}, Ljava/util/zip/CRC32;-><init>()V
const/16 v3, 0x2000 # 8KB buffer
new-array v3, v3, [B
:read_loop
invoke-virtual {v1, v3}, Ljava/io/FileInputStream;->read([B)I
move-result v4
if-ltz v4, :read_loop
const/4 v4, 0x0
invoke-virtual {v2, v3, v4, v4}, Ljava/util/zip/CRC32;->update([BII)V
goto :read_loop
:check_crc
invoke-virtual {v1}, Ljava/io/FileInputStream;->close()V
invoke-virtual {v2}, Ljava/util/zip/CRC32;->getValue()J
move-result-wide v0
# 与预期CRC比较
const-wide v2, 0x12345678L
cmp-long v0, v0, v2
if-nez v0, :tampered
const/4 v0, 0x1
return v0
:tampered
const/4 v0, 0x0
return v0
.end method
# ========== 检测调试器 ==========
.method public isDebuggerAttached()Z
.registers 3
# 方法1:Debug.isDebuggerConnected()
invoke-static {}, Landroid/os/Debug;->isDebuggerConnected()Z
move-result v0
if-eqz v0, :debugger_detected
# 方法2:检查TracerPid
# 需要读取 /proc/self/status
# ...
const/4 v0, 0x0
return v0
:debugger_detected
const/4 v0, 0x1
return v0
.end method
# ========== 检测模拟器 ==========
.method public isEmulator()Z
.registers 4
# 检查Build信息
sget-object v0, Landroid/os/Build;->FINGERPRINT:Ljava/lang/String;
const-string v1, "generic"
invoke-virtual {v0, v1}, Ljava/lang/String;->contains(Ljava/lang/CharSequence;)Z
move-result v0
if-eqz v0, :is_emulator
sget-object v0, Landroid/os/Build;->MODEL:Ljava/lang/String;
const-string v1, "Emulator"
invoke-virtual {v0, v1}, Ljava/lang/String;->contains(Ljava/lang/CharSequence;)Z
move-result v0
if-eqz v0, :is_emulator
sget-object v0, Landroid/os/Build;->HARDWARE:Ljava/lang/String;
const-string v1, "goldfish"
invoke-virtual {v0, v1}, Ljava/lang/String;->contains(Ljava/lang/CharSequence;)Z
move-result v0
if-eqz v0, :is_emulator
const/4 v0, 0x0
return v0
:is_emulator
const/4 v0, 0x1
return v0
.end method
10.2 反调试
SMALI
# ========== 反调试完整方案 ==========
.method public antiDebug()V
.registers 5
# 1. 检测调试器
invoke-static {}, Landroid/os/Debug;->isDebuggerConnected()Z
move-result v0
if-eqz v0, :kill_process
# 2. 检测TracerPid
# 轮询 /proc/self/status 中的 TracerPid
# 如果 TracerPid != 0,说明有调试器附加
# 3. 检测JDWP线程
# 检查是否存在JDWP线程
# 4. 时间检测
invoke-static {}, Ljava/lang/System;->currentTimeMillis()J
move-result-wide v0
# 执行一些操作...
invoke-static {}, Ljava/lang/System;->currentTimeMillis()J
move-result-wide v2
sub-long/2addr v2, v0
const-wide/32 v0, 0x3e8 # 1000ms
cmp-long v0, v2, v0
if-gtz v0, :normal
:kill_process
invoke-static {}, Landroid/os/Process;->myPid()I
move-result v0
invoke-static {v0}, Landroid/os/Process;->killProcess(I)V
const/4 v0, 0x0
invoke-static {v0}, Ljava/lang/System;->exit(I)V
:normal
return-void
.end method
# ========== 代码混淆思路 ==========
# 在Smali层面,可以手动混淆:
# 1. 修改类名(需要同时修改所有引用)
# 2. 修改方法名(需要同时修改所有调用)
# 3. 插入无用代码(nop指令、死代码分支)
# 4. 字符串加密(不直接使用常量字符串)
# 5. 控制流平坦化(使用switch替代if-else)
# 示例:插入nop指令(无操作指令)
.method public obfuscatedMethod()V
.registers 2
nop # 无用指令
nop # 无用指令
# 实际代码
invoke-static {}, Lcom/example/Utils;->doSomething()V
nop # 无用指令
return-void
.end method
十一、总结
11.1 Smali编程核心要点
| 要点 | 说明 |
|---|---|
| 寄存器模型 | 理解v寄存器(局部)和p寄存器(参数)的区别,long/double占2个寄存器 |
| 类型系统 | 掌握基本类型单字母描述符(Z/B/S/C/I/J/F/D/V)和对象类型L全路径; |
| 方法调用 | 区分invoke-virtual/direct/static/super/interface五种调用方式 |
| 字段访问 | 区分iget/iput(实例)和sget/sput(静态),注意类型后缀 |
| 控制流 | 掌握if系列指令和goto跳转,理解packed-switch和sparse-switch |
| 异常处理 | 理解.catch指令的语法和try-catch-finally的实现模式 |
| 数组操作 | 掌握new-array、filled-new-array、aget/aput和fill-array-data |
11.2 学习路径
CODE
Smali基础语法 → 类型系统 → 寄存器模型 → 方法调用 → 字段访问
↓ ↓ ↓ ↓ ↓
数据类型 ZBSCIJFD v/p寄存器 invoke指令 iget/iput
指令格式 L对象类型 寄存器分配 返回值处理 sget/sput
控制流 → 对象操作 → 数组操作 → 异常处理 → 实战修改
↓ ↓ ↓ ↓ ↓
if跳转 new-instance new-array .catch APK修改
switch check-cast filled-new throw 方法Hook
循环 instance-of fill-data finally 字符串替换
11.3 进阶方向
- 动态Hook:使用Frida/Xposed进行运行时修改
- SO库分析:学习ARM汇编,分析Native层代码
- 加壳脱壳:理解APK加固原理和脱壳技术
- 协议分析:抓包分析网络协议,加密算法逆向
- 自动化工具:编写Python脚本批量修改Smali代码
11.4 推荐资源
- Smali/Baksmali官方仓库:https://github.com/JesusFreke/smali
- Apktool官方文档:https://ibotpeaches.github.io/Apktool/
- Android开发者文档:https://developer.android.com/docs
- Dalvik字节码文档:https://source.android.com/devices/tech/dalvik/dalvik-bytecode
- Android源码:https://source.android.com/
- XDA开发者论坛:https://forum.xda-developers.com/
- 看雪论坛:https://bbs.pediy.com/
祝你通过本书掌握Smali语言,成为Android逆向工程的高手!