/

CVE-2026-78654

Severity:

HIGH RISK

(7.3)

Prototype Pollution (CWE-1321) in Deep Framework Code

CVE-2026-78654

Deferred

Vulnerability type

Category:

Prototype Pollution

CWE:

CWE-94, CWE-1321

Impact:

Remote application compromise and potential code execution

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 prototype pollution vulnerability in the Deep framework's deepExtend function allows remotely supplied data to modify object prototype attributes. In affected applications, this may alter application behavior and could enable further attacks when polluted properties are trusted by security-sensitive code.

Affected context

The vulnerability occurs in applications using the Deep framework or its associated deep package through affected versions of the deepExtend implementation. Risk is higher when remotely controlled objects are passed to the merge or extension function and resulting properties influence authorization, execution, configuration, or other security-sensitive behavior.

Exploit preconditions

  • Attack surface: An application endpoint, message handler, or other remote interface that accepts structured object data
  • Required access: The ability to submit or influence input processed by deepExtend
  • Trigger point: Recursive object extension or merging involving attacker-controlled properties
  • Why exploitation is possible: The implementation does not sufficiently restrict writes to special object prototype attributes, allowing input data to affect shared object behavior

Why this happens

The underlying bug is an unsafe object-merging pattern that permits attacker-controlled keys to modify prototype attributes. This maps primarily to CWE-1321: Improperly Controlled Modification of Object Prototype Attributes, commonly known as prototype pollution. In some application contexts, polluted properties may influence dynamic execution paths or unsafe sinks, creating a relationship to CWE-94: Improper Control of Generation of Code.

Potential impact

  • Application logic may be altered through inherited polluted properties
  • Authorization or validation checks could be bypassed
  • Requests or configurations may be manipulated unexpectedly
  • Availability could be affected through widespread object corruption
  • Downstream unsafe code paths could potentially result in code execution

General mitigation guidance

Mitigation generally focuses on preventing untrusted object keys from reaching recursive merge operations and reducing the trust placed in inherited properties.

Common defensive patterns include:

  • Rejecting or neutralizing prototype-related keys during object merging
  • Using allowlisted schemas and narrowly scoped merge functions
  • Preferencing null-prototype dictionaries or immutable data structures for untrusted records
  • Avoiding dynamic evaluation and other code-generating sinks
  • Validating security-sensitive values as own properties with explicit types
  • Running affected application components with least privilege and restricted access

How teams detect issues like this

Organizations can detect prototype pollution risks through:

  • Static analysis rules for recursive merge, deep extension, and dynamic property assignment patterns
  • Code review checks for writes involving prototype-related keys
  • Tests that submit nested objects containing reserved property names and verify prototype isolation
  • Dependency and software composition analysis for vulnerable object-manipulation libraries
  • Runtime monitoring for unexpected changes to shared object behavior or security-relevant properties
  • Policy enforcement requiring schema validation and approved merge utilities for externally supplied objects

Sources

SourceLink
github.comgithub.com/cleverbrush/framework/
github.comgithub.com/cleverbrush/framework/commit/810398c1308c500c3b8b6af380b5a89371389327
github.comgithub.com/cleverbrush/framework/issues/213
github.comgithub.com/cleverbrush/framework/pull/215
github.comgithub.com/cleverbrush/framework/releases/tag/%40cleverbrush/async%404.4.1
vuldb.comvuldb.com/cve/CVE-2026-78654
vuldb.comvuldb.com/submit/886401
vuldb.comvuldb.com/vuln/394866
vuldb.comvuldb.com/vuln/394866/cti

Frequently asked

questions

Yes, where an application exposes a remote input path that passes attacker-controlled objects to the vulnerable deep-extension logic.

Not necessarily. The required access depends on the application endpoint and its authorization controls; an unauthenticated input path would increase exposure.

Prevent untrusted keys from modifying prototypes, use allowlisted schemas and merge behavior, and ensure security-sensitive logic does not rely on inherited properties.

Combine dependency governance with static analysis, security-focused tests for object merging, strict input validation, and least-privilege runtime controls.

Find out what's already
exploitable in your codebase.