CVEReports
CVEReports

Automated vulnerability intelligence platform. Comprehensive reports for high-severity CVEs generated by AI.

Product

  • Home
  • Sitemap
  • RSS Feed

Company

  • About
  • Contact
  • Privacy Policy
  • Terms of Service

© 2026 CVEReports. All rights reserved.

Made with love by Amit Schendel & Alon Barad



CVE-2026-76905

CVE-2026-76905: Denial of Service via Nil-Pointer Dereference in getkin/kin-openapi openapi3filter

Alon Barad
Alon Barad
Software Engineer

Aug 22, 2026·6 min read·62 visits

Executive Summary (TL;DR)

Unauthenticated remote attackers can crash servers using getkin/kin-openapi (v0.10.0 to v0.140.0) by transmitting a malformed multipart/form-data request, triggering a nil-pointer dereference panic in the error validation encoder.

CVE-2026-76905 is a high-severity Denial of Service (DoS) vulnerability in the getkin/kin-openapi library, specifically inside the openapi3filter sub-package. When processing multipart/form-data request validation errors, a missing nil-pointer guard causes a Go runtime panic during error formatting. This panic terminates the active server process if no recovery handler is present, resulting in a total denial of service. The vulnerability affects versions from v0.10.0 to v0.140.0, and is resolved in v0.141.0.

Vulnerability Overview

The getkin/kin-openapi library is a standard tool in the Go ecosystem for validating, parsing, and verifying HTTP traffic against OpenAPI specification files. Within this ecosystem, the openapi3filter sub-package is frequently implemented as request-validation middleware. This middleware exposes an attack surface to arbitrary remote inputs, parsing request parameters and incoming message bodies before handing them off to downstream controllers.

When openapi3filter encounters a schema discrepancy, it constructs a structural parsing or validation error representation. Downstream services routinely invoke validation helpers such as openapi3filter.ConvertErrors or the ValidationErrorEncoder to translate these internally generated validation errors into client-facing JSON objects. This conversion step acts as the precise point of failure.

The underlying security issue resides within the error translation logic. During parsing of certain complex payloads, the translation routine attempts to access properties of structural references that were never initialized. This logic gap results in a NULL pointer dereference, classified under CWE-476. The vulnerability manifests when formatting validation errors for malformed requests.

Root Cause Analysis

The bug is located within the convertParseError helper function inside openapi3filter/validation_error_encoder.go. The validation subsystem defines a core struct named RequestError which maintains metadata regarding the validation failure context. A RequestError can point to parameter-based input violations or body-based input violations, but never both simultaneously.

When a request body is validated (such as a multipart or JSON structure), the parameter validation struct member e.Parameter is explicitly initialized as nil. However, if the error relates to a URI query parameter, e.Parameter contains a reference to the active parameter specification. This logic expects downstream code paths to respect the optional nature of this property.

During multipart/form-data processing, a non-string and non-numeric scalar field that violates schema type guidelines yields a nested structure containing an outer *ParseError wrapping an inner core failure. This nesting triggers a specific code branch in convertParseError that attempts to verify whether the root cause represents an invalid query parameter format.

The logic attempts to evaluate rootErr.Kind == KindInvalidFormat && e.Parameter.In == "query". Because the validation error originated inside the request body, e.Parameter is nil. When the engine attempts to evaluate e.Parameter.In, it dereferences a NULL pointer, throwing a panic that is not recovered inside the validation library itself.

Code Analysis

Analyzing the vulnerable logic before and after commit 1d0a337c9b1570fab283be8a04c8af6e43b9a22c reveals the exact structural fault and its corrective patch.

Prior to the patch, the vulnerability in openapi3filter/validation_error_encoder.go was structured as follows:

func convertParseError(e *RequestError, innerErr *ParseError) *ValidationError {
    // ...
    } else if innerErr.RootCause() != nil {
        // e.Parameter is dereferenced directly without verifying if it is nil
        if rootErr, ok := innerErr.Cause.(*ParseError); ok &&
            rootErr.Kind == KindInvalidFormat && e.Parameter.In == "query" {
            return &ValidationError{
                Status: http.StatusBadRequest,
                Title: fmt.Sprintf("parameter %q in %s is invalid: %v is %s",
                    e.Parameter.Name, e.Parameter.In, rootErr.Value, rootErr.Reason),
            }
        }
        return &ValidationError{
            Status: http.StatusBadRequest,
            Title:  innerErr.Reason,
        }
    }
    return nil
}

The corresponding patch introduces a strict logical boundary that prevents NULL dereferencing. It updates the conditional branch using Go's short-circuit evaluation behavior:

func convertParseError(e *RequestError, innerErr *ParseError) *ValidationError {
 	} else if innerErr.RootCause() != nil {
 		if rootErr, ok := innerErr.Cause.(*ParseError); ok &&
-			rootErr.Kind == KindInvalidFormat && e.Parameter.In == "query" {
+			rootErr.Kind == KindInvalidFormat && e.Parameter != nil && e.Parameter.In == "query" {
 			return &ValidationError{
 				Status: http.StatusBadRequest,
 				Title: fmt.Sprintf("parameter %q in %s is invalid: %v is %s",
 					e.Parameter.Name, e.Parameter.In, rootErr.Value, rootErr.Reason),
 			}
 		}
+		// For body parse errors (e.Parameter == nil) the outer ParseError's
+		// Reason is often empty, e.g. the multipart decoder wraps a part's
+		// *ParseError without setting one. Fall back to the full error text so
+		// the response still carries a meaningful message.
+		title := innerErr.Reason
+		if title == "" {
+			title = innerErr.Error()
+		}
 		return &ValidationError{
 			Status: http.StatusBadRequest,
-			Title:  innerErr.Reason,
+			Title:  title,
 		}
 	}
 	return nil
}

By placing e.Parameter != nil before e.Parameter.In == "query", any body-based request error causes the logical evaluation of the if statement to fail immediately. The engine skips evaluating the properties of the nil reference, neutralizing the panic. The added fallback title formatting ensures that body-parsing errors return a valid description.

Exploitation Methodology

Exploiting CVE-2026-76905 requires a simple delivery sequence. The targeted application must process validation errors using openapi3filter.ConvertErrors or ValidationErrorEncoder to process user input failures.

The attack is initiated by submitting a multipart request containing a data representation error. The targeted API endpoint must be configured to process multipart/form-data with an OpenAPI schema containing a non-string or non-boolean scalar (e.g., an integer). The attacker transmits a payload containing a non-numeric string where the integer value is expected.

POST /v1/upload HTTP/1.1
Host: target-api.internal
Content-Type: multipart/form-data; boundary=----WebKitFormBoundaryXyZ
Content-Length: 185
 
------WebKitFormBoundaryXyZ
Content-Disposition: form-data; name="age"
 
notanumber
------WebKitFormBoundaryXyZ--

Upon processing the boundary parts, the server's internal parser fails to map "notanumber" to an integer object. It initializes a nested ParseError containing the structural failure but omits the initialization of e.Parameter. When the app formats the failure with ConvertErrors, the service dereferences e.Parameter, throwing a panic that shuts down the entire thread.

Impact Assessment

The primary impact is service unavailability. A single, small payload containing a malformed boundary value can terminate the active server process.

In Go, unrecovered panics are fatal. Unlike languages where exceptions are confined to localized runtime execution spaces, a Go panic that escapes the active HTTP routine halts the parent process. This results in an absolute Denial of Service (DoS) for all clients interacting with the system.

The vulnerability does not allow remote code execution, file system access, or privilege escalation. It has a CVSS v3.1 score of 7.5, reflecting a network-exploitable vector that requires low complexity and no special privilege states. The absence of data leakage or execution control limits the scope to availability.

Remediation & Defense

The definitive remediation for CVE-2026-76905 is updating the dependency version of github.com/getkin/kin-openapi to version v0.141.0 or higher.

If upgrading is not immediately possible, implement a structural panic-recovery middleware block. This wrapper catches escaped runtime panics and maps them to a normal HTTP error state, such as a 500 Internal Server Error, protecting the parent process.

func PanicRecoveryMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        defer func() {
            if err := recover(); err != nil {
                // Prevent server shutdown by catching the runtime error
                log.Printf("[SECURITY] Recovered from validation panic: %v", err)
                w.WriteHeader(http.StatusInternalServerError)
                w.Write([]byte(`{"error":"Internal Server Error"}`))
            }
        }()
        next.ServeHTTP(w, r)
    })
}

Additionally, validation processes can be modified to bypass calling ConvertErrors() when formatting incoming schema issues. Instead, check the error type directly in user code to generate client responses safely.

Official Patches

getkinSecurity Advisory GHSA-mmfr-pmjx-hw9w
getkinPatch Commit 1d0a337c9b1570fab283be8a04c8af6e43b9a22c

Fix Analysis (1)

Technical Appendix

CVSS Score
7.5/ 10
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H

Affected Systems

Go applications using getkin/kin-openapi in combination with openapi3filter validation handlers.

Affected Versions Detail

Product
Affected Versions
Fixed Version
github.com/getkin/kin-openapi
getkin
>= 0.10.0, < 0.141.0v0.141.0
AttributeDetail
CWE IDCWE-476
Attack VectorNetwork
CVSS Score7.5
EPSS PercentileN/A
ImpactDenial of Service (DoS)
Exploit StatusProof-of-Concept
KEV StatusNot Listed

MITRE ATT&CK Mapping

T1499Endpoint Denial of Service
Impact
CWE-476
NULL Pointer Dereference

A NULL pointer dereference occurs when the application attempts to read or write to a memory address assumed to be valid but is instead NULL, triggering a crash.

Known Exploits & Detection

GitHubRegression test suite illustrating the crash vectors during request validation.

Vulnerability Timeline

Fix merged into repository main branch
2026-07-10
Release v0.141.0 containing the security patch
2026-08-21
GitHub Security Advisory GHSA-mmfr-pmjx-hw9w published
2026-08-21

References & Sources

  • [1]GitHub Security Advisory GHSA-mmfr-pmjx-hw9w
  • [2]Patch Commit 1d0a337c9b1570fab283be8a04c8af6e43b9a22c
  • [3]Release Tag v0.141.0

Attack Flow Diagram

Press enter or space to select a node. You can then use the arrow keys to move the node around. Press delete to remove it and escape to cancel.
Press enter or space to select an edge. You can then press delete to remove it or escape to cancel.

More Reports

•23 minutes ago•CVE-2026-122247
8.2

CVE-2026-122247: Unauthenticated Global-Admin and Database Creation via Tenant-Confusion Bypass in Budibase

A tenant-confusion vulnerability in the user initialization endpoint of the Budibase worker service (prior to version 3.50.0) allows unauthenticated remote attackers to bypass the one-time administrative setup guard. By supplying arbitrary tenant identifiers in POST requests to /api/global/users/init, an attacker can force the underlying CouchDB datastore to dynamically provision unlimited tenant databases and persist latent global administrator accounts. This results in datastore resource exhaustion, denial of service, and unauthorized administrative account creation inside non-default tenant contexts.

Amit Schendel
Amit Schendel
1 views•9 min read
•about 1 hour ago•CVE-2026-103026
8.1

CVE-2026-103026: Arbitrary Method Invocation and State Tampering in Paymenter via Livewire HasConfirmation Trait

Paymenter versions prior to 1.5.7 contain an arbitrary method invocation vulnerability within the base Livewire component architecture. The application includes a legacy trait, HasConfirmation, inside app/Livewire/Component.php, which is inherited across 36 client-facing Livewire components. This trait exposes a public remote procedure call (RPC) endpoint named executeConfirmedAction without access controls or method allowlisting. Remote attackers can invoke arbitrary methods on any inheriting component, including Livewire's internal fill() method, enabling them to bypass #[Locked] property protections and manipulate internal component state and hydrated Eloquent models.

Alon Barad
Alon Barad
2 views•9 min read
•about 2 hours ago•CVE-2026-104885
6.3

CVE-2026-104885: Cross-Realm MQTT Session Disconnect via Missing Authorization in OpenRemote

OpenRemote prior to version 1.31.0 contains a Missing Authorization vulnerability (CWE-862) in the user management REST API endpoint responsible for disconnecting active MQTT sessions. The disconnectUserSession method in UserResourceImpl fails to verify whether the requesting user owns the target MQTT session, holds administrative privileges, or belongs to the realm specified in the request path. As a result, any authenticated user who obtains a valid MQTT session identifier can forcefully terminate active MQTT connections belonging to other users or IoT devices across any tenant realm.

Amit Schendel
Amit Schendel
2 views•9 min read
•about 3 hours ago•CVE-2026-69133
5.3

CVE-2026-69133: Cumulation Buffer Memory Retention in Netty OHTTP Codec

CVE-2026-69133 (GHSA-cg26-4c6j-2x8h) is a missing resource release vulnerability (CWE-772) in io.netty.incubator:netty-incubator-codec-ohttp affecting versions 0.0.20.Final through 0.0.26.Final. Both OHttpClientCodec and OHttpServerCodec retain the outer cumulationBuffer at its expanded high-water capacity after an Oblivious HTTP (OHTTP) exchange finishes. A remote unauthenticated attacker can complete a large OHTTP request or response over an HTTP keep-alive connection and leave the connection idle, pinning pooled or direct memory allocations across concurrent connections to induce denial of service.

Amit Schendel
Amit Schendel
2 views•8 min read
•about 4 hours ago•CVE-2026-104773
6.8

CVE-2026-104773: Session Fixation in CKAN User Registration View

A session fixation vulnerability (CWE-384) exists in CKAN (Comprehensive Knowledge Archive Network) prior to versions 2.10.11 and 2.11.6. When configured with server-side session storage and active public web registration, the user registration view programmatically authenticates newly created accounts without regenerating the active session identifier. An attacker capable of fixing or capturing a victim's pre-authentication session cookie can hijack the newly registered account immediately after registration completes.

Alon Barad
Alon Barad
2 views•9 min read
•about 5 hours ago•CVE-2026-35374
6.3

CVE-2026-35374: Arbitrary File Truncation via TOCTOU Race Condition in uutils coreutils split

CVE-2026-35374 is a Time-of-Check to Time-of-Use (TOCTOU) race condition (CWE-367) in the split utility of uutils coreutils. The utility validates that the input and output paths do not refer to the same file before opening the output file with truncation flags. A local attacker with write permissions in the destination directory can replace the output file path with a symbolic link during this race window, causing the process to truncate and overwrite arbitrary files accessible to the user executing split.

Amit Schendel
Amit Schendel
2 views•11 min read