Skip to main content

protobufjs CVE-2026-54269

| EUVDEUVD-2026-38307 MEDIUM
Uncontrolled Recursion (CWE-674)
2026-06-15 https://github.com/protobufjs/protobuf.js GHSA-f38q-mgvj-vph7
5.3
CVSS 3.1 · Vendor: https://github.com/protobufjs/protobuf.js
View

Attack ChainAIDerived

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

  1. Recon
    Attacker crafts schema with reserved field or method name
  2. Delivery
    Schema submitted to application accepting untrusted input
  3. Exploit
    Application loads schema via protobufjs JSON/reflection path
  4. Install
    Client triggers affected API path (verify/toObject/RPC invocation)
  5. C2
    Runtime reads schema data in place of internal helper
  6. Execute
    Deterministic exception or stack-exhausting recursion triggered
  7. Impact
    Denial of service on affected processing path

Vulnerability Assessment

Weakness
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Recursion depth limits
Exploitation Conditions

Exploitation requires all three of the following conditions to be satisfied simultaneously: (1) The application must run an unpatched version of protobufjs (7.x at or below 7.6.2, or 8.x between 8.0.0 and 8.5.0) or protobufjs-cli (1.x at or below 1.3.2, or 2.x between 2.0.0 and 2.5.0). (2) The application must load or use a schema or protobufjs JSON descriptor containing at least one of three specific reserved names: a field named exactly hasOwnProperty, a field or oneof named $type accessed through the JSON or reflection descriptor loading path (not static code generation), or a service method whose generated helper name is rpcCall. (3) The application must invoke the precise API path associated with the shadowed name - verify, toObject, or required-field decode post-checks for hasOwnProperty; reflected message JSON serialization for $type; or RPC service invocation for rpcCall. Applications using only trusted, internally-controlled schemas that do not contain these names are not exploitable regardless of patch status. The CVSS PR:N rating means no authentication is required from the attacker's perspective when the application accepts schemas from network-accessible external sources, but this attack vector only applies when untrusted schema loading is part of the application's design.

Impact

The vendor-assigned CVSS 3.1 score of 5.3 (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:L) accurately represents the worst-case network-accessible scenario where an application accepts untrusted schemas from external parties, but it overstates risk for the much more common deployment pattern of fully trusted, pre-compiled schemas. Real-world exploitability is gated behind three concurrent deployment conditions (unpatched version, schema containing a specific reserved name, and the application reaching the precise affected API path), which meaningfully narrows the practical attack surface beyond what the raw CVSS implies. No EPSS score was provided in the intelligence, so exploitation probability cannot be quantified. The vulnerability is not present in CISA KEV, and no public proof-of-concept exploit code has been identified, both of which indicate low current weaponization. The 'RCE' tag in the source metadata is erroneous and should be disregarded - the vendor advisory unambiguously states no code execution path is known. This is a genuine, addressable risk for multi-tenant or API-driven applications that dynamically load user-supplied or third-party protobuf schemas, but represents low operational urgency for applications operating exclusively with trusted, internally-controlled schemas.

Exploit ScenarioDerived

An attacker operating against a multi-tenant gRPC gateway that accepts user-supplied .proto schema files submits a service definition containing a method whose generated protobufjs helper resolves to rpcCall. When the gateway loads this schema and a client invokes the service, the runtime's RPC dispatch reads the schema-derived method value instead of the internal rpcCall base helper, triggering uncontrolled recursion that exhausts the call stack and crashes the affected service worker. No public proof-of-concept exploit code has been identified, but the deterministic nature of the failure - reproducible whenever the specific API path is reached with an affected schema - makes this straightforward to trigger once an attacker understands the three affected name categories.

This Month Plan within 30 days. Why: MEDIUM severity (CVSS 4.0-6.9).
Patch available 0.2% exploitation probability (EPSS)

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

Alert me

AnalysisAIv1 – Jun 15, 2026

Schema-name shadowing in protobufjs (npm packages protobufjs and protobufjs-cli) enables denial of service when an attacker can supply or influence protobuf schemas containing field or service method names that collide with JavaScript runtime-significant identifiers used by the protobufjs runtime. Affected names - specifically a field named hasOwnProperty, a field or oneof named $type via JSON/reflection descriptors, and service methods whose generated helper resolves to rpcCall - cause the runtime to read schema-controlled data in place of expected internal helpers, producing deterministic exceptions or uncontrolled recursion (CWE-674) across decode, verification, serialization, and RPC invocation paths. No public exploit has been identified and no active exploitation is confirmed; the misleading 'RCE' tag in the intelligence metadata is directly contradicted by the vendor advisory, which explicitly states the issue is not known to allow code execution.

RemediationAI

Upgrade protobufjs to version 7.6.3 (for the 7.x series) or 8.6.0 (for the 8.x series), and upgrade protobufjs-cli to version 1.3.3 (for the 1.x series) or 2.5.1 (for the 2.x series). These fix versions are confirmed by the vendor advisory at https://github.com/protobufjs/protobuf.js/security/advisories/GHSA-f38q-mgvj-vph7. If immediate upgrade is not feasible, the vendor-documented workaround is to reject untrusted schema input entirely - do not load protobuf schemas or protobufjs JSON descriptors from external or user-controlled sources until patched. If untrusted schemas must be accepted, implement pre-load validation that inspects field names, oneof names, and service method generated helper names and rejects any that match hasOwnProperty, $type, or rpcCall; note that this requires understanding protobufjs name-generation logic to enumerate all rpcCall-colliding method names. For applications using only trusted schemas, rename any fields, oneofs, or service methods using the problematic identifiers, or avoid invoking the affected API paths (verify, toObject, reflected JSON serialization, RPC invocation) on types containing those names as a compensating control - though this may limit application functionality.

Affected VersionsENISA

protobuf.js 8.0.0, < 8.6.0
protobuf.js < 7.6.3

Affected Packages

npm protobufjs fix: 7.6.3, 8.6.0
npm protobufjs-cli fix: 1.3.3, 2.5.1
euvd protobuf_js fix: 7.6.3, 8.6.0

Source: OSV (Open Source Vulnerabilities)

Affects your stack

Affects 3 packages in npm, euvd

Checking this CVE against your own stacks and servers is part of the Basic plan and up.

Technical ContextAI · show details

protobufjs (pkg:npm/protobufjs) is the canonical JavaScript/TypeScript implementation of Protocol Buffers for Node.js and browser environments. The library generates runtime objects and service stubs from schema definitions, attaching internal helpers such as hasOwnProperty (inherited from Object.prototype), $type (reflected type metadata used in JSON serialization), and rpcCall (base RPC service helper) directly onto generated message and service objects. JavaScript's prototype-based property lookup means that if a schema defines a field or method using one of these reserved names, the generated object's own-property assignment shadows the prototype-chain or runtime-assigned helper. When protobufjs subsequently attempts to call what it believes is an internal utility, it instead invokes or reads the schema-derived value, causing either a TypeError (if the value is not callable) or recursive self-invocation leading to stack exhaustion - the class of failure described by CWE-674 (Uncontrolled Recursion). The vulnerability surfaces in verify, toObject, required-field decode post-checks, reflected JSON serialization, and RPC service invocation. Companion package protobufjs-cli (pkg:npm/protobufjs-cli) is also affected because it performs schema loading and code generation using the same library.

Know when the next one hits your stack

  • 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 (https://github.com/protobufjs/protobuf.js) PRIMARY 5.3 MEDIUM
AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:L
vuln.today AI 5.3 MEDIUM

Network-reachable schema injection requires no authentication; availability impact is partial and scoped to the affected API processing path only, with no confidentiality or integrity impact.

3.1 AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:L
4.0 AV:N/AC:L/AT:P/PR:N/UI:N/VC:N/VI:N/VA:L/SC:N/SI:N/SA:N
Red Hat 5.3 LOW

Primary rating from Vendor (https://github.com/protobufjs/protobuf.js).

CVSS VectorVendor: https://github.com/protobufjs/protobuf.js

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

DescriptionCVE.org

Summary

protobufjs accepted certain schema-derived names that could collide with properties used by protobufjs runtime helpers. The known affected names are fields named hasOwnProperty, field or oneof names such as $type when loaded through protobufjs JSON/reflection descriptors, and service methods whose generated helper name is rpcCall.

When affected message or service types were used, protobufjs could read schema-controlled data where it expected an own-property helper, reflected type metadata, or the base RPC helper. This could cause deterministic exceptions or recursive calls in affected decode post-checks, verification, object conversion, reflected JSON serialization, or protobufjs RPC helper invocation.

Impact

An attacker who can provide or influence protobuf schemas or protobufjs JSON descriptors may be able to make affected message or service types unusable, resulting in denial of service for the affected processing path.

Applications using only trusted schemas are affected only if those schemas contain one of the problematic names and the application reaches the affected API path.

The issue is not known to allow code execution by itself.

Preconditions

  • The application must use an affected protobufjs version.
  • The application must load or use a schema or protobufjs JSON descriptor containing one of the problematic names:
  • a field named hasOwnProperty,
  • a field or oneof named $type through protobufjs JSON/reflection descriptor input,
  • or a service method whose generated helper name is rpcCall.
  • The application must reach the affected API path for that name: required-field decode post-checks, verify, or toObject for hasOwnProperty; reflected message JSON serialization for $type; or protobufjs RPC service invocation for rpcCall.

Workarounds

Do not load protobuf schemas or protobufjs JSON descriptors from untrusted sources with affected versions. If untrusted schemas or descriptors must be accepted, validate schema-derived field, oneof, and service method names before loading and reject the problematic names described above.

Applications using trusted schemas can avoid the issue by renaming affected fields or service methods, or by avoiding the affected API path.

Blast Radius

ecosystem impact
† from your stack dependencies † transitive graph · vuln.today resolves 4-path depth
  • 1,832 npm packages depend on protobufjs (158 direct, 1,675 indirect)

Ecosystem-wide dependent count for version 8.0.0.

Threat Intelligence Overview

EPSS Score
0.2%
Top 85% exploitable
Threat Intel
1
1 source
Exploit
POC
Public exploit code exists
Data Quality
7 sources
Confidence: High
EUVD NVD CVE.org EPSS Vulnrichment GHSA Vendor GitHub

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 MEDIUM
CISA KEV No
Public POC Yes
EPSS 0.2%
Patch available Yes
Active threat No
Deciding rule
MEDIUM severity (CVSS 4.0-6.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
None
System Exposure· derived
Open
Automatable
Yes
Human Impact· derived
Medium
Technical Impact
Partial

Priority Score

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

Attack Technique

Remote Code Execution represents the critical moment when an attacker successfully runs arbitrary code on a target system without physical access.

Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.

Vendor StatusVendor

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