Comment résoudre les erreurs de redirection WebView sur Android et iOS ?

opoinstall
2026-11-19
5 min read

webview-safe-fallback-loop-prevention.webp

Comment résoudre les erreurs de redirection WebView sur Android et iOS ? Identifiez si l'échec concerne une navigation HTTPS standard, un schéma d'URL personnalisé, une URI Android intent:// ou une requête de nouvelle fenêtre, puis inspectez la navigation via Chrome DevTools ou Safari Web Inspector et tracez le délégué natif correspondant (shouldOverrideUrlLoading, onCreateWindow, decidePolicyForNavigationAction ou createWebViewWith). Vérifiez la résolution de l'application cible, les listes d'autorisations d'URI, les politiques de frame et d'interaction utilisateur, ainsi que le routage de repli pour isoler les erreurs au niveau du conteneur des échecs de transmission du système d'exploitation.

Une erreur de redirection WebView se produit lorsqu'une WebView Android Chromium ou un WKWebView WebKit iOS intégré ne parvient pas à acheminer une requête de navigation vers sa destination prévue. Les causes typiques incluent les schémas d'URL personnalisés non pris en charge, les requêtes target="_blank" non gérées, les déclarations de visibilité de package manquantes et les redirections de repli rejetées ou en boucle.

Pourquoi les conteneurs intégrés Android WebView et iOS WKWebView abandonnent-ils les redirections

Layered WebView redirect architecture reveals native policy and operating system dispatch failures.

Lors du débogage des échecs de redirection, les équipes d'ingénierie doivent séparer le comportement du moteur WebView (la manière dont Chromium ou WebKit analyse les URL, les cibles de frame et les événements pop-up) de la politique de l'application hôte (la manière dont les éléments WebViewClient, WebChromeClient, WKNavigationDelegate ou WKUIDelegate fournis par l'application évaluent les types d'interaction utilisateur, les listes d'autorisations et les transferts vers des applications externes). Les navigateurs autonomes intègrent des répartiteur d'URI et des gestionnaires de transfert de liens, tandis que android.webkit.WebView et WKWebView d'Apple sont des composants de rendu intégrés qui attendent par défaut des réponses réseau standard http:// ou https://.

Lorsqu'une page Web déclenche un schéma personnalisé (tel que myapp://product/42) ou un lien Android intent:// sans substitution de délégué actif, le comportement par défaut du conteneur diverge selon les plateformes :

  • Android Chromium WebView : Conformément à la spécification Android WebViewClient, si aucun WebViewClient personnalisé n'est attribué, la WebView peut demander au gestionnaire d'activités (Activity Manager) de résoudre l'URL via les gestionnaires système disponibles. Lorsqu'un WebViewClient personnalisé est attribué et que shouldOverrideUrlLoading renvoie false pour un schéma personnalisé non pris en charge, la WebView continue de le charger dans Chromium et affiche l'erreur net::ERR_UNKNOWN_URL_SCHEME.
  • iOS WebKit WKWebView : WebKit rejette les schémas non HTTP en interne et abandonne la navigation à moins que le WKNavigationDelegate de l'hôte n'intercepte la requête et ne la transfère à UIApplication, ce qui échoue souvent en silence ou déclenche NSURLErrorUnsupportedURL.

Notez également que la fonctionnalité Apple Promoting Apps with Smart App Banners est une option de prise en charge propre à Safari, conçue pour la navigation autonome sur Safari plutôt que pour une API de navigation WKWebView intégrée, et doit être évaluée séparément des redirections de schémas d'URL personnalisés au sein de l'application.

En un coup d'œil

  • Séparer le comportement du moteur de la politique de l'hôte : Isolez si une navigation a échoué au sein du moteur Web (Chromium/WebKit), au niveau des substitutions de délégués natifs ou à la frontière de résolution des packages du système d'exploitation.
  • Inspecter les redirections en direct avant de coder : Utilisez Chrome DevTools (chrome://inspect) et Safari Web Inspector (isInspectable = true) pour capturer les chaînes de redirection 3xx, les états targetFrame et les indicateurs de gestes.
  • Appliquer une validation d'URI et d'intentions adaptée à la plateforme : Sur Android, associez les schémas personnalisés et les cibles intent:// en relation biunivoque aux packages vérifiés via IntentSanitizer sans indicateurs de tâche fournis par la page Web ; sur iOS, validez les structures d'URI personnalisées complètes (en s'appuyant sur les Universal Links lorsque l'identité vérifiée de l'application au domaine est requise) et rejetez les clés de requête en double sur les deux plateformes.
  • Appliquer une défense en profondeur pour les pop-up et les conditions de concurrence : Limitez l'état de session des pop-up Android strictement au thread UI tout en comprenant les frontières de rappel entre shouldInterceptRequest et shouldOverrideUrlLoading, et séparez les vérifications de politiques pures des effets secondaires de répartition externe dans WKWebView sur iOS grâce à une déduplication au niveau des actions et des jetons de génération de navigation.

Causes courantes et étapes de vérification des erreurs de redirection WebView

Mise en correspondance des erreurs client observées avec les mécanismes d'échec sous-jacents du conteneur

Utilisez la matrice de diagnostic ci-dessous pour associer les symptômes observés sur la WebView aux causes profondes courantes, aux étapes de vérification et aux correctifs ciblés :

Symptôme ou erreur observé(e) Plateforme cible Cause racine courante Étape de vérification du diagnostic Correction ciblée
La WebView affiche net::ERR_UNKNOWN_URL_SCHEME Android WebView Le WebViewClient personnalisé renvoie false ou manque de liste d'autorisations pour le schéma Inspecter request.url dans shouldOverrideUrlLoading Intercepter les URI autorisées et répartir une action Intent.ACTION_VIEW liée à un package de manière biunivoque
Blocage silencieux lors du appui sur un lien de schéma personnalisé iOS WKWebView WebKit abandonne l'URI non HTTP lorsque WKNavigationDelegate renvoie .allow Journaliser navigationAction.request.url dans decidePolicyForNavigationAction Acheminer les schémas validés via UIApplication.shared.open et transmettre .cancel
target="_blank" remplace la page actuelle dans la WebView Android WebView setSupportMultipleWindows(false) traite les nouvelles fenêtres comme des chargements de niveau supérieur Vérifier webView.settings.supportMultipleWindows() Activer setSupportMultipleWindows(true) uniquement si des conteneurs pop-up séparés sont nécessaires
target="_blank" ne fait rien ou supprime les redirections OAuth 302 Android WebView onCreateWindow est manquant, ou le client enfant bloque les sauts isRedirect dépourvus de hasGesture() Vérifier les journaux onCreateWindow, request.isRedirect et shouldInterceptRequest Attacher une WebView pop-up hébergée par une vue avec un état de session basé sur le thread UI et des sauts isRedirect limités
Un lien avec target="_blank" ou window.open() ne fait rien iOS WKWebView La navigation dans une nouvelle fenêtre définit targetFrame == nil et requiert WKUIDelegate Vérifier navigationAction.targetFrame == nil Détecter targetFrame == nil dans decidePolicyForNavigationAction et gérer via WKUIDelegate
L'application cible est installée, mais la page de repli s'ouvre Android 11+ (targetSdk >= 30) Des déclarations <queries> manquantes amènent resolveActivity() ou queryIntentActivities() à renvoyer des résultats incomplets pour les packages invisibles Ajouter une journalisation au niveau de l'application autour de resolveActivity() et inspecter la sortie via adb logcat Déclarer des intentions <queries> en cas de vérification préalable, ou appeler startActivity directement avec une gestion de l'exception ActivityNotFoundException
La redirection par minuteur JavaScript ne parvient pas à ouvrir l'application externe iOS / Android La redirection par script automatisé manque d'un signal d'interaction utilisateur Vérifier request.hasGesture() (Android) ou navigationType (iOS) Lier les redirections aux appuis directs des utilisateurs et définir une politique explicite de gestes de l'hôte
Le lien universel (Universal Link) se charge dans WKWebView au lieu de l'application cible iOS WKWebView Le contexte de navigation, la relation de domaine ou la navigation JS maintient le chargement dans WebKit Vérifier navigationType et l'hôte dans decidePolicyForNavigationAction Appeler UIApplication.shared.open avec .universalLinksOnly: true pour les hôtes externes autorisés

Checklist de diagnostic rapide des redirections WebView en cinq minutes

  • Étape 1 : Vérifier le schéma de protocole dans DevTools : Vérifiez si la page a émis un URI https://, un schéma personnalisé ou un URI intent:// et confirmez qu'il n'a pas été bloqué par la politique de sécurité du contenu (CSP).
  • Étape 2 : Inspecter la hiérarchie des frames : Vérifiez si le déclencheur provient d'un élément <iframe> tiers (!isMainFrame). Les applications hôtes peuvent intentionnellement bloquer le lancement d'applications externes initié à partir d'iframes tiers.
  • Étape 3 : Distinguer les redirections des minuteurs : Vérifiez si une navigation sans geste est une redirection de serveur HTTP 3xx autorisée (request.isRedirect sur Android) par rapport à un minuteur JavaScript non sollicité.
  • Étape 4 : Vérifier les déclencheurs de nouvelle fenêtre : Confirmez si target="_blank" ou window.open() a créé une requête de nouvelle fenêtre (targetFrame == nil sur iOS ou onCreateWindow sur Android).
  • Étape 5 : Vérifier la résolution des packages du système d'exploitation : Pour les applications ciblant l'API 30+ sur Android 11+, confirmez si les appels préliminaires resolveActivity() échouent en raison de déclarations <queries> manquantes.

Le flux de diagnostic suivant illustre le parcours de triage séquentiel pour isoler les échecs de redirection du conteneur :

[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)

Comment inspecter les événements de navigation WebView à l'aide d'outils de débogage à distance

Activation du débogage à distance via Chrome DevTools et ADB Logcat sur Android

Avant de modifier les délégués natifs, vérifiez si la page Web chargée émet la redirection attendue. Conformément au guide de débogage à distance Android Chrome DevTools, activez explicitement le débogage de WebView à distance dans les versions de développement en inspectant ApplicationInfo.FLAG_DEBUGGABLE et en invoquant WebView.setWebContentsDebuggingEnabled(true). Ne livrez jamais le débogage activé dans les versions de production :

// Android - Enable WebView debugging exclusively in debuggable builds
if (applicationInfo.flags and ApplicationInfo.FLAG_DEBUGGABLE != 0) {
    WebView.setWebContentsDebuggingEnabled(true)
}

Connectez l'appareil via USB, ouvrez chrome://inspect/#devices dans Chrome sur bureau, et surveillez l'onglet Network en ayant coché l'option Preserve log. Filtrez simultanément les journaux d'exécution natifs via adb logcat pour capturer ActivityNotFoundException, SecurityException ou les journaux personnalisés du wrapper. Notez que les avertissements de dépréciation pour la signature héritée shouldOverrideUrlLoading(WebView, String) apparaissent lors de la compilation Android Studio / Gradle plutôt que dans le runtime adb logcat :

# Terminal - Filter logcat for custom WebView tags and ActivityTaskManager intent resolution
adb logcat -s "WebViewDebug" "ActivityTaskManager" "PackageManager"

Configuration de isInspectable et attachement de Safari Web Inspector et de la console Xcode sur iOS

À partir d'iOS 16.4 et macOS 13.3, Apple exige que les applications optent explicitement pour cette fonctionnalité via WKWebView.isInspectable, qui est défini par défaut sur false. Activez webView.isInspectable = true à l'intérieur des blocs #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

Sur l'appareil iOS physique, accédez à Réglages > Apps > Safari > Avancé (sur les anciennes versions d'iOS, Réglages > Safari > Avancé) et activez Web Inspector. Connectez-vous via USB, ouvrez le menu Développement de Safari sur le bureau et surveillez simultanément la console Xcode pour afficher la sortie de fin des méthodes natives decidePolicyForNavigationAction, createWebViewWith et UIApplication.shared.open.

Android WebView and iOS WKWebView use distinct native navigation and popup handlers.

Résolution des abandons silencieux de nouvelles fenêtres et des gestes utilisateur manquants dans iOS WKWebView

Séparation de l'évaluation des politiques et des effets secondaires entre WKNavigationDelegate et WKUIDelegate

Lorsqu'un lien Web spécifie target="_blank" ou window.open(), WebKit crée une requête de navigation de nouvelle fenêtre où navigationAction.targetFrame vaut nil et fait intervenir à la fois WKNavigationDelegate et WKUIDelegate. Si l'application hôte n'implémente pas webView(_:createWebViewWithConfiguration:for:windowFeatures:), WebKit ne peut pas générer de WebView secondaire et les navigations peuvent sembler échouer silencieusement.

Pour éviter les lancements d'applications externes en double ou les jetons de génération incrémentés deux fois lorsque les deux délégués inspectent une requête, séparez l'évaluation de politique pure (evaluateNavigationPolicy) des effets secondaires d'exécution, et effectuez une déduplication par l'instance WKNavigationAction spécifique (ObjectIdentifier(navigationAction)) plutôt que de vous fier uniquement à un seuil temporel brut qui pourrait supprimer des clics répétés rapides et intentionnels de la part de l'utilisateur. Évaluez navigationAction.targetFrame == nil directement dans decidePolicyForNavigationAction : si l'évaluation renvoie un plan de transfert externe, exécutez-le une seule fois (en enregistrant l'identifiant WKNavigationAction) et renvoyez .cancel ; si elle renvoie .allowInWebView pour une URL de pop-up autorisée, renvoyez .allow afin que createWebViewWith charge la pop-up en toute sécurité. Vérifiez toujours l'ordre exact des rappels des délégués sur les versions iOS cibles.

Contexte des Universal Links, sécurité des conditions de concurrence asynchrones et identité des schémas personnalisés

Le transfert par Universal Link dépend du contexte de navigation source, de la relation de domaine et de la configuration des domaines associés (Associated Domains, vérifiés via le fichier apple-app-site-association du serveur cible). La note technique d'Apple TN3155: Debugging universal links documente comment la navigation sur un même domaine dans Safari favorise le maintien dans le navigateur, tandis que des sous-domaines distincts modifient l'éligibilité. Testez toujours le comportement des domaines associés sur les versions iOS cibles à l'intérieur de WKWebView.

Lors de l'appel de UIApplication.shared.open(url, options: [.universalLinksOnly: true]), protégez-vous contre les conditions de concurrence de navigation asynchrones : si un utilisateur initie une tentative de navigation ultérieure sur le cadre principal pendant que le système traite le transfert Universal Link, un gestionnaire de fin non protégé renvoyant false pourrait écraser le nouvel état de navigation de l'utilisateur. Incrémentez un jeton de génération de navigation monotone activeNavigationGeneration à chaque nouvelle évaluation de navigation du cadre principal (y compris les tentatives bloquées ou redirigées) afin que tout repli asynchrone antérieur en attente soit immédiatement invalidé, et vérifiez self.activeNavigationGeneration == requestGeneration parallèlement à self.isViewLoaded && self.view.window != nil avant de recharger les URL de repli.

Respectez deux frontières de sécurité strictes :

  • Classification WKNavigationType : Conformément à la documentation Apple sur WKNavigationType, formSubmitted représente une requête de soumission de formulaire plutôt qu'un appui sur un lien, et les scripts de page peuvent soumettre des formulaires par programmation. Restreignez les transferts d'applications externes aux événements .linkActivated classifiés par WebKit combinés à sourceFrame.isMainFrame et à des listes d'autorisations d'URI complètes, plutôt que de traiter .linkActivated comme un jeton de geste cryptographique isolé.
  • Unicité des schémas personnalisés et pollution de paramètres : Conformément au guide d'Apple sur la définition d'un schéma d'URL personnalisé pour votre application, plusieurs applications peuvent revendiquer le même schéma personnalisé. isAllowedCustomURL(_:) valide la structure de l'URI (schéma, hôte, port par défaut nil, motif de chemin, absence d'informations utilisateur/fragment, et rejet des clés de requête en double), et non l'identité de l'ID de bundle cible. Utilisez des Universal Links vérifiés par domaine chaque fois que la liaison d'identité d'application est requise.

Avertissement concernant l'architecture de référence : L'implémentation suivante constitue une architecture de référence défensive. Validez la disponibilité des API, l'ordre des délégués et le comportement du cycle de vie par rapport aux versions exactes d'AndroidX et d'iOS utilisées par votre application.

// 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
    }
}

Correction des erreurs ERR_UNKNOWN_URL_SCHEME et des problèmes de visibilité de package dans Android WebView

Rappels dépréciés, hasGesture() et frontières POST

Android a déprécié shouldOverrideUrlLoading(WebView, String) au niveau d'API 24 au profit de shouldOverrideUrlLoading(WebView, WebResourceRequest). WebResourceRequest fournit isForMainFrame, isRedirect et hasGesture(). Notez deux contraintes officielles de la plateforme : shouldOverrideUrlLoading n'est pas invoqué pour les appels webView.loadUrl() initiés par l'application ou pour les navigations HTTP POST, et hasGesture() peut renvoyer false pour des redirections JavaScript asynchrones légitimes ou des sauts 302 côté serveur.

Gestion des pop-up par défense en profondeur et isolution des threads dans WebChromeClient.onCreateWindow

Le comportement des pop-up Android dépend de WebSettings.setSupportMultipleWindows. Si votre application ne requiert pas de pop-up interactifs, conserver setSupportMultipleWindows(false) (ou renvoyer false depuis onCreateWindow) empêche les iframes tiers d'ouvrir des conteneurs secondaires, ou d'ouvrir des destinations vérifiées via un point d'entrée explicite contrôlé par l'hôte.

Lorsque setSupportMultipleWindows(true) est activé, WebChromeClient.onCreateWindow ne fournit pas l'URL de destination dans sa signature de rappel, et aucun rappel unique ne couvre tous les vecteurs de navigation. Comprendre le modèle de thread exact et les frontières de rappel est essentiel pour une approche de référence en matière de défense en profondeur :

  • shouldOverrideUrlLoading (Thread UI — Responsable de la navigation et de l'état de session) : S'exécute exclusivement sur le thread UI et détient tout l'état de session de pop-up mutable (isInitialTransportLoad, isAuthorizedPopupSession, popupRedirectHops et popupChainStartMs). Ce n'est que lorsqu'un chargement initial vérifié ou un geste utilisateur direct correspond à policy.isAllowedPopupUri que shouldOverrideUrlLoading autorise la session pour les redirections HTTP 302 limitées ultérieures (request.isRedirect), garantissant que les chaînes de redirection se rattachent à une session autorisée plutôt qu'à des redirections arbitraires de confiance.
  • shouldInterceptRequest (Thread d'E/S de la WebView en arrière-plan — Garde de lecture seule sans état) : S'exécute sur un thread WebView non-UI. Étant donné qu'il ne doit jamais modifier l'état de session du thread UI, il fonctionne strictement comme une vérification de politique en lecture seule et sans état sur safeClient.policy (bloquant les requêtes HTTP/HTTPS du cadre principal qui échouent à isAllowedPopupUri et répartissant disposeActivePopup() sur le thread principal). Notez que, selon la documentation Android, shouldInterceptRequest est uniquement appelé pour l'URL de la ressource initiale, et non pour les URL de redirection HTTP 302 ultérieures ; ces dernières doivent être évaluées par shouldOverrideUrlLoading.
  • onPageStarted (Thread UI — Vérification de repli au démarrage de la navigation) : S'exécute lorsque le chargement du cadre principal commence (et non comme un filtre pré-navigation). Il met à jour la bannière d'origine visible pour la transparence de l'utilisateur et fournit une vérification de repli au démarrage de la navigation appelant stopLoading() et disposeActivePopup() si une destination non approuvée commence à se charger.

Testez toujours les URL initiales malveillantes, les chaînes HTTP 302 inter-domaines, les redirections 302 consécutives, target="_blank", window.open() et les déclencheurs d'iframe tiers sur les versions cibles physiques de WebView.

Visibilité des packages sur Android 11+ et conseils concernant la méthode obsolète canOpenURL

Dans le cadre des règles de visibilité des packages Android, les applications exécutées sur Android 11 (niveau d'API 30) ou version ultérieure et ciblant le niveau d'API 30 ou supérieur (targetSdk >= 30) reçoivent des résultats null ou vides de intent.resolveActivity() ou queryIntentActivities() à moins que les applications cibles ne soient déclarées sous la balise <queries> dans le fichier AndroidManifest.xml. Android recommande d'appeler directement startActivity(intent) dans un bloc try/catch pour gérer ActivityNotFoundException et SecurityException plutôt que d'étendre la balise <queries>.

Sur iOS, Apple a déprécié UIApplication.canOpenURL(_:) et recommande de tenter d'exécuter directement UIApplication.shared.open(_:options:completionHandler:) et de gérer toute défaillance dans le gestionnaire de fin (ou de migrer vers les Universal Links pour supprimer la pré-validation des schémas). La clé LSApplicationQueriesSchemes dans Info.plist n'est requise que si le code existant continue d'appeler canOpenURL(_:), tandis que open(_:options:completionHandler:) ne nécessite pas de déclarer des schémas dans Info.plist. À la fois <queries> et LSApplicationQueriesSchemes contrôlent la visibilité des requêtes — ce ne sont pas des listes d'autorisations de sécurité permettant de valider des URI Web non fiables.

<!-- 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>

Comment analyser en toute sécurité les URI d'intention Chrome et éviter les boucles de redirection

Sécurisation de Intent.parseUri contre les exploits de redirection d'intentions

Les URI Android intent:// encodent un schéma cible, un package et une URL de repli (S.browser_fallback_url). L'analyse d'URI Web non fiables via Intent.parseUri(rawUri, Intent.URI_INTENT_SCHEME) introduit des risques de redirection d'intention (Intent Redirection) détaillés dans le guide de sécurité sur la redirection d'intentions Android et le guide de test de sécurité des applications mobiles de l'OWASP (OWASP MASTG). Même avec Android 16 (API 36) ajoutant un renforcement par défaut au niveau de la plateforme, les applications doivent imposer une validation stricte avant de répartir les intentions.

Layered URI validation blocks unsafe WebView intents before external application dispatch.

Pour mettre en œuvre une validation par refus par défaut (fail-closed) à l'aide de l'utilitaire AndroidX IntentSanitizer (androidx.core:core:1.9.0+ ou androidx.core:core-ktx:1.9.0+ qui intègre androidx.core:core) sans déclencher de conflits d'exclusion mutuelle de l'outil de construction (Builder) entre allowAnyComponent() et les méthodes de liste d'autorisations de packages/composants :

  • Vérifications de pré-assainissement : Rejetez immédiatement les intentions portant des champs component ou selector non nuls (parsedIntent.component != null || parsedIntent.selector != null). Extrayez et supprimez browser_fallback_url avant l'assainissement, et vérifiez de manière native que parsedIntent.data?.scheme correspond de manière biunivoque à parsedIntent.package via customSchemeTargetPackages (en s'assurant que myapp:// se résout strictement à com.example.target, et jamais à un autre package partenaire).
  • Exécution de l'assainisseur : Effacez temporairement parsedIntent.package = null sur la copie non fiable, exécutez IntentSanitizer.Builder().allowAnyComponent().allowAction(Intent.ACTION_VIEW).allowCategory(Intent.CATEGORY_BROWSABLE).allowData { ... }.build().sanitizeByThrowing(parsedIntent) (zéro indicateur de tâche fourni par la page Web), et réattribuez le expectedPackage validé et CATEGORY_BROWSABLE sur l'intention assainie appartenant à l'hôte avant les assertions post-assainissement.
  • Indicateurs de lancement conscients du contexte : Injectez Intent.FLAG_ACTIVITY_NEW_TASK dans le répartiteur natif (launchWithContextSafety) uniquement lorsque view.context !is Activity. Pour la vérification de l'association domaine-application, privilégiez les liens d'application Android HTTPS vérifiés (assetlinks.json).

Prévention des boucles de repli infinies avec un état de chaîne monotone

Lorsque startActivity lève l'exception ActivityNotFoundException, validez l'URL browser_fallback_url à l'aide d'une vérification dédiée isAllowedFallbackUri(uri) (strictement HTTPS, port par défaut, hôte vérifié, préfixes de chemin de repli explicites, absence de clés de requête en double et absence de fragments). Rejetez les représentations de ports explicites sur les schémas personnalisés en vérifiant à la fois uri.port == -1 et !uri.encodedAuthority.orEmpty().contains(":").

Suivez les chaînes de repli à l'aide de SystemClock.elapsedRealtime() (en évitant les sauts d'horloge murale System.currentTimeMillis()), isolez les chaînes via fallbackLoopKey() (plutôt qu'une canonisation IETF RFC 3986 complète), réinitialisez l'état via un wrapper d'hôte explicite loadNewNavigation(webView, url), et acheminez les replis de pop-up vers le conteneur principal via onPopupFallbackHandoff afin qu'aucun domaine non autorisé ne se charge jamais dans une boîte de dialogue pop-up.

Avertissement concernant l'architecture de référence : L'implémentation suivante constitue une architecture de référence défensive. Validez la disponibilité des API, l'ordre des délégués et le comportement du cycle de vie par rapport aux versions exactes d'AndroidX et d'iOS utilisées par votre application.

// 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()
    }
}

Foire aux questions (FAQ)

Pourquoi Android WebView affiche-t-il net::ERR_UNKNOWN_URL_SCHEME même lorsque l'application cible est installée ?
Cette erreur se produit lorsque Chromium tente de récupérer un schéma d'URL personnalisé non HTTP via sa pile réseau au lieu de le transmettre au gestionnaire d'activités (Activity Manager) d'Android. Vérifiez cinq points de contrôle : confirmez qu'un <code>WebViewClient</code> personnalisé est attribué ; assurez-vous que <code>shouldOverrideUrlLoading(WebView, WebResourceRequest)</code> renvoie <code>true</code> pour le schéma intercepté ; confirmez que la structure de l'URI et le package cible biunivoque passent votre liste d'autorisations ; vérifiez que <code>startActivity(intent)</code> s'exécute proprement (en interceptant <code>ActivityNotFoundException</code> ou en configurant <code>&lt;queries&gt;</code> pour <code>targetSdk &gt;= 30</code> si vous appelez <code>resolveActivity()</code>) ; et confirmez que le manifeste de l'application cible déclare un filtre <code>&lt;intent-filter&gt;</code> correspondant avec <code>CATEGORY_BROWSABLE</code>.
Pourquoi shouldOverrideUrlLoading ne se déclenche-t-il pas lorsque mon application appelle directement loadUrl sur la WebView ?
Par conception de l'infrastructure Android, <code>shouldOverrideUrlLoading</code> n'est pas invoqué pour les appels <code>webView.loadUrl()</code> initiés par l'application ou pour les navigations HTTP <code>POST</code>. Il se déclenche principalement pour les navigations initiées par le contenu Web, les interactions des utilisateurs ou les redirections de serveur HTTP 3xx prises en charge. Déclenchez des redirections de test à partir d'interactions du DOM ou de réponses de serveur à l'intérieur de la page, et utilisez des wrappers d'hôte explicites (tels que <code>loadNewNavigation</code>) lors de l'audit des chargements initiés par l'application.
Pourquoi les liens target blank avec des schémas personnalisés échouent-ils silencieusement à l'intérieur de WKWebView ?
Lorsqu'un lien Web utilise <code>target="_blank"</code> ou <code>window.open()</code>, WebKit crée une requête de navigation de nouvelle fenêtre où <code>navigationAction.targetFrame</code> vaut <code>nil</code>. Étant donné que <code>WKWebView</code> n'ouvre pas automatiquement de nouveaux onglets, ces navigations peuvent échouer silencieusement à moins que l'application hôte ne détecte <code>targetFrame == nil</code> dans <code>decidePolicyForNavigationAction</code> et n'implémente <code>WKUIDelegate.webView(_:createWebViewWith:for:windowFeatures:)</code> pour évaluer et acheminer la requête dans le cadre de sa politique de navigation unifiée.

Résumé et cadre de décision

La résolution des échecs de redirection par liens profonds (deep-linking) dans les WebView nécessite d'isoler le comportement du moteur WebView des politiques de navigation de l'application hôte. En reproduisant les événements de navigation dans Chrome DevTools ou Safari Web Inspector, en limitant l'état de session des pop-up Android strictement au thread UI tout en associant un filtrage des requêtes initiales sans état à des vérifications de redirection 302 autorisées par la session, en appliquant des listes d'autorisations IntentSanitizer en mode de refus par défaut (fail-closed), et en protégeant les replis d'Universal Links iOS contre les écrasements asynchrones obsolètes et les lancements de délégués en double, les équipes d'ingénierie peuvent réduire les parcours utilisateur rompus et aider à prévenir les vulnérabilités de redirection côté client.

Une fois que les délégués natifs au niveau du conteneur et les chemins de repli sont vérifiés, les équipes d'ingénierie doivent également valider les pages de destination d'attribution de bout en bout et les chaînes de routage de lancement en un clic (One-Click Launch) à l'aide de plateformes telles que OpoInstall pour confirmer la préservation des paramètres lors des transitions du navigateur vers l'application.

Glossaire des entités

Terme Définition Entité associée Rôle d'intention de recherche
WebView Un composant d'interface utilisateur natif intégré utilisé pour afficher des pages Web à l'intérieur d'une application mobile. WebViewClient / WKWebView Informationnel / Technique
Schéma d'URL personnalisé (Custom URL Scheme) Un préfixe d'URI enregistré par l'application (par exemple, myapp://) permettant une navigation externe vers des écrans natifs. Intent.ACTION_VIEW Technique / Informationnel
WKNavigationDelegate Le protocole WebKit permettant à une application hôte d'accepter, d'annuler ou de rediriger des actions de navigation dans WKWebView. decidePolicyForNavigationAction Technique
WKUIDelegate Le protocole WebKit responsable de la gestion des requêtes de création de nouvelles fenêtres dans WKWebView. createWebViewWith Technique
WebResourceRequest L'objet Android API 24+ encapsulant l'URL, le frame, la méthode HTTP, la redirection et les métadonnées de geste. shouldOverrideUrlLoading Technique
WebChromeClient L'interface de rappel Android WebView gérant les dialogues JavaScript, la progression et onCreateWindow. WebViewTransport Technique
IntentSanitizer L'utilitaire AndroidX Core utilisé pour filtrer ou valider strictement les champs d'intention non fiables avant la répartition. Défense contre la redirection d'intention Technique / Sécurité
Universal Links (Liens universels) Le standard de liens profonds basé sur HTTPS d'Apple reliant des domaines Web vérifiés à des applications iOS installées. Domaines associés (Associated Domains) Technique / Informationnel
Visibilité des packages (Package Visibility) Le filtrage du système d'exploitation Android 11+ (targetSdk >= 30) restreignant les applications installées qu'une application hôte peut interroger via PackageManager. Balise de manifeste <queries> Technique
URI d'intention (Intent URI) Un URI Android structuré (intent://) encodant le package cible, le schéma et les URL de repli du navigateur. Intent.URI_INTENT_SCHEME Technique

Base de référence de compatibilité et état de vérification

  • Cibles de compatibilité prévues : Android minSdk 24, compileSdk 34/35, targetSdk 34/35 (Android 14/15), contexte de renforcement de la redirection d'intentions Android 16 (API 36), androidx.core:core:1.9.0+ (IntentSanitizer) ; iOS 15.0–18.0 (contrôle isInspectable activé sur iOS 16.4+), Xcode 15/16, Swift 5.9/6.0.

  • État de vérification :

    • Examen de l'API statique et des spécifications : Réalisé par rapport aux spécifications officielles des développeurs Android, AndroidX Core, Apple Developer, IETF RFC 3986 et OWASP MASTG.

    • Compilation et vérification sur appareil physique : Non encore exécuté au cours de ce cycle de révision. Les équipes doivent compiler et exécuter des tests de régression sur des appareils physiques couvrant les URL de pop-up initiales malveillantes, les chaînes 302 inter-domaines, les sauts 302 consécutifs, la création de fenêtres d'iframe tiers, les liens d'application Android (Android App Links, assetlinks.json), les domaines associés iOS (mise en cache AASA), l'annulation asynchrone obsolète d'Universal Links, les chaînes de repli intent:// et la répartition d'ActivityNotFoundException avant le déploiement en production.

Références

Share this article