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);
}
}
}
