Back to Intelligence

CVE-2026-130756: pnpm Standalone Builds Trust Compromised eMudhra CA — Supply Chain MitM Detection and Remediation

SA
Security Arsenal Team
November 19, 2026
11 min read

The NVD has published CVE-2026-130756, a CVSS 9.8 (Critical), network-exploitable vulnerability affecting the standalone pnpm executable builds before version 10.34.8. The flaw is not a memory corruption bug or a parsing error — it is a trust-anchoring failure: the pnpm exe distribution embeds an outdated Node.js runtime whose TLS trust store still includes compromised eMudhra intermediate CA certificates. Any attacker who holds (or has recovered) the corresponding intermediate private key can present a valid-looking certificate chain for registry.npmjs.org or any private registry, intercept pnpm registry fetches on the network path, and serve forged package metadata or poisoned tarballs that the victim's tooling will accept as authentic.

For defenders, this is a supply-chain-grade problem. pnpm is embedded in CI/CD pipelines, developer workstations, container build stages, and ephemeral build agents. A single intercepted pnpm install can deliver attacker-controlled JavaScript into production builds without tripping a single signature or integrity alarm — because as far as the TLS stack is concerned, everything is legitimate. If your organization ships Node.js software and any developer or build runner uses the standalone pnpm executable (rather than a Node-bundled install), treat this as an urgent remediation item, not a routine patch.

Technical Analysis

Affected Component and Versions

  • Product: pnpm standalone executable builds (pnpm distributed as a self-contained binary with an embedded Node.js runtime)
  • Affected versions: All pnpm exe builds prior to 10.34.8
  • Fixed version: pnpm 10.34.8 and later
  • Vulnerability class: Improper certificate validation via stale trust store — CWE-295 (Improper Certificate Validation) territory, manifested through an outdated embedded runtime
  • Attack vector: Network (AV:N per the NVD vector), no authentication or user interaction required beyond the victim performing a registry fetch
  • CVE: CVE-2026-130756 | CVSS v3.1: 9.8 (Critical)

Critically, this affects the standalone exe distribution only. pnpm installed via npm install -g pnpm or Corepack inherits the host Node.js runtime's trust store — but you cannot assume that's how it's deployed in your environment. Docker base images, bootstrap scripts, and air-gapped developer kits frequently pin the standalone binary precisely because it doesn't depend on a system Node.js install.

How the Attack Works (Defender's View of the Chain)

  1. Recon/positioning: The attacker obtains a network position on the path between the victim and the npm registry — hostile Wi-Fi, compromised ISP edge, poisoned DNS, a rogue proxy in a cloud egress path, or a compromised VPN concentrator. This is a classic MitM precondition, which is why the vector is NETWORK rather than ADJACENT in practice for routed environments.
  2. Forged chain presentation: When the victim's pnpm exe initiates a TLS handshake to the registry, the attacker presents a certificate for the registry hostname signed by the compromised eMudhra intermediate CA. Because the embedded Node.js runtime still trusts that intermediate, chain validation succeeds.
  3. Payload substitution: The attacker now controls the entire registry session. They can return modified packuments (package metadata) pointing dependency resolutions at attacker-hosted tarballs, or directly substitute tarball content. Because the TLS layer validated, pnpm proceeds to install.
  4. Execution: The poisoned package lands in node_modules, executes lifecycle scripts (preinstall/postinstall) during install, or ships into a production bundle — yielding code execution in developer and CI contexts, credential theft (.npmrc tokens, cloud keys), and downstream software supply-chain compromise.

The one mitigating control defenders must verify is lockfile and integrity-hash enforcement: pnpm-lock.yaml records expected tarball integrity hashes. An attacker substituting tarballs without also controlling the lockfile will trigger an integrity mismatch — but CI jobs that regenerate lockfiles, first-time installs, or --no-frozen-lockfile invocations have no such protection, and forged metadata can steer fresh resolutions entirely.

Exploitation Status

As of publication, CVE-2026-130756 is documented by NVD with the compromised-intermediate trust chain described above; there is no confirmed CISA KEV listing at time of writing, but the exploitation prerequisites (recovered intermediate key + network position) are squarely within nation-state and sophisticated criminal capability — compromised CA material is precisely the kind of asset that gets stockpiled. Given a 9.8 network vector against a developer supply-chain tool, assume motivated actors are evaluating it and treat exposure data as your guide: any internet-adjacent or untrusted-network build path running pnpm exe <10.34.8 is at risk today.

Detection & Response

Detection here has two prongs: (1) asset discovery — find every vulnerable pnpm exe before an attacker does, and (2) behavioral hunting — look for evidence that registry traffic was intercepted or that unexpected code entered via installs.

Sigma Rules

YAML
---
title: Vulnerable pnpm Standalone Executable Version Detected
id: 3f8a2b91-7c4e-4d5a-9e1b-2c6d8f0a1b3c
status: experimental
description: Detects execution of pnpm standalone exe builds reporting a version below 10.34.8, which embed a Node.js runtime trusting compromised eMudhra intermediate CAs (CVE-2026-130756).
references:
  - https://nvd.nist.gov/vuln/detail/CVE-2026-130756
author: Security Arsenal
date: 2026/06/15
tags:
  - attack.initial_access
  - attack.t1195.001
logsource:
  category: process_creation
  product: windows
detection:
  selection_img:
    Image|endswith:
      - '\pnpm.exe'
      - '\pnpm'
  selection_cli:
    CommandLine|contains:
      - '--version'
      - ' install'
      - ' add'
      - ' fetch'
  condition: all of selection_*
falsepositives:
  - Patched pnpm versions (tune by pairing with version output collection or EDR software inventory)
level: medium
---
title: pnpm Registry Connection Overridden to Non-Standard Host
id: 9d4e7c2a-1b6f-4a8d-b3e5-5f9c2d7e8a01
status: experimental
description: Detects pnpm executions where the registry is overridden via command line or environment to a non-default host, a pattern consistent with MitM-steered or attacker-influenced package resolution following CVE-2026-130756 interception.
references:
  - https://nvd.nist.gov/vuln/detail/CVE-2026-130756
author: Security Arsenal
date: 2026/06/15
tags:
  - attack.command_and_control
  - attack.t1195.001
logsource:
  category: process_creation
  product: linux
detection:
  selection:
    CommandLine|contains:
      - 'pnpm'
  selection_registry:
    CommandLine|contains:
      - '--registry='
      - 'npm_config_registry='
      - 'NPM_CONFIG_REGISTRY='
  filter_legit:
    CommandLine|contains:
      - 'registry.npmjs.org'
      - 'registry.yarnpkg.com'
  condition: selection and selection_registry and not filter_legit
falsepositives:
  - Legitimate private registries (Artifactory, Nexus, Verdaccio) — allowlist your internal mirrors
level: high
---
title: pnpm Install With Frozen Lockfile Disabled in CI Context
id: 61b3f8d4-2a9c-4e7b-8d1f-4c5a9e0b2d6f
status: experimental
description: Detects pnpm install executions that bypass lockfile integrity enforcement, removing the key control that would catch forged tarballs delivered via a compromised eMudhra CA MitM (CVE-2026-130756).
references:
  - https://nvd.nist.gov/vuln/detail/CVE-2026-130756
author: Security Arsenal
date: 2026/06/15
tags:
  - attack.defense_evasion
  - attack.t1195.001
logsource:
  category: process_creation
detection:
  selection:
    CommandLine|contains:
      - 'pnpm install'
      - 'pnpm add'
  selection_bypass:
    CommandLine|contains:
      - '--no-frozen-lockfile'
      - '--lockfile-only=false'
      - 'frozen-lockfile=false'
  condition: selection and selection_bypass
falsepositives:
  - Local developer dependency updates — correlate with CI agent hostnames and build service accounts
level: medium

KQL Hunt (Microsoft Sentinel / Defender)

KQL — Microsoft Sentinel / Defender
// Hunt 1: Find vulnerable pnpm standalone binaries executing in the environment
// Pair with your software inventory; flag hosts where pnpm exe version < 10.34.8
DeviceProcessEvents
| where TimeGenerated > ago(14d)
| where FileName =~ "pnpm" or FileName =~ "pnpm.exe" or ProcessCommandLine has "pnpm"
| where ProcessCommandLine has_any ("install", "add", "fetch", "--version")
| summarize Executions = count(), DistinctCommands = make_set(ProcessCommandLine, 10) by DeviceName, FolderPath, InitiatingProcessAccountName
| order by Executions desc

// Hunt 2: pnpm processes connecting to non-standard registry destinations
// A MitM redirect or hostile proxy path will surface as unexpected remote endpoints
DeviceNetworkEvents
| where TimeGenerated > ago(14d)
| where InitiatingProcessFileName in~ ("pnpm", "pnpm.exe", "node", "node.exe")
| where RemotePort == 443
| where not(RemoteUrl has_any ("registry.npmjs.org", "registry.yarnpkg.com", "npmjs.com"))
| extend IsPrivateIP = ipv4_is_private(RemoteIP)
| summarize Connections = count(), Endpoints = make_set(strcat(RemoteUrl, " / ", RemoteIP), 20)
  by DeviceName, InitiatingProcessFileName, IsPrivateIP
| where not(IsPrivateIP) // review private hits separately against known Artifactory/Nexus hosts
| order by Connections desc

// Hunt 3: Syslog/CEF-ingested Linux build agents — TLS handshake anomalies to registries
// Look for registry FQDNs resolved to infrastructure that isn't Fastly/npm CDN
Syslog
| where TimeGenerated > ago(14d)
| where ProcessName has "pnpm" or SyslogMessage has "pnpm"
| where SyslogMessage has_any ("ERR_PNPM", "integrity", "checksum", "EINTEGRITY", "certificate")
| project TimeGenerated, Computer, ProcessName, SyslogMessage
| order by TimeGenerated desc

Velociraptor VQL Hunt

VQL — Velociraptor
-- Locate standalone pnpm executables and capture version + embedded runtime evidence
-- Deploy as a hunt across developer workstations and CI/build agents
SELECT FullPath, Size, Mtime,
       read_file(filename=FullPath, length=0) AS _touch,
       version_info(string=FullPath) AS VersionInfo
FROM glob(globs=[
  'C:/Users/*/AppData/Local/pnpm/**/pnpm.exe',
  'C:/Program Files/pnpm/**',
  'C:/tools/pnpm/**',
  '/usr/local/bin/pnpm',
  '/home/*/.local/share/pnpm/pnpm',
  '/home/*/.pnpm-home/**',
  '/opt/**/pnpm'
])
WHERE NOT IsDir
VQL — Velociraptor
-- Enumerate active pnpm/node processes and their network connections
-- Flag registry sessions terminating at non-CDN infrastructure
SELECT Pid, Name, CommandLine, Exe, Username
FROM pslist()
WHERE Name =~ '(?i)pnpm|node'
  AND CommandLine =~ '(?i)install|fetch|add|publish'
VQL — Velociraptor
-- Correlate node-family processes with outbound 443 connections to non-allowlisted registries
SELECT Pid, Name, CommandLine, LocalAddr, LocalPort, RemoteAddr, RemotePort, Status
FROM netstat()
WHERE Name =~ '(?i)pnpm|node'
  AND RemotePort = 443
  AND RemoteAddr !~ '^(10\\.|172\\.(1[6-9]|2[0-9]|3[01])\\.|192\\.168\\.|127\\.)'

Remediation & Verification Script

Bash / Shell
#!/usr/bin/env bash
# CVE-2026-130756 — pnpm standalone exe remediation & verification
# Run on developer workstations and CI/build agents (Linux/macOS).
set -euo pipefail

REQUIRED_MAJOR=10
REQUIRED_MINOR=34
REQUIRED_PATCH=8

echo "[*] Locating pnpm installations..."
PNPM_PATHS=$(command -v -a pnpm 2>/dev/null || true)
# Also sweep common standalone install locations
for p in "$HOME/.local/share/pnpm/pnpm" /usr/local/bin/pnpm /opt/pnpm/pnpm; do
  [ -x "$p" ] && PNPM_PATHS="$PNPM_PATHS
$p"
done

[ -z "${PNPM_PATHS:-}" ] && { echo "[+] No pnpm found on this host."; exit 0; }

VULN=0
while IFS= read -r bin; do
  [ -z "$bin" ] && continue
  VER=$("$bin" --version 2>/dev/null || echo "unknown")
  echo "    Found: $bin  (version: $VER)"
  if [[ "$VER" =~ ^([0-9]+)\.([0-9]+)\.([0-9]+) ]]; then
    MAJ="${BASH_REMATCH[1]}"; MIN="${BASH_REMATCH[2]}"; PAT="${BASH_REMATCH[3]}"
    if [ "$MAJ" -lt "$REQUIRED_MAJOR" ] || \
       { [ "$MAJ" -eq "$REQUIRED_MAJOR" ] && [ "$MIN" -lt "$REQUIRED_MINOR" ]; } || \
       { [ "$MAJ" -eq "$REQUIRED_MAJOR" ] && [ "$MIN" -eq "$REQUIRED_MINOR" ] && [ "$PAT" -lt "$REQUIRED_PATCH" ]; }; then
      echo "[!] VULNERABLE: $bin is below 10.34.8"
      VULN=1
    fi
  else
    echo "[!] WARNING: could not parse version for $bin — treat as suspect"
    VULN=1
  fi
done <<< "$PNPM_PATHS"

if [ "$VULN" -eq 1 ]; then
  echo ""
  echo "[>] Upgrading standalone pnpm to latest (>=10.34.8)..."
  # Preferred: pnpm self-update for standalone builds
  if command -v pnpm >/dev/null 2>&1; then
    pnpm self-update 2>/dev/null || true
  fi
  # Fallback: reinstall standalone via official installer
  curl -fsSL https://get.pnpm.io/install.sh | env PNPM_VERSION=latest sh -
  echo "[>] Post-upgrade version: $(pnpm --version 2>/dev/null || echo 'verify manually')"
fi

echo ""
echo "[*] Verifying registry configuration integrity..."
# Confirm registry is pinned to expected endpoint, not silently redirected
npm config get registry
pnpm config get registry 2>/dev/null || true
echo "    ^ Expected: https://registry.npmjs.org/ or your approved internal mirror"

echo ""
echo "[*] Enforcing frozen lockfiles in CI (integrity mismatch will now fail the build)..."
# Add to CI pipeline definitions:
echo '    pnpm config set frozen-lockfile true'

echo ""
echo "[*] Auditing lockfiles for recent unexpected changes (last 14 days)..."
find . -name 'pnpm-lock.yaml' -mtime -14 2>/dev/null | while read -r lock; do
  echo "    Recently modified: $lock — diff against version control before trusting"
done

echo ""
echo "[*] DONE. Re-run after upgrade to confirm all pnpm binaries report >= 10.34.8."

Remediation

  1. Upgrade every standalone pnpm exe to 10.34.8 or later immediately. This is the definitive fix — the updated build ships a Node.js runtime with the compromised eMudhra intermediates removed from the trust store. Check all install locations: developer workstations, CI runners, Docker build stages (grep -r pnpm your Dockerfiles for pinned versions), golden images, and air-gapped tool bundles. Self-updaters are not guaranteed in managed environments — verify the post-patch version explicitly.
  2. Enforce frozen lockfiles everywhere. Set frozen-lockfile=true (the default in CI, but verify) so any tarball integrity mismatch — the primary tell of a substituted package — fails the build loudly. Audit --no-frozen-lockfile usage; it should be a deliberate, reviewed exception.
  3. Pin and monitor your registry path. Route all package traffic through an internal mirror/proxy (Artifactory, Nexus, or a vetted caching proxy) so registry sessions terminate on infrastructure you control, collapsing the attacker's MitM window. Alert on any pnpm process reaching non-allowlisted registry endpoints.
  4. Audit for compromise if vulnerable versions ran on untrusted networks. If pnpm exe <10.34.8 performed installs over hotel, conference, home, or otherwise untrusted network paths, diff pnpm-lock.yaml against source control, re-verify tarball hashes, rotate npm tokens and any credentials present on affected build agents (.npmrc, cloud provider keys), and review build outputs produced during the exposure window.
  5. Track CISA KEV. CVE-2026-130756 is a CVSS 9.8 network-exploitable supply-chain vector — if it lands on the KEV, federal deadlines (typically 21 days for FCEB agencies) and your internal SLA clock start immediately. Pre-stage the patch now so KEV inclusion is a non-event.
  6. Governance fix: add embedded-runtime components like the pnpm standalone binary to your SBOM and third-party software inventory. This CVE exists because a bundled runtime drifted from upstream trust-store maintenance — the same exposure class applies to every self-contained toolchain binary in your estate.

Official references: NVD — CVE-2026-130756 and the pnpm project's release notes for 10.34.8.

Related Resources

Security Arsenal Penetration Testing Services AlertMonitor Platform Book a SOC Assessment vulnerability-management Intel Hub

Is your security operations ready?

Get a free SOC assessment or see how AlertMonitor cuts through alert noise with automated triage.