PHP was the reminder of the week. The two flaws disclosed on October 21, CVE-2026-109618 and CVE-2026-109619, allow code execution without credentials on any installation of the language that serves web pages, and the CISA advisory refers in the same document to the alerts from the NSA, the UK NCSC and the Canadian Centre for Cyber Security. The project published four fixed versions that same day, from 8.5.12 to 8.2.35, and updating to one of them closes the hole.
The problem is not that identifiers are missing, but that there are too many and they arrive without context. A corporate bulletin can bring you forty CVEs in one morning and none of them touch you, while the one that does affect you appears on the third line of an email nobody has read. Knowing how to read a CVE means separating the number from what it means: what code carries the flaw, whether that code is in your inventory, whether someone can reach it from outside and whether there is evidence that it is being exploited.
Public data makes it possible to sort that noise without guessing. The CISA KEV catalog, in its October 23 version, gathers 1,756 vulnerabilities with evidence of real exploitation, while the daily EPSS file scores 395,308 CVEs with a median 30-day probability of 0.0063. Less than 0.5% of what is published has proof that someone is using it to attack. With that attention budget, the decision is made in a fixed order and in ten minutes.
What exactly is a CVE and what is it not?
A CVE is a unique identifier that the CVE program assigns to a specific flaw, and in PHP it is assigned by the project itself as CNA, the authority that describes it. It is not a note, nor an alert, nor proof that an exploit exists.
The practical consequence is that a CVE without a record is not much use, and the record is what you read. The CVE-2026-109618 entry, published on October 21 in the 5.2 format, includes the technical description, the affected versions, the vector signed by the project itself and the reference to the vendor's advisory. That is where what you need to decide is, and that is where the work few people do begins: reading the record before looking at the number in the headline.
One thing the bulletins hide is worth adding: the identifier counts flaws, not deployments. The two PHP CVEs describe different primitives of the same engine and are fixed with the same update, so anyone planning two maintenance windows will have duplicated the work and the risk of leaving one branch half done.
How do you read a record field by field?
The record is read from top to bottom, but in a different order from the document, because the deciding datum is not the score. Start with the versions, continue with the description and leave CVSS for the end: by the time you reach the vector you will already know whether the rest matters to you or not.
| Field |
What it tells you |
What decision it drives |
| Description |
What condition triggers the flaw and what the attacker achieves |
Whether the scenario fits your deployment |
| Affected versions |
The exact range, with the fixed version alongside |
Whether your installation falls within it |
| `defaultStatus` |
What happens to versions that do not appear |
Whether you rule out the rest of the inventory |
| CVSS 4.0 vector |
Attack conditions and impact, metric by metric |
How much it weighs if the code is exposed |
| CWE |
The family of code error |
Whether you need to patch or mitigation is enough |
| References |
Vendor and third-party advisories |
What to update and what to check afterwards |
In the PHP case, the range starts at the 8.2 branch and runs to 8.4.26, with 8.5.11 as the ceiling of the newest branch, and the record marks `defaultStatus: unaffected` for everything outside it. That field saves arguments: a server on 7.4 is not part of this specific flaw. And if your version appears in the list, the same entry gives you the fixed one and there is nothing to interpret.
The vector in the example is `CVSS:4.0/AV:N/AC:H/AT:P/PR:N/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N`, which the project scores 9.2 and labels critical. The useful reading is in two letters: `AC:H` and `AT:P` mean the attack does not work first time against any server, but depends on execution conditions and on winning a memory race. That does not make it harmless, but it explains why a 9.2 is not the same as a universal exploit you launch in ten minutes.
That number is not what it seems either. The CVSS 4.0 specification requires each score to be labeled, and what is published is a CVSS-B: base metrics only, with threat and environmental metrics at the default value that assumes the worst case.
The CWE completes the reading with the family of error, and the linked advisory tells you what to do with the system running. Siemens, for example, had already added its RUGGEDCOM APE1808 equipment to the list of affected products in the record itself, because the flaw traveled inside one of its products that nobody would have looked for as PHP.
Do I have this code, is it reachable and is it exposed?
With the record open, the deciding question is more boring than the headline one: is this code in something I run? CISA warns of this in the advisory itself, because PHP often travels inside other programs and its presence is not visible at a glance in the inventory. A WordPress on shared hosting with mod_php is the obvious case; a vendor's administration console that embeds PHP also counts, even if nobody calls it PHP in the tally.
Reachability cuts the list again. If the flaw is triggered when processing an HTTP request, everything listening on the internet is within anyone's reach; if it lives in a library that only loads an internal binary connected through a local socket, the likelihood of someone getting that far drops, though it does not disappear. Note the scope of what you check, because a negative without scope becomes an excuse and not a decision.
Exposure and asset value are the two pieces no public database will give you, and they are precisely what separates two opposite decisions with the same version installed.
There are cases where the vulnerable code is not yours and still reaches you. The eight eMudhra intermediate certificates that browsers blocked on October 17 were not on any server of your own, but they were in the trust store of the clients connecting to them, as we reviewed when reconstructing that incident. What decides is where the code is, not who owns the machine running it.
How do you prioritize when there are twenty records open?
Order matters more than the formula. The sequence advocated by the Software Security prioritization framework puts evidence of exploitation ahead of any score and then adds the local facts no database knows.
- Look up the CVE in KEV and, if it appears, treat it as an urgency with a date.
- Check the day's EPSS with its date and the model version.
- Read CVSS 4.0 or the SSVC values as consequence, never as probability.
- Confirm that the vulnerable component is in the deployed artifact.
- Check reachability and exposure, and count the unknown as exposed.
- Adjust the deadline by asset value and save the evidence.
The first two steps are settled with two queries. CISA adds a vulnerability to KEV when there is an identifier, reliable evidence of exploitation and a clear remediation action; attempted exploitation counts, while a scan or a public proof of concept is not enough. FIRST's EPSS estimates each day the probability of observed exploitation activity in the next 30 days, and its tail is very short: in the October 25 file, the 90th percentile sits at 0.0383.
EPSS is not multiplied by CVSS, even though it is tempting. FIRST warns that this product has no interpretable reading, because one is a calibrated probability and the other an ordinal severity scale, so multiplying adds noise with the appearance of rigor.
The Strapi case documented by that same framework shows it in practice. CVE-2023-22894 entered KEV on October 8 with a three-day deadline, and the next day EPSS gave it 0.034, below the 90th percentile. If you had sorted the queue by EPSS, that flaw would have been left at the end. CISA's list had already put it first, and that is the difference between a patching policy and a waiting policy.
The opposite movement also exists. The two PHP CVEs had an EPSS of 5% on October 22 and 12% on the 24th, while the October 25 file assigns them almost 100%, with no KEV entry and no CISA warning of active exploitation in the public sources I have consulted. A jump like that does not say what happened, but it shows that a snapshot from the day before yesterday is no use for deciding today: note the date and the model version alongside each score.
What are the most costly mistakes?
The first is patching by score. A 9.8 in a library used only by an internal service with no internet access consumes the maintenance window that the 7.0 on the public portal needed, and that trade is made without realizing it. The score measures the consequence of a successful attack in the worst case, not the probability that someone reaches your specific server with the right exploit.
That first mistake is fixed with an uncomfortable question: what breaks if you patch and what breaks if you don't. The answer is not in any public catalog, but in your service map and your team's on-call schedule.
The second is dismissing a CVE because its CVSS is mediocre. A low score says nothing about whether someone is using it: a 6.5 with active attackers is an urgency today, while a 9.8 with no public exploit can wait for the normal cycle. If the asset is exposed and the flaw appears on the exploited list, the discussion about the number is superfluous and only delays the patch.
The third is trusting the scanner without checking the real version. Scanners fail in both directions: they do not see PHP embedded in a third-party product, as CISA warns, and sometimes they flag as vulnerable a package the distribution has already fixed with a backported patch. Check the number in the binary that runs and not in the dependency file, and cross-check with the distribution's advisory when the package comes from a repository.
The identifier opens the conversation
Ten minutes are enough to know whether a CVE affects you, but only if you accept that the answer may be "I don't know yet." The identifier tells you where to look; the inventory, exposure and evidence of exploitation are what make the decision, and you have that data, not the vendor or the CISA catalog.
In the October cycle it happened with PHP and with the Linux kernel vulnerabilities, which arrived with the same haste and the same underlying question. The next record that opens in your inbox deserves three checks before any other: what version is really running on the server, whether the flaw is in KEV and what date the EPSS you are reading carries.