CVEReports
CVEReports

Automated vulnerability intelligence platform. Comprehensive reports for high-severity CVEs generated by AI.

Product

  • Home
  • Sitemap
  • RSS Feed

Company

  • About
  • Contact
  • Privacy Policy
  • Terms of Service

© 2026 CVEReports. All rights reserved.

Made with love by Amit Schendel & Alon Barad



CVE-2026-45740

CVE-2026-45740: Uncontrolled Recursion in protobufjs Leading to Denial of Service

Alon Barad
Alon Barad
Software Engineer

May 19, 2026·6 min read·135 visits

Executive Summary (TL;DR)

protobufjs fails to enforce recursion limits during JSON parsing, allowing remote attackers to crash the Node.js process via deeply nested schema payloads.

An uncontrolled recursion vulnerability exists in the protobufjs library prior to versions 7.5.8 and 8.2.0. The lack of depth limits in the JSON descriptor parsing logic allows attackers to cause a stack overflow and crash the Node.js process via deeply nested payloads.

Vulnerability Overview

The protobufjs package is a widely used Node.js library responsible for compiling Protocol Buffer definitions into JavaScript functions. A fundamental weakness exists in how the library handles the expansion of nested JSON descriptors. Specifically, the parsing engine does not enforce limitations on the maximum nesting depth of input schemas.

This flaw is classified as CWE-674: Uncontrolled Recursion. The vulnerability resides within the Root.fromJSON() and Namespace.addJSON() methods. These methods traverse the properties of parsed JSON objects recursively to construct the final programmatic schema representation.

When a deeply nested JSON object is passed to these methods, the JavaScript engine allocates a new stack frame for each level of recursion. Because there is no artificial bound applied to this traversal, a malicious input can force the engine to exceed its maximum call stack size limit.

This vulnerability affects branches of the protobufjs library prior to version 7.5.8, as well as the 8.0.x release line prior to version 8.2.0. The primary impact is a Denial of Service (DoS) resulting from an unhandled RangeError exception that terminates the Node.js execution environment.

Root Cause Analysis

The vulnerability stems from the unconstrained recursive design of the JSON descriptor expansion logic. When protobufjs processes a JSON representation of a protobuf schema, it traverses the nested properties of the object to build the internal namespace hierarchy. This traversal relies on function calls that invoke one another synchronously.

During normal operation, Root.fromJSON(json) receives the initial input and passes the json.nested object to root.addJSON(). The addJSON method iterates over the keys of this nested object. For each key, it determines the appropriate constructor and invokes its respective fromJSON method, such as Namespace.fromJSON.

Inside Namespace.fromJSON, the code encounters further nested properties and calls addJSON again to process them. In vulnerable versions, the application maintained no state regarding the current depth of this call chain. The V8 engine enforces a strict limit on the number of synchronous frames on the call stack, typically around 10,000 frames depending on the environment.

The cyclical call between Namespace.fromJSON and namespace.addJSON continues unabated until the V8 engine aborts the operation. This architectural oversight exposes the application to resource exhaustion based entirely on the structure of the provided input.

Code Analysis

Prior to the patch, the Namespace.prototype.addJSON function accepted an object and iterated through it, calling the appropriate parsing functions without any depth context. The underlying fromJSON methods similarly lacked any parameters to track how far down the schema hierarchy the parser had traveled.

The maintainers addressed this in commit 9050289ad214ea351d3b030cbc74385e81e02d79 by introducing global limits that align with the default behavior of the official protoc compiler. They added util.recursionLimit = 100 for general namespace traversal and util.nestingLimit = 32 for message-level nesting.

The signatures of the parsing functions were updated to accept a depth parameter. The root entry points initialize this parameter to zero, and each recursive call increments it. The core mitigation logic validates this incremented value against the newly defined global limits.

// src/namespace.js (Patched)
Namespace.fromJSON = function fromJSON(name, json, depth) {
    // ... initialization ...
    if (json.nested) {
        // depth is passed and checked within addJSON
        namespace.addJSON(json.nested, depth);
    }
    return namespace;
};
 
Namespace.prototype.addJSON = function addJSON(nested, depth) {
    depth = depth || 0;
    if (depth > util.recursionLimit) {
        throw Error("max depth exceeded");
    }
    // ... recursively call child fromJSON methods with (depth + 1)
    for (var i = 0; i < keys.length; ++i) {
        // ...
        this.add(ctor.fromJSON(keys[i], nested[keys[i]], depth + 1));
    }
};

Exploitation

To exploit this vulnerability, an attacker must have a vector to supply an arbitrary JSON schema to the target application. This scenario is common in applications that dynamically generate protobuf configurations, accept schemas via API endpoints for validation, or process user-uploaded definition files.

The attacker constructs a specialized JSON payload containing a deeply nested hierarchical structure. Because the structure only requires empty nested objects, the payload size remains exceptionally small, making the attack highly efficient. The payload leverages the nested key to build a chain of objects that exceeds the target engine's stack limit.

Upon processing the malicious payload, the application enters the synchronous parsing loop. Because Node.js operates primarily on a single-threaded event loop, this synchronous exhaustion blocks all other operations. The V8 engine eventually throws a RangeError: Maximum call stack size exceeded exception.

const protobuf = require("protobufjs");
 
// Generate a deeply nested JSON descriptor
function generatePayload(depth) {
    let root = { nested: {} };
    let current = root.nested;
    for (let i = 0; i < depth; i++) {
        const name = "n" + i;
        current[name] = { nested: {} };
        current = current[name].nested;
    }
    return root;
}
 
// 2000 levels is sufficient to exhaust the V8 stack limit
const payload = generatePayload(2000); 
 
// Triggers the Denial of Service
protobuf.Root.fromJSON(payload);

Impact Assessment

The direct consequence of this vulnerability is an application crash. In the Node.js ecosystem, an unhandled RangeError originating from stack exhaustion causes the entire process to terminate immediately. This architecture amplifies the severity of the flaw compared to similar vulnerabilities in multi-threaded environments.

Process termination results in an immediate Denial of Service for all active and pending connections handled by the affected instance. If the application is managed by a process manager (such as PM2 or Kubernetes), the service will restart, but continuous submission of the malicious payload will result in a persistent outage condition known as a crash loop.

The National Vulnerability Database (NVD) assigned a base CVSS score of 5.3, categorizing the availability impact as Low. However, third-party security scanners frequently evaluate the availability impact as High, resulting in a CVSS score of 7.5. This higher rating accurately reflects the total loss of availability for the process processing the payload.

Applications that accept schemas from untrusted sources are at the highest risk. Systems that only compile static, developer-controlled .proto files during the build process are generally not exposed to runtime exploitation via this vector.

Remediation

Organizations must upgrade their protobufjs dependencies to incorporate the patch. The maintainers have released fixes in versions 7.5.8 and 8.2.0. Upgrading to these versions or higher ensures the parsing logic respects the newly introduced recursion depth limits.

If immediate patching is not feasible due to dependency constraints, developers must implement an input validation mechanism before passing untrusted JSON schemas to protobufjs. This mechanism involves creating a custom, iterative function to calculate the maximum depth of the JSON object.

The pre-validation function must operate without utilizing deep recursion to avoid triggering the very stack overflow it aims to prevent. Payloads exceeding a conservative depth threshold, such as 32 levels, should be rejected at the application boundary.

Security and operations teams should utilize dependency scanning tools to identify vulnerable configurations within their environments. Scanning package-lock.json or yarn.lock files for protobufjs versions prior to 7.5.8 or within the 8.0.0 to 8.1.9 range will isolate components requiring remediation.

Official Patches

GitHub Security AdvisoryOfficial GHSA Advisory
protobufjsPatch commit applying recursion limits

Fix Analysis (1)

Technical Appendix

CVSS Score
5.3/ 10
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:L
EPSS Probability
0.06%
Top 82% most exploited

Affected Systems

Node.js applications utilizing protobufjs < 7.5.8Node.js applications utilizing protobufjs 8.0.0 - 8.1.9

Affected Versions Detail

Product
Affected Versions
Fixed Version
protobufjs
protobufjs_project
< 7.5.87.5.8
protobufjs
protobufjs_project
>= 8.0.0, < 8.2.08.2.0
AttributeDetail
CWE IDCWE-674
Attack VectorNetwork-based
CVSS Base Score5.3 (NVD) / 7.5 (Scanners)
EPSS Score0.00058
ImpactDenial of Service (Process Crash)
Exploit StatusProof-of-Concept
KEV StatusNot Listed

MITRE ATT&CK Mapping

T1499.003Endpoint Denial of Service: Application Exhaustion
Impact
CWE-674
Uncontrolled Recursion

The product does not properly control the amount of recursion that takes place, consuming excessive resources, such as allocated memory or the program stack.

Known Exploits & Detection

Research ContextProof of Concept demonstrating process crash via 2000-level nested JSON structure
NucleiDetection Template Available

Vulnerability Timeline

Initial hardening of input handling in version 8.0.2 (PR #2143)
2026-04-27
Version 8.2.0 released with primary fixes
2026-05-09
GHSA-jggg-4jg4-v7c6 published and version 8.2.1 released
2026-05-13
CVE-2026-45740 published to the NVD
2026-05-13

References & Sources

  • [1]GitHub Security Advisory: GHSA-jggg-4jg4-v7c6
  • [2]Protobuf.js Changelog
  • [3]NVD CVE-2026-45740
  • [4]Fix Commit 9050289

Attack Flow Diagram

Press enter or space to select a node. You can then use the arrow keys to move the node around. Press delete to remove it and escape to cancel.
Press enter or space to select an edge. You can then press delete to remove it or escape to cancel.

More Reports

•about 11 hours ago•CVE-2026-53998
10.0

CVE-2026-53998: Format String Injection and Information Disclosure in Arize Phoenix applyChatTemplate

CVE-2026-53998 is a critical format string injection vulnerability in Arize Phoenix affecting versions 13.0.0 prior to 15.7.0. The flaw resides in the applyChatTemplate GraphQL endpoint, which passes user-supplied template strings directly to Python's native str.format() method via FStringTemplateFormatter._format. Because attribute access is not restricted, an attacker can traverse Python dunder attributes (__class__, __init__, __globals__) to read arbitrary process memory and environment variables, including the PHOENIX_SECRET cryptographic key and third-party API credentials.

Amit Schendel
Amit Schendel
7 views•9 min read
•about 12 hours ago•CVE-2026-63634
6.9

CVE-2026-63634: EVM Calldata Padding Gas Drainage in pympp Fee-Payer Verification

CVE-2026-63634 is an improper input validation vulnerability (CWE-20) in pympp, the official Python SDK for the Machine Payments Protocol (MPP) developed by tempoxyz. In versions prior to 0.9.1, servers acting as transaction fee payers validate incoming Ethereum Virtual Machine (EVM) transaction calldata using minimum-length thresholds rather than exact byte-length assertions. Because EVM smart contract dispatchers ignore trailing unparsed bytes while the protocol charges intrinsic gas for every byte in a transaction payload, an unauthenticated attacker can append thousands of non-zero padding bytes to legitimate payment requests. The server cosigns and broadcasts the oversized transaction, forcing the fee-payer wallet to expend inflated gas costs up to the policy limit and depleting its native token reserves.

Amit Schendel
Amit Schendel
5 views•11 min read
•about 13 hours ago•CVE-2026-14265
7.5

CVE-2026-14265: Remote Code Execution via Unsafe Deserialization in AWS Advanced JDBC Wrapper

CVE-2026-14265 (GHSA-c5q4-97jw-jggh) is a high-severity Remote Code Execution (RCE) vulnerability in the Amazon Web Services (AWS) Advanced JDBC Wrapper versions 3.3.0 through 4.0.0. The defect resides in the `RemoteQueryCachePlugin` and its underlying `CachedResultSet` implementation, which uses an unfiltered `java.io.ObjectInputStream` to deserialize cached SQL query results retrieved from external Redis or Valkey backends. An attacker with write access to the shared cache infrastructure can inject serialized Java gadget chains into cache keys, achieving arbitrary code execution within the JVM context of any application server consuming the cached entries.

Amit Schendel
Amit Schendel
6 views•10 min read
•about 14 hours ago•CVE-2026-63672
6.1

CVE-2026-63672: User-Controlled Identity Provider Selection in EGroupware SAML Authentication

CVE-2026-63672 is an open redirect and insecure Identity Provider (IdP) selection vulnerability in the SAML Single Sign-On (SSO) authentication module of EGroupware. In affected versions, the login method in api/src/Auth/Saml.php accepts an unauthenticated HTTP request parameter (idp) and passes it to the underlying SimpleSAMLphp library after only verifying that the string begins with https://. Because the input is not validated against the application's configured whitelist of trusted identity providers, an attacker can construct a malicious link that redirects authenticating users to an arbitrary, attacker-controlled SAML Identity Provider.

Amit Schendel
Amit Schendel
7 views•9 min read
•about 15 hours ago•CVE-2026-62336
8.5

CVE-2026-62336: Local Privilege Escalation via Symlink Following in qbee-agent

CVE-2026-62336 (GHSA-xhv5-8fpq-g7hf) is a high-severity local privilege escalation, arbitrary file overwrite, and denial-of-service vulnerability in qbee-agent, the client daemon for the qbee.io IoT device management platform. Prior to version 2026.27, the root-privileged agent failed to validate path components against symbolic links during directory creation and file opening operations in app/configuration/file_manager.go. Local unprivileged users can exploit this flaw by planting symlinks in user-controlled configuration paths or predictable temporary staging locations, causing the daemon to overwrite, truncate, or change ownership of sensitive root-owned system files.

Amit Schendel
Amit Schendel
5 views•10 min read
•about 16 hours ago•CVE-2026-110782
8.7

CVE-2026-110782: Cryptographic Signature Verification Bypass and Cross-IdP Impersonation in SimpleSAMLphp SAML2

CVE-2026-110782 is an authentication bypass and cryptographic signature verification failure in the SimpleSAMLphp SAML2 library (simplesamlphp/saml2). Resulting from an incomplete fix for CVE-2026-49283, the HTTP-Artifact binding implementation verifies the outer ArtifactResponse signature but unconditionally returns unsigned embedded SAML Responses without verifying signatures or validating that the embedded issuer matches the artifact issuer. In multi-IdP federation environments, an attacker controlling one trusted Identity Provider (IdP) can forge arbitrary identity assertions claiming to originate from another trusted IdP.

Amit Schendel
Amit Schendel
9 views•11 min read