classfilerenamer.java

j2me 混淆包,用于混淆j2me的原代码用的

/* $Id: ClassFileRenamer.java,v 1.37 2004/11/20 15:41:24 eric Exp $
 *
 * ProGuard -- shrinking, optimization, and obfuscation of Java class files.
 *
 * Copyright (c) 2002-2004 Eric Lafortune ([e-mail])
 *
 * 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.annotation.*;
import proguard.classfile.util.*;
import proguard.classfile.visitor.*;

/**
 * This <code>ClassFileVisitor</code> renames the class names and class member
 * names of the classes it visits, using names previously determined by the
 * obfuscator. It can also make package visible classes and class members public,
 * and it can replace the source file attribute by a given constant string.
 *
 * @see ClassFileObfuscator
 *
 * @author Eric Lafortune
 */
public class ClassFileRenamer
  implements ClassFileVisitor,
             MemberInfoVisitor,
             CpInfoVisitor,
             AttrInfoVisitor,
             LocalVariableInfoVisitor,
             LocalVariableTypeInfoVisitor,
             AnnotationVisitor,
             ElementValueVisitor
{
    private MyNameAndTypeRenamer nameAndTypeRenamer = new MyNameAndTypeRenamer();

    private boolean openUpPackages;
    private String  newSourceFileAttribute;


    /**
     * Creates a new ClassFileRenamer.
     * @param openUpPackages         specifies whether to make package visible
     *                               classes and class members public.
     * @param newSourceFileAttribute the new string to be put in the source file
     *                               attribute (if present) of the visited classes,
     *                               or <code>null</code> to leave it unchanged.
     */
    public ClassFileRenamer(boolean openUpPackages,
                            String  newSourceFileAttribute)
    {
        this.openUpPackages         = openUpPackages;
        this.newSourceFileAttribute = newSourceFileAttribute;
    }


    // Implementations for ClassFileVisitor.

    public void visitProgramClassFile(ProgramClassFile programClassFile)
    {
        // Rename class members.
        programClassFile.fieldsAccept(this);
        programClassFile.methodsAccept(this);

        // Rename NameAndTypeCpInfo type references in the constant pool.
        programClassFile.constantPoolEntriesAccept(nameAndTypeRenamer);

        // Rename class references and class member references in the constant pool.
        programClassFile.constantPoolEntriesAccept(this);

        // Make package visible classes public, if specified.
        if (openUpPackages && isPackageVisible(programClassFile.u2accessFlags))
        {
            programClassFile.u2accessFlags = makePublic(programClassFile.u2accessFlags);
        }

        programClassFile.attributesAccept(this);
    }


    public void visitLibraryClassFile(LibraryClassFile libraryClassFile) {}


    // Implementations for MemberInfoVisitor.

    public void visitProgramFieldInfo(ProgramClassFile programClassFile, ProgramFieldInfo programFieldInfo)
    {
        visitMemberInfo(programClassFile, programFieldInfo);
    }

    public void visitProgramMethodInfo(ProgramClassFile programClassFile, ProgramMethodInfo programMethodInfo)
    {
        visitMemberInfo(programClassFile, programMethodInfo);
    }

    private void visitMemberInfo(ProgramClassFile programClassFile, ProgramMemberInfo programMemberInfo)
    {
        String name       = programMemberInfo.getName(programClassFile);
        String descriptor = programMemberInfo.getDescriptor(programClassFile);

        // The new name is stored with the class member.
        String newName = MemberInfoObfuscator.newMemberName(programMemberInfo);
        if (newName != null &&
            !newName.equals(name))
        {
            programMemberInfo.u2nameIndex =
                createUtf8CpInfo(programClassFile, newName);
        }

        // Compute the new descriptor.
        String newDescriptor = newDescriptor(programMemberInfo.getDescriptor(programClassFile),
                                             programMemberInfo.referencedClassFiles);
        if (newDescriptor != null)
        {
            programMemberInfo.u2descriptorIndex =
                createUtf8CpInfo(programClassFile, newDescriptor);
        }

        // Make package visible class members public, if specified.
        if (openUpPackages && isPackageVisible(programMemberInfo.u2accessFlags))
        {
            programMemberInfo.u2accessFlags = makePublic(programMemberInfo.u2accessFlags);
        }
    }


    public void visitLibraryFieldInfo(LibraryClassFile libraryClassFile, LibraryFieldInfo libraryFieldInfo) {}
    public void visitLibraryMethodInfo(LibraryClassFile libraryClassFile, LibraryMethodInfo libraryMethodInfo) {}


    /**
     * This CpInfoVisitor renames all type elements in all NameAndTypeCpInfo
     * constant pool entries it visits.
     */
    private class MyNameAndTypeRenamer
       implements CpInfoVisitor
    {
        // Implementations for CpInfoVisitor.

        public void visitIntegerCpInfo(ClassFile classFile, IntegerCpInfo integerCpInfo) {}
        public void visitLongCpInfo(ClassFile classFile, LongCpInfo longCpInfo) {}
        public void visitFloatCpInfo(ClassFile classFile, FloatCpInfo floatCpInfo) {}
        public void visitDoubleCpInfo(ClassFile classFile, DoubleCpInfo doubleCpInfo) {}
        public void visitStringCpInfo(ClassFile classFile, StringCpInfo stringCpInfo) {}
        public void visitUtf8CpInfo(ClassFile classFile, Utf8CpInfo utf8CpInfo) {}
        public void visitClassCpInfo(ClassFile classFile, ClassCpInfo classCpInfo) {}
        public void visitFieldrefCpInfo(ClassFile classFile, FieldrefCpInfo fieldrefCpInfo) {}
        public void visitInterfaceMethodrefCpInfo(ClassFile classFile, InterfaceMethodrefCpInfo interfaceMethodrefCpInfo) {}
        public void visitMethodrefCpInfo(ClassFile classFile, MethodrefCpInfo methodrefCpInfo) {}


        public void visitNameAndTypeCpInfo(ClassFile classFile, NameAndTypeCpInfo nameAndTypeCpInfo)
        {
            // Compute the new descriptor.
            String newDescriptor = newDescriptor(nameAndTypeCpInfo.getType(classFile),
                                                 nameAndTypeCpInfo.referencedClassFiles);
            if (newDescriptor != null)
            {
                nameAndTypeCpInfo.u2descriptorIndex =
                    createUtf8CpInfo((ProgramClassFile)classFile, newDescriptor);
            }
        }
    }


    // Implementations for CpInfoVisitor.

    public void visitIntegerCpInfo(ClassFile classFile, IntegerCpInfo integerCpInfo) {}
    public void visitLongCpInfo(ClassFile classFile, LongCpInfo longCpInfo) {}
    public void visitFloatCpInfo(ClassFile classFile, FloatCpInfo floatCpInfo) {}
    public void visitDoubleCpInfo(ClassFile classFile, DoubleCpInfo doubleCpInfo) {}
    public void visitUtf8CpInfo(ClassFile classFile, Utf8CpInfo utf8CpInfo) {}
    public void visitNameAndTypeCpInfo(ClassFile classFile, NameAndTypeCpInfo nameAndTypeCpInfo) {}


    public void visitStringCpInfo(ClassFile classFile, StringCpInfo stringCpInfo)
    {
        // If the string is being used in a Class.forName construct, the new
        // class name can be retrieved from the referenced ClassFile.
        String newClassName = newClassName(stringCpInfo.getString(classFile),
                                           stringCpInfo.referencedClassFile);
        if (newClassName != null)
        {
            String newExternalClassName = ClassUtil.externalClassName(newClassName);

            // Refer to a new Utf8 entry.
            stringCpInfo.u2stringIndex =
                createUtf8CpInfo((ProgramClassFile)classFile, newExternalClassName);
        }
    }


    public void visitClassCpInfo(ClassFile classFile, ClassCpInfo classCpInfo)
    {
        // Compute the new class name (or type).
        String newClassName = newClassName(classCpInfo.getName(classFile),
                                           classCpInfo.referencedClassFile);
        if (newClassName != null)
        {
            // Refer to a new Utf8 entry.
            classCpInfo.u2nameIndex =
                createUtf8CpInfo((ProgramClassFile)classFile, newClassName);
        }
    }


    public void visitFieldrefCpInfo(ClassFile classFile, FieldrefCpInfo fieldrefCpInfo)
    {
        visitRefCpInfo(classFile, fieldrefCpInfo);
    }


    public void visitInterfaceMethodrefCpInfo(ClassFile classFile, InterfaceMethodrefCpInfo interfaceMethodrefCpInfo)
    {
        visitRefCpInfo(classFile, interfaceMethodrefCpInfo);
    }


    public void visitMethodrefCpInfo(ClassFile classFile, MethodrefCpInfo methodrefCpInfo)
    {
        visitRefCpInfo(classFile, methodrefCpInfo);
    }


    private void visitRefCpInfo(ClassFile classFile, RefCpInfo refCpInfo)
    {
        // Compute the new class member name.
        String newMemberName = newMemberName(refCpInfo.referencedMemberInfo);

        if (newMemberName != null)
        {
            // Refer to a new NameAndType entry.
            refCpInfo.u2nameAndTypeIndex =
                createNameAndTypeCpInfo((ProgramClassFile)classFile,
                                        newMemberName,
                                        refCpInfo.getType(classFile));
        }
    }


    // Implementations for AttrInfoVisitor.

    public void visitUnknownAttrInfo(ClassFile classFile, UnknownAttrInfo unknownAttrInfo) {}
    public void visitInnerClassesAttrInfo(ClassFile classFile, InnerClassesAttrInfo innerClassesAttrInfo) {}
    public void visitConstantValueAttrInfo(ClassFile classFile, FieldInfo fieldInfo, ConstantValueAttrInfo constantValueAttrInfo) {}
    public void visitExceptionsAttrInfo(ClassFile classFile, MethodInfo methodInfo, ExceptionsAttrInfo exceptionsAttrInfo) {}
    public void visitCodeAttrInfo(ClassFile classFile, MethodInfo methodInfo, CodeAttrInfo codeAttrInfo) {}
    public void visitLineNumberTableAttrInfo(ClassFile classFile, MethodInfo methodInfo, CodeAttrInfo codeAttrInfo, LineNumberTableAttrInfo lineNumberTableAttrInfo) {}
    public void visitDeprecatedAttrInfo(ClassFile classFile, DeprecatedAttrInfo deprecatedAttrInfo) {}
    public void visitSyntheticAttrInfo(ClassFile classFile, SyntheticAttrInfo syntheticAttrInfo) {}


    public void visitEnclosingMethodAttrInfo(ClassFile classFile, EnclosingMethodAttrInfo enclosingMethodAttrInfo)
    {
        // Compute the new class member name.
        String newMethodName = newMemberName(enclosingMethodAttrInfo.referencedMethodInfo);

        if (newMethodName != null)
        {
            // Refer to a new NameAndType entry.
            enclosingMethodAttrInfo.u2nameAndTypeIndex =
                createNameAndTypeCpInfo((ProgramClassFile)classFile,
                                        newMethodName,
                                        enclosingMethodAttrInfo.getType(classFile));
        }
    }


    public void visitLocalVariableTableAttrInfo(ClassFile classFile, MethodInfo methodInfo, CodeAttrInfo codeAttrInfo, LocalVariableTableAttrInfo localVariableTableAttrInfo)
    {
        // Rename the types of the local variables.
        localVariableTableAttrInfo.localVariablesAccept(classFile, methodInfo, codeAttrInfo, this);
    }


    public void visitLocalVariableTypeTableAttrInfo(ClassFile classFile, MethodInfo methodInfo, CodeAttrInfo codeAttrInfo, LocalVariableTypeTableAttrInfo localVariableTypeTableAttrInfo)
    {
        // Rename the signatures of the local variables.
        localVariableTypeTableAttrInfo.localVariablesAccept(classFile, methodInfo, codeAttrInfo, this);
    }


    public void visitSourceFileAttrInfo(ClassFile classFile, SourceFileAttrInfo sourceFileAttrInfo)
    {
        // Rename the source file attribute, if specified.
        if (newSourceFileAttribute != null)
        {
            sourceFileAttrInfo.u2sourceFileIndex =
                createUtf8CpInfo((ProgramClassFile)classFile, newSourceFileAttribute);
        }
    }


    public void visitSourceDirAttrInfo(ClassFile classFile, SourceDirAttrInfo sourceDirAttrInfo)
    {
        // Rename the source file attribute, if specified.
        if (newSourceFileAttribute != null)
        {
            sourceDirAttrInfo.u2sourceDirIndex =
                createUtf8CpInfo((ProgramClassFile)classFile, newSourceFileAttribute);
        }
    }


    public void visitSignatureAttrInfo(ClassFile classFile, SignatureAttrInfo signatureAttrInfo)
    {
        // Compute the new signature.
        String newSignature = newDescriptor(classFile.getCpString(signatureAttrInfo.u2signatureIndex),
                                            signatureAttrInfo.referencedClassFiles);
        if (newSignature != null)
        {
            signatureAttrInfo.u2signatureIndex =
                createUtf8CpInfo((ProgramClassFile)classFile, newSignature);
        }
    }


    public void visitRuntimeVisibleAnnotationAttrInfo(ClassFile classFile, RuntimeVisibleAnnotationsAttrInfo runtimeVisibleAnnotationsAttrInfo)
    {
        // Rename the annotations.
        runtimeVisibleAnnotationsAttrInfo.annotationsAccept(classFile, this);
    }


    public void visitRuntimeInvisibleAnnotationAttrInfo(ClassFile classFile, RuntimeInvisibleAnnotationsAttrInfo runtimeInvisibleAnnotationsAttrInfo)
    {
        // Rename the annotations.
        runtimeInvisibleAnnotationsAttrInfo.annotationsAccept(classFile, this);
    }


    public void visitRuntimeVisibleParameterAnnotationAttrInfo(ClassFile classFile, RuntimeVisibleParameterAnnotationsAttrInfo runtimeVisibleParameterAnnotationsAttrInfo)
    {
        // Rename the annotations.
        runtimeVisibleParameterAnnotationsAttrInfo.annotationsAccept(classFile, this);
    }


    public void visitRuntimeInvisibleParameterAnnotationAttrInfo(ClassFile classFile, RuntimeInvisibleParameterAnnotationsAttrInfo runtimeInvisibleParameterAnnotationsAttrInfo)
    {
        // Rename the annotations.
        runtimeInvisibleParameterAnnotationsAttrInfo.annotationsAccept(classFile, this);
    }