bb-tools/proguard4.7/src/proguard/obfuscate/ClassObfuscator.java
/*
* ProGuard -- shrinking, optimization, obfuscation, and preverification
* of Java bytecode.
*
* Copyright (c) 2002-2011 Eric Lafortune (eric@graphics.cornell.edu)
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the Free
* Software Foundation; either version 2 of the License, or (at your option)
* any later version.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
package proguard.obfuscate;
import proguard.classfile.*;
import proguard.classfile.attribute.*;
import proguard.classfile.attribute.visitor.*;
import proguard.classfile.constant.ClassConstant;
import proguard.classfile.constant.visitor.ConstantVisitor;
import proguard.classfile.util.*;
import proguard.classfile.visitor.ClassVisitor;
import proguard.util.*;
import java.util.*;
/**
* This <code>ClassVisitor</code> comes up with obfuscated names for the
* classes it visits, and for their class members. The actual renaming is
* done afterward.
*
* @see ClassRenamer
*
* @author Eric Lafortune
*/
public class ClassObfuscator
extends SimplifiedVisitor
implements ClassVisitor,
AttributeVisitor,
InnerClassesInfoVisitor,
ConstantVisitor
{
private final DictionaryNameFactory classNameFactory;
private final DictionaryNameFactory packageNameFactory;
private final boolean useMixedCaseClassNames;
private final StringMatcher keepPackageNamesMatcher;
private final String flattenPackageHierarchy;
private final String repackageClasses;
private final boolean allowAccessModification;
private final Set classNamesToAvoid = new HashSet();
// Map: [package prefix - new package prefix]
private final Map packagePrefixMap = new HashMap();
// Map: [package prefix - package name factory]
private final Map packagePrefixPackageNameFactoryMap = new HashMap();
// Map: [package prefix - numeric class name factory]
private final Map packagePrefixClassNameFactoryMap = new HashMap();
// Map: [package prefix - numeric class name factory]
private final Map packagePrefixNumericClassNameFactoryMap = new HashMap();
// Field acting as temporary variables and as return values for names
// of outer classes and types of inner classes.
private String newClassName;
private boolean numericClassName;
/**
* Creates a new ClassObfuscator.
* @param programClassPool the class pool in which class names
* have to be unique.
* @param classNameFactory the optional class obfuscation dictionary.
* @param packageNameFactory the optional package obfuscation
* dictionary.
* @param useMixedCaseClassNames specifies whether obfuscated packages and
* classes can get mixed-case names.
* @param keepPackageNames the optional filter for which matching
* package names are kept.
* @param flattenPackageHierarchy the base package if the obfuscated package
* hierarchy is to be flattened.
* @param repackageClasses the base package if the obfuscated classes
* are to be repackaged.
* @param allowAccessModification specifies whether obfuscated classes can
* be freely moved between packages.
*/
public ClassObfuscator(ClassPool programClassPool,
DictionaryNameFactory classNameFactory,
DictionaryNameFactory packageNameFactory,
boolean useMixedCaseClassNames,
List keepPackageNames,
String flattenPackageHierarchy,
String repackageClasses,
boolean allowAccessModification)
{
this.classNameFactory = classNameFactory;
this.packageNameFactory = packageNameFactory;
// First append the package separator if necessary.
if (flattenPackageHierarchy != null &&
flattenPackageHierarchy.length() > 0)
{
flattenPackageHierarchy += ClassConstants.INTERNAL_PACKAGE_SEPARATOR;
}
// First append the package separator if necessary.
if (repackageClasses != null &&
repackageClasses.length() > 0)
{
repackageClasses += ClassConstants.INTERNAL_PACKAGE_SEPARATOR;
}
this.useMixedCaseClassNames = useMixedCaseClassNames;
this.keepPackageNamesMatcher = keepPackageNames == null ? null :
new ListParser(new FileNameParser()).parse(keepPackageNames);
this.flattenPackageHierarchy = flattenPackageHierarchy;
this.repackageClasses = repackageClasses;
this.allowAccessModification = allowAccessModification;
// Map the root package onto the root package.
packagePrefixMap.put("", "");
// Collect all names that have been taken already.
programClassPool.classesAccept(new MyKeepCollector());
}
// Implementations for ClassVisitor.
public void visitProgramClass(ProgramClass programClass)
{
// Does this class still need a new name?
newClassName = newClassName(programClass);
if (newClassName == null)
{
// Make sure the outer class has a name, if it exists. The name will
// be stored as the new class name, as a side effect, so we'll be
// able to use it as a prefix.
programClass.attributesAccept(this);
// Figure out a package prefix. The package prefix may actually be
// the an outer class prefix, if any, or it may be the fixed base
// package, if classes are to be repackaged.
String newPackagePrefix = newClassName != null ?
newClassName + ClassConstants.INTERNAL_INNER_CLASS_SEPARATOR :
newPackagePrefix(ClassUtil.internalPackagePrefix(programClass.getName()));
// Come up with a new class name, numeric or ordinary.
newClassName = newClassName != null && numericClassName ?
generateUniqueNumericClassName(newPackagePrefix) :
generateUniqueClassName(newPackagePrefix);
setNewClassName(programClass, newClassName);
}
}
// Implementations for AttributeVisitor.
public void visitAnyAttribute(Clazz clazz, Attribute attribute) {}
public void visitInnerClassesAttribute(Clazz clazz, InnerClassesAttribute innerClassesAttribute)
{
// Make sure the outer classes have a name, if they exist.
innerClassesAttribute.innerClassEntriesAccept(clazz, this);
}
public void visitEnclosingMethodAttribute(Clazz clazz, EnclosingMethodAttribute enclosingMethodAttribute)
{
// Make sure the enclosing class has a name.
enclosingMethodAttribute.referencedClassAccept(this);
String innerClassName = clazz.getName();
String outerClassName = clazz.getClassName(enclosingMethodAttribute.u2classIndex);
numericClassName = isNumericClassName(innerClassName,
outerClassName);
}
// Implementations for InnerClassesInfoVisitor.
public void visitInnerClassesInfo(Clazz clazz, InnerClassesInfo innerClassesInfo)
{
// Make sure the outer class has a name, if it exists.
int innerClassIndex = innerClassesInfo.u2innerClassIndex;
int outerClassIndex = innerClassesInfo.u2outerClassIndex;
if (innerClassIndex != 0 &&
outerClassIndex != 0)
{
String innerClassName = clazz.getClassName(innerClassIndex);
if (innerClassName.equals(clazz.getName()))
{
clazz.constantPoolEntryAccept(outerClassIndex, this);
String outerClassName = clazz.getClassName(outerClassIndex);
numericClassName = isNumericClassName(innerClassName,
outerClassName);
}
}
}
/**
* Returns whether the given inner class name is a numeric name.
*/
private boolean isNumericClassName(String innerClassName,
String outerClassName)
{
int innerClassNameStart = outerClassName.length() + 1;
int innerClassNameLength = innerClassName.length();
if (innerClassNameStart >= innerClassNameLength)
{
return false;
}
for (int index = innerClassNameStart; index < innerClassNameLength; index++)
{
if (!Character.isDigit(innerClassName.charAt(index)))
{
return false;
}
}
return true;
}
// Implementations for ConstantVisitor.
public void visitClassConstant(Clazz clazz, ClassConstant classConstant)
{
// Make sure the outer class has a name.
classConstant.referencedClassAccept(this);
}
/**
* This ClassVisitor collects package names and class names that have to
* be kept.
*/
private class MyKeepCollector implements ClassVisitor
{
public void visitProgramClass(ProgramClass programClass)
{
// Does the class already have a new name?
String newClassName = newClassName(programClass);
if (newClassName != null)
{
// Remember not to use this name.
classNamesToAvoid.add(mixedCaseClassName(newClassName));
// Are we not aggressively repackaging all obfuscated classes?
if (repackageClasses == null ||
!allowAccessModification)
{
String className = programClass.getName();
// Keep the package name for all other classes in the same
// package. Do this recursively if we're not doing any
// repackaging.
mapPackageName(className,
newClassName,
repackageClasses == null &&
flattenPackageHierarchy == null);
}
}
}
public void visitLibraryClass(LibraryClass libraryClass)
{
}
/**
* Makes sure the package name of the given class will always be mapped
* consistently with its new name.
*/
private void mapPackageName(String className,
String newClassName,
boolean recursively)
{
String packagePrefix = ClassUtil.internalPackagePrefix(className);
String newPackagePrefix = ClassUtil.internalPackagePrefix(newClassName);
// Put the mapping of this package prefix, and possibly of its
// entire hierarchy, into the package prefix map.
do
{
packagePrefixMap.put(packagePrefix, newPackagePrefix);
if (!recursively)
{
break;
}
packagePrefix = ClassUtil.internalPackagePrefix(packagePrefix);
newPackagePrefix = ClassUtil.internalPackagePrefix(newPackagePrefix);
}
while (packagePrefix.length() > 0 &&
newPackagePrefix.length() > 0);
}
}
// Small utility methods.
/**
* Finds or creates the new package prefix for the given package.
*/
private String newPackagePrefix(String packagePrefix)
{
// Doesn't the package prefix have a new package prefix yet?
String newPackagePrefix = (String)packagePrefixMap.get(packagePrefix);
if (newPackagePrefix == null)
{
// Are we keeping the package name?
if (keepPackageNamesMatcher != null &&
keepPackageNamesMatcher.matches(packagePrefix.length() > 0 ?
packagePrefix.substring(0, packagePrefix.length()-1) :
packagePrefix))
{
return packagePrefix;
}
// Are we forcing a new package prefix?
if (repackageClasses != null)
{
return repackageClasses;
}
// Are we forcing a new superpackage prefix?
// Otherwise figure out the new superpackage prefix, recursively.
String newSuperPackagePrefix = flattenPackageHierarchy != null ?
flattenPackageHierarchy :
newPackagePrefix(ClassUtil.internalPackagePrefix(packagePrefix));
// Come up with a new package prefix.
newPackagePrefix = generateUniquePackagePrefix(newSuperPackagePrefix);
// Remember to use this mapping in the future.
packagePrefixMap.put(packagePrefix, newPackagePrefix);
}
return newPackagePrefix;
}
/**
* Creates a new package prefix in the given new superpackage.
*/
private String generateUniquePackagePrefix(String newSuperPackagePrefix)
{
// Find the right name factory for this package.
NameFactory packageNameFactory =
(NameFactory)packagePrefixPackageNameFactoryMap.get(newSuperPackagePrefix);
if (packageNameFactory == null)
{
// We haven't seen packages in this superpackage before. Create
// a new name factory for them.
packageNameFactory = new SimpleNameFactory(useMixedCaseClassNames);
if (this.packageNameFactory != null)
{
packageNameFactory =
new DictionaryNameFactory(this.packageNameFactory,
packageNameFactory);
}
packagePrefixPackageNameFactoryMap.put(newSuperPackagePrefix,
packageNameFactory);
}
return generateUniquePackagePrefix(newSuperPackagePrefix, packageNameFactory);
}
/**
* Creates a new package prefix in the given new superpackage, with the
* given package name factory.
*/
private String generateUniquePackagePrefix(String newSuperPackagePrefix,
NameFactory packageNameFactory)
{
// Come up with package names until we get an original one.
String newPackagePrefix;
do
{
// Let the factory produce a package name.
newPackagePrefix = newSuperPackagePrefix +
packageNameFactory.nextName() +
ClassConstants.INTERNAL_PACKAGE_SEPARATOR;
}
while (packagePrefixMap.containsValue(newPackagePrefix));
return newPackagePrefix;
}
/**
* Creates a new class name in the given new package.
*/
private String generateUniqueClassName(String newPackagePrefix)
{
// Find the right name factory for this package.
NameFactory classNameFactory =
(NameFactory)packagePrefixClassNameFactoryMap.get(newPackagePrefix);
if (classNameFactory == null)
{
// We haven't seen classes in this package before.
// Create a new name factory for them.
classNameFactory = new SimpleNameFactory(useMixedCaseClassNames);
if (this.classNameFactory != null)
{
classNameFactory =
new DictionaryNameFactory(this.classNameFactory,
classNameFactory);
}
packagePrefixClassNameFactoryMap.put(newPackagePrefix,
classNameFactory);
}
return generateUniqueClassName(newPackagePrefix, classNameFactory);
}
/**
* Creates a new class name in the given new package.
*/
private String generateUniqueNumericClassName(String newPackagePrefix)
{
// Find the right name factory for this package.
NameFactory classNameFactory =
(NameFactory)packagePrefixNumericClassNameFactoryMap.get(newPackagePrefix);
if (classNameFactory == null)
{
// We haven't seen classes in this package before.
// Create a new name factory for them.
classNameFactory = new NumericNameFactory();
packagePrefixNumericClassNameFactoryMap.put(newPackagePrefix,
classNameFactory);
}
return generateUniqueClassName(newPackagePrefix, classNameFactory);
}
/**
* Creates a new class name in the given new package, with the given
* class name factory.
*/
private String generateUniqueClassName(String newPackagePrefix,
NameFactory classNameFactory)
{
// Come up with class names until we get an original one.
String newClassName;
String newMixedCaseClassName;
do
{
// Let the factory produce a class name.
newClassName = newPackagePrefix +
classNameFactory.nextName();
newMixedCaseClassName = mixedCaseClassName(newClassName);
}
while (classNamesToAvoid.contains(newMixedCaseClassName));
// Explicitly make sure the name isn't used again if we have a
// user-specified dictionary and we're not allowed to have mixed case
// class names -- just to protect against problematic dictionaries.
if (this.classNameFactory != null &&
!useMixedCaseClassNames)
{
classNamesToAvoid.add(newMixedCaseClassName);
}
return newClassName;
}
/**
* Returns the given class name, unchanged if mixed-case class names are
* allowed, or the lower-case version otherwise.
*/
private String mixedCaseClassName(String className)
{
return useMixedCaseClassNames ?
className :
className.toLowerCase();
}
/**
* Assigns a new name to the given class.
* @param clazz the given class.
* @param name the new name.
*/
static void setNewClassName(Clazz clazz, String name)
{
clazz.setVisitorInfo(name);
}
/**
* Retrieves the new name of the given class.
* @param clazz the given class.
* @return the class's new name, or <code>null</code> if it doesn't
* have one yet.
*/
static String newClassName(Clazz clazz)
{
Object visitorInfo = clazz.getVisitorInfo();
return visitorInfo instanceof String ?
(String)visitorInfo :
null;
}
}