Back to Intelligence

Fake Web3 Accelerator Drops Infostealers via Malicious npm Packages — Detection and Response Guide for Windows and macOS

SA
Security Arsenal Team
October 19, 2026
12 min read

Elastic Security Labs has disclosed an active campaign in which a fraudulent Web3 accelerator is distributing malicious npm packages that deliver information stealers and remote access tooling to Windows and macOS developer workstations. The social engineering hook is tailored for 2026: the fake accelerator promises free API credits for Anthropic Claude and Google Gemini, AI coding tools, and complimentary security audits — bait calibrated to hit exactly the population (Web3 and AI developers) most likely to hold high-value secrets on their endpoints.

This is a supply-chain-by-social-engineering attack. There is no memory corruption, no zero-day, no CVE. The vulnerability is trust in the npm ecosystem combined with developer workstations that hold cloud credentials, SSH keys, crypto wallets, browser sessions, and — increasingly — AI agent API keys and MCP configurations. If your engineers run npm install on untrusted boilerplate from an 'accelerator program,' you have an incident in progress.

What Happened

According to Elastic's research, the threat actors stand up a convincing fake Web3 accelerator front — complete with marketing materials promising free AI credits for Claude and Gemini, coding toolkits, and security audits. Victims who 'apply' or engage are directed to pull down project scaffolding or tooling distributed as npm packages. Those packages carry the payload:

  • Information stealers targeting both Windows and macOS, aimed at browser credential stores, cookies/session tokens, cryptocurrency wallets, keychain material, and developer secrets.
  • Remote access mechanisms (RAT-style implants) giving the operators persistent, interactive access to compromised developer machines.
  • AI agent traffic hijacking — the campaign specifically targets the AI toolchain, intercepting or abusing traffic and credentials associated with AI agents (Claude, Gemini API keys and agent sessions). In 2026, an AI agent API key with attached billing and tool-use permissions is a monetizable asset and a lateral-movement primitive.

The delivery vehicle — npm package lifecycle scripts (preinstall, install, postinstall) — is the critical mechanic. Lifecycle scripts execute arbitrary code at install time with the developer's privileges. No exploit is required; the victim runs the loader voluntarily.

Technical Analysis

Affected platforms

  • Windows: developer workstations running Node.js/npm, particularly Web3 and AI engineering environments.
  • macOS: same profile — Apple Silicon dev machines are a premium target because of crypto wallet and keychain density.
  • Ecosystem: any organization whose developers install third-party npm packages without lockfile pinning, provenance verification, or install-time script controls.

Attack chain (defender's view)

  1. Lure: Victim engages with the fake accelerator (direct outreach, social media, Web3 community channels) and is promised free Claude/Gemini credits, tooling, or an audit.
  2. Delivery: Victim clones or installs attacker-provided npm packages. npm install triggers lifecycle scripts.
  3. Execution: node/npm spawns child processes — cmd.exe, powershell.exe, curl/Invoke-WebRequest on Windows; bash, curl, osascript on macOS — to stage the second-stage payload.
  4. Payload deployment: Infostealer and remote access implant are dropped, typically to user-writable locations (%APPDATA%, %TEMP%, ~/Library/Application Support, /tmp, or paths under the npm cache).
  5. Collection: Browser credential databases (Chrome/Edge/Firefox Login Data, Cookies), macOS Keychain, crypto wallet files and extensions, SSH keys, .env files, cloud CLI credential caches, and AI provider API keys (Anthropic, Google) are harvested.
  6. Exfiltration & persistence: Stolen data is exfiltrated over HTTPS to attacker infrastructure; the RAT component establishes persistence (Run keys, LaunchAgents) and interactive C2. AI agent traffic is intercepted or proxied — giving operators visibility into, and control over, the victim's AI-assisted workflows.

Exploitation status

This is confirmed active, in-the-wild exploitation — not a theoretical technique. Elastic observed operational campaigns delivering working stealers and RATs to real victims. No CVE is associated; there is no patch to deploy. The control surface is process governance, endpoint detection, and developer workflow hygiene.

Why the AI angle matters

Elastic's note about hijacking AI agent traffic deserves emphasis. Developers increasingly run autonomous or semi-autonomous agents with long-lived API keys, MCP server configurations, and tool-use permissions. Compromising the agent layer yields: paid API quota theft, prompt/context data leakage (which often contains source code and secrets), and a covert C2 channel that blends into legitimate Anthropic/Google API traffic. Treat AI agent configuration directories and API keys as credential stores in your IR scoping.

Detection & Response

The highest-fidelity behavioral signal in this campaign is npm/node spawning shells and download utilities at install time, followed by non-browser processes touching browser credential stores and wallet/keychain artifacts. The detections below are tuned for those behaviors.

YAML
---
title: npm or Node Lifecycle Script Spawning Shell or Download Utility
id: 3f8c2a71-9b4e-4d6a-b1c7-2e5f8a0d1b34
status: experimental
description: Detects node.exe/npm.cmd spawning command interpreters or download utilities, consistent with malicious npm lifecycle scripts (preinstall/postinstall) staging infostealer payloads as seen in the fake Web3 accelerator campaign.
references:
  - https://thehackernews.com/2026/10/fake-web3-accelerator-uses-npm-packages.html
  - https://attack.mitre.org/techniques/T1195/002/
  - https://attack.mitre.org/techniques/T1059/
author: Security Arsenal
date: 2026/10/20
tags:
  - attack.execution
  - attack.t1059
  - attack.supply_chain_compromise
  - attack.t1195.002
logsource:
  category: process_creation
  product: windows
detection:
  selection_parent:
    ParentImage|endswith:
      - '\node.exe'
      - '\npm.cmd'
      - '\npm.exe'
      - '\npx.cmd'
      - '\yarn.exe'
      - '\pnpm.exe'
  selection_child:
    Image|endswith:
      - '\cmd.exe'
      - '\powershell.exe'
      - '\pwsh.exe'
      - '\wscript.exe'
      - '\cscript.exe'
      - '\curl.exe'
      - '\certutil.exe'
      - '\bitsadmin.exe'
      - '\mshta.exe'
      - '\rundll32.exe'
      - '\regsvr32.exe'
  condition: selection_parent and selection_child
falsepositives:
  - Legitimate build tooling (node-gyp, esbuild post-install) — baseline per repo and alert on deviations
level: high
---
title: Suspicious Process Access to Browser Credential Stores or Crypto Wallets
id: 7d1e4b92-3c6f-4a8e-9d2b-5f7a1c3e8b56
status: experimental
description: Detects non-browser processes reading browser credential databases, cookie stores, or cryptocurrency wallet files — the collection behavior of the infostealer delivered by this campaign's malicious npm packages.
references:
  - https://thehackernews.com/2026/10/fake-web3-accelerator-uses-npm-packages.html
  - https://attack.mitre.org/techniques/T1555/003/
  - https://attack.mitre.org/techniques/T1539/
author: Security Arsenal
date: 2026/10/20
tags:
  - attack.credential_access
  - attack.t1555.003
  - attack.t1539
logsource:
  category: file_event
  product: windows
detection:
  selection_target:
    TargetFilename|contains:
      - '\Google\Chrome\User Data\'
      - '\Microsoft\Edge\User Data\'
      - '\BraveSoftware\Brave-Browser\User Data\'
      - '\Mozilla\Firefox\Profiles\'
      - '\Opera Software\Opera Stable\'
      - '\Roaming\Exodus\'
      - '\Roaming\Electrum\'
      - '\Roaming\MetaMask\'
      - '.config\solana\'
  selection_files:
    TargetFilename|endswith:
      - 'Login Data'
      - 'Cookies'
      - 'Web Data'
      - 'logins.json'
      - 'key4.db'
      - 'wallet.dat'
      - 'Local State'
  filter_browser:
    Image|endswith:
      - '\chrome.exe'
      - '\msedge.exe'
      - '\brave.exe'
      - '\firefox.exe'
      - '\opera.exe'
  condition: selection_target and selection_files and not filter_browser
falsepositives:
  - Enterprise password managers and EDR scanners legitimately reading browser stores — allowlist known good hashes
level: high
---
title: Node Process Executing Shell Commands on macOS
id: 9a5c3d18-2e7b-4f1a-8c4d-6b9e2f5a7c89
status: experimental
description: Detects node/npm child processes spawning shells, curl, or osascript on macOS — the install-time staging behavior used by this campaign's malicious npm packages against Mac developers.
references:
  - https://thehackernews.com/2026/10/fake-web3-accelerator-uses-npm-packages.html
  - https://attack.mitre.org/techniques/T1059/004/
author: Security Arsenal
date: 2026/10/20
tags:
  - attack.execution
  - attack.t1059.004
  - attack.supply_chain_compromise
logsource:
  category: process_creation
  product: macos
detection:
  selection_parent:
    ParentImage|contains:
      - '/node'
      - '/npm'
      - '/npx'
      - '/yarn'
      - '/pnpm'
  selection_child:
    Image|endswith:
      - '/bash'
      - '/zsh'
      - '/sh'
      - '/curl'
      - '/osascript'
      - '/python'
      - '/python3'
  selection_args:
    CommandLine|contains:
      - 'curl '
      - 'http'
      - 'base64'
      - 'chmod +x'
      - 'LaunchAgents'
      - 'security find-generic-password'
  condition: selection_parent and selection_child and selection_args
falsepositives:
  - Legitimate postinstall compilation scripts — correlate with recently added or unpinned dependencies
level: high

The KQL below hunts the same install-time staging behavior across your Windows fleet via Defender for Endpoint, and extends to AI-credential access patterns. Run it as a 14-day lookback after any suspected exposure:

KQL — Microsoft Sentinel / Defender
// Hunt: npm/node spawning shells or download utilities (install-time staging),
// plus follow-on access to credential stores and AI API key locations
let ScriptHosts = dynamic(["cmd.exe","powershell.exe","pwsh.exe","wscript.exe","cscript.exe","curl.exe","certutil.exe","bitsadmin.exe","mshta.exe","rundll32.exe","regsvr32.exe","bash.exe","sh.exe"]);
let PackageManagers = dynamic(["node.exe","npm.cmd","npm.exe","npx.cmd","yarn.exe","pnpm.exe","bun.exe"]);
let Staging =
    DeviceProcessEvents
    | where TimeGenerated > ago(14d)
    | where InitiatingProcessFileName in~ (PackageManagers)
    | where FileName in~ (ScriptHosts)
    | project StagingTime=TimeGenerated, DeviceName, AccountName, InitiatingProcessCommandLine, FileName, ProcessCommandLine, ProcessId, DeviceId;
let CredAccess =
    DeviceProcessEvents
    | where TimeGenerated > ago(14d)
    | where ProcessCommandLine has_any ("Login Data","Cookies","Web Data","key4.db","wallet.dat","Local State","find-generic-password",".env","ANTHROPIC_API_KEY","GEMINI_API_KEY","GOOGLE_API_KEY","claude")
       or FolderPath has_any ("\\Exodus\\","\\Electrum\\","\\MetaMask\\","solana")
    | project CredTime=TimeGenerated, DeviceName, AccountName, FileName, ProcessCommandLine, DeviceId;
Staging
| join kind=leftouter CredAccess on DeviceName
| where isnull(CredTime) or CredTime between (StagingTime .. StagingTime + 2h)
| project StagingTime, DeviceName, AccountName, InitiatingProcessCommandLine, ProcessCommandLine, CredAccess_Process = FileName1, CredAccess_CmdLine = ProcessCommandLine1
| sort by StagingTime desc

For IR scoping on a potentially compromised developer workstation, this Velociraptor artifact enumerates suspicious npm lifecycle scripts across installed projects — the persistence-free loader mechanism itself:

VQL — Velociraptor
-- Hunt: Enumerate npm lifecycle scripts and node child processes across endpoints
-- Fake Web3 accelerator campaign: malicious preinstall/postinstall hooks stage infostealers

LET pkg_scripts = SELECT FullPath AS PackageJson,
       read_file(filename=FullPath, length=200000) AS Content
FROM glob(globs=[
  'C:/Users/*/*/package.json',
  'C:/Users/*/Documents/**/package.json',
  'C:/Users/*/source/**/package.json',
  'C:/Users/*/projects/**/package.json',
  '/Users/*/**/package.json'
])
WHERE Content =~ '"(preinstall|install|postinstall)"'
  AND Content =~ '(curl|wget|powershell|cmd |bash|sh |base64|http://|https://(?!registry.npmjs.org))'

LET node_children = SELECT Pid, Name, Exe, CommandLine, Username, CreateTime
FROM pslist()
WHERE Name =~ '(cmd|powershell|pwsh|curl|bash|zsh|osascript|certutil|mshta)'
  AND CommandLine =~ '(curl|http|base64|-enc|iex|download|LaunchAgents|Login Data|Cookies)'

SELECT * FROM pkg_scripts
UNION ALL
SELECT NULL AS PackageJson,
       format(format='%v | %v | %v | %v', args=[Name, Pid, Username, CommandLine]) AS Content
FROM node_children

Use this PowerShell to audit a developer workstation or CI runner for exposure — it flags lifecycle scripts in dependency trees, checks npm configuration for script execution controls, and looks for recently staged executables in user-writable paths:

PowerShell
# Security Arsenal - Malicious npm Package Exposure Audit
# Run elevated on developer workstations / CI runners

$report = @()

# 1) Find package.json files with executable lifecycle hooks
$searchRoots = @("$env:USERPROFILE\source", "$env:USERPROFILE\Documents", "$env:USERPROFILE\Desktop", "$env:USERPROFILE\projects", "$env:USERPROFILE\dev")
foreach ($root in $searchRoots) {
    if (Test-Path $root) {
        Get-ChildItem -Path $root -Recurse -Filter "package.json" -ErrorAction SilentlyContinue |
          Where-Object { $_.FullName -notmatch 'node_modules' } | ForEach-Object {
            $content = Get-Content $_.FullName -Raw -ErrorAction SilentlyContinue
            if ($content -match '"(preinstall|install|postinstall)"\s*:\s*"[^"]*(curl|wget|powershell|cmd|node -e|base64|http)[^"]*"') {
                $report += [PSCustomObject]@{ Finding="Suspicious lifecycle script"; Path=$_.FullName; Detail=$Matches[0] }
            }
        }
    }
}

# 2) Scan node_modules for lifecycle hooks in installed dependencies
foreach ($root in $searchRoots) {
    if (Test-Path $root) {
        Get-ChildItem -Path $root -Recurse -Directory -Filter "node_modules" -ErrorAction SilentlyContinue | ForEach-Object {
            Get-ChildItem $_.FullName -Recurse -Filter "package.json" -Depth 2 -ErrorAction SilentlyContinue | ForEach-Object {
                $content = Get-Content $_.FullName -Raw -ErrorAction SilentlyContinue
                if ($content -match '"(preinstall|install|postinstall)"') {
                    $report += [PSCustomObject]@{ Finding="Dependency with install hook"; Path=$_.FullName; Detail="Review package provenance" }
                }
            }
        }
    }
}

# 3) Check npm global config for ignore-scripts hardening
$npmrc = "$(npm config get globalconfig 2>$null)"
$userNpmrc = "$env:USERPROFILE\.npmrc"
foreach ($rc in @($npmrc, $userNpmrc)) {
    if ($rc -and (Test-Path $rc)) {
        $cfg = Get-Content $rc -Raw
        if ($cfg -notmatch 'ignore-scripts\s*=\s*true') {
            $report += [PSCustomObject]@{ Finding="ignore-scripts NOT enabled"; Path=$rc; Detail="Set 'ignore-scripts=true'" }
        }
    }
}

# 4) Hunt recently created executables/scripts in user-writable staging paths (last 7 days)
$stagingPaths = @("$env:APPDATA", "$env:LOCALAPPDATA\Temp", "$env:TEMP")
foreach ($p in $stagingPaths) {
    Get-ChildItem -Path $p -Recurse -Include *.exe,*.dll,*.ps1,*.bat,*.js,*.vbs -ErrorAction SilentlyContinue |
      Where-Object { $_.CreationTime -gt (Get-Date).AddDays(-7) -and $_.FullName -notmatch '(npm-cache|_cacache|Microsoft\\Windows)' } |
      ForEach-Object { $report += [PSCustomObject]@{ Finding="Recent executable in staging path"; Path=$_.FullName; Detail=$_.CreationTime } }
}

$report | Format-List
if ($report) { Write-Host "`n[!] $($report.Count) findings - escalate to IR if lifecycle scripts or staging artifacts are unexplained." -ForegroundColor Red }
else { Write-Host "[+] No suspicious npm lifecycle hooks or staging artifacts found." -ForegroundColor Green }

Remediation and Hardening

There is no vendor patch for this campaign — the fix is process control and developer workflow hardening. Prioritize:

Immediate containment (if exposure is suspected):

  1. Isolate the workstation from the network. Assume full credential compromise — the stealer class of malware exfiltrates in minutes.
  2. Rotate everything the endpoint touched: browser-saved passwords, session tokens (force sign-out of all sessions, not just password resets), SSH keys, cloud CLI tokens, crypto wallet seed material (move funds to fresh wallets — rotating a wallet password does nothing), and all AI provider API keys (Anthropic Console, Google AI Studio/Vertex). Revoke and reissue; audit billing/usage logs for unauthorized consumption.
  3. Audit AI agent configurations — MCP server definitions, agent tool permissions, and any proxying of api.anthropic.com or generativelanguage.googleapis.com traffic.
  4. Forensic triage before rebuild: capture memory and run the Velociraptor artifact above. Reimage from known-good media after evidence collection.

Structural hardening (organization-wide):

  • Set ignore-scripts=true globally in npm configuration for developer machines and CI. Legitimate native modules can be built explicitly via npm rebuild on an allowlisted basis. This single control neutralizes the entire lifecycle-script delivery class.
  • Enforce lockfile pinning and integrity checks: commit package-lock.json, use npm ci (not npm install) in CI, and verify package provenance attestations (npm audit signatures) where available.
  • Gate new dependencies: require review for any package not in an approved internal registry (Artifactory/Nexus proxy with malware screening). Block direct pulls of unvetted packages in CI.
  • Browser credential isolation: enforce enterprise password managers over browser password storage, and enable hardware-bound session tokens (DPoP/passkeys) so stolen cookies are less useful.
  • EDR coverage parity on macOS: this campaign explicitly ships macOS payloads. If your Mac developer fleet lacks the same process-lineage telemetry as Windows, close that gap now.
  • AI key governance: issue AI API keys through a broker/gateway with per-developer scoping, spend caps, and usage anomaly alerting — so a stolen key is low-value and its abuse is visible.
  • Social engineering awareness: brief engineering teams specifically on accelerator/job-offer/investment lures targeting Web3 and AI developers. This is the second major wave of developer-targeted npm lures in two years, and the tradecraft (fake recruiters, fake accelerators, fake 'security audits') is consistent.

Verification: Run the PowerShell audit above across your developer fleet. Any package.json with a network-fetching lifecycle hook that you cannot attribute to a known-good build process is an incident ticket, not a curiosity.

Key Takeaways

  • The attack vector is npm install, not a software vulnerability — no CVE, no patch, no scanner finding. Your detections must be behavioral: package managers spawning shells, and non-browser processes reading credential stores.
  • macOS is a first-class target in this campaign. Endpoint parity matters.
  • AI agent credentials and traffic are now explicit theft targets. Scope them into every developer-endpoint IR.
  • ignore-scripts=true, lockfile discipline, and private registry proxying would have stopped this campaign cold. These are cheap, well-understood controls — the gap is enforcement, not knowledge.

Related Resources

Security Arsenal Incident Response Services AlertMonitor Platform Book a SOC Assessment incident-response Intel Hub

Is your security operations ready?

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