Google’s Claim of the First Fully Automated Exploit Pipeline Rests on One Staging Server Whose Config Calls It a “Pilot,” Its Only Code Figure Comes From the Last Spectra Release Hit by a Wordfence-Reported RCE, and the AI Campaign It Cites Reached Domain Admin at 12 of 440 Victims
GTIG’s report says it found the first fully automated exploit pipeline on an exposed staging server, but it names no CVE or victim count, its one code figure comes from Spectra 2.19.25, and the...
On November 16, Google Threat Intelligence Group (GTIG) published GTIG AI Threat Tracker: Agentic Threat Activity Crosses a Significant Threshold. Its central claim is that, for the first time, GTIG saw threat actors use an LLM framework “to fully automate vulnerability discovery and exploitation without a human in the loop.” The next day SecurityWeek ran it under the headline “AI Framework Autonomously Weaponized Flaws in Real Attacks, Google Says.”
Table Of Content
- What the report says, and what the headline made of it
- exploit_agent: what one staging server shows
- What the report shows
- What it does not show
- Figure 4 and the Spectra plugin
- What the function is
- The version is the last one named in an RCE
- What the label leaves open
- A patch stream a differential-analysis pipeline can feed on
- The PaperCut campaign GTIG cites for speed
- GTIG’s sentences against the primary records
- The clock
- What the timeline says about autonomy
- The statistics behind the n-day story
- Reading Figure 3
- A public cross-check
- Smaller mismatches with cited sources
- What defenders can take from it
- What would settle it
- Bottom line
- Run the checks yourself
- Spectra releases and NVD records
- The PaperCut clock
- Figure 3 readout
- KEV additions by month
- Sources
I read the report and its figures, then checked it against the sources it leans on: GreyNoise’s write-up of the PaperCut campaign, PaperCut’s advisory, NVD, CISA’s Known Exploited Vulnerabilities (KEV) catalog, AhnLab’s count of PHP2Shell repositories on GitHub, GTIG’s own September statistics post, and the Spectra plugin releases on WordPress.org, because the report’s only code figure comes from that plugin. The short version:
- The evidence for “without a human in the loop” is one exposed staging server. The report says the framework “is set up to” compare patched and unpatched code, draft exploits and run them. The operator’s own config comment calls it a “pilot.” The report names no CVE, no victim count, no date and no number of exploits drafted or run.
- The one code figure comes from Spectra 2.19.25, the last release named in a Wordfence-reported remote code execution flaw, but the function it shows is not the fix. Spectra has more than a million active installs and shipped 11 releases in 2026 whose changelogs mention a security fix. The function in Figure 4 is identical in all 19 releases from 2.19.18, where it first appears, to today’s 2.20.6.
- The best-documented AI exploitation campaign in the report is GreyNoise’s PaperCut case, and an operator was in the loop. It began 3 days 22 hours after PaperCut’s emergency patch, took 3 hours 54 minutes to reach its first real target, and reached domain admin at 12 of 440 victims. Its log records a permission prompt to the operator, and 20 victims sat in countries the actor’s own list excluded.
- The statistics behind the n-day story reproduce, but they count flaws, not methods. Measuring the bars of the report’s Figure 3 gives GTIG’s totals of 127 and 141 exactly, with n-days rising from 2.75 to 6.75 a month and zero-days jumping to 22 in August. GTIG’s own September post says only that it is “possible” LLMs explain the n-day rise.
- A few sentences outrun their sources. “Hundreds” of non-functional proofs of concept links to a sample of 100 repositories with 27 PoC or exploit projects, and SecurityWeek’s “most used” and “mainly Chinese-speaking groups” appear nowhere in the report.
Caveats up front. I did not run exploit_agent, any of the frameworks or any exploit. I had no PHP runtime here, so I did not test whether the check in Figure 4 can be bypassed, and nothing below says it can. I could not read the body of Huntress’s PaperCut page (plain requests got a Cloudflare challenge and the excerpt tool returned only its navigation and headings), so what it says about exploit timing rests on GTIG’s text. Figure 1 is a diagram and I read it by eye.
What the report says, and what the headline made of it
SecurityWeek’s article is a faithful summary on most points, and the report is more careful in places than the headline. The table lines up the versions.
| Point | SecurityWeek | GTIG report |
|---|---|---|
| The headline claim | “AI Framework Autonomously Weaponized Flaws in Real Attacks” | An exposed staging server hosts a multi-agent framework “dubbed exploit_agent.” It “is set up to conduct continuous differential analysis of popular web application software,” and to draft exploits and execute them “without human intervention.” |
| Frameworks in use | “Attackers are using frameworks such as Artex, Cairn, CyberStrikeAI, and PentAGI” | The executive summary lists ARTEX, CAIRN, CyberStrikeAI and PentAGI together. The body says GTIG “independently observed open source tools CAIRN and PentAGI deployed in the wild, and has seen experimentation with CyberStrikeAI and HexStrike AI.” ARTEX is “the now highly-publicized” tool, linked to Wiz’s reporting. |
| ARTEX’s standing | “Artex has emerged as the most used AI framework for threat actors, mainly Chinese-speaking groups” | No such sentence. I searched this report and GTIG’s October 30 ARTEX post for “Chinese-speaking,” “most used,” “widely used” and “prevalent.” The October post says financially motivated actors and “additional suspected PRC-nexus clusters” used it. |
| Autonomy | “For the first time, GTIG has identified threat actors using an AI framework to automate both vulnerability discovery and exploitation without human intervention.” | “fully automate vulnerability discovery and exploitation without a human in the loop for the first time.” Its Figure 1 draws a “threat actor” box feeding an orchestration agent that coordinates sub-agents. |
So “without a human in the loop” is best read as a claim about the discovery and exploitation loop, with an operator still choosing targets and supplying keys. That matches the report’s own summary of what the frameworks change: “the mechanics of the intrusions remain the same,” while speed and scale go up. Our earlier posts on ARTEX cover the CrowdStrike report on Korean financial firms, Microsoft’s Storm-0940 attribution, the FBI warning and WorkOS’s sandbox escape, and one on the Cairn panels.
exploit_agent: what one staging server shows
What the report shows
- An exposed staging server with a multi-agent framework that “integrates with multiple frontier and local LLMs.”
- A setup for continuous differential analysis: it “compares code before and after patch announcements, analyzes findings to identify potential vulnerabilities, drafts exploits, and automatically executes them without human intervention.”
- “Data exfiltrated from targeted victims,” plus scripts for post-compromise work: internal reconnaissance, brute-forcing, installing webshells and “removing other attackers’ webshells.”
- Victim telemetry suggesting interest in “French websites associated with the media and entertainment industries, as well as the education sector.”
- Table 1, two Russian comments from an environment file. GTIG’s translation of the first reads “LLM API keys for auto-exploitation (exploit_agent pilot).” The second tells whoever fills in the file to enter the keys there, “not in the chat,” and adds that both lines are required.
The word “pilot” is the operator’s own, not GTIG’s. A pilot is usually a trial run, which sits oddly beside a headline about attacks in the wild.
What it does not show
- No CVE and no confirmed flaw. Figure 4 names a plugin the framework read, not a flaw it found or used. The CVEs in the report belong to other cases: PaperCut, PHP and LiteLLM.
- No count. Not the number of victims, of exploits drafted or executed, or of exploits that worked.
- No date. The report says only that GTIG identified the framework “in the past quarter.”
- No link between the victims and the framework’s own output. The report says the server held data exfiltrated from victims and post-compromise scripts. It does not say an exploit the framework drafted was the way in for any of them.
Figure 4 and the Spectra plugin
Figure 4 is a code listing introduced by the comment “Insecure capability check analyzed in v21925.php” and captioned “Agentic framework inspecting access control implementations in the Spectra (Ultimate Addons for Gutenberg) WordPress plugin, version 2.19.25.” It is the only artifact in the report that can be checked against public code, so I downloaded Spectra from WordPress.org and looked.
What the function is
- The listing is the plugin’s function
restrict_popup_rest_accessinclasses/class-uagb-init-blocks.php. With the plugin’s own comments removed, the code is identical to the figure’s. - WordPress.org shows the plugin (slug
ultimate-addons-for-gutenberg, renamed Spectra Legacy in 2.20.0) with more than 1 million active installs. Its changelog says it “receives maintenance updates only: security fixes, WordPress and PHP compatibility, and critical bug fixes.” - The function is new in 2.19.18: its docblock says
@since 2.19.18and it is absent from 2.19.17. The 2.19.18 changelog entry, dated January 20, says that release “addressed a security bug” reported by Wordfence and Patchstack. - I hashed the function’s text in every release from 2.19.17 to 2.20.6. It is absent from 2.19.17 and identical in all 19 releases from 2.19.18 to 2.20.6, which was published on November 3.
The version is the last one named in an RCE
2.19.25, released April 27, is not a security release in its changelog, which lists right-to-left language fixes. It is, however, the last version named in CVE-2026-7465, which NVD published on May 30 with Wordfence as the CVE source and a CVSS 3.1 score of 8.8. NVD says the flaw “makes it possible for authenticated attackers, with Contributor-level access and above, to execute code on the server.” The next release, 2.19.26 on May 4, says it addressed a security bug reported by Wordfence.
Between those two releases 27 of the 701 files in the earlier zip changed, 18 of them PHP, and 11 files were added. In the file that holds the Figure 4 function, the only change is one line, in which block registration stops receiving a block’s attributes. That fits the mechanism NVD describes, a block type registered from attacker-supplied data, and it does not touch the function in the figure. I did not test it. A before-and-after comparison of this release pair is what the report’s “compares code before and after patch announcements” describes, and the pair was public from May 4. The report does not say the framework compared these two releases or found this CVE.
What the label leaves open
The report calls the function an “Insecure capability check” but does not say whether the framework was right, whether GTIG confirmed it, or whether the vendor was told. It gives no CVE. The function has shipped unchanged through the eight later releases whose changelogs mention a security fix. That could mean the label was a false positive, that the finding was never reported, or that it was judged not to be a vulnerability. The NVD records do not settle it. CVE-2026-128834, a Patchstack-sourced “Missing Authorization” record covering versions through 2.20.5, does not name a route, and since the function did not change in 2.20.6, whatever that release fixed was elsewhere. I did not try to bypass the check. That would need a WordPress install I did not have here, and it is not mine to publish.
A patch stream a differential-analysis pipeline can feed on
The report says threat actors may find it “more efficient to use LLMs to rapidly weaponize patched n-day vulnerabilities” because they can focus on “a finite set of source materials.” Spectra shows what that material looks like for one plugin. The changelog flags 11 of its 19 releases in 2026 as security fixes, on January 20, March 12, April 21, May 4, June 30, July 14, July 31, August 26, September 28, October 9 and November 3, a mean gap of 28.7 days. My two NVD keyword searches found 11 records published in 2026 that name the plugin. Mapping each to the first release after its last affected version gives this:
| CVE | Flaw (shortened) | Last affected | Fixed in (changelog date) | NVD published | Days after the fix |
|---|---|---|---|---|---|
| CVE-2026-24982 | Missing authorization | 2.19.17 | 2.19.18 (Jan 20) | Feb 3 | 14 |
| CVE-2026-0950 | Information disclosure | 2.19.17 | 2.19.18 (Jan 20) | Feb 3 | 14 |
| CVE-2026-42648 | Missing authorization | 2.19.22 | 2.19.23 (Apr 21) | Apr 29 | 8 |
| CVE-2026-7465 | Code execution, Contributor and above | 2.19.25 | 2.19.26 (May 4) | May 30 | 26 |
| CVE-2026-12900 | Stored XSS, image block | 2.19.28 | 2.19.29 (Jun 30) | Jul 20 | 20 |
| CVE-2026-16302 | Sensitive information exposure | 2.20.0 | 2.20.1 (Jul 31) | Sep 24 | 55 |
| CVE-2026-92294 | Limited file deletion | 2.20.4 | 2.20.5 (Oct 9) | Oct 31 | 22 |
| CVE-2026-119520 | Stored XSS | 2.20.4 | 2.20.5 (Oct 9) | Nov 7 | 29 |
| CVE-2026-128834 | Missing authorization | 2.20.5 | 2.20.6 (Nov 3) | Nov 13 | 10 |
| CVE-2026-125800 | Stored XSS | 2.20.5 | 2.20.6 (Nov 3) | Nov 13 | 10 |
| CVE-2026-125802 | Sensitive information in sent data | 2.20.5 | 2.20.6 (Nov 3) | Nov 13 | 10 |
Each record trailed its fix by 8 to 55 days, a median of 14. The “fixed in” column is my inference (the first release after the last affected version), and all seven releases it names are flagged as security fixes in the changelog. During those days, anyone relying on NVD for details had less to go on than anyone running a diff against the release. That is the report’s point about patches, shown in one plugin with public data. It is also a reason to read the Spectra rows as evidence about patch cadence, not about exploit_agent.
The PaperCut campaign GTIG cites for speed
Much of the report’s support for fast, automated exploitation comes from outside GTIG’s own telemetry. It says threat actors exploited two PaperCut flaws “as zero-days,” that “security researchers and the cybersecurity company Huntress generated working exploits for the vulnerabilities within a day of disclosure,” and that GreyNoise reported a campaign four days after disclosure in which an actor “likely used LLMs to build and test exploits” and “expanded an initial foothold to domain administrator within minutes.” GreyNoise’s September 9 report is the primary source, and it is more definite than GTIG’s summary in places.
GTIG’s sentences against the primary records
| GTIG says | The primary records say |
|---|---|
| The actor “likely used LLMs” | GreyNoise states it flatly: the actor “used hundreds of AI Agents powered by OpenAI’s Codex (harness), a DeepSeek model (not OpenAI models), and various publicly available offensive security tools” against “at least 440 instances of PaperCut MF/NG hosted by 395 identified victim organizations in 48 countries.” The harness and model are named, with timestamps. |
| Domain admin “within minutes” | “Where domain admin was achieved, the adversary’s fastest time was five minutes and the longest time was 144 minutes.” GreyNoise’s tally has domain admin at “only 12 victim organizations,” out of 440 victims in its country table: 280 with credential harvesting, 147 with OS or domain secrets, 12 with domain admin (2.7%). |
| “Four days after the initial disclosure” | Matches. PaperCut’s emergency patch is dated 02:10 on August 28 in its bulletin’s Australian time, which is 16:10 UTC on August 27. GreyNoise’s workspace starts at 14:44:55 UTC on August 31, 3 days 22 hours 34 minutes later. |
| Exploited “as zero-days” | Fits the vendor record. PaperCut’s bulletin says “We are aware of confirmed customer incidents,” and Rapid7’s Metasploit pull request is titled “Add exploit module for the recent PaperCut MF/NG 0day.” The GreyNoise campaign itself came after the patch: the actor downloaded the advisory and “pre- and post-patch versions of the software.” Both are right about different phases. |
The clock
Every timestamp below comes from the source named in the script near the end of this post. NVD has both CVEs published on August 28, and CISA’s KEV catalog lists both with an added date of August 31, due September 14. The timeline, offset from the actor’s workspace start:
| Event (UTC) | Offset |
|---|---|
| Aug 27, 16:10: PaperCut emergency patch | 3 d 22 h 34 m before |
| Aug 28, 16:18: NVD publishes both CVEs | 2 d 22 h 26 m before |
| Aug 28, 20:36: Metasploit pull request 21842 opened | 2 d 18 h 08 m before |
| Aug 31, 14:44: workspace created, advisory and both versions downloaded | start |
| Aug 31, 15:54: versions diffed, exploits developed | +1 h 09 m |
| Aug 31, 16:04: operator prompted for permission to continue | +1 h 19 m |
| Aug 31, 18:39: first remote code execution on a real target | +3 h 54 m |
| Aug 31, 21:00: domain admin validated at that target | +6 h 15 m |
| Sep 1, 08:30: agents launch the campaign | +17 h 45 m |
| Sep 2, 15:45: last remote code execution of Sep 2 | +2 d 01 h 00 m |
What the timeline says about autonomy
- An operator was in the loop. GreyNoise’s log has “MCA is prompted for permission to continue” (MCA is its term for the malicious cyber actor) 1 hour 19 minutes in, so the harness stopped to ask. GreyNoise does not say how the actor answered. The next morning the log has “Agents launch the campaign via a second execution host,” with hundreds of SSH sessions, “11 organizations in 26 seconds” and 78 in the first hour.
- Public exploit code already existed. The Metasploit pull request was opened 2 days 18 hours before the actor’s workspace, and GreyNoise says the actor “searches the internet for public proofs of concept and exploits.” What the agents added is speed and breadth, and how much was original work is not something the log settles.
- The agents went past the operator’s own list. The actor kept a list of 28 countries to avoid. GreyNoise says its “observed victimology shows the attempted restraint failed in some instances.” By my count from its country table, 20 of the 440 victims were in 8 of those 28 countries (South Africa 9, Brazil 5, and one each in China, Kazakhstan, Namibia, Nigeria, Pakistan and Zimbabwe), and one of the 12 domain admin compromises was in South Africa.
- Most intrusions stalled short of domain admin. GreyNoise found three routes to it: LSASS memory and registry secrets with pass-the-hash, the noPac attack where a host lacked the fixes for CVE-2021-42278 and CVE-2021-42287, and a PaperCut host on a domain controller or running as a domain-admin service account. It also records a case where “Cloudflare’s Web Application Firewall (WAF) defeated the adversary.”
GreyNoise’s own takeaway is that “unless properly constrained, agentic operations can deviate from expected behavior and pose operational risk.” That is the strongest public evidence in the report of AI-run exploitation, and it is evidence of speed, breadth and drift, with an operator, rather than of a pipeline that runs alone.
The statistics behind the n-day story
The report’s Figure 3 comes from GTIG’s September post, which concludes that growth in exploitation has been “concentrated in the rapid weaponization of n-days.” Its numbers: disclosures rose from 5,045 in January 2026 to 10,477 in July and 10,740 in August, but “approximately 5,000” of the CVEs disclosed from January to August were Linux kernel ones, and “roughly 1 in 431” disclosed flaws was exploited. Exploited flaws numbered 127 in 2025 and 141 from January to August 2026, with zero-days going from 8 a month to 11, and to 22 in August.
Reading Figure 3
The chart has no data labels. I measured each bar segment in pixels and set the scale from one printed number, 22 zero-days in August 2026. That also reproduces the totals GTIG gives elsewhere: 127 for 2025 and 141 for 2026, the “11 per month” (87 over 8 months is 10.9) and the 62% zero-day share (87 of 141 is 61.7%). The printed axis labels sit about 5% off the bars’ own scale, so read against them August’s zero-day bar comes out at 23, not 22, and I did not use them.
| 2026 | Zero-days | N-days | Total |
|---|---|---|---|
| January | 5 | 2 | 7 |
| February | 12 | 3 | 15 |
| March | 6 | 4 | 10 |
| April | 9 | 6 | 15 |
| May | 12 | 7 | 19 |
| June | 12 | 12 | 24 |
| July | 9 | 13 | 22 |
| August | 22 | 7 | 29 |
| January to August | 87 | 54 | 141 |
| All of 2025 | 94 | 33 | 127 |
N-days rose from 2.75 a month in 2025 to 6.75 in 2026, peaking at 12 and 13 in June and July and falling to 7 in August, when zero-days jumped to 22. Through July, n-days account for 73% of the rise in the monthly average (my arithmetic: 3.96 of 5.42 a month). Counting August, they account for 57%. That supports GTIG’s reading that growth was concentrated in n-days for most of the year. It cannot show why. The September post words the AI link as a possibility: “It is possible that threat actors are finding it more accessible or efficient to use LLMs and AI tools to automate analysis of differences between product versions, patches, vulnerability disclosure announcements, and Proof-of-Concept (POC) code to rapidly weaponize n-days, rather than to discover new zero-days.” The November report states the same idea as a trend in its executive summary, with no new count of how many of the 54 n-days were weaponized with an LLM. It also compresses two comparisons into “nearly doubled between January and August 2026”: disclosures went 2.13 times from January to August, while exploited flaws went from a 2025 average of 10.6 a month to 17.6, or 1.67 times.
A public cross-check
CISA’s KEV catalog is not GTIG’s dataset. It counts the day CISA listed a flaw, not the day exploitation began, and it does not split zero-days from n-days. It does give a public series for direction:
| Period | KEV additions a month |
|---|---|
| 2025 (12 months) | 20.4 |
| January to August 2026 | 25.4 |
| January 2026, then August 2026 | 17, then 31 (1.82 times) |
| September and October 2026 | 43 and 36 (mean 39.5) |
The direction agrees with GTIG’s, and the two months after the report’s data window are the highest in the 22-month series.
Smaller mismatches with cited sources
| The report says | The cited source says |
|---|---|
| After the PHP patch, “hundreds of claimed but non-functional POCs, likely generated with the help of LLMs, were published” (the word “hundreds” links to AhnLab) | AhnLab analyzed the top 100 GitHub results for “php2shell” as of 1:30 p.m. on October 22. Of those, 99 were related to the two CVEs and 27 were PoC or exploit repositories. It found “conflicting claims about whether the published attack PoCs actually worked”: two repositories claimed remote code execution, one reproduced only internal state corruption and one reported an unsuccessful attempt. The article’s only mention of AI is one repository whose description says the tool was created using AI and is not guaranteed to work, in a paragraph about vulnerability-response tools. It does not attribute the PoCs to LLMs. Our PHP2Shell post covers the release. |
| Huntress, with researchers, “generated working exploits for the vulnerabilities within a day of disclosure” | I could not read Huntress’s page. PaperCut’s bulletin thanks Huntress and watchTowr on August 28, 20:42 Australian time (10:42 UTC), for security analysis that helped harden its second emergency release. That is consistent with fast analysis. It is not the claim. |
| CVE-2026-40217 is “a sandbox escape in LiteLLM that allows an attacker to elevate limited-access inference keys” into full administrative credentials | NVD: LiteLLM “allows remote attackers to execute arbitrary code via bytecode rewriting at the /guardrails/test_custom_code URI,” CVSS 3.1 8.8 with low privileges required. It is not in the KEV catalog as of November 17, although GTIG saw it exploited during an incident response. Our LiteLLM post covers a different incident. |
What defenders can take from it
- Plan for hours on internet-facing software. GreyNoise’s actor started 3 days 22 hours after PaperCut’s patch and had a shell on a real target 3 hours 54 minutes later. When a vendor’s advisory says customers are already compromised, the window has closed.
- Treat the release as the advisory. A plugin that ships a security fix every four weeks hands anyone with a diff tool a new target every four weeks, and Spectra is one of thousands. Turn on automatic security updates for plugins you cannot monitor, and remove the ones you no longer use. Spectra Legacy is maintenance-only by its own changelog, so check whether you still need it.
- Take the exposure out. PaperCut’s mitigation was to “restrict web access to your Application Server to trusted addresses only,” and a WAF stopped at least one of the agents’ attempts.
- Harden the domain controllers the agents head for. Patch the noPac pair, protect LSASS, and do not run application services as domain admin. GreyNoise saw all three gaps used.
- Expect a proof-of-concept flood. AhnLab’s sample had 27 PoC or exploit projects with conflicting reports of whether they worked, and mitigation scripts that run as root. Run public code only in a lab.
What would settle it
- A CVE, product or vendor for at least one flaw exploit_agent found or used.
- How many victims were reached with an exploit the framework drafted, and how many exploits it drafted or ran.
- The dates of the staging server’s discovery and of the Spectra analysis, and whether the vendor was told about the Figure 4 finding.
- How GTIG established “without human intervention”: run logs of the framework acting without operator input, or only its configuration.
Bottom line
The report is a useful catalog of how attackers are using agents, and its strongest evidence comes from other firms’ primary reporting. The claim of a first fully automated exploit pipeline rests on one server that its own config calls a pilot. The n-day growth is real in the data and unattributed. The PaperCut campaign shows what AI-run exploitation looks like at scale: fast, broad, error-prone and run by an operator. For defenders the practical lesson is older than the framework: the patch is public the moment it ships.
Run the checks yourself
Four short scripts reproduce the numbers above from public data. All need Python 3.10 or newer; the first and fourth need pip install requests pillow and the others use the standard library. Outputs are from November 17, 2026, and will drift as NVD, KEV and the plugin change.
Spectra releases and NVD records
This script parses the changelog and the NVD records that name the plugin, then pairs each record with the first release after its last affected version. NVD’s public API allows five requests every 30 seconds, so it pauses between calls.
# spectra_cves.py
"""spectra_cves.py: line up Spectra's security-flagged releases with NVD records.
Reads the plugin changelog from the WordPress.org API and the NVD records that
name the plugin, then prints, for every 2026 CVE, the last affected version,
the first release after it, that release's date and the days until NVD
published the record. Needs: pip install requests (Python 3.10 or newer)
"""
import html
import re
import time
from datetime import date, datetime
import requests
SLUG = "ultimate-addons-for-gutenberg"
INFO = f"https://api.wordpress.org/plugins/info/1.0/{SLUG}.json"
NVD = "https://services.nvd.nist.gov/rest/json/cves/2.0"
HEAD = {"User-Agent": "Mozilla/5.0 (research script)"}
def vkey(v):
return tuple(int(x) for x in v.split("."))
def releases():
"""Yield (version, date, flagged_as_security) from the changelog text."""
raw = requests.get(INFO, headers=HEAD, timeout=40).json()["sections"]["changelog"]
text = html.unescape(re.sub(r"\s+", " ", re.sub(r"<[^>]+>", " ", raw)))
out = {}
for chunk in re.split(r"(?=\b2\.\d+\.\d+ \W )", text):
m = re.match(r"(2\.\d+\.\d+) \W \w+day, (\d+)\w* (\w+) (\d{4})(.*)", chunk)
if m:
day = datetime.strptime(f"{m.group(2)} {m.group(3)} {m.group(4)}", "%d %B %Y").date()
out[m.group(1)] = (day, "security bug" in m.group(5))
return out
def nvd_records():
found = {}
for word in ("ultimate-addons-for-gutenberg", "Spectra Gutenberg Blocks"):
r = requests.get(NVD, params={"keywordSearch": word, "resultsPerPage": 200}, headers=HEAD, timeout=60)
for item in r.json()["vulnerabilities"]:
cve = item["cve"]
text = next(d["value"] for d in cve["descriptions"] if d["lang"] == "en")
if re.search(r"gutenberg|spectra", text, re.I) and cve["published"].startswith("2026"):
found[cve["id"]] = (cve["published"][:10], text)
time.sleep(7) # the public NVD API allows 5 requests per 30 seconds
return found
def main():
rel = releases()
in_2026 = {v: x for v, x in rel.items() if x[0].year == 2026}
flagged = sorted((x[0], v) for v, x in in_2026.items() if x[1])
gaps = [(b[0] - a[0]).days for a, b in zip(flagged, flagged[1:])]
print(f"2026 releases: {len(in_2026)}, flagged as security fixes: {len(flagged)}")
print(f"first {flagged[0][0]} last {flagged[-1][0]} mean gap {sum(gaps) / len(gaps):.1f} days")
print()
print(f"{'CVE':<16}{'NVD date':<12}{'through':<9}{'fixed in':<9}{'released':<12}{'lag'}")
order = sorted(rel, key=vkey)
for cve, (published, text) in sorted(nvd_records().items(), key=lambda kv: kv[1][0]):
m = re.search(r"(?:up to,? and including,?|through|<=)\s*(\d+\.\d+\.\d+)", text)
if not m:
print(f"{cve:<16}{published:<12}(no version in the description)")
continue
last_bad = m.group(1)
nxt = next((v for v in order if vkey(v) > vkey(last_bad)), None)
if nxt is None:
print(f"{cve:<16}{published:<12}{last_bad:<9}(no later release)")
continue
when = rel[nxt][0]
lag = (date.fromisoformat(published) - when).days
print(f"{cve:<16}{published:<12}{last_bad:<9}{nxt:<9}{when!s:<12}{lag:+d} days")
main()
Output:
2026 releases: 19, flagged as security fixes: 11
first 2026-01-20 last 2026-11-03 mean gap 28.7 days
CVE NVD date through fixed in released lag
CVE-2026-24982 2026-02-03 2.19.17 2.19.18 2026-01-20 +14 days
CVE-2026-0950 2026-02-03 2.19.17 2.19.18 2026-01-20 +14 days
CVE-2026-42648 2026-04-29 2.19.22 2.19.23 2026-04-21 +8 days
CVE-2026-7465 2026-05-30 2.19.25 2.19.26 2026-05-04 +26 days
CVE-2026-12900 2026-07-20 2.19.28 2.19.29 2026-06-30 +20 days
CVE-2026-16302 2026-09-24 2.20.0 2.20.1 2026-07-31 +55 days
CVE-2026-92294 2026-10-31 2.20.4 2.20.5 2026-10-09 +22 days
CVE-2026-119520 2026-11-07 2.20.4 2.20.5 2026-10-09 +29 days
CVE-2026-128834 2026-11-13 2.20.5 2.20.6 2026-11-03 +10 days
CVE-2026-125800 2026-11-13 2.20.5 2.20.6 2026-11-03 +10 days
CVE-2026-125802 2026-11-13 2.20.5 2.20.6 2026-11-03 +10 days
The PaperCut clock
The timestamps are copied from PaperCut’s bulletin (converted from UTC+10), the GitHub API record of the Metasploit pull request, NVD, and GreyNoise’s timeline, which prints some times rounded.
# papercut_clock.py
"""papercut_clock.py: the PaperCut timeline from three public sources, in UTC.
Standard library only. Each timestamp is copied from the source named beside
it. PaperCut's bulletin uses Australian Eastern Standard Time (UTC+10), and
GreyNoise prints some of its times rounded (21:00:00, 08:30:00).
"""
from datetime import datetime, timedelta, timezone
def t(text):
return datetime.strptime(text, "%Y-%m-%d %H:%M:%S").replace(tzinfo=timezone.utc)
EVENTS = [
("PaperCut emergency patch (bulletin: 28 Aug 02:10 AEST)", t("2026-08-27 16:10:00")),
("NVD publishes CVE-2026-81578 and CVE-2026-82078", t("2026-08-28 16:18:29")),
("Metasploit pull request 21842 opened (GitHub API)", t("2026-08-28 20:36:31")),
("GreyNoise: workspace created, advisory and both versions downloaded", t("2026-08-31 14:44:55")),
("GreyNoise: versions diffed, exploits developed", t("2026-08-31 15:54:53")),
("GreyNoise: operator prompted for permission to continue", t("2026-08-31 16:04:42")),
("GreyNoise: first remote code execution on a real target", t("2026-08-31 18:39:39")),
("GreyNoise: domain admin validated at that target", t("2026-08-31 21:00:00")),
("GreyNoise: agents launch the campaign", t("2026-09-01 08:30:00")),
("GreyNoise: last remote code execution of Sep 2", t("2026-09-02 15:45:35")),
]
start = EVENTS[3][1]
print("offset from the GreyNoise workspace start")
for name, when in EVENTS:
delta = when - start
sign = "-" if delta < timedelta(0) else "+"
s = int(abs(delta).total_seconds())
print(f"{when:%b %d %H:%M:%S} {sign}{s // 86400}d {s % 86400 // 3600:02d}h {s % 3600 // 60:02d}m {name}")
Output:
offset from the GreyNoise workspace start
Aug 27 16:10:00 -3d 22h 34m PaperCut emergency patch (bulletin: 28 Aug 02:10 AEST)
Aug 28 16:18:29 -2d 22h 26m NVD publishes CVE-2026-81578 and CVE-2026-82078
Aug 28 20:36:31 -2d 18h 08m Metasploit pull request 21842 opened (GitHub API)
Aug 31 14:44:55 +0d 00h 00m GreyNoise: workspace created, advisory and both versions downloaded
Aug 31 15:54:53 +0d 01h 09m GreyNoise: versions diffed, exploits developed
Aug 31 16:04:42 +0d 01h 19m GreyNoise: operator prompted for permission to continue
Aug 31 18:39:39 +0d 03h 54m GreyNoise: first remote code execution on a real target
Aug 31 21:00:00 +0d 06h 15m GreyNoise: domain admin validated at that target
Sep 01 08:30:00 +0d 17h 45m GreyNoise: agents launch the campaign
Sep 02 15:45:35 +2d 01h 00m GreyNoise: last remote code execution of Sep 2
Figure 3 readout
The script measures the bars of the report’s chart. It sets the scale from the printed August count and checks the result against the 127 and 141 totals, which it does not use. The pixel constants fit the 2,000 by 1,080 image served on November 17, and the script prints a hash of the file it read.
# fig3_readout.py
"""fig3_readout.py: read the bar heights of GTIG's "vulnerabilities exploited per month" chart.
Needs: pip install requests pillow
The bars carry no data labels, so each segment is measured in pixels. The scale
is set from one number the report prints (22 zero-days in August 2026) and then
checked against two totals it does not print next to the chart (127 for 2025 and
141 for January to August 2026, from GTIG's September post).
"""
import hashlib
import io
import requests
from PIL import Image
URL = ("https://storage.googleapis.com/gweb-cloudblog-publish/images/"
"Figure_3_Count_of_vulnerabilities_exploite.max-2000x2000.jpg")
raw = requests.get(URL, timeout=60).content
img = Image.open(io.BytesIO(raw)).convert("RGB")
print("image", img.size, "sha256", hashlib.sha256(raw).hexdigest()[:16])
BASELINE = 907 # pixel row where the bars start
CENTRES = [182 + 88 * i for i in range(12)] + [1264 + 88 * i for i in range(8)]
LABELS = [f"2025-{m:02d}" for m in range(1, 13)] + [f"2026-{m:02d}" for m in range(1, 9)]
def kind(pixel):
r, g, b = pixel
if r > 228 and g > 232 and b > 238:
return "empty"
if r > 140 and g > 190 and b > 225:
return "n-day"
if b > 150 and r < 140:
return "zero-day"
return "other"
def segment_tops(x):
"""Pixel rows where the zero-day (dark) part and the whole bar end."""
column = [(y, kind(img.getpixel((x, y)))) for y in range(BASELINE - 2, 270, -1)]
dark_top = next(y for i, (y, _) in enumerate(column)
if all(k != "zero-day" for _, k in column[i:i + 4]))
top = next((y for i, (y, _) in enumerate(column)
if y < dark_top and all(k == "empty" for _, k in column[i:i + 6])), dark_top)
return dark_top, top
heights = {}
for label, x in zip(LABELS, CENTRES):
dark_top, top = segment_tops(x)
heights[label] = (BASELINE - dark_top, BASELINE - top)
unit = heights["2026-08"][0] / 22 # pixels per vulnerability
print(f"scale {unit:.2f} px per vulnerability (from 22 zero-days in August 2026)")
print("month zero-day n-day total")
rows = {}
for label, (zero_px, top_px) in heights.items():
zero = round(zero_px / unit)
total = round(top_px / unit)
rows[label] = (zero, total - zero, total)
print(f"{label} {zero:8d} {total - zero:5d} {total:5d}")
for name, keys in (("2025", [k for k in rows if k.startswith("2025")]),
("2026 Jan-Aug", [k for k in rows if k.startswith("2026")])):
zero = sum(rows[k][0] for k in keys)
nday = sum(rows[k][1] for k in keys)
print(f"{name}: zero-days {zero}, n-days {nday}, total {zero + nday}, per month {(zero + nday) / len(keys):.1f}")
Output:
image (2000, 1080) sha256 ea2a4a4a0bbc7658
scale 20.73 px per vulnerability (from 22 zero-days in August 2026)
month zero-day n-day total
2025-01 9 2 11
2025-02 8 4 12
2025-03 14 3 17
2025-04 11 4 15
2025-05 9 3 12
2025-06 6 4 10
2025-07 6 5 11
2025-08 5 0 5
2025-09 9 2 11
2025-10 6 3 9
2025-11 3 0 3
2025-12 8 3 11
2026-01 5 2 7
2026-02 12 3 15
2026-03 6 4 10
2026-04 9 6 15
2026-05 12 7 19
2026-06 12 12 24
2026-07 9 13 22
2026-08 22 7 29
2025: zero-days 94, n-days 33, total 127, per month 10.6
2026 Jan-Aug: zero-days 87, n-days 54, total 141, per month 17.6
KEV additions by month
# kev_months.py
"""kev_months.py: CISA KEV additions per month, a public proxy for exploitation trends.
Standard library only. It counts dateAdded, the day CISA listed a flaw,
which is not the day exploitation began.
"""
import json
import urllib.request
from collections import Counter
URL = "https://www.cisa.gov/sites/default/files/feeds/known_exploited_vulnerabilities.json"
request = urllib.request.Request(URL, headers={"User-Agent": "Mozilla/5.0 (research script)"})
feed = json.load(urllib.request.urlopen(request, timeout=60))
months = Counter(v["dateAdded"][:7] for v in feed["vulnerabilities"])
y25 = [months[f"2025-{m:02d}"] for m in range(1, 13)]
y26 = [months[f"2026-{m:02d}"] for m in range(1, 11)]
print("catalog", feed["catalogVersion"], "entries", feed["count"])
print("2025 by month ", y25, "mean", round(sum(y25) / 12, 1))
print("2026 Jan-Aug ", y26[:8], "mean", round(sum(y26[:8]) / 8, 1))
print("2026 Sep, Oct ", y26[8:], "mean", round(sum(y26[8:]) / 2, 1))
print("Aug 2026 over Jan 2026:", round(y26[7] / y26[0], 2))
Output:
catalog 2026.11.17 entries 1782
2025 by month [14, 27, 32, 15, 24, 20, 20, 15, 16, 31, 11, 20] mean 20.4
2026 Jan-Aug [17, 28, 26, 31, 21, 23, 26, 31] mean 25.4
2026 Sep, Oct [43, 36] mean 39.5
Aug 2026 over Jan 2026: 1.82
Sources
- GTIG: AI Threat Tracker, November 16, its Figure 3 image, the September statistics post and the October 30 ARTEX post
- SecurityWeek, November 17
- GreyNoise, Agents Gone Wild: An AI-Orchestrated Global Campaign Against PaperCut NG/MF and PaperCut’s security bulletin of 27 August 2026
- NVD: CVE-2026-81578, CVE-2026-82078, CVE-2026-7465, CVE-2026-128834 and CVE-2026-40217; the CISA KEV feed
- Rapid7 Metasploit pull request 21842
- Spectra Legacy on WordPress.org, its plugin API record and release zips such as 2.19.25
- AhnLab on GitHub repositories after the PHP disclosure and Huntress on PaperCut (body not read)








No Comment! Be the first one.