Cisco's own advisory sentence for CVE-2026-76466 reads "unauthenticated, remote attacker with persistent cookies and network access to execute commands as root on a clustered device via the database service." Read it twice. An unauthenticated attacker who holds persistent cookies. The resolution of the contradiction is in the cluster-manager module. A function called add_allowed_wombat_node/1 admits any Erlang distribution identity whose name begins with wombat@. The same function installs a maintenance cookie whose value is the ASCII string wombat. Both values are compile-time literals in cm_server. Every affected release of Cisco Expressway ships the same two words. The CVE description is not wrong. It is admitting that the cookie is public.
CVE-2026-76466: Cisco Expressway's Cluster Manager Admits Any Erlang Node Named `wombat@`. The Cookie Is Also `wombat`.
vendor
patterns
cve
proof of concept
The CVE description is a contradiction unless the cookie is published
NVD prints the vendor's own language. "Unauthenticated, remote attacker with persistent cookies and network access can execute commands as root on a clustered device via the database service." The sentence names "unauthenticated" and "persistent cookies" in the same breath. An attacker holding persistent cookies has credentials. An attacker who has credentials is authenticated. The only way both clauses are factually true at once is if the cookies are not credentials in the sense authentication normally uses that word. They are public constants.
That is exactly what CVE-2026-76466 is. The term "persistent cookies" in the sentence is the Erlang-distribution shared-secret cookie, not an HTTP cookie. What persists is the value across source releases, not a session the server minted. Reading one shipped binary publishes the credential across every affected deployment of every affected release. CISA added CVE-2026-76466 to the Known Exploited Vulnerabilities catalog with a federal remediation deadline of November 23. The CVE was published on October 21. Thirty-one days from publication to KEV listing, with a two-business-day compliance window on the back end. There is enough in-wild activity to compress that window to a shape federal operators do not typically see.
cm_server admits every identity whose name begins with wombat@
Cisco Expressway runs Erlang/OTP for its cluster database service. When two or more nodes are configured as a cluster, each node runs a TLS-wrapped Erlang distribution listener on TCP/4372 and a fake EPMD multiplexed on the same port. The Erlang distribution protocol authenticates peer nodes via a shared "cookie," a single byte string that both sides concatenate with a per-connection challenge, MD5, and exchange. Hold the cookie and reach the port, hold root on the remote node. Erlang's rpc:call/4 routes arbitrary function invocations through the distribution handshake into the remote VM, which runs with the privileges of the Erlang runtime, which on Expressway is root.
Expressway ships its cluster-management logic as the Erlang module cm_server. The module contains a function Nicolas Krassas found by static-analyzing the compiled beam: add_allowed_wombat_node/1. The function is explicit. It takes a node identity as an argument, admits any identity whose name begins with the four-character prefix wombat followed by @, and installs a matching cookie into the Erlang auth table via cm_dist:set_allowed_nodes/1. The identity prefix is a hardcoded literal. The cookie is a hardcoded literal. The compiled module's binary is identical across every installation of every affected release.
The dist listener invokes this function on every inbound handshake. When a connecting client presents a node name beginning with wombat@, the function admits the identity and registers the cookie before the cookie challenge runs. The string after the @ is unconstrained. The PoC uses [email protected]; any string works, because the server's trust decision is the prefix, not the fully-qualified name.
The handshake then runs normally. The server generates a four-byte challenge and sends it to the client. The client computes MD5(cookie || str(challenge)) and sends the digest back. The server verifies that the client's digest matches what it would have computed with the admitted cookie. The admitted cookie is "wombat". Any client that knows the string "wombat" passes the challenge.
# From dinosn/cve-2026-76466/exploit/cve_2026_76466.py
my_challenge = random.getrandbits(32)
digest = hashlib.md5(
cookie.encode() + str(server_challenge).encode()).digest()
_send_raw(sock, b"r" + struct.pack(">I", my_challenge) + digest)The default on the PoC's --cookie flag is literally wombat. The default on --node is [email protected]. Those are the strings that complete the handshake.
The visible cookie file is not this cookie
Operators who manage Expressway know there is a file called erlangcookie.conf on the appliance. Under normal cluster operation, the two peers authenticate to each other with the value in that file. An operator who reads the advisory and goes looking for a credential to rotate finds that file first. Krassas's analysis is explicit: that is the peer cookie, not the maintenance cookie. The peer cookie is derived by cm_server from a base value plus an internal version identifier, which means rotating the visible file does not rotate the peer cookie, and rotating the peer cookie does not touch the maintenance cookie at all. The maintenance cookie is installed by a separate code path, in the same module, on every handshake that arrives bearing the wombat@ prefix. There is no file for it. There is no configuration knob for it.
That is why Cisco's advisory lists no workaround. The common first move, identify the shipped credential, rotate it, redeploy, does not reach this credential, because this credential is not a deployed artifact. It is a compiled constant inside a shipped binary. The patch (release X15.5.20) is the only remediation Cisco offers because the patch is the only release in which the compiled constant is different.
TLS Permissive is the factory default, which is what "unauthenticated" means
The Erlang dist listener on 4372 is wrapped in TLS. Reading the CVSS vector with an operator's eye, one might assume AV:N / AC:L / PR:N requires some TLS-layer credential: a client certificate, a pre-shared key, a token. It does not. Expressway ships two TLS client-authentication modes. Enforcing: the server validates client certificates against a configured trust store before accepting the connection. Permissive: the server accepts any TLS client, with or without a certificate. The factory default is Permissive. The PoC's tls_connect is a three-line standard-library block:
ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
ctx.check_hostname = False
ctx.verify_mode = ssl.CERT_NONENo client certificate. No key material. In Permissive mode the server accepts the TLS handshake and routes the raw bytes into cm_server. The TLS layer is doing transport encryption; it is not doing authentication. "Unauthenticated" in the CVE text is not loose language. It is factually correct in Permissive mode, which is the mode the server is shipped in.
Once the handshake completes, rpc:call/4 is os:cmd/1
The Erlang distribution protocol was designed for trusted intra-cluster use. A peer that completes the handshake is a peer: it can invoke any exported function on any process on the remote VM. The PoC uses erpc:execute_call, the modern implementation path for rpc:call/4, to send a spawn request to the remote rex server. The request body is a four-element tuple: a request id, the module atom os, the function atom cmd, and an argument list containing the string "id -u". The remote VM spawns the function, executes id -u as a shell command in the VM's process context, and returns the resulting IO list. The Expressway VM runs as root. os:cmd/1 runs the shell command as root. "0" returns.
# From dinosn/cve-2026-76466/exploit/cve_2026_76466.py
mfa = tup(atom("erpc"), atom("execute_call"), small_int(4))
opts = lst([atom("monitor")])
args = lst([req_id, atom("os"), atom("cmd"), lst([string_ext("id -u")])])
send_dist(sock, tup(small_int(29), req_ref, mypid, gl, mfa, opts), args)os:cmd is not the only sink. erlang:spawn/3, os:putenv/2, file:write_file/2, any exported Erlang function. The bounded command in the PoC is a scope decision by the author. The primitive is the full rpc:call.
"No workaround" means the credential is in the binary
Cisco's advisory offers "None" under Workarounds. The usual reading of that word is "we did not identify a safe config change." The actual reading of this instance is "the credential is a compiled constant." There is no wombat_cookie setting to flip. There is no node-allowlist override that disables the prefix match, because the override would need to live below cm_server, and cm_server is the module authoring the override in the first place. The maintenance identity is admitted before the configured peer list is consulted. The only remediation that reaches the credential is a software upgrade to a release in which cm_server was rewritten.
The practical defender has one knob between here and X15.5.20: switch TLS from Permissive to Enforcing, require client certificates, and configure a client-cert allowlist that denies anything the server did not issue for its own cluster peers. That is a mitigation, not a workaround. The defect in cm_server is still there; the mitigation sits at the TLS layer one tier above it. If any configured peer certificate is exposed (a backup is read, a management station is compromised), the mitigation falls. Cisco did not list it as a workaround because it is not scoped to this CVE, and because the factory default is not Enforcing.
The maintenance primitive is the attack surface
add_allowed_wombat_node/1 is a trust inversion at the cluster-management layer. The function reads like what a vendor's platform team would build to attach bringup nodes against production clusters without threading per-deployment credentials: admit a well-known identity prefix, install a well-known cookie, do not require the operator to coordinate state with every appliance in the fleet. In the factory-default TLS Permissive mode, the primitive is reachable from any network client. The tool Cisco built to manage access to its clustered appliances is the tool an unauthenticated attacker uses to reach the same appliances. The function exists, is exported, is called on every handshake, and does exactly what its name says. The defect is that the maintenance surface was never gated from the production surface, so the mechanism Cisco uses to reach its own fleet is the mechanism anyone on the network uses to reach the same fleet.
Cookie Is The Credential, at a non-HTTP transport
The Cookie Is The Credential pattern names a three-part shape. A field the client writes. A hardcoded literal in the server. A login flow whose only effect is to arrange for the literal to appear in every legitimate caller's handshake. Prior exhibits (Redline WR3200, GPUStack) are HTTP: the field is a browser cookie or a reverse-proxy header, the literal is "admin" or "127.0.0.1", the login flow writes the Set-Cookie. CVE-2026-76466 is the same shape at the Erlang distribution layer. The client-writable field is the cookie bytes the client concatenates into its challenge response. The server-side literal is "wombat" in cm_server. The "login flow" is whatever bootstrap script Cisco's provisioning tools run when a maintenance node attaches to a cluster; what that script does is present the same compile-time literal every time, on every appliance, in every release of the affected line.
The pattern does not require the transport to be HTTP. The pattern requires the credential to be a public constant and the comparison to be the entire gate. A reader coming from the Redline and GPUStack exhibits will recognize the diagnostic: when the only authentication artifact is a value the vendor ships identically into every instance, the authentication step has zero bits of entropy. The CVE text's word for that is "unauthenticated." The word is correct.
The pattern diverges from the HTTP exhibits on one axis. On Redline and GPUStack, the credential is written into the caller's browser by the vendor's own UI; reading the UI once publishes the credential. On Expressway, the credential never travels. It is inside the binary and has to be read out of the binary. The attacker's cost is reverse-engineering a .beam file. The population cost is zero: one reverse-engineering effort against one binary publishes the credential across every deployment of every affected release. The vendor cannot revoke a secret the vendor has already shipped. The vendor can only ship a new binary. That is X15.5.20.
There is no workaround because the credential is not configuration. The only release in which it is different is the one Cisco would like you to install.