Merge ThisTestUser's fork

Author: ThisTestUser

src/main/java/com/javadeobfuscator/deobfuscator/Deobfuscator.java

@@ -16,41 +16,26 @@
 
 package com.javadeobfuscator.deobfuscator;
 
-import com.javadeobfuscator.deobfuscator.asm.ConstantPool;
-import com.javadeobfuscator.deobfuscator.config.Configuration;
-import com.javadeobfuscator.deobfuscator.config.TransformerConfig;
-import com.javadeobfuscator.deobfuscator.exceptions.NoClassInPathException;
-import com.javadeobfuscator.deobfuscator.rules.Rule;
-import com.javadeobfuscator.deobfuscator.rules.Rules;
-import com.javadeobfuscator.deobfuscator.transformers.Transformer;
-import com.javadeobfuscator.deobfuscator.utils.ClassTree;
-import com.javadeobfuscator.deobfuscator.utils.Utils;
-import org.apache.commons.io.IOUtils;
-import org.objectweb.asm.ClassReader;
-import org.objectweb.asm.ClassWriter;
-import org.objectweb.asm.Opcodes;
-import org.objectweb.asm.commons.JSRInlinerAdapter;
-import org.objectweb.asm.tree.AbstractInsnNode;
-import org.objectweb.asm.tree.ClassNode;
-import org.objectweb.asm.tree.MethodInsnNode;
-import org.objectweb.asm.tree.MethodNode;
-import org.objectweb.asm.util.CheckClassAdapter;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.io.File;
-import java.io.FileOutputStream;
-import java.io.IOException;
-import java.lang.reflect.Modifier;
-import java.util.AbstractMap.SimpleEntry;
+import com.javadeobfuscator.deobfuscator.asm.*;
+import com.javadeobfuscator.deobfuscator.config.*;
+import com.javadeobfuscator.deobfuscator.exceptions.*;
+import com.javadeobfuscator.deobfuscator.rules.*;
+import com.javadeobfuscator.deobfuscator.transformers.*;
+import com.javadeobfuscator.deobfuscator.utils.*;
+import org.apache.commons.io.*;
+import org.objectweb.asm.*;
+import org.objectweb.asm.commons.*;
+import org.objectweb.asm.tree.*;
+import org.objectweb.asm.util.*;
+import org.slf4j.*;
+
+import java.io.*;
+import java.lang.reflect.*;
+import java.util.AbstractMap.*;
 import java.util.*;
-import java.util.Map.Entry;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
-import java.util.regex.PatternSyntaxException;
-import java.util.zip.ZipEntry;
-import java.util.zip.ZipFile;
-import java.util.zip.ZipOutputStream;
+import java.util.Map.*;
+import java.util.regex.*;
+import java.util.zip.*;
 
 public class Deobfuscator {
     private Map<String, ClassNode> classpath = new HashMap<>();
@@ -83,6 +68,13 @@ public Deobfuscator(Configuration configuration) {
      * enable this to dump troublesome classes. Note that this will not get rid of all junk classes.
      */
     private static final boolean DELETE_USELESS_CLASSES = false;
+    
+    public Map<String, byte[]> invaildClasses = new HashMap<>();
+    
+    /**
+     * Must enable for paramorphism obfuscated files.
+     */
+    private static final boolean PARAMORPHISM = false;
 
     public ConstantPool getConstantPool(ClassNode classNode) {
         return this.constantPools.get(classNode);
@@ -176,26 +168,69 @@ private boolean isClassIgnored(ClassNode classNode) {
     }
 
     private void loadInput() throws IOException {
+    	if(PARAMORPHISM)
+    	{
+    		Map<String, String> classNameToName = new HashMap<>();
+    		Map<String, byte[]> entries = new HashMap<>();
+    		//Check all duplicate files
+	    	try (ZipFile zipIn = new ZipFile(configuration.getInput())) {
+	            Enumeration<? extends ZipEntry> e = zipIn.entries();
+	            while (e.hasMoreElements()) {
+	                ZipEntry next = e.nextElement();
+	                if (next.isDirectory() || !next.getName().endsWith(".class")) {
+	                    continue;
+	                }
+	                
+	                try {
+		                byte[] data = IOUtils.toByteArray(zipIn.getInputStream(next));
+	                    ClassReader reader = new ClassReader(data);
+	                    ClassNode node = new ClassNode();
+	                    reader.accept(node, ClassReader.SKIP_FRAMES);
+	                    if(entries.containsKey(node.name))
+	                    {
+	                    	invaildClasses.put(next.getName(), data);
+	                    	invaildClasses.put(classNameToName.get(node.name), entries.get(node.name));
+	                    }else
+	                    {
+	                    	classNameToName.put(node.name, next.getName());
+	                    	entries.put(node.name, data);
+	                    }
+	                }catch(Exception ex)
+	                {
+	                	continue;
+	                }
+	            }
+	        }
+	    	//Filter out real classes
+	    	List<String> real = new ArrayList<>();
+	    	for(Entry<String, byte[]> entry : invaildClasses.entrySet())
+	    	{
+                ClassReader reader = new ClassReader(entry.getValue());
+                ClassNode node = new ClassNode();
+                reader.accept(node, ClassReader.SKIP_FRAMES);
+                if((node.name + ".class").equals(entry.getKey()))
+                	real.add(entry.getKey());
+	    	}
+	    	real.forEach(s -> invaildClasses.remove(s));
+    	}
         try (ZipFile zipIn = new ZipFile(configuration.getInput())) {
             Enumeration<? extends ZipEntry> e = zipIn.entries();
             while (e.hasMoreElements()) {
                 ZipEntry next = e.nextElement();
-                if (next.isDirectory() && !next.getName().endsWith(".class/")) {
+                if (next.isDirectory()) {
                     continue;
                 }
 
                 byte[] data = IOUtils.toByteArray(zipIn.getInputStream(next));
                 loadInput(next.getName(), data);
             }
-
-            classpath.putAll(classes);
         }
     }
 
     public void loadInput(String name, byte[] data) {
         boolean passthrough = true;
 
-        if (name.endsWith(".class") || name.endsWith(".class/")) {
+        if (name.endsWith(".class")) {
             try {
                 ClassReader reader = new ClassReader(data);
                 ClassNode node = new ClassNode();
@@ -212,13 +247,17 @@ public void loadInput(String name, byte[] data) {
                         node.methods.set(i, adapter);
                     }
 
-                    classes.put(node.name, node);
+                    if(!invaildClasses.containsKey(name))
+                    	classes.put(node.name, node);
+                    classpath.put(node.name, node);
                     passthrough = false;
                 } else {
                     classpath.put(node.name, node);
                 }
-            } catch (Exception x) {
-                logger.error("Could not parse {} (is it a class file?)", name, x);
+            } catch (IllegalArgumentException x) {
+            	logger.error("Could not parse {} (is it a class file?)", name, x);
+            } catch (ArrayIndexOutOfBoundsException x) {
+            	logger.error("Could not parse {} (is it a class file?)", name, x);
             }
         }
 
@@ -402,10 +441,6 @@ public List<ClassNode> loadHierachy(ClassNode specificNode) {
         if (specificNode.name.equals("java/lang/Object")) {
             return Collections.emptyList();
         }
-        if ((specificNode.access & Opcodes.ACC_INTERFACE) != 0) {
-            getOrCreateClassTree(specificNode.name).parentClasses.add("java/lang/Object");
-            return Collections.emptyList();
-        }
         List<ClassNode> toProcess = new ArrayList<>();
 
         ClassTree thisTree = getOrCreateClassTree(specificNode.name);