diff --git a/Assets/Dumper/DumpLib.dll b/Assets/Dumper/DumpLib.dll index 88d09ae..974ac83 100644 Binary files a/Assets/Dumper/DumpLib.dll and b/Assets/Dumper/DumpLib.dll differ diff --git a/ReCodeItCLI/Commands/Dumper.cs b/ReCodeItCLI/Commands/Dumper.cs index cb4208b..bf8fb61 100644 --- a/ReCodeItCLI/Commands/Dumper.cs +++ b/ReCodeItCLI/Commands/Dumper.cs @@ -17,9 +17,11 @@ public class Dumper : ICommand DataProvider.IsCli = true; DataProvider.LoadAppSettings(); - Logger.Log("Creating Dumper..."); - - ReCodeItLib.Dumper.Dumper.CreateDumper(ManagedDirectory); + Logger.Log("Creating DumperClass..."); + + var dumper = new DumperClass(ManagedDirectory); + dumper.CreateDumpFolders(); + dumper.CreateDumper(); Logger.Log("Complete", ConsoleColor.Green); diff --git a/RecodeItLib/Dumper/Dumper.cs b/RecodeItLib/Dumper/DumperClass.cs similarity index 50% rename from RecodeItLib/Dumper/Dumper.cs rename to RecodeItLib/Dumper/DumperClass.cs index 09f895f..4bb46ee 100644 --- a/RecodeItLib/Dumper/Dumper.cs +++ b/RecodeItLib/Dumper/DumperClass.cs @@ -1,88 +1,114 @@ -using Mono.Cecil; -using Mono.Cecil.Cil; +using System.Collections; +using dnlib.DotNet; +using dnlib.DotNet.Emit; using ReCodeIt.Utils; namespace ReCodeItLib.Dumper; -public class Dumper +public class DumperClass { - public static void CreateDumper(string managedPath) + private ModuleDefMD? _gameModule { get; set; } + private ModuleDefMD? _checkerModule { get; set; } + private string _assemblyPath { get; set; } + private string _fileCheckerPath { get; set; } + private string _managedPath { get; set; } + private List? _gameTypes { get; set; } + private List? _checkerTypes { get; set; } + + public DumperClass(string managedPath) { - var resolver = new DefaultAssemblyResolver(); - resolver.AddSearchDirectory(managedPath); + _managedPath = managedPath; + _assemblyPath = Path.Combine(managedPath, "Assembly-Csharp-cleaned.dll"); // TODO: must be the cleaned one + _fileCheckerPath = Path.Combine(managedPath, "FilesChecker.dll"); - // remove these dirs so it resolves to managed folder only - resolver.RemoveSearchDirectory("."); - resolver.RemoveSearchDirectory("bin"); + if (!File.Exists(_assemblyPath)) + { + Logger.Log($"File Assembly-CSharp-cleaned.dll does not exist at {_assemblyPath}", ConsoleColor.Red); + } - var readerParameters = new ReaderParameters { AssemblyResolver = resolver }; + if (!File.Exists(_fileCheckerPath)) + { + Logger.Log($"File FilesChecker.dll does not exist at {_fileCheckerPath}", ConsoleColor.Red); + } + + // will explode if they are not there? + _gameModule = DataProvider.LoadModule(_assemblyPath); + _checkerModule = DataProvider.LoadModule(_fileCheckerPath); + _gameTypes = _gameModule.GetTypes().ToList(); + _checkerTypes = _checkerModule.GetTypes().ToList(); + } + + + public void CreateDumper() + { + if (_gameModule == null || _gameTypes == null) + { + Logger.Log($"_gameModule or _gameTypes in DumpyRemake was null", ConsoleColor.Red); + return; + } - // Assembly-CSharp section - var assemblyPath = Path.Combine(managedPath, "Assembly-Csharp.dll"); - var dumperOutputPath = Path.Combine(managedPath, "dumper"); - var dumperBackupPath = Path.Combine(dumperOutputPath, "backup"); - var dumperDataFolder = Path.Combine(dumperOutputPath, "DUMPDATA"); - var newAssemblyPath = Path.Combine(dumperOutputPath, "Assembly-CSharp.dll"); - - Directory.CreateDirectory(dumperOutputPath); - Directory.CreateDirectory(dumperBackupPath); - Directory.CreateDirectory(dumperDataFolder); - - File.Copy(Path.Combine(managedPath, "Assembly-CSharp.dll"), Path.Combine(dumperBackupPath, "Assembly-CSharp.dll"), true); - File.Copy(Path.Combine(managedPath, "FilesChecker.dll"), Path.Combine(dumperBackupPath, "FilesChecker.dll"), true); - File.Copy(".\\Assets\\Dumper\\DumpLib.dll", Path.Combine(dumperOutputPath, "DumpLib.dll"), true); - File.Copy(".\\Assets\\Dumper\\DUMPDATA\\botReqData.json", dumperDataFolder + "\\botreqData.json", true); - File.Copy(".\\Assets\\Dumper\\DUMPDATA\\config.json", dumperDataFolder + "\\config.json", true); - File.Copy(".\\Assets\\Dumper\\DUMPDATA\\raidSettings.json", dumperDataFolder + "\\raidSettings.json", true); - - // loads assembly - var oldAssembly = AssemblyDefinition.ReadAssembly(assemblyPath, readerParameters); - - // gets all types - var types = oldAssembly.MainModule.GetTypes().ToList(); - - // finds and checks for type with backRequest - var backRequestType = types.Where(DumpyTypeHelper.GetBackRequestType).ToList(); + if (_checkerModule == null || _checkerTypes == null) + { + Logger.Log($"_checkerModule or _checkerTypes in DumpyRemake was null", ConsoleColor.Red); + return; + } + + // get required types + var backRequestType = _gameTypes.Where(DumpyTypeHelper.GetBackRequestType).ToList(); + var validateCertType = _gameTypes.Where(DumpyTypeHelper.GetValidateCertType).ToList(); + var runValidationType = _gameTypes.Where(DumpyTypeHelper.GetRunValidationType).ToList(); + var dumpyTaskType = _gameTypes.Where(DumpyTypeHelper.GetMenuscreenType).ToList(); + + // check types CheckNullOrMulti(backRequestType, "BackRequest"); - - // finds and checks for type with ValidateCertificate - var validateCertificateType = types.Where(DumpyTypeHelper.GetValidateCertificateType).ToList(); - CheckNullOrMulti(validateCertificateType, "ValidateCertificate"); - - // finds and checks for type with RunValidation - var runValidationType = types.Where(DumpyTypeHelper.GetRunValidationType).ToList(); + CheckNullOrMulti(validateCertType, "ValidateCertificate"); CheckNullOrMulti(runValidationType, "RunValidation"); - - var dumpyTaskType = types.Where(DumpyTypeHelper.GetMenuScreenType).ToList(); CheckNullOrMulti(dumpyTaskType, "DumpyTask"); - + // apply code changes - SetBackRequestCode(oldAssembly, backRequestType[0]); - SetValidateCertificateCode(validateCertificateType[0]); - SetRunValidationCode(oldAssembly, runValidationType[0]); - SetDumpyTaskCode(oldAssembly, dumpyTaskType[0]); - - // write modified assembly to file - oldAssembly.Write(newAssemblyPath); - - // FilesChecker section - var oldFilesCheckerPath = Path.Combine(managedPath, "FilesChecker.dll"); - var oldFilesChecker = AssemblyDefinition.ReadAssembly(oldFilesCheckerPath, readerParameters); - var newFilesCheckerPath = Path.Combine(dumperOutputPath, Path.GetFileName(oldFilesCheckerPath)); - - // gets all types - types = oldFilesChecker.MainModule.GetTypes().ToList(); - - // finds and checks for type called EnsureConsistency - var ensureConsistencyType = types.Where(DumpyTypeHelper.GetEnsureConsistencyType).ToList(); - CheckNullOrMulti(ensureConsistencyType, "EnsureConsistency"); + SetBackRequestCode(backRequestType[0]); + SetValidateCertCode(validateCertType[0]); + SetRunValidationCode(runValidationType[0]); + SetDumpyTaskCode(dumpyTaskType[0]); + // TODO: Write game assembly to file + _gameModule.Write(Path.Combine(_managedPath, "Assembly-CSharp-dumper.dll")); + + // get types + var ensureConsistencyTypes = _checkerTypes.Where(DumpyTypeHelper.GetEnsureConsistencyType).ToList(); + + // check types + CheckNullOrMulti(ensureConsistencyTypes, "EnsureConsistency"); + // apply code changes - SetEnsureConsistencyCode(oldFilesChecker, ensureConsistencyType[0]); - SetEnsureConsistencySingleCode(oldFilesChecker, ensureConsistencyType[0]); + SetEnsureConsistencyCode(ensureConsistencyTypes[0]); + SetEnsureConsistencySingleCode(ensureConsistencyTypes[0]); + + // TODO: Write fileChecker assembly to file + _checkerModule.Write(Path.Combine(_managedPath, "FilesChecker-dumper.dll")); + } + + public void CreateDumpFolders() + { + // create dumper folders + } - // Write modified assembly to file - oldFilesChecker.Write(newFilesCheckerPath); + /// + /// Checks for null or multiple types + /// + /// ICollection + /// string + private void CheckNullOrMulti(ICollection types, string name = "") + { + if (types == null) + { + Logger.Log($"{name} was null"); + } + + if (types.Count > 1) + { + Logger.Log($"{name} count was more than 1"); + } } /// @@ -93,34 +119,31 @@ public class Dumper /// /// /// - private static void SetBackRequestCode(AssemblyDefinition oldAssembly, TypeDefinition type) + private void SetBackRequestCode(TypeDef type) { // find method - var method = type.Methods.First(x => - x.Parameters.Any(p => p.Name is "backRequest") && x.Parameters.Any(p => p.Name == "bResponse")); + var method = type.Methods.First(x => x.Parameters.Any(p => p.Name is "backRequest" && x.Parameters.Any(p => p.Name == "bResponse"))); if (method == null || method.Body.Instructions.Count != 269) { Logger.Log($"BackRequest Instructions count has changed from 269 to {method.Body.Instructions.Count}", ConsoleColor.Red); } - // where we insert the new instructions var startOfInstructions = 252; - - var processor = method.Body.GetILProcessor(); - - var liList = DumpyInstructionsHelper.GetBackRequestInstructions(oldAssembly, method); - + var liList = DumpyInstructionsHelper.GetBackRequestInstructions(_gameModule, method); var index = method.Body.Instructions[startOfInstructions]; - foreach (var item in liList) + foreach (var li in liList) { - processor.InsertBefore(index, item); + // something along these lines, this needs to be tested + method.Body.Instructions.InsertBefore(index, li); } - var ins = Instruction.Create(OpCodes.Brfalse_S, method.Body.Instructions[startOfInstructions]); // create instruction to jump to index 252 + // create instruction + var ins = Instruction.Create(OpCodes.Brfalse_S, method.Body.Instructions[startOfInstructions]); - method.Body.Instructions[220] = ins; // instruction to jump from 202 to 252 + // replace instruction at 220 with this + method.Body.Instructions[220] = ins; } /// @@ -131,7 +154,7 @@ public class Dumper /// /// /// - private static void SetValidateCertificateCode(TypeDefinition type) + private void SetValidateCertCode(TypeDef type) { var methods = type.Methods.Where(x => x.Name == "ValidateCertificate"); // should be 2 @@ -142,10 +165,8 @@ public class Dumper if (firstMethod?.Body.Instructions.Count != 55 || secondMethod?.Body.Instructions.Count != 14) { - var errorMessage = - $"Instruction count has changed, method with 'certificate' as a param - before: 51, now: {firstMethod.Body.Instructions.Count}, " + - $"method with 'certificateData' as a param - before: 14, now: {secondMethod.Body.Instructions.Count}"; - Logger.Log(errorMessage, ConsoleColor.Red); + Logger.Log($"Instruction count has changed, method with 'certificate' as a param - before: 51, now: {firstMethod.Body.Instructions.Count}, " + + $"method with 'certificateData' as a param - before: 14, now: {secondMethod.Body.Instructions.Count}", ConsoleColor.Red); } if (methods.Count() != 2) @@ -178,19 +199,21 @@ public class Dumper /// /// /// - private static void SetRunValidationCode(AssemblyDefinition oldAssembly, TypeDefinition type) + private void SetRunValidationCode(TypeDef type) { + var importer = new Importer(_gameModule); + var method = type.Methods.First(x => x.Name == "RunValidation"); var method2 = type.NestedTypes[0].Methods.First(x => x.Name == "MoveNext"); if (method == null || method.Body.Instructions.Count != 25) { - Logger.Log($"RunValidation Instructions count has changed from 25 to {method.Body.Instructions.Count}", ConsoleColor.Red); + Logger.Log($"RunValidation Instructions count has changed from 25 to {method.Body.Instructions.Count}"); } if (method2 == null || method2.Body.Instructions.Count != 171) { - Logger.Log($"RunValidation's MoveNext Instructions count has changed from 171 to {method2.Body.Instructions.Count}", ConsoleColor.Red); + Logger.Log($"RunValidation's MoveNext Instructions count has changed from 171 to {method2.Body.Instructions.Count}"); } // Clear these from the body of each method respectively @@ -199,27 +222,24 @@ public class Dumper method2.Body.Variables.Clear(); method2.Body.ExceptionHandlers.Clear(); - var processor = method.Body.GetILProcessor(); - var processor2 = method2.Body.GetILProcessor(); - - var liList = DumpyInstructionsHelper.GetRunValidationInstructions(oldAssembly, method); - var liList2 = DumpyInstructionsHelper.GetRunValidationInstructionsMoveNext(oldAssembly, method2); + var liList = DumpyInstructionsHelper.GetRunValidationInstructions(_gameModule, method); + var liList2 = DumpyInstructionsHelper.GetRunValidationInstructionsMoveNext(_gameModule, method2); foreach (var instruction in liList) { - processor.Append(instruction); + method.Body.Instructions.Add(instruction); } - + foreach (var instruction in liList2) { - processor2.Append(instruction); + method2.Body.Instructions.Add(instruction); } var ins = Instruction.Create(OpCodes.Leave_S, method2.Body.Instructions[14]); // Create instruction to jump to index 14 var ins1 = Instruction.Create(OpCodes.Leave_S, method2.Body.Instructions[method2.Body.Instructions.IndexOf(method2.Body.Instructions.Last())]); // Create instruction to jump to last index - processor2.InsertAfter(method2.Body.Instructions[5], ins); // Instruction to jump from 5 to 14 - processor2.InsertAfter(method2.Body.Instructions[14], ins1); // Instruction to jump from 14 to last index + method2.Body.Instructions.InsertAfter(method2.Body.Instructions[5], ins); // Instruction to jump from 5 to 14 + method2.Body.Instructions.InsertAfter(method2.Body.Instructions[14], ins1); // Instruction to jump from 14 to last index // Create exception handler with defined indexes var handler = new ExceptionHandler(ExceptionHandlerType.Catch) @@ -228,13 +248,32 @@ public class Dumper TryEnd = method2.Body.Instructions[7], HandlerStart = method2.Body.Instructions[7], HandlerEnd = method2.Body.Instructions[16], - CatchType = method2.Module.ImportReference(typeof(Exception)), + CatchType = importer.Import(typeof(Exception)), }; // Add exception handler to method body method2.Body.ExceptionHandlers.Add(handler); } + private void SetDumpyTaskCode(TypeDef type) + { + var method = type.Methods.First(x => x.Name == "Awake"); + + if (method == null || method.Body.Instructions.Count != 62) + { + Logger.Log($"MainMenu is null or isnt 62 instructions, SOMETHING HAD CHANGED!", ConsoleColor.Red); + } + + var liList = DumpyInstructionsHelper.GetDumpyTaskInstructions(_gameModule, method); + + var index = method.Body.Instructions.First(x => x.OpCode == OpCodes.Ret); + + foreach (var item in liList) + { + method.Body.Instructions.InsertBefore(index, item); + } + } + /// /// Finds the method called EnsureConsistency. /// if this is not the case, this needs to be checked. @@ -242,27 +281,25 @@ public class Dumper /// /// /// - private static void SetEnsureConsistencyCode(AssemblyDefinition oldFileChecker, TypeDefinition type) + private void SetEnsureConsistencyCode(TypeDef type) { var method = type.Methods.First(x => x.Name == "EnsureConsistency"); if (method == null || method.Body.Instructions.Count != 152) { - Logger.Log($"EnsureConsistency is null or Instructions count has changed from 152 to {method.Body.Instructions.Count}", ConsoleColor.Red); + Logger.Log($"EnsureConsistency Instructions count has changed from 152 to {method.Body.Instructions.Count}", ConsoleColor.Red); } - var processor = method.Body.GetILProcessor(); - // clear these from the method body method.Body.Instructions.Clear(); method.Body.Variables.Clear(); method.Body.ExceptionHandlers.Clear(); - var liList = DumpyInstructionsHelper.GetEnsureConsistencyInstructions(oldFileChecker, method); - + var liList = DumpyInstructionsHelper.GetEnsureConsistencyInstructions(_gameModule, _checkerModule, method); + foreach (var li in liList) { - processor.Append(li); + method.Body.Instructions.Append(li); } } @@ -273,13 +310,13 @@ public class Dumper /// /// /// - private static void SetEnsureConsistencySingleCode(AssemblyDefinition oldFileChecker, TypeDefinition type) + private void SetEnsureConsistencySingleCode(TypeDef type) { var method = type.Methods.First(x => x.Name == "EnsureConsistencySingle"); if (method == null || method.Body.Instructions.Count != 101) { - Logger.Log($"EnsureConsistencySingle is null or Instructions count has changed from 101 to {method.Body.Instructions.Count}", ConsoleColor.Red); + Logger.Log($"EnsureConsistencySingle Instructions count has changed from 101 to {method.Body.Instructions.Count}", ConsoleColor.Red); } // clear these from the method body @@ -287,52 +324,11 @@ public class Dumper method.Body.Variables.Clear(); method.Body.ExceptionHandlers.Clear(); - var processor = method.Body.GetILProcessor(); - - var liList = DumpyInstructionsHelper.GetEnsureConsistencyInstructions(oldFileChecker, method); - + var liList = DumpyInstructionsHelper.GetEnsureConsistencyInstructions(_gameModule, _checkerModule, method); + foreach (var li in liList) { - processor.Append(li); - } - } - - private static void SetDumpyTaskCode(AssemblyDefinition oldAssembly, TypeDefinition type) - { - var method = type.Methods.First(x => x.Name == "Awake"); - - if (method == null || method.Body.Instructions.Count != 62) - { - Logger.Log($"MainMenu is null or instructions have changed from 62 to {method.Body.Instructions.Count}", ConsoleColor.Red); - } - - var processor = method.Body.GetILProcessor(); - - var liList = DumpyInstructionsHelper.GetDumpyTaskInstructions(oldAssembly, method); - - var index = method.Body.Instructions.First(x => x.OpCode == OpCodes.Ret); - - foreach (var item in liList) - { - processor.InsertBefore(index, item); - } - } - - /// - /// Checks for null or multiple types - /// - /// ICollection - /// string - public static void CheckNullOrMulti(List types, string name = "") - { - if (types == null) - { - Logger.Log($"{name} was null", ConsoleColor.Red); - } - - if (types.Count > 1) - { - Logger.Log($"{name} count was more than 1", ConsoleColor.Red); + method.Body.Instructions.Append(li); } } } \ No newline at end of file diff --git a/RecodeItLib/Dumper/DumpyInstructionsHelper.cs b/RecodeItLib/Dumper/DumpyInstructionsHelper.cs index 8bcb40d..c398255 100644 --- a/RecodeItLib/Dumper/DumpyInstructionsHelper.cs +++ b/RecodeItLib/Dumper/DumpyInstructionsHelper.cs @@ -1,10 +1,12 @@ using System; using System.Collections.Generic; using System.Linq; +using System.Reflection.Metadata; +using System.Runtime.CompilerServices; using System.Threading.Tasks; +using dnlib.DotNet; +using dnlib.DotNet.Emit; using DumpLib; -using Mono.Cecil; -using Mono.Cecil.Cil; namespace ReCodeItLib.Dumper; @@ -16,13 +18,15 @@ public static class DumpyInstructionsHelper /// AssemblyDefinition /// MethodDefinition /// List - public static List GetBackRequestInstructions(AssemblyDefinition assembly, MethodDefinition method) + public static List GetBackRequestInstructions(ModuleDefMD assembly, MethodDef method) { + var importer = new Importer(assembly); + return new List { Instruction.Create(OpCodes.Ldarg_1), Instruction.Create(OpCodes.Ldloc_S, method.Body.Variables[6]), - Instruction.Create(OpCodes.Call, assembly.MainModule.ImportReference(typeof(DumpLib.DumpyTool).GetMethod("LogRequestResponse", new[] { typeof(object), typeof(object) }))) + Instruction.Create(OpCodes.Call, importer.Import(typeof(DumpLib.DumpyTool).GetMethod("LogRequestResponse", new[] { typeof(object), typeof(object) }))) }; } @@ -33,18 +37,20 @@ public static class DumpyInstructionsHelper /// AssemblyDefinition /// MethodDefinition /// List - public static List GetRunValidationInstructionsMoveNext(AssemblyDefinition assembly, MethodDefinition method) + public static List GetRunValidationInstructionsMoveNext(ModuleDefMD assembly, MethodDef method) { + var importer = new Importer(assembly); + // Add our own local variables // var1 index0 class1159Type - var sptClassType = assembly.MainModule.GetTypes().First(DumpyTypeHelper.GetRunValidationType); - var sptClass = new VariableDefinition(sptClassType); + var sptClassType = assembly.GetTypes().First(DumpyTypeHelper.GetRunValidationType); + var sptClass = new Local(sptClassType.ToTypeSig()); method.Body.Variables.Add(sptClass); // var2 index1 ExceptionType - var sptExceptionType = method.Module.ImportReference(typeof(Exception)); - var sptException = new VariableDefinition(sptExceptionType); + var sptExceptionType = importer.Import(typeof(Exception)); + var sptException = new Local(sptExceptionType.ToTypeSig()); method.Body.Variables.Add(sptException); return new List @@ -52,31 +58,31 @@ public static class DumpyInstructionsHelper // most of this is to keep the Async happy Instruction.Create(OpCodes.Ldarg_0), - Instruction.Create(OpCodes.Ldfld, assembly.MainModule.GetTypes().First(DumpyTypeHelper.GetRunValidationType).NestedTypes[0].Fields[2]), + Instruction.Create(OpCodes.Ldfld, assembly.GetTypes().First(DumpyTypeHelper.GetRunValidationType).NestedTypes[0].Fields[2]), Instruction.Create(OpCodes.Stloc_0), // this.Succeed = true; Instruction.Create(OpCodes.Ldloc_0), Instruction.Create(OpCodes.Ldc_I4_1), - Instruction.Create(OpCodes.Call, assembly.MainModule.GetTypes().First(DumpyTypeHelper.GetRunValidationType).Methods.First(x => x.Name == "set_Succeed")), + Instruction.Create(OpCodes.Call, assembly.GetTypes().First(DumpyTypeHelper.GetRunValidationType).Methods.First(x => x.Name == "set_Succeed")), Instruction.Create(OpCodes.Stloc_1), Instruction.Create(OpCodes.Ldarg_0), Instruction.Create(OpCodes.Ldc_I4_S, (sbyte)-2), - Instruction.Create(OpCodes.Stfld, assembly.MainModule.GetTypes().First(DumpyTypeHelper.GetRunValidationType).NestedTypes[0].Fields[0]), + Instruction.Create(OpCodes.Stfld, assembly.GetTypes().First(DumpyTypeHelper.GetRunValidationType).NestedTypes[0].Fields[0]), Instruction.Create(OpCodes.Ldarg_0), - Instruction.Create(OpCodes.Ldflda, assembly.MainModule.GetTypes().First(DumpyTypeHelper.GetRunValidationType).NestedTypes[0].Fields[1]), + Instruction.Create(OpCodes.Ldflda, assembly.GetTypes().First(DumpyTypeHelper.GetRunValidationType).NestedTypes[0].Fields[1]), Instruction.Create(OpCodes.Ldloc_1), Instruction.Create(OpCodes.Call, - method.Module.ImportReference(assembly.MainModule.GetTypes().First(DumpyTypeHelper.GetRunValidationType).NestedTypes[0].Fields[1].FieldType.Resolve().Methods.First(x => x.Name == "SetException"))), + importer.Import(assembly.GetTypes().First(DumpyTypeHelper.GetRunValidationType).NestedTypes[0].Fields[1].FieldType.ScopeType.ResolveTypeDef().Methods.First(x => x.Name == "SetException"))), Instruction.Create(OpCodes.Ldarg_0), Instruction.Create(OpCodes.Ldc_I4_S, (sbyte)-2), - Instruction.Create(OpCodes.Stfld, assembly.MainModule.GetTypes().First(DumpyTypeHelper.GetRunValidationType).NestedTypes[0].Fields[0]), + Instruction.Create(OpCodes.Stfld, assembly.GetTypes().First(DumpyTypeHelper.GetRunValidationType).NestedTypes[0].Fields[0]), Instruction.Create(OpCodes.Ldarg_0), - Instruction.Create(OpCodes.Ldflda, assembly.MainModule.GetTypes().First(DumpyTypeHelper.GetRunValidationType).NestedTypes[0].Fields[1]), - Instruction.Create(OpCodes.Call, method.Module.ImportReference(assembly.MainModule.GetTypes().First(DumpyTypeHelper.GetRunValidationType).NestedTypes[0].Fields[1].FieldType.Resolve().Methods.First(x => x.Name == "SetResult"))), + Instruction.Create(OpCodes.Ldflda, assembly.GetTypes().First(DumpyTypeHelper.GetRunValidationType).NestedTypes[0].Fields[1]), + Instruction.Create(OpCodes.Call, importer.Import(assembly.GetTypes().First(DumpyTypeHelper.GetRunValidationType).NestedTypes[0].Fields[1].FieldType.ScopeType.ResolveTypeDef().Methods.First(x => x.Name == "SetResult"))), Instruction.Create(OpCodes.Ret), }; @@ -89,28 +95,29 @@ public static class DumpyInstructionsHelper /// AssemblyDefinition /// MethodDefinition /// List - public static List GetEnsureConsistencyInstructions(AssemblyDefinition oldFileChecker, MethodDefinition method) + public static List GetEnsureConsistencyInstructions(ModuleDefMD assembly, ModuleDefMD fileChecker, MethodDef method) { + var importer = new Importer(assembly); + // init local vars // var1 index0 TimeSpan type - var sptTimeSpanType = method.Module.ImportReference(typeof(TimeSpan)); - var sptClass = new VariableDefinition(sptTimeSpanType); + var sptTimeSpanType = importer.Import(typeof(TimeSpan)); + var sptClass = new Local(sptTimeSpanType.ToTypeSig()); method.Body.Variables.Add(sptClass); // Create genericInstance of a method - var type = oldFileChecker.MainModule.GetTypes().First(DumpyTypeHelper.GetEnsureConsistencyType).NestedTypes[0].Interfaces[0].InterfaceType; - var typeMethod = method.Module.ImportReference(typeof(Task).GetMethod("FromResult")); - var instanceType = new GenericInstanceMethod(typeMethod); - instanceType.GenericArguments.Add(type); + var type = fileChecker.GetTypes().First(DumpyTypeHelper.GetEnsureConsistencyType).NestedTypes[0].Interfaces[0].Interface; + var typeMethod = importer.Import(typeof(Task).GetMethod("FromResult")); + var generac = new MethodSpecUser(typeMethod.ResolveMethodDef(), new GenericInstMethodSig(type.ToTypeSig())); return new List { // return Task.FromResult(ConsistencyController.CheckResult.Succeed(default(TimeSpan))); Instruction.Create(OpCodes.Ldloca_S, method.Body.Variables[0]), - Instruction.Create(OpCodes.Initobj, method.Module.ImportReference(typeof(TimeSpan))), + Instruction.Create(OpCodes.Initobj, importer.Import(typeof(TimeSpan))), Instruction.Create(OpCodes.Ldloc_0), - Instruction.Create(OpCodes.Call, oldFileChecker.MainModule.GetTypes().First(DumpyTypeHelper.GetEnsureConsistencyType).NestedTypes[0].Methods.First(x => x.Name == "Succeed")), - Instruction.Create(OpCodes.Call, instanceType), + Instruction.Create(OpCodes.Call, fileChecker.GetTypes().First(DumpyTypeHelper.GetEnsureConsistencyType).NestedTypes[0].Methods.First(x => x.Name == "Succeed")), + Instruction.Create(OpCodes.Call, generac), Instruction.Create(OpCodes.Ret) }; } @@ -122,50 +129,53 @@ public static class DumpyInstructionsHelper /// AssemblyDefinition /// MethodDefinition /// List - public static List GetRunValidationInstructions(AssemblyDefinition assembly, MethodDefinition method) + public static List GetRunValidationInstructions(ModuleDefMD assembly, MethodDef method) { + var importer = new Importer(assembly); + // Create genericInstance of a method - var type = assembly.MainModule.GetTypes().First(DumpyTypeHelper.GetRunValidationType).NestedTypes[0]; - var typeMethod = method.Module.ImportReference(assembly.MainModule.GetTypes().First(DumpyTypeHelper.GetRunValidationType).NestedTypes[0].Fields[1].FieldType.Resolve().Methods.First(x => x.Name == "Start")); - var instanceMethod = new GenericInstanceMethod(typeMethod); - instanceMethod.GenericArguments.Add(type); + var type = assembly.GetTypes().First(DumpyTypeHelper.GetRunValidationType).NestedTypes[0]; + var typeMethod = importer.Import(typeof(AsyncTaskMethodBuilder).GetMethod("Start")); + var generac = new MethodSpecUser(typeMethod as IMethodDefOrRef, new GenericInstMethodSig(type.ToTypeSig())); return new List { // d__.<>t__builder = AsyncTaskMethodBuilder.Create(); Instruction.Create(OpCodes.Ldloca_S, method.Body.Variables[0]), - Instruction.Create(OpCodes.Call, method.Module.ImportReference(assembly.MainModule.GetTypes().First(DumpyTypeHelper.GetRunValidationType).NestedTypes[0].Fields[1].FieldType.Resolve().Methods.First(x => x.Name == "Create"))), - Instruction.Create(OpCodes.Stfld, assembly.MainModule.GetTypes().First(DumpyTypeHelper.GetRunValidationType).NestedTypes[0].Fields[1]), + Instruction.Create(OpCodes.Call, importer.Import(assembly.GetTypes().First(DumpyTypeHelper.GetRunValidationType).NestedTypes[0].Fields[1].FieldType.ScopeType.ResolveTypeDef().Methods.First(x => x.Name == "Create"))), + Instruction.Create(OpCodes.Stfld, assembly.GetTypes().First(DumpyTypeHelper.GetRunValidationType).NestedTypes[0].Fields[1]), // d__.<>4__this = this; Instruction.Create(OpCodes.Ldloca_S, method.Body.Variables[0]), Instruction.Create(OpCodes.Ldarg_0), - Instruction.Create(OpCodes.Stfld, assembly.MainModule.GetTypes().First(DumpyTypeHelper.GetRunValidationType).NestedTypes[0].Fields[2]), + Instruction.Create(OpCodes.Stfld, assembly.GetTypes().First(DumpyTypeHelper.GetRunValidationType).NestedTypes[0].Fields[2]), // d__.<>1__state = -1; Instruction.Create(OpCodes.Ldloca_S, method.Body.Variables[0]), Instruction.Create(OpCodes.Ldc_I4_M1), - Instruction.Create(OpCodes.Stfld, assembly.MainModule.GetTypes().First(DumpyTypeHelper.GetRunValidationType).NestedTypes[0].Fields[0]), + Instruction.Create(OpCodes.Stfld, assembly.GetTypes().First(DumpyTypeHelper.GetRunValidationType).NestedTypes[0].Fields[0]), // d__.<>t__builder.Startd__0>(ref d__); Instruction.Create(OpCodes.Ldloca_S, method.Body.Variables[0]), - Instruction.Create(OpCodes.Ldflda, assembly.MainModule.GetTypes().First(DumpyTypeHelper.GetRunValidationType).NestedTypes[0].Fields[1]), + Instruction.Create(OpCodes.Ldflda, assembly.GetTypes().First(DumpyTypeHelper.GetRunValidationType).NestedTypes[0].Fields[1]), Instruction.Create(OpCodes.Ldloca_S, method.Body.Variables[0]), - Instruction.Create(OpCodes.Call, instanceMethod), + Instruction.Create(OpCodes.Call, generac), // return d__.<>t__builder.Task; Instruction.Create(OpCodes.Ldloca_S, method.Body.Variables[0]), - Instruction.Create(OpCodes.Ldflda, assembly.MainModule.GetTypes().First(DumpyTypeHelper.GetRunValidationType).NestedTypes[0].Fields[1]), - Instruction.Create(OpCodes.Call, method.Module.ImportReference(assembly.MainModule.GetTypes().First(DumpyTypeHelper.GetRunValidationType).NestedTypes[0].Fields[1].FieldType.Resolve().Methods.First(x => x.Name == "get_Task"))), + Instruction.Create(OpCodes.Ldflda, assembly.GetTypes().First(DumpyTypeHelper.GetRunValidationType).NestedTypes[0].Fields[1]), + Instruction.Create(OpCodes.Call, importer.Import(assembly.GetTypes().First(DumpyTypeHelper.GetRunValidationType).NestedTypes[0].Fields[1].FieldType.ScopeType.ResolveTypeDef().Methods.First(x => x.Name == "get_Task"))), Instruction.Create(OpCodes.Ret), }; } - public static List GetDumpyTaskInstructions(AssemblyDefinition oldAssembly, MethodDefinition method) + public static List GetDumpyTaskInstructions(ModuleDefMD assembly, MethodDef method) { + var importer = new Importer(assembly); + return new List { - Instruction.Create(OpCodes.Call, oldAssembly.MainModule.ImportReference(typeof(DumpyTool).GetMethod("StartDumpyTask"))), + Instruction.Create(OpCodes.Call, importer.Import(typeof(DumpyTool).GetMethod("StartDumpyTask"))), Instruction.Create(OpCodes.Pop) }; } diff --git a/RecodeItLib/Dumper/DumpyTypeHelper.cs b/RecodeItLib/Dumper/DumpyTypeHelper.cs index aa1407b..14064d9 100644 --- a/RecodeItLib/Dumper/DumpyTypeHelper.cs +++ b/RecodeItLib/Dumper/DumpyTypeHelper.cs @@ -1,5 +1,5 @@ using System.Linq; -using Mono.Cecil; +using dnlib.DotNet; namespace ReCodeItLib.Dumper; @@ -11,7 +11,7 @@ public static class DumpyTypeHelper /// /// TypeDefinition /// boolean - public static bool GetBackRequestType(TypeDefinition type) + public static bool GetBackRequestType(TypeDef type) { return type.Methods.Any(m => m.Name == "SendAndHandleRetries"); } @@ -21,7 +21,7 @@ public static class DumpyTypeHelper /// /// TypeDefinition /// boolean - public static bool GetValidateCertificateType(TypeDefinition type) + public static bool GetValidateCertType(TypeDef type) { return type.Methods.Any(m => m.Name == "ValidateCertificate"); } @@ -31,7 +31,7 @@ public static class DumpyTypeHelper /// /// TypeDefinition /// boolean - public static bool GetRunValidationType(TypeDefinition type) + public static bool GetRunValidationType(TypeDef type) { return type.Methods.Any(m => m.Name == "RunValidation"); } @@ -42,12 +42,12 @@ public static class DumpyTypeHelper /// /// TypeDefinition /// boolean - public static bool GetEnsureConsistencyType(TypeDefinition type) + public static bool GetEnsureConsistencyType(TypeDef type) { return type.Name == "ConsistencyController"; } - public static bool GetMenuScreenType(TypeDefinition type) + public static bool GetMenuscreenType(TypeDef type) { return type.Name == "MenuScreen"; } diff --git a/RecodeItLib/ReCodeItLib.csproj b/RecodeItLib/ReCodeItLib.csproj index b88cc57..bd741bc 100644 --- a/RecodeItLib/ReCodeItLib.csproj +++ b/RecodeItLib/ReCodeItLib.csproj @@ -178,16 +178,4 @@ - - - - Assets\DumpLib.dll - - - ..\Assets\MonoCecil\Mono.Cecil.dll - - - ..\Assets\MonoCecil\Mono.Cecil.Rocks.dll - -