CVE-2026-33937: Handlebars.js has JavaScript Injection via AST Type Confusion
Handlebars provides the power necessary to let users build semantic templates. In versions 4.0.0 through 4.7.8, `Handlebars.compile()` accepts a pre-parsed AST object in addition to a template string. The `value` field of a `NumberLiteral` AST node is emitted directly into the generated JavaScript without quoting or sanitization. An attacker who can supply a crafted AST to `compile()` can therefore inject and execute arbitrary JavaScript, leading to Remote Code Execution on the server. Version 4.7.9 fixes the issue. Some workarounds are available. Validate input type before calling `Handlebars.compile()`; ensure the argument is always a `string`, never a plain object or JSON-deserialized value. Use the Handlebars runtime-only build (`handlebars/runtime`) on the server if templates are pre-compiled at build time; `compile()` will be unavailable.
Security readout for executives and security teams
Plain-English summary
A flaw in Handlebars.js can let an attacker run arbitrary code on a server when an application passes attacker-controlled, pre-parsed template objects into Handlebars.compile(). Ordinary template strings alone do not establish exposure. Successful exploitation could compromise data, alter systems, or disrupt service.
Executive priority
Treat exposed server-side compilation paths as an immediate remediation priority because impact can include full application compromise. Rapidly determine whether untrusted objects reach compile(); upgrade regardless where affected versions are deployed. Prioritize internet-facing and sensitive systems first.
Technical view
Handlebars.js 4.0.0 through 4.7.8 accepts AST objects in compile(). A crafted NumberLiteral node can place its value directly into generated JavaScript without quoting or sanitization, causing JavaScript injection and potential server-side remote code execution. Version 4.7.9 fixes the issue.
Likely exposure
Highest risk applies to server applications using affected Handlebars versions where untrusted plain objects, JSON-deserialized data, or attacker-influenced ASTs can reach compile(). Deployments compiling only trusted strings, or using the runtime-only build with precompiled templates, are less likely to expose the vulnerable path.
Exploitation context
The supplied CVSS score is 9.8, reflecting potentially unauthenticated, network-reachable code execution with low complexity. However, exploitation requires control over an AST object passed to compile(). The bundle marks KEV false and provides no evidence of active exploitation.
Researcher notes
The defect is AST type confusion leading to code injection: NumberLiteral.value is emitted into generated JavaScript without safe quoting. Analysis should focus on data flow into compile(), especially object inputs reconstructed from JSON. The sources establish the vulnerable mechanism and fixed release, but do not establish public or active exploitation.
Mitigation direction
Upgrade Handlebars.js to version 4.7.9 or later.
Require every argument passed to Handlebars.compile() to be a string.
Reject plain objects and JSON-deserialized values before template compilation.
Use handlebars/runtime when templates are precompiled during builds.
Validation and detection
Inventory direct and transitive Handlebars.js versions in server deployments.
Identify every server-side call to Handlebars.compile().
Trace whether untrusted data can control compile() arguments.
Confirm runtime protections reject all non-string compile() inputs.
Generated from the cited source records. This long-tail analysis has not been individually reviewed by a named human.
Potential ATT&CK relevance
Conservative CVE-to-ATT&CK context
These mappings and lookup hints may be relevant to the vulnerability behavior, CWE, affected product, or exposure path. Glexia-inferred context is not an official MITRE, ATT&CK, CWE, or CVE Program mapping.
ATT&CK lookup starting points
Use these exact CWE pages and searches to review the Glexia ATT&CK library from this CVE's weakness and description context.
cwe · low confidence lookup
CWE-843: Exact CWE lookup
Use the exact CWE identifier as the starting point before reviewing related ATT&CK behavior. Open the exact CWE lookup page first, then review the ATT&CK searches from that MITRE weakness context. This is a Glexia lookup hint, not an official ATT&CK mapping.
Code execution and unsafe deserialization weaknesses often justify reviewing execution behavior and process telemetry. Open the exact CWE lookup page first, then review the ATT&CK searches from that MITRE weakness context. This is a Glexia lookup hint, not an official ATT&CK mapping.
The CVE wording references code or command execution, so execution technique review may help defensive triage. This is a Glexia inferred lookup path, not an official MITRE, ATT&CK, or CVE Program mapping.
These fields come from the CVE record and ADP containers, not from Glexia's Take. They preserve time-varying source decisions such as CISA SSVC, KEV status, CVSS metrics, and provider references.
2CVSS vectors
5Timeline events
2ADP providers
9Source links
SSVC decision data
CISA-ADPCISA Coordinator
Timestamp
Version
2.0.3
Exploitation: pocAutomatable: yesTechnical Impact: total
CVSS vector scores
2 official scores
We collect every scored CVSS vector available in the official CNA and ADP containers. When more than one version is present, the table keeps the source vectors side by side instead of collapsing them into the highest score.
CWE links open Glexia weakness intelligence pages with official CWE context, developer remediation guidance, and related CVE mappings.
CWE-843 · source CWE mapping
Access of Resource Using Incompatible Type ('Type Confusion')
Access of Resource Using Incompatible Type ('Type Confusion') represents a recurring weakness pattern that can create exploitable paths when design, validation, or implementation controls are missing.
Improper Control of Generation of Code ('Code Injection')
Improper Control of Generation of Code ('Code Injection') represents a recurring weakness pattern that can create exploitable paths when design, validation, or implementation controls are missing.