Reverse Engineering für alle

Einführung

• x86-Kurs

  • Teil 1: Ziele
  • Teil 2: Technik
  • Teil 3: Arten von Malware
  • Teil 4: Einführung in x86-Assembler
  • Teil 5: Binärsystem
  • Teil 6: Hexadezimalsystem
  • Teil 7: Transistoren und Speicher
  • Teil 8: Byte, Word, Double Word usw.
  • Teil 9: Grundlegende x86-Architektur
  • Teil 10: Allgemeine Register
  • Teil 11: Segmentregister
  • Teil 12: Befehlszeigerregister
  • Teil 13: Steuerregister
  • Teil 14: Flags
  • Teil 15: Stack
  • Teil 16: Heap
  • Teil 17: Linux installieren
  • Teil 18: Der Texteditor vim
  • Teil 19: Warum Assembler lernen?
  • Teil 20: Verarbeitung von Opcodes
  • Teil 21: Programme kompilieren
  • Teil 22: ASM-Programm 1 [Sofortwert verschieben]
  • Teil 23: ASM-Debugging 1 [Sofortwert verschieben]
  • Teil 24: ASM-Hacking 1 [Sofortwert verschieben]
  • Teil 25: ASM-Programm 2 [Daten zwischen Registern verschieben]
  • Teil 26: ASM-Debugging 2 [Daten zwischen Registern verschieben]
  • Teil 27: ASM-Hacking 2 [Daten zwischen Registern verschieben]
  • Teil 28: ASM-Programm 3 [Daten zwischen Speicher und Registern verschieben]
  • Teil 29: ASM-Debugging 3 [Daten zwischen Speicher und Registern verschieben]
  • Teil 30: ASM-Hacking 3 [Daten zwischen Speicher und Registern verschieben]
  • Teil 31: ASM-Programm 4 [Daten zwischen Registern und Speicher verschieben]
  • Teil 32: ASM-Debugging 4 [Daten zwischen Registern und Speicher verschieben]
  • Teil 33: ASM-Hacking 4 [Daten zwischen Registern und Speicher verschieben]
  • Teil 34: ASM-Programm 5 [Indirekte Adressierung über Register]
  • Teil 35: ASM-Debugging 5 [Indirekte Adressierung über Register]
  • Teil 36: ASM-Hacking 5 [Indirekte Adressierung über Register]
  • Teil 37: ASM-Programm 6 [CMOV-Befehl]
  • Teil 38: ASM-Debugging 6 [CMOV-Befehl]
  • Teil 39: ASM-Hacking 6 [CMOV-Befehl]
  • Teil 40: Fazit

• ARM-32-Kurs 1

  • Teil 1: Der Sinn des Lebens
  • Teil 2: Zahlensystem
  • Teil 3: Binäre Addition
  • Teil 4: Binäre Subtraktion
  • Teil 5: Wortlänge
  • Teil 6: Register
  • Teil 7: Programmzähler
  • Teil 8: CPSR
  • Teil 9: Link-Register
  • Teil 10: Stack-Pointer
  • Teil 11: ARM-Firmware-Bootvorgang
  • Teil 12: Von-Neumann-Architektur
  • Teil 13: Befehlspipeline
  • Teil 14: ADD
  • Teil 15: ADD-Debugging
  • Teil 16: ADD-Hacking
  • Teil 17: ADDS
  • Teil 18: ADDS-Debugging
  • Teil 19: ADDS-Hacking
  • Teil 20: ADC
  • Teil 21: ADC-Debugging
  • Teil 22: ADC-Hacking
  • Teil 23: SUB
  • Teil 24: SUB-Debugging
  • Teil 25: SUB-Hacking

• ARM-32-Kurs 2

  • Teil 1: Der Sinn des Lebens Teil 2
  • Teil 2: Zahlensystem
  • Teil 3: Binäre Addition
  • Teil 4: Binäre Subtraktion
  • Teil 5: Wortlänge
  • Teil 6: Register
  • Teil 7: Programmzähler
  • Teil 8: CPSR
  • Teil 9: Link-Register
  • Teil 10: Stack-Pointer
  • Teil 11: Firmware-Bootvorgang
  • Teil 12: Von-Neumann-Architektur
  • Teil 13: Befehlspipeline
  • Teil 14: Hello World
  • Teil 15: Hello-World-Debugging
  • Teil 16: Hello-World-Hacking
  • Teil 17: Konstanten
  • Teil 18: Konstanten-Debugging
  • Teil 19: Konstanten-Hacking
  • Teil 20: Zeichenvariablen
  • Teil 21: Zeichenvariablen-Debugging
  • Teil 22: Zeichenvariablen-Hacking
  • Teil 23: Boolean-Variablen
  • Teil 24: Boolean-Variablen-Debugging
  • Teil 25: Boolean-Variablen-Hacking
  • Teil 26: Integer-Variablen
  • Teil 27: Integer-Variablen-Debugging
  • Teil 28: Integer-Variablen-Hacking
  • Teil 29: Gleitkomma-Variablen
  • Teil 30: Gleitkomma-Variablen-Debugging
  • Teil 31: Gleitkomma-Variablen-Hacking
  • Teil 32: Double-Variablen
  • Teil 33: Double-Variablen-Debugging
  • Teil 34: Double-Variablen-Hacking
  • Teil 35: SizeOf-Operator
  • Teil 36: SizeOf-Operator-Debugging
  • Teil 37: SizeOf-Operator-Hacking
  • Teil 38: Präinkrement-Operator
  • Teil 39: Präinkrement-Operator-Debugging
  • Teil 40: Präinkrement-Operator-Hacking
  • Teil 41: Postinkrement-Operator
  • Teil 42: Postinkrement-Operator-Debugging
  • Teil 43: Postinkrement-Operator-Hacking
  • Teil 44: Prädekrement-Operator
  • Teil 45: Prädekrement-Operator-Debugging
  • Teil 46: Prädekrement-Operator-Hacking
  • Teil 47: Postdekrement-Operator
  • Teil 48: Postdekrement-Operator-Debugging
  • Teil 49: Postdekrement-Operator-Hacking

• x64-Kurs

  • Teil 1: Cyber-Revolution
  • Teil 2: Transistoren
  • Teil 3: Logikgatter
  • Teil 4: Zahlensystem
  • Teil 5: Binäre Addition
  • Teil 6: Binäre Subtraktion
  • Teil 7: Wortlänge
  • Teil 8: Allgemeine Architektur
  • Teil 9: Calling Convention
  • Teil 10: Boolean-Befehle
  • Teil 11: Pointer
  • Teil 12: Effektive Adresse laden
  • Teil 13: Datensegment
  • Teil 14: SHL-Befehl
  • Teil 15: SHR-Befehl
  • Teil 16: ROL-Befehl
  • Teil 17: ROR-Befehl
  • Teil 18: Bootsektor-Grundlagen [Teil 1]
  • Teil 19: Bootsektor-Grundlagen [Teil 2]
  • Teil 20: Bootsektor-Grundlagen [Teil 3]
  • Teil 21: Bootsektor-Grundlagen [Teil 4]
  • Teil 22: Bootsektor-Grundlagen [Teil 5]
  • Teil 23: Bootsektor-Grundlagen [Teil 6]
  • Teil 24: Bootsektor-Grundlagen [Teil 7]
  • Teil 25: Bootsektor-Grundlagen [Teil 8]
  • Teil 26: Bootsektor-Grundlagen [Teil 9]
  • Teil 27: x64-Assembler [Teil 1]
  • Teil 28: x64-Assembler [Teil 2]
  • Teil 29: x64-Assembler [Teil 3]
  • Teil 30: x64-Assembler [Teil 4]
  • Teil 31: x64-Assembler [Teil 5]
  • Teil 32: x64-Assembler [Teil 6]
  • Teil 33: x64-Assembler [Teil 7]
  • Teil 34: x64-C++-1-Code [Teil 1]
  • Teil 35: x64-C++-2-Debug [Teil 2]
  • Teil 36: x64-C++-3-Hacking [Teil 3]
  • Teil 37: x64 C & der Ursprung des Lebens
  • Teil 38: x64-Networking-Grundlagen
  • Teil 39: Warum C?
  • Teil 40: Hello-World-Hacking!
  • Teil 41: Variablen-Hacking!
  • Teil 42: Verzweigungs-Hacking!
  • Teil 43: Pointer-Hacking!

• ARM-64-Kurs

  • Teil 1: Der Sinn des Lebens
  • Teil 2: Entwicklungsumgebung einrichten
  • Teil 3: "Hello World"
  • Teil 4: "Hello World" debuggen
  • Teil 5: "Hello World" hacken
  • Teil 6: Grundlegendes I/O
  • Teil 7: Grundlegendes I/O debuggen
  • Teil 8: Grundlegendes I/O hacken
  • Teil 9: Primitiver Zeichendatentyp
  • Teil 10: Primitiver Zeichendatentyp debuggen
  • Teil 11: Primitiver Zeichendatentyp hacken
  • Teil 12: Primitiver Boolean-Datentyp
  • Teil 13: Primitiver Boolean-Datentyp debuggen
  • Teil 14: Primitiver Boolean-Datentyp hacken
  • Teil 15: Primitiver Gleitkomma-Datentyp
  • Teil 16: Primitiver Gleitkomma-Datentyp debuggen
  • Teil 17: Primitiver Gleitkomma-Datentyp hacken
  • Teil 18: Primitiver Double-Datentyp
  • Teil 19: Primitiver Double-Datentyp debuggen
  • Teil 20: Primitiver Double-Datentyp hacken

• Pico-Hacking-Kurs

  • Teil 1: Warum und wie
  • Teil 2: Hello World
  • Teil 3: Hello-World-Debugging
  • Teil 4: Hello-World-Hacking
  • Teil 5: char
  • Teil 6: char-Debugging
  • Teil 7: char-Hacking
  • Teil 8: int
  • Teil 9: int-Debugging
  • Teil 10: int-Hacking
  • Teil 11: float
  • Teil 12: float-Debugging
  • Teil 13: float-Hacking
  • Teil 14: double
  • Teil 15: double-Debugging
  • Teil 16: double-Hacking
  • Teil 17: "Absolute Macht korrumpiert absolut!", die tragische Geschichte der Eingabe
  • Teil 18: "800 Jahre lang habe ich Jedi ausgebildet!", die Macht der Eingabe
  • Teil 19: Eingabe
  • Teil 20: Eingabe-Debugging

• Reverse Engineering For Everyone!

  • Was ist Reverse Engineering?
    • Laut Wikipedia ist Reverse Engineering der Prozess, ein künstlich geschaffenes Objekt zu zerlegen, um dessen Entwurf, Architektur, Code usw. offenzulegen oder Wissen aus dem Objekt zu extrahieren. Das ähnelt wissenschaftlicher Forschung zur Untersuchung natürlicher Phänomene.
    • Diese Tutorial-Sammlung existiert, um Reverse Engineering so einfach wie möglich zu machen.
    • Diese umfassende Tutorial-Sammlung zum Reverse Engineering behandelt x86-, x64-, 32-Bit-ARM- und 64-Bit-Architekturen.
    • Sie hilft Einsteigerinnen und Einsteigern dabei, die Grundkonzepte des Reverse Engineering zu erlernen, und ist auch für Menschen nützlich, die die Konzepte wiederholen möchten.
    • Die gesamte Tutorial-Sammlung kann im PDF- oder MOBI-Format heruntergeladen werden.

Zusammenfassung von GN⁺

• Dieser Artikel behandelt verschiedene Tutorials zum Reverse Engineering, darunter Kurse zu x86, x64, ARM-32, ARM-64 und Pico-Hacking.
• Es ist eine nützliche Ressource für alle, die sich Reverse-Engineering-Techniken auf Anfänger- bis Mittelstufenniveau aneignen möchten.
• Im Bereich Cybersicherheit sind Reverse-Engineering-Techniken sehr wichtig.
• Die Tutorials werden im PDF- und MOBI-Format bereitgestellt, um die Zugänglichkeit zu erhöhen.
• Projekte mit ähnlicher Funktionalität sind unter anderem "Practical Reverse Engineering" und "Reversing: Secrets of Reverse Engineering".