Warum ist es so einfach .NET IL-Code zu dekompilieren?

Question

Warum ist es so einfach, .NET IL-Code in dem Quellcode, im Vergleich zu decompiling nativen x86-Binärdateien zu dekompilieren? (Reflektor produziert recht gut Quellcode die meiste Zeit, während decompiling die Ausgabe eines C ++ Compiler ist fast unmöglich.)

Ist es, weil IL viele Meta-Daten enthält? Oder ist es, weil IL eine höhere Abstraktion als x86-Befehle ist? Ich habe einige Nachforschungen und fand die folgenden zwei nützliche Artikel, aber keiner von ihnen beantwortet meine Frage.

• MSIL Decompiler Theorie
• C Decompiler - Schnell-Primer

Answer 1

Ich glaube, Sie bereits die wichtigsten Bits haben.

• Wie Sie sagen, es gibt noch mehr Metadaten zur Verfügung. Ich weiß nicht, die Details von dem, was von einem C oder C ++ Compiler emittiert wird, aber ich vermute, weit mehr Namen und ähnliche Informationen sind in IL enthalten. Schauen Sie sich nur, was der Decompiler weiß über das, was in einem bestimmten Stapelrahmen, zum Beispiel - so weit wie die x86 betrifft, so wissen Sie nur, wie der Stapel verwendet ; in IL wissen Sie, was der Inhalt des Stapels darstellen (oder zumindest die Art - nicht die semantische Bedeutung)
• Auch hier, wie Sie bereits erwähnt haben, IL ist eine höhere Abstraktion als x86. x86 hat keine Ahnung, was für ein Verfahren oder Funktionsaufruf ist, oder ein Ereignis oder eine Eigenschaft usw. IL hat all diese Informationen immer noch in sie.
• Typischerweise C und C ++ Compiler optimieren viel stärker als (sagen wir) den C # -Compiler. Dies liegt daran, der C # -Compiler geht davon aus, dass die meisten der Optimierung kann noch später durchgeführt werden - durch den JIT. In gewisser Weise ist es sinnvoll für den C # -Compiler nicht versuchen, viel Optimierung zu tun, da es verschiedene Bits an Informationen gibt, die an den JIT verfügbar sind, aber nicht der C # -Compiler. Optimiertem Code ist schwieriger zu dekompilieren, weil es von weiter weg ist eine natürliche Darstellung des ursprünglichen Quellcodes zu sein.
• IL wurde entwickelt, JIT-kompiliert werden; x86 entwickelt wurde nativ ausgeführt werden (allerdings über Mikro-Code). Die Informationen der JIT-Compiler benötigt, ist ähnlich derjenigen, die ein Decompiler möchte, so ein Decompiler hat eine einfachere Zeit mit IL. In gewisser Weise ist dies wirklich nur eine Neuformulierung des zweiten Punktes.

Answer 2

Es gibt eine Reihe von Dingen, die Reverse-Engineering-il ziemlich einfach zu machen.

• Geben Sie Informationen. Dies ist massiv. In x86-Assembler, müssen Sie die Variablentypen ableiten, je nachdem, wie sie verwendet werden.

• Struktur. Informationen über die Struktur der Anwendung ist in il Demontagen zur Verfügung. Dies, kombiniert mit Typinformationen, gibt Ihnen eine erstaunliche Menge an Daten. Sie arbeiten auf ein ziemlich hohes Niveau an dieser Stelle (bezogen auf x86-Assembler). In nativen Assembler, haben Sie das Struktur-Layout (und auch die Tatsache, dass sie Strukturen sind) abzuleiten, basierend darauf, wie die Daten verwendet werden. Nicht unmöglich, aber viel mehr Zeit in Anspruch.

• Namen. die Namen der Dinge zu wissen, kann nützlich sein.

Diese Dinge, kombiniert, bedeutet, dass Sie eine ganze Menge von Daten über die ausführbare Datei. Il ist grundsätzlich auf einem Niveau arbeiten viel näher an der Quelle als ein Compiler von nativen Code wäre. Das höhere Niveau die Bytecode arbeitet an, das einfache Reverse-Engineering ist, allgemein gesprochen.

Answer 3

C # und IL fast Karte Eins-zu-eins. (Dies ist weniger so mit einigen neueren C # 3.0-Features.) Die Nähe der Abbildung (und das Fehlen eines Optimierer in der C # Compiler) macht die Dinge so ‚reversibel‘.

Answer 4

Erweitern von Brians richtigen Antwort

Wenn Sie alle IL denken leicht rückübersetzbar ist, schlage ich vor, eine nicht-triviale F # Programm zu schreiben und versuchen, diesen Code zu dekompilieren. F # hat eine Menge Code-Transformationen und hat daher eine sehr schlechte Zuordnung von dem tatsächlichen emittieren IL und die ursprüngliche Codebasis. IMHO ist es wesentlich schwieriger bei dekompilierten F # Code zu suchen und das ursprüngliche Programm zurück, als es für C # oder VB.Net ist.