Summary
Typebot's HTTP request URL validator can be bypassed using the IPv6 unspecified address (::), allowing crafted URLs to evade checks on local, metadata, and private ranges.
When a workspace editor or creator configures server-side HTTP Request blocks or guarded script fetches, this flaw can make the Typebot server initiate requests to internal services, becoming risky wherever untrusted chat flows can trigger server-side network access.
Affected context
This vulnerability appears in Typebot deployments that:
- Allow workspace editors or creators to configure server-side HTTP Request blocks or guarded script fetches
- Rely on the shared SSRF validator in
validateHttpReqUrl.tsto block unsafe destinations - Accept chat interactions through endpoints such as:
POST /v1/typebots/{publicId}/startChatPOST /v1/sessions/{sessionId}/continueChat
Under these conditions, use of the IPv6 unspecified address (:: or its expanded form) may permit requests to local HTTP services when the server resolves or interprets the address in ways not covered by the validator.
Exploit preconditions
- Attack surface: Typebot server-side HTTP request functionality (HTTP Request blocks, guarded script fetches) exposed through chatbot flows.
- Required access: Ability to create or edit a workspace that defines server-side HTTP requests, or to trigger existing flows that use these blocks.
- Trigger point: Invocation of a flow that causes the Typebot server to perform an outbound HTTP request via
safeKy, using a URL based on the IPv6 unspecified address. - Why exploitation is possible: The SSRF validator's
validateIPAddressroutine correctly blocks local, metadata, and private ranges but does not treat::(or its expanded form) as a forbidden address, allowing malformed or edge-case URLs to bypass protections and reach internal services.
Why this happens
The underlying issue is an incomplete network address validation logic in the SSRF protection layer.
The validateHttpReqUrl function depends on validateIPAddress to filter unsafe destinations but the implementation focuses on common local, private, and metadata ranges without fully covering special IPv6 addresses, including the unspecified address ::.
This gap exemplifies CWE-918: Server-Side Request Forgery (SSRF), where server-side HTTP clients accept attacker-controlled URLs and rely on insufficient validation to prevent access to internal or sensitive endpoints.
Potential impact
- The attacker may use the Typebot server as a proxy to reach internal HTTP services that are not directly exposed to the internet.
- The attacker could interact with cloud metadata services or internal admin panels if reachable through misinterpreted IPv6 addressing.
- The attacker can potentially enumerate internal services and ports reachable from the Typebot server environment.
- The attacker may leverage internal access to escalate privileges, retrieve secrets, or pivot further within the hosting infrastructure.
General mitigation guidance
Effective mitigation focuses on strengthening SSRF defenses and minimizing trust in user-configured network targets.
Common defensive patterns include:
- Implement comprehensive IP and hostname validation that explicitly handles IPv6 special addresses, localhost aliases, and encoded forms (e.g., DNS rebinding, IPv4-mapped IPv6).
- Enforce allowlists of external domains or endpoints that server-side HTTP requests can reach, rather than attempting to block known-bad ranges.
- Separate internal management or metadata networks from any path reachable by application-level HTTP clients.
- Apply least-privilege to server network access, limiting outbound connectivity to only what is required for core functionality.
- Consider sandboxing or proxying server-side HTTP requests through hardened intermediaries that enforce strict policies on destinations.
How teams detect issues like this
Teams can detect and manage SSRF risks through a combination of code-level and operational controls:
- Static analysis or linters that flag custom HTTP client usages lacking robust destination validation or that bypass central SSRF enforcement logic.
- Code review checklists that treat any new server-side HTTP request functionality as security-sensitive and require explicit allowlist or policy enforcement.
- Runtime monitoring of outbound traffic patterns from application servers, alerting on attempts to reach internal IP ranges, metadata endpoints, or unusual IPv6 addresses.
- Periodic security testing that includes SSRF-focused test cases, such as usage of special IPv6 addresses, obfuscated hostnames, and DNS rebinding scenarios.
- Optional use of automated security scanners or application security testing tools configured to identify SSRF sinks and insufficient validation in URL handling code.

