/

CVE-2026-78181

Severity:

HIGH RISK

(7.3)

Prototype Pollution (CWE-1321) in Ractive#set Method

CVE-2026-78181

Deferred

Vulnerability type

Category:

Prototype Pollution

CWE:

CWE-94, CWE-1321

Impact:

Prototype Pollution and Potential Code Injection

Severity:

HIGH RISK

(7.3)

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

A high-severity prototype pollution vulnerability in Ractive's Ractive#set function can allow improperly controlled modification of JavaScript object prototype properties. If attacker-controlled key paths or update data reach the affected setter, a remote attacker may influence application behavior and potentially enable further security impact.

Affected context

The weakness affects Ractive applications using versions up to 1.4.4 where externally influenced data can be processed by the Ractive#set keypath handler. Risk depends on whether untrusted input reaches object-property updates without adequate key filtering, validation, or isolation. The associated CWE-94 classification reflects the possibility that prototype manipulation could contribute to later code-execution conditions in a vulnerable application context.

Exploit preconditions

  • Attack surface: Application code or a remotely reachable endpoint that invokes Ractive state updates
  • Required access: Ability to supply or influence values, property names, or key paths processed by Ractive#set
  • Trigger point: Handling of attacker-influenced object updates by the keypath handler
  • Why exploitation is possible: Insufficient controls may allow special prototype-related properties to be modified instead of treating them as ordinary application data

Why this happens

The underlying bug is an unsafe object-property update pattern in a JavaScript state-management API. When dynamic key paths are accepted without rejecting prototype-sensitive properties or validating the update structure, attacker-controlled data may alter inherited object behavior.

This maps primarily to CWE-1321: Improperly Controlled Modification of Object Prototype Attributes. In some application designs, altered prototypes can affect security-sensitive logic or create conditions associated with CWE-94: Improper Control of Generation of Code, although code execution is context-dependent rather than guaranteed by the prototype modification alone.

Potential impact

  • Application logic may be altered through inherited properties
  • Security checks or authorization decisions could be bypassed
  • Session, configuration, or data-processing behavior may be affected
  • Downstream code could execute unexpectedly if polluted properties reach dangerous sinks
  • The application may experience denial of service or data integrity issues

General mitigation guidance

Mitigation generally focuses on preventing untrusted data from controlling prototype-sensitive property updates.

Common defensive patterns include:

  • Rejecting prototype-related property names and unsafe key paths
  • Using schema-based allowlists for state updates
  • Treating external objects as untrusted and copying only approved fields
  • Using null-prototype dictionaries or equivalent isolated data structures where appropriate
  • Separating user-controlled data from executable, authorization, and configuration objects
  • Applying least privilege to affected application processes and limiting the impact of compromised state
  • Keeping dependency risk review and security testing integrated into normal maintenance workflows

These measures reduce exposure without relying solely on input escaping or assumptions about client-side behavior.

How teams detect issues like this

Detection approaches can include:

  • Static analysis rules for dynamic property assignment and unvalidated keypath processing
  • Code review checks for Ractive#set calls that consume request, message, or serialized data
  • Tests using prototype-sensitive property names to verify that updates are rejected or isolated
  • Runtime monitoring for unexpected changes to object prototypes or inherited properties
  • Dependency and software-composition analysis for affected Ractive versions
  • Policy enforcement requiring allowlisted schemas for externally supplied state changes

Automated code-review and security-scanning tools may help identify dangerous data flows, but findings should be validated against the application's actual reachability and object-handling patterns.

Sources

SourceLink
github.comgithub.com/ractivejs/ractive/
github.comgithub.com/ractivejs/ractive/issues/3448
vuldb.comvuldb.com/cve/CVE-2026-78181
vuldb.comvuldb.com/submit/884187
vuldb.comvuldb.com/vuln/394565
vuldb.comvuldb.com/vuln/394565/cti

Frequently asked

questions

It can be remotely reachable when an application exposes a path that lets untrusted users influence data processed by Ractive#set. Exploitability depends on the application's data flow and exposed endpoints.

Not necessarily. Authentication requirements depend on which routes or features pass user-controlled values to the affected function and whether those routes are publicly accessible.

Prevent untrusted input from controlling arbitrary key paths, use strict allowlisted schemas, and reject prototype-sensitive properties before state updates occur.

Combine dependency review, prototype-pollution-focused tests, static analysis, secure object construction, and code-review policies for dynamic property assignments.

Find out what's already
exploitable in your codebase.