/// <summary> /// Gets a <see cref="CorLibTypeSig"/> if <paramref name="namespace"/> and /// <paramref name="name"/> matches a primitive type. /// </summary> /// <param name="self">this</param> /// <param name="namespace">Namespace</param> /// <param name="name">Name</param> /// <param name="defAsm">Definition assembly</param> /// <returns>A <see cref="CorLibTypeSig"/> or <c>null</c> if it didn't match any primitive type</returns> public static CorLibTypeSig GetCorLibTypeSig(this ICorLibTypes self, string @namespace, string name, IAssembly defAsm) { if (@namespace != "System") { return(null); } if (defAsm is null || !defAsm.IsCorLib()) { return(null); } return(name switch { "Void" => self.Void, "Boolean" => self.Boolean, "Char" => self.Char, "SByte" => self.SByte, "Byte" => self.Byte, "Int16" => self.Int16, "UInt16" => self.UInt16, "Int32" => self.Int32, "UInt32" => self.UInt32, "Int64" => self.Int64, "UInt64" => self.UInt64, "Single" => self.Single, "Double" => self.Double, "String" => self.String, "TypedReference" => self.TypedReference, "IntPtr" => self.IntPtr, "UIntPtr" => self.UIntPtr, "Object" => self.Object, _ => null, });
public void Initialize(DecompilerContext context, ILBlock method) { this.labelGlobalRefCount.Clear(); this.labelToBasicBlock.Clear(); this.context = context; this.corLib = context.CurrentMethod.Module.CorLibTypes; foreach (var e in method.GetSelfAndChildrenRecursive <ILExpression>(List_ILExpression, e => e.IsBranch())) { foreach (var target in e.GetBranchTargets()) { labelGlobalRefCount[target] = labelGlobalRefCount.GetOrDefault(target) + 1; } } foreach (ILBasicBlock bb in method.GetSelfAndChildrenRecursive <ILBasicBlock>(List_ILBasicBlock)) { int index = 0; for (;;) { var node = bb.GetNext(ref index); if (node == null) { break; } var label = node as ILLabel; if (label == null) { continue; } labelToBasicBlock[label] = bb; } } }
/// <summary> /// Constructor /// </summary> /// <param name="helper">Token resolver</param> /// <param name="corLibTypes">ICorLibTypes instance</param> /// <param name="reader">The signature data</param> SignatureReader(ISignatureReaderHelper helper, ICorLibTypes corLibTypes, IImageStream reader) { this.helper = helper; this.corLibTypes = corLibTypes; this.reader = reader; this.recursionCounter = new RecursionCounter(); }
private TypeSig getRandomTypeSigForField(ICorLibTypes types) { switch (random.Next(6)) { case 0: return(types.Byte); case 1: return(types.Char); case 2: return(types.Boolean); case 3: return(types.String); case 4: return(types.Object); case 5: return(types.Int16); default: return(types.Byte); } }
/// <summary> /// Reads a <see cref="TypeSig"/> signature /// </summary> /// <param name="helper">Token resolver</param> /// <param name="corLibTypes">A <see cref="ICorLibTypes"/> instance</param> /// <param name="signature">The signature reader which will be owned by us</param> /// <param name="gpContext">Generic parameter context</param> /// <param name="extraData">If there's any extra data after the signature, it's saved /// here, else this will be <c>null</c></param> /// <returns>A new <see cref="TypeSig"/> instance or <c>null</c> if /// <paramref name="signature"/> is invalid.</returns> public static TypeSig ReadTypeSig(ISignatureReaderHelper helper, ICorLibTypes corLibTypes, IBinaryReader signature, GenericParamContext gpContext, out byte[] extraData) { try { using (var reader = new SignatureReader(helper, corLibTypes, signature, gpContext)) { TypeSig ts; try { ts = reader.ReadType(); } catch (IOException) { reader.reader.Position = 0; ts = null; } extraData = reader.GetExtraData(); return(ts); } } catch { extraData = null; return(null); } }
/// <summary> /// Constructor /// </summary> /// <param name="helper">Token resolver</param> /// <param name="corLibTypes">A <see cref="ICorLibTypes"/> instance</param> /// <param name="reader">The signature data</param> /// <param name="gpContext">Generic parameter context</param> SignatureReader(ISignatureReaderHelper helper, ICorLibTypes corLibTypes, IBinaryReader reader, GenericParamContext gpContext) { this.helper = helper; this.corLibTypes = corLibTypes; this.reader = reader; this.gpContext = gpContext; this.recursionCounter = new RecursionCounter(); }
/// <summary> /// Constructor /// </summary> /// <param name="readerModule">Reader module</param> /// <param name="sig">#Blob stream offset of signature</param> /// <param name="gpContext">Generic parameter context</param> SignatureReader(ModuleDefMD readerModule, uint sig, GenericParamContext gpContext) { helper = readerModule; corLibTypes = readerModule.CorLibTypes; reader = readerModule.BlobStream.CreateReader(sig); this.gpContext = gpContext; recursionCounter = new RecursionCounter(); }
internal static void Patch() { context = TerrariaPatcher.context; memRes = TerrariaPatcher.memRes; typeSys = context.PrimaryAssembly.ManifestModule.CorLibTypes; AddZephyrFishBuffID(); }
internal static void Patch() { context = TerrariaPatcher.context; memRes = TerrariaPatcher.memRes ; typeSys = context.PrimaryAssembly.ManifestModule.CorLibTypes; AddZephyrFishBuffID(); }
internal static void Patch() { context = TerrariaPatcher.context; memRes = TerrariaPatcher.memRes; typeSys = context.PrimaryAssembly.ManifestModule.CorLibTypes; typeDef_Proj = memRes.GetType("Terraria.Projectile"); WrapMethods(); AddFieldForBHandler(); }
internal static void Patch() { context = TerrariaPatcher.context; memRes = TerrariaPatcher.memRes; typeSys = context.PrimaryAssembly.ManifestModule.CorLibTypes; typeDef_Recipe = memRes.GetType("Terraria.Recipe"); AddGroupRecipeField(); WrapMethods(); }
internal static void Patch() { context = TerrariaPatcher.context; memRes = TerrariaPatcher.memRes ; typeSys = context.PrimaryAssembly.ManifestModule.CorLibTypes; typeDef_Recipe = memRes.GetType("Terraria.Recipe"); AddGroupRecipeField(); WrapMethods(); }
internal static void Patch() { context = TerrariaPatcher.context; memRes = TerrariaPatcher.memRes; typeSys = context.PrimaryAssembly.ManifestModule.CorLibTypes; typeDef_WorldFile = memRes.GetType("Terraria.IO.WorldFile"); InjectSaveHook(); InjectLoadHook(); EnlargeFrameImportantArray(); }
internal static void Patch() { context = TerrariaPatcher.context; memRes = TerrariaPatcher.memRes ; typeSys = context.PrimaryAssembly.ManifestModule.CorLibTypes; typeDef_Item = memRes.GetType("Terraria.Item"); WrapSetDefaults(); AddFieldForBHandler(); AddFieldForSound(); }
internal static void Patch() { context = TerrariaPatcher.context; memRes = TerrariaPatcher.memRes; typeSys = context.PrimaryAssembly.ManifestModule.CorLibTypes; typeDef_Mount = memRes.GetType("Terraria.Mount"); WrapMethods(); AddFieldForBHandler(); Remove_FromFields(); RemoveTypeLimitations(); }
/// <summary> /// Gets a <see cref="CorLibTypeSig"/> if <paramref name="namespace"/> and /// <paramref name="name"/> matches a primitive type. /// </summary> /// <param name="self">this</param> /// <param name="namespace">Namespace</param> /// <param name="name">Name</param> /// <param name="defAsm">Definition assembly</param> /// <returns>A <see cref="CorLibTypeSig"/> or <c>null</c> if it didn't match any primitive type</returns> public static CorLibTypeSig GetCorLibTypeSig(this ICorLibTypes self, string @namespace, string name, IAssembly defAsm) { if (@namespace != "System") { return(null); } if (defAsm == null || !defAsm.IsCorLib()) { return(null); } switch (name) { case "Void": return(self.Void); case "Boolean": return(self.Boolean); case "Char": return(self.Char); case "SByte": return(self.SByte); case "Byte": return(self.Byte); case "Int16": return(self.Int16); case "UInt16": return(self.UInt16); case "Int32": return(self.Int32); case "UInt32": return(self.UInt32); case "Int64": return(self.Int64); case "UInt64": return(self.UInt64); case "Single": return(self.Single); case "Double": return(self.Double); case "String": return(self.String); case "TypedReference": return(self.TypedReference); case "IntPtr": return(self.IntPtr); case "UIntPtr": return(self.UIntPtr); case "Object": return(self.Object); } return(null); }
public SimpleControlFlow(DecompilerContext context, ILBlock method) { this.context = context; this.corLib = context.CurrentMethod.Module.CorLibTypes; foreach(ILLabel target in method.GetSelfAndChildrenRecursive<ILExpression>(e => e.IsBranch()).SelectMany(e => e.GetBranchTargets())) { labelGlobalRefCount[target] = labelGlobalRefCount.GetOrDefault(target) + 1; } foreach(ILBasicBlock bb in method.GetSelfAndChildrenRecursive<ILBasicBlock>()) { foreach(ILLabel label in bb.GetChildren().OfType<ILLabel>()) { labelToBasicBlock[label] = bb; } } }
/// <summary> /// Reads a <see cref="CallingConventionSig"/> signature /// </summary> /// <param name="helper">Token resolver</param> /// <param name="corLibTypes">A <see cref="ICorLibTypes"/> instance</param> /// <param name="signature">The signature reader</param> /// <param name="gpContext">Generic parameter context</param> /// <returns>A new <see cref="CallingConventionSig"/> instance or <c>null</c> if /// <paramref name="signature"/> is invalid.</returns> public static CallingConventionSig ReadSig(ISignatureReaderHelper helper, ICorLibTypes corLibTypes, DataReader signature, GenericParamContext gpContext) { try { var reader = new SignatureReader(helper, corLibTypes, ref signature, gpContext); if (reader.reader.Length == 0) { return(null); } return(reader.ReadSig()); } catch { return(null); } }
/// <summary> /// Reads a <see cref="CallingConventionSig"/> signature /// </summary> /// <param name="helper">Token resolver</param> /// <param name="corLibTypes">ICorLibTypes instance</param> /// <param name="signature">The signature reader which will be owned by us</param> /// <returns>A new <see cref="CallingConventionSig"/> instance or <c>null</c> if /// <paramref name="signature"/> is invalid.</returns> public static CallingConventionSig ReadSig(ISignatureReaderHelper helper, ICorLibTypes corLibTypes, IImageStream signature) { try { using (var reader = new SignatureReader(helper, corLibTypes, signature)) { if (reader.reader.Length == 0) { return(null); } return(reader.ReadSig()); } } catch { return(null); } }
/*static bool IsGet2DArrCall(TypeReference arrayType, Instruction i) * { * var inner = arrayType.GetElementType(); * * if (i.OpCode.Code != Code.Call) * return false; * * var mtd = i.Operand as MethodReference; * * // for debugging * //if (mtd == null) * // return false; * //if (mtd.Name != "Get") * // return false; * //if (mtd.DeclaringType.FullName != arrayType.FullName) * // return false; * //if (!mtd.HasThis) * // return false; * //if (mtd.ReturnType != inner) * // return false; * //if (mtd.Parameters.Count != 2) * // return false; * //if (!mtd.Parameters.All(pd => pd.ParameterType == typeSys.Int32)) * // return false; * * //return true; * * return mtd != null && mtd.Name == "Get" && mtd.DeclaringType.FullName == arrayType.FullName && mtd.ReturnType == inner && !mtd.HasGenericParameters && mtd.Parameters.Count == 2 && mtd.Parameters.All(pd => pd.ParameterType == typeSys.Int32) && mtd.HasThis; * }*/ /*static void AddExtendedWallTypeField() * { * var wallTypeEx = new FieldDefinition("P_wallTypeEx", FieldAttributes.Assembly | FieldAttributes.Static, memRes.ReferenceOf(typeof(ushort[]))); * * var main_t = memRes.GetType("Terraria.Main"); * #region add field * { * typeDef_Tile.Fields.Add(wallTypeEx); * * // initialize in static ctor * var cb = typeDef_Tile.GetOrCreateStaticCtor().Body; * var cproc = cb.GetILProcessor(); * * var finalRet = cb.Instructions.Last(); * * cproc.InsertBefore(finalRet, Instruction.Create(OpCodes.Ldsfld, main_t.GetField("maxTilesX"))); * cproc.InsertBefore(finalRet, Instruction.Create(OpCodes.Ldsfld, main_t.GetField("maxTilesY"))); * cproc.InsertBefore(finalRet, Instruction.Create(OpCodes.Dup)); * cproc.InsertBefore(finalRet, Instruction.Create(OpCodes.Newarr, wallTypeEx.FieldType)); * cproc.InsertBefore(finalRet, Instruction.Create(OpCodes.Stsfld, wallTypeEx)); * } #endregion * #region add twodimentional getter * { * var getWallType = new MethodDefinition("GetWallType", MethodAttributes.Public | MethodAttributes.Static, typeSys.UInt16); * * getWallType.Parameters.Add(new ParameterDefinition("x", 0, typeSys.Int32)); * getWallType.Parameters.Add(new ParameterDefinition("y", 0, typeSys.Int32)); * * var gwproc = getWallType.Body.GetILProcessor(); * * gwproc.Emit(OpCodes.Ldsfld, wallTypeEx); * * // wallTypeEx[y * Main.maxTilesY + x] * gwproc.Emit(OpCodes.Ldarg_1); * //gwproc.Emit(OpCodes.Ldsfld, main_t.GetField("maxTilesY")); * gwproc.Emit(OpCodes.Ldc_I4, LARGEST_WLD_Y); * gwproc.Emit(OpCodes.Mul); * gwproc.Emit(OpCodes.Ldarg_0); * gwproc.Emit(OpCodes.Add); * gwproc.Emit(OpCodes.Ldelem_Ref); * gwproc.Emit(OpCodes.Ret); * * typeDef_Tile.Methods.Add(getWallType); * * // add an overload with a tile argument that ignores the tile, so the stack doesn't get messed up when using injected GetWallType(I) calls. * { * var getWallTypeI = new MethodDefinition("GetWallTypeI", MethodAttributes.Assembly | MethodAttributes.Static, typeSys.UInt16); * * getWallTypeI.Parameters.Add(new ParameterDefinition("tile", 0, typeSys.Object)); * getWallTypeI.Parameters.Add(new ParameterDefinition("x", 0, typeSys.Int32)); * getWallTypeI.Parameters.Add(new ParameterDefinition("y", 0, typeSys.Int32)); * * var gwiproc = getWallTypeI.Body.GetILProcessor(); * * gwiproc.Emit(OpCodes.Ldsfld, wallTypeEx); * * // wallTypeEx[y * Main.maxTilesY + x] * gwiproc.Emit(OpCodes.Ldarg_2); * //gwiproc.Emit(OpCodes.Ldsfld, main_t.GetField("maxTilesY")); * gwiproc.Emit(OpCodes.Ldc_I4, LARGEST_WLD_Y); * gwiproc.Emit(OpCodes.Mul); * gwiproc.Emit(OpCodes.Ldarg_1); * gwiproc.Emit(OpCodes.Add); * gwiproc.Emit(OpCodes.Ldelem_Ref); * gwiproc.Emit(OpCodes.Ret); * * typeDef_Tile.Methods.Add(getWallTypeI); * } * } #endregion * #region add twodimentional setter * { * var setWallType = new MethodDefinition("SetWallType", MethodAttributes.Public | MethodAttributes.Static, typeSys.Void); * * setWallType.Parameters.Add(new ParameterDefinition("x" , 0, typeSys. Int32)); * setWallType.Parameters.Add(new ParameterDefinition("y" , 0, typeSys. Int32)); * setWallType.Parameters.Add(new ParameterDefinition("value", 0, typeSys.UInt16)); * * var swproc = setWallType.Body.GetILProcessor(); * * swproc.Emit(OpCodes.Ldsfld, wallTypeEx); * * // wallTypeEx[y * Main.maxTilesY + x] * swproc.Emit(OpCodes.Ldarg_1); * //swproc.Emit(OpCodes.Ldsfld, main_t.GetField("maxTilesY")); * swproc.Emit(OpCodes.Ldc_I4, LARGEST_WLD_Y); * swproc.Emit(OpCodes.Mul); * swproc.Emit(OpCodes.Ldarg_0); * swproc.Emit(OpCodes.Add); * swproc.Emit(OpCodes.Ldarg_2); * swproc.Emit(OpCodes.Stelem_Ref); * swproc.Emit(OpCodes.Ret); * * typeDef_Tile.Methods.Add(setWallType); * * // add an overload with a tile argument that ignores the tile, so the stack doesn't get messed up when using injected SetWallType(I) calls. * { * var setWallTypeI = new MethodDefinition("SetWallTypeI", MethodAttributes.Assembly | MethodAttributes.Static, typeSys.Void); * * setWallTypeI.Parameters.Add(new ParameterDefinition("tile", 0, typeDef_Tile)); * setWallTypeI.Parameters.Add(new ParameterDefinition("x", 0, typeSys.Int32)); * setWallTypeI.Parameters.Add(new ParameterDefinition("y", 0, typeSys.Int32)); * setWallTypeI.Parameters.Add(new ParameterDefinition("value", 0, typeSys.UInt16)); * * var swb = setWallTypeI.Body; * * var swiproc = swb.GetILProcessor(); * * swiproc.Emit(OpCodes.Ldsfld, wallTypeEx); * * // wallTypeEx[y * Main.maxTilesY + x] * swiproc.Emit(OpCodes.Ldarg_2); * //swiproc.Emit(OpCodes.Ldsfld, main_t.GetField("maxTilesY")); * swiproc.Emit(OpCodes.Ldc_I4, LARGEST_WLD_Y); * swiproc.Emit(OpCodes.Mul); * swiproc.Emit(OpCodes.Ldarg_1); * swiproc.Emit(OpCodes.Add); * swiproc.Emit(OpCodes.Ldarg_3); * swiproc.Emit(OpCodes.Stelem_Ref); * swiproc.Emit(OpCodes.Ret); * * typeDef_Tile.Methods.Add(setWallTypeI); * } * } #endregion * }*/ /*static void ReplaceGetWallTypeCalls() * { * var gw = typeDef_Tile.GetMethod("GetWallTypeI"); // using the internal version * * var main_t = memRes.GetType("Terraria.Main"); * var main_tile = main_t.GetField("tile"); * var tile_wall = typeDef_Tile.GetField("wall"); * * foreach (var td in context.PrimaryAssembly.MainModule.Types) * foreach (var md in td.Methods) * { * if (!md.HasBody) * continue; * * var body = md.Body; * var ins = body.Instructions; * var proc = body.GetILProcessor(); * * for (int i = 0; i < ins.Count; i++) * { * var n = ins[i]; * * if (IsGet2DArrCall(main_tile.FieldType, n)) * { * n = n.Next; * * if (n == null) * continue; * * if (n.OpCode.Code == Code.Ldfld && n.Operand == tile_wall) * { * var p = ins[i].Previous; // shouldn't be null, tile array + indices are loaded on the IL stack * * proc.Remove(p.Next); * proc.Remove(n); * * proc.InsertAfter(p, Instruction.Create(OpCodes.Call, gw)); * * // rewire branch targets * foreach (var i_ in ins) * if (i_ != n && i_ != ins[i] && i_.Operand == ins[i]) * i_.Operand = p.Next; * * i--; * } * } * } * } * }*/ /*static void ReplaceSetWallTypeCalls() * { * var sw = typeDef_Tile.GetMethod("SetWallTypeI"); // using the internal version * * var main_t = memRes.GetType("Terraria.Main"); * var main_tile = main_t.GetField("tile"); * var tile_wall = typeDef_Tile.GetField("wall"); * * foreach (var td in context.PrimaryAssembly.MainModule.Types) * foreach (var md in td.Methods) * { * if (!md.HasBody) * continue; * * var body = md.Body; * var ins = body.Instructions; * var proc = body.GetILProcessor(); * * for (int i = 0; i < ins.Count; i++) * { * var n = ins[i]; * * if (n.OpCode.Code == Code.Stfld && n.Operand == tile_wall) * { * var p = ins[i].Previous; // shouldn't be null, tile array + indices are loaded on the IL stack * * proc.Remove(n); * * proc.InsertAfter(p, Instruction.Create(OpCodes.Call, sw)); * * // rewire branch targets * foreach (var i_ in ins) * if (i_ != n && i_.Operand == n) * i_.Operand = p.Next; * } * } * } * } * static void HideWallField() * { * var wall = typeDef_Tile.GetField("wall"); * * wall.Name = "P_wall"; * * wall.Attributes = FieldAttributes.Assembly; * }*/ #endregion internal static void Patch() { context = TerrariaPatcher.context; memRes = TerrariaPatcher.memRes; typeSys = context.PrimaryAssembly.ManifestModule.CorLibTypes; typeDef_Tile = memRes.GetType("Terraria.Tile"); ChangeFieldType(); ChangeLocalTypes(); //AddExtendedWallTypeField(); //ReplaceGetWallTypeCalls (); //ReplaceSetWallTypeCalls (); //HideWallField(); }
private MethodDef createObfuscatedByMethod(ICorLibTypes types, TypeDefUser typeDef) { MethodDefUser mdu = new MethodDefUser("You are fooled!", new MethodSig(CallingConvention.Default, 0, types.String, types.String), MethodAttributes.Public); mdu.Body = new CilBody(false, new Instruction[] { OpCodes.Nop.ToInstruction(), OpCodes.Ldarg_0.ToInstruction(), OpCodes.Ret.ToInstruction() }, new ExceptionHandler[0], new Local[0]); mdu.Parameters[0].CreateParamDef(); mdu.Parameters[0].ParamDef.Name = "wisser_tg"; typeDef.Methods.Add(mdu); return(mdu); }
internal static void Patch() { context = TerrariaPatcher.context; memRes = TerrariaPatcher.memRes ; typeSys = context.PrimaryAssembly.ManifestModule.CorLibTypes; typeDef_Tile = memRes.GetType("Terraria.Tile"); ChangeFieldType (); ChangeLocalTypes(); //AddExtendedWallTypeField(); //ReplaceGetWallTypeCalls (); //ReplaceSetWallTypeCalls (); //HideWallField(); }
public IntrinsicsAssemblyBuilder(string corlibAssemblyFullName) { var corlibRef = new AssemblyRefUser(new AssemblyNameInfo(corlibAssemblyFullName)); module = new ModuleDefUser(Guid.NewGuid().ToString(), Guid.NewGuid(), corlibRef); module.Kind = ModuleKind.Dll; var asm = new AssemblyDefUser(Guid.NewGuid().ToString()); asm.Modules.Add(module); intrinsicsType = new TypeDefUser(ExpressionCompilerConstants.IntrinsicAssemblyNamespace, ExpressionCompilerConstants.IntrinsicAssemblyTypeName, module.CorLibTypes.Object.TypeDefOrRef); intrinsicsType.Attributes = TypeAttributes.Public | TypeAttributes.AutoLayout | TypeAttributes.Class | TypeAttributes.AnsiClass | TypeAttributes.Abstract | TypeAttributes.Sealed; module.Types.Add(intrinsicsType); corlibTypes = module.CorLibTypes; exceptionTypeSig = new ClassSig(corlibTypes.GetTypeRef(nameof(System), nameof(Exception))); typeTypeSig = new ClassSig(corlibTypes.GetTypeRef(nameof(System), nameof(Type))); guidTypeSig = new ValueTypeSig(corlibTypes.GetTypeRef(nameof(System), nameof(Guid))); }
public SimpleControlFlow(DecompilerContext context, ILBlock method) { this.context = context; this.corLib = context.CurrentMethod.Module.CorLibTypes; foreach (ILLabel target in method.GetSelfAndChildrenRecursive <ILExpression>(e => e.IsBranch()).SelectMany(e => e.GetBranchTargets())) { labelGlobalRefCount[target] = labelGlobalRefCount.GetOrDefault(target) + 1; } foreach (ILBasicBlock bb in method.GetSelfAndChildrenRecursive <ILBasicBlock>()) { foreach (ILLabel label in bb.GetChildren().OfType <ILLabel>()) { labelToBasicBlock[label] = bb; } } }
/// <summary> /// Reads a <see cref="TypeSig"/> signature /// </summary> /// <param name="helper">Token resolver</param> /// <param name="corLibTypes">A <see cref="ICorLibTypes"/> instance</param> /// <param name="signature">The signature reader which will be owned by us</param> /// <param name="gpContext">Generic parameter context</param> /// <returns>A new <see cref="TypeSig"/> instance or <c>null</c> if /// <paramref name="signature"/> is invalid.</returns> public static TypeSig ReadTypeSig(ISignatureReaderHelper helper, ICorLibTypes corLibTypes, IBinaryReader signature, GenericParamContext gpContext) { try { using (var reader = new SignatureReader(helper, corLibTypes, signature, gpContext)) { TypeSig ts; try { ts = reader.ReadType(); } catch (IOException) { ts = null; } return(ts); } } catch { return(null); } }
internal static void Patch() { context = TerrariaPatcher.context; memRes = TerrariaPatcher.memRes ; typeSys = context.PrimaryAssembly.ManifestModule.CorLibTypes; typeDef_NPC = memRes.GetType("Terraria.NPC" ); WrapMethods(); AddFieldForBHandler(); AddFieldsForAudio(); InsertInitialize(); ReplaceSoundHitCalls(); ReplaceSoundKilledCalls(); InjectBuffEffectsCall(); InitBuffBHandlerArray(); }
internal static void Patch() { context = TerrariaPatcher.context; memRes = TerrariaPatcher.memRes; typeSys = context.PrimaryAssembly.ManifestModule.CorLibTypes; typeDef_Player = memRes.GetType("Terraria.Player"); WrapMethods(); AddFieldForBHandler(); AddPlaceThingHook(); InsertSaveLoadHooks(); RemoveBuggyPlayerLoading(); RemoveStatCaps(); ReplaceUseSoundCalls(); FixOnEnterWorldBackingFieldName(); InjectMidUpdate(); InitBuffBHandlerArray(); }
/// <summary> /// Reads a <see cref="TypeSig"/> signature /// </summary> /// <param name="helper">Token resolver</param> /// <param name="corLibTypes">ICorLibTypes instance</param> /// <param name="signature">The signature reader which will be owned by us</param> /// <returns>A new <see cref="TypeSig"/> instance or <c>null</c> if /// <paramref name="signature"/> is invalid.</returns> public static TypeSig ReadTypeSig(ISignatureReaderHelper helper, ICorLibTypes corLibTypes, IImageStream signature) { try { using (var reader = new SignatureReader(helper, corLibTypes, signature)) { TypeSig ts; try { ts = reader.ReadType(); } catch (IOException) { reader.reader.Position = 0; ts = null; } return(ts); } } catch { return(null); } }
internal static void Patch() { context = TerrariaPatcher.context; memRes = TerrariaPatcher.memRes; typeSys = context.PrimaryAssembly.ManifestModule.CorLibTypes; typeDef_NPC = memRes.GetType("Terraria.NPC"); WrapMethods(); AddFieldForBHandler(); AddFieldsForAudio(); InsertInitialize(); ReplaceSoundHitCalls(); ReplaceSoundKilledCalls(); InjectBuffEffectsCall(); InitBuffBHandlerArray(); }
internal static void Patch() { context = TerrariaPatcher.context; memRes = TerrariaPatcher.memRes; typeSys = context.PrimaryAssembly.ManifestModule.CorLibTypes; typeDef_Main = memRes.GetType("Terraria.Main"); WrapMethods(); RemoveVanillaNpcDrawLimitation(); FixOnEngineLoadField(); RemoveArmourDrawLimitations(); AddPreDrawHook(); AddOnUpdateKeyboardHook(); AddPostScreenClearHook(); //These are causing System.InvalidProgramExceptions so I'm just commenting them out (pls don't remove them) //AddIsChatAllowedHook(); //AddLocalChatHook(); }
/// <summary> /// Gets a <see cref="CorLibTypeSig"/> if <paramref name="type"/> matches a primitive type. /// </summary> /// <param name="self">this</param> /// <param name="type">The type</param> /// <returns>A <see cref="CorLibTypeSig"/> or <c>null</c> if it didn't match any primitive type</returns> public static CorLibTypeSig GetCorLibTypeSig(this ICorLibTypes self, ITypeDefOrRef type) { CorLibTypeSig corLibType; if (type is TypeDef td && td.DeclaringType is null && !((corLibType = self.GetCorLibTypeSig(td.Namespace, td.Name, td.DefinitionAssembly)) is null)) { return(corLibType); } if (type is TypeRef tr && !(tr.ResolutionScope is TypeRef) && !((corLibType = self.GetCorLibTypeSig(tr.Namespace, tr.Name, tr.DefinitionAssembly)) is null)) { return(corLibType); } return(null); }
public static CorLibTypeSig GetCorLibTypeSig(this ICorLibTypes clt, ElementType t) { switch (t) { case ElementType.I: return(clt.IntPtr); case ElementType.U: return(clt.UIntPtr); case ElementType.I1: return(clt.SByte); case ElementType.I2: return(clt.Int16); case ElementType.I4: return(clt.Int32); case ElementType.I8: return(clt.Int64); case ElementType.U1: return(clt.Byte); case ElementType.U2: return(clt.UInt16); case ElementType.U4: return(clt.UInt32); case ElementType.U8: return(clt.UInt64); case ElementType.R4: return(clt.Single); case ElementType.R8: return(clt.Double); case ElementType.Char: return(clt.Char); case ElementType.Void: return(clt.Void); case ElementType.Object: return(clt.Object); case ElementType.String: return(clt.String); case ElementType.Boolean: return(clt.Boolean); default: throw new CodeBug.Unreachable(); } }
public void Initialize(DecompilerContext context, ILBlock method) { this.labelGlobalRefCount.Clear(); this.labelToBasicBlock.Clear(); this.context = context; this.corLib = context.CurrentMethod.Module.CorLibTypes; foreach (var e in method.GetSelfAndChildrenRecursive<ILExpression>(List_ILExpression, e => e.IsBranch())) { foreach (var target in e.GetBranchTargets()) labelGlobalRefCount[target] = labelGlobalRefCount.GetOrDefault(target) + 1; } foreach(ILBasicBlock bb in method.GetSelfAndChildrenRecursive<ILBasicBlock>(List_ILBasicBlock)) { int index = 0; for (;;) { var node = bb.GetNext(ref index); if (node == null) break; var label = node as ILLabel; if (label == null) continue; labelToBasicBlock[label] = bb; } } }
public Il2cppContext(string imagePath) { Module = ModuleDefMD.Load(imagePath); Debug.Assert(Module != null); // 加载主模块 AssemblyResolver asmRes = new AssemblyResolver(); ModuleContext modCtx = new ModuleContext(asmRes); asmRes.DefaultModuleContext = modCtx; asmRes.EnableTypeDefCache = true; asmRes.FindExactMatch = false; asmRes.EnableFrameworkRedirect = true; asmRes.FrameworkRedirectVersion = Module.RuntimeVersion; Module.Context = modCtx; Module.Context.AssemblyResolver.AddToCache(Module); CorLibTypes = Module.CorLibTypes; CorLibModule = CorLibTypes.Object.TypeRef.Resolve().Module; RuntimeVersion = Module.RuntimeVersion; Reset(); }
/// <summary> /// Gets a <see cref="CorLibTypeSig"/> if <paramref name="type"/> matches a primitive type. /// </summary> /// <param name="self">this</param> /// <param name="type">The type</param> /// <returns>A <see cref="CorLibTypeSig"/> or <c>null</c> if it didn't match any primitive type</returns> public static CorLibTypeSig GetCorLibTypeSig(this ICorLibTypes self, ITypeDefOrRef type) { CorLibTypeSig corLibType; TypeDef td; if ((td = type as TypeDef) != null && td.DeclaringType == null && (corLibType = self.GetCorLibTypeSig(td.Namespace, td.Name, td.DefinitionAssembly)) != null) { return(corLibType); } TypeRef tr; if ((tr = type as TypeRef) != null && !(tr.ResolutionScope is TypeRef) && (corLibType = self.GetCorLibTypeSig(tr.Namespace, tr.Name, tr.DefinitionAssembly)) != null) { return(corLibType); } return(null); }
public IEnumerable <TypeDefUser> Execute(ICorLibTypes types) { string current_namespace = "DEFAULT_IF_NOT_EXISTS"; for (int i = 0; i < junksAmount; i++) { if (i % 4 == 0) { current_namespace = renamer.GetObfuscated(false); } TypeDefUser tdu = new TypeDefUser(current_namespace, renamer.GetObfuscated(false)); tdu.Attributes = TypeAttributes.Class | TypeAttributes.Public | TypeAttributes.Sealed; MethodDef md_obf = createObfuscatedByMethod(types, tdu); for (int fields_i = 0; fields_i < random.Next(junksFieldsA, junksFieldsB); fields_i++) { tdu.Fields.Add(new FieldDefUser(renamer.GetObfuscated(false), new FieldSig(getRandomTypeSigForField(types)), fields_i % 3 == 0 ? FieldAttributes.Private : FieldAttributes.Public)); } for (int methods_i = 0; methods_i < random.Next(junksFieldsA, junksFieldsB); methods_i++) { MethodDefUser mdu = new MethodDefUser(renamer.GetObfuscated(false), new MethodSig(CallingConvention.Default, 0, types.String), methods_i % 3 == 0 ? MethodAttributes.Public : MethodAttributes.Private); mdu.Body = new CilBody(true, new Instruction[] { OpCodes.Nop.ToInstruction(), OpCodes.Ldstr.ToInstruction("Obfuscated by Wisser Tg"), OpCodes.Callvirt.ToInstruction(md_obf), OpCodes.Ret.ToInstruction() }, new ExceptionHandler[0], new Local[0]); tdu.Methods.Add(mdu); } yield return(tdu); } }
/* needs a better name */ static TypeSig ICast(TypeSig a, TypeSig b, ICorLibTypes ts) { if (comp.Equals(a, b)) return a; if (comp.Equals(a, ts.String)) return a; if (comp.Equals(b, ts.String)) return b; if (comp.Equals(a, ts.IntPtr) || comp.Equals(a, ts.UIntPtr)) return a; if (comp.Equals(b, ts.IntPtr) || comp.Equals(b, ts.UIntPtr)) return b; if (comp.Equals(a, ts.Double)) return a; if (comp.Equals(b, ts.Double)) return b; if (comp.Equals(a, ts.Single)) return a; if (comp.Equals(b, ts.Single)) return b; if (comp.Equals(a, ts.Int64) || comp.Equals(a, ts.UInt64)) return a; if (comp.Equals(b, ts.Int64) || comp.Equals(b, ts.UInt64)) return b; if (!a.IsByRef || !b.IsByRef) return ts.Object; var ad = a.ToTypeDefOrRef().ResolveTypeDefThrow(); var bd = b.ToTypeDefOrRef().ResolveTypeDefThrow(); if ((!ad.IsSequentialLayout || !ad.IsExplicitLayout) && (!bd.IsSequentialLayout || !bd.IsExplicitLayout)) return ts.IntPtr; // close enough return ad.PackingSize > bd.PackingSize ? a : b; }
public PatternMatcher(ICorLibTypes corLib) { this.corLib = corLib; }
public PatternMatcher(DecompilerContext context, ICorLibTypes corLib) { this.context = context; this.corLib = corLib; }
public void Initialize(ICorLibTypes corLib) { this.corLib = corLib; Reset(); }
public PatternMatcher(ICorLibTypes typeSystem) { this.typeSystem = typeSystem; }