/

CVE-2026-44335

Severity:

CRITICAL RISK

(9.8)

SSRF in PraisonAI URL Validation Logic

CVE-2026-44335

Analyzed

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-918

Impact:

Unauthorized network access via SSRF, potentially leading to data exposure or further compromise

Severity:

CRITICAL RISK

(9.8)

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 URL checking logic contained a flaw that allowed attackers to bypass intended restrictions on outbound HTTP requests, enabling server-side request forgery (SSRF).

When an attacker can influence URLs that PraisonAI fetches, they may coerce the system into making requests to internal or otherwise protected endpoints through this bypass.

Affected context

This vulnerability affects PraisonAI deployments where agents or workflows perform outbound HTTP requests based on user-supplied or externally influenced URLs.

The issue manifests in components that rely on the URL checking logic to enforce network boundaries (e.g., blocking internal IP ranges or sensitive metadata endpoints).

It becomes risky when untrusted users can supply or modify URLs that PraisonAI will dereference on the server side, especially in environments with access to internal services, cloud instance metadata, or private APIs.

Exploit preconditions

  • Attack surface: Any PraisonAI feature that accepts or derives URLs from user-controllable input (prompts, configuration, plug‑ins, or integrations) and then fetches those URLs from the server.
  • Required access: Ability to interact with PraisonAI workflows or agents in a way that influences the target URL (e.g., as an authenticated tenant user, integration partner, or in some cases anonymous user if exposed).
  • Trigger point: Submission of a crafted URL that exploits the logical flaw in the URL checking mechanism, causing PraisonAI to treat a disallowed destination as allowed.
  • Why exploitation is possible: The URL validation logic enforces network/host restrictions incorrectly; by manipulating URL formats or edge cases, an attacker can bypass these checks and induce server-side requests to otherwise blocked internal or sensitive endpoints.

Why this happens

The underlying bug is a logic flaw in URL validation and enforcement that fails to robustly distinguish allowed destinations from restricted ones.

This maps to CWE-918: Server-Side Request Forgery (SSRF), where a server-side component initiates HTTP requests based on user-controlled input without correctly constraining the reachable network locations.

Typical patterns include validating only string prefixes, relying on naive hostname checks, failing to account for DNS rebinding or redirects, or parsing the URL inconsistently between validation and the actual HTTP client.

As a result, attacker-controlled URLs can traverse validation while still resolving or redirecting to internal services, metadata endpoints, or other protected resources.

Potential impact

  • Access to internal HTTP services not directly exposed to the internet (e.g., microservices, admin panels, or databases behind the firewall)
  • Retrieval of sensitive data from cloud instance metadata endpoints (such as access tokens, credentials, or configuration)
  • Pivoting within the internal network by enumerating reachable services and ports via blind SSRF techniques
  • Abuse of PraisonAI's network position to interact with protected APIs, potentially altering data or invoking privileged operations
  • Use of PraisonAI as a proxy to obfuscate the origin of malicious traffic against third-party targets

General mitigation guidance

Effective mitigation centers on constraining where server-side HTTP requests are allowed to go and ensuring validation is both authoritative and consistent with the HTTP client behavior.

Recommended defensive patterns include:

  • Implement a strict allowlist of permitted destinations (hosts or network segments) for all server-initiated HTTP requests, rather than relying solely on blocklists.
  • Perform URL parsing using well-vetted libraries and normalize the URL before validation, ensuring the same representation is used for both validation and the HTTP request.
  • Enforce network-level egress controls (e.g., firewall rules, VPC security groups, or service mesh policies) so that application bugs cannot directly reach internal or metadata endpoints.
  • Disable or tightly restrict access to cloud metadata services from application containers or hosts where possible.
  • Separate high-privilege internal services from components that process untrusted URL inputs, reducing the blast radius of any SSRF issue.

How teams detect issues like this

Organizations can approach detection and assurance for this class of vulnerability using a combination of code-level and operational techniques:

  • Static analysis: Search for code paths where untrusted input influences HTTP client calls (e.g., requests, fetch, or custom HTTP libraries) and ensure robust validation and allowlisting are present.
  • Code review cues: Flag any custom URL or hostname validation logic that relies on string comparisons, incomplete parsing, or does not account for redirects, DNS rebinding, or alternate URL schemes.
  • Automated testing: Incorporate SSRF-focused tests that supply crafted URLs (e.g., internal IPs, localhost, metadata endpoints, redirect chains) to features that make server-side requests.
  • Network monitoring: Observe outbound traffic from PraisonAI instances for unexpected destinations such as internal address ranges, cloud metadata IPs, or unauthorized APIs.
  • Security policy enforcement: Use platform-level tools (e.g., egress proxies, service meshes, or WAFs with egress rules) to enforce outbound request policies independent of application logic.

Sources

SourceLink
github.comgithub.com/MervinPraison/PraisonAI/security/advisories/GHSA-q9pw-vmhh-384g

Frequently asked

questions

Yes. If PraisonAI exposes features where remote users can control or influence the URLs that agents fetch, an attacker can exploit the flawed URL checking logic remotely, subject to whatever authentication or tenancy boundaries are in place.

The attacker typically needs the ability to submit or affect URLs processed by PraisonAI—commonly as an authenticated user of the system, a tenant, or an integrated application. The precise access level depends on how PraisonAI is deployed and which components accept untrusted URLs.

The strongest pattern is to enforce a strict allowlist of outbound destinations, combined with robust URL parsing and normalization that matches the behavior of the HTTP client. This should be reinforced with network-level egress controls to ensure requests cannot reach internal or metadata endpoints even if application logic is bypassed.

Treat any server-side HTTP request that depends on user-supplied data as sensitive, design around allowlisted destinations, and keep internal or privileged services on networks that are not reachable from components that handle untrusted inputs. Incorporate SSRF-specific reviews and tests into your development, CI, and security assessment processes, and align application-level checks with infrastructure-level egress restrictions.

Find out what's already
exploitable in your codebase.