Automated Threat Modeling

Brief Summary: Apache Roller CVE-2026-129448, Unauthenticated XML-RPC Deserialization RCE

A brief summary of CVE-2026-129448, an unauthenticated deserialization flaw in the Apache Roller XML-RPC endpoint affecting versions 4.0.0 through 6.1.4, with patch and detection details.

CVE Analysis

9 min read

Gaurav Sarraf
Gaurav Sarraf

2026-11-17

Brief Summary: Apache Roller CVE-2026-129448, Unauthenticated XML-RPC Deserialization RCE

Introduction

An unauthenticated attacker who can reach an Apache Roller blog server can hand it a base64-encoded Java object and have it deserialized before any login check runs, turning a single XML-RPC request into remote code execution. Apache confirms this issue, CVE-2026-129448, is being actively exploited, and the published affected range now reaches back to Roller 4.0.0.

Apache Roller is a Java-based, multiuser and group blog server used for blogs of various sizes, with features such as Apache Velocity templates, Lucene search, RSS and Atom feeds, and MetaWeblog API support. It became an Apache Software Foundation project in 2007 and has a long history of use, including Sun Microsystems' employee blogging site and JRoller. Because it is a self-hosted Java web application, exposed instances tend to sit directly on the public internet behind a servlet container such as Tomcat.

Technical information

The vulnerability is a classic CWE-502 Deserialization of Untrusted Data issue. What makes it severe is where in the request lifecycle the deserialization happens.

Roller exposes a legacy XML-RPC servlet mapped at /roller-services/xmlrpc. That servlet is backed by the Apache ws-xmlrpc library. In addition to the standard XML-RPC value types (string, int, struct, and so on), the library supports non-standard vendor extension value types. One of those extension types is ex:serializable, which carries a base64-encoded Java serialized object. When the library encounters this type while parsing a request, it turns the base64 blob back into a live Java object.

Root cause

Before the fix, Roller's web.xml set the XML-RPC servlet's enabledForExtensions init-param to true, even though Roller itself never uses these extension types and relies only on the standard XML-RPC value types. With extensions enabled, the ws-xmlrpc parser accepts an ex:serializable element and deserializes its payload as part of request parsing.

Two problems compound each other:

  1. Deserialization happens before authentication. The advisory states plainly that the endpoint deserializes extension types "before authenticating the requester." Blogger and MetaWeblog credential checks run inside the method handlers, which execute only after the request body has been parsed and the object reconstructed.
  2. The administration toggle is checked too late. The servlet is mapped unconditionally, so request parsing happens even when XML-RPC is disabled. In older versions, Roller consulted the runtime feature setting only after parsing, so disabling XML-RPC in the administration UI did not prevent the deserialization path. No non-default configuration is required for the vulnerable path to be reachable.

Attack flow

Based on the briefing and the documented request shape, exploitation proceeds as follows:

  1. The attacker locates a Roller instance and the XML-RPC endpoint at POST /roller-services/xmlrpc (context-path variants such as /roller/roller-services/xmlrpc and a bare /xmlrpc are also probed).
  2. The attacker sends a methodCall with Content-Type text/xml that embeds an ex:serializable element, bound to the extensions namespace http://ws.apache.org/xmlrpc/namespaces/extensions, containing a base64-encoded Java serialized object.
  3. The ws-xmlrpc library deserializes the embedded object during parsing, before any authentication or feature-setting check.
  4. With a suitable gadget chain present on the classpath, deserialization leads to arbitrary code execution as the servlet container's operating system user.

The documented request shape from the public PoC README is:

<methodCall> <methodName>system.listMethods</methodName> <params><param><value> <ex:serializable xmlns:ex="http://ws.apache.org/xmlrpc/namespaces/extensions"> BASE64_JAVA_SERIALIZED_OBJECT </ex:serializable> </value></param></params> </methodCall>

The sources do not establish a particular serialized gadget chain as a prerequisite, the precise operating system account, or additional environment-specific conditions, so those details should not be assumed from the CVSS score alone. Apache publishes the CVSS 3.1 vector CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H with a score of 9.8, Critical.

Relationship to CVE-2026-82384

CVE-2026-129448 and CVE-2026-82384 describe the same vulnerability. They are not two stages of a chain. CVE-2026-82384 originally listed only Apache Roller 6.1.5 as affected. CVE-2026-129448 expands the documented historical exposure to cover 4.0.0 through 6.1.4. Upgrading only to 6.1.5 does not resolve this issue.

Patch information

The fix ships in Apache Roller 6.1.6. The Apache advisory recommends 6.1.6 or later because that release turns off the XML-RPC extension types and rejects XML-RPC requests when the XML-RPC feature is disabled. Inside Roller, the fix comes from pull request #171, "Disable vendor extension types on the XML-RPC servlet." It was merged into master on 2026-09-05 as merge commit 3b67aa9c055b2c2003b69e4dde1887d273e03eeb and carries the 6.1.6 label, changing three files with 263 lines added and 1 removed.

PR #171 adds two separate protections that reinforce each other.

1. Extension types are turned off (web.xml)

The enabledForExtensions init-param on the XML-RPC servlet changes from true to false. A new comment explains that Roller only uses the standard XML-RPC value types, so the extension types are switched off. With this setting, the library's parser refuses extension-typed values, and attacker-supplied serialized objects are never turned back into objects. Ordinary Blogger and MetaWeblog calls are not affected.

2. A disabled endpoint is closed before parsing (XmlRpcEnabledFilter)

The second change fixes the ordering problem. A new servlet filter checks the webservices.enableXmlRpc runtime setting before any request reaches the XML-RPC servlet:

if (!WebloggerRuntimeConfig.getBooleanProperty("webservices.enableXmlRpc")) { LOG.warn("XML-RPC service is disabled; rejecting request"); HttpServletResponse httpResponse = (HttpServletResponse) response; httpResponse.setStatus(HttpServletResponse.SC_NOT_FOUND); httpResponse.setContentType("text/plain;charset=UTF-8"); httpResponse.getWriter().write("XML-RPC service is disabled"); return; } chain.doFilter(request, response);

The filter is registered in web.xml and mapped to /roller-services/xmlrpc for the REQUEST, FORWARD and INCLUDE dispatchers. Covering forwards and includes as well as direct requests means internal routing cannot get around the check. When XML-RPC is off (the default), the request gets a plain-text 404 and never reaches the XML-RPC library, so nothing is parsed or deserialized. Before, the endpoint relied on checks inside each handler. Now the on/off setting is enforced at the servlet entry point.

The two changes back each other up. Sites with XML-RPC disabled never parse requests at all, while sites that need XML-RPC still parse requests but with extension types refused.

Regression tests

The PR adds XmlRpcExtensionTypeTest, which checks that:

  • the shipped web.xml sets enabledForExtensions to false
  • XmlRpcEnabledFilter is mapped to /roller-services/xmlrpc with all three dispatchers
  • an ordinary blogger.getUsersBlogs call still parses with extensions disabled
  • a request using an extension type throws an error when extensions are disabled
  • a disabled endpoint returns a 404 text/plain response and never calls the rest of the filter chain

The tests read the real web.xml file, so if a later change turns the setting back on, the build fails.

PR #164, also labeled 6.1.6, was merged the same day. The advisory does not list it as the CVE fix. It makes the Blogger and MetaWeblog handlers check the caller's weblog or entry permissions for each method. The 6.1.6 release notes describe both changes together: the handlers "answer a disabled endpoint before doing any authentication work," and "Vendor extension types are disabled on the XML-RPC servlet."

Version 6.1.6 is the minimum documented fix for this issue, which is not the same as saying it resolves all known Roller security issues. Apache's November 10, 2026 announcement recommends 6.1.7 for every installation because it fixes 15 further security vulnerabilities, including issues affecting 6.1.6.

Detection methods

The attack has a single target, the legacy XML-RPC servlet at /roller-services/xmlrpc. Because the servlet stays mapped even when an admin turns XML-RPC off in the UI, an instance that "has XML-RPC disabled" still needs monitoring.

1. Request-level inspection (WAF, reverse proxy, IDS body inspection)

This check has the highest fidelity. The documented attack surface is:

  • Endpoint: POST /roller-services/xmlrpc. Watch for the context-path variant /roller/roller-services/xmlrpc and a bare /xmlrpc.
  • Content-Type: text/xml.
  • Trigger: an ex:serializable element inside a methodCall, bound to the namespace http://ws.apache.org/xmlrpc/namespaces/extensions.

Legitimate Roller traffic should never contain an ex:serializable element or the extensions namespace URI, because Roller relies only on the standard XML-RPC value types. The base64 content will usually be a Java serialization stream. The PoC's built-in probe value begins rO0AB, which is base64 for the Java serialization header, so that prefix is a useful extra hunting string inside the element. Plain web access logs only record method, path and status, so you need body logging on a WAF, reverse proxy or network sensor to see the payload.

2. Log and response hunting (no body visibility)

If you only have access logs, start from the endpoint itself. On sites that never use the Blogger or MetaWeblog APIs, any POST to the XML-RPC path is worth investigating. The PoC treats an HTTP 500 on that path as a sign the deserialization path was reached. It also scans responses for deserialization error strings such as InvalidClassException, StreamCorruptedException, ObjectInputStream, NotSerializableException and deserializ. The same exception names appearing in Tomcat or Roller logs right after an XML-RPC request are a strong sign that someone sent a malformed or gadget payload.

3. Scanner fingerprint

The public check/exploit tool can be recognised by its behaviour:

  • fingerprinting GET requests to /, /roller-ui/, /roller-ui/login.rol and /roller/
  • a harmless system.listMethods POST to each candidate XML-RPC path for endpoint discovery
  • an ex:serializable probe when --probe-deser is set or the version is not confirmed patched
  • by default, a PoCbit (+https://pocbit.org) tag added to a Chrome User-Agent string

That tag is trivial to change, so it is a low-cost bonus rather than a dependable indicator. The tool has a threaded mass mode, so expect bursts of this sequence across many hosts.

4. Post-exploitation signals

The PoC suggests two ysoserial gadgets. URLDNS provides an out-of-band DNS callback used as proof, so watch for DNS lookups of unfamiliar or OAST-style domains coming from the Roller/Tomcat JVM host. CommonsCollections6 is used for command execution as the Tomcat/Roller OS user, so endpoint telemetry should alert when the servlet container's Java process launches shells or other unexpected child processes. These signals rest on the documented gadgets, not on published campaign IoCs.

5. Exposure and configuration auditing

To find instances, the PoC README lists these FOFA internet-scan queries:

body="Apache Roller" body="/roller-ui/" body="/roller-services/xmlrpc" title="Roller"

On each host, read the deployed WEB-INF/web.xml and check whether enabledForExtensions is still true and whether the /roller-services/xmlrpc servlet mapping is present. The CVE record says the admin-UI toggle does not close the hole on older versions, so the UI setting is not proof of safety. The PoC's check mode fingerprints Roller, finds the endpoint and can send a probe, but its version logic was written for 6.1.5. It flags 6.1.0 through 6.1.5 as vulnerable and returns "unknown" for 4.x and 5.x, so read results with the wider 4.0.0 through 6.1.4 range in mind.

Scoping notes and gaps

Do not confuse this CVE with CVE-2026-123374, a separate Roller deserialization flaw fixed in 6.1.7 that lives in the XML-RPC client (Roller deserializes object data from responses to weblog update pings). Inbound rules on /roller-services/xmlrpc will not catch it. At the time of this writing there were no public CVE-specific Snort/Suricata, Sigma or YARA rules, vendor IPS signature, or campaign IoCs, and no public Nuclei template. Until vendor content appears, the most reliable detection is to alert on the ex:serializable body pattern at the XML-RPC endpoint.

Affected systems and versions

  • Vulnerable: Apache Roller versions 4.0.0 through 6.1.4 (per CVE-2026-129448).
  • Also affected: Apache Roller 6.1.5, as originally documented under CVE-2026-82384, which describes the same vulnerability. Upgrading only to 6.1.5 does not resolve this issue.
  • Fixed: Apache Roller 6.1.6 or later disables the vendor extension types and rejects XML-RPC requests when the feature is disabled. Apache also recommends 6.1.7, which fixes 15 further security vulnerabilities, some of which affect 6.1.6.

The default configuration is affected. No non-default setup is required, and disabling XML-RPC in the administration UI does not protect older versions because the request body is parsed before that setting is checked.

Vendor security history

Roller's published policy routes suspected vulnerabilities privately to [email protected]. Accepted reports receive a CVE identifier, a fix, and a release, with security fixes shipped on the current release line rather than patched in place on older releases.

The release history shows why a single fixed version is not a blanket security guarantee. CVE-2025-24859, published April 14, 2025, concerned insufficient session expiration after password changes, where existing sessions remained usable after a credential change. Roller 6.1.5 fixed that issue through centralized session management that invalidates active sessions when passwords change or users are disabled. That same 6.1.5 release is affected by this separate XML-RPC deserialization vulnerability. Likewise, 6.1.6 repairs this deserialization flaw but is affected by other issues fixed in 6.1.7, whose fixes include XML external entity processing, administrative CSRF, and deserialization of weblog update responses. A precise minimum fixed version and a broader upgrade recommendation can both be correct at once.

References

Detect & fix
what others miss

Works with
  • GitHub
  • GitLab
  • Bitbucket
  • Azure DevOps Services
  • Gerrit
  • CVS
  • Jira
  • Linear
  • Slack
  • Security Compass
Explore integrations
Security magnifying glass visualization