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-44643

CVE-2026-44643: Sandbox Escape and Remote Code Execution in angular-expressions

Amit Schendel
Amit Schendel
Senior Security Researcher

May 11, 2026·5 min read·130 visits

Executive Summary (TL;DR)

A critical sandbox escape in angular-expressions < 1.5.2 allows RCE via prototype traversal in malicious filter definitions.

CVE-2026-44643 is a critical sandbox escape vulnerability in the peerigon/angular-expressions library. The flaw permits unauthenticated remote code execution via prototype traversal and improper validation of filter expressions. By crafting specific malicious inputs, attackers can access the global Function constructor.

Vulnerability Overview

The peerigon/angular-expressions library provides a standalone implementation of AngularJS expressions for Node.js and browser environments. The component relies on a dedicated sandbox mechanism to parse and evaluate user-supplied string expressions safely. This design restricts access to global objects, preventing standard JavaScript primitives from executing within the host context.

The vulnerability identified as CVE-2026-44643 constitutes an Eval Injection flaw (CWE-95). The breakdown occurs within the expression parsing logic, specifically where property access boundaries for filters are established. Attackers exploit this boundary failure by supplying carefully structured string expressions that traverse the JavaScript prototype chain.

Successful exploitation results in immediate, unauthenticated remote code execution. Systems evaluating untrusted input through the library are highly exposed, resulting in a CVSS 4.0 score of 9.3. The impact is particularly severe in backend Node.js environments where access to the process object grants comprehensive system control.

Root Cause Analysis

The root cause of the vulnerability is the insufficient validation of property access during the resolution of expression filters. The parser evaluates expression strings and dynamically looks up properties to apply the required filter logic. Prior to version 1.5.2, the compiler did not consistently require hasOwnProperty validation checks on the target objects.

This lack of strict property enforcement facilitates prototype traversal. Attackers construct payloads that reference the __proto__ or constructor attributes of the objects being evaluated. The parser processes these attributes sequentially, ascending the prototype chain instead of restricting lookups to the object's own properties.

Reaching the top of the prototype chain provides the attacker with a reference to the global Function constructor. The Function constructor dynamically generates and executes JavaScript code from raw string inputs. Invoking this constructor bypasses the library's intended containment, allowing interaction with the host environment and native Node.js libraries.

Code Analysis and Patch Review

In vulnerable versions, the files lib/parse.js and lib/main.js handled object property lookups directly without verifying ownership. The parser permitted expressions to navigate through the filter object and retrieve properties inherited from Object.prototype. This architectural decision left the constructor property entirely exposed during evaluation.

The remediation introduced in version 1.5.2 implements several structural hardening techniques. The primary defense is the introduction of a bounded hasOwn function replacing standard property lookups. This utility strictly calls Object.prototype.hasOwnProperty.call, preventing attackers from overriding or bypassing the check by mutating the evaluated object.

// Conceptual representation of the fix in lib/parse.js
// Before Patch
if (obj[key]) { return obj[key]; }
 
// After Patch
const hasOwn = Function.prototype.call.bind(Object.prototype.hasOwnProperty);
if (hasOwn(obj, key)) { return obj[key]; }

Additionally, the patch alters how the filter registry is instantiated. The registry is now initialized using Object.create(null). This creates a null-prototype object, effectively stripping the __proto__ and constructor properties from the root filter context. The ASTCompiler was also modified to detect and block explicit prototype traversal syntaxes.

Exploitation Methodology

Exploitation requires the application to pass user-controlled strings into the angular-expressions evaluation function. The attacker embeds a malicious payload within standard AngularJS filter syntax. The payload appears syntactically valid to the parser but logically forces the evaluation engine to navigate the object tree.

A functional exploit payload uses consecutive constructor calls to step outside the sandbox constraints. The following string demonstrates the bypass mechanism:

"1 | filter: 'constructor.constructor(\"return process\")().mainModule.require(\"child_process\").execSync(\"id\")()'"

When the parser processes this string, the filter lookup resolves the constructor of the filter function itself. The second constructor call accesses the global Function constructor. The attacker passes "return process" to retrieve the active Node.js process object, subsequent calls require the child_process module, and finally invoke execSync to execute arbitrary operating system commands.

Impact Assessment

The execution of arbitrary code via this vulnerability completely compromises the host application. The attacker executes instructions with the privileges of the underlying Node.js process. This level of access typically permits the extraction of sensitive environment variables, database connection strings, and application configuration files.

The CVSS v4.0 vector (CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N) reflects the critical severity of the flaw. The attack vector is strictly network-based, requires no special privileges, and functions independently of user interaction. The impact metrics for confidentiality, integrity, and availability are fully maximized.

In containerized or cloud-native environments, the compromised Node.js process can serve as a staging point for lateral movement. The attacker utilizes standard post-exploitation techniques to pivot into internal networks or cloud service metadata endpoints.

Remediation and Mitigation

The primary remediation step is upgrading the angular-expressions dependency to version 1.5.2 or later. This patch fundamentally alters the object property lookup mechanism and removes the prototype chain from the filter registry. Applying this update neutralizes the known exploitation vectors immediately.

If immediate patching is unfeasible, administrators must apply runtime mitigations. Node.js applications should be executed with the --disable-proto=delete flag. This command-line argument globally disables __proto__ mutations across the runtime, significantly degrading the reliability of prototype-based sandbox escapes.

Developers must implement stringent input validation on any strings passed to the expression evaluator. The application layer should reject inputs containing keywords explicitly associated with traversal or code execution, such as constructor, __proto__, Function, or eval. Defense-in-depth measures, including rigorous Content Security Policies (CSP), restrict the execution scope even if an escape occurs.

Official Patches

peerigonCommit diff between 1.5.1 and 1.5.2

Technical Appendix

CVSS Score
9.3/ 10
CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N

Affected Systems

Node.js environments utilizing peerigon/angular-expressionsBrowser applications relying on client-side expression evaluation

Affected Versions Detail

Product
Affected Versions
Fixed Version
angular-expressions
peerigon
< 1.5.21.5.2
AttributeDetail
CWE IDCWE-95
CVSS v4.09.3
Attack VectorNetwork
ImpactRemote Code Execution (RCE)
Privileges RequiredNone
CISA KEV StatusNot Listed

MITRE ATT&CK Mapping

T1190Exploit Public-Facing Application
Initial Access
T1059.007Command and Scripting Interpreter: JavaScript
Execution
CWE-95
Eval Injection

Improper Neutralization of Directives in Dynamically Evaluated Code ('Eval Injection')

Vulnerability Timeline

Vulnerability published and CVE-2026-44643 assigned
2026-05-11
GitHub Advisory GHSA-pw8r-6689-xvf4 released
2026-05-11
Fixed version 1.5.2 released by Peerigon
2026-05-11

References & Sources

  • [1]GitHub Security Advisory GHSA-pw8r-6689-xvf4
  • [2]NVD Record for CVE-2026-44643
  • [3]angular-expressions GitHub Repository

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 2 hours ago•CVE-2026-71861
7.4

CVE-2026-71861: Authentication Bypass via Unsigned Binding Headers in Chainguard Go SDK

CVE-2026-71861 (GHSA-wq26-3j2m-4hvv) is a high-severity authentication bypass and cryptographic signature-binding replay vulnerability in the Chainguard Go SDK (chainguard.dev/sdk / github.com/chainguard-dev/sdk) affecting versions prior to v0.1.107. The vulnerability resides in the auth/aws.VerifyToken function, which validates AWS STS GetCallerIdentity requests signed with AWS Signature Version 4 (SigV4) to authenticate AWS workloads. Prior to version v0.1.107, VerifyToken verified the values of custom HTTP binding headers (Chainguard-Audience and Chainguard-Identity) without confirming that those headers were listed in the SigV4 SignedHeaders parameter of the Authorization header. Because AWS STS ignores unsigned headers when recomputing and verifying the SigV4 signature, an attacker who captures any valid, fresh SigV4-signed STS GetCallerIdentity request from a victim AWS principal can inject or overwrite the Chainguard-Audience and Chainguard-Identity headers and replay the token to bypass authentication and impersonate the victim identity.

Alon Barad
Alon Barad
3 views•11 min read
•about 3 hours ago•CVE-2026-73864
7.5

CVE-2026-73864: Unverified Native Artifact Download Leading to Remote Code Execution in install-artifact-from-github

CVE-2026-73864 is a CWE-494 (Download of Code Without Integrity Check) vulnerability in the Node.js package install-artifact-from-github prior to version 1.7.0. The tool downloads precompiled native Node.js C/C++ addons (.node binaries) from GitHub Releases or configurable mirrors and writes them directly to disk without verifying cryptographic checksums or signatures. Furthermore, its HTTP client follows cross-protocol redirects from HTTPS to plaintext HTTP. When the consuming application loads the downloaded addon via require(), the unverified native binary executes immediately within the Node.js process, permitting arbitrary native code execution if an attacker compromises a GitHub release asset, poisons a configured mirror, or intercepts downgraded network traffic.

Amit Schendel
Amit Schendel
5 views•11 min read
•about 4 hours ago•CVE-2026-68903
7.7

CVE-2026-68903: Arbitrary Host File Read via Model.spec.source hostPath Injection in LLMKube

LLMKube prior to version 0.9.0 fails to restrict local filesystem paths and file:// URIs supplied in the Model.spec.source field of custom resources. A namespace-level user with permission to create or modify Model and InferenceService resources can traverse the filesystem of the operator controller pod or mount arbitrary host node files via a HostPathVolumeSource. This enables unauthorized disclosure of high-privilege Kubernetes ServiceAccount tokens and underlying host credentials.

Alon Barad
Alon Barad
4 views•9 min read
•about 5 hours ago•CVE-2026-75521
10.0

CVE-2026-75521: Unverified Client Certificate Authentication Bypass in Miren Runtime

CVE-2026-75521 is an unauthenticated remote authentication bypass vulnerability in Miren Runtime prior to version 0.11.1. The QUIC/HTTP3 RPC service configures its TLS listener with tls.RequestClientCert, which requests client certificates without validating them against the cluster Certificate Authority. Simultaneously, the RPC authenticators extract caller identities directly from PeerCertificates[0] without checking VerifiedChains, granting any caller presenting a self-signed certificate the AuthMethodCert identity and a complete Role-Based Access Control (RBAC) bypass.

Alon Barad
Alon Barad
5 views•9 min read
•about 6 hours ago•CVE-2026-63129
8.8

CVE-2026-63129: SQL Injection and Pre-Confirmation Bypass in mssql-mcp-core and Downstream MSSQL MCP Servers

CVE-2026-63129 is a high-severity SQL injection vulnerability (CWE-89) in the @connorbritain/mssql-mcp-core library and its downstream implementations (mssql-mcp-server, mssql-mcp-reader, and mssql-mcp-writer). The flaw results from the direct concatenation of unvalidated database identifiers, filter predicates, and enum parameters into T-SQL batches passed to the node-mssql Request.query() interface. Because pre-execution row count and preview queries execute before safety confirmation flags are checked, an attacker with access to invoke Model Context Protocol (MCP) tools can bypass confirmation controls and execute arbitrary stacked T-SQL statements.

Amit Schendel
Amit Schendel
7 views•11 min read
•about 7 hours ago•CVE-2026-73504
5.5

CVE-2026-73504: Plaintext Authentication Token Exposure in cassandra-jdbc-wrapper Debug Logs

CVE-2026-73504 (GHSA-jc42-994r-vvwp) is a credential exposure vulnerability in ING Bank's cassandra-jdbc-wrapper (com.ing.data:cassandra-jdbc-wrapper). Resulting from an incomplete remediation of AIKIDO-2024-10565, the log sanitization routines in DriverUtil redact the password property but fail to redact the token property. When DEBUG logging is enabled, connection properties and JDBC URLs containing DataStax Astra DB bearer tokens are written in plaintext to application logs, enabling local users or log aggregation readers to harvest active database credentials.

Amit Schendel
Amit Schendel
5 views•9 min read