# What is a zero-day: flaws with no patch, and how AI now finds them

> A zero-day is a bug attackers can use before a fix exists. Java4Shell, found with OpenAI's Codex and patched on November 17, shows where the line falls.

URL: https://claudegpt.si/news/what-is-a-zero-day  
Published: 2026-11-18T02:57:56.299Z  
Author: ClaudeGPT Si Newsroom  
Section: Research  
Topics: Cybersecurity, AI security, Google, Codex, OpenAI  
Publisher: ClaudeGPT Si

## Key takeaways

- A zero-day is a vulnerability exploited before its maker has shipped a patch; once a fix is out it becomes an n-day.
- Google's Big Sleep agent found an exploitable SQLite bug in 2024 that 150 CPU-hours of fuzzing had missed, and a Calif researcher found Java4Shell in 2026 with OpenAI's Codex.
- Java4Shell (CVE-2026-114938) was disclosed and patched on the same day, November 17, 2026, with no reported exploitation, so it was never a zero-day in the exploited-in-the-wild sense.

A zero-day is a security flaw that attackers can use before the software's maker has shipped a fix, which is what the name means: defenders have had zero days to patch it. NIST's glossary defines a [zero-day attack](https://csrc.nist.gov/glossary/term/zero_day_attack) as one "that exploits a previously unknown hardware, firmware, or software vulnerability." Once a patch is out, the same bug becomes an n-day: known, fixed, and still dangerous on every machine that hasn't updated.

On November 17, 2026, the security firm Calif disclosed [Java4Shell](https://calif.io/java4shell/), a critical bug in Java that a researcher found with help from OpenAI's Codex. A day earlier, Google reported that attackers are now using AI to turn freshly patched bugs into working attacks with no human involved.

## Zero-day vulnerability, exploit and attack

People use "zero-day" for three related things:

- **A zero-day vulnerability** is the flaw itself: a mistake in code that lets someone do what they shouldn't, such as read memory or run their own program.
- **A zero-day exploit** is the code that uses the flaw. A bug is a door left unlocked. The exploit is someone walking through it.
- **A zero-day attack** is an exploit used against real targets.

The strict definition, used by the teams that count them, is about exploitation. Google Threat Intelligence Group (GTIG) [defines a zero-day](https://cloud.google.com/blog/topics/threat-intelligence/2024-zero-day-trends) as "a vulnerability that was maliciously exploited in the wild before a patch was made publicly available." By that count there were 75 in 2024, down from 98 in 2023. Google Project Zero keeps a public [tracking sheet](https://projectzero.google/0day.html) of detected in-the-wild zero-day exploits, and says memory corruption is the root cause of 68% of them.

Looser usage calls any newly found, unpatched bug a zero-day, even one only a researcher knows about. That difference is the key to the Java4Shell question below.

## Zero-day vs n-day

| | Zero-day | N-day |
| --- | --- | --- |
| Patch available | No | Yes |
| Who knows about it | The finder, maybe an attacker | Everyone, through an advisory and a CVE ID |
| Main risk | Nothing to install yet | Systems that haven't installed the fix |
| How attackers find it | Original research | Reading the patch and the advisory |

N-days do most of the damage in practice, because patching is slow. CISA's [Known Exploited Vulnerabilities catalog](https://www.cisa.gov/known-exploited-vulnerabilities-catalog), which it calls the "authoritative source of vulnerabilities that have been exploited in the wild," listed 1,782 entries in its November 17, 2026 version. Each entry carries a due date for fixing it.

## How zero-days are found

Two methods have done most of the work for decades.

**Fuzzing** means feeding a program huge amounts of random or mutated input and watching for crashes. Google's open-source [OSS-Fuzz](https://github.com/google/oss-fuzz) project says it had helped find and fix over 13,000 vulnerabilities and 50,000 bugs across 1,000 projects as of May 2025. It only finds what its test harness reaches.

**Code audit** means a person reading the source, or the compiled program, and reasoning about where it breaks. It finds subtle logic bugs that fuzzers miss, but skilled auditors are scarce and slow.

A researcher who finds a bug reports it. An attacker keeps it quiet and uses it.

## How disclosure and patching work

Most bugs found by researchers go through coordinated disclosure: the finder tells the vendor privately, the vendor builds a fix, and both publish on the same day. The bug gets a CVE ID, a public label that lets every advisory, scanner and patch note refer to the same flaw.

Project Zero's [disclosure policy](https://projectzero.google/vulnerability-disclosure-policy.html) sets a 90-day deadline: it publishes details after 90 days whether or not the vendor has shipped a fix. If it finds evidence that a bug is being exploited against real users, the deadline drops to 7 days. Project Zero says it plans to shorten the standard deadline to 60 days on February 2, 2027, and to 30 days on January 3, 2028.

After disclosure, the race moves to the defenders: every system running the old version stays exposed until someone installs the update.

## How AI models now find zero-days

The newest bug hunters are AI agents that read code, guess where it breaks, and write a test to check.

- **Big Sleep, November 2024.** Project Zero and Google DeepMind [reported](https://projectzero.google/2024/10/from-naptime-to-big-sleep.html) that their agent, Big Sleep, found an exploitable stack buffer underflow in SQLite before it reached an official release. The SQLite developers fixed it the same day. The team said it was "the first public example of an AI agent finding a previously unknown exploitable memory-safety issue in widely used real-world software." Traditional fuzzing had missed it, including 150 CPU-hours with the AFL fuzzer.
- **Big Sleep, July 2025.** Google [said](https://blog.google/technology/safety-security/cybersecurity-updates-summer-2025/) Big Sleep, combined with threat intelligence, found CVE-2025-6965 in SQLite, a flaw Google says was known only to attackers, and helped block its exploitation.
- **Java4Shell, November 2026.** Calif researcher Quang Luong used Codex to audit HotSpot, the engine that compiles and runs Java code. Calif says the model produced many unrealistic findings before it surfaced the real one, that discovery took about an hour, a first working exploit two more hours, and the total token cost was under $200.

Attackers use the same tools. In its [AI Threat Tracker](https://cloud.google.com/blog/topics/threat-intelligence/agentic-threat-activity-crosses-a-significant-threshold) of November 16, 2026, GTIG said it found threat actors using AI frameworks to fully automate vulnerability discovery and exploitation "without a human in the loop for the first time." One framework, which GTIG calls exploit_agent, compares web application code before and after a patch, finds the fixed flaw, writes an exploit and runs it. [Our report on the tracker](https://claudegpt.si/news/gtig-ai-threat-tracker-autonomous-exploits) has the details.

GTIG's view is that AI makes n-days more attractive than zero-days, because a patch tells the model exactly where to look. GTIG says overall disclosures and exploits nearly doubled between January and August 2026, while exploited zero-days rose more slowly, from an average of 8 a month in 2025 to 11 a month in 2026, before a spike to 22 in August.

## Was Java4Shell a zero-day?

Strictly, no. Java4Shell, CVE-2026-114938, is a memory-corruption bug in OpenJDK HotSpot's x86-64 Base64 decoder intrinsic, a hand-optimized routine that uses AVX-512 instructions on newer Intel and AMD chips. Calif says a 65-byte malformed Base64 string makes the decoder write 62 bytes past the end of a buffer, and that it demonstrated remote code execution in Jenkins, Jira, Keycloak and other Java apps.

But it went through coordinated disclosure. The [CVE record](https://www.cve.org/CVERecord?id=CVE-2026-114938) shows Oracle reserved the ID on October 22, 2026, almost four weeks before going public. Oracle and the [OpenJDK project](https://openjdk.org/groups/vulnerability/advisories/2026-11-17) shipped fixes on November 17, the day Calif published. CISA's assessment on the record marks exploitation as "none," and the bug was not in the KEV catalog as of November 17. Calif's page does not report attacks in the wild.

So Java4Shell was a zero-day only in the loose sense: an unknown bug, known to its finder and the vendors before the patch. It was never a zero-day by GTIG's or Project Zero's exploited-in-the-wild definition. Since November 17 it has been an n-day, which is exactly the kind of bug GTIG says AI tools now weaponize within days.

Calif rates it 9.2 out of 10 under CVSS 4.0. Oracle's score in the CVE record is 8.1 under CVSS 3.1, rated "difficult to exploit." Calif says to update Java now, or, where that isn't possible, to start the JVM with `-XX:-UseBASE64Intrinsics` to turn off the affected routine. Our [Java4Shell report](https://claudegpt.si/news/java4shell-openjdk-cve-2026-114938) lists the affected versions and both stopgap flags.

For more on how AI labs probe their own models for weaknesses, see our explainer on [AI red teaming](https://claudegpt.si/news/what-is-ai-red-teaming).

## Frequently asked questions

### What is a zero-day exploit?

It is the code that takes advantage of a zero-day vulnerability, a flaw the vendor has not yet patched. When that code is used against real targets, it is a zero-day attack.

### What is the difference between a zero-day and an n-day?

A zero-day has no patch available. An n-day has a public fix and advisory, and is dangerous only on systems that have not installed the update, though attackers can study the patch to build an exploit.

### How many zero-days are exploited each year?

Google Threat Intelligence Group tracked 75 zero-days exploited in the wild in 2024 and 98 in 2023. In 2026 it counted an average of 11 a month, with 22 in August.

### Can AI find zero-day vulnerabilities?

Yes. Google's Big Sleep agent found an exploitable SQLite bug in 2024, and Calif says its researcher used OpenAI's Codex to find Java4Shell in OpenJDK in about an hour in 2026.

## Sources

- [Java4Shell: a memory-corruption vulnerability in OpenJDK's Base64 decoder](https://calif.io/java4shell/), Calif
- [CVE-2026-114938](https://www.cve.org/CVERecord?id=CVE-2026-114938), CVE Program
- [OpenJDK Vulnerability Advisory: 2026/11/17](https://openjdk.org/groups/vulnerability/advisories/2026-11-17), OpenJDK
- [AI Threat Tracker: Agentic threat activity crosses a significant threshold](https://cloud.google.com/blog/topics/threat-intelligence/agentic-threat-activity-crosses-a-significant-threshold), Google Threat Intelligence Group
- [2024 zero-day exploitation analysis](https://cloud.google.com/blog/topics/threat-intelligence/2024-zero-day-trends), Google Threat Intelligence Group
- [From Naptime to Big Sleep: using large language models to catch vulnerabilities in real-world code](https://projectzero.google/2024/10/from-naptime-to-big-sleep.html), Google Project Zero
- [0day In the Wild tracking](https://projectzero.google/0day.html), Google Project Zero
- [Vulnerability disclosure policy](https://projectzero.google/vulnerability-disclosure-policy.html), Google Project Zero
- [Cybersecurity updates, summer 2025](https://blog.google/technology/safety-security/cybersecurity-updates-summer-2025/), Google
- [Known Exploited Vulnerabilities catalog](https://www.cisa.gov/known-exploited-vulnerabilities-catalog), CISA
- [Zero day attack (glossary)](https://csrc.nist.gov/glossary/term/zero_day_attack), NIST
- [OSS-Fuzz](https://github.com/google/oss-fuzz), Google
