referencia - ¿Es posible ejecutar una secuencia de ensamblaje x86 desde C#?

n50 ensamblaje

Question

Continuando con mi educación de ingeniería inversa, a menudo he querido poder copiar partes del código ensamblador x86 y llamarlo desde un lenguaje de alto nivel de mi elección para realizar pruebas.

¿Alguien sabe de un método para llamar a una secuencia de instrucciones x86 desde un método C #? Sé que esto se puede hacer usando C ++ pero tengo curiosidad si se puede hacer en C #?

Nota: No estoy hablando de ejecutar instrucciones MSIL. Estoy hablando de ejecutar una serie de instrucciones de ensamblaje x86 en bruto.

Answer 1

Creo que puede agregar un proyecto administrado de C ++ a su solución y exponer el método con el uso de instrucciones asm. Puede hacer referencia a ese proyecto desde cualquier proyecto .Net (no solo C #), de modo que puede llamar a ese método desde allí.

Answer 2

No, pero puede escribir ensamblados en C ++ y llamarlos desde C #. Mira este ejemplo .

Answer 3

Sí, mira mi respuesta detallada here
La parte principal es: (Sin ninguna P / invocación o referencia externa)

public static unsafe int? InjectAndRunX86ASM(this Func<int> del, byte[] asm)
{
    if (del != null)
        fixed (byte* ptr = &asm[0])
        {
            FieldInfo _methodPtr = typeof(Delegate).GetField("_methodPtr", BindingFlags.NonPublic | BindingFlags.Instance);
            FieldInfo _methodPtrAux = typeof(Delegate).GetField("_methodPtrAux", BindingFlags.NonPublic | BindingFlags.Instance);

            _methodPtr.SetValue(del, ptr);
            _methodPtrAux.SetValue(del, ptr);

            return del();
        }
    else
        return null;
}

Que se puede usar de la siguiente manera:

Func<int> del = () => 0;
byte[] asm_bytes = new byte[] { 0xb8, 0x15, 0x03, 0x00, 0x00, 0xbb, 0x42, 0x00, 0x00, 0x00, 0x03, 0xc3 };
// mov eax, 315h
// mov ebx, 42h
// add eax, ebx
// ret

int? res = del.InjectAndRunX86ASM(asm_bytes); // should be 789 + 66 = 855

Answer 4

Sí.

Simplemente use P / Invoke en las funciones de winapi.

WriteProcessMemory o encuentra el puntero a tu buffer. Habilite el bit de ejecución en la página (no recuerde la función para esto).

CreateThread en el puntero. WaitForObject (si quieres que sea de un solo hilo).

Answer 5

Solo para contrarrestar el reclamo de Brian, se reescribió el código del link respuesta de Leppie:

using System;
using System.Collections.Generic;
using System.Runtime.InteropServices;

namespace DynamicX86
{
    class Program
    {
        const uint PAGE_EXECUTE_READWRITE = 0x40;
        const uint MEM_COMMIT = 0x1000;

        [DllImport("kernel32.dll", SetLastError = true)]
        static extern IntPtr VirtualAlloc(IntPtr lpAddress, uint dwSize, uint flAllocationType, uint flProtect);

        private delegate int IntReturner();

        static void Main(string[] args)
        {
            List<byte> bodyBuilder = new List<byte>();
            bodyBuilder.Add(0xb8);
            bodyBuilder.AddRange(BitConverter.GetBytes(42));
            bodyBuilder.Add(0xc3);
            byte[] body = bodyBuilder.ToArray();
            IntPtr buf = VirtualAlloc(IntPtr.Zero, (uint)body.Length, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
            Marshal.Copy(body, 0, buf, body.Length);

            IntReturner ptr = (IntReturner)Marshal.GetDelegateForFunctionPointer(buf, typeof(IntReturner));
            Console.WriteLine(ptr());
        }
    }
}