high

CVE

CVE-2026-124680, CVE-2026-124679, CVE-2026-124666, CVE-2026-124716, CVE-2026-124723, CVE-2026-124726, CVE-2026-124719

CWE

CWE-436, CWE-863, CWE-290, CWE-23, CWE-441

Affected Surface

  • Apache APISIX 0.9 through 3.19.0 (`CVE-2026-124680`, route-level auth bypass through path normalization)
  • Apache APISIX 1.4.0 through 3.19.0 with `authz-keycloak` (`CVE-2026-124716`)
  • Apache APISIX 3.8.0 through 3.19.0 with `multi-auth` falling back from `wolf-rbac` (`CVE-2026-124666`)
  • Apache APISIX 3.18.0 through 3.19.0 with `jwe-decrypt` (`strict: false`) or `forward-auth` (`allow_degradation: true`) (`CVE-2026-124679`), or with `match_uri_encoded_slash` plus `skip_mtls_uri_regex` (`CVE-2026-124723`)
  • Apache APISIX 3.19.0 with `openapi-to-mcp` (`CVE-2026-124726`, `CVE-2026-124719`)
  • `apache/apisix` container images before `3.20.0-debian`, `3.20.0-ubuntu` and `3.20.0-redhat`

TL;DR

Apache APISIX 3.20.0 shipped on 11 November 2026. Two days later the project published seven CVEs that the release fixes, all of them ways for a request to reach an upstream without the authentication or authorization the route was configured to enforce:

  1. Path normalization mismatch (CVE-2026-124680, CVSS 4.0 7.0, APISIX 0.9 through 3.19.0). APISIX matched routes on NGINX’s normalized $uri but forwarded the raw request line. If an upstream has one route with an auth plugin and another without, and the upstream does not collapse encoded dot segments, an unauthenticated client can get to the protected path through the open route.
  2. Spoofed identity headers (CVE-2026-124679, CVSS 7.8, and CVE-2026-124666, CVSS 6.4). With jwe-decrypt set to strict: false, a client sending no token could put its own value in the header the upstream treats as decrypted plaintext. forward-auth with allow_degradation: true passed client copies of upstream_headers through when the auth service was down. multi-auth falling back from wolf-rbac to another authenticator left client-supplied Wolf identity headers in place.
  3. Partial Keycloak grants (CVE-2026-124716, CVSS 6.4, 1.4.0 through 3.19.0). authz-keycloak let a token through when it held any one of the route’s required permissions or scopes, including HTTP methods Keycloak had denied.
  4. mTLS and openapi-to-mcp (CVE-2026-124723, CVE-2026-124726, CVE-2026-124719). With match_uri_encoded_slash on, a %2F path could match a skip_mtls_uri_regex exemption and skip the client certificate check. In 3.19.0’s openapi-to-mcp, an MCP caller could reach API paths the OpenAPI document never declared, using the credentials the route adds, and could act as another identity when the route’s configured headers carried one.

None of the seven is listed as exploited, and CISA’s SSVC entries for the four it has scored say “Exploitation: none”. FIRST had no EPSS score for any of them when we checked on 14 November.

What to do now: upgrade to APISIX 3.20.0 (or the apache/apisix:3.20.0-* images). Several fixes change behavior and none can be switched back, so read the upgrade notes first. Until you can upgrade, make sure upstreams do not trust identity headers on routes that use strict: false or allow_degradation: true, and do not mix authenticated and unauthenticated routes on one upstream.

Affected packages and projects

EcosystemProjectCVECVSS 4.0Affected versionsFixed versionCondition
Apache / Docker HubApache APISIX, apache/apisixCVE-2026-1246807.00.9 through 3.19.03.20.0An unauthenticated route and an authenticated route share an upstream that does not collapse encoded dot segments
Apache / Docker HubApache APISIXCVE-2026-1246797.83.18.0 through 3.19.03.20.0jwe-decrypt with strict: false and a forward_header distinct from the token header, or forward-auth with allow_degradation: true
Apache / Docker HubApache APISIXCVE-2026-1246666.43.8.0 through 3.19.03.20.0multi-auth falls back from wolf-rbac and the upstream reads Wolf identity headers
Apache / Docker HubApache APISIXCVE-2026-1247166.41.4.0 through 3.19.03.20.0authz-keycloak route listing several permissions or scopes, or http_method_as_scope
Apache / Docker HubApache APISIXCVE-2026-1247236.33.18.0 through 3.19.03.20.0match_uri_encoded_slash enabled together with skip_mtls_uri_regex
Apache / Docker HubApache APISIXCVE-2026-1247266.93.19.03.20.0openapi-to-mcp route
Apache / Docker HubApache APISIXCVE-2026-1247192.33.19.03.20.0openapi-to-mcp route whose configured headers carry a caller identity that the OpenAPI document also declares

Technical analysis

APISIX runs on OpenResty, so every request passes through NGINX before APISIX’s Lua router sees it. Most of these bugs come from the gateway and the upstream disagreeing about what a request means: which path it targets, which identity headers are trustworthy, or which grant was actually issued. The release notes link each fix to a pull request, and the commits below are the ones that match the advisory text.

1. The router matched one path and forwarded another (CVE-2026-124680)

NGINX decodes the path and resolves dot segments before filling $uri, and APISIX’s router matches on $uri. The request that reached the upstream, though, was built from the original request line. So the router could pick a route (and its auth plugins, or lack of them) based on the normalized path, while the upstream received the raw path with its encoded dot segments intact. The advisory gives the conditions: a route without auth exists on the same upstream, and “the upstream does not collapse encoded dot segments”. When both hold, a request can be matched to the open route at the gateway and still be served from a path the authenticated route was supposed to protect.

The fix in commit 4a080d0 (PR #14035) detects when NGINX did more than percent-decode or merge slashes, and in that case forwards the path the router actually matched:

-- apisix/init.lua (3.20.0)
local function uri_normalized_by_nginx(request_uri, uri)
    if request_uri == uri then
        return false
    end
    if core.string.has_prefix(request_uri, uri)
       and str_byte(request_uri, #uri + 1) == str_byte("?") then
        return false
    end

    local path = request_uri
    local args_pos = core.string.find(path, "?")
    if args_pos then
        path = str_sub(path, 1, args_pos - 1)
    end
    local decoded = percent_decode(path, false)
    if decoded == uri then
        return false
    end
    return re_gsub(decoded, [[//+]], "/", "jo") ~= uri
end
+    -- forward the path the route was matched on; binary allows decoded
+    -- control chars, proxy_pass escapes them
+    if not (local_conf.apisix and local_conf.apisix.normalize_uri_like_servlet)
+       and uri_normalized_by_nginx(api_ctx.var.request_uri, uri) then
+        ngx.req.set_uri(uri, false, true)
+    end

Line by line: identical strings, or a raw URI that only adds a query string, mean nothing was normalized. If percent-decoding the raw path alone yields $uri, the difference was encoding only, and APISIX keeps forwarding the original request line so encoded data such as %2F survives. Only when the decoded path, with repeated slashes merged, still differs from $uri (a dot segment was resolved, or the path was cut at #) does APISIX overwrite the upstream URI with the matched path. The side effect is in the release notes: /a/./b%2Fc now reaches the upstream as /a/b/c. proxy-rewrite.use_real_request_uri_unsafe: true restores the old behavior for one route, and the project labels it a risk-accepted option.

The affected range starts at 0.9, so every APISIX deployment before 3.20.0 has this behavior. Whether it can be exploited depends on route layout and on the upstream’s own path handling.

2. Client identity headers that survived “skip” paths (CVE-2026-124679, CVE-2026-124666)

Upstreams behind a gateway often trust identity headers because only the gateway is supposed to set them. Three plugins had paths where APISIX let the request continue without setting those headers, but also without removing the client’s copy.

Commit f7139e2 (PR #14096) handles jwe-decrypt and forward-auth:

--- a/apisix/plugins/jwe-decrypt.lua
+++ b/apisix/plugins/jwe-decrypt.lua
 function _M.rewrite(conf, ctx)
     -- fetch token and hide credentials if necessary
     local jwe_token, err = fetch_jwe_token(conf, ctx)
+    -- only the decrypted plaintext may reach the upstream in forward_header
+    core.request.set_header(ctx, conf.forward_header, nil)
     if not jwe_token then
         -- If true, throw a 403 error if JWE token is missing from the request.
         -- If false, do not throw an error when JWE token is not found.
--- a/apisix/plugins/forward-auth.lua
+++ b/apisix/plugins/forward-auth.lua
     local res, err = httpc:request_uri(conf.uri, params)
     if not res and conf.allow_degradation then
+        -- drop client-supplied copies of the configured upstream headers
+        for _, header in ipairs(conf.upstream_headers) do
+            core.request.set_header(ctx, header, nil)
+        end
         return

In jwe-decrypt, the plugin used to return early when there was no token and strict was false, leaving any client-sent forward_header untouched. The header now gets cleared before the token lookup, so the only value that can reach the upstream is one the plugin decrypted itself. In forward-auth, allow_degradation: true means “let the request through if the auth service is unreachable”. Before 3.20.0 the request also kept whatever upstream_headers the client had sent, which are the same headers the auth service would normally have filled in. An attacker who could make the auth service time out, or just wait for an outage, could choose their own identity.

CVE-2026-124666 is the wolf-rbac version of the same bug. Under multi-auth, if wolf-rbac failed and a later authenticator succeeded, the client’s X-UserId, X-Username and X-Nickname headers stayed on the request. PR #13929 moves header_prefix from the Consumer to the Route or Service so that the route owns the header namespace and clears it before any authenticator runs. A Consumer that still sets a custom header_prefix is rejected after the upgrade.

3. authz-keycloak accepted any one of the required grants (CVE-2026-124716)

authz-keycloak sends the route’s configured permissions (for example orders#read, delete) to Keycloak’s token endpoint. Before 3.20.0, a successful response was enough. The plugin did not check that every requested resource and scope came back. There was also a whitespace bug: " delete" with its leading space was sent untrimmed, Keycloak dropped it, and that scope was never enforced. Commit ae87b94 (PR #14098) asks for response_mode=permissions and checks each requested scope against what was granted:

-- apisix/plugins/authz-keycloak.lua (3.20.0)
local function is_permission_granted(granted, resource, scopes)
    for _, perm in ipairs(granted) do
        if type(perm) == "table"
            and (resource == "" or perm.rsname == resource or perm.rsid == resource)
        then
            local granted_scopes = {}
            if type(perm.scopes) == "table" then
                for _, scope in ipairs(perm.scopes) do
                    granted_scopes[scope] = true
                end
            end

            local all_granted = true
            for _, scope in ipairs(scopes) do
                if not granted_scopes[scope] then
                    all_granted = false
                    break
                end
            end

            if all_granted then
                return true
            end
        end
    end

    return false
end

A request is allowed only when Keycloak returned a permission entry for the resource that covers every requested scope, including the HTTP method when http_method_as_scope is on. A token endpoint response that is not a permissions list now returns 503 instead of being read as an allow. Expect new 403s after the upgrade from any route where your Keycloak policies were looser than the route configuration suggested.

4. mTLS exemptions and openapi-to-mcp (CVE-2026-124723, CVE-2026-124726, CVE-2026-124719)

skip_mtls_uri_regex lets a TLS host require client certificates on everything except a few paths. With match_uri_encoded_slash enabled, routing works on a URI that keeps %2F inside a segment, but the exemption regex was checked against the decoded URI only. A client without a certificate could send a path that decodes to an exempt URI and reach the upstream of a route that should have required one. PR #14108 now requires the exemption to match both forms; the release notes suggest patterns such as ^/open(?:/|%2F).* for paths that are meant to be exempt either way.

openapi-to-mcp arrived in 3.19.0 and turns an OpenAPI document into MCP tools, so an AI agent can call the API through the gateway. In 3.19.0 a tool call could push undeclared parameters and path components through to the upstream, reaching endpoints the document never declared while carrying the credentials the route injects (CVE-2026-124726). When the route’s configured headers carried a caller identity and the document also declared that header, the caller’s value could win (CVE-2026-124719). PRs #13959 and #14154 restrict tool arguments to declared parameters, give route-configured headers precedence, reject / and \ in path parameters by default, and bind SSE sessions to their route and consumer. The old mcp-bridge plugin is gone in 3.20.0.

Indicators

These are vulnerability disclosures, so there are no malware IOCs. In access logs, look for:

  • Requests to unauthenticated routes containing %2e%2e, %2e/, /./ or /../ that share an upstream with authenticated routes.
  • Client requests that already carry the Wolf identity headers (X-UserId, X-Username, X-Nickname with the default prefix), the jwe-decrypt forward_header, or any forward-auth upstream_headers, especially while the auth service was returning errors.
  • Paths containing %2F against hosts that use skip_mtls_uri_regex, served without a client certificate.
  • openapi-to-mcp tool calls whose upstream request path is not declared in the OpenAPI document.

Detection and remediation

# Running version (container and package installs)
docker ps --format '{{.Image}}' | rg 'apache/apisix'
apisix version 2>/dev/null

# Plugins and options tied to these CVEs, in standalone YAML or exported config
rg -n 'strict:\s*false|allow_degradation:\s*true|multi-auth|wolf-rbac|authz-keycloak|http_method_as_scope|skip_mtls_uri_regex|match_uri_encoded_slash|openapi-to-mcp|mcp-bridge' \
  conf/ apisix.yaml config.yaml 2>/dev/null

# Same check against the Admin API (etcd-backed deployments)
curl -s -H "X-API-KEY: $APISIX_ADMIN_KEY" http://127.0.0.1:9180/apisix/admin/routes \
  | jq -r '.list[].value | [.id, (.plugins // {} | keys | join(","))] | @tsv' \
  | rg 'jwe-decrypt|forward-auth|multi-auth|wolf-rbac|authz-keycloak|openapi-to-mcp'

# Encoded dot segments hitting the gateway (adjust the log path)
rg -n '%2e%2e|%2e/|/\./|/\.\./' /usr/local/apisix/logs/access.log | head
  1. Upgrade to APISIX 3.20.0 (apache/apisix:3.20.0-debian, 3.20.0-ubuntu or 3.20.0-redhat, published on Docker Hub on 13 November). Remove mcp-bridge from your configuration first, since 3.20.0 will not load it, and move any custom wolf-rbac header_prefix from the Consumer to the Route or Service.
  2. Test the behavior changes. Upstreams now receive the normalized path when NGINX resolved dot segments. authz-keycloak returns 403 unless every requested scope is granted. oas-validator verifies remote spec certificates by default, and forward-auth uses the FFI HTTP client.
  3. If you cannot upgrade yet: set strict: true on jwe-decrypt, turn off allow_degradation on forward-auth, and have upstreams ignore identity headers unless they can verify the gateway set them. Avoid putting authenticated and unauthenticated routes on the same upstream, or make the upstream reject encoded dot segments. Audit Keycloak policies so each route’s permissions are granted together, and disable openapi-to-mcp on 3.19.0.
  4. Rotate credentials only where logs show abuse. The fixes are about authorization at the gateway, and nothing in the advisories says these bugs expose gateway secrets.

Timeline

  • 2026-10-26 to 2026-11-06: Fixes merge into apache/apisix master: router path normalization (PR #14035, 26 October), openapi-to-mcp hardening (PR #13959, 26 October), jwe-decrypt and forward-auth header clearing (PR #14096, 27 October), authz-keycloak full-grant check (PR #14098, 28 October), wolf-rbac header prefix move and mTLS exemption fix (PRs #13929 and #14108, 30 October), and openapi-to-mcp path-segment confinement (PR #14154, 6 November).
  • 2026-11-11: Apache APISIX 3.20.0 is tagged on GitHub and announced on the project blog.
  • 2026-11-13 (11:10 to 11:14 UTC): apache/apisix 3.20.0-redhat, 3.20.0-ubuntu and 3.20.0-debian images are pushed to Docker Hub.
  • 2026-11-13 (15:50 UTC): The APISIX PMC posts the CVE-2026-124680 announcement to oss-security, alongside per-CVE announcement threads on the Apache lists.
  • 2026-11-13 (17:49 to 17:53 UTC): The seven CVE records are published; CISA adds SSVC entries with “Exploitation: none” for four of them.
  • 2026-11-14: No EPSS scores yet; no public exploitation reported.

From research to remediation

Check whether this pattern exists in your codebase

Turn this research into a remediation workflow. Use AI-native static analysis to find similar application vulnerabilities and generate review-ready fixes.

References