Critical Java and nginx flaws Java4Shell + nginx2rootScan my domain
Apache RollerJavaRCECVEVulnerabilityDeserialization

CVE-2026-129448: unauthenticated deserialization in Apache Roller's XML-RPC interface

CVE-2026-129448: pre-authentication deserialization in XML-RPC of Apache Roller 4.0.0 to 6.1.5, exploited according to Apache. Fix in 6.1.6, workaround.

by 20 min read
CVE-2026-129448: unauthenticated deserialization in Apache Roller's XML-RPC interface

Context

On 17 November 2026, the Apache Software Foundation published CVE-2026-129448 for Apache Roller, its blog engine written in Java. The advisory describes a deserialization of untrusted data in the XML-RPC interface, reached before any authentication, which allows code execution on the server. It also contains a sentence Apache advisories rarely carry: the flaw is being actively exploited.

The flaw itself is old. The same defect had received a first identifier, CVE-2026-82384, on 25 September, and version 6.1.6 had fixed it the day before. But that first record declared only one version affected, 6.1.5. The second extends the range to everything before it, back to 4.0.0.

The gap between the two records is the real subject of this article. For fifty-three days, the operator of a Roller 6.1.4, 6.0 or 5.2 who read the September advisory could conclude in good faith that they were not affected. They were, and the fix that showed where to look had been public since the end of August.

We did not reproduce the flaw and ran none of the public exploits. We read Apache's two announcements, the two CVE records, the fix, and the configuration Roller ships across several versions, from 4.0 to 6.1.7. For real-world exploitability, we rely on the lab work of an independent researcher, cited below.

Technical summary

ItemValue
IdentifiersCVE-2026-129448 (versions 4.0.0 to 6.1.4) and CVE-2026-82384 (version 6.1.5), same defect
ComponentRoller's XML-RPC servlet, path /roller-services/xmlrpc
ClassCWE-502, deserialization of untrusted data
SeverityCVSS 3.1 of 9.8 from Apache, AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H
Affected versionsApache Roller 4.0.0 to 6.1.5
FixApache Roller 6.1.6 (24 September 2026); current version 6.1.7 (11 November 2026)
ConditionNone: default configuration, no authentication
Discoveryn0mi1k; Apache also credits Matt Raible for the report that led to the second CVE
ExploitationStated by Apache on 17 November, without detail; public exploit code; absent from the KEV

The 9.8 score assumes a simple attack (AC:L). That is accurate for reaching the deserialization: a single request is enough, with no account and no particular configuration. Getting from there to code execution depends on what the installation bundles, and we will see that a recent Roller and a ten-year-old Roller do not tell the same story.

We would not use that nuance to lower the priority. A deserialization reached without authentication on an internet-facing service is handled as critical, all the more so when the vendor says it sees it exploited. Our triage method is described in the article on vulnerability prioritisation.

Affected systems

Two records for one flaw

The first announcement, sent on 25 September to Apache's announce list, gives "Apache Roller 6.1.5" as the affected versions and nothing else. The second, sent on 17 November to the Roller users list, states "4.0.0 before 6.1.5" and adds that it is the same vulnerability.

Read together, they do cover the whole range. Read alone, the second is confusing: its title carries the words "releases before 6.1.5", and several articles and vulnerability databases concluded that 6.1.5 was the fixed version. That is wrong. 6.1.5 is the version the first record targeted, and the fix only arrives in 6.1.6.

We wanted to check the lower bound instead of copying it. The setting at fault, enabledForExtensions set to true on the XML-RPC servlet, is present in the web.xml file of every version we opened in the repository: 4.0, 4.0.1, 5.0, 6.0.0 and 6.1.5. The range Apache announces therefore matches what the code shows.

One detail in passing: the git repository carries no tag for 6.1.4, although Apache's download archive does contain a v6.1.4 directory. We did not try to explain the discrepancy. It changes nothing about what to do, since both versions are affected.

The administration setting does not count

Roller offers an "enable XML-RPC" checkbox in its administration interface (webservices.enableXmlRpc). It is unchecked by default, as the settings definition file of 6.1.5 confirms. An administrator who has never used an external blogging client may therefore believe the XML-RPC interface is closed on their installation.

It is not. The servlet is declared unconditionally in web.xml and answers on its path whatever the state of the checkbox. The setting is only consulted later, by the functions that handle the call, once the request has been fully parsed. And parsing is where the problem lies.

The practical consequence is that every Roller installation in the range is affected, whether it uses XML-RPC or not. No default configuration protects, and there is no subset of installations to leave out of the inventory.

What limits the reach

Roller is niche software, nowhere near the large content management systems. We found no published count of exposed installations, at Censys or at Shadowserver, and we will not give one.

That small number only half reassures us. A blog engine installed long ago, for a company blog or an internal technical blog opened to the internet, is the kind of service nobody updates and that has dropped out of inventories. Those are the installations where the flaw is easiest to exploit, for a reason explained below.

How it works

This section relies on Apache's two advisories, on the fix and on our reading of Roller's configuration. We stay at the level of detail of the public advisories.

XML-RPC and its extension types

XML-RPC is an old remote procedure call protocol in which the request is an XML document sent by POST. Roller uses it for the Blogger and MetaWeblog interfaces, which let writing software publish a post without going through the browser. In those interfaces, the username and password travel as ordinary parameters of the call.

Roller does not handle the protocol itself. It relies on the Apache XML-RPC library and declares its servlet as is. The library knows the value types of the standard (strings, integers, arrays) and adds "extension" types of its own. One of them carries a serialized Java object.

Those extensions are off by default in the library. Roller switched them on explicitly, through the enabledForExtensions parameter, although its interface has no use for them. The description of the fix says so plainly: Roller uses only the standard types.

Parsing that comes before any check

When a request arrives, the library first parses the whole XML document and rebuilds each value. If one of them is of the serialized extension type, it deserializes it at that point. The name of the method called, the credentials supplied and the state of the administration checkbox are only examined afterwards.

Deserialization therefore happens before anyone has checked anything. The request can name a method that does not exist and carry a wrong password: the object has already been rebuilt by the time the server notices.

Kill chain

From the XML-RPC request to deserialization

  1. 1

    Anonymous request

    the attacker sends a POST to /roller-services/xmlrpc, without an account.

  2. 2

    Servlet always reachable

    it answers even when XML-RPC is disabled in the administration.

  3. 3

    Extension value

    the request contains a serialized Java object, of a type Roller had enabled without using it.

  4. 4

    Deserialization

    the library rebuilds the object during parsing, before any identity check.

  5. Code execution

    depending on the libraries present on the server, rebuilding the object triggers code chosen by the attacker.

Reconstructed from Apache's advisories and the fix. We did not reproduce these steps.

From deserialization to code execution

Deserializing an object is not enough to run a command. The attacker has to compose the object from classes already present on the server, so that rebuilding them chains calls up to the desired effect. Those chains have been known and catalogued for about ten years, and they depend on the exact versions of the installed libraries.

This is where the age of the installation comes in. Yanis Alim, of Tuxshin Security, built a lab with the official binaries of versions 6.1.4 to 6.1.7 on a recent JDK 11. He confirms that deserialization is reached in 6.1.4 and in 6.1.5. He also finds that the usual chains fail on that configuration: the bundled Commons Collections library refuses to deserialize its dangerous classes, and the JDK blocks the other classic route. He only obtained code execution by relaxing a JDK protection, and does not publish his object.

That result holds for a recent Roller on a recent Java, and says nothing about the rest. We looked at what the older versions declare. The Commons Collections protection dates from its version 3.2.2. Roller 6.0.0 does declare that version, but Roller 5.0.1 declares 3.2.1 and Roller 4.0 ships 3.2, neither of which has that safeguard. We did not open the archive of every version in between, and the installed JDK weighs as much as these libraries.

The reading we draw from it is simple. The older the installation, the more exploitation looks like what the 9.8 score promises. And old installations are exactly the ones the September record did not flag.

A precedent from 2016

The library's behaviour is not a discovery. CVE-2016-5003 already described code execution through a serialized object in an extension element of Apache XML-RPC 3.1.3, in Apache Archiva at the time.

Roller bundles that same version 3.1.3 in every version we looked at from 5.1.1 to 6.1.7, the fixed one included. The fix does not touch the library, it stops enabling the option. Any other application that declares this servlet with enabledForExtensions set to true is in Roller's position, and a serious inventory would look for that parameter beyond Roller.

The fix

The fix fits in a single pull request, number 171 of the apache/roller repository, titled "Disable vendor extension types on the XML-RPC servlet". It does two things.

The first is to set enabledForExtensions to false in web.xml. The library then rejects any value of an extension type during parsing, and ordinary calls keep working. The tests added by the fix check both cases.

The second is a filter, XmlRpcEnabledFilter, placed in front of the servlet. While XML-RPC is disabled in the administration, it answers 404 with the text "XML-RPC service is disabled" and the request no longer reaches the library. The administration checkbox finally does what its label says.

The two measures complement each other, and we find the correction well designed. The first removes the cause. The second shrinks the surface for most installations, those that never enabled XML-RPC, and would protect them from another defect in the same library.

6.1.6 or 6.1.7

6.1.6 is enough for this flaw. We would still install 6.1.7, released on 11 November, which fixes fifteen other flaws. One of them, CVE-2026-123374, is a second deserialization of untrusted data, in the handling of responses to update pings. Apache rates it "important".

Roller's security page lists eighteen CVEs for 6.1.6 and fifteen for 6.1.7, thirty-three in seven weeks for a project that used to publish very few. A volume like that suggests the code was reviewed systematically. For the operator, it mostly means that an installation left on 6.1.5 or below accumulates all of those flaws, and not only the one being discussed this week.

When we read that same page on 19 November, it did not yet mention CVE-2026-129448. It only showed CVE-2026-82384, filed under the 6.1.6 fixes. Anyone relying on it to learn the affected versions still finds only 6.1.5 there.

Exploitation status

The 17 November advisory contains one sentence, "This issue is being actively exploited", and no detail. Apache does not say since when, against which versions, or what the attackers do once inside. BleepingComputer, which relayed the advisory the next day, obtained nothing more.

The other sources do not confirm, without contradicting either. The flaw is absent from the KEV catalog in its 18 November version, which we reread on the 19th. The assessment CISA attaches to the CVE record, dated 18 November, still reads "exploitation: none". We found no measurement published by a honeypot operator.

We take Apache's word. A vendor has no interest in writing that one of its projects is under attack if it is not, and CISA's assessment is a field filled in when the record is received, not the result of an investigation. The second CVE itself is hard to explain otherwise: nobody reopens a file closed two months earlier without a reason. That is our hypothesis, which the advisory does not state.

Public exploit code since September

The calendar is harsh on old installations. A first demonstration repository appeared on GitHub on 28 September at 08

UTC, eight minutes after the NVD record for CVE-2026-82384 went online. Its description advertises a check, an exploit and a mass-scanning mode. A second one, with a lab, was published on 18 November. We ran neither.

The fix was readable well before that. The pull request was opened publicly on 29 August, with a title and a description that name the option and the path, and merged on 5 September. The fixed version came out on the 24th. For nearly four weeks, anyone following the repository could understand the defect while no fixed version existed.

We do not hold that against the project: a public repository does not offer many other ways of working, and the description of the fix stays sober. But what follows comes from it. On 25 September, users of 6.1.5 are told to update, and the others are told nothing. Public exploit code, for its part, makes no difference between a 6.1.5 and a 5.0. The window during which old versions were exploitable without their operators knowing therefore runs from 28 September to 17 November.

Checking an installation

The reliable check is made in the files of the deployed application. Two lines of web.xml are enough to settle it:

# Parameter value: "true" on an affected version, "false" from 6.1.6 onwards
grep -A1 'enabledForExtensions' /path/to/webapps/roller/WEB-INF/web.xml
 
# Presence of the filter added by the fix: 0 before 6.1.6
grep -c 'XmlRpcEnabledFilter' /path/to/webapps/roller/WEB-INF/web.xml

If the application server does not unpack the archive, the same reading is done inside the .war file:

unzip -p /path/to/roller.war WEB-INF/web.xml | grep -A1 'enabledForExtensions'

That reading is better than the version number the application displays. It covers what is actually deployed, and it stays correct on an installation where the workaround was applied by hand.

From the outside

A plain GET request gives partial information, without sending anything that looks like an attack:

curl -s -i https://blog.example.com/roller-services/xmlrpc | head -n 20

If the answer is a 404 whose body contains "XML-RPC service is disabled", the filter from the fix answered: the installation is at least on 6.1.6 and XML-RPC is disabled there. We take that reading from the code of the fix, not from a test.

Any other answer is inconclusive. A fixed version on which XML-RPC has been enabled lets the request through to the servlet, as an affected version does. Mind the prefix too: depending on the deployment, the path is /roller-services/xmlrpc or /roller/roller-services/xmlrpc.

The public tools go further and send a harmless serialized object to watch how the server reacts. We would only do that on our own machines. It is still a deserialization provoked on the target, and a GitHub repository created eight minutes after a CVE record is not a program to run without reading it.

Remediation

  1. Update to Roller 6.1.7, or 6.1.6 at the very least.
  2. Restart the application server and check web.xml in the deployed application, not in the downloaded archive.
  3. Look for forgotten installations. A Roller that has not been updated for years is rarely in the inventory.
  4. Review the logs before considering the matter closed, for the reasons given in the next section.

Workaround

Apache gives two workarounds for those who cannot update right away, each to be followed by a restart of Roller.

The first is the one in the fix: set enabledForExtensions to false in WEB-INF/web.xml. It is the one we would apply, because it removes the cause without taking anything away from legitimate XML-RPC clients.

<init-param>
    <param-name>enabledForExtensions</param-name>
    <param-value>false</param-value>
</init-param>

The second is to remove the servlet-mapping declaration for /roller-services/xmlrpc from web.xml. The interface disappears entirely, which suits an installation that does not use it perfectly well.

Both share the same weak point: they change a file of the deployed application. Redeploying the original archive, by a script or by a colleague, puts the vulnerable setting back without warning. Until the update is done, we would therefore add a block on the path at the reverse proxy.

We would not settle for that block alone. A proxy and a Java application server do not always normalise a path the same way, and a rule written on the URL is easier to get around than a setting applied in the application.

Finally, it bears repeating because the mistake is tempting: unchecking XML-RPC in the administration does nothing on an affected version. Apache's advisory says so itself.

Looking for compromise

Apache has published no indicator. The ones below come from the analyses by Corgea and Tuxshin Security, and from our reading of the fix. We have not tested them against a real attack.

The first signal is in the access logs: any POST request to /roller-services/xmlrpc. On an installation where XML-RPC was never enabled, no legitimate client has a reason to send one, and every line deserves a look. The search should go back at least to the end of August, when the fix became readable.

grep -h 'roller-services/xmlrpc' /path/to/tomcat/logs/localhost_access_log.* | grep '"POST'

Access logs do not record request bodies. If a proxy or a web application firewall keeps them, look for the ex:serializable element and the namespace of the Apache XML-RPC extensions, which Roller's legitimate traffic never uses. The string rO0AB, the usual start of a Base64-encoded Java object, is a weaker clue.

On the application side, Tuxshin notes that a deserialization failing for lack of a class leaves the message "Failed to load class for result object", and stack traces that mention SerializableParser or ObjectInputStream. On a fixed version, a different line is worth searching for: the filter logs "XML-RPC service is disabled; rejecting request" for every request it refuses. It signals no compromise, but it shows that someone is probing that path.

Then come the traces of a successful execution: a shell or a download tool launched by the Java process, unusual outbound connections, .jsp files that appeared or changed in the applications directory, a Roller administrator account nobody created.

If one of these signals is confirmed, updating is no longer enough. The compromised process had access to Roller's configuration file and its database credentials, and to the authors' password hashes. All of that has to be rotated, and the machine examined as a system on which a third party has run code.

Timeline

Timeline

Timeline of CVE-2026-129448

Fix

  1. 29 August 2026

    Public pull request

    the fix is proposed on the repository, with the option and the path in its description.

  2. 5 September 2026

    Merge

    pull request number 171 is merged.

  3. 24 September 2026

    Roller 6.1.6

    first fixed version, with seventeen other security fixes.

First record

  1. 25 September 2026, 20

    CVE-2026-82384

    Apache's announcement, which declares only version 6.1.5 affected.

  2. 28 September 2026, 08

    First public code

    a demonstration repository appears eight minutes after the NVD record.

Second record

  1. 11 November 2026

    Roller 6.1.7

    fifteen security fixes, including another deserialization.

  2. 17 November 2026, 11

    CVE-2026-129448

    the range is extended back to 4.0.0, and Apache reports active exploitation.

  3. 18 November 2026

    Aftermath

    second public code, with a lab. CISA's assessment still reads "exploitation: none".

  4. 19 November 2026

    Status on that date

    flaw absent from the KEV catalog, no detail published about the attacks.

Dates taken from the apache/roller repository, Apache's mailing lists, the NVD and GitHub. Times in UTC.

What this flaw says about security advisories

A security advisory is read by people in a hurry, looking for the answer to one question: am I affected? The "affected versions" line is the one they read, and often the only one. When it is too narrow, the advisory does worse than saying nothing, since it reassures the people it should alert.

We do not know why the first record stopped at 6.1.5. The most likely explanation is mundane: the version on which the defect was reported and verified gets declared, and nobody walks back through the history. It is half an hour of work, which we did for this article by opening five web.xml files.

For an operator, the lesson goes beyond Roller. When an advisory names a single version while the defect comes from a setting or a dependency, it is better to check whether that setting exists on your side than to compare numbers. And software nobody has touched for years does not leave the scope because an advisory does not mention it. You still have to know it exists, which leads back to inventorying your external attack surface.

Frequently asked questions about CVE-2026-129448

What is CVE-2026-129448?

It is a deserialization of untrusted data in Apache Roller's XML-RPC interface. A request sent without authentication makes the server rebuild a Java object supplied by the attacker, which can lead to code execution.

How does it differ from CVE-2026-82384?

In substance it does not, it is the same defect. CVE-2026-82384, published on 25 September 2026, declared only version 6.1.5 affected. CVE-2026-129448, published on 17 November, covers versions 4.0.0 to 6.1.4.

Which versions of Apache Roller are affected?

Every version from 4.0.0 to 6.1.5 inclusive. 6.1.5 is not fixed, contrary to what some articles suggest. The fix is in 6.1.6, and the current version is 6.1.7.

XML-RPC is disabled on my installation, am I protected?

No, not on an affected version. The request is parsed, and the object deserialized, before that setting is consulted. It only really closes the interface from 6.1.6 onwards.

Is the flaw being exploited?

Apache says so in its 17 November 2026 advisory, without detail. As of 19 November, it is not in CISA's KEV catalog and no independent measurement has been published. Exploit code has been public since 28 September.

Does code execution work on every installation?

Deserialization is reached everywhere. Code execution depends on the installed libraries and JDK. A researcher found that the usual methods fail on a Roller 6.1.x with a recent Java. Older versions bundle libraries without those protections.

What if the update cannot be done right away?

Set enabledForExtensions to false in WEB-INF/web.xml, or remove the /roller-services/xmlrpc servlet mapping, then restart Roller. Blocking that path at the reverse proxy complements the measure without replacing it.

Sources

Let’s discuss your external exposure

Request a personalized Flawfence demo and discover your real exposure level.