This is a peephole in a locked apartment, not a blown-open front door
CVE-2026-11148 is a Chrome for Android Payments bug that can expose cross-origin data before version 149.0.7827.53. The public record says it is a *local attacker* issue triggered with a crafted HTML page, which matters: this is not a server bug and not a one-packet internet exploit. The affected population is Android Chrome clients below 149.0.7827.53, with impact limited to confidentiality rather than code execution, persistence, or sandbox escape.
The vendor's 6.5/MEDIUM is defensible in a vacuum, but it still overstates the operational urgency for a 10,000-host enterprise patch queue. The attack path is constrained by platform scope (Android only), client-side reachability, required user interaction, and the unusually important prerequisite implied by *local attacker* in the CNA text. That combination pushes this down from 'patch now' to 'patch in normal mobile/browser hygiene,' unless you have a high-risk Android fleet handling sensitive payments or regulated browser sessions.
3 steps from start to impact.
Land on the Android device
- Target runs Chrome on Android prior to
149.0.7827.53 - Attacker has local foothold on the device or another reliable way to open crafted content in vulnerable Chrome
- Victim uses Chrome rather than another browser
- Enterprise Android fleets often block sideloading and unknown sources
- Play Protect, MDM app allowlisting, and mobile threat defense reduce malicious-app reach
- Android-only scope immediately shrinks the exposed population
Trigger the Payments logic flaw
501738451 remains access-restricted, so exploit details are not public.- Victim opens the crafted page in vulnerable Chrome for Android
- The vulnerable Payments path is reachable in that session
- User interaction occurs, consistent with the
UI:Rvector
- No public exploit recipe lowers copycat risk
- Payments-specific preconditions usually mean more brittle reproduction than generic DOM bugs
- Browser hardening and site isolation reduce adjacent bug chaining value
Exfiltrate whatever cross-origin data is exposed
- Victim has useful session state or sensitive data available to leak
- Outbound network access exists for exfiltration
- The leaked data is valuable enough to matter operationally
- Impact is limited to data exposure, not full browser or device takeover
- No integrity or availability impact is documented
- Per-session targeting makes this much less scalable than wormable or service-side bugs
- Perimeter firewalls do not solve this because the vulnerable surface is the client browser rendering crafted content, not an inbound service port.
- Server-side WAF rules are weak compensation because the attacker-controlled content can be hosted anywhere and the bug lives in Chrome's client logic.
- Password rotation does not address the root issue unless you have evidence specific browser session data was actually exposed.
The supporting signals.
| In-the-wild status | No public evidence of active exploitation found. CISA ADP enrichment marks Exploitation: none, and the CVE is not in KEV. |
|---|---|
| PoC availability | No public PoC or weaponized repo located in accessible sources. The Chromium issue is access-restricted, which usually delays copycat exploit development. |
| EPSS | 0.00008 (*user-supplied intel*), which is effectively floor-level exploitation probability. Percentile was not independently confirmed from accessible FIRST results. |
| KEV status | Not KEV-listed as of 2026-06-06 based on the official CISA KEV catalog and the absence of a KEV reference in the public record. |
| CVSS vector | CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:N/A:N → remote content trigger on paper, but with required user interaction and confidentiality-only impact; the CNA description's *local attacker* wording is the real downward-pressure factor. |
| Affected versions | Google Chrome on Android prior to 149.0.7827.53. |
| Fixed version | Update Chrome on Android to 149.0.7827.53 or later. Desktop 149.0.7827.53/.54 shipped on 2026-06-02; Android 149.0.7827.48 early stable started on 2026-05-28, and the CVE record ties the Android fix boundary to 149.0.7827.53. |
| Exposure/scanning reality | Inference: Shodan/Censys/FOFA/GreyNoise are largely irrelevant here because this is a client-side Android browser flaw, not an internet-facing service. Your exposure question is fleet inventory coverage, not open-port census. |
| Disclosure timeline | CVE published 2026-06-04; NVD last modified 2026-06-06. Google lists the bug as reported by Google on 2026-04-11 in the Chrome 149 stable notes. |
| Researcher / reporter | Reported by Google, not an external researcher bounty submission, per the Chrome 149 stable-channel advisory. |
Sources.
- NVD CVE-2026-11148
- Chrome Releases: Stable Channel Update for Desktop (Chrome 149)
- Chrome Releases: Early Stable Update for Desktop
- Chrome Releases: Chrome for Android Update
- Chromium issue 501738451
- Vulnerability-Lookup entry for CVE-2026-11148
- CISA Known Exploited Vulnerabilities Catalog
- FIRST EPSS API documentation
Why this verdict
- Local-attacker wording cuts hard against urgency — the CNA description itself says *local attacker*, which implies the adversary is already on the handset or has another on-device execution path.
- Android-only client population is narrower — this is not Chrome across all platforms and not a shared server component; only Android Chrome clients below
149.0.7827.53are in scope. - Impact is confidentiality-only — no code execution, no sandbox escape, no persistence, and no availability hit are documented.
- User interaction is still required — the victim must open or engage with crafted content, which reduces automation and mass-exploitation value.
- Threat intel is cold — no KEV entry, no public exploitation evidence, no public PoC, and an extremely low EPSS all argue against near-term attacker demand.
Why not higher?
It does not clear the bar for MEDIUM-or-higher operational urgency because the reachable population is constrained and the attack does not produce device takeover. If this were unauthenticated remote, cross-platform, or paired with public exploitation evidence, the score would climb fast.
Why not lower?
It is still a real same-origin boundary failure in a widely deployed browser, and confidentiality impact can matter if the user is sitting on authenticated sessions. Browser bugs also age poorly once root cause diffing becomes easier after broad patch adoption.
Crowdsourced verification payload.
Run this on an auditor workstation with adb installed and USB debugging or enterprise shell access to the Android device. Invoke it as ./check_chrome_android_cve_2026_11148.sh SERIAL (example: ./check_chrome_android_cve_2026_11148.sh emulator-5554). No root is required, but you need permission to query package metadata on the target device.
#!/usr/bin/env bash
# check_chrome_android_cve_2026_11148.sh
# Checks whether Google Chrome on an attached Android device is below 149.0.7827.53
# Output: VULNERABLE / PATCHED / UNKNOWN
# Exit codes: 0=PATCHED, 1=VULNERABLE, 2=UNKNOWN, 3=usage/dependency error
set -u
FIXED_VERSION="149.0.7827.53"
PACKAGE="com.android.chrome"
usage() {
echo "Usage: $0 <adb-serial>"
exit 3
}
if [ $# -ne 1 ]; then
usage
fi
SERIAL="$1"
if ! command -v adb >/dev/null 2>&1; then
echo "UNKNOWN - adb not found in PATH"
exit 3
fi
adb -s "$SERIAL" get-state >/dev/null 2>&1
if [ $? -ne 0 ]; then
echo "UNKNOWN - device not reachable via adb: $SERIAL"
exit 2
fi
VERSION_LINE=$(adb -s "$SERIAL" shell dumpsys package "$PACKAGE" 2>/dev/null | tr -d '\r' | grep -m1 'versionName=')
if [ -z "$VERSION_LINE" ]; then
echo "UNKNOWN - could not read Chrome package metadata (package missing or restricted)"
exit 2
fi
INSTALLED_VERSION=${VERSION_LINE#*=}
INSTALLED_VERSION=$(echo "$INSTALLED_VERSION" | awk '{print $1}')
normalize_version() {
local ver="$1"
local IFS='.'
local parts
read -r -a parts <<< "$ver"
while [ ${#parts[@]} -lt 4 ]; do
parts+=(0)
done
printf "%d %d %d %d\n" "${parts[0]}" "${parts[1]}" "${parts[2]}" "${parts[3]}"
}
compare_versions() {
# returns 0 if equal, 1 if first > second, 2 if first < second
local a b i
read -r -a a <<< "$(normalize_version "$1")"
read -r -a b <<< "$(normalize_version "$2")"
for i in 0 1 2 3; do
if [ "${a[$i]}" -gt "${b[$i]}" ]; then
return 1
fi
if [ "${a[$i]}" -lt "${b[$i]}" ]; then
return 2
fi
done
return 0
}
compare_versions "$INSTALLED_VERSION" "$FIXED_VERSION"
CMP=$?
if [ $CMP -eq 2 ]; then
echo "VULNERABLE - Chrome $INSTALLED_VERSION < $FIXED_VERSION on device $SERIAL"
exit 1
elif [ $CMP -eq 0 ] || [ $CMP -eq 1 ]; then
echo "PATCHED - Chrome $INSTALLED_VERSION >= $FIXED_VERSION on device $SERIAL"
exit 0
else
echo "UNKNOWN - version comparison failed for $INSTALLED_VERSION"
exit 2
fi