GCSA Insights: vCenter zero-day vulnerability leads to domain controller database theft; Wagyu XMR1 stolen and cashed out 13.51 million USDC.

vCenter's zero-day vulnerability led to the theft of its domain controller database; Wagyu XMR1 was stolen and subsequently sold off for 13.51 million USDC.

wg1mtrU3Xx62nC71inehLKeGpnIKvw4FNxN5XpPc.jpg
Introduction

A domain controller can lose its database while operating normally. In an incident disclosed by Mandiant and Google's threat intelligence team, ARMORY CASTLE, after gaining access to the internal network, exploited a VMware vCenter zero-day vulnerability to gain administrative privileges on the virtualization platform. He then gained access to the ESXi host and extracted the Active Directory database from the domain controller's virtual disks. This incident pushed the enterprise's risk boundary beyond the domain controller: gaining administrative privileges to read the domain controller's virtual disks and access to sensitive data within the domain controller.

In the digital asset market, the consequences of compromised permissions are directly reflected in the order book. Attackers transferred 5.2 million XMR1 tokens from Wagyu's deployer account, selling 369,623 of them on Hyperliquid, cashing out approximately 13.51 million USDC. XMR1 plummeted from around $500 to around $1. Fluidkey disclosed that a third-party logging tool leaked session data, revealing that unauthorized transactions were signed when users opened the app and then relayed to six chains by official intermediaries. On-chain tracking shows at least $1.58 million flowed to addresses associated with the attackers. Fluidkey stated that user private keys always remain on the device.


Two other threat intelligence reports revealed easily overlooked entry points. A real-world intrusion into Cisco Expressway extended from two public network devices to two internal network nodes within the same cluster. An Apache Roller vulnerability has been added to the CISA Known Exploited Vulnerabilities (KEV) list. In the affected version, the system processes XML-RPC requests before checking background switches, so simply disabling this feature in the management interface is insufficient to prevent attacks.

The following is the full text of the original analysis report:


01. VMware vCenter 0-day CVE-2026-123890 has been exploited by ARMORY CASTLE: Unauthenticated users can obtain SRP session keys, impersonate [email protected], and then use Golden SAML to migrate to ESXi.

Daily Security Insights (Event Analysis) | November 21, 2026 | All times in this article are Tokyo time (UTC+9)

On November 19th (US time), Broadcom released VMSA-2026-0009, patching the authentication bypass vulnerability CVE-2026-123890 in VMware vCenter directory service (vmdird), CVSS 9.8. The official statement noted that "no temporary mitigation measures are available." On the same day, Mandiant, which discovered and reported the vulnerability, and the Google Threat Intelligence Group (GTIG) released details of their forensic investigation: ARMORY CASTLE (formerly UNC5221), which GTIG classifies as a suspected Chinese-linked spy organization, had already used its self-developed tool BONESAW as a zero-day exploit in early September 2026. After gaining root privileges in vCenter, they forged SAML tokens, enabled SSH, stole the master key, and finally directly extracted the domain controller's NTDS database from a virtual disk on ESXi. CISA included the vulnerability in its KEV on November 20th (US time), and the deadline for federal agencies to patch it is November 23rd.

This incident deserves to be discussed separately for two reasons: First, the vulnerability lies in vCenter's Single Sign-On (SSO) authentication chain, and breaching it is equivalent to obtaining the key to the entire virtualization platform; second, the attacker did not directly attack vCenter from the Internet, but first used another zero-day exploit to enter the internal network, and then found vCenter laterally—this means that "vCenter is not open to the public" does not exempt it from this risk.

I. Event Timeline

Table1:Timeline ofCVE-2026-123890Utilization and Disclosure

Time (Tokyo timeUTC+9)

event

Source/Evidence

2026-07-13 18:21

BONESAW's Go binary embedded build timestamp is 2026-07-13T09:21:24Z (Mandiant indicates that this metadata can be modified).

Mandiant / GTIG Report

July 29, 2026 (US time)

Another vmdir authentication bypass vulnerability, CVE-2026-59309 (LDAP ports 389/636), is publicly exposed.

Mandiant / GTIG Report

Early September 2026

ARMORY CASTLE executed BONESAW on a patched CVE-2026-59309 vCenter, creating an SSO administrator and exporting the LMDB database.

Mandiant Log Evidence Collection

October 15, 2026 (US time)

Mandiant/GTIG disclosed that the group exploited BeyondTrust Remote Support 0-day CVE-2026-102764 (which has been patched in BT26-05).

Mandiant / GTIG Previous Report

2026-11-19 (US time)

Broadcom released VMSA-2026-0009 to fix CVE-2026-123890 (Workarounds: None); Mandiant/GTIG released "ARMORY CASTLE Exploits vSphere"

Broadcom Announcement; Google Cloud Blog

2026-11-21 02:48

CISA KEV data source updated (2026-11-20T17:48Z), includes CVE-2026-123890, requiring pre-treatment and evidence collection triage by 11-23.

CISA KEV JSON / CISA Announcement

II. What is the vulnerability: The SRP session key was obtained by an unauthenticated person.

Single sign-on in vCenter is handled by VMware Directory Service (process vmdird), which, in addition to the common LDAP ports 389/636, also provides a DCE/RPC control interface over TCP 2012. Internal vCenter components can use this interface for password authentication using theSRP-6a(Secure Remote Password) protocol. The design goal of SRP is that the client and server can each calculate the same shared session key K without transmitting the password. Whoever can calculate K is considered the legitimate party who knows the password. Therefore, the entire security of SRP rests on the fact that "only the person who knows the password can calculate K."

According to the Mandiant report and the French CERT Santé announcement, CVE-2026-123890 is caused by the fact that the SRP authentication interface (which Mandiant refers to as the rpc_srp_verifier service) can predict the UUIDv1 timestamp generated. An attacker can then obtain the SRP session key K based on this predictability, without needing to know any password. The UUIDv1 itself is composed of a timestamp, a clock sequence, and a node identifier, designed for "uniqueness" rather than "secrecy." Once used in an authentication process requiring unpredictability, an attacker can deduce its value based on the time. After obtaining K, the attacker can establish a session authenticated using the [email protected] (vSphere SSO's highest-privilege built-in account).

After successful authentication, an attacker can invoke another RPC interface of vmdird, vmdirdbcp. Mandiant points out that this interface can be used to execute arbitrary commands and obtain files, the most critical of which is /storage/db/vmware-vmdir/data.mdb—vSphere SSO's LMDB database, which stores the RSA private key used by the Security Token Service (STS) to issue SAML tokens. Mandiant's published BONESAW YARA rules list these elements together: the database path, the beginning of the SRP 2048-bit prime number N, and the UUIDs of the two DCE/RPC interfaces, vmdirdbcp and the SRP verification interface (Figure 1).

RF03k0g22AMSiqx9x8lLfNH7gAGd4jCV8IULpUSu.png

Figure 1: Mandiant's publicly disclosed BONESAW detection rules: simultaneously include the data.mdb path, the SRP prime number, and the UUIDs of two vmdir RPC interfaces, corresponding to the two steps of "passing SRP first, then pulling the database".

Mandiant specifically distinguished it from CVE-2026-59309, which was disclosed in July: both can obtain the shared session key K without knowing the password, but 59309 involves sending LDAP packets with malformed authorization tokens via ports 389/636, while CVE-2026-123890 is a DCE/RPC SRP interface issue on port 2012. This also explains why a vCenter instance that had been patched for 59309 was still compromised in September.

III. What did the attacker do at each step?

1. Cross-migrating from a BeyondTrust device to a Linux device without EDR

The initial entry point for ARMORY CASTLE was the 0-day CVE-2026-102764 from BeyondTrust Remote Support. After gaining a foothold, they used nmap to scan VMware-related ports on the internal network. The scan commands repeatedly showed ports 443, 2012, 5480, and 9080: 2012 is the SSO RPC control interface, and 5480 is the vCenter device management interface (VAMI). They then gained access to an internal Linux device without EDR deployed, first deploying ActiveSer.jsp (SLIMSAVAGE, with the password parameter pwd=123 to execute a webshell), and about four hours later deploying u.jsp (CAGEMATCH, specifically responsible for uploading files to /tmp/). The privilege escalation technique involved attaching gdb to the process and executing `chmod u+s /bin/env`, allowing any user to run commands as root via /bin/env.

2. Use Bonesaw to create a vCenter 0-day exploit and export the SSO database.

The attacker used curl to pull a RAR tool and an encrypted compressed file named 123.rar from the BeyondTrust device, decrypting /tmp/123, which is BONESAW. This is an exploit tool written in Go, internally named vcenter-db-teamcheck-go. The core subcommand csa completes the following in one step: exploiting CVE-2026-123890 on port 2012 to obtain the administrator session → streaming data.mdb via vmdirdbcp → parsing the tenant's STS signing private key and certificate chain (found as files such as *-tenantcredential-N.key.pem) → creating a backdoor machine account via vmdir → forging an administrator SAML 2.0 assertion → granting "global administrator" privileges in the vCenter root directory via the vSphere SOAP API. Mandiant confirmed that BONESAW is effective on both vCenter 7.x and 8.x.

3. Golden SAML: Directly issue administrator tokens using the signing private key.

After obtaining the STS signing private key, the attacker deploys `/tmp/sss` (SAWSNAKE), a Go port of the publicly available tool `vcenter_saml_login.py`: it extracts the IdP signing private key and trusted certificate from `data.mdb`, self-signs the Administrator's SAML assertion, and exchanges it for the administrator session cookie from `/ui/saml/websso/sso`. The danger of this type of "Golden SAML" attack lies in the fact that the token is signed with the real signing private key, vCenter cannot distinguish between genuine and counterfeit tokens, and the MFA will not be triggered; moreover, as long as the signing certificate is not rotated, even if the vulnerability is patched, the attacker's private key can still continue to sign tokens.

4. Enable SSH, steal the master key, and then compromise ESXi.

The attackers logged in as a newly created local administrator named `sps-<de-identified>@vsphere.local`, sent the command `PUT /rest/appliance/access/ssh` via the VAMI API to open SSH, and then read the vCenter's internal master symmetric key file and PostgreSQL password file. After succeeding, they immediately disabled SSH using the VAMI API. Next, they logged into the ESXi Host Client as `vpxuser` and SSHed into ESXi as root, writing the public key to root's `authorized_keys`. They created a hidden directory `.a` on a VMFS volume, uploaded `vmfs-pydist.tar.gz`, and used `vmfs_browser.py` within it to bypass the client operating system, directly extracting the Windows/NTDS, SYSTEM, SECURITY registry hive, and DNS directories from the `-flat.vmdk` virtual disk, packaging them into `o.tar.gz`, and sending it back. Extracting NTDS and SYSTEM means that all account hashes in the Active Directory domain of this client machine can be cracked offline or directly used for ticket forgery.

pnRijH0qqzfD8vi6cNmx7JT3CDFX3yxL5RXpZXqW.png

Figure 2: The complete link of ARMORY CASTLE moving from BeyondTrust 0day to vCenter 0day, and then accessing and extracting domain controller data via Golden SAML and ESXi.

5. Persistent and Covert Channels

On the Linux device, /tmp/dbr (BEARBONES), a modified Dropbear SSH server, was also deployed: during password authentication, if the first 14 bytes of the client's password's SHA-256 hash equaled the built-in hash, it was allowed to proceed, while the plaintext password was recorded. The banner was changed to SSH-2.0-pulsesecure_23345, which led Mandiant to discover a batch of compromised firewalls and routers exposing this banner on the internet, determining it to be an attacker's obfuscated network. On another device, LAZYBONES (/usr/bin/vmtoolscs, systemd restarts every 50 minutes) was deployed, sending and receiving commands encrypted with AES-256-CTR and Base64 encoded via Slack channels, supporting the commands cmd, upload, download, and sleep. This backdoor also appeared in the group's 2025 operation using CVE-2025-22457.

IV. Why was it successful?

First, the prerequisites are very low: as long as you can connect to vCenter's TCP 2012 port from the network, no account is required. vCenter is usually not directly exposed to the public network, but ARMORY CASTLE's approach shows that as long as one border device or an unmonitored Linux device on the internal network is compromised, port 2012 is within the attacker's range. Second, vCenter's default VAMI host firewall is too coarse-grained: Mandiant points out that it can only allow access based on the source IP, not by port, and it doesn't care about outbound traffic or log rejected connections. Moreover, it is managed by the VAMI on port 5480—an attacker who gains VAMI privileges can simply disable it. Third, both the SSO signing private key and the vCenter master key are stored locally on the device; a single database export can upgrade "authentication bypass" to "long-term reusable identity forgery capabilities."

V. Scope of Impact and Restoration

According to Broadcom's response matrix, the affected and patched versions are: vCenter 9.1.x upgraded to 9.1.1.0200, 9.0.x upgraded to 9.0.2.0200, 8.0 upgraded to 8.0 U3m, VMware Cloud Foundation 5.x upgraded to 5.2.5, and Telco Cloud Platform and Telco Cloud Infrastructure are handled according to KB463116; vCenter 7.0 ended general support in October 2025, and there are no public patches. Customers with extended support contracts need to contact Broadcom. The same announcement also fixes SQL injection, command injection, and local privilege escalation issues (CVE-2026-123891/123892/123893) in SDDC Manager, as well as an issue in VMware Tools for Windows (CVE-2026-123894).

The patch addresses the leak of unauthenticated session keys on port 2012, but the exported data.mdb file, STS signing private key, vCenter master key, and PostgreSQL password will not be invalidated by the upgrade. For environments where port 2012 has been accessible from non-management network segments since September 2026, the following should be handled as "control plane may have been compromised": rotate the STS signing certificate and SSO administrator credentials, replace vCenter master key related credentials, PostgreSQL password, and ESXi root password, and check for any unexpected administrator or machine accounts in SSO; if a domain controller is running on ESXi, handle the domain credentials as if NTDS has been compromised.

Mandiant's hardening strategy bypasses the VAMI graphical firewall by implementing default denial using iptables at the VCSA Photon Linux kernel level: 2012, 443, 5480, and 22 are only allowed access from specified management nodes, with outbound blocking to prevent Slack C2 and SCP backhauls; simultaneously, denied connections and shell commands are forwarded to SIEM. During troubleshooting, the following publicly available indicators can be traced back: files ActiveSer.jsp, u.jsp, /tmp/123, /tmp/sss, /tmp/dbr, /usr/bin/vmtoolscs; the VAMI access log showing PUT /rest/appliance/access/ssh; the SSH banner SSH-2.0-pulsesecure_23345; and the 11 indicators listed by Mandiant. The following IPs are obfuscated: 103[.]147[.]251[.]5, 103[.]190[.]38[.]3, 118[.]174[.]128[.]34, 118[.]174[.]128[.]36, 118[.]174[.]128[.]38, 176[.]9[.]89[.]66, 185[.]71[.]15[.]109, 220[.]121[.]128[.]41, 222[.]108[.]77[.]44, 61[.]216[.]56[.]127, 81[.]45[.]89[.]43 (Report Table 2).

3B6IP6qWpYgVVqIQHRajCKfC0pBh5BgxN8eC9nWi.png

Figure 3: vCenter administrator's handling sequence: First upgrade, then tighten 2012/443/5480/22, and backtrack according to IOC; for those already compromised, rotate signature certificates and various keys according to control plane vulnerability.

Reference source

• Broadcom VMSA-2026-0009 (CVE-2026-123890, etc.):
https://support.broadcom.com/web/ecx/support-content-notification/-/external/content/SecurityAdvisories/0/39495

• Mandiant/GTIG: ARMORY CASTLE Exploits vSphere (2026-11-19):
https://cloud.google.com/blog/topics/threat-intelligence/armory-castle-exploits-vsphere

• CISA: CISA Adds Four Known Exploited Vulnerabilities to Catalog (2026-11-20):
https://www.cisa.gov/news-events/alerts/2026/11/20/cisa-adds-four-known-exploited-vulnerabilities-catalog

• NVD: CVE-2026-123890:
https://nvd.nist.gov/vuln/detail/CVE-2026-123890

• CERT Santé: VMware vCenter - CVE-2026-123890 (2026-11-20):
https://cyberveille.esante.gouv.fr/alertes/vmware-vcenter-cve-2026-123890-2026-11-20


02. Wagyu XMR1 suffers approximately $13.51 million theft: Deployer's private key stolen, 5.2 million Monero coins damaged in Hyperliquid (99.8% breached).

Daily Security Insights (Event Analysis) | November 21, 2026 | All times in this article are Tokyo time (UTC+9)

On the afternoon of November 20th, the price of packaged Monero XMR1 issued by the cross-chain exchange service Wagyu on Hyperliquid plummeted from approximately $500 to around $1 within half an hour. On-chain records show that between 13:46 and 14:16, the XMR1 deployer account transferred 5.2 million XMR1 tokens in three separate transactions to a new address opened that morning, which then continuously sold them on the spot order book. According to Bitquery's transaction-by-transaction matching, the attacker sold a total of 369,623 tokens, obtaining$13.51million from 420 buyers, and then converted the funds into ETH for cross-chain transfer to Ethereum. Wagyu spokesperson PerpetualCow stated that the deployer's private key was leaked from the compromised Icelandic custodian 1984.hosting and promised to personally compensate all those who suffered losses.

There were no smart contract vulnerabilities or bypassed protocol logic in this incident; what was compromised was "who held the private key of the issuing account and where the private key was stored." When almost the entire supply of an asset is placed in an account controlled by a single private key, the private key itself becomes the security boundary of the entire asset.

I. Event Timeline

Table1:Timeline ofXMR1Theft and Sale

Time (Tokyo timeUTC+9)

event

Source/Evidence

11-16

The deployer transferred 20,000 and 100,000 XMR1 tokens to 0x048b75dc…5eb3 respectively, and the latter was then distributed to users in small quantities; at this point, the deployer still held approximately 93% of the supply.

Bitquery

11-20 12:30

The attacking address 0x1464daca…20bf received 0.098 ETH from Tornado Cash as seed funding.

Bitquery (Ethereum transaction 0x33513047…53ee)

11-20 12:38

This address is used to open an account with Hyperliquid.

Bitquery

11-20 13:46:58

Deployer's first send: 100,000 XMR1 tokens → Attack address

Hyperliquid API, hash 0x328fc4ef…a26b

11-20 13:49

The attacker made a large initial sell order, followed by approximately 3 minutes of further sales equivalent to the cryptocurrency's daily trading volume (about $6.9 million).

Bitquery

11-20 14:14:30 / 14:16:10

The second transaction was for 100,000 tokens, and the third transaction was for 5 million tokens.

Hyperliquid API, hash 0xfe18b369…a1d7, 0x8453d81d…c203

Before 14:00 on November 20th

76% of the sell orders were executed, and the price dropped to around $1; selling continued around $1 until 15:35, and sporadic selling occurred between 16:38 and 19:28.

Bitquery

11-20 18:36

PerpetualCow's first post: The cause is still unclear; market makers were primarily affected, while exchange users suffered no losses. I am willing to negotiate with the attackers.

X @PerpetualCow

11-20 20:08

Icelandic media outlet DV reported that 1984 ehf and CERT-IS issued a joint statement saying they had suffered a severe cyberattack and all services were suspended.

Bitquery leads to DV

11-20 20:31

PerpetualCow promises to fully compensate those who suffered losses while market making on XMR1, and Wagyu will be relisted.

X @PerpetualCow

11-20 21:48

PerpetualCow issued a post-incident statement: The deployer's private key was stored on an old, now-deleted server (1984.hosting), and the hosting provider still retained the logs/files.

X @PerpetualCow

11-21 10:05

Verification: The attackers have not moved approximately 7,348 ETH on Ethereum and Arbitrum.

publicnode eth_getBalance

II. What is XMR1, and why is one private key sufficient?

Monero (XMR) operates on its own blockchain and cannot be directly traded on Hyperliquid. Wagyu's approach is as follows: users send real XMR to Wagyu's bridge, which then provides the user with an equivalent amount of XMR1 on Hyperliquid; sending the XMR1 back allows the user to redeem their XMR. In other words, the value of XMR1 derives entirely from the promise that "Wagyu has corresponding Monero available for redemption."

On Hyperliquid, newly issued spot tokens are minted with their entire fixed supply to the account that deployed them, which then distributes them as needed. According to Bitquery, before the incident, the XMR1 deployer account 0x207700bd…e06a still held approximately 93% of the supply; this account had an API wallet named "wagyu," which Wagyu later confirmed was indeed the XMR1 deployer. Hyperliquid's API wallet can only place orders on behalf of users, while token transfers (sends) require a user action signed with the account's master private key. Therefore, the attacker's ability to transfer tokens indicates that they possessed the deployer account's master private key, not just the API key used for a specific transaction.

MkE4SEiPwwWyOYGsiHdK3jUKHp3tqEjNKvi03zNm.png

Figure 1: Raw ledger records returned by the Hyperliquid public API: The deployer account transferred 100,000 XMR1 tokens to the attack address that was newly opened that day via a send action, and then transferred out 100,000 and 5 million tokens.

III. What did the attacker do at each step?

Preparation.At 12:30, the attacking address received 0.098 ETH from Tornado Cash and opened an account on Hyperliquid 8 minutes later. The initial funding was provided using a mixer to sever this address's connection to the attacker's other assets.

Transfer out.Starting at 13:46:58, the deployer account sent 100,000, 100,000, and 5 million XMR1 tokens to the attacking address in three separate transactions. Bitquery pointed out that these three transfers followed the exact same steps as the normal replenishment four days prior, the only difference being that the recipient was a new address—from an on-chain perspective, this was a legitimate operation signed by the deployer himself, and Hyperliquid had no reason to refuse.

The attackerdumped the tokens.Starting at 13:49, the attacker directly sold to the buy orders in the order book. XMR1's daily trading volume is typically around $6.9 million, and the attacker sold the equivalent amount in less than 3 minutes. 76% of the proceeds were traded within the first 11 minutes, causing the price to plummet from around $500 to around $1. The attacker continued to sell in small amounts around $1, but as of the time Bitquery's statistics, only 7% of the tokens had been sold, leaving approximately 309,000 tokens in buy orders and millions more in the account—but no one was willing to buy at the original price anymore.

Who took over?420 buyers paid $13.51 million for these tokens, 75% of which came from buy orders placed in advance on the order book—typical market maker behavior; the largest single buyer's order was wiped out, amounting to $3.56 million. PerpetualCow also confirmed that the main losers were market makers. Besides the buyers who directly took over, everyone who held XMR1 at the time watched their holdings depreciate by 99.8%. Whether they can exchange their holdings for XMR at the original ratio depends on the handling after the Wagyu Bridge recovers.

Cross-chain currency swap.The attacker transferred USDC to Arbitrum (worth $13.28 million) in 11 transactions via the Hyperliquid official bridge, exchanged it for 7,467 ETH via the CoW Protocol, and then sent 6,929 ETH to Ethereum via Socket routing and the Mayan and Stargate bridges (6,810 ETH received, with a bridge loss of approximately 1.7%). Of this, 4,836 ETH was transferred to a new wallet (0xf32d7842…dc59) that had never been used for external transactions. Before the attack, the attacker also distributed 6,000 XMR1 tokens to 7 accounts, 4 of which transferred the tokens to the same "aggregate address" within half a minute. Bitquery determined that this resembled a deposit address for an exchange service, meaning the attacker may have attempted to directly exchange some XMR1 for real Monero, and the destination on the Monero chain was untraceable.

cnb3mF6JWkdhcceN1FXKIg9gJS59kqMtO95TGtkN.png

Figure 2: Funding path of the XMR1 event: Tornado Cash initial funding → Deployers transfer 5.2 million tokens → Order book dump → Arbitrum exchange for ETH → Bridge to Ethereum and remain idle.

IV. How was the private key lost?

In its subsequent statement, PerpetualCow stated that the entire hosting provider, 1984.hosting, was compromised, and customer data and internal server files were stolen. The XMR1 deployer's private key had been stored on an old server hosted by the provider; although the server had been deleted, the provider still retained related logs and files. Icelandic media outlet DV reported that 1984 ehf and the national cybersecurity emergency response organization CERT-IS issued a joint statement saying that the company had suffered a large-scale, severe cyberattack and had suspended all services; DNS and email would be restored first under special monitoring.

The custodian attack is corroborated by announcements from 1984 ehf and CERT-IS; the claim that "the deployer's private key was leaked from there" is currently only supported by Wagyu's side, and the source of the private key cannot be proven on-chain. What can be confirmed on-chain is that the signature of the transferred tokens came from the deployer's account itself, and the initial funds for the attack address came from Tornado Cash.

If this claim is true, the problem lies in two aspects. First, a private key controlling almost the entire supply is placed on a regular cloud server connected to the internet, rather than in a hardware wallet, multi-signature, or dedicated signing service. Second, "deleting the server" does not equate to data destruction; the custodian's snapshots, backups, and logs may be stored longer than customers believe. Once the custodian itself is compromised, these remnants become readily available material for attackers.

V. Losses and Handling

Amount breakdown: According to Bitquery's transaction-by-transaction matching of Hyperliquid, the attacker sold 369,623 XMR1 tokens, with buyers paying a total of$13.51million (statistics up to 22:00 on November 20th); PerpetualCow's subsequent statement also referred to this as a "$13 million XMR theft." According to the on-chain verification at 10:05 on November 21st, address 0xf32d7842…dc59 held 4,835.67 ETH, while the attacking address held 1,974.56 ETH on Ethereum and 538.11 ETH on Arbitrum, totaling approximately 7,348 ETH, consistent with Bitquery's statistics from the previous night, and these amounts have not yet been moved.

Wagyu has suspended services, and PerpetualCow has pledged to personally compensate all those who have suffered losses, stating that Wagyu will be back online later. As of 22:16 on November 20th, according to Bitquery's check, the top 10 buyers have not yet received transfers from other Hyperliquid accounts. Another noteworthy risk is that the same deployer account still holds 99.97% of the ZEC1 (wrapped Zcash) supply, as well as three other tokens, controlled by the same stolen private key. Users and market makers holding ZEC1 or other homologous tokens should treat them as equally risky assets until the issuer completes the key migration.

For project owners issuing packaged assets, the lessons learned from this incident are concrete: Issuance and supply management accounts should use multi-signature or hardware signatures, and private keys should not be stored on general-purpose servers; uncirculated supply should not be stored in hot accounts that can be directly transferred for extended periods; before terminating a cloud server lease, the snapshot and backup destruction strategy should be confirmed, and "deleted" should not be mistaken for "destroyed." For market makers, before placing depth buy orders for packaged assets, they need to assess the risk of the issuer's single point of private key and set up automatic order cancellation in case of abnormal price fluctuations.

Reference source

• Bitquery: XMR1 hack: 420 buyers paid $13.51 million for a token that fell 99.8% (2026-11-20):
https://bitquery.io/investigations/xmr1-hyperliquid-hack

• PerpetualCow (Wagyu)'s post-incident statement, X, 2026-11-20 12:48 UTC:
https://x.com/PerpetualCow/status/2123760480061718801

• PerpetualCow Indemnity Pledge, X, 2026-11-20 11:31 UTC:
https://x.com/PerpetualCow/status/2123740930838589734

• DV: 1984 ehf. (2026-11-20):
https://www.dv.is/frettir/2026/11/20/stodva-thjonustu-timabundid-eftir-alvarlega-tolvuaras-a-innvidi-1984-ehf

• The Block: Wagyu's XMR1 wrapped Monero plunges 99% after $13 million hack (2026-11-20):
https://www.theblock.co/news/defi/2026-11-20-wagyus-xmr1-wrapped-monero-plunges-99-after-13-million-hack-founder-promises-refunds-444747

• Hyperliquid public API (userNonFundingLedgerUpdates, deployer 0x207700bd207df757825f9193ef9c648c1c65e06a):
https://api.hyperliquid.xyz/info

• Etherscan: Attacker's ETH collection wallet 0xf32d7842611a5d63b875075dadd19c55f3f1dc59:
https://etherscan.io/address/0xf32d7842611a5d63b875075dadd19c55f3f1dc59


03. Fluidkey Suffers $1.58 Million Theft: Third-Party Logging Tool Leaks Session Data; Server-Side "Prepared" Transfers Were Signed and Issued by Relays When Users Opened the App

Daily Security Insights (Event Analysis) | November 21, 2026 | All times in this article are Tokyo time (UTC+9)

Between 02:28 and 03:05 on November 20th, users of the privacy wallet Fluidkey experienced a massive outflow of funds across six blockchains: Ethereum, Base, BNB Chain, Optimism, Polygon, and Arbitrum. According to Bitquery's on-chain tracking, at least$1.58million flowed into wallets linked to the same attacker, with half of that amount withdrawn within five minutes of the outflow. Fluidkey shut down all services at 03:05 and began investigating with SEAL 911. At 01:10 on November 21st, Fluidkey released version 1.79.22 and relaunched, explaining the attack method for the first time: the attacker exploited a vulnerability in a third-party logging tool to obtain session data, prepared unauthorized transfers on Fluidkey's servers, and then had these transfers signed when users opened the app. The official statement emphasized that the private keys controlling user funds never left the device.

The statement "the private key did not leave the device" is true, but it also illustrates the problem: attackers don't need to steal the private key at all; they only need to get the private key on the user's device to sign for them.

I. Event Timeline

Table1:Timeline ofFluidkeyThefts

Time (Tokyo timeUTC+9)

event

Source/Evidence

2024-05-24

Dedaub released an audit report on the Fluidkey Stealth Account Kit, indicating that if a server is compromised, malicious JavaScript could be delivered to users, and that the security of anonymous addresses depends on server security.

Dedaub Audit Report

11-19 evening

Two new wallets successively obtained ETH from Tornado Cash and distributed Gas to other chains.

Bitquery

11-20 02:16

The attacker deposited a small amount of ETH into a Fluidkey account on Base, and within the same minute, 5.15 USDC was transferred out of that account (test).

Bitquery

11-20 02:28

Bulk transfers began almost simultaneously on Ethereum and Base.

Bitquery

11-20 02:33

Half of the proceeds from the attack have been transferred out; the largest single transfer on Ethereum involved approximately $415,800 USDT from two accounts.

Bitquery

11-20 03:04:59

The last transaction of the repeater

Bitquery

11-20 03:05

Fluidkey shut down all services, and no new unauthorized transactions occurred afterward.

Fluidkey X (Published at 05:17)

11-20 03:20

Fluidkey posted a message advising users not to interact with the website and app.

Fluidkey X

11-20 05:05–06:29

Six wallets deposited 881.6 ETH into Tornado Cash.

Bitquery

11-20 05:17

Fluidkey: Collaborating with SEAL 911 on investigation and tracing; web application and all APIs suspended.

Fluidkey X

11-20 17:52

Fluidkey warns against private messages impersonating their team.

Fluidkey X

11-21 01:10

Version 1.79.22 is now live, completely blocking the old web and mobile versions; the attack method has been disclosed, and affected users will be contacted individually and a full post-incident report will be released.

Fluidkey X

II. How Fluidkey works: Stealth address + repeater

A regular wallet has only one public address; anyone who knows this address can see its entire balance and transaction history. Fluidkey uses "stealth addresses" to sever this connection: a new address is generated for each transaction received, and outsiders only see a bunch of unrelated new addresses, making it impossible to aggregate them to a single person. According to Bitquery's summary of Fluidkey's technical specifications, each stealth address is a Safe smart contract wallet with only a single owner key; when a user signs a message using their existing wallet, the application code in the browser derivesa spending key(remaining on the user's end) anda viewing key(given to Fluidkey to generate new addresses and identify incoming transactions).

The newly generated stealth addresses do not have ETH for gas payments, so every user transfer is submitted and the transaction fees are paid by Fluidkey on their behalf. This is handled by the relay: each chain has a Fluidkey wallet signing the transaction, which is then sent through the same relay contract 0x8090a9db…58a0 (Ethereum signer 0x7997e874…82da, Base signer 0x2b40fe2e…854a). Bitquery statistics show that on the mornings of November 18th and 19th, the number of relay transactions on Ethereum and Base never exceeded 30 per hour; however, it reached 174 per hour starting at 02:00 on November 20th.

III. How was the attack carried out?

Fluidkey's official documentation outlines three defined stages, in order:

The first step was to obtain session data.The attacker exploited a vulnerability in a third-party logging tool to obtain the user's session data. The official documentation did not disclose the name of this tool or the specific type of vulnerability. Third-party components such as logging, monitoring, and error reporting are typically embedded in the front-end or back-end, allowing the attacker to view request content and session state. Once this data, such as session tokens, is recorded and read externally, the attacker can then call Fluidkey's server-side API as the user.

The second step involves preparing the transfer on the server.Using these session identities, the attacker generates a transfer request on the Fluidkey server pointing to the attacker's address. The server only recognizes session identities; once the attacker impersonates the session, they can determine the recipient and amount of the transfer.

The third stepinvolves signing the transaction whenthe user opensthe app. These prepared transfers are signed when the user opens the app. The signing uses the spending key on the user's device, so the private key itself is not actually leaked; however, the object being signed is a transfer prepared by an attacker. After signing, the relay proceeds with the gas payment as usual, submitting the transaction to the blockchain. The Safe contract sees the owner's valid signature and naturally allows it to proceed.

xSpRLXwRdlHPVM0fO6L9ncLRYX8yctt0mbKfaYSN.png

Figure 1: Fluidkey's officially confirmed attack chain: Log tool leaks session → Server prepares for transfer → App signs upon opening → Relay submits to the chain; v1.79.22 disables this path.

Why was it successful?According to the official description, the user's action of "opening the app" is sufficient for the server to sign the prepared transfer; simultaneously, the server allows the preparation of the transfer for the user based solely on the session identity. From this, we can infer (analyze and infer) that the older client lacked a step where the user locally confirmed the receiving address and amount for each transaction before signing. Dedaub's May 2024 audit already pointed out the fundamental risk of this design: the spending key is derived and used by application code in the browser. If the server is compromised, malicious code can be sent to the user; therefore, "the overall security of anonymous addresses currently depends on the security of the server." This time, the attacker did not rewrite the front-end code, but instead used the server's normal functionality to have the client sign, resulting in the same situation: "the private key is local, but what is signed is decided by someone else."

The on-chain behavior also matched this mechanism: at 02:16, the attacker first tested one account with 5.15 USDC, and 10 minutes later deposited a small amount of ETH into two other accounts. Subsequently, the relayer transferred funds out of these three accounts, indicating that the targets were pre-selected. No vulnerabilities in the Safe Contract or the six chains themselves were exploited during the entire process, and all transfers were "transactions with valid signatures and submitted by the official relayer".

IV. Fund Flow

Bitquery meticulously categorized every payment made by the relay to external wallets between 02:10 and 03:10: only payments or gas transactions linked to the attacker's wallet were counted as proceeds, totaling approximately $1.58 million. The breakdown by blockchain is as follows: Base approximately $837,000, Ethereum approximately $660,000, BNB Chain approximately $43,000, Optimism approximately $30,000, Polygon approximately $7,000, and Arbitrum approximately $990. Approximately $65,000 flowed to new wallets with undetermined ownership, and approximately $349,000 flowed to addresses with usage history (including a user transferring approximately $277,000 to a wallet they had been using since 2024 during the theft); these two portions were not included in the statistics. Approximately $13,500 worth of Ondo tokenized shares (NVIDIA, Apple, Alphabet, S&P 500, etc.) were also transferred from the BNB Chain, with approximately $5,500 of that ending up in the attacker's hands.

The stolen stablecoins were collected and converted into ETH within minutes. Funds on Base were then bridged to Ethereum via Mayan, HiFiSwap, and other platforms. From 05:05 to 06:29, six wallets deposited a total of 881.6 ETH into Tornado Cash, equivalent to approximately $1.57 million at $1,778/ETH, roughly the same as the amount obtained from the attack. The transaction chain also contained a large number of fake ETH, USDC, and USDT transfers with the same names and amounts. This was an address poisoning technique used to induce people who copied historical addresses to transfer funds to the wrong accounts.

p9qMcuWHhmk6GUZICb3HtGVAONQv6R2XslnUXrHH.png

Figure 2: Within 36 minutes, approximately $1.58 million was transferred across six blockchains, with Base and Ethereum accounting for the vast majority. Subsequently, 881.6 ETH entered Tornado Cash.

V. Losses and Handling

Amount estimates: According to Bitquery, at least $1.58 million flowed into the attacker's linked wallets, with a maximum of approximately $1.64 million; a separate tracking table on GitHub recorded $1,634,503, falling within this range. Fluidkey has not yet released the total amount of losses.

Regarding the fixes, Fluidkey stated that in v1.79.22, transfers can no longer be prepared on the server in this manner, and additional protective measures have been added. All older versions of the web and mobile apps have been blocked, and users must upgrade via "Settings > Update" to restore transactions. The official team will contact affected users individually and release a full post-incident report, while reminding users that their team will not contact them via private messages on social media.

For Fluidkey users: Only use version v1.79.22 and above; verify the outflow records of your hidden addresses between 02:00 and 03:10 on November 20th; ignore all private messages claiming to be Fluidkey customer service and contact them only through official channels; verify addresses word by word when copying them from history to prevent malicious transfers of the same amount. For wallet developers: Third-party logs, monitoring, and analysis components should be managed as "production credentials that can access the signature environment," prohibiting the recording of sensitive fields such as session tokens, and removing them from the signature page; clients should not perform seamless signatures on transactions issued by the server, and the receiving address and amount must be confirmed locally by the user; in addition to the session, the server's transaction preparation interface should also require a fresh signature or device binding from the client.

Reference source

• Fluidkey's online recovery and attack method explanation, X, 2026-11-20 16:10 UTC:
https://x.com/fluidkey/status/2123811285934506413

• Fluidkey Event Update, X, 2026-11-19 20:17 UTC:
https://x.com/fluidkey/status/2123510970165436704

• Fluidkey Incident Announcement, X, 2026-11-19 18:20 UTC:
https://x.com/fluidkey/status/2123481430634492278

• Bitquery: Fluidkey hack: $1.58M went to the attacker in 36 minutes (2026-11-20):
https://www.bitquery.io/investigations/fluidkey-hack

• Dedaub: Fluidkey Stealth Account Kit Audit (May 24, 2024):
https://dedaub.com/audits/fluidkey/fluidkey-stealth-account-kit-may-24-2024/

• 0xCERT-2026-0388: Fluidkey security incident advisory:
https://www.0xcert.com/advisory/0xCERT-2026-0388


04. Cisco Expressway cluster hardcoded maintenance credentials CVE-2026-76466: After the PoC was made public, it was used to infiltrate Russian organizations, enabling unauthenticated root command execution.

Daily Security Insights (Threat Intelligence) | November 21, 2026 | All times in this article are Tokyo time (UTC+9)

On November 18, 2026, Russian cybersecurity company F6 disclosed the first real-world breach of CVE-2026-76466: shortly after the public PoC appeared, an attacker compromised two Cisco Expressway X15.5.3 servers exposed to the internet at a Russian organization, executing commands as root, and then traversing the cluster to access two other nodes on the internal network, having prepared Python tools for lateral movement. This vulnerability, disclosed by Cisco on October 21 (CVSS 9.8), was caused by the cluster database service using hard-coded persistent cookies and the cluster TLS verification failing to validate client certificates. CISA included it in its KEV on November 20, and federal agencies were required to address it by November 23. Even if your Expressway is only deployed on the internal network, as long as the cluster ports are reachable from non-peer nodes, it is still exposed to the same attack path.

I. Event Summary

Table1:Timeline ofCVE-2026-76466Disclosure and Utilization

Time (Tokyo timeUTC+9)

event

Source/Evidence

October 21 (US time)

Cisco released a security advisory (cisco-sa-vcs-static-cred-hr7EWZ8t) disclosing CVE-2026-76466, stating that it was unaware of its public disclosure or malicious exploitation at the time.

Cisco Announcement

11-05

The GitHub repository dinosn/cve-2026-76466 contains a Python script for detecting vulnerabilities using tools and fleet detection.

GitHub repository metadata

11-18

F6 issued a press release stating that two Expressway X15.5.3 servers belonging to a Russian organization were compromised, and the attackers gained access to two internal nodes via a cluster.

F6 Press Release

11-19 22:12

SecurityWeek reported that the intrusion occurred shortly after the Proof-of-Concept (PoC) was made public.

SecurityWeek

11-21 02:48

CISA KEV data source update (2026-11-20T17:48Z), includes CVE-2026-76466, as of 11-23.

CISA KEV JSON

F6's reconstruction of the intrusion path revealed that the attackers first compromised two internet-accessible Expressway servers, then used one of them to access two other cluster nodes located on the internal network. After gaining root access, they deployed a self-written Python script on the device to scan the network, locate accessible SMB shares, connect to SQL Server and WinRM, and search GitLab repositories, aiming to steal credentials and other sensitive information. F6 noted that the script was modified on-site during the attack, and the source code comments showed signs of AI assistant intervention. Cisco's announcement, as of the SecurityWeek report on November 19th, still stated "no malicious exploitation found," contrasting with F6's forensic findings.

II. Why are there risks?

1. The cluster database port uses the Erlang distributed protocol.

Expressway's clustered database is an Erlang/OTP application. When two or more nodes form a cluster, each node runs a TLS-protected Erlang distributed listener on TCP port 4372 and reuses a fake EPMD (port mapping) on the same port. Erlang distributed sessions are authenticated using a shared "cookie" (shared secret): whoever knows the cookie and can connect to the port can join the distributed mesh and call arbitrary functions. The Erlang virtual machine runs as root, so `rpc:call(Target, os, cmd, [command])` executes a system command as root.

2. Node identity and cookies are hardcoded into the product.

Technical analysis of the publicly available PoC repository indicates that Expressway's cluster management module, cm_server, contains a function add_allowed_wombat_node/1: when a connecting party reports a node name starting with wombat@, it adds this identity to the allowed list and loads a fixed maintenance cookie. Both the node name prefix and the cookie are hard-coded literals compiled into the module, and are identical across all affected installations. Cisco's announcement states that "persistent cookies are used," adding that client certificates are not verified in cluster TLS Verify mode. The PoC author reproduced this in the factory default TLS Permissive mode: no client certificate is required; simply reporting [email protected] and completing the challenge response with the wombat cookie is sufficient to obtain a session.

nxatJDnNt5Ph74QXXanFDJx2LxPc0u6DRCyKGItI.png

Figure 1: From TCP 4372 to root command execution: hard-coded wombat@ identity + fixed cookie + no client certificate verification

3. The cookie visible on the device is not the key.

The erlangcookie.conf file visible on the device stores peer cookies used for communication between nodes, not maintenance credentials. The PoC authors point out that peer cookies are derived from a base value plus an internal version identifier, and directly reading and replaying this file will not pass the test; maintenance cookies are a different, simpler set of values loaded by a module from the same vendor. This means that "checking whether the cookies in the configuration file have been modified" will not uncover this backdoor entry point—it is already in the production code.

4. The attack chain can be fully verified during runtime.

The PoC authors conducted runtime verification on a two-node Expressway-C X15.3.2 cluster in TLS Permissive mode: Node names not listed in the allowed list will receive a `not_allowed` response even with the correct cookie; maintaining the identity with an incorrect cookie will result in a challenge rejection; forcing TLS 1.2 will be rejected (TLS 1.3 is the minimum); not providing a client certificate is still acceptable; maintaining the identity with the correct cookie returns a `pong`; subsequently, `rpc:call(os,cmd,["id -u"])` returns 0, confirming execution as root. After the test, both peer nodes still functioned normally, indicating that the exploit itself will not crash the cluster.

III. What consequences might this cause?

A successful exploit grants root privileges to the device's operating system. The F6 case illustrates what happens next: the external network node becomes a springboard, allowing attackers to access the internal network node via the Erlang cluster, and then launch internal network reconnaissance against SMB, SQL Server, WinRM, and GitLab from this collaboration and video infrastructure. Expressway typically connects both the enterprise's internal network and external collaboration partners, making it a typical location that is "accessible from the external network and able to reach the internal network." The Cisco announcement covers virtual machine and hardware versions of Expressway-C and Expressway-E, but only if the devices are deployed in a cluster; single-machine deployments are not affected by this vulnerability.

IV. What you should do now

1.Upgrade immediately.X15.5.3 and earlier versions should upgrade to X15.5.20; X14 and earlier versions need to be migrated to a release containing the fix. Cisco states that there are no temporary mitigations; upgrading is the only official fix path. This fix is also included in the Expressway security hardening release disclosed in October 2026.

2.Tighten port restrictions before patching.F6 recommends restricting TCP 4371–4372 access to trusted cluster peer IPs on the firewall, blocking other sources. This is not a substitute for upgrading, but it can prevent exploits originating from non-peer addresses.

3.Checkfor exploitationby IOC. Check the Erlang system log (erlang.log) of each Expressway node for the entry `nodeup,'[email protected]'` – this indicates someone has successfully connected to the distributed session as a maintenance node. Also check for suspicious Python scripts (#### is a four-digit number followed by a letter) under the path `/mnt/harddisk/i####[a-zA-Z]?/*.py`. The source IPs published by F6 are: 66[.]179[.]31[.]32 and 18[.]130[.]47[.]116.

4.If the exploitation has been confirmed, treat it as a compromised host.Isolate the relevant nodes, rotate all credentials that may have been accessed from the device (domain accounts, databases, GitLab, WinRM, etc.), and audit lateral movement traces from the time of the intrusion. Do not assume that "only external network nodes were attacked, and the internal network is still clean."

KTbGcxthQHo9YB3LFegMRhFKjo0LRu3Hx1q0EO0d.png

Figure 2: F6 Reconstruction of the Real Intrusion: After two external Expressway servers were compromised, the attackers entered the internal network through the cluster and prepared lateral movement tools.

V. IOC

Table2: Relevant Indicators for this Sample (De-hazardous Chemicals)

type

index

illustrate

Log characteristics

nodeup, '[email protected]'

Successful connection records in Expressway's erlang.log

File path

/mnt/harddisk/i####[a-zA-Z]?/*.py

Script write path observed by F6

IP

66[.]179[.]31[.]32

F6 Associated Source Address

IP

18[.]130[.]47[.]116

F6 Associated Source Address

Node identity

wombat@127[.]0[.]0[.]1

The node name is hard-coded and maintained (not for malicious IOCs, but for verification).

port

TCP 4371–4372

Erlang cluster database port

The above IOCs only apply to the intrusion sample published by F6; cookie values themselves should not be publicly disseminated as network detection signatures. C2 and scripts can be replaced at any time, and should simultaneously cover log signatures, disk paths, and connections to 4372 from non-peer ends.

VI. Supplementary Explanation

The affected scenario requires that the vulnerable version is running and configured as a cluster. Standalone Expressway instances are not affected. The PoC author has not tested TLS Enforcing mode, Expressway-E, or X14; Cisco's announcement covers Expressway-C/E, with the fix in version X15.5.20. The public PoC repository includes `--mode ping` (authentication only, no command execution) and Fleet detection scripts, which can be used for self-checks within the authorized scope.

VII. Recommendations for Subsequent Use

Treat Expressway cluster ports as entry points with the same sensitivity as the management plane: by default, disallow access to ports 4371–4372 from non-peer network segments; create alerts for nodeup events in erlang.log; after upgrading to the patched version, review whether the cluster TLS verification is in a mode that enforces client certificate verification. Any cluster component that maintains its identity with hard-coded authentication should be included in a regular audit checklist.

Reference source

• Cisco: Cisco Expressway Series Remote Code Execution Vulnerability (CVE-2026-76466, 2026-10-21):
https://www.cisco.com/c/en/us/support/docs/csa/cisco-sa-vcs-static-cred-hr7EWZ8t.html

• F6: First recorded use of CVE-2026-76466 in the wild (2026-11-18):
https://www.f6.ru/media-center/press-releases/cisco-cve-2026-76466/

• SecurityWeek: Hackers Exploit Cisco Expressway Vulnerability Soon After PoC Release (2026-11-19):
https://www.securityweek.com/hackers-exploit-cisco-expressway-vulnerability-soon-after-poc-release/

• Publicly available technical analysis: github.com/dinosn/cve-2026-76466/docs/technical-analysis.md
https://github.com/dinosn/cve-2026-76466/blob/main/docs/technical-analysis.md

• CISA: Adds Four Known Exploited Vulnerabilities to Catalog (2026-11-20):
https://www.cisa.gov/news-events/alerts/2026/11/20/cisa-adds-four-known-exploited-vulnerabilities-catalog

• NVD: CVE-2026-76466:
https://nvd.nist.gov/vuln/detail/CVE-2026-76466


05. Apache Roller XML-RPC Uncertified Deserialization CVE-2026-129448: Even disabling XML-RPC in the background cannot prevent it; it has been exploited in the wild.

Daily Security Insights (Threat Intelligence) | November 21, 2026 | All times in this article are Tokyo time (UTC+9)

On November 17th, the Apache Software Foundation released security advisory CVE-2026-129448: An XML-RPC endpoint in Apache Roller versions 4.0.0 to 6.1.5 (inclusive) deserializes vendor extension types in requests before authentication, allowing unauthenticated attackers to execute arbitrary code. The same vulnerability was previously registered as CVE-2026-82384, which only affected version 6.1.5; the new number expands the impact to all older versions from 4.0.0 onwards and explicitly states that it is being exploited in the wild. CISA added it to its KEVs on November 20th. Even if you disable XML-RPC in the admin panel, the servlet mappings for the vulnerable version still exist, and the parser will still run—the admin switch cannot prevent this attack.

I. Event Summary

Table1:Timeline ofCVE-2026-129448 / CVE-2026-82384Disclosure

Time (Tokyo timeUTC+9)

event

Source/Evidence

09-06 05:43

Fixed PR #171 and merged it into apache/roller (submission 3b67aa9c), disabling vendor extensions and adding endpoint gate filters.

GitHub PR #171

09-26 05:12

Apache has issued a CVE-2026-82384 alert, listing only version 6.1.5 as affected, and recommending an upgrade to 6.1.6 or later.

Apache mailing list

11-17 20:02

Apache has expanded the scope of its API documentation with CVE-2026-129448 to include versions 4.0.0–6.1.4, and stated that it is being exploited in the wild; the same document also covers version 6.1.5.

Apache mailing list

Around 11-18

BleepingComputer reports that the vulnerability is being exploited; Tuxshin releases a complete reproduction and detection method.

BleepingComputer; Tuxshin

11-21 02:48

CISA KEV data source update (2026-11-20T17:48Z), includes CVE-2026-129448, as of 11-23, evidence collection and triage required.

CISA KEV JSON

Apache has not yet released the attacker's identity or the number of compromised servers. The original announcement stated "4.0.0 through 6.1.4", but the fix was only implemented in 6.1.6, and Tuxshin's verification of the official 6.1.4/6.1.5 binaries shows that both still have enabledForExtensions=true and lack XmlRpcEnabledFilter, therefore 6.1.5 is also vulnerable—consistent with the earlier CVE-2026-82384 record.

II. Why are there risks?

1. XML-RPC servlets have vendor extensions enabled by default.

Apache Roller is a Java blogging platform that has been in use since the early 2000s, still retaining an XML-RPC API for older blogging clients. It maps the generic XmlRpcServlet from the Apache XML-RPC library to /roller-services/xmlrpc and sets the initialization parameter enabledForExtensions to true in WEB-INF/web.xml. This switch allows the library to register a set of non-standard vendor extension types, including ex:serializable: clients can include Base64-encoded Java serialized bytes in XML, which the library will then pass to ObjectInputStream.readObject(). Roller itself does not use these extension types, but it enables them.

6E4WDGcuurM28NB8xStijlLYkI6GYHl3tcih0XKh.png

Figure 1: Vulnerable version of web.xml: XmlRpcServlet's enabledForExtensions is true, and it unconditionally maps to /roller-services/xmlrpc

2. The only gatekeeper is "whether to enable expansion".

In Apache XML-RPC 3.1.3's `TypeFactoryImpl.getParser()`, when the namespace is an extended URI, the function first checks `isEnabledForExtensions()`. If it's false, it returns null; if it's true, it dispatches a parser based on the tag name. When encountering a `serializable` tag, it returns `SerializableParser`. In other words, from the library's perspective, the only gatekeeper preventing deserialization is this configuration option—and the vulnerable Roller version sets it to true.

7hPm7e0TqtIsFn5wcPtanmQIFF4gguMgAMa1O31F.png

Figure 2: In xmlrpc-common 3.1.3: under the extended namespace, when isEnabledForExtensions is true, the serializable tag is handed over to SerializableParser.

3. Deserialization occurs before authentication.

The implementation of `SerializableParser.getResult()` is only a few lines long: it retrieves the byte array parsed from the parent class, puts it into an `ObjectInputStream`, and calls `readObject()`. There is no class whitelist. The key lies in the execution order: XML parsing (including `readObject()`) → finding the handler → the handler verifies the username and password. The vulnerability is triggered in the first step, so attackers don't need any accounts. This is also why "disabling XML-RPC in the management backend" is ineffective—that switch only affects the handler layer; the servlet mapping remains, and the parser still runs.

pAgRk0mD47rJpGzShbKHWVjnggug0ltQQyE5ZNMa.png

Figure 3: SerializableParser.getResult(): Passes the Base64 bytes from the request directly to ObjectInputStream.readObject(), which occurs before authentication.

ibEfQbmaBmezCYd44W5cZoCUc3hAMNlPSegclKhX.png

Figure 4: Request processing order: Deserialization is completed during the parsing phase, and the background "Disable XML-RPC" switch does not have time to take effect.

4. Gadgets are also needed from deserialization to code execution.

The deserialization entry point itself is not equivalent to remote code execution; a usable Gadget chain on the classpath is also required. Tuxshin documented two obstacles in his reproduction: the commons-collections 3.2.2 bundled with Roller has readObject() protection, which rejects unsafe functors like InvokerTransformer, thus rendering the classic CommonsCollections 1/3/5/6/7 ineffective; the CommonsBeanutils1 chain encounters a hardening mechanism that newer JDKs disable TemplatesImpl deserialization by default (controlled by jdk.xml.enableTemplatesImplDeserialization). In his experimental environment, Tuxshin only enabled this JDK flag and used PriorityQueue + BeanComparator + TemplatesImpl chain to complete the out-of-band callback proof. Whether RCE is actually successful depends on the target server's classpath and JDK version; however, the deserialization entry point is certain to exist in the vulnerable version. By sending a probe request with a class name that does not exist on the server, the error "Failed to load class for result object: …" can be used to confirm that the entry point is reachable without executing any code.

III. What are the possible consequences?

For instances of the vulnerable version exposing `/roller-services/xmlrpc`, an unauthenticated attacker can trigger arbitrary Java deserialization. In environments where Gadget chains are available, this amounts to remote code execution, allowing an attacker to take over the application server process running Roller, thereby reading blog content and user credentials, implanting a webshell, and lateral movement. Apache has confirmed that this issue is being exploited in the wild. Roller's market share is far smaller than modern CMSs like WordPress, but once deployed on the internet, its XML-RPC endpoint is an account-free entry point.

IV. What you should do now

1.Upgrade.Upgrade to Apache Roller 6.1.6 or later (currently the latest is 6.1.7). In 6.1.6, change enabledForExtensions to false and add XmlRpcEnabledFilter: when webservices.enableXmlRpc is configured to be off at runtime, the filter returns a 404 directly before the servlet, and the request never reaches the parser.

2.Temporary measures when immediate upgrade is not possible.Change `enabledForExtensions` to `false` in `WEB-INF/web.xml`, or directly delete the servlet mapping for `/roller-services/xmlrpc`, and then restart Roller. Simply disablingXML-RPCin the management backendis insufficient.

3.Self-check version and configuration.

unzip -p roller.war WEB-INF/web.xml | grep -A2 enabledForExtensions - should be false.

The command `unzip -p roller.war WEB-INF/web.xml | grep XmlRpcEnabledFilter` should find the filter in versions 6.1.6 and above.

4.Detection and Troubleshooting.Monitor POST requests to /roller-services/xmlrpc, especially those containing `ex:serializable`, extended namespaces `hxxp://ws[.]apache[.]org/xmlrpc/namespaces/extensions`, or the Base64 serialization prefix `rO0AB`. Simultaneously monitor abnormal child processes spawned by the Java process and abnormal outbound connections. If the endpoint is confirmed to have been exposed, treat it as a potential host compromise: isolate it, collect evidence, and rotate the credentials on that host.

V. IOC

Table2: Testing and Verification Indicators (De-hazardous Chemicals)

type

index

illustrate

URL path

/roller-services/xmlrpc

XML-RPC servlet mapping

XML namespaces

hxxp://ws[.]apache[.]org/xmlrpc/namespaces/extensions

Manufacturers extend namespaces

XML tags

e:serializable

The tag that triggers SerializableParser

Load characteristics

rO0AB…

Common Base64 prefixes for Java serialized streams

Detection echo

Failed to load class for result object:

Error when readingObject loads an unknown class (Tuxshin)

Configuration verification

enabledForExtensions=false

Values retrieved in the repaired web.xml file (not malicious, for verification purposes only).

The above metrics only address the exploitation and detection characteristics of this vulnerability. CISA requires forensic triage of KEV entries; simply patching without checking whether it has already been exploited is insufficient.

VI. Supplementary Explanation

The core changes in PR #171 are twofold: changing enabledForExtensions from true to false; and adding XmlRpcEnabledFilter to reject requests at the endpoint layer when webservices.enableXmlRpc is false. Tuxshin verified the official binary SHA-256: 6.1.4 a67cc9dd…55823, 6.1.5 c0f16e07…07ea8, 6.1.6 59e22302…39525, and 6.1.7 59a1fcc2…726a4; the XML-RPC jar bundled with the four versions has identical bytes, indicating this is a pure Roller-side configuration fix. The discoverer is listed as n0mi1k, and Matt Raible is listed as the reporter for CVE-2026-129448.

VII. Recommendations for Subsequent Use

Legacy interfaces such as XML-RPC and SOAP, which are "reserved for compatibility with older clients," should be disabled by default, and the toggle should be set at the endpoint layer—not the business handler layer. Any extended types that trigger native Java deserialization should not be enabled on public-facing interfaces. For legacy Java applications still in operation, the "admin panel feature switches" and the "actual mappings in web.xml" should be checked separately, as they often differ.

Reference source

• Apache Security Bulletin CVE-2026-129448 (November 17, 2026):
https://lists.apache.org/thread/lnz4s26tv6hdo03wngtdbpfj4hg4gtds

• Apache Security Bulletin CVE-2026-82384 (September 26, 2026):
https://lists.apache.org/thread/cc0jck13nb9vvcmzxzwotr6n16mx28z9

• GitHub Advisory: GHSA-pxp4-phq9-fx2q:
https://github.com/advisories/GHSA-pxp4-phq9-fx2q

• Fix PR: apache/roller#171:
https://github.com/apache/roller/pull/171

• Tuxshin: Exploiting Apache Roller: pre-auth XML-RPC deserialization:
https://tuxshin.com/article-apache-roller-xmlrpc-deserialization

• BleepingComputer: Apache warns of Roller RCE vulnerability exploited in attacks:
https://www.bleepingcomputer.com/news/security/apache-warns-of-roller-rce-vulnerability-exploited-in-attacks/

• CISA KEV Announcement (November 20, 2026):
https://www.cisa.gov/news-events/alerts/2026/11/20/cisa-adds-four-known-exploited-vulnerabilities-catalog

• NVD: CVE-2026-129448:
https://nvd.nist.gov/vuln/detail/CVE-2026-129448


Conclusion

To assess the risk of a permission, one must consider what it ultimately accesses. In the VMware case, virtualization management permissions could access domain controller data. In the Wagyu case, the issuing account had access to far more inventory than the actual market trading volume, but even a portion of the tokens entering the order book was enough to cause the price to plummet by approximately 99.8%. Fluidkey brings another boundary to the forefront: even if the private key remains on the device, a user could still complete a signature without explicit authorization.

These differences determine what needs to be investigated after an incident. After patching vCenter or Expressway, companies need to trace back whether management credentials, internal nodes, and sensitive data have been accessed. Issuers need to calculate how much inventory a single account can move at once. Wallet teams need to verify whether the receiving address and amount seen and confirmed by the user are consistent with the transaction ultimately signed by the device. Only such verification can translate "the vulnerability has been patched" into a more specific judgment: what data, credentials, or assets were previously exposed?

Copyright and Disclaimer

This article and related technical analysis are exclusively published by the GCSA Global Cybersecurity Alliance. For reprint permission, please retain the official GCSA source and original link in full, and do not maliciously alter the core viewpoints of the report.

This article is for cybersecurity research, public risk awareness, and informational reference only, and does not constitute investment, legal, or financial advice. The terms "potential breaches," "potential risks," and attack scenarios mentioned herein should be distinguished from verified facts. Unless otherwise expressly stated, the GCSA has not conducted independent forensic investigations or attributed the attack to this incident.

Please follow GCSA on the following social media platforms for the latest updates.

GCSA X (Twitter):
https://x.com/gcsa_com

GCSA Telegram:
https://t.me/GCSAofficial

GCSA WeChat Official Account:
https://mp.weixin.qq.com/s/ouyL9NwrDDjhMumvehdOmw

Source:Global Cybersecurity Alliance (GCSA)
Website:www.gcsa.org