Skip to main content

kin-openapi CVE-2026-76905

| EUVDEUVD-2026-64150 HIGH
NULL Pointer Dereference (CWE-476)
2026-08-21 GitHub_M GHSA-mmfr-pmjx-hw9w
7.5
CVSS 3.1 · Vendor: GitHub_M
View

Attack ChainAIDerived

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

  1. Access
    Send multipart/form-data POST with malformed scalar field
  2. Delivery
    Body decoder wraps ParseError inside nested ParseError
  3. Exploit
    ConvertErrors invokes convertParseError on nil e.Parameter
  4. Execution
    Nil pointer dereference panics handler goroutine
  5. Impact
    Application denies service to all clients

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A10:2025 - Mishandling of Exceptional Conditions
ASVS 5.0
V16 - Security Logging and Error Handling Null pointer safety, defensive checks
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

Three conditions must simultaneously hold: the target application uses kin-openapi versions 0.10.0 through 0.140.x, the targeted endpoint validates multipart/form-data request bodies against an OpenAPI schema (not application/json), and the application renders validation errors using the library-provided ConvertErrors or ValidationErrorEncoder helpers rather than custom error rendering. Applications that use only JSON request bodies are explicitly not affected, as the JSON decoder does not produce the nested *ParseError-in-*ParseError structure that reaches the vulnerable branch. Applications with a panic recovery middleware (recover() in an HTTP middleware layer) will catch the panic and return a 500 error rather than crashing, which limits but does not eliminate the DoS impact. No authentication, network privilege, or user interaction is required beyond the ability to send an HTTP request to the target endpoint.

Impact

The CVSS 3.1 score of 7.5 (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H) reflects network accessibility, no authentication requirement, and complete availability impact, which are all accurate for the base vulnerability class. The real-world risk is narrower than a raw 7.5 suggests: exploitation requires that the target application both accepts multipart/form-data bodies and routes validation errors through ConvertErrors or ValidationErrorEncoder - applications with custom error handling or JSON-only APIs are entirely unaffected. A panic recovery middleware (recover() in HTTP middleware) would prevent a full crash, further limiting blast radius. No EPSS score was provided in the input, so exploitation probability cannot be quantified numerically. No CISA KEV listing exists, and no public exploit code has been independently identified, though the GHSA advisory and reproduction test case provide sufficient detail for trivial exploitation by any attacker who reads the disclosure. For affected configurations the risk is real and high, warranting prompt patching.

Exploit ScenarioDerived

An unauthenticated attacker sends a single HTTP POST with Content-Type multipart/form-data to any endpoint that validates such bodies against an OpenAPI schema, inserting a string value (e.g., 'notanumber') for a schema-defined integer field. The kin-openapi multipart decoder wraps the parse failure in a nested *ParseError; when the application calls ConvertErrors or ValidationErrorEncoder to render the response, convertParseError dereferences a nil e.Parameter, panicking the handler goroutine. Without a recovery boundary, repeated requests deny service to all users of the application.

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

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

Alert me

AnalysisAIv1 – Aug 21, 2026

Nil pointer dereference in kin-openapi's openapi3filter.ConvertErrors allows any unauthenticated remote client to crash a Go web service with a single HTTP request. Applications using kin-openapi 0.10.0 through 0.140.x that validate multipart/form-data request bodies and render errors through the library-provided ValidationErrorEncoder or ConvertErrors helpers are vulnerable; application/json request bodies are explicitly unaffected by this bug. No public exploit identified at time of analysis, but the published GHSA advisory includes exact code paths and a reproduction test case, making exploitation trivial; the vendor-released fix is available in v0.141.0.

RemediationAI

The primary fix is to upgrade kin-openapi to version 0.141.0 or later; the fix commit is https://github.com/getkin/kin-openapi/commit/1d0a337c9b1570fab283be8a04c8af6e43b9a22c and the release is at https://github.com/getkin/kin-openapi/releases/tag/v0.141.0. For applications that cannot immediately upgrade, the most effective compensating control is to add a panic recovery middleware (a recover() deferred function wrapping request handlers), which prevents the goroutine crash from propagating; the trade-off is that validation errors on malformed multipart fields will produce 500 responses instead of 400, degrading client-facing error quality. A second workaround is to replace ValidationErrorEncoder and ConvertErrors with custom error rendering that checks for nil e.Parameter before accessing its fields. Applications serving only application/json request bodies require no remediation, as the JSON decoder does not produce the nested error shape that triggers the nil dereference.

Affected VersionsENISA

kin-openapi 0.10.0, < 0.141.0

Affected Packages

go github.com/getkin/kin-openapi fix: 0.141.0
euvd kin_openapi_0_10_0 fix: 0.141.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 library for loading, validating, and serving OpenAPI 3.x specifications. The root cause (CWE-476: NULL Pointer Dereference) is in the convertParseError function within openapi3filter/validation_error_encoder.go at line 120. A *RequestError struct carries either a Parameter field (for parameter errors) or a RequestBody field (for body errors), never both simultaneously - ValidateRequestBody leaves e.Parameter nil for body errors. The multipart decoder is the only code path that wraps a failed part's *ParseError inside another *ParseError (at req_resp_decoder.go:1549 and 1558), creating a nested error structure. When convertParseError processes this nested error, it reaches the branch checking e.Parameter.In == 'query' without a nil guard on e.Parameter, causing a goroutine panic. JSON body decoders do not produce this nested *ParseError-in-*ParseError shape, which is why they are unaffected.

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 7.5 HIGH
AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H
vuln.today AI 7.5 HIGH

Single unauthenticated HTTP request over network (AV:N, AC:L, PR:N, UI:N) causes goroutine panic with no confidentiality or integrity impact, only high availability loss.

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 HIGH
Red Hat 5.3 MEDIUM

Primary rating from Vendor (GitHub_M).

CVSS VectorVendor: GitHub_M

Attack Vector
Network
Attack Complexity
Low
Privileges Required
None
User Interaction
None
Scope
Unchanged
Confidentiality
None
Integrity
None
Availability
High

Lifecycle Timeline

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

DescriptionCVE.org

kin-openapi is a Go project for handling OpenAPI files. From 0.10.0 until 0.141.0, openapi3filter.convertParseError in openapi3filter/validation_error_encoder.go dereferences e.Parameter.In without checking whether e.Parameter is nil. A malformed non-string scalar field in a multipart/form-data request body produces a nested ParseError with a nil RequestError.Parameter, and applications that render the validation error through openapi3filter.ConvertErrors or ValidationErrorEncoder panic. An unauthenticated client can repeatedly send such requests to deny service when the application lacks a recovery boundary. JSON request bodies and applications that do not use these error-rendering helpers are not affected. This issue is fixed in version 0.141.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 library versions 0.10.0-0.140.x contain a nil pointer dereference vulnerability allowing unauthenticated remote users to crash Go web applications with a single HTTP request, directly impacting service availability. Organizations using affected versions face immediate operational risk from trivial denial-of-service attacks that require no authentication or special access.

Business Impact: High
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.4%
Top 71% exploitable
Prevalence
Low
niche Go OpenAPI validation library, limited enterprise footprint
Threat Intel
1
1 source
Social Media
1
Sightings
Data Quality
8 sources
Confidence: High
EUVD NVD CVE.org EPSS Vulnrichment GHSA Vendor CIRCL GitHub VulDB

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.4%
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
Out-of-Cycle
Exploitation
Poc
System Exposure· derived
Open
Automatable
Yes
Human Impact
High
Technical Impact
Partial

Priority Score

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

Attack Technique

A null pointer dereference occurs when a program attempts to access memory through a pointer that has been set to NULL (address 0x0).

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

CVE-2026-77354 HIGH POC
8.7 Aug 21

Uncontrolled heap allocation in kin-openapi versions 0.124.0 through 0.141.x allows any unauthenticated remote client to

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