❌

Reading view

The 15-Minute Patch, Reverse-Engineered: What Had to Be True?

In Part 2 of the Patch Sound Barrier series, I shared a thought experiment from a talk in May 2026: imagine any vulnerability in your environment can be patched within 15 minutes of release. Now reverse-engineer that reality. What had to be true?

Gemini imagining this blog

Usman and I revisited this exercise in our “basics at AI scale” post. Readers asked: “How do I actually run this exercise with my team?”

So here’s how. Two ground rules first:

  • This is not a 15-minute patch SLA. If you take this post and write “all vulnerabilities remediated within 15 minutes” into a policy, I will find you… I utterly hated “30 days flat” policies as an analyst and “15 minutes flat” is the same mistake with more zeros. The number is a probe, not a target.
  • You will never get there across your whole environment. Legacy systems guarantee it. The point is the gap between the fantasy and your reality, because that gap is the most honest map of your program you will ever get. The Patch Sound Barrier is real; this exercise tells you where yours is and what it is made of.

Why 15 minutes, and not “fast”

“Fast” allows cheating. Some consider 90 days “fast” because they started at an annual cadence. “Patch faster” is generic advice everyone agrees with, but rarely acts on (or: barely acts on). An aggressive, specific number forces you to identify which pipeline steps physically cannot fit.

The Cloudflare quote from Part 2 summarizes this: demanding faster patching without redesigning the process leads to skipped steps. If regression testing takes a day, a two-hour SLA just skips testing. This exercise targets pipeline design, not raw speed. A 15-minute window leaves room only for automated steps. Everything else itemizes your sound barrier.

The 15 minutes, minute by minute

Assume a patch drops at T+0. At each stage, ask:

  1. What must be true for this stage to fit the timeframe?
  2. What is current reality, and what is the gap?

Details:

Process machinery 1

and

Process machinery 2

A 15-minute timeline leaves zero room for manual deliberation. In this model, humans define policies, build automation, and handle (rare!) exceptions. They do not manually approve or execute patches.

The five things the exercise refuses to let you skip

  1. Inventory as a live graph. If identifying affected systems takes hours, downstream automation cannot compensate. First move: measure how long it takes to locate a specific library or version today. That duration is your baseline gap. Most organizations are shocked. Log4j much?
  2. Rapid automated testing. Manual testing blocks rapid remediation. First move: time how long it takes to get from “patch available” to “confident it won’t break prod” on core systems, then work out what it would take to make that 5 minutes.
  3. Replaceable infrastructure. Rapid patching relies on redeploying updated templates rather than patching running instances. First move: determine your “replaceability ratio”: the percentage of systems that can be automatically rebuilt from source fast enough to fit the deploy window.
  4. Pipeline-level governance. Per-change approval gates prevent rapid execution. Approve the policy and the pipeline, not each patch. First move: transition low-risk change classes to pre-approved automated pipelines.
  5. Rehearsed rollback. Teams patch slowly because they fear breaking prod, and they fear it because they’ve never practiced un-breaking it. First move: execute and time an intentional rollback on a non-critical production system.

The cheat code: change the verb from “patched” to “non-exploitable”

For legacy systems, OT networks, or appliances you can’t modify, 15-minute patching is fiction. So change the verb: make the vulnerability non-exploitable or harmless within 15 minutes. That’s the Part 1 move: assume you can’t patch, then decide what you’ll do instead.

(source)

The difference (reminder for most, new for some...):

  • Patching eliminates the flaw. It requires vendor fixes, testing, deployment, and mutable target systems, factors largely outside your immediate operational control.
  • Mitigation reduces exposure risk. It relies on controls you own (network segmentation, identity policies, access gateways … at times an ax) without modifying target code, so actions can be pre-engineered and pre-approved easier.

The 15-minute mitigation exercise tests four capabilities:

  1. Can you isolate network paths immediately via automated policy?
  2. Can you revoke or scope down credentials in minutes?
  3. Do you know the blast radius well enough to isolate a component without breaking the business?
  4. Can you push a protection rule via API in minutes? (See API or Die.)

Your patch clock partly belongs to the vendor (partially). Your mitigation clock is all yours. For legacy, that’s the only 15-minute clock that matters.

But a segmentation diagram is not segmentation, and a kill switch nobody has pulled is a hypothesis. As I argued in Survival of the Basics, a mitigation counts only if it is a tested, operational control.

How to actually run this with your team

Book 90 minutes, a whiteboard, and the right people: platform/infra, an app owner, whoever runs change management, and QA. Security alone will find the gaps, but won’t own any of them.

  1. Select three specific target systems: modern (containerized service), median (standard application server), and legacy (high-risk core system).
  2. Map the clock for each system: document stage durations and identify the gaps.
  3. Identify the primary bottleneck stage.
  4. Define a single corrective move for that bottleneck: one bottleneck, fixed end to end (same logic as Baby ASO).
  5. Apply the mitigation model to legacy targets: establish rapid containment controls where patching is impossible.
  6. Track stage durations quarterly: progress shows up as shorter stages on your critical systems.

No time for a workshop? Pick a widely used component (a core library or agent) and time how long your team takes to find every active instance with high confidence. That’s your T+0 to T+1 baseline.

So, will you get to 15 minutes?

Containerized microservices can get there (yes, really, but provided some moons are aligned just right). Standard application servers can perhaps go from weeks to hours. Legacy systems need rapid mitigation (segmentation, credential scoping, containment) rather than patching.

What do you think? Is this totally crazy or what?

Related posts and resources:


The 15-Minute Patch, Reverse-Engineered: What Had to Be True? was originally published in Anton on Security on Medium, where people are continuing the conversation by highlighting and responding to this story.

  •  

Veel datacenters in EU lijken water- en stroomgebruik onterecht geheim te houden

Veel datacenters, ook in Nederland, lijken hun water- en stroomgebruik onterecht geheim te houden. Daarnaast zou het voor EU-burgers lastig zijn om van overheidsinstanties inzage te krijgen in de milieu-impact van datacenters, terwijl die informatie openbaar zou moeten zijn. Er wordt een speciale procedure gestart.
  •  

UK rail cops' £320K face-scanning spree nets zero matches

British Transport Police (BTP) spent more than £320,000 putting half a million commuters through live facial recognition cameras, only for the system to identify precisely nobody it was looking for. Figures obtained by civil campaign group Liberty Investigates through Freedom of Information requests, and reported by The Guardian, show BTP's six-month trial scanned more than 500,000 faces at London railway stations and generated just one alert. That turned out to be a false positive, meaning the technology produced no correct matches and no arrests directly resulting from an LFR alert. The exercise wasn't exactly light on resources either. According to the figures, deployments swallowed almost 100 hours of police officers' time and cost more than £320,000. Privacy campaigners at Big Brother Watch told The Register the results would be funny if the implications weren't more serious. "The figures from the British Transport Police's live facial recognition pilot would be laughable, if they didn't have such troubling implications for our rights and freedoms," said Jasleen Chaggar, senior legal and policy officer at the campaign group. "Millions of Londoners use the city's stations every day and may have already found themselves caught in a digital police line-up, likely without even realizing." Then there's the small matter of what taxpayers got for their £320,000. "It's not fair to subject innocent people to intrusive identity checks during their commute, but it's even more insulting to waste almost 100 hours of officers' time and £320,000 of public money when it produces such meagre results," she said. "The pilot figures show that replacing officers with AI surveillance does not improve Londoners' safety and British Transport Police should drop their use of live facial recognition." But BTP isn't dropping it. In fact, the trial has been extended until November and expanded from Network Rail stations onto the London Underground. The system uses NEC's NeoFace M40 facial recognition tech, and cameras scan people passing through a designated area, comparing their faces against a police watchlist. When the software thinks it has spotted someone on that list, it generates an alert for an officer to review before deciding whether to stop the person. BTP says it cannot identify people who aren't on a watchlist and that it immediately deletes their biometric data. It also says deployments are intelligence-led and targeted at crime hotspots where officers believe "high harm offenders" are likely to pass through. That claim of a targeted approach isn't convincing everyone. Sarah Simms, senior policy officer at Privacy International, told The Register the results of the trial show just how many innocent passers-by can have their faces processed along the way. "We are deeply concerned by the results of the British Transport Police's live FRT trial. It reaffirms how invasive and disproportionate live facial recognition tech is and why it shouldn't be permitted. Thousands of people have their highly sensitive facial data processed in public spaces as they go about their daily lives, sometimes unknowingly. It also undermines claims of it being a targeted measure." Simms also pointed to the lack of legislation specifically governing the technology as BTP continues to expand its use. "What's further concerning is that they continue to extend these deployments when there is no specific legal framework in place to regulate facial recognition, which is essential to ensure there are restrictions and safeguards on its use to protect people's rights," she said. Those assurances haven't put the wider controversy around police facial recognition to bed. Earlier this year, UK police temporarily suspended deployments after independent testing raised concerns about racial bias at some operating thresholds. BTP's own experiment has produced a rather different problem so far: after scanning more than half a million faces, the only person its cameras picked out was the wrong one.®

  •  

Update: search-for-compression.py Version 0.0.8

I’ve noticed when a zlib compressed chunk of data is followed by other data, search-for-compression.py will not always be able to detect the compressed chunk. This is caused by the fact that the other data generates a decompression error, and the complete chunk is disregarded.

I’ve added a new option to try to solve this: -S

Option -S takes a value, a positive number. It’s the size of the decompression buffer. By default, its value is 0.

When you try -S 100 for example, search-for-compression.py will try to decompress up to 100 bytes. If that succeeds, then we assume that we found compressed data, and search-for-compression.py will try to decompress the remainder of the data until either a decompression error occurs, or there is no more data. But when an error occurs, search-for-compression.py will revert to the last decompression without error, and report that.

search-for-compression.py is still in my beta repository.

  •  

EU rolt bende op die miljoen oude smartphones als nieuw zou hebben verkocht

Europese opsporingsdiensten hebben een vermeende criminele bende opgerold die op grote schaal gebruikte smartphones als nieuw verkocht. De toestellen zouden uit oude onderdelen bestaan en vervolgens aan klanten in de EU zijn verkocht. Ook Nederland en België waren bij de actie betrokken.
  •  

Spectre bug is back, this time to haunt JIT engines

The Spectre microarchitecture vulnerability has returned yet again, this time to vex just-in-time (JIT) engines that generate machine code for browsers, runtimes, and kernels. The vulnerability is found in many CPUs that use speculative execution, the process of executing code before it is called to boost performance. Researchers found speculative execution opens the door to side channel attacks through which secrets can be exposed or inferred. When news of that risk became known, chipmakers and OS developers scrambled to fix these vulnerabilities, which were referred to as Spectre and Meltdown. And since then, researchers have found two or three dozen variations, such as 2025's VMScape, one of several so-called "Spectre v2" attacks that attempt to exploit indirect branch prediction, where program control is passed indirectly by pointing to an address where the next instruction can be found rather than specifying the instruction itself. The attacker trains the branch predictor to execute speculatively to a chosen address in order to leak data about the microarchitecture state. Researchers from Vrije Universiteit in the Netherlands and Scuola Superiore Sant’Anna in Italy have revived Spectre in a form called Branch Target Reuse (BTR), which they describe as the first practical in-place Spectre v2 attack that attacks just-in-time (JIT) compilers. An in-place attack is confined to the victim's branch while an out-of-place attack relies on speculation directed toward a target on a different branch. The researchers – Sander Wiebing, Yuhui Zhu, Alessandro Biondi, and Cristiano Giuffrida – found that this novel Spectre form can be conjured from code left in JIT engines including Linux cBPF, Oracle GraalVM, and Mozilla SpiderMonkey. "The key insight behind the attack is that, while modern CPUs restore architectural code coherence after self-modification, they do not necessarily invalidate stale indirect branch prediction entries (i.e., branch targets)," the authors explain. "In JIT engines, these stale targets can outlive the original code and later be reused when the code cache is repopulated, yielding a speculative execute-after-free primitive." The result is that an attacker can commandeer speculative control flow in a way that avoids some software defenses like FineIBT [PDF]. The authors showed they could exploit this flaw by designing two proof-of-concept exploits against an Intel-based Linux kernel that reveal the root password hash even with the constant binding defense provided by cBPF. The expected leakage rate is 5.7 KB/sec for Intel Raptor Cove chips and 5.4 KB/sec for Lion Cove. It's slow but enough for an unprivileged user to coax a sensitive password hash out of a vulnerable system. After the researchers disclosed their findings, Linux kernel developers and Oracle put mitigations in place. Two CVEs were assigned: CVE-2026-64507 and CVE-2026-64508. Mozilla, the researchers said, has opted to prioritize work on site isolation instead of addressing the issue directly. Strong mitigations like IBPB are said to be effective but add complexity and hinder performance. The Branch Target Reuse paper has been accepted for publication at the ACM Conference on Computer and Communications Security (CCS) 2026, which will be held November 15 through 19 in The Hague, Netherlands. ®

  •  

Citrix NetScaler CVE-2026-88772 Exploit Details Show Pre-Auth Path to Shellcode Execution

Cybersecurity researchers have disclosed technical details of a recently patched critical security flaw in Citrix NetScaler ADC and Gateway that has come under active exploitation in the wild. The vulnerability, tracked as CVE-2026-88772 (CVSS score: 9.5), has been described as a memory overflow bug in the Datagram Transport Layer Security (DTLS) protocol handling that's rooted in the NetScaler

  •  
❌