Back to Intelligence

Chrome 158.0.8127.42 for Android Released: Security Fixes Synced from Desktop 158 — Patch Now

SA
Security Arsenal Team
November 18, 2026
10 min read

Google has released Chrome 158.0.8127.42 for Android, rolling out via Google Play over the next several days. While the official announcement emphasizes stability and performance improvements, the critical detail for defenders is buried in the advisory: Android releases contain the same security fixes as their corresponding Desktop releases — specifically Windows/Mac 158.0.8127.36/.37 and Linux 158.0.8127.36.

This synchronization model means that any vulnerabilities patched in the Desktop 158 release are now also patched on Android. For enterprises managing BYOD or corporate-owned Android devices, this update is not optional maintenance — it is a security patch cycle that closes the same attack surface threat actors exploit on desktop platforms. Mobile browsers are increasingly targeted for credential theft, session hijacking, and drive-by exploitation, particularly in phishing campaigns that bypass traditional email gateways by shifting to SMS (smishing) and malicious mobile ads.

The urgency is straightforward: if your desktop fleet required patching for Chrome 158, your Android fleet requires the same attention. Delayed mobile browser updates create a persistent gap in your endpoint security posture, especially for users accessing SaaS applications, corporate email, and VPN portals from mobile devices.

Technical Analysis

Affected Products and Versions

  • Product: Google Chrome for Android
  • Patched Version: 158.0.8127.42
  • Corresponding Desktop Versions:
    • Windows & Mac: 158.0.8127.36 / 158.0.8127.37
    • Linux: 158.0.8127.36
  • Platform: Android (all versions supported by current Chrome releases)

Vulnerability Details

Google's Chrome releases blog does not enumerate specific CVEs in this announcement, but the synchronized release model confirms that security fixes from Desktop 158 are included. Historically, Chrome stable channel updates address a mix of:

  • Use-after-free vulnerabilities in rendering engines (Blink, V8)
  • Type confusion flaws in JavaScript execution
  • Sandbox escapes via compromised renderer processes
  • Origin bypass and spoofing issues in WebContents or navigation handling
  • Out-of-bounds memory access in media codecs, WebRTC, or graphics processing (Skia, ANGLE)

Without a detailed CVE list in this announcement, defenders should consult the Chrome Desktop 158 release notes and the Chrome Security Release Notes for the full vulnerability inventory. Enterprises with threat intelligence feeds should cross-reference any CVEs listed in the Desktop 158 advisory against CISA KEV and exploit broker activity.

Attack Surface and Exploitation Context

Mobile Chrome is exposed to the same web-based attack vectors as desktop Chrome:

  • Drive-by downloads: Malicious ads (malvertising) or compromised websites serving exploit kits
  • Phishing and credential harvesting: Fake login portals delivered via SMS, QR codes, or social media
  • Watering hole attacks: Industry-specific or region-specific sites compromised to target mobile users
  • Zero-click exploitation: While rare, browser vulnerabilities can be chained with OS-level flaws (e.g., WebKit or Chromium renderer + Android kernel) for full device compromise

Android Chrome is particularly attractive to attackers because:

  • Mobile devices often have weaker endpoint detection compared to workstations
  • Users are more likely to dismiss or delay updates on mobile platforms
  • Mobile browsers handle sensitive authentication tokens (OAuth, SAML, session cookies) for cloud apps
  • Android fragmentation means patch lag across carriers and OEMs

Exploitation Status

As of this writing, Google has not disclosed whether any of the vulnerabilities fixed in Chrome 158 are under active exploitation. However, the synchronized release pattern and the absence of a detailed CVE list suggest a routine security patch cycle rather than an emergency out-of-band fix. That said, browser vulnerabilities are frequently weaponized within days of public disclosure, especially when exploit code is traded in underground forums or integrated into commercial exploit kits.

Defenders should monitor:

  • CISA Known Exploited Vulnerabilities (KEV) catalog for any Chrome 158-related CVEs
  • Google's Chrome Security Release Notes for post-release updates on exploitation
  • Threat intelligence feeds for indicators of exploit kit integration or in-the-wild PoCs

Detection & Response

This is a technical threat (browser vulnerability patching), so detection content is provided below. The focus is on identifying outdated Chrome versions across your managed Android and desktop fleet, as well as hunting for post-exploitation behaviors commonly seen after browser compromise.

Sigma Rules

The following Sigma rules detect suspicious process execution and network activity associated with browser exploitation or post-compromise actions. These are tuned to minimize false positives by focusing on anomalous child processes and uncommon network destinations.

YAML
---
title: Chrome Renderer Spawning Suspicious Child Process
id: 3f8a1c92-7d4e-4b6a-9c1f-2e5d8a3b6f01
status: experimental
description: Detects Chrome renderer process spawning command shells, scripting engines, or unexpected binaries — a common indicator of successful browser exploitation or sandbox escape.
references:
  - https://attack.mitre.org/techniques/T1203/
  - https://attack.mitre.org/techniques/T1059/
author: Security Arsenal
date: 2026/11/02
tags:
  - attack.execution
  - attack.t1203
  - attack.t1059
logsource:
  category: process_creation
  product: windows
detection:
  selection_parent:
    ParentImage|endswith:
      - '\chrome.exe'
  selection_child:
    Image|endswith:
      - '\cmd.exe'
      - '\powershell.exe'
      - '\wscript.exe'
      - '\cscript.exe'
      - '\mshta.exe'
      - '\rundll32.exe'
      - '\regsvr32.exe'
  condition: selection_parent and selection_child
falsepositives:
  - Rare legitimate browser extensions or enterprise tools
  - Developer debugging workflows
level: high
---
title: Chrome Network Connection to Rare External IP
id: 9a2f5d81-4c6b-4e9a-b3d7-1f8e2a6c9d04
status: experimental
description: Detects Chrome browser establishing network connections to IP addresses not associated with common CDNs or known-good infrastructure. Useful for identifying C2 callbacks or data exfiltration post-exploitation.
references:
  - https://attack.mitre.org/techniques/T1071/
  - https://attack.mitre.org/techniques/T1041/
author: Security Arsenal
date: 2026/11/02
tags:
  - attack.command_and_control
  - attack.exfiltration
  - attack.t1071.001
logsource:
  category: network_connection
  product: windows
detection:
  selection:
    Image|endswith: '\chrome.exe'
    Initiated: 'true'
  filter_common:
    DestinationIp|startswith:
      - '142.250.'  # Google
      - '172.217.'  # Google
      - '13.107.'   # Microsoft
      - '152.199.'  # Azure CDN
      - '151.101.'  # Fastly
      - '104.16.'   # Cloudflare
  condition: selection and not filter_common
falsepositives:
  - Legitimate but uncommon web services
  - Regional or niche CDN providers
  - Corporate intranet or partner sites
level: medium
---
title: Chrome Executable Launched from Unusual Path
id: 5c1e9a47-8f3d-4b2e-a6f9-3d7b1e5c8a02
status: experimental
description: Detects Chrome executable running from non-standard installation directories, which may indicate a fake browser, sideloaded payload, or malware masquerading as Chrome.
references:
  - https://attack.mitre.org/techniques/T1036/
author: Security Arsenal
date: 2026/11/02
tags:
  - attack.defense_evasion
  - attack.t1036.005
logsource:
  category: process_creation
  product: windows
detection:
  selection:
    Image|endswith: '\chrome.exe'
  filter_legitimate:
    Image|startswith:
      - 'C:\Program Files\Google\Chrome\Application\'
      - 'C:\Program Files (x86)\Google\Chrome\Application\'
      - 'C:\Users\'
  condition: selection and not filter_legitimate
falsepositives:
  - Portable Chrome installations
  - Enterprise deployment tools using custom paths
level: high

KQL (Microsoft Sentinel / Defender)

This KQL query hunts for outdated Chrome versions on Windows endpoints. It can be adapted for Android by querying mobile device management (MDM) inventory tables if integrated with Sentinel.

KQL — Microsoft Sentinel / Defender
// Hunt for outdated Chrome installations on Windows endpoints
// Adjust version threshold as needed based on current patch level
let CurrentChromeVersion = "158.0.8127.42";
DeviceProcessEvents
| where FileName =~ "chrome.exe"
| where ProcessVersionInfoProductName =~ "Google Chrome"
| extend ChromeVersion = ProcessVersionInfoProductVersion
| where ChromeVersion != CurrentChromeVersion
| summarize LatestExecution = max(TimeGenerated), 
            DeviceCount = dcount(DeviceId), 
            Versions = make_set(ChromeVersion) 
            by DeviceName, ChromeVersion
| order by DeviceCount desc
| project DeviceName, ChromeVersion, LatestExecution, DeviceCount

// Alternative: Hunt for Chrome spawning suspicious child processes
DeviceProcessEvents
| where InitiatingProcessFileName =~ "chrome.exe"
| where FileName in~ ("cmd.exe", "powershell.exe", "wscript.exe", "cscript.exe", "mshta.exe", "rundll32.exe")
| project TimeGenerated, DeviceName, InitiatingProcessCommandLine, FileName, ProcessCommandLine, AccountName
| order by TimeGenerated desc

// Hunt for Chrome network connections to rare external IPs (requires baseline tuning)
DeviceNetworkEvents
| where InitiatingProcessFileName =~ "chrome.exe"
| where RemoteIPType == "Public"
| summarize ConnectionCount = count() by RemoteIP, RemoteUrl, DeviceName
| where ConnectionCount < 5  // Rare connections
| order by ConnectionCount asc

Velociraptor VQL

This VQL artifact hunts for Chrome processes running from unexpected paths or spawning suspicious child processes across a fleet.

VQL — Velociraptor
-- Hunt for Chrome processes with suspicious parent-child relationships or unusual paths
SELECT 
    Pid,
    Name,
    Exe,
    CommandLine,
    Username,
    CreateTime,
    Ppid,
    pslist(pid=Ppid).Name AS ParentName,
    pslist(pid=Ppid).Exe AS ParentExe
FROM pslist()
WHERE 
    (Name =~ 'chrome' AND ParentName =~ 'chrome')  -- Chrome spawning Chrome
    OR (ParentName =~ 'chrome' AND Name =~ '(cmd|powershell|wscript|cscript|mshta|rundll32)')  -- Chrome spawning shells
    OR (Name =~ 'chrome' AND Exe !~ 'Program Files')  -- Chrome from unusual path
ORDER BY CreateTime DESC

-- Hunt for Chrome network connections to external IPs
SELECT 
    Pid,
    Name,
    Exe,
    CommandLine,
    netstat(pid=Pid).RemoteAddr AS RemoteAddr,
    netstat(pid=Pid).RemotePort AS RemotePort,
    netstat(pid=Pid).Status AS ConnectionStatus
FROM pslist()
WHERE Name =~ 'chrome' AND netstat(pid=Pid).RemoteAddr !~ '^(10\.|172\.16\.|192\.168\.|127\.)'

Remediation Script

The following PowerShell script checks the installed Chrome version on Windows endpoints and flags devices running outdated versions. For Android, use your MDM platform (Intune, Workspace ONE, etc.) to enforce minimum version compliance.

PowerShell
# Check Chrome version on Windows endpoint
$CurrentVersion = "158.0.8127.42"
$ChromePath = "C:\Program Files\Google\Chrome\Application\chrome.exe"

if (Test-Path $ChromePath) {
    $InstalledVersion = (Get-Item $ChromePath).VersionInfo.ProductVersion
    Write-Output "Installed Chrome version: $InstalledVersion"
    
    if ([version]$InstalledVersion -lt [version]$CurrentVersion) {
        Write-Output "ALERT: Chrome is outdated. Current version is $CurrentVersion. Please update immediately."
        # Optionally trigger update
        # Start-Process "$env:ProgramFiles\Google\Update\GoogleUpdate.exe" -ArgumentList "/ua"
    } else {
        Write-Output "Chrome is up to date."
    }
} else {
    Write-Output "Chrome not found at expected path: $ChromePath"
}

# For Android devices, use MDM compliance policies to enforce minimum Chrome version
# Example (Intune): Set minimum version to 158.0.8127.42 in app configuration policy

Remediation

Immediate Actions

  1. Patch Android Devices:

    • Instruct users to update Chrome via Google Play Store
    • For managed devices, use your MDM platform to enforce app updates or push the update directly
    • Set a compliance policy requiring Chrome version 158.0.8127.42 or higher
  2. Patch Desktop Browsers:

    • Ensure all Windows, Mac, and Linux endpoints are running Chrome 158.0.8127.36/.37 or higher
    • Use enterprise software deployment tools (SCCM, Intune, Jamf, etc.) to push updates if auto-update is disabled
  3. Verify Patch Compliance:

    • Run the PowerShell script above across your Windows fleet
    • Query your MDM for Android devices not yet on 158.0.8127.42
    • Generate a compliance report and escalate devices that remain unpatched after 72 hours

Configuration Hardening

  • Enable Chrome Safe Browsing (Enhanced Protection): Provides real-time protection against malicious sites and downloads
  • Block Third-Party Cookies: Reduces tracking and some attack vectors
  • Enforce HTTPS-Only Mode: Prevents downgrade attacks
  • Disable Unnecessary Extensions: Audit and remove unused or high-risk browser extensions
  • Enable Site Isolation: Enabled by default, but verify via enterprise policy

Mobile-Specific Controls

  • Enforce Device Encryption: Require full-disk encryption on all Android devices
  • Enable Google Play Protect: Ensure Play Protect is active and scanning for malicious apps
  • Restrict Sideloading: Block installation of apps from unknown sources
  • Use Mobile Threat Defense (MTD): Deploy MTD solutions (Lookout, Zimperium, Microsoft Defender for Endpoint) to detect exploit attempts and malicious apps

Monitoring and Detection

  • Enable Enhanced Logging: Ensure Chrome telemetry and Safe Browsing logs are forwarded to your SIEM
  • Deploy the Sigma rules above to detect post-exploitation behaviors
  • Hunt for outdated versions using the KQL query provided
  • Monitor CISA KEV for any Chrome 158-related CVEs added to the catalog

Vendor Advisory and Resources

Workarounds

If immediate patching is not possible (e.g., legacy application dependencies, testing requirements), implement compensating controls:

  • Network Segmentation: Isolate unpatched devices from critical internal resources
  • Web Filtering: Use a secure web gateway (SWG) to block known malicious domains and exploit kits
  • Browser Isolation: Consider remote browser isolation (RBI) for high-risk users or unpatched devices
  • Application Whitelisting: Restrict which applications can execute on endpoints to prevent post-exploitation payloads

However, workarounds are not a substitute for patching. Chrome updates are cumulative and address multiple vulnerabilities. Delaying updates increases risk exposure.

Related Resources

Security Arsenal Penetration Testing Services AlertMonitor Platform Book a SOC Assessment vulnerability-management Intel Hub

Is your security operations ready?

Get a free SOC assessment or see how AlertMonitor cuts through alert noise with automated triage.