Why patching matters: lessons from real breaches
Patching matters because most breaches don't use a secret, brand-new flaw — they use a known one that already had a fix. The gap between a patch being published and a server actually running it is the window attackers live in. Close that window and you remove the most common way in.
Good patch management is four habits: patch in proportion to risk, verify the fix against what's actually running (per CVE, not the version string), get a person's approval for risky changes, and keep a record you can show.
What an unpatched vulnerability actually is
Software ships with bugs. Some of those bugs are security vulnerabilities — ways to make a program do something it shouldn't, like run an attacker's code or leak memory. When one is found, it gets a public identifier, a CVE (Common Vulnerabilities and Exposures) number, and usually a severity score. The maintainers release a fixed version.
From that moment, two clocks start. One is yours: the time it takes you to notice the fix exists and apply it everywhere it's needed. The other is the attacker's: the time it takes them to turn the public details into a working exploit and start scanning the internet for machines that haven't patched. For high-severity, internet-facing flaws, the attacker's clock is often measured in days. An unpatched vulnerability is simply a server that lost that race — the fix exists, but this machine is still running the old, exploitable code.
What's happened when servers weren't patched
These are among the most-studied security incidents of the last decade. In each, a fix existed before the damage — the problem was the gap between the patch and the servers.
Equifax, 2017 — CVE-2017-5638 (Apache Struts)
A remote-code-execution flaw in the Apache Struts web framework was disclosed, with a fix, in March 2017. Equifax ran an internet-facing application on a vulnerable version and didn't apply the patch; attackers used the flaw from around May 2017, and the intrusion ran for weeks before it was found. The U.S. Government Accountability Office reports it exposed personal data for at least 145.5 million people; Equifax's own later count was about 147 million.
The lesson: the patch had been available for months. Internet-facing software is where the window to patch is shortest, because that's what gets scanned first.
WannaCry, 2017 — MS17-010 (SMBv1)
WannaCry was ransomware that spread by exploiting a flaw in the SMBv1 file-sharing protocol. Microsoft had released the fix, MS17-010, in March 2017; WannaCry hit in May 2017 — roughly two months later — and, by widely reported estimates, spread to around 200,000 computers across about 150 countries, disrupting hospitals, telecoms and manufacturers. CISA's own guidance for it is, first, to apply MS17-010. The machines it hit were the ones that hadn't.
The lesson: the fix was out well before the attack. “We'll patch it next maintenance window” is a bet that nobody weaponises the flaw in the meantime.
Log4Shell, 2021 — CVE-2021-44228 (Log4j)
Log4Shell was a remote-code-execution flaw in Log4j, a logging library embedded in a huge range of Java applications. Disclosed in December 2021 and scored at the maximum severity (CVSS 10.0), it drew internet-wide exploitation within hours. The hardest part for defenders wasn't applying the fix — it was finding every place Log4j was running, often buried deep inside other software.
The lesson: you can only patch what you know you're running. An accurate inventory of what's installed is half the job.
Heartbleed, 2014 — CVE-2014-0160 (OpenSSL)
Heartbleed was a flaw in OpenSSL — the library behind much of the web's encryption — that let an attacker read chunks of a server's memory, potentially including private keys and passwords. Because the leak could expose secrets, patching the library wasn't enough on its own: responsible operators also had to assume compromise and rotate keys and certificates.
The lesson: some fixes need follow-up. Knowing a patch is applied — and what else it implies — matters as much as applying it.
Shellshock, 2014 — CVE-2014-6271 (Bash)
Shellshock was a flaw in Bash, the shell present on almost every Linux and Unix system, that allowed command execution through specially crafted environment variables. Because Bash is so ubiquitous, the exposure was enormous, and automated attacks began very quickly after disclosure.
The lesson: the most dangerous flaws are often in the most common, least-glamorous components — the ones you forget are even there.
How fast do attackers actually move?
Once a vulnerability is public, the same details that help defenders patch also help attackers build an exploit. For serious, internet-facing flaws, that gap is short: working proof-of-concept code often appears within days of disclosure, and automated scanning for vulnerable servers follows close behind. You don't have to be a chosen target — much of this is indiscriminate. Attackers scan broad ranges of the internet, fingerprint what software is answering, and fire known exploits at anything that matches.
Old vulnerabilities don't retire, either. Years after a fix ships, unpatched servers are still found and compromised through the same flaw — because somewhere a machine was never updated: forgotten, left running, or nobody was sure it was safe to touch. CISA, the U.S. cybersecurity agency, maintains a public catalogue of vulnerabilities known to be exploited in the wild, and many of its entries are years old. A patch that existed in 2017 is no help to a server still running the 2016 code today.
The practical takeaway: patching is a race you're entered in whether you want to be or not. The question isn't whether a flaw in your stack will be scanned for — it will — but whether the fix is already running when it is.
Why patching is harder than it looks
If patching were just “run the updater,” none of the above would have happened. In practice, a few things make it genuinely hard to know whether a server is safe.
The window is short, and work gets in the way. Between disclosure and exploitation you may have days, but patching touches running systems, risks downtime, and competes with everything else on the queue. Changes get deferred, and deferred changes get forgotten.
Version-string checks miss backported fixes. Distributions often fix a vulnerability by patching the version they already ship, without changing the version number. A check that only reads version strings then reports a package that's actually fixed as still open — noise that teaches people to ignore the report.
Installed isn't the same as running. You can upgrade a package on disk while the old, vulnerable code keeps running — most often the kernel, which keeps running the old version until a reboot, and shared libraries, which services keep using until they restart. A server can read as “updated” and still be exploitable. Our guide on checking your running kernel shows the difference.
And then there's no record. Even when a change is made correctly, few teams can later show who approved what and when it was verified. Without that, “is this patched?” becomes a matter of memory.
What good patching looks like
Good patch management isn't exotic. It's four habits done consistently:
- Timely — fixes applied in proportion to risk, with critical internet-facing flaws measured in hours or days, not weeks.
- Verified against what's running — proof, per CVE, that the fix is live, measured against the distribution's own data and the running kernel, not just the installed version string.
- Approved for risky changes — a person signs off before a patch, restart or reboot that could cause downtime, rather than fire-and-forget.
- Recorded — a durable record of what changed, who approved it, and how it was verified, that you can hand an auditor.
This isn't only a security-team concern. Common security and compliance frameworks — SOC 2, ISO 27001, PCI DSS and the CIS Controls — all expect timely patching and evidence that it happened. “We patch regularly” isn't an answer an auditor accepts; a record of what was fixed, when, and how it was checked is. The habits that keep you safe are the same ones that let you prove you're safe.
How HostCrust does this. This is the loop HostCrust is built around: Patch Proof checks each server per CVE against your distribution's own security data and the kernel that's actually running, backports counted; by default, patches, restarts and reboots wait for a person's approval; and every change lands in a receipt you can verify offline. See the product or how it's built.
A short patching checklist
- Know what you run. Keep an accurate inventory of installed packages, versions and the running kernel on every server.
- Check against your distro's data, per CVE. Not a version-string guess — use the distribution's own security data, and count backports. Our security-updates guide shows how on Ubuntu and Debian.
- Apply promptly, by risk. Prioritise critical and internet-facing flaws; test where you can; don't let fixes sit.
- Verify it took effect. Confirm the fix is running — reboot for a kernel, restart services using an updated library.
- Keep a record. Who approved it, what changed, and how it was verified — so “is it patched?” has an answer you can show.
How we checked this: This is a background guide, not a command walkthrough. Every breach, date, CVE and severity in it was checked against the primary sources listed below — the NVD CVE records, the U.S. GAO report on the Equifax breach, CISA's WannaCry alert and Known Exploited Vulnerabilities catalogue, and the Apache Log4j advisory — on 16 Nov 2026. Impact figures are described as reported, and no claim is made beyond what those sources support. Anything we didn't run ourselves comes from the official documentation listed under Sources.
Check which CVEs are really open on your server
HostCrust Patch Proof compares every installed package with your distribution's own security data. It counts fixes your distro backported and checks the kernel that is actually running, not just the one on disk. Read-only, no root, free.
FAQ
How quickly should I patch a critical CVE?
For a critical, internet-facing vulnerability, as fast as you safely can — hours to a few days, not weeks. Attackers often build working exploits within days of a public CVE. Prioritise by exposure and severity, test where you can, apply, and then verify the fix is actually live.
Do automatic updates keep me safe?
They help, but not on their own. Automatic updates can skip held packages and third-party software, and a kernel update doesn't take effect until a reboot — so a server can look updated and still be running the vulnerable code. They also leave no clear record of what changed. Confirm auto-updates are running and that fixes are actually in effect. Our unattended-upgrades guide shows how.
Why is a server still vulnerable after apt upgrade?
Because a package can be upgraded on disk while the old, vulnerable version keeps running — most often the kernel, until you reboot. Services that loaded an old shared library keep using it until they restart. Check what's actually running, not just what's installed.
What is a backported fix?
A security fix your distribution applies to the version it already ships, without raising the version number. It's why a check that only compares version strings can report a package that's actually fixed as still vulnerable.
How do I prove a server is patched?
Check each installed package and the running kernel against your distribution's own security data, per CVE — not just the version number — and keep a record of what was changed and verified. That's the difference between “packages updated” and proof. You can check one server free with Patch Proof.
Sources
- NVD: CVE-2017-5638 (Apache Struts remote code execution)
- U.S. GAO-18-559: Actions Taken by Equifax and Federal Agencies in Response to the 2017 Breach
- CISA alert TA17-132A: Indicators Associated With WannaCry Ransomware (apply MS17-010)
- NVD: CVE-2021-44228 (Apache Log4j “Log4Shell”, CVSS 10.0)
- Apache Log4j Security Vulnerabilities
- NVD: CVE-2014-0160 (OpenSSL “Heartbleed”)
- NVD: CVE-2014-6271 (GNU Bash “Shellshock”)
- CISA Known Exploited Vulnerabilities (KEV) Catalog
- CIS Critical Security Controls (continuous vulnerability management)