Elo JavaScript Emitter Sandbox Escape via `.constructor` Access (CVE-2026-44267)
Detects exploitation of CVE-2026-44267, a sandbox escape in the @enspirit/elo npm package (versions <= 1.0.0). Elo's JavaScript emitter does not filter `.constructor` member access on user-controlled expressions, allowing an attacker to reach `Function`/`process` and achieve arbitrary Node.js or browser code execution (CWE-94, CWE-693, CWE-1336). Detection focuses on dependency inventory of the vulnerable package, template/expression payloads containing `constructor` chains, and post-exploitation process/network behavior spawned from a Node.js runtime hosting Elo.
Vulnerability Intelligence
Public PoCAffected Software
- Vendor
- npm
- Product
- @enspirit/elo
- Versions
- <= 1.0.0
Timeline
- Disclosed
- November 3, 2026
References & Proof of Concept
CVSS
- Attack Vector
- Network
- Attack Complexity
- Low
- Privileges Required
- None
- User Interaction
- None
- Scope
- Unchanged
- Confidentiality
- High
- Integrity
- High
- Availability
- High
What is CVE-2026-44267 Elo JavaScript Emitter Sandbox Escape via `.constructor` Access (CVE-2026-44267)?
Elo JavaScript Emitter Sandbox Escape via `.constructor` Access (CVE-2026-44267) (CVE-2026-44267) maps to the Execution and Initial Access tactics — the adversary is trying to run malicious code or instructions on a system in MITRE ATT&CK.
This page provides production-ready detection logic for Elo JavaScript Emitter Sandbox Escape via `.constructor` Access (CVE-2026-44267), covering the data sources and telemetry it touches: IIS Logs, App Service HTTP Logs, Syslog. The queries below are rated critical severity at medium confidence, and ship for 7 SIEM platforms — KQL, SPL, Elastic, QRadar, Sumo, YARA-L, LogScale.
MITRE ATT&CK
- Tactic
- Execution Initial Access
// df00tech DF00-b7b8bed07c · https://df00tech.com/detections/CVE-2026-44267 · licence: https://df00tech.com/detections/licence
// Detect Elo expression payloads reaching .constructor (sandbox escape) in HTTP/app logs
let escapePatterns = dynamic(["constructor","process.mainModule","child_process","Function(","require("]);
union isfuzzy=true W3CIISLog, AppServiceHTTPLogs, Syslog
| extend Payload = coalesce(column_ifexists("csUriQuery", ""), column_ifexists("CsUriQuery",""), column_ifexists("SyslogMessage",""), column_ifexists("Message",""))
| where isnotempty(Payload)
| extend DecodedPayload = url_decode(Payload)
| where DecodedPayload has "constructor" and (DecodedPayload has_any ("process","child_process","require","Function","globalThis"))
| project TimeGenerated, SourceIP = coalesce(column_ifexists("cIP",""), column_ifexists("CIp","")), Payload, DecodedPayload, _ResourceId = column_ifexists("_ResourceId","")
| order by TimeGenerated desc Flags HTTP requests or application logs where an Elo expression/template payload references `.constructor` combined with Node.js escape primitives (process, child_process, require, Function), indicating an attempt to exploit the unfiltered member access.
Data Sources
Required Tables
False Positives
- Legitimate application code or templates that intentionally reference `.constructor` for metaprogramming.
- Security scanners and vulnerability-assessment tools probing the application.
- Developer debugging traffic containing JavaScript source in request bodies.
Query fingerprint DF00-b7b8bed07c · licence
Sigma logsource & community rules
The detection logic for Elo JavaScript Emitter Sandbox Escape via `.constructor` Access (CVE-2026-44267) (CVE-2026-44267) above is provided in a vendor-neutral
form so you can deploy it on any SIEM. The same logic is shipped here as native
KQL (Microsoft Sentinel / Defender), SPL (Splunk), Elastic (Elastic Security (EQL)), QRadar (IBM QRadar (AQL)), Sumo (Sumo Logic CSE), YARA-L (Google Chronicle / SecOps), LogScale (CrowdStrike LogScale (CQL)) queries. In Sigma terms, this detection targets the
following logsource:
logsource:
product: windows Browse the community-maintained Sigma rules for this technique:
Platform-specific guides for CVE-2026-44267
Testing Methodology
Validate this detection against 3 adversary techniques from Atomic Red Team. Each test below lists the behaviour to exercise and the telemetry you should expect to see. Executable commands and cleanup steps are further down this page.
- Test 1 Elo constructor sandbox escape to code execution (Node)
Expected signal: Node.js process start with an inline `-e` command line containing `constructor`.
- Test 2 Shell spawned via Elo-style constructor escape
Expected signal: Node.js parent process spawning /bin/sh or id with child_process in the command line.
- Test 3 HTTP payload carrying constructor escape
Expected signal: Web access log entry containing an encoded `.constructor` expression with `process`.
Response Playbook
Triage
- Confirm whether the affected host or application bundles @enspirit/elo at version <= 1.0.0 by inspecting package-lock.json / node_modules / SBOM.
- Decode and examine the flagged payload to determine whether `.constructor` was chained to `Function`, `process`, or `require` reaching real code execution versus a benign reference.
- Correlate the request with the hosting Node.js process timeline to identify any child processes, outbound connections, or file writes spawned immediately after.
Containment
- Upgrade or remove @enspirit/elo to a fixed version above 1.0.0, or disable the emitter path that evaluates untrusted expressions.
- Isolate the affected host from the network if post-exploitation child processes or outbound C2 connections are confirmed.
Evidence Collection
- Capture the full raw request/payload, application logs, and the node process command line and environment.
- Collect process-creation telemetry (parent=node) and any files written or scripts fetched during the suspect window.
Escalation Criteria
- ! Escalate to IR if a shell or interpreter was spawned as a child of the Node.js process hosting Elo.
- ! Escalate if outbound connections to unknown infrastructure or credential/secret access follow the suspect expression evaluation.
Investigation Guide
Forensic Artifacts
- >
Node.js process command line and child-process tree. - >
Web/application access logs containing the `.constructor` payload. - >
package-lock.json / node_modules showing @enspirit/elo <= 1.0.0.
Tuning Guidance
Baseline legitimate uses of `.constructor` in your application's templates and exclude known-good expression sources. Pair payload matches with process-creation telemetry (shell child of node) to raise confidence before alerting, and suppress traffic from authorized scanners by source IP.
Hunting Queries
Hunts application/syslog output for Elo expression evaluation reaching Node.js execution primitives.
// df00tech DF00-b7b8bed07c · https://df00tech.com/detections/CVE-2026-44267 · licence: https://df00tech.com/detections/licence
Syslog | where SyslogMessage has "constructor" and SyslogMessage has_any ("child_process","process.mainModule","require(") | project TimeGenerated, Computer, SyslogMessage ``` df00tech DF00-b7b8bed07c · https://df00tech.com/detections/CVE-2026-44267 · licence: https://df00tech.com/detections/licence ```
index=* sourcetype=syslog constructor (child_process OR process.mainModule OR "require(") | table _time host _raw Atomic Red Team Tests
Simulates the Elo emitter evaluating an untrusted expression that uses `.constructor` to reach Function and execute code.
Command
node -e "const p='x'; const r=({}).constructor.constructor('return process')(); console.log(r.version);" Cleanup
echo 'no cleanup required' Expected Telemetry
Node.js process start with an inline `-e` command line containing `constructor`.
Expected Detection
Process/command-line detections and payload rules match the `.constructor.constructor` chain.
Uses the constructor chain to spawn a child shell, emulating post-exploitation command execution.
Command
node -e "({}).constructor.constructor('return this.process')().mainModule.require('child_process').execSync('id');" Cleanup
echo 'no cleanup required' Expected Telemetry
Node.js parent process spawning /bin/sh or id with child_process in the command line.
Expected Detection
EQL/CQL process-lineage rules flag a shell child of node.
Sends an HTTP request whose parameter contains an Elo expression using `.constructor` and process primitives.
Command
curl -s 'http://localhost:8080/render?expr=%7B%7B%28%29.constructor.constructor%28%22return+process%22%29%28%29%7D%7D' || true Cleanup
echo 'no cleanup required' Expected Telemetry
Web access log entry containing an encoded `.constructor` expression with `process`.
Expected Detection
Web-log payload rules (KQL/SPL/QRadar/Sumo/Chronicle) match the decoded constructor+process payload.
Related Detections
Tactic Hubs
Related Techniques
Same Tactic: Execution
Blog posts about this detection
Browse by tactic
- Reconnaissance TA0043
- Resource Development TA0042
- Initial Access TA0001
- Execution TA0002
- Persistence TA0003
- Privilege Escalation TA0004
- Stealth TA0005
- Defense Impairment TA0112
- Credential Access TA0006
- Discovery TA0007
- Lateral Movement TA0008
- Collection TA0009
- Command and Control TA0011
- Exfiltration TA0010
- Impact TA0040