Latest / AI Newspaper / AI Found Decade-Old Flaws in PHP, the Code Behind Most of the Web, and the Patch Race Is On

Transcript

AI Found Decade-Old Flaws in PHP, the Code Behind Most of the Web, and the Patch Race Is On · AI Newspaper

• 0:00
  Welcome to the AI Newspaper, your daily update
• 0:02
  on everything happening with AI. Visit AINewspaper
• 0:05
  .org to see today's stories and sign up for email
• 0:08
  alerts. So if we look back at October 17th, cyber
• 0:14
  defenders monitoring global networks kind of
• 0:17
  realized they had a massive problem on their
• 0:19
  hands. Yeah, to put it mildly. Right, because
• 0:20
  someone or maybe something was actively trying
• 0:23
  to break into servers and they were using this
• 0:25
  flaw. In the PHP programming language, that was,
• 0:28
  well, it was supposedly impossible to exploit.
• 0:30
  Right. And the truly terrifying part here is
• 0:34
  that they were doing it for full days before
• 0:36
  the fix for that flaw was even made public. It
• 0:39
  really is a complete paradigm shift. I mean,
• 0:43
  we are now living in a reality where the defining
• 0:46
  security challenge isn't really about whether
• 0:48
  these massive hidden software bugs exist anymore.
• 0:52
  Yeah. It's entirely about this high stakes race
• 0:54
  over disclosure windows and patch speeds. Because
• 0:58
  when frontier AI models can take a 10 -year -old
• 1:00
  impossibly complex software flaw and turn it
• 1:03
  into a working attack weapon overnight, well,
• 1:06
  the advantage heavily shifts to whoever finds
• 1:08
  that flaw first. And that is exactly the lens
• 1:10
  we're looking through today on this deep dive.
• 1:12
  We are breaking down the PHP to shell vulnerabilities.
• 1:16
  We really need to figure out how AI models manage
• 1:19
  to conquer the limits of human complexity. crack
• 1:22
  these ancient flaws. So we're going to look at
• 1:24
  the frantic minute -by -minute timeline of the
• 1:26
  real -world exploits that followed, and then,
• 1:29
  you know, analyze the massive global coordination
• 1:31
  it's taking to quite literally patch the foundation
• 1:34
  of the web. Because the sheer scale of the blast
• 1:37
  radius here is, it's incredibly hard to overstate.
• 1:40
  I mean, if you interact with the internet in
• 1:42
  any capacity, you interact with PHP. Right, it's
• 1:45
  everywhere. It is the core programming language
• 1:47
  that powers platforms like WordPress, Drupal,
• 1:50
  Joomla. wikipedia we're talking about roughly
• 1:54
  70 of all websites relying on this architecture
• 1:56
  wow okay so before we get into the global race
• 1:59
  to fix this i really want to unpack exactly what
• 2:02
  these flaws are because reading the initial reports
• 2:04
  is just a wall of dense jargon oh absolutely
• 2:07
  so we have two critical vulnerabilities there's
• 2:10
  um cve -2026 -109618 which is described as Let
• 2:18
  me get this right. Out of memory handling leading
• 2:20
  to the use of uninitialized data. Right. And
• 2:23
  then there's CVE -2026 -109619, which is a use
• 2:28
  after free flaw leading to opcache type confusion.
• 2:32
  Yes. Let's pause right there because if you aren't
• 2:34
  a software engineer, your eyes probably just
• 2:35
  glazed over completely. Can we translate that
• 2:38
  a bit? Yeah. Let's break it down and maybe start
• 2:40
  with the severity. So both of these bugs carry
• 2:43
  a CVSS score of 9 .2. Okay, and CVSS is the standard
• 2:48
  scoring system, right? Exactly. It's the industry
• 2:50
  standard for scoring vulnerabilities on a scale
• 2:52
  of 1 to 10. And 9 .2 essentially means the house
• 2:55
  is actively on fire. Right. In practical terms,
• 2:58
  it allows for what we call unauthenticated remote
• 3:00
  code execution, or RCE. Meaning an attacker doesn't
• 3:04
  need a password, they don't need an account on
• 3:06
  your website, they literally just need to send
• 3:08
  a specific package of data over the internet
• 3:10
  to take total control of your server? Exactly.
• 3:13
  Anyone, from anywhere, can run arbitrary code
• 3:17
  on your machine plus it allows for a heart bleed
• 3:21
  style memory disclosure oh wow yeah meaning they
• 3:24
  can silently siphon off sensitive data like passwords
• 3:27
  or user sessions straight from the server's active
• 3:30
  memory and the truly chilling part is that this
• 3:33
  flaw is baked into php itself so it doesn't matter
• 3:36
  what application you're running on top of it
• 3:38
  exactly completely independent you could have
• 3:41
  the most secure stripped down basic website imaginable
• 3:44
  But if the underlying server is running a vulnerable
• 3:47
  version of PHP, which right now includes every
• 3:50
  single version dating back to 5 .4, you are completely
• 3:54
  exposed. Okay, I want to try and visualize this
• 3:57
  memory issue because I know concepts like use
• 4:00
  after free and uninitialized data, they sound
• 4:02
  incredibly abstract. They do. So if we imagine
• 4:04
  PHP as a chaotic, high -volume restaurant kitchen.
• 4:08
  I like this. An order comes in, which is basically
• 4:11
  a web request. The chefs start prepping the meal,
• 4:14
  pulling ingredients out of the fridge. But suddenly,
• 4:16
  halfway through, the customer abruptly cancels
• 4:18
  the order. Right. And in our technical scenario,
• 4:21
  that cancellation is the out -of -memory error.
• 4:24
  Exactly. Now, in a perfectly functioning kitchen,
• 4:26
  the staff would immediately throw out all the
• 4:29
  half -cooked contaminated ingredients and wipe
• 4:32
  down their counters before starting the next
• 4:33
  ticket. Right. But because of this bug, they
• 4:36
  don't wipe down the counter. Yeah, the cleanup
• 4:38
  process just crashes. The contaminated ingredients
• 4:41
  are left sitting there. Then a brand new order
• 4:44
  comes in. And the chefs, rushing to fulfill it,
• 4:47
  accidentally grab those stale, contaminated ingredients
• 4:51
  left on the counter and use them to cook the
• 4:53
  new meal. Which brings us to the Opcache -type
• 4:56
  confusion. Right. So an Opcache is basically
• 4:59
  PHP's way of remembering translated code, so
• 5:02
  it doesn't have to rebuild it from scratch every
• 5:04
  time a user loads a web page. It's a shortcut
• 5:06
  for speed. Okay. So type confusion means the
• 5:09
  attacker has manipulated those contaminated ingredients
• 5:11
  so cleverly that they trick the kitchen into
• 5:15
  thinking a piece of malicious, poisonous code
• 5:17
  is just a standard, harmless recipe. Oh, wow.
• 5:21
  Yeah. When the system caches it, it accidentally
• 5:23
  arms the bomb. But wait, if this broken cleanup
• 5:25
  process, like this messy kitchen counter, has
• 5:28
  been sitting in the PHP code for more than 10
• 5:31
  years, why is it only a crisis today? That's
• 5:34
  the big question. Right. I mean, human security
• 5:35
  researchers have cracked incredibly complex systems
• 5:38
  before. Was it really impossible for a human
• 5:41
  to find this, or were people just not looking
• 5:43
  hard enough? Well, it wasn't mathematically impossible
• 5:45
  for a human, but practically. The return on investment
• 5:47
  was abysmal. How so? Because memory bugs are
• 5:50
  notoriously fragile and temperamental. To turn
• 5:53
  that messy kitchen counter into a reliable working
• 5:55
  exploit, you have to adapt your attack to the
• 5:57
  specific memory layout of every single server
• 5:59
  you target. Oh. So it changes depending on the
• 6:03
  server. Exactly. A configuration that works perfectly
• 6:05
  against one specific WordPress deployment will
• 6:08
  completely crash and fail against a slightly
• 6:10
  different Drupal deployment running on a different
• 6:11
  operating system. Right, right. So for a human
• 6:13
  researcher, mapping and chaining all those variables
• 6:16
  together requires an unbelievable amount of highly
• 6:19
  specialized, just tedious manual debugging. You're
• 6:22
  talking about staring at memory registers and
• 6:24
  crash dumps for months. Months for one exploit.
• 6:27
  Yeah. It operated at the absolute edge of what
• 6:29
  human researchers could practically achieve,
• 6:31
  so it acted as a natural barrier. It was basically
• 6:34
  security by obscurity. We kind of just assumed
• 6:36
  that if a vulnerability was too frustrating and
• 6:39
  difficult for a human to weaponize, it wasn't
• 6:41
  a practical, scalable threat. Exactly. But AI
• 6:45
  has fundamentally altered the economics of vulnerability
• 6:47
  discovery. Researchers basically decided to throw
• 6:51
  frontier models, specifically Gemini 4 Argon
• 6:55
  and GPT 5 .6 Sol, at this exact problem. Okay.
• 7:00
  And they didn't just ask the AI to read the code.
• 7:02
  They set the AI up as autonomous agents alongside
• 7:06
  standard security testing tools. So how does
• 7:10
  that actually work in practice? Like paint a
• 7:12
  picture of that workflow for me. Sure. So the
• 7:15
  human sets up a sandboxed environment, safe,
• 7:18
  isolated server running PHP. Right. And they
• 7:21
  give the AI model a goal. Find a way to reliably
• 7:23
  execute code using this memory glitch. Okay.
• 7:26
  So the AI writes a Python script to attack the
• 7:29
  server. The server crashes. Naturally. Right.
• 7:33
  But instead of a human spending three days analyzing
• 7:35
  why it crashed, the AI instantly ingests the
• 7:38
  crash dump, reads the memory offsets, realizes
• 7:41
  it missed the target by a few bytes, rewrites
• 7:44
  its own exploit script, and fires again. Wow.
• 7:47
  And it does this thousands of times. It tests,
• 7:50
  debugs, and iterates working exploits across
• 7:52
  different memory layouts in mere hours. Hours.
• 7:57
  Instead of months of painstaking manual labor.
• 8:00
  It's essentially automating the scientific method
• 8:03
  at light speed. Precisely. And that completely
• 8:05
  removes the specialist effort that used to bottleneck
• 8:08
  this kind of attack. It takes a theoretical flaw
• 8:11
  that we basically ignored for a decade and turns
• 8:14
  it into a highly practical, mass -producible
• 8:17
  weapon. Which brings us back to that October
• 8:19
  17th anomaly I mentioned at the top of the show.
• 8:22
  Because if AI can do this in hours, it begs the
• 8:24
  obvious question of who got to the finish line
• 8:27
  first with this specific bug. Right. The good
• 8:30
  guys or the bad guys. Because finding the bug
• 8:32
  first is now literally the only thing that matters.
• 8:36
  Let's look at this timeline because the margin
• 8:38
  for error has basically vanished here. It really
• 8:41
  has. So researchers... first discovered these
• 8:44
  bugs using their AI setup in August of 2026.
• 8:47
  And they did the responsible thing. They quietly
• 8:49
  notified the maintainers. And a coordinated patch
• 8:52
  and public disclosure was scheduled for October
• 8:54
  22nd. Right, giving everyone time to prepare.
• 8:57
  Exactly. The plan was to release the fix and
• 8:59
  the announcement simultaneously so people could
• 9:01
  patch immediately. But they had to rush the release
• 9:04
  a day early to October 21st because the CVE identifiers,
• 9:08
  the tracking numbers for the bugs, leaked on
• 9:10
  social media. Yeah, and the leak alone is stressful
• 9:13
  enough, but that isn't even the worst part of
• 9:15
  the timeline. No, the terrifying part is what
• 9:18
  Threat Intelligence Network saw four days prior.
• 9:21
  They operate these things called honeypots, right?
• 9:23
  Yes. Fake servers set up across the internet
• 9:25
  designed to look vulnerable, purely to monitor
• 9:28
  what hackers are trying to do. And on October
• 9:30
  17th, those honeypots started logging active
• 9:33
  exploitation attempts perfectly targeting this
• 9:36
  exact PHP flaw. It's wild. This means attackers
• 9:39
  were already moving. Either they independently
• 9:42
  found the exact same 10 -year -old flaw using
• 9:44
  their own AI infrastructure, or they intercepted
• 9:47
  the highly classified disclosure intel and built
• 9:49
  an exploit overnight. It means AI allows malicious
• 9:53
  actors to weaponize intelligence so fast that
• 9:55
  traditional patching schedules aren't entirely
• 9:57
  obsolete. Yeah, and this really forces us to
• 10:00
  confront a concept in cybersecurity known as
• 10:02
  the defender's window. Okay, what is that? Historically,
• 10:05
  when a vulnerability was found, defenders enjoyed
• 10:07
  a great period. The time between the initial
• 10:09
  discovery of a flaw and the widespread mass exploitation
• 10:13
  of that flaw usually took weeks, sometimes months.
• 10:16
  That gave software maintainers time to write
• 10:19
  a patch, and it gave IT teams time to test it
• 10:21
  and deploy it across their networks. But you're
• 10:24
  saying that window just doesn't exist anymore.
• 10:26
  It is completely collapsing. As we see with this
• 10:29
  October 17th activity, keeping defenders ahead
• 10:32
  is now purely a race over disclosure management
• 10:34
  and deployment speed. Yeah. You have to assume
• 10:36
  that... The absolute second a flaw is known to
• 10:39
  anyone, whether it's leaked on social media,
• 10:41
  whispered in a dark web forum, or discovered
• 10:44
  by rogue AI, the clock to widespread exploitation
• 10:47
  isn't ticking in weeks or days anymore. It's
• 10:49
  ticking in hours, minutes even. So with attackers
• 10:52
  literally knocking at the door days before the
• 10:55
  patch was even public, how did the tech industry
• 10:57
  mobilize? Because again, we're talking about
• 10:59
  patching 70 % of the web. Yeah. If you're listening
• 11:02
  to this and thinking, well, I just run a small
• 11:04
  WordPress blog for my dental practice. Nobody
• 11:07
  is targeting me. That's the old way of thinking,
• 11:09
  right? Completely. With AI automated exploits,
• 11:13
  attackers are not handpicking targets. Right.
• 11:15
  They are not looking at your dental practice.
• 11:17
  They are using automated tools to query the entire
• 11:20
  internet for any IP address, returning a header
• 11:23
  that says it runs a vulnerable version of PHP,
• 11:25
  and you are just caught in the dragnet. So how
• 11:28
  do we protect everyone caught in that drag now?
• 11:30
  Well, it required a massive cross -industry coalition
• 11:33
  working around the clock. You had the core PHP
• 11:36
  maintainers, the major AI labs, massive cloud
• 11:39
  providers, and top -tier security firms, all
• 11:41
  coordinating in private channels. The PHP team
• 11:44
  pushed out official compiled patches for the
• 11:47
  active versions, 8 .2, 8 .3, 8 .4, and 8 .5.
• 11:51
  Cloud providers immediately updated their managed
• 11:54
  serverless platforms where they had direct control
• 11:57
  over the infrastructure. But hold on. What about
• 11:59
  the older versions? What about the end -of -life
• 12:01
  versions from 7 .4 up to 8 .1? Because a massive
• 12:05
  portion of the web runs on legacy code. Yeah,
• 12:07
  and this is where it gets brutal. Those end -of
• 12:09
  -life versions did not receive official compiled
• 12:12
  fixes. Wait, really? Yeah. The PHP security team
• 12:15
  only provided what we call minimal source backports.
• 12:19
  So what does that actually mean for the average
• 12:20
  business owner? It means that instead of clicking
• 12:23
  a button to download and install a neat prepackaged
• 12:26
  update, you are just given the raw, corrected
• 12:29
  source code. Oh, no. Yeah. You have to manually
• 12:32
  compile the entire PHP language from scratch
• 12:34
  for your specific server environment. And the
• 12:37
  vast majority of small businesses do not have
• 12:39
  the technical engineering chops to compile a
• 12:42
  programming language from source code. Which...
• 12:45
  entirely explains the drastic response from the
• 12:47
  government. I mean, the U .S. Cyber Defense Agency,
• 12:49
  CISA, literally published guidance telling organizations
• 12:53
  to take internet -facing PHP 8 .1 systems completely
• 12:56
  offline if they cannot be patched. They didn't
• 12:59
  say, hey, put a firewall up in front of it. They
• 13:02
  said, pull the plug. Why wouldn't a standard
• 13:05
  firewall work here? Well, in the past, if you
• 13:08
  ran unsupported software, you could often survive
• 13:10
  by using defensive stopcaps. You could put a
• 13:13
  web application firewall or WAF in front of your
• 13:15
  server. Right. A WAF looks at incoming traffic,
• 13:18
  matches it against the list of known bad signatures,
• 13:20
  and blocks the malicious stuff. Cloud providers
• 13:23
  did try to push out WAF rules during this crisis.
• 13:25
  But it wasn't enough. No, because as the cloud
• 13:28
  providers themselves admitted, those rules are
• 13:30
  just bandages on a bullet wound. AI -driven exploits
• 13:34
  are polymorphic. Meaning? They change their shape.
• 13:37
  Exactly. The AI generating the attack can constantly
• 13:40
  morph the payload. Shifting the syntax just enough
• 13:43
  to bypass the static, rigid rules of a traditional
• 13:45
  firewall, while still triggering the underlying
• 13:47
  memory corruption in PHP. That is terrifying.
• 13:50
  The structural reality we are facing is that
• 13:52
  if you rely on unsupported, unpatchable software
• 13:54
  in the AI era, you are functionally defenseless.
• 13:57
  If you cannot fix the underlying flaw, an AI
• 14:00
  -driven attack will eventually find a way around
• 14:02
  your perimeter defenses. Full stop. just staggering.
• 14:08
  I was reading about a $1 billion initiative called
• 14:11
  Patch the Planet that launched right alongside
• 14:13
  this disclosure. Yes, a massive effort. It's
• 14:16
  essentially subsidizing AI access for frontline
• 14:19
  network defenders. They released highly specific
• 14:22
  AI generated query tools for enterprise security
• 14:24
  teams. Which is so crucial right now. Right.
• 14:27
  Like, for example, a defender can use tools like
• 14:30
  Hexa AI to instantly query their entire corporate
• 14:33
  network for any digital asset that was seen in
• 14:35
  the last 14 days running a vulnerable version
• 14:38
  of PHP. And the AI doesn't just find it, it automatically
• 14:41
  creates the critical remediation tickets, assigns
• 14:45
  them to the right IT staff, and provides the
• 14:47
  exact patch commands. Which is a brilliant, necessary
• 14:49
  evolution. Right. We have to arm the defenders
• 14:51
  with the exact same capabilities the attackers
• 14:53
  are using. Exactly. If the offense is fully automated,
• 14:56
  highly intelligent, and operating at machine
• 14:59
  speed, Well, your defense must be automated and
• 15:02
  intelligent just to keep pace. You cannot fight
• 15:05
  an AI with a spreadsheet and a human IT ticketing
• 15:08
  system. But even with Patch the Planet, it feels
• 15:10
  like we are just running faster on a treadmill.
• 15:13
  You know, we're sprinting to patch a 10 -year
• 15:14
  -old bug. This incident doesn't feel like a one
• 15:17
  -off emergency. It feels like a very grim preview
• 15:20
  of the new normal. It really does. If the economics
• 15:23
  of hacking have fundamentally changed this much,
• 15:25
  how does the actual engineering of software need
• 15:28
  to adapt? We can't keep doing this every time
• 15:30
  an AI finds a new messy kitchen counter. No,
• 15:33
  we can't. And you've hit on the core structural
• 15:34
  force shaping the future of the industry right
• 15:37
  now. We cannot survive by playing endless whack
• 15:40
  -a -mole. The focus of software engineering is
• 15:43
  undergoing a massive shift away from reactive
• 15:45
  patching and toward building mathematically secure
• 15:48
  -by -default foundations. So what does that actually
• 15:51
  look like in practice? How do you build a secure
• 15:54
  by default foundation? It takes a few different
• 15:57
  forms happening simultaneously. First, it involves
• 16:00
  integrating AI coding models directly into the
• 16:03
  developer's environment. So when an engineer
• 16:06
  types a line of code that might introduce a memory
• 16:08
  flaw, the AI acts as a real -time safeguard,
• 16:11
  refusing to let the bad code commit and suggesting
• 16:14
  a safer default structure. Oh, that's smart.
• 16:17
  Like spellcheck, but for vulnerabilities. Exactly.
• 16:20
  And second, we are seeing a massive industry
• 16:22
  -wide push to migrate critical infrastructure
• 16:25
  away from older languages like C and C++, which
• 16:28
  are what PHP is written in underneath, and moving
• 16:31
  toward memory -safe languages like Rust. Right.
• 16:35
  I've heard a lot about Rust lately. Yeah, these
• 16:38
  modern languages are designed in a way that makes
• 16:40
  entire classes of errors, like out -of -memory
• 16:43
  or use -after -free bugs, virtually impossible
• 16:46
  to write in the first place. The compiler simply
• 16:48
  won't allow it. But the most fascinating part
• 16:52
  of this structural shift has to be the rise of
• 16:54
  formal verification. I saw this mentioned heavily
• 16:57
  in the aftermath of the PHP crisis. Can you unpack
• 17:00
  what formal verification actually means? Sure.
• 17:04
  Formal verification is essentially the holy grail
• 17:06
  of software engineering. Think about how we traditionally
• 17:09
  test software. Okay. We write a program and then
• 17:12
  we run unit tests. We throw a bunch of different
• 17:15
  inputs at the software to see if it breaks. It
• 17:18
  is trial and error. Right. Formal verification
• 17:20
  is different. It is turning software from a craft
• 17:23
  into a mathematical theorem. It means you use
• 17:27
  advanced mathematics to conclusively prove that
• 17:30
  a critical software component satisfies strict
• 17:32
  security properties under every possible condition.
• 17:36
  You aren't just testing it. You are proving it
• 17:38
  cannot fail in specific ways. I love this concept.
• 17:42
  It is exactly like structural engineering for
• 17:46
  a suspension bridge. Yes. When we build a massive
• 17:48
  bridge, we don't just pour the concrete, wait
• 17:51
  for a crack to appear under the weight of rush
• 17:54
  hour traffic, and then run out there with some
• 17:56
  duct tape to patch it. We use math, physics,
• 17:59
  and load -bearing calculations to absolutely
• 18:02
  prove the bridge can hold the weight before we
• 18:04
  even buy the steel. We need to do the exact same
• 18:08
  thing for our software infrastructure. That is
• 18:10
  a perfect analogy. And the reason we haven't
• 18:12
  done that for most software historically is that
• 18:14
  formal verification is unbelievably dense. I
• 18:17
  can imagine. The mathematics required to prove
• 18:19
  a complex system are too slow, too tedious, and
• 18:22
  too expensive for humans to do at a large scale.
• 18:25
  It was reserved for things like spacecraft or
• 18:28
  nuclear reactor controls. Ah, okay. But frontier
• 18:31
  AI models are perfectly suited for this. They
• 18:34
  can handle the mathematical density. They can
• 18:37
  generate the proofs at scale, applying that structural
• 18:40
  engineering rigor to the everyday code that runs
• 18:42
  the internet. It really puts this whole crisis
• 18:44
  and the patch the planet initiative into perspective.
• 18:47
  We aren't just trying to patch PHP. We are being
• 18:50
  forced to fundamentally patch the way we build
• 18:52
  the digital world because the old way is just
• 18:55
  indefensible in the age of AI. Absolutely. Which
• 18:58
  leaves me with a thought for you to ponder today.
• 19:00
  We just spent all this time discussing how AI
• 19:03
  is incredibly adept at finding hidden flaws in
• 19:06
  messy human written code. But as AI begins to
• 19:09
  write more and more of our software entirely
• 19:11
  from scratch. Will it actually build those mathematically
• 19:15
  perfect, formally verified systems we just talked
• 19:17
  about? Or, operating without human oversight,
• 19:21
  will it weave in entirely new classes of vulnerabilities?
• 19:25
  Flaws so alien, so structurally complex that
• 19:28
  only other AIs can even comprehend them, leaving
• 19:31
  human defenders entirely locked out of the kitchen.
• 19:33
  Thanks for listening to the AI Newspaper. Visit
• 19:36
  AINewspaper .org to catch up on the latest updates
• 19:38
  and sign up for free email alerts.