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.

