A vulnerability is a weakness. An exploit is the thing that uses it. That one sentence is the whole difference between vulnerability vs exploit, and mixing the two up is how a calm Tuesday turns into a 2 a.m. change window nobody planned for.
In October 2026, PHP shipped emergency fixes for two flaws the community nicknamed PHP2Shell: CVE-2026-109618 and CVE-2026-109619, each rated 9.2 under CVSS v4.0. Within hours, timelines filled with “PHP is being exploited everywhere.” Some of that was true. Much of it was a vulnerability being described as if it were a breach.
If you run servers, containers, or web stacks, this matters to you more than you might think. The words decide how fast you get asked to move. Let’s make this simple.
Vulnerability vs exploit: the four words people blur together
Picture a building you manage. A first-floor window has a latch that doesn’t close properly.
| Term | Plain definition | In the building | In PHP2Shell |
|---|---|---|---|
| Vulnerability | A weakness in software, hardware, a configuration, or a process that could be abused | The broken latch | Memory-handling bugs in how PHP processes HTTP requests |
| Exploit | Code or a technique that actually abuses the weakness to make the system do something it shouldn’t | The trick that pops the latch from outside | Proof-of-concept code that turns a crafted POST request into remote code execution |
| Threat | Someone or something with the intent and ability to use the exploit | The person walking the block, testing windows | Botnets and scanners spraying exploit attempts at public PHP servers |
| Risk | The likelihood that a threat succeeds, multiplied by what it would cost you | Ground floor, facing the street, payroll files in the room | An internet-facing PHP app on mod_php, unpatched, holding customer data |
Three things follow from that table, and they are the ones people get wrong.
A vulnerability can exist for years with no exploit. Of the roughly 398,000 CVE records in the CVE program’s list, only 1,766, under 0.5%, appear in CISA’s Known Exploited Vulnerabilities catalog of flaws confirmed exploited in real attacks (as of October 30, 2026). The latch is broken, but most of the time nobody has figured out how to open it from the street.
An exploit existing is not the same as you being compromised. In the first days of PHP2Shell, security researchers reported scanning and exploit attempts in the millions, yet no confirmed successful remote code execution in real-world attacks as of October 23. Many public proofs of concept were nonfunctional or depended on an uncommon setting. Attempts are not breaches.
Risk is the only word that is about you. The same vulnerability can be urgent on one server and nearly irrelevant on another. That depends on exposure, configuration, and what the box holds. That is an IT question before it is a security question.
The supporting cast: CVE, CVSS, proof of concept, zero-day
Once you separate vulnerability from exploit, the rest of the vocabulary snaps into place.
- CVE (Common Vulnerabilities and Exposures): a public ID for one specific vulnerability, like CVE-2026-109618. It is a name tag, not a severity rating and not proof of attack.
- CVSS (Common Vulnerability Scoring System): a 0–10 score for how bad a vulnerability could be in a generic environment. PHP2Shell scored 9.2. A high score says “look at this first,” not “you are breached.” Our threat modeling guide explains why a 9.8 on a box nobody can reach can wait behind a 7.5 on your front door.
- Proof of concept (PoC): exploit code written to demonstrate the flaw is real. PoCs are often fragile, but they shorten the distance between “disclosed” and “weaponized.”
- Exploited in the wild: someone used it against real systems, not a lab. This is the signal that changes priorities overnight. In the US, CISA tracks it in the Known Exploited Vulnerabilities (KEV) catalog.
- Zero-day: NIST defines a zero-day attack as one that exploits a previously unknown hardware, firmware, or software vulnerability. In practice: defenders have had zero days to patch, because no patch exists yet.
PHP2Shell shows how blurry that last line can get. Datadog reported that AWS saw exploitation attempts four days before public disclosure. For those four days, anyone targeted was facing a zero-day. On October 21, once the fix shipped, it became an “n-day”: known, patchable, and now a race.
The patch lifecycle: two clocks start at disclosure
Every vulnerability runs on two clocks. The attacker’s clock measures how long until a working exploit hits your systems. Yours measures how long until the fix is live. Patch management is the discipline of making your clock faster.
Here is how the lifecycle runs, stage by stage:
- Discovery. A researcher, vendor, or attacker finds the flaw. If an attacker finds it first, exploitation can start before anyone else knows. That is the zero-day window.
- Disclosure and CVE. The vendor publishes an advisory and a CVE ID. The attacker’s clock speeds up here, because everyone, including attackers, now knows where to look.
- Patch release. The vendor ships fixed versions. For PHP2Shell that meant 8.2.35, 8.3.36, 8.4.27, and 8.5.12, per Datadog Security Labs.
- Triage. Security decides how urgent it is for your environment: CVSS, exposure, whether it is exploited in the wild, what the asset holds.
- Test. IT validates the fix against the application. This is where most real delays live, and they are usually legitimate.
- Deploy. Rollout through change management, by tier, critical and internet-facing first.
- Verify. Confirm the fix actually took. For PHP2Shell, installing the package was not enough: every worker running the old runtime had to be restarted or replaced, and container images rebuilt.
- Mitigate what can’t be patched. End-of-life systems, frozen apps, vendor appliances. Here you reduce exposure instead: config changes, a WAF in front, network restriction, isolation, then a dated plan to retire it.
Step 7 is the one most teams skip. A server that shows the new package version but still runs old PHP workers in memory is patched on paper and vulnerable in practice.
Why security’s “patch this now” isn’t drama
From the IT side, an urgent patch request can look like security moving the goalposts again. You have a change calendar, a test cycle, and an application owner who does not want a restart at noon. Fair. So here is what security sees when it sends that ticket.

The attacker’s clock started before the defenders’ did; KEV and deadline dates are pending verification.
The attacker’s clock now starts in hours, not weeks. Security Affairs, citing Cloudflare, reported that PHP2Shell drew thousands of exploit attempts in the 10 hours before the public announcement, tens of thousands within 45 minutes after it, and millions by the next day. Attackers read advisories too. Disclosure is a starting gun for both sides.
The exposed surface is enormous. Censys counted more than 34.4 million PHP services still on vulnerable versions as of October 23. Scanners do not care whether your app is important. They try every IP.
The federal benchmark tightened. CISA’s Binding Operational Directive 26-04, issued in June 2026, gives federal agencies as little as three days to fix a publicly exposed, KEV-listed flaw that attackers can automate. PHP2Shell landed exactly there: CISA added both CVEs to the KEV catalog on October 26 with a due date of October 29. Private companies are not bound by that directive, but many security teams use KEV as their own trigger.
And yet, the honest part: PHP2Shell was not a free-for-all. Mandiant told Cybersecurity Dive there was no evidence of widescale exploitation as of October 26, and some PoCs only worked against default mod_php, not PHP-FPM. Good security teams use exactly that nuance to rank which servers move first. Urgent does not mean everything at once. It means the right things first.
So when the request lands, the most useful reply from IT is not “why the rush?” It is: “Which of my systems match, and which do I do first?” That question is already a security question.
You’re closer to security than your job title says
Look back at the lifecycle. Test, deploy, verify, restart the workers, rebuild the images, keep the change record. That is IT work. Security owns the why and the which first. IT owns the how and the did it actually work. The handoff between them is where most real-world exposure lives.
That is why we keep saying cybersecurity is not rocket science. The problem for most IT pros isn’t capability. It’s that nobody showed them the decision layer that sits on top of work they already do. Here is how a vulnerability like PHP2Shell runs through the Threat & Control Method:
- Inventory. Which servers run PHP? Which version, which handler (mod_php, PHP-FPM), which are internet-facing, which containers bake it in? If you have a CMDB or a decent Ansible inventory, you are already halfway to an Asset Inventory.
- Threats. Is it exploited in the wild? Does a working exploit exist for your configuration? Who would target this system? That becomes your Threat Model.
- Controls. Patch, restart, rebuild. Where you can’t, apply the documented config mitigations, filter at the proxy, restrict access. That is a Security Plan, not a panic.
- Scale. Next month it won’t be PHP. It will be a VPN appliance or a Java library. The same four questions apply, which gives you a Repeatable Decision Process.
Notice what changed. You didn’t learn a new tool. You learned to ask the questions in an order that turns a ticket into a decision. That is the difference between “the admin who patched it” and “the person who knew which systems mattered.” One of those reads like support on a resume. The other reads like blue team.
Key takeaways
- A vulnerability is the weakness; an exploit is the method that abuses it; risk is what it means for your systems.
- Exploit attempts are not compromises. PHP2Shell drew millions of attempts with no confirmed real-world RCE in its first days.
- Disclosure starts two clocks. Patch management is how you win yours.
- “Patched” means verified running, not just installed.
- Most of the lifecycle is already IT work. The missing piece is the decision layer.
If you want the full method, not just the concept, our program walks IT professionals through applying it step by step to real systems: see how the program works.
Want one practical breakdown like this every week? Join the Keep IT Safe newsletter: real incidents, explained for people who already run infrastructure.

