Day-321-移动应用加固技术

# Day 338: 移动应用加固技术 - 代码混淆/防篡改/反调试/环境检测

> 移动安全系列第 18 天 | 预计阅读时间：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();
}
```

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

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

# 反射保护
-keepattributes Signature
-keepattributes *Annotation*
```

### R8 混淆

**R8 配置**：
```groovy
// build.gradle
android {
    buildTypes {
        release {
            minifyEnabled true
            shrinkResources true
            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
        }
    }
}
```

**混淆效果**：
```
类名混淆:
- MainActivity → a
- LoginActivity → b
- UserService → c

方法名混淆:
- login() → a()
- logout() → b()
- getUser() → c()

字段名混淆:
- username → a
- password → b
- token → c
```

---

## 防篡改技术

### 签名验证

**运行时验证**：
```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 "";
        }
    }
}
```

### 完整性校验

**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;
        }
    }
}
```

**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 {
    
    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"
        };
        
        for (String pkg : packages) {
            try {
                PackageManager pm = context.getPackageManager();
                pm.getPackageInfo(pkg, 0);
                return true;
            } catch (Exception e) {
            }
        }
        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;
    }
}
```

---

## 加固方案

### 商业加固

**腾讯乐固**：
```
功能:
- DEX 加密
- SO 加密
- 资源加密
- 防篡改

优势:
- 免费基础版
- 兼容性好
- 更新及时

使用:
- 上传 APK
- 选择加固方案
- 下载加固包
```

**360 加固**：
```
功能:
- 多重加密
- 防篡改
- 渠道打包
- 漏洞扫描

优势:
- 免费使用
- 功能全面
- 技术支持

使用:
- 注册账号
- 上传应用
- 配置加固
- 下载加固包
```

### 自研加固

**加固流程**：
```
1. DEX 加密
   - DEX 文件加密
   - 动态加载
   - 内存执行

2. SO 加密
   - SO 文件加密
   - 动态解密
   - 内存加载

3. 资源加密
   - 资源文件加密
   - 运行时解密
   - 缓存管理

4. 保护代码
   - 注入保护代码
   - 完整性校验
   - 反调试检测
```

---

## 总结与思考

### 核心要点回顾

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

### 深入思考

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

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

### 最佳实践

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

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

---

## 参考资料

### 学习资源

- **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 338 完成 | 移动应用加固技术详解 | 字数：约 15,000 字*