On September 8, 2026, Check Point Research published a finding that should change how anyone defending an organization thinks about AI assistants with connected apps. A hidden instruction planted in a ChatGPT conversation could make the assistant read a victim’s connected Gmail account and hand the contents to a completely different ChatGPT account — with no approval prompt, and with the only visible trace a small “Talked to Gmail” label that appeared after the read had already happened. OpenAI confirmed to Check Point that the internal service behind the leak has been decommissioned. There is nothing for users to patch.
Most coverage will file this under prompt injection, and the injection is real: a malicious prompt pasted into a chat, a shared conversation link, or a custom GPT carrying a hidden instruction were each enough to plant it. But the injection only pulled the trigger. What made the attack work — and what makes it worth studying — was a tenant-isolation failure in the infrastructure underneath the model. If you are preparing for CompTIA CySA+ (CS0-003), or you run a SOC that has approved AI tools with mailbox access, this is a case study in broken access control, compensating controls, and the limits of your own visibility.
Watch the summary
How the Attack Chain Worked
Three stages, each one ordinary on its own.
1. The trigger. The attacker plants an instruction the victim never reads. When the victim sends an ordinary message, ChatGPT handles the visible request and, alongside it, carries out the hidden task.
2. The read. The hidden task uses ChatGPT’s connected-app integration to read the victim’s Gmail. Under the default connected-app permission setting, read actions the platform considers low risk are approved automatically, without a separate confirmation step. The victim is never asked. The “Talked to Gmail” label is logged after the fact.
3. The exfiltration. This is the part that matters. ChatGPT’s code-execution containers pull Python and npm packages from an internal JFrog Artifactory instance. Artifactory’s item-management API lets a client attach text or binary properties to a repository item and read them back. Check Point found that every container carried credentials able to use that API, and that the properties were not isolated per account. A container in the attacker’s session could read what a container in the victim’s session had written. Larger payloads were split across several properties and reassembled on the other side. Package-delivery metadata had become, in Check Point’s words, a shared clipboard between containers that were supposed to be walled off from one another.
No outbound internet connection was required. The handoff happened entirely inside OpenAI’s infrastructure, between two sandboxes belonging to two different accounts.
This is the second exfiltration channel Check Point has published out of the same code-execution runtime this year. The first, fixed in February 2026, encoded data into DNS queries that the sandbox was still allowed to make. The pattern is worth noticing: the model’s guardrails held both times. The infrastructure around the model is where the holes were.
Where This Maps on the CS0-003 Exam
This incident spans two domains and one recurring exam trap.
Domain 2, objective 2.4 — recommending controls to mitigate attacks and software vulnerabilities. The core flaw is broken access control: an API that authenticated clients but did not authorize them per tenant. It is also insecure design and security misconfiguration — a management interface reachable from a runtime that only needed to download packages. If a question describes a multi-tenant service where one customer’s process can read another customer’s data through a shared component, you are looking at broken access control, not at the payload that used it.
Domain 1, objective 1.1 — system and network architecture concepts. Containerization is the isolation boundary here, and the exam expects you to understand what a container does and does not isolate. Containers isolate processes, filesystems, and usually networks. They do not isolate anything the containers share by design — and here they shared a package registry with a writable metadata API. Shared infrastructure is a trust boundary whether or not the architecture diagram draws it as one.
The exam trap: confusing the trigger with the vulnerability. Scenario questions often describe a phishing email, a malicious link, or an injected string, then ask which control would have prevented the impact. Candidates reach for the control that blocks the trigger — email filtering, input validation. The higher-scoring answer usually targets the weakness that turned a trigger into an impact. Here, prompt filtering would not have helped; per-tenant authorization on the Artifactory API, or simply making it unreachable from the sandbox, would have.
For readers who follow the OWASP Top 10 for LLM Applications, the same incident touches Prompt Injection (LLM01), Sensitive Information Disclosure (LLM02), and Excessive Agency (LLM06) — the last one being the connected-app permission that let a hidden task act on the mailbox without confirmation.
The Defender’s Problem: You Had No Telemetry
Here is the uncomfortable part for anyone running a SOC. Suppose your organization uses ChatGPT with Gmail connected, and one of your users pasted a poisoned prompt in July. What log would you query to find out?
There is none on your side. The read happened inside OpenAI’s infrastructure, through OpenAI’s connector, against Google’s API, using an OAuth grant your user approved once. The exfiltration happened between two containers on OpenAI’s internal registry. The only customer-visible artifact was a “Talked to Gmail” label in a chat transcript — after the fact, and only if someone looked. Your SIEM has nothing to ingest, your DLP never saw the bytes, and your EDR has no process to watch. You cannot retro-hunt what was never logged anywhere you can reach.
That leads to a conclusion worth stating plainly: when an AI agent runs inside a vendor’s container, the permission grant is your entire control surface. Not monitoring. Not detection. The grant. Everything you decide about which apps are connected, what scopes they hold, and whether actions require confirmation is the whole of your defense, because it is the only layer you actually operate.
That reframes AI-tool governance from a policy nicety into the same category as identity and access management — which is exactly where CS0-003 objective 1.1 places privilege management and least privilege.
Action Checklist: Run This Against Your Own Environment
- Change the connected-app permission from the default to “Always ask.” The default approves low-risk reads silently, and reads are what exfiltration is. Requiring confirmation on every action turns a silent read into a prompt the user can refuse.
- Audit connectors per workspace. ChatGPT Enterprise and Edu administrators control app access policies. List which connectors are enabled, which users hold them, and remove any that are not doing work someone can name.
- Scope OAuth grants. Where the connector supports it, grant read access to a label or folder rather than a mailbox, and to specific drives rather than all of them. Least privilege applies to agents exactly as it applies to service accounts.
- Inventory standing AI tokens. Every AI tool holding a live OAuth token into mail, drive, ticketing, or source code is a standing credential with no logging on your side. Record each one in the same register as your service accounts, with an owner and a review date.
- Put tenant isolation in vendor questionnaires. Ask AI vendors how they isolate tenants in shared infrastructure — package registries, caches, queues, object storage — and whether management APIs are reachable from the execution sandbox. The answer tells you more than a compliance badge does.
- Treat the model’s own logs as evidence, not monitoring. “Talked to Gmail” in a transcript is a forensic artifact, not an alert. If your incident response plan for AI tools does not say where to find that artifact and how to preserve it, add it now.
Exam Tips
- When a scenario describes one tenant’s process reading another tenant’s data through a shared service, the vulnerability class is broken access control (objective 2.4), regardless of how the attacker got a process running in the first place.
- Know what containerization isolates and what it does not. Shared registries, caches, and message queues sit outside the container boundary and need their own authorization.
- Compensating controls are a valid answer when you cannot fix the underlying flaw (objective 2.5). You cannot patch a vendor’s registry — tightening a permission setting, reducing scope, or removing a connector is the compensating control.
- Least privilege applies to non-human identities: service accounts, API keys, and now agent permission grants. An agent that can read a mailbox without asking is an over-privileged identity.
- Separate the trigger from the vulnerability in incident questions. The injected prompt is the trigger; the missing authorization check is the vulnerability; the control question is usually about the latter.
Sources
- Check Point Blog — “ChatGPT Let Attackers Read Victims’ Gmail Through a Hidden Channel Between Accounts” (September 8, 2026)
- Check Point Research — “The Shared Clipboard Inside the Sandbox: Cross-Account Data Leakage in ChatGPT” (September 8, 2026)
- The Hacker News — “ChatGPT Flaw Let a Planted Prompt Send a Victim’s Gmail Data to Another Account” (September 8, 2026)
- Cyber Security News — “ChatGPT Sandbox Flaw Lets Attackers Steal Gmail Data Across Accounts via Hidden Channel” (September 8, 2026)
- eSecurity Planet — “Check Point Research Reveals ChatGPT Data Exfiltration Flaw” (March 31, 2026), covering the earlier DNS-based channel
The featured image and the summary video above were produced with AI tools. The reporting, analysis, and exam mapping are the author’s own, drawn from the sources listed.



