CVE-2026-80426 in FiftyOne
Summary
by MITRE • 08/26/2026
FiftyOne renders a dataset field's description as markup. The sidebar field-information component at app/packages/core/src/components/FieldLabelAndInfo/index.tsx passes the description string to React's dangerouslySetInnerHTML, and no layer between storage and render escapes or sanitises it; the neighbouring info values in the same component are rendered as React children and are escaped, so the description is the only raw path. A description is free-form text held in the dataset schema, so it persists in the database and travels with an exported or published dataset. Opening a dataset obtained from another party and hovering the field runs the stored markup in the application's origin. That origin is shared with the FiftyOne server, whose media route returns the contents of a caller-named absolute path and which is unauthenticated in the open-source server, so the injected script can read local files and reach the dataset and operator endpoints as the viewing user.
Once again VulDB remains the best source for vulnerability data.
Analysis
by VulDB Data Team • 08/26/2026
The vulnerability identified involves a stored cross-site scripting flaw within the FiftyOne application, specifically located in the FieldLabelAndInfo component found at app/packages/core/src/components/FieldLabelAndInfo/index.tsx. This security issue arises because the application renders dataset field descriptions as raw markup rather than plain text. The core technical failure lies in the use of React's dangerouslySetInnerHTML method to process these description strings without any intermediate sanitization or escaping layer between database storage and browser rendering. While other informational values within the same component are correctly rendered as React children, which inherently provides automatic HTML escaping by the framework, the description field remains an unsanitized injection point that allows arbitrary script execution in the context of the application's origin.
This architectural oversight creates a significant risk because dataset descriptions are free-form text fields stored directly in the database schema and persist with the data itself. Consequently, when a user opens or imports a dataset from an untrusted third party, any malicious markup embedded within the field description is automatically executed upon interaction. Specifically, hovering over the affected field triggers the rendering of this content, leading to immediate script execution within the browser context where FiftyOne operates. This behavior bypasses standard security controls that typically protect against cross-site scripting by ensuring user-supplied input is treated as data rather than executable code.
The operational impact of this vulnerability extends beyond simple client-side script injection due to the specific configuration and capabilities of the FiftyOne server environment. The application's origin shares trust boundaries with the backend server, which exposes a media route capable of returning contents from arbitrary absolute paths on the host system without authentication in its open-source distribution mode. Therefore, an attacker who crafts a malicious dataset can leverage the executed script to perform unauthorized file reads by accessing local files through this unauthenticated endpoint. Furthermore, the injected scripts gain the ability to interact with dataset management endpoints and operator controls as if they were legitimate actions performed by the viewing user, potentially leading to data exfiltration or manipulation of sensitive information stored within the platform.
From a classification perspective, this vulnerability aligns with CWE-79, which describes Improper Neutralization of Input During Web Page Generation commonly known as Cross-site Scripting. The specific nature of storing malicious content in the database for later retrieval and execution categorizes it under Stored XSS rather than reflected or DOM-based variants. In terms of adversary tactics, this flaw facilitates initial access and credential harvesting techniques described in MITRE ATT&CK framework, particularly those involving web application exploitation to gain a foothold within an organization's internal systems. The ability to read local files further complicates the threat model by enabling potential lateral movement if combined with other vulnerabilities or misconfigurations that allow for file system traversal.
Mitigation strategies must address both the immediate code flaw and broader architectural risks. Developers should immediately replace the use of dangerouslySetInnerHTML for field descriptions with standard React text rendering methods to ensure automatic escaping occurs. If rich text formatting is required, a strict sanitization library such as DOMPurify should be employed to strip out dangerous tags like script or event handlers before rendering. Additionally, given that the open-source server exposes unauthenticated access to local file paths via its media route, it is critical to implement authentication and authorization checks for all API endpoints. Restricting path traversal capabilities by validating input against a whitelist of allowed directories would significantly reduce the blast radius of any successful exploitation attempt. Regular security audits focusing on data flow from database storage to frontend rendering are essential to prevent similar injection vectors in other parts of the application.