/

CVE-2026-34207

Severity:

HIGH RISK

(7.6)

Server-Side Request Forgery (SSRF) in TypeBot Webhook Blocks

CVE-2026-34207

Deferred

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-20, CWE-918

Impact:

Network Access to Internal or Protected Services

Severity:

HIGH RISK

(7.6)

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 webhook and HTTP request blocks allowed crafted hostnames that resolved to internal or loopback IPs to bypass SSRF protections because validation was performed only on the literal URL string, not on resolved addresses.

Under certain configurations, an attacker controlling webhook targets could coerce the server into making requests to localhost, cloud metadata services, or private network hosts.

Affected context

This vulnerability affects deployments of TypeBot where:

  • Chatbot flows use webhook / HTTP request blocks to call arbitrary URLs supplied by users or external configuration.
  • The backend server performs outbound HTTP requests on behalf of the bot.
  • SSRF protections rely on string-based URL and hostname checks without resolving DNS before allowing the request.

Environments with accessible internal services, loopback-only admin interfaces, or cloud provider metadata endpoints are more exposed to risk.

Exploit preconditions

  • Attack surface: Webhook / HTTP Request blocks that accept attacker-controlled or indirectly influenced URLs.
  • Required access: Ability to configure or trigger a bot flow with a chosen webhook/HTTP target (e.g., malicious participant input, compromised configuration, or tenant account).
  • Trigger point: When the backend resolves and fetches the provided URL as part of executing a chatbot step.
  • Why exploitation is possible: SSRF filtering is applied only to the literal URL string, hostnames, and IP formats. DNS resolution is not performed prior to validation, so hostnames that appear benign but resolve to 127.0.0.1, 169.254.169.254, or internal/private IP ranges are allowed and subsequently requested by the server.

Why this happens

The core issue is an incomplete validation of untrusted URLs before use in outbound HTTP requests.

Instead of resolving hostnames and enforcing allow/deny policies on the final IP address, the implementation relies on pattern checks of the raw URL string and literal IP formats.

This aligns with:

  • CWE-918: Server-Side Request Forgery (SSRF) — where a server-side component makes HTTP requests to arbitrary domains or addresses controlled or influenced by an attacker.
  • CWE-20: Improper Input Validation — because the validation logic fails to account for DNS resolution and the possibility that seemingly safe hostnames map to forbidden internal or loopback addresses.

The abstract insecure pattern is: taking user-supplied URLs, performing only superficial syntactic checks, and using them directly in a high-privilege HTTP client that can reach internal networks or special-purpose endpoints.

Potential impact

  • The server may issue HTTP requests to 127.0.0.1, potentially accessing internal admin panels, debugging endpoints, or services bound only to loopback.
  • The server could contact cloud provider metadata endpoints (e.g., 169.254.169.254), which may expose instance credentials, tokens, or configuration data.
  • Internal/private network services (RFC1918 address space) may be probed or accessed via SSRF, potentially revealing sensitive APIs or configuration panels.
  • Attackers could chain SSRF with other weaknesses (e.g., unsafe admin endpoints, misconfigured internal services) to escalate privileges or pivot deeper into the infrastructure.
  • Logs or error messages returned from internal services might leak sensitive details such as service versions, internal hostnames, or architecture information.

General mitigation guidance

Effective mitigation focuses on hardening how outbound HTTP requests are constructed and where they are allowed to go, rather than on specific patch versions:

  • Resolve hostnames to IP addresses before enforcing SSRF rules, and apply allow/deny policies based on the final destination IP, including checks for loopback, link-local, and private ranges.
  • Implement a default-deny network policy for server-initiated HTTP requests, allowing only explicitly trusted domains or CIDR ranges (e.g., via a configurable allowlist).
  • Use dedicated egress proxies or network-layer controls so that the application server cannot directly reach internal networks or cloud metadata IP ranges from webhook functionality.
  • Normalize and parse URLs with robust libraries, rejecting ambiguous or malformed URLs, and avoid relying solely on string matching for security-critical decisions.
  • Run outbound-HTTP-capable services with least-privilege network access, segmenting them from sensitive internal networks where possible.
  • Treat user or tenant-supplied URLs as untrusted inputs and apply centralized, reusable validation logic instead of ad-hoc filters in individual features.

How teams detect issues like this

Detecting this class of issue typically involves both code-centric and operational approaches:

  • Static analysis and code review:
  • Search for code paths where user- or tenant-supplied URLs are passed directly into HTTP clients (e.g., fetch, axios, node-fetch, request libraries) without a dedicated SSRF guard.
  • Flag URL validation logic that inspects only strings or host components without resolving DNS and inspecting the resulting IP addresses.
  • Review for missing or inconsistent allowlists, and for custom regex-based filters on URLs which can be bypassed via DNS tricks or URL parsing edge cases.
  • Runtime and logging analysis:
  • Monitor outbound HTTP logs for requests to unexpected destinations, especially 127.0.0.1, 169.254.169.254, and RFC1918 private ranges originating from webhook or user-configurable request features.
  • Configure alerting for unusual patterns such as repeated requests to cloud metadata IPs or non-production internal services.
  • Security testing and policies:
  • Incorporate SSRF-focused tests in security assessments, using domain names that resolve to internal/loopback addresses to validate protections.
  • Enforce engineering guidelines that all features which make outbound calls from user-controlled data must use standardized SSRF-safe helper utilities or middleware.
  • Automated code scanning tools that support SSRF rules can be integrated into CI/CD pipelines to flag risky patterns early.

Sources

SourceLink
github.comgithub.com/baptisteArno/typebot.io/commit/23818bb0e54db23c456ee3fa6b12d82b2af848b8
github.comgithub.com/baptisteArno/typebot.io/releases/tag/v3.16.0
github.comgithub.com/baptisteArno/typebot.io/security/advisories/GHSA-grcc-6x37-wwgp

Frequently asked

questions

Exploitability depends on how webhook or HTTP request targets are configured. If attackers can directly supply URLs (for example, via user input or tenant-controlled bot flows), they may be able to direct the server to internal or sensitive destinations. In tightly controlled deployments where only trusted administrators can set targets and inputs are not attacker-influenced, practical exploitability is lower.

An attacker typically needs the ability to influence or configure the URL used by a webhook or HTTP request block. This could come from having an account that can design or modify bots, abusing unvalidated user input that is embedded into URLs, or compromising configuration where outbound targets are derived from external data.

The safest approach is to centralize outbound HTTP handling behind a strict SSRF control layer that resolves hostnames, validates the resulting IPs against explicit allowlists, and blocks access to loopback, link-local, and private ranges by default. This pattern is more robust than ad-hoc regex checks on raw URL strings and can be reused by all features that need to make external requests.

Prevention involves architectural and process measures: design outbound HTTP features with a clear threat model, restrict reachable destinations at both the application and network layers, and mandate use of shared URL-validation and SSRF-mitigation utilities. Incorporating SSRF checks into code review, static analysis, and security testing pipelines helps catch regressions before deployment.

Find out what's already
exploitable in your codebase.