/

CVE-2026-80426

Severity:

HIGH RISK

(7.1)

Stored XSS (CWE-79) in FiftyOne Field Descriptions

CVE-2026-80426

Deferred

Vulnerability type

Category:

Stored Cross-Site Scripting

CWE:

CWE-79

Impact:

Stored Cross-Site Scripting, data disclosure, and unauthorized actions

Severity:

HIGH RISK

(7.1)

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

FiftyOne renders dataset field descriptions as raw HTML without escaping or sanitization, creating a stored cross-site scripting vulnerability.

An attacker who can influence a dataset schema may cause script content to execute when another user views the dataset, potentially exposing data and making requests with that user's application privileges.

Affected context

The issue occurs in FiftyOne's field-information sidebar, where a free-form dataset field description is passed directly to React's dangerouslySetInnerHTML. The description may persist in the database and travel with exported or published datasets. Risk is greatest when a user opens a dataset from an untrusted or insufficiently trusted source and views the affected field in an application origin that can access server and dataset functionality.

Exploit preconditions

  • Attack surface: The dataset field-description rendering path in the FiftyOne web application
  • Required access: The ability to create, modify, publish, or otherwise supply a dataset containing a crafted field description
  • Trigger point: A target user opens the dataset and views or hovers over the affected field so the sidebar renders its description
  • Why exploitation is possible: The description reaches dangerouslySetInnerHTML without an escaping or sanitization layer, allowing markup containing executable browser content to run in the viewer's application origin
  • Additional exposure: Where server routes and permissions allow it, the running script may be able to access data or invoke application endpoints available to the viewing user

Why this happens

The vulnerability is caused by treating a user-controlled, persisted text field as trusted markup. Unlike neighboring values rendered as React children, the field description is inserted through dangerouslySetInnerHTML without contextual output encoding or sanitization. This is a classic CWE-79: Improper Neutralization of Input During Web Page Generation, commonly known as cross-site scripting. The insecure pattern is allowing stored content to cross a trust boundary and become executable browser markup.

Potential impact

  • A malicious dataset description could execute script in the application's origin.
  • An attacker could potentially access dataset information available to the viewer.
  • The injected code could make requests using the viewing user's authenticated or otherwise authorized application context.
  • Local files or server endpoints could be exposed where accessible routes and permissions permit it.
  • Dataset integrity, operator actions, or session confidentiality could be affected.

General mitigation guidance

Mitigation generally centers on keeping dataset descriptions as data rather than executable markup.

Common defensive patterns include:

  • Render descriptions as escaped text by default instead of using raw HTML insertion.
  • If formatted markup is a required feature, apply a well-maintained allowlist sanitizer immediately before rendering.
  • Restrict permitted elements, attributes, URL schemes, and event-handler content according to the intended display format.
  • Reduce trust in imported and published dataset metadata, and preserve its untrusted status across storage and export boundaries.
  • Apply least privilege to server routes, separate media access from sensitive filesystem paths, and require appropriate authorization for dataset and operator operations.
  • Use browser isolation controls such as a restrictive Content Security Policy as defense in depth.

How teams detect issues like this

Detection approaches can include:

  • Static analysis rules that flag dangerouslySetInnerHTML and equivalent raw HTML sinks fed by dataset, metadata, or user-controlled values.
  • Code review checks tracing field descriptions from storage, import, or publication paths through to browser rendering.
  • Tests containing benign markup and script-like event attributes to verify that untrusted descriptions are escaped or sanitized.
  • Policy enforcement requiring an approved sanitizer and documented allowlist whenever rich text rendering is unavoidable.
  • Runtime monitoring for unexpected script execution, unusual dataset-origin requests, or access to sensitive endpoints following dataset viewing.
  • Automated security review tools may help identify raw HTML sinks, but data-flow validation remains important.

Sources

SourceLink
github.comgithub.com/voxel51/fiftyone
github.comgithub.com/voxel51/fiftyone/blob/v1.20.1/app/packages/core/src/components/FieldLabelAndInfo/index.tsx
github.comgithub.com/voxel51/fiftyone/pull/8117
github.comgithub.com/voxel51/fiftyone/releases/tag/v1.21.0
vulncheck.comvulncheck.com/advisories/fiftyone-before-1.21.0-stored-cross-site-scripting-via-unescaped-field-description

Frequently asked

questions

It can affect users remotely when an attacker can provide or publish a dataset containing a crafted field description and a target user opens that dataset. The attacker does not necessarily need direct access to the target's browser or server.

The key requirement is the ability to influence a persisted dataset field description, such as through dataset creation, modification, import, or publication. The target must then view the affected field in the vulnerable application.

Treat field descriptions as plain text and let the framework escape them during rendering. If trusted rich text is necessary, sanitize it with a strict allowlist immediately before insertion into the DOM.

Track untrusted data from storage and dataset imports to browser sinks, prohibit raw HTML rendering by default, test imported metadata as hostile input, and enforce least-privilege access for server and media routes.

Find out what's already
exploitable in your codebase.