Day-313-Android 应用加固

# Day 330: Android 应用加固 - 代码混淆/防篡改/反调试/环境检测

> 移动安全系列第 10 天 | 预计阅读时间：40 分钟 | 难度：★★★★☆

---

## 清单 目录

1. [加固技术概述](#加固技术概述)
2. [代码混淆](#代码混淆)
3. [防篡改技术](#防篡改技术)
4. [反调试技术](#反调试技术)
5. [环境检测](#环境检测)
6. [实战配置](#实战配置)
7. [总结与思考](#总结与思考)
8. [参考资料](#参考资料)

---

## 加固技术概述

### 加固目标

**保护内容**：
```
代码保护:
- 业务逻辑
- 核心算法
- 敏感数据

数据保护:
- API 密钥
- 加密密钥
- 用户数据

完整性保护:
- 防篡改
- 防重打包
- 防二次打包
```

**防护等级**：
```
基础防护:
- 代码混淆
- 签名验证
- 基础检测

中级防护:
- 加固保护
- 反调试
- 环境检测

高级防护:
- 白盒加密
- 硬件绑定
- 持续监控
```

---

## 代码混淆

### ProGuard 混淆

**基础配置**：
```proguard
# proguard-rules.pro

# 启用混淆
-optimizations

# 保留应用入口
-keep public class * extends android.app.Activity
-keep public class * extends android.app.Application
-keep public class * extends android.app.Service

# 保留 JNI 方法
-keepclasseswithmembernames class * {
    native <methods>;
}

# 保留序列化
-keepclassmembers class * implements java.io.Serializable {
    static final long serialVersionUID;
    private static final java.io.ObjectStreamField[] serialPersistentFields;
    private void writeObject(java.io.ObjectOutputStream);
    private void readObject(java.io.ObjectInputStream);
    java.lang.Object writeReplace();
    java.lang.Object readResolve();
}

# 混淆策略
-obfuscationdictionary obfuscation_dictionary.txt
-classobfuscationdictionary obfuscation_dictionary.txt
-packageobfuscationdictionary obfuscation_dictionary.txt
```

**字典配置**：
```
# obfuscation_dictionary.txt
a
b
c
...
z
aa
ab
...
```

### R8 混淆

**R8 配置**：
```proguard
# 启用 R8
android.enableR8=true
android.enableR8.fullMode=true

# R8 规则
-keep class com.example.KeepClass { *; }
-keepclassmembers class com.example.KeepClass {
    public <methods>;
}

# 移除未使用代码
-shrinkresources
-minifyenabled true
```

**高级混淆**：
```proguard
# 控制流混淆
-assumenosideeffects class android.util.Log {
    public static *** d(...);
    public static *** v(...);
}

# 字符串加密
-keepclassmembers class * {
    @com.example.Encrypt <fields>;
}
```

---

## 防篡改技术

### 签名验证

**运行时验证**：
```java
public class SignatureVerifier {
    
    public static boolean verifySignature(Context context) {
        try {
            // 获取应用签名
            PackageInfo info = context.getPackageManager()
                .getPackageInfo(context.getPackageName(),
                    PackageManager.GET_SIGNATURES);
            
            Signature signature = info.signatures[0];
            String currentSig = hashSignature(signature);
            
            // 与预期签名对比
            String expectedSig = "EXPECTED_SIGNATURE_HASH";
            
            return currentSig.equals(expectedSig);
        } catch (Exception e) {
            return false;
        }
    }
    
    private static String hashSignature(Signature signature) {
        try {
            MessageDigest md = MessageDigest.getInstance("SHA-256");
            md.update(signature.toByteArray());
            return bytesToHex(md.digest());
        } catch (Exception e) {
            return "";
        }
    }
    
    private static String bytesToHex(byte[] bytes) {
        StringBuilder sb = new StringBuilder();
        for (byte b : bytes) {
            sb.append(String.format("%02x", b));
        }
        return sb.toString();
    }
}
```

### 完整性校验

**DEX 校验**：
```java
public class DexIntegrityChecker {
    
    public static boolean checkDexIntegrity(Context context) {
        try {
            ApplicationInfo info = context.getApplicationInfo();
            String sourceDir = info.sourceDir;
            
            // 计算 DEX 文件哈希
            String currentHash = calculateHash(sourceDir);
            
            // 与预期哈希对比
            String expectedHash = getExpectedHash();
            
            return currentHash.equals(expectedHash);
        } catch (Exception e) {
            return false;
        }
    }
    
    private static String calculateHash(String filePath) {
        // 计算文件哈希
        // 实现略
    }
}
```

**SO 库校验**：
```java
public class SoLibraryChecker {
    
    static {
        // 加载前校验
        if (!verifySoLibrary("libnative.so")) {
            throw new SecurityException("SO library verification failed");
        }
        System.loadLibrary("native");
    }
    
    private static native boolean verifySoLibrary(String name);
}
```

---

## 反调试技术

### 调试检测

**基础检测**：
```java
public class DebugDetector {
    
    // 检查 isDebuggerConnected
    public static boolean isDebugged() {
        return Debug.isDebuggerConnected();
    }
    
    // 检查调试端口
    public static boolean checkDebugPort() {
        try {
            BufferedReader reader = new BufferedReader(
                new FileReader("/proc/net/tcp")
            );
            String line;
            while ((line = reader.readLine()) != null) {
                // 检查调试端口 (0x1db8 = 8631)
                if (line.contains(":1DB8") || line.contains(":1DB9")) {
                    return true;
                }
            }
        } catch (Exception e) {
        }
        return false;
    }
    
    // 检查进程状态
    public static boolean checkProcessStatus() {
        try {
            BufferedReader reader = new BufferedReader(
                new FileReader("/proc/self/status")
            );
            String line;
            while ((line = reader.readLine()) != null) {
                if (line.startsWith("TracerPid:")) {
                    int pid = Integer.parseInt(line.split(":")[1].trim());
                    return pid != 0;
                }
            }
        } catch (Exception e) {
        }
        return false;
    }
}
```

### 反 Hook 检测

**Frida 检测**：
```java
public class FridaDetector {
    
    // 检查 Frida 特征
    public static boolean detectFrida() {
        // 检查端口
        if (checkFridaPort()) {
            return true;
        }
        
        // 检查文件
        if (checkFridaFiles()) {
            return true;
        }
        
        // 检查进程映射
        if (checkProcessMaps()) {
            return true;
        }
        
        return false;
    }
    
    private static boolean checkFridaPort() {
        // 检查 27042 端口
        // 实现略
        return false;
    }
    
    private static boolean checkFridaFiles() {
        // 检查 /data/local/tmp/re.frida.server
        // 实现略
        return false;
    }
    
    private static boolean checkProcessMaps() {
        // 检查 frida-agent.so
        // 实现略
        return false;
    }
}
```

**Xposed 检测**：
```java
public class XposedDetector {
    
    public static boolean isXposed() {
        // 检查堆栈
        StackTraceElement[] stack = Thread.currentThread().getStackTrace();
        for (StackTraceElement element : stack) {
            if (element.getClassName().contains("de.robv.android.xposed")) {
                return true;
            }
        }
        
        // 检查类存在
        try {
            Class.forName("de.robv.android.xposed.XposedBridge");
            return true;
        } catch (ClassNotFoundException e) {
        }
        
        return false;
    }
}
```

---

## 环境检测

### Root 检测

**Root 检测方法**：
```java
public class RootDetector {
    
    public static boolean isRooted() {
        // 检查 su 二进制
        if (checkSuBinary()) {
            return true;
        }
        
        // 检查 Root 管理应用
        if (checkRootApps()) {
            return true;
        }
        
        // 检查危险属性
        if (checkBuildProperties()) {
            return true;
        }
        
        // 检查 Magisk
        if (checkMagisk()) {
            return true;
        }
        
        return false;
    }
    
    private static boolean checkSuBinary() {
        String[] paths = {
            "/system/bin/su",
            "/system/xbin/su",
            "/sbin/su",
            "/su/bin/su"
        };
        
        for (String path : paths) {
            File file = new File(path);
            if (file.exists() && file.canExecute()) {
                return true;
            }
        }
        return false;
    }
    
    private static boolean checkRootApps() {
        String[] packages = {
            "com.noshufou.android.su",
            "com.thirdparty.superuser",
            "eu.chainfire.supersu",
            "com.kingroot.kinguser",
            "com.kingroot.master"
        };
        
        for (String pkg : packages) {
            try {
                PackageManager pm = MainApp.getContext().getPackageManager();
                pm.getPackageInfo(pkg, 0);
                return true;
            } catch (Exception e) {
            }
        }
        return false;
    }
    
    private static boolean checkBuildProperties() {
        String tags = Build.TAGS;
        return tags != null && tags.contains("test-keys");
    }
    
    private static boolean checkMagisk() {
        // 检查 Magisk 特征
        // 实现略
        return false;
    }
}
```

### 模拟器检测

**模拟器特征**：
```java
public class EmulatorDetector {
    
    public static boolean isEmulator() {
        // 检查硬件特征
        if (checkHardware()) {
            return true;
        }
        
        // 检查系统属性
        if (checkSystemProperties()) {
            return true;
        }
        
        // 检查传感器
        if (checkSensors()) {
            return true;
        }
        
        return false;
    }
    
    private static boolean checkHardware() {
        // 检查硬件信息
        String hardware = Build.HARDWARE;
        String model = Build.MODEL;
        String product = Build.PRODUCT;
        
        return hardware.equals("goldfish") ||
               hardware.equals("vbox86") ||
               model.contains("Emulator") ||
               product.contains("sdk");
    }
    
    private static boolean checkSystemProperties() {
        // 检查系统属性
        String[] properties = {
            "ro.kernel.qemu",
            "ro.boot.qemu",
            "ro.hardware.qemu"
        };
        
        for (String prop : properties) {
            String value = getSystemProperty(prop);
            if ("1".equals(value)) {
                return true;
            }
        }
        return false;
    }
    
    private static boolean checkSensors() {
        // 检查传感器数量
        SensorManager sensorManager = 
            (SensorManager) MainApp.getContext().getSystemService(SENSOR_SERVICE);
        List<Sensor> sensors = sensorManager.getSensorList(Sensor.TYPE_ALL);
        
        // 模拟器通常传感器较少
        return sensors.size() < 5;
    }
    
    private static String getSystemProperty(String key) {
        try {
            Class<?> clazz = Class.forName("android.os.SystemProperties");
            Method method = clazz.getMethod("get", String.class);
            return (String) method.invoke(clazz, key);
        } catch (Exception e) {
            return "";
        }
    }
}
```

---

## 实战配置

### 加固方案选择

**商业加固**：
```
腾讯乐固:
- 免费基础版
- DEX 加密
- SO 加密
- 资源加密

360 加固:
- 免费使用
- 多重加密
- 防篡改
- 渠道打包

梆梆安全:
- 企业版
- 高级保护
- 安全监测
- 合规服务
```

**自研加固**：
```
优点:
- 可控性强
- 定制灵活
- 成本可控

缺点:
- 开发成本高
- 维护成本高
- 安全性待验证
```

### 加固配置

**Gradle 配置**：
```groovy
// build.gradle

android {
    buildTypes {
        release {
            // 启用混淆
            minifyEnabled true
            shrinkResources true
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
            
            // 签名配置
            signingConfig signingConfigs.release
        }
    }
    
    // 签名配置
    signingConfigs {
        release {
            storeFile file('keystore/release.keystore')
            storePassword 'store_password'
            keyAlias 'key_alias'
            keyPassword 'key_password'
        }
    }
}

// 加固任务
task protectApp(type: Exec) {
    commandLine 'java', '-jar', 'protect.jar', 
                '-input', 'build/outputs/apk/release/app.apk',
                '-output', 'build/outputs/apk/protected/app-protected.apk'
}
```

---

## 总结与思考

### 核心要点回顾

1. **代码混淆**：ProGuard、R8、混淆策略
2. **防篡改**：签名验证、完整性校验
3. **反调试**：调试检测、反 Hook 检测
4. **环境检测**：Root 检测、模拟器检测
5. **实战配置**：加固方案、Gradle 配置

### 深入思考

**安全平衡**：
- 安全与性能
- 安全与体验
- 安全与成本

**持续对抗**：
- 加固与脱壳
- 检测与绕过
- 攻防升级

### 最佳实践

**分层防护**：
- 基础混淆
- 加固保护
- 运行时检测
- 持续监控

**深度防御**：
- 多层检测
- 交叉验证
- 隐蔽检测
- 动态更新

---

## 参考资料

### 学习资源

- **Android Security**: https://source.android.com/security
- **ProGuard**: https://www.guardsquare.com/proguard
- **OWASP Mobile Security**: https://owasp.org/www-project-mobile-security/

### 工具资源

- **ProGuard**: https://www.guardsquare.com/proguard
- **腾讯乐固**: https://lg.qq.com
- **360 加固**: https://jiagu.360.cn

---

*Day 330 完成 | Android 应用加固详解 | 字数：约 15,000 字 (拆分版)*

*Android 安全系列 5 篇完整教程完结！完成*