public void SetBody(MethodBodyReader mbr) { Flags2 = mbr.Flags2; MaxStack = mbr.MaxStack; Locals = mbr.Locals; Instructions = mbr.Instructions; ExceptionHandlers = mbr.ExceptionHandlers; }
/// <summary> /// Declare the local variables used in the new method. /// </summary> private void DeclareLocalVariableTypes(ILGenerator generator, MethodBodyReader reader) { List <Type> locals = reader.GetLocalTypes(); // Declare all the local variable types. foreach (Type type in locals) { generator.DeclareLocal(type); } }
public static List <ILInstruction> GetInstructions(MethodBase method) { var dummy = new DynamicMethod("Dummy", typeof(void), new Type[] { }); if (method.GetMethodBody() is null) { return(null); } return(MethodBodyReader.GetInstructions(dummy.GetILGenerator(), method)); }
public MethodBody GetMethodBody(uint rid, RVA rva, IList <Parameter> parameters) { var dm = GetDumpedMethod(rid); if (dm == null) { return(null); } return(MethodBodyReader.CreateCilBody(module, dm.code, dm.extraSections, parameters, dm.mhFlags, dm.mhMaxStack, dm.mhCodeSize, dm.mhLocalVarSigTok)); }
internal static MethodBase TargetMethod() { var shwGetter = ReflectionHelper.Settings.GetProperty("ShowHaxchiWarning").GetGetMethod(); return((from method in ReflectionHelper.NusGrabberForm.GetMethods(BindingFlags.NonPublic | BindingFlags.Instance) where method.GetParameters().Length == 1 && method.GetParameters()[0].ParameterType.IsAbstract let instructions = MethodBodyReader.GetInstructions(null, method) where instructions.Any(i => i.opcode == OpCodes.Callvirt && ((MethodInfo)i.operand) == shwGetter) select method).FirstOrDefault()); }
public bool GetMethodBody(uint rid, RVA rva, IList <Parameter> parameters, GenericParamContext gpContext, out MethodBody methodBody) { var dm = GetDumpedMethod(rid); if (dm == null) { methodBody = null; return(false); } methodBody = MethodBodyReader.CreateCilBody(module, dm.code, dm.extraSections, parameters, dm.mhFlags, dm.mhMaxStack, dm.mhCodeSize, dm.mhLocalVarSigTok, gpContext); return(true); }
public static HashSet <int> ComputeLabels(MethodBase definition) { var labels = new HashSet <int>(); var body = definition.GetMethodBody(); if (body == null) { return(labels); } var instructions = MethodBodyReader.GetInstructions(definition); foreach (var instruction in instructions) { var opcodeStr = instruction.OpCode.Value; switch (opcodeStr) { case ObcodeIntValues.Beq: case ObcodeIntValues.BeqS: case ObcodeIntValues.Bne: case ObcodeIntValues.BneS: case ObcodeIntValues.Bge: case ObcodeIntValues.BgeS: case ObcodeIntValues.Bgt: case ObcodeIntValues.BgtS: case ObcodeIntValues.BrTrueS: case ObcodeIntValues.BrTrue: case ObcodeIntValues.BrZero: case ObcodeIntValues.BrZeroS: case ObcodeIntValues.Blt: case ObcodeIntValues.BltS: case ObcodeIntValues.BrS: case ObcodeIntValues.Br: case ObcodeIntValues.Leave: case ObcodeIntValues.LeaveS: { var offset = ((Instruction)instruction.Operand).Offset; AddLabelIfDoesntExist(offset, labels); } break; case ObcodeIntValues.Switch: { var offsets = (Instruction[])instruction.Operand; foreach (var offset in offsets) { AddLabelIfDoesntExist(offset.Offset, labels); } } break; } } return(labels); }
private void ParseInstructions(MethodInfo mi, string fromId) { MethodBodyReader mr = GetMethodBodyReader(mi); if (mr == null) { return; } if (mr.instructions == null) { return; } foreach (ILInstruction instruction in mr.instructions) { if (CheckWorker()) { break; } if (instruction.Operand == null) { continue; } if (instruction.Code.OperandType != OperandType.InlineMethod) { continue; } Type declType; string name, calledId; GetInstrDetails(instruction, out name, out declType, out calledId); if (name == null) { continue; } calledId = declType.FullName; BaseItem calledItem = _projectBrowser.Lookup(calledId); if (calledItem == null) { continue; } // Or external types - optional? if (_addedNodes.ContainsKey(calledId)) { AddEdge(fromId, calledId, EdgeStyle.NormalArrow); } } }
public static IEnumerable <CodeInstruction> TranspileStart(IEnumerable <CodeInstruction> instructions) { MethodBase ReplacementMethod = typeof(CheckPlantGrowthStageActionPatch).GetMethod("Start"); List <ILInstruction> MethodILInstructions = MethodBodyReader.GetInstructions(ReplacementMethod); List <CodeInstruction> ReplacementMethodInstructions = new List <CodeInstruction>(); foreach (ILInstruction MethodILInstruction in MethodILInstructions) { ReplacementMethodInstructions.Add(MethodILInstruction.GetCodeInstruction()); } return(ReplacementMethodInstructions); }
public static List <CodeInstruction> GetInstructionsFromMethod(MethodInfo targetMethod) { Validate.NotNull(targetMethod); List <CodeInstruction> instructions = new List <CodeInstruction>(); foreach (ILInstruction instruction in MethodBodyReader.GetInstructions(targetMethod)) { instructions.Add(instruction.GetCodeInstruction()); } return(instructions); }
private void lbAvailableMethodsList_SelectedValueChanged(object sender, EventArgs e) { try { MethodInfo mi = methods[lbAvailableMethodsList.SelectedIndex]; SDILReader.MethodBodyReader mr = new MethodBodyReader(mi); rchMethodBodyCode.Clear(); rchMethodBodyCode.Text = mr.GetBodyCode(); } catch { } }
protected MethodBodyReader GetMethodBodyReader(MethodInfo mi) { SDILReader.MethodBodyReader mr = null; try { mr = new MethodBodyReader(mi); } catch (System.IO.FileNotFoundException) { // We will already have been warned about missing files during the load. } return(mr); }
private void ParseInstructions(string methodNodeId, MethodInfo mi) { MethodBodyReader mr = GetMethodBodyReader(mi); if (mr == null) { return; } if (mr.instructions == null) { return; } foreach (ILInstruction instruction in mr.instructions) { if (CheckWorker()) { break; } if (instruction.Operand == null) { continue; } if (instruction.Code.OperandType != OperandType.InlineMethod) { continue; } Type declType; string name, calledId; GetInstrDetails(instruction, out name, out declType, out calledId); if (name == null) { continue; } if (declType != null) { if (declType == (_activeItem as TypeItem).TypeRef) { // Only link to nodes we've added. This may or may not include // property get set methods, depending on the setting. if (_addedNodes.ContainsKey(calledId)) { AddEdge(methodNodeId, calledId, EdgeStyle.NormalArrow); } } } } }
public void GetCalledMethodsTest() { MethodBase method = MethodBase.GetCurrentMethod(); MethodBodyReader reader = new MethodBodyReader(method); IList <MethodBase> calledMethods = reader.GetCalledMethods(false, false); foreach (MethodBase calledMethod in calledMethods) { Console.WriteLine(" {0}.{1}", calledMethod.ReflectedType, calledMethod.Name); } Assert.IsTrue(calledMethods.Count > 3); }
internal static IEnumerable <CodeInstruction> LoadDefinitionsTranspiler( IEnumerable <CodeInstruction> instructions) { var replacementMethod = AccessTools.Method(typeof(TileDatabasePatches), nameof(LoadDefinitionsInit)); var methodIlInstructions = MethodBodyReader.GetInstructions(new DynamicMethod(Guid.NewGuid().ToString(), typeof(object), new Type[0]).GetILGenerator(), replacementMethod); var replacementMethodInstructions = new List <CodeInstruction>(); foreach (var methodIlInstruction in methodIlInstructions) { replacementMethodInstructions.Add(methodIlInstruction.GetCodeInstruction()); } return(replacementMethodInstructions); }
public static byte[] changeCode(byte[] Before, object Me, aops A, List <object> O) { List <Type> Tnew = O.Select(x => x.GetType()); List <byte> Q = new List <byte>(Before); var N = new MethodBodyReader(Addition.module, Before); List <ILInstruction> CastClass = N.instructions.FindAll(x => x.Code == OpCodes.Castclass); if (CastClass.Count > Tnew.Count) { CastClass.RemoveRange(Tnew.Count, CastClass.Count - Tnew.Count); } var Told = CastClass.Select(x => (Type)x.Operand); Dictionary <Type, List <Type> > Compare = new Dictionary <Type, List <Type> >(); List <Type> L; for (int i = 0; i < Tnew.Count; i++) { if (Compare.TryGetValue(Tnew[i], out L)) { if (!L.Contains(Told[i])) { L.Add(Told[i]); } } else { Compare.Add(Tnew[i], new List <Type>()); Compare[Tnew[i]].Add(Told[i]); } } Predicate <OpCode> M = (x) => ((x == OpCodes.Call) || (x == OpCodes.Calli) || (x == OpCodes.Callvirt)); Predicate <OpCode> C = (x) => (x == OpCodes.Newobj); Predicate <OpCode> F = (x) => ((x == OpCodes.Stsfld) || (x == OpCodes.Stfld) || (x == OpCodes.Ldsfld) || (x == OpCodes.Ldfld) || (x == OpCodes.Ldsflda) || (x == OpCodes.Ldflda)); for (int i = 0; i < Tnew.Count; i++) { changeEntities <MethodInfo>(N, M, Compare, Tnew, i, Q); changeEntities <ConstructorInfo>(N, C, Compare, Tnew, i, Q); changeEntities <FieldInfo>(N, F, Compare, Tnew, i, Q); changeEntity <Type>(Q, CastClass[i], Tnew[i]); } /* var I = new MethodBodyReader(Addition.module, Q.ToArray()); * MessageBox.Show(N.GetBodyCode(Before) + I.GetBodyCode(Q.ToArray()));*/ return(Q.ToArray()); }
public static ILMethodInfo Disassemble(MethodInfo method) { if (method == null) { return(null); } var reader = new MethodBodyReader(method); var ilCode = reader.GetBodyCode(); if (string.IsNullOrWhiteSpace(ilCode)) { return(null); } var localVariables = new List <LocalVariableInfo>(); if (reader.LocalVariables != null) { localVariables.AddRange(reader.LocalVariables); } var lines = ilCode?.Split('\n').ToList(); lines.RemoveAll(string.IsNullOrWhiteSpace); var ilCodeLines = lines.ToArray(); var ilLinesInfos = new OpCodeInfo[ilCodeLines?.Length ?? 0]; if (reader.instructions == null) { return(null); } for (var index = 0; index < reader.instructions.Count && index < ilLinesInfos.Length; index++) { var instruction = reader.instructions[index]; var d = ILNavigator.TryGetOpCodeDescription(instruction.Code); if (d == null) { continue; } ilLinesInfos[index] = d; } var instructions = FindBlocks(ilCodeLines, reader.instructions, ilLinesInfos); return(new ILMethodInfo(localVariables, instructions)); }
public static DissectResult Dissect(MethodBase mb) { MethodBodyReader mbr = new MethodBodyReader(mb); WaitDissector wd = new WaitDissector(mbr.instructions); wd.Dissect(); EnsureNotInitBehavior(mbr.instructions, wd.DissectionPoints[0], mb.Name); List <MethodCode> states = new List <MethodCode>(); HashSet <int> exits = new HashSet <int>(wd.DissectionPoints); foreach (int ilIndex in wd.DissectionPoints) { MethodCode mc = MethodCode.Create(mb, ilIndex + 1, exits); states.Add(mc); } return(new DissectResult(states, wd.DissectionPoints)); }
private static void ScanMethodsForLocalizerInvocations(IReflect callerType, IDictionary <string, List <string> > translations) { foreach (var callerMethod in callerType.GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance | BindingFlags.CreateInstance)) { if (GetStringMethods.Contains(callerMethod)) { continue; // skip calling self } var callerBody = callerMethod.GetMethodBody(); if (callerBody == null) { continue; // no body } var instructions = MethodBodyReader.GetInstructions(callerMethod); foreach (Instruction instruction in instructions) { if (instruction.Operand is MethodInfo methodInfo && GetStringMethods.Contains(methodInfo) && instruction.Previous.Operand is string value) { string scope; if (instruction.Previous.Previous != null && instruction.Previous.Previous.Operand is FieldInfo field) { scope = field.DeclaringType != null && field.DeclaringType.IsGenericType ? field.DeclaringType.NormalizeResourceControllerName().Replace("_T", string.Empty) : field.DeclaringType?.Name ?? string.Empty; } else { scope = string.Empty; } if (!translations.TryGetValue(scope, out var list)) { translations.Add(scope, list = new List <string>()); } list.Add(value); } } } }
private void LookForMethodCallers() { AssemblyScanner.Register(type => { var methods = type.GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static); foreach (MethodInfo methodInfo in methods) { if (methodInfo.IsAbstract) { continue; } MethodBody methodBody = methodInfo.GetMethodBody(); if (methodBody == null) { continue; } try{ List <Instruction> instructions = MethodBodyReader.GetInstructions(methodInfo); foreach (var instruction in instructions) { MethodInfo calledMethod = instruction.Operand as MethodInfo; if (calledMethod == null) { continue; } foreach (var users in allusers) { if (users.TryAddCall(type, methodInfo, calledMethod, instruction)) { break; } } } }catch (Exception e) { //Debug.LogError("On " + methodInfo.DeclaringType.Name+"."+methodInfo.Name); //Debug.LogException(e); } } }, AssemblyScanner.OnlyProject ); AssemblyScanner.Scan(); }
public static List <MethodInterpreter> ComputeDependencies(MethodBase definition) { var resultDict = new Dictionary <string, MethodInterpreter>(); var body = definition.GetMethodBody(); if (body == null) { return(new List <MethodInterpreter>()); } var instructions = MethodBodyReader.GetInstructions(definition); foreach (var instruction in instructions) { var opcodeStr = instruction.OpCode.Value; switch (opcodeStr) { case ObcodeIntValues.CallVirt: case ObcodeIntValues.Call: case ObcodeIntValues.CallInterface: { var operand = (MethodBase)instruction.Operand; if (operand == null) { break; } AddMethodIfNecessary(operand, resultDict); break; } case ObcodeIntValues.NewObj: { var operand = (ConstructorInfo)instruction.Operand; if (operand == null) { break; } AddMethodIfNecessary(operand, resultDict); break; } } } return(resultDict.Values.ToList()); }
static void ReadAssemblies(List <string> assemblyList) { assemblyList.ForEach(a => { Console.WriteLine("Reading {0}", a); Assembly assembly = Assembly.LoadFile(Path.Combine(Environment.CurrentDirectory, a)); List <Type> types = assembly.GetTypes().ToList(); types.ForEach(t => { List <MethodInfo> methods = t.GetMethods().ToList(); methods.ForEach(m => { MethodBase methodBase = m; ParameterInfo[] parameters = m.GetParameters(); string functionName = string.Format("{0}({1})", m.Name, String.Join(", ", parameters.Select(p => p.ParameterType.FullName).ToArray()) ); int functId = db.WriteFunction(t.Namespace, t.Name, functionName); var instructions = MethodBodyReader.GetInstructions(methodBase); foreach (Instruction instruction in instructions) { MethodInfo methodInfo = instruction.Operand as MethodInfo; if (methodInfo != null) { Type type = methodInfo.DeclaringType; ParameterInfo[] instParameters = methodInfo.GetParameters(); string instName = string.Format("{0}({1})", methodInfo.Name, String.Join(", ", instParameters.Select(p => p.ParameterType.FullName).ToArray()) ); db.WriteReference(functId, type.Namespace, type.Name, instName); } } }); }); }); }
public void InstructionsTest() { MethodBase method = MethodBase.GetCurrentMethod(); ILanguageInfo language = new CsLanguageInfo(); MethodBodyReader reader = new MethodBodyReader(method, language); language.RegisterNamespace("System"); language.RegisterNamespace("System.Collections.Generic"); language.RegisterNamespace("System.Reflection"); language.RegisterNamespace("Arebis.Reflection"); IList <ILInstruction> instructions = reader.Instructions; foreach (ILInstruction instruction in instructions) { Console.WriteLine(" {0}", instruction.GetCode()); } Assert.IsTrue(instructions.Count > 12); }
public void Process(CrRuntimeLibrary crRuntime) { if (Kind != MethodKind.Default) { return; } if (Interpreted) { return; } if (HandlePlatformInvokeMethod(Method)) { return; } if (Method.GetMethodBody() == null) { return; } var instructions = MethodBodyReader.GetInstructions(Method); var labelList = ComputeLabels(Method); MidRepresentation.Method = Method; MidRepresentation.Vars.SetupLocalVariables(Method); var evaluator = new EvaluatorStack(); var operationFactory = new MetaMidRepresentationOperationFactory(MidRepresentation, evaluator); for (var index = 0; index < instructions.Length; index++) { var instruction = instructions[index]; EvaluateInstuction(instruction, operationFactory, labelList, crRuntime); } //Ensure.IsTrue(evaluator.Count == 0, "Stack not empty!"); AnalyzeProperties.Setup(MidRepresentation.Vars.Arguments, MidRepresentation.Vars.VirtRegs, MidRepresentation.Vars.LocalVars); Interpreted = true; }
private static HashSet <string> DumpKeybinds(MethodInfo method) { var instructions = new List <CodeInstruction> { }; MethodBodyReader.GetInstructions(GetILGenerator(), method).ForEach( (instr) => instructions.Add(instr.GetCodeInstruction()) ); // Uses Harmony's internals, because the proper method is not present in SRML's version of Harmony. var set = new HashSet <string> { }; foreach (CodeInstruction instr in instructions) { if (instr.opcode == OpCodes.Ldstr && ((string)instr.operand).StartsWith(Keybind.KEYBIND_PREFIX)) { set.Add((string)instr.operand); } } return(set);
static void Check(Type checkType, string methodName) { MethodBase methodBase = checkType.GetMethod(methodName, new Type[] { typeof(Int32) }); var instructions = MethodBodyReader.GetInstructions(methodBase); foreach (Instruction instruction in instructions) { MethodInfo methodInfo = instruction.Operand as MethodInfo; if (methodInfo != null) { Type type = methodInfo.DeclaringType; ParameterInfo[] parameters = methodInfo.GetParameters(); Console.WriteLine("{0}.{1}({2});", type.FullName, methodInfo.Name, String.Join(", ", parameters.Select(p => p.ParameterType.FullName + " " + p.Name).ToArray()) ); } } }
/// <summary> /// Checks if the given method has a IL instruction that SETS (therefore, it changes the value) a customized field /// </summary> private static IEnumerable <FieldInfo> GetCustomizedFieldsChangedByMethod(MethodBase partModuleMethod, ModuleDefinition definition) { var listOfFields = new HashSet <FieldInfo>(); var method = DynamicTools.CreateDynamicMethod(partModuleMethod, "read"); var instructions = MethodBodyReader.GetInstructions(method.GetILGenerator(), partModuleMethod); //OpCodes.Stfld is the opcode for SETTING the value of a field foreach (var instruction in instructions.Where(i => i.opcode == OpCodes.Stfld)) { if (!(instruction.operand is FieldInfo operand)) { continue; } if (definition.Fields.Any(f => f.FieldName == operand.Name)) { listOfFields.Add(operand); } } return(listOfFields); }
/// <summary> /// Constructs an instance based on a method or constructor /// </summary> /// <param name="mi">a method or constructor</param> public ILInstructionInfo(MethodBase mi) { Method = mi; MethodBodyReader mbr = new MethodBodyReader(mi); Instructions = mbr.instructions; MethodBody body = mi.GetMethodBody(); Body = body; byte[] msil = body.GetILAsByteArray(); Marshal = new ILInstruction() { Offset = msil.Length, Index = Instructions.Count, Code = OpCodes.Ret }; _imap = new ILInstruction[msil.Length + 1]; foreach (ILInstruction ili in Instructions) { _imap[ili.Offset] = ili; } _imap[msil.Length] = Marshal; InitHandlerMaps(); }
public static List <ILInstruction> GetInstructions(MethodInfo method) { var dummy = new DynamicMethod("Dummy", typeof(void), new Type[] { }); return(MethodBodyReader.GetInstructions(dummy.GetILGenerator(), method)); }
public void CallCompiler(string inputAssemblyName, string outputExeName) { var commandLineParse = CommandLineParse.Instance; if (!String.IsNullOrEmpty(inputAssemblyName)) { commandLineParse.ApplicationInputAssembly = inputAssemblyName; } if (!String.IsNullOrEmpty(outputExeName)) { commandLineParse.ApplicationNativeExe = outputExeName; } var dir = Directory.GetCurrentDirectory(); inputAssemblyName = Path.Combine(dir, commandLineParse.ApplicationInputAssembly); var asm = Assembly.LoadFile(inputAssemblyName); var definition = asm.EntryPoint; var start = Environment.TickCount; OptimizationLevelBase.ClearOptimizations(); OptimizationLevelBase.Instance = new OptimizationLevels(); OptimizationLevelBase.Instance.EnabledCategories.Clear(); OptimizationLevelBase.Instance.EnabledCategories.AddRange(OptimizationList); OptimizationLevelBase.UpdateOptimizationsFromCategories(OptimizationLevelBase.OptimizationPasses); OptimizationLevelBase.SortOptimizations(); // OptimizationLevelBase.Instance = new OptimizationLevels(); // OptimizationLevelBase.OptimizerLevel = 2; // OptimizationLevelBase.Instance.EnabledCategories.Add(OptimizationCategories.All); var closureEntities = ClosureEntitiesUtils.BuildClosureEntities(definition, typeof(CrString).Assembly); var sb = closureEntities.BuildFullSourceCode(); var end = Environment.TickCount - start; CompilerErrors += String.Format("Compilation time: {0} ms", end); var opcodes = closureEntities.MethodImplementations; var intermediateOutput = "-------------IL:-------------\n"; foreach (var opcode in opcodes) { intermediateOutput += " " + opcode.Key + ": \n"; if (opcode.Value.Kind != MethodKind.CilInstructions) { intermediateOutput += "// Provided By Framework \n\n"; continue; } try { var instructions = MethodBodyReader.GetInstructions(((CilMethodInterpreter)opcode.Value).Method); foreach (var op in instructions) { var oper = string.Format("\t{0}", op);; intermediateOutput += " " + oper + "\n"; } } catch (Exception) { intermediateOutput += "// Method has no body \n\n"; } intermediateOutput += "\n"; } intermediateOutput += "\n-------------IR:-------------\n"; foreach (var opcode in opcodes) { intermediateOutput += " " + opcode.Key + ": \n"; if (opcode.Value.Kind != MethodKind.CilInstructions) { intermediateOutput += "// Provided By Framework \n\n"; continue; } var cilInterpreter = (CilMethodInterpreter)opcode.Value; foreach (var op in cilInterpreter.MidRepresentation.LocalOperations) { var oper = string.Format("{1}\t({0})", op.Kind, op);; intermediateOutput += " " + oper + "\n"; } intermediateOutput += "\n"; } OutputCode = sb.ToString(); ILCode = intermediateOutput; //TODO: Make this call all the different compilers i.e. TestHelloWorld_GCC.exe etc... }
void Decrypt(IBinaryReader reader, int delegateTypeToken, ISimpleDeobfuscator simpleDeobfuscator) { var delegateType = module.ResolveToken(delegateTypeToken) as TypeDef; if (delegateType == null) throw new ApplicationException("Couldn't find delegate type"); int delToken, encMethToken, encDeclToken; if (!GetTokens(delegateType, out delToken, out encMethToken, out encDeclToken)) throw new ApplicationException("Could not find encrypted method tokens"); if (delToken != delegateTypeToken) throw new ApplicationException("Invalid delegate type token"); var encType = module.ResolveToken(encDeclToken) as ITypeDefOrRef; if (encType == null) throw new ApplicationException("Invalid declaring type token"); var encMethod = module.ResolveToken(encMethToken) as MethodDef; if (encMethod == null) throw new ApplicationException("Invalid encrypted method token"); var bodyReader = new MethodBodyReader(module, reader); bodyReader.Read(encMethod); bodyReader.RestoreMethod(encMethod); Logger.v("Restored method {0} ({1:X8}). Instrs:{2}, Locals:{3}, Exceptions:{4}", Utils.RemoveNewlines(encMethod.FullName), encMethod.MDToken.ToInt32(), encMethod.Body.Instructions.Count, encMethod.Body.Variables.Count, encMethod.Body.ExceptionHandlers.Count); delegateTypes.Add(delegateType); simpleDeobfuscator.MethodModified(encMethod); }
/// <summary> /// Saves localizable JSON data in the current working directory for the provided assembly. /// </summary> /// <param name="assembly">Assembly to save localization data from.</param> public static void ExportLocalizableForAssembly(Assembly assembly) { var types = assembly.GetTypes(); var outList = new Dictionary <string, LocEntry>(); foreach (var type in types.Where(x => x.IsClass || x.IsAbstract)) { var toParse = new List <MethodBase>(); toParse.AddRange(type.GetTypeInfo().DeclaredConstructors); toParse.AddRange(type.GetTypeInfo().DeclaredMethods); foreach (var method in toParse) { try { var instructions = MethodBodyReader.GetInstructions(method); foreach (var instruction in instructions) { if (instruction.OpCode == OpCodes.Call) { var methodInfo = instruction.Operand as MethodInfo; if (methodInfo != null && methodInfo.IsStatic) { var methodType = methodInfo.DeclaringType; var parameters = methodInfo.GetParameters(); if (!methodInfo.Name.Contains("Localize")) { continue; } Console.WriteLine("->({0}) {1}.{2}.{3}({4});", method.DeclaringType.Assembly.GetName().Name, type.FullName, methodType.Name, methodInfo.Name, string.Join(", ", parameters.Select(p => p.ParameterType.FullName + " " + p.Name).ToArray()) ); var entry = new LocEntry { Message = instruction.Previous.Operand as string, Description = $"{type.Name}.{method.Name}" }; var key = instruction.Previous.Previous.Operand as string; if (string.IsNullOrEmpty(key)) { throw new Exception( $"Key was empty for message: {entry.Message} (from {entry.Description})"); } if (outList.Any(x => x.Key == key)) { if (outList.Any(x => x.Key == key && x.Value.Message != entry.Message)) { throw new Exception( $"Message with key {key} has previous appearance but other fallback text in {entry.Description}"); } } else { Console.WriteLine($" ->{key} - {entry.Message} (from {entry.Description})"); outList.Add(key, entry); } } } } } catch (Exception ex) { Debug.WriteLine($"Couldn't parse {method.Name}:\n{ex}"); } } } File.WriteAllText($"{GetAssemblyName(assembly)}_Localizable.json", JsonConvert.SerializeObject(outList, new JsonSerializerSettings { Formatting = Formatting.Indented })); }
public void Run() { string path = @"F:\src\git\DotWeb\build\bin\Debug\DotWeb.Sample.Script.dll"; var reader = GetReaderFor(path); var sourceType = Type.GetType("DotWeb.Sample.Script.Test.Sandbox, DotWeb.Sample.Script"); var sourceMethod = sourceType.GetConstructor(Type.EmptyTypes); var token = new SymbolToken(sourceMethod.MetadataToken); var symMethod = reader.GetMethod(token); var points = new SequencePointCollection(symMethod); string fileName = "Test.dll"; string outDir = @"F:\src\git\DotWeb\build\bin\Debug"; string outPath = Path.Combine(outDir, fileName); var asmName = new AssemblyName("Test"); var asmBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(asmName, AssemblyBuilderAccess.Save, outDir); var moduleBuilder = asmBuilder.DefineDynamicModule(fileName, fileName, true); var typeBuilder = moduleBuilder.DefineType("Test", System.Reflection.TypeAttributes.Public | System.Reflection.TypeAttributes.Class); var ctorBuilder = typeBuilder.DefineConstructor(System.Reflection.MethodAttributes.Public, CallingConventions.Standard, Type.EmptyTypes); var ilg = ctorBuilder.GetILGenerator(); var methodReader = new MethodBodyReader(sourceMethod); foreach (var il in methodReader.Instructions) { var point = points.GetSequencePointAtOffset(il.Offset); if (point != null) { var doc = GetDocumentWriterFor(point.Document, moduleBuilder); ilg.MarkSequencePoint(doc, point.Line, point.Column, point.EndLine, point.EndColumn); } if (il.Operand is MethodInfo) { RedirectMethodInfo(il); } Emit(ilg, il); } typeBuilder.CreateType(); asmBuilder.Save(fileName); var asm = Assembly.LoadFile(outPath); var types = asm.GetTypes(); var type = asm.GetType("Test"); var obj = Activator.CreateInstance(type); }
public MethodDefReader(ImageReader imageReader, IBinaryReader reader) { this.bmd = new BabelMethodDef(); this.methodRefReader = new MethodRefReader(imageReader, reader, bmd); this.methodBodyReader = new MethodBodyReader(imageReader, reader); }