Android 应用签名与安全加固完整指南

作为 Android 开发者，我们常常关注功能开发而忽视安全性。2026 年的移动安全环境比以往任何时候都更复杂——黑灰产已经形成完整的 App 破解、二次打包、恶意篡改产业链。本文将系统梳理 Android 应用从签名到运行时防护的完整加固方案。

1. 应用签名机制

应用签名是 Android 安全的基础。每次 APK/AAB 安装时，系统都会校验签名，确保应用未被篡改。

签名方案演进

最佳实践：使用 Play App Signing

Google Play App Signing 是目前推荐的方式，它将应用签名密钥托管在 Google 的 HSM 中，保护程度远高于本地存储：

• 应用签名密钥：Google 保管，用于最终签名的密钥
• 上传密钥：你自己保管，用于上传 AAB 到 Play Console 的密钥

配置 build.gradle

android {
    signingConfigs {
        release {
            // 使用环境变量或密钥管理服务注入，永远不要硬编码
            storeFile file(System.getenv("ANDROID_KEYSTORE_PATH"))
            storePassword System.getenv("ANDROID_STORE_PASSWORD")
            keyAlias System.getenv("ANDROID_KEY_ALIAS")
            keyPassword System.getenv("ANDROID_KEY_PASSWORD")
            
            // 启用 v2 和 v3 签名
            enableV2Signing true
            enableV3Signing true
        }
    }
    
    buildTypes {
        release {
            signingConfig signingConfigs.release
            isMinifyEnabled true
            isShrinkResources true
            proguardFiles(
                getDefaultProguardFile("proguard-android-optimize.txt"),
                "proguard-rules.pro"
            )
        }
    }
}

2. 代码混淆与资源压缩

R8（Android 默认的混淆工具）不仅缩小 APK 体积，还通过重命名类、方法和字段名来增加逆向难度。

R8 配置要点

# proguard-rules.pro 关键配置

# 保留实体类（序列化/反序列化需要）
-keep class com.yourpackage.data.** {
    *;
}

# 保留枚举（R8 优化可能导致枚举行为异常）
-keep enum com.yourpackage.** { *; }

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

# 保留反射调用的方法
-keepclassmembers class * {
    @com.google.gson.annotations.SerializedName <fields>;
}

# 禁止日志输出（发布版本）
-assumenosideeffects class android.util.Log {
    public static boolean isLoggable(java.lang.String, int);
    public static int v(...);
    public static int d(...);
    public static int i(...);
}

混淆映射文件

每次构建保留混淆映射文件，用于崩溃堆栈反混淆：

# 映射文件默认位于：
# app/build/outputs/mapping/release/mapping.txt

# 反混淆堆栈
retrace.sh -verbose mapping.txt obfuscated_stacktrace.txt

3. 完整性校验

完整性校验用于检测 APK 是否被二次打包或运行时篡改。

方法一：签名验证

fun verifyApkSignature(context: Context, expectedHash: String): Boolean {
    try {
        val packageInfo = context.packageManager.getPackageInfo(
            context.packageName,
            PackageManager.GET_SIGNATURES
        )
        val signature = packageInfo.signatures[0]
        val digest = MessageDigest.getInstance("SHA-256")
        val currentHash = bytesToHex(digest.digest(signature.toByteArray()))
        
        return currentHash.uppercase() == expectedHash.uppercase()
    } catch (e: Exception) {
        return false
    }
}

方法二：Play Integrity API（推荐）

Play Integrity API 是 Google 官方推荐的完整性校验方案，它不仅验证 APK 签名，还检查设备环境和 Google Play 服务状态：

class IntegrityVerifier(private val context: Context) {
    
    private val integrityManager by lazy {
        IntegrityManagerFactory.create(context)
    }
    
    suspend fun verifyIntegrity(): IntegrityResult {
        return suspendCancellableCoroutine { cont ->
            val request = IntegrityTokenRequest.builder()
                .setCloudProjectNumber(CLOUD_PROJECT_NUMBER)
                .build()
            
            integrityManager.requestIntegrityToken(request)
                .addOnSuccessListener { response ->
                    cont.resume(parseToken(response.token()))
                }
                .addOnFailureListener { e ->
                    cont.resume(IntegrityResult.Error(e.message ?: "Unknown"))
                }
        }
    }
    
    private fun parseToken(token: String): IntegrityResult {
        // 在服务端解析 token 验证完整性
        // 关键检查项：
        // - deviceIntegrity: MEETS_DEVICE_INTEGRITY
        // - appRecognitionVerdict: PLAY_RECOGNIZED
        // - accountDetails: appLicensedVertex
        return IntegrityResult.Passed
    }
}

sealed class IntegrityResult {
    object Passed : IntegrityResult()
    data class Error(val message: String) : IntegrityResult()
}

4. 运行时防护

Root 检测

object RootDetector {
    
    fun isDeviceRooted(): Boolean {
        return checkBuildTags() || 
               checkSU() || 
               checkRootApps() || 
               checkTestKeys()
    }
    
    private fun checkBuildTags(): Boolean {
        val buildTags = Build.TAGS
        return buildTags != null && buildTags.contains("test-keys")
    }
    
    private fun checkSU(): Boolean {
        val paths = listOf(
            "/system/bin/su",
            "/system/xbin/su",
            "/system/app/Superuser.apk",
            "/sbin/su",
            "/data/local/xbin/su",
            "/data/local/bin/su"
        )
        return paths.any { File(it).exists() }
    }
    
    private fun checkRootApps(): Boolean {
        val rootPackages = listOf(
            "com.noshufou.android.su",
            "com.thirdparty.superuser",
            "eu.chainfire.supersu",
            "com.topjohnwu.magisk"
        )
        return rootPackages.any { isPackageInstalled(it) }
    }
}

模拟器检测

object EmulatorDetector {
    
    fun isEmulator(): Boolean {
        return checkBuildProps() || 
               checkHardware() || 
               checkNetworkOperator()
    }
    
    private fun checkBuildProps(): Boolean {
        return Build.FINGERPRINT.startsWith("google/sdk_gphone") ||
               Build.FINGERPRINT.contains("generic") ||
               Build.PRODUCT.contains("sdk") ||
               Build.HARDWARE.contains("goldfish") ||
               Build.MODEL.contains("Android SDK built for x86")
    }
    
    private fun checkHardware(): Boolean {
        return (Build.BRAND.startsWith("generic") && 
                Build.DEVICE.startsWith("generic")) ||
               Build.PRODUCT == "google_sdk" ||
               Build.HARDWARE == "ranchu"
    }
    
    private fun checkNetworkOperator(): Boolean {
        val operator = if (Build.VERSION.SDK_INT >= 26) {
            // 模拟器网络运营商为空或 "android"
            val tm = context.getSystemService(Context.TELEPHONY_SERVICE)
            tm?.networkOperatorName ?: ""
        } else ""
        return operator.isEmpty() || operator == "Android"
    }
}

防调试

class AntiDebug {
    
    fun detectDebugger() {
        // 方法 1: 检查调试器附加
        if (Debug.isDebuggerConnected()) {
            exitProcess(1)
        }
        
        // 方法 2: 检查 trace
        if (Debug.waitingForDebugger()) {
            exitProcess(1)
        }
        
        // 方法 3: Timer 检查（反动态调试）
        Thread {
            while (true) {
                if (Debug.isDebuggerConnected()) {
                    exitProcess(1)
                }
                Thread.sleep(1000)
            }
        }.apply { isDaemon = true }.start()
    }
}

5. 网络通信安全

证书锁定

// OkHttp 证书锁定配置
val client = OkHttpClient.Builder()
    .certificatePinner(
        CertificatePinner.Builder()
            .add("api.yourdomain.com", 
                 "sha256/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=")
            .build()
    )
    .build()

6. 安全加固清单

按优先级整理的完整加固清单：

7. Google Play Protect 集成

Android 16 增强的 Play Protect 提供了新的开发者 API，可以直接在应用内展示安全检查结果：

val safetyCenter = SafetyCenter(this)
safetyCenter.showSafetyCheckResult {
    // 展示安全评分和修复建议
}

这是 Google 在 Android 16 中推进的「安全透明化」策略的一部分。用户可以随时在设置中查看应用的安全状态。

总结

Android 应用安全加固不是一次性工作，而是持续的过程。我建议按照以下节奏推进：

• 第 1 周：完成 P0 全部措施（签名、混淆、Integrity API）
• 第 2 周：实现 P1 措施（HTTPS、运行时检测）
• 第 3-4 周：评估 P2 措施的必要性，按需实现

记住安全的基本原则：没有绝对的安全，只有足够的安全。目标不是让应用无法破解（这是不可能的），而是让破解成本 > 应用价值，从而劝退 99% 的破解者。