xssearch

Fortgeschrittenes XSS-Erkennungstool, geschrieben in Rust, das kontextbewusste Payload-Intelligenz mit der Injektionsbreite kombiniert.

Dieses Tool wurde von XSStrike und XSSER inspiriert. Die Payloads wurden aus verschiedenen Quellen gesammelt:

• https://github.com/ardakocadoru/xss-cheatsheet
• https://github.com/Proviesec/xss-payload-list
• https://cheatsheetseries.owasp.org/cheatsheets/XSS_Filter_Evasion_Cheat_Sheet.html
• https://github.com/swisskyrepo/PayloadsAllTheThings

Danke Leute, ihr seid großartig ❤️

Warnung: Nur gegen Systeme verwenden, die Sie besitzen oder für die Sie eine ausdrückliche schriftliche Genehmigung zum Testen haben.

Funktionen

• Kontextbewusstes Scannen – sondiert zuerst jeden Parameter, erkennt, wo der Wert reflektiert wird (HTML-Body, Attribut, JavaScript, Kommentar, <title>, <textarea> usw.) und wählt die für diesen Kontext am besten geeigneten Payloads aus, anstatt blind alles abzufeuern
• Über 100 integrierte Payloads – HTML-Tags, Attribut-Ausbrüche, JS-Injektion, Polyglots, DOM-Sinks, WAF-Bypass-Varianten
• WAF-Erkennung & -Bypass – Fingerprinting von Cloudflare, ModSecurity, Sucuri, Imperva, Akamai, AWS WAF, F5 BIG-IP, Barracuda, Wordfence; wendet WAF-spezifische Bypass-Transformationen an (Groß-/Kleinschreibungsmutation, Kommentareinfügung, Zero-Width-Zeichen und Kodierung)
• Crawler – durchsucht Links und Formulare, um injizierbare Parameter automatisch zu entdecken
• Header- & Cookie-Injektion – testet Referer, User-Agent, X-Forwarded-For, X-Real-IP und andere Header sowie Cookie-Werte
• Blind XSS – injiziert Out-of-Band-Callback-Payloads (kompatibel mit Burp Collaborator, interactsh) in jeden Sink für Szenarien mit verzögerter Ausführung (Admin-Panels, Log-Viewer und Ähnliches)
• DOM-XSS-Analyse – statische Untersuchung von innerHTML, eval, document.write, location.href, jQuery .html() und anderen gefährlichen Sinks mit Quellenerkennung
• Payload-Kodierung – URL-, Doppel-URL-, HTML-Entity-, Unicode- und base64/eval-Kodierung mit kombinierbaren Flags
• JSON-Ausgabe – strukturierte Ergebnisse für die Integration mit anderen Tools
• Markdown-Bericht – menschenlesbarer Bericht mit einer Schweregrad-Übersichtstabelle, Detailabschnitten pro Fund und einer Schnellreferenztabelle; bereit zum Einfügen in ein Wiki oder Anhängen an ein Ticket
• Reines Rust/rustls – keine OpenSSL-Abhängigkeit; einzelne quasi-statische Binärdatei

Installation

Aus dem Quellcode (Nix)

git clone https://github.com/fabian-affolter/xssearch
cd xssearch
nix-shell --run "cargo build --release"
# binary: target/release/xssearch

Release-Build mit LTO und entfernten Symbolen:

nix-shell --argstr release true --run "$BUILD"

Aus dem Quellcode (Standard)

Erfordert Rust 1.75+.

cargo build --release

Nixpkgs

Für Nix- oder NixOS-Nutzer ist ein Paket verfügbar. Beachten Sie, dass die neuesten Releases möglicherweise nur im unstable-Kanal vorhanden sind.

nix-env -iA nixos.xssearch

Verwendung

xssearch [OPTIONS] <--url <URL> | --file <URLS_FILE>>

Optionen

Flag	Beschreibung
-u, --url <URL>	Ziel-URL. Verwenden Sie FUZZ, um einen benutzerdefinierten Injektionspunkt zu markieren
-f, --file <FILE>	Datei mit einer URL pro Zeile
-d, --data <DATA>	POST-Body. Verwenden Sie FUZZ, um den Injektionspunkt zu markieren
-H, --header <H>	Zusätzlicher Request-Header, wiederholbar
--cookie <COOKIE>	Cookie-String
--proxy <URL>	HTTP/HTTPS-Proxy
--timeout <N>	Request-Timeout in Sekunden (Standard: 10)
--user-agent <UA>	Benutzerdefinierter User-Agent
--follow-redirects	HTTP-Redirects folgen
--threads <N>	Gleichzeitige Requests (Standard: 2)
--delay <MS>	Verzögerung zwischen Requests in Millisekunden
--crawl	Ziel nach Links und Formularen durchsuchen
--crawl-depth <N>	Crawl-Tiefe (Standard: 3)
--headers-inject	Gängige HTTP-Header als Injektionspunkte testen
--cookie-inject	Cookie-Werte als Injektionspunkte testen
--blind <URL>	Blind-XSS-Callback-URL
--dom	Statische DOM-XSS-Sink-Analyse
--fuzz	Alle Payloads abfeuern, unabhängig vom Reflexionskontext
--payload-set <SET>	all | html | js | attr | poly | dom | mxss | waf (Standard: all)
--payloads-file <FILE>	Benutzerdefinierte Payload-Datei, eine pro Zeile
--encode <LIST>	Kommagetrennte Kodierungen: url,html,unicode,double,base64
--prefix <STR>	String jedem Payload voranstellen
--suffix <STR>	String an jeden Payload anhängen
--waf-detect	WAF vor dem Scannen per Fingerprint identifizieren
--waf-bypass	WAF-Bypass-Transformationen auf Payloads anwenden
--output-json <FILE>	Ergebnisse in JSON-Datei schreiben
--output-md <FILE>	Ergebnisse in Markdown-Datei schreiben
-v, --verbose	Ausführliche Ausgabe (Kontext anzeigen, alle Sonden)
-V, --version	Version ausgeben und beenden

Beispiele

Einfacher GET-Parameter-Scan

xssearch -u "https://example.com/search?q=test"

POST-Formular

xssearch -u "https://example.com/login" -d "user=admin&pass=FUZZ"

Von der Wurzel crawlen, WAF erkennen, Header testen

xssearch -u "https://example.com/" --crawl --waf-detect --headers-inject -v

WAF-Bypass mit URL- + HTML-Kodierung

xssearch -u "https://example.com/?q=FUZZ" --waf-detect --waf-bypass --encode url,html

Blind XSS mit interactsh-Callback

xssearch -u "https://example.com/contact" -d "msg=FUZZ" \
  --blind "https://abc123.oast.fun/xssearch"

Nur DOM-XSS-Statikanalyse

xssearch -u "https://example.com/app" --dom --no-banner

Ergebnisse als JSON speichern

xssearch -u "https://example.com/?q=test" --output-json results.json

Ergebnisse als Markdown speichern

xssearch -u "https://example.com/?q=test" --output-md report.md

Beide Formate gleichzeitig speichern

xssearch -f targets.txt --crawl --waf-detect --output-json results.json --output-md report.md

Proxy über Burp Suite

xssearch -u "https://example.com/?q=test" --proxy http://127.0.0.1:8080 -v

Testen

Lokales minimales Ziel

Der schnellste Weg, das Tool zu verifizieren, ist, lokal einen absichtlich verwundbaren Python-Server hochzufahren:

python3 - <<'EOF'
import http.server, urllib.parse

class H(http.server.BaseHTTPRequestHandler):
    def log_message(self, *a): pass
    def do_GET(self):
        p = urllib.parse.urlparse(self.path)
        q = urllib.parse.parse_qs(p.query)
        val = q.get('q', [''])[0]
        body = f'<html><body><p>Search: {val}</p></body></html>'.encode()
        self.send_response(200)
        self.send_header('Content-Type', 'text/html')
        self.end_headers()
        self.wfile.write(body)

http.server.HTTPServer(('127.0.0.1', 9999), H).serve_forever()
EOF

Dann scannen Sie es:

xssearch -u "http://127.0.0.1:9999/?q=test" -v

Erwartete Ausgabe: [Vuln] XSS in 'q' mit einem HTML-Kontext-Payload.

Lokale Docker-Ziele

Diese Images sind speziell für das Testen von Sicherheitstools entwickelt und enthalten keine echten Benutzerdaten.

DVWA (Damn Vulnerable Web Application)

docker run -d -p 8080:80 vulnerables/web-dvwa
# Set security level to Low in the UI first
xssearch -u "http://localhost:8080/vulnerabilities/xss_r/?name=test" \
  --cookie "PHPSESSID=<your-session>; security=low"

OWASP WebGoat

docker run -d -p 8081:8080 webgoat/goat-and-wolf
xssearch -u "http://localhost:8081/WebGoat/" --crawl --crawl-depth 2 -v

OWASP Juice Shop

docker run -d -p 3000:3000 bkimminich/juice-shop
xssearch -u "http://localhost:3000/" --crawl --dom -v