Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessAttacker controls or compromises data provider API
-
DeliveryAPI returns JSON with malicious field names
-
ExploitInferencer interpolates names into JSX unescaped
-
ExecutionDeveloper renders Inferencer page
-
ImpactInjected JavaScript executes in developer's browser
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V1 - Encoding and Sanitization Code injection prevention, sandbox exec
MITRE ATT&CK
2 techniques across 2 tactics: Execution, Initial Access 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 attacker control (or have compromised) the data provider / backend API that the refine application consumes, so that crafted JSON property names can be returned. A developer must then use @refinedev/inferencer (versions through 7.0.0) and render an Inferencer-generated page, at which point the unescaped field names execute as JavaScript in the developer's browser. Limiting factors: this is a development-time scaffolding tool rather than a production runtime component; it needs a malicious/untrusted data provider (unlikely with trusted first-party APIs); and it needs developer interaction (UI:P) plus specific crafted input (AC:H/AT:P), which together substantially narrow realistic exploitation. |
| Impact | This is a code-injection flaw (CWE-94) in a developer-time scaffolding tool, and the real-world risk is materially lower than the 7.7 CVSS 4.0 headline suggests. The vendor vector CVSS:4.0/AV:N/AC:H/AT:P/PR:N/UI:P/VC:H/VI:H/VA:H already encodes heavy limiters: AC:H (crafted field names required), AT:P (a specific attack precondition - the attacker must control the data provider), and UI:P (a developer must render an Inferencer page). PR:N is technically correct because no authentication to the victim's app is needed, but that is offset by the practical requirement of controlling or compromising the backend API the refine app consumes. There is no CISA KEV listing, no EPSS score, and no public exploit code in the provided references (only the GitHub issue #7556, the repo, two source-line references, and the VulnCheck advisory) - so exploitation status is: no public exploit identified at time of analysis. The impact rating VC:H/VI:H/VA:H reflects arbitrary JavaScript running in the developer's browser context, not server-side compromise; the 'RCE' tag overstates this since execution is client-side in a dev browser, not remote OS code execution. Net: a legitimate but niche, precondition-heavy issue best treated as medium priority rather than a drop-everything emergency. |
| Exploit ScenarioDerived | A developer scaffolds CRUD views with @refinedev/inferencer against a data provider that is attacker-controlled or has been compromised (for example a third-party or self-hosted API returning attacker-influenced schema). The API responds with JSON whose property names contain crafted JavaScript; Inferencer interpolates those field names unescaped into generated JSX, so when the developer opens the Inferencer page the injected script executes in their browser. No public POC is present in the provided data, though the vendor references pinpoint the vulnerable source lines. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Sep 16, 2026
Refine's @refinedev/inferencer package through version 7.0.0 interpolates API field names straight into generated JSX source without escaping, so an attacker who controls or has compromised the data provider can supply crafted JSON property names that execute as JavaScript in a developer's browser when an Inferencer-generated page renders. Remote, unauthenticated input is possible per the published vector (PR:N), but exploitation is gated on developer interaction (UI:P/UI:R), a malicious or untrusted backend (AC:H/AT:P), and a developer actually previewing Inferencer output - hence our independent assessment rates real-world risk materially below the 7.7 CVSS 4.0 headline, and no public exploit code was identified at time of analysis. The issue is tracked upstream in the refinedev/refine repository as issue #7556.
RemediationAI
Vendor-released patched version is not confirmed in the available data - no exact fix version appears in the advisory references, which point only to upstream issue https://github.com/refinedev/refine/issues/7556 and the VulnCheck advisory https://www.vulncheck.com/advisories/refinedev-inferencer-through-7.0.0-code-injection-via-api-field-names - so upgrade @refinedev/inferencer to the first release after 7.0.0 that the maintainers designate as fixed and re-run generation, treating any 0.x-7.0.0 pin as vulnerable until then. Because the flaw is only reachable when generated source is built and rendered, the most effective interim control is to keep the inferencer strictly out of any environment fed by untrusted input: do not render Inferencer pages against third-party, user-configurable, or otherwise attacker-influenceable data providers, and restrict development sessions to trusted first-party APIs - the trade-off is slower schema scaffolding for external or customer-supplied endpoints. Additional compensating measures, each with caveats: convert any already-generated components into hand-written code and remove @refinedev/inferencer from the dependency tree so it can never execute (costs the convenience of automatic generation and must be redone when schemas change); run the development server and any preview/storybook infrastructure in a sandboxed, low-privilege browser profile or container isolated from production credentials and internal networks (reduces blast radius if a payload does fire but does not prevent execution); and, on the API side, enforce strict allow-listing or normalization of response field names so that keys containing JSX-significant or script-bearing characters are rejected before reaching the client - this depends on controlling the data provider and is not feasible when the attacker owns that backend, which is precisely the exploitation precondition here.
Affected VersionsENISA
Affected Packages
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
The root cause is CWE-94 (Improper Control of Generation of Code / code injection) in @refinedev/inferencer, the scaffolding component of the Refine React framework that reads live API responses and auto-generates JSX/TSX page components. Rather than treating JSON object keys as opaque data, the inferencer templates them as source-code tokens - the referenced code paths in packages/inferencer/src/inferencers/antd/list.tsx (around lines 140-144) and packages/inferencer/src/create-inferencer/index.tsx (around lines 117-128) show field names being string-interpolated into generated markup. Because that generated source is then compiled and rendered in the developer's own browser, a property name crafted to break out of its JSX attribute or expression context is interpreted as executable script rather than displayed as text, giving arbitrary JavaScript execution in the developer's session. The affected component is identified by the wildcard CPE cpe:2.3:a:refinedev:@refinedev/inferencer:*:*:*:*:*:*:*:*, meaning all published versions of the package are in scope, and EUVD records the vulnerable range as @refinedev/inferencer 0 through 7.0.0. Context matters for triage: this is development-time code-generation tooling rather than a production runtime dependency, and the CVSS 4.0 vector (AV:N/AC:H/AT:P/PR:N/UI:P, all three impact metrics High) describes a worst case in which the attacked component is fed attacker-influenced schema data; our independent CVSS 3.1 assessment (AV:N/AC:H/PR:N/UI:R/S:U/C:H/I:H/A:L) agrees on network reachability and confidentiality/integrity impact but scores availability lower and emphasizes the required user interaction and attacker-controlled data source.
Know when React 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
CVSS:4.0/AV:N/AC:H/AT:P/PR:N/UI:P/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N
AC:H and UI:R capture the crafted field names plus required developer page render; PR:N because no app auth is needed though a malicious data provider is a precondition; arbitrary browser JS gives C:H/I:H, A:L.
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
DescriptionCVE.org
@refinedev/inferencer through 7.0.0 fails to escape API field names when interpolating them into generated JSX source code. Attackers controlling the data provider can inject malicious JavaScript through crafted JSON property names that execute in the developer's browser when the Inferencer page renders.
Executive ViewAI
The @refinedev/inferencer package through version 7.0.0 can run attacker-controlled JavaScript in a developer's browser when generated pages render data from a malicious or compromised backend, putting developer workstations and connected internal systems at risk. Exploitation depends on a developer previewing Inferencer output against an untrusted data provider, so real-world likelihood is lower than the 7.7 CVSS headline, but the lack of a vendor-released patch means security and engineering leadership should track and mitigate this actively.
No vendor-released patch identified at time of analysis. Interim mitigations: avoid or disable @refinedev/inferencer-generated pages for untrusted or compromised data providers; validate and escape API field names before JSX generation; restrict developer preview environments to trusted backends; apply least privilege and network segmentation to developer workstations; monitor refinedev/refine issue #7556 and apply the vendor patch when released.
Threat Intelligence Overview
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.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
Code injection occurs when an application accepts user input and passes it directly into a language interpreter or evaluator without proper sanitization.
Remote Code Execution represents the critical moment when an attacker successfully runs arbitrary code on a target system without physical access.
React Server Components in React 19.x contain a critical pre-authentication remote code execution vulnerability (CVE-202
Pre-authentication denial of service in React Server Components (versions 19.0.0 through 19.2.1) allows unauthenticated
Information disclosure in React Server Components 19.x, distributed as react-server-dom-webpack, react-server-dom-turbop
react-native-keys version 0.7.11 contains a sensitive information disclosure vulnerability where encryption ciphers and
Unsafe deserialization in React Server Components Server Function endpoints allows remote unauthenticated attackers to t
HTML injection in Preact and React through unsafe JSON deserialization allows remote attackers to inject arbitrary scrip
Reflected XSS in Repostat's RepoCard React component prior to version 1.0.1 allows attackers to execute arbitrary JavaSc
OS command injection in create-react-app's react-dev-utils component enables remote code execution on macOS developer wo
Uncontrolled resource consumption in React Server Components (react-server-dom-parcel, react-server-dom-turbopack, react
Simple Membership (WordPress plugin) versions up to 4.7.0 contains a security vulnerability (CVSS 6.5).
React-Router versions up to 6.30.1 is affected by url redirection to untrusted site (open redirect) (CVSS 6.5).
Wekan is an open source kanban tool built with Meteor. [CVSS 6.5 MEDIUM]
EUVD-2026-81047
GHSA-x4x4-phr8-wp7p
NVD
CVE.org
EPSS
Exploit-DB