Eine kurze Einführung in Reverse Engineering

rebel1725@tilde.club (Rebel Zhang) — Sat, 16 May 2026 19:37:05 +0800

In den vergangenen Wochen habe ich x86_64-Assembler, AArch64-Assembler und verschiedene Grundlagen gelernt. Vor Kurzem hatte ich endlich meine allererste Erfahrung mit Reverse Engineering. Ich freue mich, mehr Einzelheiten über meine Erfahrung zu teilen.

Was ist Reverse Engineering

Ein Computer ist in Wirklichkeit eine ziemlich dumme Maschine. Er löst kein Problem von selbst; er führt nur die Lösung aus — genauer gesagt führt er nur die Anweisungen von Menschen nacheinander und in der Reihenfolge aus. Um mit so einer Maschine ein Problem zu lösen, gehen wir typischerweise so vor:

ein Problem analysieren;
eine Lösung für dieses Problem finden;
die Lösung durch das Entwerfen eines Algorithmus umsetzen;
den Algorithmus durch das Schreiben von Code umsetzen;
aus dem Code durch Kompilieren das ausführbare Programm erzeugen;
dieses ausführbare Programm der dummen Maschine übergeben, damit sie das Problem löst.

Das ist ein Verfahren, bei dem die Lösung in Code und dann in Anweisungen umgewandelt wird.

Gewöhnlich können wir leicht verstehen, was ein Programm tut, indem wir den Code lesen. Das ist der Mittelweg zwischen der Lösung und den Anweisungen. In den 1970er Jahren wurde Code meist unter Menschen geteilt, damit jede Person Lösungen innerhalb der Gemeinschaft studieren, verbessern und weitergeben konnte.

Seit dem Auftauchen dieser äusserst bösen Monster der Entwicklung proprietärer Software hat sich das jedoch geändert. Sie verweigern dem Volk den Zugang zum Code, nehmen den Nutzerinnen und Nutzern die Kontrolle über ihre Rechner ab, bauen allerlei bösartige Funktionen ein, um ihre Nutzer auszubeuten, und nutzen alle möglichen Methoden, um zu verbergen, was ihre Programme tun — die Lösung. Sie errichten Barrieren. Sie zerstören das Teilen. Sie schaffen Katastrophen und Verzweiflung. Sie tun alles gegen das Volk, die Gemeinschaft und die Menschheit. All das tun sie für ihre unethischen und ungerechten Profite.

Software sollte dem Volk dienen, nicht den unethischen und ungerechten Profiten der Kapitalisten. Doch gerade diese unethischen und ungerechten Entwickler proprietärer Software, die niemals existieren sollten und aus der Welt ausgemerzt werden müssten, machen die Welt schlechter. Aber wir können proprietäre Software nicht auf einmal beseitigen. Wir entwickeln dafür freie Ersatzlösungen und nehmen die Kontrolle über das Rechnen schrittweise zurück.

Deshalb ist es an der Zeit, das oben beschriebene Verfahren in umgekehrter Reihenfolge durchzuführen. Mit anderen Worten:

wir analysieren das ausführbare Programm;
wir versuchen, den Code wiederherzustellen, den das ausführbare Programm ausführt;
wir finden den Algorithmus, den der Code umsetzt;
wir kehren die Lösung um, die der Algorithmus umsetzt;
wir implementieren die Lösung neu, um das Problem zu lösen.

Das ist die Umwandlung von Anweisungen in Code und dann in Lösung.

Die Praxis, so etwas in umgekehrter Reihenfolge zu tun, heisst Reverse Engineering, auch RE genannt.

Warum Reverse Engineering wichtig ist

Der wichtigste Grund, warum Reverse Engineering wichtig ist, besteht darin, dass es uns hilft, freie Betriebssysteme wie postmarketOS und LineageOS auf verschiedene Geräte zu portieren. Das ist auch der Hauptgrund, warum ich Reverse Engineering lerne.

Auf Desktop-PCs ist Softwarefreiheit viel leichter zu erreichen, da wir normalerweise alle möglichen freien GNU/Linux-Distributionen ohne ernsthafte Probleme ausführen können. Auf Mobilgeräten wie Smartphones oder Tablets ist das jedoch nicht der Fall.

Diese Geräte haben oft viele herstellerspezifische und gerätespezifische Anpassungen, und es ist fast unmöglich, eine Einheitslösung zu finden, um ein freies Betriebssystem universell auf solchen Geräten zum Laufen zu bringen. Noch schlimmer ist, dass die Hersteller diese technischen Details zu verbergen wählen, und selbst Google hat sich entschieden, die Gerätetrees und Hersteller-Binärblobs nicht mehr zu veröffentlichen. Daher müssen wir jetzt die binären Firmware-Blobs analysieren und ihre Logik ableiten, um postmarketOS, LineageOS oder andere freie Betriebssysteme auf diesen Geräten zum Laufen zu bringen.

Tatsächlich arbeitet auch die Free Software Foundation unter dem Projekt Librephone an diesem Problem. Dieses Projekt kann ohne Reverse Engineering nicht fortgeführt werden.

Die Anwendung von Reverse Engineering ist allerdings keineswegs auf das Portieren freier Betriebssysteme beschränkt. Es ist auch von grosser Bedeutung für:

das Herausfinden der Einzelheiten proprietärer Protokolle,
das Finden von Beweisen für bösartige Funktionen in proprietärer Software,
das Umgehen von Digital Restrictions Management,
und vieles mehr.

Wie man Reverse Engineering macht

Typisches Reverse Engineering besteht aus diesen zwei Schritten:

Das ausführbare Programm in Assembler umwandeln; dieser Prozess heisst Disassemblieren.
Durch das Lesen des Assemblercodes versuchen, die Ideen wiederherzustellen oder gleichwertigen Code neu zu schreiben.

Wir können dies direkt am ausführbaren Programm tun, ohne es auszuführen; das nennt man statische Analyse, oder während es ausgeführt wird; das nennt man dynamische Analyse.

Beispiel für statische Analyse

Nehmen wir dieses Beispiel:

#include <stdio.h>
#include <string.h>

const char *PASS = "weakpasswd";

int main()
{
    char buf[64];
    for (int i = 0; i < 3; i++)
    {
        printf("%d verbleibende Versuche.\nPasswort: ", 3 - i);
        fgets(buf, sizeof buf, stdin);
        if (strncmp(PASS, buf, strlen(PASS)))
            puts("Falsches Passwort!\n");
        else
        {
            puts("Richtig!\nWillkommen in der Welt "
                 "des Reverse Engineering!\n");
            break;
        }
    }
    return 0;
}

Kompilieren Sie dies mit GCC:

$ gcc -o ./demo ./demo.c

Öffnen Sie das ausführbare Programm in radare2:

$ r2 ./demo

Sie werden dies sehen:

[0x00000800]>

Analysieren wir das ausführbare Programm:

[0x00000800]> aaa
INFO: Analyze all flags starting with sym. and entry0 (aa)
INFO: Analyze imports (af@@@i)
INFO: Analyze entrypoint (af@ entry0)
INFO: Analyze symbols (af@@@s)
INFO: Analyze all functions arguments/locals (afva@@F)
INFO: Analyze function calls (aac)
INFO: Analyze len bytes of instructions for references (aar)
INFO: Finding and parsing C++ vtables (avrr)
INFO: Analyzing methods (af @@ method.*)
INFO: Finding function preludes (aap)
INFO: Emulate functions to find computed references (aaef)
INFO: Recovering local variables (afva@@@F)
INFO: Type matching analysis for all functions (afft)
INFO: Propagate noreturn information (aanr)
INFO: Use -AA or aaaa to perform additional experimental analysis
INFO: Finding xrefs in noncode sections (e anal.in=io.maps.x; aav)
WARN: Skipping aav because base address is zero. Use -B 0x800000 or aav0

Listen wir die Funktionen auf:

[0x00000800]> afl
0x00000750    1     16 sym.imp.strlen
0x00000760    1     16 sym.imp.__libc_start_main
0x00000770    1     16 sym.imp.__cxa_finalize
0x00000780    1     32 sym.imp.strncmp
0x000007a0    1     16 sym.imp.abort
0x000007b0    1     16 sym.imp.puts
0x000007c0    1     16 sym.imp.printf
0x000007d0    1     20 sym.imp.fgets
0x00000800    1     48 entry0
0x00000834    3     20 sym.call_weak_fn
0x00000860    4     48 sym.deregister_tm_clones
0x00000890    4     60 sym.register_tm_clones
0x000008cc    5     80 entry.fini0
0x00000920    1      8 entry.init0
0x000009f8    1     24 sym._fini
0x00000928    7    208 main
0x00000708    1     28 sym._init
0x00000730    1     32 fcn.00000730

Jetzt können wir in die Funktion main springen und den Disassemblierungscode ausgeben:

[0x00000800]> s main
[0x00000928]> pdf
            ; DATA XREF from entry0 @ 0x820(r)
            ; DATA XREF from entry.fini0 @ 0x8e0(r)
┌ 208: int main (int argc);
│ `- args(x0) vars(5:sp[0x4..0x70])
│           0x00000928      fd7bb9a9       stp x29, x30, [sp, -0x70]!
│           0x0000092c      fd030091       mov x29, sp
│           0x00000930      f30b00f9       str x19, [var_10h]
│           0x00000934      ff6f00b9       str wzr, [var_6ch]          ; argc
│       ┌─< 0x00000938      29000014       b 0x9dc
│       │   ; CODE XREF from main @ 0x9e4(x)
│      ┌──> 0x0000093c      61008052       mov w1, 3
│      ╎│   0x00000940      e06f40b9       ldr w0, [var_6ch]
│      ╎│   0x00000944      2000004b       sub w0, w1, w0
│      ╎│   0x00000948      e103002a       mov w1, w0
│      ╎│   0x0000094c      00000090       adrp x0, 0
│      ╎│   0x00000950      00a02891       add x0, x0, str._d_retries_remaining._nPassword: ; 0xa28 ; "%d verbleibende Versuche.\nPasswort: " ; const char *format
│      ╎│   0x00000954      9bffff97       bl sym.imp.printf           ; int printf(const char *format)
│      ╎│   0x00000958      e00000f0       adrp x0, 0x1f000
│      ╎│   0x0000095c      00e447f9       ldr x0, [x0, 0xfc8]         ; [0x1ffc8:4]=0
│      ╎│                                                              ; reloc.stdin
│      ╎│   0x00000960      010040f9       ldr x1, [x0]                ; int size
│      ╎│   0x00000964      e0a30091       add x0, sp, 0x28            ; char *s
│      ╎│   0x00000968      e20301aa       mov x2, x1                  ; FILE *stream
│      ╎│   0x0000096c      01088052       mov w1, 0x40
│      ╎│   0x00000970      98ffff97       bl sym.imp.fgets            ; char *fgets(char *s, int size, FILE *stream)
│      ╎│   0x00000974      00010090       adrp x0, reloc.strlen       ; 0x20000
│      ╎│   0x00000978      00600191       add x0, x0, 0x58
│      ╎│   0x0000097c      130040f9       ldr x19, [x0]               ; [0xa18:4]=0x6b616577 ; "weakpasswd"
│      ╎│   0x00000980      00010090       adrp x0, reloc.strlen       ; 0x20000
│      ╎│   0x00000984      00600191       add x0, x0, 0x58
│      ╎│   0x00000988      000040f9       ldr x0, [x0]                ; [0xa18:4]=0x6b616577 ; "weakpasswd" ; const char *s
│      ╎│   0x0000098c      71ffff97       bl sym.imp.strlen           ; size_t strlen(const char *s)
│      ╎│   0x00000990      e10300aa       mov x1, x0
│      ╎│   0x00000994      e0a30091       add x0, sp, 0x28
│      ╎│   0x00000998      e20301aa       mov x2, x1                  ; size_t n
│      ╎│   0x0000099c      e10300aa       mov x1, x0                  ; const char *s2
│      ╎│   0x000009a0      e00313aa       mov x0, x19                 ; const char *s1
│      ╎│   0x000009a4      77ffff97       bl sym.imp.strncmp          ; int strncmp(const char *s1, const char *s2, size_t n)
│      ╎│   0x000009a8      1f000071       cmp w0, 0
│     ┌───< 0x000009ac      a0000054       b.eq 0x9c0
│     │╎│   0x000009b0      00000090       adrp x0, 0
│     │╎│   0x000009b4      00402991       add x0, x0, str.Wrong_password__n ; 0xa50 ; "Falsches Passwort!\n" ; const char *s
│     │╎│   0x000009b8      7effff97       bl sym.imp.puts             ; int puts(const char *s)
│    ┌────< 0x000009bc      05000014       b 0x9d0
│    ││╎│   ; CODE XREF from main @ 0x9ac(x)
│    │└───> 0x000009c0      00000090       adrp x0, 0
│    │ ╎│   0x000009c4      00a02991       add x0, x0, str.Correct__nWelcome_to_the_world_of_reverse_engineering__n ; 0xa68 ; "Richtig!\nWillkommen in der Welt des Reverse Engineering!\n" ; const char *s
│    │ ╎│   0x000009c8      7affff97       bl sym.imp.puts             ; int puts(const char *s)
│    │┌───< 0x000009cc      07000014       b 0x9e8
│    ││╎│   ; CODE XREF from main @ 0x9bc(x)
│    └────> 0x000009d0      e06f40b9       ldr w0, [var_6ch]
│     │╎│   0x000009d4      00040011       add w0, w0, 1
│     │╎│   0x000009d8      e06f00b9       str w0, [var_6ch]
│     │╎│   ; CODE XREF from main @ 0x938(x)
│     │╎└─> 0x000009dc      e06f40b9       ldr w0, [var_6ch]
│     │╎    0x000009e0      1f080071       cmp w0, 2
│     │└──< 0x000009e4      cdfaff54       b.le 0x93c
│     │     ; CODE XREF from main @ 0x9cc(x)
│     └───> 0x000009e8      00008052       mov w0, 0
│           0x000009ec      f30b40f9       ldr x19, [var_10h]
│           0x000009f0      fd7bc7a8       ldp x29, x30, [sp], 0x70
└           0x000009f4      c0035fd6       ret

Radare2 liefert uns nicht nur den Assemblercode, sondern auch die jeweilige Adresse jeder Anweisung und die Aufrufbeziehungen zwischen ihnen.

Es ist jedoch noch nicht besonders klar. Zeigen wir also die Disassemblierung als Graph an:

[0x00000928]> VV

Nun werden Sie dies sehen:

Im Graphen bedeutet t, dass bei wahrer Bedingung gesprungen wird. f bedeutet, dass bei falscher Bedingung gesprungen wird. v bedeutet einen unbedingten Sprung.

Jetzt wird das Leben viel einfacher. Radare2 hat die logischen Beziehungen zwischen den Assemblercode-Blöcken bereits herausgefunden, und Sie müssen nur noch die Assemblercode-Blöcke selbst verstehen.

Im Graphen können wir die Logik der Passwortprüfung am Ende des [0x93c]-Blocks leicht finden:

; int strncmp(const char *s1, const char *s2, size_t n)
bl sym.imp.strncmp
cmp w0, 0
b.eq 0x9c0

Hier wird sym.imp.strncmp aufgerufen, und dann wird der von dieser Funktion in w0 zurückgegebene Wert überprüft. Wenn er gleich 0 ist, springt das Programm zum [0x9c0]-Block und signalisiert Erfolg. Andernfalls geht es zum [0x9b0]-Block weiter, was einen Fehler bedeutet.

Gemäss der AArch64-Aufrufkonvention befinden sich die Zeiger auf die beiden zu vergleichenden Zeichenketten in den Registern x0 und x1; dann rufen wir sym.imp.strncmp auf. Das Ergebnis wird anschliessend im Register x0 gespeichert (w0 ist einfach die untere Hälfte von x0), und wenn die beiden Zeichenketten identisch sind, erhalten wir 0.

Nun schauen wir zurück und sehen:

mov x0, x19

Dann schauen wir weiter zurück, um die Anweisung zu finden, die x19 bearbeitet:

; [0xa18:4]=0x6b616577
; "weakpasswd"
ldr x19, [x0]

Radare2 hat uns das Top-Secret bereits verraten. Probieren wir es aus:

$ ./demo
3 verbleibende Versuche.
Passwort: weakpasswd
Richtig!
Willkommen in der Welt des Reverse Engineering!

Das ist alles.

Wenn wir den Graphen genauer betrachten, können wir mehr als nur das Passwort lernen. Zum Beispiel sehen wir im Graphen einen Zyklus: [0x9dc] -> [0x93c] -> [0x9b0] -> [0x9d0] -> [0x9dc]. In einem Graphen deutet ein Zyklus oft auf Schleifensteuerfluss hin. Das ist eine sehr wichtige Denkweise beim Reverse Engineering.

Im [0x9dc]-Block:

ldr w0, [var_6ch]
cmp w0, 2
b.le 0x93c

Er lädt die Variable var_6ch in ein Register und vergleicht sie mit 2. Wenn sie grösser ist, geht es zum [0x9e8]-Block und das Programm endet. Andernfalls geht es zum [0x93c]-Block.

Schauen Sie sich das Ende des [0x93c]-Blocks an. Wir wissen bereits, dass das Programm bei erfolgreicher Passwortprüfung zum [0x9c0]-Block springt, die Erfolgsnachricht ausgibt und dann zum [0x9e8]-Block springt, der das Programm beendet.

Aber was geschieht, wenn die Prüfung fehlschlägt? Dann geht es zum [0x9b0]-Block. Dort wird einfach die Fehlermeldung ausgegeben, also ist hier nichts Interessantes; gehen wir also zum [0x9d0]-Block weiter. Dort finden wir etwas Interessantes:

ldr w0, [var_6ch]
add w0, w0, 1
str w0, [var_6ch]

Er lädt die Variable var_6ch in ein Register, erhöht den Wert um eins und speichert den Wert wieder zurück. Dann springt er zurück zum [0x9dc]-Block, der den Wert von var_6ch überprüft.

Drücken Sie zweimal q, um zur Eingabeaufforderung zurückzukehren. Führen Sie afv und afvd aus, um die Variablen und ihre Informationen aufzulisten:

[0x000009b0]> afv
arg int argc @ x0
var int64_t var_70h @ sp+0x0
var int64_t var_70h_2 @ sp+0x8
var int64_t var_10h @ sp+0x10
var char * s2 @ sp+0x28
var int64_t var_6ch @ sp+0x6c
[0x000009b0]> afvd
arg argc = 0x00000000 0x00010102464c457f   .ELF.... @ pstate
var var_6ch = 0x0017806c = (qword)0x0000000000000000
var s2 = 0x00178028 = ""
var var_10h = 0x00178010 = (qword)0x0000000000000000
var var_70h = 0x00178000 = (qword)0x0000000000000000
var var_70h_2 = 0x00178008 = (qword)0x0000000000000000

Wir sehen, dass der Wert var_6ch ein int64_t ist und sein Anfangswert 0 beträgt.

Nun können wir schliessen, dass var_6ch ein Zähler ist. Sein Anfangswert ist 0. Wenn die Passwortprüfung fehlschlägt, wird der Zähler um eins erhöht. Sobald er grösser als 2 ist, fragt das Programm nicht mehr nach dem Passwort und beendet sich. Nun können wir sagen, dass dies unserem C-Code for (int i = 0; i < 3; i++) entspricht!

Das ist jedoch ein sehr einfaches Beispiel. In der realen Welt wird es schwieriger, da Entwickler proprietärer Software oft Anti-Analyse- und Anti-Debugging-Techniken einsetzen.

Compileroptimierungen verstehen

Kompilieren wir nun diesen noch einfacheren Code:

#include <stdio.h>

int main()
{
    int a;
    scanf("%d", &a);
    printf("%d", a % 65536);
    return 0;
}

Er liest eine ganze Zahl aus der Eingabe und gibt ihr Modulo 65536 aus.

Disassemblieren wir seine main-Funktion:

[0x00000700]> aaa
INFO: Analyze all flags starting with sym. and entry0 (aa)
......
WARN: Skipping aav because base address is zero. Use -B 0x800000 or aav0
[0x00000700]> s main
[0x00000828]> pdf
            ; DATA XREF from entry0 @ 0x720(r)
            ; DATA XREF from entry.fini0 @ 0x7e0(r)
┌ 76: int main (int argc, char **argv, char **envp);
│ afv: vars(3:sp[0x4..0x20])
│           0x00000828      fd7bbea9       stp x29, x30, [sp, -0x20]!
│           0x0000082c      fd030091       mov x29, sp
│           0x00000830      e0730091       add x0, sp, 0x1c
│           0x00000834      e10300aa       mov x1, x0
│           0x00000838      00000090       adrp x0, 0
│           0x0000083c      00602291       add x0, x0, 0x898
│           0x00000840      94ffff97       bl sym.imp.__isoc23_scanf
│           0x00000844      e01f40b9       ldr w0, [var_1ch]
│           0x00000848      e103006b       negs w1, w0
│           0x0000084c      003c0012       and w0, w0, 0xffff
│           0x00000850      213c0012       and w1, w1, 0xffff
│           0x00000854      0044815a       csneg w0, w0, w1, mi
│           0x00000858      e103002a       mov w1, w0
│           0x0000085c      00000090       adrp x0, 0
│           0x00000860      00602291       add x0, x0, 0x898           ; const char *format
│           0x00000864      97ffff97       bl sym.imp.printf           ; int printf(const char *format)
│           0x00000868      00008052       mov w0, 0
│           0x0000086c      fd7bc2a8       ldp x29, x30, [sp], 0x20
└           0x00000870      c0035fd6       ret

Sie könnten verwirrt sein, weil Sie hier nichts über eine Modulo-Operation sehen (sdiv, mul, sub usw.). Stattdessen sehen Sie:

and w0, w0, 0xffff
and w1, w1, 0xffff

Das liegt daran, dass moderne Compiler klug genug sind, gewisse spezielle Berechnungsmuster zu erkennen und sie in einfachere Anweisungen zu optimieren. 65536 ist 2^16, also ist die binäre Zahl modulo 65536 einfach ihre niederwertigsten 16 Bits. Eine bitweise Operation reicht aus; es sind keine Addierer oder Multiplikatoren nötig.

Wenn wir 65536 jedoch durch etwas anderes ersetzen, zum Beispiel 50000, ist das nicht mehr der Fall:

            ; DATA XREF from entry0 @ 0x720(r)
            ; DATA XREF from entry.fini0 @ 0x7e0(r)
┌ 80: int main (int argc, char **argv, char **envp);
│ afv: vars(3:sp[0x4..0x20])
│           0x00000828      fd7bbea9       stp x29, x30, [sp, -0x20]!
│           0x0000082c      fd030091       mov x29, sp
│           0x00000830      e0730091       add x0, sp, 0x1c
│           0x00000834      e10300aa       mov x1, x0
│           0x00000838      00000090       adrp x0, 0
│           0x0000083c      00602291       add x0, x0, 0x898
│           0x00000840      94ffff97       bl sym.imp.__isoc23_scanf
│           0x00000844      e01f40b9       ldr w0, [var_1ch]
│           0x00000848      016a9852       mov w1, 0xc350
│           0x0000084c      020cc11a       sdiv w2, w0, w1
│           0x00000850      016a9852       mov w1, 0xc350
│           0x00000854      417c011b       mul w1, w2, w1
│           0x00000858      0000014b       sub w0, w0, w1
│           0x0000085c      e103002a       mov w1, w0
│           0x00000860      00000090       adrp x0, 0
│           0x00000864      00602291       add x0, x0, 0x898           ; const char *format
│           0x00000868      96ffff97       bl sym.imp.printf           ; int printf(const char *format)
│           0x0000086c      00008052       mov w0, 0
│           0x00000870      fd7bc2a8       ldp x29, x30, [sp], 0x20
└           0x00000874      c0035fd6       ret

Nun sehen wir die Anweisungen sdiv, mul und sub, die zusammen die Modulo-Operation ausführen.

Und was ist mit dynamischer Analyse?

Für die dynamische Analyse benötigen Sie GDB. Mit GDB können Sie Disassemblierung anzeigen, Haltepunkte setzen, Speicher und Register untersuchen und sogar die Werte von Registern und Variablen ändern, während das Programm läuft.

Ich habe die dynamische Analyse bisher noch nicht im Detail untersucht. Vielleicht schreibe ich in Zukunft einen neuen Blogbeitrag, um die dynamische Analyse zu erklären.

Empfohlene Ressourcen

Was ich hier erklärt habe, ist nur die Spitze des Eisbergs. Um Reverse Engineering zu lernen, müssen Sie tiefer gehen, mehr üben und durch Tun lernen. Nachfolgend eine Liste empfohlener Ressourcen:

Pwn.college ist ein guter Ort für den Einstieg. Sie können dort im Einführungs-Dojo x86_64-Assembler lernen und anschliessend im Modul Intro to Cybersecurity zum Bereich Reverse Engineering übergehen.
Reverse Engineering for Beginners ist ein sehr gutes Buch über Reverse Engineering. Es ist frei (im Sinne von Freiheit), unter der Lizenz CC BY-SA 4.0 veröffentlicht und hier zum Herunterladen verfügbar.
ARM bietet offizielle Dokumentation für seine AArch64-Architektur an.
Hier können Sie Crackmes herunterladen, um Ihre Fähigkeiten im Reverse Engineering zu üben.
Hier ist ein GitHub-Repository mit vielen Ressourcen zum Erlernen von Reverse Engineering.

Haftungsausschluss

Dieser Artikel dient nur zu Bildungszwecken. Bitte konsultieren Sie Ihre örtlichen Gesetze, um zu erfahren, was Sie nicht tun dürfen. Ich bin nicht für irgendwelche Ihrer Handlungen verantwortlich.

ReverseEngineering on Rebel Zhangs Blog