Raw vector
CVSS:3.1/AV:L/AC:L/PR:L/UI:R/S:C/C:H/I:H/A:HSummary
CVE-2026-33941 is a high-severity Cross-site Scripting (CWE-79) vulnerability in Handlebarsjs Handlebars. Its CVSS base score is 8.2 (High).
Operationally, exploitation aligns with the MITRE ATT&CK technique Browser Session Hijacking (T1185); ranked at the 21th percentile by exploit likelihood (below the median); it is not currently listed in the CISA KEV catalog; a public proof-of-concept is referenced.
The strongest mitigations our analysis identified map to SA-11 (Developer Testing and Evaluation) and SI-10 (Information Input Validation) — see the control section below for these in your framework.
Deeper analysis AI-assisted summary
Synthesised by an AI model from the NVD description and linked references — a reading aid, not an authoritative source.
CVE-2026-33941 is a code injection vulnerability in the Handlebars CLI precompiler, specifically in `bin/handlebars` and `lib/precompiler.js`, affecting versions 4.0.0 through 4.7.8 of the Handlebars templating library. The precompiler concatenates user-controlled inputs, such as template filenames and CLI options, directly into the emitted JavaScript bundle without escaping or sanitization. This allows injection of arbitrary JavaScript code, which executes when the generated bundle is loaded in a Node.js environment or browser. The vulnerability is rated 8.2 on the CVSS 3.1 scale (AV:L/AC:L/PR:L/UI:R/S:C/C:H/I:H/A:H) and maps to CWE-79 (XSS), CWE-94 (code injection), and CWE-116 (improper encoding).
An attacker with local access and low privileges (PR:L) can exploit this by controlling template filenames or CLI arguments, typically requiring user interaction (UI:R) to invoke the precompiler. Successful exploitation injects malicious JavaScript into the output bundle, achieving remote code execution with high confidentiality, integrity, and availability impacts in the context of the loading environment (S:C), such as a Node.js server or browser runtime during template compilation in build pipelines.
The issue is fixed in Handlebars version 4.7.9, as detailed in the release notes and associated commit. The GitHub security advisory (GHSA-xjpj-3mr7-gcpf) recommends mitigations including validating CLI inputs to reject characters with JavaScript escaping significance (e.g., `"`, `'`, `;`), using fixed trusted namespace strings via configuration files instead of command-line arguments, running the precompiler in a sandboxed environment like a container without write access to sensitive paths, and auditing template filenames in repositories used by automated build pipelines.
OWASP Top 10 for Web (2025)
EU & UK References
- 🇪🇺 ENISA EUVD: EUVD-2026-16862
Vulnerability Data
Handlebars provides the power necessary to let users build semantic templates. In versions 4.0.0 through 4.7.8, the Handlebars CLI precompiler (`bin/handlebars` / `lib/precompiler.js`) concatenates user-controlled strings — template file names and several CLI options — directly into the JavaScript it…
more
emits, without any escaping or sanitization. An attacker who can influence template filenames or CLI arguments can inject arbitrary JavaScript that executes when the generated bundle is loaded in Node.js or a browser. Version 4.7.9 fixes the issue. Some workarounds are available. First, validate all CLI inputs before invoking the precompiler. Reject filenames and option values that contain characters with JavaScript string-escaping significance (`"`, `'`, `;`, etc.). Second, use a fixed, trusted namespace string passed via a configuration file rather than command-line arguments in automated pipelines. Third, run the precompiler in a sandboxed environment (container with no write access to sensitive paths) to limit the impact of successful exploitation. Fourth, audit template filenames in any repository or package that is consumed by an automated build pipeline.
- CWE(s)
Related Threats
MITRE ATT&CK Enterprise Techniques
CVEs Like This One
Affected Assets
Mitigating Controls
Control response
—
—
—
V1.1.2V1.2.1V1.2.3V1.3.2
Mitigating Controls (NIST 800-53 r5) AI
Developer testing and evaluation can discover missing or incorrect input neutralization through targeted web-application tests.
Input validation directly enforces neutralization of untrusted data before it reaches web output generation.
Output filtering can catch or sanitize unneutralized script content before it is served to users.
Least privilege limits the damage an injected code fragment can perform once executed.
Requiring documented secure development standards and tools enforces use of safe code-generation APIs and escaping.
Mitigating Controls (NIST CSF 2.0) AI
Derived directly from the weakness types (CWEs) cited in the NVD entry via our AI-authored CWE→CSF cross-walk (authority under review) — links open the control.
Secure SDLC practices directly target introduction of XSS via coding standards/testing (mostly), yet the single broad outcome leaves many specific neutralization vectors unaddressed (partial).
Patching and EOL replacement can remediate known XSS instances in libraries or frameworks (partial) but do nothing to enforce input neutralization in application code (none).
PR.DS-10 protects runtime data confidentiality/integrity but has no bearing on neutralizing externally influenced input during code generation, so neither direction shows any preventive effect.
Mitigating Controls (ISO/IEC 27001:2022 Annex A) AI
Derived directly from the weakness types (CWEs) cited in the NVD entry via our AI-authored CWE→ISO cross-walk (authority under review) — links open the control.
Secure coding standards explicitly require correct output encoding and escaping to preserve message structure.
Secure-coding testing and automated code-analysis tools are applied to detect improper neutralization of script-related content during web-page generation.
Knowledge exchange on emerging attack techniques and patches reduces the likelihood that cross-site scripting flaws remain unaddressed in deployed applications.
Operational indicators of compromise for web-application attacks can be incorporated into WAF or input-filtering rules, lowering the likelihood that unsanitized data reaches the browser.
Requiring language-specific secure-coding standards and automated scanning during the SDLC catches missing output encoding or improper neutralization of untrusted data before the software reaches production.
Application security requirements include explicit rules for safe output handling and encoding.