The integerEncryptionExclude Statement
(Note, generally speaking, any reference below to an integer constant should be taken to mean a reference to a byte, char, short or int constant.
See Integer Constant Encryption tutorial for more detail.)
The ZKM Script integerEncryptionExclude statement excludes specified eligible integer constants from being encrypted
by the Zelix KlassMaster™ obfuscate statement.
If an exclusion parameter is at the class level (i.e. a classExcludeParameter) then all the eligible integer constants within the specified class or classes
will be excluded from Integer encryption.
If an exclusion parameter is at the field level (i.e. a fieldExcludeParameter) then the initial values
of matching integer fields will not be Integer encrypted.
If an exclusion parameter is at the method level (i.e. a methodExcludeParameter) then the references to integer constants within the matching methods will not be Integer encrypted.
There is a subtle distinction here. If you exclude at the class level then you are excluding all the integer literals
of that class from Integer encryption.
So "integerEncryptionExclude *.*" is equivalent to "integerEncryptionExclude *.* * and *.* *(*)".
The statement has no impact if the obfuscate statement's encryptIntegerConstants parameter is set to none.
Similarly, a parameter that specifies a non-integer field or an integer field that is not initialized has no impact.
Successive integerEncryptionExclude statements have a cumulative effect. Once an exclusion has been set
the only way to remove it is with a resetIntegerEncryptionExclusions
statement.
The remainder of this page is organized into the following sections.
integerEncryptionExclude statement parameters may be loosely categorized into the following groups
Put informally (with mandatory components in bold), the syntax is:
<classAnnotations> <classModifiers> "<archiveQualifier>"!<packageQualifiers>.<className> <containingClause> <extendsClause> <implementsClause>;
For all the integer constants in a class to be excluded, all of the following must be true:
- Its annotations must match any specified annotations.
- The class's modifiers (e.g.
public final) must match all parameter modifiers.
So if the parameters are public abstract !interface then the class must be
public, abstract and NOT an interface to be excluded.
- If the parameter has an archive qualifier then the class must be contained in an archive which matches that archive qualifier.
- The class's package qualifiers must match any specified package exclude parameter component. If there is no
package exclude parameter component then the class must be in the default package.
- The class's unqualified name must match the parameter's class name specifier.
- If the parameter has a containing clause then the class must contain members which match the specified class
- If the parameter has an extends clause then the class must be a subclass of the specified class
- If the parameter has an implements clause then the class must directly or indirectly implement all of the specified interfaces
integerEncryptionExclude
pack2.Class1 and //Exclude all integer constants in class pack2.Class1 from encryption
*.* and //Exclude all integer constants in all classes from encryption
//Exclude all integer constants in all classes contained in a JAR file with a name matching "MyJar*.jar"
"MyJar*.jar"!*.* and
//Exclude all integer constants in all classes annotated which an annotation matching *.MyAnnotation0
@*.MyAnnotation0 *.*;
Put informally (with mandatory components in bold), the syntax is:
<classAnnotations> <classModifiers> "<archiveQualifier>"!<packageQualifiers>.<className> <extendsClause> <implementsClause>
<fieldAnnotations> <fieldModifiers> <fieldType> <fieldName>;
For the intitialization integer constant of a field to be excluded, all of the following must be true:
- The field's containing class must match any class exclude parameter component (see Class exclude parameters).
- The field's annotations must match any specified field level annotations.
- The field's modifiers (e.g.
public volatile) must match all parameter field modifiers.
So if the parameters are public static !transient then the field must be
public, static and NOT transient to be excluded.
- The field's type (e.g. int[] or java.lang.String) must match the parameter field type if it exists.
- The field's name must match the parameter field name specifier.
integerEncryptionExclude
*.* public static * and //Exclude integer constants that initialize
//public static fields in any class from encryption
pack2.Class1 * and //Exclude integer constants that initialize any fields
//in pack2.Class1 from encryption
//Exclude integer constants that initialize any fields annotated with a class matching *.MyAnnotation0.
*.* @*.MyAnnotation0 *;
Put informally (with mandatory components in bold), the syntax is:
<classAnnotations> <classModifiers> "<archiveQualifier>"!<packageQualifiers>.<className> <extendsClause> <implementsClause>
<methodAnnotations> <methodModifiers> <methodName> (<argumentTypes>) <throwsClause>;
For an integer constant referenced in a method to be excluded, all of the following must be true:
- The method's containing class must match any class exclude parameter component (see Class exclude parameters).
- The method's annotations must match any specified method level annotations.
- The method's modifiers (e.g.
public synchronized) must match all parameter method modifiers.
So if the parameters are public static !synchronized then the method must be
public, static and NOT synchronized to be excluded.
- Its name must match the parameter method name specification.
The special name
<init> matches all constructors and the special name <clinit>
matches all static initializers.
- Its argument types (e.g.
int[], java.lang.String) must match the parameter argument types if they exist.
(A single parameter argument type of "*" matches any method argument types including no arguments.)
If the parameter has no argument type then the method must take no arguments.
- Its throws clause must contain all the classes specified in the integerEncryptionExclude parameter's throw clause.
So, if the integerEncryptionExclude parameter's throws clause is
throws java.io.IOException then the method
must throw java.io.IOException or one of its subclasses to be excluded.
integerEncryptionExclude
*.* public static *(*) and //Exclude integer constants referenced in any
//public static method in any class from encryption
pack2.Class1 *(*); //Exclude integer constants referenced in any method
//in pack2.Class1 from encryption
"integerEncryptionExclude" excludeParameter ("and" excludeParameter)* ";"
annotationSpecifier ::= ("@" [packageExcludeParameter] nameSpecifier) | annotationSpecifierAndList
annotationSpecifierAndList ::= ["!"] "(" annotationSpecifierOrList ("&&" annotationSpecifierOrList)* ")"
annotationSpecifierOrList ::= annotationSpecifier ("||" annotationSpecifier)*
classExcludeParameter ::=
[annotationSpecifier] [["!"] "public" | "package"]
[["!"] "abstract"] [["!"] "final"] [["!"] "interface"] [["!"] "synthetic"] [["!"] "enum"] [["!"] "annotation"]
["\"" archiveQualifier "\"" "!"] [packageExcludeParameter ["."]] nameSpecifier [containingClause]
[extendsClause] [implementsClause]
containingClause ::= "containing" "{" "memberAndList" "}"
excludeParameter ::=
|
classExcludeParameter
|
|
|
|
|
fieldExcludeParameter
|
|
|
|
|
methodExcludeParameter
|
|
extendsClause ::= "extends" [annotationSpecifier] wildcardClassName
fieldExcludeParameter ::=
classExcludeParameter [annotationSpecifier] [["!"] "public" | "protected"| "package"| "private"]
[["!"] "static"] [["!"] "final"] [["!"] "transient"] [["!"] "volatile"] [["!"] "synthetic"] [["!"] "enum"]
[type] nameSpecifier
methodExcludeParameter ::=
classExcludeParameter [annotationSpecifier] [["!"] "public" | "protected"| "package"| "private"]
[["!"] "abstract"] [["!"] "static"] [["!"] "final"] [["!"] "native"] [["!"] "synchronized"] [["!"] "synthetic"] [["!"] "bridge"]
(nameSpecifier | "<init>" | "<clinit>") "(" [ "*" | (parameter ("," parameter)*)] ")"
["throws" wildcardClassName]
fullyQualifiedClassName ::= name ("." name)*
implementsClause ::= "implements" [annotationSpecifier] wildcardClassName ("," [annotationSpecifier] wildcardClassName)*
memberAndList ::= ["!"] "(" memberOrList ("&&" memberOrList)* ")"
memberOrList ::= memberSpecifier ("||" memberSpecifier)*
memberSpecifier ::= fieldExcludeParameter | methodExcludeParameter
nameAndList ::= ["!"] "(" nameOrList ("&&" nameOrList)* ")"
name ::= (["0"-"9","a"-"z","A"-"Z","$","_"])+
i.e. a Java identifer (e.g. a package, class, field or method name) with no wildcards allowed
nameAndList ::= ["!"] "(" nameOrList ("&&" nameOrList)* ")"
nameOrList ::= nameSpecifier ("||" nameSpecifier)*
nameSpecifier ::= wildcardName | nameAndList
packageExcludeParameter ::= packageName | packageNameAndList
packageName ::= wildcardName ("." wildcardName)* "."
NB: the final "." is part of the package name
packageNameAndList ::= ["!"] "(" packageNameOrList ("&&" packageNameOrList)* ")"
packageNameOrList ::= packageExcludeParameter ("||" packageExcludeParameter)*
parameter ::= [annotationSpecifier] ("*" | "?" | type)
type ::=
("byte" | "short" | "char" | "int" | "long" | "float" | "double"| "boolean" |
fullyQualifiedClassName) ("[]")*
wildcardClassName ::= wildcardName ("." wildcardName)*
wildcardName ::= (["*","0"-"9","a"-"z","A"-"Z","$","_"])+
i.e. a Java identifer (e.g. a package, class, field or method name) with the "*" wildcard allowed
|
