Skip to main content

Lightning Flow Scanner CVE-2025-67750

HIGH
Code Injection (CWE-94)
2025-12-12 security-advisories@github.com
8.4
CVSS 3.1 · Vendor: github
View

Attack ChainAIDerived

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

  1. Access
    Plant malicious rule config/flow file
  2. Delivery
    Victim scans untrusted repository
  3. Exploit
    APIVersion rule calls new Function()
  4. Execution
    Injected JavaScript executes on host
  5. Impact
    Compromise dev machine or CI runner

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 Lightning Flow Scanner (CLI, VS Code extension, or GitHub Action, versions ≤6.10.5) actually scan attacker-influenced input in which the APIVersion rule is active. The concrete sink is the APIVersion rule's options.expression string, which is concatenated into new Function('return <apiVersion><expression>;'); an attacker-controlled expression in the rule configuration (and/or crafted flow metadata) is evaluated as JavaScript. Limiting factors: the APIVersion rule must be configured/invoked, and the attacker must get their malicious config or flow file scanned by the victim (e.g., a CI pipeline auto-scanning an untrusted pull request, or a developer opening a hostile repo with the extension installed). It is a local/host-side execution issue, not a remotely reachable network endpoint, so delivery depends on the victim's scanning workflow rather than direct attacker connectivity.

Impact

This is a genuine code-execution flaw (CWE-94) confirmed by the vendor GHSA advisory and the patch commit, which removes the unsafe new Function() call. The provided CVSS 3.1 vector (AV:L/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H, base 8.4) is internally consistent and credible: the vector is LOCAL because exploitation requires the scanner to process an attacker-influenced input file on the host (developer machine, CI runner, or VS Code editor), not a network service. The HIGH C/I/A ratings are justified because arbitrary JavaScript runs in the context of the scanning process. No EPSS score, KEV listing, or public POC was provided; exploitation status is therefore 'no public exploit identified at time of analysis.' The absence of KEV/EPSS data means real-world exploitation frequency cannot be quantified from this input. The most important nuance the raw CVSS score hides is the delivery constraint: the injected JavaScript flows through the APIVersion rule's expression option (rule configuration) and/or crafted flow metadata, so an attacker must get a malicious repository/config scanned - a realistic supply-chain vector for CI pipelines that auto-scan untrusted pull requests, but a meaningful barrier compared to a remotely reachable service. Net: a real priority for teams running this scanner against untrusted Salesforce flow repos, but the LOCAL vector and niche product footprint temper the absolute risk versus the 8.4 headline.

Exploit ScenarioDerived

An attacker submits a pull request (or publishes a repository) containing a malicious Lightning Flow Scanner rule configuration that sets a crafted expression for the APIVersion rule, or a crafted flow metadata file. When a CI runner or a developer's VS Code extension scans the repo, the APIVersion rule passes the attacker-controlled string into new Function(), executing arbitrary JavaScript on the host. No public exploit code was identified in the provided data, though the vulnerable code path is fully disclosed in the patch commit.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
Patch available 0.2% exploitation probability (EPSS)

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

Alert me

AnalysisAIv1 – Oct 14, 2026

Lightning Flow Scanner 6.10.5 and earlier contains a code injection flaw (CWE-94) in the APIVersion rule, which uses new Function() to evaluate expression strings, allowing arbitrary JavaScript execution when scanning crafted flow metadata or malicious rule configuration. The CVSS 3.1 score is 8.4 (AV:L/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H), reflecting that an unauthenticated local attacker who can influence scanned input can compromise developer machines, CI runners, or editor environments. No public exploit code has been identified at time of analysis, and the vendor has released patched versions: core-v6.10.6, VS Code extension v2.4.4, and GitHub Action v3.1.0.

RemediationAI

Upgrade the core package to version 6.10.6, the VS Code Extension to v2.4.4, and the GitHub Action to v3.1.0. Vendor advisory GHSA-55jh-84jv-8mx8 and commit 10f64a5eb193d8a777e453b25e910144e4540795 provide the patch. If immediate upgrade is not possible, avoid scanning untrusted flow metadata or rule configurations with the APIVersion rule enabled; the advisory provides a workaround that removes the APIVersion rule from the standard scan configuration and manually evaluates it using a safe numeric comparison. Disabling the APIVersion rule prevents the code path entirely but may reduce the scanner's API version compliance checks. Additionally, run scans of untrusted code in an isolated environment (e.g., a container with no sensitive credentials) to limit the impact of any code execution.

Affected Packages

npm lightning-flow-scanner fix: 6.10.6

Source: OSV (Open Source Vulnerabilities)

Affects your stack

Affects 1 package in npm

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

Technical ContextAI · show details

The vulnerability is a code injection (CWE-94) in Lightning Flow Scanner's core package, specifically in the APIVersion rule (packages/core/src/main/rules/APIVersion.ts). The rule constructs a JavaScript function via new Function('return ' + flowAPIVersionNumber + options.expression + ';'), concatenating the flow's API version number with an attacker-influenced expression string from rule configuration. Because expression is not sanitized, an attacker can supply a malicious string (e.g., in a crafted flow metadata file or a poisoned rule config) that breaks out of the intended numeric comparison and executes arbitrary JavaScript. The scanner is used in three contexts: a CLI plugin, a VS Code Extension, and a GitHub Action, so exploitation affects developer endpoints, CI runners, and editor environments. The patch (commit 10f64a5) removes new Function() and replaces it with a regex-based parser that only allows operators (>, >=, <, <=, , =, !==) and numeric comparisons, preventing arbitrary code evaluation. The CVSS vector indicates local attack vector (AV:L), no privileges required (PR:N), no user interaction (UI:N), and high confidentiality, integrity, and availability impact.

Know when the next one hits your stack

  • 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 (github) PRIMARY 8.4 HIGH
AV:L/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H
vuln.today AI 8.4 HIGH

AV:L because a malicious file must be processed locally by the scanner; PR:N/UI:N as a CI runner can auto-scan untrusted input; arbitrary JS yields full C/I/A:H.

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

Primary rating from Vendor (github).

CVSS VectorVendor: github

Attack Vector
Local
Attack Complexity
Low
Privileges Required
None
User Interaction
None
Scope
Unchanged
Confidentiality
High
Integrity
High
Availability
High

DescriptionCVE.org

Lightning Flow Scanner provides a A CLI plugin, VS Code Extension and GitHub Action for analysis and optimization of Salesforce Flows. Versions 6.10.5 and below allow a maliciously crafted flow metadata file to cause arbitrary JavaScript execution during scanning. The APIVersion rule uses new Function() to evaluate expression strings, enabling an attacker to supply a malicious expression within rule configuration or crafted flow metadata. This could compromise developer machines, CI runners, or editor environments. This issue is fixed in version 6.10.6.

Executive ViewAI

Why It Matters

Lightning Flow Scanner 6.10.5 and earlier - a static-analysis tool used to lint Salesforce Flow metadata - can be induced to execute arbitrary JavaScript on developer workstations and CI runners when it scans crafted flow metadata or a malicious rule configuration, and the CVSS vector indicates no authentication is required. This places engineering environments, build pipelines, and the source code, tokens, and deployment credentials they can reach at risk of full compromise. No public exploit code has been identified at time of analysis, but patch status is inconsistent between the vulnerability feed and the fix versions referenced in the technical description, so leadership should treat remediation as urgent and require verification against the vendor advisory before assuming coverage.

Business Impact: High
Compensating Controls

Apply vendor patch: upgrade to core v6.10.6, VS Code extension v2.4.4, and GitHub Action v3.1.0. If those versions cannot be deployed immediately, restrict scanning to trusted, internally controlled flow metadata and rule configurations, run scans in disposable least-privilege containers or ephemeral runners with restricted network egress, and avoid loading unreviewed custom rule definitions.

Threat Intelligence Overview

EPSS Score
0.2%
Top 92% exploitable
Prevalence
Low
niche Salesforce developer tooling, limited to Flow-scanning teams
Data Quality
3 sources
Confidence: Low

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.2%
Patch available Yes
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
Small
Automatable· derived
No
Human Impact
High

Priority Score

42
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +42
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.

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