critical

CVE

CVE-2026-129448, CVE-2026-82384

CWE

CWE-502, CWE-306

Affected Surface

  • Apache Roller 4.0.0 through 6.1.4 (`CVE-2026-129448`, published 17 November 2026, actively exploited per Apache)
  • Apache Roller 6.1.5 (`CVE-2026-82384`, published 25 September 2026)
  • Any Roller deployment where `/roller-services/xmlrpc` is reachable, including sites that switched XML-RPC off in the admin UI

TL;DR

Apache Roller is a Java blog server that usually runs as a WAR in Tomcat. It exposes the old Blogger and MetaWeblog APIs over XML-RPC at /roller-services/xmlrpc. That servlet was configured with enabledForExtensions=true, which tells the Apache XML-RPC library to accept vendor extension types. One of those types, <ex:serializable>, is a base64-encoded Java serialized object. The library deserializes it while parsing the request body, before Roller looks at credentials or checks whether XML-RPC is even enabled.

Apache first disclosed this in September as CVE-2026-82384 and listed only Roller 6.1.5 as affected. On 17 November it published CVE-2026-129448 to say the same bug affects every release from 4.0.0 through 6.1.4, and that it is being actively exploited. A Python PoC has been public on GitHub since 28 September. Both CVEs are CVSS 9.8.

What to do now:

  1. Upgrade to Roller 6.1.7 (released 11 November, it also fixes 15 other CVEs). 6.1.6 is the first release with this fix.
  2. If you can’t upgrade today, set enabledForExtensions to false in WEB-INF/web.xml, or delete the /roller-services/xmlrpc servlet mapping, and restart. Turning XML-RPC off in the Roller admin UI does not protect older versions.
  3. Block POST /roller-services/xmlrpc at your reverse proxy or WAF unless you actually use a desktop blogging client.
  4. If the endpoint was reachable from the internet, check the host for compromise before you patch over it (see below).

Affected packages and projects

EcosystemPackageAffected versionsFixed or safe version
Java web application (WAR)Apache Roller4.0.0 through 6.1.4 (CVE-2026-129448)6.1.6 or later; 6.1.7 recommended
Java web application (WAR)Apache Roller6.1.5 (CVE-2026-82384)6.1.6 or later; 6.1.7 recommended

Roller ships as a download from roller.apache.org rather than as a Maven Central library, so dependency scanners that only read pom.xml or lockfiles won’t flag it. You need to look at what’s deployed.

EPSS for CVE-2026-82384 was 0.0099 (63rd percentile) on 16 November, before Apache’s exploitation notice. FIRST had no score yet for CVE-2026-129448. Neither CVE was in CISA KEV when we checked on 17 November.

Technical analysis

1. The vulnerable configuration

This is the XML-RPC servlet definition and mapping in Roller 6.1.5’s app/src/main/webapp/WEB-INF/web.xml:

<servlet>
    <servlet-name>XmlRpcServlet</servlet-name>
    <servlet-class>org.apache.xmlrpc.webserver.XmlRpcServlet</servlet-class>
    <init-param>
        <description>
            Sets whether the servlet supports vendor extensions for XML-RPC.
        </description>
        <param-name>enabledForExtensions</param-name>
        <param-value>true</param-value>
    </init-param>
</servlet>

<servlet-mapping>
    <servlet-name>XmlRpcServlet</servlet-name>
    <url-pattern>/roller-services/xmlrpc</url-pattern>
</servlet-mapping>
  • org.apache.xmlrpc.webserver.XmlRpcServlet is the stock servlet from the Apache XML-RPC (ws-xmlrpc) library. It parses the whole methodCall body into Java objects before it dispatches to Roller’s Blogger or MetaWeblog handler.
  • enabledForExtensions=true turns on the library’s non-standard types, including ex:serializable. The parser for that type passes the decoded bytes to ObjectInputStream.readObject(). This is the same library behavior behind CVE-2016-5003 in Apache Archiva.
  • The servlet-mapping has no condition. The endpoint is live on every install, and the webservices.enableXmlRpc switch in the admin UI was only checked later, inside Roller’s handlers. By then the object had already been deserialized.
  • Authentication is also a handler concern (the username and password are parameters of each Blogger/MetaWeblog call), so it runs after parsing too.

Roller doesn’t use any of the extension types, so turning them on bought nothing and exposed a deserialization sink to anonymous users. Whether the sink becomes code execution depends on which gadget classes are in the WAR’s WEB-INF/lib and Tomcat’s classpath. The public PoC’s README points to ysoserial for building the gadget chain.

2. The fix (PR #171, merged 5 September 2026, first released in 6.1.6)

The patch makes two changes. It flips the init parameter so the library rejects extension types:

             <param-name>enabledForExtensions</param-name>
-            <param-value>true</param-value>
+            <param-value>false</param-value>

And it adds a servlet filter in front of the endpoint so that a disabled XML-RPC service is closed at the URL rather than inside each handler:

+    <filter-mapping>
+        <filter-name>XmlRpcEnabledFilter</filter-name>
+        <url-pattern>/roller-services/xmlrpc</url-pattern>
+        <dispatcher>REQUEST</dispatcher>
+        <dispatcher>FORWARD</dispatcher>
+        <dispatcher>INCLUDE</dispatcher>
+    </filter-mapping>
public void doFilter(ServletRequest request, ServletResponse response,
                     FilterChain chain) throws IOException, ServletException {
    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 runs before XmlRpcServlet reads the body. With XML-RPC off, the request gets a 404 and the parser never sees it. With XML-RPC on, the first change still stops ex:serializable from being decoded. Either change alone would have closed the unauthenticated path for most sites. Apache shipped both.

3. What an attack request looks like

The PoC repository describes a plain POST with Content-Type: text/xml to /roller-services/xmlrpc (or /roller/roller-services/xmlrpc when Roller isn’t the root context). The body is an ordinary methodCall whose parameter is an extension value. This is an illustrative skeleton with the gadget removed:

<?xml version="1.0"?>
<methodCall xmlns:ex="http://ws.apache.org/xmlrpc/namespaces/extensions">
  <methodName>blogger.getUsersBlogs</methodName>
  <params>
    <param><value><ex:serializable>rO0ABX...BASE64-JAVA-SERIALIZED-OBJECT...</ex:serializable></value></param>
  </params>
</methodCall>

The method name doesn’t matter, because the object is deserialized during parsing. rO0AB is the base64 form of the Java serialization magic bytes AC ED 00 05, which makes a good WAF and log signature.

4. Why the version range changed

The September advisory said “Roller 6.1.5” only. The enabledForExtensions=true setting and the unconditional servlet mapping go back much further, and Apache’s 17 November notice widens the range to 4.0.0 through 6.1.4 and confirms exploitation. Anyone who read the September advisory, saw an older version and decided they were safe has been exposed for the past seven weeks while a public PoC was available.

IOCs

Apache has not published attacker IPs, payloads or post-exploitation artifacts. Hunt for the technique:

  • POST requests to /roller-services/xmlrpc or /roller/roller-services/xmlrpc, especially from clients that have never used XML-RPC before, or with unusually large bodies.
  • Request bodies containing ex:serializable, http://ws.apache.org/xmlrpc/namespaces/extensions, or rO0AB.
  • Child processes of the Tomcat JVM (sh, bash, curl, wget, python, powershell.exe) and new outbound connections from the Tomcat user.
  • New or modified .jsp files under Tomcat’s webapps/ directories, and unexpected Roller admin accounts.

Detection and remediation

Find the version and the risky setting on each host:

# Exploded WAR under Tomcat
ROLLER=${CATALINA_BASE:-/opt/tomcat}/webapps/roller
grep -A1 'enabledForExtensions' "$ROLLER/WEB-INF/web.xml"
grep -c 'XmlRpcEnabledFilter' "$ROLLER/WEB-INF/web.xml"   # 0 = pre-6.1.6

# Packed WAR
unzip -p roller.war WEB-INF/web.xml | grep -A1 'enabledForExtensions'

Any <param-value>true</param-value> after enabledForExtensions means the host is exposed.

Check from outside whether the endpoint answers. This sends a harmless standard call with no extension types:

curl -s -o /dev/null -w '%{http_code}\n' -X POST -H 'Content-Type: text/xml' \
  --data '<?xml version="1.0"?><methodCall><methodName>system.listMethods</methodName></methodCall>' \
  https://blog.example.com/roller-services/xmlrpc

On 6.1.6 or later with XML-RPC disabled you should get 404 and the body XML-RPC service is disabled. A 200 means the servlet is parsing requests, so make sure the version and enabledForExtensions are right, or block the path.

Search access and WAF logs for past attempts:

zgrep -hE '"POST [^"]*/roller-services/xmlrpc' /var/log/nginx/access.log* \
  ${CATALINA_BASE:-/opt/tomcat}/logs/localhost_access_log.* 2>/dev/null \
  | awk '{print $1}' | sort | uniq -c | sort -rn | head

# If your WAF or proxy logs request bodies
zgrep -lE 'ex:serializable|rO0AB' /var/log/waf/* 2>/dev/null

Temporary mitigation if you can’t upgrade:

sed -i '/<param-name>enabledForExtensions<\/param-name>/{n;s/true/false/}' "$ROLLER/WEB-INF/web.xml"
# then restart Tomcat

or at an nginx front end:

location ~* /roller-services/xmlrpc { return 404; }

If the endpoint was exposed to the internet on a vulnerable version:

  1. Preserve logs and take a disk snapshot before you change anything.
  2. Rebuild the host from a clean image with Roller 6.1.7 rather than patching in place.
  3. Rotate the database credentials in roller-custom.properties, any mail or LDAP credentials Roller uses, and anything else the Tomcat user could read (cloud instance credentials, SSH keys, deployment tokens).
  4. Review Roller users and weblog templates for unexpected admins and injected scripts.

Timeline

  • 2026-09-05: PR #171 merges (3b67aa9c05), disabling vendor extensions and adding XmlRpcEnabledFilter.
  • 2026-09-24: Roller 6.1.6 released with the fix and 17 other CVEs, per the Roller security page.
  • 2026-09-25: Apache announces CVE-2026-82384 on the Roller lists and oss-security, listing only 6.1.5 as affected. Credit: n0mi1k.
  • 2026-09-28: Public PoC repository murrez/cve-2026-82384 is created.
  • 2026-11-11: Roller 6.1.7 released with 15 more CVE fixes.
  • 2026-11-16: EPSS for CVE-2026-82384 is 0.0099.
  • 2026-11-17 11:02 UTC: Apache announces CVE-2026-129448 for Roller 4.0.0 through 6.1.4, states the issue is being actively exploited, and credits Matt Raible as reporter. NVD publishes the record at 11:17 UTC.

From research to remediation

Check whether this pattern exists in your codebase

Turn this research into a remediation workflow. Use AI-native static analysis to find similar application vulnerabilities and generate review-ready fixes.

References