unicorn net

Unicorn.Net

Etwas ausgefalleneres WIP .NET-Binding/Wrapper für die Unicorn-Engine.

NOTIZ

Die API ist derzeit sehr anfällig für Änderungen.

Beispiele

Hier ist ein Beispiel für die Verwendung. Dies ist auch das gleiche Beispiel wie die hier verfügbare offizielle Dokumentation, jedoch in C# und unter Verwendung von Unicorn.Net.

 using ( var emulator = new X86Emulator ( X86Mode . b32 ) )
{
    ulong addr = 0x1000000 ;
    byte [ ] x86code =
    {
        0x41 , // INC ECX
        0x4a  // DEC EDX
    } ;

    var ecx = 0x1234 ;
    var edx = 0x7890 ;

    // Map 2mb of memory.
    emulator . Memory . Map ( addr , 2 * 1024 * 1024 , MemoryPermissions . All ) ;

    emulator . Registers . ECX = ecx ;
    emulator . Registers . EDX = edx ;

    emulator . Memory . Write ( addr , x86code , x86code . Length ) ;

    emulator . Start ( addr , addr + ( ulong ) x86code . Length ) ;

    Console . WriteLine ( emulator . Registers . ECX ) ;
    Console . WriteLine ( emulator . Registers . EDX ) ;
} 

Registriert

Lesen und Schreiben in Register.

NOTIZ

Derzeit gibt es keine Möglichkeit, mithilfe von Register-IDs in Register zu schreiben, dies kann sich jedoch ändern.

 // Assume emulator is an instance of the X86Emulator type.

// Reading from registers.
var val = emulator . Registers . ECX ;
// Writing to registers.
emulator . Registers . ECX = 0x10 ; 

Erinnerung

Zuordnen, Aufheben der Zuordnung, Lesen, Schreiben und Ändern von Speicherberechtigungen.

 var addr = 0x100000 ;
// Getting memory regions.
var regions = emulator . Memory . Regions ;
// Getting memory page size.
var pageSize = emulator . Memory . PageSize ;

// Mapping memory.
emulator . Memory . Map ( addr , 2 * 1024 , 2 * 1024 , MemoryPermissions . All ) ;
// Unmapping memory.
emulator . Memory . Unmap ( addr + ( 4 * 1024 ) , 4 * 1024 ) ;
// Changing memory permissions.
emulator . Memory . Protect ( addr + ( 4 * 1024 ) , 4 * 1024 , MemoryPermissions . Read ) ;

// Code to write to memory.
var code = new byte [ ]
{
    0x41 , // INC ECX
    0x4a  // DEC EDX
}

// Buffer thats going to be the storage for data read from memory.
var buffer = new byte [ 2 ] ;

// Writing to memory.
emulator . Memory . Write ( code , 0 , code . Length ) ;
// Reading to memory.
emulator . Memory . Read ( buffer , 0 , buffer . Length ) ; 

Haken

Derzeit ist das Hooking noch in Arbeit und kann sich ändern.

 // Adding a memory read hook.
emulator . Hooks . Memory . Add ( MemoryHookType . Read , ( emu , type , address , size , val , userData ) => {
    Console . WriteLine ( " stuff was read from memory." ) ;
} , addr , addr + ( ulong ) code . Length , null ) ; 

Kontexte

Kontexte erfassen und wiederherstellen.

 // emulator.Context will create a new Context object
// which you will to dispose afterwards. Hence the `using` statement.

// Capturing the context.
using ( var ctx = emulator . Context )
{
    .. .
    
    // To restore the context simply do this.
    emulator . Context = ctx ;
} 

Rohe Bindungen

Unicorn.Net stellt über die Bindings -Klasse auch einige Rohbindungen bereit.

 var bindings = new Bindings ( ) ;
bindings . Open ( .. . ) ;
bindings . MemMap ( .. . ) ;
.. .

TODO

Liste der Dinge, die implementiert werden müssen oder implementiert wurden.

• Emulator

  • uc_emu_start
  • uc_emu_stop
  • uc_query

• Kontext

  • uc_context_alloc
  • uc_context_save
  • uc_context_restore

• Registriert

  • uc_reg_read
  • uc_reg_write

• Erinnerung

  • uc_mem_write
  • uc_mem_read
  • uc_mem_protect
  • uc_mem_regions
  • uc_mem_map
  • uc_mem_unmap

• Haken

  • uc_hook_add
  • uc_hook_del

• Bögen

  • x86
  • Arm
  • arm64
  • m68k
  • mips
  • sparc

• Tatsächliche Bindungen

Lizenzierung

Unicorn.Net ist unter der freizügigen MIT-Lizenz lizenziert.