Explore 31 source-supported AI security cases for 13.19 · Credential and Token Exposure in Databricks DASF 3.0, with evidence, scope, and defensive analysis.
Risk category
API keys, OAuth tokens, or other credentials are exposed through unsafe handling, storage, or transmission. Examples include hardcoded secrets, stolen tokens, and credentials written to logs. Because MCP integrations use these credentials to reach other services, disclosure can expose the authority those integrations hold.
Mittwald’s MCP integration connected AI assistants to its hosting-management service. The provider confirmed stolen session tokens and compromised projects, illustrating how a connector incident can inherit the connected user’s authority. The public record supports precise revocation and recovery guidance, but not a reconstructed exploit payload.
Why it relates: The operator confirms exposure and abuse of session tokens associated with the MCP server.
The confirmed token and project effects are retained; the unpublished extraction mechanism and later incident relationship remain unknown.
Cato validated code execution and login-token theft through a malicious model endpoint in Open WebUI, a self-hosted AI-chat interface. The victim must use an enabled Direct Connections integration; the endpoint’s SSE execute event runs in the browser without requiring a model-generated attack. Reusing the token can additionally reach backend Python execution only when the account has workspace.tools permission.
Why it relates: A browser-stored login JWT is exposed through unsafe AI integration response handling. The credential belongs to Open WebUI, and the channel is model SSE rather than MCP. The shared fact is credential exposure across the AI client boundary.
Model-protocol events and a conditional account-to-backend execution path; the malicious event need not be model-generated.
Check Point researchers tested how Claude Code, an AI coding assistant, loads files from an untrusted repository. Separate hook, MCP startup and API-base-URL paths produced local command execution or API-key disclosure. The hook path required accepting repository trust; the other two could act before that decision. The demonstrated workspace-file access was limited to the tested key and workspace.
Why it relates: The shared risk is credential exposure in an AI tool client: an endpoint override sends its API key to the attacker. The leaked credential is for the Anthropic API, not an MCP authentication token; the MCP category is used for its same client-side credential-transmission boundary.
Three native project-startup paths, with the tested credential consequence. Model prompt interpretation is not the exploit.
Zeabur, a platform for hosting applications and databases, reported an October 14-15 intrusion affecting hosted AI-service credentials. Attackers used leaked internal credentials across cluster and cloud boundaries; a replacement credential was captured in a later backup and subsequently used without authorization. Customers own upstream-key revocation and recovery of deployments they administer; the operator owns internal isolation and backup access.
Why it relates: Hosted integration credentials were targeted and exposed through unsafe custody and privileged reads, matching the credential-exposure mechanism. DASF places this category under MCP server tools. No MCP server is established here; the overlap is credential custody and disclosure, not MCP protocol behavior.
October operational incident only. Shared mechanisms and AI-hosting layers can justify bounded practical overlap; no inference that an agent, MCP server or particular LLM was deployed. Same-author second pass, not independent validation.
Fireworks AI, a hosted platform for running, evaluating and training models, disclosed unauthorized access to customer evaluation-job secrets and later development-machine activity affecting customer data. Customers can revoke exposed credentials at their issuers; the platform operator owns isolation between development systems and customer assets.
Why it relates: API keys and tokens held for customer evaluation jobs were exposed, sharing the exact credential-custody failure and downstream authority-at-risk described by this category. This is an evaluation-platform secret store, not an established MCP server, OAuth token family or agent integration. No MCP deployment is inferred.
Mappings cover unauthorized AI-platform credential and data access, affected infrastructure/data operations, supplier dependency and model-asset confidentiality. Practical overlaps explicitly preserve missing agent, MCP, model-query and completed-copy evidence. No mapping represents a verified defensive success.
Researchers at Lumia have demonstrated that it is possible to extract authentication tokens from the memory of LLM Desktop Applications. An attacker could then use those tokens to impersonate the victim to the LLM backend, thereby gaining access to the victim's conversations as well as the ability to interfere in future conversations. The attacker's access would allow them the ability to directly inject prompts to change the LLM's behavior, poison the LLM's context to have persistent effects, manipulate the user's conversation history to cover their tracks, and ultimately impact the confidentiality, integrity, and availability of the system. The researchers demonstrated this on Anthropic Claude, Microsoft M365 Copilot, and OpenAI ChatGPT. Vendor Responses to Responsible Disclosure: - Anthropic (HackerOne) - Closed as informational since local attack. - Microsoft Security Response Center - Attack doesn't bypass security boundaries for CVE. - OpenAI (BugCrowd) - Closed as informational and noted that it's up to Microsoft to patch this behavior.
Why it relates: Researchers at Lumia have demonstrated that it is possible to extract authentication tokens from the memory of LLM Desktop Applications. The relevant category is Credential and Token Exposure: API keys, OAuth tokens, or other credentials are exposed through unsafe handling, storage, or transmission. The shared mechanism is exposure or replay of an AI-system credential. MCP deployment or an MCP-specific credential boundary is not established.
Researchers at Lumia have demonstrated that it is possible to extract authentication tokens from the memory of LLM Desktop Applications. An attacker could then use those tokens to impersonate the victim to the LLM backend, thereby gaining access to the victim's conversations as well as the ability to interfere in future conversations. The attacker's access would allow them the ability to directly inject prompts to change the LLM's behavior, poison the LLM's context to have persistent effects, manipulate the user's conversation history to cover their tracks, and ultimately impact the confidentiality, integrity, and availability of the system. The researchers demonstrated this on Anthropic Claude, Microsoft M365 Copilot, and OpenAI ChatGPT. Vendor Responses to Responsible Disclosure: - Anthropic (HackerOne) - Closed as informational since local attack. - Microsoft Security Response Center - Attack doesn't bypass security boundaries for CVE. - OpenAI (BugCrowd) - Closed as informational and noted that it's up to Microsoft to patch this behavior.
The publicly available Streamlit application MathGPT (https://mathgpt.streamlit.app/) uses GPT-3, a large language model (LLM), to answer user-generated math questions. Recent studies and experiments have shown that LLMs such as GPT-3 show poor performance when it comes to performing exact math directly. However, they can produce more accurate answers when asked to generate executable code that solves the question at hand. In the MathGPT application, GPT-3 is used to convert the user's natural language question into Python code that is then executed. After computation, the executed code and the answer are displayed to the user. Some LLMs can be vulnerable to prompt injection attacks, where malicious user inputs cause the models to perform unexpected behavior. In this incident, the actor explored several prompt-override avenues, producing code that eventually led to the actor gaining access to the application host system's environment variables and the application's GPT-3 API key, as well as executing a denial of service attack. As a result, the actor could have exhausted the application's API query budget or brought down the application. After disclosing the attack vectors and their results to the MathGPT and Streamlit teams, the teams took steps to mitigate the vulnerabilities, filtering on select prompts and rotating the API key.
Why it relates: The publicly available Streamlit application MathGPT (https://mathgpt.streamlit.app/) uses GPT-3, a large language model (LLM), to answer user-generated math questions. The relevant category is Credential and Token Exposure: API keys, OAuth tokens, or other credentials are exposed through unsafe handling, storage, or transmission. The shared mechanism is exposure or replay of an AI-system credential. MCP deployment or an MCP-specific credential boundary is not established.
The publicly available Streamlit application MathGPT (https://mathgpt.streamlit.app/) uses GPT-3, a large language model (LLM), to answer user-generated math questions. Recent studies and experiments have shown that LLMs such as GPT-3 show poor performance when it comes to performing exact math directly. However, they can produce more accurate answers when asked to generate executable code that solves the question at hand. In the MathGPT application, GPT-3 is used to convert the user's natural language question into Python code that is then executed. After computation, the executed code and the answer are displayed to the user. Some LLMs can be vulnerable to prompt injection attacks, where malicious user inputs cause the models to perform unexpected behavior. In this incident, the actor explored several prompt-override avenues, producing code that eventually led to the actor gaining access to the application host system's environment variables and the application's GPT-3 API key, as well as executing a denial of service attack. As a result, the actor could have exhausted the application's API query budget or brought down the application. After disclosing the attack vectors and their results to the MathGPT and Streamlit teams, the teams took steps to mitigate the vulnerabilities, filtering on select prompts and rotating the API key.
Remus is Windows malware that steals application data after gaining execution on a device. SpyCloud identified AI-client directories among its configurable collection targets, including Codex, Cursor and OpenCode. The AI-security exposure is reusable credentials and locally retained activity data; protecting an agent tool alone does not contain malware already running elsewhere on the host.
Why it relates: The campaign targets AI-client credential files, creating a concrete token-exposure boundary. The exposure concerns AI clients broadly; no assertion is made that every targeted credential belongs to MCP.
Host infostealer targeting AI-client credentials and retained files; no prompt injection or confirmed credential replay is asserted.
Zenity tested an AWS Bedrock AgentCore deployment, a managed environment for running AI agents, with a network-capable agent and a broad execution role. The agent relayed temporary role credentials from its metadata endpoint. Off-platform API calls then reached other memories and agents. The distinctive persistence path wrote short-term conversation events that configured extraction strategies could turn into long-term records; later retrieval directed the agent to a mutable command page. The reach was demonstrated within an account and region, not as a microVM escape or automatic cross-account compromise. The researchers observed major default-role restrictions on September 29; existing deployed roles still require independent inspection.
Why it relates: The role can retrieve outbound-tool provider secrets that represent external service authority. The direct path is AWS Secrets Manager and provider configuration; a specific downstream MCP deployment is not asserted.
Controlled broad-role AgentCore deployment with separate direct API and retained-memory/C2 branches; account/region scope, tool prerequisites and later default-role restrictions remain explicit.
On October 21, LiteLLM, a Python library and gateway for accessing model providers, published a credential-stealing 1.107.0 release through its legitimate build and signing pipeline. The vendor's October 23 investigation traces entry to an unrevoked master key leaked from its experimental Agent Platform, followed by theft of an organization-owner GitHub token. Separate CI runs stole two maintainer tokens. Consumer-side admission of previously approved exact bytes, and revocation at each credential issuer, address boundaries that a valid release signature did not protect.
Why it relates: Reusable integration tokens are exposed and reused to reach a release system with their existing authority. The shared mechanism is integration credential exposure; the source does not establish that the API or GitHub integration used MCP.
Confirmed October 21 software supply-chain incident, using the October 23 corrected Agent Platform credential entry and separately attributed malware analysis.
In Unit 42's controlled SupportCo test, instructions hidden in a support ticket made an agent run a script through AgentCore Harness's default shell. The script read PID 1 memory, sent the operator's MCP service-account JWT and server URL in one HTTP POST to a simulated attacker webhook, and the researchers replayed the JWT from a laptop to retrieve sample customer PII. The credential was not an end-user token. AWS treated this as shared-responsibility configuration guidance, not a patched service vulnerability.
Why it relates: Unit 42's controlled SupportCo scenario placed instructions in an inbound support ticket. The relevant category is Credential and Token Exposure: API keys, OAuth tokens, or other credentials are exposed through unsafe handling, storage, or transmission.
Unit 42's controlled SupportCo scenario placed instructions in an inbound support ticket. With a permissive model and default shell tool, the agent fetched and ran a recon script as root in AgentCore Harness. The shell shared UID and readable /proc/1/mem access with the harness process; researchers recovered a plaintext JWT for the operator's downstream MCP service account and its endpoint. The injected script sent both in one HTTP POST to a simulated attacker webhook; the researchers replayed the JWT from a laptop and retrieved sample customer PII through the downstream MCP server. AWS treated this as shared-responsibility configuration guidance, not a patched service vulnerability.
A public issue title could make Cline's Claude triage workflow run shell commands; the researcher reproduced this first step in a mirror. Its shared Actions cache created a route to nightly-release secrets. Separately, Cline confirmed that a still-active npm token was used by a third party to publish cline@2.3.0 with an OpenClaw postinstall script, but the exact token-theft sequence was not forensically established.
Why it relates: A public issue title could make Cline's Claude triage workflow run shell commands; the researcher reproduced this first step in a mirror. The relevant category is Credential and Token Exposure: API keys, OAuth tokens, or other credentials are exposed through unsafe handling, storage, or transmission. Issue content reaches shell execution and a shared Actions cache; the actual token-theft sequence behind a separate malicious release is unproven.
A public issue title could make Cline's Claude triage workflow run shell commands; the researcher reproduced this first step in a mirror. Its shared Actions cache created a route to nightly-release secrets. Separately, Cline confirmed that a still-active npm token was used by a third party to publish cline@2.3.0 with an OpenClaw postinstall script, but the exact token-theft sequence was not forensically established.
A security researcher identified hundreds of exposed ClawdBot control interfaces on the public internet. ClawdBot (now OpenClaw) "is a personal AI assistant you run on your own devices. It answers you on the channels you already use ... , plus extension channels. ... It can speak and listen on macOS/iOS/Android, and can render a live Canvas you control." The researcher was able to access credentials to a variety of connected applications via ClawdBot's configuration file. They were also able to invoke ClawdBot's skills by prompting it via the chat interface, leading to root access in the container. The researcher searched Shodan to identify Clawdbot instances exposed on the public internet, some without authentication enabled. The researcher demonstrated that the ClawdBot's authentication mechanism could be bypassed due to a proxy misconfiguration. With access to ClawdBot's control interface, they were then able to access ClawdBot's configuration, which contained credentials to a variety of other services. Across various exposed instances of ClawdBot, they identified Anthropic API Keys, Telegram Bot Tokens, Slack Oauth Credentials, and Signal Device Linking URIs. The researcher prompted ClawdBot directly via the chat interface, which led to exposure of its system prompt. They were also able to get ClawdBot to execute commands via its bash skill, which at least in at least one instance led to root access in the ClawdBot container. The researcher noted a broad range of other impacts they could have had with this level of access, including: - Manipulation of user chat history with the ClawdBot AI agent - Exfiltration of conversation histories of any connected messaging services - Impersonation of users by sending messages on their behalf via connected messaging services
Why it relates: A security researcher identified hundreds of exposed ClawdBot control interfaces on the public internet. The relevant category is Credential and Token Exposure: API keys, OAuth tokens, or other credentials are exposed through unsafe handling, storage, or transmission.
A security researcher identified hundreds of exposed ClawdBot control interfaces on the public internet. ClawdBot (now OpenClaw) "is a personal AI assistant you run on your own devices. It answers you on the channels you already use ... , plus extension channels. ... It can speak and listen on macOS/iOS/Android, and can render a live Canvas you control." The researcher was able to access credentials to a variety of connected applications via ClawdBot's configuration file. They were also able to invoke ClawdBot's skills by prompting it via the chat interface, leading to root access in the container. The researcher searched Shodan to identify Clawdbot instances exposed on the public internet, some without authentication enabled. The researcher demonstrated that the ClawdBot's authentication mechanism could be bypassed due to a proxy misconfiguration. With access to ClawdBot's control interface, they were then able to access ClawdBot's configuration, which contained credentials to a variety of other services. Across various exposed instances of ClawdBot, they identified Anthropic API Keys, Telegram Bot Tokens, Slack Oauth Credentials, and Signal Device Linking URIs. The researcher prompted ClawdBot directly via the chat interface, which led to exposure of its system prompt. They were also able to get ClawdBot to execute commands via its `bash` skill, which at least in at least one instance led to root access in the ClawdBot container. The researcher noted a broad range of other impacts they could have had with this level of access, including: - Manipulation of user chat history with the ClawdBot AI agent - Exfiltration of conversation histories of any connected messaging services - Impersonation of users by sending messages on their behalf via connected messaging services
Wiz Threat Research ran honeypots emulating LiteLLM, Flowise, LangChain, Langflow, ChromaDB, Ollama and other services for 90 days. Alongside ordinary CVE exploitation, the traffic showed tooling written specifically for AI internals: prompts injected into agent frameworks to make them run operating-system commands, confirmed by a DNS callback rather than visible output; proxy credentials read out of a running process's Python module state instead of from disk; and cryptominers staged in directories named after AI tooling.
Why it relates: Wiz Threat Research ran honeypots emulating LiteLLM, Flowise, LangChain, Langflow, ChromaDB, Ollama and other services for 90 days. The relevant category is Credential and Token Exposure: API keys, OAuth tokens, or other credentials are exposed through unsafe handling, storage, or transmission.
Wiz Threat Research ran honeypots emulating LiteLLM, Flowise, LangChain, Langflow, ChromaDB, Ollama and other services for 90 days. Alongside ordinary CVE exploitation, the traffic showed tooling written specifically for AI internals: prompts injected into agent frameworks to make them run operating-system commands, confirmed by a DNS callback rather than visible output; proxy credentials read out of a running process's Python module state instead of from disk; and cryptominers staged in directories named after AI tooling. Injection aimed at the shell, not the answer. Against LangChain, Flowise, OpenWebUI and Node-RED, attackers sent prompts designed to make agents run OS commands. A DNS query to an attacker-controlled domain confirmed execution, the target's address encoded in the subdomain, so no output needed to come back. The second stage came from Pastebin, base64-encoded to evade logs and filtering. Post-exploitation adapted to the product. On LiteLLM, rather than hunting for credential files, attackers imported the running application's own Python modules and read the master key from module state, because it lives in memory rather than on disk. They also enumerated config paths and fingerprinted the backend with the documented default key. Miners dressed as AI artifacts. One Langflow miner was staged in a .claude directory and renamed unicorn; a Node-RED miner sat where it blended into the Node.js tree. Evidence boundary. These are honeypots: no event counts, window dates, or named victims are published. Wiz states plainly that the injection prompt text is a reconstruction, not captured traffic; it observed the process tree, the callback, and the miner.
Zenity disrupted an active campaign that impersonated Paperclip and Browser Use through look-alike organizations, skills, repositories, and packages. The Paperclip skill family appeared on skills.sh while its skill documents were still benign, accumulated displayed installs, and was weaponized on July 11 with instructions that steered agents to attacker-controlled code and a remote loader. A Browser Use lure instead instructed agents to install a trojanized PyPI package. Recovered payloads searched more than 100 configured paths and posted a base64-encoded plaintext bundle to api[.]getpaperclipp[.]com/feedback . The reported 1.7 million figure is an aggregate displayed-install counter, not unique users or confirmed infections.
Why it relates: An active campaign created look-alike Paperclip and Browser Use projects. The relevant category is Credential and Token Exposure: API keys, OAuth tokens, or other credentials are exposed through unsafe handling, storage, or transmission.
An active campaign created look-alike Paperclip and Browser Use projects. The Paperclip skill family appeared while its skill documents were clean, accumulated displayed installs, then received malicious setup instructions. A Browser Use lure instead installed a trojanized PyPI package. Both paths executed credential-stealing code that posted a base64-encoded plaintext bundle to the attacker's feedback endpoint.
On June 5, 2026, a previously compromised contributor account pushed commit 5f456b8 to Azure/durabletask. The commit added four repository-local trigger files and a 4.6 MB obfuscated .github/setup.js credential harvester. Opening the project could launch that payload through Claude Code or Gemini CLI SessionStart hooks, a Cursor always-applied rule, or a VS Code folder-open task. GitHub later disabled 73 repositories across four Microsoft organizations in a 105-second automated sweep; that number describes containment scope, not proof that all 73 repositories contained the malicious commit.
Why it relates: A compromised contributor account pushed commit 5f456b8 to Azure/durabletask. The relevant category is Credential and Token Exposure: API keys, OAuth tokens, or other credentials are exposed through unsafe handling, storage, or transmission.
A compromised contributor account pushed commit 5f456b8 to Azure/durabletask. When a developer opens the repository, Claude Code or Gemini CLI SessionStart hooks, a Cursor always-applied rule, or a VS Code folder-open task can launch .github/setup.js, a 4.6 MB obfuscated credential harvester.
Storm-2139 built custom jailbreak tooling to bypass guardrails on Azure OpenAI Services, allowing users to generate harmful synthetic content. Microsoft reported that members of Storm-2139 scraped exposed customer credentials from public sources and used them to access accounts for generative AI services. The group developed and operated tools and services that bypassed safety safeguards, modified service capabilities, and enabled end users to generate harmful and illicit content, including non-consensual intimate images of celebrities and other sexually explicit content. The operation included creators who developed illicit tools, providers who modified and supplied those tools, and users who generated prohibited content. Microsoft pursued civil legal action.
Why it relates: Storm-2139 built custom jailbreak tooling to bypass guardrails on Azure OpenAI Services, allowing users to generate harmful synthetic content. The relevant category is Credential and Token Exposure: API keys, OAuth tokens, or other credentials are exposed through unsafe handling, storage, or transmission.
Storm-2139 built custom jailbreak tooling to bypass guardrails on Azure OpenAI Services, allowing users to generate harmful synthetic content. Microsoft reported that members of Storm-2139 scraped exposed customer credentials from public sources and used them to access accounts for generative AI services. The group developed and operated tools and services that bypassed safety safeguards, modified service capabilities, and enabled end users to generate harmful and illicit content, including non-consensual intimate images of celebrities and other sexually explicit content. The operation included creators who developed illicit tools, providers who modified and supplied those tools, and users who generated prohibited content. Microsoft pursued civil legal action.
The Backslash Security Research Team demonstrated that a Model Context Protocol (MCP) tool can be used as a vector for an indirect prompt injection attack on Cursor, potentially leading to the execution of malicious shell commands. The Backslash Security Research Team created a proof-of-concept MCP server capable of scraping webpages. When a user asks Cursor to use the tool to scrape a site containing a malicious prompt, the prompt is injected into Cursor's context. The prompt instructs Cursor to execute a shell command to exfiltrate the victim's AI agent configuration files containing credentials. Cursor does prompt the user before executing the malicious command, potentially mitigating the attack.
Why it relates: The Backslash Security Research Team demonstrated that a Model Context Protocol (MCP) tool can be used as a vector for an indirect prompt injection attack on Cursor, potentially leading to the execution of malicious shell commands. The relevant category is Credential and Token Exposure: API keys, OAuth tokens, or other credentials are exposed through unsafe handling, storage, or transmission. Tool output proposes a credential-exfiltrating shell command, but user execution confirmation remains a required boundary.
The Backslash Security Research Team demonstrated that a Model Context Protocol (MCP) tool can be used as a vector for an indirect prompt injection attack on Cursor, potentially leading to the execution of malicious shell commands. The Backslash Security Research Team created a proof-of-concept MCP server capable of scraping webpages. When a user asks Cursor to use the tool to scrape a site containing a malicious prompt, the prompt is injected into Cursor's context. The prompt instructs Cursor to execute a shell command to exfiltrate the victim's AI agent configuration files containing credentials. Cursor does prompt the user before executing the malicious command, potentially mitigating the attack.
Orca found Internet-exposed vector databases containing source text, personal data, medical records, credentials, and internal configuration, then validated that credentials from one support-ticket index could reach external SaaS systems. Separately, two critical Milvus vulnerabilities bypassed authentication through a trusted sourceID header and unauthenticated APIs on port 9091. Together, the findings show that a vector database is both a sensitive data store and an AI infrastructure control boundary.
Why it relates: Orca found Internet-exposed vector databases containing source text, personal data, medical records, credentials, and internal configuration, then validated that credentials from one support-ticket index could reach external SaaS systems. The relevant category is Credential and Token Exposure: API keys, OAuth tokens, or other credentials are exposed through unsafe handling, storage, or transmission.
Orca found Internet-exposed vector databases containing source text, personal data, medical records, credentials, and internal configuration, then validated that credentials from one support-ticket index could reach external SaaS systems. Separately, two critical Milvus vulnerabilities bypassed authentication through a trusted sourceID header and unauthenticated APIs on port 9091. Together, the findings show that a vector database is both a sensitive data store and an AI infrastructure control boundary. Vector databases can retain readable source material. Orca found original text, metadata, personal and medical records, credentials, and internal configuration in publicly reachable deployments. In controlled validation, the team used plaintext SaaS credentials from one support-ticket index to authenticate to the corresponding external services. CVE-2025-64513 trusted a caller-controlled identity claim. A crafted sourceID made a vulnerable Milvus proxy treat an external request as internal, bypassing password and API-key checks. Fixes were released in 2.4.24, 2.5.21, and 2.6.5. CVE-2026-26190 exposed two paths on port 9091. The /expr route used a predictable value derived from the default etcd.rootPath , while /api/v1/* routes lacked authentication. A reachable attacker could read secrets, manage users and collections, disrupt service, and under stated conditions write files. Exposure is not evidence of malicious exploitation. Orca confirmed real data exposure and disclosed it to affected organizations. The Milvus advisories show practical exploitability, but there is currently no public evidence that either vulnerability has been used in an actual attack.
Microsoft found that untrusted GitHub issue, pull request, or comment text could direct Claude Code GitHub Action to read /proc/self/environ . Bash commands were inside bubblewrap and received a scrubbed environment, but the in-process Read tool used a different path and returned ANTHROPIC_API_KEY ; removing its prefix helped evade refusal and GitHub redaction. Anthropic patched the reported sensitive /proc read, but every tool path still needs the same secret boundary and deterministic authorization.
Why it relates: The Microsoft Defender Security Research Team (https://www.microsoft.com/en-us/security/blog/author/windows-defender-research/) demonstrated that Anthropic's Claude Code GitHub Action (https://github.com/anthropics/claude-code-action) could expose CI/CD workflow secrets when processing GitHub content, such as issue bodies, pull request descriptions, and comments, containing prompt injections. The relevant category is Credential and Token Exposure: API keys, OAuth tokens, or other credentials are exposed through unsafe handling, storage, or transmission. The shared mechanism is exposure or replay of an AI-system credential. MCP deployment or an MCP-specific credential boundary is not established.
The Microsoft Defender Security Research Team (https://www.microsoft.com/en-us/security/blog/author/windows-defender-research/) demonstrated that Anthropic's Claude Code GitHub Action (https://github.com/anthropics/claude-code-action) could expose CI/CD workflow secrets when processing GitHub content, such as issue bodies, pull request descriptions, and comments, containing prompt injections. The researchers analyzed the Claude Code Action codebase and obfuscated Claude Agent SDK to understand how agent tools executed and how GitHub events supplied content to the agent. They crafted a prompt framed as a compliance review that directed Claude to read a credential from its process environment, remove the credential prefix, and emit the transformed value. They introduced the prompt through attacker-controlled GitHub content processed by the lab workflow. The action fetched the malicious content into Claude's context, where it was interpreted as instructions. Claude invoked its Read tool against `/proc/self/environ`, returning the action process's unsanitized environment, including `ANTHROPIC_API_KEY`. Unlike Bash subprocesses, Read operations did not execute within the Bubblewrap sandbox and scrubbed-environment boundary. Removing the key's `sk-ant-` prefix allowed the output to bypass Claude's refusal behavior and GitHub's secret-pattern detection while remaining reconstructable by the researchers. Microsoft identified WebFetch, Bash, GitHub MCP, and GitHub Actions logs as potential additional exfiltration channels depending on workflow configuration. Microsoft disclosed the issue to Anthropic through HackerOne on April 29, 2026. Anthropic mitigated the vulnerability in Claude Code 2.1.128 on May 5, 2026, by blocking Read access to sensitive `/proc` files.
Linux packages for PyTorch's pre-release version, called Pytorch-nightly, were compromised from December 25 to 30, 2022 by a malicious binary uploaded to the Python Package Index (PyPI) code repository. The malicious binary had the same name as a PyTorch dependency and the PyPI package manager (pip) installed this malicious package instead of the legitimate one. This supply chain attack, also known as "dependency confusion," exposed sensitive information of Linux machines with the affected pip-installed versions of PyTorch-nightly. On December 30, 2022, PyTorch announced the incident and initial steps towards mitigation, including the rename and removal of torchtriton dependencies.
Why it relates: Linux packages for PyTorch's pre-release version, called Pytorch-nightly, were compromised from December 25 to 30, 2022 by a malicious binary uploaded to the Python Package Index (PyPI) code repository. The relevant category is Credential and Token Exposure: API keys, OAuth tokens, or other credentials are exposed through unsafe handling, storage, or transmission.
Linux packages for PyTorch's pre-release version, called Pytorch-nightly, were compromised from December 25 to 30, 2022 by a malicious binary uploaded to the Python Package Index (PyPI) code repository. The malicious binary had the same name as a PyTorch dependency and the PyPI package manager (pip) installed this malicious package instead of the legitimate one. This supply chain attack, also known as "dependency confusion," exposed sensitive information of Linux machines with the affected pip-installed versions of PyTorch-nightly. On December 30, 2022, PyTorch announced the incident and initial steps towards mitigation, including the rename and removal of `torchtriton` dependencies.
Zafran validated arbitrary file read and SSRF in exposed applications built with Chainlit, a Python framework for LLM chat and agent apps. An authenticated attacker could copy server-readable files into their session; deployments using the LangChain disk cache could also expose other users' prompts and responses. The reachable files, secrets and cloud impact depend on deployment configuration and workload permissions.
Why it relates: Zafran reported ChainLeak vulnerabilities in Chainlit that enabled arbitrary file read, cross-user prompt and response cache leakage, and SSRF through element URL handling, creating a path from AI framework helper APIs to secrets and cloud takeover risk. The relevant category is Credential and Token Exposure: API keys, OAuth tokens, or other credentials are exposed through unsafe handling, storage, or transmission.
Zafran reported ChainLeak vulnerabilities in Chainlit that enabled arbitrary file read, cross-user prompt and response cache leakage, and SSRF through element URL handling, creating a path from AI framework helper APIs to secrets and cloud takeover risk.
Zenity's controlled demonstration steered Perplexity Comet from a poisoned calendar invite into an unlocked 1Password extension and authenticated vault session. It revealed vault values and exfiltrated them in URL parameters; a second route changed the account password and extracted the Secret Key from an emailed Emergency Kit. The browser agent inherited sensitive authenticated state while following untrusted workflow content.
Why it relates: Zenity demonstrated that a poisoned calendar invite could redirect Perplexity Comet from a routine meeting task into an installed and unlocked 1Password session. The relevant category is Credential and Token Exposure: API keys, OAuth tokens, or other credentials are exposed through unsafe handling, storage, or transmission.
Zenity demonstrated that a poisoned calendar invite could redirect Perplexity Comet from a routine meeting task into an installed and unlocked 1Password session. One path searched a Login item, revealed its username and password, and sent them through ordinary browser navigation. A second path changed the 1Password account password, obtained the account email and full Secret Key through the Emergency Kit flow, and exfiltrated that recovery material. The controlled proof of concept required no software vulnerability and relied on intended browser-agent capabilities plus shared authenticated state.
Wiz showed that older Amazon Q for VS Code (AWS's AI coding assistant extension) language-server versions automatically loaded workspace MCP (Model Context Protocol, a way for AI assistants to connect to external tools) configuration without consent, letting a malicious repository define a command-backed MCP server that inherited the developer environment and exfiltrated AWS identity data. AWS fixed CVE-2026-12957 in language server 1.65.0 and later.
Why it relates: Wiz disclosed CVE-2026-12957 in Amazon Q Developer for VS Code, where workspace MCP configuration could be auto-loaded without consent, start command-backed MCP servers, inherit developer environment variables, and exfiltrate AWS identity data before AWS fixed the issue in language server 1.65.0. The relevant category is Credential and Token Exposure: API keys, OAuth tokens, or other credentials are exposed through unsafe handling, storage, or transmission.
Wiz disclosed CVE-2026-12957 in Amazon Q Developer for VS Code, where workspace MCP configuration could be auto-loaded without consent, start command-backed MCP servers, inherit developer environment variables, and exfiltrate AWS identity data before AWS fixed the issue in language server 1.65.0.
Zenity reported active exploitation attempts against two LiteLLM (an AI gateway for routing LLM requests) control-plane paths: the custom-code guardrail tester and the connection-test API. Together they show why an AI gateway is a critical asset: it sits near provider keys, routing policy, sandboxed code execution, and the model traffic every application depends on.
Why it relates: Zenity Labs recorded 2,721 LiteLLM admin requests from April 7 through June 1, 2026. The relevant category is Credential and Token Exposure: API keys, OAuth tokens, or other credentials are exposed through unsafe handling, storage, or transmission.
Zenity Labs recorded 2,721 LiteLLM admin requests from April 7 through June 1, 2026. The dominant path sent 2,704 nested /health/test_connection requests that paired an attacker-controlled api_base with api_key: os.environ/LITELLM_MASTER_KEY; Zenity reproduced the proxy resolving the environment reference and transmitting the real key to a collector. Sixteen /chat/completions requests instead aimed api_base at cloud instance metadata. One /model/new request stored a loopback api_base, but the source does not show that route later being used. The flow preserves all three paths and their different evidence limits. Zenity Labs recorded 569 POST requests to LiteLLM's /guardrails/test_custom_code endpoint from April 15 through May 24, 2026. The activity combined guessed or empty master-key values with a custom Python guardrail, first using 520 identical capability probes and later using hand-crafted CVE-2026-40217 sandbox escapes. Captured payloads rebuilt forbidden Python names, recovered builtins through generator or coroutine internals, and split into two observed outcomes: serializing environment secrets into the HTTP response, or launching a shell command through subprocess.Popen. Zenity replayed both captured paths on LiteLLM 1.83.0 and confirmed secret return and command execution; it does not claim that every honeypot attempt compromised a real target.
Socket linked 34+ malicious packages and 384+ related versions and artifacts across npm, PyPI and Crates.io to the TrapDoor credential-stealing campaign. Alongside working package payloads, the attacker planted AI-facing instructions in .cursorrules and CLAUDE.md and opened documentation-style pull requests. Socket describes an attempt to induce AI assistants to run a disguised security scan; it does not establish that every proposed pull request was merged or that cloning alone caused successful AI-assisted theft.
Why it relates: Socket linked 34+ malicious packages and 384+ related versions and artifacts across npm, PyPI and Crates.io to the TrapDoor credential-stealing campaign. The relevant category is Credential and Token Exposure: API keys, OAuth tokens, or other credentials are exposed through unsafe handling, storage, or transmission. Separate install/import/build payloads steal secrets, while AI-facing instructions require repository admission, model compliance and execution authority.
Socket linked 34+ malicious packages and 384+ related versions and artifacts across npm, PyPI and Crates.io to the TrapDoor credential-stealing campaign. Alongside working package payloads, the attacker planted AI-facing instructions in .cursorrules and CLAUDE.md and opened documentation-style pull requests. Socket describes an attempt to induce AI assistants to run a disguised security scan; it does not establish that every proposed pull request was merged or that cloning alone caused successful AI-assisted theft. Two ways in, and one targets AI assistant config. TrapDoor reaches developers through the usual malicious-package route, but its distinctive move is poisoning the configuration files an AI coding assistant reads - .cursorrules and CLAUDE.md - so the assistant can be steered into stealing data. The AI-facing route is an observed delivery attempt. Campaign-linked files and pull requests ask an assistant to follow remote guidance or run a disguised security scan. Hidden Unicode and familiar documentation titles can conceal the instructions. Exposure depends on whether the file reaches a repository, whether the assistant reads and follows it, and whether its execution permissions allow secret access and egress. Socket warns that the technique may not work consistently across tools or models. The package path executes at install, import, and build time. On npm, a postinstall hook runs the 1,149-line trap-core.js automatically. On PyPI, packages execute at import time, pull JavaScript from an attacker GitHub Pages domain, and run it with node -e . On Crates.io, a build.rs script runs during compilation, encrypts local keystores with a hardcoded XOR key, and exfiltrates them to GitHub Gists. What gets taken, and how the attacker filters it. Targets include SSH keys, AWS credentials, GitHub tokens, browser login databases, environment variables, API keys, and Solana, Sui, and Aptos wallet keystores. The payload validates stolen AWS and GitHub credentials with live API calls so the attacker can separate working secrets from expired ones. It digs in and spreads. trap-core.js establishes persistence through .cursorrules , CLAUDE.md , Git hooks, shell hooks, systemd, cron, and SSH, and attempts lateral movement by reusing stolen SSH keys. A deliberate "disguise layer" maps credential theft onto benign-sounding tasks - security audits, wallet safety checks, cloud configuration validation. The boundary that breaks is "config is not code." Once an AI assistant treats repository files as trustworthy instructions, an attacker who can land a file in a repo - through a package or a single docs PR - can drive the assistant's actions. The possible exposure extends to assistants that read the poisoned files; cloning alone is not evidence of execution or credential compromise. The package and repository activity was observed in May 2026 and the PRs came from the GitHub account ddjidd564 against browser-use, langchain, langflow, llama_index, MetaGPT, and OpenHands.
Microsoft Defender Security Research reports that real-world AI and agentic apps expose powerful services with weak or missing authentication: unauthenticated remote MCP servers, Mage AI shell access (data-pipeline automation) through public Kubernetes LoadBalancers, exposed kagent services (Kubernetes agents), and Microsoft AutoGen Studio instances (local agent-building interfaces) leaking AI provider keys. AI apps are production workloads; govern exposure, authentication, service identity, least privilege, and posture drift before endpoints reach the internet.
Why it relates: Microsoft Defender Security Research reports that real-world AI and agentic apps expose powerful services with weak or missing authentication: unauthenticated remote MCP servers, Mage AI shell access (data-pipeline automation) through public Kubernetes LoadBalancers, exposed kagent services (Kubernetes agents), and Microsoft AutoGen Studio instances (local agent-building interfaces) leaking AI provider keys. The relevant category is Credential and Token Exposure: API keys, OAuth tokens, or other credentials are exposed through unsafe handling, storage, or transmission.
Microsoft Defender Security Research reports that real-world AI and agentic apps expose powerful services with weak or missing authentication: unauthenticated remote MCP servers, Mage AI shell access (data-pipeline automation) through public Kubernetes LoadBalancers, exposed kagent services (Kubernetes agents), and Microsoft AutoGen Studio instances (local agent-building interfaces) leaking AI provider keys. AI apps are production workloads; govern exposure, authentication, service identity, least privilege, and posture drift before endpoints reach the internet. The attack starts with a reachable AI service, not a zero-day. Microsoft describes the core failure as public exposure plus weak or missing authentication. Once an AI UI, API, or agent endpoint is internet-reachable, normal requests may reach tools, data, or execution features behind it. Remote MCP servers can expose internal tools directly. Microsoft observed unauthenticated MCP servers where callers could reach ticketing systems, HR systems, and private code repositories because tool actions ran in the server's broad security context. Mage AI turned a default deployment into shell access. An internet-facing Kubernetes LoadBalancer exposed the UI without authentication. The UI included shell execution, and the mounted service account had highly privileged roles. kagent and Microsoft AutoGen Studio show the same deployment risk. Exposed kagent agents could deploy privileged pods, steal workload credentials, or configure malicious models. Exposed Microsoft AutoGen Studio instances could leak plaintext AI provider keys or accept malicious agent configurations.
BeyondTrust Phantom Labs reported that OpenAI Codex (an AI coding agent) accepted a GitHub branch name into a container setup shell path, allowing command injection that exposed GitHub OAuth and installation tokens. The issue affected Codex Web and could be replicated through CLI, SDK, and IDE credentials; an automated variant used malicious branch refs to target multiple users working in a shared repository. OpenAI remediated the reported issues, but the defensive lesson remains: repository metadata must be treated as untrusted execution input.
Why it relates: BeyondTrust Phantom Labs reported that OpenAI Codex (an AI coding agent) accepted a GitHub branch name into a container setup shell path, allowing command injection that exposed GitHub OAuth and installation tokens. The relevant category is Credential and Token Exposure: API keys, OAuth tokens, or other credentials are exposed through unsafe handling, storage, or transmission.
BeyondTrust Phantom Labs reported that OpenAI Codex (an AI coding agent) accepted a GitHub branch name into a container setup shell path, allowing command injection that exposed GitHub OAuth and installation tokens. The issue affected Codex Web and could be replicated through CLI, SDK, and IDE credentials; an automated variant used malicious branch refs to target multiple users working in a shared repository. OpenAI remediated the reported issues, but the defensive lesson remains: repository metadata must be treated as untrusted execution input. GitHub metadata reached a shell command. BeyondTrust found that the branch parameter in the Codex task request was reflected into setup logic that fetched the selected repository and branch. The branch name became command injection. Shell metacharacters in a GitHub branch ref could break out of the expected command context and run attacker-controlled commands inside the Codex container. The target was the GitHub token Codex used for the task. During repository clone and review flows, Codex used OAuth or GitHub App installation tokens. The injected command could copy token-bearing remote configuration or logs and send the value outward. The attack could scale through the repository. An attacker with branch-control rights could create or modify a malicious branch, hide payloads with Unicode spacing, or make the branch default so other Codex users trigger the payload. Local Codex credentials expanded the path. The report also describes Codex CLI, SDK, and IDE credentials in ~/.codex/auth.json , which could be used to call backend APIs and retrieve task history or logs.
LayerX reported that Cursor (an AI coding IDE) stores API keys and session tokens in a local SQLite database that any installed Cursor extension can read. The attack does not need a prompt injection or user interaction after installation: a benign-looking extension can extract OpenAI, Anthropic, Google, or Cursor credentials and quietly exfiltrate them. The defensive lesson is that AI coding IDEs need protected credential storage, per-extension permission enforcement, and enterprise extension governance.
Why it relates: LayerX reported that Cursor (an AI coding IDE) stores API keys and session tokens in a local SQLite database that any installed Cursor extension can read. The relevant category is Credential and Token Exposure: API keys, OAuth tokens, or other credentials are exposed through unsafe handling, storage, or transmission.
LayerX reported that Cursor (an AI coding IDE) stores API keys and session tokens in a local SQLite database that any installed Cursor extension can read. The attack does not need a prompt injection or user interaction after installation: a benign-looking extension can extract OpenAI, Anthropic, Google, or Cursor credentials and quietly exfiltrate them. The defensive lesson is that AI coding IDEs need protected credential storage, per-extension permission enforcement, and enterprise extension governance. The secret store was not a real boundary. LayerX says Cursor stores credentials in state.vscdb , not behind an OS keychain or credential manager. Any installed extension became a credential reader. A theme, helper, or productivity extension can query the local SQLite database without an obvious credential-access prompt. The blast radius leaves Cursor. The database can hold Cursor session tokens and OpenAI, Anthropic, or Google keys; stolen keys enable impersonation, paid API abuse, and prompt or completion exposure. This is extension supply chain, not model behavior. After installation, the attack path is local code reading local storage and sending the result to an attacker server. Trust semantics matter. If a product treats all extensions as the same local trust boundary, enterprises need extension allowlisting and protected storage before using real keys.
Mercor confirmed it was impacted by the LiteLLM (an AI gateway for routing LLM requests) supply-chain compromise after malicious PyPI (Python package index) releases harvested credentials from systems that installed them. Separately, Lapsus$ claimed large-scale access to Mercor data; whether the full dataset is accurate or not, the defensive lesson is the same: AI dependencies must be pinned, vetted, installed in low-trust sandboxes, and assumed capable of stealing every secret visible at install or runtime.
Why it relates: Mercor confirmed it was impacted by the LiteLLM (an AI gateway for routing LLM requests) supply-chain compromise after malicious PyPI (Python package index) releases harvested credentials from systems that installed them. The relevant category is Credential and Token Exposure: API keys, OAuth tokens, or other credentials are exposed through unsafe handling, storage, or transmission.
Mercor confirmed it was impacted by the LiteLLM (an AI gateway for routing LLM requests) supply-chain compromise after malicious PyPI (Python package index) releases harvested credentials from systems that installed them. Separately, Lapsus$ claimed large-scale access to Mercor data; whether the full dataset is accurate or not, the defensive lesson is the same: AI dependencies must be pinned, vetted, installed in low-trust sandboxes, and assumed capable of stealing every secret visible at install or runtime. The initial failure was upstream package trust. LiteLLM versions 1.82.7 and 1.82.8 were published to PyPI outside the project's normal GitHub release flow after the maintainer account was hijacked. The payload was a credential thief, not a nuisance bug. LiteLLM's own incident issue says the malicious code collected SSH keys, environment secrets, cloud and Kubernetes credentials, database passwords, and CI configuration. Version 1.82.8 made execution unusually sticky. A malicious .pth file meant the payload could run on any Python startup, even if LiteLLM was never explicitly imported. Mercor confirmed downstream impact, while the extortion claims remain only partly verified. Cybernews reported Lapsus$ claims about source code, databases, and VPN data, but the full dataset was not independently confirmed at publication. This is why AI dependency risk is special. Libraries like LiteLLM sit near model keys, cloud credentials, CI runners, and internal data paths, so one poisoned package can bridge from developer tooling into enterprise compromise.
CodeWall found working credentials in a public Pyxis JavaScript bundle and established a session in 18 minutes. A subsequent SQL-injection path ran under a broadly privileged database account; a separate GraphQL path allowed identity-directory operations. These are distinct authentication and authorization boundaries. CodeWall reported remediation by March 19, 2026, and verification-only testing, not malicious exploitation.
Why it relates: CodeWall found working credentials in a public Pyxis JavaScript bundle and established a session in 18 minutes. The relevant category is Credential and Token Exposure: API keys, OAuth tokens, or other credentials are exposed through unsafe handling, storage, or transmission.
CodeWall found working credentials in a public Pyxis JavaScript bundle and established a session in 18 minutes. A subsequent SQL-injection path ran under a broadly privileged database account; a separate GraphQL path allowed identity-directory operations. These are distinct authentication and authorization boundaries. CodeWall reported remediation by March 19, 2026, and verification-only testing, not malicious exploitation. Initial access. Public frontend credentials enabled platform login; CodeWall inferred an AI service-account role from the redacted identity. Database boundary. SQL injection reached 11 databases under an overprivileged backend account. Reachable data does not establish wholesale exfiltration. Separate escalation surfaces. The report identifies GraphQL identity writes, logged JWTs, exports and database cloning. The system prompt was exposed through conversation metadata, not a demonstrated prompt table. Response. CodeWall reported all findings remediated before publication.