On November 13, 2026, Google Project Zero retired the “90+30” disclosure policy that many security teams had planned around. Vendors used to get 90 days to fix a bug, then 30 more days for users to roll out the patch. The new “Full 90” model publishes 90 days after the report, with no soak period, and it shrinks to Full 30 by 2028. The patch window, the exposure between an advisory and a deployed patch, now needs a control of its own.
For internet-facing applications, that control is a rule in front of the origin that blocks the exploit before it reaches vulnerable code. It covers less than a patch does, and knowing exactly where it stops is what makes it safe to lean on for a few days.
Why the Project Zero change matters to CISOs
Under 90+30, the soak period gave customers a month to install a fix before the details became public. The Project Zero policy post now calls that buffer meaningless and says it can create a false sense of secrecy.
Project Zero gives two reasons. Language models let attackers find bugs faster, make it more likely that several parties find the same one, and shorten the time it takes to turn a patch into a working exploit, so its planning assumption is that the time from patch to exploitation can be zero. And the team now finds several vulnerabilities a week, too many to negotiate fix status and grace periods one by one, so the policy drops grace periods and no longer waits for a fix.
The policy binds only the bugs Project Zero reports, but its published calendar is a useful planning input: Full 90 today, Full 60 from February 2, 2027, and Full 30 from January 3, 2028.
Why patch SLAs no longer match disclosure deadlines
Most patch SLAs were written for the old rhythm, on the assumption that public exploit details would trail the fix by weeks. At Full 90, a vendor that uses the whole period ships the fix on the day the details go public. At Full 30, a vendor that needs longer than 30 days leaves you with public details and no patch at all. Your team still has to find every affected system, test, and schedule a deploy, and that time does not shrink because a disclosure deadline did.
How much of that gap lands on you depends on the rules your industry already patches against.
Financial services: a one-month clock that starts at release
Banks, payment companies, and fintechs that handle card data patch against PCI DSS. Requirement 6.3.3 asks for critical security patches to be installed within one month of release. A team that patches on day 29 is compliant, and if the fix shipped on the day the details went public, it also ran for 29 days with the exploit public. Change advisory boards and test cycles do not move faster because of a disclosure date, so a control in front of the origin is what covers the days the compliance clock allows.
Retail: the same clock, plus peak-season freezes
Retailers that take card payments face the same PCI DSS requirement, and many also freeze production changes around Black Friday and other peak dates. An advisory that lands during a freeze forces a choice between breaking the freeze and staying exposed until it ends. A firewall rule changes no application code, so it can go in while the code freeze holds. The same peak brings the bot traffic covered in our Black Friday bot protection post.
Technology and SaaS: exposure now sets the deadline
SaaS companies that run systems for US federal agencies inherit CISA’s Binding Operational Directive 26-04, issued on June 10, 2026. Its remediation timelines depend on four inputs, which are whether the asset is exposed, whether the flaw is in the Known Exploited Vulnerabilities catalog, whether exploitation can be automated, and its technical impact. The shortest timeline is three days, together with a forensic triage of the asset. The directive also changes the deadline when exposure changes, since taking a system off the internet counts as a valid mitigation.
For the rest of the sector the directive is guidance, but the logic fits SaaS well: most of the surface is exposed over HTTP, and much of it runs on open source runtimes, such as PHP, that only the upstream project can fix.
What is a rule in front of the origin?
A rule in front of the origin is a policy, or a function, that recognizes the request pattern of a known exploit. It blocks that request before it reaches the vulnerable code. The vulnerable code stays in place, and the exploit request stops arriving.
That makes the rule a bridge to the patch. It covers the patch window between the advisory and the deploy, while the patch is still what removes the flaw. The market often calls this virtual patching, and our post on the OWASP Top 10:2025 covers it in the context of supply chain risk. This post focuses on timing.
At Azion, the control sits in Firewall, the Azion Platform resource that holds the policy for each application. Requests pass through it in order before any reach the origin, as described in the OWASP and zero-day use case:
- DDoS Protection runs first, on every workload, and needs no configuration.
- Network Shield lists refuse matching clients with a 403.
- The Web Application Firewall (WAF) scores the request against eight threat families. In Blocking mode, a score at the threshold returns a 400.
- Bot Manager scores the request and runs the action you set.
- Only requests that no rule stops reach the application.
A rule for a specific CVE fits into this sequence, as a Rules Engine rule that denies the exploit request or as a function run in Firewall, written by your team or published on Azion Marketplace, such as the PHP2Shell hotfix.
Two things matter in an emergency. The rule runs in the same policy as WAF, Bot Manager, and the network lists, and custom logic in JavaScript runs there too, with no separate tool to buy or integrate. Real-Time Events then records which rule matched each request, so in the first hour the team can see whether the new rule is catching exploit traffic or blocking customers, and tune it in the same place.
The PHP2Shell patch window, a real-world example
PHP2Shell shows the patch window in practice. On October 21, 2026, PHP disclosed CVE-2026-109618 and CVE-2026-109619, two runtime flaws rated 9.2 in CVSS v4.0 that can allow unauthenticated remote code execution. The identifiers circulated before the coordinated disclosure, and a proof-of-concept video was published by mistake.
| Stage | Event |
|---|---|
| Before October 21, 2026 | CVE identifiers and a proof-of-concept video circulate publicly |
| October 21, 2026 | PHP discloses both CVEs |
| Before your patch | Azion’s security team publishes a hotfix on Azion Marketplace, applied to Firewall |
| Your deploy date | PHP updated to 8.5.12, 8.4.27, 8.3.36, or 8.2.35 |
The hotfix runs as a function in Firewall. It inspects each request before it reaches the origin and makes one decision, allow or block, with no server access and no worker restarts. The PHP2Shell post lists the detection reasons and the steps to apply it.
The hotfix does not replace the last row of that table. As the PHP2Shell post states, the permanent fix is updating PHP, and updating application code, frameworks, or plugins does not fix the problem. The PHP update also closes variants of CVE-2026-109619 that start inside the server, such as fatal errors and timeouts.
The exposure started before the advisory, the control went in without touching a server, and the patch arrived whenever each team’s change process allowed. The diagram shows the same sequence for any internet-facing application.

Where a request-level control adds value, and where it stops
A rule in front of the origin only sees what crosses it. Before you count a CVE as covered, check it against these limits:
- Flaws that start inside the server, from a timeout, a background job, or a fatal error, leave no request to block.
- Services that do not speak HTTP, such as a database port, SSH, or a message broker, are outside Firewall’s reach.
- Traffic that reaches the origin’s IP address directly skips the policy entirely.
- East-west traffic between internal services never crosses the public request path, which is a case for network segmentation.
- A rewritten payload can slip past a rule built for a known exploit pattern.
The third item has a specific fix. Origin Shield publishes the Azion Origin Shield list, the prefixes Azion uses to connect to origins. When the origin’s firewall accepts only those prefixes, clients cannot go around the policy. Keep IPv6 prefixes in the allowlist, and update it within 7 days of a new prefix, since servers behind it enter production 7 days after Azion publishes it.
How to tell if a rule can cover a CVE in the patch window
Those limits turn into four questions your team can answer from the advisory in the first hour:
- Is the vulnerable code reachable by an HTTP request from the internet?
- Does the advisory or the proof of concept show what the exploit request looks like, such as a path, a parameter name, a header, or a payload shape? If it only says “memory corruption in the parser”, a WAF threat family is the closer fit than a custom rule.
- Does all traffic to that origin pass through the firewall, with Origin Shield closing direct access?
- Does every known trigger start with a request, unlike the PHP2Shell variants that start from timeouts or fatal errors?
Four yes answers mean the rule covers the request path and the patch covers the rest. Any no is an exposure the owner accepts in writing until the deploy date, or a reason to take the feature offline.
Ways to cover the patch window, compared
When a critical advisory lands and the patch is days away, the realistic options are few, and most teams combine them.
| Option | What it closes | Time to effect | Cost or limit |
|---|---|---|---|
| Emergency patch | The flaw itself | Your fastest safe change cycle | Skips testing, may not be possible for third-party software |
| Take the service offline or disable the feature | All exposure for that service | Minutes | Lost revenue or function until the patch ships |
| Rule in front of the origin | Known exploit vectors in HTTP requests | Minutes for a rule to take effect | Does not cover in-server or non-HTTP paths |
Network segmentation sits next to all three, since it limits what an attacker can reach if one of them fails.
How to run the patch window as a process
A rule in front of the origin works best when the decisions are made before the advisory. Under Full 30, a team that starts planning on disclosure day has already lost part of its patch window.
Decide ownership before the next advisory
Name who reads advisories, who answers the four questions above, and who writes or applies the rule. When a Marketplace hotfix exists, as it did for PHP2Shell, applying it is a configuration task. When there is none, the rule needs someone who can read the advisory and the proof of concept.
Write the emergency rule from the advisory
Take an illustrative advisory: an unauthenticated request to a debug endpoint at /internal/debug of a third-party admin panel runs code on the server, and the proof of concept passes the command in a cmd query parameter. Your application never needs that endpoint from the internet. A Rules Engine rule in the firewall for that application can be as small as this:
| Field | Value |
|---|---|
| Criteria | ${request_uri} starts with /internal/debug |
| Behavior | Deny (403 Forbidden) |
The URI criterion needs no extra module. If the endpoint must stay public, narrow the match to the exploit itself by adding a second criterion, ${request_args} matches (^|&)cmd=. Criteria that read arguments need WAF on that firewall. When the pattern needs more than a match, such as decoding a field before checking it, the logic moves into a function run through Run Function, which is how the PHP2Shell hotfix works. The full list of variables, operators, and behaviors is in the Firewall Rules Engine reference.
Budget the time a rule takes
A new firewall rule goes live in minutes, with no deploy and no change to the application, and a change to a network list takes effect even faster. The use case documentation lists the exact propagation times, so you can plan the first hour around them.
Observe, then block
Apply WAF to every path, with a criterion such as URI starts with /, not only to the home page. Start in Logging mode, read the detections in Real-Time Events, adjust if legitimate traffic is flagged, then switch to Blocking. The documentation recommends 3 days of tuning first, and shortening that during an active exploit wave is a risk decision for the owner you named.
Measure the impact with two clocks
For every critical CVE, measure the time from disclosure to block and from disclosure to patch. The first shows how fast your control responds, the second how long it has to hold, and when the second is long, the next improvement belongs in the change process.
After the patch is deployed, decide whether the rule stays. Keeping it covers systems someone forgot to patch, and removing it keeps the rule set lean.
Next steps for your patch window
Disclosure deadlines are now set by the people who find the bugs, and Project Zero’s calendar ends at 30 days in 2028. Your patch cycle will not shrink at the same pace, so the patch window needs an owner, a control, and a measurement.
For internet-facing applications, a rule in front of the origin is that control. It buys the days the disclosure calendar no longer gives, and the patch is still the fix. To see how Firewall, WAF, Bot Manager, and Origin Shield fit together, read the use case Protect web applications from OWASP Top 10 and zero-day attacks.
