79% frente al 51%: los neobancos independientes quedan atrás en seguridad de aplicaciones. Leer el informe

Análisis a fondo

Análisis a fondo

Evasión de sandbox en Chrome: impacto en Android WebView (CVE-2026-9998)

Chrome 148 corrige dos evasiones de sandbox, incluida una falla de Skia SkSL en Android WebView; corregido en 148.0.7778.215/216, sin explotación conocida.

Resumen

  • Chrome 148 corrigió dos evasiones de sandbox de severidad alta. CVE-2026-9997 es un use-after-free en la ruta de eventos táctiles, y CVE-2026-9998 es un desbordamiento de entero en el compilador SkSL de Skia. Google publicó ambas correcciones el 2026-05-27.
  • CVE-2026-9997 afecta a Chrome de escritorio en Windows, Linux y ChromeOS. CVE-2026-9998 está en Skia y se distribuye con Android WebView, donde el servicio de GPU se ejecuta dentro del proceso de la aplicación.
  • Ninguna de las dos fallas tiene explotación conocida en entornos reales, y ninguna está en el catálogo KEV de la CISA al 2026-11-20. El informe automatizado de Google para CVE-2026-9998 indica que no tenía una prueba de concepto funcional.
  • Actualice Chrome a 148.0.7778.215 (Linux, macOS) o 148.0.7778.216 (Windows), y actualice el proveedor de Android WebView. Consulte «¿Cómo lo corrijo?» para la comprobación de versión en la aplicación.

¿Estoy afectado?

Está afectado cuando ejecuta una versión de Chrome o WebView anterior a la versión corregida de su plataforma, y el atacante ya ha comprometido el renderizador.

  • Su versión de Chrome de escritorio es anterior a 148.0.7778.216 en Windows, o anterior a 148.0.7778.215 en macOS o Linux.
  • Su versión de Chrome para Android es anterior a 148.0.7778.215.
  • Su aplicación Android muestra contenido web con el sistema WebView, y el proveedor WebView del dispositivo es anterior a 148.0.7778.215.
  • Para CVE-2026-9997, el navegador se ejecuta en Windows, Linux o ChromeOS con entrada táctil. Android y WebView no están en el alcance de esa falla.

Ambas son evasiones de sandbox, así que ninguna es un punto de entrada por sí sola. Un atacante necesita un compromiso separado del renderizador para que cualquiera de las dos importe. CVE-2026-9998 alcanza toda versión que compile SkSL, lo que incluye todas las versiones de Chrome y WebView de la tabla.

Chrome representa el 66.97% de los navegadores de escritorio, y Android el 72.39% de la cuota de sistemas operativos móviles (Statcounter, octubre de 2026).

Rama Versiones afectadas Versión corregida
Chrome, Windows anterior a 148.0.7778.216 148.0.7778.216 o 148.0.7778.217
Chrome, macOS anterior a 148.0.7778.215 148.0.7778.215 o 148.0.7778.216
Chrome, Linux anterior a 148.0.7778.215 148.0.7778.215
Chrome para Android anterior a 148.0.7778.215 148.0.7778.215 o posterior
Android WebView anterior a 148.0.7778.215 148.0.7778.215 o posterior

La nota de versión de Google enumera 148.0.7778.215 para Linux, 148.0.7778.215 o 148.0.7778.216 para macOS, y 148.0.7778.216 o 148.0.7778.217 para Windows. Los registros CVE usan el rango único «anterior a 148.0.7778.216», y las versiones Linux, Android y WebView 148.0.7778.215 ya contienen ambas correcciones. ChromeOS aparece como afectado en el informe de CVE-2026-9997, y recibe Chrome mediante su propia actualización de plataforma.

Los demás navegadores basados en Chromium incluyen el mismo motor. El Hong Kong Computer Emergency Response Team Coordination Centre (HKCERT) enumera ambos CVE en su boletín de Edge y da Microsoft Edge 148.0.3967.97 como versión corregida.

Compruebe la versión instalada en el escritorio:

# Linux
google-chrome --version

# macOS
"/Applications/Google Chrome.app/Contents/MacOS/Google Chrome" --version

# Windows PowerShell
(Get-Item "$env:ProgramFiles\Google\Chrome\Application\chrome.exe").VersionInfo.ProductVersion

Compruebe Chrome para Android y el proveedor WebView con ADB:

adb shell dumpsys package com.android.chrome | grep versionName
adb shell dumpsys webviewupdate

La salida de dumpsys webviewupdate tiene una línea que empieza por Current WebView package (name, version):. La versión entre paréntesis es la del proveedor. Una aplicación puede leer el mismo valor en tiempo de ejecución:

val info = WebViewCompat.getCurrentWebViewPackage(context)
Log.i("WebView", "${info?.packageName} ${info?.versionName}")

WebViewCompat.getCurrentWebViewPackage procede de la biblioteca AndroidX WebKit.

¿Cómo lo corrijo?

Instale la versión corregida de Chrome para su plataforma y actualice el proveedor WebView por separado en Android.

  1. En el escritorio, abra chrome://settings/help. Chrome descarga la actualización y ofrece reiniciar.
  2. En Debian o Ubuntu, ejecute sudo apt update && sudo apt install --only-upgrade google-chrome-stable. En Fedora, ejecute sudo dnf upgrade google-chrome-stable.
  3. Reinicie Chrome y confirme que la versión coincide con la versión corregida de su plataforma en la tabla.
  4. En Android, abra Google Play, seleccione Chrome y pulse Actualizar. Compruebe la versión en Ajustes y luego en Acerca de Chrome.
  5. Abra Google Play, seleccione Android System WebView y pulse Actualizar. Confirme la versión del proveedor con adb shell dumpsys webviewupdate.

Una aplicación no puede corregir el motor WebView, porque el proveedor es un paquete de sistema separado. Una aplicación puede negarse a ejecutar flujos sensibles con un proveedor antiguo:

  1. Lea WebViewCompat.getCurrentWebViewPackage al iniciar.
  2. Compare versionName con 148.0.7778.215.
  3. Bloquee el flujo sensible, o muestre una solicitud de actualización, cuando el proveedor sea anterior.

Esa comprobación limita lo que su aplicación muestra en un dispositivo vulnerable. No corrige el motor, y no cubre ninguno de los dos CVE para las demás aplicaciones del mismo dispositivo.

No hay una solución de contingencia que elimine las fallas. Si no puede actualizar todavía, reduzca la probabilidad de un compromiso del renderizador.

  1. Desactive JavaScript para contenido no confiable con WebSettings.setJavaScriptEnabled(false).
  2. Desactive el acceso a archivos con WebSettings.setAllowFileAccess(false).
  3. Limite la navegación a sus propios orígenes en WebViewClient.shouldOverrideUrlLoading.

Esos ajustes no cubren ninguno de los dos CVE. Solo eliminan rutas habituales hacia el compromiso del renderizador que ambas fallas necesitan primero.

¿Cuál es la causa raíz?

CVE-2026-9997 es un use-after-free en el proceso del navegador, y CVE-2026-9998 es un desbordamiento de entero en el compilador que convierte un shader en código de GPU.

La primera falla está en RenderWidgetHostViewAura::ProcessAckedTouchEvent, en content/browser/renderer_host/render_widget_host_view_aura.cc. El navegador acusa recibo de un evento táctil que el renderizador marcó como consumido. Ese acuse envía el gesto generado de forma síncrona. Un cambio de foco o una activación de ventana durante ese envío puede destruir el WebContents, y con él la vista que sigue en la pila.

// content/browser/renderer_host/render_widget_host_view_aura.cc, 148.0.7778.180
window_host->dispatcher()->ProcessedTouchEvent(
    touch.event.unique_touch_event_id, window_, result,
    input::InputEventResultStateIsSetBlocking(ack_result));
if (touch.event.touch_start_or_first_touch_move &&
    result == ui::ER_HANDLED && host()->delegate() &&
    host()->delegate()->GetInputEventRouter()) {

host() lee un miembro a través de this. El objeto es un aura::WindowDelegate, y su ruta de destrucción llama a delete this. Cuando vuelve la llamada síncrona, el objeto puede haber desaparecido, así que la lectura de host() usa memoria liberada.

La misma corrección también cambia TouchEventAckQueue::ProcessAckedTouchEvents en components/input/render_widget_host_input_event_router.cc. Ese código copia un registro AckData que contiene punteros brutos a la vista raíz y a la vista objetivo. Extrae el elemento de la cola y luego llama a la vista raíz. Si esa llamada destruye la vista, los punteros copiados quedan colgantes.

// components/input/render_widget_host_input_event_router.cc, 148.0.7778.180
TouchEventAckQueue::AckData ack_data = ack_queue_.front();
ack_queue_.pop_front();

if ((!touch_emulator ||
     !touch_emulator->HandleTouchEventAck(ack_data.touch_event.event,
                                          ack_data.ack_result)) &&
    (client_->IsViewInMap(ack_data.root_view) ||
     client_->ViewMapIsEmpty())) {
  ack_data.root_view->ProcessAckedTouchEvent(ack_data.touch_event,
                                             ack_data.ack_result);
}

La segunda falla está en calculate_count, en src/sksl/analysis/SkSLGetLoopUnrollInfo.cpp de Skia. SkSL es el lenguaje de shader de Skia, y el compilador desenrolla bucles para que cumplan el requisito ES2. calculate_count estima el número de iteraciones a partir de los límites del bucle. En la revisión vulnerable usaba doble precisión y convertía el resultado a int.

// src/sksl/analysis/SkSLGetLoopUnrollInfo.cpp, Skia a2888b27
static int calculate_count(double start, double end, double delta, bool forwards, bool inclusive) {
    // ...
    double iterations = sk_ieee_double_divide(end - start, delta);
    double count = std::ceil(iterations);
    // ...
    return (int)count;
}

Para for (int i = 2147483640; i < 2147483647; i += 100), el cálculo en doble da ceil(7 / 100), que es 1. En la GPU, i += 100 desborda el entero con signo de 32 bits y vuelve a -2147483556. La condición solo falla exactamente en 2147483647, y los pasos de 100 desde 2147483640 nunca caen en ese valor, así que el bucle nunca termina. El compilador ya lo ha aceptado con un recuento de 1, y un índice como arr[i - 2147483640] sale de la matriz.

¿Cómo se explota?

CVE-2026-9997 convierte un acuse de recibo táctil en un use-after-free en el proceso del navegador, y CVE-2026-9998 convierte un shader en una escritura fuera de límites en el servicio de GPU.

Para CVE-2026-9997:

  1. El atacante compromete el renderizador con otra falla.
  2. El renderizador acusa recibo de un inicio de toque como consumido.
  3. El navegador envía un gesto de forma síncrona, y un cambio de foco destruye la vista.
  4. ProcessAckedTouchEvent desreferencia la vista liberada.
  5. El atacante convierte el use-after-free en ejecución de código en el proceso del navegador, fuera del sandbox del renderizador.

Para CVE-2026-9998:

  1. El atacante compromete el renderizador con otra falla.
  2. El renderizador hace que el servicio de GPU compile un shader con un bucle int cuyos límites desbordan.
  3. El análisis cuenta una iteración en doble precisión, así que el bucle pasa la comprobación de terminación ES2.
  4. La GPU ejecuta el bucle de forma nativa, el índice desborda y la escritura en la matriz sale de los límites.
  5. La escritura corrompe la memoria del servicio de GPU. En WebView, ese servicio se ejecuta en el proceso de la aplicación.

El informe Project Fortify de Google para CVE-2026-9998 califica sus pasos de teóricos. Indica que las herramientas del proyecto no podían ejecutar código ni producir una prueba de concepto funcional. Project Fortify es un proyecto de seguridad experimental de Chrome, y las preguntas frecuentes de Google cubren los informes de seguridad generados por IA que reciben ahora los equipos de Chrome. Google aun así clasificó la falla como alta y publicó la corrección.

¿Cómo se desarrolla el ataque?

Un renderizador comprometido convierte un acuse de recibo táctil o un shader en ejecución de código fuera del sandbox del renderizador. En Android WebView, la ruta del shader termina en el proceso de la aplicación.

flowchart LR A["Renderizador comprometido"] --> B["Acuse de recibo táctil marcado como consumido (CVE-2026-9997)"] A --> C["Shader con un bucle int que desborda (CVE-2026-9998)"] B --> D["Un gesto síncrono destruye la vista Aura"] D --> E["Vista liberada desreferenciada, sin comprobación de vida"] C --> F["SkSL cuenta en dobles, sin comprobación del desbordamiento int32"] F --> G["El bucle se ejecuta, el índice desborda, escritura fuera de límites"] E --> H["Ejecución de código en el proceso del navegador"] G --> I["Ejecución de código en el servicio de GPU (WebView: el proceso de la aplicación)"]

¿Qué puede hacer un atacante?

CVE-2026-9997 da a un atacante que ya ha comprometido el renderizador una ruta hacia la ejecución de código en el proceso del navegador en Windows, Linux y ChromeOS. CVE-2026-9998 da una escritura fuera de límites en el servicio de GPU. El proceso del navegador está fuera del sandbox del renderizador.

El informe describe un use-after-free que el atacante debe convertir en una primitiva de lectura o escritura. El exploit necesita un inicio de toque que el renderizador marque como consumido, y un cambio de foco o de ventana que destruya la vista.

La escritura de CVE-2026-9998 corrompe el servicio de GPU: un proceso separado, fuera del sandbox del renderizador, en Chrome de escritorio, y el propio proceso de la aplicación en Android WebView.

La misma corrupción llega al espacio de direcciones de la aplicación, con sus permisos y sus datos. La escritura apunta a memoria local del shader, y el informe de Google califica la cadena completa de teórica.

Ninguna de las dos fallas da ejecución remota de código por sí sola. El enriquecimiento ADP de la CISA en ambos registros CVE da una puntuación CVSS v3.1 de 8.3, CVSS:3.1/AV:N/AC:H/PR:N/UI:R/S:C/C:H/I:H/A:H.

La complejidad de ataque alta y la interacción del usuario requerida encajan con una cadena que empieza por otra falla del renderizador.

¿Por qué funciona la corrección?

La corrección táctil comprueba que la vista sigue viva después de la llamada síncrona, y la corrección de Skia hace que el análisis de bucles modele el desbordamiento de 32 bits.

Para CVE-2026-9997, la corrección toma un WeakPtr antes del envío y vuelve cuando la fábrica lo ha invalidado:

       CHECK(!sent_ack);
+      auto weak_this = weak_ptr_factory_.GetWeakPtr();
       window_host->dispatcher()->ProcessedTouchEvent(
           touch.event.unique_touch_event_id, window_, result,
           input::InputEventResultStateIsSetBlocking(ack_result));
+      if (!weak_this) {
+        return;
+      }
       if (touch.event.touch_start_or_first_touch_move &&

La fábrica invalida el puntero débil cuando se destruye la vista, así que la función vuelve antes de que host() lea el objeto liberado. La parte del enrutador extrae el elemento de la cola primero y borra target_view al destruirse, así que ningún puntero bruto sobrevive a la llamada.

Para CVE-2026-9998, la corrección añade una ruta de 32 bits para los bucles int:

+static int calculate_count_int(int32_t start, int32_t end, int32_t delta,
+                               Inclusive inclusive) {
+    if (delta == 0) {
+        return kLoopTerminationLimit;
+    }
+    SkSafeMath math;
+    int roundUp = delta > 0 ? math.subInt(delta, 1) : math.addInt(delta, 1);
+    int width = math.subInt(end, start);
+    int iterations = math.addInt(width, roundUp) / delta;
+    // Check that we won't overflow while looping
+    math.addInt(start, math.mulInt(delta, iterations));
+    if (!math || iterations < 0 || iterations > kLoopTerminationLimit) {
+        return kLoopTerminationLimit;
+    }
+    return iterations;
+}

El análisis ahora simula el bucle con aritmética con signo de 32 bits cuando la variable de inducción es un int. SkSafeMath::subInt detecta el caso INT_MIN que la negación del delta perdería. Si el bucle simulado desborda, o si la cuenta supera el límite de 100,000 iteraciones, la función devuelve el límite. El compilador entonces rechaza el bucle con «loop must guarantee termination in fewer iterations».

Los bucles de coma flotante mantienen el cálculo en doble, lo cual es correcto porque los flotantes no desbordan en bucle. La corrección cubre cada operador de comparación que trata el análisis. Google la publicó en 148.0.7778.215 y 148.0.7778.216.

¿Cómo compruebo si estuve comprometido?

No se publican indicadores de compromiso para ninguno de los dos CVE, así que un intento fallido puede no dejar rastro, y uno exitoso necesitaría el compromiso del renderizador que vino primero.

  • En el escritorio, abra chrome://crashes y busque informes de fallo repetidos del proceso de GPU alrededor de una carga de página sospechosa.
  • En Android, ejecute adb logcat -b crash -d | grep -Ei "chromium|webview" y busque fallos del proveedor WebView o de la aplicación.

Un fallo es una pista, no una prueba. Ni los informes de Google ni los registros CVE enumeran archivos, dominios o líneas de registro que comparar.

Cronología

  • 2026-05-14: Project Fortify de Google presenta ambos informes. La nota de versión de Chrome atribuye el hallazgo a Google en esa fecha.
  • 2026-05-19: La corrección principal de CVE-2026-9997 llega a la rama principal.
  • 2026-05-20: Llega la corrección de Skia para CVE-2026-9998, y llega la selección M148 de la corrección táctil.
  • 2026-05-27: Salen Chrome 148.0.7778.215 y 148.0.7778.216, y WebView 148.0.7778.215 llega a Play Store.
  • 2026-05-28: Se publican los registros CVE de ambas fallas.
  • 2026-06-04: El boletín de Edge de HKCERT, actualizado ese día, da Microsoft Edge 148.0.3967.97 como versión corregida.

Chrome publicó las versiones corregidas de escritorio y Android 13 días después de los informes, y los registros CVE llegaron al día siguiente.

Chrome publicó las versiones corregidas 13 días después de los informes de Project Fortify
Figura 1: de los informes de Project Fortify a las versiones corregidas de Chrome y Edge. Fuente: Chrome Releases, commits de Chromium y Skia, Chromium Dash y HKCERT, comprobado el 20 de noviembre de 2026

FAQ

¿CVE-2026-9997 afecta a Android WebView?

No. El informe limita la falla a Aura en Windows, Linux y ChromeOS, y Android usa otra clase de vista. El mismo commit reforzó la cola compartida de acuses de recibo táctiles, pero el use-after-free que da lugar al CVE es solo de escritorio.

¿Se explotó alguna de las dos en entornos reales?

No se informa de explotación conocida. Ninguno de los dos CVE está en el catálogo KEV de la CISA: la versión 2026.11.18 no los enumera. El bloque SSVC de la CISA en cada registro, fechado el 2026-05-29, indica «Exploitation: none».

¿Puede una aplicación Android corregir su propio WebView?

No. WebView es un componente del sistema que Play Store actualiza mediante un paquete proveedor, y la aplicación no puede sustituir el motor. La aplicación puede leer la versión del proveedor y negarse a ejecutar flujos sensibles con una versión antigua.

¿Es CVE-2026-9998 un punto de entrada por sí solo?

No. Es una evasión de sandbox, así que necesita un compromiso separado del renderizador. Por eso el vector CVSS tiene complejidad de ataque alta e interacción del usuario requerida.

¿Por qué una falla de Skia cuenta como evasión de sandbox?

SkSL se compila en el servicio de GPU, que se ejecuta fuera del sandbox del renderizador. En Android WebView, ese servicio se ejecuta en el proceso de la aplicación. La corrupción de memoria en cualquiera de los dos lugares cruza la frontera que traza el sandbox del renderizador.

¿Debo actualizar Chrome si mi aplicación solo usa WebView?

Sí. Chrome y WebView son proveedores separados con actualizaciones separadas en la mayoría de los dispositivos. Actualizar uno no actualiza el otro, así que compruebe ambas versiones.

Referencias

  • Chrome Releases, «Stable Channel Update for Desktop», 27 de mayo de 2026: https://chromereleases.googleblog.com/2026/05/stable-channel-update-for-desktop_0877304591.html (comprobado el 20 de noviembre de 2026)
  • Registro CVE-2026-9997, CVE Program: https://www.cve.org/CVERecord?id=CVE-2026-9997 (comprobado el 20 de noviembre de 2026)
  • Registro CVE-2026-9998, CVE Program: https://www.cve.org/CVERecord?id=CVE-2026-9998 (comprobado el 20 de noviembre de 2026)
  • Corrección de Chromium para CVE-2026-9997, commit a1542142, 20 de mayo de 2026: https://chromium.googlesource.com/chromium/src/+/a154214297dcc12c53161999c010d66472127bad (comprobado el 20 de noviembre de 2026)
  • Corrección de Skia para CVE-2026-9998, commit f219800, 20 de mayo de 2026: https://skia.googlesource.com/skia/+/f21980088d33692a6191dc55f156eb1e3b9fbf40 (comprobado el 20 de noviembre de 2026)
  • Informe Project Fortify para CVE-2026-9997, Chromium issue 513324041: https://issues.chromium.org/issues/513324041 (comprobado el 20 de noviembre de 2026)
  • Informe Project Fortify para CVE-2026-9998, Chromium issue 513337118: https://issues.chromium.org/issues/513337118 (comprobado el 20 de noviembre de 2026)
  • Documentación de Chromium, «Android WebView Architecture»: https://chromium.googlesource.com/chromium/src/+/HEAD/android_webview/docs/architecture.md (comprobado el 20 de noviembre de 2026)
  • Chrome Security Team, «AI-generated security bugs FAQ», abril de 2026: https://chromium.googlesource.com/chromium/src/+/main/docs/security/ai-generated-security-bugs-faq.md (comprobado el 20 de noviembre de 2026)
  • Chromium Dash, versiones estables de WebView: https://chromiumdash.appspot.com/releases?platform=Webview (comprobado el 20 de noviembre de 2026)
  • CISA, catálogo Known Exploited Vulnerabilities, versión 2026.11.18: https://www.cisa.gov/known-exploited-vulnerabilities-catalog (comprobado el 20 de noviembre de 2026)
  • Statcounter, cuota de mercado de navegadores de escritorio, octubre de 2026: https://gs.statcounter.com/browser-market-share/desktop/worldwide (comprobado el 20 de noviembre de 2026)
  • Statcounter, cuota de mercado de sistemas operativos móviles, octubre de 2026: https://gs.statcounter.com/os-market-share/mobile/worldwide (comprobado el 20 de noviembre de 2026)
  • HKCERT, «Microsoft Edge Multiple Vulnerabilities», 29 de mayo de 2026, actualizado el 4 de junio de 2026: https://www.hkcert.org/security-bulletin/microsoft-edge-multiple-vulnerabilities_20260529 (comprobado el 20 de noviembre de 2026)
  • Android Developers, «WebViewCompat»: https://developer.android.com/reference/androidx/webkit/WebViewCompat (comprobado el 20 de noviembre de 2026)