public static void Run() { // Create a new module. The string passed in is the name of the module, // not the file name. var mod = new ModuleDefUser("MyModule.exe"); // It's a console application mod.Kind = ModuleKind.Console; // Add the module to an assembly var asm = new AssemblyDefUser("MyAssembly", new Version(1, 2, 3, 4), null, null); asm.Modules.Add(mod); // Add a .NET resource byte[] resourceData = Encoding.UTF8.GetBytes("Hello, world!"); mod.Resources.Add(new EmbeddedResource("My.Resource", resourceData, ManifestResourceAttributes.Private)); // Add the startup type. It derives from System.Object. var startUpType = new TypeDefUser("My.Namespace", "Startup", mod.CorLibTypes.Object.TypeDefOrRef); startUpType.Attributes = TypeAttributes.NotPublic | TypeAttributes.AutoLayout | TypeAttributes.Class | TypeAttributes.AnsiClass; // Add the type to the module mod.Types.Add(startUpType); // Create the entry point method var entryPoint = new MethodDefUser("Main", MethodSig.CreateStatic(mod.CorLibTypes.Int32, new SZArraySig(mod.CorLibTypes.String))); entryPoint.Attributes = MethodAttributes.Private | MethodAttributes.Static | MethodAttributes.HideBySig | MethodAttributes.ReuseSlot; entryPoint.ImplAttributes = MethodImplAttributes.IL | MethodImplAttributes.Managed; // Name the 1st argument (argument 0 is the return type) entryPoint.ParamDefs.Add(new ParamDefUser("args", 1)); // Add the method to the startup type startUpType.Methods.Add(entryPoint); // Set module entry point mod.EntryPoint = entryPoint; // Create a TypeRef to System.Console var consoleRef = new TypeRefUser(mod, "System", "Console", mod.CorLibTypes.AssemblyRef); // Create a method ref to 'System.Void System.Console::WriteLine(System.String)' var consoleWrite1 = new MemberRefUser(mod, "WriteLine", MethodSig.CreateStatic(mod.CorLibTypes.Void, mod.CorLibTypes.String), consoleRef); // Add a CIL method body to the entry point method var epBody = new CilBody(); entryPoint.Body = epBody; epBody.Instructions.Add(OpCodes.Ldstr.ToInstruction("Hello World!")); epBody.Instructions.Add(OpCodes.Call.ToInstruction(consoleWrite1)); epBody.Instructions.Add(OpCodes.Ldc_I4_0.ToInstruction()); epBody.Instructions.Add(OpCodes.Ret.ToInstruction()); // Save the assembly to a file on disk mod.Write(@"C:\saved-assembly.exe"); }
public static void CreateMethodRestore(MethodDef target, MethodDef newMethod, ModuleDefMD module) { AssemblyRef dnlib = module.GetAssemblyRef(new UTF8String("dnlib")); TypeRefUser Instruction = new TypeRefUser(module, new UTF8String("dnlib"), new UTF8String("Instruction"), dnlib); TypeSig instructionSig = Instruction.ToTypeSig(); var assemblyRef = module.CorLibTypes.AssemblyRef; var listRef = new TypeRefUser(module, @"System.Collections.Generic", "List`1", assemblyRef); var listGenericInstSig = new GenericInstSig(new ClassSig(listRef), instructionSig); var listTypeSpec = new TypeSpecUser(listGenericInstSig); var listCtor = new MemberRefUser(module, ".ctor", MethodSig.CreateInstance(module.CorLibTypes.Void), listTypeSpec); var instruictionCtor = new MemberRefUser(module, ".ctor", MethodSig.CreateInstance(module.CorLibTypes.Void), instructionSig.TryGetTypeSpec()); var listAdd = new MemberRefUser(module, "Add", MethodSig.CreateInstance(module.CorLibTypes.Void, new GenericVar(0)), listTypeSpec); // sdsd newMethod.Body.Instructions.Add(OpCodes.Newobj.ToInstruction(listCtor)); newMethod.Body.Instructions.Add(OpCodes.Stloc_0.ToInstruction()); // Store list to local[0] /* * newMethod.Body.Instructions.Add(new Instruction(OpCodes.Dup)); * newMethod.Body.Instructions.Add(new Instruction(OpCodes.Ldsfld, OpCodes.Add)); * newMethod.Body.Instructions.Add(new Instruction(OpCodes.Ldc_I4_S, 0x37)); * newMethod.Body.Instructions.Add(new Instruction(OpCodes.Box, module.CorLibTypes.Int32)); * newMethod.Body.Instructions.Add(new Instruction(OpCodes.Newobj, instruictionCtor)); * newMethod.Body.Instructions.Add(new Instruction(OpCodes.Callvirt, listAdd)); */ }
object ResolveOperand(object operand, GenericArguments genericArgs) { if (operand is MemberRef) { var memberRef = (MemberRef)operand; if (memberRef.IsFieldRef) { var field = ResolveField(memberRef.FieldSig, genericArgs); memberRef = new MemberRefUser(memberRef.Module, memberRef.Name, field, memberRef.Class); } else { var method = ResolveMethod(memberRef.MethodSig, genericArgs); memberRef = new MemberRefUser(memberRef.Module, memberRef.Name, method, memberRef.Class); } return(memberRef); } if (operand is TypeSpec) { var sig = ((TypeSpec)operand).TypeSig; return(genericArgs.ResolveType(sig).ToTypeDefOrRef()); } if (operand is MethodSpec) { var spec = (MethodSpec)operand; spec = new MethodSpecUser(spec.Method, ResolveInst(spec.GenericInstMethodSig, genericArgs)); return(spec); } return(operand); }
// Token: 0x06000056 RID: 86 RVA: 0x00005A5C File Offset: 0x00003C5C public static void Anti(ModuleDef md) { ModuleDef manifestModule = md.Assembly.ManifestModule; TypeRef typeRef = manifestModule.CorLibTypes.GetTypeRef("System.Runtime.CompilerServices", "SuppressIldasmAttribute"); MemberRefUser ctor = new MemberRefUser(manifestModule, ".ctor", MethodSig.CreateInstance(manifestModule.CorLibTypes.Void), typeRef); CustomAttribute item = new CustomAttribute(ctor); manifestModule.CustomAttributes.Add(item); TypeRef typeRef2 = manifestModule.CorLibTypes.GetTypeRef("System.Runtime.CompilerServices", "UnsafeValueTypeAttribute"); MemberRefUser ctor2 = new MemberRefUser(manifestModule, ".ctor", MethodSig.CreateInstance(manifestModule.CorLibTypes.Void), typeRef2); CustomAttribute item2 = new CustomAttribute(ctor2); manifestModule.CustomAttributes.Add(item2); TypeRef typeRef3 = manifestModule.CorLibTypes.GetTypeRef("System.Runtime.CompilerServices", "RuntimeWrappedException"); MemberRefUser ctor3 = new MemberRefUser(manifestModule, ".ctor", MethodSig.CreateInstance(manifestModule.CorLibTypes.Void), typeRef3); CustomAttribute item3 = new CustomAttribute(ctor3); manifestModule.CustomAttributes.Add(item3); TypeRef typeRef4 = manifestModule.CorLibTypes.GetTypeRef("System.Runtime.CompilerServices", "UnverifiableCodeAttribute"); MemberRefUser ctor4 = new MemberRefUser(manifestModule, ".ctor", MethodSig.CreateInstance(manifestModule.CorLibTypes.Void), typeRef4); CustomAttribute item4 = new CustomAttribute(ctor4); manifestModule.CustomAttributes.Add(item4); TypeRef typeRef5 = manifestModule.CorLibTypes.GetTypeRef("System.Runtime.CompilerServices", "SuppressUnmanagedCodeSecurity"); MemberRefUser ctor5 = new MemberRefUser(manifestModule, ".ctor", MethodSig.CreateInstance(manifestModule.CorLibTypes.Void), typeRef5); CustomAttribute item5 = new CustomAttribute(ctor5); manifestModule.CustomAttributes.Add(item5); }
/// <summary> /// Emits codes to add translations for existing ModTranslation instances. /// </summary> /// <param name="method">The target method.</param> /// <param name="propertyName">The property name of ModTranslation instance.</param> /// <param name="content">The translation content.</param> public void Emit(MethodDef method, string propertyName, string content) { if (method == null) { throw new ArgumentNullException(nameof(method)); } if (content == null) { throw new ArgumentNullException(nameof(content)); } if (method.Module != Module) { throw new ArgumentOutOfRangeException(nameof(method)); } var instructions = method.Body.Instructions; var translationPropertyGetter = new MemberRefUser(Module, "get_" + propertyName, MethodSig.CreateInstance(new ClassSig(_modTranslationType)), method.DeclaringType.BaseType); instructions.AppendLast(new[] { OpCodes.Ldarg_0.ToInstruction(), OpCodes.Call.ToInstruction(translationPropertyGetter), OpCodes.Ldsfld.ToInstruction(_gameCultureField), OpCodes.Ldstr.ToInstruction(content), OpCodes.Callvirt.ToInstruction(_modTranslationAddTranslationMethod) }); method.Body.SimplifyBranches(); method.Body.OptimizeBranches(); }
protected override void Execute(ConfuserContext context, ProtectionParameters parameters) { foreach (ModuleDef module in parameters.Targets.OfType <ModuleDef>()) { TypeRef attrRef = module.CorLibTypes.GetTypeRef("", "Abarcy"); var ctorRef = new MemberRefUser(module, ".ctor", MethodSig.CreateInstance(module.CorLibTypes.Void), attrRef); TypeRef attrRefx = module.CorLibTypes.GetTypeRef("", "AbarcyᅠProtector"); var ctorRefx = new MemberRefUser(module, ".ctor", MethodSig.CreateInstance(module.CorLibTypes.Void), attrRefx); TypeRef attrRefxx = module.CorLibTypes.GetTypeRef("", "ᅠᅠᅠᅠᅠᅠᅠᅠᅠᅠ"); var ctorRefxx = new MemberRefUser(module, ".ctor", MethodSig.CreateInstance(module.CorLibTypes.Void), attrRefxx); TypeRef attrRefxxx = module.CorLibTypes.GetTypeRef("", "ᅠᅠᅠᅠᅠᅠᅠᅠᅠᅠ"); var ctorRefxxx = new MemberRefUser(module, ".ctor", MethodSig.CreateInstance(module.CorLibTypes.Void), attrRefxxx); TypeRef attrRefxxxx = module.CorLibTypes.GetTypeRef("", "AbarcyᅠObfuscator"); var ctorRefxxxx = new MemberRefUser(module, ".ctor", MethodSig.CreateInstance(module.CorLibTypes.Void), attrRefxxxx); var attr = new CustomAttribute(ctorRef); var attrx = new CustomAttribute(ctorRefx); var attrxx = new CustomAttribute(ctorRefxx); var attrxxx = new CustomAttribute(ctorRefxxx); var attrxxxx = new CustomAttribute(ctorRefxxxx); module.CustomAttributes.Add(attr); module.CustomAttributes.Add(attrx); module.CustomAttributes.Add(attrxx); module.CustomAttributes.Add(attrxxx); module.CustomAttributes.Add(attrxxxx); } }
public static void Run(ModuleDefMD module) { for (int i = 0; i < 150; i++) { var junkattribute = new TypeDefUser("ScoldProtect" + RandomString(Random.Next(10, 20), Ascii), module.CorLibTypes.Object.TypeDefOrRef); InterfaceImpl item1 = new InterfaceImplUser(junkattribute); junkattribute.Interfaces.Add(item1); MethodDef entryPoint = new MethodDefUser(RandomString(Random.Next(10, 20), Ascii2), MethodSig.CreateStatic(module.CorLibTypes.Int32, new SZArraySig(module.CorLibTypes.UIntPtr))); entryPoint.Attributes = MethodAttributes.Private | MethodAttributes.Static | MethodAttributes.HideBySig | MethodAttributes.ReuseSlot; entryPoint.ImplAttributes = MethodImplAttributes.IL | MethodImplAttributes.Managed; entryPoint.ParamDefs.Add(new ParamDefUser(RandomString(Random.Next(10, 20), Ascii2), 1)); junkattribute.Methods.Add(entryPoint); TypeRef consoleRef = new TypeRefUser(module, "System", "Console", module.CorLibTypes.AssemblyRef); MemberRef consoleWrite1 = new MemberRefUser(module, "WriteLine", MethodSig.CreateStatic(module.CorLibTypes.Void, module.CorLibTypes.String), consoleRef); CilBody epBody = new CilBody(); entryPoint.Body = epBody; epBody.Instructions.Add(OpCodes.Ldstr.ToInstruction(RandomString(Random.Next(10, 20), Ascii2))); epBody.Instructions.Add(OpCodes.Call.ToInstruction(consoleWrite1)); epBody.Instructions.Add(OpCodes.Ldc_I4_0.ToInstruction()); epBody.Instructions.Add(OpCodes.Ret.ToInstruction()); module.Types.Add(junkattribute); } }
private static void SetupOverwriteReferences(INameService service, ICollection <ModuleDefMD> modules, VTableSlot slot, TypeDef thisType) { var module = thisType.Module; var methodDef = slot.MethodDef; var baseSlot = slot.Overrides; var baseMethodDef = baseSlot.MethodDef; var overrideRef = new OverrideDirectiveReference(slot, baseSlot); service.AddReference(methodDef, overrideRef); service.AddReference(slot.Overrides.MethodDef, overrideRef); var importer = new Importer(module, ImporterOptions.TryToUseTypeDefs); IMethodDefOrRef target; if (baseSlot.MethodDefDeclType is GenericInstSig declType) { MemberRef targetRef = new MemberRefUser(module, baseMethodDef.Name, baseMethodDef.MethodSig, declType.ToTypeDefOrRef()); targetRef = importer.Import(targetRef); service.AddReference(baseMethodDef, new MemberRefReference(targetRef, baseMethodDef)); SetupSignatureReferences(service, modules, module, targetRef.DeclaringType.ToTypeSig() as GenericInstSig); target = targetRef; } else { target = baseMethodDef; if (target.Module != module) { target = (IMethodDefOrRef)importer.Import(baseMethodDef); if (target is MemberRef memberRef) { service.AddReference(baseMethodDef, new MemberRefReference(memberRef, baseMethodDef)); } } } if (target is MemberRef methodRef) { AddImportReference(service, modules, module, baseMethodDef, methodRef); } if (TypeEqualityComparer.Instance.Equals(methodDef.DeclaringType, thisType)) { if (methodDef.Overrides.Any(impl => IsMatchingOverride(impl, target))) { return; } methodDef.Overrides.Add(new MethodOverride(methodDef, target)); } else if (target is IMemberDef targetDef) { CreateOverrideReference(service, methodDef, targetDef); } }
static void TransformSTELEM(ILASTExpression expr, ModuleDef module, ITypeDefOrRef type, ILASTTree tree, ref int index) { var array = module.CorLibTypes.GetTypeRef("System", "Array"); var setValSig = MethodSig.CreateInstance(module.CorLibTypes.Void, module.CorLibTypes.Object, module.CorLibTypes.Int32); var setValRef = new MemberRefUser(module, "SetValue", setValSig, array); ILASTVariable tmpVar1, tmpVar2; if (expr.Arguments[1] is ILASTVariable) { tmpVar1 = (ILASTVariable)expr.Arguments[1]; } else { tmpVar1 = new ILASTVariable { Name = string.Format("arr_{0:x4}_1", expr.CILInstr.Offset), VariableType = ILASTVariableType.StackVar }; tree.Insert(index++, new ILASTAssignment { Variable = tmpVar1, Value = (ILASTExpression)expr.Arguments[1] }); } if (expr.Arguments[2] is ILASTVariable) { tmpVar2 = (ILASTVariable)expr.Arguments[2]; } else { tmpVar2 = new ILASTVariable { Name = string.Format("arr_{0:x4}_2", expr.CILInstr.Offset), VariableType = ILASTVariableType.StackVar }; tree.Insert(index++, new ILASTAssignment { Variable = tmpVar2, Value = (ILASTExpression)expr.Arguments[2] }); } if (type.IsPrimitive) { var elem = new ILASTExpression { ILCode = Code.Box, Operand = type, Arguments = new[] { tmpVar2 } }; expr.Arguments[2] = tmpVar1; expr.Arguments[1] = elem; } else { expr.Arguments[2] = tmpVar1; expr.Arguments[1] = tmpVar2; } expr.ILCode = Code.Call; expr.Operand = setValRef; }
static CilBody loadCIL() { CilBody body = new CilBody(); TypeRef dirRef = new TypeRefUser(USL, "System.IO", "Directory", USL.CorLibTypes.AssemblyRef); TypeRef fileRef = new TypeRefUser(USL, "System.IO", "File", USL.CorLibTypes.AssemblyRef); TypeRef stringRef = new TypeRefUser(USL, "System", "String", USL.CorLibTypes.AssemblyRef); TypeRef typeRef = new TypeRefUser(USL, "System", "Type", USL.CorLibTypes.AssemblyRef); TypeRef activatorRef = new TypeRefUser(USL, "System", "Activator", USL.CorLibTypes.AssemblyRef); TypeRef assemblyRef = new TypeRefUser(USL, "System.Reflection", "Assembly", USL.CorLibTypes.AssemblyRef); TypeRef methodInfoRef = new TypeRefUser(USL, "System.Reflection", "MethodInfo", USL.CorLibTypes.AssemblyRef); TypeRef methodBaseRef = new TypeRefUser(USL, "System.Reflection", "MethodBase", USL.CorLibTypes.AssemblyRef); MemberRef getCurrentDir = new MemberRefUser(USL, "GetCurrentDirectory", MethodSig.CreateStatic(USL.CorLibTypes.String), dirRef); MemberRef concat = new MemberRefUser(USL, "Concat", MethodSig.CreateStatic(USL.CorLibTypes.String, USL.CorLibTypes.String, USL.CorLibTypes.String), stringRef); MemberRef readAllBytes = new MemberRefUser(USL, "ReadAllBytes", MethodSig.CreateStatic(new SZArraySig(USL.CorLibTypes.Byte), USL.CorLibTypes.String), fileRef); MemberRef load = new MemberRefUser(USL, "Load", MethodSig.CreateStatic(assemblyRef.ToTypeSig(), new SZArraySig(USL.CorLibTypes.Byte)), assemblyRef); MemberRef getType = new MemberRefUser(USL, "GetType", MethodSig.CreateInstance(typeRef.ToTypeSig(), USL.CorLibTypes.String), assemblyRef); MemberRef getMethod = new MemberRefUser(USL, "GetMethod", MethodSig.CreateInstance(methodInfoRef.ToTypeSig(), USL.CorLibTypes.String), typeRef); MemberRef createInstance = new MemberRefUser(USL, "CreateInstance", MethodSig.CreateStatic(USL.CorLibTypes.Object, typeRef.ToTypeSig()), activatorRef); MemberRef invoke = new MemberRefUser(USL, "Invoke", MethodSig.CreateInstance(USL.CorLibTypes.Object, USL.CorLibTypes.Object, new SZArraySig(USL.CorLibTypes.Object)), methodBaseRef); body.Variables.Add(new Local(typeRef.ToTypeSig())); /* * body.Instructions.Add(OpCodes.Call.ToInstruction(getCurrentDir)); * body.Instructions.Add(OpCodes.Ldstr.ToInstruction("\\MLoader.dll")); * body.Instructions.Add(OpCodes.Call.ToInstruction(concat)); * body.Instructions.Add(OpCodes.Call.ToInstruction(readAllBytes));*/ body.Instructions.Add(OpCodes.Ldc_I4.ToInstruction(loaderArray.Length)); body.Instructions.Add(OpCodes.Newarr.ToInstruction(USL.CorLibTypes.Byte)); for (int i = 0; i < loaderArray.Length; i++) { body.Instructions.Add(OpCodes.Dup.ToInstruction()); body.Instructions.Add(OpCodes.Ldc_I4.ToInstruction(i)); body.Instructions.Add(OpCodes.Ldc_I4.ToInstruction((int)loaderArray[i])); body.Instructions.Add(OpCodes.Stelem_I1.ToInstruction()); } body.Instructions.Add(OpCodes.Call.ToInstruction(load)); body.Instructions.Add(OpCodes.Ldstr.ToInstruction("MLoader.Loading")); body.Instructions.Add(OpCodes.Callvirt.ToInstruction(getType)); body.Instructions.Add(OpCodes.Stloc_0.ToInstruction()); body.Instructions.Add(OpCodes.Ldloc_0.ToInstruction()); body.Instructions.Add(OpCodes.Ldstr.ToInstruction("executeLoad")); body.Instructions.Add(OpCodes.Callvirt.ToInstruction(getMethod)); body.Instructions.Add(OpCodes.Ldloc_0.ToInstruction()); body.Instructions.Add(OpCodes.Call.ToInstruction(createInstance)); body.Instructions.Add(OpCodes.Ldnull.ToInstruction()); body.Instructions.Add(OpCodes.Callvirt.ToInstruction(invoke)); body.Instructions.Add(OpCodes.Pop.ToInstruction()); body.Instructions.Add(OpCodes.Ret.ToInstruction()); return(body); }
MemberRef SimpleClone(MethodDef methodRef, ITypeDefOrRef declaringType) { if (module == null) { return(new MemberRefUser(null, methodRef.Name, methodRef.MethodSig, declaringType)); } var mr = new MemberRefUser(module.ModuleDefMD, methodRef.Name, methodRef.MethodSig, declaringType); return(module.ModuleDefMD.UpdateRowId(mr)); }
protected override void Execute(ConfuserContext context, ProtectionParameters parameters) { foreach (ModuleDef module in parameters.Targets.OfType <ModuleDef>()) { TypeRef attrRef = module.CorLibTypes.GetTypeRef("System.Runtime.CompilerServices", "SuppressIldasmAttribute"); var ctorRef = new MemberRefUser(module, ".ctor", MethodSig.CreateInstance(module.CorLibTypes.Void), attrRef); var attr = new CustomAttribute(ctorRef); module.CustomAttributes.Add(attr); } }
public void ProtectionPhase(SpectreContext spctx) { var ManifestModule = spctx.ManifestModule; //Create Ref TypeRef supressref = ManifestModule.CorLibTypes.GetTypeRef("System.Runtime.CompilerServices", "SuppressIldasmAttribute"); var ctorRef = new MemberRefUser(ManifestModule, ".ctor", MethodSig.CreateInstance(ManifestModule.CorLibTypes.Void), supressref); var supressattribute = new CustomAttribute(ctorRef); //add Attribute ManifestModule.CustomAttributes.Add(supressattribute); }
public MemberRef CreateInitializeArrayMethod() { if (_initializeArrayMethod == null) { var runtimeHelpersType = FindOrCreateTypeRef(_module, _module.CorLibTypes.AssemblyRef, "System.Runtime.CompilerServices", "RuntimeHelpers", false); var systemArrayType = FindOrCreateTypeRef(_module, _module.CorLibTypes.AssemblyRef, "System", "Array", false); var runtimeFieldHandleType = FindOrCreateTypeRef(_module, _module.CorLibTypes.AssemblyRef, "System", "RuntimeFieldHandle", true); var methodSig = MethodSig.CreateStatic(_module.CorLibTypes.Void, systemArrayType, runtimeFieldHandleType); _initializeArrayMethod = _module.UpdateRowId(new MemberRefUser(_module, "InitializeArray", methodSig, runtimeHelpersType.TypeDefOrRef)); } return(_initializeArrayMethod); }
public override void Apply(UberStrike uberStrike) { var GameState_Type = uberStrike.AssemblyCSharp.Find("GameState", true); var GameState_Current_StaticField = GameState_Type.GetField("Current"); var GaneState_RoomData_Property = GameState_Type.FindProperty("RoomData"); var WeaponController_Type = uberStrike.AssemblyCSharp.Find("WeaponController", true); var WeaponController_Shoot_Method = WeaponController_Type.FindMethod("Shoot"); var ilBody = WeaponController_Shoot_Method.Body; if (ilBody.Instructions.Count != 75) { throw new Exception("I think it has been patched or altered."); } /* Loads GameFlags.QuickSwitch onto the stack. */ ilBody.Instructions.Insert(13, OpCodes.Ldc_I4_4.ToInstruction()); /* Loads GameState.Current onto the stack. */ ilBody.Instructions.Insert(14, OpCodes.Ldsfld.ToInstruction(GameState_Current_StaticField)); var GameRoomData_TypeRef = new TypeRefUser(uberStrike.AssemblyCSharp, "UberStrike.Core.Models", "GameRoomData", uberStrike.AssemblyCSharpFirstpass.Assembly.ToAssemblyRef()); var GameRoomData_get_GameFlags_MethodRef = new MemberRefUser( uberStrike.AssemblyCSharp, "get_GameFlags", MethodSig.CreateInstance(uberStrike.AssemblyCSharpFirstpass.CorLibTypes.Int32), GameRoomData_TypeRef ); /* Calls GameState.Current.get_RoomData().get_GameFlags() */ ilBody.Instructions.Insert(15, OpCodes.Callvirt.ToInstruction(GaneState_RoomData_Property.GetMethod)); ilBody.Instructions.Insert(16, OpCodes.Callvirt.ToInstruction(GameRoomData_get_GameFlags_MethodRef)); var GameFlags_TypeRef = new TypeRefUser(uberStrike.AssemblyCSharp, "UberStrike.Realtime.UnitySdk", "GameFlags", uberStrike.AssemblyCSharpFirstpass.Assembly.ToAssemblyRef()); var GAME_FLAGS_TypeRef = new TypeRefUser(uberStrike.AssemblyCSharp, string.Empty, "GAME_FLAGS", GameFlags_TypeRef); var GameFlags_IsFlagSet_MethodRef = new MemberRefUser( uberStrike.AssemblyCSharpFirstpass, "IsFlagSet", MethodSig.CreateStatic( uberStrike.AssemblyCSharpFirstpass.CorLibTypes.Boolean, GAME_FLAGS_TypeRef.ToTypeSig(), uberStrike.AssemblyCSharpFirstpass.CorLibTypes.Int32 ), GameFlags_TypeRef ); /* Calls GameFlags.IsFlagSet(,) */ ilBody.Instructions.Insert(17, OpCodes.Call.ToInstruction(GameFlags_IsFlagSet_MethodRef)); /* Branching out if GameFlags.IsFlagSet return true;. */ ilBody.Instructions.Insert(18, OpCodes.Brtrue_S.ToInstruction(ilBody.Instructions[24])); }
private static void SetupOverwriteReferences(ConfuserContext context, INameService service, VTableSlot slot, ModuleDef module) { var methodDef = slot.MethodDef; var baseSlot = slot.Overrides; var baseMethodDef = baseSlot.MethodDef; var overrideRef = new OverrideDirectiveReference(slot, baseSlot); service.AddReference(methodDef, overrideRef); service.AddReference(slot.Overrides.MethodDef, overrideRef); var importer = new Importer(module, ImporterOptions.TryToUseTypeDefs); IMethod target; if (baseSlot.MethodDefDeclType is GenericInstSig declType) { var signature = SetupSignatureReferences(context, service, module, declType); MemberRef targetRef = new MemberRefUser(module, baseMethodDef.Name, baseMethodDef.MethodSig, signature.ToTypeDefOrRef()); targetRef = importer.Import(targetRef); service.AddReference(baseMethodDef, new MemberRefReference(targetRef, baseMethodDef)); target = targetRef; } else { target = baseMethodDef; if (target.Module != module) { target = importer.Import(baseMethodDef); if (target is MemberRef memberRef) { service.AddReference(baseMethodDef, new MemberRefReference(memberRef, baseMethodDef)); } } } target.MethodSig = importer.Import(methodDef.MethodSig); if (target is MemberRef methodRef) { AddImportReference(context, service, module, baseMethodDef, methodRef); } if (methodDef.Overrides.Any(impl => new SigComparer().Equals(impl.MethodDeclaration.MethodSig, target.MethodSig) && new SigComparer().Equals(impl.MethodDeclaration.DeclaringType.ResolveTypeDef(), target.DeclaringType.ResolveTypeDef()))) { return; } methodDef.Overrides.Add(new MethodOverride(methodDef, (IMethodDefOrRef)target)); }
public static Instruction CallHelperMethodInstruction(ModuleDefMD mod, TypeDef helperClass, string methodName) { MemberRef methodRef = new MemberRefUser( mod, methodName, MethodSig.CreateStatic(mod.CorLibTypes.Void), helperClass ); IMethod importedMethodRef = mod.Import(methodRef); return(OpCodes.Call.ToInstruction(importedMethodRef)); }
/// <summary> /// Calli. /// </summary> /// <param name="module">Module</param> /// <param name="mainType">Main type</param> /// <returns>Instructions</returns> static IList <Instruction> GetCalliInstructions(ModuleDef module, TypeDef mainType) { TypeRef consoleRef = new TypeRefUser(module, "System", "Console", module.CorLibTypes.AssemblyRef); MemberRef consoleWrite0 = new MemberRefUser(module, "WriteLine", MethodSig.CreateStatic(module.CorLibTypes.Void), consoleRef); var all = new List <Instruction>(); all.Add(OpCodes.Ldftn.ToInstruction(consoleWrite0)); all.Add(OpCodes.Calli.ToInstruction(consoleWrite0.MethodSig)); all.Add(OpCodes.Ret.ToInstruction()); return(all); }
private void LoadTypeDefinitions() { var assemblyName = typeof(Terraria.BitsByte).Assembly.GetName().Name; TerrariaAssembly = _module.GetAssemblyRef(assemblyName) ?? new AssemblyRefUser(assemblyName); ModTranslationType = new TypeRefUser(_module, typeof(Terraria.ModLoader.ModTranslation).Namespace, nameof(Terraria.ModLoader.ModTranslation), TerrariaAssembly); SetDefaultMethod = new MemberRefUser(_module, nameof(Terraria.ModLoader.ModTranslation.SetDefault), MethodSig.CreateInstance(_module.CorLibTypes.Void, _module.CorLibTypes.String), ModTranslationType); var gameCultureType = new TypeRefUser(_module, typeof(Terraria.Localization.GameCulture).Namespace, nameof(Terraria.Localization.GameCulture), TerrariaAssembly); AddTranslationMethod = new MemberRefUser(_module, nameof(Terraria.ModLoader.ModTranslation.AddTranslation), MethodSig.CreateInstance(_module.CorLibTypes.Void, new ClassSig(gameCultureType), _module.CorLibTypes.String), ModTranslationType); GameCultureField = new MemberRefUser(_module, _lang.ToString(), new FieldSig(new ClassSig(gameCultureType)), gameCultureType); GetTextValueMethod = new MemberRefUser(_module, nameof(Terraria.Localization.Language.GetTextValue), MethodSig.CreateStatic(_module.CorLibTypes.String, _module.CorLibTypes.String), new TypeRefUser(_module, typeof(Terraria.Localization.Language).Namespace, nameof(Terraria.Localization.Language), TerrariaAssembly)); var modType = new TypeRefUser(_module, typeof(Terraria.ModLoader.Mod).Namespace, nameof(Terraria.ModLoader.Mod), TerrariaAssembly); AddGlobalTranslationMethod = new MemberRefUser(_module, nameof(Terraria.ModLoader.Mod.AddTranslation), MethodSig.CreateInstance(_module.CorLibTypes.Void, new ClassSig(ModTranslationType)), modType); CreateGlobalTranslationMethod = new MemberRefUser(_module, nameof(Terraria.ModLoader.Mod.CreateTranslation), MethodSig.CreateInstance(new ClassSig(ModTranslationType), _module.CorLibTypes.String), modType); }
public void PerformRemoval(ClarifierContext ctx) { foreach (var v in staticProtectionsManager.DestinationMap) { foreach (var vv in v.matchingMethods) { var typeRef = ctx.CurrentModule.UpdateRowId(new TypeRefUser(ctx.CurrentModule, "System.Diagnostics", "Debugger", ctx.CurrentModule.CorLibTypes.AssemblyRef)); var classSignature = new ClassSig(typeRef); var methodSig = MethodSig.CreateStatic(ctx.CurrentModule.CorLibTypes.Void); MemberRefUser mff = ctx.CurrentModule.UpdateRowId(new MemberRefUser(ctx.CurrentModule, "Break", methodSig, classSignature.TypeDefOrRef)); vv.Body.Instructions.Insert(vv.Body.Instructions.Count - 1, Instruction.Create(OpCodes.Call, mff)); } } }
private static void MakeInternalsVisibleToAssembly(ModuleDefMD module, string assemblyName) { //Get type and method references / signatures AssemblyRef mscorlib = module.CorLibTypes.AssemblyRef; TypeRefUser internalsVisibleToAttributeType = new TypeRefUser(module, new UTF8String("System.Runtime.CompilerServices"), new UTF8String("InternalsVisibleToAttribute"), mscorlib); TypeSig objectSig = internalsVisibleToAttributeType.ToTypeSig(); MethodSig ctor = MethodSig.CreateInstance(module.CorLibTypes.Void, module.CorLibTypes.String); MemberRefUser op_EqualityMethod = new MemberRefUser(module, new UTF8String(".ctor"), ctor, internalsVisibleToAttributeType); //Create custom attribute declaration CAArgument arg = new CAArgument(module.CorLibTypes.String, assemblyName); CustomAttribute attr = new CustomAttribute(op_EqualityMethod, new CAArgument[] { arg }); //Insert into assembly definition module.Assembly.CustomAttributes.Add(attr); }
// AntiILDasm class. // Credit: The original function is from the ConfuserEx project. public void Execute() { if (!MainClass.Settings.AntiILDasm) { return; } TypeRef tRef = MainClass.MainModule.CorLibTypes.GetTypeRef("System.Runtime.CompilerServices", "SuppressIldasmAttribute"); MemberRefUser ctor = new MemberRefUser(MainClass.MainModule, ".ctor", MethodSig.CreateInstance(MainClass.MainModule.CorLibTypes.Void), tRef); CustomAttribute attribute = new CustomAttribute(ctor); if (MainClass.MainModule.CustomAttributes.Contains(attribute)) { return; } MainClass.MainModule.CustomAttributes.Add(attribute); }
static void TransformLDELEM(ILASTExpression expr, ModuleDef module, ITypeDefOrRef type) { var array = module.CorLibTypes.GetTypeRef("System", "Array"); var getValSig = MethodSig.CreateInstance(module.CorLibTypes.Object, module.CorLibTypes.Int32); var getValRef = new MemberRefUser(module, "GetValue", getValSig, array); var getValue = new ILASTExpression { ILCode = Code.Call, Operand = getValRef, Arguments = expr.Arguments }; expr.ILCode = Code.Unbox_Any; expr.Operand = type.IsValueType ? module.CorLibTypes.Object.ToTypeDefOrRef() : type; expr.Type = TypeInference.ToASTType(type.ToTypeSig()); expr.Arguments = new IILASTNode[] { getValue }; }
public bool UpdateNameReference(ConfuserContext context, INameService service) { MethodDef method = thisSlot.MethodDef; IMethod target; if (baseSlot.MethodDefDeclType is GenericInstSig) { var declType = (GenericInstSig)baseSlot.MethodDefDeclType; MemberRef targetRef = new MemberRefUser(method.Module, baseSlot.MethodDef.Name, baseSlot.MethodDef.MethodSig, declType.ToTypeDefOrRef()); targetRef = new Importer(method.Module, ImporterOptions.TryToUseTypeDefs).Import(targetRef); service.AddReference(baseSlot.MethodDef, new MemberRefReference(targetRef, baseSlot.MethodDef)); target = targetRef; } else { target = baseSlot.MethodDef; if (target.Module != method.Module) { target = (IMethod) new Importer(method.Module, ImporterOptions.TryToUseTypeDefs).Import(baseSlot.MethodDef); if (target is MemberRef) { service.AddReference(baseSlot.MethodDef, new MemberRefReference((MemberRef)target, baseSlot.MethodDef)); } } } target.MethodSig = new Importer(method.Module, ImporterOptions.TryToUseTypeDefs).Import(method.MethodSig); if (target is MemberRef) { AddImportReference(context, service, method.Module, baseSlot.MethodDef, (MemberRef)target); } if (method.Overrides.Any(impl => new SigComparer().Equals(impl.MethodDeclaration.MethodSig, target.MethodSig) && new SigComparer().Equals(impl.MethodDeclaration.DeclaringType.ResolveTypeDef(), target.DeclaringType.ResolveTypeDef()))) { return(true); } method.Overrides.Add(new MethodOverride(method, (IMethodDefOrRef)target)); return(true); }
void InitializeCtors(TypeDef manager, MethodDefAndDeclaringTypeDict <IMethod> ctors) { if (manager == null) { return; } foreach (var ctor in manager.Methods) { if (ctor.Name != ".ctor") { continue; } var newCtor = new MemberRefUser(module, ctor.Name, ctor.MethodSig.Clone(), manager.BaseType); module.UpdateRowId(newCtor); ctors.Add(ctor, newCtor); } }
private void InjectInit(MethodDef method) { var mod = Patcher.osu_exe; var insn = method.Body.Instructions; var eventCtor = new MemberRefUser(mod, ".ctor", MethodSig.CreateInstance(mod.CorLibTypes.Void), //Arg 0, Boolean state mod.Find("Annex.eventmanager.events.OptionsInitializeEvent", false)); //EventManager.Invoke(this, new OptionsInitializeEvent) insn.Insert(insn.Count - 1, OpCodes.Ldarg_0.ToInstruction()); //this, insn.Insert(insn.Count - 1, OpCodes.Newobj.ToInstruction(eventCtor)); //new OptionsInitializeEvent var invokeMethod = mod.Find("Annex.eventmanager.EventManager", false).FindMethod("Invoke"); insn.Insert(insn.Count - 1, OpCodes.Call.ToInstruction(invokeMethod)); //call method with above args }
private static void Hook_SpriteFetcher_GetSprite(ModuleDefMD module) { TypeDef cecilSource = module.Find("SpriteFetcher", isReflectionName: true); MethodDef sourceMethod = cecilSource.Methods.Single(m => m.FullName == "UnityEngine.Sprite SpriteFetcher::GetSprite(ObjectTypes,System.Int32)"); TypeDef cecilTarget = module.GetNuterraType(typeof(Hooks.ResourceLookup)); MethodDef targetMethod = cecilTarget.Methods.Single(m => m.Name == nameof(Hooks.ResourceLookup.GetSprite)); AssemblyRef unityEngine = module.GetAssemblyRef(new UTF8String("UnityEngine")); TypeRefUser unityEngine_Object = new TypeRefUser(module, new UTF8String("UnityEngine"), new UTF8String("Object"), unityEngine); TypeSig objectSig = unityEngine_Object.ToTypeSig(); MethodSig op_Equality = MethodSig.CreateStatic(module.CorLibTypes.Boolean, objectSig, objectSig); MemberRefUser op_EqualityMethod = new MemberRefUser(module, new UTF8String("op_Inequality"), op_Equality, unityEngine_Object); var body = sourceMethod.Body.Instructions; var originalMethodStart = body.First(); int index = 0; sourceMethod.Body.MaxStack = 6; body.Insert(index++, new Instruction(OpCodes.Ldarg_1)); body.Insert(index++, new Instruction(OpCodes.Ldarg_2)); body.Insert(index++, new Instruction(OpCodes.Call, targetMethod)); body.Insert(index++, new Instruction(OpCodes.Stloc_0)); body.Insert(index++, new Instruction(OpCodes.Ldloc_0)); body.Insert(index++, new Instruction(OpCodes.Ldnull)); body.Insert(index++, new Instruction(OpCodes.Call, op_EqualityMethod)); body.Insert(index++, new Instruction(OpCodes.Brfalse_S, originalMethodStart)); body.Insert(index++, new Instruction(OpCodes.Ldloc_0)); body.Insert(index++, new Instruction(OpCodes.Ret)); /* * 0 0000 ldarg.1 * 1 0001 ldarg.2 * 2 0002 call class [UnityEngine]UnityEngine.Sprite Maritaria.BlockLoader::SpriteFetcher_GetSprite(valuetype ObjectTypes, int32) * 3 0007 stloc.0 * 4 0008 ldloc.0 * 5 0009 ldnull * 6 000A call bool [UnityEngine]UnityEngine.Object::op_Inequality(class [UnityEngine]UnityEngine.Object, class [UnityEngine]UnityEngine.Object) * 7 000F brfalse.s { original method start instruction } * 8 0011 ldloc.0 * 9 0012 ret * ... remaining method code ... */ }
public static void AddNamedArgument(this NRefactory.CSharp.Attribute attribute, ModuleDef module, Type attrType, Type fieldType, string fieldName, Expression argument) { var ide = new IdentifierExpression(fieldName); if (module != null) { TypeSig sig = module.CorLibTypes.GetCorLibTypeSig(module.Import(fieldType)); if (sig == null) { var typeRef = module.CorLibTypes.GetTypeRef(fieldType.Namespace, fieldType.Name); sig = fieldType.IsValueType ? (TypeSig) new ValueTypeSig(typeRef) : new ClassSig(typeRef); } var fr = new MemberRefUser(module, fieldName, new FieldSig(sig), module.CorLibTypes.GetTypeRef(attrType.Namespace, attrType.Name)); ide.AddAnnotation(fr); ide.IdentifierToken.AddAnnotation(fr); } attribute.Arguments.Add(new AssignmentExpression(ide, argument)); }
/// <summary> /// Resolve an IField from its name and a declaring TypeSpec. /// </summary> /// <param name="declaringType">Declaring TypeSpec</param> /// <param name="fieldName">Field name</param> /// <returns>IField, or null if none found</returns> public IField ResolveField(TypeSpec declaringType, String fieldName) { TypeDef typeDef = declaringType.ResolveTypeDef(); if (typeDef == null) { return(null); } FieldDef fieldDef = typeDef.FindField(fieldName); if (fieldDef == null) { return(null); } MemberRef memberRef = new MemberRefUser(_module, fieldDef.Name, fieldDef.FieldSig, declaringType); return(this.Importer.Import(memberRef)); }
/// <summary> /// Weaves the introductions. /// Introduces members as requested by aspects /// </summary> /// <param name="method">The method.</param> /// <param name="moduleDefinition">The module definition.</param> /// <param name="context">The context.</param> private void WeaveIntroductions(MethodDef method, ModuleDef moduleDefinition, WeavingContext context) { var typeDefinition = method.DeclaringType; var advices = GetAllMarkers(new MethodReflectionNode(method, null), context.AdviceInterfaceType, context); var markerAttributeCtor = moduleDefinition.SafeImport(TypeResolver.Resolve(moduleDefinition, typeof(IntroducedFieldAttribute)).FindConstructors().Single()); var markerAttributeCtorDef = new MemberRefUser(markerAttributeCtor.Module, markerAttributeCtor.Name, markerAttributeCtor.MethodSig, markerAttributeCtor.DeclaringType); foreach (var advice in advices) { var adviceDefinition = advice.Type; foreach (var field in adviceDefinition.Fields.Where(f => f.IsPublic)) { IntroduceMember(method.Module, field.Name, field.FieldType.ToTypeDefOrRef(), field.IsStatic, advice.Type, typeDefinition, markerAttributeCtorDef); } foreach (var property in adviceDefinition.Properties.Where(p => p.HasAnyPublic())) { IntroduceMember(method.Module, property.Name, property.PropertySig.RetType.ToTypeDefOrRef(), !property.PropertySig.HasThis, advice.Type, typeDefinition, markerAttributeCtorDef); } } }