Skip to navigation

Threat reportVulnerabilityTL-2026-2926

Google's PageBreak AI Agent Finds 500+ Verified XSS Flaws and Builds Working Exploit Chains

mediumMONITORING

Google's Product Security team disclosed PageBreak, an internal Gemini-based security agent that found over 500 verified cross-site scripting (XSS) vulnerabilities in Google first-party web applications by confirming each suspected flaw with a working exploit against a live environment. It also assembled working exploit chains: cache poisoning on apis.google.com, an XSS in the admin.google.com console, and arbitrary JavaScript execution via the Tag Assistant Extension.

Key facts

IdentifiersTL-2026-2926
Also known asPageBreak, Google PageBreak project
SeverityMEDIUM
Affected productsGoogle Google first-party web applications (including apis.google.com and the admin.google.com console); Google Tag Assistant Extension (Chrome)
Weaknesses (CWE)CWE-79, CWE-601, CWE-349, CWE-346
ToolsCodeMender, Gemini 3.1 Pro, Gemini 3.5 Flash, PageBreak, Tag Assistant Extension
MITRE ATT&CK techniquesT1059.007 JavaScript, T1176 Software Extensions, T1185 Browser Session Hijacking, T1190 Exploit Public-Facing Application, T1539 Steal Web Session Cookie, T1659 Content Injection
MotivationUNKNOWN
Target sectorstechnology, cloud-services, enterprise-software
Target regionsGlobal
Detection rules9 (1 shown free)
Sources8 cited sources

Detection coverage

As of 2026-10-05, Threadlinqs Intelligence publishes 9 detection rule(s) for TL-2026-2926 across Splunk SPL, Microsoft KQL and Sigma, covering 11 indicator(s) of compromise. The whole corpus is readable without an account. Every threat comes with one complete detection in Splunk SPL, Microsoft KQL and Sigma, free for everyone; a free account adds daily TL Creds to unlock the rest. Paid plans add a larger daily allowance, correlation and the MCP server. Threadlinqs MCP server · View plans.

Free detection: PageBreak Chain — Dangerous URI Scheme in Redirect Parameter on admin.google.com autodns Endpoints

Detects javascript:, data: or vbscript: URIs supplied in redirect_uri-style parameters of requests to the /a/autodns/ endpoints of the Google admin console. PageBreak's admin.google.com chain assigned an unverified redirect_uri to window.location on /a/autodns/registrar and defeated the signature check with a javascript: URI. Google fixed the flaw, so this fires on residual probing, copy-cat exploitation of the same sink pattern, or a user being lured to a crafted link; run it against web-proxy telemetry for your users and the same logic against your own redirect handlers.

  • Languages: Splunk SPL, Microsoft KQL, Sigma
  • ATT&CK: T1190, T1059.007, T1566.002
  • Data sources: web_proxy, pan:url, zscalernss-web, CommonSecurityLog
  • Severity: medium
  • Confidence: medium

Splunk SPL

```PageBreak admin.google.com autodns: non-http(s) scheme in a redirect parameter (T1190 / T1059.007 / T1566.002)```
index=proxy sourcetype IN ("pan:url","zscalernss-web","bluecoat:proxysg:access:syslog") url="*/a/autodns/*"
| eval url_decoded=lower(urldecode(urldecode(url)))
| rex field=url_decoded "(?:redirect_uri|redirect|continue|return_to|next)=\s*(?<scheme>javascript|data|vbscript):"
| where isnotnull(scheme)
| stats count min(_time) as first_seen max(_time) as last_seen values(url) as urls values(scheme) as schemes by src user dest
| convert ctime(first_seen) ctime(last_seen)

Microsoft KQL

// PageBreak admin.google.com autodns: non-http(s) scheme in a redirect parameter (T1190 / T1059.007)
let lookback = 24h;
CommonSecurityLog
| where TimeGenerated > ago(lookback)
| where RequestURL contains "/a/autodns/"
| extend UrlDecoded = tolower(url_decode(url_decode(tostring(RequestURL))))
| where UrlDecoded matches regex @'(redirect_uri|redirect|continue|return_to|next)=\s*(javascript|data|vbscript):'
| extend Scheme = extract(@'(?:redirect_uri|redirect|continue|return_to|next)=\s*([a-z]+):', 1, UrlDecoded)
| summarize Requests = count(), FirstSeen = min(TimeGenerated), LastSeen = max(TimeGenerated), Urls = make_set(RequestURL, 10) by SourceIP, SourceUserName, DeviceVendor, Scheme
| project FirstSeen, LastSeen, SourceIP, SourceUserName, Scheme, Requests, Urls, DeviceVendor

Sigma

title: Dangerous URI Scheme in redirect_uri on Google Admin autodns Endpoints
id: 3b6f1c0e-8a4d-4e52-9f17-2c5d7a90b6e1
status: experimental
description: Detects javascript:, data: or vbscript: URIs in the redirect_uri parameter of /a/autodns/ requests, the sink class abused in the PageBreak admin.google.com XSS chain.
references:
  - https://blog.google/security/agentic-hacks-real-proofs-inside-googles-pagebreak-project/
  - https://bughunters.google.com/blog/pagebreak-real-world-findings
author: Threadlinqs Team
date: 2026/10/05
tags:
  - attack.initial-access
  - attack.t1190
  - attack.execution
  - attack.t1059.007
  - attack.t1566.002
logsource:
  category: proxy
detection:
  selection_endpoint:
    c-uri|contains: '/a/autodns/'
  selection_scheme:
    c-uri|contains:
      - 'redirect_uri=javascript:'
      - 'redirect_uri=javascript%3a'
      - 'redirect_uri=javascript%253a'
      - 'redirect_uri=data:'
      - 'redirect_uri=data%3a'
      - 'redirect_uri=vbscript:'
      - 'redirect_uri=vbscript%3a'
  condition: selection_endpoint and selection_scheme
falsepositives:
  - Authorised web-application security testing against Google Workspace tenants
level: high

Known false positives:

  • Authorised penetration tests or bug-bounty researchers probing the Google admin console
  • Security scanners replaying XSS corpora through the corporate proxy

Tuning notes: Field names (url, src, user, dest; RequestURL, SourceUserName) assume CIM / CEF normalisation; map them to your proxy sourcetype. Requires TLS inspection to see full URLs. Add your own redirect parameter names to the alternation and allowlist scanner source IPs.

8 more detection rules (Splunk SPL, Microsoft KQL, Sigma) · unlock with TL Creds. Sign up free to unlock the detection rules or query them with the Threadlinqs MCP server (Purple and Gold in full, 2 calls a day on a free account)
  • PageBreak Chain — Cache-Poisoning Probes Against [indicator] Script Paths · unlock with TL Creds
  • PageBreak Follow-On — Browser Extension Profile Modified by Non-Browser Process · unlock with TL Creds
  • PageBreak Follow-On — Entra Session Used from Multiple IPs and Countries Within One Hour · unlock with TL Creds
  • PageBreak Chain — XSS Payload Markers in Requests to Google Admin, API and Tag Assistant Hosts · unlock with TL Creds
  • PageBreak Follow-On — Chromium Browser Launched with Unpacked Extension Flags · unlock with TL Creds
  • PageBreak Follow-On — Browser Launched with data: or javascript: URL on the Command Line · unlock with TL Creds
  • PageBreak Chain — autodns authorize Signing Abuse Followed by registrar Redirect · unlock with TL Creds
  • PageBreak Follow-On — Google Session Cookie Exfiltration from Google Admin or API Page Context · unlock with TL Creds

Indicators of compromise

As of 2026-10-05, Threadlinqs Intelligence tracks 11 indicators of compromise for TL-2026-2926.

Sample indicators (2 of 11)

  • Domain: apis[.]google[.]com
  • Domain: admin[.]google[.]com

Defanged, TLP:CLEAR. Full set of 11 indicators: unlock with TL Creds.

11 indicators of compromise · unlock with TL Creds. Compare plans

Technical analysis

No in-the-wild exploitation is reported.

PageBreak is an internal AI agent built by Google's Product Security team to test Google's first-party web applications. It began as a pilot in November 2025 and became a full project in January 2026. Google disclosed it publicly on 2026-09-24 (blog post 'Agentic hacks, real proofs: inside Google's PageBreak project' on blog.google, attributed in press coverage to Michał Bentkowski, plus a Bug Hunters post, 'Google's PageBreak Project', covering real-world findings). Most scans use Gemini models, including Gemini 3.1 Pro and Gemini 3.5 Flash, though the agent can work with other models.

The design priority is deterministic validation. The agent forms hypotheses from code and traffic, then hands each one to a separate, human-written, non-AI validator that tries to exploit it in a live running copy of the application. The XSS validator injects a specific JavaScript payload and uses a rendering harness to check whether the script actually executes. Validators also exist for SQL injection (output and timing changes), path traversal (planted readable files), remote code execution (sleep delays, file writes, DNS/HTTP callbacks) and SSRF (requests reaching internal services). Unverified findings are not sent to product teams as confirmed bugs; they feed later scans and validator development. Google credits its mono-repo, its Security Signals data that maps live HTTP paths to source code, and an existing scanner with credentials to nearly all Google applications. The result is over 500 verified XSS vulnerabilities and a near-zero false-positive rate. Google did not name most affected applications or give a severity breakdown.

Three exploit chains were described. (1) Cache poisoning on apis.google.com: an unchecked URL path segment was reflected into a returned JavaScript file but excluded from the cache key, so a poisoned response could be served to other visitors in the same region, including external sites loading that script. (2) Admin console XSS on admin.google.com: the /a/autodns/registrar endpoint assigned an unverified redirect_uri value to window.location, which a cryptographic signature check initially protected. PageBreak found a separate endpoint, /a/autodns/authorize, that would compute a valid signature for a malicious javascript: URI, which defeated the protection. (3) Tag Assistant Extension universal XSS: weak validation of external connections, recovery of a one-time nonce and unsafe message forwarding let attacker-controlled script content reach the page being debugged, and support for data: URLs allowed arbitrary JavaScript execution.

Applications built on Google's high-assurance (secure-by-design) web frameworks showed only 2 XSS issues across hundreds of applications as of 2026-09-04, both in internal apps or debug endpoints. Google plans to pair PageBreak with CodeMender, its automated fix-generation agent, so that product teams validate proposed patches instead of triaging report accuracy. No CVEs, CVSS scores, attacker infrastructure or exploitation in the wild are reported. The defensive relevance is that AI-driven, proof-validated vulnerability discovery and exploit chaining is now operational at scale, which shortens the window between a flaw's introduction and its discovery by any party using similar tooling.

MITRE ATT&CK techniques by tactic:

Execution

T1059.007 JavaScript

Persistence

T1176 Software Extensions

Collection

T1185 Browser Session Hijacking

Initial Access

T1190 Exploit Public-Facing Application; T1659 Content Injection

Credential Access

T1539 Steal Web Session Cookie

Remediation

Patches

  • Google reports fixing the PageBreak-identified issues internally; no public patch identifiers or CVEs were published

Immediate actions

  • No customer action is required for the Google-hosted flaws; Google reports fixing them internally
  • Keep the Tag Assistant Extension updated to the current Chrome Web Store version
  • Run the same proof-based validation (payload injection plus a rendering harness) against your own web applications before trusting scanner output

Workarounds

  • Deploy a strict Content-Security-Policy and Trusted Types where feasible
  • Apply the same pairing of AI-driven discovery with automated patch generation (as Google plans with CodeMender), with human review of proposed fixes

Longer-term hardening

  • Adopt secure-by-design frameworks (strict output encoding, Trusted Types, strict CSP) so whole XSS classes are structurally prevented
  • Include every URL component that influences a response body in the cache key, and reject unvalidated path segments reflected into cached JavaScript
  • Never assign unvalidated redirect parameters to window.location; allowlist schemes and reject javascript: and data: URIs
  • Do not expose signing endpoints that will sign attacker-supplied parameters
  • Validate the origin of extension external connections and message senders, and avoid forwarding messages from untrusted pages

Affected and fixed versions

  • Google — Google first-party web applications (including apis.google.com and the admin.google.com console)
    Vulnerable versions: Not disclosed; 500+ XSS findings across first-party applications
    Fixed in: Fixed internally by Google; no public version identifiers
  • Google — Tag Assistant Extension (Chrome)
    Vulnerable versions: Version not disclosed
    Fixed in: Fixed by Google; version not disclosed

Timeline

  • Google Product Security starts PageBreak as a pilot to test first-party web applications (month-level precision in sources).
  • PageBreak moves from pilot to a fully-fledged project (month-level precision in sources).
  • Snapshot shows only 2 XSS issues across hundreds of applications built on Google's high-assurance web frameworks, both in internal apps or debug endpoints.
  • Write-up details cache poisoning on locked-ioc-4, an locked-ioc-3 /a/autodns/registrar XSS via /a/autodns/authorize signing, and a Tag Assistant Extension universal XSS.
  • Google publicly discloses PageBreak (blog.google post and Bug Hunters write-up) with 500+ verified XSS findings and three exploit-chain case studies.
  • Cyber Security News reports the findings; no in-the-wild exploitation, CVEs or CVSS scores are reported.

Sources cited

Previous and next in vulnerability

Drafted by the Threadlinqs research pipeline from 8 sources; published ; last updated —.

Threadlinqs Intelligence — Real-Time Threat Detection Platform

// threat_feed
$ sort --newest
Showing all threats

Live intelligence console

Threat level

Latest Threats