Skip to main content

Yeti Platform EUVDEUVD-2026-116266

| CVE-2026-63502 HIGH
Path Traversal (CWE-22)
2026-11-03 GitHub_M
8.3
CVSS 3.1 · Vendor: GitHub_M
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Authenticate with low-privileged account
  2. Delivery
    POST export task with traversal name
  3. Exploit
    unsanitized file_name joined in local_storage
  4. Execution
    GET export content reads service-account-readable file
  5. Impact
    Exfiltrate 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.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
No patch listed yet

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – 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

yeti ≤ 2.5.0

Affected Packages

euvd yeti no fix

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

Vendor (GitHub_M) PRIMARY 8.3 HIGH
AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:L
vuln.today AI 8.3 HIGH

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.

3.1 AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:L
4.0 AV:N/AC:L/AT:N/PR:L/UI:N/VC:H/VI:H/VA:L/SC:N/SI:N/SA:N

Primary rating from Vendor (GitHub_M).

CVSS VectorVendor: GitHub_M

Attack Vector
Network
Attack Complexity
Low
Privileges Required
Low
User Interaction
None
Scope
Unchanged
Confidentiality
High
Integrity
High
Availability
Low

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

Why It Matters

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.

Business Impact: High
Compensating Controls

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

Prevalence
Low
niche open-source CTI/DFIR threat-intel platform, specialist security-team footprint
Data Quality
3 sources
Confidence: Low

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.

SignalValue
Severity HIGH
CISA KEV No
Public POC No
EPSS N/A
Patch available No
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision· derived
Scheduled
Exploitation· derived
None
System Exposure· derived
Open
Automatable· derived
No
Human Impact
High

Priority Score

42
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +42
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

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.

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy