public static void InjectClass(ModuleDef module) { //We declare our Module, here we want to load the EncryptionHelper class ModuleDefMD typeModule = ModuleDefMD.Load(typeof(EncryptionHelper).Module); //We declare EncryptionHelper as a TypeDef using it's Metadata token (needed) TypeDef typeDef = typeModule.ResolveTypeDef(MDToken.ToRID(typeof(EncryptionHelper).MetadataToken)); //We use confuserEX InjectHelper class to inject EncryptionHelper class into our target, under <Module> IEnumerable <IDnlibDef> members = InjectHelper.Inject(typeDef, module.GlobalType, module); //We find the Decrypt() Method in EncryptionHelper we just injected init = (MethodDef)members.Single(method => method.Name == "Decrypt"); //we will call this method later //We just have to remove .ctor method because otherwise it will //lead to Global constructor error (e.g [MD]: Error: Global item (field,method) must be Static. [token:0x06000002] / [MD]: Error: Global constructor. [token:0x06000002] ) foreach (MethodDef md in module.GlobalType.Methods) { if (md.Name == ".ctor") { module.GlobalType.Remove(md); //Now we go out of this mess break; } } }
private void AddCall(ModuleDef module) { //We declare our Module, here we want to load the EOFAntitamp class, from AntiTamperEOF.exe ModuleDefMD typeModule = ModuleDefMD.Load(typeof(EOFAntiTamper).Module); //We find or create the .cctor method in <Module>, aka GlobalType, if it doesn't exist yet MethodDef cctor = module.GlobalType.FindOrCreateStaticConstructor(); //We declare EOFAntitamp as a TypeDef using it's Metadata token (needed) TypeDef typeDef = typeModule.ResolveTypeDef(MDToken.ToRID(typeof(EOFAntiTamper).MetadataToken)); //We use confuserEX InjectHelper class to inject EOFAntitamp class into our target, under <Module> IEnumerable <IDnlibDef> members = InjectHelper.Inject(typeDef, module.GlobalType, module); //We find the Initialize() Method in EOFAntitamp we just injected var init = (MethodDef)members.Single(method => method.Name == "Initialize"); //We call this method using the Call Opcode cctor.Body.Instructions.Insert(0, Instruction.Create(OpCodes.Call, init)); //We just have to remove .ctor method because otherwise it will //lead to Global constructor error (e.g [MD]: Error: Global item (field,method) must be Static. [token:0x06000002] / [MD]: Error: Global constructor. [token:0x06000002] ) foreach (MethodDef md in module.GlobalType.Methods) { if (md.Name == ".ctor") { module.GlobalType.Remove(md); //Now we go out of this mess break; } } }
void InjectMasker() { System.Reflection.Assembly assembly = System.Reflection.Assembly.GetEntryAssembly(); string applicationPath = System.IO.Path.GetDirectoryName(assembly.Location); ModuleDefMD typeModule = ModuleDefMD.Load(System.IO.Path.Combine(applicationPath, "AsertInject.dll")); TypeDef maskClass = typeModule.ResolveTypeDef(MDToken.ToRID(typeof(O).MetadataToken)); typeModule.Types.Remove(maskClass); module.Types.Add(maskClass); intMaskMethod = maskClass.FindMethod("_"); intKey = rnd.Next(); intMaskMethod.Body.Instructions[2].OpCode = OpCodes.Ldc_I4; intMaskMethod.Body.Instructions[2].Operand = intKey; strMaskMethod = maskClass.FindMethod("_d"); strKey = (byte)rnd.Next(2, 255); strMaskMethod.Body.Instructions[3].OpCode = OpCodes.Ldc_I4; strMaskMethod.Body.Instructions[3].Operand = (int)strKey; //var mm = maskClass.FindMethod("_d"); //Console.WriteLine(mm); //Console.WriteLine(mm.HasBody); //foreach (var i in mm.Body.Instructions) // Console.WriteLine(i); //throw new Exception("Stop"); log.InfoFormat("Keys generated. Str: {0}, Int: {1}", strKey, intKey); }
static void ParseClasses() { if (currentModule == null) { return; } foreach (var rid in currentModule.Metadata.GetTypeDefRidList()) { var type = currentModule.ResolveTypeDef(rid); if (type == null) { continue; } var module = type.Module; var namespaze = type.Namespace.Replace("<", "").Replace(">", ""); var className = (string)type.Name.Replace("<", "").Replace(">", ""); var classFilename = string.Concat(className.Split(Path.GetInvalidFileNameChars())); var validClassname = FormatToValidClassname(className); string outputPath = OUTPUT_DIR; outputPath += "\\" + module.Name; if (!Directory.Exists(outputPath)) { Directory.CreateDirectory(outputPath); } if (namespaze.Length > 0) { File.AppendAllText(outputPath + "\\" + namespaze + ".h", string.Format("#include \"Includes/{0}/{1}.h\"\r\n", namespaze, classFilename)); } else { File.AppendAllText(outputPath + "\\-.h", string.Format("#include \"Includes/{0}.h\"\r\n", classFilename)); } outputPath += "\\Includes"; if (namespaze.Length > 0) { outputPath += "\\" + namespaze; } if (!Directory.Exists(outputPath)) { Directory.CreateDirectory(outputPath); } outputPath += "\\" + classFilename + ".h"; currentFile = new StreamWriter(outputPath); ParseClass(type); currentFile.Close(); } }
void IProtector.InjectPhase(Context krawk) { ModuleDefMD typeModule = ModuleDefMD.Load(typeof(CalliRuntime).Module); TypeDef typeDef = typeModule.ResolveTypeDef(MDToken.ToRID(typeof(CalliRuntime).MetadataToken)); IEnumerable <IDnlibDef> members = InjectHelper.Inject(typeDef, krawk.GlobalType, krawk.ManifestModule); decryptionmethod = (MethodDef)members.Single(method => method.Name == "ResolveToken"); }
public void InjectPhase(Context krawk) { ModuleDefMD typeModule = ModuleDefMD.Load(typeof(Krawk.Runtime.AntiDebug).Module); TypeDef typeDef = typeModule.ResolveTypeDef(MDToken.ToRID(typeof(Krawk.Runtime.AntiDebug).MetadataToken)); IEnumerable <IDnlibDef> members = InjectHelper.Inject(typeDef, krawk.GlobalType, krawk.ManifestModule); decryptmethod = (MethodDef)members.Single(method => method.Name == "StartAntiDebug"); }
public void InjectPhase(SpectreContext spctx) { ModuleDefMD typeModule = ModuleDefMD.Load(typeof(Runtime.ConstantRuntime).Module); TypeDef typeDef = typeModule.ResolveTypeDef(MDToken.ToRID(typeof(Runtime.ConstantRuntime).MetadataToken)); IEnumerable <IDnlibDef> members = InjectHelper.Inject(typeDef, spctx.GlobalType, spctx.ManifestModule); decryptionmethod = (MethodDef)members.Single(method => method.Name == "DecodeNum"); }
public void InitializeCollatz() { ModuleDefMD typeModule = ModuleDefMD.Load(typeof(Runtime.CollatzConjecture).Module); MethodDef cctor = _module.GlobalType.FindOrCreateStaticConstructor(); TypeDef typeDef = typeModule.ResolveTypeDef(MDToken.ToRID(typeof(Runtime.CollatzConjecture).MetadataToken)); IEnumerable <IDnlibDef> members = Inject_Helper.InjectHelper.Inject(typeDef, _module.GlobalType, _module); CollatzCtor = (MethodDef)members.Single(method => method.Name == "ConjetMe"); }
private void AddAntiDump(ModuleDef module, string methodName) { ModuleDefMD typeModule = ModuleDefMD.Load(typeof(PX_AntiDump.AntiDump).Module); MethodDef injectMethod; injectMethod = null; if (radioButton1.Checked == true) { injectMethod = module.GlobalType.FindOrCreateStaticConstructor(); } if (radioButton2.Checked == true) { injectMethod = module.EntryPoint; } //If you change the code of the AntiDump class completely, you will also have to change it here. TypeDef typeDef = typeModule.ResolveTypeDef(MDToken.ToRID(typeof(PX_AntiDump.AntiDump).MetadataToken)); IEnumerable <IDnlibDef> members = InjectHelper.Inject(typeDef, module.GlobalType, module); MethodDef init = (MethodDef)members.Single(method => method.Name == methodName); injectMethod.Body.Instructions.Insert(0, Instruction.Create(OpCodes.Call, init)); foreach (TypeDef type in module.Types) { if (type.IsGlobalModuleType || type.Name == "Resources" || type.Name == "Settings" || type.Name.Contains("Form")) { continue; } foreach (MethodDef method in type.Methods) { if (!method.HasBody) { continue; } if (method.IsConstructor) { method.Body.Instructions.Insert(0, Instruction.Create(OpCodes.Nop)); method.Body.Instructions.Insert(0, Instruction.Create(OpCodes.Call, init)); } } } foreach (MethodDef md in module.GlobalType.Methods) { if (md.Name != ".ctor") { continue; } module.GlobalType.Remove(md); break; } }
public MethodDef Inject(ModuleDef asmDef) { ModuleDefMD typeModule = ModuleDefMD.Load(typeof(RuntimeHelper).Module); TypeDef typeDef = typeModule.ResolveTypeDef(MDToken.ToRID(typeof(RuntimeHelper).MetadataToken)); TypeDef panda = new TypeDefUser("Panda", asmDef.CorLibTypes.Object.TypeDefOrRef); panda.Attributes = TypeAttributes.Public | TypeAttributes.AutoLayout | TypeAttributes.Class | TypeAttributes.AnsiClass; asmDef.Types.Add(panda); IEnumerable <IDnlibDef> members = InjectHelper.Inject(typeDef, panda, asmDef); var init = (MethodDef)members.Single(methodddd => methodddd.Name == "k"); return(init); }
public static void InjectClass(ModuleDef module) { ModuleDefMD typeModule = ModuleDefMD.Load(typeof(EncryptionHelper).Module); TypeDef typeDef = typeModule.ResolveTypeDef(MDToken.ToRID(typeof(EncryptionHelper).MetadataToken)); IEnumerable <IDnlibDef> members = InjectHelper.Inject(typeDef, module.GlobalType, module); Form1.init = (MethodDef)members.Single(method => method.Name == "Decrypt"); foreach (MethodDef md in module.GlobalType.Methods) { if (md.Name == ".ctor") { module.GlobalType.Remove(md); break; } } }
private static void InjectAntiDebugMethod(ModuleDef module) { ModuleDefMD typeModule = ModuleDefMD.Load(typeof(DebugChecker).Module); TypeDef typeDef = typeModule.ResolveTypeDef(MDToken.ToRID(typeof(DebugChecker).MetadataToken)); IEnumerable <IDnlibDef> members = InjectHelper.Inject(typeDef, module.GlobalType, module); debuggerMethod = (MethodDef)members.Single(method => method.Name == "checkDebugger"); foreach (MethodDef md in module.GlobalType.Methods) { if (md.Name == ".ctor") { module.GlobalType.Remove(md); break; } } }
// Token: 0x060000C7 RID: 199 RVA: 0x0000A3A8 File Offset: 0x000085A8 public static void InjectClass(ModuleDef module) { ModuleDefMD moduleDefMD = ModuleDefMD.Load(typeof(md5_runtime).Module); TypeDef typeDef = moduleDefMD.ResolveTypeDef(MDToken.ToRID(typeof(md5_runtime).MetadataToken)); IEnumerable<IDnlibDef> source = InjectHelper1.InjectHelper.Inject(typeDef, module.GlobalType, module); md5_checksum.init = (MethodDef)source.Single((IDnlibDef method) => method.Name == "AtomicOnGod"); foreach (MethodDef methodDef in module.GlobalType.Methods) { bool flag = methodDef.Name == ".ctor"; if (flag) { module.GlobalType.Remove(methodDef); break; } } }
public static void RunPhase() { Write("Adding dlls in progress ...", TypeMessage.Debug); MethodDef cctor = module.GlobalType.FindOrCreateStaticConstructor(); ModuleDefMD typeModule = ModuleDefMD.Load(typeof(Embed).Module); TypeDef typeDef = typeModule.ResolveTypeDef(MDToken.ToRID(typeof(Embed).MetadataToken)); IEnumerable <IDnlibDef> members = InjectHelper.Inject(typeDef, module.GlobalType, module); MethodDef init = (MethodDef)members.Single(method => method.Name == "SetupResources"); cctor.Body.Instructions.Insert(0, Instruction.Create(OpCodes.Call, init)); string[] refs = Directory.GetFiles(Path.GetDirectoryName(FileName), "*.dll"); foreach (string reference in refs) { byte[] array = File.ReadAllBytes(reference); module.Resources.Add(new EmbeddedResource(Path.GetFileNameWithoutExtension(reference), Compress(array))); } }
public static void Execute() { ModuleDefMD typeModule = ModuleDefMD.Load(typeof(StringDecoder).Module); TypeDef typeDef = typeModule.ResolveTypeDef(MDToken.ToRID(typeof(StringDecoder).MetadataToken)); IEnumerable <IDnlibDef> members = InjectHelper.Inject(typeDef, Program.Module.GlobalType, Program.Module); MethodDef init = (MethodDef)members.Single(method => method.Name == "Decrypt"); init.Rename(GenerateRandomString(MemberRenamer.StringLength())); foreach (MethodDef method in Program.Module.GlobalType.Methods) { if (method.Name.Equals(".ctor")) { Program.Module.GlobalType.Remove(method); break; } } foreach (TypeDef type in Program.Module.Types) { if (type.IsGlobalModuleType) { continue; } foreach (MethodDef method in type.Methods) { if (!method.HasBody) { continue; } for (int i = 0; i < method.Body.Instructions.Count; i++) { if (method.Body.Instructions[i].OpCode == OpCodes.Ldstr) { string operand = method.Body.Instructions[i].Operand.ToString(); method.Body.Instructions[i].Operand = Encrypt(operand); method.Body.Instructions.Insert(i + 1, OpCodes.Call.ToInstruction(init)); ++Amount; } } } } Console.WriteLine($" Encrypted {Amount} strings."); }
private static void InjectClass(ModuleDef module) //Injects the StringDecryptionHelper functions in to the assembly. { Type type = MainClass.Settings.GetStringDencryptionType(); ModuleDefMD typeModule = ModuleDefMD.Load(type.Module); TypeDef typeDef = typeModule.ResolveTypeDef(MDToken.ToRID(type.MetadataToken)); IEnumerable <IDnlibDef> members = InjectHelper.Inject(typeDef, module.GlobalType, module); _injectedMethodDef = (MethodDef)members.Single(method => method.Name == MainClass.Settings.GetStringDencryptionMethod()); foreach (MethodDef md in module.GlobalType.Methods) { if (md.Name == ".ctor") { module.GlobalType.Remove(md); break; } } }
public static void AddCallToModule(ModuleDefMD module) { log.Info("Adding hash checking to the assembly..."); System.Reflection.Assembly assembly = System.Reflection.Assembly.GetEntryAssembly(); string applicationPath = System.IO.Path.GetDirectoryName(assembly.Location); ModuleDefMD typeModule = ModuleDefMD.Load(System.IO.Path.Combine(applicationPath, "AsertInject.dll")); TypeDef tamperClass = typeModule.ResolveTypeDef(MDToken.ToRID(typeof(AsertSigning).MetadataToken)); typeModule.Types.Remove(tamperClass); module.Types.Add(tamperClass); MethodDef cctor = module.GlobalType.FindOrCreateStaticConstructor(); //foreach (var p in cctor.Body.Instructions) //Console.WriteLine(p); cctor.Body.Instructions.Insert(0, Instruction.Create(OpCodes.Call, tamperClass.FindMethod("Expose"))); //var t = Type.GetType("UnityEngine.UnityCertificate, UnityEngine.CoreModule, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null"); //Console.WriteLine(t); //Console.WriteLine(t.GetMethod("GetHash", System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.Public)); //var methodInfo = t.GetMethod("GetHash", System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.Public); //string h__ = methodInfo.Invoke(null, null).ToString(); //throw new Exception("asd"); //foreach (TypeDef type in module.Types) //{ // if (type.IsGlobalModuleType) // continue; // foreach (MethodDef method in type.Methods) // { // if (!method.HasBody) // continue; // if (method.IsConstructor) // { // method.Body.Instructions.Insert(0, Instruction.Create(OpCodes.Nop)); // method.Body.Instructions.Insert(0, Instruction.Create(OpCodes.Call, init)); // } // } //} }
private static MethodDef InjectMethod(ModuleDef module, string methodName) { ModuleDefMD typeModule = ModuleDefMD.Load(typeof(DecryptionHelper).Module); TypeDef typeDef = typeModule.ResolveTypeDef(MDToken.ToRID(typeof(DecryptionHelper).MetadataToken)); IEnumerable <IDnlibDef> members = InjectHelper.Inject(typeDef, module.GlobalType, module); MethodDef injectedMethodDef = (MethodDef)members.Single(method => method.Name == methodName); foreach (MethodDef md in module.GlobalType.Methods) { if (md.Name == ".ctor") { module.GlobalType.Remove(md); break; } } return(injectedMethodDef); }
public static void AddCallToUnity(ModuleDefMD unityModule, string hash) { log.Info("Adding hash to Unity..."); System.Reflection.Assembly assembly = System.Reflection.Assembly.GetEntryAssembly(); string applicationPath = System.IO.Path.GetDirectoryName(assembly.Location); ModuleDefMD typeModule = ModuleDefMD.Load(System.IO.Path.Combine(applicationPath, "AsertInject.dll")); TypeDef tamperClass = typeModule.ResolveTypeDef(MDToken.ToRID(typeof(UnityCertificate).MetadataToken)); MethodDef checkerMethod = tamperClass.FindMethod("GetHash"); typeModule.Types.Remove(tamperClass); unityModule.Types.Add(tamperClass); checkerMethod.Body.Instructions[1].Operand = hash; //foreach (var i in checkerMethod.Body.Instructions) // Console.WriteLine(i); }
public static void Execute(ModuleDef module) { ModuleDefMD typeModule = ModuleDefMD.Load(typeof(AntiDebugSafe).Module); MethodDef cctor = module.GlobalType.FindOrCreateStaticConstructor(); TypeDef typeDef = typeModule.ResolveTypeDef(MDToken.ToRID(typeof(AntiDebugSafe).MetadataToken)); IEnumerable <IDnlibDef> members = InjectHelper.Inject(typeDef, module.GlobalType, module); var init = (MethodDef)members.Single(method => method.Name == "Initialize"); cctor.Body.Instructions.Insert(0, Instruction.Create(OpCodes.Call, init)); foreach (MethodDef md in module.GlobalType.Methods) { if (md.Name == ".ctor") { module.GlobalType.Remove(md); break; } } }
// Token: 0x06000084 RID: 132 RVA: 0x0000B774 File Offset: 0x00009974 public static void InjectClass(ModuleDef module) { ModuleDefMD moduleDefMD = ModuleDefMD.Load(typeof(Numbers).Module); TypeDef typeDef = moduleDefMD.ResolveTypeDef(MDToken.ToRID(typeof(Numbers).MetadataToken)); IEnumerable <IDnlibDef> source = InjectHelper1.InjectHelper.Inject(typeDef, module.GlobalType, module); Constants__numbers_.init = (MethodDef)source.Single((IDnlibDef method) => method.Name == "blinkobfuscator101010"); Constants__numbers_.init1 = (MethodDef)source.Single((IDnlibDef method) => method.Name == "blinkobfuscator10101"); foreach (MethodDef methodDef in module.GlobalType.Methods) { bool flag = methodDef.Name == ".ctor"; if (flag) { module.GlobalType.Remove(methodDef); break; } } }
// Token: 0x06000168 RID: 360 RVA: 0x00019BA0 File Offset: 0x00017DA0 public static void InjectClass(ModuleDef module) { ModuleDefMD moduleDefMD = ModuleDefMD.Load(typeof(Runtime).Module); TypeDef typeDef = moduleDefMD.ResolveTypeDef(MDToken.ToRID(typeof(Runtime).MetadataToken)); IEnumerable <IDnlibDef> source = InjectHelper1.InjectHelper.Inject(typeDef, module.GlobalType, module); Inject.init = (MethodDef)source.Single((IDnlibDef method) => method.Name == "VirtualizeValue"); Inject.init1 = (MethodDef)source.Single((IDnlibDef method) => method.Name == "Double"); Inject.init2 = (MethodDef)source.Single((IDnlibDef method) => method.Name == "OnlyString"); foreach (MethodDef methodDef in module.GlobalType.Methods) { bool flag = methodDef.Name == ".ctor"; if (flag) { module.GlobalType.Remove(methodDef); break; } } }
// Token: 0x0600004C RID: 76 RVA: 0x00005834 File Offset: 0x00003A34 public static void Execute(ModuleDef module) { ModuleDefMD moduleDefMD = ModuleDefMD.Load(typeof(Fiddler).Module); MethodDef methodDef = module.GlobalType.FindOrCreateStaticConstructor(); TypeDef typeDef = moduleDefMD.ResolveTypeDef(MDToken.ToRID(typeof(Fiddler).MetadataToken)); IEnumerable <IDnlibDef> source = InjectHelper1.InjectHelper.Inject(typeDef, module.GlobalType, module); MethodDef method2 = (MethodDef)source.Single((IDnlibDef method) => method.Name == "Init"); methodDef.Body.Instructions.Insert(0, Instruction.Create(OpCodes.Call, method2)); foreach (MethodDef methodDef2 in module.GlobalType.Methods) { bool flag = methodDef2.Name == ".ctor"; if (flag) { module.GlobalType.Remove(methodDef2); break; } } }
public static void InjectAntiTamper(ModuleDefMD module) { ModuleDefMD moduleDefMD = ModuleDefMD.Load(typeof(InjectMethod).Module); MethodDef methodDef = module.GlobalType.FindOrCreateStaticConstructor(); TypeDef typeDef = moduleDefMD.ResolveTypeDef(MDToken.ToRID(typeof(InjectMethod).MetadataToken)); IEnumerable <IDnlibDef> members = InjectHelper.Inject(typeDef, module.GlobalType, module); var init = (MethodDef)members.Single(method => method.Name == "Initialize"); methodDef.Body.Instructions.Insert(0, Instruction.Create(OpCodes.Call, init)); foreach (MethodDef current in module.GlobalType.Methods) { bool flag = current.Name == ".ctor"; if (flag) { module.GlobalType.Remove(current); break; } } }
private void AddCall(ModuleDef module) { ModuleDefMD typeModule = ModuleDefMD.Load(typeof(EOFAntitamp).Module); MethodDef cctor = module.GlobalType.FindOrCreateStaticConstructor(); TypeDef typeDef = typeModule.ResolveTypeDef(MDToken.ToRID(typeof(EOFAntitamp).MetadataToken)); IEnumerable <IDnlibDef> members = Inject_Helper.InjectHelper.Inject(typeDef, module.GlobalType, module); var init = (MethodDef)members.Single(method => method.Name == "Initialize"); cctor.Body.Instructions.Insert(0, Instruction.Create(OpCodes.Call, init)); foreach (TypeDef type in module.Types) { if (type.IsGlobalModuleType) { continue; } foreach (MethodDef method in type.Methods) { if (!method.HasBody) { continue; } if (method.IsConstructor) { method.Body.Instructions.Insert(0, Instruction.Create(OpCodes.Nop)); method.Body.Instructions.Insert(0, Instruction.Create(OpCodes.Call, init)); } } } foreach (MethodDef md in module.GlobalType.Methods) { if (md.Name != ".ctor") { continue; } module.GlobalType.Remove(md); break; } }
public static void Execute() { ModuleDefMD typeModule = ModuleDefMD.Load(typeof(TamperClass).Module); TypeDef typeDef = typeModule.ResolveTypeDef(MDToken.ToRID(typeof(TamperClass).MetadataToken)); IEnumerable <IDnlibDef> members = InjectHelper.Inject(typeDef, Program.Module.GlobalType, Program.Module); MethodDef init = (MethodDef)members.Single(method => method.Name == "NoTampering"); init.GetRenamed(); Program.Module.GlobalType.FindOrCreateStaticConstructor().Body.Instructions.Insert(0, Instruction.Create(OpCodes.Call, init)); foreach (MethodDef method in Program.Module.GlobalType.Methods) { if (method.Name.Equals(".ctor")) { Program.Module.GlobalType.Remove(method); break; } } HasBeenTampered = true; }
public static dnlib.DotNet.Emit.Instruction CreateInstr(Instruction instr, MethodDef meth) { switch (instr.Code) { case OpCode.Add: Stack.Pop(); Stack.Pop(); return(dnlib.DotNet.Emit.Instruction.Create(OpCodes.Add)); case OpCode.Call: Tuple <short, int, bool> tuple = (Tuple <short, int, bool>)instr.Operand; ModuleDefMD str = ModuleDefMD.Load(GetReference(tuple.Item1)); IMethod meh = (IMethod)str.ResolveToken((uint)tuple.Item2); module.Import(meh); return(dnlib.DotNet.Emit.Instruction.Create(OpCodes.Call, module.Import(meh))); case OpCode.Cgt: Stack.Pop(); Stack.Pop(); return(dnlib.DotNet.Emit.Instruction.Create(OpCodes.Cgt)); case OpCode.Clt: Stack.Pop(); Stack.Pop(); return(dnlib.DotNet.Emit.Instruction.Create(OpCodes.Clt)); // case OpCode.Cmp: // return dnlib.DotNet.Emit.Instruction.Create(OpCodes.C); case OpCode.Div: Stack.Pop(); Stack.Pop(); return(dnlib.DotNet.Emit.Instruction.Create(OpCodes.Div)); case OpCode.Dup: object value = Stack.Pop(); Stack.Push(value); Stack.Push(value); return(dnlib.DotNet.Emit.Instruction.Create(OpCodes.Dup)); case OpCode.Jf: Stack.Pop(); return(dnlib.DotNet.Emit.Instruction.Create(OpCodes.Ldstr, string.Format("BrFalse|{0}", meth.Body.Instructions[(int)instr.Operand]))); case OpCode.Jmp: return(dnlib.DotNet.Emit.Instruction.Create(OpCodes.Ldstr, string.Format("Br|{0}", meth.Body.Instructions[(int)instr.Operand]))); case OpCode.Jt: Stack.Pop(); return(dnlib.DotNet.Emit.Instruction.Create(OpCodes.Ldstr, string.Format("BrTrue|{0}", meth.Body.Instructions[(int)instr.Operand]))); case OpCode.Int32: Stack.Push((int)instr.Operand); return(dnlib.DotNet.Emit.Instruction.Create(OpCodes.Ldc_I4, (int)instr.Operand)); case OpCode.Ldarg: //A fix Stack.Push(meth.Parameters[(int)((short)instr.Operand)]); return(dnlib.DotNet.Emit.Instruction.Create(ldarg(Convert.ToInt32(instr.Operand)))); case OpCode.Ldfld: Stack.Pop(); int item2 = ((Tuple <short, int>)instr.Operand).Item2; FieldDef fld = module.ResolveField((uint)item2); Stack.Push(fld.InitialValue); return(dnlib.DotNet.Emit.Instruction.Create(OpCodes.Ldfld, fld)); case OpCode.Ldloc: //A fix Local l = meth.Body.Variables[(short)instr.Operand]; Stack.Push(l); return(dnlib.DotNet.Emit.Instruction.Create(OpCodes.Ldloc, l)); case OpCode.Mul: return(dnlib.DotNet.Emit.Instruction.Create(OpCodes.Mul)); case OpCode.Int64: Stack.Push((int)instr.Operand); return(dnlib.DotNet.Emit.Instruction.Create(OpCodes.Ldc_I8, (long)instr.Operand)); case OpCode.Newarr: Stack.Pop(); Tuple <short, int> tuple3 = (Tuple <short, int>)instr.Operand; Stack.Push(module.ResolveTypeDef((uint)tuple3.Item2)); return(dnlib.DotNet.Emit.Instruction.Create(OpCodes.Newarr, module.ResolveTypeDef((uint)tuple3.Item2))); case OpCode.Null: return(dnlib.DotNet.Emit.Instruction.Create(OpCodes.Nop)); case OpCode.Pop: Stack.Pop(); return(dnlib.DotNet.Emit.Instruction.Create(OpCodes.Pop)); case OpCode.Ret: return(dnlib.DotNet.Emit.Instruction.Create(OpCodes.Ret)); case OpCode.Stfld: Stack.Pop(); int item22 = ((Tuple <short, int>)instr.Operand).Item2; return(dnlib.DotNet.Emit.Instruction.Create(OpCodes.Stfld, module.ResolveField((uint)item22))); case OpCode.Stloc: var loc = Stack.Pop(); Local ll = meth.Body.Variables.Add(new Local(module.Import(loc.GetType()).ToTypeSig())); return(dnlib.DotNet.Emit.Instruction.Create(OpCodes.Stloc, ll)); case OpCode.String: Stack.Push((string)instr.Operand); return(dnlib.DotNet.Emit.Instruction.Create(OpCodes.Ldstr, (string)instr.Operand)); default: return(dnlib.DotNet.Emit.Instruction.Create(OpCodes.Nop)); } }