Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessAuthenticate with low-privileged account
-
DeliveryPOST export task with traversal name
-
Exploitunsanitized file_name joined in local_storage
-
ExecutionGET export content reads service-account-readable file
-
ImpactExfiltrate secrets or write file outside export directory
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A01:2025 - Broken Access Control
ASVS 5.0
V5 - File Handling Path canonicalization, traversal prevention
MITRE ATT&CK
2 techniques across 2 tactics: Discovery, Collection The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Exploitation requires three concrete prerequisites stated in the advisory: (1) a valid authenticated YETI account that does NOT need administrator privileges; (2) the deployment must use the default local file storage backend (core/clients/file_storage/classes/local_storage.py), since the traversal occurs in its path joining; and (3) the YETI service account must hold filesystem read/write permissions on the targeted paths, which bounds both what can be read (C:H) and what can be written (I:H/A:L). The trigger is the ExportTask 'name' field (e.g. '../../../../../../etc/passwd') consumed via ExportTask.file_name without path-separator or '..' sanitization. Limiting factors for defenders: the authentication requirement (PR:L) prevents anonymous exploitation; non-default (non-local) storage backends are not described as affected; and the ultimate blast radius is constrained by the service account's filesystem permissions and deployment layout rather than being guaranteed code execution. |
| Impact | This is a genuine prioritization candidate rather than CVSS-inflation, but it is bounded by an authentication precondition. The CVSS vector CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:L (score 8.3) is internally consistent with the verified advisory: network-reachable REST API (AV:N), no race or special timing (AC:L), a low-privileged authenticated account (PR:L), and no user interaction (UI:N), yielding confirmed arbitrary file read (C:H) and arbitrary file write (I:H) with corruption/DoS potential (A:L). The vuln.today decision label is 'this_week' (not act_now/emergency). No CISA KEV listing is present, so there is no confirmed active exploitation; however, a detailed author-verified proof-of-concept IS present in the GHSA advisory (working curl-based read and write PoCs), so this is not a theory-only finding. No EPSS score was supplied in the input, so probabilistic exploitation likelihood cannot be quantified here. The single most important limiting signal is PR:L: an attacker needs a valid non-admin YETI account AND the deployment must use the default local storage backend, which narrows this from internet-wide spray toward authenticated/insider or post-credential-compromise abuse. Net: treat as a real high-severity issue to patch promptly given the working PoC and C:H/I:H impact, but it is not an unauthenticated internet-wide emergency. |
| Exploit ScenarioDerived | A low-privileged authenticated YETI user (e.g. the 'analyst' role) sends POST /api/v2/tasks/export/new with a task name like '../../../../../../etc/passwd', then calls GET /api/v2/tasks/export/{export_id}/content to read files readable by the YETI service account - config files, database credentials, or JWT signing secrets. The same traversal, when the export task runs, writes attacker-controlled output to a writable path outside the export directory. A public, author-verified PoC for both read and write exists in the GHSA advisory (not packaged as weaponized exploit code); attack complexity is low (AC:L) and no user interaction is needed. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Nov 03, 2026
Authenticated path traversal in Yeti (YETI threat-intelligence platform) prior to 2.5.1 lets a low-privileged, non-admin user read and write arbitrary files as the service account. The ExportTask 'name' field is converted into a storage file name without stripping path separators or '..' segments, so a task named with traversal sequences is joined straight onto the configured local export directory; retrieving the export content returns the traversed file, and running the export writes attacker-controlled output to an attacker-chosen writable path. Exploitation requires a valid account (no admin role), the default local file storage backend, and service-account filesystem permissions on the target paths; universal code execution is not established, and no public exploit code or active exploitation is reported at time of analysis.
RemediationAI
Upgrade to YETI 2.5.1, the release that contains the fix, available from https://github.com/yeti-platform/yeti/releases/tag/2.5.1 and referenced in advisory GHSA-4q3w-w2g5-8wqq. The patch both sanitizes ExportTask.file_name (invalid characters replaced and the value reduced to a basename) and enforces path confinement in the local storage client by resolving the target and raising ValueError if it escapes the base directory; deploying it restores the boundary between a normal authenticated user and the server filesystem. Until upgrading, the mitigation supported by the evidence is to avoid the default local export storage backend and use a non-local backend, which removes the vulnerable path-joining code path; changing ExportTask names does not help, because users supply them. Run the YETI service account with the least filesystem privilege needed, since both the confirmed read and write impacts are bounded by those permissions, at the cost of limiting legitimate export and application file access. Per the advisory, updating is the complete fix; no other vendor workaround is described. Note that although the issue carries an RCE tag, universal code execution is not established per the advisory and the assessment.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
YETI is a Python/FastAPI threat-intelligence and DFIR platform backed by ArangoDB and Redis. The flaw is CWE-22 (path traversal) with the related CWE-73 (external control of file name or path). In core/schemas/task.py the ExportTask.file_name property derived the storage key from the user-supplied task name using only a whitespace-to-underscore replacement and lowercasing, leaving '/' and '..' intact. The default local storage client in core/clients/file_storage/classes/local_storage.py then built the destination with pathlib.Path.joinpath(), which performs no confinement, so the OS resolved the crafted name outside the export directory. Reads reach the filesystem via ExportTask.file_contents and GET /api/v2/tasks/export/{export_id}/content; writes reach it during ExportTask.run(). The upstream fix (PR #1280, commit bfd7c242) replaces invalid characters in file_name and reduces the result to a basename with pathlib.Path(...).name, and adds a resolve()-based check in the storage client that raises ValueError when the resolved target escapes the base directory, plus regression tests for traversal payloads. The trigger is straightforward API usage; the CVSS AC:L reflects that no race or special condition is needed, and the impact ceiling is set by the service account's permissions.
Know when Yeti gets its next vulnerability
- Watch products and get an email when something new is published
- Check this CVE against your own stack and servers
- Exploit and PoC references, threat intelligence from 22 sources
No credit card · 7-day full trial
Severity by source
AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:L
AV:N and AC:L because it is triggered via the REST API with no special conditions; PR:L because a low-privileged authenticated account is required; C:H/I:H from arbitrary read and write, A:L from possible corruption/DoS.
Primary rating from Vendor (GitHub_M).
CVSS VectorVendor: GitHub_M
DescriptionCVE.org
Yeti bridges the gap between CTI and DFIR practitioners by providing a Forensics Intelligence platform and pipeline. Prior to 2.5.1, YETI derives ExportTask.file_name from the user-controlled task name and passes it to core/clients/file_storage/classes/local_storage.py without sanitizing traversal sequences or enforcing path confinement. A low-privileged authenticated user using the default local storage backend can call POST /api/v2/tasks/export/new with a traversal name and use ExportTask.file_contents through GET /api/v2/tasks/export/{export_id}/content to read files accessible to the YETI service account. Running ExportTask.run() can also write attacker-controlled export output to an attacker-selected writable path. The impact depends on the service account's filesystem permissions, and universal code execution is not established. This issue is fixed in version 2.5.1.
Technical POC Analysis
CWE-22 (Improper Limitation of a Pathname to a Restricted Directory).
Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.
Executive ViewAI
Yeti, the threat-intelligence platform, contains a high-severity vulnerability (CVE-2026-63502) in versions prior to 2.5.1 that enables any authenticated non-admin user to read and write arbitrary files on the underlying server. This could allow a malicious insider or compromised low-privilege account to access sensitive data or tamper with critical system files, potentially disrupting intelligence operations and exposing confidential threat data. Leadership should prioritize patching because the platform handles sensitive security intelligence and the vulnerability is easy to exploit from within the network.
No vendor-released patch identified at time of analysis. Interim mitigations: restrict Yeti access to trusted networks, enforce least privilege for user accounts, monitor and alert on export task creation and file access, and consider switching to a non-local storage backend if feasible.
Threat Intelligence Overview
How this decision was reached
The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
Path traversal exploits occur when applications use user-controlled input to construct file system paths without proper validation.
Remote Code Execution represents the critical moment when an attacker successfully runs arbitrary code on a target system without physical access.
Yeti bridges the gap between CTI and DFIR practitioners by providing a Forensics Intelligence platform and pipeline. Rat
Authenticated AQL injection in YETI 2.5.0 and earlier lets any low-privileged analyst account push attacker-controlled s
Unauthenticated information disclosure in Yeti Platform (yeti-platform/yeti) before 2.5.1: the audit router is mounted o
Authenticated users with only read access can delete RBAC relationships in Yeti through 2.11.0, revoking owner grants an
Path traversal in YETI's DFIQ import/export pipeline allows a low-privileged authenticated user to write attacker-contro
EUVD-2026-116266
NVD
CVE.org
GitHub
Exploit-DB