Nov 19, 2026·9 min read·1 visit
Miren Runtime versions prior to 0.11.1 fail to validate client certificates on the QUIC/HTTP3 RPC port (8443). Unauthenticated network attackers can present a self-signed client certificate to bypass authentication and RBAC, obtaining full cluster superuser privileges.
CVE-2026-75521 is an unauthenticated remote authentication bypass vulnerability in Miren Runtime prior to version 0.11.1. The QUIC/HTTP3 RPC service configures its TLS listener with tls.RequestClientCert, which requests client certificates without validating them against the cluster Certificate Authority. Simultaneously, the RPC authenticators extract caller identities directly from PeerCertificates[0] without checking VerifiedChains, granting any caller presenting a self-signed certificate the AuthMethodCert identity and a complete Role-Based Access Control (RBAC) bypass.
Miren Runtime (miren.dev/runtime) is the core orchestration and execution engine of the Miren application platform. It manages application sandboxes, persistent storage disks, secret stores, and compute workloads across a cluster. Communication with the control plane occurs over a QUIC/HTTP3 Remote Procedure Call (RPC) interface listening on port 8443 by default.
In versions prior to 0.11.1, the RPC listener contains an improper certificate validation vulnerability classified under CWE-295 (Improper Certificate Validation) and CWE-287 (Improper Authentication). The vulnerability arises from an interaction between the Go crypto/tls configuration in pkg/rpc/state.go, the identity extraction logic in the RPC authenticators, and the privilege assignment rules in the authorization engine.
To support both mutual TLS (mTLS) clients and certificate-less clients authenticating via OpenID Connect (OIDC) or JSON Web Tokens (JWT), the server defaulted to the tls.RequestClientCert client authentication policy. Under Go's standard library implementation, tls.RequestClientCert requests a client certificate during the TLS handshake but performs no cryptographic verification against the configured ClientCAs root pool.
When a client presents an unverified certificate, the downstream RPC authenticators (LocalOnlyAuthenticator and RPCAuthenticator) inspect only r.TLS.PeerCertificates and fail to verify that r.TLS.VerifiedChains is populated. Because the Miren Runtime authorization layer grants an unconditional Role-Based Access Control (RBAC) bypass to any identity authenticated via rpc.AuthMethodCert, an unauthenticated remote attacker with network access to port 8443 can present a self-signed certificate to assume full cluster superuser privileges.
The root cause of CVE-2026-75521 spans three distinct layers of the Miren Runtime authentication architecture: the TLS handshake configuration, the HTTP request authenticator, and the RBAC authorization evaluator.
At the transport layer (pkg/rpc/state.go), Go's crypto/tls.Config defines four distinct policies for handling incoming client certificates when a certificate authority is present:
tls.NoClientCert: The server does not request a certificate from the client.tls.RequestClientCert: The server requests a certificate during the handshake, but does not verify its signature or trust chain against ClientCAs. ConnectionState.PeerCertificates is populated with the raw bytes provided by the peer, while ConnectionState.VerifiedChains remains empty (nil).tls.VerifyClientCertIfGiven: The server requests a certificate. If the client provides one, the TLS engine validates it against ClientCAs and aborts the handshake on failure. If the client provides no certificate, the handshake succeeds.tls.RequireAndVerifyClientCert: The server requires a certificate and verifies it against ClientCAs.In setupServerTls, Miren Runtime selected tls.RequestClientCert whenever so.requireClientCerts was false, which is the default state required to allow JWT and OIDC callers to connect without a client certificate. Furthermore, the server configured an explicit no-op VerifyConnection callback returning nil.
At the application authentication layer (pkg/rpc/authenticator.go and pkg/cloudauth/rpc_authenticator.go), the Authenticate method evaluated whether r.TLS != nil && len(r.TLS.PeerCertificates) > 0. Because PeerCertificates contains the raw unverified certificates sent over the wire, this condition evaluated to true for any client certificate regardless of issuer or signature validity. The authenticator extracted PeerCertificates[0].Subject.CommonName and returned an rpc.Identity struct with Method: rpc.AuthMethodCert.
At the authorization layer (pkg/oidcauth/composite_test.go), the runtime enforces a policy where any caller authenticated with rpc.AuthMethodCert bypasses all RBAC checks, even for unknown resources. Consequently, the unverified certificate identity is promoted directly to an unrestricted administrative context.
The vulnerability was resolved in commit e2159c8c8559da3f1c1485b463c794d656cd2fe4 by enforcing cryptographic chain verification at the TLS transport layer and adding defense-in-depth validation checks in both RPC authenticators.
In pkg/rpc/state.go, the setupServerTls method previously assigned tls.RequestClientCert and overrode VerifyConnection with a stub function:
// Vulnerable code in pkg/rpc/state.go
if so.requireClientCerts {
tlsCfg.ClientAuth = tls.RequireAndVerifyClientCert
} else {
tlsCfg.ClientAuth = tls.RequestClientCert // Requests cert, performs zero verification
}
tlsCfg.VerifyConnection = func(cs tls.ConnectionState) error {
return nil
}The patch replaces tls.RequestClientCert with tls.VerifyClientCertIfGiven and removes the no-op VerifyConnection callback. This ensures that certificate-less clients can complete the TLS handshake and authenticate at the HTTP layer via Authorization headers, while any client presenting a certificate during the handshake must chain back to the configured ClientCAs pool:
--- a/pkg/rpc/state.go
+++ b/pkg/rpc/state.go
@@ -398,18 +398,13 @@ func (s *State) setupServerTls(so *stateOptions) error {
if so.requireClientCerts {
tlsCfg.ClientAuth = tls.RequireAndVerifyClientCert
} else {
- tlsCfg.ClientAuth = tls.RequestClientCert
+ // VerifyClientCertIfGiven: a client is not required to present a
+ // cert (JWT/OIDC callers authenticate via the Authorization header),
+ // but if one IS presented it MUST chain to ClientCAs.
+ tlsCfg.ClientAuth = tls.VerifyClientCertIfGiven
}
- tlsCfg.VerifyConnection = func(cs tls.ConnectionState) error {
- return nil
- }To prevent regression if the TLS configuration is altered in future code paths, both LocalOnlyAuthenticator (pkg/rpc/authenticator.go) and RPCAuthenticator (pkg/cloudauth/rpc_authenticator.go) were updated to verify that r.TLS.VerifiedChains is non-empty before trusting r.TLS.PeerCertificates[0]:
--- a/pkg/rpc/authenticator.go
+++ b/pkg/rpc/authenticator.go
@@ -125,8 +125,11 @@ func (l *LocalOnlyAuthenticator) Authenticate(ctx context.Context, r *http.Request) (*Identity, error) {
- // Check for TLS client certificate
- if r.TLS != nil && len(r.TLS.PeerCertificates) > 0 {
+ // Check for TLS client certificate. Only trust a cert that the TLS layer
+ // verified against the cluster CA (VerifiedChains non-empty); a
+ // presented-but-unverified cert must never yield a cert identity.
+ if r.TLS != nil && len(r.TLS.VerifiedChains) > 0 && len(r.TLS.PeerCertificates) > 0 {
cert := r.TLS.PeerCertificates[0]
return &Identity{
Subject: cert.Subject.CommonName,--- a/pkg/cloudauth/rpc_authenticator.go
+++ b/pkg/cloudauth/rpc_authenticator.go
@@ -123,8 +123,11 @@ func (a *RPCAuthenticator) Authenticate(ctx context.Context, r *http.Request) (*Identity, error) {
- // Fall back to TLS client certificate
- if r.TLS != nil && len(r.TLS.PeerCertificates) > 0 {
+ // Fall back to TLS client certificate. Only trust a cert that the TLS
+ // layer verified against the cluster CA (VerifiedChains non-empty).
+ if r.TLS != nil && len(r.TLS.VerifiedChains) > 0 && len(r.TLS.PeerCertificates) > 0 {
cert := r.TLS.PeerCertificates[0]
return &rpc.Identity{
Subject: cert.Subject.CommonName,> [!NOTE]
> Fix Completeness Assessment: The combination of tls.VerifyClientCertIfGiven at the transport listener and len(r.TLS.VerifiedChains) > 0 in the authenticators provides complete remediation against unverified client certificates. In addition, the patch adds unit and integration tests (TestServerVerifiesClientCertChain in pkg/rpc/mtls_test.go and TestServerTLSVerifiesClientCertsWhenCAConfigured in pkg/rpc/authenticator_test.go) to verify that forged certificates with spoofed Issuer Distinguished Names are rejected at the TLS layer.
Exploiting CVE-2026-75521 requires no prior authentication, user interaction, or knowledge of internal cluster secrets. The sole prerequisite is network connectivity to the Miren Runtime QUIC/HTTP3 RPC service port (default 8443).
To execute the attack, an adversary generates an asymmetric key pair (such as ECDSA P-256 or RSA-2048) and constructs an X.509 client certificate template. The attacker populates the Subject.CommonName field with an administrative identifier (e.g., admin) and sets the Extended Key Usage to x509.ExtKeyUsageClientAuth. Even if the attacker sets the certificate's Issuer Distinguished Name to match the cluster CA's raw subject bytes, signing the certificate with the attacker's own private key is sufficient because signature verification is bypassed under tls.RequestClientCert.
The regression test forgeClientCert added in commit e2159c8c8559da3f1c1485b463c794d656cd2fe4 (pkg/rpc/mtls_test.go) illustrates the exact certificate forgery methodology:
// Excerpt from pkg/rpc/mtls_test.go demonstrating forged certificate construction
attackerKey, _ := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
serial, _ := rand.Int(rand.Reader, new(big.Int).Lsh(big.NewInt(1), 128))
// Spoof the cluster CA Subject bytes in the forged template
spoofedIssuerTemplate := &x509.Certificate{
SerialNumber: serial,
RawSubject: caCert.RawSubject,
NotBefore: time.Now().Add(-time.Hour),
NotAfter: time.Now().Add(24 * time.Hour),
KeyUsage: x509.KeyUsageCertSign,
IsCA: true,
}
leafTemplate := &x509.Certificate{
SerialNumber: serial,
Subject: pkix.Name{CommonName: "forged-admin"},
NotBefore: time.Now().Add(-time.Hour),
NotAfter: time.Now().Add(24 * time.Hour),
KeyUsage: x509.KeyUsageDigitalSignature,
ExtKeyUsage: []x509.ExtKeyUsage{x509.ExtKeyUsageClientAuth},
}
// Sign the leaf certificate using the attacker's private key
der, _ := x509.CreateCertificate(rand.Reader, leafTemplate, spoofedIssuerTemplate, &attackerKey.PublicKey, attackerKey)When the attacker initiates a QUIC/HTTP3 connection to port 8443 presenting this certificate, the vulnerable server completes the TLS handshake and populates r.TLS.PeerCertificates[0]. The RPC authenticator assigns Subject: "forged-admin" with Method: rpc.AuthMethodCert, and the authorization engine permits unrestricted RPC invocation across all cluster resources.
CVE-2026-75521 carries a maximum CVSS v4.0 base score of 10.0 (Critical) (CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:H/VI:H/VA:H/SC:H/SI:H/SA:H). Both the vulnerable system impact (VC:H/VI:H/VA:H) and subsequent system impact (SC:H/SI:H/SA:H) are rated High across Confidentiality, Integrity, and Availability.
Because AuthMethodCert grants a blanket RBAC bypass in Miren Runtime's authorization engine, a successful exploit gives an unauthenticated attacker complete administrative control over the runtime control plane and all hosted workloads.
Concretely, an attacker can perform the following actions:
client_secret tokens, and stored password hashes.Operators running Miren Runtime must immediately upgrade all cluster nodes to version 0.11.1 or later, which includes fix commit e2159c8c8559da3f1c1485b463c794d656cd2fe4. This release enforces tls.VerifyClientCertIfGiven on the QUIC/HTTP3 RPC listener and validates r.TLS.VerifiedChains in both local and cloud RPC authenticators.
If immediate patching is not feasible, access to the QUIC/HTTP3 RPC service port (default 8443 over UDP and TCP) must be restricted at the network perimeter. Operators should use host firewalls, cloud security groups, or private virtual network peering to ensure only trusted administrative endpoints and internal cluster nodes can reach port 8443.
Because unauthenticated callers could read sensitive configuration items from the entity store on pre-0.11.1 instances that were network-accessible, patching alone is insufficient if the instance was exposed. Operators must assume any secrets stored in the runtime entity store during the exposure window were compromised.
Following the disclosure, the Miren development team committed a dedicated exposure auditing utility (scripts/security/audit-exposure/audit-exposure.py). This script scans the entity store for explicitly sensitive variables as well as unmarked credentials using Shannon entropy analysis ($\ge 3.8$), regular expression key-name matching, PEM header detection, and cloud token prefix checks. Administrators should run this audit script and rotate all identified application secrets, API keys, OIDC client secrets, and database credentials.
CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:H/VI:H/VA:H/SC:H/SI:H/SA:H| Product | Affected Versions | Fixed Version |
|---|---|---|
Miren Runtime Miren Dev | < 0.11.1 | 0.11.1 |
| Attribute | Detail |
|---|---|
| CVE ID | CVE-2026-75521 / GHSA-8fh7-7q4q-cq52 |
| Weakness Class | CWE-295 (Improper Certificate Validation) |
| CVSS v4.0 Score | 10.0 Critical (CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:H/VI:H/VA:H/SC:H/SI:H/SA:H) |
| Attack Vector | Network (QUIC/HTTP3 RPC service on port 8443) |
| Affected Versions | Miren Runtime < 0.11.1 |
| Patched Version | 0.11.1 (Commit e2159c8c8559da3f1c1485b463c794d656cd2fe4) |
| Impact | Unauthenticated Remote Authentication & RBAC Bypass (Cluster Superuser) |
| CISA KEV Status | Not Listed |
The product does not validate, or incorrectly validates, a certificate, allowing an attacker to spoof a trusted entity by presenting an unverified or self-signed certificate.
CVE-2026-63129 is a high-severity SQL injection vulnerability (CWE-89) in the @connorbritain/mssql-mcp-core library and its downstream implementations (mssql-mcp-server, mssql-mcp-reader, and mssql-mcp-writer). The flaw results from the direct concatenation of unvalidated database identifiers, filter predicates, and enum parameters into T-SQL batches passed to the node-mssql Request.query() interface. Because pre-execution row count and preview queries execute before safety confirmation flags are checked, an attacker with access to invoke Model Context Protocol (MCP) tools can bypass confirmation controls and execute arbitrary stacked T-SQL statements.
CVE-2026-73504 (GHSA-jc42-994r-vvwp) is a credential exposure vulnerability in ING Bank's cassandra-jdbc-wrapper (com.ing.data:cassandra-jdbc-wrapper). Resulting from an incomplete remediation of AIKIDO-2024-10565, the log sanitization routines in DriverUtil redact the password property but fail to redact the token property. When DEBUG logging is enabled, connection properties and JDBC URLs containing DataStax Astra DB bearer tokens are written in plaintext to application logs, enabling local users or log aggregation readers to harvest active database credentials.
A denial-of-service vulnerability (CWE-400) exists in PGPainless versions prior to 1.7.8 and 2.0.x prior to 2.0.4 within the MessageInspector and InlineDetachImpl components. These components manually iterate over OpenPGP packet streams without enforcing the global 16-layer maximum nesting limit (MAX_LAYER_DEPTH). An unauthenticated remote attacker can supply a specially crafted OpenPGP message containing deeply nested PGPCompressedData packets to trigger unbounded recursive decompression, resulting in CPU starvation and Java Virtual Machine (JVM) heap exhaustion.
An authorization bypass and broken object-level access control vulnerability exists in djangocms-versioning prior to version 2.6.1. The check_discard and check_edit_redirect condition pipelines on the Version model omitted the user_can_change permission predicate. Because the corresponding administrative views retrieve target versions directly by their URL primary key and depend entirely on these condition pipelines for object-level access control, authenticated staff users without per-object change permissions can permanently delete draft versions or spawn new draft versions from published content.
A missing authorization vulnerability exists in django-filer versions prior to 3.5.0 when the optional per-folder permission system (FILER_ENABLE_PERMISSIONS) is enabled. The bulk delete admin action (delete_files_or_folders) verifies global Django model-level deletion permissions but fails to enforce object-level FolderPermission edit checks. Consequently, an authenticated staff user holding model-level delete rights can delete files, folders, and directory trees from folders where their access has been explicitly restricted to read-only via FolderPermission.
CVE-2026-75506 (GHSA-vc6p-m6vx-6cwq) is a second-order OS command injection vulnerability in OliveTin affecting versions 3000.0.0 prior to 3000.18.1. The post-execution hook mechanism, shellAfterCompleted, interpolates runtime execution outputs and username variables directly into a shell command string passed to sh -c without validation. When an action emits untrusted output containing shell metacharacters, those metacharacters break out of the intended syntax and execute arbitrary OS commands under the context of the OliveTin service process.