Six vulnerabilities discovered in protobuf.js could allow attackers to execute arbitrary code, crash services, and compromise software supply chains across cloud, AI, messaging, and development environments.
According to Cyera researchers, the flaws affect the widely used JavaScript implementation of Google’s Protocol Buffers, a data serialization framework that underpins communication across countless distributed systems.
The library receives more than 50 million weekly downloads and is embedded directly or indirectly in many enterprise applications.
We “… found six vulnerabilities in [protobuf] that let attackers achieve remote code execution or denial of service by poisoning schema-derived data,” said Cyera researcher Vladimir Tokarev in his analysis.
Key Takeaways
- Six vulnerabilities in protobuf.js could enable remote code execution, denial-of-service attacks, prototype pollution, and code injection.
- The flaws affect a library with more than 50 million weekly downloads that is widely used across cloud services, AI platforms, CI/CD pipelines, and messaging applications.
- Researchers demonstrated real-world attack scenarios, including CI/CD compromise, persistent WhatsApp bot crashes, and service disruptions in Google Cloud Functions.
- Organizations should upgrade to patched versions immediately and review both direct and transitive dependencies for vulnerable instances.
Inside the protobuf.js Vulnerabilities
The vulnerabilities affect protobuf.js versions 7.5.5 and earlier, as well as versions 8.0.0 and 8.0.1.
Collectively, the six flaws create exposure to remote code execution (RCE), denial-of-service (DoS), prototype pollution, and code injection attacks.
The findings are concerning because protobuf.js is often introduced as a transitive dependency, meaning organizations may rely on the library without directly installing or tracking it.
Cyera noted that protobuf.js appears in widely used technologies such as Google Cloud client libraries, OpenTelemetry, Milvus, Temporal, and popular messaging frameworks, expanding the potential attack surface.
At the center of the issue is how protobuf.js handles schema-related inputs.
Field names, type names, descriptors, and configuration values were treated as trusted metadata, even though they could be influenced by attackers in some environments.
How Attackers Could Exploit protobuf.js
One of the more concerning issues is CVE-2026-44295, a code injection flaw in the pbjs command-line tool.
Attackers can craft malicious schema names that are written into generated JavaScript files during code generation.
If those files are later imported during a build, test, or deployment process, the injected code can run inside a trusted CI/CD environment, potentially exposing source code, signing certificates, cloud credentials, and other sensitive assets.
Researchers also identified a prototype pollution attack chain that could lead to remote code execution (RCE).
In vulnerable environments, attackers could abuse prototype pollution elsewhere in a Node.js application and use protobuf.js as a code-execution gadget.
Because protobuf.js dynamically creates JavaScript functions with the Function() constructor, attacker-controlled values could be incorporated into generated code and executed by the application.
Denial-of-Service (DoS) Risk
The research also uncovered denial-of-service risks that could disrupt production services.
One flaw allows attackers to send deeply nested recursive protobuf messages that exhaust the JavaScript call stack during decoding.
Cyera demonstrated this against WhatsApp bots built on the Baileys framework, where a single malicious message could force a bot into a persistent crash-and-restart loop.
Researchers reproduced similar behavior against Google Cloud Functions processing protobuf-based Pub/Sub events, showing how one malicious payload could repeatedly trigger service failures until it is manually removed or routed to a dead-letter queue.
Together, the findings show how vulnerabilities in a widely used serialization library can ripple across cloud infrastructure, AI systems, software supply chains, and customer-facing services.
How to Mitigate protobuf.js Risks
Because protobuf.js is often deployed indirectly through third-party dependencies, organizations should review their environments carefully and implement additional safeguards to limit the risk of code execution, service disruption, and supply chain compromise.
- Upgrade to the latest protobuf.js version and audit both direct and transitive dependencies for vulnerable instances.
- Prioritize patching internet-facing services, APIs, message queues, and applications that process untrusted protobuf payloads.
- Treat all externally sourced .proto files, JSON descriptors, and schema registries as untrusted input, and validate or allowlist approved schemas before use.
- Reduce exposure to code-generation risks by preferring build-time schema compilation, restricting dynamic schema loading, and hardening CI/CD pipelines that use pbjs.
- Enforce message size, recursion depth, and input validation controls to prevent denial-of-service attacks caused by malformed or deeply nested protobuf messages.
- Monitor for decoding failures, repeated service crashes, unusual schema activity, and indicators of prototype pollution attempts across Node.js environments.
- Test incident response and recovery plans to ensure teams can identify, contain, and remediate protobuf-related attacks or service disruptions.
These measures can help reduce the risk of exploitation and improve overall resilience.
Expanding the Attack Surface
As organizations rely more heavily on schemas, metadata, automation, and AI-generated code, security teams need to treat these inputs as part of the overall attack surface.
Cyber resilience depends on understanding where trusted data flows through critical systems and implementing guardrails before that data can influence application behavior.
As this case demonstrates, vulnerabilities in trusted dependencies can quickly cascade across entire ecosystems, making software supply chain security an important priority for security teams.