Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessIdentify endpoint backed by circular schema
-
DeliverySend single crafted request reaching that schema
-
ExploitTrigger unbounded recursion in visitJSON/decodeValue
-
ExecutionExhaust goroutine stack, fatal unrecoverable panic
-
ImpactCrash entire process, denying all requests
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Recursion depth limits
|
| Exploitation Conditions | Exploitation requires the target service to be running kin-openapi before version 0.149.0 AND to have loaded an OpenAPI document containing an allOf, anyOf, or oneOf chain that refers back to an ancestor schema (a circular reference that the loader and document validation accept without error). The attacker must then send a request (or elicit a response) that reaches that recursive schema so runtime validation via Schema.visitJSON or openapi3filter.decodeValue is invoked. The primary LIMITING factor is that the vulnerable circular schema must exist in the deployed spec - a default/non-circular spec is not affected - so this is not exploitable against all kin-openapi deployments; no authentication or user interaction is required once the condition is present. |
| Impact | This is a denial-of-service vulnerability (CWE-674, uncontrolled recursion) with a CVSS 3.1 base score of 7.5 driven entirely by availability (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H - C:N/I:N/A:H), so there is no confidentiality or integrity impact. The signals are largely consistent: network vector, low complexity, and no privileges or user interaction required, which supports the high availability score because a single crafted request can trigger an unrecoverable fatal stack overflow that terminates the whole Go process (including unrelated in-flight requests), not just the offending request. However, the real-world risk is gated by a precondition the CVSS vector does not capture: the server must be running an OpenAPI spec that itself contains a circular allOf/anyOf/oneOf reference back to an ancestor schema. No EPSS score, KEV listing, or SSVC decision data was provided in the input, and no public exploit code was supplied (only the vendor fix commit and a regression test). This is therefore a genuine but conditional priority - severe impact (total process crash) and trivial to trigger once the vulnerable spec condition exists, but not universally exploitable against every kin-openapi deployment. Note the input Tags label this a 'Buffer Overflow,' which conflicts with the actual CWE-674 stack-exhaustion-via-recursion mechanism; the two are distinct and this discrepancy should be corrected. |
| Exploit ScenarioDerived | A Go service uses kin-openapi (before 0.149.0) with an OpenAPI document whose schema contains a self-referential allOf/anyOf/oneOf chain that the loader and document validation accept. An unauthenticated remote attacker sends a single HTTP request to an endpoint whose parameter or body maps to that recursive schema; runtime validation (Schema.visitJSON or openapi3filter.decodeValue) recurses until the goroutine stack is exhausted, producing a fatal runtime error that cannot be recovered and crashes the entire process, dropping all concurrent requests. No public exploit code was provided, though the vendor commit includes a regression test demonstrating the crash condition. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 15, 2026
Denial of service in kin-openapi before 0.149.0 allows unauthenticated remote attackers to terminate the entire Go process by triggering unbounded recursion during runtime schema validation. When a loaded OpenAPI document contains an allOf, anyOf, or oneOf chain that refers back to an ancestor schema - a circular reference the loader and document validation accept without error - a request or response that reaches that schema causes Schema.visitJSON or openapi3filter.decodeValue to recurse until the goroutine stack is exhausted; the resulting fatal stack overflow cannot be caught with recover and aborts the whole process, including unrelated in-flight requests. The assessed CVSS 3.1 vector is AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H (7.5), driven entirely by availability with no confidentiality or integrity impact; the key limiting factor is that a vulnerable circular schema must already exist in the deployed spec, so default non-circular specs are unaffected. No public exploit code or confirmed in-the-wild exploitation was identified at time of analysis, and the issue is fixed in version 0.149.0.
RemediationAI
Vendor-released patch: upgrade to kin-openapi 0.149.0, which adds pointer-identity cycle detection in Schema.VisitJSON (settings.visitedSchemas) and a seen-slice guard (decodeValueGuarded returning errCircularSchema) in openapi3filter, converting the fatal crash into a clean validation error - see the release at https://github.com/getkin/kin-openapi/releases/tag/v0.149.0, the advisory at https://github.com/getkin/kin-openapi/security/advisories/GHSA-g8cf-rcjf-c8cf, and the fix commit at https://github.com/getkin/kin-openapi/commit/9245cef66c840e27a08409a8a5cd0ee930c5bcff. For deployments that cannot upgrade immediately, the most effective compensating control is to remove or restructure the vulnerable circular reference in the served OpenAPI document, since the crash is only reachable when such a schema exists: flatten $refs and break any allOf/anyOf/oneOf chain that points back to an ancestor (trade-off: may require spec rewriting and can change validation semantics for legitimate self-referential models, which should be re-tested against real payloads). A pre-deployment lint/schema check that rejects self-referential combinator cycles is worthwhile but is only as good as the pipeline that enforces it. Because the stack overflow terminates the whole process, isolate the affected service in its own process/container with restart-on-crash and low latency budgets, or run request validation in a separate sidecar or worker so a crash cannot take down unrelated request handling (trade-off: added latency and operational complexity, and the crash still occurs - it is only contained, not prevented). Note that recover() cannot mitigate this class of failure, so panic-recovery middleware is not an effective workaround.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 2 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
kin-openapi is a widely used Go library for parsing, validating, and serving OpenAPI 3.x documents, often embedded in API gateways and middleware that validate inbound requests against the spec at runtime. The root cause is CWE-674 (uncontrolled recursion): the schema loader and the static Schema.validate() path perform stack-based cycle detection and therefore accept a document whose allOf/anyOf/oneOf chain points back to an ancestor schema, but the runtime visitor path did not. In Schema.VisitJSON (openapi3/schema.go), the combined-schema handling in visitXOFOperations recursed into the same *Schema pointer without tracking what it had already visited, and openapi3filter.decodeValue in openapi3filter/req_resp_decoder.go separately recursed while decoding styled parameters with no seen-set. Because Go's goroutine stacks grow dynamically until the runtime limit is hit, the recursion consumes memory until the runtime raises a fatal stack-overflow error; such fatal runtime errors deliberately bypass recover(), so an affected server cannot shield the request handler and the whole process dies, taking down unrelated traffic. The upstream fix, commit 9245cef66c840e27a08409a8a5cd0ee930c5bcff, adds a pointer-identity visitedSchemas map to schemaValidationSettings (inserted on entry and removed via defer, mirroring the stack-based detection in Schema.validate()) and introduces decodeValueGuarded with a seen []*openapi3.Schema slice in the filter, returning a clean errCircularSchema error instead of recursing. A regression test, openapi3filter/circular_recursion_test.go, covers both the direct VisitJSON path and the ValidateRequest path.
Know when Go 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:L/PR:N/UI:N/S:U/C:N/I:N/A:H
Single unauthenticated remote request crashes the whole process (A:H, no C/I impact); AC:L retained to match vendor, though it depends on the spec containing a circular schema.
Primary rating from Vendor (GitHub_M).
CVSS VectorVendor: GitHub_M
Lifecycle Timeline
2DescriptionCVE.org
kin-openapi is a Go project for handling OpenAPI files. Prior to 0.149.0, runtime request, response, and direct schema validation lacks cycle detection when an allOf, anyOf, or oneOf chain refers back to an ancestor schema, even though loading and document validation accept the circular reference. A request or response that reaches the affected schema causes unbounded recursion in Schema.visitJSON or openapi3filter.decodeValue and exhausts the Go goroutine stack. The resulting fatal stack overflow cannot be caught with recover and terminates the entire process, including unrelated requests. This issue is fixed in version 0.149.0.
Technical POC Analysis
CWE-674 (Uncontrolled Recursion).
Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.
Executive ViewAI
kin-openapi, a widely used Go library for parsing and validating OpenAPI specifications, contains a denial-of-service flaw that allows any unauthenticated caller to crash the entire Go process hosting a service. Internet-facing Go APIs that perform runtime schema validation with kin-openapi are affected, and a single request can terminate the whole process, including unrelated in-flight requests handled by the same instance. Impact is confined to availability (no data exposure or tampering), and no public exploit identified at time of analysis, but the low attack complexity and lack of authentication make this a credible disruption risk wherever a vulnerable circular schema is already present in a deployed specification.
No vendor-released patch identified at time of analysis. Interim mitigations: detect and eliminate circular allOf/anyOf/oneOf reference chains in every deployed OpenAPI document (flatten or bound the schema), block deployment of specs that fail an automated cycle check in CI/CD, enforce payload size and schema-validation limits at the API gateway, and isolate affected services so a single process abort cannot cascade to unrelated workloads; upgrading to kin-openapi 0.149.0 or later is indicated by the advisory's version boundary.
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
A buffer overflow occurs when a program writes more data to a memory buffer than it was allocated to hold, causing the excess data to spill into adjacent memory regions.
Denial of service against HTTP/2 server implementations allows remote unauthenticated attackers to exhaust server resour
The net/http package in Go through 1.6 does not attempt to address RFC 3875 section 4.1.18 namespace conflicts and there
Critical certificate validation bypass in Go crypto/tls during session resumption. If ClientCAs or RootCAs fields are mu
net/url in Go before 1.11.13 and 1.12.x before 1.12.8 mishandles malformed hosts in URLs, leading to an authorization by
Casdoor through 4.4.0 exposes its instance-wide built-in JWT signing private key unmasked through the /api/get-certs and
Host header injection in Nezha 2.2.3's OAuth2 redirect endpoint (/api/v1/oauth2/{provider}) allows an unauthenticated re
Session cross-wiring in SUSE NeuVector before 5.6.1 allows an unauthenticated remote attacker to obtain another user's a
Unauthenticated path traversal in Uber Kraken through 0.1.29 allows remote attackers to read files outside the configure
The "go get" implementation in Go 1.9.4, when the -insecure command-line option is used, does not validate the import pa
Denial of service in Temporal Server allows an authenticated caller holding at least namespace read permission to crash
Account takeover in Klever-Go's KleverUpdateAccountPermission built-in (all versions prior to 1.7.20) allows an attacker
Maliciously crafted on-chain account names processed by Klever-Go prior to 1.7.20 are spliced into Elasticsearch _bulk r
EUVD-2026-102162
GHSA-g8cf-rcjf-c8cf
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB