/

CVE-2026-61429

Severity:

HIGH RISK

(8.5)

SSRF via DNS Rebinding (CWE-918) in PraisonAI Crawl4AI

CVE-2026-61429

Deferred

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-918

Impact:

Internal Service Data Exposure and Pivoting

Severity:

HIGH RISK

(8.5)

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

PraisonAI's Crawl4AI/Chromium backend contains a server-side request forgery issue where DNS rebinding and HTTP redirects can be abused to bypass SSRF validation.

By crafting URLs that initially pass validation but later resolve to internal services, attackers can make the headless browser read internal responses, including sensitive canary values.

Affected context

This vulnerability occurs in PraisonAI deployments that use the Crawl4AI/Chromium backend to fetch and process remote URLs on behalf of users.

It manifests when SSRF protections rely on a single, early-stage network or DNS validation, while the headless browser continues to follow redirects and reuse connections.

Environments where internal services, metadata endpoints, or diagnostic canary URLs are reachable from the crawling backend are more exposed to risk.

Exploit preconditions

  • Attack surface: URL submission endpoints or APIs that trigger Crawl4AI/Chromium fetching.
  • Required access: Ability to provide arbitrary URLs to the crawling backend (e.g., via web UI, API, or task configuration).
  • Trigger point: The moment the backend performs DNS resolution and follows HTTP redirects for the attacker-controlled URL.
  • Why exploitation is possible: SSRF validation is applied only to the initial host resolution and URL, but DNS rebinding and redirect chains can change the effective target after validation, allowing access to internal services.

Why this happens

The underlying bug is an incomplete SSRF defense pattern where URL validation is treated as a one-time check before the actual network interaction begins.

DNS rebinding and redirect-driven navigation are not revalidated against SSRF policies, allowing the effective destination host or IP to change from an external address to internal infrastructure.

This maps to CWE-918: Server-Side Request Forgery, in which a server-side component that fetches remote resources is influenced by attacker-controlled URLs and fails to enforce strict target constraints throughout the entire request lifecycle.

Potential impact

  • Access to internal HTTP services that should not be reachable from user input
  • Reading sensitive canary or health-check values from protected endpoints
  • Discovery of internal network topology and service metadata
  • Potential pivoting into other internal services via exposed tokens or configuration data
  • Enhanced impact when combined with other flaws (e.g., internal admin panels or debug endpoints)

General mitigation guidance

Mitigation generally focuses on hardening SSRF defenses across the full request lifecycle rather than a single validation step.

Useful defensive patterns include:

  • Enforcing strict allowlists of external domains and IP ranges that the crawling backend may contact, and rejecting all other targets.
  • Revalidating the destination after each redirect and disallowing redirects to non-approved hosts, internal IP ranges, or link-local/metadata endpoints.
  • Treating DNS as untrusted data by resolving, caching, and verifying IPs against SSRF policies immediately before each outbound request.
  • Running the crawling backend with constrained network access, isolating it from sensitive internal services and metadata endpoints.
  • Reducing the privileges of the crawling component and limiting any credentials or tokens available to it, so that internal responses leak minimal sensitive data even if contacted.

How teams detect issues like this

Effective detection strategies typically combine code-level and runtime observations:

  • Static analysis rules and code review checklists that flag URL-fetching components which validate only the initial request but not redirect chains or post-resolution IPs.
  • Examination of SSRF protection logic to ensure that internal IP ranges, loopback addresses, and metadata endpoints are blocked regardless of DNS behavior or redirects.
  • Logging and monitoring of outbound HTTP requests from the crawling backend, with alerts for requests to internal address spaces or unexpected hostnames.
  • Integration of automated security testing tools that attempt DNS rebinding and redirect-based SSRF against URL ingestion endpoints, validating defenses in CI pipelines.

Sources

SourceLink
github.comgithub.com/MervinPraison/PraisonAI/security/advisories/GHSA-6g59-gm2v-qhvq
vulncheck.comvulncheck.com/advisories/praisonai-before-ssrf-via-crawl4ai-chromium-backend

Frequently asked

questions

Yes. Any remote user or system that can submit or influence URLs processed by the Crawl4AI/Chromium backend may exploit SSRF, subject to deployment-specific access controls.

The attacker must be able to supply arbitrary URLs to the crawling component—typically via an API, web interface, or automation workflow that feeds URLs into PraisonAI.

Apply strict, defense-in-depth SSRF controls: enforce outbound allowlists, block internal ranges, and validate every redirect target and DNS resolution against policy, while also limiting the crawler's network reach.

Treat URL fetching as a high-risk operation, architect crawlers as isolated, low-privilege services, implement comprehensive SSRF validation that covers redirects and DNS behavior, and continuously test endpoints with automated SSRF probes during development.

Find out what's already
exploitable in your codebase.