`
1025250620
  • 浏览: 230446 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

Proguard源码分析(五) ConfigurationParser.keep参数

 
阅读更多

本章节我们绕回来讲Keep参数,也就是ConfigurationParser 这个类。

ConfigurationParser这个类是非常重要的类,如果你已经开始看源码,你会发现所有的类和功能都围着它来转,本章节我们来揭开它的地一层面纱。

else if (ConfigurationConstants.KEEP_OPTION.startsWith(nextWord))
                configuration.keep = parseKeepClassSpecificationArguments(
                        configuration.keep, true, false, false);
            else if (ConfigurationConstants.KEEP_CLASS_MEMBERS_OPTION
                    .startsWith(nextWord))
                configuration.keep = parseKeepClassSpecificationArguments(
                        configuration.keep, false, false, false);
            else if (ConfigurationConstants.KEEP_CLASSES_WITH_MEMBERS_OPTION
                    .startsWith(nextWord))
                configuration.keep = parseKeepClassSpecificationArguments(
                        configuration.keep, false, true, false);
            else if (ConfigurationConstants.KEEP_NAMES_OPTION
                    .startsWith(nextWord))
                configuration.keep = parseKeepClassSpecificationArguments(
                        configuration.keep, true, false, true);
            else if (ConfigurationConstants.KEEP_CLASS_MEMBER_NAMES_OPTION
                    .startsWith(nextWord))
                configuration.keep = parseKeepClassSpecificationArguments(
                        configuration.keep, false, false, true);
            else if (ConfigurationConstants.KEEP_CLASSES_WITH_MEMBER_NAMES_OPTION
                    .startsWith(nextWord))
                configuration.keep = parseKeepClassSpecificationArguments(
                        configuration.keep, false, true, true);

可见,所有以keep打头的参数都是调用的parseKeepClassSpecificationArguments

跟一下这个函数的逻辑

while (true) {
            readNextWord("keyword '" + ConfigurationConstants.CLASS_KEYWORD
                    + "', '" + ClassConstants.EXTERNAL_ACC_INTERFACE
                    + "', or '" + ClassConstants.EXTERNAL_ACC_ENUM + "'",
                    false, true);

            if (!ConfigurationConstants.ARGUMENT_SEPARATOR_KEYWORD
                    .equals(nextWord)) {
                // Not a comma. Stop parsing the keep modifiers.
                break;
            }

            readNextWord("keyword '"
                    + ConfigurationConstants.ALLOW_SHRINKING_SUBOPTION + "', '"
                    + ConfigurationConstants.ALLOW_OPTIMIZATION_SUBOPTION
                    + "', or '"
                    + ConfigurationConstants.ALLOW_OBFUSCATION_SUBOPTION + "'");

            if (ConfigurationConstants.ALLOW_SHRINKING_SUBOPTION
                    .startsWith(nextWord)) {
                allowShrinking = true;
            } else if (ConfigurationConstants.ALLOW_OPTIMIZATION_SUBOPTION
                    .startsWith(nextWord)) {
                allowOptimization = true;
            } else if (ConfigurationConstants.ALLOW_OBFUSCATION_SUBOPTION
                    .startsWith(nextWord)) {
                allowObfuscation = true;
            } else {
                throw new ParseException("Expecting keyword '"
                        + ConfigurationConstants.ALLOW_SHRINKING_SUBOPTION
                        + "', '"
                        + ConfigurationConstants.ALLOW_OPTIMIZATION_SUBOPTION
                        + "', or '"
                        + ConfigurationConstants.ALLOW_OBFUSCATION_SUBOPTION
                        + "' before " + reader.locationDescription());
            }
        }

ConfigurationConstants.ARGUMENT_SEPARATOR_KEYWORD
                    .equals(nextWord)代表以非ConfigurationConstants.ARGUMENT_SEPARATOR_KEYWORD 作为终结符号,也就是说在keep之后可以跟一些参数,这些参数我们来看一下~

    public static final String ALLOW_SHRINKING_SUBOPTION             = "allowshrinking";
    public static final String ALLOW_OPTIMIZATION_SUBOPTION          = "allowoptimization";
    public static final String ALLOW_OBFUSCATION_SUBOPTION           = "allowobfuscation";

也就是说你可以采用下面这种写法:

-keep,allowshrinking,allowoptimization public class *;

我们来看一下这三个参数的影响:

if ((shrinking   && !keepClassSpecification.allowShrinking)    ||
                    (optimizing  && !keepClassSpecification.allowOptimization) ||
                    (obfuscating && !keepClassSpecification.allowObfuscation))
{
                    ClassPoolVisitor classPoolVisitor = createClassPoolVisitor(keepClassSpecification,
                            classVisitor,
                            memberVisitor);
                    multiClassPoolVisitor.addClassPoolVisitor(classPoolVisitor);
}

结果似乎并不是我想的那样,要对这个类不做任何处理,必须保证这三个参数都为true.

在这之后会调用parseClassSpecificationArguments() 来生成一个ClassSpecification 的原始数据

             classSpecification.requiredSetAccessFlags,
             classSpecification.requiredUnsetAccessFlags,
             classSpecification.annotationType,
             classSpecification.className,
             classSpecification.extendsAnnotationType,
             classSpecification.extendsClassName,
             classSpecification.fieldSpecifications,
             classSpecification.methodSpecifications

requiredSetAccessFlags 和requiredUnsetAccessFlags 两个是必须设置的
它是检测是否加载该类的入口之一。他们的值是:

public static final int INTERNAL_ACC_PUBLIC       = 0x0001;
    public static final int INTERNAL_ACC_PRIVATE      = 0x0002;
    public static final int INTERNAL_ACC_PROTECTED    = 0x0004;
    public static final int INTERNAL_ACC_STATIC       = 0x0008;
    public static final int INTERNAL_ACC_FINAL        = 0x0010;
    public static final int INTERNAL_ACC_SUPER        = 0x0020;
    public static final int INTERNAL_ACC_SYNCHRONIZED = 0x0020;
    public static final int INTERNAL_ACC_VOLATILE     = 0x0040;
    public static final int INTERNAL_ACC_TRANSIENT    = 0x0080;
    public static final int INTERNAL_ACC_BRIDGE       = 0x0040;
    public static final int INTERNAL_ACC_VARARGS      = 0x0080;
    public static final int INTERNAL_ACC_NATIVE       = 0x0100;
    public static final int INTERNAL_ACC_INTERFACE    = 0x0200;
    public static final int INTERNAL_ACC_ABSTRACT     = 0x0400;
    public static final int INTERNAL_ACC_STRICT       = 0x0800;
    public static final int INTERNAL_ACC_SYNTHETIC    = 0x1000;
    public static final int INTERNAL_ACC_ANNOTATTION  = 0x2000;
    public static final int INTERNAL_ACC_ENUM         = 0x4000;

parseClassSpecificationArguments() 方法中定义了class的写法

当你的:

if (accessFlag == ClassConstants.INTERNAL_ACC_ANNOTATTION) {
                // Already read the next word.
                readNextWord("annotation type or keyword '"
                        + ClassConstants.EXTERNAL_ACC_INTERFACE + "'", false,
                        false);

                // Is the next word actually an annotation type?
                if (!nextWord.equals(ClassConstants.EXTERNAL_ACC_INTERFACE)
                        && !nextWord.equals(ClassConstants.EXTERNAL_ACC_ENUM)
                        && !nextWord.equals(ConfigurationConstants.CLASS_KEYWORD)) {
                    // Parse the annotation type.
                    annotationType = ListUtil.commaSeparatedString(
                            parseCommaSeparatedList("annotation type", false,
                                    false, false, false, true, false, false,
                                    true, null), false);

                    // Continue parsing the access modifier that we just read
                    // in the next cycle.
                    continue;
                }

                // Otherwise just handle the annotation modifier.
            }

accessFlag 为注解符号的时候,大致写法是这样的:

-keep @com.test.TestAnno
public class * {
*;
}
-keepclassmembers class * {
    @com.test.TestAnno <methods>;
}

也就是说完全按照java的语法标准来实现。

解析完注解之后直到解析class interface enum 这些关键字

if (strippedWord.equals(ClassConstants.EXTERNAL_ACC_INTERFACE)
                    || strippedWord.equals(ClassConstants.EXTERNAL_ACC_ENUM)
                    || strippedWord.equals(ConfigurationConstants.CLASS_KEYWORD)) {
                // The interface or enum keyword. Stop parsing the class flags.
                break;
            }

得到externalClassName

之后调用

if (!configurationEnd()) {
            // Parse 'implements ...' or 'extends ...' part, if any.
            if (ConfigurationConstants.IMPLEMENTS_KEYWORD.equals(nextWord)
                    || ConfigurationConstants.EXTENDS_KEYWORD.equals(nextWord)) {
                readNextWord("class name or interface name", false, true);
                // Parse the annotation type, if any.
                LOG.log("start ");
                if (ConfigurationConstants.ANNOTATION_KEYWORD.equals(nextWord)) {
                    extendsAnnotationType = ListUtil.commaSeparatedString(
                            parseCommaSeparatedList("annotation type", true,
                                    false, false, false, true, false, false,
                                    true, null), false);
                }

                String externalExtendsClassName = ListUtil
                        .commaSeparatedString(
                                parseCommaSeparatedList(
                                        "class name or interface name", false,
                                        false, false, false, true, false,
                                        false, false, null), false);
                extendsClassName = ConfigurationConstants.ANY_CLASS_KEYWORD
                        .equals(externalExtendsClassName) ? null : ClassUtil
                        .internalClassName(externalExtendsClassName);
            }
        }

configurationEnd() 的结束条件是-和@,那么括号里面的又是干什么用的呢?

这是一种语法结构大致结构是这个样子的:

-keep public class * extends @com.test.TestAnno * #here

{
*;
}

解析到here这个位置,代表保持这个这个标注注解类的子类

最后将定义个类的元数据:

ClassSpecification classSpecification = new ClassSpecification(
                lastComments, requiredSetClassAccessFlags,
                requiredUnsetClassAccessFlags, annotationType, className,
                extendsAnnotationType, extendsClassName);

进行下一次的匹配,

if (!configurationEnd()) {
            // Check the class member opening part.
            if (!ConfigurationConstants.OPEN_KEYWORD.equals(nextWord)) {
                throw new ParseException("Expecting opening '"
                        + ConfigurationConstants.OPEN_KEYWORD + "' at "
                        + reader.locationDescription());
            }

            // Parse all class members.
            while (true) {
                readNextWord("class member description" + " or closing '"
                        + ConfigurationConstants.CLOSE_KEYWORD + "'", false,
                        true);

                if (nextWord.equals(ConfigurationConstants.CLOSE_KEYWORD)) {
                    // The closing brace. Stop parsing the class members.
                    readNextWord();

                    break;
                }

                parseMemberSpecificationArguments(externalClassName,
                        classSpecification);
            }
        }

这个匹配必须是非结束符号也就是不是 - 或者@

这就说明proguard的语法支持

-keep public class ...或者

-keep public class ...{...}

我们来看下第二种它是怎么做的:

if (nextWord.equals(ConfigurationConstants.CLOSE_KEYWORD)) {
                    // The closing brace. Stop parsing the class members.
                    readNextWord();

                    break;
 }

当读入的字符不为}的时候将继续读入

解析成员通过方法parseMemberSpecificationArguments 来生成

这个方法跟类分析程序非常相似多了一些参数的条件,比如static native transient volatile final 这类用来形容方法或者变量的属性当然在这之前有过注解验证,也就是说支持:

{

@anno

static test

}

这种写法

接下来会通过

if (    ConfigurationConstants.ANY_CLASS_MEMBER_KEYWORD.equals(nextWord)
                || ConfigurationConstants.ANY_FIELD_KEYWORD.equals(nextWord)
                || ConfigurationConstants.ANY_METHOD_KEYWORD.equals(nextWord))

三个方法来对三种通配符号做处理,这三种通配符号分别是:*,<fields>,<methods>

匹配完成之后会生成叫做MemberSpecification 的对象来倒入到class的配置中

*可以看作是后面两个东西的集合,所以在proguard处理的时候会同时调用

classSpecification.addField(new MemberSpecification(
                        requiredSetMemberAccessFlags,
                        requiredUnsetMemberAccessFlags, annotationType, null,
                        null));
                classSpecification.addMethod(new MemberSpecification(
                        requiredSetMemberAccessFlags,
                        requiredUnsetMemberAccessFlags, annotationType, null,
                        null));

这两个方法。

如果你不采用通配符号的方式来写的话,也就是说你默认会给出一个精确表达式,也有可能是一个模式匹配的表达式。我们来看一下Proguard对它的处理流程:

ConfigurationConstants.OPEN_ARGUMENTS_KEYWORD.equals(name)

proguard会先检测是否是携带参数:

这里它对构造器方法和一些错误的可能做的屏蔽处理:

if (!(type.equals(ClassConstants.INTERNAL_METHOD_NAME_INIT)
                        || type.equals(externalClassName) || type
                            .equals(ClassUtil
                                    .externalShortClassName(externalClassName)))) {
                    throw new ParseException("Expecting type and name "
                            + "instead of just '" + type + "' before "
                            + reader.locationDescription());
                }

 原理很简单,由于构造器是没有返回值的,所以你之前期望得到的返回类型应该就是构造器的方法名<init>

if (ConfigurationConstants.SEPARATOR_KEYWORD.equals(nextWord)) {
                // It's a field.
                checkFieldAccessFlags(requiredSetMemberAccessFlags,
                        requiredUnsetMemberAccessFlags);

                // We already have a field descriptor.
                String descriptor = ClassUtil.internalType(type);

                // Add the field.
                classSpecification.addField(new MemberSpecification(
                        requiredSetMemberAccessFlags,
                        requiredUnsetMemberAccessFlags, annotationType, name,
                        descriptor));
            } else if (ConfigurationConstants.OPEN_ARGUMENTS_KEYWORD
                    .equals(nextWord)) {
                // It's a method.
                checkMethodAccessFlags(requiredSetMemberAccessFlags,
                        requiredUnsetMemberAccessFlags);

                // Parse the method arguments.
                String descriptor = ClassUtil.internalMethodDescriptor(
                        type,
                        parseCommaSeparatedList("argument", true, true, true,
                                false, true, false, false, false, null));

                if (!ConfigurationConstants.CLOSE_ARGUMENTS_KEYWORD
                        .equals(nextWord)) {
                    throw new ParseException("Expecting separating '"
                            + ConfigurationConstants.ARGUMENT_SEPARATOR_KEYWORD
                            + "' or closing '"
                            + ConfigurationConstants.CLOSE_ARGUMENTS_KEYWORD
                            + "' before " + reader.locationDescription());
                }

                // Read the separator after the closing parenthesis.
                readNextWord("separator '"
                        + ConfigurationConstants.SEPARATOR_KEYWORD + "'");

                if (!ConfigurationConstants.SEPARATOR_KEYWORD.equals(nextWord)) {
                    throw new ParseException("Expecting separator '"
                            + ConfigurationConstants.SEPARATOR_KEYWORD
                            + "' before " + reader.locationDescription());
                }

                // Add the method.
                classSpecification.addMethod(new MemberSpecification(
                        requiredSetMemberAccessFlags,
                        requiredUnsetMemberAccessFlags, annotationType, name,
                        descriptor));
            } else {
                // It doesn't look like a field or a method.
                throw new ParseException("Expecting opening '"
                        + ConfigurationConstants.OPEN_ARGUMENTS_KEYWORD
                        + "' or separator '"
                        + ConfigurationConstants.SEPARATOR_KEYWORD
                        + "' before " + reader.locationDescription());
            }

这段代码也非常好理解,对于只有名字然后直接跟分号的话,它认为是成员变量参数,如果是(则是方法,对于方法来说最重要的就是方法的签名,我们来关注一下方法是如何获得签名的.

方法签名是通过String descriptor = ClassUtil.internalMethodDescriptor(
                        type,
                        parseCommaSeparatedList("argument", true, true, true,
                                false, true, false, false, false, null));

来获得,其中type就是你的返回值,我们不说详细过程,只注重一些细节的结果parseCommaSeparatedList的参数列表最后得到相应的方法签名例如:

(ILcom/test/Base;)V

第一个I代表的是INT ,如果你想关注这些,不妨看一下jvm汇编一类的知识,其实c++的方法签名方式也大同小异。所以如果你之前从事过这方面的话,应该是不会陌生的。

 

 

 

 

 

 

 

 

分享到:
评论

相关推荐

    android_proguard-base-6.0.3.zip

    proguard6.0.3混淆包 替换Jar包以后使 混淆的类名方法名变成空白 直接 替换 5.3.3版本的 混淆jar包 Mac 路径为 Contents/gradle/m2repository/net/sf/proguard/proguard-base Win gradle/m2repository/...

    proguard4.5beta4.tar.zip

    ProGuard 是一款强大的Java字节码混淆、优化、压缩和预校验工具,主要用于减少应用程序的大小,提高安全性和性能。在Android开发中,它被广泛用于混淆代码,以防止反编译和保护知识产权。ProGuard 4.5beta4是该工具...

    proguard-7.2.2.tar.gz

    在使用ProGuard时,我们需要创建一个名为`proguard.cfg`或`proguard-project.txt`的配置文件,定义混淆规则、保留某些关键类或方法等。例如: ```properties -keep class com.example.** { *; } # 保留com.example...

    如何混淆Android项目代码(ProGuard)防止反编译.rar

    由于Android应用主要使用Java语言编写,并且APK文件本质上是可被解压的ZIP文件,因此容易受到反编译工具的攻击,暴露源码,甚至可能导致敏感信息泄露。为了对抗这种威胁,开发者通常会采用代码混淆技术,其中...

    proguard-7.0.0.tar.gz

    **ProGuard**是一款广泛使用的Java代码混淆、优化和压缩工具,尤其在Android开发中扮演着重要角色。ProGuard 7.0.0是该工具的一个官方版本,它提供了最新的功能和改进,确保开发者能够对他们的应用程序进行高效且...

    proguard最新版本proguard6.0.13

    使用ProGuard 6.0.13时,开发者可以通过配置文件(proguard.cfg或proguard-rules.pro)定制混淆规则,例如保留特定的类、方法和注解,以确保关键代码不受混淆影响。 在实际项目中,为了充分利用ProGuard,开发者...

    proguard-base-5.2.1.jar

    附件为修改过的proguard5.2.1版本Jar,修改内容为: proguard\src\proguard\classfile\ClassConstants.java 修改ATTR_StackMapTable的值,将原来的StackMapTable改为dummy.

    proguard(汉化版).rar

    ProGuard的配置文件`proguard.cfg`或`proguard-project.txt`包含了混淆规则,如保留特定类和方法不被混淆,或者指定混淆策略。例如,为了保持调试信息,可以使用`-keepattributes SourceFile,LineNumberTable`;为了...

    ProGuard工具包,Java代码混淆

    ProGuard的配置文件通常为`proguard.cfg`或`proguard-project.txt`,其中包含了一系列的规则和指令。常见的配置选项包括: - `-keep`:指定不进行混淆的类或方法。 - `-optimizations`:定义要执行的优化步骤。 - `...

    一步步教你使用Proguard混淆Java源代码 .docx

    首先,需要从 http://proguard.sourceforge.net/ 官方网站下载 Proguard 工具。 2. 准备 Jar 包 准备好要混淆的 Jar 包,例如 test.jar。 3. 解压 Proguard 解压下载的 Proguard 工具,执行 bin 目录下的 ...

    apk自定义混淆字典集合.zip

    任选其中一个字典进行自定混淆配置即可,以proguard-1il.txt字典为例,在proguard-rules.pro文件中添加以下代码: -obfuscationdictionary ../proguard-1il.txt -packageobfuscationdictionary ../proguard-1il.txt...

    解决proguard混淆报错-Proguard5.1

    proguard混淆jar包提示错误:Unknown verification type [*] in stack map frame 解决方案:找到proguard源码中proguard\src\proguard\classfile\ClassConstants.java类,然后...资源已经处理(源码+proguard.jar包)。

    android自动打包方法(ant+proguard+签名)知识.pdf

    &lt;property name="proguard.home" value="D:/software/j2me/proguard4.5.1/proguard4.5.1"/&gt; &lt;!-- 设置Android SDK路径 --&gt; &lt;property name="sdk.dir" value="E:\dev\android-sdk-windows"/&gt; &lt;!-- 签名相关设置 -...

    proguard-project

    proguard-project.txt 解决Gson引入而混淆不能通讯问题

    Proguard4.2.zip(java编码混淆器)

    try processing the jar itself: &lt;br&gt; cd examples java -jar ../lib/proguard.jar @proguard.pro &lt;br&gt;The resulting proguard_out.jar contains the same application, but it's a lot smaller!...

    proguard4.5beta3.zip

    在使用ProGuard时,首先你需要配置`proguard.cfg`或`proguard-project.txt`文件,这是ProGuard的工作指令集,定义了哪些类、方法和变量需要保留,哪些可以删除或混淆。混淆过程会将公共类和方法名转换为短而无意义的...

    proguard6.2.2.zip

    proguard6.2.2(201912月8日版本)最新版,解决java版本太高无法匹配的问题,解压后替换AndriodSDK\sdk\tools\proguard目录即可,亲测可用.注意不支持中文目录

    proguard 4.6版lib目录下的3个文件

    在给定的标题和描述中,我们关注的是ProGuard 4.6版本的lib目录下的三个关键文件:`proguard.jar`, `proguardgui.jar`, 和 `retrace.jar`。 1. **proguard.jar**:这是ProGuard的核心库文件,包含了混淆、优化、...

    proguard-v4.11.rar

    在Android SDK中,ProGuard是默认集成的,开发者可以通过修改`proguard.cfg`或`proguard-project.txt`配置文件来定制混淆规则。 ProGuard 4.11版本是一个重要的里程碑,因为它在当时引入了一些改进和修复,比如更好...

    proguard6.2.2.zip/proguard6.2.2.rar/proguard6.2.2/proguard

    `bin`目录下包含了可执行文件,如`proguard.jar`和相关的脚本,使得用户可以在命令行环境中运行ProGuard,进行代码混淆、优化和压缩等操作。 `core`目录则包含了ProGuard的核心库,实现了混淆、优化和压缩等功能。...

Global site tag (gtag.js) - Google Analytics