¿Cómo se solucionan los errores de redirección en WebView en Android e iOS? Identifica si el fallo involucra una navegación HTTPS estándar, un esquema de URL personalizado, una URI intent:// de Android o una solicitud de ventana nueva; luego, inspecciona la navegación a través de Chrome DevTools o Safari Web Inspector y rastrea el delegado nativo correspondiente (shouldOverrideUrlLoading, onCreateWindow, decidePolicyForNavigationAction o createWebViewWith). Verifica la resolución de la aplicación de destino, las listas permitidas de URI, las políticas de marcos e interacción del usuario, y el enrutamiento de respaldo para aislar los errores a nivel de contenedor de los fallos de distribución del sistema operativo.
Se produce un error de redirección en WebView cuando un Chromium WebView integrado en Android o un WKWebView de WebKit en iOS no puede enrutar una solicitud de navegación hacia su destino previsto. Las causas típicas incluyen esquemas de URL personalizados no compatibles, solicitudes
target="_blank"no manejadas, declaraciones faltantes de visibilidad de paquetes y redirecciones de respaldo rechazadas o en bucle.
Por qué los contenedores integrados Android WebView y iOS WKWebView descartan redirecciones

Al depurar fallos de redirección, los equipos de ingeniería deben separar el comportamiento del motor de WebView (cómo Chromium o WebKit analiza las URL, los destinos de marcos y los eventos emergentes) de la política de la aplicación host (cómo el WebViewClient, WebChromeClient, WKNavigationDelegate o WKUIDelegate proporcionados por la aplicación evalúan los tipos de interacción del usuario, las listas permitidas y las transferencias a aplicaciones externas). Los navegadores independientes incluyen despachadores de URI integrados y controladores de transferencia de enlaces, mientras que android.webkit.WebView y WKWebView de Apple son componentes de renderizado integrados que esperan respuestas de red estándar http:// o https:// de forma predeterminada.
Cuando una página web activa un esquema personalizado (como myapp://product/42) o un enlace intent:// de Android sin una anulación de delegado activa, el comportamiento predeterminado del contenedor diverge entre plataformas:
- Android Chromium WebView: Según la especificación de
WebViewClientde Android, si no se asigna unWebViewClientpersonalizado, WebView puede pedir al Administrador de Actividades que resuelva la URL a través de los controladores del sistema disponibles. Cuando sí se asigna unWebViewClientpersonalizado yshouldOverrideUrlLoadingdevuelvefalsepara un esquema personalizado no compatible, WebView continúa cargándola dentro de Chromium y renderizanet::ERR_UNKNOWN_URL_SCHEME. - iOS WebKit WKWebView: WebKit rechaza internamente los esquemas que no son HTTP y anula la navegación a menos que el
WKNavigationDelegatedel host intercepte la solicitud y la reenvíe aUIApplication, fallando a menudo de forma silenciosa o generandoNSURLErrorUnsupportedURL.
Tenga en cuenta también que la función Promoción de aplicaciones con banners de aplicaciones inteligentes de Apple es una función de soporte de Safari diseñada para la navegación independiente en Safari en lugar de una API de navegación integrada de WKWebView, y debe evaluarse por separado de las redirecciones de esquemas de URL personalizados dentro de la aplicación.
De un vistazo
- Separar el comportamiento del motor de la política del host: Aísle si una navegación falló dentro del motor web (Chromium/WebKit), dentro de las anulaciones de delegados nativos o en el límite de resolución de paquetes del sistema operativo.
- Inspeccionar redirecciones en vivo antes de programar: Utilice Chrome DevTools (
chrome://inspect) y Safari Web Inspector (isInspectable = true) para capturar cadenas de redirección 3xx, estados detargetFramee indicadores de gestos. - Aplicar validación de URI e intent adecuada para la plataforma: En Android, vincule esquemas personalizados y destinos
intent://1 a 1 con paquetes verificados medianteIntentSanitizersin indicadores de tareas proporcionados por la página web; en iOS, valide estructuras de URI personalizadas completas (confiando en Enlaces Universales donde se requiere identidad verificada de aplicación a dominio) y rechace claves de consulta duplicadas en ambas plataformas. - Aplicar defensa en profundidad para ventanas emergentes y condiciones de carrera: Confine el estado de sesión de las ventanas emergentes de Android estrictamente al hilo de la interfaz de usuario mientras comprende los límites de devolución de llamada en
shouldInterceptRequestyshouldOverrideUrlLoading, y separe las comprobaciones de política pura de los efectos secundarios de despacho externo enWKWebViewde iOS utilizando la deduplicación a nivel de acción y los tokens de generación de navegación.
Causas comunes y pasos de verificación para errores de redirección en WebView
Mapeo de errores de cliente observados a mecanismos subyacentes de fallo del contenedor
Utilice la matriz de diagnóstico a continuación para relacionar los síntomas observados en WebView con las causas raíz comunes de la plataforma, los pasos de verificación y las correcciones específicas:
| Síntoma o error observado | Plataforma de destino | Causa raíz común | Paso de verificación de diagnóstico | Corrección específica |
|---|---|---|---|---|
WebView muestra net::ERR_UNKNOWN_URL_SCHEME |
Android WebView | Un WebViewClient personalizado devuelve false o carece de lista permitida de esquemas |
Inspeccionar request.url en shouldOverrideUrlLoading |
Interceptar URI en lista blanca y enviar Intent.ACTION_VIEW vinculado 1 a 1 al paquete |
| Bloqueo silencioso al tocar un enlace de esquema personalizado | iOS WKWebView | WebKit anula la URI que no es HTTP cuando WKNavigationDelegate devuelve .allow |
Registrar navigationAction.request.url en decidePolicyForNavigationAction |
Enrutar esquemas validados mediante UIApplication.shared.open y pasar .cancel |
target="_blank" reemplaza la página actual en WebView |
Android WebView | setSupportMultipleWindows(false) trata las nuevas ventanas como cargas de nivel superior |
Comprobar webView.settings.supportMultipleWindows() |
Habilitar setSupportMultipleWindows(true) solo si se necesitan contenedores emergentes separados |
target="_blank" no hace nada o descarta redirecciones OAuth 302 |
Android WebView | Falta onCreateWindow, o el cliente secundario bloquea saltos isRedirect que carecen de hasGesture() |
Comprobar registros de onCreateWindow, request.isRedirect y shouldInterceptRequest |
Adjuntar un WebView emergente alojado en vista con estado de sesión en el hilo de la interfaz de usuario y saltos isRedirect acotados |
El enlace con target="_blank" o window.open() no hace nada |
iOS WKWebView | La navegación de ventana nueva establece targetFrame == nil y requiere WKUIDelegate |
Comprobar navigationAction.targetFrame == nil |
Detectar targetFrame == nil en decidePolicyForNavigationAction y manejar mediante WKUIDelegate |
| La aplicación de destino está instalada, pero se abre la página de respaldo | Android 11+ (targetSdk >= 30) |
Faltan declaraciones <queries> que hacen que resolveActivity() o queryIntentActivities() devuelvan resultados incompletos para paquetes invisibles |
Añadir registro a nivel de aplicación alrededor de resolveActivity() e inspeccionar la salida mediante adb logcat |
Declarar intents <queries> si se realiza una comprobación previa, o invocar startActivity directamente con captura de ActivityNotFoundException |
| La redirección del temporizador de JavaScript no abre la aplicación externa | iOS / Android | La redirección de scripts automatizados carece de una señal de interacción del usuario | Comprobar request.hasGesture() (Android) o navigationType (iOS) |
Vincular las redirecciones a toques directos del usuario y definir una política explícita de gestos del host |
El Enlace Universal se carga dentro de WKWebView en lugar de la aplicación de destino |
iOS WKWebView | El contexto de navegación, la relación de dominio o la navegación JS mantienen la carga en WebKit | Comprobar navigationType y host en decidePolicyForNavigationAction |
Llamar a UIApplication.shared.open con .universalLinksOnly: true para hosts externos permitidos |
Lista de comprobación rápida de cinco minutos para redirecciones en WebView
- Paso 1: Comprobar el esquema de protocolo en DevTools: Verifique si la página emitió una URI
https://, un esquema personalizado ointent://, y confirme que no fue bloqueada por la Política de Seguridad de Contenido (CSP). - Paso 2: Inspeccionar la jerarquía de marcos: Compruebe si el activador se originó dentro de un
<iframe>de terceros (!isMainFrame). Las aplicaciones host pueden bloquear intencionalmente lanzamientos de aplicaciones externas iniciados desde iframes de terceros. - Paso 3: Distinguir redirecciones de temporizadores: Compruebe si una navegación sin gestos es una redirección de servidor HTTP 3xx autorizada (
request.isRedirecten Android) frente a un temporizador de JavaScript no solicitado. - Paso 4: Comprobar activadores de nuevas ventanas: Confirme si
target="_blank"owindow.open()creó una solicitud de ventana nueva (targetFrame == nilen iOS oonCreateWindowen Android). - Paso 5: Verificar la resolución de paquetes del sistema operativo: Para aplicaciones dirigidas a la API 30+ en Android 11+, confirme si las llamadas de pre-evaluación
resolveActivity()están fallando debido a declaraciones<queries>faltantes.
El siguiente flujo de trabajo de diagnóstico ilustra la ruta de triaje secuencial para aislar los fallos de redirección del contenedor:
[WebView Navigation Failure]
│
▼
[Inspect URL + Network + Console via Chrome DevTools / Safari Web Inspector]
│
▼
[Identify Navigation Source]
│
├── App loadUrl() or HTTP POST
│ │
│ └── shouldOverrideUrlLoading is NOT invoked; inspect host-side call path
│
├── target="_blank" or window.open()
│ │
│ ├── Android (multiple-windows=false) ──> Replaces current WebView page
│ ├── Android (multiple-windows=true) ──> Inspect onCreateWindow + shouldInterceptRequest
│ └── iOS (targetFrame == nil) ──> Inspect WKNavigationDelegate + WKUIDelegate
│
├── HTTP / HTTPS Navigation
│ │
│ └── Inspect Host + Port Allowlist, 3xx Redirects, Universal Link, or App Link matching
│
└── Custom Scheme or Chrome intent://
│
├── Evaluate User Interaction + Main Frame policy
├── Verify Full URI Structure (Scheme, Host, Port, Path, No Duplicate Query Keys)
├── Sanitize Intent (Reject Explicit Components, Verify 1-to-1 Package, Zero Webpage Flags)
├── Check Target-App Resolution (<queries> / ActivityNotFoundException)
└── Validate Fallback Path + Query Allowlist + Monotonic Chain Guard (elapsedRealtime)
Cómo inspeccionar eventos de navegación en WebView utilizando herramientas de depuración remota
Habilitación de la depuración remota mediante Chrome DevTools y ADB Logcat en Android
Antes de modificar los delegados nativos, verifique si la página web cargada emite la redirección esperada. Según la guía de depuración remota de Chrome DevTools para Android, habilite explícitamente la depuración remota de WebView en las compilaciones de desarrollo inspeccionando ApplicationInfo.FLAG_DEBUGGABLE e invocando WebView.setWebContentsDebuggingEnabled(true). Nunca envíe la depuración habilitada en versiones de producción:
// Android - Enable WebView debugging exclusively in debuggable builds
if (applicationInfo.flags and ApplicationInfo.FLAG_DEBUGGABLE != 0) {
WebView.setWebContentsDebuggingEnabled(true)
}
Conecte el dispositivo mediante USB, abra chrome://inspect/#devices en el Chrome de escritorio y supervise la pestaña Network con Preserve log marcado. Filtre simultáneamente los registros de tiempo de ejecución nativos a través de adb logcat para capturar ActivityNotFoundException, SecurityException o registros de contenedor personalizados. Tenga en cuenta que las advertencias de obsolescencia para la firma heredada shouldOverrideUrlLoading(WebView, String) aparecen durante la compilación de Android Studio / Gradle en lugar de en el tiempo de ejecución de adb logcat:
# Terminal - Filter logcat for custom WebView tags and ActivityTaskManager intent resolution
adb logcat -s "WebViewDebug" "ActivityTaskManager" "PackageManager"
Configuración de isInspectable y conexión de Safari Web Inspector y la consola de Xcode en iOS
A partir de iOS 16.4 y macOS 13.3, Apple requiere que las aplicaciones opten por el uso de WKWebView.isInspectable, que por defecto es false. Habilite webView.isInspectable = true dentro de los bloques #if DEBUG:
// iOS - Enable Safari Web Inspector opt-in on iOS 16.4+ debug builds
#if DEBUG
if #available(iOS 16.4, *) {
webView.isInspectable = true
}
#endif
En el dispositivo iOS físico, navegue a Configuración > Aplicaciones > Safari > Avanzado (en versiones de iOS anteriores, Configuración > Safari > Avanzado) y habilite Web Inspector. Conéctese mediante USB, abra el menú Develop de Safari de escritorio y supervise la Consola de Xcode simultáneamente para ver los resultados nativos de la finalización de decidePolicyForNavigationAction, createWebViewWith y UIApplication.shared.open.

Resolución de caídas silenciosas de nuevas ventanas y gestos de usuario faltantes en iOS WKWebView
Separación de la evaluación de políticas de los efectos secundarios en WKNavigationDelegate y WKUIDelegate
Cuando un enlace web especifica target="_blank" o window.open(), WebKit crea una solicitud de navegación de ventana nueva donde navigationAction.targetFrame es nil e involucra tanto a WKNavigationDelegate como a WKUIDelegate. Si la aplicación host no implementa webView(_:createWebViewWithConfiguration:for:windowFeatures:), WebKit no puede generar un WebView secundario y las navegaciones pueden parecer fallar en silencio.
Para evitar lanzamientos duplicados de aplicaciones externas o tokens de generación incrementados dobles cuando ambos delegados inspeccionan una solicitud, separe la evaluación de políticas puras (evaluateNavigationPolicy) de los efectos secundarios de ejecución, y deduplique por la instancia específica de WKNavigationAction (ObjectIdentifier(navigationAction)) en lugar de depender puramente de un umbral de tiempo aproximado que podría suprimir los clics rápidos repetidos intencionales de un usuario. Evalúe navigationAction.targetFrame == nil directamente en decidePolicyForNavigationAction: si la evaluación devuelve un plan de transferencia externo, ejecútelo una vez (registrando el identificador de WKNavigationAction) y pase .cancel; si devuelve .allowInWebView para una URL emergente en lista blanca, pase .allow para que createWebViewWith cargue la ventana emergente de forma segura. Verifique siempre el orden exacto de las devoluciones de llamada de los delegados en las versiones de iOS de destino.
Contexto de enlaces universales, seguridad contra carreras asíncronas e identidad de esquemas personalizados
La transferencia de enlaces universales depende del contexto de navegación de origen, la relación de dominio y la configuración de dominios asociados (verificada a través del archivo apple-app-site-association del servidor de destino). La nota técnica TN3155: Depuración de enlaces universales de Apple documenta cómo la navegación en el mismo dominio en Safari prefiere permanecer en el navegador, mientras que los subdominantes distintos alteran la elegibilidad. Pruebe siempre el comportamiento de los dominios asociados en las versiones de iOS de destino dentro de WKWebView.
Al llamar a UIApplication.shared.open(url, options: [.universalLinksOnly: true]), protéjase contra condiciones de carrera de navegación asíncronas: si un usuario inicia cualquier intento posterior de navegación en el marco principal mientras el sistema procesa la transferencia del enlace universal, un controlador de finalización no protegido que devuelva false podría sobrescribir el estado de navegación más nuevo del usuario. Incremente un token monotónico activeNavigationGeneration en cada nueva evaluación de navegación del marco principal (incluidos los intentos bloqueados o redirigidos) para que cualquier respaldo asincrónico anterior pendiente quede invalidado inmediatamente, y verifique self.activeNavigationGeneration == requestGeneration junto con self.isViewLoaded && self.view.window != nil antes de volver a cargar las URL de respaldo.
Observe dos límites estrictos de seguridad:
- Clasificación de
WKNavigationType: Según la documentación deWKNavigationTypede Apple,formSubmittedrepresenta una solicitud para enviar un formulario en lugar de un toque de enlace, y los scripts de página pueden enviar formularios mediante programación. Restrinja las transferencias de aplicaciones externas a eventos.linkActivatedclasificados por WebKit combinados consourceFrame.isMainFramey listas completas de URI permitidas, en lugar de tratar.linkActivatedcomo un token de gesto criptográfico aislado. - Unicidad de esquemas personalizados y contaminación de parámetros: Según la guía de Apple sobre Definición de un esquema de URL personalizado para su aplicación, varias aplicaciones pueden reclamar el mismo esquema personalizado.
isAllowedCustomURL(_:)valida la estructura de la URI (esquema, host, puerto predeterminadonil, patrón de ruta, sin información de usuario/fragmento, y rechaza claves de consulta duplicadas), no la identidad del ID de paquete de destino. Utilice enlaces universales verificados por dominio siempre que se requiera la vinculación de la identidad de la aplicación.
Descargo de responsabilidad de la arquitectura de referencia: La siguiente implementación es una arquitectura de referencia defensiva. Valide la disponibilidad de la API, el orden de los delegados y el comportamiento del ciclo de vida frente a las versiones exactas de AndroidX e iOS utilizadas por su aplicación.
// iOS - WebViewContainerController.swift
// Reference architecture: compile and test against your specific project targets (iOS 15.0–18.0)
import UIKit
import WebKit
final class WebViewContainerController: UIViewController, WKNavigationDelegate, WKUIDelegate {
private enum NavigationPlan: Equatable {
case allowInWebView
case launchCustomScheme(URL)
case attemptUniversalLink(URL)
case block
}
private var webView: WKWebView!
// Explicit allowlist for external custom URL schemes, hosts, and query keys
private let allowedCustomSchemes: Set<String> = ["myapp", "partnerapp"]
private let allowedCustomHosts: Set<String> = ["open", "product", "promo"]
private let allowedCustomQueryKeys: Set<String> = ["id", "ref", "promo"]
// Explicit allowlist for HTTPS hosts permitted inside the primary WebView container
private let allowedWebHosts: Set<String> = [
"example.com",
"m.example.com",
"links.example.com"
]
// Isolated allowlists specifically for child popup windows (target="_blank")
private let allowedPopupHosts: Set<String> = ["example.com", "auth.example.com"]
private let allowedPopupPathPrefixes: [String] = ["/oauth", "/popup", "/window"]
// External Universal Link hosts that attempt native app handoff on link activation
private let externalUniversalLinkHosts: Set<String> = ["links.example.com"]
// Monotonic navigation generation token incremented on every new main-frame navigation attempt
private var activeNavigationGeneration: UInt64 = 0
// Action-level deduplication preventing duplicate dispatches for the same WKNavigationAction
private var dispatchedActionIDs: [ObjectIdentifier] = []
private let maxTrackedActionIDs = 16
// Monotonic-uptime TTL-bounded bypass cache keyed by normalized Universal Link key
private var bypassedUniversalLinkKeys: [String: TimeInterval] = [:]
private let maxBypassedKeys = 10
private let bypassTTLSeconds: TimeInterval = 300
// Adapt significant query keys to match your application's actual routing parameters
private let significantLoopQueryKeys: Set<String> = ["id"]
override func viewDidLoad() {
super.viewDidLoad()
let configuration = WKWebViewConfiguration()
webView = WKWebView(frame: view.bounds, configuration: configuration)
webView.autoresizingMask = [.flexibleWidth, .flexibleHeight]
webView.navigationDelegate = self
webView.uiDelegate = self
#if DEBUG
if #available(iOS 16.4, *) {
webView.isInspectable = true
}
#endif
view.addSubview(webView)
}
// MARK: - WKNavigationDelegate
func webView(
_ webView: WKWebView,
decidePolicyFor navigationAction: WKNavigationAction,
decisionHandler: @escaping (WKNavigationActionPolicy) -> Void
) {
guard let url = navigationAction.request.url else {
decisionHandler(.cancel)
return
}
let isMainFrame = navigationAction.sourceFrame.isMainFrame
let isNewWindow = (navigationAction.targetFrame == nil)
// Increment generation token on every main-frame navigation attempt (including blocked attempts)
// so any pending prior asynchronous Universal Link fallback is invalidated immediately.
if isMainFrame && !isNewWindow {
activeNavigationGeneration &+= 1
}
let requestGeneration = activeNavigationGeneration
let plan = evaluateNavigationPolicy(
url: url,
navigationType: navigationAction.navigationType,
isMainFrame: isMainFrame,
isNewWindow: isNewWindow
)
switch plan {
case .allowInWebView:
decisionHandler(.allow)
case .launchCustomScheme(let targetURL):
if isMainFrame { activeNavigationGeneration &+= 1 }
executeExternalDispatchOnce(
action: navigationAction,
url: targetURL,
isUniversalLink: false,
requestGeneration: activeNavigationGeneration
)
decisionHandler(.cancel)
case .attemptUniversalLink(let targetURL):
if isMainFrame { activeNavigationGeneration &+= 1 }
let currentGen = activeNavigationGeneration
executeExternalDispatchOnce(
action: navigationAction,
url: targetURL,
isUniversalLink: true,
requestGeneration: currentGen
)
decisionHandler(.cancel)
case .block:
decisionHandler(.cancel)
}
}
// MARK: - WKUIDelegate (Handles target="_blank" and window.open)
func webView(
_ webView: WKWebView,
createWebViewWith configuration: WKWebViewConfiguration,
for navigationAction: WKNavigationAction,
windowFeatures: WKWindowFeatures
) -> WKWebView? {
guard navigationAction.targetFrame == nil,
let url = navigationAction.request.url else {
return nil
}
let isMainFrame = navigationAction.sourceFrame.isMainFrame
if isMainFrame {
activeNavigationGeneration &+= 1
}
let currentGen = activeNavigationGeneration
let plan = evaluateNavigationPolicy(
url: url,
navigationType: navigationAction.navigationType,
isMainFrame: isMainFrame,
isNewWindow: true
)
switch plan {
case .allowInWebView:
webView.load(navigationAction.request)
case .launchCustomScheme(let targetURL):
executeExternalDispatchOnce(
action: navigationAction,
url: targetURL,
isUniversalLink: false,
requestGeneration: currentGen
)
case .attemptUniversalLink(let targetURL):
executeExternalDispatchOnce(
action: navigationAction,
url: targetURL,
isUniversalLink: true,
requestGeneration: currentGen
)
case .block:
break
}
return nil
}
// MARK: - Pure Navigation Policy Evaluation (Zero Side Effects)
private func evaluateNavigationPolicy(
url: URL,
navigationType: WKNavigationType,
isMainFrame: Bool,
isNewWindow: Bool
) -> NavigationPlan {
guard let scheme = url.scheme?.lowercased() else {
return .block
}
let isLinkActivated = (navigationType == .linkActivated)
// 1. Evaluate non-HTTP/HTTPS Custom URL Schemes
// Note: Custom scheme allowlisting validates URI structure; it cannot guarantee target Bundle ID identity.
if scheme != "http" && scheme != "https" {
guard isMainFrame, isLinkActivated, isAllowedCustomURL(url) else {
return .block
}
return .launchCustomScheme(url)
}
// 2. Enforce HTTPS-only, default port (nil or 443), and Host Allowlists
let targetHost = url.host?.lowercased()
if isNewWindow {
guard isMainFrame, isLinkActivated, isAllowedPopupWebURL(url) else {
return .block
}
} else {
guard isAllowedWebURL(url), let host = targetHost, allowedWebHosts.contains(host) else {
return .block
}
}
// 3. Evaluate Universal Link Handoffs for designated external hosts on link activation
if let host = targetHost,
externalUniversalLinkHosts.contains(host),
isMainFrame,
isLinkActivated,
let loopKey = universalLinkLoopKey(for: url),
!isBypassedKeyActive(loopKey) {
return .attemptUniversalLink(url)
}
return .allowInWebView
}
// MARK: - Action-Level Deduplicated External Dispatch Execution
private func executeExternalDispatchOnce(
action: WKNavigationAction,
url: URL,
isUniversalLink: Bool,
requestGeneration: UInt64
) {
let actionID = ObjectIdentifier(action)
if dispatchedActionIDs.contains(actionID) {
return
}
if dispatchedActionIDs.count >= maxTrackedActionIDs {
dispatchedActionIDs.removeFirst()
}
dispatchedActionIDs.append(actionID)
if isUniversalLink {
guard let loopKey = universalLinkLoopKey(for: url) else { return }
UIApplication.shared.open(url, options: [.universalLinksOnly: true]) { [weak self] success in
// Verify view lifecycle AND generation token to prevent stale async fallback overwrites
guard let self = self,
self.isViewLoaded,
self.view.window != nil,
self.activeNavigationGeneration == requestGeneration else {
return
}
if !success {
self.recordBypassedKey(loopKey)
self.webView.load(URLRequest(url: url))
}
}
} else {
UIApplication.shared.open(url, options: [:]) { success in
if !success {
print("[WebViewDebug] Failed to launch custom scheme (app may not be installed)")
}
}
}
}
private func isAllowedWebURL(_ url: URL) -> Bool {
guard let components = URLComponents(url: url, resolvingAgainstBaseURL: false),
let scheme = components.scheme?.lowercased(),
scheme == "https",
components.user == nil,
components.password == nil,
(components.port == nil || components.port == 443) else {
return false
}
return true
}
private func isAllowedPopupWebURL(_ url: URL) -> Bool {
guard isAllowedWebURL(url),
let components = URLComponents(url: url, resolvingAgainstBaseURL: false),
let host = components.host?.lowercased(),
allowedPopupHosts.contains(host),
components.fragment == nil else {
return false
}
let path = components.path
return allowedPopupPathPrefixes.contains { path == $0 || path.hasPrefix("\($0)/"); }
}
private func isAllowedCustomURL(_ url: URL) -> Bool {
guard let components = URLComponents(url: url, resolvingAgainstBaseURL: false),
let scheme = components.scheme?.lowercased(),
let host = components.host?.lowercased(),
allowedCustomSchemes.contains(scheme),
allowedCustomHosts.contains(host),
components.user == nil,
components.password == nil,
components.port == nil, // Reject explicit ports on custom schemes
components.fragment == nil else {
return false
}
let path = components.path
if !path.isEmpty &&
path.range(of: "^/[A-Za-z0-9/_-]{1,64}$", options: .regularExpression) == nil {
return false
}
if let queryItems = components.queryItems {
var seenKeys = Set<String>()
for item in queryItems {
if seenKeys.contains(item.name) {
return false
}
seenKeys.insert(item.name)
guard allowedCustomQueryKeys.contains(item.name),
let value = item.value,
value.count <= 64,
value.range(of: "^[A-Za-z0-9_-]+$", options: .regularExpression) != nil else {
return false
}
}
}
return true
}
private func universalLinkLoopKey(for url: URL) -> String? {
guard let components = URLComponents(url: url, resolvingAgainstBaseURL: false),
let scheme = components.scheme?.lowercased(),
let host = components.host?.lowercased() else {
return nil
}
let portPart = (components.port != nil && components.port != 443) ? ":\(components.port!)" : ""
let significantParams = (components.queryItems ?? [])
.filter { significantLoopQueryKeys.contains($0.name) }
.sorted { $0.name < $1.name }
.map { "\($0.name)=\($0.value ?? "")" }
.joined(separator: "&")
let querySuffix = significantParams.isEmpty ? "" : "?\(significantParams)"
return "\(scheme)://\(host)\(portPart)\(components.path)\(querySuffix)"
}
private func isBypassedKeyActive(_ key: String) -> Bool {
let now = ProcessInfo.processInfo.systemUptime
bypassedUniversalLinkKeys = bypassedUniversalLinkKeys.filter {
(now - $0.value) < bypassTTLSeconds
}
return bypassedUniversalLinkKeys[key] != nil
}
private func recordBypassedKey(_ key: String) {
let now = ProcessInfo.processInfo.systemUptime
bypassedUniversalLinkKeys = bypassedUniversalLinkKeys.filter {
(now - $0.value) < bypassTTLSeconds
}
if bypassedUniversalLinkKeys.count >= maxBypassedKeys,
let oldestKey = bypassedUniversalLinkKeys.min(by: { $0.value < $1.value })?.key {
bypassedUniversalLinkKeys.removeValue(forKey: oldestKey)
}
bypassedUniversalLinkKeys[key] = now
}
}
Solución de ERR_UNKNOWN_URL_SCHEME y fallos de visibilidad de paquetes en Android WebView
Devoluciones de llamada obsoletas, hasGesture() y límites de POST
Android marcó como obsoleto shouldOverrideUrlLoading(WebView, String) en el nivel de API 24 a favor de shouldOverrideUrlLoading(WebView, WebResourceRequest). WebResourceRequest proporciona isForMainFrame, isRedirect y hasGesture(). Tenga en cuenta dos restricciones oficiales de la plataforma: shouldOverrideUrlLoading no se invoca para llamadas webView.loadUrl() iniciadas por la aplicación ni para navegaciones HTTP POST, y hasGesture() puede devolver false para redirecciones legítimas de JavaScript asíncrono o saltos 302 del lado del servidor.
Manejo de ventanas emergentes de defensa en profundidad y aislamiento de subprocesos en WebChromeClient.onCreateWindow
El comportamiento de las ventanas emergentes de Android depende de WebSettings.setSupportMultipleWindows. Si su aplicación no requiere ventanas emergentes interactivas, mantener setSupportMultipleWindows(false) (o devolver false desde onCreateWindow) evita que los iframes de terceros abran contenedores secundarios, o abre destinos verificados a través de un punto de entrada explícito controlado por el host.
Cuando setSupportMultipleWindows(true) está habilitado, WebChromeClient.onCreateWindow no proporciona la URL de destino en su firma de devolución de llamada, y ninguna devolución de llamada única cubre cada vector de navegación. Comprender el modelo de subprocesos exacto y los límites de las devoluciones de llamada es esencial para un enfoque de referencia de defensa en profundidad:
shouldOverrideUrlLoading(Hilo de la interfaz de usuario — Propietario de la navegación y el estado de la sesión): Se ejecuta exclusivamente en el hilo de la interfaz de usuario y posee todo el estado mutable de la sesión emergente (isInitialTransportLoad,isAuthorizedPopupSession,popupRedirectHopsypopupChainStartMs). Solo una vez que una carga inicial verificada o un gesto directo del usuario coincide conpolicy.isAllowedPopupUri,shouldOverrideUrlLoadingautoriza la sesión para las posteriores redirecciones HTTP 302 acotadas (request.isRedirect), asegurando que las cadenas de redirección se vinculen a una sesión autorizada en lugar de confiar en redirecciones arbitrarias.shouldInterceptRequest(Hilo de E/S de WebView en segundo plano — Guardia de solo lectura sin estado): Se ejecuta en un subproceso de WebView que no es de la interfaz de usuario. Debido a que nunca debe mutar el estado de la sesión del hilo de la interfaz de usuario, opera estrictamente como una comprobación de política de solo lectura sin estado ensafeClient.policy(bloqueando las solicitudes HTTP/HTTPS del marco principal que no superanisAllowedPopupUriy enviandodisposeActivePopup()al hilo principal). Tenga en cuenta que, según la documentación de Android,shouldInterceptRequestsolo se llama para la URL del recurso inicial, no para las URL de redirección HTTP 302 posteriores; las URL de redirección posteriores deben ser evaluadas porshouldOverrideUrlLoading.onPageStarted(Hilo de la interfaz de usuario — Comprobación de respaldo de inicio de navegación): Se ejecuta cuando comienza la carga del marco principal (no como un filtro previo a la navegación). Actualiza el banner de origen visible para la transparencia del usuario y proporciona una comprobación de respaldo de inicio de navegación llamando astopLoading()ydisposeActivePopup()si una categoría de destino no aprobada comienza a cargarse.
Pruebe siempre las URL iniciales maliciosas, las cadenas HTTP 302 entre dominios, las redirecciones 302 consecutivas, target="_blank", window.open() y los activadores de iframes de terceros en las compilaciones físicas de WebView de destino.
Visibilidad de paquetes en Android 11+ y directrices obsoletas de canOpenURL
Bajo las reglas de visibilidad de paquetes de Android, las aplicaciones que se ejecutan en Android 11 (nivel de API 30) o superior y se dirigen al nivel de API 30 o superior (targetSdk >= 30) reciben resultados nulos o vacíos de intent.resolveActivity() o queryIntentActivities() a menos que las aplicaciones de destino estén declaradas bajo <queries> en AndroidManifest.xml. Android recomienda llamar a startActivity(intent) directamente dentro de un bloque try/catch para ActivityNotFoundException y SecurityException en lugar de ampliar <queries>.
En iOS, Apple ha desaprobado UIApplication.canOpenURL(_:) y recomienda intentar UIApplication.shared.open(_:options:completionHandler:) directamente y manejar cualquier fallo en el controlador de finalización (o migrar a Enlaces Universales para eliminar la prevalidación de esquemas). LSApplicationQueriesSchemes en Info.plist solo es necesario si el código heredado continúa llamando a canOpenURL(_:), mientras que open(_:options:completionHandler:) no requiere declarar esquemas en Info.plist. Tanto <queries> como LSApplicationQueriesSchemes controlan la visibilidad de consultas; no son listas blancas de seguridad para validar URI web no confiables.
<!-- Manifest Fragment: Merge <queries> into your existing AndroidManifest.xml -->
<!-- Required for targetSdk >= 30 on Android 11+ ONLY if calling resolveActivity or queryIntentActivities -->
<queries>
<intent>
<action android:name="android.intent.action.VIEW" />
<category android:name="android.intent.category.BROWSABLE" />
<data android:scheme="myapp" />
</intent>
<intent>
<action android:name="android.intent.action.VIEW" />
<category android:name="android.intent.category.BROWSABLE" />
<data android:scheme="partnerapp" />
</intent>
</queries>
<!-- Info.plist Fragment: Insert under the root <dict> in Info.plist -->
<!-- Legacy: Required on iOS ONLY if calling deprecated UIApplication.shared.canOpenURL; open(_:options:completionHandler:) does not require this key -->
<key>LSApplicationQueriesSchemes</key>
<array>
<string>myapp</string>
<string>partnerapp</string>
</array>
Cómo analizar de forma segura las URI de intents de Chrome y evitar bucles de redirección
Protección de Intent.parseUri contra vulnerabilidades de redirección de intents
Las URI intent:// de Android codifican un esquema de destino, un paquete y una URL de respaldo (S.browser_fallback_url). El análisis de URI web no confiables a través de Intent.parseUri(rawUri, Intent.URI_INTENT_SCHEME) introduce riesgos de redirección de intents detallados en la guía de seguridad de redirección de intents de Android y la Guía de pruebas de seguridad de aplicaciones móviles de OWASP. Incluso con la incorporación por parte de Android 16 (API 36) de un endurecimiento predeterminado a nivel de plataforma, las aplicaciones deben aplicar una validación estricta antes de enviar los Intents.

Para implementar una validación de bloqueo en caso de fallo utilizando la utilidad AndroidX IntentSanitizer (androidx.core:core:1.9.0+, o androidx.core:core-ktx:1.9.0+ que incluye androidx.core:core) sin activar conflictos de exclusión mutua de constructores entre allowAnyComponent() y los métodos de lista blanca de paquetes/componentes:
- Comprobaciones de desinfección previa: Rechace inmediatamente los intents que transporten campos
componentoselectorno nulos (parsedIntent.component != null || parsedIntent.selector != null). Extraiga y eliminebrowser_fallback_urlantes de la desinfección, y verifique de forma nativa queparsedIntent.data?.schemese asigne 1 a 1 al paqueteparsedIntent.a través decustomSchemeTargetPackages(asegurando quemyapp://se resuelva estrictamente encom.example.target, nunca en otro paquete asociado). - Ejecución del desinfectante: Limpie temporalmente el paquete
parsedIntent.= null en la copia no confiable, ejecuteIntentSanitizer.Builder().allowAnyComponent().allowAction(Intent.ACTION_VIEW).allowCategory(Intent.CATEGORY_BROWSABLE).allowData { ... }.build().sanitizeByThrowing(parsedIntent)(cero indicadores de tareas proporcionados por la página web) y reasigne elexpectedPackagevalidado yCATEGORY_BROWSABLEen el Intent de propiedad del host desinfectado antes de las aserciones posteriores a la desinfección. - Indicadores de lanzamiento conscientes del contexto: Inyecte
Intent.FLAG_ACTIVITY_NEW_TASKdentro del despachador nativo (launchWithContextSafety) solo cuandoview.context !is Activity. Para la verificación de asociación de dominio a aplicación, prefiera los Enlaces de Aplicaciones de Android HTTPS verificados (assetlinks.json).
Prevención de bucles de respaldo infinitos con estado de cadena monotónica
Cuando startActivity genera una ActivityNotFoundException, valide browser_fallback_url con una comprobación dedicada isAllowedFallbackUri(uri) (estrictamente HTTPS, puerto predeterminado, host verificado, prefijos de ruta de respaldo explícitos, sin claves de consulta duplicadas y sin fragmentos). Rechace representaciones de puertos explícitos en esquemas personalizados verificando tanto que uri.port == -1 como que !uri.encodedAuthority.orEmpty().contains(":").
Realice un seguimiento de las cadenas de respaldo utilizando SystemClock.elapsedRealtime() (evitando saltos de reloj de pared System.currentTimeMillis()), aísle las cadenas a través de fallbackLoopKey() (no la canonicalización completa de IETF RFC 3986), restablezca el estado a través de un contenedor de host explícito loadNewNavigation(webView, url) y enrute las reservas de ventanas emergentes al contenedor principal mediante onPopupFallbackHandoff para que los dominios no autorizados nunca se carguen dentro de un cuadro de diálogo emergente.
Descargo de responsabilidad de la arquitectura de referencia: La siguiente implementación es una arquitectura de referencia defensiva. Valide la disponibilidad de la API, el orden de los delegados y el comportamiento del ciclo de vida frente a las versiones exactas de AndroidX e iOS utilizadas por su aplicación.
// Android - SafeWebViewModules.kt
// Reference architecture: compile and test against your specific project targets
// Requires androidx.core:core:1.9.0+ (or androidx.core:core-ktx:1.9.0+) for IntentSanitizer; targets minSdk >= 24.
package com.example.hostapp.webview
import android.app.Activity
import android.app.Dialog
import android.content.ActivityNotFoundException
import android.content.Intent
import android.content.pm.ApplicationInfo
import android.net.Uri
import android.os.Bundle
import android.os.Message
import android.os.SystemClock
import android.util.Log
import android.view.ViewGroup
import android.widget.TextView
import android.webkit.WebChromeClient
import android.webkit.WebResourceRequest
import android.webkit.WebResourceResponse
import android.webkit.WebView
import android.webkit.WebViewClient
import androidx.appcompat.app.AppCompatActivity
import androidx.core.content.IntentSanitizer
import java.io.ByteArrayInputStream
import java.net.URISyntaxException
// 1. Policy Module (Immutable / Thread-Safe for read-only access from IO & UI threads)
class CustomUriPolicy(
val customSchemeTargetPackages: Map<String, String> = mapOf(
"myapp" to "com.example.target",
"partnerapp" to "com.partner.app"
),
val allowedCustomHosts: Set<String> = setOf("open", "product", "promo"),
val allowedCustomQueryKeys: Set<String> = setOf("id", "ref", "promo"),
val allowedWebHosts: Set<String> = setOf("example.com", "downloads.example.com"),
val allowedFallbackHosts: Set<String> = setOf("downloads.example.com", "example.com"),
val allowedFallbackPathPrefixes: List<String> = listOf("/download", "/app", "/landing"),
val allowedFallbackQueryKeys: Set<String> = setOf("id", "ref", "promo", "utm_source"),
// Isolated allowlists explicitly for popup windows; distinct from general web hosts
val allowedPopupHosts: Set<String> = setOf("example.com", "auth.example.com"),
val allowedPopupPathPrefixes: List<String> = listOf("/oauth", "/popup", "/window")
) {
val allowedCustomSchemes: Set<String> get() = customSchemeTargetPackages.keys
val allowedTargetPackages: Set<String> get() = customSchemeTargetPackages.values.toSet()
private val pathPattern = Regex("^/[A-Za-z0-9/_-]{1,64}$")
private val queryValuePattern = Regex("^[A-Za-z0-9_-]{1,64}$")
fun isAllowedWebUri(uri: Uri): Boolean {
val scheme = uri.scheme?.lowercase() ?: return false
val host = uri.host?.lowercase() ?: return false
return scheme == "https" &&
host in allowedWebHosts &&
(uri.port == -1 || uri.port == 443) &&
uri.userInfo == null
}
fun isAllowedPopupUri(uri: Uri): Boolean {
val scheme = uri.scheme?.lowercase() ?: return false
val host = uri.host?.lowercase() ?: return false
if (scheme != "https" || host !in allowedPopupHosts) return false
if ((uri.port != -1 && uri.port != 443) || uri.userInfo != null || uri.fragment != null) return false
val path = uri.path.orEmpty()
return allowedPopupPathPrefixes.any { path == it || path.startsWith("$it/") } && pathPattern.matches(path)
}
fun isAllowedFallbackUri(uri: Uri): Boolean {
val scheme = uri.scheme?.lowercase() ?: return false
val host = uri.host?.lowercase() ?: return false
if (scheme != "https" || host !in allowedFallbackHosts) return false
if ((uri.port != -1 && uri.port != 443) || uri.userInfo != null || uri.fragment != null) {
return false
}
val path = uri.path.orEmpty()
if (allowedFallbackPathPrefixes.none { path == it || path.startsWith("$it/") } ||
!pathPattern.matches(path)
) {
return false
}
// Validate query keys, enforce value syntax, and reject duplicate keys
val queryNames = uri.queryParameterNames
for (paramName in queryNames) {
if (paramName !in allowedFallbackQueryKeys) return false
val values = uri.getQueryParameters(paramName)
if (values.size != 1 || !queryValuePattern.matches(values[0])) return false
}
return true
}
fun isAllowedCustomUri(uri: Uri): Boolean {
val scheme = uri.scheme?.lowercase() ?: return false
val host = uri.host?.lowercase() ?: return false
if (scheme !in allowedCustomSchemes || host !in allowedCustomHosts) return false
// Reject network ports strictly by checking both uri.port == -1 and raw authority colon absence
val rawAuthority = uri.encodedAuthority.orEmpty()
if (uri.userInfo != null || uri.port != -1 || rawAuthority.contains(":") || uri.fragment != null) {
return false
}
val path = uri.path.orEmpty()
if (path.isNotEmpty() && !pathPattern.matches(path)) return false
// Validate query keys, enforce value syntax, and reject duplicate keys
val queryNames = uri.queryParameterNames
for (paramName in queryNames) {
if (paramName !in allowedCustomQueryKeys) return false
val values = uri.getQueryParameters(paramName)
if (values.size != 1 || !queryValuePattern.matches(values[0])) return false
}
return true
}
}
// 2. Fallback Manager: Monotonic Elapsed-Time Chain State (Isolates active chain from repeat sessions)
class FallbackLoopGuard(
private val maxHopsPerChain: Int = 3,
private val chainTtlMs: Long = 30_000L,
private val significantQueryKeys: Set<String> = setOf("id")
) {
private var chainStartElapsedMs: Long = 0L
private var fallbackHopCount: Int = 0
private val visitedInCurrentChain = mutableSetOf<String>()
fun resetChain() {
chainStartElapsedMs = 0L
fallbackHopCount = 0
visitedInCurrentChain.clear()
}
fun canLoadFallback(uri: Uri, currentWebViewUrl: String?): Boolean {
val now = SystemClock.elapsedRealtime()
if (chainStartElapsedMs == 0L || (now - chainStartElapsedMs) > chainTtlMs) {
chainStartElapsedMs = now
fallbackHopCount = 0
visitedInCurrentChain.clear()
}
val loopKey = fallbackLoopKey(uri)
val currentKey = currentWebViewUrl?.let { fallbackLoopKey(Uri.parse(it)) }
if (fallbackHopCount >= maxHopsPerChain ||
loopKey == currentKey ||
loopKey in visitedInCurrentChain
) {
return false
}
visitedInCurrentChain.add(loopKey)
fallbackHopCount++
return true
}
// Application-level loop key normalizing default HTTPS port and preserving significant query keys
private fun fallbackLoopKey(uri: Uri): String {
val scheme = uri.scheme?.lowercase().orEmpty()
val host = uri.host?.lowercase().orEmpty()
val portSuffix = if (uri.port != -1 && uri.port != 443) ":${uri.port}" else ""
val path = uri.path.orEmpty()
val sigParams = uri.queryParameterNames
.filter { it in significantQueryKeys }
.sorted()
.joinToString("&") { key -> "$key=${uri.getQueryParameter(key).orEmpty()}" }
val querySuffix = if (sigParams.isEmpty()) "" else "?$sigParams"
return "$scheme://$host$portSuffix$path$querySuffix"
}
}
// 3. Router & Fail-Closed IntentSanitizer WebViewClient (UI Thread Only)
class SafeRedirectWebViewClient(
val policy: CustomUriPolicy = CustomUriPolicy(),
val loopGuard: FallbackLoopGuard = FallbackLoopGuard(),
private val onPopupFallbackHandoff: ((fallbackUri: Uri) -> Unit)? = null
) : WebViewClient() {
// Explicit host-initiated navigation API that resets fallback chain state prior to loadUrl()
fun loadNewNavigation(webView: WebView, url: String) {
val targetUri = Uri.parse(url)
if (!policy.isAllowedWebUri(targetUri)) {
Log.w("WebViewDebug", "Blocked host-initiated navigation to untrusted URL")
return
}
loopGuard.resetChain()
webView.loadUrl(url)
}
// Dedicated fallback loader with internal validation preserving active chain state
fun loadFallbackNavigation(webView: WebView, fallbackUri: Uri) {
if (!policy.isAllowedFallbackUri(fallbackUri)) {
Log.w("WebViewDebug", "Blocked untrusted fallback navigation attempt")
return
}
webView.loadUrl(fallbackUri.toString())
}
override fun shouldOverrideUrlLoading(view: WebView, request: WebResourceRequest): Boolean {
return handleNavigation(
view = view,
uri = request.url,
isForMainFrame = request.isForMainFrame,
hasUserGesture = request.hasGesture(),
isPopupContext = false
)
}
fun handleNavigation(
view: WebView,
uri: Uri?,
isForMainFrame: Boolean,
hasUserGesture: Boolean,
isPopupContext: Boolean
): Boolean {
val targetUri = uri ?: return true
val scheme = targetUri.scheme?.lowercase() ?: return true
// 1. Enforce HTTPS-only & Web Host Allowlist on all HTTP/HTTPS navigations
if (scheme == "http" || scheme == "https") {
if (!policy.isAllowedWebUri(targetUri)) {
Log.w("WebViewDebug", "Blocked non-HTTPS, custom-port, or untrusted web host")
return true
}
if (hasUserGesture && isForMainFrame) {
loopGuard.resetChain()
}
return false
}
// 2. Enforce main-frame and user-gesture constraints on external app launches
if (!isForMainFrame || !hasUserGesture) {
Log.w("WebViewDebug", "Blocked non-main-frame or non-gesture scheme: $scheme")
return true
}
// 3. Parse and fail-closed sanitize Chrome intent:// URIs
if (scheme == "intent") {
return handleIntentUri(view, targetUri.toString(), isPopupContext)
}
// 4. Validate and explicitly bind allowlisted custom URL schemes to 1-to-1 verified target packages
if (policy.isAllowedCustomUri(targetUri)) {
val expectedPackage = policy.customSchemeTargetPackages[scheme] ?: return true
val viewIntent = Intent(Intent.ACTION_VIEW, targetUri).apply {
addCategory(Intent.CATEGORY_BROWSABLE)
`package` = expectedPackage
}
launchIntentSafely(view, viewIntent)
return true
}
// 5. Block all unrecognized schemes
Log.w("WebViewDebug", "Blocked unrecognized URL scheme: $scheme")
return true
}
// UI-Thread Navigation Evaluator for child popup WebViews tying 302 redirects to authorized sessions
fun handlePopupNavigation(
view: WebView,
uri: Uri?,
isForMainFrame: Boolean,
hasUserGesture: Boolean,
isRedirect: Boolean,
isInitialTransportLoad: Boolean,
isAuthorizedPopupSession: Boolean,
onAuthorizedInitialSession: () -> Unit,
canProceedPopupRedirect: () -> Boolean
): Boolean {
val targetUri = uri ?: return true
val scheme = targetUri.scheme?.lowercase() ?: return true
if (scheme == "http" || scheme == "https") {
if (!isForMainFrame) {
Log.w("WebViewDebug", "Blocked subframe HTTPS navigation inside popup")
return true
}
if (!policy.isAllowedPopupUri(targetUri)) {
Log.w("WebViewDebug", "Blocked untrusted popup HTTPS host or path navigation")
return true
}
// Authorize session only on UI thread when initial load or user tap matches allowlist
if (isInitialTransportLoad || hasUserGesture) {
onAuthorizedInitialSession()
return false
}
// Permit bounded server-side 302 redirects ONLY for previously authorized popup sessions
if (isRedirect && isAuthorizedPopupSession && canProceedPopupRedirect()) {
return false
}
Log.w("WebViewDebug", "Blocked unauthorized redirect or non-gesture popup navigation")
return true
}
return handleNavigation(view, targetUri, isForMainFrame, hasUserGesture, isPopupContext = true)
}
private fun handleIntentUri(view: WebView, rawUri: String, isPopupContext: Boolean): Boolean {
val parsedIntent = try {
Intent.parseUri(rawUri, Intent.URI_INTENT_SCHEME)
} catch (e: URISyntaxException) {
Log.w("WebViewDebug", "Malformed intent URI syntax")
return true
}
val fallbackUrl = parsedIntent.getStringExtra("browser_fallback_url")
parsedIntent.removeExtra("browser_fallback_url")
// 1-to-1 Binding: Extract target scheme and validate natively against expected target package
val dataUri = parsedIntent.data ?: return true
val targetScheme = dataUri.scheme?.lowercase() ?: return true
val expectedPackage = policy.customSchemeTargetPackages[targetScheme] ?: run {
Log.w("WebViewDebug", "Blocked intent with unmapped custom scheme: $targetScheme")
return true
}
val rawPackage = parsedIntent.`package`
if (rawPackage != expectedPackage) {
Log.w("WebViewDebug", "Blocked intent package mismatch: expected $expectedPackage")
return true
}
// Reject webpage-specified explicit components and selectors immediately
if (parsedIntent.component != null || parsedIntent.selector != null) {
Log.w("WebViewDebug", "Blocked intent with explicit component or selector")
return true
}
// Clear verified package temporarily before invoking IntentSanitizer with allowAnyComponent()
// to avoid Builder mutual-exclusion constraints while strictly rejecting untrusted flags/extras.
parsedIntent.`package` = null
val sanitizedIntent = try {
IntentSanitizer.Builder()
.allowAnyComponent()
.allowAction(Intent.ACTION_VIEW)
.allowCategory(Intent.CATEGORY_BROWSABLE)
.allowData { uri -> policy.isAllowedCustomUri(uri) }
.build()
.sanitizeByThrowing(parsedIntent)
} catch (e: SecurityException) {
Log.w("WebViewDebug", "IntentSanitizer threw SecurityException for disallowed fields or flags")
return true
} catch (e: IllegalArgumentException) {
Log.w("WebViewDebug", "IntentSanitizer rejected invalid intent arguments")
return true
}
// Re-bind verified target package + host-enforced category + post-sanitization assertions
sanitizedIntent.`package` = expectedPackage
sanitizedIntent.addCategory(Intent.CATEGORY_BROWSABLE)
val sanitizedData = sanitizedIntent.data
if (sanitizedIntent.component != null ||
sanitizedIntent.action != Intent.ACTION_VIEW ||
sanitizedIntent.`package` != expectedPackage ||
sanitizedData == null ||
!policy.isAllowedCustomUri(sanitizedData)
) {
Log.w("WebViewDebug", "Post-sanitization intent assertions failed")
return true
}
try {
launchWithContextSafety(view, sanitizedIntent)
loopGuard.resetChain()
} catch (e: ActivityNotFoundException) {
if (!fallbackUrl.isNullOrBlank()) {
val fallbackUri = Uri.parse(fallbackUrl)
if (policy.isAllowedFallbackUri(fallbackUri) &&
loopGuard.canLoadFallback(fallbackUri, view.url)
) {
if (isPopupContext) {
onPopupFallbackHandoff?.invoke(fallbackUri)
} else {
loadFallbackNavigation(view, fallbackUri)
}
} else {
Log.w("WebViewDebug", "Blocked untrusted or looping fallback URL")
}
}
} catch (e: SecurityException) {
Log.w("WebViewDebug", "SecurityException blocked intent launch")
}
return true
}
private fun launchIntentSafely(view: WebView, intent: Intent) {
try {
launchWithContextSafety(view, intent)
} catch (e: ActivityNotFoundException) {
Log.i("WebViewDebug", "No installed application handles target package/scheme")
} catch (e: SecurityException) {
Log.w("WebViewDebug", "SecurityException blocked custom scheme launch")
}
}
private fun launchWithContextSafety(view: WebView, intent: Intent) {
val safeIntent = Intent(intent)
if (view.context !is Activity) {
safeIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
}
view.context.startActivity(safeIntent)
}
}
// 4. Lifecycle-Managed Popup WebChromeClient (Strict UI-Thread Session State & Stateless Background Guard)
class SafePopupWebChromeClient(
private val safeClient: SafeRedirectWebViewClient
) : WebChromeClient() {
private var activeDialog: Dialog? = null
private var activeChildWebView: WebView? = null
private var isDisposed: Boolean = false
private fun disposeActivePopup() {
if (isDisposed) return
isDisposed = true
val dialog = activeDialog
val child = activeChildWebView
activeDialog = null
activeChildWebView = null
dialog?.setOnDismissListener(null)
dialog?.dismiss()
child?.let {
(it.parent as? ViewGroup)?.removeView(it)
it.stopLoading()
it.webViewClient = WebViewClient()
it.webChromeClient = null
it.destroy()
}
}
override fun onCreateWindow(
view: WebView,
isDialog: Boolean,
isUserGesture: Boolean,
resultMsg: Message?
): Boolean {
if (!isUserGesture) return false
val activity = view.context as? Activity
if (activity == null || activity.isFinishing || activity.isDestroyed) {
return false
}
val transport = resultMsg?.obj as? WebView.WebViewTransport ?: return false
disposeActivePopup()
isDisposed = false
val popupDialog = Dialog(activity)
val popupRoot = android.widget.LinearLayout(activity).apply {
orientation = android.widget.LinearLayout.VERTICAL
layoutParams = ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT)
}
val originBanner = TextView(activity).apply {
setPadding(24, 16, 24, 16)
setBackgroundColor(android.graphics.Color.DKGRAY)
setTextColor(android.graphics.Color.WHITE)
textSize = 12f
text = "Loading destination..."
}
popupRoot.addView(originBanner)
// All popup session state variables below are read and mutated strictly on the UI thread
var isInitialTransportLoad = true
var isAuthorizedPopupSession = false
var popupRedirectHops = 0
var popupChainStartMs = SystemClock.elapsedRealtime()
val maxPopupRedirects = 5
val maxPopupRedirectWindowMs = 30_000L
val childWebView = WebView(activity).apply {
layoutParams = android.widget.LinearLayout.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT)
settings.apply {
javaScriptEnabled = true
allowFileAccess = false
allowContentAccess = false
setSupportMultipleWindows(false)
}
webViewClient = object : WebViewClient() {
// UI Thread: Owns navigation, redirect, and session authorization state
override fun shouldOverrideUrlLoading(
childView: WebView,
request: WebResourceRequest
): Boolean {
val hasGesture = request.hasGesture()
if (hasGesture) {
popupRedirectHops = 0
popupChainStartMs = SystemClock.elapsedRealtime()
}
val result = safeClient.handlePopupNavigation(
view = childView,
uri = request.url,
isForMainFrame = request.isForMainFrame,
hasUserGesture = hasGesture,
isRedirect = request.isRedirect,
isInitialTransportLoad = isInitialTransportLoad,
isAuthorizedPopupSession = isAuthorizedPopupSession,
onAuthorizedInitialSession = {
isAuthorizedPopupSession = true
},
canProceedPopupRedirect = {
val withinWindow = (SystemClock.elapsedRealtime() - popupChainStartMs) <= maxPopupRedirectWindowMs
if (withinWindow && popupRedirectHops < maxPopupRedirects) {
popupRedirectHops++
true
} else {
false
}
}
)
isInitialTransportLoad = false
return result
}
// Background WebView IO Thread: Strictly stateless, read-only policy check.
// Never mutates UI-thread session state; covers initial resource URL only (not subsequent 302 hops).
override fun shouldInterceptRequest(
childView: WebView,
request: WebResourceRequest
): WebResourceResponse? {
if (request.isForMainFrame) {
val targetUri = request.url
val scheme = targetUri?.scheme?.lowercase()
if ((scheme == "http" || scheme == "https") && !safeClient.policy.isAllowedPopupUri(targetUri)) {
Log.w("WebViewDebug", "Blocked unapproved popup main-frame request in shouldInterceptRequest")
childView.post { disposeActivePopup() }
return WebResourceResponse("text/plain", "utf-8", ByteArrayInputStream(ByteArray(0)))
}
}
return super.shouldInterceptRequest(childView, request)
}
// UI Thread: Navigation-start fallback check & origin display (not a pre-navigation filter)
override fun onPageStarted(childView: WebView, url: String?, favicon: android.graphics.Bitmap?) {
super.onPageStarted(childView, url, favicon)
isInitialTransportLoad = false
val uri = url?.let { Uri.parse(it) }
if (uri == null || !safeClient.policy.isAllowedPopupUri(uri)) {
Log.w("WebViewDebug", "Navigation-start fallback check terminated unapproved popup URL")
childView.stopLoading()
disposeActivePopup()
return
}
isAuthorizedPopupSession = true
val scheme = uri.scheme?.lowercase() ?: "https"
val host = uri.host?.lowercase() ?: "Unknown"
originBanner.text = "Origin: $scheme://$host"
}
}
webChromeClient = object : WebChromeClient() {
override fun onCloseWindow(window: WebView?) {
disposeActivePopup()
}
}
}
popupRoot.addView(childWebView)
popupDialog.setContentView(popupRoot)
popupDialog.setOnDismissListener {
disposeActivePopup()
}
activeDialog = popupDialog
activeChildWebView = childWebView
popupDialog.show()
transport.webView = childWebView
resultMsg.sendToTarget()
return true
}
fun destroyPopups() {
disposeActivePopup()
}
}
// 5. Complete Host Activity Registration & Lifecycle Cleanup Example (JavaScript Enabled on Main WebView)
class SafeWebViewActivity : AppCompatActivity() {
private lateinit var webView: WebView
private lateinit var safeClient: SafeRedirectWebViewClient
private lateinit var popupChromeClient: SafePopupWebChromeClient
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
if (applicationInfo.flags and ApplicationInfo.FLAG_DEBUGGABLE != 0) {
WebView.setWebContentsDebuggingEnabled(true)
}
val policy = CustomUriPolicy()
val loopGuard = FallbackLoopGuard()
safeClient = SafeRedirectWebViewClient(
policy = policy,
loopGuard = loopGuard,
onPopupFallbackHandoff = { fallbackUri ->
popupChromeClient.destroyPopups()
safeClient.loadFallbackNavigation(webView, fallbackUri)
}
)
popupChromeClient = SafePopupWebChromeClient(safeClient)
webView = WebView(this).apply {
settings.apply {
// Enable JavaScript explicitly for trusted landing pages requiring JS redirects or window.open()
javaScriptEnabled = true
allowFileAccess = false
allowContentAccess = false
// Enable multiple windows only if hosting interactive popup containers
setSupportMultipleWindows(true)
}
webViewClient = safeClient
webChromeClient = popupChromeClient
}
setContentView(webView)
// Use explicit host wrapper rather than bare webView.loadUrl()
safeClient.loadNewNavigation(webView, "https://example.com/landing")
}
override fun onDestroy() {
popupChromeClient.destroyPopups()
(webView.parent as? ViewGroup)?.removeView(webView)
webView.destroy()
super.onDestroy()
}
}
Preguntas frecuentes (FAQ)
¿Por qué Android WebView muestra net::ERR_UNKNOWN_URL_SCHEME incluso cuando la aplicación de destino está instalada?
¿Por qué shouldOverrideUrlLoading no se activa cuando mi aplicación llama directamente a WebView loadUrl?
¿Por qué los enlaces target blank con esquemas personalizados fallan silenciosamente dentro de WKWebView?
Resumen y marco de decisiones
Resolver los fallos de redirección de enlaces profundos en WebView requiere aislar el comportamiento del motor de WebView de las políticas de navegación de la aplicación host. Al reproducir eventos de navegación en Chrome DevTools o Safari Web Inspector, confinando estrictamente el estado de la sesión emergente de Android al hilo de la interfaz de usuario mientras se combina el filtrado de solicitudes iniciales sin estado con comprobaciones de redirección 302 autorizadas por la sesión, aplicando listas permitidas estrictas de cierre por fallo IntentSanitizer y protegiendo las reservas de Enlaces Universales de iOS contra sobrescrituras asíncronas obsoletas y lanzamientos de delegados duplicados, los equipos de ingeniería pueden reducir las rutas de usuario interrumpidas y ayudar a prevenir vulnerabilidades de redirección del lado del cliente.
Una vez que se han verificado los delegados nativos a nivel de contenedor y las rutas de respaldo, los equipos de ingeniería también deben validar las páginas de destino de atribución de extremo a extremo y las cadenas de enrutamiento de lanzamiento con un solo clic utilizando plataformas como OpoInstall para confirmar la preservación de los parámetros en las transiciones del navegador a la aplicación.
Glosario de entidades
| Término | Definición | Entidad relacionada | Rol de intención de búsqueda |
|---|---|---|---|
| WebView | Un componente de interfaz de usuario nativo integrado que se utiliza para renderizar páginas web dentro de una aplicación móvil. | WebViewClient / WKWebView |
Informativo / Técnico |
| Esquema de URL personalizado | Un prefijo de URI registrado por la aplicación (p. ej., myapp://) que permite la navegación externa hacia pantallas nativas. |
Intent.ACTION_VIEW |
Técnico / Informativo |
| WKNavigationDelegate | El protocolo WebKit que permite que una aplicación host acepte, cancele o redirija acciones de navegación en WKWebView. |
decidePolicyForNavigationAction |
Técnico |
| WKUIDelegate | El protocolo WebKit responsable de gestionar las solicitudes de creación de nuevas ventanas en WKWebView. |
createWebViewWith |
Técnico |
| WebResourceRequest | El objeto de Android API 24+ que encapsula la URL, el marco, el método HTTP, la redirección y los metadatos de gestos. | shouldOverrideUrlLoading |
Técnico |
| WebChromeClient | La interfaz de devolución de llamada de Android WebView que maneja diálogos de JavaScript, progreso y onCreateWindow. |
WebViewTransport |
Técnico |
| IntentSanitizer | La utilidad AndroidX Core utilizada para filtrar o validar estrictamente campos de Intent no confiables antes del envío. | Defensa de redirección de intents | Técnico / Seguridad |
| Enlaces universales | El estándar de enlaces profundos basado en HTTPS de Apple que vincula dominios web verificados con aplicaciones de iOS instaladas. | Dominios asociados | Técnico / Informativo |
| Visibilidad de paquetes | Filtrado del sistema operativo Android 11+ (targetSdk >= 30) que restringe qué aplicaciones instaladas puede consultar una aplicación host a través de PackageManager. |
Etiqueta de manifiesto <queries> |
Técnico |
| URI de Intent | Una URI estructurada de Android (intent://) que codifica el paquete de destino, el esquema y las URL de respaldo del navegador. |
Intent.URI_INTENT_SCHEME |
Técnico |
Línea de base de compatibilidad y estado de verificación
-
Destinos de compatibilidad previstos: Android
minSdk 24,compileSdk 34/35,targetSdk 34/35(Android 14/15), contexto de endurecimiento de redirección de intents de Android 16 (API 36),androidx.core:core:1.9.0+(IntentSanitizer); iOS 15.0–18.0 (isInspectablelimitado en iOS 16.4+), Xcode 15/16, Swift 5.9/6.0. -
Estado de verificación:
-
Revisión estática de API y especificaciones: Completada frente a las especificaciones oficiales de Android Developers, AndroidX Core, Apple Developer, IETF RFC 3986 y OWASP MASTG.
-
Verificación de compilación y dispositivos físicos: Aún no ejecutada en este ciclo de revisión. Los equipos deben compilar y ejecutar una regresión en dispositivos físicos que cubra URL emergentes iniciales maliciosas, cadenas 302 entre dominios, saltos 302 consecutivos, creación de ventanas de iframes de terceros, Enlaces de Aplicaciones de Android (
assetlinks.json), Dominios Asociados de iOS (almacenamiento en caché de AASA), cancelación asíncrona obsoleta de Enlaces Universales, cadenas de respaldointent://y despacho deActivityNotFoundExceptionantes del lanzamiento a producción.
-
Referencias
Share this article



