Six days after I published an article about what happens when digital trust fails, PHP shipped emergency security fixes. By then, certificate authorities and software release pipelines were in the news too.

On 15 October, I wrote that Bitcoin would be the smaller story in a serious cryptographic failure. I was more concerned about private records, software updates and the systems we rely on to decide whom to trust.

A week later, “Black October” was circulating as a name for a pile-up of security disclosures. The phrase had reached an interview with PHP maintainer Ondřej Surý. It describes a week’s mood better than a single technical event.

The timing is uncomfortable. It is also worth being precise about what happened. These incidents do not establish that AI has broken modern cryptography. They show how much damage is possible while the mathematics remains perfectly sound.

The calendar can mislead you

A disclosure date tells us when a problem became public. It doesn’t tell us when the flaw was introduced, when someone first found it or when an attacker started using it.

Wiz’s PHP2Shell timeline, for example, starts with discovery on 19 August and a report to PHP on 24 August. The patches and public disclosure arrived on 21 October. The weaknesses were there well before I wrote the previous article.

That matters because it changes the lesson. A busy week of announcements is not evidence that the internet suddenly acquired all these flaws. It may tell us that we are getting better at finding an existing stock of them. Sometimes that is encouraging. It is less comforting when the person finding them has no intention of reporting them.

Discovery, disclosure and publication are different dates.
  1. 19 AUG / DISCOVERYWiz finds the first PHP flawIts published timeline records AI-assisted research.
  2. 15 OCT / PREVIOUS ESSAYThe wider cost of broken trustMy article discusses records, signatures and software.
  3. 21 OCT / DISCLOSUREPHP patches become availableLiteLLM also reports a compromised release that day.

Selected milestones, not a count of attacks or a claim that the events share a cause. Sources: Wiz’s disclosure timeline and LiteLLM’s incident report, linked in the text.

Three failures that deserve a closer look

PHP: old code, newly practical attacks

The PHP Foundation’s 21 October release addressed the issues tracked as CVE-2026-109618 and CVE-2026-109619. These were failures in the runtime beneath applications. Fixing your own website’s code would not, by itself, repair the PHP engine running it.

Wiz reports that frontier models helped researchers find the flaws and develop working exploits. The demonstrated consequences included unauthenticated code execution and disclosure of process memory. That is the part worth paying attention to: AI helped turn complicated weaknesses into something demonstrably exploitable.

A flaw can survive for years because tracing it is difficult, because reproducing it is tedious, or because nobody has time to keep following a promising lead. More capable research tools can change which of those leads are worth pursuing. Age is a poor substitute for evidence of safety.

eMudhra: strong cryptography, disastrously weak keys

The certificate incident is the closest link to my previous article. Mozilla’s investigation found that eight eMudhra intermediate certificate-authority keys used P-384 private values below 256. The key-generation process had produced a tiny set of possibilities where an enormous one was intended.

No general breakthrough against elliptic-curve cryptography was needed. Mozilla independently recovered the keys and also reported that local agents recovered them on their first attempt. That is a result about these defective keys, not a demonstration that agents can recover properly generated P-384 keys.

An intermediate CA is part of the machinery used to establish trust in certificates. Its signing key is therefore much more consequential than a forgotten password on an unused account.

eMudhra says it revoked the eight intermediates on 18 October, that none had issued certificates, and that no data was breached. Mozilla’s incident record documents its rapid blocking response. The potential severity and the observed harm are different things; both belong in the account.

LiteLLM: the update was the delivery mechanism

LiteLLM disclosed that its release pipeline had been compromised on 21 October. Version 1.107.0 carried credential-stealing malware and tools for remote code execution. The malicious PyPI release was available from roughly 11:39 to 13:23 UTC, with affected container images available over a different interval.

The maintainers said the official GitHub source tag did not contain the malicious files: the distributed artifacts had been built from an attacker-controlled repository. Checking the familiar project name, or reading the legitimate source, would not have answered whether the downloaded package was the one you intended to trust.

The incident report called for affected environments to be treated as compromised and reachable credentials to be rotated. Removing a bad package does not invalidate a key somebody has already copied.

These three cases involve different failure modes. I would not attribute all of them to autonomous attackers. The evidence for AI’s role is explicit in the PHP research and Mozilla’s key-recovery test; that does not establish AI as the cause of every incident carrying the Black October label.

You don’t have to break the cipher to get the data

This is the thread connecting the week to the earlier essay. An application eventually needs to read its protected data. A release system eventually needs authority to publish. A certificate authority needs a private key that was generated correctly.

If an attacker reaches one of those points, a perfectly good encryption algorithm may offer no answer. The attacker can steal an existing credential, read data after decryption or substitute software before it reaches the customer.

We should still migrate vulnerable public-key cryptography towards post-quantum alternatives. But a post-quantum signature cannot rescue a release process that signs and distributes the wrong artifact. Nor can it make a predictable private key unpredictable.

That is why I keep returning to the systems around the mathematics. The practical cost of failure falls on whoever trusted the result: a developer installing a dependency, a company running a website, a person whose records sit behind that website. A cryptocurrency price chart captures very little of it.

Now put an agent on the other side

Automated scanning is old. The change I worry about is what happens after the first attempt fails.

A fixed script follows the path someone wrote for it. A capable agent can inspect a response, reconsider an assumption and decide whether another approach is worth trying. It can sustain more of the investigation between “something looks wrong” and “this actually works”. That ability is still uneven. It is also precisely the kind of work models are being trained to improve.

The NCSC’s assessment through 2027 anticipated more effective vulnerability research and exploitation, while judging fully automated, end-to-end advanced attacks unlikely over that horizon. We should keep both parts in view. An attacker does not need perfect autonomy to become more productive.

My expectation is that pressure will increase as agents become cheaper and more reliable. More targets will be worth investigating. More unsuccessful attempts will get a follow-up. Forgotten services may receive the kind of patient attention that used to be reserved for more valuable targets.

Picture a small business with an old deployment it rarely uses. Today, obscurity might occasionally buy it time. In a web continually searched by agents, that is a fragile advantage. The service remains reachable whether its owner remembers it or not.

There are limits: models make mistakes, attempts cost money, access controls work, and defenders can detect and block activity. I would still plan for more persistent pressure rather than assume those limits will keep the workload comfortable.

Finding more bugs is useful. Who fixes them?

The defensive opportunity is real. PHP2Shell was found by researchers working towards disclosure and patches. Mozilla’s response to the certificate report also shows that a serious problem can trigger fast, coordinated action.

The PHP Foundation reports 15 published CVEs since 1 July alongside more than 100 reports that were invalid, duplicates or not reproducible. Those are different units, so they do not give us a false-positive rate. They do show why producing more reports is not the same as producing more security.

But discovery is only the first part of the job. Someone has to validate a report, prepare a fix, test it, identify affected installations and get the change deployed. A dependency used by thousands of organisations still has to be updated in thousands of organisations.

Agents can help with that work too. They can assist with inventory, testing and bounded updates. They cannot make ownership, downtime decisions and supplier dependencies disappear. A team may produce a patch quickly while its customers take weeks to apply it.

That gap is where I expect the next few years to hurt. An attacker can benefit from one forgotten installation. A defender needs to find the forgotten installations before someone else does.

I would measure how long it takes to identify exposure, revoke a compromised credential and deploy a verified fix. I would also want to know which services can be taken offline safely, and who has authority to make that decision. Those answers tell me more than a count of AI tools in the security budget.

October will end. The pressure may not.

Black October does not prove that every system is broken, or that autonomous agents caused every headline. It does make the cost of slow security operations harder to ignore.

I expect this to get worse as more agents search the web, test what they find and return to unfinished work. Better defensive tools could eventually leave us with safer software. Getting there will mean finding and repairing weaknesses faster than people can turn them into damage, across systems that were never built for that pace.

Last week, I worried about which signatures we might stop being able to trust. This week offered a more immediate reminder: an attacker may never need to defeat the signature if they can compromise the system around it.

The agents will keep looking. A service left online will not get the weekend off.