This week, three separate AI development tools exposed credentials or data through attack patterns that weren't novel — they were predictable. The incidents:
github.dev — unscoped, full repo access (HN #4, 488 points)Three incidents. One week. The same root cause: AI dev tools have broad credential access with no blast-radius control.
VSCode github.dev token steal (June 3). Security researcher Ammar Askar demonstrated that visiting a URL can trigger a 1-click OAuth flow in the github.dev web editor. The attacker-controlled page POSTs an unscoped GitHub OAuth token to a remote server. The token has full access to every repo the victim can reach — read, write, delete, admin. The attack works because GitHub's web editor accepts OAuth tokens via a webview POST that the host page controls. No user interaction beyond visiting a link. The full disclosure is on his blog.
ChatGPT Google Sheets exfiltration (June 1). PromptArmor demonstrated that malicious instructions placed in a Google Sheet cell can instruct ChatGPT for Google Sheets to call the Sheets API and exfiltrate the entire workbook. The model obeys — because that's what LLMs do with embedded instructions. OpenAI patched it by removing Apps Script generation. The researcher reported it through official channels and was ignored until the public disclosure.
LiteLLM Mercor supply-chain attack (Late May). The LiteLLM installation at Mercor was compromised, resulting in 4TB of data exfiltration. Credentials, conversation logs, system prompts, and internal data were stolen via the LiteLLM installation itself as the entry point.
Firewall rules, DLP policies, SIEM alerts — all of these operate at the network or file level. None of them sees an API call that an AI tool makes on behalf of a user, using a token the user authorized, to exfiltrate data through a legitimate API endpoint.
In the Google Sheets case, the exfiltration happened via the Sheets API — a completely legitimate, audited, expected API call. The data left through the front door. No firewall blocked it because the call was authorized. No DLP policy caught it because the payload looked like a normal Sheets API response. No SIEM alert fired because the call sequence was indistinguishable from normal usage.
The same is true for the GitHub token steal. The OAuth token POSTs to an external server via what looks like a normal HTTP request. There's no malware signature. There's no anomalous DNS lookup. There's just a POST from a browser tab to an external endpoint — exactly what happens when you fill out a web form.
These attacks are invisible to tools that look for known-bad patterns, because the attack pattern is a known-good API call used for an unknown-bad purpose.
Trimio's virtual key system works on a different principle: credentials should be scoped to what the tool is actually allowed to do, not to what the user authorized. A virtual key for a GitHub integration should be able to read repos — and only read repos. It shouldn't be able to push. It shouldn't be able to manage SSH keys. It shouldn't be able to access organization settings. The blast radius of a compromised VK is limited to its grant, not to the full scope of the user's OAuth token.
The same principle applies to the Sheets integration: a VK for ChatGPT for Google Sheets should be able to read the sheet data the user has open — not export the entire workbook to an external endpoint. The VK scope is the enforceable blast-radius control, not the OAuth token, not the user's Google account permissions.
Here's how this would have changed each incident:
There's a second layer that traditional security misses: the signature of a credential dump in progress. A compromised VK or manipulated agent making repeated, high-volume API calls to a data export endpoint has a recognizable pattern — sudden spike in output tokens, repeated identical API calls, data egress volume that exceeds normal usage patterns for that VK.
A proxy layer with budget enforcement can detect and stop this pattern in real time. The budget pre-check fails before the call executes. The loop stops. No more data leaves. This isn't ML-based anomaly detection — it's a budget cap that understands what the VK's normal usage looks like and refuses to debit beyond a threshold.
Both the Google Sheets and VSCode cases involved a disclosure process that failed. PromptArmor reported the Sheets vulnerability through official channels and was ignored. The VSCode researcher (Ammar Askar) disclosed to GitHub, GitHub acknowledged it, and the fix is in — but the timeline from disclosure to patch was weeks, not hours.
This matters for enterprise procurement: the security of your AI tools depends partly on the disclosure process working. When it doesn't — and the history of security disclosures is full of ignored reports — the vulnerability stays open until a public HN thread forces action.
The architecture answer is the only reliable one. Don't rely on every AI tool vendor having a working disclosure process. Instead, architect your credential layer so that a successful exploit is contained by the VK scope. A VK with read-only access to specific repos can't be made into a data exfiltration pipeline. The credential doesn't have the capability — no disclosure process required.
AI agents compound the problem. An agent that uses a VK to call a CRM tool, a GitHub tool, and a Slack tool has three credentials in the same loop. If any one of those credentials is scoped too broadly — which is the default in most setups — a prompt injection or manipulation of the agent's reasoning can use any of those credentials to exfiltrate data.
The VSCode github.dev attack is an example: the OAuth token didn't just get stolen — it got POSTed to an external server by a webview that the attacker controlled. In an agentic context, the equivalent attack is a prompt injection that instructs the agent to POST its GitHub token to an external endpoint. The agent obeys. The token leaves. The blast radius is the full scope of the OAuth token.
Trimio's MCP gateway addresses this directly: every tool call by an agent passes through Trimio's governance chain, including budget pre-check and VK scope enforcement. A VK scoped to repo read-only can't POST the token to an external server — the scope doesn't cover outbound HTTP calls, only GitHub API calls. The attack surface is structurally reduced.
Audit your AI tool inventory and identify every credential that has broad access. GitHub OAuth tokens, Google account permissions, CRM API keys — these are the credentials that went from "user's normal access" to "attacker's blast radius" in each of these incidents.
For each credential: determine the minimum scope it actually needs to do its job. Read-only? Specific repos only? Specific data classes? Create virtual keys at that scope and replace the broad credentials. The effort is a configuration change, not a code rewrite.
Set budget caps on every VK. Not just to manage costs — to serve as a security control. A VK with a $50/month budget that's burning through it at 3am is a security signal, and the budget cap stops it before the damage compounds.
Monitor for the pattern. Sudden spikes in output token volume from a VK, repeated identical API calls, tool responses that don't match expected patterns — these are the signatures of a compromised or manipulated agent. Your proxy layer should surface these in real time, not in the next morning's cost report.
Trimio's virtual key system and MCP gateway provide the structural controls. See how it works.