// news

Apache Roller CVE-2026-129448: Exploited Pre-Auth RCE, Upgrade to 6.1.6

Apache Roller CVE-2026-129448 cover: exploited pre-auth XML-RPC RCE, upgrade to Roller 6.1.6

The Apache Software Foundation says attackers are actively exploiting CVE-2026-129448, a CVSS 9.8 deserialization flaw in Apache Roller's XML-RPC endpoint that lets anyone run code on the server without logging in. Every Roller release from 4.0.0 through 6.1.4 is affected, and the fix is 6.1.6 or later. Do not stop at 6.1.5, the only version a September advisory for the same bug listed as affected.

Key takeaways

  • ASF confirms active exploitation of CVE-2026-129448 (CVSS 9.8), a pre-auth RCE in Apache Roller's XML-RPC endpoint.
  • Affected: Roller 4.0.0 through 6.1.4. The September advisory for the same bug (CVE-2026-82384) listed only 6.1.5, so upgrade to 6.1.6 or later.
  • Disabling XML-RPC in the admin UI does nothing on older builds, because deserialization happens before the setting is checked.
  • Workarounds: set enabledForExtensions to false in WEB-INF/web.xml or remove the /roller-services/xmlrpc mapping, then restart.
  • Exposed instances need a compromise assessment. Attackers never show up in login records because the bug fires before authentication.

What did ASF disclose about Apache Roller CVE-2026-129448?

ASF disclosed a pre-authentication remote code execution bug in Roller’s XML-RPC endpoint and confirmed that attackers are using it. The maintainers’ description: “Deserialization of Untrusted Data in Apache Roller versions 4.0.0 through 6.1.4 allows an unauthenticated remote attacker to execute arbitrary code.”

The root cause is just as short: “The XML-RPC endpoint accepts vendor extension types and deserializes them before authenticating the requester.” Roller’s XML-RPC interface lets blog clients post and manage entries remotely. Vendor extension types let a request carry richer data than the base spec defines.

Roller rebuilds those objects first and checks the caller second. In Java, rebuilding an object graph that an attacker controls is a well-documented route to code execution. The attacker influences which classes get instantiated and which methods run during reconstruction. No password, no session, no account.

On exploitation, ASF said only: “This issue is being actively exploited.” The Hacker News (Ravie Lakshmanan, 18 November 2026) noted that ASF “did not share any details on how the vulnerability is being exploited, or who is being targeted.” Security Affairs carried the same news.

No threat actor, campaign name, sector, victim count or CVSS vector string has been published. ASF credits researcher n0mi1k with finding the flaw and acknowledges Matt Raible for reporting it.

Injected code runs as the Roller Java process, typically the Tomcat service account. That is not root, but it does not need to be. The account can read the database credentials in the application config, and it owns the blog content. In many Tomcat deployments it can also write to the webapp directory, a common place to drop a webshell.

Which Apache Roller versions are actually affected?

Treat every Roller install from 4.0.0 through 6.1.4 as vulnerable, do not rely on 6.1.5, and move to 6.1.6 or later. The confusion comes from ASF’s own paperwork.

In September 2026, ASF patched CVE-2026-82384, which was also rated 9.8. ASF now says that bug and CVE-2026-129448 are the same issue. The two advisories list very different affected versions:

September 2026 November 2026
CVE CVE-2026-82384 CVE-2026-129448
CVSS 9.8 9.8
Affected versions listed 6.1.5 only 4.0.0 through 6.1.4
Exploitation Not stated Confirmed active
Fixed release Not named in coverage 6.1.6 or later

Neither advisory, as reported, explains how those ranges fit together, and we won’t guess. The cautious reading is that the September list was incomplete.

That has a practical consequence. Suppose someone compared an old 4.x or 5.x box against “6.1.5 only” in September and concluded it was safe. If the cautious reading is right, that conclusion has been wrong for two months: the underlying flaw was never fully patched, and it is now confirmed exploited.

The inclusive range spans three major release lines. Long-lived corporate and project blogs on 4.x and 5.x are often installs that nobody has touched in years, running on Tomcat hosts that nobody remembers owning.

Roller 6.1.6 changes two things. It disables the vendor extension types, and it rejects XML-RPC requests when the XML-RPC feature is turned off. The second change matters more than it sounds.

Why the admin UI toggle does not stop the request

Turning off XML-RPC in Roller’s administration UI does not protect older versions, because the server deserializes the request before it reads that setting. ASF says so directly: “Disabling XML-RPC in the administration UI is not enough, because older versions deserialize the request before checking that setting.”

This is a control-placement bug. The toggle is a policy check that runs after the parser. By the time the code asks whether XML-RPC is enabled, it has already rebuilt the attacker’s object, and the side effects have already run.

The admin screen shows XML-RPC as off. Someone ticks the box in the change ticket. The endpoint keeps answering.

That makes exposure a network question, not an identity question. It does not matter whether your staff use XML-RPC or how strong the blog passwords are. What matters is whether an untrusted network can reach /roller-services/xmlrpc on a vulnerable build.

For many installs it can. Roller commonly serves a public corporate, community or project blog from Tomcat, and the XML-RPC path shares the site’s host and port.

Insecure deserialization falls under OWASP’s software and data integrity failures category, and the toggle makes it harder to spot. A check that reads configuration state will report the endpoint as closed. Only a live request proves otherwise. That is why we test pre-auth parsers by hand in OWASP Top 10 penetration testing instead of trusting the admin screen.

What to change if you cannot upgrade today

If an upgrade has to wait, ASF offers two configuration workarounds. Both require a restart before they take effect.

  1. Disable extension types. In the deployed application’s WEB-INF/web.xml, set enabledForExtensions to false, then restart Roller.
  2. Remove the endpoint. Delete the /roller-services/xmlrpc servlet mapping from WEB-INF/web.xml, then restart Roller.

Do not skip the restart. Tomcat loads servlet configuration at startup, so if you fix the file on disk while the old mapping is still live in memory, you have protected nothing. Edit the instance that actually serves traffic, not a copy in a source archive or an old deploy directory.

Blocking the path at a reverse proxy or WAF is reasonable defense in depth, and across a fleet it buys time quickly. It does not fix the code. Attackers get around edge rules through alternate hostnames, direct-to-origin access and path normalization quirks. Keep the proxy rule, and still make the web.xml change or ship the upgrade.

Patching closes the door. It does not evict anyone who already walked through it. Any Roller instance that was reachable while attackers were exploiting the flaw needs a compromise assessment, not just a version bump.

How should an AppSec team verify exposure?

Verify three things: the version that is actually deployed, whether the XML-RPC mapping is reachable from outside, and whether anyone used it before you closed it.

  • Inventory. Find every Roller deployment, including those on marketing, community and dev hosts. Read the version from the running application, not from the ticket that says someone upgraded. Anything from 4.0.0 through 6.1.5 needs action.
  • Configuration. On the deployed app, search WEB-INF/web.xml for enabledForExtensions and /roller-services/xmlrpc. Confirm that the flag is false or the mapping is gone, and that the service was restarted afterward.
  • Reachability. From a network outside your perimeter, confirm that the endpoint no longer exists or that a 6.1.6 instance rejects extension-type requests. A check against localhost tells you nothing about the proxy path that internet traffic takes.
  • Logs. Preserve access logs, Roller and Tomcat application logs, and web.xml before log rotation or a redeployment wipes them. Look for unexplained inbound requests to the XML-RPC path, deserialization errors and unusual class-loading stack traces.
  • Host. Check for unexpected child processes spawned by the JVM, new or modified files in the webapp directories, JSP files that look like webshells, outbound connections from the Tomcat process and unusual use of the application’s database credentials.

Login records will not help you here. The bug fires before authentication, so attackers never appear among successful logins, and a clean login history proves nothing. ASF has published no victim list, and a lack of alerts does not mean attackers skipped your instance.

On older Java blog and CMS deployments, the XML-RPC endpoint is one of the first things we find, usually because the owning team forgot it existed. The pattern we see most often: someone disables a feature in the admin console, closes the ticket, and the servlet keeps responding on the same URL for years.

Our rule for this fix is blunt. It isn’t done until someone outside your network sends a request to the endpoint and gets refused or a 404. That retest belongs in any web application penetration testing that covers the host, along with a review of what the Tomcat account can read and write.

What is still unknown about the Roller XML-RPC vulnerability?

ASF has disclosed almost nothing about the attacks themselves: who is exploiting the flaw, since when, against which organizations, or through what delivery path. ASF has not said whether exploitation began before the September patch, and the reports name no sectors or countries.

No CVSS vector string has been published for either CVE, and ASF has not explained why the September advisory listed only 6.1.5. For indicators of compromise, rely on the vendor advisory rather than secondhand lists.

If ASF or a responding vendor publishes telemetry later, scope your retrospective reviews generously. Start the review window no later than September 2026, and earlier for any host running 4.x or 5.x.

FAQ

Is CVE-2026-129448 the same bug as CVE-2026-82384?

Yes, according to ASF. CVE-2026-82384 was patched in September 2026 with only Roller 6.1.5 listed as affected. CVE-2026-129448 covers 4.0.0 through 6.1.4 and confirms active exploitation.

Do I need credentials to exploit Apache Roller XML-RPC deserialization?

No. The XML-RPC endpoint deserializes vendor extension types before it authenticates the requester, so anyone who can reach /roller-services/xmlrpc on a vulnerable build can trigger the flaw.

Is Apache Roller 6.1.5 a complete fix?

Do not treat it as one. ASF's current guidance names 6.1.6 or later as the fixed release, and the two advisories' version lists have not been reconciled.

What does Roller 6.1.6 change?

It disables the vendor extension types and rejects XML-RPC requests when the XML-RPC feature is turned off. Older versions did neither.

Is disabling XML-RPC in the Roller admin UI enough?

No. Older versions deserialize the request before they check that setting. Use one of the web.xml workarounds followed by a restart, or upgrade to 6.1.6.

Who found the flaw, and did ASF name any targets?

ASF credits researcher n0mi1k with finding the flaw and acknowledges Matt Raible for reporting it. ASF named no threat actor, targets, sectors or victim count.

If you run Roller or similar long-lived Java apps on the public internet, our application security testing team can confirm that the endpoint is really closed and check what an attacker could have reached through the Tomcat account.


// get started

Work with AgentOffense

Tell us about your target and goals. We’ll reply with scope and a fixed-price quote — usually within one business day.

./request_engagement