LiteLoader 1.6.4_02 - experimental - hook packet classes using ASM instead of re…

…flection, fall back to reflection if transformation fails

LiteLoader 1.6.4_02 - experimental - hook packet classes using ASM instead of re…
…flection, fall back to reflection if transformation fails
Mumfrey
1 parent 239a6eb0
Showing 12 changed files with 519 additions and 84 deletions
java/com/mumfrey/liteloader/core/Events.java
java/com/mumfrey/liteloader/core/LiteLoader.java
java/com/mumfrey/liteloader/core/PluginChannels.java
java/com/mumfrey/liteloader/core/hooks/HookProfiler.java
java/com/mumfrey/liteloader/core/hooks/asm/ASMHookProxy.java
java/com/mumfrey/liteloader/core/hooks/asm/ChatPacketTransformer.java
java/com/mumfrey/liteloader/core/hooks/asm/CrashReportTransformer.java
java/com/mumfrey/liteloader/core/hooks/asm/CustomPayloadPacketTransformer.java
java/com/mumfrey/liteloader/core/hooks/asm/LoginPacketTransformer.java
java/com/mumfrey/liteloader/core/hooks/asm/PacketTransformer.java
java/com/mumfrey/liteloader/launch/LiteLoaderTransformer.java
java/com/mumfrey/liteloader/launch/LiteLoaderTweaker.java
@@ -12,6 +12,10 @@ import com.mumfrey.liteloader.Tickable;
 import com.mumfrey.liteloader.core.hooks.HookChat;
 import com.mumfrey.liteloader.core.hooks.HookLogin;
 import com.mumfrey.liteloader.core.hooks.HookProfiler;
+import com.mumfrey.liteloader.core.hooks.asm.ASMHookProxy;
+import com.mumfrey.liteloader.core.hooks.asm.ChatPacketTransformer;
+import com.mumfrey.liteloader.core.hooks.asm.LoginPacketTransformer;
+import com.mumfrey.liteloader.core.hooks.asm.PacketTransformer;
 import com.mumfrey.liteloader.util.ModUtilities;
 import com.mumfrey.liteloader.util.PrivateFields;
@@ -37,6 +41,11 @@ public class Events implements IPlayerUsage
 	private final PluginChannels pluginChannels;
 	/**
+	 * ASM hook proxy 
+	 */
+	private final ASMHookProxy asmProxy;
+	
+	/**
 	 * Reference to the minecraft timer
 	 */
 	private Timer minecraftTimer;
@@ -144,11 +153,12 @@ public class Events implements IPlayerUsage
 	 * @param minecraft
 	 * @param pluginChannels
 	 */
-	Events(LiteLoader loader, Minecraft minecraft, PluginChannels pluginChannels)
+	Events(LiteLoader loader, Minecraft minecraft, PluginChannels pluginChannels, ASMHookProxy asmProxy)
 	{
 		this.loader = loader;
 		this.minecraft = minecraft;
 		this.pluginChannels = pluginChannels;
+		this.asmProxy = asmProxy;
 	}
 	/**
@@ -239,16 +249,34 @@ public class Events implements IPlayerUsage
 			if ((this.chatListeners.size() > 0 || this.chatFilters.size() > 0) && !this.chatHooked)
 			{
 				this.chatHooked = true;
-				HookChat.register();
-				HookChat.registerPacketHandler(this);
+				
+				if (ChatPacketTransformer.isInjected())
+				{
+					PacketTransformer.registerProxy(Packet3Chat.class, this.asmProxy);
+				}
+				else
+				{
+					LiteLoader.getLogger().info("Callback injection failed for chat packet, injecting reflection hook");
+					HookChat.register();
+					HookChat.registerPacketHandler(this);
+				}
 			}
 			// Login hook
 			if ((this.preLoginListeners.size() > 0 || this.loginListeners.size() > 0) && !this.loginHooked)
 			{
 				this.loginHooked = true;
-				ModUtilities.registerPacketOverride(1, HookLogin.class);
-				HookLogin.events = this;
+				
+				if (LoginPacketTransformer.isInjected())
+				{
+					PacketTransformer.registerProxy(Packet1Login.class, this.asmProxy);
+				}
+				else
+				{
+					LiteLoader.getLogger().info("Callback injection failed for login packet, injecting reflection hook");
+					ModUtilities.registerPacketOverride(1, HookLogin.class);
+					HookLogin.events = this;
+				}
 			}
 			// Tick hook
@@ -614,7 +642,7 @@ public class Events implements IPlayerUsage
 	}
 	/**
-	 * Callback from the chat hook
+	 * Callback from the reflective chat hook
 	 * 
 	 * @param chatPacket
 	 * @return
@@ -35,6 +35,7 @@ import net.minecraft.src.SimpleReloadableResourceManager;
 import net.minecraft.src.World;
 import com.mumfrey.liteloader.*;
+import com.mumfrey.liteloader.core.hooks.asm.ASMHookProxy;
 import com.mumfrey.liteloader.crashreport.CallableLiteLoaderBrand;
 import com.mumfrey.liteloader.crashreport.CallableLiteLoaderMods;
 import com.mumfrey.liteloader.gui.GuiControlsPaginated;
@@ -149,6 +150,11 @@ public final class LiteLoader
 	private final LinkedList<ModFile> disabledMods = new LinkedList<ModFile>();
 	/**
+	 * ASM hook proxy
+	 */
+	private final ASMHookProxy asmProxy = new ASMHookProxy();
+	
+	/**
 	 * Event manager
 	 */
 	private Events events;
@@ -156,7 +162,7 @@ public final class LiteLoader
 	/**
 	 * Plugin channel manager 
 	 */
-	private final PluginChannels pluginChannels = new PluginChannels();
+	private final PluginChannels pluginChannels = new PluginChannels(this.asmProxy);
 	/**
 	 * Permission Manager
@@ -350,7 +356,7 @@ public final class LiteLoader
 		this.minecraft = minecraft;
 		// Create the event broker
-		this.events = new Events(this, this.minecraft, this.pluginChannels);
+		this.events = new Events(this, this.minecraft, this.pluginChannels, this.asmProxy);
 		// Spawn mod instances
 		this.loadMods();
@@ -12,6 +12,9 @@ import net.minecraft.src.Packet250CustomPayload;
 import com.mumfrey.liteloader.PluginChannelListener;
 import com.mumfrey.liteloader.core.hooks.HookPluginChannels;
+import com.mumfrey.liteloader.core.hooks.asm.ASMHookProxy;
+import com.mumfrey.liteloader.core.hooks.asm.CustomPayloadPacketTransformer;
+import com.mumfrey.liteloader.core.hooks.asm.PacketTransformer;
 import com.mumfrey.liteloader.permissions.PermissionsManagerClient;
 /**
@@ -39,11 +42,16 @@ public class PluginChannels
 	 * List of mods which implement PluginChannelListener interface
 	 */
 	private LinkedList<PluginChannelListener> pluginChannelListeners = new LinkedList<PluginChannelListener>();
+	
+	private ASMHookProxy asmProxy;
 	/**
 	 * Package private
 	 */
-	PluginChannels() {}
+	PluginChannels(ASMHookProxy proxy)
+	{
+		this.asmProxy = proxy;
+	}
 	/**
 	 * 
@@ -53,8 +61,17 @@ public class PluginChannels
 		// Plugin channels hook
 		if (this.pluginChannelListeners.size() > 0 && !this.hookInitDone)
 		{
-			HookPluginChannels.register();
-			HookPluginChannels.registerPacketHandler(this);
+			if (CustomPayloadPacketTransformer.isInjected())
+			{
+				PacketTransformer.registerProxy(Packet250CustomPayload.class, this.asmProxy);
+			}
+			else
+			{
+				LiteLoader.getLogger().info("Callback injection failed for custom payload packet, injecting reflection hook");
+				HookPluginChannels.register();
+				HookPluginChannels.registerPacketHandler(this);
+			}
+			
 			this.hookInitDone = true;
 		}
 	}
@@ -140,6 +140,7 @@ public class HookProfiler extends Profiler
 	{
 		if (Thread.currentThread() != this.minecraftThread)
 		{
+			this.logger.severe("Profiler cross thread access detected, this indicates an error with one of your mods.");
 			throw new ProfilerCrossThreadAccessException(Thread.currentThread().getName());
 		}
@@ -203,6 +204,7 @@ public class HookProfiler extends Profiler
 	{
 		if (Thread.currentThread() != this.minecraftThread)
 		{
+			this.logger.severe("Profiler cross thread access detected, this indicates an error with one of your mods.");
 			throw new ProfilerCrossThreadAccessException(Thread.currentThread().getName());
 		}
+package com.mumfrey.liteloader.core.hooks.asm;
+
+import com.mumfrey.liteloader.core.Events;
+import com.mumfrey.liteloader.core.LiteLoader;
+import com.mumfrey.liteloader.core.PluginChannels;
+
+import net.minecraft.src.NetHandler;
+import net.minecraft.src.Packet1Login;
+import net.minecraft.src.Packet250CustomPayload;
+import net.minecraft.src.Packet3Chat;
+
+/**
+ * Proxy class which handles the redirected calls from the injected packet hooks and routes them to the
+ * relevant liteloader handler classes. We do this rather than patching a bunch of bytecode into the packet
+ * classes themselves because this is easier to maintain.
+ * 
+ * @author Adam Mummery-Smith
+ */
+public class ASMHookProxy
+{
+	/**
+	 * Packet3Chat::processPacket()
+	 * 
+	 * @param netHandler
+	 * @param packet
+	 */
+	public void handleChatPacket(NetHandler netHandler, Packet3Chat packet)
+	{
+		Events events = LiteLoader.getEvents();
+		if (events.onChat(packet))
+		{
+			netHandler.handleChat(packet);
+		}
+	}
+	
+	/**
+	 * Packet3Chat::processPacket()
+	 * 
+	 * @param netHandler
+	 * @param packet
+	 */
+	public void handleLoginPacket(NetHandler netHandler, Packet1Login packet)
+	{
+		Events events = LiteLoader.getEvents();
+		if (events.onPreLogin(netHandler, packet))
+		{
+			netHandler.handleLogin(packet);
+			events.onConnectToServer(netHandler, packet);
+		}
+	}
+	
+	/**
+	 * Packet3Chat::processPacket()
+	 * 
+	 * @param netHandler
+	 * @param packet
+	 */
+	public void handleCustomPayloadPacket(NetHandler netHandler, Packet250CustomPayload packet)
+	{
+		netHandler.handleCustomPayload(packet);
+		
+		PluginChannels pluginChannels = LiteLoader.getPluginChannels();
+		pluginChannels.onPluginChannelMessage(packet);
+	}
+}
+package com.mumfrey.liteloader.core.hooks.asm;
+
+/**
+ * Transformer for Packet 3 (chat)
+ *
+ * @author Adam Mummery-Smith
+ */
+public class ChatPacketTransformer extends PacketTransformer
+{
+	private static boolean injected = false;
+	
+	public ChatPacketTransformer()
+	{
+		// TODO Obfuscation 1.6.4
+		super("net.minecraft.src.Packet3Chat", "dm", "handleChatPacket");
+	}
+	
+	@Override
+	protected void notifyInjected()
+	{
+		ChatPacketTransformer.injected = true;
+	}
+	
+	public static boolean isInjected()
+	{
+		return ChatPacketTransformer.injected;
+	}
+}
+package com.mumfrey.liteloader.core.hooks.asm;
+
+import java.util.ListIterator;
+
+import net.minecraft.launchwrapper.IClassTransformer;
+
+import org.objectweb.asm.ClassReader;
+import org.objectweb.asm.ClassWriter;
+import org.objectweb.asm.Opcodes;
+import org.objectweb.asm.tree.AbstractInsnNode;
+import org.objectweb.asm.tree.ClassNode;
+import org.objectweb.asm.tree.InsnList;
+import org.objectweb.asm.tree.MethodInsnNode;
+import org.objectweb.asm.tree.MethodNode;
+import org.objectweb.asm.tree.VarInsnNode;
+
+public class CrashReportTransformer implements IClassTransformer
+{
+	private static final String classMappingCallableJVMFlags = "net.minecraft.src.CallableJVMFlags";
+	
+	// TODO Obfuscation 1.6.4
+	private static final String classMappingCallableJVMFlagsObf = "h";
+	
+	@Override
+	public byte[] transform(String name, String transformedName, byte[] basicClass)
+	{
+		if (classMappingCallableJVMFlags.equals(name) || classMappingCallableJVMFlagsObf.equals(name))
+		{
+			try
+			{
+				return this.transformCallableJVMFlags(basicClass);
+			}
+			catch (Exception ex) {}
+		}
+		
+		return basicClass;
+	}
+	
+	/**
+	 * Inject the additional callback for populating the crash report into the CallableJVMFlags class
+	 * 
+	 * @param basicClass basic class
+	 * @return transformed class
+	 */
+	private byte[] transformCallableJVMFlags(byte[] basicClass)
+	{
+		ClassReader classReader = new ClassReader(basicClass);
+		ClassNode classNode = new ClassNode();
+		classReader.accept(classNode, ClassReader.EXPAND_FRAMES);
+		
+		for (MethodNode method : classNode.methods)
+		{
+			if ("<init>".equals(method.name))
+			{
+				this.transformCallableJVMFlagsConstructor(method);
+			}
+		}
+		
+		ClassWriter writer = new ClassWriter(ClassWriter.COMPUTE_MAXS | ClassWriter.COMPUTE_FRAMES);
+		classNode.accept(writer);
+		return writer.toByteArray();
+	}
+
+	/**
+	 * @param ctor
+	 */
+	public void transformCallableJVMFlagsConstructor(MethodNode ctor)
+	{
+		InsnList code = new InsnList();
+		code.add(new VarInsnNode(Opcodes.ALOAD, 1));
+		code.add(new MethodInsnNode(Opcodes.INVOKESTATIC, "com/mumfrey/liteloader/core/LiteLoader", "populateCrashReport", "(Ljava/lang/Object;)V"));
+		
+		ListIterator<AbstractInsnNode> insns = ctor.instructions.iterator();
+		while (insns.hasNext())
+		{
+			AbstractInsnNode insnNode = insns.next();
+			if (insnNode.getOpcode() == Opcodes.RETURN)
+				ctor.instructions.insertBefore(insnNode, code);
+		}
+	}
+}
+package com.mumfrey.liteloader.core.hooks.asm;
+
+/**
+ * Transformer for Packet 250 (custom paylor)
+ *
+ * @author Adam Mummery-Smith
+ */
+public class CustomPayloadPacketTransformer extends PacketTransformer
+{
+	private static boolean injected = false;
+	
+	public CustomPayloadPacketTransformer()
+	{
+		// TODO Obfuscation 1.6.4
+		super("net.minecraft.src.Packet250CustomPayload", "ea", "handleCustomPayloadPacket");
+	}
+	
+	@Override
+	protected void notifyInjected()
+	{
+		CustomPayloadPacketTransformer.injected = true;
+	}
+	
+	public static boolean isInjected()
+	{
+		return CustomPayloadPacketTransformer.injected;
+	}
+}
+package com.mumfrey.liteloader.core.hooks.asm;
+
+/**
+ * Transformer for Packet 1 (login)
+ *
+ * @author Adam Mummery-Smith
+ */
+public class LoginPacketTransformer extends PacketTransformer
+{
+	private static boolean injected = false;
+	
+	public LoginPacketTransformer()
+	{
+		// TODO Obfuscation 1.6.4
+		super("net.minecraft.src.Packet1Login", "ep", "handleLoginPacket");
+	}
+	
+	@Override
+	protected void notifyInjected()
+	{
+		LoginPacketTransformer.injected = true;
+	}
+	
+	public static boolean isInjected()
+	{
+		return LoginPacketTransformer.injected;
+	}
+}
 \ No newline at end of file
+package com.mumfrey.liteloader.core.hooks.asm;
+
+import java.lang.reflect.Field;
+import java.util.List;
+
+import org.objectweb.asm.ClassReader;
+import org.objectweb.asm.ClassWriter;
+import org.objectweb.asm.Opcodes;
+import org.objectweb.asm.tree.ClassNode;
+import org.objectweb.asm.tree.FieldInsnNode;
+import org.objectweb.asm.tree.FieldNode;
+import org.objectweb.asm.tree.InsnNode;
+import org.objectweb.asm.tree.MethodInsnNode;
+import org.objectweb.asm.tree.MethodNode;
+import org.objectweb.asm.tree.VarInsnNode;
+
+import net.minecraft.launchwrapper.IClassTransformer;
+
+/**
+ * Class transformer which transforms a Packet class and alters the "processPacket" function to call the specified
+ * callback method in ASMHookProxy instead of the usual behaviour of calling handleXXXPacket in NetClientHandler.
+ *
+ * @author Adam Mummery-Smith
+ */
+public abstract class PacketTransformer implements IClassTransformer
+{
+	private static final String netHandlerClass = "net/minecraft/src/NetHandler";
+	private static final String processPacketMethod = "processPacket";
+	
+	// TODO Obfuscation 1.6.4
+	private static final String netHandlerClassObf = "ez";
+	private static final String processPacketMethodObf = "a";
+	
+	private final String packetClass;
+	private final String packetClassObf;
+
+	private final String handlerMethodName;
+	
+	/**
+	 * ctor
+	 * @param packetClass Packet class name we want to override (FQ)
+	 * @param packetClassObf Obfuscated packet class name
+	 * @param handlerMethodName Method name to map to in handlerClass (must have signature (NetHandler, PacketClass)Void) 
+	 */
+	protected PacketTransformer(String packetClass, String packetClassObf, String handlerMethodName)
+	{
+		this.packetClass = packetClass;
+		this.packetClassObf = packetClassObf;
+		this.handlerMethodName = handlerMethodName;
+	}
+
+	/* (non-Javadoc)
+	 * @see net.minecraft.launchwrapper.IClassTransformer#transform(java.lang.String, java.lang.String, byte[])
+	 */
+	@Override
+	public byte[] transform(String name, String transformedName, byte[] basicClass)
+	{
+		if (this.packetClass.equals(name) || this.packetClassObf.equals(name))
+		{
+			try
+			{
+				byte[] transformedClass = this.transformClass(name, basicClass);
+				this.notifyInjected();
+				return transformedClass;
+			}
+			catch (Exception ex) {}
+		}
+		
+		return basicClass;
+	}
+	
+	/**
+	 * Found the packet class we want to transform, attempt to transform it
+	 * 
+	 * @param className
+	 * @param basicClass
+	 * @return
+	 */
+	private byte[] transformClass(String className, byte[] basicClass)
+	{
+		boolean transformed = true;
+		
+		ClassReader classReader = new ClassReader(basicClass);
+		ClassNode classNode = new ClassNode();
+		classReader.accept(classNode, ClassReader.EXPAND_FRAMES);
+		
+		// Try and transform obfuscated first
+		if (!this.tryTransformMethod(className, classNode, PacketTransformer.processPacketMethodObf, PacketTransformer.netHandlerClassObf))
+		{
+			// Try to transform non-obf for use in dev env
+			if (!this.tryTransformMethod(className, classNode, PacketTransformer.processPacketMethod, PacketTransformer.netHandlerClass))
+			{
+				transformed = false;
+			}
+		}
+
+		// If we successfully transformed the method, transform the class and add a private static field "proxy" which will hold the handler
+		if (transformed)
+		{
+			classNode.fields.add(new FieldNode(Opcodes.ACC_PRIVATE + Opcodes.ACC_STATIC, "proxy", "Lcom/mumfrey/liteloader/core/hooks/asm/ASMHookProxy;", null, null));
+		}
+		
+		ClassWriter writer = new ClassWriter(ClassWriter.COMPUTE_MAXS | ClassWriter.COMPUTE_FRAMES);
+		classNode.accept(writer);
+		return writer.toByteArray();
+	}
+
+	/**
+	 * @param className
+	 * @param classNode
+	 * @param functionName
+	 * @param netHandlerClassName
+	 */
+	private boolean tryTransformMethod(String className, ClassNode classNode, String functionName, String netHandlerClassName)
+	{
+		MethodNode method = this.findMethodByNameAndSignature(classNode.methods, functionName, "(L" + netHandlerClassName + ";)V");
+		
+		if (method != null)
+		{
+			String targetMethodSig = "(L" + netHandlerClassName + ";L" + className.replace('.', '/') + ";)V";
+			this.transformMethod(className, method, targetMethodSig);
+			return true;
+		}
+		
+		return false;
+	}
+	
+	/**
+	 * Clear the old method contents and replace with the call to our handler function
+	 * 
+	 * @param method
+	 * @param targetMethodSig
+	 */
+	private void transformMethod(String className, MethodNode method, String targetMethodSig)
+	{
+		// Dump the old method content, we don't want it any more
+		method.instructions.clear();
+		
+		// Get the value of the "proxy" field from the object on the stack (which is "this")
+		method.instructions.add(new FieldInsnNode(Opcodes.GETSTATIC, className.replace('.', '/'), "proxy", "Lcom/mumfrey/liteloader/core/hooks/asm/ASMHookProxy;"));
+
+		// Push method argument 1 (NetHandler instance) onto the stack
+		method.instructions.add(new VarInsnNode(Opcodes.ALOAD, 1));
+		
+		// Push "this" onto the stack
+		method.instructions.add(new VarInsnNode(Opcodes.ALOAD, 0));
+		
+		// Invoke the handler function with the args we just pushed onto the stack
+		method.instructions.add(new MethodInsnNode(Opcodes.INVOKEVIRTUAL, "com/mumfrey/liteloader/core/hooks/asm/ASMHookProxy", this.handlerMethodName, targetMethodSig));
+		
+		// Return
+		method.instructions.add(new InsnNode(Opcodes.RETURN));
+	}
+	
+	/**
+	 * For subclasses, to set a local flag indicating the code was successfully injected
+	 */
+	protected abstract void notifyInjected();
+	
+	/**
+	 * @param classNode
+	 * @param funcName
+	 * @param funcNameObf
+	 * @param funcSig
+	 * @param funcSigObf
+	 * @return 
+	 */
+	private MethodNode findMethodByNameAndSignature(List<MethodNode> methods, String funcName, String funcSig)
+	{
+		for (MethodNode method : methods)
+		{
+			if (funcName.equals(method.name) && funcSig.equals(method.desc))
+				return method;
+		}
+		
+		return null;
+	}
+	
+	/**
+	 * Register the proxy (handler) for a packet
+	 * 
+	 * @param packetClass
+	 * @param proxy
+	 */
+	public static void registerProxy(Class<?> packetClass, ASMHookProxy proxy)
+	{
+		try
+		{
+			Field fProxy = packetClass.getDeclaredField("proxy");
+			fProxy.setAccessible(true);
+			fProxy.set(null, proxy);
+		}
+		catch (Exception ex)
+		{
+			ex.printStackTrace();
+		}
+	}
+}
 \ No newline at end of file
 package com.mumfrey.liteloader.launch;
-import java.util.ListIterator;
-
 import net.minecraft.launchwrapper.IClassTransformer;
-import org.objectweb.asm.ClassReader;
-import org.objectweb.asm.ClassWriter;
-import org.objectweb.asm.Opcodes;
-import org.objectweb.asm.tree.AbstractInsnNode;
-import org.objectweb.asm.tree.ClassNode;
-import org.objectweb.asm.tree.InsnList;
-import org.objectweb.asm.tree.MethodInsnNode;
-import org.objectweb.asm.tree.MethodNode;
-import org.objectweb.asm.tree.VarInsnNode;
-
 public class LiteLoaderTransformer implements IClassTransformer
 {
 	private static final String classMappingRenderLightningBolt = "net.minecraft.src.RenderLightningBolt";
-	private static final String classMappingCallableJVMFlags = "net.minecraft.src.CallableJVMFlags";
 	// TODO Obfuscation 1.6.4
 	private static final String classMappingRenderLightningBoltObf = "bha";
-	private static final String classMappingCallableJVMFlagsObf = "h";
 	private static boolean postInit = false;
@@ -35,58 +21,6 @@ public class LiteLoaderTransformer implements IClassTransformer
 			LiteLoaderTweaker.postInit();
 		}
-		if (classMappingCallableJVMFlags.equals(name) || classMappingCallableJVMFlagsObf.equals(name))
-		{
-			try
-			{
-				return this.transformCallableJVMFlags(basicClass);
-			}
-			catch (Exception ex) {}
-		}
-		
 		return basicClass;
 	}
-	
-	/**
-	 * Inject the additional callback for populating the crash report into the CallableJVMFlags class
-	 * 
-	 * @param basicClass basic class
-	 * @return transformed class
-	 */
-	private byte[] transformCallableJVMFlags(byte[] basicClass)
-	{
-		ClassReader classReader = new ClassReader(basicClass);
-		ClassNode classNode = new ClassNode();
-		classReader.accept(classNode, ClassReader.EXPAND_FRAMES);
-		
-		for (MethodNode method : classNode.methods)
-		{
-			if ("<init>".equals(method.name))
-			{
-				this.transformCallableJVMFlagsConstructor(method);
-			}
-		}
-		
-		ClassWriter writer = new ClassWriter(ClassWriter.COMPUTE_MAXS | ClassWriter.COMPUTE_FRAMES);
-		classNode.accept(writer);
-		return writer.toByteArray();
-	}
-
-	/**
-	 * @param ctor
-	 */
-	public void transformCallableJVMFlagsConstructor(MethodNode ctor)
-	{
-		InsnList code = new InsnList();
-		code.add(new VarInsnNode(Opcodes.ALOAD, 1));
-		code.add(new MethodInsnNode(Opcodes.INVOKESTATIC, "com/mumfrey/liteloader/core/LiteLoader", "populateCrashReport", "(Ljava/lang/Object;)V"));
-		
-		ListIterator<AbstractInsnNode> insns = ctor.instructions.iterator();
-		while (insns.hasNext())
-		{
-			AbstractInsnNode insnNode = insns.next();
-			if (insnNode.getOpcode() == Opcodes.RETURN)
-				ctor.instructions.insertBefore(insnNode, code);
-		}
-	}
 }
@@ -61,6 +61,14 @@ public class LiteLoaderTweaker implements ITweaker
 	private List<String> passThroughArgs;
+	private static final String[] requiredTransformers = {
+		"com.mumfrey.liteloader.launch.LiteLoaderTransformer",
+		"com.mumfrey.liteloader.core.hooks.asm.CrashReportTransformer",
+		"com.mumfrey.liteloader.core.hooks.asm.ChatPacketTransformer",
+		"com.mumfrey.liteloader.core.hooks.asm.LoginPacketTransformer",
+		"com.mumfrey.liteloader.core.hooks.asm.CustomPayloadPacketTransformer"
+	};
+	
 	@SuppressWarnings("unchecked")
 	@Override
 	public void acceptOptions(List<String> args, File gameDirectory, File assetsDirectory, String profile)
@@ -124,33 +132,45 @@ public class LiteLoaderTweaker implements ITweaker
 			if (arg.startsWith("-"))
 			{
 				if (classifier != null)
-					classifier = this.addClassifiedArg(classifier, "");
+				{
+					this.addClassifiedArg(classifier, "");
+					classifier = null;
+				}
 				else if (arg.contains("="))
-					classifier = this.addClassifiedArg(arg.substring(0, arg.indexOf('=')), arg.substring(arg.indexOf('=') + 1));
+				{
+					this.addClassifiedArg(arg.substring(0, arg.indexOf('=')), arg.substring(arg.indexOf('=') + 1));
+				}
 				else
+				{
 					classifier = arg;
+				}
 			}
 			else
 			{
 				if (classifier != null)
-					classifier = this.addClassifiedArg(classifier, arg);
+				{
+					this.addClassifiedArg(classifier, arg);
+					classifier = null;
+				}
 				else
 					this.singularLaunchArgs.add(arg);
 			}
 		}
 	}
-	private String addClassifiedArg(String classifiedArg, String arg)
+	private void addClassifiedArg(String classifiedArg, String arg)
 	{
 		this.launchArgs.put(classifiedArg, arg);
-		return null;
 	}
 	@Override
 	public void injectIntoClassLoader(LaunchClassLoader classLoader)
 	{
-		LiteLoaderTweaker.logger.info("Injecting LiteLoader class transformer");
-		classLoader.registerTransformer(LiteLoaderTransformer.class.getName());
+		for (String requiredTransformerClassName : LiteLoaderTweaker.requiredTransformers)
+		{
+			LiteLoaderTweaker.logger.info(String.format("Injecting required class transformer '%s'", requiredTransformerClassName));
+			classLoader.registerTransformer(requiredTransformerClassName);
+		}
 		for (String transformerClassName : LiteLoaderTweaker.modTransformers)
 		{