Gibt es gute VB / C # x86 Disassembler Bibliotheken? [geschlossen]

Question

Ich bin für eine Bibliothek, die x86-Code in eine Art Objektmodell zerlegen wird, dass ich dann Routinen schreiben kann, die den Code zu analysieren. Ich bin in einer Bibliothek nicht daran interessiert, die x86-Code konvertiert Zerlegung in Text - ich habe gefunden mehr als ein paar von denen, aber sie sind nicht so nützlich, da ich einige Arbeit auf dem Code tun wollen, dass ich zu zerlegen . Oh, und ich mag es .NET-Code (VB oder C # vorzuziehen).

sein

Answer 1

Reflector tun x86 nicht so weit ich weiß.

Ihre beste Wette wird mit dem Scripting oder COM-Schnittstelle an OllyDbg oder IDA Pro .

Ich würde empfehlen, IDA Pro, wenn Sie es sich leisten können. IDA hat eine sehr reiche API, die aktive Entwicklung und viele Dokumentation. Sie können es im autonomen Modus laufen, ich glaube, die ‚-AS‘ Schalter. Siehe http://www.hex-rays.com/idapro/idadoc/417 HTM für weitere Informationen über die Befehlszeilenargumente.

Ich lief auch in libdasm , aber es nie benutzt, so dass nicht sicher, wie gut es ist. libdasm sieht aus wie C / C ++, so dass es einfach sein sollte, einen API-Wrapper in C # zu schreiben.

Answer 2

Eine alte Frage, aber wenn jemand kommt sonst entlang und Sie sind nach einer 100% C # .NET-Implementierung statt Interop verwenden, SharpDisasm bietet einen x86 / x86-64 Disassembler zu Intel und AT & T-Syntax. Er dekodiert jeden Befehl auf ein Objekt, das Zugriff auf Low-Level-Informationen über die Befehl (z.B. Befehlsgröße, Operanden Anzahl und Arten usw.).

liefert

SharpDisasm ist ein Full-C # Hafen von der libudis86 C-Bibliothek Disassembler.

Die Disassembler durch die SharpDisam.Disassembler Klasse ausgesetzt ist.

Ausgabe von der mitgelieferten Beispiel-Konsole App:

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, als einige Zeit vergangen ist.
Ja, es gibt tatsächlich mehrere.

Capstone.NET ist so ziemlich Feature-complete (libcapsone-Port ARM, ARM64 (aka ARMv8 / AArch64), M68K, Mips, PowerPC, Sparc, systemz, XCore, X86 (einschließlich X86_64). Es unterstützt die meisten modernen CPU-Erweiterungen ):
https://github.com/9ee1/Capstone.NET
http://www.capstone-engine.org/features.html
(MIT Lizenz)

Dann wird, wie bereits erwähnt, gibt es SharpDisasm (libudis-Port):
https://sharpdisasm.codeplex.com/
(Vereinfachtes BSD-Lizenz (BSD))

Dann gibt es Reko (x86-DECOMPILER)
https://github.com/uxmal/reko
(GNU General Public License)

Es gibt ElfSharp ELF-Dateien zu lesen:
https://github.com/konrad-kruczynski/elfsharp
(MIT & LLVM-Lizenz)

oder das PE-Format wie folgt lauten:
http://code.cheesydesign.com/?p=572

oder mit PETools:
https://github.com/jsok/PETools
(MIT-Lizenz)

Es gibt auch ein Werkzeug lib Dateien zu überprüfen:
https://github.com/BlazingHeart/SymbolExplorer

Es gibt auch eine x86-Assembler-Bibliothek:
https://code.google.com/p/managed-x86/

Und die ELF-Hashing-Funktion
https://damieng.com/ Blog / 2007/11/24 / Berechnungs-elf-32-in-c-und-net
Außerdem gibt es eine eigene Seite bei wikibooks:
https://en.wikibooks.org/wiki/X86_Disassembly/Disassemblers_and_Decompilers

Es gibt auch die Schneemann-Decompiler, die Capstone verwendet:
https://github.com/yegord/snowman

Es gibt auch eine vollständig verwaltete x86-Assembler: https://github.com/meikeric/managed-x86