//nefariousplan

CVE-2026-123890: vmdir's DCE/RPC Interface Returned the SRP Session Key to Callers Who Had Not Proved the Password. Broadcom Patched the Same Primitive on vmdir's LDAP Interface in July.

vendor

patterns

cve

proof of concept

vmdir, VMware's directory service, authenticates callers over two transports. LDAP on 389 and 636. DCE/RPC on 2012. Both transports negotiate SRP-6a with the caller and reconstruct a shared session key K from the server's stored verifier for [email protected]. On July 29, 2026 Broadcom's VMSA-2026-0007 patched a flaw that let an unauthenticated LDAP caller recover K without knowing the password: CVE-2026-59309. On November 19, 2026 VMSA-2026-0009 patched the same primitive over DCE/RPC: CVE-2026-123890. Google Threat Intelligence attributes the DCE/RPC exploit to the China-nexus actor ARMORY CASTLE, and the recovered loader carries a Portable Executable compile timestamp of 2026-07-13T09:21:24Z. The compile predates the LDAP CVE's publication by sixteen days.

The daemon has two surfaces

vmdir is the directory daemon that backs vSphere Single Sign-On. It stores users, groups, service principals, and the SRP verifiers that authenticate them. A vSphere administrator never talks to vmdir directly. A vSphere administrator talks to the SSO Security Token Service, the Security Token Service talks to vmdir, and vmdir checks the password.

vmdir listens on two transports. The LDAP listener handles bind requests on port 389 and port 636, and its SRP mechanism is registered inside the daemon's SASL plumbing. The DCE/RPC listener handles the service's internal control plane on port 2012, and its SRP exchange is implemented in a dedicated interface named rpc_srp_verifier, UUID c7e94609-6ab0-4767-8e92-b6485bff1649. The UUID is the one Google Threat Intelligence published in its November 20 YARA rule for the ARMORY CASTLE loader.

Both interfaces answer the same question. Given a username and the client's SRP A value, what is the shared session key K that the client and the server derived from the stored verifier? The LDAP interface answers it as part of SASL BIND. The DCE/RPC interface answers it in five discrete RPC calls. The two interfaces are a parallel implementation gap in the strict form: the same capability, implemented twice in the same source tree, with one copy gated by a proof check and the other copy, for one hundred and thirteen more days, not gated at all.

The primitive is the session key

The Secure Remote Password protocol produces a shared secret K between a client who knows a password and a server who knows a verifier derived from that password. The client sends A. The server sends B and the salt s. Both sides derive a scrambling parameter u. The server computes K from (A, v, u, b). The client computes K from (a, B, u, x), where x is derived from the password. The two sides then exchange proofs, M from the client and HAMK from the server, each of which is a hash over K and the public values. If the proofs match, both sides know they derived the same K, and K becomes the authenticated session key.

K is the thing you cannot derive without the password. Everything else in the exchange is public. The design property of SRP-6a is that the server reveals nothing about the password until the client proves it knows the password.

vmdir's upstream source lives under VMware's Lightwave project. The DCE/RPC interface is defined in vmdir/idl/srp_verifier.idl:

long rpc_srp_verifier_new(
    [in] handle_t hServer,
    [in] long alg,
    [in] long ng_type,
    [in, string, ptr] char *username,
    [in] rpc_p_srp_bytes_container bytes_A,
    [in, out] rpc_p_srp_bytes_container *B_value,
    [in, out] rpc_p_srp_bytes_container *bytes_s,
    [in, out] rpc_p_srp_bytes_container *MDA_value,
    [in, string, ptr] char *n_hex,
    [in, string, ptr] char *g_hex,
    [in, out] srp_verifier_handle_t *hSrp);

long rpc_srp_verifier_get_session_key(
    [in] handle_t hServer,
    [in] srp_verifier_handle_t hSrp,
    [in, out] rpc_p_srp_bytes_container *key);

long rpc_srp_verifier_verify_session(
    [in] handle_t hServer,
    [in] srp_verifier_handle_t hSrp,
    [in] rpc_p_srp_bytes_container user_M,
    [in, out] rpc_p_srp_bytes_container *bytes_HAMK);

rpc_srp_verifier_new initialises the exchange on the server and returns B and the salt to the caller. rpc_srp_verifier_verify_session receives the client's proof M and returns the server's proof HAMK if the proofs matched. Between those two calls sits rpc_srp_verifier_get_session_key, which returns the derived session key K to the caller as a byte container.

The server implementation in vmdir/server/vmdir/rpcsrpserv.c does what the IDL says it does. The get_session_key handler looks up the per-connection verifier state from the context handle and asks the vendored csrp library for the key:

const unsigned char *key = NULL;
int key_len = 0;
key = srp_verifier_get_session_key(ver, &key_len);
dwError = _srp_bytes_container_allocate(key, key_len, &key_cont);

From the caller's perspective, get_session_key is the middle call of a three-call sequence: new, get_session_key, delete. verify_session is a separate call on the same context handle. Whether the caller invokes verify_session before or after get_session_key, and whether the caller invokes verify_session at all, is a decision the caller gets to make. The IDL does not express an ordering constraint on get_session_key, and the server does not enforce one.

This is the shape of the primitive. The caller receives K from the server before, or without, demonstrating that the caller can also derive K.

July was the LDAP surface

On July 29, 2026 Broadcom's VMSA-2026-0007 patched CVE-2026-59309, an authentication bypass in vmdir's LDAP SRP mechanism. The advisory summary is one sentence. The mechanism in the source is that the LDAP SASL dispatcher wrote the derived K into the connection's authenticated-identity slot after the server computed K and before the client's M was checked against HAMK. A client that disconnected after the server sent B, or that sent an M of the correct length that did not verify, had already seen into its negotiating state everything that a successful authentication would have produced.

Broadcom's fix for CVE-2026-59309 moved the K assignment to run only after the proof check succeeded. That fix shipped on July 29. It covered the LDAP surface. It did not touch rpcsrpserv.c.

November was the RPC surface

On November 19, 2026 VMSA-2026-0009 patched CVE-2026-123890, an authentication bypass in vmdir's DCE/RPC SRP interface. The affected transport is port 2012. The CWE assigned is 288, Authentication Bypass Using an Alternate Path or Channel. The advisory names three fixed releases, 8.0 U3m, 9.0.2.0200, and 9.1.1.0200, extends extended-support coverage to 7.0, and declines to cover 6.5 and 6.7. There is no workaround.

The mechanism is the one the IDL describes. A caller invokes rpc_srp_verifier_new with a username and A. The server derives B, s, and K from the stored verifier and returns B and s. The caller invokes rpc_srp_verifier_get_session_key. The server returns K. The caller never invokes rpc_srp_verifier_verify_session. The caller now holds K for [email protected] without having proved the password.

What the caller does with K is in the fixtures Google Threat Intelligence published alongside its ARMORY CASTLE write-up. K is used to sign subsequent SSO token requests and to authenticate follow-on RPC calls that vmdir treats as a privileged administrator session. Once the caller holds K for [email protected], the caller is [email protected].

The patch for CVE-2026-123890 adds a state check inside Srv_rpc_srp_verifier_get_session_key that refuses to return the key container unless the handle's verifier has transitioned into the verified state, which Srv_rpc_srp_verifier_verify_session is the only thing that sets. The fix is four lines. It was available to be written in July. It was written in November.

The loader was compiled on July 13

Google Threat Intelligence published the ARMORY CASTLE attribution on November 20. The write-up names a family of implants installed on compromised vCenter appliances and a staging loader whose Portable Executable compile-time field reads 2026-07-13T09:21:24Z. Google's YARA rule for the loader keys on the RPC interface UUID of rpc_srp_verifier, present as a static byte sequence in the sample. The UUID is the one in srp_verifier.idl in the Lightwave source tree.

The LDAP CVE was patched on July 29. The RPC CVE was patched on November 19. The loader was built on July 13. Sixteen days before the LDAP surface of this primitive was named, ARMORY CASTLE already held a working exploit for the RPC surface of the same primitive, carrying the RPC interface UUID as a static constant.

The pattern is not that July's patch was incomplete. The pattern is that July's patch addressed one of two surfaces, and the actor holding exploits for both surfaces watched the one they were not using get fixed.

The PoC on GitHub is for a different protocol entirely

The public PoC for CVE-2026-123890 on GitHub, published to the LLCForge/CVE-2026-123890 repository within hours of VMSA-2026-0009, is a Python script that opens a TCP connection to port 135 or port 445 and sends what it calls a "DCERPC auth_len=0 bypass" against the IRemUnknown2 DCOM interface, UUID 00000143-0000-0000-c000-000000000046. None of that applies to vmdir. vmdir does not listen on 135 or 445. IRemUnknown2 is a Microsoft DCOM interface and is not present in vmdir's endpoint map. The auth_len=0 bypass is a different class of vulnerability in a different RPC runtime on a different operating system. The PoC author's own code carries the comment # This is the standard DCOM interface; actual vCenter management interfaces differ.

The repository's README names VMSA-2026-0019 as the advisory of record, cites CWE-287, places the fix range from 8.0 U4a to 8.0 U4b, and credits Mandiant's incident-response team for the discovery. Broadcom's advisory of record is VMSA-2026-0009, the CWE is 288, the fix range begins at 8.0 U3m, and Mandiant's role is post-exploitation attribution rather than vulnerability discovery. Every verifiable claim in the README is wrong, in a direction that is plausible to a reader who has not opened the advisory.

This is phantom project documentation. The repository describes an advisory that does not exist, a CWE that does not match, a patch range that does not match, a discoverer who did not discover, and a transport that is not the vulnerable one, each field internally plausible and none of them jointly true. It will appear in the "available exploits" column of several asset-inventory products before the week is out, and in the "detections added" column of several endpoint products shortly after.

The primitive was readable, then it was readable, then it was named

CVE-2026-59309 named a session-key-return-before-proof flaw in vmdir's LDAP SRP implementation on July 29. The implementation of the sibling interface, rpc_srp_verifier, was in the same source tree with the same shape and the same target account. A reader who opened vmdir's source on July 30 to understand what had been patched would have found Srv_rpc_srp_verifier_get_session_key returning K from a handle whose verified state the function did not check. The reader who found that in July and reported it to Broadcom's PSIRT does not exist in the public record. ARMORY CASTLE, the reader who found it before July and did not report it, exists in Google's November blog post.

The claim this post makes is not that Broadcom fixes bugs slowly. The claim is that Broadcom fixes bugs locally. The July patch was correct for the LDAP transport. It was silent on the RPC transport. The RPC transport ran the same mistake for one hundred and thirteen more days.

What was quiet

The reason no one at Broadcom audited the RPC surface after shipping the LDAP patch is a question for Broadcom. The reason no external researcher audited it either, with the advisory and the upstream source both pointing at a surface that was once wrong and might still be wrong, is a question for the rest of us. SRP-6a's design property is that the server reveals nothing about the password until the client proves it knows the password. VMware's implementation revealed K to a caller who did not prove it, on an LDAP socket in July and on an RPC socket in November, from the same source tree with two transport layers above the same crypto library.

The CVE record for November 19 does not reference the CVE record for July 29. The advisory for November 19 does not reference the advisory for July 29. The connection between them exists in the code and in the compile timestamp of ARMORY CASTLE's loader.