Skip to main content

Knative pkg EUVDEUVD-2026-111135

| CVE-2026-54462 MEDIUM
Allocation of Resources Without Limits or Throttling (CWE-770)
2026-10-27 GitHub_M GHSA-j8gc-gxpv-w8rg
6.5
CVSS 3.1 · Vendor: GitHub_M
View

Attack ChainAIDerived

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

  1. Access
    Gain pod-network access to webhook port
  2. Delivery
    Craft oversized AdmissionReview POST
  3. Exploit
    Send body to unbounded decoder
  4. Execution
    Decoder and bodyBuffer retain amplified copies
  5. Persist
    Controller exceeds memory limit and is OOM-killed
  6. Impact
    Admission flow disrupted (outage if failurePolicy=Fail)

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A06:2025 - Insecure Design
ASVS 5.0
V2 - Validation and Business Logic Resource allocation 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

Exploitation requires network reachability to the admission webhook HTTP(S) endpoint (commonly port 8443) of a controller that embeds knative.dev/pkg/webhook with the vulnerable admissionHandler - i.e. a deployed Knative, Tekton, KEDA, Sigstore policy-controller, or Kpack webhook server using a vulnerable pkg version. No authentication to the application and no user interaction are needed beyond sending an oversized POST to the webhook path; the CVSS PR:L reflects the attacker needing a foothold on the pod/cluster network rather than application credentials. The severity of the outcome is limited and shaped by two deployment factors stated in the evidence: the pod's memory limit (a lower limit OOMs with a smaller body - e.g. a 512 MiB pod can be killed with ~128 MiB), and the webhook's failurePolicy - failurePolicy=Fail turns the OOM into a cluster/namespace admission outage, while failurePolicy=Ignore only takes that one webhook offline while other admissions proceed.

Impact

This is a genuine but bounded availability-only issue, best characterized as a medium-priority service-disruption flaw rather than a top-tier emergency. The CVSS 3.1 vector (AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:N/A:H, 6.5 MEDIUM) correctly captures a network-reachable, low-complexity attack with only availability impact (A:H) and no confidentiality or integrity loss. The vuln.today decision label is 'this_month', consistent with a serious-but-not-drop-everything DoS. No EPSS score was provided and the CVE is not listed in CISA KEV, so there is no signal of widespread or active exploitation - treat exploitation status as 'no public exploit identified' except that the GHSA advisory itself references a reporter-built PoC (cmd/poc-c2/main.go) demonstrating ~4.5× memory amplification; that PoC is described as 'available on request' and is not verified as packaged, working public exploit code. The main thing elevating real-world concern is breadth of inheritance, not sophistication: because the vulnerable handler lives in the shared knative.dev/pkg webhook library, every downstream consumer (Knative, Tekton, KEDA, Sigstore policy-controller, Kpack) inherits it, and for consumers running failurePolicy=Fail the controller OOM can translate into a cluster- or namespace-wide admission outage. No conflicting signals were found between the vector and the description - both point to a remote, low-privilege, availability-only DoS. The GHSA note that this could be argued as HIGH 7.5+ is a scoping opinion (library-wide vs per-consumer) and is not reflected in the assigned 6.5; defenders should weight their own exposure by how many affected controllers they run and their failurePolicy settings.

Exploit ScenarioDerived

An attacker with access to the pod/cluster network sends a single oversized POST (e.g. a multi-hundred-MiB or multi-GiB JSON body) to the admission webhook port (typically 8443) of any controller built on knative.dev/pkg, such as a Tekton or Knative webhook. The handler decodes the body through json.NewDecoder(io.TeeReader(r.Body, &bodyBuffer)) with no http.MaxBytesReader, so the decoder and the tee'd bodyBuffer retain amplified copies - the reporter observed ~4.5× the body size - until the pod exceeds its memory limit and is OOM-killed. A reporter PoC reference exists but is not verified as working public exploit code; the attack requires only low complexity and pod-network reachability.

This Month Plan within 30 days. Why: MEDIUM severity (CVSS 4.0-6.9).
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 – Oct 28, 2026

Memory exhaustion in the shared knative.dev/pkg admission webhook handler allows a pod-network attacker to OOM-kill any controller built on the library by sending one oversized POST to its admission endpoint. All knative.dev/pkg versions prior to 0.0.0-20260531000007-52dbd5ece63f are affected, and the flaw propagates to every downstream consumer of the shared webhook server - Knative Serving and Eventing, Tekton Pipelines and Triggers, KEDA, Sigstore policy-controller and Kpack - because none of them bound the request body before decoding. Impact is availability-only: with failurePolicy=Fail the OOM becomes a namespace or cluster admission outage, with failurePolicy=Ignore only the affected webhook goes offline; the advisory includes a reproduction script and measured memory-amplification logs, but there is no public exploit identified at time of analysis in the sense of confirmed attack activity and the issue is not in CISA KEV. A vendor patch is available, and the assessed priority is to remediate this month rather than as an emergency.

RemediationAI

Vendor-released patch: knative.dev/pkg 0.0.0-20260531000007-52dbd5ece63f (commit 52dbd5ece63fe6d2d340ecbebec160550f460818, PR https://github.com/knative/pkg/pull/3363), which wraps the webhook mux with http.MaxBytesHandler using a fixed 3 MiB cap in webhook/webhook.go. Because the cap is applied inside the library with no API change, operators must upgrade the dependency and rebuild and redeploy every downstream controller (Knative Serving/Eventing, Tekton Pipelines/Triggers, KEDA, Sigstore policy-controller, Kpack) rather than waiting for a library-only fix to take effect. Until rebuilt images are running, the prerequisite attack path is pod-network reachability to the webhook port (commonly 8443), so restricting which workloads can reach those endpoints reduces exposure - with the trade-off that the Kubernetes API server itself must still be allowed to call the webhook or admission breaks. Review each webhook's failurePolicy deliberately: failurePolicy=Fail converts an OOM-kill into a namespace or cluster admission outage, while switching to Ignore limits the blast radius to the single webhook but stops that webhook's validation or mutation from being enforced while the controller restarts. Raise memory limits and alert on controller restarts or OOMKills as a detection measure, understanding this only shortens the outage window rather than preventing it.

Affected VersionsENISA

pkg < 0.0.0-20260531000007-52dbd5ece63f

Affected Packages

go knative.dev/pkg fix: 0.0.0-20260531000007-52dbd5ece63f
euvd pkg fix: 0.0.0-20260531000007-52dbd5ece63f

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

The flaw is CWE-770 (allocation of resources without limits or throttling) in Go's net/http handling of an admission request. In webhook/admission.go the handler constructs an admissionv1.AdmissionReview with json.NewDecoder(io.TeeReader(r.Body, &bodyBuffer)).Decode(&review) and never wraps r.Body in http.MaxBytesReader, so the decoder reads until EOF or a matching closing brace regardless of Content-Length. The io.TeeReader simultaneously copies every byte consumed into a bytes.Buffer that the rest of the handler uses for response and observability, so the body is retained twice; the advisory's verification measured roughly 4.5x amplification rather than the conservative 2x estimate, driven by bytes.Buffer.ReadFrom growth reallocation plus the decoder's own working buffer. A Go PoC running the eight-line vulnerable snippet verbatim reported a 2 GiB streamed body producing about 9.0 GiB HeapAlloc, meaning even a 128 MiB request can OOM a 512 MiB-limited Pod. Legitimate AdmissionReview payloads are small, so the read path is not a functional requirement for large bodies. The library is default scaffolding reused across the CNCF webhook ecosystem, and the advisory notes the same antipattern as CVE-2026-24514 (ingress-nginx) and GHSA-9539-c3xr-w9vm (Kyverno).

Know when Pkg 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 6.5 MEDIUM
AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:N/A:H
vuln.today AI 6.5 MEDIUM

Pod-network-reachable webhook port and a single oversized POST give AV:N/AC:L/PR:L/UI:N; only memory exhaustion occurs, so C:N/I:N/A:H with S:U.

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

Primary rating from Vendor (GitHub_M).

CVSS VectorVendor: GitHub_M

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

Lifecycle Timeline

1
Patch available
Oct 27, 2026 - 17:18 EUVD

DescriptionCVE.org

Knative pkg provides common packages shared across Knative repositories. Prior to 0.0.0-20260531000007-52dbd5ece63f, the knative.dev/pkg/webhook admissionHandler in webhook/admission.go decodes an attacker-supplied AdmissionReview through json.NewDecoder(io.TeeReader(r.Body, &bodyBuffer)) under an http.HandlerFunc without an http.MaxBytesReader or equivalent body-size limit. A pod-network client can send one oversized POST to an admission webhook, causing the decoder and bodyBuffer to retain amplified copies of the request until the controller pod exhausts memory and is OOM-killed. Every downstream consumer using the shared webhook server inherits the vulnerable behavior, including Knative, Tekton, KEDA, Sigstore policy-controller, and Kpack. For consumers configured with failurePolicy=Fail, loss of the controller can interrupt admission; with failurePolicy=Ignore, the affected webhook is unavailable while other admissions continue. This issue is fixed in version 0.0.0-20260531000007-52dbd5ece63f.

Threat Intelligence Overview

EPSS Score
0.4%
Top 69% exploitable
Prevalence
Medium
shared CNCF webhook library behind Knative, Tekton, KEDA, Sigstore, Kpack
Data Quality
5 sources
Confidence: Medium

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 MEDIUM
CISA KEV No
Public POC No
EPSS 0.4%
Patch available Yes
Active threat No
Deciding rule
MEDIUM severity (CVSS 4.0-6.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
Scheduled
Exploitation· derived
None
System Exposure· derived
Open
Automatable· derived
No
Human Impact· derived
Medium

Priority Score

32
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +32
PoC: 0
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.

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