CVEReports
CVEReports

Automated vulnerability intelligence platform. Comprehensive reports for high-severity CVEs generated by AI.

Product

  • Home
  • Sitemap
  • RSS Feed

Company

  • About
  • Contact
  • Privacy Policy
  • Terms of Service

© 2026 CVEReports. All rights reserved.

Made with love by Amit Schendel & Alon Barad



CVE-2026-44340

CVE-2026-44340: Arbitrary File Write via Symlink Traversal in PraisonAI Tar Extraction

Alon Barad
Alon Barad
Software Engineer

May 11, 2026·7 min read·52 visits

Executive Summary (TL;DR)

A symlink-based path traversal in PraisonAI's recipe unpacking allows arbitrary file overwriting, potentially leading to remote code execution.

PraisonAI versions prior to 4.6.37 contain a path traversal vulnerability in the `_safe_extractall` function. The flaw allows an attacker to write arbitrary files outside the intended extraction directory via maliciously crafted tar archives containing unresolved symbolic links.

Vulnerability Overview

PraisonAI is a multi-agent systems platform that relies on a recipe ecosystem to share and deploy configurations. The platform exposes recipe pull, recipe publish, and recipe unpack workflows to manage these configurations via archive files. The vulnerability resides within the _safe_extractall helper function located in src/praisonai/praisonai/recipe/registry.py.

The _safe_extractall function is responsible for securely extracting tar archives to a designated destination directory. While the function implements checks to prevent standard directory traversal using absolute paths and .. segments, it fails to account for symbolic and hard links. This class of vulnerability is categorized as CWE-59: Improper Link Resolution Before File Access, commonly referred to as a "TarSlip" vulnerability.

An attacker exploiting this flaw can construct a malicious archive that bypasses the directory restrictions during the extraction process. When a victim processes the malicious recipe archive, the application writes files to arbitrary locations on the victim's filesystem. This arbitrary file write capability directly enables privilege escalation and remote code execution by targeting sensitive configuration files or execution paths.

Root Cause Analysis

The root cause of the vulnerability is a discrepancy between the static validation of archive members and the stateful extraction behavior of the Python tarfile library. The _safe_extractall function iterates over the tar.getmembers() list and performs lexical validation on the member.name attribute. It uses Path.resolve() to ensure the evaluated destination path falls within the target directory boundaries.

This validation approach is inadequate because a Tar archive can contain members defined as symbolic links (SYMTYPE) or hard links (LNKTYPE). These specific member types contain a linkname attribute that specifies the target of the link. The original implementation of _safe_extractall entirely omitted validation of the linkname attribute.

Because the validation loop executes prior to the extraction of any files, Path.resolve() evaluates the paths lexically against the current filesystem state. A path referencing a symlink that does not yet exist on the filesystem will resolve successfully as a standard path within the destination directory. The validation logic approves the member, unaware that the path will behave as a symlink during actual extraction.

The extraction phase occurs via a single call to tar.extractall(). This function processes members sequentially in the exact order they appear in the archive. If an attacker places a symlink member first, extractall() creates the symlink on the disk. When a subsequent member targets a path inside that symlink, the operating system routes the write operation through the symlink to the external directory.

Code Analysis

The original implementation of _safe_extractall applied structural checks exclusively to the member.name property. It verified that paths were not absolute and did not contain directory traversal sequences. However, it passed the entire archive to tarfile.extractall(dest_dir) without assessing the internal symlink destinations.

The remediation introduced in commit 0cec9fd1c3fc457c70712d97e21ea1caaa32ecda implements strict resolution checks for the linkname attribute. The patch explicitly queries member.issym() and member.islnk() during the validation loop. If a link is detected, the application reconstructs the intended target relative to the member's extraction path.

if member.issym() or member.islnk():
    linkname = member.linkname or ""
    if linkname.startswith("/"):
        raise RegistryError(f"Refusing to extract link with absolute target: {member.name} -> {linkname}")
    
    # Resolve the intended target relative to the member's position
    link_target = (dest_resolved / member_path.parent / linkname).resolve()
    
    # Ensure the resolved target is still within the destination directory
    if not str(link_target).startswith(str(dest_resolved) + os.sep) and link_target != dest_resolved:
        raise RegistryError(f"Refusing to extract link escaping target directory: {member.name} -> {linkname}")

Beyond manual validation, the patch introduces defense-in-depth by adopting the PEP 706 security filter for the tarfile module. The execution phase now calls tar.extractall(dest_dir, filter="data") within a try-except TypeError block. On Python 3.12 and newer, the data filter natively blocks the extraction of absolute paths and symlinks that traverse outside the target directory.

Exploitation Methodology

Exploiting this vulnerability requires the construction of a specifically ordered GZipped Tar archive. The attacker must control the sequence of the archive members to manipulate the internal state of the extraction process. The first required component is a symlink member pointing to the target external directory, such as /home/user/.ssh/.

The second required component is a standard file member routed through the namespace of the previously defined symlink. The file name must be prefixed with the symlink's name, for example, symlink_name/authorized_keys. The attacker injects their payload, such as an SSH public key, into the contents of this file.

The exploit execution is triggered when the victim invokes praisonai recipe pull or praisonai recipe unpack on the malicious archive. The validation loop approves both members because their standard string representations lack explicit traversal characters. The extractall function subsequently creates the symlink and routes the file write operation to the external directory.

Impact Assessment

The vulnerability exerts a severe impact on the integrity of the host system. An attacker obtains arbitrary file write capabilities restricted only by the filesystem permissions of the user executing the PraisonAI utility. This allows the attacker to silently modify or overwrite any writable file on the system during routine recipe operations.

The standard progression for this vulnerability class involves immediate escalation to unauthenticated Remote Code Execution (RCE). Attackers typically achieve this by overwriting SSH .authorized_keys files, bash profile scripts (.bashrc), cron jobs, or the source code files of the PraisonAI application itself. The resulting compromise grants the attacker persistent access to the victim environment.

The vulnerability is tracked with a CVSS 4.0 score of 8.7 (High) and a CVSS 3.1 score of 7.5 (High). The metrics reflect the severity of the arbitrary write capability combined with the lack of required privileges, balanced against the necessity of user interaction to trigger the archive processing.

The calculated EPSS score is 0.00017 (0.045 percentile). The low probability of exploitation in the wild correlates with the requirement for user interaction via a CLI tool and the specific targeting required against the PraisonAI developer ecosystem.

Remediation

The primary remediation strategy requires upgrading the PraisonAI application to version 4.6.37 or later. The patched release implements comprehensive structural validation for all symlink and hardlink targets prior to executing extraction operations. The fix is verified to properly reject archives containing outbound link definitions.

Organizations utilizing PraisonAI should mandate the use of Python 3.12 or newer across all execution environments. Python 3.12 introduces native protections against TarSlip vulnerabilities via the PEP 706 filter="data" parameter. The patched PraisonAI release integrates this native filter natively, establishing an enforced secondary boundary against unexpected extraction behaviors.

Administrators must enforce the principle of least privilege for the user accounts executing the PraisonAI utilities. Restricting the filesystem write permissions of the application process limits the blast radius of arbitrary file write vulnerabilities. The application process should explicitly lack write access to sensitive configuration directories, cron configurations, and system binaries.

Official Patches

PraisonAIFix commit for symlink path traversal bypass

Fix Analysis (2)

Technical Appendix

CVSS Score
8.7/ 10
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:H/A:N
EPSS Probability
0.02%
Top 96% most exploited

Affected Systems

PraisonAI multi-agent teams system prior to 4.6.37

Affected Versions Detail

Product
Affected Versions
Fixed Version
PraisonAI
PraisonAI
< 4.6.374.6.37
AttributeDetail
CWE IDCWE-59 (Link Following) / CWE-22 (Path Traversal)
Attack VectorNetwork (Malicious Archive)
CVSS 4.0 Score8.7
CVSS 3.1 Score7.5
ImpactArbitrary File Write / Remote Code Execution
EPSS Score0.00017
Exploit StatusPoC Available

MITRE ATT&CK Mapping

T1534Internal Spearphishing
Initial Access
T1210Exploitation of Remote Services
Lateral Movement
T1083File and Directory Discovery
Discovery
T1005Data from Local System
Collection
CWE-59
Improper Link Resolution Before File Access ('Link Following')

Improper Link Resolution Before File Access ('Link Following')

Known Exploits & Detection

GitHub AdvisoryAdvisory details indicating functional regression tests serve as PoC

Vulnerability Timeline

Fix commits pushed to GitHub
2026-05-04
Security advisory published (GHSA-9q28-ghcr-c4x3)
2026-05-08
CVE-2026-44340 assigned and published
2026-05-08
EPSS score calculated
2026-05-11

References & Sources

  • [1]NVD - CVE-2026-44340
  • [2]GitHub Security Advisory GHSA-9q28-ghcr-c4x3
  • [3]PraisonAI Fix Commit 0cec9fd1c3fc457c70712d97e21ea1caaa32ecda
  • [4]PraisonAI Release v4.6.37

Attack Flow Diagram

Press enter or space to select a node. You can then use the arrow keys to move the node around. Press delete to remove it and escape to cancel.
Press enter or space to select an edge. You can then press delete to remove it or escape to cancel.

More Reports

•22 minutes ago•CVE-2026-129301
6.5

CVE-2026-129301: Security Scanner Evasion and Batch Denial of Service in SpamScope mail-parser via Unhandled Attachment Exceptions

CVE-2026-129301 (GHSA-8cgq-x343-p74c) is an uncaught exception and MIME interpretation conflict vulnerability in the Python email parsing library mail-parser (versions >= 4.6.0 and < 4.6.3). The write_attachments() function iterates over parsed email attachments without per-attachment exception containment. When processing a specially crafted MIME part containing an RFC 2231-encoded null byte in the filename, a basename exceeding filesystem NAME_MAX limits, or a malformed base64 payload, the function raises an unhandled standard library exception (ValueError, OSError, or binascii.Error). This prematurely aborts the attachment extraction loop, preventing subsequent attachments from being written to disk for downstream security inspection while also triggering unhandled worker crashes in applications that only catch MailParserError.

Amit Schendel
Amit Schendel
1 views•11 min read
•about 1 hour ago•CVE-2026-129239
6.5

CVE-2026-129239: Privilege Escalation and Unauthorized Data Exposure in Directus SharesService

Directus versions prior to 12.3.1 contain an authorization bypass and privilege management flaw in the SharesService component. Authenticated non-administrative users with update permissions on the directus_shares collection can modify the user_created, role, item, and collection fields of an existing owned share. Because the update operation validates permissions solely against the pre-update record state without revalidating the modified fields, an attacker can reassign share ownership and role context to an administrator. Subsequent guest access using the share token derives administrative accountability, exposing restricted relational data.

Alon Barad
Alon Barad
2 views•10 min read
•about 2 hours ago•CVE-2026-88987
5.4

CVE-2026-88987: Stored Cross-Site Scripting via XHTML and XML Data URIs in Silverstripe Framework

CVE-2026-88987 (GHSA-qqrg-8jpm-8mph) is a stored Cross-Site Scripting (XSS) vulnerability in the Silverstripe Framework prior to version 6.2.13. The framework's HTML sanitization engine, XssSanitiser, relies on an incomplete regular expression denylist when filtering URI schemes in HTML attributes. Specifically, the sanitizer strips data:text/html URIs but fails to restrict executable XML and XHTML media types such as data:application/xhtml+xml, data:text/xml, and data:application/xml. An authenticated user with content creation privileges can embed crafted data URIs inside HTML attributes like iframe src or object data, leading to arbitrary JavaScript execution when the content is rendered by a victim's browser.

Amit Schendel
Amit Schendel
1 views•9 min read
•about 3 hours ago•CVE-2026-88988
5.4

CVE-2026-88988: Stored Cross-Site Scripting via SVG Data URIs in Silverstripe Framework

A Stored Cross-Site Scripting (XSS) vulnerability exists in Silverstripe Framework versions prior to 6.2.13 within the SilverStripe\Core\XssSanitiser component. The HTML sanitizer fails to strip SVG data URIs (data:image/svg*) from dangerous HTML attributes such as href, src, lowsrc, and data. Authenticated CMS authors can persist crafted SVG data URIs in stored content, leading to arbitrary JavaScript execution in the browser context of users who view or interact with the rendered page.

Alon Barad
Alon Barad
3 views•9 min read
•about 4 hours ago•CVE-2026-88989
4.3

CVE-2026-88989: Authorization Bypass in Silverstripe Framework GridFieldDetailForm

CVE-2026-88989 (tracked as GHSA-3qh3-54qg-gpq3) is a missing authorization vulnerability (CWE-862) in the Silverstripe Framework affecting versions prior to 6.2.13. The flaw exists within the GridFieldDetailForm_ItemRequest request handler, which orchestrates record creation and editing workflows inside the Silverstripe CMS backend. Specifically, the server-side persistence method saveFormIntoRecord() fails to verify whether an authenticated user possesses the necessary creation permissions (canCreate) when processing an unpersisted DataObject record. Consequently, a low-privileged CMS user who has permission to access a GridField interface and edit existing records can bypass role-based creation restrictions. By sending a crafted HTTP POST request directly to the item/new endpoint with the action_doSave parameter, the user can instantiate and persist unauthorized database records. The vulnerability is rated Medium severity with a CVSS v3.1 base score of 4.3 and is remediated in Silverstripe Framework version 6.2.13.

Amit Schendel
Amit Schendel
2 views•10 min read
•about 5 hours ago•CVE-2026-91112
6.8

CVE-2026-91112: Privilege Escalation via CMS_ACCESS_SecurityAdmin in Silverstripe Framework

Silverstripe Framework prior to version 6.2.13 contains an improper privilege management vulnerability (CWE-269) within the Group authorization and validation logic. A delegated administrator possessing the CMS_ACCESS_SecurityAdmin permission, but lacking full ADMIN privileges, can edit or reparent groups that acquire administrative capabilities indirectly via permission roles or ancestor inheritance. By adding their own account to such a group or moving a controlled group underneath a role-privileged parent, the user escalates to full administrative access across the CMS.

Amit Schendel
Amit Schendel
3 views•9 min read