Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessLure authenticated victim to malicious page
-
DeliveryAuto-submit cross-site POST form with _method=GET
-
ExploitMethodOverride rewrites POST to GET before CSRF
-
ExecutionCSRF token and Sec-Fetch-Site checks skipped
-
ImpactOriginal POST state-change handler executes unauthorized action
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A01:2025 - Broken Access Control
ASVS 5.0
V3 - Web Frontend Security Anti-CSRF tokens, SameSite cookies
MITRE ATT&CK
1 technique across 1 tactic: Initial Access The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Exploitation requires a specific non-default deployment: MethodOverride middleware must be registered via e.Use() (post-routing) BEFORE the CSRF middleware in the chain, AND configured with a browser-settable getter such as MethodFromForm('_method') or MethodFromQuery - these are the getters a cross-site HTML form or URL can control. It also requires an authenticated victim with an active session who visits an attacker-controlled page (classic CSRF user interaction). Key limiting factors: the DEFAULT X-HTTP-Method-Override header getter is NOT exploitable cross-site because a cross-site form cannot set request headers; registering MethodOverride with e.Pre() (the documented placement) or registering CSRF before MethodOverride also closes the bypass; and only POST requests are overrideable. Thus applications using Echo's defaults are not affected - the vulnerable form/query-getter-before-CSRF ordering must be explicitly configured. |
| Impact | This is a genuine but conditional, medium-severity CSRF-protection bypass (CWE-352) - not a drop-everything emergency. The CVSS signals are mildly conflicting: the input base score is 5.3 with vector AV:N/AC:H/PR:N/UI:R/S:U/C:N/I:H/A:N, while the vendor GHSA advisory rates it 5.1 with AV:N/AC:L/PR:N/UI:R/S:U/C:L/I:H/A:N - they disagree on Attack Complexity (H vs L) and Confidentiality (N vs L) but agree on the core: network vector, no attacker privileges, user interaction required, high integrity impact, no availability impact. No EPSS score was supplied and the CVE is not on the CISA KEV list, so there is no evidence of widespread or active exploitation. The vuln.today decision label is 'this_month' (not act_now/emergency), consistent with a real-but-paced fix priority. Crucially, exploitability hinges on a non-default and arguably misconfigured middleware setup (MethodOverride registered before CSRF via e.Use() with a browser-settable getter), which materially lowers real-world reach below what the network vector alone implies. Bottom line: prioritize patching this month for teams running the vulnerable configuration; it is a legitimate integrity risk but closer to a targeted/conditional issue than a mass-exploitable one. |
| Exploit ScenarioDerived | An attacker hosts a web page that auto-submits a cross-site POST form to a state-changing endpoint (e.g. /transfer) on a vulnerable Echo application, including a form field such as _method=GET. When an authenticated victim visits the page, Echo routes the request to the original POST handler, MethodOverride rewrites the method to GET before CSRF runs, and both the CSRF token check and the Sec-Fetch-Site check are skipped, so the state-changing action executes. The GHSA advisory includes a working reproducer (curl commands and a browser auto-submit form), demonstrating the bypass; attack complexity is low once the vulnerable ordering/getter is deployed, but it still requires the victim to be authenticated and to load the attacker page. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 28, 2026
CSRF protection in Labstack Echo can be skipped entirely when the MethodOverride middleware rewrites a POST to a safe method (GET, HEAD, OPTIONS or TRACE) before the CSRF middleware runs, letting the original state-changing POST handler execute without token validation or a Sec-Fetch-Site check. Affected are echo v4 before 4.16.0 and echo v5 before 5.4.0, but only in a specific non-default setup: MethodOverride registered with e.Use() ahead of CSRF and configured with a browser-settable getter such as MethodFromForm('_method') or MethodFromQuery, plus an authenticated victim lured to an attacker page (CVSS 3.1 5.3, AV:N/AC:H/PR:N/UI:R, C:N/I:H/A:N). The default X-HTTP-Method-Override header getter is not reachable from a cross-site form, and applications using e.Pre() as documented or placing CSRF first are unaffected; there is no CISA KEV entry and the advisory supplies a public proof-of-concept reproducer rather than confirmed exploitation in the wild.
RemediationAI
Upgrade to github.com/labstack/echo/v4 v4.16.0 or github.com/labstack/echo/v5 v5.4.0, which no longer allow a POST to be overridden to GET, HEAD, OPTIONS, TRACE or CONNECT (vendor-released patch; fixes at https://github.com/labstack/echo/commit/b838391e2eade87ae7e5a09d7bb5087bec271ec1 and https://github.com/labstack/echo/commit/fc410094b2f3415cf2bf5204082137b205bfd5af, advisory https://github.com/labstack/echo/security/advisories/GHSA-r7w9-592q-9vg4). Be aware of the documented behavior change: clients that relied on X-HTTP-Method-Override: GET to smuggle a long query in a POST body will now keep the POST method. If upgrading is not immediately possible, the vendor-listed workarounds are to register MethodOverride with Echo#Pre so the router matches the overridden method and a POST-to-GET override yields 404/405 without reaching the handler, to register the CSRF middleware before MethodOverride so validation runs on the original POST, or to use the default X-HTTP-Method-Override header getter, which a cross-site form cannot set; the first two depend on correct middleware ordering being maintained in every service, and the third changes how clients are expected to signal overrides.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 3 packages in go, euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
Echo is a Go HTTP web framework whose middleware runs in two stages: e.Pre() executes before routing, while e.Use() registers post-routing middleware wrapped around the already-selected handler (echo.go:700, applyMiddleware(e.router.Route(c), e.middleware...)). MethodOverrideConfig.ToMiddleware() in middleware/method_override.go only restricts the source method (POST), then assigns any non-empty string returned by the configured Getter directly to req.Method - so '_method=GET' turns the request into a GET after the POST route was already bound. CSRFConfig.ToMiddleware() in middleware/csrf.go decides whether to validate based on c.Request().Method, switching over GET/HEAD/OPTIONS/TRACE to skip token checks, and checkSecFetchSiteRequest() (csrf.go:283) performs the same safe-method test against a slice of safe methods before allowing cross-site requests. Because both checks read the mutated method, the legacy token path and the modern Sec-Fetch-Site path are defeated simultaneously, and audit logging records GET for what was a state-changing operation. The root cause is the missing whitelist of legitimate override targets (PUT, PATCH, DELETE), a CWE-352 (CSRF) failure that the advisory also characterizes as CWE-807 (reliance on untrusted input in a security decision); the trigger requires the middleware-ordering and getter configuration described in the advisory, not merely the presence of the vulnerable version.
Know when Echo gets its next vulnerability
- Watch products and get an email when something new is published
- Check this CVE against your own stack and servers
- Exploit and PoC references, threat intelligence from 22 sources
No credit card · 7-day full trial
Severity by source
AV:N/AC:H/PR:N/UI:R/S:U/C:N/I:H/A:N
Network CSRF with no attacker privileges (PR:N) and required victim interaction (UI:R); AC:H because it needs the specific vulnerable MethodOverride-before-CSRF ordering with a browser-settable getter; C:N as CSRF does not directly disclose data, I:H for arbitrary state change, A:N.
Primary rating from Vendor (GitHub_M).
CVSS VectorVendor: GitHub_M
Lifecycle Timeline
1DescriptionCVE.org
Echo is a Go web framework. Prior to 4.16.0 and 5.4.0, Echo's MethodOverride middleware accepts a safe HTTP method as the override target for a POST request. When MethodOverride is registered before CSRF in the post-routing middleware chain, route selection retains the original state-changing POST handler but the override changes the method before CSRF evaluates it, causing both token validation and Sec-Fetch-Site checks to be skipped. A cross-site exploit requires an authenticated victim and an override value that a browser-submitted request can control, such as the form getter used by the advisory reproducer; the default X-HTTP-Method-Override header getter is not settable by a cross-site form. This issue is fixed in 4.16.0 and 5.4.0.
Threat Intelligence Overview
How this decision was reached
The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
Cross-Site Request Forgery exploits the automatic credential inclusion behavior of web browsers.
Labstack Echo v4.8.0 was discovered to contain an open redirect vulnerability via the Static Handler component. Rated cr
An issue in Inspect Element Ltd Echo.ac v.5.2.1.0 allows a local attacker to gain privileges via a crafted command to th
Unauthenticated remote file read in Echo web framework versions 5.0.0-5.0.2 on Windows allows attackers to traverse outs
Path-based access control bypass in the LabStack Echo Go web framework (versions prior to 4.15.3 and 5.2.0) lets remote
An issue was discovered in Veal98 Echo Open-Source Community System 2.2 thru 2.3 allowing an unauthenticated attacker to
An open redirect in the Go web framework Echo lets an attacker craft a link on a trusted domain that sends victims to an
Spoofed forwarded-scheme headers let remote clients defeat Echo's HTTPS enforcement: Context.Scheme() in LabStack Echo b
Echo's WWWRedirect() and NonWWWRedirect() middlewares build the Location header from Context.Scheme(), which returns the
The Echo extension for MediWiki does not properly implement the hideuser functionality, which allows remote authenticate
Sensitive notification data is exposed to authenticated but unauthorized actors through the Echo extension's API layer i
EUVD-2026-112403
GHSA-r7w9-592q-9vg4
NVD
CVE.org
Exploit-DB