GitHub reviewed GHSA-8fh7-7q4q-cq52 (CVE-2026-75521) as critical on November 19, 2026: the Miren Runtime RPC control plane accepted TLS client certificates on QUIC port :8443 without verifying they chained to the cluster CA, then treated cert-method identity as a blanket superuser. Any party who could reach the listener could mint a forged self-signed certificate and perform full cluster RPC—enumerate and manipulate entities, apps, sandboxes, disks, and other orchestrated resources. The fix ships in v0.11.1. If coding agents manage your agent-hosting infrastructure, upgrade immediately, close public ingress on :8443, and redeploy plus rotate secrets the vendor recommends after control-plane exposure.
TL;DR
| Question | Answer |
|---|---|
| Am I affected? | Yes if miren.dev/runtime < 0.11.1 and RPC :8443 is reachable from a network you do not fully trust |
| Is there a fix? | v0.11.1 — listener uses tls.VerifyClientCertIfGiven; authenticators require non-empty VerifiedChains |
| Attacker prerequisites? | TCP/QUIC reachability to RPC; no valid cert or password required on the vulnerable build |
| Severity? | Critical, CVSS 4.0 10.0 on the GitHub advisory |
| Workaround until patch? | Remove 0.0.0.0/0 ingress on :8443; management networks only — containment, not remediation |
| After patch? | Restart server, redeploy apps, rotate env credentials; Miren points to an audit-exposure script |
| Coding-agent angle? | Agents that scaffold cluster YAML/Helm may expose the port or assume client certs imply auth — verify, do not trust generated ingress |
What Miren Runtime is in this context
Miren Runtime (miren.dev/runtime, Go) is a cluster runtime that exposes management over QUIC/HTTP3 RPC (default :8443). It orchestrates entities, applications, sandboxes, disks, and related cluster resources—workloads teams increasingly run for isolated agent execution, batch jobs, and app sandboxes beside harnesses like Claude Code or Codex when a managed control plane (compare Parcha AgentRun or Prime Radiant external sandboxes) sits in front of the harness.
This advisory is not a model prompt-injection issue. It is a classic TLS and authorization composition failure on the management API—the layer agents touch indirectly when they apply infra changes.
What the advisory says
The GitHub-reviewed text credits disclosure with public availability on July 8, 2026 and NVD publication November 18, 2026. GitHub’s reviewed stamp is November 19, 2026. Weakness: CWE-295 (improper certificate validation). NVD mirrors the same mechanism.
Impact in one sentence: complete, unauthenticated authentication bypass of the cluster control plane—confidentiality, integrity, and availability of the cluster and everything it orchestrates.
Exposure rule: network reachability only. Internet-exposed :8443 means anyone can exploit; private management VLAN means any insider or lateral mover on that VLAN.
Because unauthorized RPC use may leave no reliable detection signal, Miren’s advisory recommends redeploying applications and rotating credentials referenced in environment variables after remediation, and links a read-only script to review standing access and recent changes.
Mechanism step by step
Three independent flaws compound:
1. The listener requested but did not verify client certificates
When a cluster CA was configured, the RPC listener used tls.RequestClientCert. That mode asks for a client certificate but does not require a chain validated against ClientCAs. In Go, tls.ConnectionState.VerifiedChains stays empty, and no VerifyPeerCertificate / VerifyConnection hook re-validated the chain.
Operators often read “mutual TLS enabled” from config and assume verified mutual TLS. Request is not require-and-verify.
2. Authenticators trusted an unverified peer certificate
RPC authenticators read PeerCertificates[0].Subject.CommonName as caller identity with method cert, without checking that verification succeeded.
3. Authorization bypassed all RBAC for cert identities
The authorizer returned allowed for any cert-method identity, skipping RBAC. Forged cert + accepted CommonName = implicit superuser.
4. Forging a cert the stock Go client will present
Go’s TLS client presents a certificate whose issuer Distinguished Name matches a CA the server advertises—but that match compares public DN bytes, not a valid signature from the CA private key.
An attacker generates a self-signed client certificate whose issuer DN is byte-identical to the cluster CA subject, signed with an attacker-controlled key. The stock client sends it; the vulnerable server accepts it and trusts the CommonName as superuser identity.
5. Patch behavior in v0.11.1
Per the advisory:
- The listener now uses
tls.VerifyClientCertIfGivenwhen a cluster CA is configured—a presented certificate must chain to the configured CA to complete the handshake. Callers using JWT/OIDC via theAuthorizationheader without a client cert remain supported. - Defense in depth: both RPC authenticators require non-empty
VerifiedChainsbefore deriving identity from a client certificate. - Restart required so the new listener configuration loads.
Workaround until upgraded: restrict :8443 to trusted management networks; remove 0.0.0.0/0 ingress. The advisory states this is containment only.
This pattern rhymes with other “policy declared but enforcement path ignores it” bugs we covered this month—node-opcua namespace RBAC fail-open and GPUStack auth bypass on administrative routes—but here the failure is entirely in TLS verification + cert-method superuser.
Why RequestClientCert is not mutual TLS
Security reviewers often map “client cert requested” to mTLS. In Go’s crypto/tls, the modes differ:
| Listener mode | Client may send cert | Server verifies chain to ClientCAs |
|---|---|---|
RequestClientCert | Optional | No — handshake can complete with empty VerifiedChains |
RequireAnyClientCert | Required | No — still no automatic CA verification |
VerifyClientCertIfGiven | Optional | Yes when a cert is presented and ClientCAs is set |
RequireAndVerifyClientCert | Required | Yes |
The vulnerable Miren build sat in the first row while authorization treated any presented cert as proof of identity. Penetration testers classically reproduce this by completing the handshake and inspecting VerifiedChains in a short Go probe—if the slice is empty yet RPC calls succeed, you are in bypass territory.
Operators who previously ran only JWT/OIDC on RPC are still affected when the listener accepted optional client certificates during the vulnerable window: an attacker does not need stolen bearer tokens if they can speak TLS to :8443.
Forensics and detection gaps
The advisory states Miren cannot reliably detect whether unauthorized RPC ran. Practical review steps on < 0.11.1 clusters with exposed management networks:
- Firewall and load-balancer logs for successful sessions to
:8443from IPs outside your bastion CIDR during the exposure window. - Application and sandbox inventory for entities created, resized, or deleted without change tickets—superuser RPC can manipulate apps and sandboxes wholesale.
- Credential rotation history for secrets injected via orchestrated workloads; treat unexplained rotations as suspicious if they precede your upgrade date.
- Git history on infra repos if coding agents committed Helm values that exposed
:8443or documented “mTLS” without verify flags—those commits are worth blaming in postmortems even when the root CVE is server-side.
Negative findings still belong in incident notes: auditors ask whether agent-stored kubeconfigs could have been exfiltrated through a rebuilt sandbox definition, not only whether someone ran kubectl manually.
Who is affected
In scope:
- Any cluster running
miren.dev/runtimeversions below0.11.1 - Deployments where
:8443is reachable from office Wi‑Fi, CI runners, shared lab VLANs, or the public internet - Teams that enabled client certificate authentication on RPC without independently testing forged cert rejection
- Agent-platform engineers who treat Miren as the scheduler behind sandboxes coding agents target through MCP or CI
Lower immediate risk:
- Installations already on
0.11.1+with management-only network policy - Environments with no client cert path and JWT-only callers after patch (still upgrade—pre-patch builds were vulnerable to forged certs regardless of your intent)
Not fixed by patching agents: Claude Code, Codex, and Cursor binaries do not embed Miren. Risk is control-plane compromise and downstream secrets (API keys, kubeconfigs, sandbox images) agents pull on the next run.
How to check and fix
Version and exposure
- Identify the running build — container tag, Helm
appVersion, orgo list -m miren.dev/[email protected]as the target floor. - Map
:8443listeners —ss/netstaton hosts, cloud security groups, and agent-generated Terraform for load balancers. - Read TLS listener config — search repos for
RequestClientCert; confirm production values move toVerifyClientCertIfGivenpost-upgrade (patch description in the advisory).
Upgrade path
- Deploy
v0.11.1from GitHub releases. - Restart the RPC server process so TLS settings reload.
- Run Miren’s audit-exposure helper to review standing access and which secrets to rotate (read-only script path cited in the advisory).
- Redeploy applications the cluster managed and rotate credentials stored in environment variables if the RPC port was exposed during the vulnerable window.
Containment if you cannot patch immediately
- Deny ingress to
:8443from non-management CIDRs at the firewall and cloud edge. - Do not rely on “we only use OIDC” on a vulnerable build—the bypass is forged client certs, not stolen bearer tokens.
What this means if you run AI coding agents
Coding agents change how this vulnerability reaches production, not whether the bug exists:
- Infra scaffolding at machine speed — Agents asked to “add Miren” or “expose the control API for debugging” often emit
hostNetwork,0.0.0.0bindings, or LoadBalancer Services without reading TLS verify mode. Treat every agent PR that touches:8443like a production admin API change—same discipline as NGINX HTTP/2 RCE patches this month when agents batch emergency fixes. - False confidence from “mTLS” comments — A README line that says “client certificates enabled” does not prove
VerifyClientCertIfGiven. Ask agents to cite listener code or Helm values, not adjectives. - Sandbox integrity — A superuser RPC session can reshape sandboxes and disks your harness uses through AgentRun-style wrappers. After upgrade, rebuild sandbox images if the control plane was internet-exposed on
< 0.11.1. - Secret rotation — Agents stash kubeconfigs, cloud tokens, and MCP URLs in env files. Control-plane compromise is a prompt to rotate, not only to bump a Go module. See November 2026 attacks timeline for how quickly infra CVEs stack beside agent incidents.
- Supply-chain parallels — The failure is Go stdlib TLS semantics, not npm—but the operator mistake matches trusting config names over enforcement paths, the same lesson as MCP rug-pull patterns when agents add servers without version pins.
What agents should not do after exposure: run broad “cleanup” shell scripts across the cluster without human review; that is a common post-compromise path when teams panic-patch.
What Beam can and cannot do here
Beam does not terminate Miren QUIC RPC, validate TLS client certificates on your cluster, or patch miren.dev/runtime. It is local, on-device observability for Claude Code, Codex, and similar harnesses on developer machines.
Where overlap exists: if incident response leads agents to rewrite kubeconfigs, paste new MCP endpoints, or chmod/curl credential files during rotation, Beam’s heuristic skill and MCP config scanning, PreToolUse hook denies (where configured), and redaction before storage can surface risky follow-on actions on the laptop. That is secondary—not a substitute for v0.11.1 and network containment. Scanning is heuristic; enforce modes can be fail-open without cached policy. See how Beam watches agent activity.
Frequently asked questions
What is CVE-2026-75521?
It is a critical authentication bypass in Miren Runtime before 0.11.1 where unverified TLS client certificates on the QUIC RPC listener granted cluster superuser access.
Which Miren Runtime versions are affected?
Versions of miren.dev/runtime below 0.11.1 per GHSA-8fh7-7q4q-cq52.
How do attackers exploit CVE-2026-75521?
They present a forged self-signed client certificate whose issuer DN matches the public cluster CA subject; the server accepts the CommonName and skips RBAC for cert-method callers.
Is CVE-2026-75521 remotely exploitable?
Yes when port :8443 is internet-reachable; otherwise exploitation requires access to the network where RPC is exposed.
What is the CVSS score for CVE-2026-75521?
GitHub lists 10.0 on CVSS 4.0 with network vector and high CIA impact on vulnerable and subsequent systems.
How do I check if I run vulnerable Miren Runtime?
Compare deployed tags and go list -m output to 0.11.1 and audit firewall rules for :8443.
What should I do after patching Miren Runtime?
Restart the server, redeploy orchestrated apps, rotate environment credentials, and use Miren’s audit-exposure script cited in the advisory.
Does this affect AI coding agents directly?
Agents do not bundle Miren, but they may expose or misconfigure the control plane; compromise there affects sandboxes and secrets agents use on the next deploy.
Related reading
- node-opcua CVE-2026-95860 RBAC fail-open
- GPUStack SAML callback auth bypass CVE-2026-102894
- AgentRun managed agents and sandbox trust boundaries
- Prime Radiant external sandboxes for Claude Code and Codex
- MCP security practical guide
- November 2026 attacks timeline
CVE text, CVSS, and patched version are accurate as of November 19, 2026, per the GitHub advisory and v0.11.1 release.

