Esistono buone librerie di disassemblatori VB/C# x86?

Question

Sto cercando una libreria che smonti il ​​codice x86 in una sorta di modello a oggetti che posso quindi utilizzare per scrivere routine che analizzano il codice. Non sono interessato a una libreria che converte il codice x86 in smontaggio di testo: ne ho trovato più di alcuni, ma non sono così utili dal momento che voglio lavorare sul codice che ho smontato . Oh, e mi piacerebbe che fosse. Codice netto (preferibile VB o C#).

Answer 1

Reflector non esegue x86 per quanto ne so.

La soluzione migliore è utilizzare lo script o l'interfaccia COM su OllyDbg o IDA Pro.

Consiglierei IDA Pro se te lo puoi permettere. IDA ha un'API molto ricca, uno sviluppo attivo e molta documentazione. Puoi eseguirlo in modalità autonoma, credo che usi l'opzione '-AS'. Vedi http://www.hex-rays.com/idapro/idadoc/417.htm per maggiori informazioni sugli argomenti della riga di comando.

Ho anche corse in libdasm, ma mai usato, quindi non so quanto è buono. libdasm sembra C/C++ quindi dovrebbe essere semplice scrivere un wrapper API in C#.

Answer 2

una vecchia questione, ma se qualcun altro arriva e tu sei dopo un'implementazione .NET C# 100% invece di usare Interop, SharpDisasm fornisce un x86/x86-64 disassembler sia Intel e AT & sintassi T. Decodifica ogni istruzione per un oggetto che fornisce l'accesso a informazioni di basso livello sull'istruzione (ad esempio dimensioni dell'istruzione, numero di operandi e tipi ecc.).

SharpDisasm è un porto pieno C# del disassembler libudis86 C-biblioteca.

Il disassembler è esposta attraverso la classe SharpDisam.Disassembler.

output dell'esempio console app fornito:

C:\>echo a1 c9 fd ff ff a1 37 02 00 00 b8 37 02 00 00 b4 09 8a 
25 09 00 00 00 8b 04 6d 85 ff ff ff 89 45 f0| disasmcli 32 

00000000 a1 c9 fd ff ff     mov eax, [0xfffffdc9] 
00000005 a1 37 02 00 00     mov eax, [0x237] 
0000000a b8 37 02 00 00     mov eax, 0x237 
0000000f b4 09       mov ah, 0x9 
00000011 8a 25 09 00 00 00    mov ah, [0x9] 
00000017 8b 04 6d 85 ff ff ff   mov eax, [ebp*2-0x7b] 
0000001e 89 45 f0      mov [ebp-0x10], eax 

C:\>echo 488b05f7ffffff67668b40f06766035e1048030425ffff 
000067660344bef04c0384980000008048a10000000000800000 | disasmcli 64 

0000000000000000 48 8b 05 f7 ff ff ff   mov rax, [rip-0x9] 
0000000000000007 67 66 8b 40 f0     mov ax, [eax-0x10] 
000000000000000c 67 66 03 5e 10     add bx, [esi+0x10] 
0000000000000011 48 03 04 25 ff ff 00 00  add rax, [0xffff] 
0000000000000019 67 66 03 44 be f0    add ax, [esi+edi*4-0x10] 
000000000000001f 4c 03 84 98 00 00 00 80  add r8, [rax+rbx*4-0x80000000] 
0000000000000027 48 a1 00 00 00 00 00 80 00 00 mov rax, [0x800000000000] 

Answer 3

Necromancing, come un po 'di tempo è passato.
Sì, ce ne sono in realtà diversi.

Capstone.NET è praticamente feature-complete (ARM libcapsone-port, ARM64 (aka ARMv8/AArch64), M68K, Mips, PowerPC, Sparc, Systemz, XCore, X86 (compreso x86_64).Supporta la maggior parte estensioni CPU moderne):
https://github.com/9ee1/Capstone.NET
http://www.capstone-engine.org/features.html
(MIT licenza)

Poi, come già detto, non v'è SharpDisasm (libudis-port):
https://sharpdisasm.codeplex.com/
(semplificato Licenza BSD (BSD))

Poi c'è Reko (x86-DECOMPILER)
https://github.com/uxmal/reko
(GNU General Pu BLIC License)

C'è ElfSharp per leggere i file ELF:
https://github.com/konrad-kruczynski/elfsharp
(MIT & LLVM License)

O leggere il formato PE in questo modo:
http://code.cheesydesign.com/?p=572

o utilizzando PETools:
https://github.com/jsok/PETools
(MIT License)

C'è anche uno strumento per controllare i file lib:
https://github.com/BlazingHeart/SymbolExplorer

C'è anche una libreria x86 assembler:
https://code.google.com/p/managed-x86/

E la funzione ELF hashing
https://damieng.com/blog/2007/11/24/calculating-elf-32-in-c-and-net


In più c'è una pagina dedicata at wikibooks:
https://en.wikibooks.org/wiki/X86_Disassembly/Disassemblers_and_Decompilers

C'è anche il pupazzo di neve-decompilatore, che utilizza Capstone:
https://github.com/yegord/snowman