Skip to main content

Refine Inferencer EUVDEUVD-2026-81047

| CVE-2026-92784 HIGH
Code Injection (CWE-94)
2026-09-16 VulnCheck GHSA-x4x4-phr8-wp7p
7.7
CVSS 4.0 · Vendor: VulnCheck
View

Attack ChainAIDerived

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

  1. Access
    Attacker controls or compromises data provider API
  2. Delivery
    API returns JSON with malicious field names
  3. Exploit
    Inferencer interpolates names into JSX unescaped
  4. Execution
    Developer renders Inferencer page
  5. Impact
    Injected 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.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
No patch listed yet 0.4% exploitation probability (EPSS)

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

Alert me

AnalysisAIv1 – 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

@refinedev/inferencer 0 ≤7.0.0

Affected Packages

euvd refinedev_inferencer 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

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

Vendor (VulnCheck) PRIMARY 7.7 HIGH
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
vuln.today AI 7.1 HIGH

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.

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

Primary rating from Vendor (VulnCheck).

CVSS VectorVendor: VulnCheck

Attack Vector
Network
Attack Complexity
High
Attack Requirements
Present
Privileges Required
None
User Interaction
Passive
Vulnerable system: Confidentiality
High
Vulnerable system: Integrity
High
Vulnerable system: Availability
High
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
None

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

Why It Matters

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.

Business Impact: Medium
Compensating Controls

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

EPSS Score
0.4%
Top 63% exploitable
Prevalence
Medium
popular open-source React framework, but dev-only Inferencer scaffolding subset
Data Quality
5 sources
Confidence: Medium

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 HIGH
CISA KEV No
Public POC No
EPSS 0.4%
Patch available No
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.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· derived
None
System Exposure· derived
Open
Automatable· derived
No
Human Impact
Medium

Priority Score

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

Attack Technique

Code Injection CRITICAL

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.

More in React

View all
CVE-2025-55182 CRITICAL POC
10.0 Dec 03

React Server Components in React 19.x contain a critical pre-authentication remote code execution vulnerability (CVE-202

CVE-2025-55184 HIGH POC
7.5 Dec 11

Pre-authentication denial of service in React Server Components (versions 19.0.0 through 19.2.1) allows unauthenticated

CVE-2025-55183 MEDIUM POC
5.3 Dec 11

Information disclosure in React Server Components 19.x, distributed as react-server-dom-webpack, react-server-dom-turbop

CVE-2025-45001 HIGH POC
7.5 Jun 09

react-native-keys version 0.7.11 contains a sensitive information disclosure vulnerability where encryption ciphers and

CVE-2025-67779 HIGH
7.5 Dec 12

Unsafe deserialization in React Server Components Server Function endpoints allows remote unauthenticated attackers to t

CVE-2026-22028 MEDIUM POC
6.1 Jan 08

HTML injection in Preact and React through unsafe JSON deserialization allows remote attackers to inject arbitrary scrip

CVE-2026-27612 MEDIUM POC
6.1 Feb 25

Reflected XSS in Repostat's RepoCard React component prior to version 1.0.1 allows attackers to execute arbitrary JavaSc

CVE-2026-14802 MEDIUM POC
5.5 Jul 06

OS command injection in create-react-app's react-dev-utils component enables remote code execution on macOS developer wo

CVE-2026-23864 HIGH
7.5 Jan 26

Uncontrolled resource consumption in React Server Components (react-server-dom-parcel, react-server-dom-turbopack, react

CVE-2026-1461 MEDIUM
6.5 Feb 19

Simple Membership (WordPress plugin) versions up to 4.7.0 contains a security vulnerability (CVSS 6.5).

CVE-2025-68470 MEDIUM
6.5 Jan 10

React-Router versions up to 6.30.1 is affected by url redirection to untrusted site (open redirect) (CVSS 6.5).

CVE-2026-30847 MEDIUM
6.5 Mar 06

Wekan is an open source kanban tool built with Meteor. [CVSS 6.5 MEDIUM]

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