I don't think the timelines make sense for it to have been included in training data, LLM training does not seem to be nearly efficient enough to learn these things from lone examples, and it wouldn't make sense for this earlier work to have made its way into both OpenAI and Gemini's data. Navier-Stokes is not strong evidence that this kind of thing can happen, as OpenAI denies that Buckmaster's work was in the training data for the model they used, Buckmaster didn't have a blowup that they could steal, and Scientific American reports[1] that the similarities between their approaches were superficial. It's also well-established that models can find novel vulns at this point.

[1]https://www.scientificamerican.com/article/openais-blockbust...

How is a bug that was patched six years ago causing RCE today? Not sure your link is correct.

Many exploits are used by security services, so this gives time to wrap any investigations or surveillance or find another method of accessing target servers.

Can anyone explain the lack of the irresponsible disclosure in the 'Responsible' disclosure timeline? The one that happened just before the coordinated release?

People should stop reading AI slop on X and other social media. The exploit is advanced and took some effort to fix. If there really was an open RCE in PHP for anyone to use the impact would be massive.

BTW, the backport fix seems to disable session upload entire in old version, not fixing the issue like new versions:

https://github.com/php/php-src/commit/712e60f9edfd03f0960fc4...

Both of them memory safety issues. C is just not fit for purpose in this decade.

Whats the issue with the POC video? I dont understand why thats surprising

It's generally safe for a defender to assume that if an attacker can corrupt the heap they can achieve RCE, because there are usually so many ways to do it. They're all very specific ways that are hard to find because of all the complexity and mitigations, but there are a practically unlimited supply if someone puts in the effort to find one. But as a defender you don't need to, you should just say game over as soon as you get heap corruption, and go fix it.

Generally the attacker has to cause a sequence of heap allocations so that a certain kind of object gets allocated into the freed space that's still being pointed to, then use the old pointer to corrupt that object, then use the object. A good target is any C++ object with a vtable pointer - not sure if PHP is written in C++. If you can rewrite a vtable pointer and make it point to attacker-controlled data, you can get execution to jump to an attacker-controlled address.

Plenty of function pointers to overwrite, presumably

One pattern of AI-assisted writing I hate is that technical articles now read as Atlantic journalistic tech-noir stories, which require scrolling through 20+ pages of content to get to the meat of a post.

no it was discovered first by an independent researcher https://x.com/calif_io/status/2112914613297668583

The OpenAI post linked says Sol assisted https://openai.com/index/coordinated-disclosure-of-critical-... and they invite more open source projects to apply to their program https://patchtheplanet.org/

Lots of stuff is PHP e.g. most message boards. It was very popular pre-dynamic web.

First the product they sell, then the product they got early access too...

I know they waited two months with this but wouldn't it be wiser to wait just a little bit more than a few minutes after the fix released?

a little self promotion there :P

Anything that compiles to a static site will be nearly immune!

I like to be AI sceptical as well but I think it's even more noticeable if the flaw is in 20 year old code which thousands of people have read and reviewed and not noticed, isn't it?

I discovered a large security concern that has existed for a decade, since the code was originally written. I was working on an unrelated task when my AI agent discovered an oversight because the agent happen to examine that file.

Everything was sound and every test passed for years along with every security scan because intent was not validated.

I would expect an unending source of exploits in the future until AI rewrites everything.

Eh, it's an RCE that's been around forever and runs on a pretty large number of websites. Worse a lot of businesses have things like wordpress sites so one of those getting compromised is a foot in the door allowing movement into the more protected areas of the network.

So yea, it's a big deal.

php RCE's are a big deal. So much of public facing stuff is drupal or wordpress and heaven knows all the places php is being used. Think embedded systems and appliances and in turn-key software.

I don't know why php is impossible to harden, but its a security minefield, and if there is an RCE then its trivial to attack because so many of these systems are public facing. I veto any php based applications just over this.

That's why so much emphasis is now placed on trying to make incorrect software either fail to build or fail at runtime in a way that doesn't let people take over the computer. C makes it extremely likely that a random correctness issue will be a security issue. Newer languages much less so. They're far from perfect but it's a lot better.

Grinding through abandoned source code in hopes of finding a vulnerability isn't exactly the most fulfilling work for many, perfect use case for AI which doesn't sleep.

Apparently both bugs had been reported previously, pre-AI, if so some important questions need to be asked about how those reports slipped through without a fix.

OpenCloud had been great for me lately

> I want to understand how it leaked. I guess a whole lot of people were looped in between September 21 and October 21?

Yes. I was at AWS when Spectre and Meltdown were discovered, and we received approximately a month of advance notice and put together teams to apply mitigations. The work of the team was on a need-to-know basis--even team members' managers only knew they were pulled onto a critical project, not what the specific project was. But there were still 30+ people in the company who knew, and that was just one company (I'm guessing Google/Azure/other cloud providers got similar advance notice).

Now, this is a much wider scale vulnerability, in the sense that Spectre/Meltdown primarily impacted cloud providers, but this attack impacts literally anyone who runs PHP. Dozens, if not hundreds, of companies likely got advance notice that a patch needed to be installed. In those companies there are teams of people applying those patches. All it takes is one of them who wants 15 minutes of internet fame to leak the details.

Two months is way too long for this, and the people involved seem to not know the "way" to do this - it shouldn't have taken a month from "reports" to "PHP acknowledges" which smells like "we sent an email or filled out a web form" when the ACTUAL reporting mechanism is "we talked to our friends at <MAJOR DISTRO> or <WORDPRESS> who called the right people and a patch is being slipped in."

> I want to understand how it leaked

If I understand correctly someone showed off a video of exploit in action - just like the ones included in article - and the visible messages were enough for other LLM users to discover the exploited bug.

> I want to understand how it leaked

I'm confused. How do you know it leaked?

It would have been nice if there had been time for downstream distributors to patch as well.

Simon, it seems you spend too much time close to the AIs and your writing is getting flagged.

That's wiz.io for you. Blogspam

That's... not how coding agents work.