Cloud environments are increasingly vulnerable not just through servers and networks, but through tooling used during software development. A growing pattern of supply chain attacks shows attackers embedding credential-stealing malware within trusted packages and development utilities. Once on a developer’s machine or within automated build systems, malicious code can steal access keys, tokens, private keys, or repository credentials—even before an application is fully built. This allows attackers to break into cloud infrastructure, siphon off data, or remain hidden well before software ever reaches production.
Shai-Hulud and Mini Shai-Hulud: Malware Hunting Secrets
One notable campaign, Shai-Hulud, emerged in September 2025. It specifically targeted developer tools by deploying scripts that searched infected environments for cloud credentials. If those secrets were discovered, the malware uploaded them to attacker-controlled GitHub repositories. In later waves, including one dubbed Mini Shai-Hulud, attackers shifted tactics—using pre-installation scripts that run before a package is fully installed. The scale of Mini Shai-Hulud’s May 2026 round was substantial: nearly 639 package versions across 323 packages were compromised.
Other malicious campaigns mimicked innocuous developer utilities in ecosystems like Ruby and Go. For example, BufferZoneCorp published gems and modules disguised as helpful tools, but which secretly gathered credentials, weakened package verification, and stealthily added attacker-controlled keys to maintain access. Similarly, breaches impacting scanning tools and libraries—such as those feeding into cloud build pipelines—allowed attackers to slip in unnoticed.
The exposure reaches broadly. In April 2026 alone, attacks targeted major repositories—npm, PyPI, Docker Hub—within just 48 hours. Some malicious packages falsely claiming to be search-libraries stole pipeline secrets and cloud credentials. Attackers then used compromised publishing tokens to spread their reach into more packages, amplifying the damage from a single compromised developer account.
Strategies to Defend the Build Chain
Simply removing bad packages isn’t enough. Defenders need to assume secrets housed on either developer machines or build systems may already be compromised. Best practices include revoking or rotating exposed credentials, auditing cloud activity during the period of exposure, and ensuring all dependencies are approved and version-locked via lockfiles. When possible, automatic install scripts should be disabled unless strictly necessary and reviewed. Build jobs should run with the minimum permissions required; deployment and compile phases should be separate. Temporary credentials and restrictive cloud policies help limit lasting damage.
Additional safeguards include hardening cloud metadata services, particularly when build systems don’t need them. Using more secure identity mechanisms—such as managed or federated identities—and enforcing recent best practices (AWS’s IMDSv2, for instance) can make it harder for attackers to pivot within cloud infrastructure. Monitoring audit logs for unusual resource creation, access jumps, or newly introduced components is critical to understanding how far an attack may have penetrated.
Security monitoring tools should also track indicators of compromise (IoCs) like unexpected references to configuration or credentials files (e.g. ~/.aws/credentials, ~/.kube/config), environment variables (AWS_ACCESS_KEY_ID, GITHUB_TOKEN), or other artifacts like unauthorized_keys files. Even domain names like webhook.site may serve as exfiltration targets despite appearing benign. Recognizing these signs early can mean the difference between a contained breach and a widespread compromise.
This trend makes clear that the traditional boundary between ‘developer environment’ and ‘production/cloud infrastructure’ is collapsing. Attack vectors now routinely walk across that boundary, using tools and packages to infiltrate clouds long before deployment.
What this means: modern security demands that firms treat development environments and cloud infrastructure as a unified attack surface. Guarding just one side leaves the system exposed. Monitoring dependencies, separating duties, enforcing tight permissions, and deploying zero-trust thinking to development workflows are no longer optional—they’re essential. Expect more shifts like this where attackers exploit trust in supply chains. Teams that proactively reduce what their build tools can access—and continuously audit credentials—will stand a far better chance at staying ahead of threats.