如何从已加载的程序集中提取类IL代码并将其保存到磁盘? [英] How to extract class IL code from loaded assembly and save to disk?

问题描述

我将如何提取在运行时通过反射生成的类的IL代码，以便将其保存到磁盘上?如果可能的话.我无法控制生成这些类的代码.

How would I go about extracting the IL code for classes that are generated at runtime by reflection so I can save it to disk? If at all possible. I don't have control of the piece of code that generates these classes.

最终，我想将此IL代码从磁盘加载到另一个程序集中.

Eventually, I would like to load this IL code from disk into another assembly.

我知道我可以序列化/反序列化类，但是我希望使用纯IL代码.我对安全隐患不屑一顾.

I know I could serialise/deserialise classes but I wish to use purely IL code. I'm not fussed with the security implications.

运行Mono 2.10.1

Running Mono 2.10.1

推荐答案

或者更好的方法是使用Mono.Cecil.

Or better yet, use Mono.Cecil.

它使您可以获取单独的说明，甚至可以进行操作和拆卸(使用单反编译器添加).

It will allow you to get at the individual instructions, even manipulating them and disassembling them (with the mono decompiler addition).

请注意，反编译器仍在开发中(上次我检查它是否不完全支持lambda表达式和Visual Basic异常块)，但是只要不打到C#，就可以很容易地在C#中反编译输出.这些边界条件.此后，工作也取得了进展.

Note that the decompiler is a work in progress (last time I checked it did not fully support lambda expressions and Visual Basic exception blocks), but you can have pretty decompiled output in C# pretty easily as far as you don't hit these boundary conditions. Also, work has progressed since.

通常，Mono Cecil还可以将IL写入新程序集，然后，如果您想发挥优势，可以随后将其加载到您的appdomain中.

Mono Cecil in general let's you write the IL to a new assembly, as well, which you can then subsequently load into your appdomain if you like to play with bleeding edge.

更新，我来尝试一下.不幸的是，我认为我发现了您遇到的问题.事实证明，似乎没有办法获得生成类型的IL字节，除非程序集碰巧被写出了可以从其加载的位置.

Update I came round to trying this. Unfortunately I think I found what problem you run into. It turns out there is seems to be no way to get at the IL bytes for a generated type unless the assembly happened to get written out somewhere you can load it from.

我假设您可以通过反射来获取这些位(因为这些类支持所需的方法)，但是相关的方法只会在调用时引发异常The invoked member is not supported in a dynamic module..您可以使用下面的代码进行尝试，但是简而言之，我想这意味着它不会发生，除非您要

I assumed you could just get the bits via reflection (since the classes support the required methods), however the related methods just raise an exception The invoked member is not supported in a dynamic module. on invocation. You can try this with the code below, but in short I suppose it means that it ain't gonna happen unless you want to f*ck with Marshal::GetFunctionPointerForDelegate(). You'd have to binary dump the instructions and manually disassemble them as IL opcodes. There be dragons.

代码段:

using System;
using System.Linq;
using Mono.Cecil;
using Mono.Cecil.Cil;
using System.Reflection.Emit;
using System.Reflection;

namespace REFLECT
{
    class Program
    {
        private static Type EmitType()
        {
            var dyn = AppDomain.CurrentDomain.DefineDynamicAssembly(new AssemblyName("Emitted"), AssemblyBuilderAccess.RunAndSave);
            var mod = dyn.DefineDynamicModule("Emitted", "Emitted.dll");
            var typ = mod.DefineType("EmittedNS.EmittedType", System.Reflection.TypeAttributes.Public);
            var mth = typ.DefineMethod("SuperSecretEncryption", System.Reflection.MethodAttributes.Public | System.Reflection.MethodAttributes.Static, typeof(String), new [] {typeof(String)});

            var il = mth.GetILGenerator();
            il.EmitWriteLine("Emit was here");
            il.Emit(System.Reflection.Emit.OpCodes.Ldarg_0);    
            il.Emit(System.Reflection.Emit.OpCodes.Ret);
            var result = typ.CreateType();
            dyn.Save("Emitted.dll");
            return result;
        }

        private static Type TestEmit()
        {
            var result = EmitType();
            var instance = Activator.CreateInstance(result);
            var encrypted = instance.GetType().GetMethod("SuperSecretEncryption").Invoke(null, new [] { "Hello world" });
            Console.WriteLine(encrypted); // This works happily, print "Emit was here" first

            return result;
        }

        public static void Main (string[] args)
        {
            Type emitted = TestEmit();

              // CRASH HERE: even if the assembly was actually for SaveAndRun _and_ it 
              // has actually been saved, there seems to be no way to get at the image
              // directly:
            var ass = AssemblyFactory.GetAssembly(emitted.Assembly.GetFiles(false)[0]);

              // the rest was intended as mockup on how to isolate the interesting bits
              // but I didn't get much chance to test that :)
            var types = ass.Modules.Cast<ModuleDefinition>().SelectMany(m => m.Types.Cast<TypeDefinition>()).ToList();
            var typ = types.FirstOrDefault(t => t.Name == emitted.Name);

            var operands = typ.Methods.Cast<MethodDefinition>()
                .SelectMany(m => m.Body.Instructions.Cast<Instruction>())
                .Select(i => i.Operand);

            var requiredTypes = operands.OfType<TypeReference>()
                .Concat(operands.OfType<MethodReference>().Select(mr => mr.DeclaringType))
                .Select(tr => tr.Resolve()).OfType<TypeDefinition>()
                .Distinct();
            var requiredAssemblies = requiredTypes
                .Select(tr => tr.Module).OfType<ModuleDefinition>()
                .Select(md => md.Assembly.Name as AssemblyNameReference);

            foreach (var t in types.Except(requiredTypes))
                ass.MainModule.Types.Remove(t);

            foreach (var unused in ass.MainModule
                     .AssemblyReferences.Cast<AssemblyNameReference>().ToList()
                     .Except(requiredAssemblies))
                ass.MainModule.AssemblyReferences.Remove(unused);

            AssemblyFactory.SaveAssembly(ass, "/tmp/TestCecil.dll");
        }
    }
}

这篇关于如何从已加载的程序集中提取类IL代码并将其保存到磁盘?的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！