从 AGP 4.1.2 到 7.5.1——自定义混淆映射失效？

关注

原创 2024-02-23 14:07:53 1.3k 阅读 AI 写同款· GEO 优化 ›

从ProGuard到R8：Android代码混淆与优化工具演进全解析（含AGP 7.0+配置差异）本文全面解析了从ProGuard到R8的Android代码混淆与优化工具演进历程，详细对比了两者的核心机制与优势，并提供了AGP 7.0+的配置差异和迁移策略。通过实际案例和高级优化技巧，帮助开发者提升应用性能和安全性，同时解决常见问题。阅读详情

在这里插入图片描述
通常我们配置混淆规则都是在 build.gradle 中，如下所示：

android {
    buildTypes {
        release {
            minifyEnabled true
            zipAlignEnabled true
            shrinkResources true
            //自定义混淆规则
            proguardFiles 'rand_dict_proguard.pro','proguard-rules.pro','my-proguard-rules.pro'
            signingConfig signingConfigs.release
        }
    }
}

我们知道 proguardFiles 就是一个数组，内容是混淆文件路径列表，可以是相对路径、也可以是绝对路径。

问题

自定义深度混淆插件的需要，在 AGP7+ 版本之前是通过插件动态向proguardFiles列表添加混淆文件路径，这样可以达到指定任务路径的映射文件。

AGP4+

//也就是上述 build.gradle 配置的 proguardFiles 列表，动态添加自定义混淆文件路径，
//便是对 proguardList 数组的删除或添加，最后重新赋值
project.android.buildTypes.release.proguardFiles = proguardList

然而在 AGP7+ 发现此段代码虽然把自定义混淆文件路径添加到 proguardFiles 列表中，但是打包查看 apk 没有达到期望的代码映射。

排查 & 分析

经一番折腾… … 发现有这样规则文件 build\intermediates\aapt_proguard_file\变体Release\aapt_rules.txt，里面是一些混淆规则。（看了下 AGP4+ 的项目也有改文件~）

在这里插入图片描述

打包观察发现 aapt_rules.txt 文件是打包开始一段时间之后生成的（具体是在哪个任务生成的没细究），既然有这个文件存在，那么就会被使用，如果把自定义混淆规则写到这个文件里面就会被使用，这样做是不是可以生效了？

在打包过程中把自定义映射文件内容追加写到 aapt_rules.txt 文件

尝试方式一

1、把混淆文件 ① 的内容追加到 aapt_rule.txt 是可以的，并且最终生成的混淆规则汇总文件build/outputs/apk/archives/configuration.txt中也能查看到内容被引用，安装包查看也达到了预期的混淆效果，说明混淆生效了，该方式是可行的。

-applymapping  obs-mapping.txt
-keep class com.xihdvy.zbhhrn { *; }
-keep class com.jh.mnrj.nearme.gamecenter { *; }

尝试方式二

2、把混淆文件 ② 的内容追加到 aapt_rule.txt 内容写进去了，但是观察打包过程发现中途改内容又被删除了，打包完成查看最终生成的混淆规则汇总文件也没有此内容，理所当然混淆没有生效。

# rand_dict_proguard.pro 指定混淆字典
-obfuscationdictionary E:\ALLMine\tmpDemo\AGP1\app\rand_dict.txt
-classobfuscationdictionary E:\ALLMine\tmpDemo\AGP1\app\rand_dict.txt
-packageobfuscationdictionary E:\ALLMine\tmpDemo\AGP1\app\rand_dict.txt

后来并没有细究，而是通过其他方式在 build.gradle 中配置proguardFiles 'rand_dict_proguard.pro'打包混淆生效了~

还有一个奇怪的问题是：
把混淆文件 ① 的内容通过 build.gradle proguardFiles 配置竟然没有生效！（由于时间时间、能力原因，我也不再细究了）

为什么混淆规则 ② 的内容写入不行？
没有细究原因，后来发现在同级目录下还发现了另外一个混淆文件目录 build/intermediates/default_proguard_files/global（该目录在 AGP4+ 是没有的）

猜想：

混淆规则文件 ② 的内容是否可以写入到 default_proguard_files目录下的混淆文件，尝试查看是否可生效（由于时间问题，并没有实测，这交给你们了~）

在这里插入图片描述

解决

方式一

通过 proguardFiles 配置解决（但不一定都生效）

android {
    buildTypes {
        release {
            minifyEnabled true
            zipAlignEnabled true
            shrinkResources true
            //自定义混淆规则
            proguardFiles 'rand_dict_proguard.pro','proguard-rules.pro','my-proguard-rules.pro'
            signingConfig signingConfigs.release
        }
    }
}

方式二

通过把规则写入 aapt_rules.txt 文件解决（但不一定都生效）

或自行测试把规则写入 default_proguard_files 目录下混淆文件尝试解决

通过轮询线程池不断检测 aapt_rules.txt 是否存在，文件存在时把自定义混淆内容追加到文件中（更好的思路应该是在某个 Task doFirst 或 doLast aapt_rules.txt 文件明确生成之后操作，就无需线程池，但我没有找这个 Task 是否存在）

import java.util.HashMap;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;

/**
 * 创建者：村长
 * 时间：2024/2/22 17:05
 */
public class ThreadPool {
    private ScheduledExecutorService mScheduledThreadPool = null;

    private HashMap<String, ScheduledFuture<?>> mScheduledFutureMap = new HashMap<>();

    private ThreadPool() {
        mScheduledThreadPool = Executors.newSingleThreadScheduledExecutor();
    }

    private static final class SingletonCreator {
        private static final ThreadPool INSTANCE = new ThreadPool();
    }

    public static ThreadPool getInstance() {
        return SingletonCreator.INSTANCE;
    }

    public void scheduleWithFixedRun(Runnable runnable, int intervalSeconds, String tag) {
        if (runnable == null) {
            return;
        }

        ScheduledFuture<?> future = mScheduledThreadPool.scheduleWithFixedDelay(runnable, 0, intervalSeconds, TimeUnit.SECONDS);
        mScheduledFutureMap.put(tag, future);
    }

    public ScheduledFuture<?> popScheduledFutureFromMap(String tag) {
        if (tag == null) {
            return null;
        }

        if (mScheduledFutureMap.containsKey(tag)) {
            ScheduledFuture<?> future = mScheduledFutureMap.get(tag);
            mScheduledFutureMap.remove(tag);
            return future;
        }
        return null;
    }
}

void readObsProguard(Project project) {
    File proguardFile = new File(pathJoin(project.getProjectDir().getPath(), "obs-proguard.pro"))
    File methodProguardFile = new File(pathJoin(project.getProjectDir().getPath(), "obs-proguard-method.pro"))

    if (!proguardFile.exists() && !methodProguardFile.exists()) {
        return
    }

    def aapRulePath = PluginFileUtils.adjustPath(mProject.projectDir.getPath(),
            "build",
            "intermediates",
            "aapt_proguard_file",
            "commonRelease",
            "aapt_rules.txt")
    File aaptRuleFile = new File(aapRulePath)

    final String tag = "copyFileToAaptRuleFile"
    ThreadPool.getInstance().scheduleWithFixedRun(new Runnable() {
        boolean copy = false
        int waitedCnt = 0

        @Override
        void run() {
            if (aaptRuleFile.exists() && !copy) {
                copy = true
                copyFileToAaptRuleFile2(aaptRuleFile, proguardFile)
                CommUtils.sleep(1)
                copyFileToAaptRuleFile(aaptRuleFile, methodProguardFile)
                CommUtils.sleep(1)
            }

            if (copy) {
                waitedCnt = waitedCnt + 1
                if (waitedCnt >= 5) {
                    def future = ThreadPool.getInstance().popScheduledFutureFromMap(tag)
                    if (future != null) {
                        future.cancel(true)
                    }
                }
            }
        }
    }, 1, tag)
}

private void copyFileToAaptRuleFile(File targetFile, File sourceFile) {
    if (sourceFile == null || !sourceFile.exists()) {
        return
    }

    def sourceStr = PluginFileUtils.realFile(sourceFile)
    Files.write(Paths.get(targetFile.getPath()), sourceStr.getBytes(), StandardOpenOption.WRITE, StandardOpenOption.APPEND)
}

private void copyFileToAaptRuleFile2(File targetFile, File sourceFile) {
    if (sourceFile == null || !sourceFile.exists()) {
        return
    }

    def lines = Files.readAllLines(sourceFile.toPath())
    StringBuilder sb = new StringBuilder()
    for (String it : lines) {
        if (it.contains("-applymapping") && it.contains("obs-mapping.txt")) {
            File obsMappingFile = new File(mProject.getProjectDir(), ObsFileName.OBS_MAPPING_FILENAME)
            String tmp = it.replace("obs-mapping.txt", obsMappingFile.getAbsolutePath())
            sb.append(tmp).append("\n")
        } else {
            sb.append(it).append("\n")
        }
    }

    Files.write(Paths.get(targetFile.getPath()), sb.toString().getBytes(), StandardOpenOption.WRITE, StandardOpenOption.APPEND)
}

混淆效果回来了~

在这里插入图片描述

其他

1、dependencies add classpath 失效

//AGP4+ 添加插件依赖
this.buildscript.dependencies {
    add("classpath", "com.bytedance.android.byteX:base-plugin:0.3.0")
    add("classpath", "com.bytedance.android.byteX:shrink-r-plugin:0.3.0")
}

AGP7+ 还是老老实实在项目根目录 build.gradle 添加

buildscript {
    dependencies {
        classpath "com.bytedance.android.byteX:base-plugin:0.3.0"
        classpath "com.bytedance.android.byteX:shrink-r-plugin:0.3.0"
    }
}