/

CVE-2026-84196

Severity:

HIGH RISK

(7.7)

SSRF (CWE-918) in Kyverno apiCall.service.url Field

CVE-2026-84196

Awaiting Analysis

Vulnerability type

Category:

Server-Side Request Forgery

CWE:

CWE-918

Impact:

Internal Network Access and Non-Blind Data Exfiltration

Severity:

HIGH RISK

(7.7)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

Summary

Kyverno contains a server-side request forgery vulnerability in the apiCall.service.url field, where authenticated users may influence HTTP destinations through variable substitution. Successful exploitation could allow requests to internal services, cloud metadata endpoints, or loopback addresses, with response data reflected in admission error messages.

Affected context

The vulnerability affects Kyverno configurations that use apiCall.service.url with user-controlled or insufficiently constrained variable substitution. It becomes risky when an authenticated user can influence values inserted into the service URL and Kyverno can reach internal network resources or return upstream responses through admission errors. Deployments with restricted egress and tightly controlled policy inputs may reduce exposure.

Exploit preconditions

  • Attack surface: Kyverno policy evaluation through the apiCall.service.url feature
  • Required access: Authenticated access sufficient to influence inputs used in variable substitution or submit requests evaluated by the affected policy
  • Trigger point: An admission or policy-processing operation that constructs and sends the service URL
  • Why exploitation is possible: User-controlled values can influence the destination of server-side HTTP requests, while response content may be reflected in admission error messages

Why this happens

The underlying bug is insufficient separation between trusted service destinations and user-controlled variable values. When variable substitution can affect an outbound request URL without strong destination validation, the server may be induced to contact resources that were not intended by the policy author. This behavior maps to CWE-918: Server-Side Request Forgery, including the possibility of response reflection that makes otherwise blind requests observable.

Potential impact

  • An attacker may access services on internal network interfaces
  • Cloud instance metadata or other sensitive endpoint responses could be disclosed
  • Loopback and host-local services could be queried
  • Response data may be exfiltrated through admission error messages
  • Internal service exposure could support further compromise or reconnaissance

General mitigation guidance

Mitigation generally focuses on ensuring that outbound request destinations are trusted, constrained, and independent of untrusted input.

Common defensive patterns include:

  • Allowlisting approved schemes, hosts, ports, and paths for service requests
  • Keeping destination components separate from user-controlled variables
  • Rejecting loopback, link-local, private, and other restricted network ranges where they are not required
  • Applying egress network policies and firewall controls to limit reachable services
  • Avoiding reflection of upstream response bodies in admission errors
  • Running Kyverno with only the network and privileges required for its function
  • Treating policy inputs and admission-request data as untrusted by default

How teams detect issues like this

Organizations can identify SSRF risks through:

  • Static analysis for request URLs assembled from admission data, variables, or other untrusted inputs
  • Code and policy reviews that examine apiCall.service.url construction and substitution boundaries
  • Configuration policies requiring destination allowlists and rejecting restricted address ranges
  • Network monitoring for unexpected requests from Kyverno components to metadata services, loopback addresses, or internal administrative endpoints
  • Admission-log analysis for unusual outbound destinations or error messages containing upstream response data
  • Automated security review tools that flag dynamic URL construction and missing egress restrictions

Sources

SourceLink
github.comgithub.com/kyverno/kyverno/security/advisories/GHSA-qr4g-8hrp-c4rw
vulncheck.comvulncheck.com/advisories/kyverno-before-1.18.0-server-side-request-forgery-via-apicall

Frequently asked

questions

It can be exploitable through Kyverno's authenticated policy or admission-processing interfaces when an attacker can influence values used in apiCall.service.url. The exact scope depends on authorization and policy configuration.

The attacker generally needs authenticated access that permits supplying or triggering data participating in variable substitution. They also benefit from a Kyverno deployment with network reachability to the targeted resource.

Keep outbound destinations trusted and statically defined where possible, enforce strict host and network-range allowlists, and prevent untrusted variables from controlling request destinations.

Treat all admission and policy-derived values as untrusted, apply layered egress restrictions, avoid exposing upstream response bodies, and use code review or automated analysis to detect dynamic outbound URL construction.

Find out what's already
exploitable in your codebase.