Search: gemini.com
63 threats
Most recently published first
| Severity | CVSS | Signals | Threat | Source | Published | Score and star |
|---|---|---|---|---|---|---|
| Malicious | – | MaliciousGCVE Database The gemini-cli-a2a-server npm package version 1.0.0 contains malicious code that executes during installation. Its postinstall script collects host system identifiers and sends them to a hardcoded external URL. The package name mimics an internal Google Gemini CLI component, suggesting it is used for dependency confusion attacks to exfiltrate environment data when mistakenly installed instead of the intended private package. | GCVE Database | |||
| Medium | 6.7 | EPSS 0.7% | Medium6.7EPSS 0.7%GCVE DatabaseCVE-2025-64340 A command injection vulnerability exists in FastMCP when installing the claude-code or gemini-cli tools on Windows. Server names containing shell metacharacters such as '&' can cause arbitrary command execution due to how Windows .cmd wrappers are invoked via cmd.exe. This affects FastMCP versions from 0.11.9 up to but not including 0.23.0. The issue does not affect macOS or Linux, nor config-file-based install targets. The vulnerability is patched in version 0.23.0 by validating server names to reject shell metacharacters. | GCVE Database | ||
| Medium | 4.8 | EPSS 0.2% | CVE-2026-19368PV-Bhat gemsuite-mcp · Path Traversal Medium4.8EPSS 0.2%CVE Database V5CVE-2026-19368 CVE-2026-19368 is a path traversal vulnerability in PV-Bhat gemsuite-mcp version 1.0.0. It affects an unspecified functionality in the file src/handlers/unified-gemini.ts related to components gemini_search, gemini_reason, gemini_process, and gemini_analyze. The vulnerability arises from manipulation of the file_path or file_paths argument, allowing local attackers to perform path traversal. The vendor has not yet responded or issued a fix. EPSS 0.2%Vulnerability | CVE Database V5 | ||
| Malicious | – | MaliciousGCVE Database --- _-= Per source details. Do not edit below this line.=-_ ## Source: amazon-inspector (91ae2c72e5e03d23f3f5704859e8c92b9ce6c565c6d14d744d4382b980a0d233) This WhatsApp bot package ships several mechanisms that give the author persistent remote control of any installer's running instance and access to the installer's WhatsApp account. config.env and config/index.js hardcode OWNER_NUMBERS (falling back to '94726800969' when unset) that parser.js uses to set isCreator/isOwner; src/commands/filemanager.js exposes creator-gated WhatsApp commands (.getfile,.putfile,.mkdir,.fullzip) that read arbitrary files under the bot project root, overwrite files, and zip the entire project tree back to the remote party — giving the hardcoded author numbers full file read/write and full-tree exfiltration over WhatsApp. config/index.js also defaults MONGODB_URI to 'mongodb+srv://unity-free:unity-free@unity-free.pc6vkvw.mongodb.net/...', and src/commands/index.js persists the Baileys auth state (creds and signal keys — the full auth material for the paired WhatsApp account) into that database via useMongoDBAuthState, so an installer running with shipped defaults uploads their WhatsApp session credentials to a cluster whose credentials are controlled by the author, enabling remote account takeover. config.env additionally ships live TG_PAIR_BOT_TOKEN and TG_SUPER_BOT_TOKEN plus hardcoded TG_ADMIN_IDS; src/telegram/superBot.js polls these tokens at startup and gates commands (/pair, downloads, session management) on isAdmin() matching those hardcoded IDs, providing a second remote-control channel into every default-configured installer. The package also ships additional third-party credentials belonging to the author (Gemini API key, Gmail SMTP app password, dashboard secret/password). | GCVE Database | |||
| Malicious | – | MaliciousGCVE Database --- _-= Per source details. Do not edit below this line.=-_ ## Source: amazon-inspector (fc34f69b5a68c549feccfb32cc2dbfbf2d4c787a4876241027b4299305fd2c53) The package is a platform-specific leaf (linux/arm64) whose only shipped artifact is a 12 MB stripped Go binary at bin/sxt. The package.json omits repository, author, main, bin, files, and scripts fields, and its license field points at github.com/ddos798/claude_control — a self-labeled 'claude_control' project. Strings in bin/sxt reveal a full WebRTC stack (pion/webrtc/v4, pion/turn/v5, pion/ice/v4, coder/websocket, go-qrcode) plus a hardcoded signaling/relay endpoint https://relay.sextant.top/install, giving the binary the shape of a remote-control agent that pairs the installer's host to an author-controlled peer over WebRTC data channels. Adjacent strings 'sk-ant-', 'CLAUDE_CONFIG_DIR', 'https://api.anthropic.com/v1/models', 'https://claude.ai/install.sh', and '@google/gemini-cli' show the binary is positioned to read Anthropic API keys and Claude Code / Gemini CLI configuration from the installer and hand them to the remote peer through the established channel. An additional string http://ip-api.com/json/ provides public-IP geolocation of the host for the remote operator. The combination of an opaque metadata-only npm manifest, a bundled native binary embedding a full peer-to-peer control stack, a hardcoded author relay, and embedded references to developer AI-credential material is a backdoor with credential-theft capability against the installer. | GCVE Database | |||
| Malicious | – | MaliciousGCVE Database --- _-= Per source details. Do not edit below this line.=-_ ## Source: amazon-inspector (23978b08a7e3f8af97d2c8060e7fc3aca9a18d9f3435163a9d3ab97ac0b9d4d0) Package ships a darwin/arm64 Go binary that opens an outbound WebSocket to a hardcoded author-controlled relay at wss://relay.sextant.top and links a PTY library (github.com/creack/pty) with a WebSocket client (github.com/coder/websocket), implementing the network-driven pseudo-terminal remote-shell pattern that yields full-host code execution to the operator of that relay. The binary additionally binds listeners on 0.0.0.0:7280, 0.0.0.0:7281, and 0.0.0.0:9000 (a 'ws://%s:%s%s' format string is present), exposing the PTY/WebSocket surface to the local network rather than loopback. Embedded strings include a regex specifically matching Anthropic API keys ('sk-ant-[a-z0-9]+-[A-Za-z0-9_-]{40,}') and references to CLAUDE_CONFIG_DIR and ~/.claude paths, allowing extraction of the installer's Anthropic credentials, which are then reachable via the same relay channel. A separate POST to https://relay.sextant.top/install combined with a call to http://ip-api.com/json/?fields=status,message,country,countryCode,city,timezone,query reports installer geolocation and host identity to the author. The npm-facing metadata describes the package only as 'Sextant (sxt) binary for darwin/arm64', while the license field points to a GitHub repository named 'claude_control' — the shipped functionality (remote control of Claude Code / Gemini CLI sessions plus API-key exfiltration) is not disclosed in the package description or README. | GCVE Database | |||
| –Not rated | – | SecurityWeek A crafted prompt to a low-privilege Google ADK agent could be used to pass a malicious hand-off comment to a privileged agent. The post Gemini Agent-to-Agent Attack Method Exposed Secrets, Enabled Pull Request Tampering appeared first on SecurityWeek . | SecurityWeek | |||
| –Not rated | – | Cisco Talos Actor usage of AI is exploding. By analyzing artifacts left behind, Talos has created a detailed analysis of how we are seeing adversaries leverage the technology to include development, force multiplication, and vulnerability research. Based on the evidence Talos gathered, guardrails did not provide much protection, with most actors able to convince the models to comply despite the lack of sophisticated techniques or encoding. The pre-existing skill of the actor has a large impact on what they can accomplish with AI. Talos observed novice users able to create malicious capabilities, albeit with limited capabilities and success. Advanced users were able to build astonishing capabilities, pushing the models to create sophisticated and complex outputs. Artificial intelligence (AI) and associated language models are now ubiquitous and heavily used in both personal and professional contexts to streamline tasks and expand capabilities. With AI being used everywhere and by almost everyone, one of the biggest questions is how malicious actors are taking advantage. Fortunately, actors make mistakes and chatbots leave artifacts. Leveraging cloud-based AI models leaves behind a variety of artifacts, most notably a prompt log. These logs can take on a variety of shapes and sizes, but they are left on endpoints that are running various applications, such as Claude Code, CodeX, Cursor, or Gemini. Over the course of our research, we’ve collected a significant corpus of these files and can start discussing the ways we see bad actors leveraging these technologies. In conducting the research, three categories of activity emerged. One was using AI as a malicious software engineer, leveraging AI to write (in some cases) very sophisticated code with clear malicious intentions. Another was actors leveraging AI to scale criminal operations and campaigns. Finally, there were a lot of actors leveraging it for bug bounty or vulnerability research, rapidly accelerating their capabilities of discovery and disclosure. Each category demonstrates how threat actors are currently leveraging AI. Within each category is a wide disparity in sophistication based on the knowledge level of the actors involved. We tried to include use cases to cover the breadth of what we found. Takeaways and high-level findings With the recent disclosures from Hugging Face and OpenAI , it's clear the era of agentic attackers has effectively arrived. In that incident, the models were operating inside a sanctioned evaluation with safeguards deliberately relaxed — but they autonomously escaped their sandbox, found and chained real vulnerabilities, and compromised production infrastructure to reach their objective. The capabilities exist; the only missing ingredient is malicious intent, and it's a matter of time before threat actors supply it. For defenders, this is a wake-up call: Vulnerabilities will surface faster, exploitation will happen sooner, and the actors behind it won't need rest or downtime. As the case studies below show, the central challenge for guardrails right now is supporting legitimate dual-use work — red teaming and vulnerability research — without empowering malicious actors. One of the immediate takeaways is that guardrails are not functioning as expected. We did not encounter any sophisticated encoding or techniques designed to trick the models — most of the time it was a simple “I'm allowed to do this,” and the model complied. When guardrails did engage, they accomplished little. In one instance, we watched an actor abandon a censored model and pivot to an uncensored version, which completed the task without question. In another, a model pushed back on a distributed denial-of-service (DDoS) operator, but by that point the tooling had already been built. This wasn't specific to a single model or platform; it was across the board. The other big takeaway is that an actor's skill level largely determines how effectively AI can be leveraged and how much impact it u… | Cisco Talos | |||
| –Not rated | – | Bleeping Computer ESET's H1 2026 Threat Report highlights a rise in malicious use of AI skills and AI-assisted malware. Attackers are adapting established techniques to AI platforms and emerging technologies, including social engineering methods like ClickFix and increased QR code phishing (quishing). The report also notes ransomware tools designed to disable security software (EDR killers) remain prevalent. The use of AI in malware, such as the Android PromptSpy leveraging Google's Gemini, illustrates growing flexibility in threats. Overall, attackers are scaling campaigns by combining AI, social engineering, and ransomware innovations. | Bleeping Computer | |||
| –Not rated | – | Tenable Research Attackers have shifted from hiding from AI tools to running inside them. By poisoning the config files that govern AI coding assistants, a new worm class achieves silent persistence, evades AI-based scanners, and spreads across an organization's repositories through developers' own tools. Key takeaways AI coding assistant configuration files, such as settings.json hooks, .cursorrules Cursor MDC rules, and similar harness files, are now explicit targets in supply-chain attacks, not collateral damage. These files simultaneously sit at the intersection of three trust relationships: The developer trusts them as config, the integrated development environment (IDE) executes them automatically, and the large language model (LLM) treats them as authoritative instructions, making them a uniquely powerful persistence vector. Defenders should treat harness config files as code that requires mandatory reviews and hash pinning in the CI/CD pipeline; enforce --ignore-scripts on package installs; and flag AI scanner refusals as a suspicious signal rather than a clean result. While analyzing a recent Mini Shai-Hulud campaign and its other variants, Tenable made a discovery: The payload wasn’t just stealing tokens and exfiltrating credentials. It was rewriting the configuration files that tell AI coding assistants what to do every time a developer opens a project. The Mini Shai-Hulud worm, which targets npm, PyPI, and other third-party registries simultaneously, includes a dedicated module that scans the developer’s home directory for configuration files belonging to AI coding tools by name, such as Anthropic’s Claude Code, Google’s Gemini CLI, Microsoft’s GitHub Copilot, SpaceX’s Cursor, OpenAI’s ChatGPT Codex, Cline’s eponymous tool, the open-source tool Aider, and others. For each one it finds, it injects a hook command which helps the malware stay persistent. From that point forward, every time the developer starts an AI coding session, the malware runs silently and automatically, and with the same level of trust the developer placed in their own tools. This is a deliberate architectural choice: The attacker modeled the execution environment, identified the highest-privilege auto-run mechanism available on a developer’s machine, and built the attack specifically for it. Supply-chain attacks used to end at credential theft. Now the AI agent’s harness is both the target and the propagation vector. Why AI agent harness files are a uniquely attractive target For years, defenders have focused supply-chain security on the package itself: Inspect the preinstall script, scan the tarball, verify the checksum. That model assumes the malicious payload lives only inside the installed artifact. The threat described here breaks that assumption: The payload lands in a completely different place. AI coding assistants’ configuration files occupy a structural position unlike any other file in a developer’s working environment. They are simultaneously trusted as developer configuration, so they survive aggressive code reviews focused on business logic; are executed automatically by the IDE, so no user interaction is required after initial compromise; and are treated as authoritative instructions by the AI model itself, so the LLM will act on their content without prompting the user. No other file class has all three properties at once. A malicious package.json script requires execution. A malicious comment in source code requires a developer to act on it. A malicious hook in .claude/settings.json runs every time the developer opens a session. The attack surface is also nearly invisible to conventional scanning. These files are small, structured, and look identical to legitimate developer config. A poisoned settings.json with a malicious SessionStart hook has the same schema and structure as a clean one; the only difference is what the command field points to. Meanwhile, the files are rarely subject to the same review discipline as production code. They live… | Tenable Research | |||
| –Not rated | – | Bleeping Computer Researchers escaped the sandboxes in Cursor, Codex, Gemini CLI and Antigravity by having the AI agent write files that trusted host tools later run. Multiple CVEs, patches, and Google downgrading two Antigravity findings. [...] | Bleeping Computer | |||
| –Not rated | – | Bleeping Computer A Russian-speaking threat actor known as "bandcampro" used Google's open-source Gemini CLI AI tool as a hacking agent and to operate a small-scale botnet. [...] | Bleeping Computer | |||
| –Not rated | – | AlienVault OTX General A Russian-speaking threat actor known as 'bandcampro' leveraged Google Gemini CLI to migrate and operate a command-and-control botnet in six minutes, with the AI handling 89% of all work including architecture, coding, deployment, and debugging. Analysis of 200 Gemini CLI session logs from March-April 2026 revealed the actor controlled eight computers in a dental clinic, accessing OpenDental databases. The actor communicated intentions in plain Russian while AI executed technical operations. The entire C&C infrastructure fits in three plain-text files totaling 5KB, making it highly portable and disposable. Beyond botnet operations, the actor used AI for password cracking, WordPress compromise, and planning cryptocurrency fraud targeting elderly victims in the US and Canada. The AI proactively suggested improvements 59 times unprompted, demonstrating how AI lowers barriers for threat actors by replacing technical skill requirements with simple natural-language instructions. | AlienVault OTX General | |||
| –Not rated | – | Reddit Cybersecurity A recent report highlights how a jailbroken AI model named Gemini was used to rapidly create a new command-and-control (C2) server for a Russian fraudster in just six minutes. This incident demonstrates the increasing speed and efficiency with which AI-enabled attackers can operate, lowering the technical skill barrier for malicious activities. The threat involves botnet activity facilitated by AI automation. No specific affected software versions or patches are identified. The report is based on a Reddit cybersecurity discussion linking to an external article. | Reddit Cybersecurity | |||
| Malicious | – | MaliciousGCVE Database --- _-= Per source details. Do not edit below this line.=-_ ## Source: amazon-inspector (076f813c0d0a60ee43f7a73f8aad609e5043cd8d92b57b5c3c3c08954accbb4f) The package impersonates the popular express-session library by copying its name pattern, author metadata (TJ Holowaychuk <tj@vision-media.ca>), and repository field (expressjs/session-kit). The library body is a verbatim copy of express-session with a dropper appended to index.js: an initServer() function invoked at module load spawns a detached, stdio-ignored `node` subprocess to run a sibling payload script. That payload (session/check.js) performs an HTTP GET to http://check-server-state.vercel.app/server/v2 with a `bearrtoken: gemini` header, and when the endpoint responds with HTTP 404 carrying a JSON `token` field, wraps that field with `new Function("require", err.response.data.token)` and immediately invokes it with the real require — granting the remote endpoint arbitrary code execution in the Node process. Delivery via a 404 error body is a covert channel designed to look like a benign failed probe. Although the current dropper references./lib/check.js while the payload actually ships at./session/check.js and the spawn/path bindings are not imported (so the current tarball's dropper would throw before spawning), the second-stage payload file is present, complete, and directly requireable; any consumer that requires the payload — or a trivial fix in a subsequent version — makes the RCE live. Combined with the typosquat cover, this is a supply-chain attack targeting developers who mistype express-session. ## Source: ghsa-malware (44b1bb99fbd84a5cd6a12254371c4689b14a2b8f679157961cd58e26b87b26f9) Any computer that has this package installed or running should be considered fully compromised. All secrets and keys stored on that computer should be rotated immediately from a different computer. The package should be removed, but as full control of the computer may have been given to an outside entity, there is no guarantee that removing the package will remove all malicious software resulting from installing it. | GCVE Database | |||
| Critical | 10.0 | EPSS 0.2% | CVE-2026-12537Google Cloud Gemini CLI · Improper Input Validation Critical10.0EPSS 0.2%CVE Database V5CVE-2026-12537 CVE-2026-12537 is a critical vulnerability in Google Cloud Gemini CLI and the run-gemini-cli GitHub Action that allows an unprivileged attacker to execute code on the host system. This occurs due to improper input validation leading to OS command injection via a maliciously crafted .gemini/.env file on headless CI platforms. The vulnerability affects Gemini CLI versions prior to 0.39.1 and run-gemini-cli GitHub Action versions prior to 0.1.22. A patch is available to address this issue. | CVE Database V5 | ||
| –Not rated | – | Tenable Research A stolen session cookie sat in underground markets for seven weeks before attackers used it to poison 32 Red Hat packages in the npm software registry, an example of the industrial approach behind modern supply chain attacks. Key takeaways Miasma is a self-propagating npm worm derived from Mini Shai-Hulud that TeamPCP open-sourced on May 12. The public release of the full weaponized toolchain means any operator can now replicate structurally identical supply chain campaigns. The Miasma campaign compromised 89-plus npm packages across three waves (June 1-5), affecting Red Hat, Vapi.ai, and Microsoft Azure repositories. The worm produced malicious packages with valid SLSA Build Level 3 provenance attestations, defeating the highest tier of supply-chain integrity verification. The root cause was a stolen developer credential that sat in infostealer logs for seven weeks before weaponization. This infostealer-to-supply-chain pipeline is the defining pattern of the Developer Credential Economy. The Miasma campaign’s third wave (June 5) introduced a significant escalation: persistence files that target AI coding assistants (Claude Code, Cursor, Gemini CLI, VS Code), expanding the attack surface from package registries to the developer’s local environment. Relying on execution-layer detection, such as EDR, is insufficient against supply chain threats because EDR tools lack visibility into the ephemeral CI/CD environments where credential theft and weaponization occur. Organizations should treat developer credentials as control-plane infrastructure and adopt a phased Continuous Threat Exposure Management (CTEM) approach: harden the generation layer, neutralize harvested secrets in real time, and enforce human-gated publishing controls. Background on the Miasma worm and npm supply chain attack On June 1, the Miasma self-propagating worm compromised 32 official npm packages under the @redhat-cloud-services namespace, delivering a credential-harvesting payload to an estimated 80,000 to 117,000 weekly downloads. Within five days, the campaign escalated through three distinct attack waves and forced GitHub to disable 73 repositories across four Microsoft organizations . The technical details of the Miasma supply-chain attack are alarming: valid Supply Chain Levels for Software Artifacts (SLSA) provenance attestations on malicious packages; a novel execution technique that bypasses install-script monitoring; and a new persistence mechanism that targets AI coding assistants. But the most important detail is a timestamp. Dark web monitoring firm Whiteintel detected a Red Hat employee’s GitHub credential and session cookie in infostealer logs on April 13. A second sighting appeared on May 15. The credential sat in underground markets for approximately seven weeks before attackers weaponized it on June 1. That seven-week gap is the signature of an emerging threat model that Tenable’s Research Special Operations (RSO) team calls the Developer Credential Economy , and has been tracking since March 2026. The Developer Credential Economy is a structured black market for highly privileged developer credentials where open-source supply chain compromises function as credential generation infrastructure, underground markets serve as the distribution layer, and multiple threat actors with distinct motivations weaponize the harvested access downstream. The Miasma campaign is the clearest example of this model to date, and it validates a pattern that has been accelerating across the npm, PyPI, and GitHub ecosystems throughout 2026. The three-layer economy, explained through Miasma When it first assessed this pattern in March, Tenable RSO built the analysis around the TeamPCP cascading campaign (Trivy, KICS, LiteLLM, Telnyx, and 66+ npm packages) and the Sapphire Sleet/UNC1069 Axios compromise . The thesis identified a three-layer structure: credential generation, distribution, and weaponization. Three months later, the Miasma campaign validates each layer with striking clarity. Layer Actor / group Operational focus Primary targets Miasma validation Generation TeamPCP Bulk credential harvesting via tool exploitation Trivy, KICS, TanStack, Red Hat npm scope Miasma's payload sweeps GitHub tokens, cloud credentials, CI/CD secrets, SSH keys, and .env files from every infected environment Distribution Underground markets, infostealer aggregators Credential brokering and tooling proliferation Stolen developer credentials; open-sourced worm code Red Hat employee credential sat in infostealer logs for seven weeks before weaponization; Shai-Hulud source published May 12 Weaponization Sapphire Sleet (DPRK-nexus), LAPSUS$, Miasma operator, copycat actors State-sponsored exfiltration, data theft, cascading supply chain compromise Axios (npm), Mercor AI, @vapi-ai/server-sdk, Azure/durabletask Each Miasma wave generates A fresh credential pool, feeding the next wave and enabling downstream actors Layer 1: Credential generation The Developer Credential Economy’s first layer is extraction. Threat actors compromise developer tooling and open-source infrastructure not primarily to distribute malware to end users, but to harvest the credentials those environments contain, such as GitHub tokens, npm publishing tokens, cloud provider credentials, CI/CD secrets, SSH keys, and API keys. TeamPCP pioneered this at scale beginning in September 2025 with the original Shai-Hulud worm. Its defining innovation was cascading credential extraction: compromise one trusted tool, harvest the credentials it holds, and use those credentials to compromise the next tool in the dependency chain. The Trivy vulnerability scanner compromise yielded CI/CD runner secrets. Those secrets enabled the KICS compromise . KICS yielded additional cloud credentials. Each link in the chain generated a broader set of privileged access. By May, TeamPCP had refined this into the Mini Shai-Hulud variant, which introduced two capabilities that made the generation layer dramatically more efficient: Wormable propagation : The malware queries the npm registry for every package the compromised identity can publish, and republishes itself across all of them automatically. CI/CD pipeline hijack via OpenID Connect (OIDC) token extraction : Rather than stealing static credentials, Mini Shai-Hulud requests short-lived OIDC tokens through GitHub Actions, enabling it to publish packages with valid cryptographic provenance. In the Miasma supply chain campaign, this generation layer operated through a Red Hat employee’s compromised GitHub account. The worm’s payload swept the infected environment for: GitHub tokens and personal access tokens npm publishing tokens AWS, GCP, and Azure cloud credentials HashiCorp Vault tokens Kubernetes service account tokens SSH private keys Docker registry credentials GPG keys .env files The June variant added dedicated collectors for GCP and Azure cloud identities, going beyond secret extraction to enumerate all cloud access the infected machine holds. Every machine that ran npm install against a compromised @redhat-cloud-services package version became a credential generation node. Layer 2: Distribution The second layer is the marketplace. Stolen credentials flow from the generation layer into underground markets, infostealer log aggregators, and access brokering services, where they become available to any buyer. The Miasma supply chain-attack timeline makes this layer visible in a way previous campaigns did not. Whiteintel detected the Red Hat employee’s GitHub credential and session cookie in infostealer logs on April 13. That credential was not generated by a targeted supply chain attack against Red Hat; a commodity infostealer harvested it, one of 13.2 million infostealer infections that SpyCloud's 2025 Identity Exposure Report documented as producing an average of 50 credentials per infection. The credential entered the distribution layer as one data point among billions: SpyCloud recaptured 5.3 billion credential pairs, 18.1 million exposed API keys and tokens, and 8.6 billion stolen session cookies from criminal underground monitoring in 2025 alone. For seven weeks, the credential sat in the distribution layer before someone acted on it. That dwell time is the systemic gap that the Developer Credential Economy exploits. Organizations that do not monitor underground markets for exposed developer credentials are operating on the assumption that the generation-to-weaponization pipeline does not exist, or that it operates too slowly to matter. Miasma demonstrates that even a seven-week window, which is long by underground market standards, is more than sufficient for weaponization. The distribution layer was further amplified on May 12, when TeamPCP published the complete Mini Shai-Hulud source code on GitHub under an MIT License with the message “Shai-Hulud: Open Sourcing The Carnage.” The release included CI cache-poisoning scripts, the OIDC token extractor, and the credential stealer with its propagation logic. This is the supply chain equivalent of publishing a working exploit framework: the tooling itself became a distribution channel, lowering the barrier to entry for any operator who wants to run a structurally identical campaign. Layer 3: Weaponization The third layer is operational use. Actors with distinct motivations acquire credentials from the distribution layer and weaponize them against specific targets. In March, the RSO team documented at least three distinct actors operating from the same credential pool : TeamPCP harvested at scale: Sapphire Sleet/UNC1069 (DPRK-nexus) operationalized stolen npm tokens for financial gain through the Axios compromise and LAPSUS$ exploited compromised Tailscale VPN credentials from the LiteLLM breach for data theft from Mercor AI. The same credential ecosystem fed all three. Miasma’s weaponization layer continues to evolve, but the trajectory across its three waves demonstrates the pattern: Wave 1 (June 1) used the stolen R | Tenable Research |
Page 2 of 4 · 3 duplicate CVE records merged