Smali编程完全指南

← 返回指南列表

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语言,成为Android逆向工程的高手!