public byte[] Compile(out DSEELocalAndMethod[] locals, out string typeName, out string errorMessage) {
if (generatedModule == null) {
locals = Array.Empty<DSEELocalAndMethod>();
typeName = string.Empty;
errorMessage = null;
return Array.Empty<byte>();
}
foreach (var p in sourceMethod.Parameters) {
var name = language.GetVariableName(GetName(p), isThis: p.IsHiddenThisParameter);
var kind = p.IsHiddenThisParameter ? LocalAndMethodKind.This : LocalAndMethodKind.Parameter;
var (methodName, flags) = AddMethod(p.Type, p.Index, isLocal: false);
localAndMethodBuilder.Add(new DSEELocalAndMethod(name, name, methodName, flags, kind, p.Index, Guid.Empty, null));
}
var body = sourceMethod.Body;
if (body != null) {
foreach (var l in body.Variables) {
var name = language.GetVariableName(GetName(l), isThis: false);
const LocalAndMethodKind kind = LocalAndMethodKind.Local;
var (methodName, flags) = AddMethod(l.Type, l.Index, isLocal: true);
localAndMethodBuilder.Add(new DSEELocalAndMethod(name, name, methodName, flags, kind, l.Index, Guid.Empty, null));
}
}
var memStream = new MemoryStream();
var writerOptions = new ModuleWriterOptions(generatedModule);
generatedModule.Write(memStream, writerOptions);
locals = localAndMethodBuilder.ToArray();
typeName = getLocalsType.ReflectionFullName;
errorMessage = null;
return memStream.ToArray();
}
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 void TestInvalidOpCodeMap()
{
var random = new Random();
var mod = new ModuleDefUser("test");
var type = new TypeDefUser("Constants");
for (var i = 0; i < random.Next(0, 100); i++)
{
type.Fields.Add(new FieldDefUser("randomName" + random.Next(), new FieldSig(mod.CorLibTypes.Byte)));
}
mod.Types.Add(type);
var ms = new MemoryStream();
mod.Write(ms);
var ctx = new RhydonContext {
Module = ModuleDefMD.Load(ms), Logger = new DummyLogger()
};
OpCodeMap.Parse(ctx);
Assert.IsNull(ctx.Constants);
}
protected override void Pack(ConfuserContext context, ProtectionParameters parameters)
{
var ctx = context.Annotations.Get <CompressorContext>(context, ContextKey);
if (ctx == null)
{
context.Logger.Error("No executable module!");
throw new ConfuserException(null);
}
ModuleDefMD originModule = context.Modules[ctx.ModuleIndex];
ctx.OriginModuleDef = originModule;
var stubModule = new ModuleDefUser(ctx.ModuleName, originModule.Mvid, originModule.CorLibTypes.AssemblyRef);
if (ctx.CompatMode)
{
var assembly = new AssemblyDefUser(originModule.Assembly);
assembly.Name += ".cr";
assembly.Modules.Add(stubModule);
}
else
{
ctx.Assembly.Modules.Insert(0, stubModule);
ImportAssemblyTypeReferences(originModule, stubModule);
}
stubModule.Characteristics = originModule.Characteristics;
stubModule.Cor20HeaderFlags = originModule.Cor20HeaderFlags;
stubModule.Cor20HeaderRuntimeVersion = originModule.Cor20HeaderRuntimeVersion;
stubModule.DllCharacteristics = originModule.DllCharacteristics;
stubModule.EncBaseId = originModule.EncBaseId;
stubModule.EncId = originModule.EncId;
stubModule.Generation = originModule.Generation;
stubModule.Kind = ctx.Kind;
stubModule.Machine = originModule.Machine;
stubModule.RuntimeVersion = originModule.RuntimeVersion;
stubModule.TablesHeaderVersion = originModule.TablesHeaderVersion;
stubModule.Win32Resources = originModule.Win32Resources;
InjectStub(context, ctx, parameters, stubModule);
var snKey = context.Annotations.Get <StrongNameKey>(originModule, Marker.SNKey);
using (var ms = new MemoryStream()) {
var options = new ModuleWriterOptions(stubModule)
{
StrongNameKey = snKey
};
var injector = new KeyInjector(ctx);
options.WriterEvent += injector.WriterEvent;
stubModule.Write(ms, options);
context.CheckCancellation();
ProtectStub(context, context.OutputPaths[ctx.ModuleIndex], ms.ToArray(), snKey, new StubProtection(ctx, originModule));
}
}
public static Option <Type> CreateInterfaceTypeFrom(Option <MethodInfo> sourceMethod)
{
if (!sourceMethod.HasValue)
{
return(Option.None <Type>());
}
var methodInfo = sourceMethod.ValueOrFailure();
var parameterTypes = methodInfo.GetParameters();
var returnType = methodInfo.ReturnType;
var typeId = Guid.NewGuid().ToString();
var methodName = $"AnonymousMethod_{typeId}";
var module = new ModuleDefUser($"anonymous_module_{typeId}.dll")
{
Kind = ModuleKind.Dll
};
var assembly = new AssemblyDefUser($"anonymous_assembly_{typeId}");
assembly.Modules.Add(module);
var interfaceType = new TypeDefUser($"IAnonymousInterface_{typeId}")
{
Attributes = TypeAttributes.Class | TypeAttributes.Abstract | TypeAttributes.Interface |
TypeAttributes.Public | TypeAttributes.AutoClass | TypeAttributes.AnsiClass
};
module.Types.Add(interfaceType);
var methodAttributes = MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.NewSlot |
MethodAttributes.Abstract | MethodAttributes.Virtual;
var methodImplAttributes = MethodImplAttributes.Managed | MethodImplAttributes.IL;
var importedReturnType = module.ImportAsTypeSig(returnType);
var importedParameterTypes = parameterTypes.Select(type => module.ImportAsTypeSig(type.ParameterType));
var method = new MethodDefUser(methodName,
MethodSig.CreateInstance(importedReturnType, importedParameterTypes.ToArray()),
methodImplAttributes, methodAttributes);
for (var paramNumber = 0; paramNumber < parameterTypes.Length; paramNumber++)
{
method.ParamDefs.Add(new ParamDefUser($"arg{paramNumber++}"));
}
interfaceType.Methods.Add(method);
var stream = new MemoryStream();
module.Write(stream);
var loadedAssembly = Assembly.Load(stream.ToArray());
return(loadedAssembly.GetTypes().FirstOrNone());
}
public static void Run() {
// Create a new module. The string passed in is the name of the module,
// not the file name.
ModuleDef mod = new ModuleDefUser("MyModule.exe");
// It's a console application
mod.Kind = ModuleKind.Console;
// Add the module to an assembly
AssemblyDef 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.
TypeDef 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
MethodDef 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
TypeRef consoleRef = new TypeRefUser(mod, "System", "Console", mod.CorLibTypes.AssemblyRef);
// Create a method ref to 'System.Void System.Console::WriteLine(System.String)'
MemberRef consoleWrite1 = new MemberRefUser(mod, "WriteLine",
MethodSig.CreateStatic(mod.CorLibTypes.Void, mod.CorLibTypes.String),
consoleRef);
// Add a CIL method body to the entry point method
CilBody 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");
}
private static void Main(string[] args)
{
var file = "";
Console.WriteLine("Origami by drakonia - https://github.com/dr4k0nia/Origami \r\n");
if (args.Length == 0)
{
Console.WriteLine("Usage: Origami.exe <file> or Origami.exe -inject <host> <payload>");
Console.ReadKey();
return;
}
file = args[0];
if (!File.Exists(file))
{
throw new FileNotFoundException($"Could not find file: {file}");
}
var originModule = ModuleDefMD.Load(file);
if (!Utils.IsExe(originModule))
{
throw new Exception("Invalid file format => supported are .net executables");
}
//input file as payload
payload = File.ReadAllBytes(file);
//Generate stub based on origin file
Console.WriteLine("Generating new stub module");
ModuleDefUser stubModule = CreateStub(originModule);
ModifyModule(stubModule, false);
//Rename Global Constructor
var moduleGlobalType = stubModule.GlobalType;
moduleGlobalType.Name = "Origami";
var writerOptions = new ModuleWriterOptions(stubModule);
writerOptions.WriterEvent += OnWriterEvent;
stubModule.Write(file.Replace(".exe", "_origami.exe"), writerOptions);
Console.WriteLine("Saving module...");
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("Finished");
Console.ReadKey();
}
public void TestNoKoiHeader()
{
var mod = new ModuleDefUser("test");
var ms = new MemoryStream();
mod.Write(ms);
var ctx = new RhydonContext {
Module = ModuleDefMD.Load(ms), Logger = new DummyLogger()
};
KoiHeader.Parse(ctx);
Assert.IsNull(ctx.Header);
ms.Close();
}
// Token: 0x060000B7 RID: 183 RVA: 0x0000E52C File Offset: 0x0000C72C
public static void Pack(ModuleDef md, string directory)
{
string s = Convert.ToBase64String(File.ReadAllBytes(directory));
ModuleDefUser moduleDefUser = new ModuleDefUser(Renamer.Random(25));
moduleDefUser.Kind = ModuleKind.Console;
AssemblyDefUser assemblyDefUser = new AssemblyDefUser(Renamer.Random(25), new Version(Packer.random.Next(1, 9), Packer.random.Next(1, 9), Packer.random.Next(1, 9), Packer.random.Next(1, 9)));
assemblyDefUser.Modules.Add(moduleDefUser);
TypeDefUser typeDefUser = new TypeDefUser(Renamer.Random(25), Renamer.Random(25), moduleDefUser.CorLibTypes.Object.TypeDefOrRef);
typeDefUser.Attributes = dnlib.DotNet.TypeAttributes.NotPublic;
moduleDefUser.Types.Add(typeDefUser);
MethodDefUser methodDefUser = new MethodDefUser("Main", MethodSig.CreateStatic(moduleDefUser.CorLibTypes.Void, new SZArraySig(moduleDefUser.CorLibTypes.String)));
methodDefUser.Attributes = (dnlib.DotNet.MethodAttributes.Static | dnlib.DotNet.MethodAttributes.HideBySig);
methodDefUser.ImplAttributes = dnlib.DotNet.MethodImplAttributes.IL;
methodDefUser.ParamDefs.Add(new ParamDefUser("args", 1));
typeDefUser.Methods.Add(methodDefUser);
moduleDefUser.EntryPoint = methodDefUser;
CilBody cilBody = new CilBody();
methodDefUser.Body = cilBody;
cilBody.Instructions.Add(OpCodes.Nop.ToInstruction());
cilBody.Instructions.Add(OpCodes.Ldstr.ToInstruction(s));
cilBody.Instructions.Add(OpCodes.Call.ToInstruction(methodDefUser.Module.Import(typeof(Convert).GetMethod("FromBase64String", new Type[]
{
typeof(string)
}))));
cilBody.Instructions.Add(OpCodes.Call.ToInstruction(methodDefUser.Module.Import(typeof(Assembly).GetMethod("Load", new Type[]
{
typeof(byte[])
}))));
cilBody.Instructions.Add(OpCodes.Callvirt.ToInstruction(methodDefUser.Module.Import(typeof(Assembly).GetMethod("get_EntryPoint", new Type[0]))));
cilBody.Instructions.Add(OpCodes.Ldnull.ToInstruction());
cilBody.Instructions.Add(OpCodes.Ldc_I4_1.ToInstruction());
cilBody.Instructions.Add(OpCodes.Newarr.ToInstruction(methodDefUser.Module.Import(typeof(object))));
cilBody.Instructions.Add(OpCodes.Callvirt.ToInstruction(methodDefUser.Module.Import(typeof(MethodBase).GetMethod("Invoke", new Type[]
{
typeof(object),
typeof(object[])
}))));
cilBody.Instructions.Add(OpCodes.Pop.ToInstruction());
cilBody.Instructions.Add(OpCodes.Ret.ToInstruction());
moduleDefUser.Write(directory);
}
private byte[] DecryptArray(MethodDef method, byte[] encryptedArray)
{
ModuleDefUser tempModule = new ModuleDefUser("TempModule");
AssemblyDef tempAssembly = new AssemblyDefUser("TempAssembly");
tempAssembly.Modules.Add(tempModule);
var tempType = new TypeDefUser("", "TempType", tempModule.CorLibTypes.Object.TypeDefOrRef);
tempType.Attributes = TypeAttributes.Public | TypeAttributes.Class;
MethodDef tempMethod = Utils.Clone(method);
tempMethod.ReturnType = new SZArraySig(tempModule.CorLibTypes.Byte);
tempMethod.MethodSig.Params.Add(new SZArraySig(tempModule.CorLibTypes.Byte));
tempMethod.Attributes = MethodAttributes.Public | MethodAttributes.Static;
for (int i = 0; i < 5; i++)
{
tempMethod.Body.Instructions.RemoveAt(2); // read encrypted array from argument
}
tempMethod.Body.Instructions.Insert(2, OpCodes.Ldarg_0.ToInstruction());
for (int i = 0; i < 2; i++)
{
tempMethod.Body.Instructions.RemoveAt(tempMethod.Body.Instructions.Count -
2); // make return decrypted array
}
tempType.Methods.Add(tempMethod);
tempModule.Types.Add(tempType);
using (MemoryStream memoryStream = new MemoryStream())
{
ModuleWriterOptions moduleWriterOptions = new ModuleWriterOptions();
moduleWriterOptions.MetaDataOptions = new MetaDataOptions();
tempModule.Write(memoryStream, moduleWriterOptions);
Assembly patchedAssembly = Assembly.Load(memoryStream.ToArray());
var type = patchedAssembly.ManifestModule.GetType("TempType");
var methods = type.GetMethods();
MethodInfo patchedMethod = methods.First(m => m.IsPublic && m.IsStatic);
byte[] decryptedBytes = (byte[])patchedMethod.Invoke(null, new object[] { encryptedArray });
return(Lzma.Decompress(decryptedBytes));
}
}
public void TestValidOpCodeMap()
{
var random = new Random();
var mod = new ModuleDefUser("test");
var type = new TypeDefUser("Constants");
for (var i = 0; i < 119; i++)
{
type.Fields.Add(new FieldDefUser("randomName" + random.Next(), new FieldSig(mod.CorLibTypes.Byte)));
}
mod.Types.Add(type);
var ctor = type.FindOrCreateStaticConstructor();
var body = new CilBody();
for (var i = 1; i < 119; i++)
{
body.Instructions.Insert(0, Instruction.Create(OpCodes.Stfld, type.Fields[i]));
body.Instructions.Insert(0, Instruction.Create(OpCodes.Ldc_I4, random.Next(0, 0xFF)));
body.Instructions.Insert(0, Instruction.Create(OpCodes.Ldnull));
}
body.Instructions.Add(Instruction.Create(OpCodes.Ldnull));
body.Instructions.Add(Instruction.Create(OpCodes.Ldc_I4, 112));
body.Instructions.Add(Instruction.Create(OpCodes.Stfld, type.Fields[0]));
body.Instructions.Add(Instruction.Create(OpCodes.Ret));
ctor.Body = body;
var ms = new MemoryStream();
mod.Write(ms);
var ctx = new RhydonContext {
Module = ModuleDefMD.Load(ms), Logger = new DummyLogger()
};
OpCodeMap.Parse(ctx);
Assert.IsNotNull(ctx.Constants);
Assert.IsTrue(ctx.Constants.REG_R0 == 112);
ms.Close();
}
public byte[] GetBrandNewAssemblyFromType(TypeDef typeToInject)
{
// First of all, a temporary assembly is created and methods are injected into this assembly.
// Once this assembly is ready, this try to execute the method in order to replace all the references in
// the original assembly with its result.
// This is probably the weakest part of the deobfuscator but I doubt there's an easier way to do this.
AssemblyDef dummyAssembly = new AssemblyDefUser("DummyAssembly", new System.Version(1, 0, 0, 0), null);
ModuleDefUser dummyModule = new ModuleDefUser("DummyModule")
{
Kind = ModuleKind.Dll
};
TypeDef dummyType = new TypeDefUser("DummyNamespace", "DummyType", dummyModule.CorLibTypes.Object.TypeDefOrRef);
dummyType.Attributes = TypeAttributes.NotPublic | TypeAttributes.AutoLayout |
TypeAttributes.Class | TypeAttributes.AnsiClass;
dummyModule.Types.Add(dummyType);
dummyAssembly.Modules.Add(dummyModule);
// Copy everything in dummyType
Inject(typeToInject, dummyType, dummyModule, null);
// Provide a default constructor
if (dummyType.FindDefaultConstructor() == null)
{
var ctor = new MethodDefUser(".ctor",
MethodSig.CreateInstance(dummyModule.CorLibTypes.Void),
MethodImplAttributes.Managed,
MethodAttributes.HideBySig | MethodAttributes.Public |
MethodAttributes.SpecialName | MethodAttributes.RTSpecialName);
ctor.Body = new CilBody();
ctor.Body.MaxStack = 0;
ctor.Body.Instructions.Add(OpCodes.Ret.ToInstruction());
dummyType.Methods.Add(ctor);
}
// Save the assembly to a memorystream
using (MemoryStream stream = new MemoryStream())
{
dummyModule.Write(stream);
return(stream.ToArray());
}
}
public static void Build(string fullPath, string outputPath)
{
var mod = new ModuleDefUser(ModuleName, null, ModuleDefMD.Load(typeof(void).Module).Assembly.ToAssemblyRef())
{
Kind = ModuleKind.Dll
};
var ass = new AssemblyDefUser(AssemblyName, Version.Parse("1.0.0.0"));
ass.Modules.Add(mod);
//get resourceset
var set = new ResourceElementSet();
foreach (ResourceElement re in FileFormatHelper.GetResourceElements(fullPath))
{
set.Add(re);
}
//write set to byte[] and add to module resources
using (var ms = new MemoryStream()) {
ResourceWriter.Write(mod, ms, set);
mod.Resources.Add(new EmbeddedResource(Resources, ms.ToArray(), ManifestResourceAttributes.Private));
}
//create store type
TypeDef store = new TypeDefUser(Namespace, ResourceStore, mod.CorLibTypes.Object.TypeDefOrRef)
{
Attributes = TypeAttributes.Public | TypeAttributes.BeforeFieldInit
};
//add the type to the module
mod.Types.Add(store);
//add code
BuildStore(mod, ref store);
//write module
mod.Write(Path.Combine(outputPath, "osu!ui-rebuilt.dll"));
}
//https://github.com/0xd4d/dnlib/blob/master/Examples/Example3.cs
public static void Run(string encrypted, string writedir)
{
//create module
var mod = new ModuleDefUser(RandomString()); mod.Kind = ModuleKind.Console;
// create and add asm in module
var asm = new AssemblyDefUser(RandomString(), new Version(random.Next(1, 9), random.Next(1, 9), random.Next(1, 9), random.Next(1, 9)));
asm.Modules.Add(mod);
// create startup class for ep
var startUpType = new TypeDefUser(RandomString(), RandomString(), mod.CorLibTypes.Object.TypeDefOrRef);
startUpType.Attributes = TypeAttributes.NotPublic | TypeAttributes.AutoLayout | TypeAttributes.Class | TypeAttributes.AnsiClass;
mod.Types.Add(startUpType);
//create ep method main(string[] args)
var entryPoint = new MethodDefUser("Main", MethodSig.CreateStatic(mod.CorLibTypes.Void, new SZArraySig(mod.CorLibTypes.String)));
entryPoint.Attributes = MethodAttributes.Static | MethodAttributes.HideBySig | MethodAttributes.ReuseSlot;
entryPoint.ImplAttributes = MethodImplAttributes.IL | MethodImplAttributes.Managed;
entryPoint.ParamDefs.Add(new ParamDefUser("args", 1));
startUpType.Methods.Add(entryPoint);
mod.EntryPoint = entryPoint;
var epBody = new CilBody();
entryPoint.Body = epBody;
// add instructions in ep method
epBody.Instructions.Add(OpCodes.Nop.ToInstruction());
epBody.Instructions.Add(OpCodes.Ldstr.ToInstruction(encrypted));
epBody.Instructions.Add(OpCodes.Call.ToInstruction(entryPoint.Module.Import(typeof(System.Convert).GetMethod("FromBase64String", new Type[] { typeof(string) }))));
epBody.Instructions.Add(OpCodes.Call.ToInstruction(entryPoint.Module.Import(typeof(System.Reflection.Assembly).GetMethod("Load", new Type[] { typeof(byte[]) }))));
epBody.Instructions.Add(OpCodes.Callvirt.ToInstruction(entryPoint.Module.Import(typeof(System.Reflection.Assembly).GetMethod("get_EntryPoint", new Type[0]))));
epBody.Instructions.Add(OpCodes.Ldnull.ToInstruction());
epBody.Instructions.Add(OpCodes.Ldc_I4_1.ToInstruction());
epBody.Instructions.Add(OpCodes.Newarr.ToInstruction(entryPoint.Module.Import(typeof(System.Object))));
epBody.Instructions.Add(OpCodes.Callvirt.ToInstruction(entryPoint.Module.Import(typeof(System.Reflection.MethodBase).GetMethod("Invoke", new Type[] { typeof(object), typeof(object[]) }))));
epBody.Instructions.Add(OpCodes.Pop.ToInstruction());
epBody.Instructions.Add(OpCodes.Ret.ToInstruction());
// save new file
mod.Write(writedir.Replace(".exe", "_packed.exe"));
}
static void Main(string[] args)
{
string[] file = File.ReadAllLines("precomp.psnbin");
ModuleDefUser mod = newmod("PointySnakeModule");
MethodDefUser entryPoint = new MethodDefUser("Main", MethodSig.CreateStatic(mod.CorLibTypes.Int32, new SZArraySig(mod.CorLibTypes.String)));
startUpType = new TypeDefUser("PointySnake", "Program", mod.CorLibTypes.Object.TypeDefOrRef);
mod.Types.Add(startUpType);
entryPoint.Attributes = MethodAttributes.Private | MethodAttributes.Static | MethodAttributes.HideBySig | MethodAttributes.ReuseSlot;
entryPoint.ImplAttributes = MethodImplAttributes.IL | MethodImplAttributes.Managed | MethodImplAttributes.AggressiveOptimization;
entryPoint.ParamDefs.Add(new ParamDefUser("args", 1));
var epBody = new CilBody();
entryPoint.Body = epBody;
startUpType.Attributes = TypeAttributes.Public;
startUpType.Methods.Add(entryPoint);
mod.EntryPoint = entryPoint;
currentfunc = mod.EntryPoint;
foreach (string line in file)
{
WriteInstruction(line, mod, currentfunc.Body);
}
if (epBody.Instructions.Count == 0 || epBody.Instructions[epBody.Instructions.Count - 1].OpCode != OpCodes.Ret)
{
entryPoint.Body.Instructions.Add(OpCodes.Ldc_I4_0.ToInstruction());
entryPoint.Body.Instructions.Add(OpCodes.Ret.ToInstruction());
}
entryPoint.Body.OptimizeBranches();
entryPoint.Body.OptimizeMacros();
Console.WriteLine("done");
var options = new ModuleWriterOptions(mod);
options.PEHeadersOptions.Machine = dnlib.PE.Machine.AMD64;
mod.Write("executable.exe", options);
awaitbutton();
}
public static void Run()
{
// 创建一个新模块。 传入的字符串是模块的名称，而不是文件名。
ModuleDef mod = new ModuleDefUser("MyModule.exe");
// 这是一个控制台应用程序
mod.Kind = ModuleKind.Console;
//将模块添加到装配中
AssemblyDef asm = new AssemblyDefUser("MyAssembly", new Version(1, 2, 3, 4), null, "");
asm.Modules.Add(mod);
//添加.NET资源
// byte[] resourceData = Encoding.UTF8.GetBytes("Hello, world!");
//mod.Resources.Add(new EmbeddedResource("My.Resource", resourceData,
// ManifestResourceAttributes.Private));
// 添加启动类型。 它派生自System.Object。
TypeDef startUpType = new TypeDefUser("My.Namespace", "Startup", mod.CorLibTypes.Object.TypeDefOrRef);
startUpType.Attributes = TypeAttributes.NotPublic | TypeAttributes.AutoLayout |
TypeAttributes.Class | TypeAttributes.AnsiClass;
// 将类型添加到模块
mod.Types.Add(startUpType);
// 创建入口点方法
MethodDef entryPoint = new MethodDefUser("Main",
MethodSig.CreateStatic(mod.CorLibTypes.Void, new SZArraySig(mod.CorLibTypes.String)));
entryPoint.Attributes = MethodAttributes.Private | MethodAttributes.Static |
MethodAttributes.HideBySig | MethodAttributes.ReuseSlot;
entryPoint.ImplAttributes = MethodImplAttributes.IL | MethodImplAttributes.Managed;
// 命名第一个参数（参数0是返回类型）
entryPoint.ParamDefs.Add(new ParamDefUser("args", 1));
// 将方法添加到启动类型
startUpType.Methods.Add(entryPoint);
// 设置模块入口点
mod.EntryPoint = entryPoint;
// 创建TypeRef到System.Console
TypeRef consoleRef = new TypeRefUser(mod, "System", "Console", mod.CorLibTypes.AssemblyRef);
// 创建方法ref为'System.Void System.Console :: WriteLine（System.String）'
MemberRef consoleWrite1 = new MemberRefUser(mod, "WriteLine",
MethodSig.CreateStatic(mod.CorLibTypes.Void, mod.CorLibTypes.String),
consoleRef);
TypeRef ConsoleKeyInfo = new TypeRefUser(mod, "System", "ConsoleKeyInfo", mod.CorLibTypes.AssemblyRef);
//TypeRef stream = new TypeRefUser(mod, "System.IO", "Stream", mod.CorLibTypes.AssemblyRef);
ClassSig classSig = new ClassSig(ConsoleKeyInfo);
SZArraySig array5 = new SZArraySig(classSig);
ITypeDefOrRef type1 = array5.ToTypeDefOrRef();
ITypeDefOrRef type2 = classSig.ToTypeDefOrRef();
TypeSig type11 = type1.ToTypeSig();
TypeSig type22 = type2.ToTypeSig();
// 创建方法ref为'System.ConsoleKeyInfo
//System.Console::ReadKey()'
MemberRef consoleReadKey = new MemberRefUser(
mod,
"ReadLine",
//MethodSig.CreateStatic(mod.CorLibTypes.Void),
MethodSig.CreateStatic(mod.CorLibTypes.String),
consoleRef
);
//LocalList localList=new LocalList(new LazyList<Local>());
Local local = new Local(mod.CorLibTypes.String);
//localList.Add(local);
//SZArraySig SZArraySig = new SZArraySig(local);
// 将CIL方法体添加到入口点方法
CilBody epBody = new CilBody();
entryPoint.Body = epBody;
epBody.Variables.Add(local);
epBody.Instructions.Add(OpCodes.Nop.ToInstruction());
epBody.Instructions.Add(OpCodes.Ldstr.ToInstruction("小宇专属"));
epBody.Instructions.Add(OpCodes.Call.ToInstruction(consoleWrite1));
epBody.Instructions.Add(OpCodes.Ldstr.ToInstruction("xiaoyu"));
epBody.Instructions.Add(OpCodes.Call.ToInstruction(consoleWrite1));
epBody.Instructions.Add(OpCodes.Nop.ToInstruction());
epBody.Instructions.Add(OpCodes.Call.ToInstruction(consoleReadKey));
//epBody.Instructions.Add(OpCodes.Ldc_I4_0.ToInstruction());
epBody.Instructions.Add(OpCodes.Stloc_0.ToInstruction());
epBody.Instructions.Add(OpCodes.Ldloc_0.ToInstruction());
epBody.Instructions.Add(OpCodes.Call.ToInstruction(consoleWrite1));
epBody.Instructions.Add(OpCodes.Nop.ToInstruction());
epBody.Instructions.Add(OpCodes.Ret.ToInstruction());
// 将程序集保存到磁盘上的文件中
mod.Write(@"saved-assembly.exe");
}
public static void Run() {
// This is the file that will be created
string newFileName = @"C:\ctor-test.exe";
// Create the module
var mod = new ModuleDefUser("ctor-test", Guid.NewGuid(),
new AssemblyRefUser(new AssemblyNameInfo(typeof(int).Assembly.GetName().FullName)));
// It's a console app
mod.Kind = ModuleKind.Console;
// Create the assembly and add the created module to it
new AssemblyDefUser("ctor-test", new Version(1, 2, 3, 4)).Modules.Add(mod);
// Create System.Console type reference
var systemConsole = mod.CorLibTypes.GetTypeRef("System", "Console");
// Create 'void System.Console.WriteLine(string,object)' method reference
var writeLine2 = new MemberRefUser(mod, "WriteLine",
MethodSig.CreateStatic(mod.CorLibTypes.Void, mod.CorLibTypes.String,
mod.CorLibTypes.Object),
systemConsole);
// Create System.Object::.ctor method reference. This is the default constructor
var objectCtor = new MemberRefUser(mod, ".ctor",
MethodSig.CreateInstance(mod.CorLibTypes.Void),
mod.CorLibTypes.Object.TypeDefOrRef);
CilBody body;
// Create the base class
var bclass = new TypeDefUser("Ctor.Test", "BaseClass", mod.CorLibTypes.Object.TypeDefOrRef);
// Add it to the module
mod.Types.Add(bclass);
// Create Ctor.Test.BaseClass constructor: BaseClass()
var bctor = new MethodDefUser(".ctor", MethodSig.CreateInstance(mod.CorLibTypes.Void),
MethodImplAttributes.IL | MethodImplAttributes.Managed,
MethodAttributes.Public |
MethodAttributes.SpecialName | MethodAttributes.RTSpecialName);
// Add the method to BaseClass
bclass.Methods.Add(bctor);
// Create method body and add a few instructions
bctor.Body = body = new CilBody();
// Make sure we call the base class' constructor
body.Instructions.Add(OpCodes.Ldarg_0.ToInstruction());
body.Instructions.Add(OpCodes.Call.ToInstruction(objectCtor));
body.Instructions.Add(OpCodes.Ldstr.ToInstruction("BaseClass: Default .ctor called"));
body.Instructions.Add(OpCodes.Ldnull.ToInstruction());
body.Instructions.Add(OpCodes.Call.ToInstruction(writeLine2));
body.Instructions.Add(OpCodes.Ret.ToInstruction());
// Create the Ctor.Test.Main type which derives from Ctor.Test.BaseClass
var main = new TypeDefUser("Ctor.Test", "Main", bclass);
// Add it to the module
mod.Types.Add(main);
// Create the static 'void Main()' method
var entryPoint = new MethodDefUser("Main", MethodSig.CreateStatic(mod.CorLibTypes.Void),
MethodImplAttributes.IL | MethodImplAttributes.Managed,
MethodAttributes.Public | MethodAttributes.Static);
// Set entry point to entryPoint and add it as a Ctor.Test.Main method
mod.EntryPoint = entryPoint;
main.Methods.Add(entryPoint);
// Create first Ctor.Test.Main constructor: Main()
var ctor0 = new MethodDefUser(".ctor", MethodSig.CreateInstance(mod.CorLibTypes.Void),
MethodImplAttributes.IL | MethodImplAttributes.Managed,
MethodAttributes.Public |
MethodAttributes.SpecialName | MethodAttributes.RTSpecialName);
// Add the method to Main
main.Methods.Add(ctor0);
// Create method body and add a few instructions
ctor0.Body = body = new CilBody();
// Make sure we call the base class' constructor
body.Instructions.Add(OpCodes.Ldarg_0.ToInstruction());
body.Instructions.Add(OpCodes.Call.ToInstruction(bctor));
body.Instructions.Add(OpCodes.Ldstr.ToInstruction("Default .ctor called"));
body.Instructions.Add(OpCodes.Ldnull.ToInstruction());
body.Instructions.Add(OpCodes.Call.ToInstruction(writeLine2));
body.Instructions.Add(OpCodes.Ret.ToInstruction());
// Create second Ctor.Test.Main constructor: Main(int,string)
var ctor1 = new MethodDefUser(".ctor", MethodSig.CreateInstance(mod.CorLibTypes.Void, mod.CorLibTypes.Int32, mod.CorLibTypes.String),
MethodImplAttributes.IL | MethodImplAttributes.Managed,
MethodAttributes.Public |
MethodAttributes.SpecialName | MethodAttributes.RTSpecialName);
// Add the method to Main
main.Methods.Add(ctor1);
// Create names for the arguments. This is optional. Since this is an instance method
// (it's a constructor), the first arg is the 'this' pointer. The normal arguments
// begin at index 1.
ctor1.Parameters[1].CreateParamDef();
ctor1.Parameters[1].ParamDef.Name = "count";
ctor1.Parameters[2].CreateParamDef();
ctor1.Parameters[2].ParamDef.Name = "name";
// Create method body and add a few instructions
ctor1.Body = body = new CilBody();
// Make sure we call the base class' constructor
body.Instructions.Add(OpCodes.Ldarg_0.ToInstruction());
body.Instructions.Add(OpCodes.Call.ToInstruction(bctor));
body.Instructions.Add(OpCodes.Ldstr.ToInstruction(".ctor(Int32) called with arg {0}"));
body.Instructions.Add(OpCodes.Ldarg_1.ToInstruction());
body.Instructions.Add(OpCodes.Box.ToInstruction(mod.CorLibTypes.Int32));
body.Instructions.Add(OpCodes.Call.ToInstruction(writeLine2));
body.Instructions.Add(OpCodes.Ret.ToInstruction());
// Create the entry point method body and add instructions to allocate a new Main()
// object and call the two created ctors.
entryPoint.Body = body = new CilBody();
body.Instructions.Add(OpCodes.Newobj.ToInstruction(ctor0));
body.Instructions.Add(OpCodes.Pop.ToInstruction());
body.Instructions.Add(OpCodes.Ldc_I4.ToInstruction(12345));
body.Instructions.Add(OpCodes.Ldnull.ToInstruction());
body.Instructions.Add(OpCodes.Newobj.ToInstruction(ctor1));
body.Instructions.Add(OpCodes.Pop.ToInstruction());
body.Instructions.Add(OpCodes.Ret.ToInstruction());
// Save the assembly
mod.Write(newFileName);
}
public static void Run()
{
// This is the file that will be created
string newFileName = @"C:\ctor-test.exe";
// Create the module
var mod = new ModuleDefUser("ctor-test", Guid.NewGuid(),
new AssemblyRefUser(new AssemblyNameInfo(typeof(int).Assembly.GetName().FullName)));
// It's a console app
mod.Kind = ModuleKind.Console;
// Create the assembly and add the created module to it
new AssemblyDefUser("ctor-test", new Version(1, 2, 3, 4)).Modules.Add(mod);
// Create System.Console type reference
var systemConsole = mod.CorLibTypes.GetTypeRef("System", "Console");
// Create 'void System.Console.WriteLine(string,object)' method reference
var writeLine2 = new MemberRefUser(mod, "WriteLine",
MethodSig.CreateStatic(mod.CorLibTypes.Void, mod.CorLibTypes.String,
mod.CorLibTypes.Object),
systemConsole);
// Create System.Object::.ctor method reference. This is the default constructor
var objectCtor = new MemberRefUser(mod, ".ctor",
MethodSig.CreateInstance(mod.CorLibTypes.Void),
mod.CorLibTypes.Object.TypeDefOrRef);
CilBody body;
// Create the base class
var bclass = new TypeDefUser("Ctor.Test", "BaseClass", mod.CorLibTypes.Object.TypeDefOrRef);
// Add it to the module
mod.Types.Add(bclass);
// Create Ctor.Test.BaseClass constructor: BaseClass()
var bctor = new MethodDefUser(".ctor", MethodSig.CreateInstance(mod.CorLibTypes.Void),
MethodImplAttributes.IL | MethodImplAttributes.Managed,
MethodAttributes.Public |
MethodAttributes.SpecialName | MethodAttributes.RTSpecialName);
// Add the method to BaseClass
bclass.Methods.Add(bctor);
// Create method body and add a few instructions
bctor.Body = body = new CilBody();
// Make sure we call the base class' constructor
body.Instructions.Add(OpCodes.Ldarg_0.ToInstruction());
body.Instructions.Add(OpCodes.Call.ToInstruction(objectCtor));
body.Instructions.Add(OpCodes.Ldstr.ToInstruction("BaseClass: Default .ctor called"));
body.Instructions.Add(OpCodes.Ldnull.ToInstruction());
body.Instructions.Add(OpCodes.Call.ToInstruction(writeLine2));
body.Instructions.Add(OpCodes.Ret.ToInstruction());
// Create the Ctor.Test.Main type which derives from Ctor.Test.BaseClass
var main = new TypeDefUser("Ctor.Test", "Main", bclass);
// Add it to the module
mod.Types.Add(main);
// Create the static 'void Main()' method
var entryPoint = new MethodDefUser("Main", MethodSig.CreateStatic(mod.CorLibTypes.Void),
MethodImplAttributes.IL | MethodImplAttributes.Managed,
MethodAttributes.Public | MethodAttributes.Static);
// Set entry point to entryPoint and add it as a Ctor.Test.Main method
mod.EntryPoint = entryPoint;
main.Methods.Add(entryPoint);
// Create first Ctor.Test.Main constructor: Main()
var ctor0 = new MethodDefUser(".ctor", MethodSig.CreateInstance(mod.CorLibTypes.Void),
MethodImplAttributes.IL | MethodImplAttributes.Managed,
MethodAttributes.Public |
MethodAttributes.SpecialName | MethodAttributes.RTSpecialName);
// Add the method to Main
main.Methods.Add(ctor0);
// Create method body and add a few instructions
ctor0.Body = body = new CilBody();
// Make sure we call the base class' constructor
body.Instructions.Add(OpCodes.Ldarg_0.ToInstruction());
body.Instructions.Add(OpCodes.Call.ToInstruction(bctor));
body.Instructions.Add(OpCodes.Ldstr.ToInstruction("Default .ctor called"));
body.Instructions.Add(OpCodes.Ldnull.ToInstruction());
body.Instructions.Add(OpCodes.Call.ToInstruction(writeLine2));
body.Instructions.Add(OpCodes.Ret.ToInstruction());
// Create second Ctor.Test.Main constructor: Main(int,string)
var ctor1 = new MethodDefUser(".ctor", MethodSig.CreateInstance(mod.CorLibTypes.Void, mod.CorLibTypes.Int32, mod.CorLibTypes.String),
MethodImplAttributes.IL | MethodImplAttributes.Managed,
MethodAttributes.Public |
MethodAttributes.SpecialName | MethodAttributes.RTSpecialName);
// Add the method to Main
main.Methods.Add(ctor1);
// Create names for the arguments. This is optional. Since this is an instance method
// (it's a constructor), the first arg is the 'this' pointer. The normal arguments
// begin at index 1.
ctor1.Parameters[1].CreateParamDef();
ctor1.Parameters[1].ParamDef.Name = "count";
ctor1.Parameters[2].CreateParamDef();
ctor1.Parameters[2].ParamDef.Name = "name";
// Create method body and add a few instructions
ctor1.Body = body = new CilBody();
// Make sure we call the base class' constructor
body.Instructions.Add(OpCodes.Ldarg_0.ToInstruction());
body.Instructions.Add(OpCodes.Call.ToInstruction(bctor));
body.Instructions.Add(OpCodes.Ldstr.ToInstruction(".ctor(Int32) called with arg {0}"));
body.Instructions.Add(OpCodes.Ldarg_1.ToInstruction());
body.Instructions.Add(OpCodes.Box.ToInstruction(mod.CorLibTypes.Int32));
body.Instructions.Add(OpCodes.Call.ToInstruction(writeLine2));
body.Instructions.Add(OpCodes.Ret.ToInstruction());
// Create the entry point method body and add instructions to allocate a new Main()
// object and call the two created ctors.
entryPoint.Body = body = new CilBody();
body.Instructions.Add(OpCodes.Newobj.ToInstruction(ctor0));
body.Instructions.Add(OpCodes.Pop.ToInstruction());
body.Instructions.Add(OpCodes.Ldc_I4.ToInstruction(12345));
body.Instructions.Add(OpCodes.Ldnull.ToInstruction());
body.Instructions.Add(OpCodes.Newobj.ToInstruction(ctor1));
body.Instructions.Add(OpCodes.Pop.ToInstruction());
body.Instructions.Add(OpCodes.Ret.ToInstruction());
// Save the assembly
mod.Write(newFileName);
}
static void Main(string[] args)
{
// Create assembly and main module
var assembly = new AssemblyDefUser("HelloWorld");
var module = new ModuleDefUser("HelloWorld.dll", null, new AssemblyRefUser("System.Runtime", new Version(4, 2, 2, 0)));
module.RuntimeVersion = dnlib.DotNet.MD.MDHeaderRuntimeVersion.MS_CLR_40;
// Create type Program
var type = new TypeDefUser(
@namespace: "HelloWorld",
name: "Program",
baseType: module.CorLibTypes.Object.TypeDefOrRef);
// Set class attributes
type.Attributes = TypeAttributes.Public | TypeAttributes.Class;
// Create method Main
var method = new MethodDefUser(
name: "Main",
methodSig: MethodSig.CreateStatic(
retType: module.CorLibTypes.Void,
argType1: new SZArraySig(module.CorLibTypes.String)));
// Name parameter
method.ParamDefs.Add(new ParamDefUser("args", 1));
// Set method attributes
method.Attributes = MethodAttributes.Public | MethodAttributes.Static;
// Set attributes for method's implementation
method.ImplAttributes = MethodImplAttributes.IL | MethodImplAttributes.Managed;
#region IMPLEMENTATION
// Create reference to System.Console
var consoleRef = new TypeRefUser(module, "System", "Console", new AssemblyRefUser("System.Console"));
// Create reference to System.Console::WriteLine(string)
var writeLineRef = new MemberRefUser(module, "WriteLine",
MethodSig.CreateStatic(
retType: module.CorLibTypes.Void,
argType1: module.CorLibTypes.String),
consoleRef);
// Implement body of the Program::Main(string[]) method
var body = new CilBody();
body.Instructions.Add(Instruction.Create(OpCodes.Ldstr, "Hello World!"));
body.Instructions.Add(Instruction.Create(OpCodes.Call, writeLineRef));
body.Instructions.Add(Instruction.Create(OpCodes.Br, body.Instructions.First()));
body.Instructions.Add(Instruction.Create(OpCodes.Ret));
method.Body = body;
#endregion
#region ASSEMBLE
// Wire-it up!
assembly.Modules.Add(module);
module.Types.Add(type);
type.Methods.Add(method);
// Set entrypoint
module.EntryPoint = method;
// Store assembly
module.Write(Path.Combine("Generated", "HelloWorld.dll"), new dnlib.DotNet.Writer.ModuleWriterOptions(module));
#endregion
}
void OnWriterEvent(object sender, ModuleWriterListenerEventArgs e)
{
var writer = (ModuleWriterBase)sender;
if (e.WriterEvent == ModuleWriterEvent.MDBeginAddResources)
{
ctx.Context.CheckCancellation();
ctx.Context.Logger.Debug("Encrypting resources...");
bool hasPacker = ctx.Context.Packer != null;
List <EmbeddedResource> resources = ctx.Module.Resources.OfType <EmbeddedResource>().ToList();
if (!hasPacker)
{
ctx.Module.Resources.RemoveWhere(res => res is EmbeddedResource);
}
// move resources
string asmName = ctx.Name.RandomName(RenameMode.Letters);
PublicKey pubKey = null;
if (writer.TheOptions.StrongNameKey != null)
{
pubKey = PublicKeyBase.CreatePublicKey(writer.TheOptions.StrongNameKey.PublicKey);
}
var module = new ModuleDefUser(asmName + ".dll", Guid.NewGuid(), ctx.Module.CorLibTypes.AssemblyRef);
module.Kind = ModuleKind.Dll;
var assembly = new AssemblyDefUser(asmName, new Version(1, 0), pubKey);
assembly.Modules.Add(module);
module.Characteristics = ctx.Module.Characteristics;
module.Cor20HeaderFlags = ctx.Module.Cor20HeaderFlags;
module.Cor20HeaderRuntimeVersion = ctx.Module.Cor20HeaderRuntimeVersion;
module.DllCharacteristics = ctx.Module.DllCharacteristics;
module.EncBaseId = ctx.Module.EncBaseId;
module.EncId = ctx.Module.EncId;
module.Generation = ctx.Module.Generation;
module.Machine = ctx.Module.Machine;
module.RuntimeVersion = ctx.Module.RuntimeVersion;
module.TablesHeaderVersion = ctx.Module.TablesHeaderVersion;
module.RuntimeVersion = ctx.Module.RuntimeVersion;
var asmRef = new AssemblyRefUser(module.Assembly);
if (pubKey == null)
{
asmRef.Attributes &= ~AssemblyAttributes.PublicKey; // ssdi: fix incorrect flags set in dnlib, "CS0009 .... -- Invalid public key." into VS2015, VS2017 msBuild
}
if (!hasPacker)
{
foreach (var res in resources)
{
res.Attributes = ManifestResourceAttributes.Public;
module.Resources.Add(res);
ctx.Module.Resources.Add(new AssemblyLinkedResource(res.Name, asmRef, res.Attributes));
}
}
byte[] moduleBuff;
using (var ms = new MemoryStream())
{
module.Write(ms, new ModuleWriterOptions(ctx.Module)
{
StrongNameKey = writer.TheOptions.StrongNameKey
});
moduleBuff = ms.ToArray();
}
// compress
moduleBuff = ctx.Context.Registry.GetService <ICompressionService>().Compress(
moduleBuff,
progress => ctx.Context.Logger.Progress((int)(progress * 10000), 10000));
ctx.Context.Logger.EndProgress();
ctx.Context.CheckCancellation();
uint compressedLen = (uint)(moduleBuff.Length + 3) / 4;
compressedLen = (compressedLen + 0xfu) & ~0xfu;
var compressedBuff = new uint[compressedLen];
Buffer.BlockCopy(moduleBuff, 0, compressedBuff, 0, moduleBuff.Length);
Debug.Assert(compressedLen % 0x10 == 0);
// encrypt
uint keySeed = ctx.Random.NextUInt32() | 0x10;
var key = new uint[0x10];
uint state = keySeed;
for (int i = 0; i < 0x10; i++)
{
state ^= state >> 13;
state ^= state << 25;
state ^= state >> 27;
key[i] = state;
}
var encryptedBuffer = new byte[compressedBuff.Length * 4];
int buffIndex = 0;
while (buffIndex < compressedBuff.Length)
{
uint[] enc = ctx.ModeHandler.Encrypt(compressedBuff, buffIndex, key);
for (int j = 0; j < 0x10; j++)
{
key[j] ^= compressedBuff[buffIndex + j];
}
Buffer.BlockCopy(enc, 0, encryptedBuffer, buffIndex * 4, 0x40);
buffIndex += 0x10;
}
Debug.Assert(buffIndex == compressedBuff.Length);
var size = (uint)encryptedBuffer.Length;
TablesHeap tblHeap = writer.MetaData.TablesHeap;
tblHeap.ClassLayoutTable[writer.MetaData.GetClassLayoutRid(ctx.DataType)].ClassSize = size;
tblHeap.FieldTable[writer.MetaData.GetRid(ctx.DataField)].Flags |= (ushort)FieldAttributes.HasFieldRVA;
encryptedResource = writer.Constants.Add(new ByteArrayChunk(encryptedBuffer), 8);
// inject key values
MutationHelper.InjectKeys(ctx.InitMethod,
new[] { 0, 1 },
new[] { (int)(size / 4), (int)(keySeed) });
}
else if (e.WriterEvent == ModuleWriterEvent.EndCalculateRvasAndFileOffsets)
{
TablesHeap tblHeap = writer.MetaData.TablesHeap;
tblHeap.FieldRVATable[writer.MetaData.GetFieldRVARid(ctx.DataField)].RVA = (uint)encryptedResource.RVA;
}
}
public static void Run()
{
// This is the file that will be created
string newFileName = @"GenericExample2.exe";
// Create the module
var mod = new ModuleDefUser("GenericExample2", Guid.NewGuid(),
new AssemblyRefUser(new AssemblyNameInfo(typeof(int).Assembly.GetName().FullName)));
// It's a console app
mod.Kind = ModuleKind.Console;
// Create the assembly and add the created module to it
new AssemblyDefUser("GenericExample2", new Version(1, 2, 3, 4)).Modules.Add(mod);
// Add the startup type. It derives from System.Object.
TypeDef 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
MethodDef 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 System.Console type reference
var systemConsole = mod.CorLibTypes.GetTypeRef("System", "Console");
// Create 'void System.Console.WriteLine(string,object)' method reference
var writeLine2 = new MemberRefUser(mod, "WriteLine",
MethodSig.CreateStatic(mod.CorLibTypes.Void, mod.CorLibTypes.String,
mod.CorLibTypes.Object),
systemConsole);
var assemblyRef = mod.CorLibTypes.AssemblyRef;
// Create 'System.Collections.ObjectModel.ReadOnlyCollection`1' type ref
var roCollectionRef = new TypeRefUser(mod, "System.Collections.ObjectModel", "ReadOnlyCollection`1", assemblyRef);
// Create 'ReadOnlyCollection<!!0>' signature for return type
var roCollectionSig = new GenericInstSig(new ClassSig(roCollectionRef), new GenericMVar(0)); // Return type
// Create 'ReadOnlyCollection<Int32>' type spec
var roCollectionTypeSpec = new TypeSpecUser(new GenericInstSig(new ClassSig(roCollectionRef), mod.CorLibTypes.Int32));
// Create 'ReadOnlyCollection<Int32>.get_Count()' method reference
var roCollectionGetCount = new MemberRefUser(mod, "get_Count",
MethodSig.CreateInstance(mod.CorLibTypes.Int32),
roCollectionTypeSpec);
// Create 'System.Array' type ref
var arrayRef = new TypeRefUser(mod, "System", "Array", assemblyRef);
// Create 'ReadOnlyCollection<T> Array.AsReadOnly<T>(T[] array)' method reference
// Apparently CreateStaticGeneric should be used only if at least one GenericMVar is used? Not 100% certain.
var asReadOnly = new MemberRefUser(mod, "AsReadOnly",
MethodSig.CreateStaticGeneric(1, roCollectionSig, new SZArraySig(new GenericMVar(0))),
arrayRef);
// Create 'Array.AsReadOnly<Int32>' method spec
var asReadOnlySpec = new MethodSpecUser(asReadOnly,
new GenericInstMethodSig(mod.CorLibTypes.Int32));
// Create 'ReadOnlyCollection<Int32>' signature for local
var roCollectionInt32 = roCollectionTypeSpec.TryGetGenericInstSig();
// Method body locals
IList <Local> locals = new List <Local>();
locals.Add(new Local(new SZArraySig(mod.CorLibTypes.Int32))); // local[0]: Int32[]
locals.Add(new Local(roCollectionInt32)); // local[1]: class [mscorlib]System.Collections.ObjectModel.ReadOnlyCollection`1<Int32>
var body = new CilBody(true, new List <Instruction>(), new List <ExceptionHandler>(), locals);
// array = new Int32[2];
body.Instructions.Add(OpCodes.Ldc_I4_2.ToInstruction());
body.Instructions.Add(OpCodes.Newarr.ToInstruction(mod.CorLibTypes.Int32));
body.Instructions.Add(OpCodes.Stloc_0.ToInstruction()); // Store array to local[0]
// array[0] = 5;
body.Instructions.Add(OpCodes.Ldloc_0.ToInstruction());
body.Instructions.Add(OpCodes.Ldc_I4_0.ToInstruction());
body.Instructions.Add(OpCodes.Ldc_I4_5.ToInstruction());
body.Instructions.Add(OpCodes.Stelem_I4.ToInstruction());
// array[1] = 111;
body.Instructions.Add(OpCodes.Ldloc_0.ToInstruction());
body.Instructions.Add(OpCodes.Ldc_I4_1.ToInstruction());
body.Instructions.Add(OpCodes.Ldc_I4.ToInstruction(111));
body.Instructions.Add(OpCodes.Stelem_I4.ToInstruction());
// collection = Array.AsReadOnly<Int32>(array)
body.Instructions.Add(OpCodes.Ldloc_0.ToInstruction());
body.Instructions.Add(OpCodes.Call.ToInstruction(asReadOnlySpec));
body.Instructions.Add(OpCodes.Stloc_1.ToInstruction());
// Console.WriteLine("Count: {0}", collection.Count)
body.Instructions.Add(OpCodes.Ldstr.ToInstruction("Count: {0}"));
body.Instructions.Add(OpCodes.Ldloc_1.ToInstruction());
body.Instructions.Add(OpCodes.Callvirt.ToInstruction(roCollectionGetCount));
body.Instructions.Add(OpCodes.Box.ToInstruction(mod.CorLibTypes.Int32));
body.Instructions.Add(OpCodes.Call.ToInstruction(writeLine2));
// return 0;
body.Instructions.Add(OpCodes.Ldc_I4_0.ToInstruction());
body.Instructions.Add(OpCodes.Ret.ToInstruction());
entryPoint.Body = body;
// Save the assembly
mod.Write(newFileName);
}
public static void Run()
{
// 创建一个新模块。 传入的字符串是模块的名称，而不是文件名。
ModuleDef mod = new ModuleDefUser("MyModule.exe");
// 这是一个控制台应用程序
mod.Kind = ModuleKind.Console;
//将模块添加到装配中
AssemblyDef asm = new AssemblyDefUser("MyAssembly", new Version(1, 2, 3, 4), null, "");
asm.Modules.Add(mod);
//添加.NET资源
// byte[] resourceData = Encoding.UTF8.GetBytes("Hello, world!");
//mod.Resources.Add(new EmbeddedResource("My.Resource", resourceData,
// ManifestResourceAttributes.Private));
// 添加启动类型。 它派生自System.Object。
TypeDef startUpType = new TypeDefUser("My.Namespace", "Startup", mod.CorLibTypes.Object.TypeDefOrRef);
startUpType.Attributes = TypeAttributes.NotPublic | TypeAttributes.AutoLayout |
TypeAttributes.Class | TypeAttributes.AnsiClass;
// 将类型添加到模块
mod.Types.Add(startUpType);
// 创建入口点方法
MethodDef entryPoint = new MethodDefUser("Main",
MethodSig.CreateStatic(mod.CorLibTypes.Void, new SZArraySig(mod.CorLibTypes.String)));
entryPoint.Attributes = MethodAttributes.Private | MethodAttributes.Static |
MethodAttributes.HideBySig | MethodAttributes.ReuseSlot;
entryPoint.ImplAttributes = MethodImplAttributes.IL | MethodImplAttributes.Managed;
// 命名第一个参数（参数0是返回类型）
entryPoint.ParamDefs.Add(new ParamDefUser("args", 1));
// 将方法添加到启动类型
startUpType.Methods.Add(entryPoint);
// 设置模块入口点
mod.EntryPoint = entryPoint;
// 创建TypeRef到System.Console
TypeRef consoleRef = new TypeRefUser(mod, "System", "Console", mod.CorLibTypes.AssemblyRef);
// 创建方法ref为'System.Void System.Console :: WriteLine（System.String）'
MemberRef consoleWrite1 = new MemberRefUser(mod, "WriteLine",
MethodSig.CreateStatic(mod.CorLibTypes.Void, mod.CorLibTypes.String),
consoleRef);
//System.Console::ReadKey()'
MemberRef memberRefReadLine = new MemberRefUser(
mod,
"ReadLine",
//MethodSig.CreateStatic(mod.CorLibTypes.Void),
MethodSig.CreateStatic(mod.CorLibTypes.String),
consoleRef
);
// 创建TypeRef到System.Console
TypeRef int32Ref = new TypeRefUser(mod, "System", "Int32", mod.CorLibTypes.AssemblyRef);
MemberRef memberRefParse = new MemberRefUser(
mod,
"Parse",
MethodSig.CreateStatic(mod.CorLibTypes.Int32, mod.CorLibTypes.String),
int32Ref
);
//string[mscorlib] System.String::Concat(object[])
TypeRef stringRef = new TypeRefUser(mod, "System", "String", mod.CorLibTypes.AssemblyRef);
MemberRef memberRefSystemStringConcat = new MemberRefUser(
mod,
"Concat",
MethodSig.CreateStatic(mod.CorLibTypes.String, new SZArraySig(mod.CorLibTypes.Object)),
stringRef
);
// 将CIL方法体添加到入口点方法
CilBody epBody = new CilBody();
entryPoint.Body = epBody;
epBody.Variables.Add(new Local(mod.CorLibTypes.String, "s1"));
epBody.Variables.Add(new Local(mod.CorLibTypes.Int32, "i1"));
epBody.Variables.Add(new Local(mod.CorLibTypes.Int32, "i2"));
epBody.Variables.Add(new Local(mod.CorLibTypes.String, "s2"));
//: nop
//: ldstr "xyzs"
//: call void [mscorlib]System.Console::WriteLine(string)
epBody.Instructions.Add(OpCodes.Nop.ToInstruction());
epBody.Instructions.Add(OpCodes.Ldstr.ToInstruction("小宇专属"));
epBody.Instructions.Add(OpCodes.Call.ToInstruction(consoleWrite1));
//: nop
//: call string [mscorlib]System.Console::ReadLine()
//: stloc.0
//: ldloc.0
//: call void [mscorlib]System.Console::WriteLine(string)
epBody.Instructions.Add(OpCodes.Nop.ToInstruction());
epBody.Instructions.Add(OpCodes.Call.ToInstruction(memberRefReadLine));
epBody.Instructions.Add(OpCodes.Stloc_0.ToInstruction());
epBody.Instructions.Add(OpCodes.Ldloc_0.ToInstruction());
epBody.Instructions.Add(OpCodes.Call.ToInstruction(consoleWrite1));
//: nop
epBody.Instructions.Add(OpCodes.Nop.ToInstruction());
//: call string [mscorlib]System.Console::ReadLine()
epBody.Instructions.Add(OpCodes.Call.ToInstruction(memberRefReadLine));
//: call int32 [mscorlib]System.Int32::Parse(string)
epBody.Instructions.Add(OpCodes.Call.ToInstruction(memberRefParse));
//: stloc.1
epBody.Instructions.Add(OpCodes.Stloc_1.ToInstruction());
//: call string [mscorlib]System.Console::ReadLine()
epBody.Instructions.Add(OpCodes.Call.ToInstruction(memberRefReadLine));
//: call int32 [mscorlib]System.Int32::Parse(string)
epBody.Instructions.Add(OpCodes.Call.ToInstruction(memberRefParse));
//: stloc.2
epBody.Instructions.Add(OpCodes.Stloc_2.ToInstruction());
//: ldc.i4.5
epBody.Instructions.Add(OpCodes.Ldc_I4_5.ToInstruction());
//: newarr [mscorlib]System.Object
epBody.Instructions.Add(OpCodes.Newarr.ToInstruction(mod.CorLibTypes.Object));
//: dup
epBody.Instructions.Add(OpCodes.Dup.ToInstruction());
//: ldc.i4.0
epBody.Instructions.Add(OpCodes.Ldc_I4_0.ToInstruction());
//: ldloc.1
epBody.Instructions.Add(OpCodes.Ldloc_1.ToInstruction());
//: box [mscorlib]System.Int32
epBody.Instructions.Add(OpCodes.Box.ToInstruction(mod.CorLibTypes.Int32));
//: stelem.ref
epBody.Instructions.Add(OpCodes.Stelem_Ref.ToInstruction());
//: dup
epBody.Instructions.Add(OpCodes.Dup.ToInstruction());
//: ldc.i4.1
epBody.Instructions.Add(OpCodes.Ldc_I4_1.ToInstruction());
//: ldstr "+"
epBody.Instructions.Add(OpCodes.Ldstr.ToInstruction("+"));
//: stelem.ref
epBody.Instructions.Add(OpCodes.Stelem_Ref.ToInstruction());
//: dup
epBody.Instructions.Add(OpCodes.Dup.ToInstruction());
//: ldc.i4.2
epBody.Instructions.Add(OpCodes.Ldc_I4_2.ToInstruction());
//: ldloc.2
epBody.Instructions.Add(OpCodes.Ldloc_2.ToInstruction());
//: box [mscorlib]System.Int32
epBody.Instructions.Add(OpCodes.Box.ToInstruction(mod.CorLibTypes.Int32));
//: stelem.ref
epBody.Instructions.Add(OpCodes.Stelem_Ref.ToInstruction());
//: dup
epBody.Instructions.Add(OpCodes.Dup.ToInstruction());
//: ldc.i4.3
epBody.Instructions.Add(OpCodes.Ldc_I4_3.ToInstruction());
//: ldstr "="
epBody.Instructions.Add(OpCodes.Ldstr.ToInstruction("="));
//: stelem.ref
epBody.Instructions.Add(OpCodes.Stelem_Ref.ToInstruction());
//: dup
epBody.Instructions.Add(OpCodes.Dup.ToInstruction());
//: ldc.i4.4
epBody.Instructions.Add(OpCodes.Ldc_I4_4.ToInstruction());
//: ldloc.1
epBody.Instructions.Add(OpCodes.Ldloc_1.ToInstruction());
//: ldloc.2
epBody.Instructions.Add(OpCodes.Ldloc_2.ToInstruction());
//: add
epBody.Instructions.Add(OpCodes.Add.ToInstruction());
//: box [mscorlib]System.Int32
epBody.Instructions.Add(OpCodes.Box.ToInstruction(mod.CorLibTypes.Int32));
//: stelem.ref
epBody.Instructions.Add(OpCodes.Stelem_Ref.ToInstruction());
//: call string [mscorlib]System.String::Concat(object[])
epBody.Instructions.Add(OpCodes.Call.ToInstruction(memberRefSystemStringConcat));
//: call void [mscorlib]System.Console::WriteLine(string)
epBody.Instructions.Add(OpCodes.Call.ToInstruction(consoleWrite1));
//: nop
epBody.Instructions.Add(OpCodes.Nop.ToInstruction());
//: ldstr "xyzs"
epBody.Instructions.Add(OpCodes.Ldstr.ToInstruction("xyzs"));
//: call void [mscorlib]System.Console::WriteLine(string)
epBody.Instructions.Add(OpCodes.Call.ToInstruction(consoleWrite1));
//: nop
epBody.Instructions.Add(OpCodes.Nop.ToInstruction());
//: call string [mscorlib]System.Console::ReadLine()
epBody.Instructions.Add(OpCodes.Call.ToInstruction(memberRefReadLine));
//: stloc.3
epBody.Instructions.Add(OpCodes.Stloc_3.ToInstruction());
//: ldloc.3
epBody.Instructions.Add(OpCodes.Ldloc_3.ToInstruction());
//: call void [mscorlib]System.Console::WriteLine(string)
epBody.Instructions.Add(OpCodes.Call.ToInstruction(consoleWrite1));
//: nop
epBody.Instructions.Add(OpCodes.Nop.ToInstruction());
//: ret
epBody.Instructions.Add(OpCodes.Ret.ToInstruction());
// 将程序集保存到磁盘上的文件中
mod.Write(@"saved-assembly31.exe");
}
public static void Run()
{
// This is the file that will be created
string newFileName = "GenericExample3.exe";
// Create the module
var mod = new ModuleDefUser("GenericExample3", Guid.NewGuid(),
new AssemblyRefUser(new AssemblyNameInfo(typeof(int).Assembly.GetName().FullName)));
// It's a console app
mod.Kind = ModuleKind.Console;
// Create the assembly and add the created module to it
new AssemblyDefUser("GenericExample3", new Version(1, 2, 3, 4)).Modules.Add(mod);
// Add the startup type. It derives from System.Object.
TypeDef 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
MethodDef 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 type with 2 generic parameters, A and B
// Would look like: public class GClass<A, B>
var genericType = new TypeDefUser("My.Namespace", "GClass", mod.CorLibTypes.Object.TypeDefOrRef);
genericType.Attributes = TypeAttributes.Public | TypeAttributes.AutoLayout |
TypeAttributes.Class | TypeAttributes.AnsiClass | TypeAttributes.BeforeFieldInit;
genericType.GenericParameters.Add(new GenericParamUser(0, GenericParamAttributes.NonVariant, "A"));
genericType.GenericParameters.Add(new GenericParamUser(1, GenericParamAttributes.NonVariant, "B"));
// Add generic type to module
mod.Types.Add(genericType);
// Note: NestedPublic instead of Public, blank namespace
// Would look like: public class GSubClass<A, B, C>
var genericSubType = new TypeDefUser("", "GSubClass", mod.CorLibTypes.Object.TypeDefOrRef);
genericSubType.Attributes = TypeAttributes.NestedPublic | TypeAttributes.AutoLayout |
TypeAttributes.Class | TypeAttributes.AnsiClass | TypeAttributes.BeforeFieldInit;
// Need to add the 2 generic parameters from the nested-parent class, A and B
genericSubType.GenericParameters.Add(new GenericParamUser(0, GenericParamAttributes.NonVariant, "A"));
genericSubType.GenericParameters.Add(new GenericParamUser(1, GenericParamAttributes.NonVariant, "B"));
// Add a generic parameter specific to this nested class, C
genericSubType.GenericParameters.Add(new GenericParamUser(2, GenericParamAttributes.NonVariant, "C"));
// public void GSubClass<A, B, C>.SomeMethod(B arg1, C arg2) { ... }
// or: public void GSubClass<!0, !1, !2>.SomeMethod(!1, !2) { ... }
var someMethod = new MethodDefUser("SomeMethod",
MethodSig.CreateInstance(mod.CorLibTypes.Void, new GenericVar(1), new GenericVar(2)));
someMethod.Attributes = MethodAttributes.Public;
someMethod.ImplAttributes = MethodImplAttributes.IL | MethodImplAttributes.Managed;
genericSubType.Methods.Add(someMethod);
// Create method with a method generic parameter (GenericMVar)
// public void GSubClass<A, B, C>.SomeOtherMethod<D>(D arg1, A arg2, C arg3) { ... }
// or: public void GSubClass<!0, !1, !2>.SomeOtherMethod<!!0>(!!0, !0, !2) { ... }
var someGenericMethod = new MethodDefUser("SomeOtherMethod",
MethodSig.CreateInstanceGeneric(1, mod.CorLibTypes.Void, new GenericMVar(0), new GenericVar(0), new GenericVar(2)));
someGenericMethod.Attributes = MethodAttributes.Public;
someGenericMethod.ImplAttributes = MethodImplAttributes.IL | MethodImplAttributes.Managed;
// Create GenericParam for !!0
someGenericMethod.GenericParameters.Add(new GenericParamUser(0, GenericParamAttributes.NonVariant, "D"));
genericSubType.Methods.Add(someGenericMethod);
// Add as nested type
genericType.NestedTypes.Add(genericSubType);
someMethod.Body = new CilBody();
someMethod.Body.Instructions.Add(OpCodes.Ret.ToInstruction());
someGenericMethod.Body = new CilBody();
someGenericMethod.Body.Instructions.Add(OpCodes.Ret.ToInstruction());
entryPoint.Body = new CilBody();
entryPoint.Body.Instructions.Add(OpCodes.Ldc_I4_0.ToInstruction());
entryPoint.Body.Instructions.Add(OpCodes.Ret.ToInstruction());
mod.Write(newFileName);
}
public static void Run()
{
// 这是将要创建的文件
string newFileName = @"ctor-test.exe";
// 创建模块
var mod = new ModuleDefUser("ctor-test", Guid.NewGuid(),
new AssemblyRefUser(new AssemblyNameInfo(typeof(int).Assembly.GetName().FullName)));
// 这是一个控制台应用程序
mod.Kind = ModuleKind.Console;
// 创建程序集并将创建的模块添加到它
new AssemblyDefUser("ctor-test", new Version(1, 2, 3, 4)).Modules.Add(mod);
// 创建System.Console类型引用
var systemConsole = mod.CorLibTypes.GetTypeRef("System", "Console");
// 创建'void System.Console.WriteLine（string，object）'方法引用
var writeLine2 = new MemberRefUser(mod, "WriteLine",
MethodSig.CreateStatic(mod.CorLibTypes.Void, mod.CorLibTypes.String,
mod.CorLibTypes.Object),
systemConsole);
// 创建System.Object ::.ctor方法引用。这是默认构造函数
var objectCtor = new MemberRefUser(mod, ".ctor",
MethodSig.CreateInstance(mod.CorLibTypes.Void),
mod.CorLibTypes.Object.TypeDefOrRef);
CilBody body;
// 创建基类
var bclass = new TypeDefUser("Ctor.Test", "BaseClass", mod.CorLibTypes.Object.TypeDefOrRef);
// 将其添加到模块中
mod.Types.Add(bclass);
// 创建Ctor.Test.Base类构造函数：Base Class（）
var bctor = new MethodDefUser(".ctor", MethodSig.CreateInstance(mod.CorLibTypes.Void),
MethodImplAttributes.IL | MethodImplAttributes.Managed,
MethodAttributes.Public |
MethodAttributes.SpecialName | MethodAttributes.RTSpecialName);
// 将方法添加到BaseClass
bclass.Methods.Add(bctor);
// 创建方法体并添加一些指令
bctor.Body = body = new CilBody();
// 确保我们调用基类的构造函数
body.Instructions.Add(OpCodes.Ldarg_0.ToInstruction());
body.Instructions.Add(OpCodes.Call.ToInstruction(objectCtor));
body.Instructions.Add(OpCodes.Ldstr.ToInstruction("BaseClass: Default .ctor called"));
body.Instructions.Add(OpCodes.Ldnull.ToInstruction());
body.Instructions.Add(OpCodes.Call.ToInstruction(writeLine2));
body.Instructions.Add(OpCodes.Ret.ToInstruction());
// 创建从Ctor.Test.BaseClass派生的Ctor.Test.Main类型
var main = new TypeDefUser("Ctor.Test", "Main", bclass);
//将其添加到模块中
mod.Types.Add(main);
//创建静态'void Main（）'方法
var entryPoint = new MethodDefUser("Main", MethodSig.CreateStatic(mod.CorLibTypes.Void),
MethodImplAttributes.IL | MethodImplAttributes.Managed,
MethodAttributes.Public | MethodAttributes.Static);
// Set entry point to entryPoint and add it as a Ctor.Test.Main method
mod.EntryPoint = entryPoint;
main.Methods.Add(entryPoint);
// Create first Ctor.Test.Main constructor: Main()
var ctor0 = new MethodDefUser(".ctor", MethodSig.CreateInstance(mod.CorLibTypes.Void),
MethodImplAttributes.IL | MethodImplAttributes.Managed,
MethodAttributes.Public |
MethodAttributes.SpecialName | MethodAttributes.RTSpecialName);
// Add the method to Main
main.Methods.Add(ctor0);
// Create method body and add a few instructions
ctor0.Body = body = new CilBody();
// Make sure we call the base class' constructor
body.Instructions.Add(OpCodes.Ldarg_0.ToInstruction());
body.Instructions.Add(OpCodes.Call.ToInstruction(bctor));
body.Instructions.Add(OpCodes.Ldstr.ToInstruction("Default .ctor called"));
body.Instructions.Add(OpCodes.Ldnull.ToInstruction());
body.Instructions.Add(OpCodes.Call.ToInstruction(writeLine2));
body.Instructions.Add(OpCodes.Ret.ToInstruction());
// Create second Ctor.Test.Main constructor: Main(int,string)
var ctor1 = new MethodDefUser(".ctor", MethodSig.CreateInstance(mod.CorLibTypes.Void, mod.CorLibTypes.Int32, mod.CorLibTypes.String),
MethodImplAttributes.IL | MethodImplAttributes.Managed,
MethodAttributes.Public |
MethodAttributes.SpecialName | MethodAttributes.RTSpecialName);
// Add the method to Main
main.Methods.Add(ctor1);
// Create names for the arguments. This is optional. Since this is an instance method
// (it's a constructor), the first arg is the 'this' pointer. The normal arguments
// begin at index 1.
ctor1.Parameters[1].CreateParamDef();
ctor1.Parameters[1].ParamDef.Name = "count";
ctor1.Parameters[2].CreateParamDef();
ctor1.Parameters[2].ParamDef.Name = "name";
// Create method body and add a few instructions
ctor1.Body = body = new CilBody();
// Make sure we call the base class' constructor
body.Instructions.Add(OpCodes.Ldarg_0.ToInstruction());
body.Instructions.Add(OpCodes.Call.ToInstruction(bctor));
body.Instructions.Add(OpCodes.Ldstr.ToInstruction(".ctor(Int32) called with arg {0}"));
body.Instructions.Add(OpCodes.Ldarg_1.ToInstruction());
body.Instructions.Add(OpCodes.Box.ToInstruction(mod.CorLibTypes.Int32));
body.Instructions.Add(OpCodes.Call.ToInstruction(writeLine2));
body.Instructions.Add(OpCodes.Ret.ToInstruction());
// Create the entry point method body and add instructions to allocate a new Main()
// object and call the two created ctors.
entryPoint.Body = body = new CilBody();
body.Instructions.Add(OpCodes.Newobj.ToInstruction(ctor0));
body.Instructions.Add(OpCodes.Pop.ToInstruction());
body.Instructions.Add(OpCodes.Ldc_I4.ToInstruction(12345));
body.Instructions.Add(OpCodes.Ldnull.ToInstruction());
body.Instructions.Add(OpCodes.Newobj.ToInstruction(ctor1));
body.Instructions.Add(OpCodes.Pop.ToInstruction());
body.Instructions.Add(OpCodes.Ret.ToInstruction());
// Save the assembly
mod.Write(newFileName);
}
public static void Run()
{
// This is the file that will be created
string newFileName = "GenericExample3.exe";
// Create the module
var mod = new ModuleDefUser("GenericExample3", Guid.NewGuid(),
new AssemblyRefUser(new AssemblyNameInfo(typeof(int).Assembly.GetName().FullName)));
// It's a console app
mod.Kind = ModuleKind.Console;
// Create the assembly and add the created module to it
new AssemblyDefUser("GenericExample3", new Version(1, 2, 3, 4)).Modules.Add(mod);
// Add the startup type. It derives from System.Object.
TypeDef 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
MethodDef 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 type with 2 generic parameters, A and B
// Would look like: public class GClass<A, B>
var genericType = new TypeDefUser("My.Namespace", "GClass", mod.CorLibTypes.Object.TypeDefOrRef);
genericType.Attributes = TypeAttributes.Public | TypeAttributes.AutoLayout |
TypeAttributes.Class | TypeAttributes.AnsiClass | TypeAttributes.BeforeFieldInit;
genericType.GenericParameters.Add(new GenericParamUser(0, GenericParamAttributes.NonVariant, "A"));
genericType.GenericParameters.Add(new GenericParamUser(1, GenericParamAttributes.NonVariant, "B"));
// Add generic type to module
mod.Types.Add(genericType);
// Note: NestedPublic instead of Public, blank namespace
// Would look like: public class GSubClass<A, B, C>
var genericSubType = new TypeDefUser("", "GSubClass", mod.CorLibTypes.Object.TypeDefOrRef);
genericSubType.Attributes = TypeAttributes.NestedPublic | TypeAttributes.AutoLayout |
TypeAttributes.Class | TypeAttributes.AnsiClass | TypeAttributes.BeforeFieldInit;
// Need to add the 2 generic parameters from the nested-parent class, A and B
genericSubType.GenericParameters.Add(new GenericParamUser(0, GenericParamAttributes.NonVariant, "A"));
genericSubType.GenericParameters.Add(new GenericParamUser(1, GenericParamAttributes.NonVariant, "B"));
// Add a generic parameter specific to this nested class, C
genericSubType.GenericParameters.Add(new GenericParamUser(2, GenericParamAttributes.NonVariant, "C"));
// public void GSubClass<A, B, C>.SomeMethod(B arg1, C arg2) { ... }
// or: public void GSubClass<!0, !1, !2>.SomeMethod(!1, !2) { ... }
var someMethod = new MethodDefUser("SomeMethod",
MethodSig.CreateInstance(mod.CorLibTypes.Void, new GenericVar(1), new GenericVar(2)));
someMethod.Attributes = MethodAttributes.Public;
someMethod.ImplAttributes = MethodImplAttributes.IL | MethodImplAttributes.Managed;
genericSubType.Methods.Add(someMethod);
// Create method with a method generic parameter (GenericMVar)
// public void GSubClass<A, B, C>.SomeOtherMethod<D>(D arg1, A arg2, C arg3) { ... }
// or: public void GSubClass<!0, !1, !2>.SomeOtherMethod<!!0>(!!0, !0, !2) { ... }
var someGenericMethod = new MethodDefUser("SomeOtherMethod",
MethodSig.CreateInstanceGeneric(1, mod.CorLibTypes.Void, new GenericMVar(0), new GenericVar(0), new GenericVar(2)));
someGenericMethod.Attributes = MethodAttributes.Public;
someGenericMethod.ImplAttributes = MethodImplAttributes.IL | MethodImplAttributes.Managed;
// Create GenericParam for !!0
someGenericMethod.GenericParameters.Add(new GenericParamUser(0, GenericParamAttributes.NonVariant, "D"));
genericSubType.Methods.Add(someGenericMethod);
// Add as nested type
genericType.NestedTypes.Add(genericSubType);
someMethod.Body = new CilBody();
someMethod.Body.Instructions.Add(OpCodes.Ret.ToInstruction());
someGenericMethod.Body = new CilBody();
someGenericMethod.Body.Instructions.Add(OpCodes.Ret.ToInstruction());
entryPoint.Body = new CilBody();
entryPoint.Body.Instructions.Add(OpCodes.Ldc_I4_0.ToInstruction());
entryPoint.Body.Instructions.Add(OpCodes.Ret.ToInstruction());
mod.Write(newFileName);
}
public static void Run()
{
// This is the file that will be created
string newFileName = @"GenericExample2.exe";
// Create the module
var mod = new ModuleDefUser("GenericExample2", Guid.NewGuid(),
new AssemblyRefUser(new AssemblyNameInfo(typeof(int).Assembly.GetName().FullName)));
// It's a console app
mod.Kind = ModuleKind.Console;
// Create the assembly and add the created module to it
new AssemblyDefUser("GenericExample2", new Version(1, 2, 3, 4)).Modules.Add(mod);
// Add the startup type. It derives from System.Object.
TypeDef 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
MethodDef 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 System.Console type reference
var systemConsole = mod.CorLibTypes.GetTypeRef("System", "Console");
// Create 'void System.Console.WriteLine(string,object)' method reference
var writeLine2 = new MemberRefUser(mod, "WriteLine",
MethodSig.CreateStatic(mod.CorLibTypes.Void, mod.CorLibTypes.String,
mod.CorLibTypes.Object),
systemConsole);
var assemblyRef = mod.CorLibTypes.AssemblyRef;
// Create 'System.Collections.ObjectModel.ReadOnlyCollection`1' type ref
var roCollectionRef = new TypeRefUser(mod, "System.Collections.ObjectModel", "ReadOnlyCollection`1", assemblyRef);
// Create 'ReadOnlyCollection<!!0>' signature for return type
var roCollectionSig = new GenericInstSig(new ClassSig(roCollectionRef), new GenericMVar(0)); // Return type
// Create 'ReadOnlyCollection<Int32>' type spec
var roCollectionTypeSpec = new TypeSpecUser(new GenericInstSig(new ClassSig(roCollectionRef), mod.CorLibTypes.Int32));
// Create 'ReadOnlyCollection<Int32>.get_Count()' method reference
var roCollectionGetCount = new MemberRefUser(mod, "get_Count",
MethodSig.CreateInstance(mod.CorLibTypes.Int32),
roCollectionTypeSpec);
// Create 'System.Array' type ref
var arrayRef = new TypeRefUser(mod, "System", "Array", assemblyRef);
// Create 'ReadOnlyCollection<T> Array.AsReadOnly<T>(T[] array)' method reference
// Apparently CreateStaticGeneric should be used only if at least one GenericMVar is used? Not 100% certain.
var asReadOnly = new MemberRefUser(mod, "AsReadOnly",
MethodSig.CreateStaticGeneric(1, roCollectionSig, new SZArraySig(new GenericMVar(0))),
arrayRef);
// Create 'Array.AsReadOnly<Int32>' method spec
var asReadOnlySpec = new MethodSpecUser(asReadOnly,
new GenericInstMethodSig(mod.CorLibTypes.Int32));
// Create 'ReadOnlyCollection<Int32>' signature for local
var roCollectionInt32 = roCollectionTypeSpec.TryGetGenericInstSig();
// Method body locals
IList<Local> locals = new List<Local>();
locals.Add(new Local(new SZArraySig(mod.CorLibTypes.Int32))); // local[0]: Int32[]
locals.Add(new Local(roCollectionInt32)); // local[1]: class [mscorlib]System.Collections.ObjectModel.ReadOnlyCollection`1<Int32>
var body = new CilBody(true, new List<Instruction>(), new List<ExceptionHandler>(), locals);
// array = new Int32[2];
body.Instructions.Add(OpCodes.Ldc_I4_2.ToInstruction());
body.Instructions.Add(OpCodes.Newarr.ToInstruction(mod.CorLibTypes.Int32));
body.Instructions.Add(OpCodes.Stloc_0.ToInstruction()); // Store array to local[0]
// array[0] = 5;
body.Instructions.Add(OpCodes.Ldloc_0.ToInstruction());
body.Instructions.Add(OpCodes.Ldc_I4_0.ToInstruction());
body.Instructions.Add(OpCodes.Ldc_I4_5.ToInstruction());
body.Instructions.Add(OpCodes.Stelem_I4.ToInstruction());
// array[1] = 111;
body.Instructions.Add(OpCodes.Ldloc_0.ToInstruction());
body.Instructions.Add(OpCodes.Ldc_I4_1.ToInstruction());
body.Instructions.Add(OpCodes.Ldc_I4.ToInstruction(111));
body.Instructions.Add(OpCodes.Stelem_I4.ToInstruction());
// collection = Array.AsReadOnly<Int32>(array)
body.Instructions.Add(OpCodes.Ldloc_0.ToInstruction());
body.Instructions.Add(OpCodes.Call.ToInstruction(asReadOnlySpec));
body.Instructions.Add(OpCodes.Stloc_1.ToInstruction());
// Console.WriteLine("Count: {0}", collection.Count)
body.Instructions.Add(OpCodes.Ldstr.ToInstruction("Count: {0}"));
body.Instructions.Add(OpCodes.Ldloc_1.ToInstruction());
body.Instructions.Add(OpCodes.Callvirt.ToInstruction(roCollectionGetCount));
body.Instructions.Add(OpCodes.Box.ToInstruction(mod.CorLibTypes.Int32));
body.Instructions.Add(OpCodes.Call.ToInstruction(writeLine2));
// return 0;
body.Instructions.Add(OpCodes.Ldc_I4_0.ToInstruction());
body.Instructions.Add(OpCodes.Ret.ToInstruction());
entryPoint.Body = body;
// Save the assembly
mod.Write(newFileName);
}
public static void Run()
{
// This is the file that will be created
string newFileName = @"GenericExample1.exe";
// Create the module
var mod = new ModuleDefUser("GenericExample1", Guid.NewGuid(),
new AssemblyRefUser(new AssemblyNameInfo(typeof(int).Assembly.GetName().FullName)));
// It's a console app
mod.Kind = ModuleKind.Console;
// Create the assembly and add the created module to it
new AssemblyDefUser("GenericExample1", new Version(1, 2, 3, 4)).Modules.Add(mod);
// Add the startup type. It derives from System.Object.
TypeDef 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
MethodDef 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 System.Console type reference
var systemConsole = mod.CorLibTypes.GetTypeRef("System", "Console");
// Create 'void System.Console.WriteLine(string,object)' method reference
var writeLine2 = new MemberRefUser(mod, "WriteLine",
MethodSig.CreateStatic(mod.CorLibTypes.Void, mod.CorLibTypes.String,
mod.CorLibTypes.Object),
systemConsole);
//
// Method 1: Create List<String> inst signature by importing (easy way)
// --------------------------------------------------------------------
//Importer importer = new Importer(mod);
//var listGenericInstSig = importer.ImportAsTypeSig(typeof(System.Collections.Generic.List<String>));
//
// Method 2: Create List<String> inst signature manually (harder way)
// ------------------------------------------------------------------
var assemblyRef = mod.CorLibTypes.AssemblyRef;
var listRef = new TypeRefUser(mod, @"System.Collections.Generic", "List`1", assemblyRef);
// Create the GenericInstSig from a ClassSig with <String> generic arg
var listGenericInstSig = new GenericInstSig(new ClassSig(listRef), mod.CorLibTypes.String);
// Create TypeSpec from GenericInstSig
var listTypeSpec = new TypeSpecUser(listGenericInstSig);
// Create System.Collections.Generic.List<String>::.ctor method reference
var listCtor = new MemberRefUser(mod, ".ctor", MethodSig.CreateInstance(mod.CorLibTypes.Void),
listTypeSpec);
// Create Add(!0) method reference, !0 signifying first generic argument of declaring type
// In this case, would be Add(String item)
// (GenericMVar would be used for method generic argument, such as Add<!!0>(!!0))
var listAdd = new MemberRefUser(mod, "Add",
MethodSig.CreateInstance(mod.CorLibTypes.Void, new GenericVar(0)),
listTypeSpec);
var listGetCount = new MemberRefUser(mod, "get_Count",
MethodSig.CreateInstance(mod.CorLibTypes.Int32),
listTypeSpec);
IList<Local> locals = new List<Local>();
locals.Add(new Local(listGenericInstSig)); // local[0]: class [mscorlib]System.Collections.Generic.List`1<string>
var body = new CilBody(true, new List<Instruction>(), new List<ExceptionHandler>(), locals);
// Call the list .ctor
body.Instructions.Add(OpCodes.Newobj.ToInstruction(listCtor));
body.Instructions.Add(OpCodes.Stloc_0.ToInstruction()); // Store list to local[0]
// list.Add("Item 1")
body.Instructions.Add(OpCodes.Ldloc_0.ToInstruction());
body.Instructions.Add(OpCodes.Ldstr.ToInstruction("Item 1"));
body.Instructions.Add(OpCodes.Callvirt.ToInstruction(listAdd));
// WriteLine("Array: {0}", list.ToArray());
//body.Instructions.Add(OpCodes.Ldstr.ToInstruction("Array: {0}"));
//body.Instructions.Add(OpCodes.Ldloc_0.ToInstruction()); // Load list from local[0]
//body.Instructions.Add(OpCodes.Callvirt.ToInstruction(listToArray));
//body.Instructions.Add(OpCodes.Call.ToInstruction(writeLine2));
// WriteLine("Count: {0}", list.Count)
body.Instructions.Add(OpCodes.Ldstr.ToInstruction("Count: {0}"));
body.Instructions.Add(OpCodes.Ldloc_0.ToInstruction()); // Load list from local[0]
body.Instructions.Add(OpCodes.Callvirt.ToInstruction(listGetCount));
body.Instructions.Add(OpCodes.Box.ToInstruction(mod.CorLibTypes.Int32));
body.Instructions.Add(OpCodes.Call.ToInstruction(writeLine2));
// return 0;
body.Instructions.Add(OpCodes.Ldc_I4_0.ToInstruction());
body.Instructions.Add(OpCodes.Ret.ToInstruction());
entryPoint.Body = body;
// Save the assembly
mod.Write(newFileName);
}
public static void Run()
{
// This is the file that will be created
string newFileName = @"GenericExample1.exe";
// Create the module
var mod = new ModuleDefUser("GenericExample1", Guid.NewGuid(),
new AssemblyRefUser(new AssemblyNameInfo(typeof(int).Assembly.GetName().FullName)));
// It's a console app
mod.Kind = ModuleKind.Console;
// Create the assembly and add the created module to it
new AssemblyDefUser("GenericExample1", new Version(1, 2, 3, 4)).Modules.Add(mod);
// Add the startup type. It derives from System.Object.
TypeDef 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
MethodDef 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 System.Console type reference
var systemConsole = mod.CorLibTypes.GetTypeRef("System", "Console");
// Create 'void System.Console.WriteLine(string,object)' method reference
var writeLine2 = new MemberRefUser(mod, "WriteLine",
MethodSig.CreateStatic(mod.CorLibTypes.Void, mod.CorLibTypes.String,
mod.CorLibTypes.Object),
systemConsole);
//
// Method 1: Create List<String> inst signature by importing (easy way)
// --------------------------------------------------------------------
//Importer importer = new Importer(mod);
//var listGenericInstSig = importer.ImportAsTypeSig(typeof(System.Collections.Generic.List<String>));
//
// Method 2: Create List<String> inst signature manually (harder way)
// ------------------------------------------------------------------
var assemblyRef = mod.CorLibTypes.AssemblyRef;
var listRef = new TypeRefUser(mod, @"System.Collections.Generic", "List`1", assemblyRef);
// Create the GenericInstSig from a ClassSig with <String> generic arg
var listGenericInstSig = new GenericInstSig(new ClassSig(listRef), mod.CorLibTypes.String);
// Create TypeSpec from GenericInstSig
var listTypeSpec = new TypeSpecUser(listGenericInstSig);
// Create System.Collections.Generic.List<String>::.ctor method reference
var listCtor = new MemberRefUser(mod, ".ctor", MethodSig.CreateInstance(mod.CorLibTypes.Void),
listTypeSpec);
// Create Add(!0) method reference, !0 signifying first generic argument of declaring type
// In this case, would be Add(String item)
// (GenericMVar would be used for method generic argument, such as Add<!!0>(!!0))
var listAdd = new MemberRefUser(mod, "Add",
MethodSig.CreateInstance(mod.CorLibTypes.Void, new GenericVar(0)),
listTypeSpec);
var listGetCount = new MemberRefUser(mod, "get_Count",
MethodSig.CreateInstance(mod.CorLibTypes.Int32),
listTypeSpec);
IList <Local> locals = new List <Local>();
locals.Add(new Local(listGenericInstSig)); // local[0]: class [mscorlib]System.Collections.Generic.List`1<string>
var body = new CilBody(true, new List <Instruction>(), new List <ExceptionHandler>(), locals);
// Call the list .ctor
body.Instructions.Add(OpCodes.Newobj.ToInstruction(listCtor));
body.Instructions.Add(OpCodes.Stloc_0.ToInstruction()); // Store list to local[0]
// list.Add("Item 1")
body.Instructions.Add(OpCodes.Ldloc_0.ToInstruction());
body.Instructions.Add(OpCodes.Ldstr.ToInstruction("Item 1"));
body.Instructions.Add(OpCodes.Callvirt.ToInstruction(listAdd));
// WriteLine("Array: {0}", list.ToArray());
//body.Instructions.Add(OpCodes.Ldstr.ToInstruction("Array: {0}"));
//body.Instructions.Add(OpCodes.Ldloc_0.ToInstruction()); // Load list from local[0]
//body.Instructions.Add(OpCodes.Callvirt.ToInstruction(listToArray));
//body.Instructions.Add(OpCodes.Call.ToInstruction(writeLine2));
// WriteLine("Count: {0}", list.Count)
body.Instructions.Add(OpCodes.Ldstr.ToInstruction("Count: {0}"));
body.Instructions.Add(OpCodes.Ldloc_0.ToInstruction()); // Load list from local[0]
body.Instructions.Add(OpCodes.Callvirt.ToInstruction(listGetCount));
body.Instructions.Add(OpCodes.Box.ToInstruction(mod.CorLibTypes.Int32));
body.Instructions.Add(OpCodes.Call.ToInstruction(writeLine2));
// return 0;
body.Instructions.Add(OpCodes.Ldc_I4_0.ToInstruction());
body.Instructions.Add(OpCodes.Ret.ToInstruction());
entryPoint.Body = body;
// Save the assembly
mod.Write(newFileName);
}
protected override void Pack(ConfuserContext context, ProtectionParameters parameters)
{
var ctx = context.Annotations.Get<CompressorContext>(context, ContextKey);
if (ctx == null) {
context.Logger.Error("No executable module!");
throw new ConfuserException(null);
}
ModuleDefMD originModule = context.Modules[ctx.ModuleIndex];
ctx.OriginModuleDef = originModule;
var stubModule = new ModuleDefUser(ctx.ModuleName, originModule.Mvid, originModule.CorLibTypes.AssemblyRef);
ctx.Assembly.Modules.Insert(0, stubModule);
stubModule.Characteristics = originModule.Characteristics;
stubModule.Cor20HeaderFlags = originModule.Cor20HeaderFlags;
stubModule.Cor20HeaderRuntimeVersion = originModule.Cor20HeaderRuntimeVersion;
stubModule.DllCharacteristics = originModule.DllCharacteristics;
stubModule.EncBaseId = originModule.EncBaseId;
stubModule.EncId = originModule.EncId;
stubModule.Generation = originModule.Generation;
stubModule.Kind = ctx.Kind;
stubModule.Machine = originModule.Machine;
stubModule.RuntimeVersion = originModule.RuntimeVersion;
stubModule.TablesHeaderVersion = originModule.TablesHeaderVersion;
stubModule.Win32Resources = originModule.Win32Resources;
ImportAssemblyTypeReferences(originModule, stubModule);
InjectStub(context, ctx, parameters, stubModule);
var snKey = context.Annotations.Get<StrongNameKey>(originModule, Marker.SNKey);
using (var ms = new MemoryStream()) {
stubModule.Write(ms, new ModuleWriterOptions(stubModule, new KeyInjector(ctx)) {
StrongNameKey = snKey
});
context.CheckCancellation();
ProtectStub(context, context.OutputPaths[ctx.ModuleIndex], ms.ToArray(), snKey, new StubProtection(ctx, originModule));
}
}
protected override void Pack(ConfuserContext context, ProtectionParameters parameters)
{
var ctx = context.Annotations.Get <CompressorContext>(context, ContextKey);
if (ctx == null)
{
context.Logger.Error("No executable module!");
throw new ConfuserException(null);
}
ModuleDefMD originModule = context.Modules[ctx.ModuleIndex];
ctx.OriginModuleDef = originModule;
var stubModule = new ModuleDefUser(ctx.ModuleName, originModule.Mvid, originModule.CorLibTypes.AssemblyRef);
if (ctx.CompatMode)
{
var assembly = new AssemblyDefUser(originModule.Assembly);
assembly.Name += ".cr";
assembly.Modules.Add(stubModule);
var targetFramework = originModule.Assembly.CustomAttributes.FirstOrDefault(ca => ca.TypeFullName == "System.Runtime.Versioning.TargetFrameworkAttribute");
if (targetFramework != null)
{
var attrType = stubModule.CorLibTypes.GetTypeRef("System.Runtime.Versioning", "TargetFrameworkAttribute");
var ctorSig = MethodSig.CreateInstance(stubModule.CorLibTypes.Void, stubModule.CorLibTypes.String);
assembly.CustomAttributes.Add(new CustomAttribute(
new MemberRefUser(stubModule, ".ctor", ctorSig, attrType), new CAArgument[] { new CAArgument(stubModule.CorLibTypes.String, targetFramework.ConstructorArguments[0].Value) }));
}
}
else
{
ctx.Assembly.Modules.Insert(0, stubModule);
ImportAssemblyTypeReferences(originModule, stubModule);
}
stubModule.Characteristics = originModule.Characteristics;
stubModule.Context = originModule.Context;
stubModule.Cor20HeaderFlags = originModule.Cor20HeaderFlags;
stubModule.Cor20HeaderRuntimeVersion = originModule.Cor20HeaderRuntimeVersion;
stubModule.DllCharacteristics = originModule.DllCharacteristics;
stubModule.EncBaseId = originModule.EncBaseId;
stubModule.EncId = originModule.EncId;
stubModule.Generation = originModule.Generation;
stubModule.Kind = ctx.Kind;
stubModule.Machine = originModule.Machine;
stubModule.RuntimeVersion = originModule.RuntimeVersion;
stubModule.TablesHeaderVersion = originModule.TablesHeaderVersion;
stubModule.Win32Resources = originModule.Win32Resources;
InjectStub(context, ctx, parameters, stubModule);
var snKey = context.Annotations.Get <StrongNameKey>(originModule, Marker.SNKey);
var snPubKey = context.Annotations.Get <StrongNamePublicKey>(originModule, Marker.SNPubKey);
var snDelaySig = context.Annotations.Get <bool>(originModule, Marker.SNDelaySig, false);
var snSigKey = context.Annotations.Get <StrongNameKey>(originModule, Marker.SNSigKey);
var snPubSigKey = context.Annotations.Get <StrongNamePublicKey>(originModule, Marker.SNSigPubKey);
using (var ms = new MemoryStream()) {
var options = new ModuleWriterOptions(stubModule)
{
StrongNameKey = snKey,
StrongNamePublicKey = snPubKey,
DelaySign = snDelaySig
};
var injector = new KeyInjector(ctx);
options.WriterEvent += injector.WriterEvent;
stubModule.Write(ms, options);
context.CheckCancellation();
ProtectStub(context, context.OutputPaths[ctx.ModuleIndex], ms.ToArray(), snKey, snPubKey, snSigKey, snPubKey, snDelaySig, new StubProtection(ctx, originModule));
}
}
