-----BEGIN PGP SIGNED MESSAGE----- Hash: SHA256 NEFARIOUSPLAN-CANONICAL-V1 {"body_md":"## The CVE description is a contradiction unless the cookie is published\n\nNVD 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.\n\nThat 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.\n\n## `cm_server` admits every identity whose name begins with `wombat@`\n\nCisco 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.\n\nExpressway 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.\n\nThe 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 `wombat@127.0.0.1`; any string works, because the server's trust decision is the prefix, not the fully-qualified name.\n\nThe 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.\n\n```python\n# From dinosn/cve-2026-76466/exploit/cve_2026_76466.py\nmy_challenge = random.getrandbits(32)\ndigest = hashlib.md5(\n cookie.encode() + str(server_challenge).encode()).digest()\n_send_raw(sock, b\"r\" + struct.pack(\">I\", my_challenge) + digest)\n```\n\nThe default on the PoC's `--cookie` flag is literally `wombat`. The default on `--node` is `wombat@127.0.0.1`. Those are the strings that complete the handshake.\n\n## The visible cookie file is not this cookie\n\nOperators 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.\n\nThat 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.\n\n## TLS Permissive is the factory default, which is what \"unauthenticated\" means\n\nThe 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:\n\n```python\nctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)\nctx.check_hostname = False\nctx.verify_mode = ssl.CERT_NONE\n```\n\nNo 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.\n\n## Once the handshake completes, `rpc:call/4` is `os:cmd/1`\n\nThe 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.\n\n```python\n# From dinosn/cve-2026-76466/exploit/cve_2026_76466.py\nmfa = tup(atom(\"erpc\"), atom(\"execute_call\"), small_int(4))\nopts = lst([atom(\"monitor\")])\nargs = lst([req_id, atom(\"os\"), atom(\"cmd\"), lst([string_ext(\"id -u\")])])\nsend_dist(sock, tup(small_int(29), req_ref, mypid, gl, mfa, opts), args)\n```\n\n`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`.\n\n## \"No workaround\" means the credential is in the binary\n\nCisco'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.\n\nThe 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.\n\n## The maintenance primitive is the attack surface\n\n`add_allowed_wombat_node/1` is a [trust inversion](/patterns/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.\n\n## Cookie Is The Credential, at a non-HTTP transport\n\nThe [Cookie Is The Credential](/patterns/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](/posts/redline-wr3200-admin-is-a-string), [GPUStack](/posts/gpustack-force-auth-localhost-defaulted-false)) 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.\n\nThe 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.\n\nThe 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.\n\nPoC: [dinosn/cve-2026-76466](https://github.com/dinosn/cve-2026-76466)","closing_line":"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.","hook_md":"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.","post_id":886,"slug":"cisco-expressway-add-allowed-wombat-node","title":"CVE-2026-76466: Cisco Expressway's Cluster Manager Admits Any Erlang Node Named `wombat@`. The Cookie Is Also `wombat`.","type":"initial","unreadable_sentence":"The CVE description names \"unauthenticated\" and \"persistent cookies\" in the same sentence. The resolution is that the cookie is a public constant compiled into every binary Cisco has ever shipped on this release line."} -----BEGIN PGP SIGNATURE----- iHUEARYIAB0WIQRf0htP5+SjynlxywneZjl4jgkQJgUCawHuswAKCRDeZjl4jgkQ JoBuAQDyvgHzgfoDVWEW2I6hC2Po8oy9qYhKcrBb68fm3yf3vQD/fuAKM0lotDaI h6p02JrtvsaD2Dgb1RIlVML5C/0Z6gE= =Ik+c -----END PGP SIGNATURE-----