Summary
A server-side request forgery (SSRF) flaw in ToolJet's RestAPI data source lets authenticated users coerce the backend into making arbitrary HTTP calls. Because the private IP filter only inspects the hostname string and not the resolved IP, crafted DNS names can bypass protections and reach cloud instance metadata services.
In environments like Azure AKS, this can expose managed identity tokens and other sensitive metadata whenever users can define RestAPI connections and issue server-side requests.
Affected context
The vulnerability appears in ToolJet deployments where users can configure RestAPI data sources that execute HTTP requests from the server-side environment.
Risk is highest when ToolJet runs inside cloud infrastructure (e.g., AKS) with access to instance metadata services or other internal endpoints, and where access controls allow general authenticated users to define or edit RestAPI data sources.
Exploit preconditions
- Attack surface: ToolJet RestAPI data source component exposed to authenticated users
- Required access: Valid ToolJet account (including free-tier) with permission to create or modify RestAPI configurations
- Trigger point: Issuing a server-side HTTP request using a hostname that resolves to a sensitive internal address (such as Azure IMDS)
- Why exploitation is possible: The private IP filter validates the hostname string only and does not inspect the resolved IP address, allowing DNS-based indirection (e.g., nip.io domains) to reach blocked link-local or private IP ranges
Why this happens
The bug stems from implementing network egress restrictions at the string hostname level instead of at the resolved network endpoint level.
In SSRF scenarios (CWE-918), the server trusts user-controlled URLs and relies on an incomplete validation mechanism that does not account for DNS resolution or IP address classification.
By allowing arbitrary hostnames with superficial checks, the backend follows attacker-supplied URLs and can be coerced into contacting otherwise protected services, such as cloud instance metadata endpoints.
Potential impact
- Attackers may steal Azure managed identity tokens from the AKS cluster
- Attackers could access cloud instance metadata, including configuration details and temporary secrets
- Attackers can potentially pivot to other internal HTTP services reachable from the ToolJet server
- Attackers might leverage stolen credentials to escalate privileges or move laterally within the cloud environment
General mitigation guidance
Effective mitigation focuses on hardening server-side HTTP request handling and reducing the trust placed in user-controlled URLs.
Recommended patterns include:
- Resolving hostnames on the server and enforcing IP-based allow/deny rules, explicitly blocking link-local, private, and metadata service ranges
- Introducing strict allowlists for outbound destinations from server-side data source components rather than generic URL freedom
- Segregating network access so that application components handling user-specified endpoints do not share access to sensitive internal services
- Running application workloads under identities with minimal cloud permissions and avoiding direct exposure of instance-level credentials
- Treating any user-specified connection configuration as untrusted and validating it through centralized egress policies
How teams detect issues like this
Teams can identify similar SSRF risks by:
- Using static analysis and configuration review to locate components that perform server-side HTTP requests from user-controlled input
- Reviewing hostname/IP validation logic for reliance on naive string checks instead of resolved IP classification
- Enforcing network-layer controls (e.g., firewalls, egress proxies) that block traffic to metadata services and sensitive internal ranges regardless of application logic
- Monitoring logs for suspicious outbound requests to known metadata endpoints (169.254.169.254, Azure IMDS URLs) initiated by application services

