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.
CHATGPT
When a shared link became an account risk
October 2026
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.

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.

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.
