本章节我们绕回来讲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++的方法签名方式也大同小异。所以如果你之前从事过这方面的话,应该是不会陌生的。
相关推荐
proguard6.0.3混淆包 替换Jar包以后使 混淆的类名方法名变成空白 直接 替换 5.3.3版本的 混淆jar包 Mac 路径为 Contents/gradle/m2repository/net/sf/proguard/proguard-base Win gradle/m2repository/...
ProGuard 是一款强大的Java字节码混淆、优化、压缩和预校验工具，主要用于减少应用程序的大小，提高安全性和性能。在Android开发中，它被广泛用于混淆代码，以防止反编译和保护知识产权。ProGuard 4.5beta4是该工具...
在使用ProGuard时，我们需要创建一个名为`proguard.cfg`或`proguard-project.txt`的配置文件，定义混淆规则、保留某些关键类或方法等。例如： ```properties -keep class com.example.** { *; } # 保留com.example...
由于Android应用主要使用Java语言编写，并且APK文件本质上是可被解压的ZIP文件，因此容易受到反编译工具的攻击，暴露源码，甚至可能导致敏感信息泄露。为了对抗这种威胁，开发者通常会采用代码混淆技术，其中...
**ProGuard**是一款广泛使用的Java代码混淆、优化和压缩工具，尤其在Android开发中扮演着重要角色。ProGuard 7.0.0是该工具的一个官方版本，它提供了最新的功能和改进，确保开发者能够对他们的应用程序进行高效且...
使用ProGuard 6.0.13时，开发者可以通过配置文件（proguard.cfg或proguard-rules.pro）定制混淆规则，例如保留特定的类、方法和注解，以确保关键代码不受混淆影响。 在实际项目中，为了充分利用ProGuard，开发者...
附件为修改过的proguard5.2.1版本Jar,修改内容为： proguard\src\proguard\classfile\ClassConstants.java 修改ATTR_StackMapTable的值，将原来的StackMapTable改为dummy.
ProGuard的配置文件`proguard.cfg`或`proguard-project.txt`包含了混淆规则，如保留特定类和方法不被混淆，或者指定混淆策略。例如，为了保持调试信息，可以使用`-keepattributes SourceFile,LineNumberTable`；为了...
首先，需要从 http://proguard.sourceforge.net/ 官方网站下载 Proguard 工具。 2. 准备 Jar 包 准备好要混淆的 Jar 包，例如 test.jar。 3. 解压 Proguard 解压下载的 Proguard 工具，执行 bin 目录下的 ...
任选其中一个字典进行自定混淆配置即可，以proguard-1il.txt字典为例，在proguard-rules.pro文件中添加以下代码: -obfuscationdictionary ../proguard-1il.txt -packageobfuscationdictionary ../proguard-1il.txt...
proguard混淆jar包提示错误：Unknown verification type [*] in stack map frame 解决方案：找到proguard源码中proguard\src\proguard\classfile\ClassConstants.java类，然后...资源已经处理（源码+proguard.jar包)。
<property name="proguard.home" value="D:/software/j2me/proguard4.5.1/proguard4.5.1"/> <!-- 设置Android SDK路径 --> <property name="sdk.dir" value="E:\dev\android-sdk-windows"/> <!-- 签名相关设置 -...
proguard-project.txt 解决Gson引入而混淆不能通讯问题
ProGuard的配置文件通常为`proguard.cfg`或`proguard-project.txt`，其中包含了一系列的规则和指令。常见的配置选项包括： - `-keep`：指定不进行混淆的类或方法。 - `-optimizations`：定义要执行的优化步骤。 - `...
try processing the jar itself: <br> cd examples java -jar ../lib/proguard.jar @proguard.pro <br>The resulting proguard_out.jar contains the same application, but it's a lot smaller!...
在使用ProGuard时，首先你需要配置`proguard.cfg`或`proguard-project.txt`文件，这是ProGuard的工作指令集，定义了哪些类、方法和变量需要保留，哪些可以删除或混淆。混淆过程会将公共类和方法名转换为短而无意义的...
proguard6.2.2(201912月8日版本)最新版,解决java版本太高无法匹配的问题,解压后替换AndriodSDK\sdk\tools\proguard目录即可,亲测可用.注意不支持中文目录
在给定的标题和描述中，我们关注的是ProGuard 4.6版本的lib目录下的三个关键文件：`proguard.jar`, `proguardgui.jar`, 和 `retrace.jar`。 1. **proguard.jar**：这是ProGuard的核心库文件，包含了混淆、优化、...
在Android SDK中，ProGuard是默认集成的，开发者可以通过修改`proguard.cfg`或`proguard-project.txt`配置文件来定制混淆规则。 ProGuard 4.11版本是一个重要的里程碑，因为它在当时引入了一些改进和修复，比如更好...
`bin`目录下包含了可执行文件，如`proguard.jar`和相关的脚本，使得用户可以在命令行环境中运行ProGuard，进行代码混淆、优化和压缩等操作。 `core`目录则包含了ProGuard的核心库，实现了混淆、优化和压缩等功能。...