> For the complete documentation index, see [llms.txt](https://docs.talsec.app/appsec-articles/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.talsec.app/appsec-articles/fraud-intelligence-reports/alert-cve-2026-9998-and-cve-2026-9997-chromium-sandbox-escapes-and-apps-with-a-webview.md).

# CVE-2026-9998 & CVE-2026-9997: Chromium sandbox escapes and apps with a WebView

Two Chromium sandbox escapes (Skia integer overflow, Input use-after-free) fixed in Chrome 148.0.7778.216. What they mean for apps with a WebView, the attack chain, and where Talsec breaks it.

**Classification** TLP:CLEAR\
**Published** 30 Oct 2026 \
**Updated** 11 Nov 2026 \
**Prepared by** Talsec Threat Intelligence & Anti-fraud Services

![Infographic: a crafted web page compromises the renderer, CVE-2026-9998 or CVE-2026-9997 escapes the sandbox into the browser or the host app's WebView process, and the attacker drains the wallet or session](https://1548930415-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNjTFXsqCLQ3RU2oA2uHC%2Fuploads%2FOxbJ0CN27p6dOU03SsYH%2Fchromium-hero-wide.svg?alt=media)

#### TLDR

An integer overflow in **Skia** (CVE-2026-9998) and a use-after-free in **Input** (CVE-2026-9997) let an attacker who *already controls a Chromium renderer* **escape the sandbox** with a crafted HTML page. Fixed both in Chrome **148.0.7778.216** on 27 May 2026.&#x20;

They are the second half of a one-click exploit chain, not a standalone threat. They matter for mobile apps because Android WebView runs its browser-side code, its GPU service and its network service **inside the host app's process**, so an escape from a WebView lands *inside your app*, with your app's tokens, keys and JavaScript bridges.&#x20;

[Section 03](#id-03-how-the-exploit-works-for-a-cto) explains the chain at CTO level, [Section 05](#id-05-who-is-exposed) who is exposed, and [Section 06](#id-06-how-a-phishing-link-ends-up-inside-your-apps-webview) how a phishing link ends up in your WebView instead of the system browser. Talsec can't patch a browser engine, and only updating Chrome/WebView fixes the bug.&#x20;

What Talsec stops is the **payoff**: hooking the app, rooting the device, dropping malware or replaying a stolen session.

{% hint style="info" %}
**Status (11 Nov 2026)**

Fixed in Chrome 148.0.7778.216 (Stable Channel update of 27 May 2026). **No in-the-wild exploitation reported** for either CVE. Both are rated **High (CVSS 8.3)** and need a separate renderer bug first. The attack chain in this alert is reconstructed from the vendor descriptions, not from an observed intrusion.
{% endhint %}

{% hint style="warning" %}
**Engineering bottom line**

The bugs are in the browser engine, below the app layer. No SDK can prevent the escape; the fix is the Chrome / Android System WebView update.&#x20;

What an app owner *can* do is gate untrusted web content on the WebView version, keep third-party pages out of the process that holds keys and tokens, and make sure a compromised runtime is visible to the backend before money moves.
{% endhint %}

***

## 01 · Vulnerability snapshot

| CVE               | Component · class                                  | Description (vendor)                                                                                                                                                                 | Chromium bug | Severity       |
| ----------------- | -------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------ | -------------- |
| **CVE-2026-9998** | Skia (2D graphics) · *integer overflow*            | An integer overflow in Skia in Chrome before 148.0.7778.216 let a remote attacker who had compromised the renderer process potentially escape the sandbox using a crafted HTML page. | `513337118`  | **High · 8.3** |
| **CVE-2026-9997** | Input (event handling) · *use-after-free, CWE-416* | A use-after-free in Input in Chrome before 148.0.7778.216 let a remote attacker who had compromised the renderer process potentially escape the sandbox using a crafted HTML page.   | `513324041`  | **High · 8.3** |

Both share the vector `AV:N/AC:H/PR:N/UI:R/S:C/C:H/I:H/A:H` (CISA-ADP). Google reported both internally on 14 May 2026. They shipped on 27 May in a Stable Channel update with 151 security fixes and reached NVD on 28 May. The CNA labelled CVE-2026-9998 as CWE-472, which looks like an error; CWE-190 would fit.

<table><thead><tr><th width="181.87109375">Attribute</th><th>Value</th></tr></thead><tbody><tr><td><strong>Fixed in</strong></td><td>Chrome <strong>148.0.7778.216</strong> (desktop Stable, 27 May 2026); Chrome for Android and Android System WebView builds from the same release line</td></tr><tr><td><strong>Precondition</strong></td><td>A compromised renderer process (a separate renderer bug, typically V8)</td></tr><tr><td><strong>User interaction</strong></td><td>Required: the victim opens a crafted page (<code>UI:R</code>)</td></tr><tr><td><strong>Scope</strong></td><td>Changed (<code>S:C</code>): the escape crosses from the renderer into the browser or host-app process</td></tr><tr><td><strong>Exploited in the wild</strong></td><td>Not reported</td></tr><tr><td><strong>Related</strong></td><td>CVE-2026-9888, a <strong>Critical</strong> use-after-free in <strong>WebView on Android</strong>, fixed in the same release cycle</td></tr></tbody></table>

***

## 02 · Why it matters on mobile

### A sandbox escape in WebView lands inside the host app

{% columns %}
{% column %}

#### Chrome browser

A successful escape gives the attacker the **browser process**: cookies, session storage and saved credentials for every origin, including a logged-in exchange or banking session. The attacker can then drive that session or steal its tokens.
{% endcolumn %}

{% column %}

#### Android System WebView (in-app browsers)

On Android, WebView's renderer is sandboxed, but its browser-side code runs **inside the embedding app's process**. If a bug of this class is reachable from WebView, an escape gives code execution *as the host app*: its tokens, keystore handles, `@JavascriptInterface` bridges and UI. A **dApp browser**, or any in-app page that loads third-party content, is the delivery surface.
{% endcolumn %}
{% endcolumns %}

{% hint style="warning" %}
**Applicability note**

The NVD/CPE entries and the Chrome release post cover **desktop** Chrome. Skia and Input are shared Chromium components, so Chrome for Android and Android System WebView builds older than 148.0.7778.216 are *likely* affected, but the advisory doesn't confirm it. The same release cycle also fixed **CVE-2026-9888**, a **Critical** use-after-free in **WebView on Android** with the same sandbox-escape impact.
{% endhint %}

***

## 03 · How the exploit works, for a CTO

### Three processes, one trust boundary, two bugs on the wrong side of it

Chromium splits the browser into processes with different privileges. The **renderer** parses HTML, runs JavaScript (V8) and lays out the page; it is the untrusted part, so it runs in an OS **sandbox** with no files, no network and no device access of its own.&#x20;

The **browser process** owns everything valuable: the profile, cookies and saved sessions, the network stack, the UI. The **GPU process** turns the renderer's drawing commands into pixels, using the **Skia** graphics library.&#x20;

The three talk over an IPC layer (Mojo), and the whole security model rests on one rule: *every message that comes out of a renderer is hostile*. The two CVEs are bugs in code that receives such messages in a privileged process.

{% stepper %}
{% step %}

### Stage 1 · The renderer is taken over (not these CVEs)

A crafted page triggers a bug in the JavaScript engine or the DOM, typically a JIT type confusion in V8. The attacker gets arbitrary read and write inside the renderer's memory, then native code execution. This is the "compromised renderer" precondition in both CVE descriptions.&#x20;

At this point the attacker is still inside the sandbox: they can send any IPC message they like, but they cannot touch files, cookies or the app.
{% endstep %}

{% step %}

### Stage 2a · CVE-2026-9998, Skia

The renderer does not draw; it sends paint operations (display lists, images, shaders, filters) to be rasterised by Skia in the privileged GPU side. One of those operations carried sizes that Skia multiplied without checking for overflow. A huge width or height wraps around to a small number, Skia allocates a buffer that is too small, and the draw writes past its end. An out-of-bounds write in a privileged process is what an attacker needs to take it over.
{% endstep %}

{% step %}

### Stage 2b · CVE-2026-9997, Input

The browser process keeps objects for every input target (frames, widgets, scroll and gesture state) and the renderer can drive their lifecycle through IPC. A crafted sequence of navigation and input events made the browser free one of those objects while another part of the code still held a pointer to it (a use-after-free). The attacker refills the freed memory with data they control, and the next use of the stale pointer runs attacker-chosen code in the browser process.
{% endstep %}

{% step %}

### Stage 3 · Where the attacker lands

In **Chrome**, the attacker now runs as the Chrome app: every cookie and session for every site, including a logged-in exchange or online banking session, plus a foothold for a kernel exploit.&#x20;

In **Android WebView**, the browser code, the GPU service and the network service all run **inside the embedding app's process** (only the renderer is a separate, sandboxed process). Both bugs therefore land the attacker *inside the app that opened the page*: same UID, same memory, same keystore handles, same `@JavascriptInterface` bridges, same UI.
{% endstep %}
{% endstepper %}

{% hint style="info" %}
**Why no app-level control catches the escape**

The corruption happens inside library code the app did not write and cannot inspect. Nothing crosses a permission boundary, no new process starts, no file changes. From the outside, the app is simply rendering a web page. That is why the only fix for the escape is the engine update, and why Talsec's controls are placed *after* it, at the point where the attacker must touch the app, the device or the backend ([Section 08](#id-08-talsec-coverage-report)).
{% endhint %}

Google does not publish exploit details for either bug, and no public exploit exists at the time of writing. The descriptions above are reconstructed from the vendor advisories and from Chromium's process architecture; they are deliberately not a how-to.

### What the victim experiences

One Tuesday evening *(illustrative; names invented)*

<table><thead><tr><th width="67.60546875">Time</th><th>Who</th><th>What happens</th></tr></thead><tbody><tr><td>21:05</td><td>Telegram group → <strong>Lukas</strong></td><td>Lukas, 29, keeps most of his crypto on an exchange whose app has a built-in dApp browser. A message in a trading group announces an airdrop for early users of a DEX he actually uses, with a button: <em>"Claim in the app"</em>. The link is the exchange app's own deep link, with the dApp page as a parameter.</td></tr><tr><td>21:05</td><td>Exchange app</td><td>The link opens the exchange app, not Chrome, and the app loads the page in its dApp browser. Lukas sees the familiar in-app browser bar, a spinner, then a page with the DEX's branding and a <strong>Claim</strong> button. The page stutters for about a second before it settles. He taps <strong>Claim</strong>; the page says tokens will arrive within 24 hours.</td></tr><tr><td>21:06</td><td>Attacker</td><td>During the stutter, a renderer bug ran in the WebView's sandboxed renderer and one of the two CVEs escaped it. The attacker's code is now running inside the exchange app's process. It reads the session and refresh tokens from memory, calls the same internal functions the app uses to sign API requests, and copies them to the attacker's server. Nothing visible happens on the phone.</td></tr><tr><td>21:10</td><td>Lukas</td><td>He closes the page, checks his balance (unchanged), and goes to bed.</td></tr><tr><td>03:15</td><td>Attacker → exchange</td><td>A withdrawal of most of his balance to a new address, submitted by the attacker's own script using the stolen tokens, from attacker infrastructure. Where the exchange demands a request signed by the genuine app, the attacker instead drives the genuine app itself, still open in the background, through the code already running inside it.</td></tr><tr><td>07:40</td><td>Lukas</td><td>A "withdrawal completed" email. He never typed a password into a fake page, never installed anything, never granted a permission.</td></tr></tbody></table>

{% columns %}
{% column %}
**What Lukas saw**

A link from a group he trusts, opened by the app he trusts, showing a page that looked like a hundred other airdrop pages. One second of lag. The whole attack was indistinguishable from a slow web page.
{% endcolumn %}

{% column %}
**What the exchange saw**

Lukas's enrolled device and app, a valid session, his usual network, and, at 03:15, a withdrawal that either came from the genuine app (if the attacker drove it) or carried his genuine tokens (if replayed). Device fingerprinting passed because the device was genuine. What was abnormal was behavioural: a new address, a night-time withdrawal of nearly everything, and, if the app ships Talsec, a runtime that started reporting hooks or an API call that did not carry a valid cryptogram (Section 08).
{% endcolumn %}
{% endcolumns %}

***

## 04 · Attack vector

### A full chain: lure, then renderer RCE, then sandbox escape, then fraud

CVE-2026-9997 and CVE-2026-9998 make up stage 2 of the chain below (the mechanics are in Section 03). On its own, neither bug gives an attacker anything. Paired with a renderer bug (typically V8), they complete a one-click chain from a web page to the user's device and wallet.

![Attack sequence with six lanes (Attacker, Victim, Renderer, Browser / app, Device OS, Backend) across four stages: delivery and renderer compromise, sandbox escape via CVE-2026-9998 or CVE-2026-9997, abuse of the app and persistence, cash-out, with ATT\&CK IDs and the Talsec control that breaks each step](https://1548930415-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNjTFXsqCLQ3RU2oA2uHC%2Fuploads%2FyiRxBoP0R4nLj1DjxZpZ%2Fcve-2026-9998-9997-attack-sequence.svg?alt=media)

{% stepper %}
{% step %}

### Lure

The victim opens a crafted HTML page: a phishing link, a fake airdrop or "claim" page, a malicious dApp opened in an in-app browser, a malvertising redirect or a compromised site. User interaction is required (`UI:R`).
{% endstep %}

{% step %}

### Renderer RCE (a separate bug)

A separate renderer bug, typically a V8 type confusion, gives native code execution *inside* the sandboxed renderer. This is the stated precondition for both CVEs, and these CVEs are not that bug.
{% endstep %}

{% step %}

### Sandbox escape: the CVEs in this alert

* **CVE-2026-9998 (Skia):** an integer overflow in a size calculation leads to an undersized buffer and an out-of-bounds write in a privileged graphics path.
* **CVE-2026-9997 (Input):** a crafted input/IPC sequence frees an object that is still in use; the heap is reclaimed and the attacker gets code execution.
  {% endstep %}

{% step %}

### Privileged code execution and abuse of the app

The attacker now runs in the Chrome browser process or, for WebView, **in the host app's process**. From there they can hook signing and transaction logic, read session and refresh tokens, call JS bridges, or swap a withdrawal address in the UI.
{% endstep %}

{% step %}

### Persist and escalate

A kernel LPE to gain root, or a companion RAT that abuses Accessibility, gives durable control beyond the current session.
{% endstep %}

{% step %}

### Cash-out

Withdrawals to attacker-controlled addresses, address-whitelist changes, new API keys, or replay of the stolen session from attacker infrastructure.
{% endstep %}
{% endstepper %}

***

## 05 · Who is exposed

### Any Chromium-based client below 148.0.7778.216 that renders attacker-chosen pages

The bugs are in Chromium's shared Skia and Input code, so exposure is decided by the **engine version** and by **whose web content the engine renders**, not by the device brand or the operating system.

<table><thead><tr><th width="168.5">Factor</th><th width="139.62890625">Limits exposure?</th><th>Detail</th></tr></thead><tbody><tr><td><strong>Browser engine</strong></td><td><strong>Yes</strong></td><td>Chromium only: Chrome, Edge, Brave, Opera, Samsung Internet, Android System WebView, and desktop apps built on Electron. Firefox (Gecko) and Safari (WebKit) are not affected by these CVEs.</td></tr><tr><td><strong>Engine version</strong></td><td><strong>Yes</strong></td><td>Fixed in <strong>148.0.7778.216</strong>. Chrome for Android follows the same version line; Android System WebView is updated through Google Play on its own schedule. Other Chromium browsers and Electron ship the fix in their own later releases.</td></tr><tr><td><strong>Platform</strong></td><td>Partly</td><td>Desktop Chrome: confirmed by the advisory. Chrome for Android and Android WebView: <em>likely</em> affected (shared components), not confirmed by Google. <strong>iOS: not affected</strong>: Chrome on iOS and every iOS app's WebView (<code>WKWebView</code>) use Apple's WebKit, not Chromium.</td></tr><tr><td><strong>Android version</strong></td><td>Partly</td><td>WebView has been an updatable Play package since Android 5, so a patched WebView reaches most devices. On Android 7 and older the WebView renderer is <strong>not</strong> a separate process, so a renderer bug alone already lands in the app, without needing these CVEs. Devices without Google Play (some Chinese and enterprise builds) depend on the OEM to ship a new WebView.</td></tr><tr><td><strong>What the app loads in WebView</strong></td><td><strong>Yes</strong></td><td><strong>Highest</strong>: a dApp browser or in-app browser that opens arbitrary third-party pages. <strong>Medium</strong>: first-party pages that embed third-party scripts, ads or link-outs. <strong>Low</strong>: a WebView that only loads your own content and blocks navigation elsewhere; the attacker then needs to compromise your web content first. <strong>None from WebView</strong>: apps with no WebView (the user is still exposed in Chrome).</td></tr><tr><td><strong>User interaction</strong></td><td><strong>Yes</strong></td><td>The victim must open the page (<code>UI:R</code>). There is no zero-click path; the attacker's whole effort goes into making the link worth tapping (Section 06).</td></tr><tr><td><strong>Attacker capability</strong></td><td><strong>Yes</strong></td><td>A sandbox escape is useless without a renderer bug, so a working chain needs two bugs. That puts fresh chains in the hands of exploit brokers, state actors and top-tier crimeware. The practical risk for most users is the <strong>n-day window</strong>: once the bugs are public, chains are rebuilt from them and used against whoever has not updated.</td></tr><tr><td><strong>Desktop web users</strong></td><td>Partly</td><td>Customers using your web app in Chrome, Edge or Brave below the fixed version. An escape there exposes their logged-in web session and cookies; a desktop wallet built on Electron is exposed until Electron ships a Chromium with the fix.</td></tr><tr><td><strong>Geography, carrier, chipset</strong></td><td>No</td><td>No regional or hardware component.</td></tr></tbody></table>

{% hint style="info" %}
**Rule of thumb for an exchange or bank.** A customer is exposed when **(a)** the Chromium engine rendering the page is below 148.0.7778.216, **and** **(b)** that engine renders a page the attacker chose: your dApp browser, an in-app browser, an embedded third party, or plain Chrome with your web app logged in. Your app can read (a) for its own WebView with `WebViewCompat.getCurrentWebViewPackage()` and send it to the backend with the session, so the fraud engine knows which sessions run on an unpatched engine. (b) is a product decision: Section 06 lists the ways a link reaches your WebView and Section 09 how to narrow them.
{% endhint %}

***

## 06 · How a phishing link ends up inside your app's WebView

### The attacker wants your WebView, not the system browser, and Android makes that easy

A link tapped in a chat, a mail or a social feed normally opens the default browser. For this attack the Chrome variant is already valuable (cookies and sessions for every site), but the **WebView variant is better for the attacker**: the escape lands inside *your* process, next to *your* tokens, keys and signing code. Android offers several ways to make sure a link opens in an app's WebView rather than in Chrome. Most of them are features, not bugs.

| Route                                     | How the link gets into the WebView                                                                                                                                                                                                                                                                                                                                                   | Who controls the URL that is loaded                                                                                                                                                                                                                               |
| ----------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Android App Links / deep links**        | Your app declares an intent filter for `https://app.yourexchange.com/...` (verified App Links) or a custom scheme such as `yourexchange://`. Android routes matching links to your app *instead of the browser*, with no chooser. If the deep link carries a page address as a parameter (`.../browser?url=`, `.../campaign?page=`, `.../dapp?uri=`), the app loads it in a WebView. | The attacker, whenever the parameter is not strictly validated. A weak check (`startsWith`, `contains`, an allowlist that includes an expired domain) is bypassed with `https://trusted.com@attacker.com/`, `trusted.com.attacker.com` or a re-registered domain. |
| **dApp browser and wallet links**         | Wallets and exchange super-apps ship a browser whose purpose is to open third-party dApps. "Open in \<Wallet>" buttons, WalletConnect links, QR codes and in-app dApp directories all end in `WebView.loadUrl(dappUrl)`.                                                                                                                                                             | The dApp author, by design. A fake or compromised dApp is a crafted page in your process.                                                                                                                                                                         |
| **In-app browser for all external links** | Many apps open every link from their feeds, chats, notifications and support pages in their own WebView (the Instagram pattern), to keep the user inside the app. A push notification with a deep link to a "campaign page" does the same.                                                                                                                                           | Whoever put the link in the feed, chat or notification: a compromised partner, an ad network, a support-chat attacker.                                                                                                                                            |
| **Navigation from a first-party page**    | The WebView starts on your own page, but the page contains a third-party script or ad, is vulnerable to XSS, or has an open redirect. The page navigates to the attacker's URL and the WebView follows, unless `shouldOverrideUrlLoading()` enforces an allowlist on **every** navigation, redirects included.                                                                       | The attacker, through your web property.                                                                                                                                                                                                                          |
| **Intent redirection**                    | A page already in the WebView issues an `intent://` URL. If the app passes it to `startActivity()` unchecked, it can reach internal screens, including other WebView screens, with an attacker-chosen URL.                                                                                                                                                                           | The attacker, once any page of theirs is loaded.                                                                                                                                                                                                                  |
| **Not a WebView: Chrome Custom Tabs**     | A Custom Tab looks like an in-app browser but runs in **Chrome's** process with Chrome's engine and Safe Browsing. An escape there lands in Chrome, not in your app.                                                                                                                                                                                                                 | Opening untrusted links in a Custom Tab instead of a WebView moves the blast radius out of your process.                                                                                                                                                          |

{% hint style="warning" %}
**The combination that matters**

Android App Links / deep links is what turns a generic phishing message into a targeted attack on your app.&#x20;

The attacker sends \
`https://app.yourexchange.com/dapp?uri=https://airdrop-claim.example` \
to your customers, Android opens *your* app for it because the domain is yours, and your app loads the attacker's page in its WebView. From the victim's side it looks like a link from your company that opened your app.&#x20;

*dApp browser and wallet links* and *In-app browser for all external links* do the same without any mistake on your side, because loading third-party pages is the feature.
{% endhint %}

### Engineering checklist for the WebView surface

* **Deep links**\
  Parse the URL and compare the **exact host** against an allowlist; never load a URL taken from a deep-link or intent parameter without that check; keep `BROWSABLE` only on the activities that need it; monitor allowlisted domains for expiry.
* **Navigation** \
  Enforce the allowlist in `shouldOverrideUrlLoading()` for every navigation and redirect, not only the first `loadUrl()`.
* **Untrusted pages**\
  Open them in a **Custom Tab**, or in a WebView hosted in a **separate `android:process`** that holds no tokens, no keystore access and no JavaScript bridges.
* **Bridges**\
  No `@JavascriptInterface` on a WebView that can reach third-party origins; use `WebViewCompat.addWebMessageListener()` with explicit origin rules instead.
* **Engine floor** \
  Read `WebViewCompat.getCurrentWebViewPackage()` at start-up, disable third-party pages below the patched version, and report the version to the backend with the session (Section 09, control 1).
* **Safe Browsing** \
  Keep WebView Safe Browsing on (default since Android 8.1) and, in a dApp browser, add your own phishing and dApp deny-list.

***

## 07 · TTPs: MITRE ATT\&CK mapping

{% hint style="info" %}
This mapping is Talsec analysis of a **reconstructed** chain, built from the vendor CVE descriptions. It is not based on an observed intrusion.
{% endhint %}

<table><thead><tr><th width="166.94140625">Tactic</th><th>Technique</th><th>How it applies to this chain</th></tr></thead><tbody><tr><td><strong>Initial access</strong></td><td><code>T1456</code> Drive-By Compromise (Mobile) · <code>T1189</code> (Enterprise)</td><td>Victim opens a crafted HTML page in Chrome or an in-app WebView (fake airdrop, dApp, malvertising, a link sent over Telegram or X).</td></tr><tr><td><strong>Execution</strong></td><td><code>T1203</code> Exploitation for Client Execution</td><td>A renderer RCE (separate CVE) gives native code execution in the sandboxed renderer: the precondition for both CVEs.</td></tr><tr><td><strong>Privilege escalation</strong></td><td><code>T1404</code> Exploitation for Privilege Escalation (Mobile) · <code>T1068</code> (Enterprise)</td><td>CVE-2026-9998 or CVE-2026-9997 is used to escape into the browser process, or into the host app process when the page runs in WebView (<code>S:C</code>).</td></tr><tr><td><strong>Credential access</strong></td><td><code>T1528</code> Steal Application Access Token · <code>T1539</code> Steal Web Session Cookie</td><td>Session cookies, OAuth/refresh tokens and stored API keys are read from the privileged process.</td></tr><tr><td><strong>Persistence / collection</strong></td><td><code>T1625</code> Hijack Execution Flow · <code>T1417</code> Input Capture · <code>T1513</code> Screen Capture</td><td>Runtime hooking (Frida-style), input capture, or follow-on malware (Accessibility RAT, overlay) after a kernel LPE.</td></tr><tr><td><strong>Impact</strong></td><td><code>T1641</code> Data Manipulation · <code>T1657</code> Financial Theft</td><td>Swapped withdrawal addresses, malicious transaction approvals, new API keys, drained funds.</td></tr></tbody></table>

***

## 08 · Talsec coverage report

### Talsec cannot patch Chromium, but it stops the payoff

The memory-corruption bugs sit in the browser engine, below the app layer, and the only fix for them is updating Chrome or WebView. Talsec's value is at steps 4b to 6, where the attacker has to touch the protected app, the device or the backend.

![Talsec coverage matrix: for each kill-chain step, which product helps (RASP+, Malware Detection, App Hardening, AppiCrypt, AppiCryptWeb, Risk State API), the verdict and what Talsec does](https://1548930415-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNjTFXsqCLQ3RU2oA2uHC%2Fuploads%2F0qKLVStGKmmaEJjqt3FM%2Fcve-2026-9998-9997-coverage-matrix-v2.svg?alt=media)

<table><thead><tr><th width="262.60546875">Kill-chain step</th><th>What Talsec does / verdict</th></tr></thead><tbody><tr><td><strong>1 · Lure</strong><br>Phishing page / dApp</td><td><code>OUT OF SCOPE</code> <br>Talsec doesn't filter URLs or content. App owners control this with strict deep-link validation, dApp allow/deny lists and Safe Browsing (Section 06).</td></tr><tr><td><strong>2 · Renderer RCE</strong><br>Separate V8 / Blink bug</td><td><code>OUT OF SCOPE</code> <br>Runs inside the isolated renderer process, where Talsec code doesn't execute.</td></tr><tr><td><strong>3 · Sandbox escape</strong><br>CVE-2026-9998 / -9997</td><td><p><code>NO DIRECT DETECTION</code> <br>There's no exploit signature to catch. Device and OS signals in the <a href="https://docs.talsec.app/premium-products/introduction/overview"><strong><code>Risk State API</code></strong></a> can feed a patch-level policy; </p><p>WebView version gating is done in the app (recommendation 1).</p></td></tr><tr><td><strong>4a · Code exec, privileged</strong><br>Browser / app process</td><td><p><mark style="background-color:yellow;"><strong>PARTIAL</strong></mark> <br><a href="https://docs.talsec.app/premium-products/product/rasp"><strong><code>RASP+</code></strong></a> sees the payload only once it hooks, injects or tampers. Pure in-memory code is hard for any in-app agent to see. </p><p><strong>Secrets Vault</strong> doesn't apply: the attacker is already in the running process.</p></td></tr><tr><td><strong>4b · Abuse app context</strong><br>Hooks, tamper, JS bridge</td><td><p><mark style="background-color:green;"><strong>COVERED</strong></mark> <br><a href="https://docs.talsec.app/premium-products/product/rasp"><strong><code>RASP+</code></strong></a> hook and instrumentation detection, app-integrity and debugger checks. </p><p><a href="https://docs.talsec.app/premium-products/product/appicrypt"><strong><code>AppiCrypt®</code></strong></a> cryptograms carry the threat state, so the backend sees a compromised runtime.</p></td></tr><tr><td><strong>5 · Persist / escalate</strong><br>Root, RAT, overlay</td><td><p><mark style="background-color:green;"><strong>COVERED</strong></mark> <br><a href="https://docs.talsec.app/premium-products/product/rasp"><strong><code>RASP+</code></strong></a> root detection (Magisk, KernelSU, Zygisk); </p><p><a href="https://docs.talsec.app/premium-products/product/malware-detection"><strong><code>Malware Detection</code></strong></a> for sideloaded RATs and Accessibility abuse; screen-capture and automation flags.</p></td></tr><tr><td><strong>6 · Cash-out</strong><br>Withdrawal, API keys, replay</td><td><p><mark style="background-color:green;"><strong>COVERED</strong></mark> 🔴<br><a href="https://docs.talsec.app/premium-products/product/appicrypt"><strong><code>AppiCrypt®</code></strong></a> rejects API calls replayed off-device or from a tampered app. <strong>AppiCryptWeb</strong> covers the browser channel. </p><p><a href="https://docs.talsec.app/premium-products/introduction/overview"><strong><code>Risk State API</code></strong></a> drives step-up.</p><p><strong>Secrets Vault</strong> keeps hardcoded API secrets out of the APK, so they can't be lifted to script a fake client.</p></td></tr></tbody></table>

{% columns %}
{% column %}
{% hint style="success" %}
**Coverage verdict**

Vulnerability itself: **not covered** (patching only).

Exploitation outcome in the app: **largely covered.** The attacker can escape the sandbox, but turning that into money means hooking the app, rooting the device, dropping malware or replaying a session. Each of those trips a Talsec signal that the backend can act on before funds move.
{% endhint %}
{% endcolumn %}

{% column %}
{% hint style="warning" %}
**Residual risk, stated plainly**

A stealthy in-process payload that never hooks, never roots and acts through the genuine app's own API calls in real time can pass [**`AppiCrypt®`**](https://docs.talsec.app/premium-products/product/appicrypt), because the device and app are genuine. Backend behavioural risk (address age, velocity, a cooldown on new whitelist entries) has to close this gap.

Talsec does not inspect web content or browser memory.
{% endhint %}
{% endcolumn %}
{% endcolumns %}

### freeRASP or RASP+? What each covers against this chain

| Kill-chain step                             | [**`freeRASP`**](https://docs.talsec.app/freerasp/freerasp/introduction)                        | [**`RASP+`**](https://docs.talsec.app/premium-products/product/rasp) / Premium                                                                                                                                                                                          |
| ------------------------------------------- | ----------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **3 · Sandbox escape**                      | <p>❌ No detection</p><p>You can read the WebView version yourself and gate content</p>          | <p>❌ No detection<br><a href="https://docs.talsec.app/premium-products/introduction/overview"><strong><code>Risk State API</code></strong></a> carries OS and device state for a patch-level policy</p>                                                                 |
| **4b · Hooks and tampering in the app**     | ⚠️ `onHooks()`, `onAppIntegrity()`, `onDebug()` in the app; result stays on the device          | ✅ Same checks, SDK built per app, **plus** the verdict carried to the server by 🔴 [**`AppiCrypt®`**](https://docs.talsec.app/premium-products/product/appicrypt)                                                                                                       |
| **5 · Root and follow-on malware**          | ✅ `onPrivilegedAccess()`; offline malware detection (`installSource` + `suspiciousPermission`)  | ✅ Same, plus remotely updatable rules ([**`Talsec Portal`**](https://docs.talsec.app/freerasp/freerasp/data-visualisation-portal)) and online **App Reputation** lookups                                                                                                |
| **5 · Overlay, screen capture, automation** | ⚠️ `Talsec.blockScreenCapture()`, `onScreenRecording()`, `onAutomation()`; no overlay detection | ✅ Same, plus **overlay detection** and Accessibility Protector                                                                                                                                                                                                          |
| **6 · Session replay and fake clients**     | ❌ No server-side verdict; API secrets stay in the APK                                           | <p>✅ <a href="https://docs.talsec.app/premium-products/product/appicrypt"><strong><code>AppiCrypt®</code></strong></a> on money-moving endpoints.</p><p><strong>AppiCryptWeb</strong> for the browser channel.</p><p><strong>Secrets Vault</strong> for API secrets</p> |

{% hint style="info" %}
**Bottom line**

Against a browser-chain compromise, [**`freeRASP`**](https://docs.talsec.app/freerasp/freerasp/introduction) tells the app that its runtime is hooked or the device rooted, which is enough to warn the user and pause sensitive flows. It can't tell your backend, and a payload that already runs in the process can drop or forge the signal.&#x20;

The controls that stop the money are server-side:

* [**`AppiCrypt®`**](https://docs.talsec.app/premium-products/product/appicrypt) on withdrawal and API-key endpoints.
* [**`Risk State API`**](https://docs.talsec.app/premium-products/introduction/overview) at authorisation, together with [**`RASP+`**](https://docs.talsec.app/premium-products/product/rasp) and [**`Malware Detection`**](https://docs.talsec.app/premium-products/product/malware-detection)**`.`**

See also [freeRASP vs RASP+](https://docs.talsec.app/freerasp/freerasp/features-and-pricing-plans/the-key-difference-freerasp-vs-rasp).
{% endhint %}

***

## 09 · Protecting crypto exchanges, wallets and banking super-apps

For an exchange or wallet, the risk isn't the browser crash itself. It's a browser-engine compromise that reaches the session, the signing flow or the withdrawal API.

<table><thead><tr><th width="95.55859375">Exposure</th><th width="176.80859375">Surface</th><th>Why it matters</th></tr></thead><tbody><tr><td><strong>Highest</strong></td><td>Web3 wallet / dApp browser</td><td>Loads arbitrary third-party pages inside the app's WebView by design: exactly the "crafted HTML page" delivery path. An escape lands in the process that holds the wallet UI and signing flow.</td></tr><tr><td><strong>Medium</strong></td><td>In-app web content</td><td>Campaign pages, content feeds, support and KYC flows in WebView. Usually first-party, but any embedded third-party script, ad or link-out widens the surface.</td></tr><tr><td><strong>Medium</strong></td><td>Web app in Chrome</td><td>Users on unpatched desktop or Android Chrome. An escape exposes the logged-in web session and cookies for every origin, so session replay is the main route to cashing out.</td></tr></tbody></table>

### Six controls, mapped to Talsec products

<table data-view="cards"><thead><tr><th></th><th></th><th></th></tr></thead><tbody><tr><td><strong>1 · Gate untrusted WebViews on engine version</strong></td><td>At startup, read the active WebView provider version (<code>WebViewCompat.getCurrentWebViewPackage()</code>). Below 148.0.7778.216 (or the current patched floor), disable the dApp browser and third-party pages and prompt the user to update. Report the version as a <a href="https://docs.talsec.app/premium-products/introduction/overview"><strong><code>Risk State</code></strong></a> signal.</td><td><em>App owner ·</em> <a href="https://docs.talsec.app/premium-products/introduction/overview"><em><strong><code>Risk State API</code></strong></em></a></td></tr><tr><td><strong>2 · Shrink the blast radius of WebView</strong></td><td>Validate every deep-link URL against an exact-host allowlist, open untrusted links in a Custom Tab, and host any third-party WebView content in a separate <code>android:process</code> with no keys, tokens or JS bridges (Section 06). An escape then lands in an empty process, or in Chrome's.</td><td><em>App owner</em></td></tr><tr><td><strong>3 ·</strong> <a href="https://docs.talsec.app/premium-products/product/rasp"><strong><code>RASP+</code></strong></a> <strong>with kill-session reactions</strong></td><td>Turn on hook, tamper, debugger, root and automation detection, with reactions that end the session and wipe in-memory tokens. Apply the same on iOS (jailbreak, Frida, integrity).</td><td><a href="https://docs.talsec.app/premium-products/product/rasp"><em><strong><code>RASP+</code></strong></em></a></td></tr><tr><td><strong>4 ·</strong> <a href="https://docs.talsec.app/premium-products/product/appicrypt"><strong><code>AppiCrypt®</code></strong></a> <strong>on money-moving endpoints</strong></td><td>Require a valid cryptogram on withdrawal, address-whitelist, API-key, P2P release and token refresh. Stolen tokens replayed from attacker infrastructure fail verification.</td><td><a href="https://docs.talsec.app/premium-products/product/appicrypt"><em><strong><code>AppiCrypt®</code></strong></em></a> <em>· AppiCryptWeb</em></td></tr><tr><td><strong>5 · Feed device risk into the fraud engine</strong></td><td>Stream <a href="https://docs.talsec.app/premium-products/introduction/overview"><strong><code>Risk State</code></strong></a> (root, hooks, malware, screen sharing, OS patch level) into transaction scoring. Require step-up authentication (passkey, cooldown) when a withdrawal comes from a device that flagged recently.</td><td> <a href="https://docs.talsec.app/premium-products/introduction/overview"><em><strong><code>Risk State API</code></strong></em></a></td></tr><tr><td><strong>6 · Catch the follow-on malware</strong></td><td><a href="https://docs.talsec.app/premium-products/product/malware-detection"><strong><code>Malware Detection</code></strong></a> with the Gen Digital (Avast/Norton) databases flags sideloaded RATs, Accessibility abusers and clipboard or address swappers: the usual persistence after a browser-chain compromise.</td><td><a href="https://docs.talsec.app/premium-products/product/malware-detection"><em><strong><code>Malware Detection</code></strong></em></a></td></tr></tbody></table>

***

## Integration guides

* [RASP+ Android](https://docs.talsec.app/premium-integration-documentations/core-sdk/rasp+/integration-guide/android)&#x20;
* [Malware Detection configuration](https://docs.talsec.app/premium-integration-documentations/enhanced-protection/malware-detection/integration-guide/configuration)&#x20;
* [AppiCrypt® Android](https://docs.talsec.app/premium-integration-documentations/enhanced-protection/appicrypt-r/sdk-integration/android) (Talsec customer login required)

***

## Sources

* NVD: CVE-2026-9998: <https://nvd.nist.gov/vuln/detail/CVE-2026-9998>
* NVD: CVE-2026-9997: <https://nvd.nist.gov/vuln/detail/CVE-2026-9997>
* Chrome Releases: *Stable Channel Update for Desktop* (27 May 2026): <https://chromereleases.googleblog.com/2026/05/stable-channel-update-for-desktop\\_0877304591.html>
* Red Hat Bugzilla 2483113 (CVE-2026-9997): <https://bugzilla.redhat.com/show\\_bug.cgi?id=2483113>
* cvefeed: CVE-2026-9997: <https://cvefeed.io/vuln/detail/CVE-2026-9997>
* OffSeq Threat Radar: CVE-2026-9998: <https://radar.offseq.com/threat/cve-2026-9998-integer-overflow-in-google-chrome-20eb53d9>
* Chromium: *WebView Architecture* (browser code, GPU and network services run in the embedding app's process; renderer sandboxed): <https://chromium.googlesource.com/chromium/src/+/lkgr/android\\_webview/docs/architecture.md>
* Android Developers: *What's new in WebView security* (renderer in a separate process from Android 8): <https://android-developers.googleblog.com/2017/06/whats-new-in-webview-security.html>
* Android Developers: *Verify Android App Links*: <https://developer.android.com/training/app-links/verify-android-applinks> · *Managing WebView objects* (Safe Browsing, version): <https://developer.android.com/develop/ui/views/layout/webapps/managing-webview>
* Chrome Developers: *Android Custom Tabs*: <https://developer.chrome.com/docs/android/custom-tabs>
* Oversecured: *Android deep link vulnerabilities* (URL-parameter and allowlist bypasses): <https://oversecured.com/blog/android-deep-link-vulnerabilities>
* MITRE ATT\&CK: [Mobile matrix](https://attack.mitre.org/matrices/mobile/) · [Enterprise matrix](https://attack.mitre.org/matrices/enterprise/)

*Protect your Android and iOS apps against browser-chain post-exploitation with* [*RASP+*](https://docs.talsec.app/premium-products/product/rasp)*,* [*AppiCrypt®*](https://docs.talsec.app/premium-products/product/appicrypt) *and* [*Malware Detection*](https://docs.talsec.app/premium-products/product/malware-detection)*, or start with* [*freeRASP*](https://github.com/talsec/Free-RASP-Community)*. The attack-chain reconstruction and ATT\&CK mapping in this alert are Talsec analysis for defensive purposes.*


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://docs.talsec.app/appsec-articles/fraud-intelligence-reports/alert-cve-2026-9998-and-cve-2026-9997-chromium-sandbox-escapes-and-apps-with-a-webview.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
