A Patch Goes Public Before the Hole Does
Why a security fix can be downloadable and diffable weeks before its advisory: how to measure the patch-to-advisory window, triage a release with no CVE, and co-release fixes with advisories.
A fixed binary is visible the moment it ships. So is a merged commit, a bumped version number, a changelog entry, and a new tag in a package registry. The advisory that explains what was fixed may arrive weeks later. That ordering — fix first, explanation later — is not a side effect of sloppy release management. It is a distinct exposure condition, and it is the one this article addresses.
The piece is written for two readers at once: security engineers and platform owners who consume upstream patches, and engineering leads whose teams publish software that others depend on. For the first group, the question is how to act on a release whose security meaning has not been announced. For the second, it is how to stop creating that gap. Both need the same three things: a measurable definition of the window, an inventory of what a release actually discloses, and instrumentation that turns the definition into something a team can track. The sections below build those, then close with an acceptance checklist a team can run against its own process.
Defining the patch-to-advisory window
Three events get conflated in most discussions of patching speed, and separating them is the precondition for measuring anything.
The first is the fix commit: the code change that removes the vulnerability. In open source, once that commit lands in a public repository, the commit message and the diff are public by the development model itself. The second is the security release: a new version published to a registry that contains the fix. The third is the advisory: a published document that names the vulnerability, identifies affected versions, and tells the world a fix exists.
The window this article is about sits between the second and third events. It is the interval in which the fix is available for download and the code change is inspectable, but no advisory has told dependent projects that a security fix exists.
A 2022 empirical study of open source release practice gives the interval a magnitude. Across 4,377 security advisories covering seven package ecosystems — Composer, Go, Maven, npm, NuGet, pip, and RubyGems — the median security release arrived in under four days of the corresponding fix. Snyk and NVD, meanwhile, took a median of 25 days from the release to publish an advisory. The study's scope matters: it covers root-package releases only, and downstream adoption by client projects is explicitly out of scope. It is a measurement of publisher behavior in seven ecosystems, not a universal law about all software.
The distribution is also not uniform. The same study reports that a quarter of releases arrived at least 20 days after the fix, and that advisory timing varies by ecosystem — the fix-to-release median ranges from zero days for npm to 13 days for Maven. A team that assumes a single industry-wide number will misjudge its own exposure.
Two other delays are frequently folded into this one and should be kept apart. Project Zero describes the "upstream patch gap" as the period in which an upstream vendor has a fix available but downstream dependents have not yet integrated it into their end product. The end-user patch gap is later still: an update exists and has not been installed. Neither is the same as the release-to-advisory delay, and each has a different owner and a different remedy.
The consequence of the release-to-advisory interval is stated plainly in the CERT Guide to Coordinated Vulnerability Disclosure: information about a vulnerability can be available to the public without being publicized. A commit comment, a public exploit, or a binary diff of two released versions can each be sufficient for an analyst to recognize that a vulnerability was fixed. In each case the existence of the vulnerability should be considered public information, even though no advisory exists. The guide's conclusion is direct: if the goal is for fixes to be deployed, making information public is insufficient — it must be publicized.
What becomes visible when a fix ships
The practical question for a defender is not whether a release leaks information in the abstract, but which artifacts their monitoring can actually see. The same study catalogued what security releases disclose and how often.
Release notes. 61.5% of security releases carried a release note documenting the corresponding fix. The study's open coding sorted those notes into categories: an explicit security notice (198 cases), a reference to the fix commit or pull request (181), a vulnerability description (150), an advisory or CVE reference (121), the affected component (79), affected versions (33), and exploit detail (26). A note that names the affected function and links the fix commit is close to a full disclosure on its own.
Version numbers. 13.4% of releases signaled backward incompatibility through semantic versioning, while only 6.4% said so in the release notes. A major version jump is therefore a weak but real signal that something structural changed — and when it coincides with a security fix, it narrows the search.
Commit history and pull request titles. These are public by default in most open source projects. The study notes that once a fix is committed, the commit message and code change become public under the open source development model. A pull request titled "remove unnecessary escape in Regex" is a fix reference in the study's taxonomy, and it is legible to anyone watching the repository.
Registry timestamps. Publication times establish ordering. A release published hours after a commit, with no accompanying advisory, is a release whose security content has not been announced.
Diffing. The technique that converts an ambiguous bulletin into root cause is patch diffing: comparing a known-vulnerable build against the build containing the fix. Project Zero demonstrated that concurrently supported branches of Windows differing by an added memset call were enough to identify three kernel memory-disclosure vulnerabilities — CVE-2017-8680, CVE-2017-8684, and CVE-2017-8685 — with what the author described as pseudocode-level diffing requiring little low-level expertise. The lesson generalizes: a fix that adds a bounds check or an initialization call is recognizable, and a release note that says only "bug fixes" does not conceal it.
That is also the honest limit. Not every artifact is equally legible, and not every release is a security release. The point of the inventory is not that every commit is a disclosure; it is that the release itself is the disclosure surface, and a team that monitors only advisory feeds is watching a channel that lags the one attackers can read.
Measuring exposure during the window
A definition is only useful if it can be measured against a specific environment. Three instrumentation steps turn the window into something a team can track.
Map deployed versions to advisories. The baseline is a software inventory joined against advisory feeds. NIST SP 800-40r4 treats this as foundational: organizations should maintain up-to-date software inventories, and vendor-supplied SBOMs can augment them. The caveat is the one the study establishes — advisory coverage lags release, so an inventory joined only against advisories will under-report what is actually running. The join needs a second input: registry release feeds for the components in the inventory, so a new version is visible before its advisory exists.
Test reachability. Presence is not exposure. The questions are whether the vulnerable code path is invoked, whether the component is network-reachable, and whether compensating controls already sit in front of it. FIRST's guidance on EPSS makes the same point from the risk side: a population-level score becomes an environment-specific decision only when combined with confirmed presence, confirmed reachability, and consequence.
Measure your own window. Timestamp two events per component: when the release was observed, and when the advisory was observed. The difference is the organization's own release-to-advisory lag, and its median is the number that matters for planning. The published 25-day figure is a study result across seven ecosystems; it is not a benchmark to copy, and a team that substitutes it for its own measurement will plan against someone else's data.
Heartbleed is a useful calibration for how fast exposure moves once disclosure happens, and for how slowly remediation follows. Durumeric et al. found no evidence of exploitation prior to public disclosure, then detected exploit attempts from almost 700 sources beginning less than 24 hours after disclosure. Remediation was slower: fewer than a quarter of Alexa Top 1 Million sites replaced certificates in the week after disclosure, and of the sites still vulnerable 48 hours after disclosure, only 10% replaced certificates within the next month.
The Heartbleed record also shows the value of pre-disclosure preparation. Google, Akamai, and other sites disabled the Heartbeat extension before public disclosure — Google's servers were Heartbeat-disabled by April 15, starting at least 12 days before the public announcement. That is what a mature response to a known-but-unannounced fix looks like: the organization acted on information it had before the advisory existed. The specific numbers are a historical record from 2014, not a forecast for any current component.
A defender playbook for the window
The playbook for the window has to work without a CVSS score, because the score arrives with the advisory. Four elements carry the load.
Triage on signals that exist now. Component criticality, network exposure, and the nature of the diff are available before any advisory. A fix that touches an authentication path, a parser, or a memory-handling routine is a different proposition from a fix to a logging format string. The study's finding that the median security release changes 134 lines of code is a reminder that these diffs are small enough to read.
Choose a risk response deliberately. NIST SP 800-40r4 frames the options as accept, mitigate, transfer, and avoid. Mitigate includes patching, disabling a vulnerable feature, upgrading to a version without the vulnerability, and deploying additional controls such as firewalls and network segmentation to isolate vulnerable assets. Avoid includes uninstalling the software or decommissioning the asset. The framework matters here because "we cannot patch yet" is not a single state — it is a choice among several responses, and the choice should be recorded.
Stage the rollout. NIST describes canary assets as a way to test a patch on a small population before broad deployment, with multiple rounds possible: a first round with technically knowledgeable users, then a wider round with early adopters. In the window, the canary stage doubles as a check that the patch does not break the service before it reaches the whole fleet.
Detect against the unpatched population. If the fix is public and the advisory is not, assume the vulnerable population is a target. Detection content aimed at the pre-patch behavior — the malformed request, the oversized length field, the unexpected input to the parsing path — is worth deploying before the advisory gives everyone else the same idea.
A short list of things not to do:
Do not treat "no advisory yet" as "not yet exploitable." The absence of an advisory is a statement about publication, not about risk.
Do not defer a patch on an internet-facing asset solely because the eventual CVSS score turns out to be low. A low score on a reachable, high-consequence asset is still a reachable, high-consequence exposure.
Do not wait for a CVE identifier before starting triage. The identifier is assigned through a separate process and may trail the release.
Engineering-side controls: co-releasing patch and advisory
For teams that publish software, the window is a design choice. Several controls close it at the source.
Keep fix work out of public history until release. GitHub supports a temporary private fork for collaborating on a security fix in a public repository, and a draft repository advisory for private discussion of the vulnerability. The study's recommendations point the same way: use a private fork for security fixes, and keep it private until the next release. The failure mode this prevents is the one the study documents — a fix commit that becomes public the moment it lands, weeks before the release that carries it.
Co-release the advisory with the release. The CERT Guide to CVD describes near-simultaneous publication of advisory and fix as a common goal, and notes that reporters often synchronize publication with the vendor's response. For a publisher, the target is straightforward: the advisory should be published at or before the moment the fixed version is downloadable, not after.
Standardize release-note language. If 61.5% of security releases already document the fix, the remaining share is a process gap, not a technical one. A release note that classifies a fix as a security fix — even without exploit detail — converts an inference into a statement and lets dependent projects act.
Coordinate timelines with downstream vendors. FIRST's multi-party coordination guidance recommends that vendors clearly communicate disclosure timelines to downstream vendors, and that downstream vendors keep components in sync with upstream recommended releases. The guidance also notes a concrete cost of selective patching: OpenSSL's CVE-2016-2108 was fixed in June 2015 releases but not recognized as a vulnerability until May 2016, so downstream vendors who tracked the latest stable release had resolved it eleven months before vendors who patched only by CVE.
Know which policy you are operating under. The coordinators' policies differ in scope and should not be treated as a single industry standard. CERT/CC discloses vulnerabilities 45 days after the initial report, regardless of whether patches exist, with earlier or later disclosure for extenuating circumstances. Project Zero operates a 90+30 policy: 90 days for a vendor to make a patch available, then 30 days before details are published, with a 7-day deadline replacing the 90 when there is evidence of in-the-wild exploitation. Project Zero's 2025 Reporting Transparency trial adds a step at the front: within about a week of reporting a vulnerability, it publicly shares the vendor, the affected product, the report date, and the deadline — with no technical details until the deadline. These are different coordinators making different judgments about the same tradeoff.
Prioritizing urgency beyond CVSS
When several window-period patches compete for the same maintenance hours, CVSS alone will misorder them. Three signals do better.
KEV. CISA's Known Exploited Vulnerabilities catalog is built on evidence of active exploitation. CISA's own framing of the problem is stark: less than 4% of the total number of CVEs have been publicly exploited, but of those, 42% are used on day zero of disclosure, 50% within two days, and 75% within 28 days. That compression is exactly why a patch shipped ahead of its advisory is dangerous — the defender's reaction time is already short when the clock starts at disclosure, and a release-first ordering starts the attacker's clock earlier.
KEV inclusion has requirements that matter for the window: a CVE ID, reliable evidence of exploitation in the wild, and clear remediation guidance. A fresh patch with no advisory yet has no CVE and no exploitation evidence, so it is not on KEV by definition. It must be triaged on other signals.
EPSS. The Exploit Prediction Scoring System produces a calibrated probability: the estimated likelihood that exploitation activity for a given vulnerability will be observed across EPSS data partners in the next 30 days. FIRST is explicit that it is not a severity score and not a complete risk score, and that it does not know what is in your environment. Its value in the window is as a likelihood input for vulnerabilities that already have identifiers; for a release with no advisory, it has nothing to score.
Reachability and consequence. FIRST's three checks — confirmed presence, confirmed reachability, and consequence — are what convert a population-level score into an environment-specific decision. Any one of the three being absent reduces urgency regardless of the score.
The rule of thumb FIRST states is the one to adopt: when a vulnerability appears on KEV, treat it as actively exploited and prioritize accordingly, regardless of EPSS score. EPSS remains useful for everything KEV does not cover, which is the large majority of the vulnerability population. For the window itself, the ordering signal is neither: it is exposure plus the nature of the diff, applied before an identifier exists.
Acceptance checklist: is your patch-to-disclosure process closed?
Each item below is phrased so the answer is observable. The right-hand column notes what evidence a "yes" requires.
Check | Evidence required |
|---|---|
Every security release has an advisory published at or before release time | Timestamps for the release and the advisory, per release |
Release notes classify security fixes explicitly | A release-note template with a security category, and a sample of recent releases showing it used |
Fix work happens in a private fork with no public commit trail before release | Repository audit of the commits preceding a security release |
The organization can state its own measured median release-to-advisory window | A query result over the last 12 months, per component |
Deployed versions are mapped to advisories on a defined cadence | The inventory-to-advisory join, its schedule, and its last run |
Reachability is assessed before urgency is assigned | A triage record showing presence, reachability, and consequence for each item |
KEV, EPSS, and exposure are combined rather than CVSS used alone | The prioritization rule as documented, and a sample of decisions it produced |
A named owner exists for the co-release step | A role assignment in the release process, not a team name |
The first four are publisher-side checks; the last four apply to both publishers and consumers. Items requiring a timestamp or a query result are evidence items. Items requiring a documented rule or a named owner are decision items — they can be verified by reading the process document, but only the evidence items prove the process ran.
FAQ
How long is the window typically? In the seven ecosystems studied, the median security release arrived in under four days of its fix, while Snyk and NVD took a median of 25 days from the release to publish an advisory. The release-to-advisory lag exceeds the fix-to-release lag because they are different processes: the first is a maintainer's release cycle, the second is a database's intake and analysis pipeline. The study's scope is root-package releases in Composer, Go, Maven, npm, NuGet, pip, and RubyGems; a team should measure its own components rather than adopt the median.
Does publishing an advisory early help attackers? Coordinators disagree, and the disagreement is worth understanding rather than resolving. Project Zero's position on its Reporting Transparency trial is that an alert is not a blueprint: no technical details, proof-of-concept code, or information that would materially assist discovery is released until the deadline. CERT/CC's position is that in the absence of evidence of exploitation, gratuitously announcing vulnerabilities may not be in the best interest of public safety. Both are judgments about the same tradeoff by coordinators with different scopes — Project Zero reports on foundational upstream technologies with large downstream ecosystems; CERT/CC coordinates multi-vendor cases across a broad range. A publisher should know which model its own disclosure practice resembles.
Does a version bump alone constitute disclosure? Not by itself. A version bump is a signal, and the study found that 13.4% of security releases indicated backward incompatibility through semantic versioning while only 6.4% said so in release notes — so a major version jump is a hint, not an announcement. But a version bump combined with a public commit diff is disclosure in the sense CERT/CC describes: the information is available to the public even if it has not been publicized.
What should a defender do when a patch ships with no advisory and no CVE? Triage on what is available: component criticality, network exposure, and the nature of the diff. Choose a risk response deliberately — patch, disable the feature, segment the asset, or accept with a recorded rationale. Deploy detection for the pre-patch behavior. Do not wait for an identifier to begin.
When KEV and EPSS disagree, which drives the decision? KEV. FIRST's rule of thumb is to treat KEV membership as evidence of active exploitation and prioritize accordingly, regardless of EPSS score. EPSS informs the large population that KEV does not cover. Neither replaces the environment checks — presence, reachability, and consequence — that determine whether a high score translates into real exposure for a specific asset.