All resources
Security Brief10 min read

How a ChatGPT share link could take over an account, and what changed.

The dangerous part was not a downloaded file. A victim only had to open a normal-looking ChatGPT share link while signed in. The exploit chain turned an HTML preview into JavaScript running with access to the ChatGPT session.

Parameter Labs reported a ChatGPT vulnerability in which an attacker could turn a public conversation share into code running inside the signed-in victim's ChatGPT session. No app install, copied snippet, or developer-tools step was required: opening the malicious share link was enough. OpenAI fixed the issue on October 26 and classified the report as P1.

The short attack chain

The exploit combined several features that looked harmless in isolation. A public ChatGPT conversation could contain an interactive HTML preview. The preview lived in a sandboxed frame, but the research chain found a way to communicate with code in the parent page through the graph and MathLive integration. An HTML injection path then crossed the intended boundary, and a content-security-policy bypass allowed attacker-controlled JavaScript to execute onchatgpt.com.

Once code ran with the signed-in origin, it could call authenticated ChatGPT APIs as the victim. Parameter Labs demonstrated reading private conversations and sending data to an external server. That is why the issue was an account and data exposure problem, not merely a visual cross-site scripting bug.

The public ChatGPT share modified the real ChatGPT page
Parameter Labs showed the public share modifying the real ChatGPT page. Image: Parameter Labs.

Why opening a link was enough

The victim did not have to trust a browser extension or paste code into a terminal. The shared page itself supplied the attacker-controlled content, while the victim's existing login supplied the privileges. That is a particularly uncomfortable class of bug because the user action looks ordinary and the visible result can look like a normal interactive conversation.

Parameter Labs reported that the chain could enumerate conversations, retrieve content from private chats, and send data to an external server. Those capabilities matter more than the label attached to the first bug in the chain: the practical outcome was access to private data and authenticated actions.

What the report does not mean

The report describes a vulnerability that OpenAI says it fixed on October 26. It does not mean every ChatGPT shared link is currently malicious, nor does it prove that every person who opened a link was compromised. The useful response is to understand the chain, apply the fix, and review sensitive sessions if a suspicious link was opened before the fix.

What users should do

  • Update or reload ChatGPT so the fixed server-side behavior is in effect, and sign out of sessions you do not recognize.
  • Review account security settings, active sessions, connected apps, and API keys if you opened an unexpected shared link during the exposure window.
  • Rotate credentials that were present in private conversations or files if those conversations could have been accessed.
  • Treat public ChatGPT links as untrusted content. Do not open unexpected links in a privileged account simply because they look like ordinary shared conversations.
Parameter Labs proof that private ChatGPT conversation data could leave the session
The original report included a controlled proof that private chat data could leave the victim's session. Image: Parameter Labs.

The lesson is about feature boundaries

Sandboxing is not a single checkbox. A frame can be isolated from direct script access and still become dangerous if another feature accepts messages from that frame, inserts HTML into a privileged page, or loads a resource that changes the execution context. The attack chain was powerful because each small assumption composed with the next.

The technical lesson is not that HTML previews should never exist. It is that every bridge between an untrusted frame and the privileged application needs an explicit origin check, a narrow message schema, safe DOM construction, and a policy that does not quietly turn a resource loader into a script loader. A single permissive bridge can undo several otherwise reasonable controls.

For AI products, this matters beyond ChatGPT. Code previews, interactive artifacts, charts, connectors, and tool calls all blur the boundary between generated content and application authority. The security question is not only whether generated code is malicious; it is what the product lets that code reach.

The signal to watch

The durable takeaway is that sharing is now an application surface. When a shared conversation can render code, call a library, and communicate with a signed-in product, it deserves the same threat modeling as an upload or an embedded third-party application.