Skip to main content

kin-openapi EUVDEUVD-2026-64151

| CVE-2026-77354 HIGH
Uncontrolled Resource Consumption (CWE-400)
2026-08-21 GitHub_M GHSA-xhj3-7xw9-vr34
8.7
CVSS 4.0 · Vendor: GitHub_M
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Recon
    Send unauthenticated HTTP GET to target endpoint
  2. Delivery
    Craft deepObject query param with large sparse index (e.g., param[items][50000000]=x)
  3. Exploit
    sliceMapToSlice uses attacker index as dense slice upper bound
  4. Install
    First multi-gigabyte heap allocation made before schema validation
  5. C2
    buildResObj performs second equal-size allocation
  6. Execute
    Process OOM-killed by OS
  7. Impact
    Service enters restart loop

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A06:2025 - Insecure Design
ASVS 5.0
V2 - Validation and Business Logic Resource consumption limits
MITRE ATT&CK

1 technique across 1 tactic: Impact

The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up.

Exploitation Conditions

The target service must run kin-openapi between version 0.124.0 and 0.141.x inclusive. At least one HTTP endpoint processed by the kin-openapi validator must declare a query parameter with style: deepObject and a schema containing an array type - this is a documented, intentional library feature and not a misconfiguration. No authentication is required (CVSS PR:N) and no user interaction is needed (CVSS UI:N); a single unauthenticated HTTP GET request is sufficient. Limiting factors: request-body encodings and non-deepObject query parameter styles are explicitly excluded by the advisory and are not affected; services that use kin-openapi but expose no deepObject array parameters cannot be reached via this path. Memory-constrained deployments such as containers with low memory limits or serverless functions will crash faster and may require manual intervention to recover from a restart loop.

Impact

The CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:N/UI:N/VA:H, score 8.7) accurately characterises this as a trivially exploitable, unauthenticated network denial-of-service requiring no special conditions and no user interaction. The availability impact is severe and sustained: a single sub-kilobyte HTTP request can OOM-kill the target process and hold it in a restart loop for as long as the attacker continues sending requests. No EPSS score was provided in the source data, so exploitation base-rate cannot be quantified; however, the zero-authentication, single-packet attack surface means that any internet-exposed endpoint matching the vulnerable parameter pattern warrants high-priority remediation regardless. Active exploitation is not confirmed - the CVE is not listed in CISA KEV as of the input data - but the public advisory includes the complete vulnerable code path and a working example payload, making independent weaponisation straightforward. No confidentiality or integrity impact is present, which appropriately bounds the score relative to code-execution vulnerabilities, but for availability-sensitive or latency-sensitive services the operational risk is equivalent to a critical finding.

Exploit ScenarioDerived

An attacker sends a single HTTP GET request - as short as GET /api/endpoint?items[0][50000000]=x HTTP/1.1 - to any endpoint of a service running kin-openapi 0.124.0 through 0.141.x that exposes a deepObject array query parameter. The decoder reads the index 50000000, allocates a 50-million-element slice filled with nil values, then immediately allocates a second identical slice in buildResObj, driving heap consumption to approximately 6.1 GiB; the OS OOM killer terminates the process, and if the service is managed by a supervisor or container orchestrator it enters a restart loop that can be sustained with repeated requests. The vendor advisory contains the complete vulnerable code path and example payload, providing sufficient detail to construct an exploit without additional research.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
1 public PoC Patch available 0.3% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – Aug 21, 2026

Uncontrolled heap allocation in kin-openapi versions 0.124.0 through 0.141.x allows any unauthenticated remote client to crash a Go API service with a single tiny HTTP request. The sliceMapToSlice function in openapi3filter/req_resp_decoder.go converts attacker-supplied sparse bracket-indexed array values from a deepObject query parameter into a dense slice by allocating one slot for every position from zero to the attacker's chosen index - before schema validation, including maxItems, ever executes. A 24-byte request such as ?param[items][50000000]=x triggers approximately 6.1 GiB of heap allocation across two sequential allocations, causing an OOM kill and sustained service restart loop; no public exploit has been separately released but the vendor advisory GHSA-xhj3-7xw9-vr34 contains the complete vulnerable code path and a working example payload.

RemediationAI

Upgrade to kin-openapi v0.142.0, the vendor-released patch available at https://github.com/getkin/kin-openapi/releases/tag/v0.142.0; the underlying fix is commit 1223a0f215d2cf9beb2d9eb9ea2649d001c21388 (https://github.com/getkin/kin-openapi/commit/1223a0f215d2cf9beb2d9eb9ea2649d001c21388), which restructures the decoder so that schema constraints are enforced before any slice allocation occurs. If an immediate upgrade is not feasible, a WAF or reverse-proxy rule that rejects query strings containing bracket-notation integer indexes beyond a safe threshold (e.g., any bracketed integer key exceeding 1000) provides a compensating control, though it may reject legitimate large-array requests and must be tested against actual API consumers before deployment. A coarser alternative is enforcing a maximum total query-string byte length at the gateway before the kin-openapi decoder is reached; the trade-off is that any sufficiently long legitimate query - not just malicious ones - would also be rejected.

Affected VersionsENISA

kin-openapi 0.124.0, < 0.142.0

Affected Packages

go github.com/getkin/kin-openapi fix: 0.142.0
euvd kin_openapi_0_124_0 fix: 0.142.0

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 (CPE: cpe:2.3:a:getkin:kin-openapi:*:*:*:*:*:*:*:*) is a Go module providing OpenAPI 3.x request and response validation through its openapi3filter package. The OpenAPI specification supports a deepObject query parameter style that encodes nested objects and arrays in bracket notation (e.g., param[key][0]=val). The vulnerable sliceMapToSlice function collects these bracket-indexed values into a map[string]any, identifies the maximum integer key present, and then allocates a dense []any covering every index from 0 to that maximum - a textbook CWE-400 (Uncontrolled Resource Consumption) pattern where externally supplied data controls allocation size without any server-side bound. A second allocation of equal size immediately follows in buildResObj, which calls make([]any, len(arr)) on the newly created slice. Because both allocations precede the schema-validation pipeline, OpenAPI-level constraints such as maxItems are completely bypassed. The root cause is treating the attacker-controlled integer index as a trusted slice-length hint.

Know when Kin Openapi 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

Vendor (GitHub_M) PRIMARY 8.7 HIGH
CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:N/VA:H/SC:N/SI:N/SA:N
vuln.today AI 7.5 HIGH

Network-reachable with no authentication or user interaction; sole impact is high availability loss via OOM crash, with scope unchanged to the vulnerable service.

3.1 AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H
4.0 AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:N/VA:H/SC:N/SI:N/SA:N
SUSE 7.5 HIGH
AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H
Red Hat 7.5 HIGH

Primary rating from Vendor (GitHub_M).

CVSS VectorVendor: GitHub_M

Attack Vector
Network
Attack Complexity
Low
Attack Requirements
None
Privileges Required
None
User Interaction
None
Vulnerable system: Confidentiality
None
Vulnerable system: Integrity
None
Vulnerable system: Availability
High
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
None

Lifecycle Timeline

2
Patch available
Aug 21, 2026 - 21:02 EUVD
CVE Published
Aug 21, 2026 - 20:44 cve.org
HIGH 8.7

DescriptionCVE.org

kin-openapi is a Go project for handling OpenAPI files. From 0.124.0 until 0.142.0, openapi3filter.sliceMapToSlice in openapi3filter/req_resp_decoder.go converts attacker-controlled sparse indexes from a deepObject query parameter into a dense slice by allocating entries from zero through the largest supplied index, after which buildResObj creates another slice of the same length. This allocation occurs before schema validation, so maxItems does not prevent it. An unauthenticated client can send a small query such as param[items][50000000]=x to an endpoint whose deepObject schema contains an array, forcing multi-gigabyte heap allocation and causing an OOM kill or restart loop. Other request-body encodings and styled parameters that do not produce bracketed integer indexes are not affected. This issue is fixed in version 0.142.0.

Latest POC

1 public PoC link from github

Sign in to open the public PoC links collected for this CVE.

Executive ViewAI

Why It Matters

kin-openapi versions 0.124.0 through 0.141.x contain a denial-of-service vulnerability that allows unauthenticated remote attackers to crash Go-based API services with a single HTTP request. Organizations using affected versions face immediate risk of service unavailability and restart loops, as attackers require only minimal network access and a 24-byte payload to trigger the vulnerability.

Business Impact: High
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.3%
Top 77% exploitable
Prevalence
Medium
widely used Go OpenAPI validation library across API services
Threat Intel
1
1 source
Social Media
1
Sightings
Data Quality
7 sources
Confidence: High

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.

SignalValue
Severity HIGH
CISA KEV No
Public POC Yes
EPSS 0.3%
Patch available Yes
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision· derived
Out-of-Cycle
Exploitation· derived
Poc
System Exposure· derived
Open
Automatable· derived
Yes
Human Impact
High

Priority Score

64
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +44
PoC: +20
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.

CVE-2026-76905 HIGH POC
7.5 Aug 21

Nil pointer dereference in kin-openapi's openapi3filter.ConvertErrors allows any unauthenticated remote client to crash

CVE-2026-73501 CRITICAL
9.1 Aug 12

Authentication bypass in the kin-openapi Go library (getkin/kin-openapi) before 0.144.0 lets unauthenticated remote atta

CVE-2026-100349 HIGH
8.2 Oct 15

Response validation in kin-openapi (openapi3filter.ValidateResponse) panics with a nil pointer dereference when an OpenA

CVE-2026-100353 HIGH
7.5 Oct 15

Nil-pointer dereference in kin-openapi 0.136.0 through 0.148.x lets an unauthenticated remote client reliably panic Go a

CVE-2026-100354 HIGH
7.5 Oct 15

Denial of service in kin-openapi before 0.149.0 allows unauthenticated remote attackers to terminate the entire Go proce

CVE-2026-97394 HIGH
7.5 Oct 15

A nil-pointer panic in kin-openapi's openapi3filter validation path can crash any Go service that embeds versions 0.136.

CVE-2026-100351 HIGH
7.4 Oct 15

An unauthenticated remote request can slip past kin-openapi's openapi3filter authentication middleware and reach a handl

CVE-2026-100350 MEDIUM
5.3 Oct 15

A low-severity denial-of-service condition affects the Go library kin-openapi in versions 0.145.0 through 0.146.0 (exclu

CVE-2026-100347 MEDIUM
5.3 Oct 15

Unsupported or non-canonical HTTP methods sent to Go services built on kin-openapi's openapi3filter.ValidationHandler wi

CVE-2026-100348 MEDIUM
5.3 Oct 15

A nil pointer dereference in kin-openapi versions prior to 0.145.0 lets a crafted OpenAPI document panic the loader, den

Vendor StatusVendor

SUSE

Severity: Important

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy