Diassemblieren - Versionsgeschichte

Satyria am 10. April 2025 um 16:01 Uhr

2025-04-10T16:01:44Z

← Nächstältere Version		Version vom 10. April 2025, 17:01 Uhr
Zeile 188:		Zeile 188:
	</syntaxhighlight>		</syntaxhighlight>

			== 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):
			: <syntaxhighlight lang="asm">
			mov x0, #-1
			</syntaxhighlight>

			* Disassemblierung:
			: <syntaxhighlight lang="shell">
			mov x0, #0xffffffffffffffff
			</syntaxhighlight>

			- `#-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:
			: <syntaxhighlight lang="asm">
			ldur x0, [sp, #-16]
			</syntaxhighlight>

			* Disassemblierung:
			: <syntaxhighlight lang="shell">
			ldur x0, [sp, #-0x10]
			</syntaxhighlight>

			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:
			: <syntaxhighlight lang="C">
			.int32 -42
			</syntaxhighlight>

			: <syntaxhighlight lang="shell">
			objdump -s -j .data a.out
			</syntaxhighlight>

			* Disassemblierung:
			: <syntaxhighlight lang="shell">
			d6 ff ff ff
			</syntaxhighlight>

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









	~~== Diassemblieren ==~~
	~~-> objdump -s -d HelloWorld.o > HelloWorld.diassem~~



	~~Hello.o: file format elf64-littleaarch64~~

	~~Contents of section .text:~~
	~~0000 200080d2 e1000058 a20180d2 080880d2 ......X........~~
	~~0010 010000d4 000080d2 a80b80d2 010000d4 ................~~
	~~0020 00000000 00000000 ........~~
	~~Contents of section .data:~~
	~~0000 48656c6c 6f20576f 726c6421 0a Hello World!.~~

	~~Disassembly of section .text:~~

	~~0000000000000000 <_start>:~~
	~~0: d2800020 mov x0, #0x1 // #1~~
	~~4: 580000e1 ldr x1, 20 <_start+0x20>~~
	~~8: d28001a2 mov x2, #0xd // #13~~
	~~c: d2800808 mov x8, #0x40 // #64~~
	~~10: d4000001 svc #0x0~~
	~~14: d2800000 mov x0, #0x0 // #0~~
	~~18: d2800ba8 mov x8~~, ~~#0x5d // #93~~
	~~1c: d4000001 svc #0x0~~
	~~...~~


	~~== negative Zahlen ==~~
	-~~> Beispiel: 5 + -3~~
	~~3 in 1 byte is 0x03 or 0000 0011.~~
	~~Inverting the bits is~~
	~~1111 1100~~
	~~Add 1 to get~~
	~~1111 1101 = 0xFD~~
	~~Now add~~
	~~5 + 0xFD = 0x102 = 2~~

	~~movadd.o: file format elf64~~-~~littleaarch64~~

	~~Contents of section .text:~~
	~~0000 001980d2 812580d2 0200018b a00080d2 ..~~.~~..%..........~~
	~~0010 41008092 0200018b 000080d2 a80b80d2 A...............~~
	~~0020 010000d4 ....~~

	~~Disassembly of section .text:~~

	~~0000000000000000 <_start>:~~
	~~0: d2801900 mov x0, #0xc8 // #200~~
	~~4: d2802581 mov x1, #0x12c // #300~~
	~~8: 8b010002 add x2, x0, x1~~
	~~c: d28000a0 mov x0, #0x5 // #5~~
	~~10: 92800041 mov x1, #0xfffffffffffffffd // #-3~~
	~~14: 8b010002 add x2, x0, x1~~
	~~18: d2800000 mov x0, #0x0 // #0~~
	~~1c: d2800ba8 mov x8, #0x5d // #93~~
	~~20: d4000001 svc #0x0~~

Satyria am 10. April 2025 um 15:34 Uhr

2025-04-10T15:34:26Z

← Nächstältere Version		Version vom 10. April 2025, 16:34 Uhr
Zeile 92:		Zeile 92:
	==== Einfaches Disassemblieren ====		==== Einfaches Disassemblieren ====
	<syntaxhighlight lang="shell">		<syntaxhighlight lang="shell">
	objdump -d ./~~blink~~		objdump -d ./program
	</syntaxhighlight>		</syntaxhighlight>

	==== Ohne Register-Aliase (z. B. `wzr` statt `w0`) ====		==== Ohne Register-Aliase (z. B. `wzr` statt `w0`) ====
	<syntaxhighlight lang="shell">		<syntaxhighlight lang="shell">
	objdump -d -M no-aliases ./~~blink~~		objdump -d -M no-aliases ./program
	</syntaxhighlight>		</syntaxhighlight>

	==== Mit klassischen Register-Namen (x0–x30) ====		==== Mit klassischen Register-Namen (x0–x30) ====
	<syntaxhighlight lang="shell">		<syntaxhighlight lang="shell">
	objdump -d -M reg-names=std ./~~blink~~		objdump -d -M reg-names=std ./program
	</syntaxhighlight>		</syntaxhighlight>

	==== Nur `.text`-Sektion ====		==== Nur `.text`-Sektion ====
	<syntaxhighlight lang="shell">		<syntaxhighlight lang="shell">
	objdump -d --section=.text ./~~blink~~		objdump -d --section=.text ./program
	</syntaxhighlight>		</syntaxhighlight>

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

	---		=== Die `-s` Option: Rohdaten anzeigen ===

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

	~~Die Option `~~-s~~` (kurz für `--full-contents`) zeigt den Hexdump des gesamten Inhalts der Datei, geordnet nach Sektionen~~.		==== Beispiel: ====
			<syntaxhighlight lang="shell">
			objdump -s ./program
			</syntaxhighlight>

	~~### Beispiel:~~		==== Beispielausgabe: ====
	~~```bash~~		<syntaxhighlight lang="shell">
	~~objdump -s ./blink~~
	~~```~~

	~~###~~ Beispielausgabe:
	~~```text~~
	Contents of section .text:		Contents of section .text:
	0000 52800000 d2800021 d2800442 d2800003 R...!...B....		0000 52800000 d2800021 d2800442 d2800003 R...!...B....
	0010 d2800004 8b030084 d2800025 d2800026 .........%...&		0010 d2800004 8b030084 d2800025 d2800026 .........%...&
	~~```~~		</syntaxhighlight>

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

	---		=== Kombination mit `-d` und `-s` ===

	~~## 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:

	~~Oft ist es sinnvoll, `-d` und `-s` gemeinsam zu nutzen – z. B., um zu sehen, wie ein Maschinenbefehl wirklich kodiert ist:~~		<syntaxhighlight lang="shell">
			objdump -ds ./program
	~~```bash~~		</syntaxhighlight>
	objdump -ds ./~~blink~~
	~~```~~

	Oder: gezielt auf eine bestimmte Sektion fokussieren:		Oder: gezielt auf eine bestimmte Sektion fokussieren:
	~~```bash~~		<syntaxhighlight lang="shell">
	objdump -s --section=.rodata ./~~blink~~		objdump -s --section=.rodata ./program
	~~```~~		</syntaxhighlight>

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

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

	~~## 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

	~~\| Situation \| Warum `-s` sinnvoll ist \|~~		Tipps:
	~~\|----------\|--------------------------\|~~		* Nur Funktionssymbol disassemblieren
	~~\| Debugging von Konstanten/Strings \| Gibt Einblick in `.rodata`, `.data`, `.bss` etc. \|~~		: Wenn du Symbole hast (nicht `strip` benutzt):
	~~\| Verstehen von Maschineninstruktionen \| Hex-Werte → ARM64-Opcode \|~~		: <syntaxhighlight lang="shell">
	\| Analyse von Binärdateien ohne Symbole \| Du siehst trotzdem, was im Speicher liegt \|
	~~\| Reverse Engineering \| Hex-Dumps helfen, Kontrollstrukturen und Datenlayout zu erkennen \|~~

	~~---~~

	~~### Bonus:~~ Nur Funktionssymbol disassemblieren

	Wenn du Symbole hast (nicht `strip` benutzt):
	~~```bash~~
	objdump -d ./blink --disassemble=_start		objdump -d ./blink --disassemble=_start
	~~```~~		</syntaxhighlight>
			* Wenn deine Datei keine Symbole enthält, verwende zusätzlich `nm` oder `readelf`, um Adressen herauszufinden.
	~~---~~		* Kombiniere `objdump` mit `grep` zur gezielten Analyse:
			: <syntaxhighlight lang="shell">
	~~### Abschluss: Tipps~~

	- Wenn deine Datei keine Symbole enthält, verwende zusätzlich `nm` oder `readelf`, um Adressen herauszufinden.
	- Kombiniere `objdump` mit `grep` zur gezielten Analyse:
	~~```bash~~
	objdump -d ./blink \| grep "<_start>"		objdump -d ./blink \| grep "<_start>"
	~~```~~		</syntaxhighlight>

Satyria am 10. April 2025 um 15:20 Uhr

2025-04-10T15:20:23Z

← Nächstältere Version		Version vom 10. April 2025, 16:20 Uhr
Zeile 88:		Zeile 88:
	\|}		\|}

	~~---~~		=== Beispiele für ARM64 ===

	~~### Beispiele für ARM64~~		==== Einfaches Disassemblieren ====
			<syntaxhighlight lang="shell">
	~~####~~ Einfaches Disassemblieren
	~~```bash~~
	objdump -d ./blink		objdump -d ./blink
	~~```~~		</syntaxhighlight>

	~~####~~ Ohne Register-Aliase (z. B. `wzr` statt `w0`)		==== Ohne Register-Aliase (z. B. `wzr` statt `w0`) ====
	~~```bash~~		<syntaxhighlight lang="shell">
	objdump -d -M no-aliases ./blink		objdump -d -M no-aliases ./blink
	~~```~~		</syntaxhighlight>

	~~####~~ Mit klassischen Register-Namen (x0–x30)		==== Mit klassischen Register-Namen (x0–x30) ====
	~~```bash~~		<syntaxhighlight lang="shell">
	objdump -d -M reg-names=std ./blink		objdump -d -M reg-names=std ./blink
	~~```~~		</syntaxhighlight>

	~~####~~ Nur `.text`-Sektion		==== Nur `.text`-Sektion ====
	~~```bash~~		<syntaxhighlight lang="shell">
	objdump -d --section=.text ./blink		objdump -d --section=.text ./blink
	~~```~~		</syntaxhighlight>

	~~####~~ Disassemblieren roher Binärdaten		==== Disassemblieren roher Binärdaten ====
	Wenn du z. B. ein 1:1-Memory-Dump oder reinen Maschinencode ohne ELF-Struktur hast:		Wenn du z. B. ein 1:1-Memory-Dump oder reinen Maschinencode ohne ELF-Struktur hast:
	~~```bash~~		<syntaxhighlight lang="shell">
	objdump -D -b binary -m aarch64 yourfile.bin		objdump -D -b binary -m aarch64 yourfile.bin
	~~```~~		</syntaxhighlight>

	~~---~~

	~~###~~ Option `-M` im Detail		=== Option `-M` im Detail ===

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

	- `no-aliases`		* `no-aliases`
	Zeigt dir "echte" Instruktionen, keine Vereinfachungen.		: Zeigt dir "echte" Instruktionen, keine Vereinfachungen.
	> Beispiel: Statt `mov x0, x1` sieht man `orr x0, x1, xzr`.		: > Beispiel: Statt `mov x0, x1` sieht man `orr x0, x1, xzr`.

	- `reg-names=std`		* `reg-names=std`
	Standardregister (x0–x30, sp, pc).		: Standardregister (x0–x30, sp, pc).

	- `reg-names=raw`		* `reg-names=raw`
	Zeigt numerische Register: `r0`, `r1`, ...		: Zeigt numerische Register: `r0`, `r1`, ...

	- `reg-names=apcs`		* `reg-names=apcs`
	Zeigt Register gemäß dem ARM Procedure Call Standard (z. B. `a1`, `v1`, `fp`, `lr`).		: Zeigt Register gemäß dem ARM Procedure Call Standard (z. B. `a1`, `v1`, `fp`, `lr`).

	---		---

Satyria am 10. April 2025 um 15:12 Uhr

2025-04-10T15:12:26Z

← Nächstältere Version		Version vom 10. April 2025, 16:12 Uhr
Zeile 13:		Zeile 13:
	Teil von `binutils`. Zeigt dir den Assembler-Code aus Objektdateien oder Binärprogrammen an. Dies ist auch meine bevorzugte Art, um etwas zu Diassemblieren.		Teil von `binutils`. Zeigt dir den Assembler-Code aus Objektdateien oder Binärprogrammen an. Dies ist auch meine bevorzugte Art, um etwas zu Diassemblieren.
	<syntaxhighlight lang="shell">		<syntaxhighlight lang="shell">
	objdump -d ./~~blink~~		objdump -d ./program
	</syntaxhighlight>		</syntaxhighlight>

Zeile 23:		Zeile 23:
	Beispiel:		Beispiel:
	<syntaxhighlight lang="shell">		<syntaxhighlight lang="shell">
	objdump -d -M reg-names=std ./~~blink~~		objdump -d -M reg-names=std ./program
	</syntaxhighlight>		</syntaxhighlight>

Zeile 29:		Zeile 29:
	Mit `gdb` (GNU Debugger) kannst du direkt im Programmfluss disassemblieren.		Mit `gdb` (GNU Debugger) kannst du direkt im Programmfluss disassemblieren.
	<syntaxhighlight lang="shell">		<syntaxhighlight lang="shell">
	gdb ./~~blink~~		gdb ./program
	(gdb) disassemble _start		(gdb) disassemble _start
	</syntaxhighlight>		</syntaxhighlight>

	== Praktische Tipps ==		== Praktische Tipps ==
			* Möchtest du den Code in einem Editor ansehen, kannst du die Ausgabe in eine Datei leiten:
			<syntaxhighlight lang="shell">
			objdump -d -M reg-names=std ./program > program.diassem
			</syntaxhighlight>
	* Achte auf die ''Sectionen'': `.text` ist der Code, andere wie `.data` oder `.bss` enthalten keine Instruktionen.		* 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).		* Prüfe, ob deine Datei ''nicht mit Strip'' bearbeitet wurde (`strip` entfernt Debugsymbole).
Zeile 62:		Zeile 65:
	=== Wichtige Optionen beim Disassemblieren ===		=== Wichtige Optionen beim Disassemblieren ===

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

	---		---

Satyria am 10. April 2025 um 12:36 Uhr

2025-04-10T12:36:14Z

Änderungen zeigen

Satyria am 8. April 2025 um 06:41 Uhr

2025-04-08T06:41:23Z

← Nächstältere Version		Version vom 8. April 2025, 07:41 Uhr
Zeile 25:		Zeile 25:
	1c: d4000001 svc #0x0		1c: d4000001 svc #0x0
	...		...


			== negative Zahlen ==
			-> Beispiel: 5 + -3
			3 in 1 byte is 0x03 or 0000 0011.
			Inverting the bits is
			1111 1100
			Add 1 to get
			1111 1101 = 0xFD
			Now add
			5 + 0xFD = 0x102 = 2

			movadd.o: file format elf64-littleaarch64

			Contents of section .text:
			0000 001980d2 812580d2 0200018b a00080d2 .....%..........
			0010 41008092 0200018b 000080d2 a80b80d2 A...............
			0020 010000d4 ....

			Disassembly of section .text:

			0000000000000000 <_start>:
			0: d2801900 mov x0, #0xc8 // #200
			4: d2802581 mov x1, #0x12c // #300
			8: 8b010002 add x2, x0, x1
			c: d28000a0 mov x0, #0x5 // #5
			10: 92800041 mov x1, #0xfffffffffffffffd // #-3
			14: 8b010002 add x2, x0, x1
			18: d2800000 mov x0, #0x0 // #0
			1c: d2800ba8 mov x8, #0x5d // #93
			20: d4000001 svc #0x0

Satyria: Die Seite wurde neu angelegt: „== Diassemblieren == -> objdump -s -d HelloWorld.o > HelloWorld.diassem Hello.o: file format elf64-littleaarch64 Contents of section .text: 0000 200080d2 e1000058 a20180d2 080880d2 ......X........ 0010 010000d4 000080d2 a80b80d2 010000d4 ................ 0020 00000000 00000000 ........ Contents of section .data: 0000 48656c6c 6f20576f 726c6421 0a Hello World!. Disassembly of section .text: 000000000000…“

2025-04-08T06:39:32Z

Die Seite wurde neu angelegt: „== Diassemblieren == -> objdump -s -d HelloWorld.o > HelloWorld.diassem Hello.o: file format elf64-littleaarch64 Contents of section .text: 0000 200080d2 e1000058 a20180d2 080880d2 ......X........ 0010 010000d4 000080d2 a80b80d2 010000d4 ................ 0020 00000000 00000000 ........ Contents of section .data: 0000 48656c6c 6f20576f 726c6421 0a Hello World!. Disassembly of section .text: 000000000000…“

Neue Seite

== Diassemblieren ==
-> objdump -s -d HelloWorld.o > HelloWorld.diassem

Hello.o: file format elf64-littleaarch64

Contents of section .text:
0000 200080d2 e1000058 a20180d2 080880d2 ......X........
0010 010000d4 000080d2 a80b80d2 010000d4 ................
0020 00000000 00000000 ........
Contents of section .data:
0000 48656c6c 6f20576f 726c6421 0a Hello World!.

Disassembly of section .text:

0000000000000000 <_start>:
0: d2800020 mov x0, #0x1 // #1
4: 580000e1 ldr x1, 20 <_start+0x20>
8: d28001a2 mov x2, #0xd // #13
c: d2800808 mov x8, #0x40 // #64
10: d4000001 svc #0x0
14: d2800000 mov x0, #0x0 // #0
18: d2800ba8 mov x8, #0x5d // #93
1c: d4000001 svc #0x0
...