Across seven Google case files, the pattern is not the bugs. It is the habit of shipping a name and leaving the mechanism to whoever reads it. The parameter named elidable, the flag named safe_mode, the function EVP_PKEY_cmp wrapped as a bool, the CVE identifier that becomes a repository slug: the label is always present, the thing the label describes is always somewhere else.
The Nefarious Plan of Google
Fix EVP_PKEY_cmp usage. Not all non-zero values mean success.
That is the subject line on AOSP commit 842d331f, authored by Joshua Duong in January 2026 and merged in March. It patches CVE-2026-0073: adbd's EVP_PKEY_cmp Was the 2020 OpenIKED Bug. The engineer wrote the name of the bug class into the subject line of the commit that fixes it, six years after OpenIKED shipped the same mistake on the same function.
OpenIKED filed CVE-2020-16088 for this misuse of
EVP_PKEY_cmpin 2020. adbd filed CVE-2026-0073 for the same misuse, six years later.
The pattern is not the bugs. Blink's aliases_ use-after-free is a real bug. Maglev's typer over-promise is a real bug. Mojo's trust disjunction is a real bug. adbd's authentication check is a real bug. Keras's deserializer is a real bug. The patches work. The pattern is the layer above the bugs, where names get issued. Google issues the name of the safety and ships the name. The body of the safety gets shipped later, or elsewhere, or by a different maintainer, or not at all. Downstream of the name, somebody reads it as if it meant what it says.
The parameter was named elidable, and the function body did not read it
CVE-2026-5865: Maglev's BuildCheckSmi Took a Parameter Named elidable and Did Not Read It is the clean exhibit.
BuildCheckSmihad a parameter namedelidable. Pre-patch, the function did not read it.
Maglev is V8's mid-tier compiler. BuildCheckSmi is the function that emits the runtime "is this value a small integer" check before any code that depends on the answer. The caller passes elidable=false when the check has to fire for real, because the caller does not trust the typer to be the only gate on the next instruction. The function body did not consult the parameter. The patch is && elidable on one line of the branch condition.
Someone wrote the parameter name. Someone put it in the signature. The design that authorised the parameter understood that a static-type oracle and a caller-knows-best override are different oracles. The function body shipped as if only one of them was.
The flag was named safe_mode, and the sink was forty lines below it
CVE-2025-1550: The safe_mode Check Is Not in the Patch is the same habit in Python.
The flag is in the function. The fix is on a different control surface.
Keras is a Google project. load_model(filepath) takes safe_mode=True by default. The docstring says the flag disallows unsafe lambda deserialization. The docstring is accurate. The flag guards one class_name string literal, __lambda__. Forty lines below, in the same function, _retrieve_class_or_fn calls importlib.import_module on whatever module name the attacker-controlled config.json carries, and returns the resolved callable to the Lambda layer, which later calls it. subprocess.run("/bin/sh") resolves through this path, under safe_mode=True, because the guard is on the marker the author imagined and not on the sink the interpreter actually reaches.
The guard named the marker. The bug was at the sink.
The 3.9.0 patch adds an allowlist in the unguarded block. The allowlist does not extend safe_mode. It is a separate control surface in the same function, written by the same maintainer. The two controls do not know about each other.
The CVE identifier is the scanner key
The habit moves out of Google's source trees when the name is a CVE number.
CVE-2026-11645: Three Public PoCs For The V8 KEV Bug. None Of Them Read Or Write Out Of Bounds. is the June 2026 instance. Google publishes the CVE. CISA attaches a federal civilian deadline. GitHub's search index registers three repositories whose names contain the identifier. The defender arrives on deadline day.
The repository names contain the CVE identifier. Nothing else in any of them does.
CVE-2026-125350: Chrome's XML UAF KEV Lands Two PoCs Within Twelve Hours. One Flags Patched Users Vulnerable. The Other Describes A Chrome From February 2025. is the November repeat. The Stable Channel Update landed at 12:52 PT on November 9. The Extended Stable Update seven minutes earlier. The KEV listing the next day. The two repositories the day after that.
Chrome's release blog named the fix on November 9. The anonymous reporter had the primitive. The two authors who published on November 10 had the identifier, a template, and twelve hours.
One of the two repositories is a version checker that hardcodes the Stable release and reports Extended Stable users as vulnerable. The author read one release-blog post and did not scroll up to the one sitting above it. The name "Extended Stable" is in the same feed. The name was there. The checker did not read it.
Five repository names resolved to one working tree
CVE-2025-4609: Chrome's Mojo Sandbox Escape Resurfaces With Five PoC Repositories. One Is A 404. Four Share The Same Git History. Their Author's Own Report Says Not To Call It A Sandbox Escape. is the distribution-layer version of the same count.
The scanner counted names. The §7 counted limitations. The defender reads the louder claim and never sees the quieter one.
Five GitHub namespaces, one git working tree, two email addresses under one researcher. The researcher's own §7 Limitations says not to call it a sandbox escape until a real trigger is demonstrated. The scanner's multi-poc×3+1 reads the width of the GitHub namespace that contains the CVE identifier. The width of the name, not the depth of the artifact.
The dashboard labelled Math.random() ASLR bypassata
CVE-2026-2441: The Vulnerable Chrome Binary Is a 404, the Heap Leak Is Math.random() is where the shape goes meta.
These are not flaws in the demonstration. They are the demonstration.
The bundled chrome-linux.zip is 223 bytes of XML from Google's own commondatastorage bucket saying NoSuchKey. The author tried to download a Chromium snapshot, got a 404, and committed the 404 under the name of the binary. The dashboard labels a Math.random() integer as ASLR bypassata. The launcher starts Chrome with --disable-web-security so same-origin credential reads can proceed, and then calls them a renderer sandbox escape. The README's mitigation section tells the reader to verify Site Isolation is enabled. The launcher in the same repository turns it off.
The label on the dashboard says ASLR bypass. The bytes under the label are Math.random(). The buyer reads the label.
The charge is not against the bugs
The seven bugs in these files are real. The patches work. CVE-2026-0073 is one == 1 on the same line. CVE-2026-5865 is && elidable. CVE-2026-2441 is a type change from const FontFeatureAliases* to const FontFeatureAliases. These are correct fixes by engineers who understood the bug.
The charge is not against the KEV catalog, which rests on telemetry and not on GitHub. CISA's deadlines on CVE-2026-11645 and CVE-2026-125350 are the catalog doing its job. The release blog's acknowledgement that CVE-2026-125350 was being exploited before the patch landed is the release blog doing its job. The anonymous reporter on CVE-2026-125350 filed working exploit bytes three days before the Stable release, and Google used them to produce the fix on the cadence the Stable release allows. That is the system working.
The charge is not against the researchers. The author of the Mojo report wrote a §7 Limitations that is the clearest self-assessment in any of these files. The research is substantive. The distribution across five namespaces is a separate decision that the research itself warned against.
The charge is against the habit above the bugs, where the name gets issued and the mechanism gets left for later or for nobody. The commit message for CVE-2026-0073 names the habit out loud. OpenSSL shipped EVP_PKEY_eq in 2021 and marked EVP_PKEY_cmp discouraged. BoringSSL is Google's fork of OpenSSL. BoringSSL has not added EVP_PKEY_eq. The next AOSP module that wraps EVP_PKEY_cmp in a C truthiness is the next CVE in the family.
The next one is in a function whose parameter the body does not read
The files tell you where to look.
Every Google codebase has a function whose parameter list contains a name no caller can trust the body to honor. Maglev had elidable. TurboFan shipped the typer-over-promise class across the decade before Maglev existed. Blink's attribute iterators that hold raw pointers to containers the script can mutate mid-iteration are a family. BoringSSL still exports EVP_PKEY_cmp with its four-return-value contract and no EVP_PKEY_eq next to it.
Open the Chromium issue tracker on the day of the next Stable Channel Update. Look for a restricted issue whose fix note reads "Google is aware that an exploit for CVE-* exists in the wild." Open GitHub and search the identifier. Count the repositories. Diff the file hashes across them.
Open an AOSP module whose CHANGELOG mentions a recent BoringSSL import. Search the module for EVP_PKEY_cmp(. Read every call site. Any site that wraps the return value in if (...) or !(...) or coerces it to a bool is the next CVE in that family.
Open any Keras loader downstream of _retrieve_class_or_fn. The 3.9.0 allowlist is per-call-site, not a refactor of the deserializer. A future resolution path that reaches a Python interpreter without going through the patched function is not gated by the allowlist. The flag named safe_mode is still in the public signature and still accurate about __lambda__ and still silent about everything else.
The next advisory will say exists in the wild
The next Google advisory in this pattern is a Chrome Stable Channel Update whose release note contains the sentence Google is aware that an exploit for CVE-* exists in the wild. attached to one of the fixed CVEs. The Chromium bug ID will be restricted at the time of the release. The reporter will be anonymous or an external vendor. Within forty-eight hours of CISA adding the identifier to KEV, at least three GitHub repositories whose names contain the CVE string will be indexed by the vulnerability-intelligence pipeline as multi-poc. None of the three will demonstrate the primitive the CVE describes. At least one will be a version checker that hardcodes the Stable release and miscategorises Extended Stable. At least one will carry a sales contact in its README, as a TinyURL or a proton inbox.
You write the name and leave the mechanism to whoever reads it. That is a fucking habit, and the commit message for CVE-2026-0073 is you naming it out loud.