/

CVE-2026-49213

Severity:

HIGH RISK

(8.1)

SSRF via IPv6 Unspecified Address (::) in Typebot

CVE-2026-49213

Deferred

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-918

Impact:

Internal network access via SSRF

Severity:

HIGH RISK

(8.1)

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

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.ts to block unsafe destinations
  • Accept chat interactions through endpoints such as:
  • POST /v1/typebots/{publicId}/startChat
  • POST /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 validateIPAddress routine 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.

Sources

SourceLink
github.comgithub.com/baptisteArno/typebot.io/commit/f56c3c3f771df13a8c11e88f500dfdd78981bed1
github.comgithub.com/baptisteArno/typebot.io/pull/2511
github.comgithub.com/baptisteArno/typebot.io/releases/tag/v3.17.2
github.comgithub.com/baptisteArno/typebot.io/security/advisories/GHSA-qx46-p88f-xxm3

Frequently asked

questions

Exploitation generally requires the ability to influence server-side HTTP request configuration or trigger flows that use those requests. Workspace editors or creators are primary actors, but if a public chatbot flow incorporates unsafe URLs derived from user input, remote users may indirectly exploit the SSRF behavior.

The attacker needs access to a workspace where they can define or modify HTTP Request blocks or guarded script fetches, or the ability to drive conversations through existing flows that already use server-side requests and accept attacker-controlled URLs or parameters.

The safest pattern is to eliminate broad, user-controlled destination URLs for server-side HTTP clients and replace them with strict allowlists or well-defined service integrations. Additionally, ensure that address validation covers all IP versions and special cases, treating internal and metadata networks as unreachable from application-level HTTP requests.

Future prevention depends on designing server-side HTTP features with security front-of-mind: centralize outbound request logic, enforce domain or endpoint allowlists, fully validate IP and hostname resolution (including IPv6 and DNS rebinding scenarios), and incorporate SSRF checks into code review, testing, and automated security tooling.

Find out what's already
exploitable in your codebase.