From cc74d0e62cfdcf14c5918234f69d587d264807ed Mon Sep 17 00:00:00 2001 From: jeff Date: Wed, 13 Aug 2014 00:22:12 -0400 Subject: added support for field access searches added proper detection/handling for constructors --- src/cuchaz/enigma/Deobfuscator.java | 30 +++++- src/cuchaz/enigma/analysis/FieldCallsTreeNode.java | 82 +++++++++++++++ src/cuchaz/enigma/analysis/JarIndex.java | 107 +++++++++++++++---- .../enigma/analysis/MethodCallsTreeNode.java | 114 +++++++++++++++------ src/cuchaz/enigma/analysis/SourceIndexVisitor.java | 5 +- src/cuchaz/enigma/gui/Gui.java | 60 ++++++++--- src/cuchaz/enigma/gui/GuiController.java | 38 ++++++- src/cuchaz/enigma/mapping/ConstructorEntry.java | 94 +++++++++++++++++ src/cuchaz/enigma/mapping/Translator.java | 8 ++ 9 files changed, 460 insertions(+), 78 deletions(-) create mode 100644 src/cuchaz/enigma/analysis/FieldCallsTreeNode.java create mode 100644 src/cuchaz/enigma/mapping/ConstructorEntry.java diff --git a/src/cuchaz/enigma/Deobfuscator.java b/src/cuchaz/enigma/Deobfuscator.java index 33eef08a..770172e3 100644 --- a/src/cuchaz/enigma/Deobfuscator.java +++ b/src/cuchaz/enigma/Deobfuscator.java @@ -34,6 +34,7 @@ import cuchaz.enigma.analysis.SourceIndexVisitor; import cuchaz.enigma.mapping.ArgumentEntry; import cuchaz.enigma.mapping.ClassEntry; import cuchaz.enigma.mapping.ClassMapping; +import cuchaz.enigma.mapping.ConstructorEntry; import cuchaz.enigma.mapping.Entry; import cuchaz.enigma.mapping.FieldEntry; import cuchaz.enigma.mapping.Mappings; @@ -185,6 +186,10 @@ public class Deobfuscator { m_renamer.setMethodTreeName( (MethodEntry)obfEntry, newName ); } + else if( obfEntry instanceof ConstructorEntry ) + { + m_renamer.setClassName( obfEntry.getClassEntry(), newName ); + } else if( obfEntry instanceof ArgumentEntry ) { m_renamer.setArgumentName( (ArgumentEntry)obfEntry, newName ); @@ -210,6 +215,10 @@ public class Deobfuscator { return translator.translateEntry( (MethodEntry)deobfEntry ); } + else if( deobfEntry instanceof ConstructorEntry ) + { + return translator.translateEntry( (ConstructorEntry)deobfEntry ); + } else if( deobfEntry instanceof ArgumentEntry ) { return translator.translateEntry( (ArgumentEntry)deobfEntry ); @@ -235,6 +244,10 @@ public class Deobfuscator { return translator.translateEntry( (MethodEntry)obfEntry ); } + else if( obfEntry instanceof ConstructorEntry ) + { + return translator.translateEntry( (ConstructorEntry)obfEntry ); + } else if( obfEntry instanceof ArgumentEntry ) { return translator.translateEntry( (ArgumentEntry)obfEntry ); @@ -263,6 +276,11 @@ public class Deobfuscator String deobfName = translator.translate( (MethodEntry)obfEntry ); return deobfName != null && !deobfName.equals( obfEntry.getName() ); } + else if( obfEntry instanceof ConstructorEntry ) + { + String deobfName = translator.translate( obfEntry.getClassEntry() ); + return deobfName != null && !deobfName.equals( obfEntry.getClassName() ); + } else if( obfEntry instanceof ArgumentEntry ) { return translator.translate( (ArgumentEntry)obfEntry ) != null; @@ -282,16 +300,20 @@ public class Deobfuscator } else if( obfEntry instanceof FieldEntry ) { - return m_jarIndex.getObfClassNames().contains( ((FieldEntry)obfEntry).getClassName() ); + return m_jarIndex.getObfClassNames().contains( obfEntry.getClassName() ); } else if( obfEntry instanceof MethodEntry ) { - return m_jarIndex.getObfClassNames().contains( ((MethodEntry)obfEntry).getClassName() ); + return m_jarIndex.getObfClassNames().contains( obfEntry.getClassName() ); + } + else if( obfEntry instanceof ConstructorEntry ) + { + return m_jarIndex.getObfClassNames().contains( obfEntry.getClassName() ); } else if( obfEntry instanceof ArgumentEntry ) { - // arguments only appear in method delcarations - // since we only show declrations for obf classes, these are always obfuscated + // arguments only appear in method declarations + // since we only show declarations for obf classes, these are always obfuscated return true; } diff --git a/src/cuchaz/enigma/analysis/FieldCallsTreeNode.java b/src/cuchaz/enigma/analysis/FieldCallsTreeNode.java new file mode 100644 index 00000000..0427b3be --- /dev/null +++ b/src/cuchaz/enigma/analysis/FieldCallsTreeNode.java @@ -0,0 +1,82 @@ +/******************************************************************************* + * Copyright (c) 2014 Jeff Martin. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the GNU Public License v3.0 + * which accompanies this distribution, and is available at + * http://www.gnu.org/licenses/gpl.html + * + * Contributors: + * Jeff Martin - initial API and implementation + ******************************************************************************/ +package cuchaz.enigma.analysis; + +import javax.swing.tree.DefaultMutableTreeNode; + +import cuchaz.enigma.mapping.ConstructorEntry; +import cuchaz.enigma.mapping.Entry; +import cuchaz.enigma.mapping.FieldEntry; +import cuchaz.enigma.mapping.MethodEntry; +import cuchaz.enigma.mapping.Translator; + +public class FieldCallsTreeNode extends DefaultMutableTreeNode +{ + private static final long serialVersionUID = -7934108091928699835L; + + private Translator m_deobfuscatingTranslator; + private FieldEntry m_entry; + + public FieldCallsTreeNode( Translator deobfuscatingTranslator, FieldEntry fieldEntry ) + { + m_deobfuscatingTranslator = deobfuscatingTranslator; + m_entry = fieldEntry; + } + + public FieldEntry getFieldEntry( ) + { + return m_entry; + } + + @Override + public String toString( ) + { + String className = m_deobfuscatingTranslator.translateClass( m_entry.getClassName() ); + if( className == null ) + { + className = m_entry.getClassName(); + } + + String targetName = m_deobfuscatingTranslator.translate( m_entry ); + if( targetName == null ) + { + targetName = m_entry.getName(); + } + return className + "." + targetName; + } + + public void load( JarIndex index, boolean recurse ) + { + // get all the child nodes + for( Entry entry : index.getFieldCallers( m_entry ) ) + { + if( entry instanceof MethodEntry ) + { + add( new MethodCallsTreeNode( m_deobfuscatingTranslator, (MethodEntry)entry ) ); + } + else if( entry instanceof ConstructorEntry ) + { + add( new MethodCallsTreeNode( m_deobfuscatingTranslator, (ConstructorEntry)entry ) ); + } + } + + if( recurse && children != null ) + { + for( Object node : children ) + { + if( node instanceof MethodCallsTreeNode ) + { + ((MethodCallsTreeNode)node).load( index, true ); + } + } + } + } +} diff --git a/src/cuchaz/enigma/analysis/JarIndex.java b/src/cuchaz/enigma/analysis/JarIndex.java index 06b01736..96bddc17 100644 --- a/src/cuchaz/enigma/analysis/JarIndex.java +++ b/src/cuchaz/enigma/analysis/JarIndex.java @@ -27,17 +27,26 @@ import javassist.CannotCompileException; import javassist.ClassPool; import javassist.CtBehavior; import javassist.CtClass; +import javassist.CtConstructor; +import javassist.CtMethod; import javassist.NotFoundException; import javassist.bytecode.Descriptor; +import javassist.expr.ConstructorCall; import javassist.expr.ExprEditor; +import javassist.expr.FieldAccess; import javassist.expr.MethodCall; +import javassist.expr.NewExpr; import com.google.common.collect.HashMultimap; +import com.google.common.collect.Lists; import com.google.common.collect.Multimap; import com.google.common.collect.Sets; import cuchaz.enigma.Constants; import cuchaz.enigma.mapping.ClassEntry; +import cuchaz.enigma.mapping.ConstructorEntry; +import cuchaz.enigma.mapping.Entry; +import cuchaz.enigma.mapping.FieldEntry; import cuchaz.enigma.mapping.MethodEntry; import cuchaz.enigma.mapping.Translator; @@ -46,7 +55,8 @@ public class JarIndex private Set m_obfClassNames; private Ancestries m_ancestries; private Multimap m_methodImplementations; - private Multimap m_methodCalls; + private Multimap m_methodCalls; + private Multimap m_fieldCalls; public JarIndex( JarFile jar ) { @@ -54,6 +64,7 @@ public class JarIndex m_ancestries = new Ancestries(); m_methodImplementations = HashMultimap.create(); m_methodCalls = HashMultimap.create(); + m_fieldCalls = HashMultimap.create(); // read the class names Enumeration enumeration = jar.entries(); @@ -133,14 +144,30 @@ public class JarIndex { // get the method entry String className = Descriptor.toJvmName( behavior.getDeclaringClass().getName() ); - final MethodEntry methodEntry = new MethodEntry( - new ClassEntry( className ), - behavior.getName(), - behavior.getSignature() - ); - - // index implementation - m_methodImplementations.put( className, methodEntry ); + final Entry thisEntry; + if( behavior instanceof CtMethod ) + { + MethodEntry methodEntry = new MethodEntry( + new ClassEntry( className ), + behavior.getName(), + behavior.getSignature() + ); + thisEntry = methodEntry; + + // index implementation + m_methodImplementations.put( className, methodEntry ); + } + else if( behavior instanceof CtConstructor ) + { + thisEntry = new ConstructorEntry( + new ClassEntry( className ), + behavior.getSignature() + ); + } + else + { + throw new IllegalArgumentException( "behavior must be a method or a constructor!" ); + } // index method calls try @@ -150,20 +177,53 @@ public class JarIndex @Override public void edit( MethodCall call ) { - // is this a jar class? String className = Descriptor.toJvmName( call.getClassName() ); - if( !m_obfClassNames.contains( className ) ) - { - return; - } - - // make entry for the called method MethodEntry calledMethodEntry = new MethodEntry( new ClassEntry( className ), call.getMethodName(), call.getSignature() ); - m_methodCalls.put( calledMethodEntry, methodEntry ); + m_methodCalls.put( calledMethodEntry, thisEntry ); + } + + @Override + public void edit( FieldAccess call ) + { + String className = Descriptor.toJvmName( call.getClassName() ); + FieldEntry calledFieldEntry = new FieldEntry( + new ClassEntry( className ), + call.getFieldName() + ); + m_fieldCalls.put( calledFieldEntry, thisEntry ); + } + + @Override + public void edit( ConstructorCall call ) + { + String className = Descriptor.toJvmName( call.getClassName() ); + ConstructorEntry calledConstructorEntry = new ConstructorEntry( + new ClassEntry( className ), + call.getSignature() + ); + m_methodCalls.put( calledConstructorEntry, thisEntry ); + } + + @Override + public void edit( NewExpr call ) + { + String className = Descriptor.toJvmName( call.getClassName() ); + ConstructorEntry calledConstructorEntry = new ConstructorEntry( + new ClassEntry( className ), + call.getSignature() + ); + + // TEMP + if( className.equals( "bgw" ) ) + { + System.out.println( calledConstructorEntry + " called by " + thisEntry ); + } + + m_methodCalls.put( calledConstructorEntry, thisEntry ); } } ); } @@ -202,7 +262,9 @@ public class JarIndex public ClassInheritanceTreeNode getClassInheritance( Translator deobfuscatingTranslator, ClassEntry obfClassEntry ) { // get the root node - List ancestry = m_ancestries.getAncestry( obfClassEntry.getName() ); + List ancestry = Lists.newArrayList(); + ancestry.add( obfClassEntry.getName() ); + ancestry.addAll( m_ancestries.getAncestry( obfClassEntry.getName() ) ); ClassInheritanceTreeNode rootNode = new ClassInheritanceTreeNode( deobfuscatingTranslator, ancestry.get( ancestry.size() - 1 ) ); // expand all children recursively @@ -241,9 +303,14 @@ public class JarIndex return rootNode; } - public Collection getMethodCallers( MethodEntry methodEntry ) + public Collection getFieldCallers( FieldEntry fieldEntry ) + { + return m_fieldCalls.get( fieldEntry ); + } + + public Collection getMethodCallers( Entry entry ) { - return m_methodCalls.get( methodEntry ); + return m_methodCalls.get( entry ); } private String getMethodKey( String name, String signature ) diff --git a/src/cuchaz/enigma/analysis/MethodCallsTreeNode.java b/src/cuchaz/enigma/analysis/MethodCallsTreeNode.java index dedfb2e7..b5cf4c33 100644 --- a/src/cuchaz/enigma/analysis/MethodCallsTreeNode.java +++ b/src/cuchaz/enigma/analysis/MethodCallsTreeNode.java @@ -10,12 +10,15 @@ ******************************************************************************/ package cuchaz.enigma.analysis; -import java.util.List; +import java.util.Set; import javax.swing.tree.DefaultMutableTreeNode; +import javax.swing.tree.TreeNode; -import com.google.common.collect.Lists; +import com.google.common.collect.Sets; +import cuchaz.enigma.mapping.ConstructorEntry; +import cuchaz.enigma.mapping.Entry; import cuchaz.enigma.mapping.MethodEntry; import cuchaz.enigma.mapping.Translator; @@ -24,72 +27,117 @@ public class MethodCallsTreeNode extends DefaultMutableTreeNode private static final long serialVersionUID = -3658163700783307520L; private Translator m_deobfuscatingTranslator; - private MethodEntry m_entry; + private MethodEntry m_methodEntry; + private ConstructorEntry m_constructorEntry; public MethodCallsTreeNode( Translator deobfuscatingTranslator, MethodEntry entry ) { m_deobfuscatingTranslator = deobfuscatingTranslator; - m_entry = entry; + m_methodEntry = entry; + m_constructorEntry = null; + } + + public MethodCallsTreeNode( Translator deobfuscatingTranslator, ConstructorEntry entry ) + { + m_deobfuscatingTranslator = deobfuscatingTranslator; + m_methodEntry = null; + m_constructorEntry = entry; } public MethodEntry getMethodEntry( ) { - return m_entry; + return m_methodEntry; } - public String getDeobfClassName( ) + public ConstructorEntry getConstructorEntry( ) { - return m_deobfuscatingTranslator.translateClass( m_entry.getClassName() ); + return m_constructorEntry; } - public String getDeobfMethodName( ) + public Entry getEntry( ) { - return m_deobfuscatingTranslator.translate( m_entry ); + if( m_methodEntry != null ) + { + return m_methodEntry; + } + else if( m_constructorEntry != null ) + { + return m_constructorEntry; + } + throw new Error( "Illegal state!" ); } @Override public String toString( ) { - String className = getDeobfClassName(); - if( className == null ) + if( m_methodEntry != null ) { - className = m_entry.getClassName(); + String className = m_deobfuscatingTranslator.translateClass( m_methodEntry.getClassName() ); + if( className == null ) + { + className = m_methodEntry.getClassName(); + } + + String methodName = m_deobfuscatingTranslator.translate( m_methodEntry ); + if( methodName == null ) + { + methodName = m_methodEntry.getName(); + } + return className + "." + methodName + "()"; } - - String methodName = getDeobfMethodName(); - if( methodName == null ) + else if( m_constructorEntry != null ) { - methodName = m_entry.getName(); + String className = m_deobfuscatingTranslator.translateClass( m_constructorEntry.getClassName() ); + if( className == null ) + { + className = m_constructorEntry.getClassName(); + } + return className + "()"; } - return className + "." + methodName + "()"; + throw new Error( "Illegal state!" ); } public void load( JarIndex index, boolean recurse ) { // get all the child nodes - List nodes = Lists.newArrayList(); - for( MethodEntry entry : index.getMethodCallers( m_entry ) ) + for( Entry entry : index.getMethodCallers( getEntry() ) ) { - nodes.add( new MethodCallsTreeNode( m_deobfuscatingTranslator, entry ) ); - } - - // add them to this node - for( MethodCallsTreeNode node : nodes ) - { - this.add( node ); + if( entry instanceof MethodEntry ) + { + add( new MethodCallsTreeNode( m_deobfuscatingTranslator, (MethodEntry)entry ) ); + } + else if( entry instanceof ConstructorEntry ) + { + add( new MethodCallsTreeNode( m_deobfuscatingTranslator, (ConstructorEntry)entry ) ); + } } - if( recurse ) + if( recurse && children != null ) { - for( MethodCallsTreeNode node : nodes ) + for( Object child : children ) { - // don't recurse into self - if( node.getMethodEntry().equals( m_entry ) ) + if( child instanceof MethodCallsTreeNode ) { - continue; + MethodCallsTreeNode node = (MethodCallsTreeNode)child; + + // don't recurse into ancestor + Set ancestors = Sets.newHashSet(); + TreeNode n = (TreeNode)node; + while( n.getParent() != null ) + { + n = n.getParent(); + if( n instanceof MethodCallsTreeNode ) + { + ancestors.add( ((MethodCallsTreeNode)n).getEntry() ); + } + } + if( ancestors.contains( node.getEntry() ) ) + { + continue; + } + + node.load( index, true ); } - - node.load( index, true ); } } } diff --git a/src/cuchaz/enigma/analysis/SourceIndexVisitor.java b/src/cuchaz/enigma/analysis/SourceIndexVisitor.java index 0ba5996c..6c14ee99 100644 --- a/src/cuchaz/enigma/analysis/SourceIndexVisitor.java +++ b/src/cuchaz/enigma/analysis/SourceIndexVisitor.java @@ -93,6 +93,7 @@ import com.strobel.decompiler.patterns.Pattern; import cuchaz.enigma.mapping.ArgumentEntry; import cuchaz.enigma.mapping.ClassEntry; +import cuchaz.enigma.mapping.ConstructorEntry; import cuchaz.enigma.mapping.FieldEntry; import cuchaz.enigma.mapping.MethodEntry; @@ -158,7 +159,9 @@ public class SourceIndexVisitor implements IAstVisitor public Void visitConstructorDeclaration( ConstructorDeclaration node, SourceIndex index ) { MethodDefinition def = node.getUserData( Keys.METHOD_DEFINITION ); - index.add( node.getNameToken(), new ClassEntry( def.getDeclaringType().getInternalName() ) ); + ClassEntry classEntry = new ClassEntry( def.getDeclaringType().getInternalName() ); + ConstructorEntry constructorEntry = new ConstructorEntry( classEntry, def.getSignature() ); + index.addDeclaration( node.getNameToken(), constructorEntry ); return recurse( node, index ); } diff --git a/src/cuchaz/enigma/gui/Gui.java b/src/cuchaz/enigma/gui/Gui.java index 072fb3a5..1d2d3ab1 100644 --- a/src/cuchaz/enigma/gui/Gui.java +++ b/src/cuchaz/enigma/gui/Gui.java @@ -67,11 +67,13 @@ import com.google.common.collect.Lists; import cuchaz.enigma.Constants; import cuchaz.enigma.analysis.ClassInheritanceTreeNode; +import cuchaz.enigma.analysis.FieldCallsTreeNode; import cuchaz.enigma.analysis.MethodCallsTreeNode; import cuchaz.enigma.analysis.MethodInheritanceTreeNode; import cuchaz.enigma.analysis.Token; import cuchaz.enigma.mapping.ArgumentEntry; import cuchaz.enigma.mapping.ClassEntry; +import cuchaz.enigma.mapping.ConstructorEntry; import cuchaz.enigma.mapping.Entry; import cuchaz.enigma.mapping.EntryPair; import cuchaz.enigma.mapping.FieldEntry; @@ -419,7 +421,7 @@ public class Gui Object node = path.getLastPathComponent(); if( node instanceof MethodCallsTreeNode ) { - m_controller.openEntry( ((MethodCallsTreeNode)node).getMethodEntry() ); + m_controller.openEntry( ((MethodCallsTreeNode)node).getEntry() ); } } } @@ -438,7 +440,7 @@ public class Gui m_tabs = new JTabbedPane(); m_tabs.setPreferredSize( new Dimension( 250, 0 ) ); m_tabs.addTab( "Inheritance", inheritancePanel ); - m_tabs.addTab( "Method Calls", callPanel ); + m_tabs.addTab( "Call Graph", callPanel ); JSplitPane splitRight = new JSplitPane( JSplitPane.HORIZONTAL_SPLIT, true, centerPanel, m_tabs ); splitRight.setResizeWeight( 1 ); // let the left side take all the slack splitRight.resetToPreferredSizes(); @@ -770,6 +772,10 @@ public class Gui { showMethodEntryPair( (EntryPair)pair ); } + else if( pair.deobf instanceof ConstructorEntry ) + { + showConstructorEntryPair( (EntryPair)pair ); + } else if( pair.deobf instanceof ArgumentEntry ) { showArgumentEntryPair( (EntryPair)pair ); @@ -800,6 +806,12 @@ public class Gui addNameValue( m_infoPanel, "Signature", pair.deobf.getSignature() ); } + private void showConstructorEntryPair( EntryPair pair ) + { + addNameValue( m_infoPanel, "Constructor", pair.deobf.getClassEntry().getName() ); + addNameValue( m_infoPanel, "Signature", pair.deobf.getSignature() ); + } + private void showArgumentEntryPair( EntryPair pair ) { addNameValue( m_infoPanel, "Argument", pair.deobf.getName() ); @@ -815,7 +827,7 @@ public class Gui container.add( panel ); JLabel label = new JLabel( name + ":", JLabel.RIGHT ); - label.setPreferredSize( new Dimension( 80, label.getPreferredSize().height ) ); + label.setPreferredSize( new Dimension( 100, label.getPreferredSize().height ) ); panel.add( label ); panel.add( unboldLabel( new JLabel( value, JLabel.LEFT ) ) ); @@ -824,23 +836,27 @@ public class Gui private void onCaretMove( int pos ) { Token token = m_controller.getToken( pos ); - m_renameMenu.setEnabled( token != null ); - if( token == null ) - { - clearEntryPair(); - return; - } + boolean isToken = token != null; m_selectedEntryPair = m_controller.getEntryPair( token ); - boolean isClassEntry = m_selectedEntryPair.obf instanceof ClassEntry; - boolean isFieldEntry = m_selectedEntryPair.obf instanceof FieldEntry; - boolean isMethodEntry = m_selectedEntryPair.obf instanceof MethodEntry; + boolean isClassEntry = isToken && m_selectedEntryPair.obf instanceof ClassEntry; + boolean isFieldEntry = isToken && m_selectedEntryPair.obf instanceof FieldEntry; + boolean isMethodEntry = isToken && m_selectedEntryPair.obf instanceof MethodEntry; + boolean isConstructorEntry = isToken && m_selectedEntryPair.obf instanceof ConstructorEntry; - showEntryPair( m_selectedEntryPair ); + if( isToken ) + { + showEntryPair( m_selectedEntryPair ); + } + else + { + clearEntryPair(); + } - m_showInheritanceMenu.setEnabled( isClassEntry || isMethodEntry ); - m_showCallsMenu.setEnabled( isMethodEntry ); - m_openEntryMenu.setEnabled( isClassEntry || isFieldEntry || isMethodEntry ); + m_renameMenu.setEnabled( isToken ); + m_showInheritanceMenu.setEnabled( isClassEntry || isMethodEntry || isConstructorEntry ); + m_showCallsMenu.setEnabled( isFieldEntry || isMethodEntry || isConstructorEntry ); + m_openEntryMenu.setEnabled( isClassEntry || isFieldEntry || isMethodEntry || isConstructorEntry ); m_openPreviousMenu.setEnabled( m_controller.hasPreviousEntry() ); } @@ -945,11 +961,21 @@ public class Gui return; } - if( m_selectedEntryPair.obf instanceof MethodEntry ) + if( m_selectedEntryPair.obf instanceof FieldEntry ) + { + FieldCallsTreeNode node = m_controller.getFieldCalls( (FieldEntry)m_selectedEntryPair.obf ); + m_callsTree.setModel( new DefaultTreeModel( node ) ); + } + else if( m_selectedEntryPair.obf instanceof MethodEntry ) { MethodCallsTreeNode node = m_controller.getMethodCalls( (MethodEntry)m_selectedEntryPair.obf ); m_callsTree.setModel( new DefaultTreeModel( node ) ); } + else if( m_selectedEntryPair.obf instanceof ConstructorEntry ) + { + MethodCallsTreeNode node = m_controller.getMethodCalls( (ConstructorEntry)m_selectedEntryPair.obf ); + m_callsTree.setModel( new DefaultTreeModel( node ) ); + } m_tabs.setSelectedIndex( 1 ); redraw(); diff --git a/src/cuchaz/enigma/gui/GuiController.java b/src/cuchaz/enigma/gui/GuiController.java index b54aeba3..534b0cc5 100644 --- a/src/cuchaz/enigma/gui/GuiController.java +++ b/src/cuchaz/enigma/gui/GuiController.java @@ -21,13 +21,16 @@ import com.google.common.collect.Lists; import cuchaz.enigma.Deobfuscator; import cuchaz.enigma.analysis.ClassInheritanceTreeNode; +import cuchaz.enigma.analysis.FieldCallsTreeNode; import cuchaz.enigma.analysis.MethodCallsTreeNode; import cuchaz.enigma.analysis.MethodInheritanceTreeNode; import cuchaz.enigma.analysis.SourceIndex; import cuchaz.enigma.analysis.Token; import cuchaz.enigma.mapping.ClassEntry; +import cuchaz.enigma.mapping.ConstructorEntry; import cuchaz.enigma.mapping.Entry; import cuchaz.enigma.mapping.EntryPair; +import cuchaz.enigma.mapping.FieldEntry; import cuchaz.enigma.mapping.MappingsReader; import cuchaz.enigma.mapping.MappingsWriter; import cuchaz.enigma.mapping.MethodEntry; @@ -118,6 +121,10 @@ public class GuiController } Entry deobfEntry = m_index.getEntry( token ); + if( deobfEntry == null ) + { + return null; + } return new EntryPair( m_deobfuscator.obfuscateEntry( deobfEntry ), deobfEntry ); } @@ -149,16 +156,41 @@ public class GuiController return MethodInheritanceTreeNode.findNode( rootNode, obfMethodEntry ); } - public MethodCallsTreeNode getMethodCalls( MethodEntry obfMethodEntry ) + public FieldCallsTreeNode getFieldCalls( FieldEntry obfFieldEntry ) { - MethodCallsTreeNode rootNode = new MethodCallsTreeNode( + FieldCallsTreeNode rootNode = new FieldCallsTreeNode( m_deobfuscator.getTranslator( TranslationDirection.Deobfuscating ), - obfMethodEntry + obfFieldEntry ); rootNode.load( m_deobfuscator.getJarIndex(), true ); return rootNode; } + public MethodCallsTreeNode getMethodCalls( Entry obfEntry ) + { + MethodCallsTreeNode rootNode; + if( obfEntry instanceof MethodEntry ) + { + rootNode = new MethodCallsTreeNode( + m_deobfuscator.getTranslator( TranslationDirection.Deobfuscating ), + (MethodEntry)obfEntry + ); + } + else if( obfEntry instanceof ConstructorEntry ) + { + rootNode = new MethodCallsTreeNode( + m_deobfuscator.getTranslator( TranslationDirection.Deobfuscating ), + (ConstructorEntry)obfEntry + ); + } + else + { + throw new IllegalArgumentException( "entry must be a MethodEntry or a ConstructorEntry!" ); + } + rootNode.load( m_deobfuscator.getJarIndex(), true ); + return rootNode; + } + public void rename( Entry obfEntry, String newName ) { m_deobfuscator.rename( obfEntry, newName ); diff --git a/src/cuchaz/enigma/mapping/ConstructorEntry.java b/src/cuchaz/enigma/mapping/ConstructorEntry.java new file mode 100644 index 00000000..e0fa7cf6 --- /dev/null +++ b/src/cuchaz/enigma/mapping/ConstructorEntry.java @@ -0,0 +1,94 @@ +/******************************************************************************* + * Copyright (c) 2014 Jeff Martin. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the GNU Public License v3.0 + * which accompanies this distribution, and is available at + * http://www.gnu.org/licenses/gpl.html + * + * Contributors: + * Jeff Martin - initial API and implementation + ******************************************************************************/ +package cuchaz.enigma.mapping; + +import java.io.Serializable; + +import cuchaz.enigma.Util; + +public class ConstructorEntry implements Entry, Serializable +{ + private static final long serialVersionUID = -868346075317366758L; + + private ClassEntry m_classEntry; + private String m_signature; + + public ConstructorEntry( ClassEntry classEntry, String signature ) + { + if( classEntry == null ) + { + throw new IllegalArgumentException( "Class cannot be null!" ); + } + if( signature == null ) + { + throw new IllegalArgumentException( "Method signature cannot be null!" ); + } + + m_classEntry = classEntry; + m_signature = signature; + } + + public ConstructorEntry( ConstructorEntry other ) + { + m_classEntry = new ClassEntry( other.m_classEntry ); + m_signature = other.m_signature; + } + + @Override + public ClassEntry getClassEntry( ) + { + return m_classEntry; + } + + @Override + public String getName( ) + { + return m_classEntry.getName(); + } + + public String getSignature( ) + { + return m_signature; + } + + @Override + public String getClassName( ) + { + return m_classEntry.getName(); + } + + @Override + public int hashCode( ) + { + return Util.combineHashesOrdered( m_classEntry, m_signature ); + } + + @Override + public boolean equals( Object other ) + { + if( other instanceof ConstructorEntry ) + { + return equals( (ConstructorEntry)other ); + } + return false; + } + + public boolean equals( ConstructorEntry other ) + { + return m_classEntry.equals( other.m_classEntry ) && m_signature.equals( other.m_signature ); + } + + @Override + public String toString( ) + { + return m_classEntry.getName() + m_signature; + } +} diff --git a/src/cuchaz/enigma/mapping/Translator.java b/src/cuchaz/enigma/mapping/Translator.java index 02565c94..50433214 100644 --- a/src/cuchaz/enigma/mapping/Translator.java +++ b/src/cuchaz/enigma/mapping/Translator.java @@ -135,6 +135,14 @@ public class Translator ); } + public ConstructorEntry translateEntry( ConstructorEntry in ) + { + return new ConstructorEntry( + translateEntry( in.getClassEntry() ), + translateSignature( in.getSignature() ) + ); + } + public String translate( ArgumentEntry in ) { for( String className : getSelfAndAncestors( in.getClassName() ) ) -- cgit v1.2.3