# GHSA-8FH7-7Q4Q-CQ52: Miren Runtime: Authentication bypass in RPC layer: unverified TLS client certificates grant cluster superuser access

- Database: GitHub
- Severity: critical (stated by ghsa, no CVSS score)
- Published: 2026-11-19
- Modified: 2026-11-19

## Tracked as

- [CVE-2026-75521](https://cve.now/CVE-2026-75521.md): Runtime authentication bypass in RPC layer via forged client certs

## Affected versions

- miren.dev/runtime (Go): fixed in 0.11.1

## Description

### Summary

  The Miren Runtime RPC server (QUIC/HTTP3, default port `:8443`) requested TLS
  client certificates but never verified that a presented certificate chained to
  the cluster Certificate Authority. Because a client-certificate identity is
  granted a blanket RBAC bypass, any party able to reach the RPC listener could
  present a forged, self-signed certificate and be authenticated as a cluster
  **superuser** — no valid CA signature, credential, or prior authorization
  required.

### Impact

  This is a complete, unauthenticated authentication bypass against the cluster
  control plane. An attacker who can reach the RPC port can perform any RPC
  operation with full privileges: enumerate and manipulate entities, apps,
  sandboxes, disks, and other cluster resources. This yields full compromise of
  confidentiality, integrity, and availability of the cluster and everything it
  orchestrates.

  Exposure is network-reachability–gated only. Deployments that expose `:8443`
  beyond a trusted network (e.g. `0.0.0.0/0`) are remotely exploitable from the
  internet by anyone; deployments that restrict `:8443` to a trusted network are
  exploitable by any party with access to that network.

Due to a lack of ability to detect if the RPC has been accessed unauthorized,
Miren recommends that all applications are redeployed and any credentials reference
in environment variables are rotated. A read-only script to help review standing access,
recent changes, and the exact secrets to rotate is available at https://github.com/mirendev/runtime/tree/089582a132f7fc1e1d5b5c0aee1e0911535fed53/scripts/security/audit-exposure.


### Details

  Three independent factors combined to produce the bypass:

  1. **The listener never verified the client-certificate chain.** When a cluster
     CA was configured, the RPC listener used `tls.RequestClientCert`, which
     requests a client certificate but does not verify it against the configured
     `ClientCAs`. `tls.ConnectionState.VerifiedChains` was therefore always empty,
     and no `VerifyPeerCertificate`/`VerifyConnection` hook re-checked the chain.

  2. **The authenticator derived identity from an unverified certificate.** The
     RPC authenticators read `PeerCertificates[0].Subject.CommonName` directly as
     the caller identity, with method `cert`, without checking that the chain had
     been verified.

  3. **Authorization granted a blanket bypass to certificate identities.** The
     authorizer returned "allowed" for any `cert`-method identity, skipping all
     RBAC checks.

  Go's TLS client only presents a certificate whose issuer Distinguished Name
  matches a CA advertised by the server, but that comparison is on the (public,
  non-secret) DN bytes only — it does not require a valid signature from the CA.
  An attacker can therefore mint a self-signed certificate whose **issuer DN is
  byte-identical to the cluster CA subject**, signed with an attacker-controlled
  key. The stock client presents it, and the vulnerable server accepts it and
  trusts its CommonName as a superuser identity.

### Patches

  Fixed by verifying the client-certificate chain before trusting it:

  - The listener now uses `tls.VerifyClientCertIfGiven` when a cluster CA is
    configured. A presented certificate must chain to the configured CA to
    complete the handshake, while certless callers (JWT/OIDC, which authenticate
    via the `Authorization` header) are still admitted.
  - As defense in depth, both RPC authenticators now require a non-empty
    `VerifiedChains` before deriving an identity from a client certificate.

  Users should upgrade to the patched release and restart the server so the
  new listener configuration takes effect.

### Workarounds

  Until the patch is deployed, restrict network access to the RPC port (`:8443`)
  so that it is not reachable from untrusted networks — remove any
  `0.0.0.0/0` ingress and limit it to trusted management networks. This is a
  containment measure only and does not remove the underlying vulnerability.

## References

- https://github.com/mirendev/runtime/security/advisories/GHSA-8fh7-7q4q-cq52
- https://nvd.nist.gov/vuln/detail/CVE-2026-75521
- https://github.com/mirendev/runtime/commit/e2159c8c8559da3f1c1485b463c794d656cd2fe4
- https://github.com/mirendev/runtime
- https://github.com/mirendev/runtime/releases/tag/v0.11.1

Page: https://cve.now/GHSA-8FH7-7Q4Q-CQ52
