LEARNING // ALIENZONE
Nachschlagewerk wird aufgebaut…
THEMEN WERDEN GELADEN
LEARNING // ALIENZONE
Großes, schnelles Nachschlagewerk: von Einfach bis Extrem — plus Quellen u. Ressourcen (DE/EN). Klare Sprache, scannbare Kacheln, ohne Overload.
Links Abschnitte aufklappen, oben suchen, Kacheln lesen — und einzelne Stufen oder Themen teilen (z. B. #level-medium, #topic-brop, #level-resources). ← zurück zum Hub
Grundlagen — PC, Systeme, Dateien, Netz, Terminal und wie Challenges ticken.
Ein PC speichert Daten und führt Programme aus. Für CTFs reicht dieses Bild:
Challenges sind oft Programme (EXE, ELF) oder Webseiten. Du musst wissen: Was läuft wo, und wo liegen Dateien?
Jedes laufende Programm ist ein Prozess. Er hat eigenen Speicherbereich und Rechte. Im Task-Manager (Windows) oder mit ps/top (Linux) siehst du sie.
Tipp: Stell dir den PC wie eine Werkstatt vor — Tools (Programme), Werkbank (RAM), Schrank (Festplatte).
Die Endung (z. B. .exe, .elf, .js, .html) ist ein Hinweis, was die Datei sein soll — aber kein Garant. Angreifer (und CTFs) benennen Dateien manchmal irreführend.
| Typ | Typisch für | Hinweis |
|---|---|---|
.exe | Windows-Programm | Läuft unter Windows (oder Wine) |
.elf / ohne Endung | Linux-Programm | Läuft unter Linux |
.js / .html | Web | Browser / DevTools |
.zip / .7z / .tar.gz | Archiv | erst entpacken |
.dll / .so | Bibliothek | wird von Programmen geladen |
.pcap | Netzwerk-Mitschnitt | Forensik / Wireshark |
Viele Dateien starten mit festen Bytes:
MZ (Hex 4D 5A)ELF (Hex 7F 45 4C 46)89 50 4E 47Mit file datei (Linux) oder einem Hex-Editor erkennst du den echten Typ.
Lade Challenge-Dateien nur vom Hub und idealerweise in einer VM, wenn du unsicher bist.
Viele Binaries hier sind Windows PE (.exe).
C:\\Users\\Name\\Downloads\\cd ~\Downloads
.\\SlapSalve.exe
Get-FileHash .\\file.exe
\\ statt /%TEMP%) — manchmal landen dort Drops/LogsStarte unbekannte EXEs am besten in einer isolierten Windows-VM.
Linux ist in der Security-Welt Standard (Server, Tools, viele Binaries).
/ (z. B. /home/user/)/devls -la # Ordnerinhalt inkl. Rechte
cd # Ordner wechseln
pwd # aktueller Pfad
file x # Dateityp raten
strings x # lesbare Texte in Binaries
chmod +x x # ausführbar machen
./x # Programm starten
cat / grep # lesen / suchen
rwx = read / write / execute. Ohne x startet ein Binary nicht mit ./.
Du musst kein Admin-Guru sein — diese Handvoll Befehle deckt viele Easy-Challenges ab.
Identifiziert einen Rechner im Netz (z. B. 192.168.1.10 im Heimnetz).
Wie eine Türnummer auf dem Rechner. Beispiele:
Browser fragt: „Gib mir /login“. Server antwortet mit HTML/JSON und Statuscode (200 ok, 404 nicht gefunden, 302 Redirect).
Web-Challenges = du sprichst mit einem Server. Manchmal lokal im Browser-Modul, manchmal über APIs.
Merke: Client (Browser/Script) ↔ Server (antwortet). Beide Seiten können interessant sein.
Viele CTF-Lösungen leben im Terminal: Programme starten, Ausgaben lesen, Tools verketten.
/home/user/chal/flag.txt oder C:\\CTF\\flag.txt./flag.txt (im aktuellen Ordner)./prog < input.txt
./prog > out.txt
Wer Pfade und Terminal beherrscht, spart in jeder Kategorie Zeit.
Encoding ist kein Verschlüsseln — es ist eine andere Schreibweise derselben Daten.
| Format | Beispiel | Nutzen |
|---|---|---|
| Hex | 46 4c 41 47 = FLAG | Speicher-Dumps, Strings |
| Base64 | RkxBR3… | Web, Tokens, Blobs |
| URL-Encoding | %20 = Leerzeichen | Query-Strings |
base64 / xxd unter LinuxWenn etwas „komisch“ aussieht: erst decoden, dann weiterdenken.
Computer speichern alles als Bytes (0–255). Menschen lesen oft Hex (41 = A).
Text: FLAG
Hex: 46 4c 41 47
Auf x86/x64 liegen mehrbyte-Werte oft „rückwärts“ im Speicher. Bei Stack-Leaks Hex-Blöcke byteweise umdrehen.
CTF-Flags sind meist reines ASCII. Sonderzeichen in Logs können UTF-8 sein.
Du musst Hex nicht auswendig können — das Prinzip reicht für den Einstieg.
CTF-Binaries sind Lernmaterial — trotzdem gut isolieren.
Fehler, Endlosschleifen, absichtliche Crashes, AV-Quarantäne — in der VM ist das egal.
Hub-Hinweis /note erklärt False-Positives von Antivirus.
Capture the Flag = spielerische Security-Rätsel. Du findest eine Flag (geheimen String) und reichst sie im Hub ein.
Nur die Challenges auf AlienZone angreifen — nicht fremde Systeme.
Punkte und Ranking belohnen erfolgreiche Flags — einmal pro Challenge.
Oft FLAG{…} oder challenge-spezifisch. Leerzeichen am Rand stören manchmal — der Hub normalisiert in der Regel.
Bio, Banner, Links (z. B. Discord) — für Seasons relevant, wenn Teilnahme an Community-Preisen.
Bei „falsch“: Tippfehler, falsche Challenge, oder Flag noch nicht komplett.
CTF trainiert Angreifer-Denken — bleib ethisch und im erlaubten Rahmen.
Für Web-Challenges ist der Browser dein Labor. DevTools (meist F12 oder Rechtsklick → Untersuchen) zeigen, was die Seite wirklich tut.
| Tab | Wozu |
|---|---|
| Elements / Elemente | HTML & CSS der Seite |
| Console | JavaScript-Fehler, console.log, kleine Tests |
| Network / Netzwerk | Jeder Request (URL, Status, Body) |
| Application / Speicher | Cookies, LocalStorage, SessionStorage |
| Sources | JS-Dateien lesen, Breakpoints |
document.cookie
localStorage
location.href
Keine Angst vor roten Fehlern — sie sind oft der Hinweis, was schiefgeht.
Ein Hash mappt Daten auf einen festen Fingerabdruck. Gleicher Input → gleicher Hash; kleine Änderung → völlig anderer Wert.
| Name | Länge (Hex, grob) | CTF-Nutzung |
|---|---|---|
| MD5 | 32 Zeichen | oft „erraten“ / Rainbow |
| SHA-1 | 40 | ähnlich |
| SHA-256 | 64 | Integrität, manchmal Flag-Format |
Get-FileHash, sha256sum)Hash ≠ Verschlüsselung. Aus dem Hash bekommst du die Originaldaten nicht „rückwärts“ (außer Brute-Force bei kurzen Inputs).
Steht in der Challenge „MD5 der Flag“: oft ist der Hash die Prüfung, nicht die Flag selbst.
Dienste lauschen auf Ports (Nummern). Web oft 80/443, SSH 22, viele CTF-Remote-Tasks z. B. 1337.
| Port | Dienst (klassisch) |
|---|---|
| 22 | SSH |
| 80 / 443 | HTTP / HTTPS |
| 21 | FTP (selten) |
| 3306 | MySQL |
| 1337 / 9999 | oft CTF-Challenges |
nc)nc host port
# oder
ncat host port
Windows: nmap/ncat oder WSL. Manche Challenges brauchen nur: connecten und Text tippen.
Lokal erreichbar ≠ im Internet offen. In deiner VM darfst du scannen — nicht fremde Netze ohne Erlaubnis.
Remote-Challenge = oft: Host + Port aus der Beschreibung, dann
ncoder Browser.
Gute Spieler verlieren weniger Zeit, weil sie schreiben, was sie schon wissen.
file, Strings, URL)Markdown-Datei, Obsidian, Notion, einfaches Notepad — egal, Hauptsache durchsuchbar.
Spoiler: im Discord erst freigeben, wenn erlaubt. Lernen > spoilern.
Git versioniert Dateien. Im CTF brauchst du selten Branches — aber oft: Repo klonen, Historie lesen, gelöschte Secrets finden.
git clone <url>
git log --oneline
git show <commit>
git checkout <datei-aus-alter-version>
.git exposed → mit Tools/Clone rekonstruierenNie eigene Secrets committen — auch nicht „nur lokal“, wenn du pushst.
Daten werden oft umkodiert, damit sie sicher in URLs, Cookies oder JSON passen — das ist keine starke Verschlüsselung.
+, /, Padding =RkxBR3suLi59base64 -d, CyberChef, PowerShell| Zeichen | Encoding |
|---|---|
| Leerzeichen | %20 oder + |
< | %3C |
> | %3E |
& | %26 |
Wenn die Flag „komisch“ aussieht: erst dekodieren, dann raten. Mehrfach-Encoding kommt vor (Base64 in Base64).
CyberChef („From Base64“, „URL decode“) spart Stunden.
CTF-Binaries und unbekannte Dateien gehören nicht auf den Alltagspfad deines Haupt-PCs.
Manche Labs laufen in Containern — praktisch, aber Isolation ist nicht magisch. Verstehe, was du startest.
AlienZone: Challenges vom Hub laden; unbekannte Fremdlinks trotzdem mit Vorsicht.
Erste echte Analyse — Web (XSS & mehr), Reverse, einfache Schwachstellen.
Web-Module laufen im Browser. Client (JavaScript) und Server tauschen HTTP-Requests aus.
UI allein reicht oft nicht — beobachte den Netzwerk-Traffic.
XSS heißt: Es gelingt, fremden JavaScript-Code in einer Seite auszuführen, die andere Nutzer (oder du selbst im CTF) sehen.
Session-Klau, Aktionen im Namen des Opfers, Phishing im echten Look der Seite.
<b>test</b>, dann Script-Kontexte<script> blocken (Umgehungen lernen — nur im CTF!)Escaping/Encoding von Ausgaben, Content-Security-Policy, sichere Templates.
Auf AlienZone: XSS nur in dafür vorgesehenen Challenges üben — nie „wild“ gegen fremde Sites.
Wenn eine App SQL-Strings aus User-Input zusammenklebt, kann man die Abfrage verbiegen.
Login-Check in der Datenbank — Input wird Teil der Query statt nur Daten.
' oder OR 1=1Prepared Statements / parametrisierte Queries — Input ist nur Wert, nie Code.
Ziel im CTF: verstehen und Flag holen, nicht echte DBs zerstören.
Kleines Datum, das der Browser mitschickt. Kann Session-ID, Sprache, Tracking … sein.
Server merkt sich: „Cookie X = User Y ist eingeloggt.“
DevTools → Application → Cookies ist dein Freund.
Viel Web-Logik steckt in .js-Dateien.
password, flag, fetch, token suchen_0x…) — schrittweise entwirrenDu musst kein Frontend-Profi sein — Suchen und Nachvollziehen reicht oft.
Ziel: Verstehen, was ein Programm tut, ohne (viel) Quellcode.
strings / lesbare Texteprintf)Nicht alles lesen — suche die Flag-Prüfung oder auffällige Strings.
Unsicher:
printf(user_input);
Sicher:
printf("%s", user_input);
Mit %x, %p, %s liest man oft Stack-Inhalte (Flag!).
%p.%p.%p… ausprobierenAlienZone-Beispiel-Mindset: „Slap Salve“-Stil — wiederholen, bis die Flag plappert.
| Art | Was | Beispiele |
|---|---|---|
| Statisch | Programm ohne Laufen lesen | strings, Ghidra, Code-Review |
| Dynamisch | Programm laufen lassen und beobachten | Debugger, Logs, Network, Input testen |
Erst grob statisch orientieren, dann dynamisch Hypothesen prüfen — und umgekehrt.
Wer nur eines von beiden kann, bleibt stecken.
| Ziel | Tool-Ideen |
|---|---|
| Web | Browser DevTools, curl, Burp Community |
| Strings / Data | strings, HxD, CyberChef |
| Reverse | Ghidra, IDA Free, Cutter |
| Windows | x64dbg (später), Procmon |
| Linux | gdb, ltrace/strace (einfach) |
| Skripte | Python 3 |
Ein Tool tief lernen schlägt zehn halb installierte.
Notiere dir deine persönliche „Standard-Reihenfolge“ pro Kategorie.
Viele CTF-APIs sprechen JSON:
{ "ok": true, "layer": 2, "token": "…" }
Network-Tab → Request kopieren → mit curl/Python nachbauen → Parameter systematisch ändern.
Layer-Challenges lieben State: Token aus Antwort 1 in Request 2 stecken.
Wenn eine App Dateinamen aus User-Input baut, kann ../ aus dem erlaubten Ordner hinaus führen.
../../etc/passwd (Linux-Lab)%2e%2e%Pfad normalisieren, Allowlist, chroot/jail, nie rohe User-Pfade.
Ziel im CTF oft: Flag-Datei lesen, die „neben“ dem Webroot liegt.
User-Input wird unsicher an eine Shell übergeben (system, popen, …). Metazeichen wie ; | && können Befehle anhängen.
Nie gegen fremde Systeme — nur Challenge/Lab.
CSRF nutzt, dass der Browser bei Requests an eine Site automatisch Cookies mitschickt. Eine fremde Seite kann so Aktionen im Namen des eingeloggten Users auslösen.
Du bist bei bank.example eingeloggt. Bösartige Seite triggert POST /transfer — Cookie fliegt mit.
SameSite-CookiesSuche nach State-ändernden Requests ohne Token. Manchmal reicht ein simpler HTML-Form-Auto-Submit.
XSS stiehlt oft Sessions; CSRF reitet auf bestehenden Sessions.
Ein JWT hat typisch drei Base64-Teile: header.payload.signature.
HS256, none, …)sub, role, exp)| Trick | Idee |
|---|---|
alg: none | Signatur weglassen, Server akzeptiert |
| weak secret | HS256 mit ratebarem Secret knacken |
| Key confusion | RS256 vs HS256 verwechseln |
| Claims ändern | role: admin nach Decode/Encode |
jwt.io oder jq + Base64 — Payload lesen ist ok; Signatur fälschen nur, wenn der Server schwach ist.
JWT ≠ magisch sicher. Immer Server-Validierung prüfen.
Wenn User-Input in Server-Templates (Jinja2, Twig, Freemarker, …) landet und als Template ausgewertet wird, kann Code auf dem Server laufen.
Probiere harmlose Template-Syntax in Eingabefeldern:
{{7*7}}
${7*7}
<%= 7*7 %>
Wenn 49 zurückkommt: heiße Spur.
RCE, Dateilesen, Config-Leaks — je nach Engine und Sandbox.
Engine identifizieren (Fehlertexte, Payload-Cheatsheets), dann gezielte Payloads. Nicht blind 50 Payloads spammen.
PortSwigger hat exzellente SSTI-Labs — ideal nach dem Einstieg hier.
Bevor du exploitest: was gibt es überhaupt?
robots.txt, sitemap.xml, .git (manchmal)admin, debug, token)curl -iListe der URLs + Methoden + Auth-Bedarf spart Doppelarbeit.
Recon ist langweilig und gewinnt Challenges.
Ghidra (NSA, kostenlos) disassembliert und decompiliert Binaries. Für Reverse-Challenges Gold wert.
main / entry / WinMainIDA Free, Binary Ninja, radare2/Cutter — Konzept ist ähnlich.
Ein String „FLAG{" ist oft der Einstieg, nicht das Ende der Analyse.
CTF-Crypto startet oft nicht bei AES-GCM, sondern bei spielerischen Chiffren.
Buchstaben verschieben. ROT13 ist Spezialfall. Brute-Force: 25 Möglichkeiten.
c = p ⊕ k. Eigenschaften:
p ⊕ k ⊕ k = pBase64, Hex, Morse — erst dekodieren, dann knacken.
CyberChef, Python, quipqiup (Substitution), dcode.fr
Lies die Challenge: oft steckt der Algorithmus im Namen oder Sample.
Ein Intercepting Proxy (Burp Community, OWASP ZAP, mitmproxy) sitzt zwischen Browser und Server. Du siehst und änderst Requests live.
role=user → admin)curl mit kopierten Headern aus DevTools — reicht oft.
Nur gegen Lab/Challenge-Hosts. Fremde Systeme = illegal.
Tiefer rein — Speicher, Binary-Schutz, Exploit-Ideen, Windows/Linux im Detail.
Lokale Variablen, Rückadressen, kurze Lebensdauer. Wächst/schrumpft mit Aufrufen.
Dynamischer Speicher (malloc / new). Länger lebend — und oft fehleranfällig.
Adresse: „Hier liegt etwas.“ Falsche Pointer → Crash oder (in CTFs) Kontrolle.
Jedes Prozess hat (vereinfacht) eigenen Speicher. ASLR verschiebt Basen.
Merke: wo Daten liegen, entscheidet viele Exploits.
Mehr Daten als Puffer-Platz → Nachbarn überschreiben (klassisch: Rückadresse).
| Schutz | Idee |
|---|---|
| ASLR | Adressen random |
| DEP/NX | Daten nicht ausführbar |
| Canary/Cookie | Overflow erkennen |
| PIE | Binary selbst verschiebbar |
Oft absichtlich schwache Builds oder Leak + Bypass als Lernpfad.
Verstehen vor Copy-Paste-Exploits.
Unter Linux oft:
checksec --file=./chal
Oder in Ghidra/IDA: Imports, Compiler-Flags grob ableiten.
DEP, ASLR, CFG … — für CTFs reicht: „Läuft mit modernen Defaults?“ und ob es Leaks gibt.
Ohne Inventur der Protections baust du ins Leere.
.exe)MZkernel32, …)ELFldd, readelf -h (Linux)file, Header ansehen, Imports listen — bevor der Debugger stundenlang läuft.
Endung lügt manchmal — Magic Bytes nicht.
Wenn eine Funktion aufgerufen wird, liegen Argumente und Rückadresse an festen Orten (Register/Stack) — je nach Architektur und OS.
rdi, rsi, rdx, …rcx, rdx, r8, r9, …Debugger und Exploits brauchen das, um Parameter und Rückwege zu verstehen.
Details lernst du on-demand — merke zuerst: Register + Stack = Aufrufzustand.
Eingaben, Adressen, was schon widerlegt ist — alles aufschreiben.
Langsam ist schnell.
Nicht jeder Bug ist ein Overflow.
„Darf User A das überhaupt?“ — fehlende Checks, TOCTOU im Business-Sinn, falsche Reihenfolge.
Zwei Abläufe gleichzeitig — Zustand wird inkonsistent (Klassiker in Datei-/Kauf-Szenarien).
Manchmal reicht, Requests parallel zu feuern oder Schritte umzusortieren.
Lies die Challenge-Story: oft steckt der Hinweis in der erlaubten Aktion.
ASLR (Address Space Layout Randomization) verschiebt Module im Speicher bei jedem Start. PIE (Position Independent Executable) macht das Binary selbst relativ.
Harte Adressen aus einem Run funktionieren im nächsten oft nicht.
Lokal setarch -R / Disable ASLR (nur Lab!) — verstehen, dann mit ASLR.
checksec: PIE/ASLR-Status notieren, bevor du Offsets hardcodest.
Ein Canary ist ein geheimer Wert vor der gespeicherten Rückadresse. Overflow zerstört ihn → Programm bricht ab (Stack Smashing Detected).
__stack_chk_fail in ImportsViele Lern-Binaries haben Canary aus — lies checksec. Mit Canary: erst Leak-Plan, dann Overflow.
Canary zerstören und hoffen ist selten die Lösung.
Ganzzahlen haben begrenzte Breite. 255 + 1 in 8 Bit → 0. Negative Werte als Größe → riesige Allocations oder Unterläufe.
n * size wrap)if (len < 0) vs unsigned)Werte an der Compare-Instruktion ansehen — oft ist der Wrap schon passiert.
Größenangaben immer misstrauen, besonders wenn sie vom Client kommen.
Du musst kein Compiler-Nerd sein — aber ein paar Mnemonics lesen zu können, spart Stunden in Ghidra/Debugger.
| Register | Rolle (Faustregel) |
|---|---|
rax | Rückgabewert / allgemein |
rdi, rsi, rdx | 1.–3. Argument |
rsp | Stack-Pointer |
rip | nächste Instruktion |
mov dest, src — kopierencall / ret — Funktionenjmp / je / jne — Sprüngepush / pop — Stackcmp + bedingter Sprung — ifIn Ghidra: Decompiler + Listing parallel. Wenn Decompiler lügt, hilft das Listing.
Lerne Mnemonics on demand an echten Challenges, nicht aus 200-Seiten-Handbuch.
Manche Challenges (oder Boot2Root) geben dir eine Shell als User — Ziel: root oder Flag-Datei mit anderen Rechten.
id
sudo -l
find / -perm -4000 2>/dev/null # SUID
getcap -r / 2>/dev/null
cat /etc/crontab
Die meisten Challenges sind kein volles OS-Privesc — aber das Denken hilft bei Dateirechten und SUID-Tasks.
GTFOBins + linPEAS sind Werkzeuge, kein Ersatz für Lesen.
Ein PCAP ist ein Mitschnitt von Paketen. In Wireshark filterst und rekonstruierst du Streams.
http
tcp.port == 80
dns
frame contains "FLAG"
strings capture.pcaphilft manchmal — Wireshark ist der Profi-Weg.
Objekte werden zu Bytes/Text serialisiert und später wieder geladen. Wenn die Daten user-kontrolliert sind, kann das Laden gefährlichen Code auslösen (je nach Sprache/Framework).
| Stack | Stichwort |
|---|---|
| PHP | unserialize, Phar |
| Java | ObjectInputStream, ysoserial |
| Python | pickle |
| .NET | BinaryFormatter (historisch) |
Niemals untrusted Input deserialisieren; JSON + Schema statt nativer Objects.
Wenn du „gadget chain“ liest: Ketten bekannter Klassen, die zu RCE führen.
Shellcode = kleine Maschinenbefehl-Sequenz, die z. B. eine Shell startet. In modernen CTFs oft durch Protections erschwert; manchmal reicht eine vorhandene Funktion (ret2win).
AlienZone: lies die Challenge — oft gibt es einen gewollten Gewinn-Pfad.
Statt komplexem Shellcode: RIP auf eine bereits existierende Gewinn-Funktion lenken (z. B. win() druckt die Flag).
Mit Overflow oft: Rückadresse = win oder sinnvoller Libc-Pfad nach Leak.
Suche im Binary nach offensichtlichen
win/flag-Funktionen, bevor du ROP baust.
Fuzzing = viele (halb-)automatische Eingaben, um Crashes und Edge-Cases zu finden.
%x, ', ../, NullbytesAFL++, libFuzzer — lohnt bei größeren Binaries, nicht bei jeder Easy-Challenge.
Ein kleines Python-
forschlägt planloses Tippen.
Viele Pwn-Challenges laufen remote: du connectest per TCP statt ./local.
nc host portremote()socketrecvuntil / klare MarkerRemote = gleiche Logik, mehr Flakiness — Scripts statt Handklick.
Anspruchsvoll — Heap, BROP, Anti-Debug, komplexe Protokolle und mehrstufige Angriffe.
Auf dem Heap liegen dynamische Objekte. Fehler wie Use-After-Free (free, Pointer behalten) erlauben, „alte“ Strukturen mit neuen Daten zu füllen.
Erst Stack/Format-String und Reverse sitzen — dann Heap.
Objekt freigegeben, Code nutzt es weiter.
Nach free Speicher mit kontrollierten Bytes füllen (gleiche Größe), dann Virtual Function / Callback / encrypted pointer missbrauchen.
Extreme Challenges (z. B. Kernel-/Xeno-Style) bauen genau solche Menü-Spielereien.
Challenges können Debugger erkennen und Verhalten ändern (kaputter Key, andere Zweige).
IsDebuggerPresentmainSolche Muster triggern Heuristiken — siehe /note.
Wenn’s mit Debugger „komisch“ wird: vielleicht soll es das.
Module erwarten oft Reihenfolge: Layer 1 → 2 → 3. Zustand steckt in Cookie/Token/Session.
Das ist näher an echter Arbeit als an einem einzelnen Button.
Manchmal speichert Code Funktionszeiger vercodet (z. B. XOR mit Adresse). Einfach überschreiben reicht nicht — du musst die Kodierung treffen.
Leaks (ASLR-Base, Heap-Adresse) + Formel = klassisches Extrem-Puzzle.
Wenn du den Stack kontrollierst, aber keinen eigenen Code ausführen darfst (NX), reihst du existierende Codeschnipsel (Gadgets) aneinander — jeweils endend mit ret.
ROPgadget, …)Nur relevant, wenn die Challenge wirklich dahin führt — nicht jeder Extrem-Task ist ROP.
Konzept kennen > blind Tool spammen.
Extrem = Organisation so wichtig wie Technik.
BROP (Blind ROP) ist eine Technik, um ROP zu fahren, wenn du das Binary nicht (vollständig) analysieren kannst — z. B. kein Download, Remote-Service, oder stark blinde Umgebung. Populär geworden u. a. durch die Arbeit von Bittau et al. (Stanford).
Klassisches ROP braucht:
pop rdi; ret, …)Blind heißt: du siehst kaum Code, hast aber vielleicht:
write/send für einen Leak zu bauen| Baustein | Wozu |
|---|---|
| Stop gadget | Ausführung „einfrieren“ / Timeout → Signal „hier ging’s noch“ |
| Probe | Adressen systematisch testen |
| Leak gadget | Speicher nach draußen schicken |
| Restart | Server startet Worker neu → viele Versuche möglich |
| | ROP | BROP |
|--|-----|------|
| Binary | meist vorhanden | oft nicht |
| Gadgets | aus Datei suchen | remote finden |
| Aufwand | mittel–hoch | sehr hoch, spezielles Setup |
Auf AlienZone brauchst du BROP nur, wenn die Challenge wirklich blind/remote denkt. Viele Extrem-Module geben dir das Binary — dann ist klassisches Reverse + ROP/Heap oft der kürzere Weg.
BROP ist ein Notfall-Werkzeugkasten, kein Default für jede Pwn-Challenge. Verstehe ROP und Debugging zuerst.
Ohne Leak oft kein ASLR-Bypass. Leaks können sein:
%p)Ein guter Leak spart drei Raten — dokumentiere Adressen und Offsets.
Manche Challenges erlauben nach dem Exploit nur noch wenige Syscalls (seccomp). Dann reicht „shell“ nicht — du brauchst open/read/write der Flag-Datei oder einen erlaubten Pfad.
Lies Challenge-Text und Fehlercodes — Sandbox-Hinweise stehen oft zwischen den Zeilen.
In der glibc-Welt haben viele Exploit-Muster Spitznamen (House of …). Du musst sie nicht alle auswendig können — aber die Landkarte kennen.
| Name (Idee) | Grob |
|---|---|
| House of Force | top chunk size → riesige Allocation steuern |
| House of Spirit | fake chunk freigeben / umleiten |
| House of Orange | fsop / unsorted bin → IOFILE (historisch) |
| Tcache poisoning | freelist-Pointer überschreiben (modern) |
Oft reicht eine klare Primitive + ein Leak. Nicht 20 Papers lesen, bevor das Binary da ist.
How2Heap (shellphish) ist die Referenz — nach dem ersten UAF-Erfolg.
C++-Objekte mit virtuellen Methoden haben oft einen VTable-Pointer am Objektanfang. Ruft man eine virtuelle Methode auf, springt der Code über diese Tabelle.
Wenn du Objekt-Speicher überschreibst:
system / One-Gadget / stack pivot_ZTV…)Nicht jedes C++-Programm ist VTable-Pwn — erst Objekt-Layout und Overflow/UAF finden.
Fake VTable + RIP-Kontrolle ist ein Extrem-Klassiker in C++-Challenges.
Userland-Exploits laufen im Prozess. Kernel-Bugs betreffen den privilegierten Kern — oft schwieriger, mächtiger, und in CTFs als eigene Kategorie.
.ko)QEMU + busybox-Rootfs ist Standard-Lab. AlienZone-Hub ist primär Userland — dieses Thema ist Orientierung für später.
Ohne stabiles Userland-Pwn (Stack, Heap, ROP) lohnt Kernel selten.
Manchmal leakt die Zeit oder das Fehlerverhalten mehr als die Ausgabe.
Login/Oracle: „wrong user“ vs „wrong password“ in unterschiedlicher Zeit/Response.
# Pseudocode: median over N tries per guess
Side-Channels brauchen Statistik und Geduld — und ein Orakel.
Jenseits von klassischem XSS gibt es die Welt der Engine-Exploits (V8, SpiderMonkey, WebKit): Type Confusion, OOB in JIT, WASM-Bugs.
Meist: absichtlich gebaute JS-Engines oder vereinfachte Interpreter-Challenges. Lies, welche Engine und welche Version.
Heap/Type Confusion aus Userland-Pwn hilft; reines „alert(1)“ reicht hier nicht.
Für AlienZone: XSS (Mittel) zuerst. Browser-Pwn ist Marathon, kein Sprint.
Viele Extrem-Web/Network-Module sprechen kein reines HTTP, sondern ein Custom-Protokoll (Länge + Opcode + Payload).
Protokoll verstehen = halbe Challenge. Dann erst Payload.
Am Extrem-Ende gewinnt, wer Schutzmechanismen kombiniert denkt.
| Mitigation | Blockiert primär | Braucht oft |
|---|---|---|
| NX/DEP | Shellcode auf Stack/Heap | ROP / vorhandene Funktionen |
| ASLR/PIE | feste Adressen | Leak |
| Canary | naive Stack-Overflows | Leak / partielle Überschreibung |
| RELRO | GOT-Overwrite | andere Write-Primitiven |
| Fortify / CFI | manche overflow patterns | andere Bugs |
| seccomp | execve-Shell | ORW / erlaubte Syscalls |
Extrem-CTF ist oft Mitigation-Puzzle, nicht nur „Overflow finden“.
Lernpfad, Blogs, Dokus und Nachschlagewerke (DE + EN) — zum Vertiefen und Mitlernen.
Stufen und Themen sind verlinkbar, z. B.:
/learning#level-medium/learning#topic-xss/learning#topic-brop/learning#level-resourcesDiscord im Footer — spoilerarm fragen.
Wissen ist Macht — Üben im Hub macht den Unterschied.
https://aethersec.de — deutschsprachiger Security-/CTF-Blog rund um Analyse, Exploitation und Praxis.
Writeups, Technik-Erklärungen und Einblicke aus dem AlienZone-/AetherSec-Umfeld. Gut als Begleitung zu den Hub-Modulen und diesem Learning-Bereich.
Starte dort, wenn du DE-sprachige Vertiefung und aktuelle Posts willst.
| Quelle | Inhalt / Hinweis |
|---|---|
| https://aethersec.de | DE-Blog: CTF, Analyse, Praxis — empfohlen |
| BSI — Bürger-CERT / Grundschutz-Themen | Solide DE-Grundlagen zu IT-Sicherheit (nicht CTF-spezifisch, aber sauber) |
| OWASP (DE-Inhalte / Cheat Sheets EN) | Web-Sicherheit: XSS, Injection, Top-Risiken — Standard |
| HackTricks (EN, sehr praxisnah) | Riesiges Nachschlagewerk zu Web/PrivEsc/… — zum Nachschlagen, nicht auswendig |
| PayloadsAllTheThings | Payloads & Cheats zu vielen Vuln-Klassen — nur im erlaubten Labor/CTF |
Kombiniere eine gute DE-Erklärung mit einer EN-Referenz, statt 20 Tabs offen zu haben.
| Quelle | Sprache | Inhalt / Hinweis |
|---|---|---|
| PortSwigger Web Security Academy | EN | Kostenlose Labs: XSS, SQLi, SSRF, … — goldener Einstieg |
| OWASP Cheat Sheet Series | EN | Kompakte Gegenmaßnahmen & Konzepte |
| MDN Web Docs | DE/EN | HTML/JS/HTTP nachschlagen — Pflicht für Web-CTFs |
| Can I use | EN | Browser-Features (selten CTF, oft nützlich) |
| JWT.io | EN | Tokens dekodieren (nur CTF/eigene Tokens) |
Zuerst Konzept (dieses Learning), dann ein Lab-Pfad auf PortSwigger.
| Quelle | Sprache | Inhalt / Hinweis |
|---|---|---|
| https://aethersec.de | DE | Praxisnahe Posts zu Analyse/Exploitation |
| LiveOverflow (YouTube) | EN | Sehr gute Video-Erklärungen zu Binary/CTF |
| pwn.college | EN | Strukturierter Binary-Pfad (akademisch, top) |
| how2heap | EN | Heap-Allocator-Demos — fortgeschritten |
| ROPgadget | EN | Gadget-Suche |
| pwntools docs | EN | Python-Exploit-Helper |
| Ghidra | EN | Kostenloser Disassembler/Decompiler |
| x64dbg | EN | Windows-Debugger |
| checksec | EN | Binary-Protections anzeigen |
man 3 printf — Format-Spezifizierer verstehen Pwn ohne Reverse ist Blindflug — Tools und Lesen trainieren.
| Quelle | Sprache | Inhalt / Hinweis |
|---|---|---|
| Linux man-pages | EN | open, read, Syscalls — die Wahrheit |
| Microsoft Learn / Docs | DE/EN | Windows-APIs, PE-Konzepte |
| Windows Internals (Buch, EN) | EN | Sysinternals-Tools + Hintergrund |
| explainshell.com | EN | Shell-Befehle zerlegen |
| tldr pages | EN | Kurze Kommando-Beispiele |
Ein Terminal-Cheat und die Manpage schlagen zehn zufällige Blogposts.
| Quelle | Sprache | Inhalt / Hinweis |
|---|---|---|
| CryptoHack | EN | Interaktive Crypto-Rätsel |
| CyberChef | EN | Encode/Decode/Analyse im Browser |
| Wireshark docs | EN | PCAP-Analyse |
| Volatility | EN | Memory-Forensik (fortgeschritten) |
Crypto in CTFs oft „knackbare“ Schwächen — erst Encoding, dann echte Crypto.
| Quelle | Inhalt / Hinweis |
|---|---|
| https://aethersec.de | DE — nicht EN, aber hier verlinkt als Heimblog |
| CTFtime writeups | Event-Writeups indexieren — nach Event suchen |
| HackTricks | Enzyklopädisch, gut zum Nachschlagen |
| 0x00sec | Forum/Artikel (Qualität variiert — kritisch lesen) |
| Team-Blogs (z. B. führende CTF-Teams) | Suche: „CTF writeup <challenge name>“ |
Writeups sind Nachschlagewerk — kein Ersatz für Denken.
| Quelle | Inhalt / Hinweis |
|---|---|
| GTFOBins | Linux-Binaries missbrauchen (PrivEsc-Labor) |
| LOLBAS | Windows Living-off-the-Land |
| ss64.com | CMD/PowerShell/Bash-Referenz |
| Regex101 | Regex bauen und testen |
| Canarytokens / eigene Lab-Notes | Eher Awareness — im CTF selten |
Baue dir eine eigene Notizdatei pro Tool (10 Befehle, die du wirklich brauchst).
| Quelle | Inhalt / Hinweis |
|---|---|
| AlienZone /note | Plattform, AV-False-Positives, CTF-Kontext |
| BSI | DE-Grundlagen sicherer IT |
| OWASP | Verantwortungsvolle Web-Security-Kultur |
Skill ohne Ethik ist nur Risiko — auf AlienZone trainieren wir ethisch.
Schnelle Übersicht — Details in den anderen Ressourcen-Kacheln.
#level-easy → … → #level-extremeEin großes Nachschlagewerk lebt von Links + eigener Übung — nicht von 100 offenen Tabs.