/

CVE-2026-32096

Severity:

CRITICAL RISK

(9.3)

SSRF in Plunk SNS Webhook Handler

CVE-2026-32096

Analyzed

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-918

Impact:

Network Pivot / Access to Internal Services via SSRF

Severity:

CRITICAL RISK

(9.3)

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

Plunk's SNS webhook handler contained a Server-Side Request Forgery (SSRF) vulnerability that allowed unauthenticated attackers to trigger arbitrary outbound HTTP GET requests from the server.

If an attacker could reach the webhook endpoint, they could leverage the application's network position to access internal services or cloud metadata endpoints that are not directly exposed to the internet.

Affected context

The vulnerability occurs in deployments of Plunk (prior to 0.7.0) where the SNS webhook handler is reachable from untrusted networks.

The handler processes incoming HTTP requests that are assumed to originate from AWS SNS but does not sufficiently restrict or validate the target URLs it will request on behalf of the caller.

In environments where the Plunk server has access to internal services, cloud metadata endpoints, or other sensitive network locations, this behavior becomes particularly risky.

Exploit preconditions

  • Attack surface: Publicly or externally exposed SNS webhook endpoint in the Plunk application.
  • Required access: No authentication required; attacker only needs the ability to send HTTP requests to the webhook handler.
  • Trigger point: Submission of a crafted request that influences where the server performs an outbound HTTP GET.
  • Why exploitation is possible: The webhook handler accepts attacker-controlled input that is used in outbound HTTP requests without proper validation, host allowlisting, or network egress controls, enabling the application to act as an HTTP proxy to internal resources.

Why this happens

This issue stems from the SNS webhook handler using untrusted request data to construct outbound HTTP GET requests without applying strict validation or destination controls.

Conceptually, this maps to CWE-918: Server-Side Request Forgery (SSRF), in which a server-side component fetches remote resources based on user-influenced URLs or hosts.

The insecure pattern is that the server trusts externally supplied parameters to decide where to connect, effectively exposing its internal network reachability and associated credentials to an attacker.

Potential impact

  • Access to internal HTTP services that are not exposed to the public internet.
  • Retrieval of sensitive data from internal APIs or administrative endpoints.
  • Potential access to cloud instance metadata endpoints, which could lead to credential theft and privilege escalation within the cloud environment.
  • Use of the server as a pivot point for further attacks against the internal network.
  • Facilitation of reconnaissance on internal infrastructure, such as port scanning via crafted SSRF requests.

General mitigation guidance

Mitigation focuses on breaking the trust boundary between user-controlled input and server-initiated outbound requests.

Recommended defensive patterns include:

  • Applying strict allowlists of permitted hosts, IP ranges, or URL schemes for any server-side HTTP requests originating from webhook handlers or similar components.
  • Normalizing and validating URLs before use, rejecting any request that points to private, loopback, link-local, or metadata address ranges.
  • Isolating services that must perform outbound callbacks into hardened network segments with minimal access to internal resources and no access to cloud metadata endpoints.
  • Implementing egress filtering at the network layer to restrict which destinations the application can reach.
  • Designing webhook consumption logic so that it does not proxy arbitrary URLs supplied by external clients, and instead uses fixed, preconfigured endpoints where possible.

How teams detect issues like this

High-level approaches to detect SSRF risks in similar code paths include:

  • Static analysis rules that flag use of HTTP client libraries where the target URL or host is derived from request parameters or other untrusted input.
  • Code review checklists that explicitly scrutinize webhook handlers, callback endpoints, and URL-fetching utilities for host validation, allowlists, and network restrictions.
  • Runtime monitoring and logging of outbound HTTP requests, with alerts for connections to unexpected internal ranges (e.g., 127.0.0.0/8, 169.254.169.254, RFC1918 address space).
  • Use of automated security scanning tools or dynamic analysis that attempt to exploit SSRF by directing the application to connect to controlled or internal endpoints.

Sources

SourceLink
github.comgithub.com/useplunk/plunk/commit/b8f1ad9ab53c78f8ef063fdc125f397c8bfc7652
github.comgithub.com/useplunk/plunk/security/advisories/GHSA-xpqg-p8mp-7g44

Frequently asked

questions

Yes. As long as the SNS webhook handler is reachable from the internet or other untrusted networks, an attacker can exploit the SSRF remotely without prior access.

No. The description indicates the issue can be triggered by an unauthenticated attacker with the ability to send crafted HTTP requests; reliance on SNS semantics alone is not sufficient protection.

The safest pattern is to eliminate any use of user-controlled URLs for server-initiated HTTP requests, and instead rely on fixed, preconfigured endpoints combined with strict host allowlists and network egress controls.

Prevention involves treating all externally influenced URLs and hosts as untrusted: apply canonicalization and validation, enforce allowlists, restrict network egress, and include SSRF-specific checks in design reviews, code reviews, and automated security testing for webhook and callback-related components.

Find out what's already
exploitable in your codebase.