Diassemblieren

Einleitung

Das Disassemblieren ist der Prozess, bei dem aus Maschinencode wieder menschenlesbarer Assembler-Code erzeugt wird. Es ist ein wichtiges Werkzeug für:

• Debugging: Nachvollziehen, was das Programm tatsächlich macht.
• Reverse Engineering: Verstehen fremder Binärdateien.
• Optimierung: Erkennen ineffizienter Codeabschnitte.
• Lernen: Verstehen, wie Hochsprachen wie C übersetzt werden.

Werkzeuge

Für ARM64 unter Linux – z. B. auf dem Raspberry Pi – bieten sich diese Tools an:

objdump

Teil von `binutils`. Zeigt dir den Assembler-Code aus Objektdateien oder Binärprogrammen an. Dies ist auch meine bevorzugte Art, um etwas zu Diassemblieren.

objdump -d ./program

Optionen:

• `-d` disassembliert ausführbare Abschnitte.
• `-M reg-names=std` (optional): zeigt Standard-Registerbezeichnungen (x0–x30).
• `-M no-aliases` (zeigt die "echten" Instruktionsnamen statt Pseudonyme).

Beispiel:

objdump -d -M reg-names=std ./program

gdb

Mit `gdb` (GNU Debugger) kannst du direkt im Programmfluss disassemblieren.

gdb ./program
(gdb) disassemble _start

Praktische Tipps

• Möchtest du den Code in einem Editor ansehen, kannst du die Ausgabe in eine Datei leiten:

objdump -d -M reg-names=std ./program > program.diassem

• Achte auf die Sectionen: `.text` ist der Code, andere wie `.data` oder `.bss` enthalten keine Instruktionen.
• Prüfe, ob deine Datei nicht mit Strip bearbeitet wurde (`strip` entfernt Debugsymbole).
• Wenn du aus einer reinen Binärdatei (ohne ELF-Header) disassemblieren willst, nutze `objdump` mit `--target binary` und `--architecture aarch64`.

Beispiel:

objdump -D -b binary -m aarch64 your.bin

Worauf achten?

• Alignment: ARM64 nutzt 4-Byte ausgerichtete Instruktionen.
• Branch-Adressen: Bei `b`, `bl`, `cbz`, `ret` und Co. kannst du nachvollziehen, wo dein Programm hin springt.
• System Calls: erkenne z. B. `mov x8, #93; svc 0` als `exit(0)`.
• Speicherzugriffe: beachte, welche Register für Adressierung verwendet werden.

`objdump` im Detail: Parameter und ihre Bedeutung

`objdump` ist ein sehr vielseitiges Werkzeug. Besonders beim Disassemblieren von ARM64-Binärdateien ist es hilfreich, die wichtigsten Optionen zu kennen.

Grundstruktur des Befehls

objdump [OPTIONEN] DATEI

Wichtige Optionen beim Disassemblieren

Option	Beschreibung
`-d`	Disassembliert alle **ausführbaren Segmente** (z. B. `.text`).
`-D`	Disassembliert **die gesamte Datei**, auch nicht-ausführbare Abschnitte. Nützlich bei rohen Binärdateien oder unüblichen Formaten.
`-M <option>`	Legt das Disassemblierungsformat fest. Mehrere Optionen sind durch Kommas trennbar (z. B. `-M reg-names=std,no-aliases`).
`--section=<name>`	Disassembliert **nur eine bestimmte Sektion**, z. B. `.text`.
`--start-address=0xADDR`	Beginnt das Disassemblieren **ab dieser Adresse**.
`--stop-address=0xADDR`	Hört bei dieser Adresse auf.
`--architecture=aarch64`	Setzt die Architektur explizit, z. B. bei rohen Binärdateien.
`-b binary`	Interpretiert die Datei als **rohe Binärdaten** (keine ELF-Struktur).
`-s`	Rohdaten anzeigen

Beispiele für ARM64

Einfaches Disassemblieren

objdump -d ./program

Ohne Register-Aliase (z. B. `wzr` statt `w0`)

objdump -d -M no-aliases ./program

Mit klassischen Register-Namen (x0–x30)

objdump -d -M reg-names=std ./program

Nur `.text`-Sektion

objdump -d --section=.text ./program

Disassemblieren roher Binärdaten

Wenn du z. B. ein 1:1-Memory-Dump oder reinen Maschinencode ohne ELF-Struktur hast:

objdump -D -b binary -m aarch64 yourfile.bin

Option `-M` im Detail

`-M` steht für **Disassembler-Modifikatoren** – mehrere können kombiniert werden:

• `no-aliases`

Zeigt dir "echte" Instruktionen, keine Vereinfachungen.

> Beispiel: Statt `mov x0, x1` sieht man `orr x0, x1, xzr`.

• `reg-names=std`

Standardregister (x0–x30, sp, pc).

• `reg-names=raw`

Zeigt numerische Register: `r0`, `r1`, ...

• `reg-names=apcs`

Zeigt Register gemäß dem **ARM Procedure Call Standard** (z. B. `a1`, `v1`, `fp`, `lr`).

Die `-s` Option: Rohdaten anzeigen

Die Option `-s` (kurz für `--full-contents`) zeigt den "Hexdump des gesamten Inhalts" der Datei, geordnet nach Sektionen.

Beispiel:

objdump -s ./program

Beispielausgabe:

Contents of section .text:
 0000 52800000 d2800021 d2800442 d2800003  R...!...B....
 0010 d2800004 8b030084 d2800025 d2800026  .........%...&

Bedeutung:

• Linke Spalte: Offset innerhalb der Sektion.
• Rechte Spalten: Hex-Werte der Bytes.
• Ganz rechts (manchmal): ASCII-Darstellung, wenn druckbar.

Kombination mit `-d` und `-s`

Oft ist es sinnvoll, `-d` und `-s` "gemeinsam" zu nutzen – z. B., um zu sehen, wie ein Maschinenbefehl wirklich kodiert ist:

objdump -ds ./program

Oder: gezielt auf eine bestimmte Sektion fokussieren:

objdump -s --section=.rodata ./program

So kannst du "Strings, Konstanten oder Sprungtabellen" sichtbar machen, die nicht disassembliert, aber trotzdem mitverarbeitet werden.

Zusammenfassung – wann `-s` nützlich ist:

• Debugging von Konstanten/Strings: Gibt Einblick in `.rodata`, `.data`, `.bss` etc.
• Verstehen von Maschineninstruktionen: Hex-Werte → ARM64-Opcode
• Analyse von Binärdateien ohne Symbole: Du siehst trotzdem, "was im Speicher liegt"
• Reverse Engineering: Hex-Dumps helfen, Kontrollstrukturen und Datenlayout zu erkennen

Tipps:

• Nur Funktionssymbol disassemblieren

Wenn du Symbole hast (nicht `strip` benutzt):

objdump -d ./blink --disassemble=_start

• Wenn deine Datei keine Symbole enthält, verwende zusätzlich `nm` oder `readelf`, um Adressen herauszufinden.
• Kombiniere `objdump` mit `grep` zur gezielten Analyse:

  objdump -d ./blink | grep "<_start>"

Negative Zahlen beim Disassemblieren mit `objdump`

1. Immediates werden hexadezimal dargestellt

`objdump` zeigt "sofortige Werte (Immediates)" standardmäßig in "Hexadezimalform" – unabhängig davon, ob es sich ursprünglich um negative Zahlen handelte.

• Beispiel (Assemblercode):

mov x0, #-1

• Disassemblierung:

mov x0, #0xffffffffffffffff

- `#-1` wird als `0xFFFFFFFFFFFFFFFF` dargestellt. - Das ist die **Zweierkomplement-Darstellung** von `-1` in 64 Bit.

2. Offsets bei Sprüngen und Speicherzugriffen

"Branches", "LOAD/STORE-Offsets" oder Stackzugriffe können negative Offsets haben. Ob `objdump` das als negativ darstellt, hängt vom Befehl ab – oft wird auch hier nur der "Zweierkomplementwert" in Hex gezeigt.

• Beispiel:

ldur x0, [sp, #-16]

• Disassemblierung:

ldur x0, [sp, #-0x10]

Hier ist `objdump` klug genug, das tatsächlich als "negativen Offset" anzuzeigen!

Aber: Das klappt "nicht bei allen Instruktionen"! Manchmal musst du selbst das Offset interpretieren.

3. Unsignierte Darstellung in Datenfeldern

Bei Verwendung von `objdump -s` (Hexdump der Daten) werden "alle Bytes als unsigned" dargestellt – also es gibt "keine negativen Zahlen" im Dump selbst, nur 0–255 (0x00–0xFF).

• Beispiel:

.int32 -42

objdump -s -j .data a.out

• Disassemblierung:

d6 ff ff ff

Das ist `0xFFFFFFD6`, also `-42` als "signed 32-Bit" im Zweierkomplement.