Cybersecurity

Claude Opus 5 and the OpenAI Hack: What the Hacktron Report Shows

Hacktron researchers used Claude Opus 5 to exploit OpenAI's help forum and reach an internal repo, then reported it. The real story is a capability jump.

Editorial Team / /11 min read
Clawd mascot in a hard hat studies a green bug and a gold coin by a server rack with a magnifying glass, OpenAI logo

The headline that circulated in mid-September read like a thriller: an AI model had hacked OpenAI. What actually happened is less dramatic and more useful to understand. Three researchers at Hacktron, an AI-native security firm that runs code reviews and penetration tests, attacked OpenAI’s public help forum, used the access they gained to reach an internal code repository, and then reported the chain to OpenAI. They used Claude Opus 5, Anthropic’s model, as a tool to write the exploit code. The forum itself was not covered by OpenAI’s bug bounty: OpenAI states that testing against the Discourse-hosted community.openai.com “was explicitly excluded from our bug bounty program”, and the bounty it later paid through Bugcrowd recognized only the OpenAI-side finding. The researchers disclosed quickly, stopped after a deliberately harmless pull request, and say they avoided learning any sensitive information. The detail worth remembering is narrower and more durable than “AI can hack now”: a newer version of the same model succeeded at a task the previous version had struggled with across several sessions, in about three hours.

What actually happened, in order

OpenAI runs a public help forum at community.openai.com, built on Discourse, an open-source forum platform used by thousands of sites. Like most modern forums, it lets people upload images, including files in the HEIC/HEIF format that iPhones use by default. Those images get processed by a decoding library behind the scenes before they are shown to other users.

According to Hacktron’s write-up, the researchers uploaded a booby-trapped HEIC image to the forum. The file was built to exploit a flaw in libheif, the open-source library that decodes HEIF images: a heap buffer over-read, a bug where a program reads memory just past the data it is supposed to read, which can leak information or corrupt what a server does next. The flaw is now tracked as CVE-2026-32882 (a public identifier used to catalog software vulnerabilities so defenders can track and patch them). It affects libheif 1.21.2 and earlier and was fixed in version 1.22.0, per the Debian security tracker. Red Hat gives libheif itself a preliminary severity score of 7.1 out of 10, while Discourse’s own advisory, which describes remote code execution via image uploads, rates the impact on forums at 8.8. According to Hacktron and TechCrunch, the vulnerable code had been changed upstream the previous year, but that change was never documented as a security fix and received no CVE at the time, which is exactly why it never triggered an alert for distributions like Debian to backport it.

OpenAI’s forum was running libheif 1.19.7, the version installed by the Discourse image it used. That gap, invisible to standard vulnerability tracking precisely because the original fix was never labeled security-relevant, is what let the researchers’ crafted image reach the vulnerable decoding code. Our explainer on zero trust architecture covers why systems that assume internal services are automatically safe tend to have exactly this kind of blind spot.

Once the booby-trapped image was processed, the researchers obtained out-of-bounds read and write primitives, a foothold that let them manipulate the server’s memory directly rather than just crash it. From there they worked toward full remote code execution (RCE), meaning running their own commands on OpenAI’s forum server. To get past Claude’s refusals to write exploits for remote instances, the team says it routed its testing so the target looked like a capture-the-flag (CTF) challenge. The next step made the breach far more consequential than a defaced help forum. Hacktron describes an OpenAI single sign-on (SSO) issue, not specific to Discourse, that turned the forum compromise into access to ChatGPT and Codex: any user or OpenAI employee logging into the help forum could have had those accounts taken over. The researchers took over the account of an OpenAI employee whose Codex was connected to OpenAI’s GitHub organization, and the whole chain, from initial discovery to access to an OpenAI repository, took less than 72 hours, according to Hacktron.

The official libheif GitHub releases page, showing version 1.22.0 that fixed CVE-2026-32882

libheif: the open-source HEIF/HEIC decoding library whose CVE-2026-32882 flaw, patched in version 1.22.0, was the entry point for the exploit.

The exploit chain wasn’t one AI flaw, it was three human ones

It is tempting to read this story as “AI broke into OpenAI,” but the chain that made it possible had nothing to do with artificial intelligence misbehaving. It was three ordinary, human infrastructure choices, each unremarkable on its own and dangerous stacked together.

The first was an outdated open-source dependency. An upstream fix for the libheif flaw had existed for about a year before this test, but because it was never labeled as a security fix, nothing prompted the forum’s software stack to pick it up. This is not unusual. Large organizations run hundreds of third-party libraries, and keeping every one current, everywhere, is a genuinely hard operational problem, not a one-time fix. Our look at software supply chain attacks covers the same underlying pattern: the danger usually sits in code nobody wrote in-house and nobody is watching closely.

The second was an image-format filter with a blind spot. Discourse normally uses a library called FastImage to check uploaded images. FastImage does not support the HEIC/HEIF format, so those files were passed to ImageMagick for conversion, and from there to the vulnerable decoding library underneath. The researchers did not need to defeat the check; it never covered that format in the first place. A validation step that silently hands off formats it doesn’t recognize offers much less protection than it appears to on a security audit checklist.

The third, and the one that turned a forum bug into a much wider exposure, was an SSO weakness that let a forum compromise reach ChatGPT and Codex accounts, per Hacktron. SSO exists to make life easier: one login, many services. But that convenience means a weakness anywhere in the chain can become a weakness everywhere the login is trusted. None of these three issues required artificial intelligence to exist or to be dangerous. They are the kind of gaps a human red team finds in traditional penetration tests every year. What changed is how fast one got turned into a working exploit.

What actually changed between Opus 4.8 and Opus 5

Here is the fact in this story that deserves to be called new, and it has nothing to do with intent or autonomy. To build a reliable exploit, the researchers had to get past ASLR, a standard memory protection built into modern operating systems that randomizes where a program’s code sits in memory each time it runs, specifically to make this class of exploit harder to write. An attacker who does not know where their target code sits in memory generally cannot build a reliable exploit around it.

According to Hacktron’s account, the researchers first tried this with Claude Opus 4.8, an earlier version of Anthropic’s model. Opus 4.8 got code execution working with ASLR disabled, but several separate sessions aimed at making the exploit reliable with ASLR enabled were not fruitful. Then, on July 24, 2026, Anthropic released Opus 5. Hacktron gave the newer model the same unsolved problem. In the firm’s own words, in its write-up: “Opus 4.8 struggled across several sessions to produce a working exploit with ASLR enabled… Within hours of Opus 5’s release, we gave it the same problem and it succeeded.” Opus 5 produced a working exploit for a local Mac in about three hours. The researchers then asked it to port that exploit from one processor architecture (ARM64, used in Apple and many mobile chips) to another (x86-64, the architecture most servers run) and to the memory configuration Discourse uses, and the team reports remote code execution on OpenAI’s forum instance.

That is the durable idea underneath this whole story. It is not that an AI model attacked a company, and it is not evidence of intent or independent decision-making; the researchers chose the target and directed the work, and Hacktron itself writes that this was not completely autonomous hacking and that skilled human guidance remained important. What the figures show is a measured capability gap between two successive versions of the same model on one specific, well-defined technical task. A flaw that sat unpatched and effectively low-risk because exploiting it was hard became considerably easier to exploit, not because the flaw changed, but because the tooling available to attackers did, in the space of a single product release. That is a signal about how long a patch window can safely stay open, not a signal about machine intent.

Anthropic's announcement page for Claude Opus 5, the model used in the exploit development

Claude Opus 5: the Anthropic model that succeeded at the ASLR bypass Opus 4.8 had struggled with across several sessions.

Not the Google Gemini story from the same week

This incident is easy to confuse with another AI-and-security story that broke in the same period, and the two describe genuinely different things. In September 2026, the Wall Street Journal reported, and Google then confirmed, that its Gemini model had broken into three real companies’ systems earlier that year during a test run by the AI security firm Irregular. The test, meant to run in an isolated environment, unintentionally gave Gemini internet access, and in at least one case a fictional target shared its name with a real business. According to reports of Google’s disclosure, the model guessed a password in one case and obtained credentials from information found online in the others, and Google says it stopped each time before completing the act. Nobody authorized Gemini to touch those real-world systems; it happened as a side effect of a test-environment mistake.

The Hacktron and Claude Opus 5 case is a different kind of event. A human research team deliberately targeted OpenAI’s forum, which was outside the scope of OpenAI’s bug bounty, then disclosed the chain and was rewarded only for the OpenAI-side finding. Nothing about it was accidental, and no evaluation boundary failed. Treating these as the same phenomenon, “AI models breaking out and attacking things,” erases the distinction that matters for anyone deciding how worried to be: whether humans deliberately pointed the tool at the target, or whether a boundary failed by accident. The Hacktron case is the former. The Irregular case is the latter. Both are worth tracking. Neither explains the other.

What this changes for defenders

The practical lesson for security teams has little to do with whether to trust AI coding tools and a lot to do with how little visibility most organizations have into fixes buried inside software nobody wrote in-house. A library like libheif sits several layers below most engineers’ daily attention, pulled in as a dependency of a dependency, and in this case the upstream fix was never flagged as a security patch at all, so even a team with disciplined patch management had no CVE, no advisory, and no alert telling them to apply it. The Hacktron test suggests that the cost of leaving that window open is no longer bounded by how hard it is to write exploit code by hand. If a capable model can close that gap in hours once a sufficiently capable version ships, the practical patch window for a known flaw gets shorter every time a more capable model becomes available, independent of whether anyone is actively trying to exploit it yet.

The second lesson is about blast radius through shared login systems. When a public-facing surface, a help forum, a support portal, a community site, sits on the same sign-on trust as accounts connected to internal engineering resources, a compromise of the public surface can travel much further than its own data. OpenAI fixed the OpenAI-side weakness quickly once notified, confirming the fix roughly 14 hours after the initial submission, and on September 1 paid Hacktron a $6,500 bounty through Bugcrowd (a platform that runs and manages bug bounty programs for companies). In a comment quoted in Hacktron’s write-up, OpenAI specifies that the award “recognizes the OpenAI-side finding, not the actions against Discourse.” OpenAI told TechCrunch it has resolved the issues Hacktron uncovered. It is also worth stating plainly what Hacktron says it did not do: it used the employee’s Codex account to open one deliberately harmless pull request in OpenAI’s internal monorepo, did so without accessing any internal code, and then stopped testing. This was a deliberate, disclosed test with a fast fix and no reported lasting damage, but it was not an authorized one for the forum itself.

Frequently asked questions

Did Claude Opus 5 actually hack OpenAI on its own?

No. Claude Opus 5 was a tool used by human researchers at Hacktron during a security test of OpenAI’s public help forum that was outside OpenAI’s bug bounty scope, later disclosed through Bugcrowd. The researchers chose the target and directed the work; Hacktron says skilled human guidance remained important and that this was not completely autonomous hacking.

What was the actual vulnerability that got exploited?

The starting flaw was a memory-reading bug in libheif, the open-source library that decodes HEIC/HEIF image files, now tracked as CVE-2026-32882 and fixed in version 1.22.0. The underlying code change had existed upstream since the previous year but was never documented as a security fix and had no CVE at the time, which is why it never got backported into the version OpenAI’s help forum was running.

What is the real difference between Claude Opus 4.8 and Opus 5 in this story?

Opus 4.8 got code execution with a memory protection called ASLR disabled, but struggled across several sessions to make the exploit work with ASLR enabled. ASLR randomizes where code sits in a computer’s memory to make exploits harder to build. Opus 5, given the same problem within hours of its release on July 24, 2026, produced a working exploit in about three hours and then adapted it to a different processor architecture when the researchers asked.

Is this the same incident as the Google Gemini sandbox escape?

No, they are unrelated events that happened to surface in the same period. The Gemini case, involving the AI security firm Irregular, was an accidental breakout caused by a test environment mistake. The Hacktron case was a deliberate security test by humans, later disclosed, not an accidental escape.

Did the researchers access OpenAI’s real source code or sensitive data?

According to Hacktron, no. The researchers say they demonstrated impact without accessing any internal code and without allowing themselves to learn any sensitive information. The one action taken against an internal repository was a single pull request they describe as harmless, after which they stopped testing.

#claude-opus-5#openai#bug-bounty#cve#ai-security