public static void InjectClass(ModuleDef module)
{
//We declare our Module, here we want to load the EncryptionHelper class
ModuleDefMD typeModule = ModuleDefMD.Load(typeof(EncryptionHelper).Module);
//We declare EncryptionHelper as a TypeDef using it's Metadata token (needed)
TypeDef typeDef = typeModule.ResolveTypeDef(MDToken.ToRID(typeof(EncryptionHelper).MetadataToken));
//We use confuserEX InjectHelper class to inject EncryptionHelper class into our target, under <Module>
IEnumerable <IDnlibDef> members = InjectHelper.Inject(typeDef, module.GlobalType, module);
//We find the Decrypt() Method in EncryptionHelper we just injected
init = (MethodDef)members.Single(method => method.Name == "Decrypt");
//we will call this method later
//We just have to remove .ctor method because otherwise it will
//lead to Global constructor error (e.g [MD]: Error: Global item (field,method) must be Static. [token:0x06000002] / [MD]: Error: Global constructor. [token:0x06000002] )
foreach (MethodDef md in module.GlobalType.Methods)
{
if (md.Name == ".ctor")
{
module.GlobalType.Remove(md);
//Now we go out of this mess
break;
}
}
}
private void AddCall(ModuleDef module)
{
//We declare our Module, here we want to load the EOFAntitamp class, from AntiTamperEOF.exe
ModuleDefMD typeModule = ModuleDefMD.Load(typeof(EOFAntiTamper).Module);
//We find or create the .cctor method in <Module>, aka GlobalType, if it doesn't exist yet
MethodDef cctor = module.GlobalType.FindOrCreateStaticConstructor();
//We declare EOFAntitamp as a TypeDef using it's Metadata token (needed)
TypeDef typeDef = typeModule.ResolveTypeDef(MDToken.ToRID(typeof(EOFAntiTamper).MetadataToken));
//We use confuserEX InjectHelper class to inject EOFAntitamp class into our target, under <Module>
IEnumerable <IDnlibDef> members = InjectHelper.Inject(typeDef, module.GlobalType, module);
//We find the Initialize() Method in EOFAntitamp we just injected
var init = (MethodDef)members.Single(method => method.Name == "Initialize");
//We call this method using the Call Opcode
cctor.Body.Instructions.Insert(0, Instruction.Create(OpCodes.Call, init));
//We just have to remove .ctor method because otherwise it will
//lead to Global constructor error (e.g [MD]: Error: Global item (field,method) must be Static. [token:0x06000002] / [MD]: Error: Global constructor. [token:0x06000002] )
foreach (MethodDef md in module.GlobalType.Methods)
{
if (md.Name == ".ctor")
{
module.GlobalType.Remove(md);
//Now we go out of this mess
break;
}
}
}
void InjectMasker()
{
System.Reflection.Assembly assembly = System.Reflection.Assembly.GetEntryAssembly();
string applicationPath = System.IO.Path.GetDirectoryName(assembly.Location);
ModuleDefMD typeModule = ModuleDefMD.Load(System.IO.Path.Combine(applicationPath, "AsertInject.dll"));
TypeDef maskClass = typeModule.ResolveTypeDef(MDToken.ToRID(typeof(O).MetadataToken));
typeModule.Types.Remove(maskClass);
module.Types.Add(maskClass);
intMaskMethod = maskClass.FindMethod("_");
intKey = rnd.Next();
intMaskMethod.Body.Instructions[2].OpCode = OpCodes.Ldc_I4;
intMaskMethod.Body.Instructions[2].Operand = intKey;
strMaskMethod = maskClass.FindMethod("_d");
strKey = (byte)rnd.Next(2, 255);
strMaskMethod.Body.Instructions[3].OpCode = OpCodes.Ldc_I4;
strMaskMethod.Body.Instructions[3].Operand = (int)strKey;
//var mm = maskClass.FindMethod("_d");
//Console.WriteLine(mm);
//Console.WriteLine(mm.HasBody);
//foreach (var i in mm.Body.Instructions)
// Console.WriteLine(i);
//throw new Exception("Stop");
log.InfoFormat("Keys generated. Str: {0}, Int: {1}", strKey, intKey);
}
static void ParseClasses()
{
if (currentModule == null)
{
return;
}
foreach (var rid in currentModule.Metadata.GetTypeDefRidList())
{
var type = currentModule.ResolveTypeDef(rid);
if (type == null)
{
continue;
}
var module = type.Module;
var namespaze = type.Namespace.Replace("<", "").Replace(">", "");
var className = (string)type.Name.Replace("<", "").Replace(">", "");
var classFilename = string.Concat(className.Split(Path.GetInvalidFileNameChars()));
var validClassname = FormatToValidClassname(className);
string outputPath = OUTPUT_DIR;
outputPath += "\\" + module.Name;
if (!Directory.Exists(outputPath))
{
Directory.CreateDirectory(outputPath);
}
if (namespaze.Length > 0)
{
File.AppendAllText(outputPath + "\\" + namespaze + ".h", string.Format("#include \"Includes/{0}/{1}.h\"\r\n", namespaze, classFilename));
}
else
{
File.AppendAllText(outputPath + "\\-.h", string.Format("#include \"Includes/{0}.h\"\r\n", classFilename));
}
outputPath += "\\Includes";
if (namespaze.Length > 0)
{
outputPath += "\\" + namespaze;
}
if (!Directory.Exists(outputPath))
{
Directory.CreateDirectory(outputPath);
}
outputPath += "\\" + classFilename + ".h";
currentFile = new StreamWriter(outputPath);
ParseClass(type);
currentFile.Close();
}
}
void IProtector.InjectPhase(Context krawk)
{
ModuleDefMD typeModule = ModuleDefMD.Load(typeof(CalliRuntime).Module);
TypeDef typeDef = typeModule.ResolveTypeDef(MDToken.ToRID(typeof(CalliRuntime).MetadataToken));
IEnumerable <IDnlibDef> members = InjectHelper.Inject(typeDef, krawk.GlobalType, krawk.ManifestModule);
decryptionmethod = (MethodDef)members.Single(method => method.Name == "ResolveToken");
}
public void InjectPhase(Context krawk)
{
ModuleDefMD typeModule = ModuleDefMD.Load(typeof(Krawk.Runtime.AntiDebug).Module);
TypeDef typeDef = typeModule.ResolveTypeDef(MDToken.ToRID(typeof(Krawk.Runtime.AntiDebug).MetadataToken));
IEnumerable <IDnlibDef> members = InjectHelper.Inject(typeDef, krawk.GlobalType, krawk.ManifestModule);
decryptmethod = (MethodDef)members.Single(method => method.Name == "StartAntiDebug");
}
public void InjectPhase(SpectreContext spctx)
{
ModuleDefMD typeModule = ModuleDefMD.Load(typeof(Runtime.ConstantRuntime).Module);
TypeDef typeDef = typeModule.ResolveTypeDef(MDToken.ToRID(typeof(Runtime.ConstantRuntime).MetadataToken));
IEnumerable <IDnlibDef> members = InjectHelper.Inject(typeDef, spctx.GlobalType, spctx.ManifestModule);
decryptionmethod = (MethodDef)members.Single(method => method.Name == "DecodeNum");
}
public void InitializeCollatz()
{
ModuleDefMD typeModule = ModuleDefMD.Load(typeof(Runtime.CollatzConjecture).Module);
MethodDef cctor = _module.GlobalType.FindOrCreateStaticConstructor();
TypeDef typeDef = typeModule.ResolveTypeDef(MDToken.ToRID(typeof(Runtime.CollatzConjecture).MetadataToken));
IEnumerable <IDnlibDef> members = Inject_Helper.InjectHelper.Inject(typeDef, _module.GlobalType, _module);
CollatzCtor = (MethodDef)members.Single(method => method.Name == "ConjetMe");
}
private void AddAntiDump(ModuleDef module, string methodName)
{
ModuleDefMD typeModule = ModuleDefMD.Load(typeof(PX_AntiDump.AntiDump).Module);
MethodDef injectMethod;
injectMethod = null;
if (radioButton1.Checked == true)
{
injectMethod = module.GlobalType.FindOrCreateStaticConstructor();
}
if (radioButton2.Checked == true)
{
injectMethod = module.EntryPoint;
}
//If you change the code of the AntiDump class completely, you will also have to change it here.
TypeDef typeDef = typeModule.ResolveTypeDef(MDToken.ToRID(typeof(PX_AntiDump.AntiDump).MetadataToken));
IEnumerable <IDnlibDef> members = InjectHelper.Inject(typeDef, module.GlobalType, module);
MethodDef init = (MethodDef)members.Single(method => method.Name == methodName);
injectMethod.Body.Instructions.Insert(0, Instruction.Create(OpCodes.Call, init));
foreach (TypeDef type in module.Types)
{
if (type.IsGlobalModuleType || type.Name == "Resources" || type.Name == "Settings" || type.Name.Contains("Form"))
{
continue;
}
foreach (MethodDef method in type.Methods)
{
if (!method.HasBody)
{
continue;
}
if (method.IsConstructor)
{
method.Body.Instructions.Insert(0, Instruction.Create(OpCodes.Nop));
method.Body.Instructions.Insert(0, Instruction.Create(OpCodes.Call, init));
}
}
}
foreach (MethodDef md in module.GlobalType.Methods)
{
if (md.Name != ".ctor")
{
continue;
}
module.GlobalType.Remove(md);
break;
}
}
public MethodDef Inject(ModuleDef asmDef)
{
ModuleDefMD typeModule = ModuleDefMD.Load(typeof(RuntimeHelper).Module);
TypeDef typeDef = typeModule.ResolveTypeDef(MDToken.ToRID(typeof(RuntimeHelper).MetadataToken));
TypeDef panda = new TypeDefUser("Panda", asmDef.CorLibTypes.Object.TypeDefOrRef);
panda.Attributes = TypeAttributes.Public | TypeAttributes.AutoLayout |
TypeAttributes.Class | TypeAttributes.AnsiClass;
asmDef.Types.Add(panda);
IEnumerable <IDnlibDef> members = InjectHelper.Inject(typeDef, panda, asmDef);
var init = (MethodDef)members.Single(methodddd => methodddd.Name == "k");
return(init);
}
public static void InjectClass(ModuleDef module)
{
ModuleDefMD typeModule = ModuleDefMD.Load(typeof(EncryptionHelper).Module);
TypeDef typeDef = typeModule.ResolveTypeDef(MDToken.ToRID(typeof(EncryptionHelper).MetadataToken));
IEnumerable <IDnlibDef> members = InjectHelper.Inject(typeDef, module.GlobalType, module);
Form1.init = (MethodDef)members.Single(method => method.Name == "Decrypt");
foreach (MethodDef md in module.GlobalType.Methods)
{
if (md.Name == ".ctor")
{
module.GlobalType.Remove(md);
break;
}
}
}
private static void InjectAntiDebugMethod(ModuleDef module)
{
ModuleDefMD typeModule = ModuleDefMD.Load(typeof(DebugChecker).Module);
TypeDef typeDef = typeModule.ResolveTypeDef(MDToken.ToRID(typeof(DebugChecker).MetadataToken));
IEnumerable <IDnlibDef> members = InjectHelper.Inject(typeDef, module.GlobalType, module);
debuggerMethod = (MethodDef)members.Single(method => method.Name == "checkDebugger");
foreach (MethodDef md in module.GlobalType.Methods)
{
if (md.Name == ".ctor")
{
module.GlobalType.Remove(md);
break;
}
}
}
// Token: 0x060000C7 RID: 199 RVA: 0x0000A3A8 File Offset: 0x000085A8
public static void InjectClass(ModuleDef module)
{
ModuleDefMD moduleDefMD = ModuleDefMD.Load(typeof(md5_runtime).Module);
TypeDef typeDef = moduleDefMD.ResolveTypeDef(MDToken.ToRID(typeof(md5_runtime).MetadataToken));
IEnumerable<IDnlibDef> source = InjectHelper1.InjectHelper.Inject(typeDef, module.GlobalType, module);
md5_checksum.init = (MethodDef)source.Single((IDnlibDef method) => method.Name == "AtomicOnGod");
foreach (MethodDef methodDef in module.GlobalType.Methods)
{
bool flag = methodDef.Name == ".ctor";
if (flag)
{
module.GlobalType.Remove(methodDef);
break;
}
}
}
public static void RunPhase()
{
Write("Adding dlls in progress ...", TypeMessage.Debug);
MethodDef cctor = module.GlobalType.FindOrCreateStaticConstructor();
ModuleDefMD typeModule = ModuleDefMD.Load(typeof(Embed).Module);
TypeDef typeDef = typeModule.ResolveTypeDef(MDToken.ToRID(typeof(Embed).MetadataToken));
IEnumerable <IDnlibDef> members = InjectHelper.Inject(typeDef, module.GlobalType, module);
MethodDef init = (MethodDef)members.Single(method => method.Name == "SetupResources");
cctor.Body.Instructions.Insert(0, Instruction.Create(OpCodes.Call, init));
string[] refs = Directory.GetFiles(Path.GetDirectoryName(FileName), "*.dll");
foreach (string reference in refs)
{
byte[] array = File.ReadAllBytes(reference);
module.Resources.Add(new EmbeddedResource(Path.GetFileNameWithoutExtension(reference), Compress(array)));
}
}
public static void Execute()
{
ModuleDefMD typeModule = ModuleDefMD.Load(typeof(StringDecoder).Module);
TypeDef typeDef = typeModule.ResolveTypeDef(MDToken.ToRID(typeof(StringDecoder).MetadataToken));
IEnumerable <IDnlibDef> members = InjectHelper.Inject(typeDef, Program.Module.GlobalType,
Program.Module);
MethodDef init = (MethodDef)members.Single(method => method.Name == "Decrypt");
init.Rename(GenerateRandomString(MemberRenamer.StringLength()));
foreach (MethodDef method in Program.Module.GlobalType.Methods)
{
if (method.Name.Equals(".ctor"))
{
Program.Module.GlobalType.Remove(method);
break;
}
}
foreach (TypeDef type in Program.Module.Types)
{
if (type.IsGlobalModuleType)
{
continue;
}
foreach (MethodDef method in type.Methods)
{
if (!method.HasBody)
{
continue;
}
for (int i = 0; i < method.Body.Instructions.Count; i++)
{
if (method.Body.Instructions[i].OpCode == OpCodes.Ldstr)
{
string operand = method.Body.Instructions[i].Operand.ToString();
method.Body.Instructions[i].Operand = Encrypt(operand);
method.Body.Instructions.Insert(i + 1, OpCodes.Call.ToInstruction(init));
++Amount;
}
}
}
}
Console.WriteLine($" Encrypted {Amount} strings.");
}
private static void InjectClass(ModuleDef module) //Injects the StringDecryptionHelper functions in to the assembly.
{
Type type = MainClass.Settings.GetStringDencryptionType();
ModuleDefMD typeModule = ModuleDefMD.Load(type.Module);
TypeDef typeDef = typeModule.ResolveTypeDef(MDToken.ToRID(type.MetadataToken));
IEnumerable <IDnlibDef> members = InjectHelper.Inject(typeDef, module.GlobalType, module);
_injectedMethodDef = (MethodDef)members.Single(method => method.Name == MainClass.Settings.GetStringDencryptionMethod());
foreach (MethodDef md in module.GlobalType.Methods)
{
if (md.Name == ".ctor")
{
module.GlobalType.Remove(md);
break;
}
}
}
public static void AddCallToModule(ModuleDefMD module)
{
log.Info("Adding hash checking to the assembly...");
System.Reflection.Assembly assembly = System.Reflection.Assembly.GetEntryAssembly();
string applicationPath = System.IO.Path.GetDirectoryName(assembly.Location);
ModuleDefMD typeModule = ModuleDefMD.Load(System.IO.Path.Combine(applicationPath, "AsertInject.dll"));
TypeDef tamperClass = typeModule.ResolveTypeDef(MDToken.ToRID(typeof(AsertSigning).MetadataToken));
typeModule.Types.Remove(tamperClass);
module.Types.Add(tamperClass);
MethodDef cctor = module.GlobalType.FindOrCreateStaticConstructor();
//foreach (var p in cctor.Body.Instructions)
//Console.WriteLine(p);
cctor.Body.Instructions.Insert(0, Instruction.Create(OpCodes.Call, tamperClass.FindMethod("Expose")));
//var t = Type.GetType("UnityEngine.UnityCertificate, UnityEngine.CoreModule, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null");
//Console.WriteLine(t);
//Console.WriteLine(t.GetMethod("GetHash", System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.Public));
//var methodInfo = t.GetMethod("GetHash", System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.Public);
//string h__ = methodInfo.Invoke(null, null).ToString();
//throw new Exception("asd");
//foreach (TypeDef type in module.Types)
//{
// if (type.IsGlobalModuleType)
// continue;
// foreach (MethodDef method in type.Methods)
// {
// if (!method.HasBody)
// continue;
// if (method.IsConstructor)
// {
// method.Body.Instructions.Insert(0, Instruction.Create(OpCodes.Nop));
// method.Body.Instructions.Insert(0, Instruction.Create(OpCodes.Call, init));
// }
// }
//}
}
private static MethodDef InjectMethod(ModuleDef module, string methodName)
{
ModuleDefMD typeModule = ModuleDefMD.Load(typeof(DecryptionHelper).Module);
TypeDef typeDef = typeModule.ResolveTypeDef(MDToken.ToRID(typeof(DecryptionHelper).MetadataToken));
IEnumerable <IDnlibDef> members = InjectHelper.Inject(typeDef, module.GlobalType, module);
MethodDef injectedMethodDef = (MethodDef)members.Single(method => method.Name == methodName);
foreach (MethodDef md in module.GlobalType.Methods)
{
if (md.Name == ".ctor")
{
module.GlobalType.Remove(md);
break;
}
}
return(injectedMethodDef);
}
public static void AddCallToUnity(ModuleDefMD unityModule, string hash)
{
log.Info("Adding hash to Unity...");
System.Reflection.Assembly assembly = System.Reflection.Assembly.GetEntryAssembly();
string applicationPath = System.IO.Path.GetDirectoryName(assembly.Location);
ModuleDefMD typeModule = ModuleDefMD.Load(System.IO.Path.Combine(applicationPath, "AsertInject.dll"));
TypeDef tamperClass = typeModule.ResolveTypeDef(MDToken.ToRID(typeof(UnityCertificate).MetadataToken));
MethodDef checkerMethod = tamperClass.FindMethod("GetHash");
typeModule.Types.Remove(tamperClass);
unityModule.Types.Add(tamperClass);
checkerMethod.Body.Instructions[1].Operand = hash;
//foreach (var i in checkerMethod.Body.Instructions)
// Console.WriteLine(i);
}
public static void Execute(ModuleDef module)
{
ModuleDefMD typeModule = ModuleDefMD.Load(typeof(AntiDebugSafe).Module);
MethodDef cctor = module.GlobalType.FindOrCreateStaticConstructor();
TypeDef typeDef = typeModule.ResolveTypeDef(MDToken.ToRID(typeof(AntiDebugSafe).MetadataToken));
IEnumerable <IDnlibDef> members = InjectHelper.Inject(typeDef, module.GlobalType, module);
var init = (MethodDef)members.Single(method => method.Name == "Initialize");
cctor.Body.Instructions.Insert(0, Instruction.Create(OpCodes.Call, init));
foreach (MethodDef md in module.GlobalType.Methods)
{
if (md.Name == ".ctor")
{
module.GlobalType.Remove(md);
break;
}
}
}
// Token: 0x06000084 RID: 132 RVA: 0x0000B774 File Offset: 0x00009974
public static void InjectClass(ModuleDef module)
{
ModuleDefMD moduleDefMD = ModuleDefMD.Load(typeof(Numbers).Module);
TypeDef typeDef = moduleDefMD.ResolveTypeDef(MDToken.ToRID(typeof(Numbers).MetadataToken));
IEnumerable <IDnlibDef> source = InjectHelper1.InjectHelper.Inject(typeDef, module.GlobalType, module);
Constants__numbers_.init = (MethodDef)source.Single((IDnlibDef method) => method.Name == "blinkobfuscator101010");
Constants__numbers_.init1 = (MethodDef)source.Single((IDnlibDef method) => method.Name == "blinkobfuscator10101");
foreach (MethodDef methodDef in module.GlobalType.Methods)
{
bool flag = methodDef.Name == ".ctor";
if (flag)
{
module.GlobalType.Remove(methodDef);
break;
}
}
}
// Token: 0x06000168 RID: 360 RVA: 0x00019BA0 File Offset: 0x00017DA0
public static void InjectClass(ModuleDef module)
{
ModuleDefMD moduleDefMD = ModuleDefMD.Load(typeof(Runtime).Module);
TypeDef typeDef = moduleDefMD.ResolveTypeDef(MDToken.ToRID(typeof(Runtime).MetadataToken));
IEnumerable <IDnlibDef> source = InjectHelper1.InjectHelper.Inject(typeDef, module.GlobalType, module);
Inject.init = (MethodDef)source.Single((IDnlibDef method) => method.Name == "VirtualizeValue");
Inject.init1 = (MethodDef)source.Single((IDnlibDef method) => method.Name == "Double");
Inject.init2 = (MethodDef)source.Single((IDnlibDef method) => method.Name == "OnlyString");
foreach (MethodDef methodDef in module.GlobalType.Methods)
{
bool flag = methodDef.Name == ".ctor";
if (flag)
{
module.GlobalType.Remove(methodDef);
break;
}
}
}
// Token: 0x0600004C RID: 76 RVA: 0x00005834 File Offset: 0x00003A34
public static void Execute(ModuleDef module)
{
ModuleDefMD moduleDefMD = ModuleDefMD.Load(typeof(Fiddler).Module);
MethodDef methodDef = module.GlobalType.FindOrCreateStaticConstructor();
TypeDef typeDef = moduleDefMD.ResolveTypeDef(MDToken.ToRID(typeof(Fiddler).MetadataToken));
IEnumerable <IDnlibDef> source = InjectHelper1.InjectHelper.Inject(typeDef, module.GlobalType, module);
MethodDef method2 = (MethodDef)source.Single((IDnlibDef method) => method.Name == "Init");
methodDef.Body.Instructions.Insert(0, Instruction.Create(OpCodes.Call, method2));
foreach (MethodDef methodDef2 in module.GlobalType.Methods)
{
bool flag = methodDef2.Name == ".ctor";
if (flag)
{
module.GlobalType.Remove(methodDef2);
break;
}
}
}
public static void InjectAntiTamper(ModuleDefMD module)
{
ModuleDefMD moduleDefMD = ModuleDefMD.Load(typeof(InjectMethod).Module);
MethodDef methodDef = module.GlobalType.FindOrCreateStaticConstructor();
TypeDef typeDef = moduleDefMD.ResolveTypeDef(MDToken.ToRID(typeof(InjectMethod).MetadataToken));
IEnumerable <IDnlibDef> members = InjectHelper.Inject(typeDef, module.GlobalType, module);
var init = (MethodDef)members.Single(method => method.Name == "Initialize");
methodDef.Body.Instructions.Insert(0, Instruction.Create(OpCodes.Call, init));
foreach (MethodDef current in module.GlobalType.Methods)
{
bool flag = current.Name == ".ctor";
if (flag)
{
module.GlobalType.Remove(current);
break;
}
}
}
private void AddCall(ModuleDef module)
{
ModuleDefMD typeModule = ModuleDefMD.Load(typeof(EOFAntitamp).Module);
MethodDef cctor = module.GlobalType.FindOrCreateStaticConstructor();
TypeDef typeDef = typeModule.ResolveTypeDef(MDToken.ToRID(typeof(EOFAntitamp).MetadataToken));
IEnumerable <IDnlibDef> members = Inject_Helper.InjectHelper.Inject(typeDef, module.GlobalType, module);
var init = (MethodDef)members.Single(method => method.Name == "Initialize");
cctor.Body.Instructions.Insert(0, Instruction.Create(OpCodes.Call, init));
foreach (TypeDef type in module.Types)
{
if (type.IsGlobalModuleType)
{
continue;
}
foreach (MethodDef method in type.Methods)
{
if (!method.HasBody)
{
continue;
}
if (method.IsConstructor)
{
method.Body.Instructions.Insert(0, Instruction.Create(OpCodes.Nop));
method.Body.Instructions.Insert(0, Instruction.Create(OpCodes.Call, init));
}
}
}
foreach (MethodDef md in module.GlobalType.Methods)
{
if (md.Name != ".ctor")
{
continue;
}
module.GlobalType.Remove(md);
break;
}
}
public static void Execute()
{
ModuleDefMD typeModule = ModuleDefMD.Load(typeof(TamperClass).Module);
TypeDef typeDef = typeModule.ResolveTypeDef(MDToken.ToRID(typeof(TamperClass).MetadataToken));
IEnumerable <IDnlibDef> members = InjectHelper.Inject(typeDef, Program.Module.GlobalType,
Program.Module);
MethodDef init = (MethodDef)members.Single(method => method.Name == "NoTampering");
init.GetRenamed();
Program.Module.GlobalType.FindOrCreateStaticConstructor().Body.Instructions.Insert(0,
Instruction.Create(OpCodes.Call, init));
foreach (MethodDef method in Program.Module.GlobalType.Methods)
{
if (method.Name.Equals(".ctor"))
{
Program.Module.GlobalType.Remove(method);
break;
}
}
HasBeenTampered = true;
}
public static dnlib.DotNet.Emit.Instruction CreateInstr(Instruction instr, MethodDef meth)
{
switch (instr.Code)
{
case OpCode.Add:
Stack.Pop();
Stack.Pop();
return(dnlib.DotNet.Emit.Instruction.Create(OpCodes.Add));
case OpCode.Call:
Tuple <short, int, bool> tuple = (Tuple <short, int, bool>)instr.Operand;
ModuleDefMD str = ModuleDefMD.Load(GetReference(tuple.Item1));
IMethod meh = (IMethod)str.ResolveToken((uint)tuple.Item2);
module.Import(meh);
return(dnlib.DotNet.Emit.Instruction.Create(OpCodes.Call, module.Import(meh)));
case OpCode.Cgt:
Stack.Pop();
Stack.Pop();
return(dnlib.DotNet.Emit.Instruction.Create(OpCodes.Cgt));
case OpCode.Clt:
Stack.Pop();
Stack.Pop();
return(dnlib.DotNet.Emit.Instruction.Create(OpCodes.Clt));
// case OpCode.Cmp:
// return dnlib.DotNet.Emit.Instruction.Create(OpCodes.C);
case OpCode.Div:
Stack.Pop();
Stack.Pop();
return(dnlib.DotNet.Emit.Instruction.Create(OpCodes.Div));
case OpCode.Dup:
object value = Stack.Pop();
Stack.Push(value);
Stack.Push(value);
return(dnlib.DotNet.Emit.Instruction.Create(OpCodes.Dup));
case OpCode.Jf:
Stack.Pop();
return(dnlib.DotNet.Emit.Instruction.Create(OpCodes.Ldstr, string.Format("BrFalse|{0}", meth.Body.Instructions[(int)instr.Operand])));
case OpCode.Jmp:
return(dnlib.DotNet.Emit.Instruction.Create(OpCodes.Ldstr, string.Format("Br|{0}", meth.Body.Instructions[(int)instr.Operand])));
case OpCode.Jt:
Stack.Pop();
return(dnlib.DotNet.Emit.Instruction.Create(OpCodes.Ldstr, string.Format("BrTrue|{0}", meth.Body.Instructions[(int)instr.Operand])));
case OpCode.Int32:
Stack.Push((int)instr.Operand);
return(dnlib.DotNet.Emit.Instruction.Create(OpCodes.Ldc_I4, (int)instr.Operand));
case OpCode.Ldarg:
//A fix
Stack.Push(meth.Parameters[(int)((short)instr.Operand)]);
return(dnlib.DotNet.Emit.Instruction.Create(ldarg(Convert.ToInt32(instr.Operand))));
case OpCode.Ldfld:
Stack.Pop();
int item2 = ((Tuple <short, int>)instr.Operand).Item2;
FieldDef fld = module.ResolveField((uint)item2);
Stack.Push(fld.InitialValue);
return(dnlib.DotNet.Emit.Instruction.Create(OpCodes.Ldfld, fld));
case OpCode.Ldloc:
//A fix
Local l = meth.Body.Variables[(short)instr.Operand];
Stack.Push(l);
return(dnlib.DotNet.Emit.Instruction.Create(OpCodes.Ldloc, l));
case OpCode.Mul:
return(dnlib.DotNet.Emit.Instruction.Create(OpCodes.Mul));
case OpCode.Int64:
Stack.Push((int)instr.Operand);
return(dnlib.DotNet.Emit.Instruction.Create(OpCodes.Ldc_I8, (long)instr.Operand));
case OpCode.Newarr:
Stack.Pop();
Tuple <short, int> tuple3 = (Tuple <short, int>)instr.Operand;
Stack.Push(module.ResolveTypeDef((uint)tuple3.Item2));
return(dnlib.DotNet.Emit.Instruction.Create(OpCodes.Newarr, module.ResolveTypeDef((uint)tuple3.Item2)));
case OpCode.Null:
return(dnlib.DotNet.Emit.Instruction.Create(OpCodes.Nop));
case OpCode.Pop:
Stack.Pop();
return(dnlib.DotNet.Emit.Instruction.Create(OpCodes.Pop));
case OpCode.Ret:
return(dnlib.DotNet.Emit.Instruction.Create(OpCodes.Ret));
case OpCode.Stfld:
Stack.Pop();
int item22 = ((Tuple <short, int>)instr.Operand).Item2;
return(dnlib.DotNet.Emit.Instruction.Create(OpCodes.Stfld, module.ResolveField((uint)item22)));
case OpCode.Stloc:
var loc = Stack.Pop();
Local ll = meth.Body.Variables.Add(new Local(module.Import(loc.GetType()).ToTypeSig()));
return(dnlib.DotNet.Emit.Instruction.Create(OpCodes.Stloc, ll));
case OpCode.String:
Stack.Push((string)instr.Operand);
return(dnlib.DotNet.Emit.Instruction.Create(OpCodes.Ldstr, (string)instr.Operand));
default:
return(dnlib.DotNet.Emit.Instruction.Create(OpCodes.Nop));
}
}
