On 25 July 2026, Hacktron's researchers turned a malformed HEIF image into code execution on OpenAI's community forum, used an OpenAI-side SSO weakness to take over employees' ChatGPT and Codex accounts, and had one employee's Codex open a harmless pull request in OpenAI's internal monorepo. A frontier model built the exploit within hours of its release. Classified by cause, the chain is #2 → #7 → #4 → #1: a server-side flaw, a payload, a stolen identity and one abused function. AI changed the attacker's capability, cost and preparation time. It did not add a mechanism — and every step still needed its own weakness.
What Happened
Hacktron published its account on 13 September 2026. On 25 July, the researchers write, they “chained two critical vulnerabilities to compromise multiple OpenAI employees’ ChatGPT accounts.”
The entry point was the image pipeline of the forum at community.openai.com — a Discourse forum hosted by Discourse, not run on OpenAI's own systems. Discourse handed HEIF/HEIC uploads to ImageMagick for conversion, which exposed the underlying libheif parser to attacker-controlled files. The installed version (1.19.7, from Debian 12) contained a heap buffer overflow that gave out-of-bounds read and write during decoding. Exploited, it yielded remote code execution and administrative access to the forum environment.
The second weakness was on OpenAI's side. Hacktron: “the vulnerability to escalate is not Discourse-specific. It is an OpenAI SSO issue that turned the forum compromise into access to ChatGPT and Codex.” With the forum under their control, the researchers confirmed “no interaction account takeover of ChatGPT/Codex accounts from active members of the forum”, reported it, and took over an employee account whose Codex was connected to OpenAI's GitHub organisation. To prove the reach without reading internal code, they had that Codex open pull request #1186742 in the internal monorepo openai/openai.
HEIF upload → libheif flaw → forum RCE → OpenAI SSO weakness → employee account → Codex → GitHub connector → internal repositoryOpenAI confirmed its fix the same day. Discourse fixed the image path within two days and published advisory GHSA-vhm9-85gw-x335. OpenAI paid a $6,500 bounty on 1 September and clarified its scope: testing against the Discourse-hosted forum was excluded from its bug bounty programme, and the award covers the OpenAI-side finding only.
That sequence is a good operational narrative. It is not yet a threat model: it mixes software components, a dependency, vulnerabilities, identity transitions, functions and consequences. TLCTC separates those before classifying anything.
Classify the Cause, Not the Headline
TLCTC classifies each attack step by the generic vulnerability it exploits. Actor, technique name, product and impact do not decide the cluster, and a multi-step attack is written as a sequence of steps rather than squeezed into one label. For this incident the evidenced path is:
#2 → #7 → #4 → #1| Step | Cluster | Why |
|---|---|---|
| A malformed HEIF file is decoded by the forum's server-side image pipeline | #2 Exploiting Server | Attacker-supplied input exploits an implementation flaw in software acting in a server role. |
| The exploit's payload runs on the forum host | #7 Malware (R-EXEC) | Foreign executable content executed. R-EXEC requires the execution to be recorded as its own step instead of disappearing inside the word “RCE”. Administrative access to the forum and anything read from the host follow from this execution. |
| Employee ChatGPT/Codex accounts are taken over | #4 Identity Theft (R-CRED) | Something the compromised forum held or could obtain was presented to ChatGPT and Codex as an employee's identity — and accepted. The OpenAI SSO weakness is what made it acceptable (next section). |
The employee's Codex, prompted by the researchers, opens PR #1186742 in openai/openai through its GitHub connector | #1 Abuse of Functions | Codex and its connector did exactly what they are built to do, for someone who should not have been able to ask. One evidenced function use, one step. |
Two things are deliberately not in the path. Merely acting as the employee is not a #1 step of its own; the #1 is the concrete use of a function, here the pull request. And the GitHub leg is not a second #4: GitHub accepted the connector's token from its authentic holder, the Codex integration acting for the connected employee. The binding held there. The authentication that failed happened once, at ChatGPT and Codex.
Where the SSO Weakness Sits
The most strategically important part of the chain is not the memory corruption. Hacktron states that the escalation would have worked from any compromised service that uses the same login: “If any first-party or third-party OpenAI service using the OpenAI SSO was compromised, it would lead to same access - Discourse was merely one way of proofing it.” The forum was one reachable entry point — and not even an OpenAI system, but a service hosted by Discourse. The identity relationship carried a compromise in a third party's environment into OpenAI accounts.
The write-up does not say how the SSO weakness worked. It does establish what the weakness made possible: an identity artifact that a compromised forum could hold or obtain was honoured by ChatGPT and Codex as the employee. Presenting it is #4 under R-CRED, and the generic vulnerability of #4 — insufficient binding, at the point of authentication, between a presented credential and the authentic holder of the identity it claims — describes that failure precisely: something that should have been good for the forum alone was accepted elsewhere.
How the artifact was obtained is not published either, and two readings fit the evidence (“no interaction”, “active members”) equally well:
- Taken from the forum. The forum held, or saw pass through, login tokens or sessions of its active members, and OpenAI's SSO let those work at ChatGPT and Codex too. Reading them from the compromised host is part of the
#7step, as when an infostealer harvests session tokens. The path stays#2 → #7 → #4 → #1. - Minted with the forum's own credentials. The attackers took the forum's SSO client secret from the server and used it to obtain tokens for its members; the SSO weakness would then be that a forum-level client could get tokens valid for ChatGPT and Codex. That adds a step on OpenAI's side before the
#4at ChatGPT: presenting the forum's secret is itself credential use (#4), or, if the forum was entitled to request tokens and the issuing function simply served it too broadly,#1.
So the SSO weakness does not need its own slot in the evidenced path. The open question is whether OpenAI's side contributed an additional step before the #4 — one of the two above, or a defect in OpenAI's SSO code (#2). If Hacktron or OpenAI publish the mechanism and it shows such a step, it goes between #7 and #4.
It is tempting to write #2 → #7 → ? → #4 → #1. TLCTC's rule for unresolved steps argues against it: a ? asserts that a step occurred whose cluster cannot yet be determined (R-UNRES-9 reserves it for exactly that). Nothing in the evidence shows an extra step; what is unknown is the mechanism behind the #4. That belongs in a note, not in the path. A taxonomy should reduce ambiguity where the evidence allows it — and not manufacture a step the evidence does not show.
A Vulnerable Dependency Is Not a Supply Chain Attack
This incident contains everything that tempts analysts to say “software supply chain”: libheif, Debian packaging, ImageMagick, a Discourse Docker image, a missing backport. The history of the flaw even makes the point sharper. Hacktron notes that the vulnerable code “had been changed upstream the previous year, but the commit was not documented as a security fix and received no CVE” — likely why Debian 12 and 13 did not receive the fix in time. Debian 13 got its security update on 8 August 2026.
But dependency provenance and attack mechanism are not the same thing.
The decisive question is whether the attacker exploited the third-party trust relationship itself. TLCTC places #10 at the Trust Acceptance Event — the moment a trust artifact becomes authoritative inside the target domain (R-SUPPLY). If the attack still works with the trust relationship taken out of the mechanism, the step was not #10.
Here the attacker supplied a malicious image to software that contained a server-side flaw. The Debian package was genuine; it was simply old. Nobody subverted Debian, the libheif maintainers, the Discourse distribution or an update channel. The library's history explains why the flaw was present in production; it does not change which weakness the attacker exploited. The step is #2.
The contrast is simple. Had an attacker compromised a maintainer, planted code in a trusted libheif release, and had the forum accepted that release because it trusted the supplier, the trust relationship would be part of the mechanism: a genuine #10, followed by whatever the planted code did.
Vulnerability provenance tells us how the weakness arrived. Threat classification tells us which generic vulnerability the attacker actually exploited.
The missing CVE is still worth a lesson — just a vulnerability-management one. A fix without a CVE is invisible to patching that is driven by CVE feeds, and parsers of complex formats deserve tracking at the level of upstream commits.
Connectors Widen the Reach of One Step
After the identity step, the attack needed no further exploit. Codex and GitHub already provided the functionality; the researchers only had to ask for it through the employee's account.
A compromised AI account should not be assessed only by what its chat interface can do. Its real attack surface includes every tool, repository, mailbox, workspace, API, cloud service and workflow the identity can reach through connected authorisation. Hacktron puts it plainly: with these accounts they could access internal repositories “and potentially many other connectors.”
That is not a new threat cluster. It is a larger authorisation graph. In the path it does not even add a step: #4 → #1 stays #4 → #1 whether the #1 can reach one repository or fifty. The connector widens what a single abused function can touch. An agent makes the graph easier and faster to traverse, because it turns a natural-language objective into tool calls, but the compromise still consists of an identity being used and a legitimate function being exercised.
This is why access reviews for agentic systems cannot stop at the model endpoint. The boundary includes the harness, tool permissions, delegated credentials, connector scopes and the systems those connectors can operate.
What AI Actually Changed
Hacktron's account of the exploit work is specific. On 24 July an Opus 4.8 session inspected the libheif package in the Discourse image, found security fixes that had not been backported, and produced a working exploit — with ASLR disabled. Several sessions failed to make it reliable with ASLR on. That evening Claude Opus 5 was released; a new session produced a working ARM64 exploit for a local Mac within three hours and then ported it to the x86-64 and jemalloc configuration Discourse uses. By 06:00 on 25 July the researchers had local code execution through an image upload. An autonomous /goal loop then achieved code execution on their own Discourse Cloud instance, and the resulting script worked against OpenAI's.
Hacktron is also clear about the limits. This was not fully autonomous hacking: “skilled human guidance remained important, but the amount of work a small team could perform increased dramatically.”
A precision about “speed”. In TLCTC, attack velocity is Δt — the time between the steps of an attack in progress (Axiom IX). That was not the remarkable part here: code execution on OpenAI's forum and access to employee accounts fell on the same day, hours apart, with a bug report filed in between. What AI compressed is the time before the first step: finding the flaw and making the exploit reliable. That time never appears in an attack path, and it used to be where much of the practical protection came from.
In TLCTC terms the model belongs to the attacker's capability, not to the threat. Actor identity never decides a cluster (Axiom IV), and neither does the tool the actor used: the #2 is #2 whether a person or a model wrote the exploit. That is a shift in capability, scale, cost and preparation time — not evidence that AI introduced a new mechanism.
AI Does Not Remove the Vulnerability Requirement
A threat becomes realizable in the presence of a corresponding vulnerability. AI can improve the ability to discover, combine and exploit vulnerabilities; it does not make the vulnerability requirement disappear.
Opus 5 could be dramatically better at exploitation than its predecessor, and the forum would still not have fallen this way if the vulnerable decoder had been absent or isolated. Compromising the forum would not have yielded employee accounts if the identity relationship had not allowed it. And a taken-over account would not have reached the internal repository without a connector path to it.
Each step needed its own enabling condition. That is why a causal path is more useful than labels such as “AI attack”, “supply-chain compromise” or “account takeover”: the labels tell the story; the path tells you where each control has to sit.
The Risk Consequence: Revisit Exploitability
The strongest strategic message is not that defenders need an “AI threat category”. It is that organisations should revisit their assumptions about which vulnerabilities are realistically exploitable, and how quickly a capable attacker can operationalise them.
Complexity used to provide a weak form of practical protection. A difficult memory-corruption bug could be known while reliable exploitation still needed scarce skill, target knowledge and time. That was never a control, but it shaped likelihood. AI is eroding that buffer.
- Shorten remediation windows for exposed exploit primitives — and track upstream fixes in parsers even when they carry no CVE.
- Treat parsers and content-transformation pipelines as high-risk components, and sandbox complex content processing (Discourse did, right after the report).
- Inspect identity federation as an attack-path amplifier: which services' compromise converts into whose accounts?
- Include connector scope in access-risk analysis for every AI account.
- Measure not only severity but the shrinking effort needed to operationalise a weakness.
None of this requires changing the ten clusters. It requires assessing how quickly and cheaply existing clusters can now be chained.
Why This Matters for Cyber Alignment
There is a broader lesson for AI alignment, and the incident contains a small, concrete instance of it. Hacktron reports that the model “refused [to] write [an] exploit for remote instances”. The researchers pointed it at their own Discourse Cloud instance through a proxy set up to look like a CTF target, and the agent achieved code execution there. The refusal keyed on how the target was presented, not on what the chain would do.
Cyber compromise is causal and compositional. An objective is reached through a chain: find a server-side weakness, obtain execution, cross an identity boundary, use delegated authorisation, operate a connected system. A model that understands those structures is more useful for defence and for offence alike. Alignment that works on target descriptions, forbidden words or refusal patterns can be steered around by describing the target differently. Cyber alignment needs to reason about the chain itself: which capabilities are being combined, what loss-of-control state each successful step creates, and whether the model is helping to build a path toward unauthorised compromise.
That is a deeper problem than recognising a list of “dangerous” techniques — and a cause-oriented taxonomy is one way to give it structure.
Conclusion
The Hacktron case is a clean example of why cyber analysis should separate capability from mechanism. AI dramatically accelerated vulnerability research and exploit engineering, and that is strategically significant. But the path was still built from understandable causes: exploitable server software, an executed payload, an identity accepted where it should not have been, and a legitimate function operated through delegated connectors.
#2 → #7 → #4 → #1One part of it is still open — how OpenAI's SSO weakness worked — and the path marks it in the right place: as the weakness behind the #4, with room for one more step if the mechanism turns out to have one.
The causal structure remains. To understand and manage the new risk, model that structure more rigorously — do not abandon it for another headline category.
Further Reading
- OpenAI – Hugging Face Incident (July 2026): TLCTC Attack-Path Documentation — the other July 2026 OpenAI incident, with agents as the attackers
- Two Theses from the AI Hacking Incidents — why an agent is a capability vector, not an actor
- They Patched the Path. The Cluster Came Back in 24 Hours. — technique-level fixes and the generic vulnerability that survives them
- The TLCTC core paper — the ten clusters, R-EXEC, R-CRED, R-SUPPLY and the unresolved-step rules
Sources. Hacktron AI (Harsh Jaiswal, Mohan Pedhapati, Rahul Maini), Hacking OpenAI — A heap overflow and SSO misconfiguration to compromise OpenAI internal repositories, 13 September 2026 — all quotations and timeline details. Discourse Security Advisory GHSA-vhm9-85gw-x335, RCE via malformed HEIF file. TLCTC core paper (v2.6): cluster definitions, R-EXEC, R-CRED, R-SUPPLY, R-UNRES-9, Axioms IV and IX. The classification of the SSO step is based on the effect Hacktron reports; its mechanism has not been published.