skip to content

A team says "we are fully patched, so we are fine" — what does patch level not cover?

level: seniorimportance: should knowfreq 58%

answer

  1. a claim about other people's code
  2. no advisory, no version, no fix to install
  3. the code does what it says
  4. strongest where attacker cost was already highest
  5. scope the claim, don't dismiss it

basics

~20 s

Patch level is a claim about third-party code someone else shipped a fix for. It says nothing about first-party authorization decisions, identifiers accepted as entitlement, workflow logic or configuration — flaws that never carry a version number at all.

solid answer

~50 s

Being fully patched means every component is at a version where a vendor has already published a fix for a defect they acknowledged. That is a real and valuable statement, but its scope is exactly the set of weaknesses somebody else could write a fix for. A missing tenant-ownership check in your own export endpoint has no advisory, no version to be behind and no patch to install: the code does precisely what it was written to do, and what it was written to do is wrong. The same holds for identifiers treated as authority, steps in a workflow that can be requested directly, permissions granted deliberately and defaults left as shipped. The sharp point to make in the review is that patching is strongest against the classes with the longest distance to a working attack, and silent on the classes with the shortest.

go deeper

for a junior

Know that patching fixes defects in code other people wrote and published a fix for. A mistake in your own application's logic has no version number and will never show up as out of date.

for a middle

Explain which weakness classes can and cannot carry a patch, and why: a patch presupposes an acknowledged defect and a shipped correction, which absent authorization logic never has.

for a senior

In a review, scope the claim rather than dismiss it, and name the specific classes it leaves untouched. Then ask what testable statement would cover them, and treat the absence of one as the finding.

for a principal

Own the inversion: patch coverage is strongest where adversary cost is highest and silent where it is zero, so a programme measured only by patch compliance is reporting on the half of its exposure that is hardest to attack.

## What the claim actually asserts "Fully patched" is a statement about **versions of code you did not write**, measured against fixes their authors have published. Unpacked, it asserts three things: a defect was acknowledged by whoever owns the code; a corrected version exists; and you are running it. Every one of those steps is somebody else's act. That is why the claim is so easy to make and so easy to over-read. ## The classes the claim never touches A flaw only gets a patch level when the fix is something that ships. These do not: - **An absent authorization decision.** The export endpoint checks that a session is valid and then serves whatever identifier it is handed. Nobody will publish a fix; the fix is a code change you author. - **An identifier treated as entitlement.** Possession of a number, link or reference is being accepted as proof of the right to the thing behind it. - **A workflow whose later step can be requested directly.** Every individual endpoint behaves as specified; the specification assumed an order the protocol does not enforce. - **Permission grants that are working as intended.** A component holding far more authority than it needs is not a defect anyone will fix for you. - **Defaults left as shipped.** The vendor's code is at the newest version and the configuration is the problem, so no version bump changes anything. What unites them is that **nothing is broken in the sense a patch fixes**. There is no crash, no memory violation, no incorrect parsing. Execution follows the intended path and produces the intended result of a wrong intention. ## The inversion worth saying out loud Put the two axes together and the review gets its punchline. | Weakness class | Distance to a working attack | Covered by "fully patched"? | | --- | --- | --- | | Memory corruption in a bundled component | Long: primitive, mitigation bypasses, reliability, often a chain | Yes | | Missing tenant-ownership check | Zero: change one value in an ordinary request | No | | Guessable reference accepted as authority | Near zero once a reference is obtained | No | | Known defect in a runtime library | Long, unless someone has already converted it | Yes | Patching is most effective exactly where the attacker's cost was already highest, and mute exactly where their cost is nil. A team that treats patch level as a sufficiency claim has optimised the half of the problem an adversary was least likely to buy their way through. ## How to answer the reviewer's sentence without dismissing it Do not respond as though patching were unimportant — it retires a genuine and continuous stream of exposure, and it is the single control that keeps you out of reach of everyone using someone else's converted work. The correct response is scope, not scorn: "Fully patched answers whether we are behind on other people's fixes. It cannot answer whether our own code decides correctly who may read what, and that second question is where the flaws that need no exploit live." Then make the claim testable. Ask what statement the team could make about the second class. Usually there is none, and the absence of one is the finding — not because anyone has been careless, but because the vocabulary of patch levels does not contain a slot for a flaw that has no version number. ## The trap in the other direction The mirror mistake is treating first-party logic flaws as the only ones that matter because they are "our fault". Third-party defects with public, reliable, packaged attacks collapse to zero distance too, and at that point the patch state of your estate is the entire question. The discipline is not to prefer one class; it is to keep two separate questions separate and refuse to let an answer to one be offered as an answer to both.

  • The team asks what claim they could make that would cover the second class. What do you tell them?
    Something of the form "every endpoint that returns tenant-scoped data makes an ownership decision, and we can name where that decision is made." It is an assertion about design, not about versions, and it is checkable per endpoint. The useful outcome of the review is usually discovering that no one owns such a statement.
  • Can a first-party flaw ever get a patch level?
    Only when you are the vendor and someone else is running your code — then you publish a fix and your customers acquire a patch level for it. Inside your own estate there is no such number: you deploy a change. That asymmetry is why a SaaS provider's own missing check is invisible to every inventory their customers keep.
  • Does being fully patched ever fully answer the exposure question for a component?
    It comes closest for a third-party component with no first-party logic around it and no configuration surface, which is rare. The moment you wire authorization, tenancy or workflow around a component, the interesting failures move into code no patch reaches, and the version number stops being a summary of your risk.

saying these in an interview costs you the question

  • Treats patch level as a complete statement of exposure
  • Assumes every real flaw has an advisory behind it
  • Dismisses patching as unimportant to score a point
  • Confuses configuration defaults with unpatched versions
  • Expects a missing ownership check to appear in a version inventory

context