0基础安卓逆向原理与实践：第4章：安卓逆向环境搭建

第4章：安卓逆向环境搭建

4.1 环境搭建概述

4.1.1 逆向分析环境架构

安卓逆向分析需要一个完整的工具链环境，包括静态分析工具、动态分析工具、调试环境和辅助工具：

graph TB
    subgraph Host[主机环境]
        IDE[开发IDE]
        StaticTools[静态分析工具]
        NetworkTools[网络分析工具]
    end
    
    subgraph VM[虚拟机环境]
        AndroidVM[安卓虚拟机]
        LinuxVM[Linux分析环境]
    end
    
    subgraph Physical[物理设备]
        TestDevice[测试设备]
        RootedDevice[Root设备]
    end
    
    subgraph Tools[分析工具]
        Disassembler[反汇编器]
        Debugger[调试器]
        Decompiler[反编译器]
        Hooking[Hook工具]
    end
    
    Host --> VM
    Host --> Physical
    Tools --> Host
    Tools --> VM
    Tools --> Physical

4.1.2 环境要求

硬件要求：

• CPU：Intel i5或AMD Ryzen 5以上，支持虚拟化技术
• 内存：至少16GB RAM（推荐32GB）
• 存储：至少100GB可用空间（推荐SSD）
• 网络：稳定的互联网连接

软件要求：

• 操作系统：Windows 10/11、macOS 10.15+、Ubuntu 18.04+
• 虚拟化：VMware Workstation/Fusion、VirtualBox
• Java：JDK 8或11
• Python：3.7+

4.2 基础环境配置

4.2.1 Java开发环境

# Ubuntu/Debian安装OpenJDK
sudo apt update
sudo apt install openjdk-11-jdk

# 验证安装
java -version
javac -version

# 配置环境变量
echo 'export JAVA_HOME=/usr/lib/jvm/java-11-openjdk-amd64' >> ~/.bashrc
echo 'export PATH=$PATH:$JAVA_HOME/bin' >> ~/.bashrc
source ~/.bashrc

Windows环境配置：

# 下载并安装Oracle JDK或OpenJDK
# 设置环境变量
set JAVA_HOME=C:\Program Files\Java\jdk-11.0.x
set PATH=%PATH%;%JAVA_HOME%\bin

# 验证安装
java -version
javac -version

4.2.2 Android SDK配置

# 下载Android SDK命令行工具
wget https://dl.google.com/android/repository/commandlinetools-linux-8512546_latest.zip
unzip commandlinetools-linux-8512546_latest.zip

# 创建SDK目录结构
mkdir -p ~/Android/Sdk/cmdline-tools
mv cmdline-tools ~/Android/Sdk/cmdline-tools/latest

# 配置环境变量
export ANDROID_HOME=~/Android/Sdk
export PATH=$PATH:$ANDROID_HOME/cmdline-tools/latest/bin
export PATH=$PATH:$ANDROID_HOME/platform-tools
export PATH=$PATH:$ANDROID_HOME/build-tools/30.0.3

# 安装必要的SDK组件
sdkmanager "platform-tools" "platforms;android-31" "build-tools;30.0.3"
sdkmanager "system-images;android-31;google_apis;x86_64"
sdkmanager "emulator"

# 接受许可协议
sdkmanager --licenses

4.2.3 Python环境配置

# 安装Python和pip
sudo apt install python3 python3-pip python3-venv

# 创建虚拟环境
python3 -m venv ~/android-reverse-env
source ~/android-reverse-env/bin/activate

# 安装常用Python库
pip install --upgrade pip
pip install requests beautifulsoup4 lxml
pip install pycryptodome cryptography
pip install frida-tools
pip install androguard
pip install r2pipe

4.3 静态分析工具

4.3.1 反编译工具

APKTool安装和使用：

# 下载APKTool
wget https://raw.githubusercontent.com/iBotPeaches/Apktool/master/scripts/linux/apktool
wget https://bitbucket.org/iBotPeaches/apktool/downloads/apktool_2.6.1.jar

# 设置执行权限
chmod +x apktool
sudo mv apktool /usr/local/bin/
sudo mv apktool_2.6.1.jar /usr/local/bin/apktool.jar

# 使用示例
apktool d app.apk -o output_dir    # 反编译APK
apktool b output_dir -o new_app.apk # 重新打包APK

dex2jar工具：

# 下载dex2jar
wget https://github.com/pxb1988/dex2jar/releases/download/2.1/dex-tools-2.1.zip
unzip dex-tools-2.1.zip
sudo mv dex-tools-2.1 /opt/dex2jar
sudo ln -s /opt/dex2jar/d2j-dex2jar.sh /usr/local/bin/d2j-dex2jar

# 使用示例
d2j-dex2jar app.apk                # 将APK转换为JAR
d2j-dex2jar classes.dex            # 将DEX转换为JAR

JD-GUI安装：

# 下载JD-GUI
wget https://github.com/java-decompiler/jd-gui/releases/download/v1.6.6/jd-gui-1.6.6.jar

# 创建启动脚本
cat > /usr/local/bin/jd-gui << 'EOF'
#!/bin/bash
java -jar /opt/jd-gui/jd-gui-1.6.6.jar "$@"
EOF

chmod +x /usr/local/bin/jd-gui

4.3.2 反汇编工具

Radare2安装：

# 从源码安装Radare2
git clone https://github.com/radareorg/radare2
cd radare2
sys/install.sh

# 或使用包管理器安装
sudo apt install radare2

# 验证安装
r2 -v

# 基本使用
r2 binary_file
[0x00000000]> aaa    # 分析所有
[0x00000000]> pdf    # 打印当前函数的反汇编
[0x00000000]> afl    # 列出所有函数

Ghidra安装：

# 下载Ghidra
wget https://github.com/NationalSecurityAgency/ghidra/releases/download/Ghidra_10.2.2_build/ghidra_10.2.2_PUBLIC_20221115.zip
unzip ghidra_10.2.2_PUBLIC_20221115.zip
sudo mv ghidra_10.2.2_PUBLIC /opt/ghidra

# 创建启动脚本
cat > /usr/local/bin/ghidra << 'EOF'
#!/bin/bash
cd /opt/ghidra
./ghidraRun
EOF

chmod +x /usr/local/bin/ghidra

4.3.3 代码分析工具

Androguard安装和使用：

# 安装Androguard
pip install androguard

# 使用示例
from androguard.misc import AnalyzeAPK

def analyze_apk(apk_path):
    """分析APK文件"""
    a, d, dx = AnalyzeAPK(apk_path)
    
    # 获取基本信息
    print(f"Package: {a.get_package()}")
    print(f"Version: {a.get_androidversion_name()}")
    print(f"Permissions: {a.get_permissions()}")
    
    # 获取活动组件
    activities = a.get_activities()
    services = a.get_services()
    receivers = a.get_receivers()
    
    print(f"Activities: {len(activities)}")
    print(f"Services: {len(services)}")
    print(f"Receivers: {len(receivers)}")
    
    # 分析DEX文件
    for dex in d:
        print(f"DEX classes: {len(dex.get_classes())}")
    
    return a, d, dx

# 使用示例
if __name__ == "__main__":
    apk_path = "example.apk"
    a, d, dx = analyze_apk(apk_path)

MobSF (Mobile Security Framework)：

# 安装MobSF
git clone https://github.com/MobSF/Mobile-Security-Framework-MobSF.git
cd Mobile-Security-Framework-MobSF

# 安装依赖
pip install -r requirements.txt

# 运行MobSF
python manage.py runserver 127.0.0.1:8000

4.4 动态分析环境

4.4.1 Android模拟器配置

Android Studio AVD配置：

# 创建AVD
avdmanager create avd -n "Android31_x64" -k "system-images;android-31;google_apis;x86_64"

# 启动模拟器
emulator -avd Android31_x64 -writable-system -selinux permissive

# 获取root权限
adb root
adb remount

Genymotion配置：

# 下载Genymotion
# 注册账户并下载个人版

# 安装VirtualBox
sudo apt install virtualbox

# 配置Genymotion
# 创建虚拟设备，选择合适的Android版本
# 启动虚拟设备并安装必要的工具

4.4.2 物理设备配置

设备Root和调试配置：

# 启用开发者选项和USB调试
# 设置 -> 关于手机 -> 连续点击版本号7次
# 设置 -> 开发者选项 -> 启用USB调试

# 连接设备并验证
adb devices

# 获取设备信息
adb shell getprop ro.build.version.release  # Android版本
adb shell getprop ro.product.cpu.abi        # CPU架构
adb shell getprop ro.build.version.sdk      # API级别

# Root设备（需要解锁Bootloader）
# 1. 解锁Bootloader（厂商特定）
# 2. 刷入自定义Recovery（如TWRP）
# 3. 刷入Magisk获取Root权限

# 验证Root权限
adb shell su -c "id"

4.4.3 Frida环境搭建

Frida服务端安装：

# 在主机上安装Frida工具
pip install frida-tools

# 下载Frida服务端
# 访问 https://github.com/frida/frida/releases
# 下载对应架构的frida-server

# 推送到设备
adb push frida-server-15.1.14-android-arm64 /data/local/tmp/frida-server
adb shell chmod 755 /data/local/tmp/frida-server

# 启动Frida服务端
adb shell su -c "/data/local/tmp/frida-server &"

# 验证连接
frida-ps -U  # 列出设备上的进程

Frida脚本示例：

// hook_example.js
Java.perform(function() {
    // Hook Activity的onCreate方法
    var Activity = Java.use("android.app.Activity");
    Activity.onCreate.implementation = function(savedInstanceState) {
        console.log("[+] Activity.onCreate called");
        console.log("[+] Activity: " + this.getClass().getName());
        
        // 调用原始方法
        this.onCreate(savedInstanceState);
    };
    
    // Hook字符串比较
    var String = Java.use("java.lang.String");
    String.equals.implementation = function(other) {
        var result = this.equals(other);
        console.log("[+] String.equals called");
        console.log("[+] this: " + this.toString());
        console.log("[+] other: " + other.toString());
        console.log("[+] result: " + result);
        return result;
    };
});

# 运行Frida脚本
frida -U -f com.example.app -l hook_example.js --no-pause

4.5 网络分析环境

4.5.1 代理工具配置

Burp Suite配置：

# 下载Burp Suite Community Edition
wget https://portswigger.net/burp/releases/download?product=community&version=2022.12.7&type=Linux

# 安装Java（如果未安装）
sudo apt install openjdk-11-jre

# 运行Burp Suite
java -jar burpsuite_community_v2022.12.7.jar

# 配置代理
# Proxy -> Options -> Proxy Listeners
# 添加监听器：127.0.0.1:8080

mitmproxy配置：

# 安装mitmproxy
pip install mitmproxy

# 启动代理
mitmproxy -p 8080

# 或使用Web界面
mitmweb -p 8080

# 配置设备代理
# 设置 -> Wi-Fi -> 长按网络 -> 修改网络 -> 高级选项
# 代理：手动，主机名：电脑IP，端口：8080

# 安装证书
# 浏览器访问 mitm.it 下载证书
# 设置 -> 安全 -> 加密与凭据 -> 从存储设备安装

4.5.2 网络监控工具

Wireshark配置：

# 安装Wireshark
sudo apt install wireshark

# 添加用户到wireshark组
sudo usermod -a -G wireshark $USER

# 重新登录后启动Wireshark
wireshark

# 捕获移动设备流量
# 1. 创建热点或使用同一网络
# 2. 选择对应网络接口
# 3. 设置过滤器：ip.addr == 设备IP

tcpdump使用：

# 在Android设备上使用tcpdump
adb shell su -c "tcpdump -i wlan0 -w /sdcard/capture.pcap"

# 拉取捕获文件
adb pull /sdcard/capture.pcap

# 分析捕获文件
wireshark capture.pcap

4.6 调试环境配置

4.6.1 GDB调试环境

GDB for Android配置：

# 下载Android NDK
wget https://dl.google.com/android/repository/android-ndk-r23c-linux.zip
unzip android-ndk-r23c-linux.zip
export NDK_HOME=~/android-ndk-r23c

# 配置GDB
export PATH=$PATH:$NDK_HOME/toolchains/llvm/prebuilt/linux-x86_64/bin

# 推送gdbserver到设备
adb push $NDK_HOME/prebuilt/android-arm64/gdbserver/gdbserver /data/local/tmp/
adb shell chmod 755 /data/local/tmp/gdbserver

# 启动gdbserver
adb shell su -c "/data/local/tmp/gdbserver :1234 --attach $(pidof target_process)"

# 端口转发
adb forward tcp:1234 tcp:1234

# 启动GDB客户端
aarch64-linux-android-gdb
(gdb) target remote :1234
(gdb) continue

4.6.2 LLDB调试环境

# 安装LLDB
sudo apt install lldb

# 配置LLDB for Android
# 下载LLDB服务端
adb push lldb-server /data/local/tmp/
adb shell chmod 755 /data/local/tmp/lldb-server

# 启动LLDB服务端
adb shell su -c "/data/local/tmp/lldb-server platform --listen '*:1234'"

# 连接LLDB
lldb
(lldb) platform select remote-android
(lldb) platform connect connect://device_ip:1234
(lldb) attach -p process_id

4.7 专用分析工具

4.7.1 Xposed框架

Xposed安装（需要Root）：

# 下载Xposed Installer
# 从官方网站下载对应版本的Xposed框架

# 安装Xposed Installer APK
adb install XposedInstaller.apk

# 刷入Xposed框架
# 通过Recovery模式刷入框架ZIP包
# 或使用Magisk模块安装

# 验证安装
# 打开Xposed Installer检查框架状态

Xposed模块开发环境：

// build.gradle (Module: app)
dependencies {
    compileOnly 'de.robv.android.xposed:api:82'
    compileOnly 'de.robv.android.xposed:api:82:sources'
}

// XposedModule.java
public class XposedModule implements IXposedHookLoadPackage {
    @Override
    public void handleLoadPackage(XC_LoadPackage.LoadPackageParam lpparam) throws Throwable {
        if (!lpparam.packageName.equals("com.example.target"))
            return;
        
        XposedHelpers.findAndHookMethod("com.example.target.MainActivity", 
            lpparam.classLoader, "onCreate", Bundle.class, new XC_MethodHook() {
            @Override
            protected void beforeHookedMethod(MethodHookParam param) throws Throwable {
                XposedBridge.log("MainActivity.onCreate called");
            }
        });
    }
}

4.7.2 专业逆向工具

IDA Pro配置：

# IDA Pro是商业软件，需要购买许可证
# 免费版本IDA Free可用于非商业用途

# 配置IDA Pro for Android
# 1. 安装IDA Pro
# 2. 配置Android调试器
# 3. 设置符号路径和源码路径

# IDA Python脚本示例
import idaapi
import idc

def analyze_functions():
    """分析所有函数"""
    for func_ea in Functions():
        func_name = idc.get_func_name(func_ea)
        func_size = idc.get_func_attr(func_ea, idc.FUNCATTR_END) - func_ea
        print(f"Function: {func_name}, Size: {func_size}")

if __name__ == "__main__":
    analyze_functions()

Binary Ninja配置：

# Binary Ninja Python API示例
import binaryninja as bn

def analyze_binary(file_path):
    """分析二进制文件"""
    bv = bn.open_view(file_path)
    
    # 获取函数列表
    functions = bv.functions
    print(f"Found {len(functions)} functions")
    
    # 分析每个函数
    for func in functions:
        print(f"Function: {func.name}")
        print(f"Address: 0x{func.start:x}")
        print(f"Size: {len(func)}")
        
        # 获取基本块
        for bb in func.basic_blocks:
            print(f"  Basic Block: 0x{bb.start:x} - 0x{bb.end:x}")
    
    return bv

# 使用示例
if __name__ == "__main__":
    bv = analyze_binary("target_binary")

4.8 环境优化与自动化

4.8.1 Docker容器化环境

Dockerfile示例：

FROM ubuntu:20.04

# 设置非交互模式
ENV DEBIAN_FRONTEND=noninteractive

# 安装基础工具
RUN apt-get update && apt-get install -y \
    wget curl unzip git vim \
    python3 python3-pip \
    openjdk-11-jdk \
    android-tools-adb \
    && rm -rf /var/lib/apt/lists/*

# 设置工作目录
WORKDIR /opt/android-reverse

# 安装Python依赖
COPY requirements.txt .
RUN pip3 install -r requirements.txt

# 下载和安装分析工具
RUN wget https://bitbucket.org/iBotPeaches/apktool/downloads/apktool_2.6.1.jar -O apktool.jar
RUN wget https://github.com/pxb1988/dex2jar/releases/download/2.1/dex-tools-2.1.zip && \
    unzip dex-tools-2.1.zip && \
    mv dex-tools-2.1 dex2jar

# 设置环境变量
ENV JAVA_HOME=/usr/lib/jvm/java-11-openjdk-amd64
ENV PATH=$PATH:$JAVA_HOME/bin:/opt/android-reverse

# 创建启动脚本
COPY start.sh .
RUN chmod +x start.sh

EXPOSE 8080 5555

CMD ["./start.sh"]

docker-compose.yml：

version: '3.8'

services:
  android-reverse:
    build: .
    ports:
      - "8080:8080"
      - "5555:5555"
    volumes:
      - ./workspace:/workspace
      - ./samples:/samples
    environment:
      - DISPLAY=${DISPLAY}
    network_mode: host
    privileged: true
    
  mobsf:
    image: opensecurity/mobsf:latest
    ports:
      - "8000:8000"
    volumes:
      - ./mobsf_data:/home/mobsf/.MobSF
    environment:
      - MOBSF_ANALYZER_IDENTIFIER=docker

4.8.2 自动化脚本

环境检查脚本：

#!/bin/bash
# check_environment.sh

echo "=== Android Reverse Engineering Environment Check ==="

# 检查Java
if command -v java &> /dev/null; then
    echo "✓ Java: $(java -version 2>&1 | head -n1)"
else
    echo "✗ Java not found"
fi

# 检查ADB
if command -v adb &> /dev/null; then
    echo "✓ ADB: $(adb version | head -n1)"
    
    # 检查设备连接
    devices=$(adb devices | grep -v "List of devices" | grep -v "^$" | wc -l)
    if [ $devices -gt 0 ]; then
        echo "✓ Connected devices: $devices"
        adb devices | grep -v "List of devices" | grep -v "^$"
    else
        echo "⚠ No devices connected"
    fi
else
    echo "✗ ADB not found"
fi

# 检查Python和依赖
if command -v python3 &> /dev/null; then
    echo "✓ Python: $(python3 --version)"
    
    # 检查关键Python包
    packages=("frida" "androguard" "requests")
    for package in "${packages[@]}"; do
        if python3 -c "import $package" 2>/dev/null; then
            echo "✓ Python package: $package"
        else
            echo "✗ Python package missing: $package"
        fi
    done
else
    echo "✗ Python3 not found"
fi

# 检查分析工具
tools=("apktool" "d2j-dex2jar" "r2" "frida-ps")
for tool in "${tools[@]}"; do
    if command -v $tool &> /dev/null; then
        echo "✓ Tool: $tool"
    else
        echo "✗ Tool missing: $tool"
    fi
done

echo "=== Environment Check Complete ==="

快速分析脚本：

#!/usr/bin/env python3
# quick_analysis.py

import os
import sys
import subprocess
import argparse
from pathlib import Path

class QuickAnalyzer:
    def __init__(self, apk_path):
        self.apk_path = Path(apk_path)
        self.output_dir = self.apk_path.parent / f"{self.apk_path.stem}_analysis"
        
    def run_analysis(self):
        """运行快速分析"""
        print(f"[+] Analyzing: {self.apk_path}")
        print(f"[+] Output directory: {self.output_dir}")
        
        # 创建输出目录
        self.output_dir.mkdir(exist_ok=True)
        
        # 1. APKTool反编译
        self.run_apktool()
        
        # 2. dex2jar转换
        self.run_dex2jar()
        
        # 3. 提取字符串
        self.extract_strings()
        
        # 4. 分析权限
        self.analyze_permissions()
        
        # 5. 生成报告
        self.generate_report()
        
    def run_apktool(self):
        """运行APKTool"""
        print("[+] Running APKTool...")
        cmd = ["apktool", "d", str(self.apk_path), "-o", str(self.output_dir / "apktool")]
        subprocess.run(cmd, capture_output=True)
        
    def run_dex2jar(self):
        """运行dex2jar"""
        print("[+] Running dex2jar...")
        jar_output = self.output_dir / f"{self.apk_path.stem}.jar"
        cmd = ["d2j-dex2jar", str(self.apk_path), "-o", str(jar_output)]
        subprocess.run(cmd, capture_output=True)
        
    def extract_strings(self):
        """提取字符串"""
        print("[+] Extracting strings...")
        strings_file = self.output_dir / "strings.txt"
        cmd = ["strings", str(self.apk_path)]
        result = subprocess.run(cmd, capture_output=True, text=True)
        
        with open(strings_file, 'w') as f:
            f.write(result.stdout)
            
    def analyze_permissions(self):
        """分析权限"""
        print("[+] Analyzing permissions...")
        try:
            from androguard.misc import AnalyzeAPK
            a, d, dx = AnalyzeAPK(str(self.apk_path))
            
            permissions = a.get_permissions()
            activities = a.get_activities()
            services = a.get_services()
            
            report = {
                'package': a.get_package(),
                'version': a.get_androidversion_name(),
                'permissions': permissions,
                'activities': activities,
                'services': services
            }
            
            import json
            with open(self.output_dir / "analysis.json", 'w') as f:
                json.dump(report, f, indent=2)
                
        except ImportError:
            print("[-] Androguard not available, skipping detailed analysis")
            
    def generate_report(self):
        """生成分析报告"""
        print("[+] Generating report...")
        report_file = self.output_dir / "report.md"
        
        with open(report_file, 'w') as f:
            f.write(f"# Analysis Report for {self.apk_path.name}\n\n")
            f.write(f"## File Information\n")
            f.write(f"- File: {self.apk_path.name}\n")
            f.write(f"- Size: {self.apk_path.stat().st_size} bytes\n")
            f.write(f"- Analysis Date: {subprocess.run(['date'], capture_output=True, text=True).stdout.strip()}\n\n")
            
            # 添加其他分析结果
            if (self.output_dir / "analysis.json").exists():
                f.write("## Detailed Analysis\n")
                f.write("See analysis.json for detailed results.\n\n")
            
            f.write("## Files Generated\n")
            for file in self.output_dir.iterdir():
                if file.is_file():
                    f.write(f"- {file.name}\n")
        
        print(f"[+] Analysis complete! Results saved to: {self.output_dir}")

def main():
    parser = argparse.ArgumentParser(description="Quick APK Analysis Tool")
    parser.add_argument("apk", help="Path to APK file")
    args = parser.parse_args()
    
    if not Path(args.apk).exists():
        print(f"Error: APK file not found: {args.apk}")
        sys.exit(1)
    
    analyzer = QuickAnalyzer(args.apk)
    analyzer.run_analysis()

if __name__ == "__main__":
    main()

4.9 常见问题与解决方案

4.9.1 环境配置问题

Q1：ADB无法连接设备

解决方案：

# 检查USB调试是否开启
adb devices

# 如果显示unauthorized，需要在设备上确认
# 重启ADB服务
adb kill-server
adb start-server

# 检查USB驱动（Windows）
# 安装对应厂商的USB驱动

# 检查udev规则（Linux）
sudo vim /etc/udev/rules.d/51-android.rules
# 添加设备规则，例如：
# SUBSYSTEM=="usb", ATTR{idVendor}=="18d1", MODE="0666", GROUP="plugdev"
sudo udevadm control --reload-rules

Q2：Frida连接失败

解决方案：

# 检查Frida版本匹配
frida --version
adb shell /data/local/tmp/frida-server --version

# 确保版本一致，重新下载对应版本
# 检查SELinux状态
adb shell getenforce

# 如果是Enforcing，尝试设置为Permissive
adb shell su -c "setenforce 0"

# 检查端口转发
adb forward --list
adb forward tcp:27042 tcp:27042

Q3：模拟器性能问题

解决方案：

# 启用硬件加速
emulator -avd Android31_x64 -gpu host

# 增加内存分配
emulator -avd Android31_x64 -memory 4096

# 使用x86镜像而非ARM镜像
# 在AVD Manager中选择x86或x86_64系统镜像

# 启用KVM加速（Linux）
sudo apt install qemu-kvm
sudo usermod -a -G kvm $USER

4.9.2 工具使用问题

Q4：APKTool反编译失败

解决方案：

# 更新APKTool到最新版本
wget https://raw.githubusercontent.com/iBotPeaches/Apktool/master/scripts/linux/apktool
wget https://bitbucket.org/iBotPeaches/apktool/downloads/apktool_2.6.1.jar

# 使用--no-res参数跳过资源解析
apktool d app.apk --no-res

# 安装framework文件
apktool if framework-res.apk

Q5：证书安装问题

解决方案：

# Android 7.0+需要将证书安装为系统证书
# 1. 获取证书hash
openssl x509 -inform PEM -subject_hash_old -in cert.pem | head -1

# 2. 重命名证书文件
cp cert.pem <hash>.0

# 3. 推送到系统证书目录
adb root
adb remount
adb push <hash>.0 /system/etc/security/cacerts/
adb shell chmod 644 /system/etc/security/cacerts/<hash>.0
adb reboot

4.10 本章小结

本章详细介绍了安卓逆向分析环境的搭建：

1. 基础环境配置：Java、Android SDK、Python环境
2. 静态分析工具：APKTool、dex2jar、JD-GUI、Radare2、Ghidra
3. 动态分析环境：Android模拟器、物理设备、Frida框架
4. 网络分析环境：Burp Suite、mitmproxy、Wireshark
5. 调试环境配置：GDB、LLDB调试器
6. 专用分析工具：Xposed框架、IDA Pro、Binary Ninja
7. 环境优化：Docker容器化、自动化脚本

完整的环境搭建为后续的逆向分析工作提供了强有力的工具支持。合理配置和使用这些工具，能够大大提高逆向分析的效率和准确性。

学习检查清单：

• 成功配置Java和Android SDK环境
• 安装并测试静态分析工具
• 配置Android模拟器或物理设备
• 成功部署Frida动态分析环境
• 配置网络代理和抓包工具
• 测试调试环境的可用性
• 了解专业逆向工具的基本使用
• 掌握环境问题的常见解决方案

下一章预告：
在下一章中，我们将深入学习APK文件的结构分析和解包技术，这是进行安卓逆向分析的第一步，也是理解安卓应用内部结构的关键。