Listen to this Post
Introduction: When Trust Becomes the Weakest Link
Modern software development depends heavily on open-source ecosystems. Millions of developers rely on package managers such as npm to accelerate innovation, reuse existing code, and build applications faster. However, every dependency added to a project also introduces a potential security risk.
The recent compromise of AsyncAPI-related npm packages highlights a dangerous evolution in supply-chain attacks. Instead of simply uploading a malicious package or abusing installation scripts, attackers infiltrated a trusted development workflow and used legitimate publishing mechanisms to distribute malware. The incident demonstrates that even packages carrying valid provenance information and official publishing signatures can become dangerous when the underlying development process is compromised.
The targeted packages belonged to the AsyncAPI ecosystem, a widely used framework for designing and documenting event-driven APIs. Because one of the affected packages, @asyncapi/specs, functions as a transitive dependency for many tools, the attack had the potential to silently spread across developer environments, automated build systems, CI/CD pipelines, containers, and production infrastructure.
This attack represents a major warning for software organizations: security cannot stop at package verification. The entire software creation pipeline, from source code management to automated publishing systems, must be protected.
Summary of the AsyncAPI npm Supply-Chain Compromise
Malicious Packages Released Through Trusted Channels
The attackers published malicious versions of multiple AsyncAPI npm packages on July 14, 2026, with the campaign lasting approximately 90 minutes before detection and response actions began.
The affected packages included:
@asyncapi/specs versions 6.11.2-alpha.1 and 6.11.2
@asyncapi/[email protected]
@asyncapi/[email protected]
@asyncapi/[email protected]
The incident became especially serious because these packages were not isolated libraries. Several AsyncAPI tools depended on them either directly or indirectly, meaning developers could have unknowingly installed compromised code through normal dependency resolution.
Unlike traditional npm malware campaigns, the attackers avoided common techniques such as malicious preinstall or postinstall scripts. This allowed the malware to bypass many standard defensive practices.
Even users who installed packages with:
npm install --ignore-scripts
would not have been protected.
The malicious code executed when developers imported the compromised modules through normal JavaScript operations:
require("@asyncapi/specs");
or:
import "@asyncapi/specs";
This approach made the attack significantly harder to detect.
Deep Analysis: How the Malware Infection Worked
Hidden Node.js Execution During Application Startup
Microsoft researchers discovered that the injected code launched a hidden Node.js process after the affected package was loaded.
The malicious loader downloaded a second-stage payload called:
sync.js
The payload was retrieved from decentralized infrastructure using IPFS, making traditional domain blocking less effective.
The malware framework behind the payload was identified as Miasma, a modular system designed for:
Command execution
Credential theft
Persistence
Data collection
Remote communication
File transfers
The infection chain followed this pattern:
Developer installs AsyncAPI package
|
v
Application imports compromised module
|
v
Hidden Node.js process starts
|
v
Downloads sync.js from IPFS
|
v
Loads Miasma malware framework
|
v
Collects credentials and communicates with attackers
The Attack Started Inside GitHub Actions
Abusing CI/CD Automation for Software Supply-Chain Theft
The most concerning part of the incident was not the malware itself, but how attackers gained the ability to publish trusted packages.
Investigators believe the attack began through a malicious pull request targeting the AsyncAPI repository.
The attackers exploited an unsafe GitHub Actions configuration involving:
pull_request_target
This workflow type is powerful because it runs with access to the base repository context, including permissions and secrets.
The dangerous combination was:
pull_request_target
+
attacker-controlled code checkout
+
repository credentials
This created an opportunity for attackers to steal privileged credentials.
The compromised identity was reportedly linked to:
asyncapi-bot
Using this identity, attackers pushed unauthorized commits into publishing branches and allowed the legitimate release pipeline to distribute malicious packages.
They did not need to directly hack npm.
Instead, they abused the
Valid Signatures Did Not Guarantee Safety
The Problem With Software Provenance
One of the most important lessons from this attack involves software provenance.
The malicious packages were published using GitHub OpenID Connect trusted publishing:
npm-oidc-no-reply@github[.]com
They also contained valid provenance attestations.
At first glance, this suggested that the packages were legitimate.
However, provenance only proves:
Where software was built
Which workflow created it
Which repository produced it
It does not prove:
The repository was not compromised
The workflow was secure
The release process was authorized
A trusted pipeline can still produce malicious software if attackers gain control before the build stage.
Miasma Malware: A Modular Threat Against Developers
Cross-Platform Persistence Techniques
The downloaded sync.js payload contained an encrypted Miasma runtime measuring approximately:
8.2 MB
The malware supported multiple operating systems.
Windows Persistence
The malware created a registry entry:
miasma-monitor
Location:
HKCUSoftwareMicrosoftWindowsCurrentVersionRun
Linux Persistence
It created a systemd user service:
miasma-monitor.service
macOS Persistence
It modified shell startup files to maintain execution after reboot.
The malware stored itself in:
Windows:
%LOCALAPPDATA%NodeJSsync.js
Linux:
~/.local/share/NodeJS/sync.js
macOS:
~/Library/Application Support/NodeJS/sync.js
Credential Theft Capabilities Target Developer Environments
Developers Became the Primary Target
Although some credential-stealing modules were disabled during analysis, the malware contained functionality designed to search for valuable developer secrets.
Potential targets included:
GITHUB_TOKEN
NPM_TOKEN
AWS_ACCESS_KEY
Azure Client Secrets
Google Cloud Credentials
Docker Tokens
Kubernetes Credentials
SSH Private Keys
.npmrc Files
HashiCorp Vault Tokens
The malware could reportedly scan more than 100 common locations and environment variables used by developers and build systems.
This is especially dangerous because developers often have access to:
Production environments
Cloud accounts
Private repositories
Internal infrastructure
Deployment systems
A compromised developer workstation can become a gateway into an entire organization.
Command-and-Control Infrastructure Used Decentralized Networks
Attackers Designed Around Blocking Attempts
The malware communicated with:
85.137.53[.]71
using ports:
8080
8081
8091
However, the attackers also implemented fallback communication methods:
IPFS
Nostr
Ethereum
BitTorrent DHT
libp2p
This decentralized architecture makes infrastructure takedowns more difficult.
Traditional security controls often rely on blocking domains or IP addresses. Decentralized communication allows malware operators to continue operations even when traditional command servers are removed.
Deep Analysis: Detection and Investigation Commands
Searching for Malicious Files
Linux:
find ~/.local/share/NodeJS -name "sync.js"
macOS:
find ~/Library/Application\ Support/NodeJS -name "sync.js"
Windows PowerShell:
Get-ChildItem "$env:LOCALAPPDATA\NodeJS" -Recurse Checking Suspicious Node.js Processes
Linux:
ps aux | grep node
Windows:
Get-Process node
Searching Installed Packages
npm:
npm list | grep asyncapi
Yarn:
yarn list | grep asyncapi
Checking GitHub Tokens and Secrets
Linux:
env | grep TOKEN
Windows:
Get-ChildItem Env:
Removing Potentially Compromised Dependencies
Example:
npm uninstall @asyncapi/specs npm cache clean --force npm install
Organizations should rebuild affected environments from trusted images rather than relying only on cleanup.
Organizational Response Recommendations
Immediate Actions Required
Security teams should:
Remove all affected AsyncAPI package versions.
Review dependency lock files.
Search build artifacts and container images.
Investigate CI/CD activity.
Rotate exposed credentials.
Rebuild developer environments.
Purge npm and Yarn caches.
Monitor unusual Node.js execution behavior.
Microsoft Defender detects related threats as:
Trojan:JS/MiasmStealer.SC
and:
Trojan:Script/Supychain.A
What Undercode Say:
The AsyncAPI incident represents a turning point in software supply-chain security.
Attackers are no longer only targeting vulnerable packages.
They are targeting trust itself.
The most dangerous part of this attack was not the malware payload.
It was the abuse of legitimate systems.
The attackers used:
GitHub workflows
Trusted publishing
Valid provenance
Official automation
Real project identities
Everything looked authentic.
That is what makes modern supply-chain attacks so difficult.
Many organizations believe package signatures solve the problem.
They do not.
A signed malicious release is still malicious.
The security industry must move beyond artifact verification.
Future defenses must analyze the entire software lifecycle.
Developers are becoming high-value targets because their machines contain powerful access.
A stolen developer token can be more valuable than a stolen password.
Attackers understand that one compromised engineer can unlock cloud environments, source repositories, and production systems.
CI/CD pipelines have effectively become part of the attack surface.
Many organizations protect servers better than they protect build systems.
That imbalance must change.
GitHub Actions, Jenkins, GitLab pipelines, and similar automation platforms should be treated like production infrastructure.
Every workflow permission should be minimized.
Every secret should be protected.
Every pull request should be treated as potentially hostile.
The AsyncAPI attack also proves that open-source security cannot depend only on maintainers.
Large ecosystems require stronger automated monitoring.
Dependency scanning must include behavioral detection.
Security tools should ask:
“Does this package behave like the software it claims to be?”
not only:
Does this package have a known vulnerability?
The future of software security will require identity protection, pipeline protection, and runtime monitoring working together.
Supply-chain attacks will continue because they offer attackers maximum impact with minimum effort.
One compromised package can reach thousands of organizations.
One stolen token can open millions of dollars worth of infrastructure.
The lesson is clear:
Trust must become continuously verified.
✅ Confirmed Facts
✅ The AsyncAPI npm packages were compromised through a software supply-chain attack involving malicious versions distributed through legitimate publishing mechanisms.
✅ The malware execution method differed from traditional npm attacks because it activated during package import rather than installation scripts.
✅ The attack highlights risks involving GitHub Actions workflows, repository secrets, and trusted publishing systems.
❌ Unverified or Requires Additional Confirmation
❌ Exact attacker identity has not been publicly confirmed.
❌ The full number of affected developers and organizations remains unknown.
❌ Some reported credential-stealing features were identified in malware code but were not necessarily active during the analyzed campaign.
Prediction
(-1) The Next Wave of Supply-Chain Attacks Will Target Development Infrastructure More Aggressively
Attackers are expected to increasingly focus on:
GitHub Actions secrets.
CI/CD credentials.
Package publishing accounts.
Developer machines.
Cloud deployment pipelines.
(+1) Organizations that adopt zero-trust development practices, stronger workflow isolation, and continuous software integrity monitoring will significantly reduce the impact of future attacks.
The software industry is entering an era where protecting code is no longer enough.
The systems that create, publish, and deploy that code must become the new security priority.
▶️ Related Video (72% Match):
🕵️📝Let’s dive deep and fact‑check.
🎓 Live Courses & Certifications:
Join Undercode Academy for Verified Certifications
🚀 Request a Custom Project:
Secure, high-velocity infrastructure and disruptive technological engineering. Contact our engineering team for high-tier development and proprietary systems:
[email protected]
💎 Smart Architecture | 🛡️ Secure by Design | ⭐ Trusted by Thousands
References:
Reported By: cyberpress.org
Extra Source Hub (Possible Sources for article):
https://www.facebook.com
Wikipedia
OpenAi & Undercode AI
Image Source:
Unsplash
Undercode AI DI v2
🔐JOIN OUR CYBER WORLD [ CVE News • HackMonitor • UndercodeNews ]
📢 Follow UndercodeNews & Stay Tuned:
𝕏 formerly Twitter 🐦 | @ Threads | 🔗 Linkedin | 🦋BlueSky | 🐘Mastodon | 📺Youtube
