Wie beheben Sie WebView-Umleitungsfehler unter Android und iOS? Identifizieren Sie, ob der Fehler eine Standard-HTTPS-Navigation, ein benutzerdefiniertes URL-Schema, eine Android-intent://-URI oder eine Anfrage für ein neues Fenster betrifft, untersuchen Sie dann die Navigation über die Chrome DevTools oder den Safari Web Inspector und verfolgen Sie den entsprechenden nativen Delegaten (shouldOverrideUrlLoading, onCreateWindow, decidePolicyForNavigationAction oder createWebViewWith). Überprüfen Sie die Ziel-App-Auflösung, URI-Allowlists, Frame- und Nutzerinteraktionsrichtlinien sowie das Fallback-Routing, um Container-Fehler von Fehlern bei der Betriebssystem-Ausführung zu isolieren.
Ein WebView-Umleitungsfehler tritt auf, wenn ein eingebettetes Android-Chromium-WebView oder ein iOS-WebKit-WKWebView eine Navigationsanfrage nicht an das gewünschte Ziel weiterleiten kann. Typische Ursachen sind nicht unterstützte benutzerdefinierte URL-Schemata, unbehandelte
target="_blank"-Anfragen, fehlende Paket-Sichtbarkeitsdeklarationen sowie abgelehnte oder in Schleifen laufende Fallback-Umleitungen.
Warum eingebettete Android-WebView- und iOS-WKWebView-Container Umleitungen verwerfen

Bei der Fehlersuche bei Umleitungsfehlern müssen Entwicklungsteams das Verhalten der WebView-Engine (wie Chromium oder WebKit URLs, Frame-Ziele und Popup-Ereignisse analysiert) von der Richtlinie der Host-Anwendung (wie die anwendungsspezifischen WebViewClient, WebChromeClient, WKNavigationDelegate oder WKUIDelegate Nutzerinteraktionstypen, Allowlists und Übergaben an externe Apps auswerten) trennen. Eigenständige Browser enthalten integrierte URI-Dispatcher und Link-Übergabehandler, wohingegen android.webkit.WebView und das WKWebView von Apple eingebettete Rendering-Komponenten sind, die standardmäßig standardmäßige Netzwerkantworten vom Typ http:// oder https:// erwarten.
Wenn eine Webseite ein benutzerdefiniertes Schema (wie myapp://product/42) oder einen Android-intent://-Link ohne aktive Delegaten-Überschreibung auslöst, weicht das Standard-Containerverhalten zwischen den Plattformen voneinander ab:
- Android Chromium WebView: Gemäß der
WebViewClient-Spezifikation für Android fordert WebView möglicherweise den Activity Manager auf, die URL über verfügbare Systemhandler aufzulösen, wenn kein benutzerdefinierterWebViewClientzugewiesen ist. Wenn jedoch ein benutzerdefinierterWebViewClientzugewiesen ist undshouldOverrideUrlLoadingfür ein nicht unterstütztes benutzerdefiniertes Schemafalsezurückgibt, lädt WebView es weiterhin in Chromium und gibtnet::ERR_UNKNOWN_URL_SCHEMEaus. - iOS WebKit WKWebView: WebKit lehnt Nicht-HTTP-Schemata intern ab und bricht die Navigation ab, es sei denn, der
WKNavigationDelegatedes Hosts fängt die Anfrage ab und leitet sie anUIApplicationweiter, was häufig stillschweigend fehlschlägt oderNSURLErrorUnsupportedURLauslöst.
Beachten Sie zudem, dass Apples Funktion Apps mit Smart App-Bannern bewerben ein Safari-Support-Feature ist, das für das eigenständige Surfen in Safari und nicht für eine eingebettete WKWebView-Navigations-API entwickelt wurde, und separat von Umleitungen über benutzerdefinierte In-App-URL-Schemata bewertet werden sollte.
Auf einen Blick
- Engine-Verhalten von Host-Richtlinien trennen: Isolieren Sie, ob eine Navigation innerhalb der Web-Engine (Chromium/WebKit), innerhalb nativer Delegaten-Überschreibungen oder an der Grenze der Betriebssystem-Paketauflösung fehlgeschlagen ist.
- Live-Umleitungen vor dem Programmieren untersuchen: Verwenden Sie Chrome DevTools (
chrome://inspect) und Safari Web Inspector (isInspectable = true), um 3xx-Umleitungsketten,targetFrame-Zustände und Gesten-Flags zu erfassen. - Plattformgerechte URI- und Intent-Validierung durchsetzen: Binden Sie unter Android benutzerdefinierte Schemata und
intent://-Ziele 1:1 überIntentSanitizeran verifizierte Pakete, ohne vom Webseiten bereitgestellte Task-Flags; validieren Sie unter iOS vollständige benutzerdefinierte URI-Strukturen (wobei auf Universal Links zurückgegriffen wird, wenn eine verifizierte App-zu-Domain-Identität erforderlich ist) und lehnen Sie doppelte Abfrageschlüssel auf beiden Plattformen ab. - Tiefenverteidigung für Popups und Race Conditions anwenden: Beschränken Sie den Android-Popup-Sitzungsstatus strikt auf den UI-Thread, während Sie die Callback-Grenzen über
shouldInterceptRequestundshouldOverrideUrlLoadinghinweg verstehen, und trennen Sie reine Richtlinienprüfungen von Nebeneffekten externer Dispatches im iOS-WKWebViewmithilfe einer aktionsbasierten Deduplizierung und Navigationsgenerierungs-Token.
Häufige Ursachen und Verifizierungsschritte für WebView-Umleitungsfehler
Zuordnung beobachteter Client-Fehler zu zugrundeliegenden Container-Fehlermechanismen
Verwenden Sie die folgende Diagnosematrix, um beobachtete WebView-Symptome gängigen Plattform-Ursachen, Verifizierungsschritten und gezielten Korrekturmaßnahmen zuzuordnen:
| Beobachtetes Symptom oder Fehler | Zielplattform | Häufige Ursache | Diagnostischer Verifizierungsschritt | Gezielte Korrekturmaßnahme |
|---|---|---|---|---|
WebView zeigt net::ERR_UNKNOWN_URL_SCHEME an |
Android WebView | Benutzerdefinierter WebViewClient gibt false zurück oder es fehlt eine Schema-Allowlist |
Untersuchen Sie request.url in shouldOverrideUrlLoading |
Allowlist-URIs abfangen und 1:1 paketgebundenes Intent.ACTION_VIEW ausführen |
| Stilles Hängenbleiben beim Tippen auf einen Link mit benutzerdefiniertem Schema | iOS WKWebView | WebKit bricht Nicht-HTTP-URI ab, wenn WKNavigationDelegate .allow zurückgibt |
Protokollieren Sie navigationAction.request.url in decidePolicyForNavigationAction |
Validierte Schemata über UIApplication.shared.open routen und .cancel übergeben |
target="_blank" ersetzt die aktuelle Seite in WebView |
Android WebView | setSupportMultipleWindows(false) behandelt neue Fenster als Ladevorgänge auf oberster Ebene |
Überprüfen Sie webView.settings.supportMultipleWindows() |
Aktivieren Sie setSupportMultipleWindows(true) nur, wenn separate Popup-Container benötigt werden |
target="_blank" bewirkt nichts oder verwirft OAuth-302-Umleitungen |
Android WebView | onCreateWindow fehlt oder der untergeordnete Client blockiert isRedirect-Hops ohne hasGesture() |
Überprüfen Sie die Protokolle für onCreateWindow, request.isRedirect und shouldInterceptRequest |
Ein in einer Ansicht gehostetes Popup-WebView mit UI-Thread-Sitzungsstatus und begrenzten isRedirect-Hops einbinden |
Link mit target="_blank" oder window.open() bewirkt nichts |
iOS WKWebView | Navigation in neuem Fenster setzt targetFrame == nil und erfordert WKUIDelegate |
Überprüfen Sie navigationAction.targetFrame == nil |
Erkennen Sie targetFrame == nil in decidePolicyForNavigationAction und verarbeiten Sie es über WKUIDelegate |
| Ziel-App ist installiert, aber die Fallback-Seite öffnet sich | Android 11+ (targetSdk >= 30) |
Fehlende <queries>-Deklarationen führen dazu, dass resolveActivity() oder queryIntentActivities() unvollständige Ergebnisse für unsichtbare Pakete liefern |
Fügen Sie anwendungsspezifisches Logging um resolveActivity() hinzu und untersuchen Sie die Ausgabe über adb logcat |
Deklarieren Sie <queries>-Intents beim Vorab-Prüfen oder rufen Sie startActivity direkt mit einem ActivityNotFoundException-Catch auf |
| JavaScript-Timer-Umleitung öffnet die externe App nicht | iOS / Android | Automatisierter Skript-Redirect entbehrt eines Nutzerinteraktionssignals | Überprüfen Sie request.hasGesture() (Android) oder navigationType (iOS) |
Verknüpfen Sie Umleitungen mit direkten Nutzertipps und definieren Sie eine explizite Host-Gesten-Richtlinie |
Universal Link wird im WKWebView anstelle der Ziel-App geladen |
iOS WKWebView | Browser-Kontext, Domain-Beziehung oder JS-Navigation hält das Laden in WebKit | Überprüfen Sie navigationType und Host in decidePolicyForNavigationAction |
Rufen Sie UIApplication.shared.open mit .universalLinksOnly: true für erlaubte externe Hosts auf |
Fünf-Minuten-Schnell-Checkliste für WebView-Umleitungen
- Schritt 1: Protokollschema in DevTools überprüfen: Überprüfen Sie, ob die Seite eine
https://, ein benutzerdefiniertes Schema oder eineintent://-URI ausgegeben hat, und vergewissern Sie sich, dass sie nicht durch die Content Security Policy (CSP) blockiert wurde. - Schritt 2: Frame-Hierarchie untersuchen: Prüfen Sie, ob der Auslöser innerhalb eines Drittanbieter-
<iframe>(!isMainFrame) entstanden ist. Host-Anwendungen können von Drittanbieter-Iframes initiierte externe App-Starts absichtlich blockieren. - Schritt 3: Umleitungen von Timern unterscheiden: Prüfen Sie, ob eine Navigation ohne Geste eine autorisierte HTTP-3xx-Serverumleitung (
request.isRedirectunter Android) im Gegensatz zu einem unaufgeforderten JavaScript-Timer ist. - Schritt 4: Auslöser für neue Fenster prüfen: Bestätigen Sie, ob
target="_blank"oderwindow.open()eine Anfrage für ein neues Fenster erstellt hat (targetFrame == nilunter iOS oderonCreateWindowunter Android). - Schritt 5: Betriebssystem-Paketauflösung verifizieren: Bestätigen Sie für Apps, die auf API 30+ unter Android 11+ abzielen, ob Pre-Flight-
resolveActivity()-Aufrufe aufgrund fehlender<queries>-Deklarationen fehlschlagen.
Der folgende Diagnose-Workflow veranschaulicht den sequenziellen Triage-Pfad zur Isolierung von Container-Umleitungsfehlern:
[WebView-Navigationsfehler]
│
▼
[URL + Netzwerk + Konsole über Chrome DevTools / Safari Web Inspector untersuchen]
│
▼
[Navigationsquelle identifizieren]
│
├── App loadUrl() oder HTTP POST
│ │
│ └── shouldOverrideUrlLoading wird NICHT aufgerufen; Aufrufpfad auf Host-Seite untersuchen
│
├── target="_blank" oder window.open()
│ │
│ ├── Android (multiple-windows=false) ──> Ersetzt aktuelle WebView-Seite
│ ├── Android (multiple-windows=true) ──> onCreateWindow + shouldInterceptRequest untersuchen
│ └── iOS (targetFrame == nil) ──> WKNavigationDelegate + WKUIDelegate untersuchen
│
├── HTTP / HTTPS Navigation
│ │
│ └── Host- und Port-Allowlist, 3xx-Umleitungen, Universal Link oder App-Link-Übereinstimmung untersuchen
│
└── Benutzerdefiniertes Schema oder Chrome intent://
│
├── Nutzerinteraktion + Main-Frame-Richtlinie auswerten
├── Vollständige URI-Struktur verifizieren (Schema, Host, Port, Pfad, keine doppelten Abfrageschlüssel)
├── Intent bereinigen (explizite Komponenten ablehnen, 1:1-Paket verifizieren, Null Webpage-Flags)
├── Ziel-App-Auflösung prüfen (<queries> / ActivityNotFoundException)
└── Fallback-Pfad + Abfrage-Allowlist + mononotische Ketten-Sicherung (elapsedRealtime) validieren
So untersuchen Sie WebView-Navigationsereignisse mit Remote-Debugging-Tools
Aktivieren des Remote-Debuggings über Chrome DevTools und ADB Logcat unter Android
Bevor Sie native Delegaten ändern, überprüfen Sie, ob die geladene Webseite die erwartete Umleitung ausgibt. Gemäß dem Leitfaden für das Remote-Debugging von Android Chrome DevTools sollten Sie das Remote-Debugging von WebViews in Entwicklungswuilds explizit aktivieren, indem Sie ApplicationInfo.FLAG_DEBUGGABLE untersuchen und WebView.setWebContentsDebuggingEnabled(true) aufrufen. Liefern Sie niemals aktivierte Debugging-Funktionen in Produktionsversionen aus:
// Android - WebView-Debugging ausschließlich in debug-fähigen Builds aktivieren
if (applicationInfo.flags and ApplicationInfo.FLAG_DEBUGGABLE != 0) {
WebView.setWebContentsDebuggingEnabled(true)
}
Verbinden Sie das Gerät über USB, öffnen Sie chrome://inspect/#devices in Chrome auf dem Desktop und überwachen Sie den Tab Network mit aktiviertem Preserve log. Filtern Sie gleichzeitig native Laufzeitprotokolle über adb logcat, um ActivityNotFoundException, SecurityException oder benutzerdefinierte Wrapper-Protokolle zu erfassen. Beachten Sie, dass Veraltungswarnungen für die ältere shouldOverrideUrlLoading(WebView, String)-Signatur während der Android Studio- / Gradle-Kompilierung und nicht in der Laufzeit von adb logcat angezeigt werden:
# Terminal - Logcat nach benutzerdefinierten WebView-Tags und Intent-Auflösung des ActivityTaskManager filtern
adb logcat -s "WebViewDebug" "ActivityTaskManager" "PackageManager"
Konfigurieren von isInspectable und Einbinden von Safari Web Inspector und Xcode Console unter iOS
Beginnend mit iOS 16.4 und macOS 13.3 verlangt Apple, dass Anwendungen sich über WKWebView.isInspectable anmelden, was standardmäßig auf false gesetzt ist. Aktivieren Sie webView.isInspectable = true innerhalb von #if DEBUG-Blöcken:
// iOS - Safari Web Inspector-Opt-in auf Debug-Builds ab iOS 16.4 aktivieren
#if DEBUG
if #available(iOS 16.4, *) {
webView.isInspectable = true
}
#endif
Navigieren Sie auf dem physischen iOS-Gerät zu Einstellungen > Apps > Safari > Erweitert (bei älteren iOS-Versionen Einstellungen > Safari > Erweitert) und aktivieren Sie den Web Inspector. Stellen Sie eine Verbindung über USB her, öffnen Sie das Menü Entwickeln von Desktop-Safari und überwachen Sie die Xcode Console gleichzeitig auf native Ausgaben zum Abschluss von decidePolicyForNavigationAction, createWebViewWith und UIApplication.shared.open.

Beheben von stillen Neufenster-Verwerfungen und fehlenden Nutzergesten in iOS WKWebView
Trennen der Richtlinienbewertung von Nebeneffekten über WKNavigationDelegate und WKUIDelegate hinweg
Wenn ein Weblink target="_blank" oder window.open() angibt, erstellt WebKit eine Navigationsanfrage für ein neues Fenster, bei der navigationAction.targetFrame den Wert nil hat und sowohl WKNavigationDelegate als auch WKUIDelegate einbezieht. Wenn die Host-App webView(_:createWebViewWithConfiguration:for:windowFeatures:) nicht implementiert, kann WebKit kein sekundäres WebView erzeugen, und Navigationen schlagen möglicherweise stillschweigend fehl.
Um doppelte Starts externer Apps oder doppelt inkrementierte Generationen-Token zu verhindern, wenn beide Delegaten eine Anfrage untersuchen, trennen Sie die reine Richtlinienbewertung (evaluateNavigationPolicy) von den Ausführungs-Nebeneffekten und deduplizieren Sie nach der spezifischen WKNavigationAction-Instanz (ObjectIdentifier(navigationAction)), anstatt sich ausschließlich auf eine grobe Zeitschwelle zu verlassen, die absichtliche, schnelle Wiederholungsklicks eines Benutzers unterdrücken könnte. Bewerten Sie navigationAction.targetFrame == nil direkt in decidePolicyForNavigationAction: Wenn die Bewertung einen Plan für die externe Übergabe zurückgibt, führen Sie diesen einmal aus (und zeichnen die WKNavigationAction-Kennung auf) und übergeben Sie .cancel; wenn sie .allowInWebView für eine erlaubte Popup-URL zurückgibt, übergeben Sie .allow, damit createWebViewWith das Popup sicher lädt. Überprüfen Sie immer die genaue Delegaten-Callback-Reihenfolge auf den Ziel-iOS-Versionen.
Universal-Link-Kontext, Asynchronitäts-Sicherheit und Identität benutzerdefinierter Schemata
Die Universal-Link-Übergabe hängt vom Quell-Browser-Kontext, der Domain-Beziehung und der Konfiguration der zugehörigen Domains (verifiziert über die apple-app-site-association-Datei des Zielservers) ab. Apples technischer Hinweis TN3155: Debugging Universal Links dokumentiert, wie die Navigation auf derselben Domain in Safari bevorzugt im Browser verbleibt, während unterschiedliche Subdomains die Berechtigung ändern. Testen Sie das Verhalten zugehöriger Domains immer auf Ziel-iOS-Releases innerhalb von WKWebView.
Wenn Sie UIApplication.shared.open(url, options: [.universalLinksOnly: true]) aufrufen, schützen Sie sich vor asynchronen Navigations-Race-Conditions: Wenn ein Benutzer einen nachfolgenden Main-Frame-Navigationsversuch unternimmt, während das System die Universal-Link-Übergabe verarbeitet, könnte ein nicht geschützter Completion-Handler, der false zurückgibt, den neueren Navigationsstatus des Benutzers überschreiben. Erhöhen Sie ein mononotisches activeNavigationGeneration-Token bei jeder neuen Main-Frame-Navigationsbewertung (einschließlich blockierter oder umgeleiteter Versuche), sodass jedes ausstehende vorherige asynchrone Fallback sofort ungültig wird, und überprüfen Sie self.activeNavigationGeneration == requestGeneration neben self.isViewLoaded && self.view.window != nil, bevor Sie Fallback-URLs neu laden.
Beachten Sie zwei strikte Sicherheitsgrenzen:
- Klassifizierung von
WKNavigationType: Gemäß derWKNavigationType-Dokumentation von Apple stelltformSubmittedeine Anfrage zum Senden eines Formulars anstelle eines Link-Tipps dar, und Seitenskripte können Formulare programmgesteuert senden. Beschränken Sie die Übergabe externer Apps auf von WebKit klassifizierte.linkActivated-Ereignisse in Kombination mitsourceFrame.isMainFrameund vollständigen URI-Allowlists, anstatt.linkActivatedals isoliertes kryptografisches Gesten-Token zu behandeln. - Einzigartigkeit benutzerdefinierter Schemata und Parameterverschmutzung: Gemäß Apples Leitfaden zum Definieren eines benutzerdefinierten URL-Schemas für Ihre App können mehrere Apps dasselbe benutzerdefinierte Schema beanspruchen.
isAllowedCustomURL(_:)validiert die URI-Struktur (Schema, Host, Standardportnil, Pfadmuster, keine Userinfo/Fragment und Ablehnung doppelt vorhandener Abfrageschlüssel), nicht jedoch die Identität der Ziel-Bundle-ID. Verwenden Sie domainverifizierte Universal Links, wann immer eine App-Identitätsbindung erforderlich ist.
Haftungsausschluss zur Referenzarchitektur: Die folgende Implementierung ist eine defensive Referenzarchitektur. Validieren Sie die API-Verfügbarkeit, die Delegaten-Reihenfolge und das Lifecycle-Verhalten anhand der genauen AndroidX- und iOS-Versionen, die von Ihrer Anwendung verwendet werden.
// iOS - WebViewContainerController.swift
// Referenzarchitektur: Kompilieren und testen Sie gegen Ihre spezifischen Projektziele (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!
// Explizite Allowlist für externe benutzerdefinierte URL-Schemata, Hosts und Abfrageschlüssel
private let allowedCustomSchemes: Set<String> = ["myapp", "partnerapp"]
private let allowedCustomHosts: Set<String> = ["open", "product", "promo"]
private let allowedCustomQueryKeys: Set<String> = ["id", "ref", "promo"]
// Explizite Allowlist für HTTPS-Hosts, die innerhalb des primären WebView-Containers erlaubt sind
private let allowedWebHosts: Set<String> = [
"example.com",
"m.example.com",
"links.example.com"
]
// Isolierte Allowlists speziell für untergeordnete Popup-Fenster (target="_blank")
private let allowedPopupHosts: Set<String> = ["example.com", "auth.example.com"]
private let allowedPopupPathPrefixes: [String] = ["/oauth", "/popup", "/window"]
// Externe Universal-Link-Hosts, die bei Link-Aktivierung eine native App-Übergabe versuchen
private let externalUniversalLinkHosts: Set<String> = ["links.example.com"]
// Monotones Navigationsgenerierungs-Token, das bei jedem neuen Main-Frame-Navigationsversuch inkrementiert wird
private var activeNavigationGeneration: UInt64 = 0
// Aktionsbasierte Deduplizierung zur Verhinderung doppelter Dispatches für dieselbe WKNavigationAction
private var dispatchedActionIDs: [ObjectIdentifier] = []
private let maxTrackedActionIDs = 16
// Monotone Betriebszeit-TTL-geschützter Bypass-Cache, indiziert nach normalisiertem Universal-Link-Schlüssel
private var bypassedUniversalLinkKeys: [String: TimeInterval] = [:]
private let maxBypassedKeys = 10
private let bypassTTLSeconds: TimeInterval = 300
// Passen Sie signifikante Abfrageschlüssel an die tatsächlichen Routing-Parameter Ihrer Anwendung an
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)
// Inkrementieren Sie das Generationen-Token bei jedem Main-Frame-Navigationsversuch (einschließlich blockierter Versuche),
// sodass ein ausstehendes vorheriges asynchrones Universal-Link-Fallback sofort ungültig wird.
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 (Behandelt target="_blank" und 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: - Reine Navigationsrichtlinienbewertung (Keine Nebeneffekte)
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. Benutzerdefinierte URL-Schemata auswerten, die nicht HTTP/HTTPS sind
// Hinweis: Die Allowlist für benutzerdefinierte Schemata validiert die URI-Struktur; sie kann keine Ziel-Bundle-ID-Identität garantieren.
if scheme != "http" && scheme != "https" {
guard isMainFrame, isLinkActivated, isAllowedCustomURL(url) else {
return .block
}
return .launchCustomScheme(url)
}
// 2. Nur HTTPS, Standardport (nil oder 443) und Host-Allowlists erzwingen
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. Universal-Link-Übergaben für bestimmte externe Hosts bei Link-Aktivierung bewerten
if let host = targetHost,
externalUniversalLinkHosts.contains(host),
isMainFrame,
isLinkActivated,
let loopKey = universalLinkLoopKey(for: url),
!isBypassedKeyActive(loopKey) {
return .attemptUniversalLink(url)
}
return .allowInWebView
}
// MARK: - Aktionsbasierte, deduplizierte Ausführung externer Dispatches
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
// Überprüfen Sie den Ansichtslebenszyklus UND das Generationen-Token, um veraltete Überschreibungen durch asynchrone Fallbacks zu verhindern
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] Fehler beim Starten des benutzerdefinierten Schemas (App ist möglicherweise nicht installiert)")
}
}
}
}
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, // Explizite Ports für benutzerdefinierte Schemata ablehnen
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
}
}
Beheben von ERR_UNKNOWN_URL_SCHEME und Paket-Sichtbarkeitsfehlern in Android WebView
Veraltete Callbacks, hasGesture() und POST-Grenzen
Android hat shouldOverrideUrlLoading(WebView, String) in API-Level 24 zugunsten von shouldOverrideUrlLoading(WebView, WebResourceRequest) als veraltet eingestuft. WebResourceRequest stellt isForMainFrame, isRedirect und hasGesture() bereit. Beachten Sie zwei offizielle Plattform-Einschränkungen: shouldOverrideUrlLoading wird nicht für vom Host initiierte webView.loadUrl()-Aufrufe oder HTTP-POST-Navigationen aufgerufen, und hasGesture() kann für legitime asynchrone JavaScript-Umleitungen oder serverseitige 302-Hops false zurückgeben.
Tiefenverteidigungs-Popup-Handhabung und Thread-Isolierung in WebChromeClient.onCreateWindow
Das Android-Popup-Verhalten hängt von WebSettings.setSupportMultipleWindows ab. Wenn Ihre App keine interaktiven Popups erfordert, verhindert das Beibehalten von setSupportMultipleWindows(false) (oder das Zurückgeben von false aus onCreateWindow), dass Drittanbieter-Iframes sekundäre Container öffnen – oder öffnet verifizierte Ziele über einen expliziten, vom Host gesteuerten Einstiegspunkt.
Wenn setSupportMultipleWindows(true) aktiviert ist, liefert WebChromeClient.onCreateWindow die Ziel-URL nicht in ihrer Callback-Signatur, und kein einzelner Callback deckt jeden Navigationsvektor ab. Das Verständnis des genauen Thread-Modells und der Callback-Grenzen ist für einen Referenzansatz der Tiefenverteidigung unerlässlich:
shouldOverrideUrlLoading(UI-Thread – Besitzer von Navigations- und Sitzungsstatus): Läuft ausschließlich auf dem UI-Thread und besitzt den gesamten veränderbaren Popup-Sitzungsstatus (isInitialTransportLoad,isAuthorizedPopupSession,popupRedirectHopsundpopupChainStartMs). Erst wenn ein verifizierter anfänglicher Ladevorgang oder eine direkte Nutzergeste mitpolicy.isAllowedPopupUriübereinstimmt, autorisiertshouldOverrideUrlLoadingdie Sitzung für nachfolgende begrenzte HTTP-302-Umleitungen (request.isRedirect), wodurch sichergestellt wird, dass Umleitungsketten sich auf eine autorisierte Sitzung zurückverfolgen lassen, anstatt beliebigen Umleitungen zu vertrauen.shouldInterceptRequest(Hintergrund-WebView-E/A-Thread – Zustandsloser, schreibgeschützter Wächter): Läuft auf einem Nicht-UI-WebView-Thread. Da er niemals den UI-Thread-Sitzungsstatus verändern darf, fungiert er streng als zustandslose, schreibgeschützte Richtlinienprüfung fürsafeClient.policy(blockiert Main-Frame-HTTP/HTTPS-Anfragen, dieisAllowedPopupUrinicht bestehen, und leitetdisposeActivePopup()an den Haupt-Thread weiter). Beachten Sie, dassshouldInterceptRequestgemäß der Android-Dokumentation nur für die ursprüngliche Ressourcen-URL aufgerufen wird, nicht für nachfolgende HTTP-302-Umleitungs-URLs; nachfolgende Umleitungs-URLs müssen vonshouldOverrideUrlLoadingbewertet werden.onPageStarted(UI-Thread – Fallback-Prüfung beim Navigationsstart): Wird ausgeführt, wenn das Laden des Main-Frames beginnt (nicht als Filter vor der Navigation). Es aktualisiert das Banner für den sichtbaren Ursprung zur Transparenz für den Benutzer und bietet eine Fallback-Prüfung beim Navigationsstart, diestopLoading()unddisposeActivePopup()aufruft, wenn ein nicht genehmigtes Ziel geladen wird.
Testen Sie bösartige initiale URLs, domänenübergreifende HTTP-302-Ketten, aufeinanderfolgende 302-Umleitungen, target="_blank", window.open() und Drittanbieter-Iframe-Auslöser immer an physischen Ziel-WebView-Builds.
Paketsichtbarkeit ab Android 11+ und veraltete Leitlinien für canOpenURL
Gemäß den Android-Paketsichtbarkeitsregeln erhalten Anwendungen, die unter Android 11 (API-Level 30) oder höher ausgeführt werden und auf API-Level 30 oder höher abzielen (targetSdk >= 30), null oder leere Ergebnisse von intent.resolveActivity() oder queryIntentActivities(), es sei denn, Ziel-Apps sind unter <queries> in AndroidManifest.xml deklariert. Android empfiehlt, startActivity(intent) direkt innerhalb eines try/catch für ActivityNotFoundException und SecurityException aufzurufen, anstatt <queries> zu erweitern.
Unter iOS hat Apple UIApplication.canOpenURL(_:) als veraltet eingestuft und empfiehlt, UIApplication.shared.open(_:options:completionHandler:) direkt zu versuchen und eventuelle Fehler im Completion-Handler zu behandeln (oder zu Universal Links zu migrieren, um die Vorab-Validierung von Schemata zu entfernen). LSApplicationQueriesSchemes in Info.plist ist nur erforderlich, wenn älterer Code weiterhin canOpenURL(_:) aufruft, während open(_:options:completionHandler:) die Deklaration von Schemata in Info.plist nicht erfordert. Sowohl <queries> als auch LSApplicationQueriesSchemes steuern die Abfragesichtbarkeit – sie sind keine Sicherheits-Allowlists für die Validierung nicht vertrauenswürdiger Web-URIs.
<!-- Manifest-Fragment: Fügen Sie <queries> in Ihr bestehendes AndroidManifest.xml ein -->
<!-- Erforderlich für targetSdk >= 30 unter Android 11+ NUR, wenn resolveActivity oder queryIntentActivities aufgerufen wird -->
<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: Unter dem Root-<dict> in Info.plist einfügen -->
<!-- Legacy: Erforderlich unter iOS NUR beim Aufruf der veralteten UIApplication.shared.canOpenURL; open(_:options:completionHandler:) erfordert diesen Schlüssel nicht -->
<key>LSApplicationQueriesSchemes</key>
<array>
<string>myapp</string>
<string>partnerapp</string>
</array>
So parsen Sie Chrome-Intent-URIs sicher und verhindern Umleitungsschleifen
Absicherung von Intent.parseUri gegen Intent-Redirection-Angriffe
Android-intent://-URIs codieren ein Zielschema, ein Paket und eine Fallback-URL (S.browser_fallback_url). Das Parsen nicht vertrauenswürdiger Web-URIs über Intent.parseUri(rawUri, Intent.URI_INTENT_SCHEME) führt zu Risiken einer Intent-Umleitung, die im Android-Sicherheitsleitfaden zur Intent-Umleitung und im OWASP Mobile Application Security Testing Guide detailliert beschrieben sind. Selbst wenn Android 16 (API 36) eine plattformweite Standardhärtung hinzufügt, müssen Anwendungen eine strikte Validierung erzwingen, bevor sie Intents ausführen.

So implementieren Sie eine Fail-Closed-Validierung mithilfe von AndroidX IntentSanitizer (androidx.core:core:1.9.0+ oder androidx.core:core-ktx:1.9.0+, das androidx.core:core bündelt), ohne Builder-Konflikte bezüglich gegenseitiger Ausschlüsse zwischen allowAnyComponent() und Paket-/Komponenten-Allowlist-Methoden auszulösen:
- Prüfungen vor der Bereinigung: Lehnen Sie Intents mit nicht nullen
component- oderselector-Feldern sofort ab (parsedIntent.component != null || parsedIntent.selector != null). Extrahieren und entfernen Siebrowser_fallback_urlvor der Bereinigung und verifizieren Sie nativ, dassparsedIntent.data?.scheme1:1 aufparsedIntent.package`` übercustomSchemeTargetPackagesabbildet (wobei sichergestellt wird, dassmyapp://sich strikt incom.example.targetauflöst, niemals in ein anderes Partnerpaket). - Ausführung des Sanitizers: Setzen Sie
parsedIntent.package` = null` auf der nicht vertrauenswürdigen Kopie temporär zurück, führen SieIntentSanitizer.Builder().allowAnyComponent().allowAction(Intent.ACTION_VIEW).allowCategory(Intent.CATEGORY_BROWSABLE).allowData { ... }.build().sanitizeByThrowing(parsedIntent)aus (null vom Webseiten bereitgestellte Task-Flags) und weisen Sie das validierteexpectedPackageundCATEGORY_BROWSABLEdem bereinigten, host-eigenen Intent vor Zusicherungen nach der Bereinigung neu zu. - Kontextbewusste Start-Flags: Injizieren Sie
Intent.FLAG_ACTIVITY_NEW_TASKim nativen Dispatcher (launchWithContextSafety) nur dann, wennview.context !is Activity. Bevorzugen Sie zur Verifizierung der Domain-zu-App-Zuordnung verifizierte HTTPS Android App Links (assetlinks.json).
Verhindern unendlicher Fallback-Schleifen mit monotonem Kettenstatus
Wenn startActivity eine ActivityNotFoundException auslöst, validieren Sie browser_fallback_url mit einer dedizierten isAllowedFallbackUri(uri)-Prüfung (strikt HTTPS, Standardport, verifizierter Host, explizite Fallback-Pfadpräfixe, keine doppelten Abfrageschlüssel und keine Fragmente). Lehnen Sie explizite Portdarstellungen für benutzerdefinierte Schemata ab, indem Sie sowohl uri.port == -1 als auch !uri.encodedAuthority.orEmpty().contains(":") verifizieren.
Verfolgen Sie Fallback-Ketten mithilfe von SystemClock.elapsedRealtime() (um Sprünge der Wanduhrzeit System.currentTimeMillis() zu vermeiden), isolieren Sie Ketten über fallbackLoopKey() (nicht vollständige IETF RFC 3986-Kanonisierungen), setzen Sie den Status über einen expliziten loadNewNavigation(webView, url)-Host-Wrapper zurück und leiten Sie Popup-Fallbacks über onPopupFallbackHandoff an den primären Container weiter, sodass unbefugte Domains niemals in einem Popup-Dialog geladen werden.
Haftungsausschluss zur Referenzarchitektur: Die folgende Implementierung ist eine defensive Referenzarchitektur. Validieren Sie die API-Verfügbarkeit, die Delegaten-Reihenfolge und das Lifecycle-Verhalten anhand der genauen AndroidX- und iOS-Versionen, die von Ihrer Anwendung verwendet werden.
// Android - SafeWebViewModules.kt
// Referenzarchitektur: Kompilieren und testen Sie gegen Ihre spezifischen Projektziele
// Erfordert androidx.core:core:1.9.0+ (oder androidx.core:core-ktx:1.9.0+) für IntentSanitizer; zielt auf 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. Richtlinienmodul (Immutabel / Threadsicher für schreibgeschützten Zugriff von E/A- & 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"),
// Isolierte Allowlists explizit für Popup-Fenster; unterscheidet sich von allgemeinen 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
}
// Abfrageschlüssel validieren, Wertesyntax erzwingen und doppelte Schlüssel ablehnen
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
// Netzwerkports strikt ablehnen, indem sowohl uri.port == -1 als auch das Fehlen des Authority-Doppelpunkts geprüft werden
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
// Abfrageschlüssel validieren, Wertesyntax erzwingen und doppelte Schlüssel ablehnen
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: Monotoner Kettenstatus basierend auf verstrichener Zeit (Isoliert aktive Kette von wiederholten Sitzungen)
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
}
// Anwendungsspezifischer Schleifenschlüssel, der den Standard-HTTPS-Port normalisiert und signifikante Abfrageschlüssel beibehält
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 (Nur UI-Thread)
class SafeRedirectWebViewClient(
val policy: CustomUriPolicy = CustomUriPolicy(),
val loopGuard: FallbackLoopGuard = FallbackLoopGuard(),
private val onPopupFallbackHandoff: ((fallbackUri: Uri) -> Unit)? = null
) : WebViewClient() {
// Explizite, vom Host initiierte Navigations-API, die den Fallback-Kettenstatus vor loadUrl() zurücksetzt
fun loadNewNavigation(webView: WebView, url: String) {
val targetUri = Uri.parse(url)
if (!policy.isAllowedWebUri(targetUri)) {
Log.w("WebViewDebug", "Vom Host initiierte Navigation zu nicht vertrauenswürdiger URL blockiert")
return
}
loopGuard.resetChain()
webView.loadUrl(url)
}
// Dedizierter Fallback-Loader mit interner Validierung unter Beibehaltung des aktiven Kettenstatus
fun loadFallbackNavigation(webView: WebView, fallbackUri: Uri) {
if (!policy.isAllowedFallbackUri(fallbackUri)) {
Log.w("WebViewDebug", "Nicht vertrauenswürdiger Fallback-Navigationsversuch blockiert")
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. HTTPS-Only & Web-Host-Allowlist bei allen HTTP/HTTPS-Navigationen erzwingen
if (scheme == "http" || scheme == "https") {
if (!policy.isAllowedWebUri(targetUri)) {
Log.w("WebViewDebug", "Nicht-HTTPS-, benutzerdefinierter Port- oder nicht vertrauenswürdiger Web-Host blockiert")
return true
}
if (hasUserGesture && isForMainFrame) {
loopGuard.resetChain()
}
return false
}
// 2. Main-Frame- und Nutzergesten-Einschränkungen bei Starts externer Apps erzwingen
if (!isForMainFrame || !hasUserGesture) {
Log.w(
"WebViewDebug",
"Schema außerhalb des Main-Frames oder ohne Geste blockiert: $scheme"
)
return true
}
// 3. Chrome intent://-URIs parsen und im Fehlerfall (Fail-Closed) bereinigen
if (scheme == "intent") {
return handleIntentUri(view, targetUri.toString(), isPopupContext)
}
// 4. Erlaubte benutzerdefinierte URL-Schemata validieren und explizit an 1:1 verifizierte Zielpakete binden
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. Alle nicht anerkannten Schemata blockieren
Log.w("WebViewDebug", "Unbekanntes URL-Schema blockiert: $scheme")
return true
}
// UI-Thread-Navigationsbewerter für untergeordnete Popup-WebViews, der 302-Umleitungen an autorisierte Sitzungen bindet
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", "Subframe-HTTPS-Navigation innerhalb des Popups blockiert")
return true
}
if (!policy.isAllowedPopupUri(targetUri)) {
Log.w(
"WebViewDebug",
"Nicht vertrauenswürdiger Popup-HTTPS-Host oder -Pfad-Navigation blockiert"
)
return true
}
// Sitzung nur im UI-Thread autorisieren, wenn der erste Ladevorgang oder Tippen des Nutzers der Allowlist entspricht
if (isInitialTransportLoad || hasUserGesture) {
onAuthorizedInitialSession()
return false
}
// Begrenzte serverseitige 302-Umleitungen NUR für zuvor autorisierte Popup-Sitzungen zulassen
if (isRedirect && isAuthorizedPopupSession && canProceedPopupRedirect()) {
return false
}
Log.w(
"WebViewDebug",
"Nicht autorisierte Umleitung oder Popup-Navigation ohne Geste blockiert"
)
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", "Fehlerhafte Intent-URI-Syntax")
return true
}
val fallbackUrl = parsedIntent.getStringExtra("browser_fallback_url")
parsedIntent.removeExtra("browser_fallback_url")
// 1:1-Bindung: Zielschema extrahieren und nativ gegen erwartetes Zielpaket validieren
val dataUri = parsedIntent.data ?: return true
val targetScheme = dataUri.scheme?.lowercase() ?: return true
val expectedPackage = policy.customSchemeTargetPackages[targetScheme] ?: run {
Log.w("WebViewDebug", "Intent mit nicht zugeordnetem benutzerdefiniertem Schema blockiert: $targetScheme")
return true
}
val rawPackage = parsedIntent.`package`
if (rawPackage != expectedPackage) {
Log.w("WebViewDebug", "Intent-Paket-Nichtübereinstimmung blockiert: erwartet $expectedPackage")
return true
}
// Vom Webseiten angegebene explizite Komponenten und Selektoren sofort ablehnen
if (parsedIntent.component != null || parsedIntent.selector != null) {
Log.w("WebViewDebug", "Intent mit expliziter Komponente oder Selektor blockiert")
return true
}
// Verifiziertes Paket vor dem Aufruf von IntentSanitizer mit allowAnyComponent() temporär löschen,
// um Builder-Beschränkungen bezüglich gegenseitiger Ausschlüsse zu vermeiden und gleichzeitig nicht vertrauenswürdige Flags/Extras strikt abzulehnen.
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 hat SecurityException für unzulässige Felder oder Flags ausgelöst")
return true
} catch (e: IllegalArgumentException) {
Log.w("WebViewDebug", "IntentSanitizer hat ungültige Intent-Argumente abgelehnt")
return true
}
// Verifiziertes Zielpaket + vom Host erzwungene Kategorie + Zusicherungen nach der Bereinigung erneut binden
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", "Intent-Zusicherungen nach der Bereinigung fehlgeschlagen")
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", "Nicht vertrauenswürdige oder schleifenförmige Fallback-URL blockiert")
}
}
} catch (e: SecurityException) {
Log.w(
"WebViewDebug",
"SecurityException hat den Start des Intents blockiert"
)
}
return true
}
private fun launchIntentSafely(view: WebView, intent: Intent) {
try {
launchWithContextSafety(view, intent)
} catch (e: ActivityNotFoundException) {
Log.i(
"WebViewDebug",
"Keine installierte Anwendung verarbeitet das Zielpaket/-schema"
)
} catch (e: SecurityException) {
Log.w(
"WebViewDebug",
"SecurityException hat den Start des benutzerdefinierten Schemas blockiert"
)
}
}
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-verwalteter Popup-WebChromeClient (Strikter UI-Thread-Sitzungsstatus & zustandsloser Hintergrundwächter)
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 = "Ziel wird geladen..."
}
popupRoot.addView(originBanner)
// Alle folgenden Popup-Sitzungsstatusvariablen werden ausschließlich im UI-Thread gelesen und verändert
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: Verwaltet Navigation, Umleitung und Sitzungsautorisierungsstatus
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
}
// Hintergrund-WebView-E/A-Thread: Streng zustandslose, schreibgeschützte Richtlinienprüfung.
// Verändert niemals den UI-Thread-Sitzungsstatus; deckt nur die ursprüngliche Ressourcen-URL ab (nicht nachfolgende 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", "Nicht genehmigte Popup-Main-Frame-Anfrage in shouldInterceptRequest blockiert")
childView.post { disposeActivePopup() }
return WebResourceResponse("text/plain", "utf-8", ByteArrayInputStream(ByteArray(0)))
}
}
return super.shouldInterceptRequest(childView, request)
}
// UI-Thread: Fallback-Prüfung beim Navigationsstart & Anzeige des Ursprungs (kein Filter vor der Navigation)
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", "Fallback-Prüfung beim Navigationsstart hat nicht genehmigte Popup-URL beendet")
childView.stopLoading()
disposeActivePopup()
return
}
isAuthorizedPopupSession = true
val scheme = uri.scheme?.lowercase() ?: "https"
val host = uri.host?.lowercase() ?: "Unknown"
originBanner.text = "Ursprung: $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. Vollständiges Beispiel für Host-Aktivitätsregistrierung & Lifecycle-Bereinigung (JavaScript im Haupt-WebView aktiviert)
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 {
// JavaScript für vertrauenswürdige Zielseiten, die JS-Umleitungen oder window.open() erfordern, explizit aktivieren
javaScriptEnabled = true
allowFileAccess = false
allowContentAccess = false
// Mehrere Fenster nur dann aktivieren, wenn interaktive Popup-Container gehostet werden
setSupportMultipleWindows(true)
}
webViewClient = safeClient
webChromeClient = popupChromeClient
}
setContentView(webView)
// Expliziten Host-Wrapper anstelle von barem webView.loadUrl() verwenden
safeClient.loadNewNavigation(webView, "https://example.com/landing")
}
override fun onDestroy() {
popupChromeClient.destroyPopups()
(webView.parent as? ViewGroup)?.removeView(webView)
webView.destroy()
super.onDestroy()
}
}
Häufig gestellte Fragen (FAQ)
Warum zeigt Android WebView net::ERR_UNKNOWN_URL_SCHEME an, obwohl die Ziel-App installiert ist?
Warum wird shouldOverrideUrlLoading nicht ausgelöst, wenn meine App WebView.loadUrl direkt aufruft?
Warum schlagen Target-Blank-Links mit benutzerdefinierten Schemata in WKWebView stillschweigend fehl?
Zusammenfassung und Entscheidungsrahmen
Das Beheben von Fehlern bei Deep-Linking-Umleitungen in WebViews erfordert die Isolierung des Verhaltens der WebView-Engine von den Navigationsrichtlinien der Host-Anwendung. Durch die Reproduktion von Navigationsereignissen in den Chrome DevTools oder dem Safari Web Inspector, die strikte Beschränkung des Android-Popup-Sitzungsstatus auf den UI-Thread bei gleichzeitiger Kopplung der zustandslosen Überprüfung initialer Anfragen mit sitzungsautorisierten 302-Umleitungsprüfungen, die Durchsetzung von Fail-Closed-Allowlists für den IntentSanitizer und den Schutz von iOS-Universal-Link-Fallbacks vor veralteten asynchronen Überschreibungen und doppelten Delegaten-Starts können Engineering-Teams fehlerhafte Nutzerreisen reduzieren und dazu beitragen, clientseitige Umleitungsschwachstellen zu verhindern.
Nachdem native Delegaten auf Container-Ebene und Fallback-Pfade verifiziert wurden, sollten Entwicklungsteams auch End-to-End-Attributions-Landingpages und One-Click-Launch-Routing-Ketten mithilfe von Plattformen wie OpoInstall validieren, um die Parameterbeibehaltung bei Übergängen vom Browser zur App zu bestätigen.
Entitäten-Glossar
| Begriff | Definition | Zugehörige Entität | Suchintention-Rolle |
|---|---|---|---|
| WebView | Eine eingebettete native UI-Komponente zum Rendern von Webseiten innerhalb einer mobilen Anwendung. | WebViewClient / WKWebView |
Informativ / Technisch |
| Benutzerdefiniertes URL-Schema | Ein von der App registriertes URI-Präfix (z. B. myapp://), das eine externe Navigation in native Bildschirme ermöglicht. |
Intent.ACTION_VIEW |
Technisch / Informativ |
| WKNavigationDelegate | Das WebKit-Protokoll, das es einer Host-App ermöglicht, Navigationsaktionen in WKWebView zu akzeptieren, abzubrechen oder umzuleiten. |
decidePolicyForNavigationAction |
Technisch |
| WKUIDelegate | Das WebKit-Protokoll, das für die Behandlung von Anfragen zur Erstellung neuer Fenster in WKWebView verantwortlich ist. |
createWebViewWith |
Technisch |
| WebResourceRequest | Das Android API 24+-Objekt, das URL, Frame, HTTP-Methode, Umleitung und Gesten-Metadaten kapselt. | shouldOverrideUrlLoading |
Technisch |
| WebChromeClient | Die Android-WebView-Callback-Schnittstelle zur Behandlung von JavaScript-Dialogen, Fortschritt und onCreateWindow. |
WebViewTransport |
Technisch |
| IntentSanitizer | Das AndroidX Core-Dienstprogramm zum Filtern oder strengen Validieren nicht vertrauenswürdiger Intent-Felder vor dem Start. | Abwehr von Intent-Umleitungen | Technisch / Sicherheit |
| Universal Links | Apples HTTPS-basierter Deep-Linking-Standard, der verifizierte Web-Domains mit installierten iOS-Anwendungen verknüpft. | Zugehörige Domains | Technisch / Informativ |
| Paketsichtbarkeit | Betriebssystemfilterung ab Android 11+ (targetSdk >= 30), die einschränkt, welche installierten Apps eine Host-App über den PackageManager abfragen kann. |
<queries>-Manifest-Tag |
Technisch |
| Intent-URI | Eine strukturierte Android-URI (intent://), die Zielpaket, Schema und Browser-Fallback-URLs codiert. |
Intent.URI_INTENT_SCHEME |
Technisch |
Kompatibilitäts-Baseline und Verifizierungsstatus
-
Vorgesehene Kompatibilitätsziele: Android
minSdk 24,compileSdk 34/35,targetSdk 34/35(Android 14/15), Android 16 (API 36) Kontext zur Härtung von Intent-Umleitungen,androidx.core:core:1.9.0+(IntentSanitizer); iOS 15.0–18.0 (isInspectablegekapselt ab iOS 16.4+), Xcode 15/16, Swift 5.9/6.0. -
Verifizierungsstatus:
-
Statische API- & Spezifikationsprüfung: Abgeschlossen gemäß den offiziellen Spezifikationen von Android Developers, AndroidX Core, Apple Developer, IETF RFC 3986 und OWASP MASTG.
-
Kompilierungs- & physische Geräteverifizierung: Noch nicht ausgeführt in diesem Überprüfungszyklus. Teams müssen Regressionen auf physischen Geräten kompilieren und ausführen, die bösartige initiale Popup-URLs, domänenübergreifende 302-Ketten, aufeinanderfolgende 302-Hops, Fenstererstellung für Drittanbieter-Iframes, Android App Links (
assetlinks.json), iOS Associated Domains (AASA-Caching), veraltete asynchrone Universal-Link-Abbrüche,intent://-Fallback-Ketten undActivityNotFoundException-Dispatches vor dem Rollout in die Produktion abdecken.
-
Referenzen
Share this article



