发版那天下午四点,我照例打开加固平台的上传页,准备把刚打出来的 release 包丢上去。页面没给我上传框,先弹了个套餐选择。翻到公告才看明白:2026 年 6 月 30 日 18:00 起,免费加固正式终止,第二天起全部转付费订阅。
以前这活儿就是「上传、等几分钟、下载、重签名」,连想都不用想。现在变成先问一句「这个月还剩几次额度」,再问一句「这笔钱走哪个预算」。一个做医疗健康类 App 的团队,发版节奏被合规整改牵着走,一个月打七八个包是常事,加固突然就成了要报审批的事。
不是没预兆,是我没当回事。往前翻,2025 年 7 月 1 日就调过一次免费额度:未认证账号 1 次/天、累计 2 次/月,个人认证 2 次/天、5 次/月,企业认证 3 次/天、10 次/月。当时我还在群里跟同事说「够用,谁一个月发十次版」。到 2026 年 4 月 7 日又加了一条更狠的:同一个应用包名,全平台所有免费账号加起来每月最多加固 10 次,额度用完就得等下月,跟账号自身的等级额度独立计算。我们那个月正好赶上一轮合规整改连着发了几个包,最后一个包名额度见底,我借了同事的账号才把包送上去。那时候就该反应过来,这服务是要收摊了。
腾讯乐固那边早就不太对个人和小团队开放免费版了,爱加密、梆梆这类走 VMP 的本来就是企业报价。于是流程变成这样:合规的同学问「加固做了吗」,我答「做了」;他再问一句「哪一条法规要求加固」,我卡住了。回头去翻原文,才发现这个问法本身就是错的。
这篇文章写的是我后来怎么把这件事重新捋了一遍:加固到底在防什么,壳是怎么把 dex 藏起来又怎么被扒出来的,为什么我最后没自己写壳,以及怎么用 Trae 把一线开发真正能落地的那部分做成一条能跑、能验、能留证据的流水线。所有提示词都是我实际跑过的,整段可以直接复制。
先把一件事说清楚:网信办没写过「必须加固」这四个字
我一开始以为「网信办要求加固」是某条硬规定,找了半天没找到。现行的是 2022 年 6 月 14 日发布、8 月 1 日施行的《移动互联网应用程序信息服务管理规定》,共 27 条,通篇没有「加固」「加壳」「混淆」这些词。跟客户端真正沾边的是这么几条:
| 条款 | 原文要点 | 落到代码上是什么 |
|---|---|---|
| 第五条 | 建立健全信息内容安全管理、数据安全和个人信息保护等管理制度,确保网络安全 | 制度文件 + 技术措施的实施记录 |
| 第十条 | 应用程序应当符合相关国家标准的强制性要求;发现安全缺陷、漏洞等风险时,应立即采取补救措施,及时告知用户并向有关主管部门报告 | 漏洞响应流程、修复留痕、版本可追溯 |
| 第十一条 | 开展数据处理活动应履行数据安全保护义务,建立全流程数据安全管理制度,采取保障数据安全技术措施和其他安全措施,加强风险监测 | 存储加密、传输加密、完整性校验、运行时风险识别 |
| 第十二条 | 处理个人信息遵循合法、正当、必要、诚信原则,公开处理规则,遵守必要个人信息范围,采取必要措施保障个人信息安全,不得因用户不同意非必要信息而拒绝基本功能 | 权限最小化、告知同意、SDK 清单、隐私政策一致性 |
| 第十四条 | 上线具有舆论属性或社会动员能力的新技术、新应用、新功能,应按规定进行安全评估 | 安全评估材料 |
| 第二十条 | 分发平台应对申请上架和更新的应用进行审核,对存在数据安全风险隐患、违法违规收集使用个人信息等的,不得提供服务 | 上架/更新时的检测与整改闭环 |
再往下是国标和规范性文件,这几个编号我后来贴在了项目 README 里,检查的时候会被直接问到:GB/T 35273-2020《信息安全技术 个人信息安全规范》、GB/T 41391-2022《信息安全技术 移动互联网应用程序(App)收集个人信息基本要求》、国信办秘字〔2021〕14 号《常见类型移动互联网应用程序必要个人信息范围规定》、国信办秘字〔2019〕191 号《App违法违规收集使用个人信息行为认定方法》,以及 TC260-PG-20202A 那份自评估指南。
191 号文里列得很具体,比如「征得用户同意前就开始收集个人信息或打开可收集个人信息的权限」「申请打开可收集个人信息的权限时未同步告知其目的」「因用户不同意非必要信息拒绝提供业务功能」「收集频度超出业务功能实际需要」——这些才是检测时真正一条条抠的东西,跟 dex 有没有加壳毫无关系。
所以我把定位改了。自建加固不是去替代第三方检测报告,也不是拿它当"合规通过"的凭证。真正卡上架的是隐私合规检测和等保测评这两份由有资质机构出具的报告,自己写的自查文档不具备那个效力;这部分该找机构还是得找机构,该做的整改一项都省不掉。自建加固能做的,是把第十一条那句「采取保障数据安全技术措施」和第十条那句「发现漏洞立即补救」,变成代码里跑得起来、构建里验得出来、检查时拿得出留痕的东西。
这个区分不是抠字眼。我见过把整包交给加固厂商、结果壳自己带了一堆设备信息采集和权限申请,隐私检测报告直接多出三条违规项的案例。加固反倒成了新的违规源,就是没想明白自己到底在满足哪一条。
后面所有设计都围绕一张表展开,这也是我给 Trae 的第一份输入:
| 监管关心的 | 客户端技术动作 | 能交出去的证据 |
|---|---|---|
| 符合国标强制性要求 | release 构建配置、导出组件显式声明、明文流量关闭、备份范围收敛 | 构建配置快照 + 逐项自检结果 |
| 保障数据安全的技术措施 | R8 全量混淆、敏感数据加密存储、证书绑定、签名与完整性校验 | mapping 归档、规则 diff、校验代码与测试记录 |
| 加强风险监测 | 运行时防调试/防注入信号只记录上报,不拦截用户、不采集设备标识 | 信号定义表 + 上报样本 + 处置流程 |
| 发现漏洞立即补救 | 每次发版生成前后差异、漏洞修复与版本绑定 | 版本变更记录、证据包差异 |
| 不因加固引入新违规 | 加固后权限与 SDK 清单基线比对 | 权限 diff、SDK 清单、隐私政策版本对应表 |
一句话,我要的是可审计,不是「看起来很安全」。
加固到底在加固什么:从 APK 被拆开那一刻讲起
想明白该做什么,得先知道对手拿到的是什么。
一个未加固的 release 包,解出来大概是这样:
app-release.apk
├── AndroidManifest.xml # 二进制 AXML,apktool 一把就能还原
├── classes.dex / classes2.dex # Java/Kotlin 字节码
├── lib/arm64-v8a/*.so # native 库
├── res/ # 编译后的资源
├── resources.arsc
├── assets/ # 原样打包,包括各种 json、证书、配置
├── META-INF/ # v1 签名相关
└── [APK Signing Block] # v2/v3 签名在这,位于中央目录之前
jadx-gui 拖进去,包名、类名、方法名、接口路径、硬编码的密钥、服务端地址,基本是明文。R8 开了混淆也只是把 UserRepositoryImpl 变成 a.b.c,反编译的人顺着调用链一样能读。真正的风险不在「被看见」,在「被改」:改掉一段鉴权判断、插一段采集代码、重签名,再挂到渠道上分发,用户装到的就不是我们发的包了。合规视角里最怕的也是这个——承载真实业务流量的客户端被替换,前面做的所有个人信息保护措施全白搭。
ART 是怎么把 dex 装进来的
Android 启动一个应用,系统给的是 PathClassLoader,链路大致是:
PathClassLoader
└─ BaseDexClassLoader
└─ DexPathList
└─ Element[] → DexFile
└─ defineClass / defineClassNative
DexPathList 里维护一个 dexElements 数组,找类时按数组顺序遍历 DexFile。双亲委派保证系统类优先,应用类在这个数组里被找到。这个结构是所有 dex 加固的着力点:只要能在系统去找真实业务类之前,把装着真实 dex 的 DexFile 塞进这个数组,或者干脆把 LoadedApk 里的 ClassLoader 换成自己的,壳就成立了。
壳的完整启动时序是这样的:
sequenceDiagram
participant Z as Zygote / system_server
participant Shell as 壳 Application
participant Dec as 解密与加载器
participant ART as ART / LoadedApk
participant Real as 真实 Application
Z->>Shell: 从 Manifest 找到壳的 Application 并实例化
Shell->>Shell: attachBaseContext()
Shell->>Dec: 从 assets / APK 尾部读出加密的真实 dex
Dec->>Dec: 解密、校验完整性
alt API 26+
Dec->>ART: InMemoryDexClassLoader(ByteBuffer[]) 内存加载
else API < 26
Dec->>ART: 写临时文件 + DexClassLoader 加载
end
Dec->>ART: 反射替换 LoadedApk.mClassLoader / 合并 dexElements
Dec->>ART: 修复 mApplication、ContentProvider、资源路径
Shell->>Real: 交给真实 Application.onCreate()
Real->>Z: 正常业务启动
这里有个坑,只有自己写过或者调过壳才会碰到:系统实例化 ContentProvider 的时机在 Application.attachBaseContext() 之后、Application.onCreate() 之前。所以解密和换 ClassLoader 必须在 attachBaseContext() 里全部完成,晚一步 Provider 就直接 ClassNotFoundException。另外 Manifest 里声明的四大组件用的是真实类名,系统拿原来的 PathClassLoader 去找会扑空,要么在壳阶段把类提前 load 进来,要么把声明改成壳的代理类再转发。这两个点我第一次读加固原理时完全没概念,是后来让 Trae 把 ActivityThread 的启动链路逐段标出来才补上的。
五代加固,其实是在跟脱壳工具赛跑
| 代次 | 做法 | 防住什么 | 怎么被破 |
|---|---|---|---|
| 第一代 | 整包 dex 加密,启动时解密成文件再 DexClassLoader 加载 | 静态反编译看不到真 dex | 磁盘上有完整明文 dex,直接拷走 |
| 第二代 | 类抽取 / 指令抽取,运行时按需回填字节码 | 静态拿不到完整方法体 | 内存 dump、Hook defineClass 时抓完整 dex |
| 第三代 | 不落盘,InMemoryDexClassLoader(API 26+)纯内存加载 | 磁盘不留明文 | Hook ART 的 DexFile / OpenDexFileFromMemory,内存里总有完整结构 |
| 第四代 | VMP / Dex2C:自定义指令解释器,或把 Java 方法转成 native | 反编译出来也读不懂 | 解释器可还原、耗时、兼容性差 |
| 第五代 | so 加固、OLLVM、运行时对抗(防调试/防注入/环境识别/端侧处置) | 抬高自动化分析的成本 | 没有终点,纯对抗 |
脱壳为什么总能成功?因为 ART 最终一定要拿到可执行的结构。不管中间怎么加密、怎么抽取、怎么虚拟化,在某个时间点,内存里必然存在能被解释或执行的东西;dex2oat 要编译、DexFile 要注册、类要被 defineClass。Frida 挂上去在这些点上一 dump,壳就漏了。加固从来不提供绝对安全,它只抬高成本、拖长时间,把脚本小子的批量扫描挡在外面,把有针对性的攻击拖到我们的版本迭代之外。
代价是实打实的
厂商文档里那些数字比任何论证都有说服力。有一家把兼容性数据公开得很细,我照着核对过自己的包:
DEX 加壳:加密 dex + native loader 一起进包 → 体积通常增加个位数到十几个百分点
(大型多 dex 应用约 +12%)
首次冷启动:解密并加载一次,典型应用 +13~20%(几十到几百毫秒)
大 DEX / HCE 支付类应用 +51~152%
常驻内存:+17~35MB
执行效率:安装期 dex2oat 的 AOT 优化吃不到,动态加载的部分走解释执行 / JIT
ABI:native 保护一般只覆盖 arm64-v8a、armeabi-v7a,x86 直接砍掉
冷启动那条对我们尤其致命——医疗健康类 App 里有一串开机就要跑的初始化,超过某个阈值首屏就会白一下。还有个容易忽略的:跨平台代码不一定在保护范围内。DEX 加壳只管 Java/Kotlin 编译出来的 dex,Flutter 的 Dart 代码编进 libapp.so、React Native 的 JS bundle 都是 assets,壳管不着;RN 只有那层 Java 桥接代码被覆盖。团队里如果有人以为「上过加固就全保护了」,这块一定要提前对齐。
为什么我最后没自己写壳
我确实动过这个念头,还让 Trae 生成过一版原型。跑了两周,放弃了,原因按踩到的顺序排:
兼容性是个无底洞。 ART 每个版本都在动内部结构,LoadedApk 的字段名、dexElements 的类型、hidden API 的灰名单策略,Android 12 到 16 换了好几轮。厂商那套壳背后是上百台真机矩阵和持续适配,我一个人维护不了。而且反射访问 hidden API 在新版本上要么被拦要么要绕过,绕过本身又是一堆不稳定代码。
Google Play 那条线不能碰。 Play 的「Device and Network Abuse」政策限制应用从 Play 以外下载可执行代码(dex/jar/so)来修改、替换或更新自身。本地打包的壳和「远程下发 dex」不是一回事,但政策边界很窄,一旦检测脚本扫到动态代码加载特征,解释成本远高于收益。国内渠道虽然没这条,但同一个包往往要出国内版和海外版,两套逻辑不划算。
加固壳本身会变成新的合规风险。 环境识别那部分要读 root 状态、Hook 框架、已安装应用列表、代理/VPN——「已安装应用列表」正好是 T/TAF 077.6 和 GB/T 41391-2022 重点关注的个人信息类型。为了防破解去采一批设备信息,转头隐私检测就报「收集与业务无关的信息」,属于自己给自己挖坑。
性价比不对。 真正让上架卡住的是权限、SDK、隐私政策一致性,不是反编译难度。把两周花在写壳上,不如把混淆规则、签名校验、构建流水线、证据归档这几件事做扎实。
想通之后,路线就清楚了:不造壳,做一层能自查、能回归、能出证据的防护。 商业壳能买就买,买不到也不至于裸奔;而且这一层做完,将来换了哪家加固厂商,前置检查和后置回归都能原样复用。
换了个思路:把加固拆成四层,每层都留得下证据
flowchart TB
subgraph B[构建期 · 交付之前]
B1[R8 全量混淆<br/>mapping / seeds / usage 归档]
B2[配置收敛<br/>allowBackup · exported · 明文流量 · 备份范围]
B3[敏感信息治理<br/>密钥 · 日志 · 字符串 · 剪贴板]
B1 --> B4[打包]
B2 --> B4
B3 --> B4
end
subgraph R[运行时 · 装到用户手机上]
R1[签名与完整性自校验]
R2[防调试 / 防注入信号<br/>只上报不拦截]
R3[存储加密 · 证书绑定]
end
subgraph V[验证期 · 出包之后]
V1[zipalign → apksigner → 渠道]
V2[权限 / SDK 基线 diff]
V3[反编译自测 · 真机矩阵 · 冷启动基线]
end
subgraph E[证据期 · 送检与检查]
E1[build-info + 哈希 + 签名指纹]
E2[条款映射表 + 自检结果]
E3[第三方检测报告 / 等保测评]
end
B4 --> V1
V1 --> R1
V1 --> V2
V1 --> V3
R1 --> E1
R2 --> E2
V2 --> E2
V3 --> E2
E1 --> E3
E2 --> E3
三条我自己立的规矩,后面每一轮提示词都带着:
加固不等于加密。 混淆、校验、配置收敛、最小权限,这些是让静态分析和二次打包变贵,不是让数据变得不可读。真要保护数据,走的是 Keystore + 加密存储 + TLS 那条线,两码事。
任何防护都不许新增个人信息采集。 不读应用列表、不采设备标识符、不因为检测到风险就拒绝服务。风险信号只用自己定义的一个枚举值,走已有日志通道上报到自己的服务端,隐私政策里如实写一句。
不能验证的防护等于没做。 每一层都要有一个能跑的命令或测试,产出能落盘的文件。检查的时候能拿出「哪次构建、哪个 commit、跑了什么、结果是什么」,比口头说「我们加固了」有用得多。
给 Trae 定规矩之前,先踩了个版本坑
我照着去年收藏的教程找 Builder 模式,设置里翻了三圈没找到。后来翻官方文档才看到:2026 年 5 月,SOLO Builder 和 SOLO Coder 合并成了 SOLO Agent,Builder 现在只是个历史叫法,界面标签和旧截图对不上。这类事在 AI IDE 上太常见了,所以后面每轮提示词我都写清楚「在哪个模式、带哪些文件」,而不是「打开 Builder 然后……」。
我实际用的分工是:
| 场景 | 用哪个 | 为什么 |
|---|---|---|
| 读代码、看某个类怎么调的、方案评审 | IDE 模式 + Chat,#Code 挂上下文 | 不动文件,省额度 |
| 生成/改一堆文件、跑命令、迭代修编译错误 | IDE 模式 + Agent | 能直接落盘和验证 |
| 需要联网核对法规条文、拉标准原文、读在线文档 | SOLO 模式(自带浏览器和文档查看器) | cite 得到出处,不会凭空编条号 |
| 长任务做完 | 新开对话 | 历史越长越容易把前面的约束冲淡 |
.trae/rules/ 是这套流程里最值钱的东西。项目根目录放总规则,子模块可以放自己的规则文件,对应模块自动生效,不用每轮重复粘贴规范。规则的生效方式有四种:alwaysApply: true 始终生效、globs 指定文件生效、description 让 AI 判断相关性、以及 @Rule 手动点名(不同版本里也写作 #Rule,以你界面上的为准)。我对加固这件事用了两条:一条始终生效的总纲,一条只在碰到 proguard-rules.pro 和 build.gradle.kts 时生效的构建规则。
先说忽略列表,这个不配好后面全是隐患。密钥、签名文件、local.properties、已经打出来的包、mapping 归档,一律不进索引:
# .traeignore
**/keystore/**
**/*.jks
**/*.keystore
**/keystore.properties
**/signing.properties
local.properties
**/build/**
**/release/**
**/dist/**
**/mapping/**
**/*.apk
**/*.aab
**/*.so
**/secrets/**
**/.env
**/.env.*
**/google-services.json
**/agconnect-services.json
这里有个细节值得单独提一句:忽略列表挡的是自动索引,不等于挡住手动 @ 挂进来的文件,也不等于挡住命令读取。真要保险,私钥压根别放进工作区,CI 里用环境变量注入签名信息。我在 Rules 里也写死了这一条。
总规则全文如下,这份是可以直接抄进 .trae/rules/security-hardening.md 的:
---
description: Android 客户端加固与合规整改的总纲,所有涉及 release 构建、
签名、权限、数据安全、反编译防护的对话都遵循
alwaysApply: true
---
# 项目背景
医疗健康类 Android 应用,Kotlin + Jetpack Compose 与少量 XML View 混用,
AGP 8.x / R8 全量混淆,minSdk 26,targetSdk 36,多模块 + 若干第三方 SDK,
国内多渠道分发,同时出海外版。当前在做个人信息保护与数据安全整改。
# 技术约束(优先级最高)
- 优先 AndroidX / 平台原生 API,不引入新的第三方依赖。
确实需要引库时,先给出理由和替代方案,等我确认再动手。
- 不引入任何第三方加固 / 加壳 / 混淆 SDK,不生成 DexClassLoader
动态加载业务代码的方案,不设计任何从网络下发 dex / jar / so 的机制。
- 不新增 Android 权限,不新增任何个人信息采集点。
尤其不读取已安装应用列表、不采集 IMEI / MAC / OAID / 广告标识。
- 运行时风险检测只产生「信号」,不拦截用户、不崩溃、不拒绝服务,
不读取设备标识作为上报内容;上报复用项目现有日志通道。
- release 构建不得开启 debuggable,不得允许明文流量,
不得信任用户 CA,不得把敏感数据纳入备份范围。
- 签名私钥、口令、服务端密钥一律不写入代码、不写入对话、不写入示例。
构建脚本只读取环境变量。
# 代码规范
- Kotlin 官方风格,新增类注明文件路径与用途。
- 所有校验逻辑放在 application 层单一入口,不要在业务代码里散落判断。
- native 代码只在确有必要时使用,附 CMakeLists.txt 与 ABI 说明。
- 每个改动都给出可执行的验证命令(adb / gradle / apksigner / aapt)。
# 交付要求
- 先说清楚改了哪些文件、为什么,再给代码;不要一次性重构整个模块。
- 涉及法规或标准时,标明文号 / 标准号与条款号,并说明是原文要求还是工程推断。
不确定的地方直接标「需人工核对」,不要补全。
- 每轮结束时列出「本轮产出的可归档文件」,供后续生成证据包使用。
- 不写 TODO、不写占位符、不写「其余部分略」。
第二条构建规则用了 globs,只在聊到混淆和打包时生效,免得每轮都把一长串 R8 注意事项塞进上下文:
---
description: 修改 proguard-rules.pro / build.gradle.kts / CI 脚本时生效,
约束 R8 混淆与签名打包顺序
alwaysApply: false
globs: "**/proguard-rules.pro,**/*.gradle.kts,**/*.gradle,**/.github/workflows/*.yml"
---
# 混淆与打包
- keep 规则按「为什么需要」分组写注释:反射、JNI、序列化、Parcelable、
SDK 要求、注解处理器生成类;禁止用大范围 `-keep class * { *; }` 兜底。
- 四大组件由 aapt2 生成的规则覆盖,不手写重复 keep。
- 保留 Signature / *Annotation* / InnerClasses / EnclosingMethod,
用 -renamesourcefileattribute 抹掉真实源文件名。
- release 必须产出 mapping.txt / seeds.txt / usage.txt,构建脚本里归档,
并在 build-info 里记录 R8 版本与配置文件哈希。
- 打包顺序:assemble → zipalign -p 4 → apksigner sign → apksigner verify。
v2/v3 签名后不许再改动 APK 字节;渠道信息写进 APK Signing Block 自定义 ID。
- 日志清理用 -assumenosideeffects,同时确认没有 -dontoptimize,
否则这条规则不生效。
- 每次改动后跑一次权限基线 diff 和反编译抽查,输出差异文件。
提示词我统一用五段式,这是 Trae 官方文档里那个结构,用在加固这种「改动多、验收严」的任务上刚好:
Goal: 这轮结束时,应该存在什么(可观察的结果,不是「优化一下」)
Context: @ 哪些文件、当前状态、上一轮改了什么
Requirements: 逐条列出要有的行为
Constraints: 明确不许改什么(这里永远是那三条硬约束的变体)
Validation: 跑哪条命令、看哪个文件、什么结果算过
前两轮我偷懒写成「帮我做一下加固」,Trae 直接给我生成了一整套 DexClassLoader 加壳原型,还挺完整,有解密、有 ClassLoader 替换、有 Application 代理。不是它不行,是我没把 Constraints 写进去。后来每轮 Constraints 都固定带这三句:
- 不引入第三方加固库,不实现 dex 加壳,不设计网络下发可执行代码的机制
- 不新增权限,不新增个人信息采集点,不读取已安装应用列表
- 风险检测只记录信号,不拦截、不崩溃、不采集设备标识
还有一句是我被坑出来的:「涉及法规条文时,标明文号与条款号;不确定就写『需人工核对』,不要补全」。没这句的时候,它给我编过一条看着很像真的「第某条要求客户端加壳」,我差点贴进整改报告里。
十二轮提示词,我按这个顺序跑完的
顺序不是随便排的。前四轮只做盘点和映射,一行产品代码都不改;中间六轮才动代码和构建;最后两轮做验证和归档。先摸清楚家底再让 AI 写东西,返工量差了一个数量级。
每一轮都写清楚:开哪个模式、@ 哪些文件、提示词原文、我实际改了什么、拿什么命令验收、跑偏了怎么追。提示词块整段复制即可。
第 1 轮 · 把家底盘清楚
IDE 模式 / Chat,#Code 挂上整个 app/ 和各 build.gradle.kts,先不让它改任何文件。
Goal: 产出一份这个 Android 工程的「攻击面清单」,只做分析,不修改任何文件。
Context: @app/src/main/AndroidManifest.xml @app/build.gradle.kts
@app/proguard-rules.pro @gradle/libs.versions.toml
以及所有模块的 build.gradle.kts。这是一个多模块 Kotlin 项目,
minSdk 26 / targetSdk 36,AGP 8.x,R8 已开启。
Requirements:
1. 逐项列出:所有 Android 权限(标明声明位置与对应业务功能)、
所有 android:exported 的组件(Activity / Service / Receiver / Provider)、
所有第三方 SDK(从 dependencies 与 Manifest 里的 meta-data / 初始化代码推断),
所有 assets 下的明文配置文件、所有 native 库及其 ABI、
allowBackup / dataExtractionRules / networkSecurityConfig / usesCleartextTraffic
当前取值、debuggable 在各 buildType 的取值。
2. 从代码里找出所有硬编码的密钥、token、服务端地址、证书、
以及 Log.* 输出中包含敏感字段的位置,给出文件与行号。
3. 列出所有反射调用、JNI native 方法、Gson/序列化/Parcelable 相关类,
这些是后续混淆规则的 keep 候选,标注「可能的」与「确定的」。
4. 输出成 docs/hardening/inventory.md,用表格,每项带文件路径。
5. 单独列一节「本清单无法从代码推断的内容」,例如服务端配置、
渠道包策略、隐私政策文本、现有检测报告,供我人工补齐。
Constraints: 不修改任何源文件;不引入依赖;推断不出来的写「待确认」,
不要猜测后填一个看起来合理的值。
Validation: 我人工核对 inventory.md 里的权限数量与
`aapt dump permissions <apk>` 的输出是否一致,不一致就指出差异。
第一版清单漏了 AndroidManifest.xml 里一个被 manifest merger 合并进来的权限——来自某个 SDK 的库清单,源码目录里根本搜不到。我追了一句:
把 merged manifest 也算进去。读 app/build/intermediates/merged_manifest/
下的输出(如果本地没有,就告诉我用哪条 Gradle task 生成),
区分「本模块声明」「库清单合并」「构建脚本注入」三个来源。
另外把每个权限对应的 SDK 标出来。
这个来源区分后来在隐私政策对齐时救了我一次:某条权限是 SDK 带进来的,我们业务代码从来没主动申请过,整改时得找 SDK 的配置开关,不是删自己的代码。
第 2 轮 · 把法规条文翻译成能检查的项
SOLO 模式,开联网,让它自己拉原文。
Goal: 产出 docs/hardening/compliance-map.md,把监管要求逐条翻译成
客户端可执行的检查项,每条带「证据文件」字段。
Context: @docs/hardening/inventory.md @.trae/rules/security-hardening.md
联网核对以下原文,不要凭记忆复述:
- 《移动互联网应用程序信息服务管理规定》(2022-08-01 施行)第 5、
10、11、12、14、20 条
- GB/T 35273-2020、GB/T 41391-2022
- 国信办秘字〔2021〕14 号、国信办秘字〔2019〕191 号
Requirements:
1. 表格列:条款号 / 原文要点(摘录,不要改写)/ 对客户端意味着什么 /
本项目当前状态(从 inventory 推断)/ 需要的技术动作 /
可归档的证据文件名 / 是否属于「加固」范畴。
2. 单独标注:哪些条款的满足凭证只能是第三方机构出具的报告,
自查文档不具备效力,不要把它们写成「代码可以解决」。
3. 对「加固」这一列,说清楚它是「技术措施」还是「合规凭证」,
两者不要混。如果原文里没有出现「加固 / 加壳 / 混淆」字样,明确写出来。
4. 对 191 号文里每一类「可被认定为违法违规」的行为,
映射成一条客户端自检命令或检查点(例如权限申请时机、
同意前是否有采集、频度是否超出业务需要)。
5. 每条证据文件给出建议路径,统一放在 docs/hardening/evidence/ 下。
Constraints: 条文引用必须带文号与条款号;区分「原文要求」与「工程推断」;
不确定处写「需人工核对」,不要补全或推测条号;不修改任何源文件。
Validation: 我逐条比对网信网原文,重点看第 10、11、20 条;
任何一条摘录对不上就整表重出。
这轮跑出来最有价值的不是表,是它明确回了一句:规定原文里没有「加固」「加壳」「混淆」这些词。我拿这句去回合规同学那个问题,才算把话题拉回正轨。
还有一处返工:它把「等保测评」和「隐私合规检测」写成了同一个东西,被我打回去重出。追问是这么写的:
这两份报告的主体、依据标准、覆盖范围不同,拆成两行重写,
并各自说明:由谁出具、查的是客户端还是后端、
本项目需不需要做、为什么。不要合并成「安全检测报告」。
第 3 轮 · R8 规则,按「为什么需要」分组生成
IDE 模式 / Agent,这轮开始动文件。
Goal: 重写 app/proguard-rules.pro,让 release 包在保留全部功能的前提下
做到最大化混淆,并产出一份规则说明文档。
Context: @app/proguard-rules.pro @docs/hardening/inventory.md
@.trae/rules/build-and-shrink.md(globs 规则,本轮请手动 @Rule 点名)
项目用 R8 全量模式,minSdk 26,含 Compose、Room、Retrofit、
Kotlin 序列化、若干 JNI 方法。
Requirements:
1. keep 规则按原因分组,每组上方写注释说明为什么必须保留、
去掉会在什么场景崩:反射、JNI、序列化、Parcelable.Creator、
注解处理器生成的类、SDK 文档明确要求的类、@Keep 标注。
2. 不要用 `-keep class * { *; }` 这类兜底;每条 keep 尽量收窄到
具体类或具体成员。四大组件由 aapt2 生成的规则覆盖,不重复写。
3. 保留 Signature / *Annotation* / InnerClasses / EnclosingMethod;
用 -renamesourcefileattribute 处理源文件名。
4. 用 -assumenosideeffects 移除 release 的 Log.v/d/i,
并确认构建配置里没有 -dontoptimize;如果有,指出在哪、怎么改。
5. 用 -repackageclasses 打散包结构,但先列出这样做可能影响的
反射点,让我确认后再加。
6. build.gradle.kts 的 release 块里补上 mapping.txt / seeds.txt /
usage.txt 的归档路径,文件名带上 versionName 和 git short commit。
7. 输出 docs/hardening/r8-rules-note.md:逐组解释规则、
列出「加了之后需要重点回归」的功能清单。
Constraints: 不引入第三方混淆库;不新增权限;
JNI 方法所在的类名与方法名不许被改,除非改用 RegisterNatives
(如果要改,先给方案等我确认);不改业务源码。
Validation: 跑 ./gradlew :app:assembleRelease,
再跑 ./gradlew :app:minifyReleaseWithR8 --dry-run 确认任务链;
把 seeds.txt 里条目数、mapping.txt 里被重命名的类占比报给我;
列出 r8-rules-note.md 里需要我人工确认的反射点。
第一版它给 Compose 的 @Composable 加了一堆保守 keep,混淆率掉得很厉害,我追了一句:
seed 里 Compose 相关的条目太多了。逐条说明每个 keep 是哪份
官方文档或哪个运行时行为要求的;没有明确依据的先删掉,
并在回归清单里标注「删掉后需要验证哪些页面」。
删完再跑一遍,映射里被重命名的类占比上来了,回归清单里多出三个页面要人工过。这个取舍我觉得值——保守 keep 会让混淆形同虚设,但也不能为了数字好看把运行时行为搞崩。
第 4 轮 · 拿真机验 keep 有没有漏
IDE 模式 / Agent,接上设备跑。
Goal: 用一组自动化检查,验证上一轮混淆规则没有把运行时依赖的类改掉,
产出 docs/hardening/evidence/r8-verify.md。
Context: @app/proguard-rules.pro @docs/hardening/r8-rules-note.md
@app/build/outputs/mapping/release/mapping.txt
@app/build/outputs/mapping/release/seeds.txt
Requirements:
1. 写一段 instrumentation 测试(用项目已有的测试框架,不引新依赖),
覆盖:所有导出组件的启动、反射调用路径、JNI 调用路径、
序列化/反序列化往返、Parcelable 读写、Compose 首屏渲染、
第三方 SDK 初始化。每一处对应 r8-rules-note.md 里的一个风险点。
2. 写一段脚本,把 mapping.txt 与 seeds.txt 做交叉检查:
找出「被 keep 但文档里没写原因」的类,和
「文档里标了风险但 mapping 里没有对应记录」的类,输出两份 diff。
3. 用 retrace 还原一段模拟的混淆堆栈,把命令和输出记进证据文件,
确认 mapping 归档可用(这是崩溃定位能不能做的前提)。
4. 给出 adb 命令:安装 release 包、抓取启动 30 秒内的 logcat、
过滤 ClassNotFoundException / NoSuchMethodError / VerifyError /
UnsatisfiedLinkError,输出过滤后的结果。
Constraints: 不引新测试框架;不修改产品代码;
测试失败时先报告具体失败用例与堆栈,不要自动放宽 keep 规则。
Validation: ./gradlew :app:connectedReleaseAndroidTest(或项目对应 task)
全部通过;diff 两份文件都落在 evidence/ 下;
retrace 还原出的类名与源码一致。
这轮真抓到一个问题:某个通过字符串拼接类名做反射的调用,R8 改了类名之后运行期直接 ClassNotFoundException,静态扫描完全看不出来。Trae 给的修法是 -keepnames 收窄到那个包,同时在回归清单里补一条。我当时让它别急着改规则,先出一版诊断:
先别改 proguard 规则。把这个反射调用的完整调用链列出来,
说明为什么 R8 无法静态识别它,再给两个方案:
A 收窄 keepnames;B 改成编译期常量引用、从根上不靠反射。
列清各自的代价,我选一个再动手。
最后选了 B,顺手把一处历史代码清掉了。这类地方,AI 直接给补丁最快,但不问一句就永远不知道自己在还什么债。
第 5 轮 · 签名和完整性,自己验一次
IDE 模式 / Agent。这轮是整套防护里唯一「真的在防二次打包」的部分。
Goal: 在 app 层加一套签名与完整性自校验,release 生效、debug 关闭,
结果通过项目现有的日志通道上报,产出证据文件。
Context: @docs/hardening/inventory.md @app/build.gradle.kts
@.trae/rules/security-hardening.md
minSdk 26 / targetSdk 36,签名信息由 CI 环境变量注入,
工作区里没有 keystore。
Requirements:
1. 新建 security/SignatureVerifier.kt:
- API 28+ 用 PackageManager.GET_SIGNING_CERTIFICATES 取
SigningInfo.getApkContentsSigners(),API 26/27 走 GET_SIGNATURES 兼容分支;
- 对 certificate.encoded 取 SHA-256,与构建期注入的期望指纹比对;
- 期望值通过 buildConfigField 注入,构建脚本从环境变量读取,
不许把指纹明文写死在 Kotlin 文件里,也不许写进日志。
2. 新建 security/IntegrityGuard.kt:
- 校验自身 APK(applicationInfo.sourceDir)里 classes*.dex 的哈希,
与构建期生成的 dex-manifest.json 比对;
- 校验 lib 目录下各 ABI 的 so 哈希;
- 所有校验放在后台线程、在 attachBaseContext 之后异步触发,
不阻塞冷启动路径(我们的首屏对启动耗时敏感);
- 结果收敛成一个枚举:OK / SIGNATURE_MISMATCH / DEX_MODIFIED /
SO_MODIFIED / CHECK_FAILED,只上报枚举与版本信息,
不崩溃、不弹窗、不拦截任何业务、不采集设备标识。
3. dex-manifest.json 由构建脚本生成,路径与归档方式写进构建规则;
每次 assembleRelease 后自动刷新,并记录进 build-info。
4. 写一个 instrumentation 测试,验证「用 debug 签名重签 release 包」
能被识别为 SIGNATURE_MISMATCH(用测试用的临时签名,不碰真实 keystore)。
5. 输出 docs/hardening/evidence/integrity-design.md:
校验时序图、每个枚举的触发条件、失败时的处置流程、
以及这套校验的能力边界(例如被 Hook 后可以绕过)。
Constraints: 不引第三方库;不新增权限;不读 /proc 之外的设备标识;
不允许在校验失败时终止进程或拒绝服务;不把指纹写进 logcat;
native 层只在确有必要时引入,并附 CMakeLists.txt。
Validation:
- ./gradlew :app:assembleRelease 后确认 dex-manifest.json 已生成
- apksigner verify --verbose --print-certs <apk> 输出的证书指纹
与 buildConfigField 注入值一致
- 用临时签名重签一次包,跑测试确认识别为 SIGNATURE_MISMATCH
- adb shell am start -W -S <pkg>/<launcher> 对比开启/关闭校验的 TotalTime,
差值记录进证据文件
第一版 Trae 把校验放在了 Application.onCreate() 开头同步跑,冷启动直接多了两百多毫秒。我把厂商文档里那段「完整性校验跑在后台 detached 线程上、检测大约 200ms~1s 后才触发,同时保留篡改后处置」的做法贴给它,让它改成异步:
把校验整体挪到后台线程,冷启动路径上只做一个 boolean 置位。
主线程不许有任何文件读取或 MessageDigest 调用。
用 Perfetto 或 am start -W 给改造前后的 TotalTime 对比数字,
写进证据文件。另外说明:异步之后,篡改检测生效前
有一小段窗口,这个窗口的风险你们怎么评估。
它给的答案挺实在:窗口期存在,但防护目标是「二次打包的持久化分发」,不是「运行瞬间的一次性篡改」,靠服务端版本与签名校验再兜一层。我把这段原话留进了设计文档,检查时被问到也能说清楚。
还有个必须讲明白的边界:纯 Java 层的签名校验很容易被 Hook 掉,改 getPackageInfo 返回值或者直接把比对逻辑短路就行。想抬高成本得把关键比对放进 native,并且服务端再验一次请求来源。我在文档里如实写了「这层能挡住自动化的批量重打包,挡不住有人专门对着我们的包挂 Frida」,没把它吹成铜墙铁壁。
第 6 轮 · 运行时风险信号,只要「看见」,不要「拦住」
IDE 模式 / Agent。这轮是合规风险最高的一轮,Constraints 写得最长。
Goal: 加一组运行时环境风险信号,只记录与上报,不做任何拦截动作。
Context: @docs/hardening/compliance-map.md @.trae/rules/security-hardening.md
@security/IntegrityGuard.kt(复用它的枚举与上报通道)
Requirements:
1. 新建 security/RuntimeSignals.kt,产出以下信号(每个都是布尔或枚举,
不带任何原始设备信息):
- DEBUGGER_ATTACHED:android.os.Debug.isDebuggerConnected()
- TRACER_PRESENT:读 /proc/self/status 的 TracerPid 字段,非 0 才置位
- INJECTION_SUSPECTED:扫 /proc/self/maps,匹配已知的
frida / gadget / xposed / substrate 特征字符串
- DEBUGGABLE_BUILD:BuildConfig.DEBUG 或
applicationInfo.flags 中的 FLAG_DEBUGGABLE
2. /proc/self/status 与 /proc/self/maps 只读取进程自身的信息,
不读 /proc 下其他进程,不读 /data 下其他应用目录,
不调用 PackageManager.getInstalledPackages 或任何应用列表相关 API。
3. 上报字段固定为:信号枚举、appVersion、buildId、时间戳、进程前后台状态。
不带 IMEI / MAC / OAID / Android ID / 设备型号 / 已安装应用列表。
4. 明确写出:所有信号一律不触发崩溃、不弹窗、不退出、不拒绝服务、
不改变任何业务功能。处置放在服务端,客户端只负责「看见」。
5. 输出 docs/hardening/evidence/runtime-signals.md:
信号定义表、读取的系统路径清单、上报字段清单、
以及一段给合规同学看的说明——为什么这些读取不构成个人信息采集,
依据是哪一条;如果拿不准,标「需人工核对」。
6. 隐私政策里需要补充的那句话,单独给一版文案建议,
标明「这是工程建议,最终由法务确认」。
Constraints: 不引入第三方安全 SDK;不新增权限;
不采集任何设备标识符;不读取已安装应用列表;
不因为信号命中就拒绝服务;不写任何反制/反击逻辑;
上报复用现有通道,不新建网络端点。
Validation:
- 静态检查:grep 一遍新增代码,确认没有 getInstalledPackages /
getInstalledApplications / TelephonyManager / AdvertisingIdClient
- 动态检查:adb shell 起应用,确认 logcat 里信号字段只有约定的枚举
- 用 `adb shell am start -D` 挂调试器,确认 DEBUGGER_ATTACHED 置位,
且应用仍能正常进入主界面
这轮它第一版给了一个「检测到注入就 System.exit(0)」的实现,看着很合理,实际上踩了两条线:一是误伤(某些 ROM 自带框架会命中特征串),二是把一次环境检测变成了拒绝服务。我直接打回:
删掉所有终止进程、退出、弹窗、跳转的分支。
风险检测的输出只能是数据,不能是控制流。
另外 /proc/self/maps 的特征串匹配可能误报,
把命中后的置信度分级写出来,并给一组已知会误报的场景。
顺带把 docs/hardening/evidence/runtime-signals.md 里那段「为什么不算个人信息采集」交给了合规同学复查,Trae 给的是工程推断,不是法律意见,这个边界我留了原话,没替法务下结论。
第 7 轮 · 密钥、日志、剪贴板这些「不起眼但一查一个准」的东西
IDE 模式 / Agent。
Goal: 按 inventory 里列出的敏感点做一轮治理,产出改动清单与证据文件。
Context: @docs/hardening/inventory.md(第 2 节的硬编码清单与 Log.* 清单)
@app/proguard-rules.pro
Requirements:
1. 逐条处理硬编码:能删的删,删不掉的改为构建期注入;
真正的密钥改为运行时从服务端下发或由 AndroidKeyStore 生成,
不在代码、assets、Manifest、BuildConfig 里留明文。
每条给出「原来在哪 / 改成什么 / 影响哪些调用方」。
2. 本地持久化:用 AndroidKeyStore 生成 AES-256 密钥(GCM 模式),
加密需要落盘的敏感字段;密钥本身不出 Keystore。
本项目不引入新的加密库,给我一个最小可用的封装并注明
与 Jetpack Security 现有组件的取舍理由。
3. 日志:确认 -assumenosideeffects 对 release 生效
(检查有没有 -dontoptimize 让它失效);
列出仍然会输出敏感字段的位置,改成脱敏或删除。
4. 剪贴板:找出写入敏感内容的代码,评估是否必要;
不在 onResume 里读剪贴板。
5. 界面快照:含身份信息/诊疗信息的页面加 FLAG_SECURE,
列出加在哪些 Activity / Fragment,以及返回后台时的处理。
6. 输出 docs/hardening/evidence/secrets-and-data.md:
改动清单、每个改动对应的国标条款、验证命令。
Constraints: 不引入新依赖;不新增权限;
不把任何密钥、口令、token 写进代码或对话;
不确定服务端是否支持下发时,标「待后端确认」,不要造一个接口。
不改业务逻辑与 UI 结构。
Validation:
- 打包后 `unzip -p <apk> assets/*` 与 `strings` 抽查,
确认 inventory 里列过的明文串都已消失
- grep 一遍 release 包反编译结果里的 Log.* 调用
- 列出所有新增 Keystore 使用的 alias 与用途
「不造一个接口」这句是必要的。前一版它顺手编了个 /api/v2/keys/issue 的下发接口,连返回字段都写好了,我问后端同事,那边根本没这个东西。AI 很擅长把缺的那块补得严丝合缝,反而是最危险的地方。
第 8 轮 · 传输、备份、导出组件:配置收敛
IDE 模式 / Agent,改 XML 为主。
Goal: 收敛 release 的网络与组件配置,输出可直接检查的配置快照。
Context: @app/src/main/AndroidManifest.xml
@app/src/main/res/xml/(现有配置)
@docs/hardening/inventory.md
minSdk 26 / targetSdk 36,Android 12+ 需要 dataExtractionRules。
Requirements:
1. 新建 res/xml/network_security_config.xml:
- 全局 cleartextTrafficPermitted="false";
- 只对自有业务域配置 domain-config,
用 <pin-set> 固定 SPKI 的 SHA-256,至少给一个 backup pin,
写明 expiration;
- debug-overrides 只允许 debug 包信任用户 CA,release 不信任;
- 不配 <certificates src="user" /> 到 release 生效的域。
附一份「证书轮换时怎么改、过期了会怎样」的说明。
2. Manifest 收敛:
- 所有带 intent-filter 的组件显式声明 android:exported;
- allowBackup 按数据分级决定,敏感数据一律排除在备份范围外;
- Android 12+ 用 android:dataExtractionRules 指向
res/xml/data_extraction_rules.xml,
明确 cloud-backup 与 device-transfer 两种场景各自的排除项;
- usagesCleartextTraffic="false";
- debug 与 release 的 debuggable 由 buildType 控制,Manifest 里不写死。
3. 列出所有仍允许明文流量的域(如果有),逐个写业务理由,
没有就明确写「无例外」。
4. 输出 docs/hardening/evidence/config-baseline.xml
与 docs/hardening/evidence/config-note.md,
含合并后的 Manifest 关键片段(从 merged manifest 读,不是源码 Manifest)。
Constraints: 不新增权限;不改接口地址与业务域;
证书 pin 的具体值我不提供时写「由运维提供」,不要编一个指纹;
不因为配置收敛改变任何用户可见行为。
Validation:
- aapt dump xmltree <apk> AndroidManifest.xml 核对最终值
- 用一台 Android 7.0 与一台 Android 14 真机分别验证
证书绑定生效、明文请求被拒、备份范围符合预期
- 把差异输出成 config-diff.txt 归档
证书 pin 这轮它老老实实写了「由运维提供」,因为在第 2 轮我就立了「不确定就标需核对」的规矩。少了这个规矩,它大概率会生成一个格式正确但完全无效的 base64 指纹,等到线上证书一换,全量用户连不上,查起来还特别费劲。
第 9 轮 · 加固之后,别多出采集点
IDE 模式 / Agent。这轮不针对某次改动,是给以后每次发版都留的一道闸门。
Goal: 建一套「权限 + SDK + 网络端点」的基线比对机制,
任何一次打包(尤其是接入外部加固之后)都能自动 diff 出新增项。
Context: @docs/hardening/inventory.md
@app/build/intermediates/merged_manifest/ 下的输出
@app/build/outputs/apk/release/
Requirements:
1. 生成 docs/hardening/baseline/permissions.txt:
从 merged manifest 提取全部权限,按「业务声明 / 库合并 / 注入」标注来源。
2. 生成 docs/hardening/baseline/sdk-list.md:
从 dependencies、Manifest 的 meta-data、初始化调用点三方交叉推断,
列出 SDK 名称、版本、收集行为说明、隐私政策中对应的条目。
3. 生成 docs/hardening/baseline/endpoints.txt:
从代码与配置中提取所有网络域,标注用途。
4. 写一个脚本 verifyBaseline.sh:
接受一个 APK 路径,用 aapt 与反编译结果重新提取上述三类信息,
与 baseline 做 diff,输出 added / removed / changed 三段;
出现任何 added 项就以非零退出码失败,并打印具体项。
5. 单独写一份 docs/hardening/evidence/post-pack-check.md:
说明「如果未来接入第三方加固壳,加固前 / 加固后各跑一次
verifyBaseline.sh」,重点核对壳自己有没有带进权限、
SDK、设备信息采集、以及新的网络域。
6. 生成 privacy-checklist.md:把 191 号文里每类违规行为
变成一条人工勾选项,对应到具体页面或代码位置。
Constraints: 不修改业务代码;不新增权限;
脚本只用 aapt / apksigner / unzip / grep / python3 这类现成工具,
不引第三方二进制;diff 结果不许自动「修正」baseline,只报告。
Validation: 拿当前 release 包跑一次,输出应为零 added;
再人为往测试分支加一条权限重打一个包,确认脚本非零退出并打印那一条。
这道闸门是我最想早点做的一轮。前面说过,外部加固壳自带采集是最容易把整改搞砸的方式;有了基线 diff,以后换厂商、升 SDK、接入新的推送组件,都不用靠人肉回忆「上一版有没有这个权限」。
第 10 轮 · 把这一切钉进构建流水线
IDE 模式 / Agent,本轮改动最多,我要求它一个文件一个文件来。
Goal: 把前面各轮的检查串成一条可重复执行的 release 流水线,
产出脚本、CI 配置与证据归档目录。
Context: @app/build.gradle.kts @.github/workflows/(现有配置)
@docs/hardening/baseline/ @docs/hardening/evidence/
@.trae/rules/build-and-shrink.md
Requirements:
1. 新建 buildSrc 或 scripts/hardening/ 下的 Gradle 任务,按序完成:
assembleRelease → 生成 dex-manifest.json(classes*.dex 与 lib/*.so 的
SHA-256)→ 归档 mapping/seeds/usage → 生成 build-info.json →
zipalign -p 4 → apksigner sign(v1/v2/v3 显式开启)→
apksigner verify --verbose → 写渠道信息 → 计算最终 APK 的 SHA-256 →
verifyBaseline.sh → 反编译抽查 → 打包 evidence/ 为 zip。
2. build-info.json 字段:versionName、versionCode、git commit、
构建时间、AGP / Gradle / R8 版本、proguard 规则文件哈希、
签名证书 SHA-256、APK SHA-256、渠道、上游 baseline 版本。
签名信息只从环境变量读,脚本里不出现口令与私钥路径。
3. 渠道信息写进 APK Signing Block 的自定义 ID-Value,不改 ZIP entries、
不破坏 v2/v3 签名。给出写入脚本与读取脚本,并说明
EOCD 里 central directory offset 为什么必须同步更新。
4. 反编译抽查脚本:用 jadx(如果环境没有就报出来,不自动下载)
把产物反编译到临时目录,grep 检查 inventory 里列过的明文串、
检查 Log.* 是否被移除、抽查若干业务类名是否已混淆;
输出 hardening-scan.txt。
5. CI 配置:新增一个 job 跑上面整条链,把 evidence/ 作为 artifact 上传,
保留天数按项目现有策略;失败时把失败阶段与日志一起报出来。
6. 输出 docs/hardening/pipeline.md:任务顺序图、每一步的产物、
失败时的定位方式、以及本地复现整条链的单条命令。
Constraints: 私钥、口令、token 不写入任何文件与对话,只从 CI 环境变量注入;
不引入新的 Gradle 插件;v2/v3 签名之后不许有任何改动 APK 字节的步骤
(渠道写入除外,且要说明理由);不自动下载外部工具。
Validation: 本地跑一次完整链,逐项核对 evidence/ 下的文件名;
apksigner verify --verbose --print-certs 通过;
把最终 APK 装到真机确认能启动、能走通登录;
CI 上重跑一次,比对两次 build-info.json 里除时间/commit 外是否一致。
渠道包那块它一开始给了个「往 META-INF/ 塞空文件」的老方案,v1 时代能用,v2 之后直接破坏签名。我让它重写:
v2/v3 时代不能往 ZIP 里加文件。改成解析 APK Signing Block:
在 "APK Sig Block 42" 之前插入自定义 ID-Value,
同步更新 block 前后两处 size 和 EOCD 的 central directory offset。
写清楚为什么这样不破坏签名,以及 v2 验签时对 EOCD 这个字段
做了什么特殊处理。给一段能跑的 python3 脚本和一句 adb 读取验证。
第 11 轮 · 加固后的回归,比加固本身更容易出事
IDE 模式 / Agent + 真机。
Goal: 出一份 release 包的回归报告与性能基线,落盘到 evidence/。
Context: @docs/hardening/r8-rules-note.md(回归清单)
@docs/hardening/evidence/ @app/build/outputs/
Requirements:
1. 设备矩阵:Android 8 / 10 / 12 / 14 / 16 各一台(arm64 为主),
再加一台 x86 镜像做对照;列出每台的型号、系统版本、ABI。
2. 每台跑:安装、冷启动、登录、核心业务路径、后台回到前台、
权限申请与拒绝、通知点击、升级安装覆盖。
记录 ClassNotFoundException / NoSuchMethodError / VerifyError /
UnsatisfiedLinkError / ANR / 崩溃。
3. 冷启动用 `adb shell am start -W -S <pkg>/<activity>`,
每台重复 7 次取中位数,记录 TotalTime;
与未做防护的基线包对比,输出差值;
同时在首屏调 reportFullyDrawn(),记一下真实可交互时间。
4. 崩溃还原演练:造一条混淆后的堆栈,用 retrace + 归档的 mapping
还原到源码行号,把命令与结果写进证据文件。
mapping 找不到或版本对不上时,明确报出来。
5. 包体积与内存:记录 APK 大小、安装后占用、
首屏稳定后的 PSS(dumpsys meminfo),与基线对比。
6. 输出 docs/hardening/evidence/regression.md,含全部原始数字、
设备清单、失败项与处置结论。
Constraints: 不修改业务代码来「适配」某台设备,失败先报告根因;
不因为个别机型异常就放宽混淆规则;
数字取实测值,不要给估计值或「约」。
Validation: 矩阵里所有设备核心路径通过;
冷启动相对基线的增幅写清楚,超过项目阈值就在报告里标红并给优化建议;
retrace 能还原到正确行号。
这轮实测下来,冷启动比基线多了几十毫秒,主要在完整性校验和 dex 哈希那块。按第 5 轮的异步改造后又降回去大半,剩下的在可接受范围。数字要真跑——我第一次让 Trae 写报告,它给了个「预计增加 5% 以内」的估计值,我删掉重跑,所以 Requirements 里专门加了「不要给估计值」这句。
第 12 轮 · 证据归档,再让它自己挑一遍刺
SOLO 模式,最后一轮分三步走。
Goal: 生成可送检的证据包,并从审核方视角做一次对抗性复核,
最后给一份回滚预案。
Context: @docs/hardening/ 整个目录 @app/build/outputs/
第一步 · 归档:
1. 汇总 evidence/ 下所有文件,生成 index.md:
文件名 / 内容摘要 / 由哪一轮产生 / 对应 compliance-map.md 里哪一条 /
生成时间 / 关联的版本与 commit。
2. 生成 evidence/manifest.json,列出每个文件与其 SHA-256,
便于后续核对材料有没有被改过。
3. 单独标出「本包不含第三方检测报告与等保测评报告」,
并写明这两份材料由谁出具、当前状态、下次复测时间。
不要把自查材料写成具备同等效力。
第二步 · 对抗性复核:
4. 现在切换到审核方视角,按国信办秘字〔2019〕191 号的
六类情形逐条审这个包,找出仍然可能被认定为违规的点。
每条给出:依据条款、触发场景、涉及的文件或代码位置、
严重度、建议动作。
5. 再按「一个只会用 jadx / apktool / Frida 的逆向者」视角,
列出这套防护里最容易被绕过的三个环节,并说明
绕过之后能拿到什么、拿不到什么。
6. 不要为了让报告好看而淡化问题;发现不了问题就写
「本轮未发现」,并说明检查范围的局限。
第三步 · 回滚:
7. 输出 docs/hardening/rollback.md:
每一层防护对应的关闭开关(构建开关或远程配置),
关闭后的影响面、需要同步撤下的证据文件、
以及出现「校验误伤正常用户」时的处置流程与责任人占位。
8. 特别写清楚:mapping.txt 丢失后线上崩溃怎么还原、
签名证书轮换时 buildConfigField 里的期望指纹如何同步,
这两件事不要等到出事再想。
Constraints: 不修改任何产品代码;不编造检测结果;
第三方报告的状态按我提供的真实情况写,不知道就标「待确认」;
复核结论里区分「已确认问题」与「需人工核对」。
Validation: 我把 index.md 每一条对应到 compliance-map.md 的条款号,
随机抽三条打开文件核对内容;manifest.json 的哈希逐个复算。
第二步是我觉得最该保留的一轮。让 AI 自己挑自己生成的东西,比让它再夸一遍有用得多。它挑出来两条我确实没注意:一是某个 SDK 在用户同意隐私政策之前就做了初始化,属于 191 号文里「征得同意前就开始收集」那一类,这个藏在前两轮的盘点之外;二是 dataExtractionRules 里漏排了一个缓存目录下的文件。两条都进了整改清单。
它也老实写了「本轮检查基于静态代码与产物,未做动态抓包与真机行为观测,这两块需人工补」——把局限写出来,比给一个漂亮的「全部通过」可信得多。
最后落地的代码长什么样
十二轮跑完,工程里多出来的东西不算多,主要是这些:
app/
├── src/main/
│ ├── AndroidManifest.xml # exported / backup / network 配置收敛
│ ├── kotlin/.../security/
│ │ ├── SignatureVerifier.kt # 签名指纹比对
│ │ ├── IntegrityGuard.kt # dex / so 完整性,异步
│ │ ├── RuntimeSignals.kt # 环境风险信号,只上报
│ │ └── CryptoBox.kt # Keystore + AES/GCM 最小封装
│ └── res/xml/
│ ├── network_security_config.xml
│ └── data_extraction_rules.xml
├── proguard-rules.pro # 按原因分组的 keep 规则
└── build.gradle.kts # mapping 归档 + buildConfigField 注入
scripts/hardening/
├── dex-manifest.gradle.kts # 计算 dex / so 哈希
├── apk_channel.py # 渠道写入 Signing Block
├── verifyBaseline.sh # 权限 / SDK / 端点 diff
└── scanRelease.sh # 反编译抽查
.github/workflows/release-hardening.yml
docs/hardening/
├── inventory.md # 攻击面清单
├── compliance-map.md # 条款 → 检查项 → 证据
├── pipeline.md # 流水线与失败定位
├── rollback.md # 回滚预案
├── privacy-checklist.md
├── baseline/ # permissions / sdk-list / endpoints
└── evidence/ # 每次发版一份,带 manifest.json
签名比对这段,API 28 是个分界。GET_SIGNING_CERTIFICATES 从 Android 9 才有,minSdk 26 就得留兼容分支,而 GET_SIGNATURES 在高版本上已废弃:
// app/src/main/kotlin/.../security/SignatureVerifier.kt
package com.example.app.security
import android.content.Context
import android.content.pm.PackageManager
import android.content.pm.Signature
import android.os.Build
import java.security.MessageDigest
object SignatureVerifier {
/** 返回当前安装包的签名证书 SHA-256,取不到时返回 null。 */
fun fingerprint(context: Context): String? {
val pm = context.packageManager
val name = context.packageName
val info = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
pm.getPackageInfo(name, PackageManager.GET_SIGNING_CERTIFICATES)
} else {
@Suppress("DEPRECATION")
pm.getPackageInfo(name, PackageManager.GET_SIGNATURES)
}
val signers: Array<out Signature> =
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
info.signingInfo?.apkContentsSigners ?: return null
} else {
@Suppress("DEPRECATION")
info.signatures ?: return null
}
// 多签名的包视为异常,交给服务端再做一次判定
if (signers.size != 1) return null
val digest = MessageDigest.getInstance("SHA-256")
.digest(signers[0].toByteArray())
return digest.joinToString("") { "%02x".format(it) }
}
fun matchesExpected(context: Context, expected: String): Boolean {
if (expected.isEmpty()) return true // 未注入期望值时不参与判定
val actual = fingerprint(context) ?: return false
return MessageDigest.isEqual(
actual.toByteArray(Charsets.US_ASCII),
expected.toByteArray(Charsets.US_ASCII)
)
}
}
期望指纹不放代码里,构建期从环境变量注入,debug 构建给空值:
// app/build.gradle.kts(节选)
android {
buildTypes {
debug {
buildConfigField("boolean", "ENABLE_INTEGRITY_CHECK", "false")
buildConfigField("String", "EXPECTED_SIGNING_SHA256", "\"\"")
}
release {
isMinifyEnabled = true
isShrinkResources = true
isDebuggable = false
signingConfig = signingConfigs.getByName("release")
proguardFiles(
getDefaultProguardFile("proguard-android-optimize.txt"),
"proguard-rules.pro"
)
buildConfigField("boolean", "ENABLE_INTEGRITY_CHECK", "true")
buildConfigField(
"String", "EXPECTED_SIGNING_SHA256",
"\"${System.getenv("RELEASE_SIGNING_SHA256").orEmpty()}\""
)
}
}
}
完整性校验不能放在启动主线程上,这是被冷启动数字教育过之后定下的:
// app/src/main/kotlin/.../security/IntegrityGuard.kt
package com.example.app.security
import android.content.Context
import com.example.app.BuildConfig
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.launch
import java.security.MessageDigest
import java.util.zip.ZipFile
enum class GuardResult {
OK, SIGNATURE_MISMATCH, DEX_MODIFIED, SO_MODIFIED, CHECK_FAILED
}
object IntegrityGuard {
@Volatile private var started = false
/** 冷启动路径上只做一次置位,实际校验全部在后台。 */
fun schedule(context: Context, scope: CoroutineScope, report: (GuardResult) -> Unit) {
if (!BuildConfig.ENABLE_INTEGRITY_CHECK || started) return
started = true
scope.launch(Dispatchers.IO) {
val result = runCatching { check(context) }
.getOrElse { GuardResult.CHECK_FAILED }
report(result)
}
}
private fun check(context: Context): GuardResult {
if (!SignatureVerifier.matchesExpected(
context, BuildConfig.EXPECTED_SIGNING_SHA256
)
) return GuardResult.SIGNATURE_MISMATCH
val expected = DexManifest.read(context.assets) // 构建期生成的哈希清单
val source = context.applicationInfo.sourceDir
ZipFile(source).use { zip ->
zip.entries().asSequence().forEach { entry ->
val isDex = entry.name.matches(Regex("classes\\d*\\.dex"))
val isSo = entry.name.startsWith("lib/") && entry.name.endsWith(".so")
if (!isDex && !isSo) return@forEach
val actual = zip.getInputStream(entry).use { stream ->
MessageDigest.getInstance("SHA-256")
.digest(stream.readBytes())
}.joinToString("") { "%02x".format(it) }
if (expected[entry.name] != actual) {
return if (isDex) GuardResult.DEX_MODIFIED
else GuardResult.SO_MODIFIED
}
}
}
return GuardResult.OK
}
}
check() 返回的永远是数据,没有任何 exitProcess、没有弹窗、没有把用户挡在门外。处置逻辑放服务端,这是第 6 轮定下的规矩,代码里也照着执行。
混淆规则的定稿版,重点在每条都写了「为什么」:
# app/proguard-rules.pro(节选)
# --- 反射 / JNI -------------------------------------------------
# JNI 通过静态注册的 Java_包名_类名_方法名 查找符号,
# 类名与方法名一旦被改就 UnsatisfiedLinkError。
-keepclasseswithmembernames,includedescriptorclasses class * {
native <methods>;
}
# 字符串拼接类名做反射的调用点已改成编译期常量引用;
# 保留下来的这一处是 SDK 内部的反射入口,去掉会在初始化时崩。
-keepnames class com.example.app.legacy.** { *; }
# --- 序列化 / Parcelable ---------------------------------------
-keepclassmembers class * implements android.os.Parcelable {
public static final android.os.Parcelable$Creator *;
}
-keepattributes Signature, *Annotation*, InnerClasses, EnclosingMethod
-keepclassmembers,allowobfuscation class * {
@kotlinx.serialization.SerialName <fields>;
}
# --- 注解 / Keep 标注 ------------------------------------------
-keepclassmembers,allowoptimization,allowshrinking,allowobfuscation class * {
@androidx.annotation.Keep *;
}
# --- 可还原的崩溃堆栈 ------------------------------------------
-keepattributes SourceFile, LineNumberTable
-renamesourcefileattribute SourceFile
# --- release 日志清理 ------------------------------------------
# 注意:项目里不能有 -dontoptimize,否则下面这条不生效
-assumenosideeffects class android.util.Log {
public static int v(...);
public static int d(...);
public static int i(...);
}
# --- 打散包结构 -------------------------------------------------
# 已核对过反射点,没有按包名字符串做查找的调用
-repackageclasses ''
-adaptclassstrings
-adaptresourcefilenames
-adaptresourcefilecontents
# --- 归档 -------------------------------------------------------
# mapping / seeds / usage 由 Gradle 任务归档,见 pipeline.md。
# 文件名带 versionName + git short commit,别被下一次构建覆盖掉。
网络和备份两份 XML,证书 pin 的值由运维给,代码里不编:
<!-- res/xml/network_security_config.xml -->
<network-security-config>
<base-config cleartextTrafficPermitted="false">
<trust-anchors>
<certificates src="system" />
</trust-anchors>
</base-config>
<domain-config cleartextTrafficPermitted="false">
<domain includeSubdomains="true">api.example.com</domain>
<!-- 证书 pin 待运维给出当前证书与备用证书的 SPKI SHA-256 后放开,
含 expiration 与至少一个 backup pin。空 pin-set 在部分系统版本
会解析失败,所以这里先注释,别留一个没内容的 pin-set。 -->
</domain-config>
<!-- 仅 debug 包生效,release 不信任用户 CA -->
<debug-overrides>
<trust-anchors>
<certificates src="user" />
</trust-anchors>
</debug-overrides>
</network-security-config>
<!-- res/xml/data_extraction_rules.xml(Android 12+) -->
<data-extraction-rules>
<cloud-backup>
<exclude domain="root" path="files/secure/" />
<exclude domain="database" path="health_records.db" />
<exclude domain="sharedpref" path="session.xml" />
</cloud-backup>
<device-transfer>
<exclude domain="root" path="files/secure/" />
<exclude domain="database" path="health_records.db" />
</device-transfer>
</data-extraction-rules>
渠道写入是我自己最满意的一段。v2/v3 签名之后不能再往 ZIP 里塞文件,但 APK Signing Block 里那些未知 ID 的 pair,验签时会直接忽略;EOCD 里的 central directory offset 在 v2 摘要计算时被替换成 signing block 起始偏移,不进摘要。所以只要同步更新两处 size 和 EOCD 的 offset,插入自定义 pair 不会让签名失效:
#!/usr/bin/env python3
# scripts/hardening/apk_channel.py
# 写/读 APK Signing Block 里的自定义渠道信息,不动 ZIP entries。
import struct
import sys
MAGIC = b"APK Sig Block 42"
CHANNEL_ID = 0x71777777
def find_eocd(data: bytes) -> int:
for i in range(len(data) - 22, 21, -1):
if data[i:i + 4] == b"PK\x05\x06":
return i
raise ValueError("EOCD not found")
def locate_block(data: bytes):
eocd = find_eocd(data)
cd_offset = struct.unpack_from("<I", data, eocd + 16)[0]
magic_pos = cd_offset - len(MAGIC)
if data[magic_pos:cd_offset] != MAGIC:
raise ValueError("no APK Signing Block; APK must be v2/v3 signed")
size = struct.unpack_from("<Q", data, cd_offset - 24)[0]
block_start = cd_offset - size - 8
return eocd, cd_offset, magic_pos, size, block_start
def read_channel(path: str) -> str:
with open(path, "rb") as f:
data = f.read()
_, cd_offset, _, size, block_start = locate_block(data)
pos = block_start + 8
end = cd_offset - 24
while pos < end:
pair_id, length = struct.unpack_from("<QI", data, pos)
value = data[pos + 12: pos + 12 + length]
if pair_id == CHANNEL_ID:
return value.decode("utf-8")
pos += 12 + length
return ""
def write_channel(path: str, channel: str) -> None:
with open(path, "rb") as f:
data = bytearray(f.read())
if read_channel(path):
raise ValueError("channel already written; start from a fresh signed APK")
eocd, cd_offset, magic_pos, size, block_start = locate_block(data)
value = channel.encode("utf-8")
pair = struct.pack("<QI", CHANNEL_ID, len(value)) + value
n = len(pair)
data[magic_pos:magic_pos] = pair # 插在 magic 之前
struct.pack_into("<Q", data, block_start, size + n) # 首部 size
struct.pack_into("<Q", data, cd_offset - 24 + n, size + n) # 尾部 size
struct.pack_into("<I", data, eocd + 16 + n, cd_offset + n) # EOCD 的 CD offset
with open(path, "wb") as f:
f.write(data)
print(f"channel={channel} block_size={size + n}")
if __name__ == "__main__":
if len(sys.argv) == 3 and sys.argv[1] == "--read":
print(read_channel(sys.argv[2]))
elif len(sys.argv) == 4 and sys.argv[1] == "--write":
write_channel(sys.argv[2], sys.argv[3])
else:
sys.exit("usage: apk_channel.py --read <apk> | --write <apk> <channel>")
写完必须验一次签名还在:
python3 scripts/hardening/apk_channel.py --write app-release.apk xiaomi
python3 scripts/hardening/apk_channel.py --read app-release.apk
apksigner verify --verbose --print-certs app-release.apk
CI 里我把整条链串成一个 job,签名信息全部走 secrets,工作区里不留 keystore:
# .github/workflows/release-hardening.yml(节选)
name: release-hardening
on:
workflow_dispatch:
inputs:
channel:
description: 渠道名
required: true
default: main
jobs:
build:
runs-on: ubuntu-latest
env:
RELEASE_KEYSTORE_B64: ${{ secrets.RELEASE_KEYSTORE_B64 }}
RELEASE_KEYSTORE_PASSWORD: ${{ secrets.RELEASE_KEYSTORE_PASSWORD }}
RELEASE_KEY_ALIAS: ${{ secrets.RELEASE_KEY_ALIAS }}
RELEASE_SIGNING_SHA256: ${{ secrets.RELEASE_SIGNING_SHA256 }}
steps:
- uses: actions/checkout@v4
- uses: actions/setup-java@v4
with:
distribution: temurin
java-version: '17'
- name: 解码签名到 runner 临时目录
run: |
echo "$RELEASE_KEYSTORE_B64" | base64 -d > "$RUNNER_TEMP/release.jks"
echo "RELEASE_KEYSTORE=$RUNNER_TEMP/release.jks" >> "$GITHUB_ENV"
- name: 构建 + 校验 + 归档
run: ./gradlew :app:assembleRelease verifyReleaseHardening
- name: 基线 diff
run: bash scripts/hardening/verifyBaseline.sh app/build/outputs/apk/release/app-release.apk
- name: 写渠道
run: |
python3 scripts/hardening/apk_channel.py \
--write app/build/outputs/apk/release/app-release.apk \
"${{ inputs.channel }}"
apksigner verify --verbose app/build/outputs/apk/release/app-release.apk
- name: 上传证据包
uses: actions/upload-artifact@v4
with:
name: hardening-evidence-${{ github.sha }}
path: docs/hardening/evidence/
retention-days: 90
- name: 清理签名
if: always()
run: rm -f "$RUNNER_TEMP/release.jks"
每次发版最后会留下这么一份 build-info.json,检查时只要把 commit 和哈希对上,就能定位到具体是哪次构建:
{
"versionName": "5.8.2",
"versionCode": 50802,
"gitCommit": "a3f91c2",
"buildTime": "2026-10-21T10:14:32+08:00",
"toolchain": {
"gradle": "8.9",
"agp": "8.7.3",
"r8": "8.7.18"
},
"proguardRulesSha256": "9d1c...e7",
"signingCertSha256": "3b7f...c1",
"apkSha256": "71a0...9d",
"channel": "main",
"baselineVersion": "baseline-2026-10-14",
"evidence": ["index.md", "r8-verify.md", "regression.md", "manifest.json"],
"thirdPartyReports": {
"privacyCompliance": { "status": "valid", "expires": "2027-03-01" },
"mlpsAssessment": { "status": "valid", "nextReview": "2027-04-01" }
}
}
thirdPartyReports 这一块是故意留的。它提醒我:这套自建防护再齐,也只是技术措施这一侧的材料,两份机构报告另算,有效期到了得提前排复测。
踩过的坑,按报错排
排查时最省时间的不是重新读原理,是知道「这个报错八成是哪一步没对齐」。我把这两年记下来的都摊在这里:
| 现象 | 根因 | 怎么修 |
|---|---|---|
release 启动 ClassNotFoundException,debug 正常 | 代码里用字符串拼类名做反射,R8 把类名改了 | 改成编译期常量引用;实在改不动就 -keepnames 收窄到那一个包 |
UnsatisfiedLinkError | JNI 静态注册靠 Java_包名_类名_方法名 找符号,类名被混淆 | -keepclasseswithmembernames class * { native <methods>; },或改用 RegisterNatives 动态注册 |
NoSuchMethodError / 反序列化拿不到字段 | 构造函数、Creator、序列化注解相关成员被移除 | 对照 usage.txt 找被删的成员,按原因补 keep,别整类 keep |
VerifyError / IncompatibleClassChangeError | 同一个类被两个 ClassLoader 各加载一份,或壳与 multidex 冲突 | 接口定义放宿主,dex 加载统一入口,检查 dexElements 顺序 |
ContentProvider 在加壳包里起不来 | Provider 实例化早于 Application.onCreate(),晚于 attachBaseContext(),ClassLoader 换晚了 | 解密与换 ClassLoader 全部前置到 attachBaseContext() |
apksigner verify 在对齐之后失败 | 顺序反了:v2/v3 签名后改动 APK 字节就破坏签名 | zipalign 必须在 apksigner sign 之前 |
| 渠道包装上就提示签名无效 | 沿用 v1 时代往 META-INF/ 塞空文件的做法 | 写进 APK Signing Block 自定义 ID |
渠道写入后 Parse error / 安装失败 | 只改了 block 两处 size,忘了同步 EOCD 的 central directory offset | 三处一起改,写完 apksigner verify 复验 |
release 包里还能看到 Log.d 的输出 | 构建配置里有 -dontoptimize,-assumenosideeffects 不生效 | 去掉 -dontoptimize,或改用编译期开关控制日志 |
| 线上崩溃还原不出行号 | mapping 归档没带版本,被下一次构建覆盖 | 文件名带 versionName + commit,写进 build-info |
| retrace 还原出来的类名对不上 | 拿错了 mapping(版本与包不一致) | 用 APK 的 SHA-256 反查 build-info,再取对应 mapping |
| 冷启动一下多了两百多毫秒 | 完整性校验和哈希计算放在 Application.onCreate() 主线程 | 挪到后台 IO,冷启动路径只留一个 boolean 置位 |
| 签名指纹比对恒为 false | 高版本仍用废弃的 GET_SIGNATURES,或多签 / v3 轮替签名场景 | API 28+ 用 GET_SIGNING_CERTIFICATES + getApkContentsSigners(),多签单独交服务端判定 |
| 隐私检测报「收集已安装应用列表」 | 第三方 SDK 或加固壳自带,源码 Manifest 里搜不到 | 从 merged manifest 定位来源,关 SDK 开关,跑 baseline diff |
| 报「征得同意前就开始收集」 | SDK 在 Application 里提前初始化 | 延迟到用户同意之后,隐私政策同步列条目 |
| 测试环境证书绑定后连不上 | debug-overrides 没配,或 release 误信用户 CA | debug 单独配 trust-anchors,release 只信 system |
| 备份恢复后敏感数据又回来了 | allowBackup / dataExtractionRules 漏排缓存目录 | 补 exclude,两种场景分别验 |
| 提交的自查材料被退回 | 把自建自查文档当成检测报告交了 | 找有资质机构出隐私合规检测与等保测评报告 |
aapt dump permissions 比源码 Manifest 多出权限 | manifest merger 把库清单合并进来了 | 一律以 merged manifest 为准,标注来源 |
| Trae 给出不存在的条号或后端接口 | 提示词没约束「不确定怎么办」 | Constraints 固定加「标需人工核对,不要补全」 |
有几个值得多说两句。
merged manifest 这件事贯穿始终。 我一开始对着 app/src/main/AndroidManifest.xml 数权限,怎么数都对不上检测报告。后来才养成习惯:所有以权限、组件、meta-data 为准的检查,全部读 app/build/intermediates/merged_manifest/ 下的输出,源码 Manifest 只用来定位声明位置。三方 SDK 带进来的东西,在你自己代码里是搜不到的。
签名相关的问题几乎都出在顺序和对齐上。 记住一句话就够:assemble → zipalign → apksigner sign → apksigner verify,v2/v3 签名之后 APK 字节不许再动,渠道信息是唯一的例外,而它靠的是 signing block 里那段本来就允许扩展的区域。
校验失败时的处置比校验本身更难设计。 我一开始觉得检测到重签名就该直接退出,写完才意识到两件事:一是特征串匹配会误伤(某些 ROM 自带框架会命中),二是「因为环境检测就拒绝服务」在合规上说不清。最后统一改成只上报枚举,服务端决定要不要降级,客户端永远不替用户做决定。
命令速查
排查时我基本只敲这几条,贴在终端旁边:
# 打包与规则
./gradlew :app:assembleRelease
./gradlew :app:minifyReleaseWithR8 --dry-run
# 最终产物到底声明了什么
aapt dump permissions app-release.apk
aapt dump xmltree app-release.apk AndroidManifest.xml
# 签名与对齐
zipalign -c -p 4 app-release.apk
apksigner verify --verbose --print-certs app-release.apk
apksigner sign --ks "$RELEASE_KEYSTORE" \
--ks-key-alias "$RELEASE_KEY_ALIAS" \
--v1-signing-enabled true --v2-signing-enabled true \
--v3-signing-enabled true --out signed.apk aligned.apk
# 包里还留着什么明文
unzip -l app-release.apk | grep -E 'classes|lib/|assets/'
unzip -p app-release.apk classes.dex | strings | grep -iE 'secret|token|password'
jadx -d /tmp/decompiled app-release.apk
# 崩溃还原(用 AGP 自带 R8 的 retrace)
java -cp "$R8_JAR" com.android.tools.r8.retrace \
--mapping mapping.txt --source-file SourceFile stacktrace.txt
# 真机
adb shell am start -W -S com.example.app/.MainActivity
adb shell dumpsys meminfo com.example.app
adb logcat -v brief | grep -E \
'ClassNotFoundException|NoSuchMethodError|VerifyError|UnsatisfiedLinkError|ANR|FATAL'
aapt dump xmltree 那条我建议每次发版都跑一次,它看到的是最终包,不是你以为自己写的那份 Manifest。
上线前我盯的几个数
这套东西做完,真正让我放心的是一组能对比的数字,而不是「感觉挺安全」。我们 5.8.2 那次灰度记录是这样:
| 项 | 基线 | 加完防护 | 我定的阈值 |
|---|---|---|---|
| 冷启动 TotalTime 中位数(7 次) | 842ms | 891ms | 增幅 < 100ms |
| APK 体积 | 38.6MB | 38.9MB | 增幅 < 1MB |
| 首屏稳定后 PSS | 186MB | 190MB | 增幅 < 10MB |
| 灰度 3 天崩溃率 | 0.12% | 0.13% | 无新增堆栈类型 |
| mapping 归档完整率 | — | 14/14 | 100% |
| 权限基线 diff | — | 0 added | 0 added |
| 反编译抽查命中的明文串 | — | 0 | 0 |
前三项的数字来自第 11 轮那台 Android 14 真机,其他机型在 regression.md 里有原始记录。冷启动那 49ms 主要花在 dex 哈希和一小段初始化上,异步改造后又压掉了二十几毫秒,没再往下抠——再优化就要动业务逻辑了,不值当。
另外几个不进表格但每次都要确认的:evidence/ 目录里 14 个文件齐不齐、manifest.json 里的哈希复算对不对、两份第三方报告有没有过期、以及 rollback.md 里那几个开关在远程配置上是不是真的能关掉。最后一条最容易变成纸面文章,我特意在灰度前演练过一次关掉完整性校验。
还能往下挖的地方
按我自己的排期,这些是后面想继续做的,顺序基本按投入产出比:
把 jadx 自测并进 CI 并设成硬卡点。 现在是产出 hardening-scan.txt 供人看,下一步让明文串命中就失败。这一步最便宜,挡的是最常见的低级疏漏。
Frida 自检脚本常态化。 自己写一组脚本挂上去试着 dump 一次,看看哪些类还是明文、校验在哪一步被短路。与其猜防护强度,不如定期自己打一遍,把结果记进证据包。
局部试点 Dex2C。 只对登录鉴权、接口签名这两三个类做,不动启动路径。前面算过兼容性和性能代价,全量做不划算,局部做可能值。需要先量清楚冷启动和方法调用耗时的变化。
SDK 清单自动化。 现在 sdk-list.md 还是靠 dependencies + meta-data + 初始化调用点三方推断,升级一次依赖就得人工核。想做成从构建产物里直接抽,跟隐私政策里的条目做自动比对。
加固前后基线 diff 接进任意厂商的产物。 将来真买了付费加固,或者换了供应商,这道闸门应该能原样复用:壳前跑一次、壳后跑一次,diff 出来的每一项都要有解释。
证书轮换演练。 pin 配了、backup pin 也留了,但从没真演过一次轮换。想找个测试域走完整流程,把「什么时候发版内置新 pin、旧 pin 什么时候摘」写成固定步骤。
AAB 与 Play 签名那条线单独梳理。 国内出 APK、海外出 AAB,Play App Signing 之后本地签名和上架签名不是一个东西,现在 EXPECTED_SIGNING_SHA256 的注入逻辑只对国内版成立。海外版得单独一套。
密钥轮换与降级路径。 现在 Keystore 里的 key 一旦因为系统升级或用户重装丢失,加密的本地数据就取不回来了。需要设计可恢复方案,同时别把恢复做成新的数据泄露口。
风险信号的误报治理。 /proc/self/maps 的特征串匹配在几台国产 ROM 上会命中,现在只是上报,没做处置;真要在服务端用它做决策,得先有一份误报样本和置信度分级。
每次发版自动生成证据差异包。 现在 evidence/ 是全量归档,检查时翻起来费劲。想要的是「相对上一版多了什么、少了什么、哪条条款的状态变了」,一页纸能看完。
后来
那次发版最后没用付费套餐。我把自查链路跑完,把 evidence 包交给合规同学,同时老老实实排了第三方检测和等保复测的时间——该走的程序还是得走,只是不再把「加固」当成一个上传按钮了。
有意思的是,检查那天被问得最细的不是反编译难度,是「你们怎么证明这些技术措施一直生效」。我把 build-info.json、权限基线 diff、回归报告和 CI 的 artifact 记录一起打开,反而比一份「已加固」的截图好答。这也算是这轮折腾最大的收获:一线开发能扛下来的不是造一个壳,是把每一层防护变成可重复、可验证、可追溯的东西。
现在每次发版,流水线自己跑完,evidence/ 自己长出来,我基本不用再记「这次有没有忘了加固」。加固这活儿看着是落到了我们头上,其实进了 CI 之后,它就不归任何人记性管了。