sometsome 1.0.2 → 3.10.42

data/lib/proguard4.7/src/proguard/obfuscate/ClassRenamer.java

@@ -0,0 +1,109 @@
+/*
+ * 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.constant.ClassConstant;
+import proguard.classfile.constant.visitor.ConstantVisitor;
+import proguard.classfile.editor.ConstantPoolEditor;
+import proguard.classfile.util.SimplifiedVisitor;
+import proguard.classfile.visitor.*;
+
+/**
+ * This <code>ClassVisitor</code> renames the class names and class member
+ * names of the classes it visits, using names previously determined by the
+ * obfuscator.
+ *
+ * @see ClassObfuscator
+ * @see MemberObfuscator
+ *
+ * @author Eric Lafortune
+ */
+public class ClassRenamer
+extends      SimplifiedVisitor
+implements   ClassVisitor,
+             MemberVisitor,
+             ConstantVisitor
+{
+    // Implementations for ClassVisitor.
+
+    public void visitProgramClass(ProgramClass programClass)
+    {
+        // Rename this class.
+        programClass.thisClassConstantAccept(this);
+
+        // Rename the class members.
+        programClass.fieldsAccept(this);
+        programClass.methodsAccept(this);
+    }
+
+
+    public void visitLibraryClass(LibraryClass libraryClass)
+    {
+        libraryClass.thisClassName = ClassObfuscator.newClassName(libraryClass);
+
+        // Rename the class members.
+        libraryClass.fieldsAccept(this);
+        libraryClass.methodsAccept(this);
+    }
+
+
+    // Implementations for MemberVisitor.
+
+    public void visitProgramMember(ProgramClass  programClass,
+                                     ProgramMember programMember)
+    {
+        // Has the class member name changed?
+        String name    = programMember.getName(programClass);
+        String newName = MemberObfuscator.newMemberName(programMember);
+        if (newName != null &&
+            !newName.equals(name))
+        {
+            programMember.u2nameIndex =
+                new ConstantPoolEditor(programClass).addUtf8Constant(newName);
+        }
+    }
+
+    public void visitLibraryMember(LibraryClass  libraryClass,
+                                   LibraryMember libraryMember)
+    {
+        String newName = MemberObfuscator.newMemberName(libraryMember);
+        if (newName != null)
+        {
+            libraryMember.name = newName;
+        }
+    }
+
+
+    // Implementations for ConstantVisitor.
+
+    public void visitClassConstant(Clazz clazz, ClassConstant classConstant)
+    {
+        // Update the Class entry if required.
+        String newName = ClassObfuscator.newClassName(clazz);
+        if (newName != null)
+        {
+            // Refer to a new Utf8 entry.
+            classConstant.u2nameIndex =
+                new ConstantPoolEditor((ProgramClass)clazz).addUtf8Constant(newName);
+        }
+    }
+}

data/lib/proguard4.7/src/proguard/obfuscate/DictionaryNameFactory.java

@@ -0,0 +1,189 @@
+/*
+ * 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 java.io.*;
+import java.util.*;
+
+/**
+ * This <code>NameFactory</code> generates names that are read from a
+ * specified input file.
+ * Comments (everything starting with '#' on a single line) are ignored.
+ *
+ * @author Eric Lafortune
+ */
+public class DictionaryNameFactory implements NameFactory
+{
+    private static final char COMMENT_CHARACTER = '#';
+
+
+    private final List        names;
+    private final NameFactory nameFactory;
+
+    private int index = 0;
+
+
+    /**
+     * Creates a new <code>DictionaryNameFactory</code>.
+     * @param file        the file from which the names can be read.
+     * @param nameFactory the name factory from which names will be retrieved
+     *                    if the list of read names has been exhausted.
+     */
+    public DictionaryNameFactory(File        file,
+                                 NameFactory nameFactory) throws IOException
+    {
+        this.names       = new ArrayList();
+        this.nameFactory = nameFactory;
+
+        Reader reader = new FileReader(file);
+
+        try
+        {
+            StringBuffer buffer = new StringBuffer();
+
+            while (true)
+            {
+                // Read the next character.
+                int c = reader.read();
+
+                // Is it a valid identifier character?
+                if (c != -1 &&
+                    (buffer.length() == 0 ?
+                         Character.isJavaIdentifierStart((char)c) :
+                         Character.isJavaIdentifierPart((char)c)))
+                {
+                    // Append it to the current identifier.
+                    buffer.append((char)c);
+                }
+                else
+                {
+                    // Did we collect a new identifier?
+                    if (buffer.length() > 0)
+                    {
+                        // Add the completed name to the list of names, if it's
+                        // not in it yet.
+                        String name = buffer.toString();
+                        if (!names.contains(name))
+                        {
+                            names.add(name);
+                        }
+
+                        // Clear the buffer.
+                        buffer.setLength(0);
+                    }
+
+                    // Is this the beginning of a comment line?
+                    if (c == COMMENT_CHARACTER)
+                    {
+                        // Skip all characters till the end of the line.
+                        do
+                        {
+                            c = reader.read();
+                        }
+                        while (c != -1 &&
+                               c != '\n' &&
+                               c != '\r');
+                    }
+
+                    // Is this the end of the file?
+                    if (c == -1)
+                    {
+                        // Just return.
+                        return;
+                    }
+                }
+            }
+        }
+        finally
+        {
+            reader.close();
+        }
+    }
+
+
+    /**
+     * Creates a new <code>DictionaryNameFactory</code>.
+     * @param dictionaryNameFactory the dictionary name factory whose dictionary
+     *                              will be used.
+     * @param nameFactory           the name factory from which names will be
+     *                              retrieved if the list of read names has been
+     *                              exhausted.
+     */
+    public DictionaryNameFactory(DictionaryNameFactory dictionaryNameFactory,
+                                 NameFactory           nameFactory)
+    {
+        this.names       = dictionaryNameFactory.names;
+        this.nameFactory = nameFactory;
+    }
+
+
+    // Implementations for NameFactory.
+
+    public void reset()
+    {
+        index = 0;
+
+        nameFactory.reset();
+    }
+
+
+    public String nextName()
+    {
+        String name;
+
+        // Do we still have names?
+        if (index < names.size())
+        {
+            // Return the next name.
+            name = (String)names.get(index++);
+        }
+        else
+        {
+            // Return the next different name from the other name factory.
+            do
+            {
+                name = nameFactory.nextName();
+            }
+            while (names.contains(name));
+        }
+
+        return name;
+    }
+
+
+    public static void main(String[] args)
+    {
+        try
+        {
+            DictionaryNameFactory factory =
+                new DictionaryNameFactory(new File(args[0]), new SimpleNameFactory());
+
+            for (int counter = 0; counter < 50; counter++)
+            {
+                System.out.println("["+factory.nextName()+"]");
+            }
+        }
+        catch (IOException ex)
+        {
+            ex.printStackTrace();
+        }
+    }
+}

data/lib/proguard4.7/src/proguard/obfuscate/MapCleaner.java

@@ -0,0 +1,57 @@
+/*
+ * 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.util.SimplifiedVisitor;
+import proguard.classfile.visitor.ClassVisitor;
+
+import java.util.Map;
+
+/**
+ * This ClassVisitor clears a given map whenever it visits a class.
+ *
+ * @author Eric Lafortune
+ */
+public class MapCleaner
+extends      SimplifiedVisitor
+implements   ClassVisitor
+{
+    private final Map map;
+
+
+    /**
+     * Creates a new MapCleaner.
+     * @param map the map to be cleared.
+     */
+    public MapCleaner(Map map)
+    {
+        this.map = map;
+    }
+
+
+    // Implementations for ClassVisitor.
+
+    public void visitAnyClass(Clazz clazz)
+    {
+        map.clear();
+    }
+}

data/lib/proguard4.7/src/proguard/obfuscate/MappingKeeper.java

@@ -0,0 +1,177 @@
+/*
+ * 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.util.*;
+import proguard.util.ListUtil;
+
+
+/**
+ * This MappingKeeper applies the mappings that it receives to its class pool,
+ * so these mappings are ensured in a subsequent obfuscation step.
+ *
+ * @author Eric Lafortune
+ */
+public class MappingKeeper implements MappingProcessor
+{
+    private final ClassPool      classPool;
+    private final WarningPrinter warningPrinter;
+
+    // A field acting as a parameter.
+    private Clazz clazz;
+
+
+    /**
+     * Creates a new MappingKeeper.
+     * @param classPool      the class pool in which class names and class
+     *                       member names have to be mapped.
+     * @param warningPrinter the optional warning printer to which warnings
+     *                       can be printed.
+     */
+    public MappingKeeper(ClassPool      classPool,
+                         WarningPrinter warningPrinter)
+    {
+        this.classPool      = classPool;
+        this.warningPrinter = warningPrinter;
+    }
+
+
+    // Implementations for MappingProcessor.
+
+    public boolean processClassMapping(String className,
+                                       String newClassName)
+    {
+        // Find the class.
+        String name = ClassUtil.internalClassName(className);
+
+        clazz = classPool.getClass(name);
+        if (clazz != null)
+        {
+            String newName = ClassUtil.internalClassName(newClassName);
+
+            // Print out a warning if the mapping conflicts with a name that
+            // was set before.
+            if (warningPrinter != null)
+            {
+                String currentNewName = ClassObfuscator.newClassName(clazz);
+                if (currentNewName != null &&
+                    !currentNewName.equals(newName))
+                {
+                    warningPrinter.print(name,
+                                         currentNewName,
+                                         "Warning: " +
+                                         className +
+                                         " is not being kept as '" +
+                                         ClassUtil.externalClassName(currentNewName) +
+                                         "', but remapped to '" +
+                                         newClassName + "'");
+                }
+            }
+
+            ClassObfuscator.setNewClassName(clazz, newName);
+
+            // The class members have to be kept as well.
+            return true;
+        }
+
+        return false;
+    }
+
+
+    public void processFieldMapping(String className,
+                                    String fieldType,
+                                    String fieldName,
+                                    String newFieldName)
+    {
+        if (clazz != null)
+        {
+            // Find the field.
+            String name       = fieldName;
+            String descriptor = ClassUtil.internalType(fieldType);
+
+            Field field = clazz.findField(name, descriptor);
+            if (field != null)
+            {
+                // Print out a warning if the mapping conflicts with a name that
+                // was set before.
+                if (warningPrinter != null)
+                {
+                    String currentNewName = MemberObfuscator.newMemberName(field);
+                    if (currentNewName != null &&
+                        !currentNewName.equals(newFieldName))
+                    {
+                        warningPrinter.print(ClassUtil.internalClassName(className),
+                                             "Warning: " +
+                                             className +
+                                             ": field '" + fieldType + " " + fieldName +
+                                             "' is not being kept as '" + currentNewName +
+                                             "', but remapped to '" + newFieldName + "'");
+                    }
+                }
+
+                // Make sure the mapping name will be kept.
+                MemberObfuscator.setFixedNewMemberName(field, newFieldName);
+            }
+        }
+    }
+
+
+    public void processMethodMapping(String className,
+                                     int    firstLineNumber,
+                                     int    lastLineNumber,
+                                     String methodReturnType,
+                                     String methodName,
+                                     String methodArguments,
+                                     String newMethodName)
+    {
+        if (clazz != null)
+        {
+            // Find the method.
+            String descriptor = ClassUtil.internalMethodDescriptor(methodReturnType,
+                                                                   ListUtil.commaSeparatedList(methodArguments));
+
+            Method method = clazz.findMethod(methodName, descriptor);
+            if (method != null)
+            {
+                // Print out a warning if the mapping conflicts with a name that
+                // was set before.
+                if (warningPrinter != null)
+                {
+                    String currentNewName = MemberObfuscator.newMemberName(method);
+                    if (currentNewName != null &&
+                        !currentNewName.equals(newMethodName))
+                    {
+                        warningPrinter.print(ClassUtil.internalClassName(className),
+                                             "Warning: " +
+                                             className +
+                                             ": method '" + methodReturnType + " " + methodName + ClassConstants.EXTERNAL_METHOD_ARGUMENTS_OPEN + methodArguments + ClassConstants.EXTERNAL_METHOD_ARGUMENTS_CLOSE +
+                                             "' is not being kept as '" + currentNewName +
+                                             "', but remapped to '" + newMethodName + "'");
+                    }
+                }
+
+                // Make sure the mapping name will be kept.
+                MemberObfuscator.setFixedNewMemberName(method, newMethodName);
+            }
+        }
+    }
+}