From 195ffb47a68c4b40d8cc04b67e6c49d8081dc3d3 Mon Sep 17 00:00:00 2001 From: jeff Date: Sun, 31 Aug 2014 22:43:13 -0400 Subject: added checks to prevent renaming classes/fields/methods/arguments to the same name as other classes/fields/methods/arguments --- src/cuchaz/enigma/analysis/JarIndex.java | 15 ++++++++++ src/cuchaz/enigma/mapping/ClassMapping.java | 20 ++++++++++++++ src/cuchaz/enigma/mapping/Mappings.java | 35 ++++++++++++++++++++++++ src/cuchaz/enigma/mapping/MethodMapping.java | 12 ++++++++ src/cuchaz/enigma/mapping/Renamer.java | 41 +++++++++++++++++++++++++++- 5 files changed, 122 insertions(+), 1 deletion(-) (limited to 'src/cuchaz') diff --git a/src/cuchaz/enigma/analysis/JarIndex.java b/src/cuchaz/enigma/analysis/JarIndex.java index fc19e7b..e7c92be 100644 --- a/src/cuchaz/enigma/analysis/JarIndex.java +++ b/src/cuchaz/enigma/analysis/JarIndex.java @@ -891,4 +891,19 @@ public class JarIndex } return thing; } + + public boolean containsObfClass( ClassEntry obfClassEntry ) + { + return m_obfClassEntries.contains( obfClassEntry ); + } + + public boolean containsObfField( FieldEntry obfFieldEntry ) + { + return m_access.containsKey( obfFieldEntry ); + } + + public boolean containsObfMethod( MethodEntry obfMethodEntry ) + { + return m_access.containsKey( obfMethodEntry ); + } } diff --git a/src/cuchaz/enigma/mapping/ClassMapping.java b/src/cuchaz/enigma/mapping/ClassMapping.java index 1219e7c..5faaf2a 100644 --- a/src/cuchaz/enigma/mapping/ClassMapping.java +++ b/src/cuchaz/enigma/mapping/ClassMapping.java @@ -334,4 +334,24 @@ public class ClassMapping implements Serializable, Comparable } return false; } + + public boolean containsDeobfField( String name ) + { + return m_fieldsByDeobf.containsKey( name ); + } + + public boolean containsDeobfMethod( String name, String signature ) + { + return m_methodsByDeobf.containsKey( getMethodKey( name, signature ) ); + } + + public boolean containsArgument( MethodEntry obfMethodEntry, String name ) + { + MethodMapping methodMapping = m_methodsByObf.get( getMethodKey( obfMethodEntry.getName(), obfMethodEntry.getSignature() ) ); + if( methodMapping != null ) + { + return methodMapping.containsArgument( name ); + } + return false; + } } diff --git a/src/cuchaz/enigma/mapping/Mappings.java b/src/cuchaz/enigma/mapping/Mappings.java index 0b03abb..378d4c0 100644 --- a/src/cuchaz/enigma/mapping/Mappings.java +++ b/src/cuchaz/enigma/mapping/Mappings.java @@ -179,4 +179,39 @@ public class Mappings implements Serializable } return classNames; } + + public boolean containsDeobfClass( String deobfName ) + { + return m_classesByDeobf.containsKey( deobfName ); + } + + public boolean containsDeobfField( ClassEntry obfClassEntry, String deobfName ) + { + ClassMapping classMapping = m_classesByObf.get( obfClassEntry.getName() ); + if( classMapping != null ) + { + return classMapping.containsDeobfField( deobfName ); + } + return false; + } + + public boolean containsDeobfMethod( ClassEntry obfClassEntry, String deobfName, String deobfSignature ) + { + ClassMapping classMapping = m_classesByObf.get( obfClassEntry.getName() ); + if( classMapping != null ) + { + return classMapping.containsDeobfMethod( deobfName, deobfSignature ); + } + return false; + } + + public boolean containsArgument( MethodEntry obfMethodEntry, String name ) + { + ClassMapping classMapping = m_classesByObf.get( obfMethodEntry.getClassName() ); + if( classMapping != null ) + { + return classMapping.containsArgument( obfMethodEntry, name ); + } + return false; + } } diff --git a/src/cuchaz/enigma/mapping/MethodMapping.java b/src/cuchaz/enigma/mapping/MethodMapping.java index b0f7ba8..bf83bd2 100644 --- a/src/cuchaz/enigma/mapping/MethodMapping.java +++ b/src/cuchaz/enigma/mapping/MethodMapping.java @@ -165,4 +165,16 @@ public class MethodMapping implements Serializable, Comparable } return false; } + + public boolean containsArgument( String name ) + { + for( ArgumentMapping argumentMapping : m_arguments.values() ) + { + if( argumentMapping.getName().equals( name ) ) + { + return true; + } + } + return false; + } } diff --git a/src/cuchaz/enigma/mapping/Renamer.java b/src/cuchaz/enigma/mapping/Renamer.java index 79cbd30..15d9af4 100644 --- a/src/cuchaz/enigma/mapping/Renamer.java +++ b/src/cuchaz/enigma/mapping/Renamer.java @@ -13,6 +13,7 @@ package cuchaz.enigma.mapping; import java.io.IOException; import java.io.ObjectOutputStream; import java.io.OutputStream; +import java.util.Set; import java.util.zip.GZIPOutputStream; import cuchaz.enigma.analysis.JarIndex; @@ -31,6 +32,12 @@ public class Renamer public void setClassName( ClassEntry obf, String deobfName ) { deobfName = NameValidator.validateClassName( deobfName ); + ClassEntry targetEntry = new ClassEntry( deobfName ); + if( m_mappings.containsDeobfClass( deobfName ) || m_index.containsObfClass( targetEntry ) ) + { + throw new IllegalNameException( deobfName, "There is already a class with that name" ); + } + ClassMapping classMapping = getOrCreateClassMapping( obf ); if( obf.isInnerClass() ) @@ -50,13 +57,32 @@ public class Renamer public void setFieldName( FieldEntry obf, String deobfName ) { deobfName = NameValidator.validateFieldName( deobfName ); + FieldEntry targetEntry = new FieldEntry( obf.getClassEntry(), deobfName ); + if( m_mappings.containsDeobfField( obf.getClassEntry(), deobfName ) || m_index.containsObfField( targetEntry ) ) + { + throw new IllegalNameException( deobfName, "There is already a field with that name" ); + } + ClassMapping classMapping = getOrCreateClassMappingOrInnerClassMapping( obf.getClassEntry() ); classMapping.setFieldName( obf.getName(), deobfName ); } public void setMethodTreeName( MethodEntry obf, String deobfName ) { - for( MethodEntry entry : m_index.getRelatedMethodImplementations( obf ) ) + Set implementations = m_index.getRelatedMethodImplementations( obf ); + + deobfName = NameValidator.validateMethodName( deobfName ); + for( MethodEntry entry : implementations ) + { + MethodEntry targetEntry = new MethodEntry( entry.getClassEntry(), deobfName, entry.getSignature() ); + if( m_mappings.containsDeobfMethod( entry.getClassEntry(), deobfName, entry.getSignature() ) || m_index.containsObfMethod( targetEntry ) ) + { + String className = m_mappings.getTranslator( m_index.getAncestries(), TranslationDirection.Deobfuscating ).translateClass( entry.getClassName() ); + throw new IllegalNameException( deobfName, "There is already a method with that name and signature in class " + className ); + } + } + + for( MethodEntry entry : implementations ) { setMethodName( entry, deobfName ); } @@ -65,6 +91,13 @@ public class Renamer public void setMethodName( MethodEntry obf, String deobfName ) { deobfName = NameValidator.validateMethodName( deobfName ); + MethodEntry targetEntry = new MethodEntry( obf.getClassEntry(), deobfName, obf.getSignature() ); + if( m_mappings.containsDeobfMethod( obf.getClassEntry(), deobfName, obf.getSignature() ) || m_index.containsObfMethod( targetEntry ) ) + { + String className = m_mappings.getTranslator( m_index.getAncestries(), TranslationDirection.Deobfuscating ).translateClass( obf.getClassName() ); + throw new IllegalNameException( deobfName, "There is already a method with that name and signature in class " + className ); + } + ClassMapping classMapping = getOrCreateClassMappingOrInnerClassMapping( obf.getClassEntry() ); String deobfSignature = m_mappings.getTranslator( m_index.getAncestries(), TranslationDirection.Deobfuscating ).translateSignature( obf.getSignature() ); classMapping.setMethodNameAndSignature( obf.getName(), obf.getSignature(), deobfName, deobfSignature ); @@ -73,6 +106,12 @@ public class Renamer public void setArgumentName( ArgumentEntry obf, String deobfName ) { deobfName = NameValidator.validateArgumentName( deobfName ); + // NOTE: don't need to check arguments for name collisions with names determined by Procyon + if( m_mappings.containsArgument( obf.getMethodEntry(), deobfName ) ) + { + throw new IllegalNameException( deobfName, "There is already an argument with that name" ); + } + ClassMapping classMapping = getOrCreateClassMappingOrInnerClassMapping( obf.getClassEntry() ); classMapping.setArgumentName( obf.getMethodName(), obf.getMethodSignature(), obf.getIndex(), deobfName ); } -- cgit v1.2.3