From 5e3743a0aca3529eacf9be400c8b8d7547f66e7f Mon Sep 17 00:00:00 2001 From: jeff Date: Mon, 16 Mar 2015 19:22:22 -0400 Subject: started adding minimal support for generics fixed mark-as-deobfuscated issue --- src/cuchaz/enigma/bytecode/ClassRenamer.java | 164 ++++++++++++++++-------- src/cuchaz/enigma/bytecode/ClassTranslator.java | 42 ++---- 2 files changed, 124 insertions(+), 82 deletions(-) (limited to 'src/cuchaz/enigma/bytecode') diff --git a/src/cuchaz/enigma/bytecode/ClassRenamer.java b/src/cuchaz/enigma/bytecode/ClassRenamer.java index e9cdea3..8bc084d 100644 --- a/src/cuchaz/enigma/bytecode/ClassRenamer.java +++ b/src/cuchaz/enigma/bytecode/ClassRenamer.java @@ -23,60 +23,100 @@ import com.google.common.collect.Maps; import com.google.common.collect.Sets; import cuchaz.enigma.mapping.ClassEntry; +import cuchaz.enigma.mapping.ClassNameReplacer; +import cuchaz.enigma.mapping.ParameterizedType; +import cuchaz.enigma.mapping.Translator; +import cuchaz.enigma.mapping.Type; public class ClassRenamer { - public static void renameClasses(CtClass c, Map map) { - - // build the map used by javassist - ClassMap nameMap = new ClassMap(); - for (Map.Entry entry : map.entrySet()) { - nameMap.put(entry.getKey().getName(), entry.getValue().getName()); - } - - c.replaceClassName(nameMap); - - // replace simple names in the InnerClasses attribute too - ConstPool constants = c.getClassFile().getConstPool(); - InnerClassesAttribute attr = (InnerClassesAttribute)c.getClassFile().getAttribute(InnerClassesAttribute.tag); - if (attr != null) { - for (int i = 0; i < attr.tableLength(); i++) { - ClassEntry classEntry = new ClassEntry(Descriptor.toJvmName(attr.innerClass(i))); - if (attr.innerNameIndex(i) != 0) { - attr.setInnerNameIndex(i, constants.addUtf8Info(classEntry.getInnermostClassName())); + public static void renameClasses(CtClass c, final Translator translator) { + renameClasses(c, new ClassNameReplacer() { + @Override + public String replace(String className) { + ClassEntry entry = translator.translateEntry(new ClassEntry(className)); + if (entry != null) { + return entry.getName(); } - - /* DEBUG - System.out.println(String.format("\tDEOBF: %s-> ATTR: %s,%s,%s", classEntry, attr.outerClass(i), attr.innerClass(i), attr.innerName(i))); - */ + return null; } - } + }); } - public static Set getAllClassEntries(final CtClass c) { + public static void moveAllClassesOutOfDefaultPackage(CtClass c, final String newPackageName) { + renameClasses(c, new ClassNameReplacer() { + @Override + public String replace(String className) { + ClassEntry entry = new ClassEntry(className); + if (entry.isInDefaultPackage()) { + return newPackageName + "/" + entry.getName(); + } + return null; + } + }); + } + + public static void moveAllClassesIntoDefaultPackage(CtClass c, final String oldPackageName) { + renameClasses(c, new ClassNameReplacer() { + @Override + public String replace(String className) { + ClassEntry entry = new ClassEntry(className); + if (entry.getPackageName().equals(oldPackageName)) { + return entry.getSimpleName(); + } + return null; + } + }); + } + + public static void renameClasses(CtClass c, ClassNameReplacer replacer) { + Map map = Maps.newHashMap(); + for (ParameterizedType type : ClassRenamer.getAllClassTypes(c)) { + ParameterizedType renamedType = new ParameterizedType(type, replacer); + if (!type.equals(renamedType)) { + map.put(type, renamedType); + } + } + renameTypes(c, map); + } + + public static Set getAllClassTypes(final CtClass c) { - // get the classes that javassist knows about - final Set entries = Sets.newHashSet(); + // TODO: might have to scan SignatureAttributes directly because javassist is buggy + + // get the class types that javassist knows about + final Set types = Sets.newHashSet(); ClassMap map = new ClassMap() { @Override public Object get(Object obj) { if (obj instanceof String) { String str = (String)obj; - // javassist throws a lot of weird things at this map - // I either have to implement my on class scanner, or just try to filter out the weirdness - // I'm opting to filter out the weirdness for now + // sometimes javasist gives us dot-separated classes... whadda hell? + str = str.replace('.', '/'); - // skip anything with generic arguments - if (str.indexOf('<') >= 0 || str.indexOf('>') >= 0 || str.indexOf(';') >= 0) { + // skip weird types + boolean hasNestedParams = str.indexOf('<') >= 0 && str.indexOf('<', str.indexOf('<')+1) >= 0; + boolean hasWeirdChars = str.indexOf('*') >= 0 || str.indexOf('-') >= 0 || str.indexOf('+') >= 0; + if (hasNestedParams || hasWeirdChars) { + // TEMP + System.out.println("Skipped translating: " + str); return null; } - // convert path/to/class.inner to path/to/class$inner - str = str.replace('.', '$'); + ParameterizedType type = new ParameterizedType(new Type("L" + str + ";")); + assert(type.isClass()); + // TEMP + try { + type.getClassEntry(); + } catch (Throwable t) { + // bad type + // TEMP + System.out.println("Skipped translating: " + str); + return null; + } - // remember everything else - entries.add(new ClassEntry(str)); + types.add(type); } return null; } @@ -85,26 +125,46 @@ public class ClassRenamer { }; c.replaceClassName(map); - return entries; + return types; } - - public static void moveAllClassesOutOfDefaultPackage(CtClass c, String newPackageName) { - Map map = Maps.newHashMap(); - for (ClassEntry classEntry : ClassRenamer.getAllClassEntries(c)) { - if (classEntry.isInDefaultPackage()) { - map.put(classEntry, new ClassEntry(newPackageName + "/" + classEntry.getName())); - } + + public static void renameTypes(CtClass c, Map map) { + + // convert the type map to a javassist class map + ClassMap nameMap = new ClassMap(); + for (Map.Entry entry : map.entrySet()) { + String source = entry.getKey().toString(); + String dest = entry.getValue().toString(); + + // don't forget to chop off the L ... ; + // javassist doesn't want it there + source = source.substring(1, source.length() - 1); + dest = dest.substring(1, dest.length() - 1); + + nameMap.put(source, dest); } - ClassRenamer.renameClasses(c, map); - } - - public static void moveAllClassesIntoDefaultPackage(CtClass c, String oldPackageName) { - Map map = Maps.newHashMap(); - for (ClassEntry classEntry : ClassRenamer.getAllClassEntries(c)) { - if (classEntry.getPackageName().equals(oldPackageName)) { - map.put(classEntry, new ClassEntry(classEntry.getSimpleName())); + + // replace!! + c.replaceClassName(nameMap); + + // replace simple names in the InnerClasses attribute too + ConstPool constants = c.getClassFile().getConstPool(); + InnerClassesAttribute attr = (InnerClassesAttribute)c.getClassFile().getAttribute(InnerClassesAttribute.tag); + if (attr != null) { + for (int i = 0; i < attr.tableLength(); i++) { + + // get the inner class full name (which has already been translated) + ClassEntry classEntry = new ClassEntry(Descriptor.toJvmName(attr.innerClass(i))); + + if (attr.innerNameIndex(i) != 0) { + // update the inner name + attr.setInnerNameIndex(i, constants.addUtf8Info(classEntry.getInnermostClassName())); + } + + /* DEBUG + System.out.println(String.format("\tDEOBF: %s-> ATTR: %s,%s,%s", classEntry, attr.outerClass(i), attr.innerClass(i), attr.innerName(i))); + */ } } - ClassRenamer.renameClasses(c, map); } } diff --git a/src/cuchaz/enigma/bytecode/ClassTranslator.java b/src/cuchaz/enigma/bytecode/ClassTranslator.java index 94ab2c4..7952577 100644 --- a/src/cuchaz/enigma/bytecode/ClassTranslator.java +++ b/src/cuchaz/enigma/bytecode/ClassTranslator.java @@ -10,8 +10,6 @@ ******************************************************************************/ package cuchaz.enigma.bytecode; -import java.util.Map; - import javassist.CtBehavior; import javassist.CtClass; import javassist.CtField; @@ -19,9 +17,6 @@ import javassist.CtMethod; import javassist.bytecode.ConstPool; import javassist.bytecode.Descriptor; import javassist.bytecode.SourceFileAttribute; - -import com.google.common.collect.Maps; - import cuchaz.enigma.mapping.BehaviorEntry; import cuchaz.enigma.mapping.ClassEntry; import cuchaz.enigma.mapping.EntryFactory; @@ -50,20 +45,15 @@ public class ClassTranslator { case ConstPool.CONST_Fieldref: { - // translate the name - FieldEntry entry = new FieldEntry( - new ClassEntry(Descriptor.toJvmName(constants.getFieldrefClassName(i))), + // translate the name and type + FieldEntry entry = EntryFactory.getFieldEntry( + Descriptor.toJvmName(constants.getFieldrefClassName(i)), constants.getFieldrefName(i), - new Type(constants.getFieldrefType(i)) + constants.getFieldrefType(i) ); FieldEntry translatedEntry = m_translator.translateEntry(entry); - - // translate the type - Type type = new Type(constants.getFieldrefType(i)); - Type translatedType = m_translator.translateType(type); - - if (!entry.equals(translatedEntry) || !type.equals(translatedType)) { - editor.changeMemberrefNameAndType(i, translatedEntry.getName(), translatedType.toString()); + if (!entry.equals(translatedEntry)) { + editor.changeMemberrefNameAndType(i, translatedEntry.getName(), translatedEntry.getType().toString()); } } break; @@ -71,15 +61,14 @@ public class ClassTranslator { case ConstPool.CONST_Methodref: case ConstPool.CONST_InterfaceMethodref: { - // translate the name and type + // translate the name and type (ie signature) BehaviorEntry entry = EntryFactory.getBehaviorEntry( Descriptor.toJvmName(editor.getMemberrefClassname(i)), editor.getMemberrefName(i), editor.getMemberrefType(i) ); BehaviorEntry translatedEntry = m_translator.translateEntry(entry); - - if (!entry.getName().equals(translatedEntry.getName()) || !entry.getSignature().equals(translatedEntry.getSignature())) { + if (!entry.equals(translatedEntry)) { editor.changeMemberrefNameAndType(i, translatedEntry.getName(), translatedEntry.getSignature().toString()); } } @@ -120,25 +109,18 @@ public class ClassTranslator { } if (entry.getSignature() != null) { - // translate the type + // translate the signature Signature translatedSignature = m_translator.translateSignature(entry.getSignature()); behavior.getMethodInfo().setDescriptor(translatedSignature.toString()); } } // translate all the class names referenced in the code - // the above code only changed method/field/reference names and types, but not the class names themselves - Map map = Maps.newHashMap(); - for (ClassEntry obfClassEntry : ClassRenamer.getAllClassEntries(c)) { - ClassEntry deobfClassEntry = m_translator.translateEntry(obfClassEntry); - if (!obfClassEntry.equals(deobfClassEntry)) { - map.put(obfClassEntry, deobfClassEntry); - } - } - ClassRenamer.renameClasses(c, map); + // the above code only changed method/field/reference names and types, but not the rest of the class references + ClassRenamer.renameClasses(c, m_translator); // translate the source file attribute too - ClassEntry deobfClassEntry = map.get(classEntry); + ClassEntry deobfClassEntry = m_translator.translateEntry(classEntry); if (deobfClassEntry != null) { String sourceFile = Descriptor.toJvmName(deobfClassEntry.getOutermostClassName()) + ".java"; c.getClassFile().addAttribute(new SourceFileAttribute(constants, sourceFile)); -- cgit v1.2.3