/

CVE-2026-43993

Severity:

HIGH RISK

(8.2)

SSRF in JunoClaw WAVS Bridge computeDataVerify

CVE-2026-43993

Deferred

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-918

Impact:

Network pivoting and unauthorized access to internal resources via SSRF

Severity:

HIGH RISK

(8.2)

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

A server-side request forgery (SSRF) flaw in JunoClaw's WAVS bridge allows agent-supplied URLs to be fetched without validation of scheme, port, or resolved IP address.

In deployments where agents can influence the URL passed to computeDataVerify, an attacker may be able to pivot through the platform to reach internal services, cloud metadata endpoints, or restricted network locations.

Affected context

This vulnerability affects JunoClaw deployments where:

  • The WAVS bridge's computeDataVerify function is exposed as part of agent workflows, and
  • Agent logic or prompts can supply or influence arbitrary URLs, and
  • The runtime environment has network access to internal services (e.g., VPC-only APIs, metadata services, admin panels).

The risk increases when the JunoClaw infrastructure is deployed in cloud or containerized environments with privileged network positioning, or when internal management and data planes are reachable from the process executing fetch().

Exploit preconditions

  • Attack surface: The computeDataVerify endpoint or workflow invoked by JunoClaw agents, where URLs are derived from agent-supplied or agent-influenced data.
  • Required access: Ability to control or meaningfully influence the URL parameter consumed by computeDataVerify (e.g., via agent configuration, prompts, task parameters, or upstream APIs).
  • Trigger point: Invocation of computeDataVerify, which internally calls fetch() on the supplied URL without checking:
  • URL scheme (e.g., allowing http, https, file-like schemes, or custom schemes),
  • Destination port (e.g., 80, 443, or internal high ports),
  • Resolved IP address (e.g., private RFC1918 ranges, link-local, or loopback).
  • Why exploitation is possible: Because URL scheme, port, and resolved IP are not validated or constrained, an attacker can steer server-side HTTP requests to otherwise unreachable network locations, leveraging the platform's network position and authentication context.

Why this happens

The core issue is that computeDataVerify trusts agent-provided URLs and passes them directly to fetch() without enforcing any network access policy.

This maps to CWE-918: Server-Side Request Forgery (SSRF), where a server-side component issues HTTP or related protocol requests based on user-controlled input without restricting the reachable address space or protocol semantics.

From an abstract perspective, the bug class is:

  • Accepting externally influenced URLs,
  • Omitting validation of scheme, port, and IP/range,
  • Executing the request from a privileged network location, effectively turning the application into a blind or semi-blind HTTP proxy into internal networks.

Potential impact

  • Unauthorized access to internal HTTP(S) services that are not directly exposed to the public internet.
  • Interaction with cloud metadata endpoints, which may lead to exposure of temporary credentials or sensitive instance configuration.
  • Port scanning and service discovery on internal networks reachable from the JunoClaw environment.
  • Access to internal administrative dashboards, management APIs, or debug endpoints not intended for external use.
  • Potential data exfiltration from internal APIs, subject to response handling and what is surfaced back to the attacker.
  • Use of the platform as a stepping stone for further lateral movement within the infrastructure.

General mitigation guidance

Effective mitigation focuses on reducing trust in agent-supplied URLs and constraining outbound network requests from server-side components:

  • Enforce URL allowlisting where possible, restricting computeDataVerify to known-good domains, paths, or services.
  • At minimum, implement denylisting or strict validation of:
  • URL schemes (e.g., allow only https, or https/http with clear justification),
  • Ports (e.g., disallow non-standard and local ports, particularly <1024 and internal admin ports),
  • Destination IPs and ranges (e.g., block private, loopback, link-local, and metadata address ranges).
  • Introduce a dedicated network egress layer or proxy with rules that define which destinations computeDataVerify is allowed to reach.
  • Separate duties so that the component performing verification runs in a network segment with minimal reach—only the external or strictly required services.
  • Treat any agent-controlled or agent-derived URL as untrusted input and validate it as part of a central URL-parsing and policy-enforcement routine rather than ad-hoc checks.
  • Apply least-privilege principles to service accounts, network roles, and credentials available to the process executing fetch().

How teams detect issues like this

Organizations can identify and monitor for SSRF patterns in AI agent platforms through a combination of code-centric and operational strategies:

  • Static analysis and code scanning:
  • Search for uses of fetch(), HTTP client libraries, or similar network APIs where the URL originates from agent input or external parameters.
  • Add custom static analysis rules that flag outbound network calls missing URL validation or network policy checks.
  • Code review practices:
  • During reviews, highlight any functionality where agents, prompts, or user-controlled workflows can influence network destinations.
  • Require design documentation for components that issue server-side HTTP requests, including explicit discussion of SSRF controls.
  • Configuration and policy enforcement:
  • Use infrastructure-as-code scanning to verify egress control policies, network ACLs, and proxy configurations.
  • Implement runtime policies (e.g., with service mesh or firewall rules) that log and restrict unexpected outbound requests.
  • Runtime monitoring:
  • Instrument logging for computeDataVerify to record target URLs, resolved IPs, and response metadata, with alerts on suspicious patterns (e.g., access to metadata IPs or internal-only domains).
  • Consider using application firewalls or API gateways that enforce outbound request policies at the edge of the environment.

Sources

SourceLink
github.comgithub.com/Dragonmonk111/junoclaw/commit/a168608
github.comgithub.com/Dragonmonk111/junoclaw/releases/tag/v0.x.y-security-1
github.comgithub.com/Dragonmonk111/junoclaw/security/advisories/GHSA-q545-mvjf-q9pg

Frequently asked

questions

Yes, in typical configurations where agents or upstream users can influence the URL passed into computeDataVerify. An attacker does not need direct network access to internal services; they only need a way to feed a crafted URL into the affected workflow.

The attacker must be able to control or significantly influence the URL parameter consumed by computeDataVerify. This could occur through direct API access, configuration of an agent, prompt injection into an agent's context, or any other mechanism that lets them specify external URLs.

The safest pattern is to centralize URL and network policy enforcement before any outbound request is made. This typically means validating scheme, port, and target IP/range against a strict allowlist, and routing all requests through a constrained egress layer or proxy that only permits business-necessary destinations.

Future prevention should combine secure design and process controls:

  • Design components assuming that any agent-supplied URL is untrusted and must pass through a robust validation and policy layer.
  • Use network segmentation and egress controls so that server-side components cannot freely reach internal or metadata services.
  • Incorporate SSRF-specific checks into code review templates, static analysis rules, and security testing for any feature that performs outbound HTTP requests.
Find out what's already
exploitable in your codebase.