AndroidおよびiOSにおけるWebViewリダイレクトエラーのトラブルシューティング方法

opoinstall
2026-11-19
5 min read

webview-safe-fallback-loop-prevention.webp

AndroidおよびiOSでWebViewのリダイレクトエラーが発生した場合、どのようにトラブルシューティングを行えばよいでしょうか。まず、失敗の原因が標準的なHTTPSナビゲーション、カスタムURLスキーム、Androidの intent:// URI、あるいは新規ウインドウ要求のいずれであるかを特定します。その後、Chrome DevToolsやSafari Web Inspectorを使用してナビゲーションをインスペクトし、対応するネイティブデリゲート(shouldOverrideUrlLoading、onCreateWindow、decidePolicyForNavigationAction、または createWebViewWith)を追跡します。対象アプリの解決、URI許可リスト、フレームおよびユーザーインタラクションのポリシー、フォールバックルーティングを検証することで、コンテナレベルのエラーとOSのディスパッチ失敗を切り分けます。

WebViewのリダイレクトエラーは、組み込みのAndroid Chromium WebViewまたはiOS WebKit WKWebViewが、ナビゲーション要求を意図した宛先へルーティングできなかった場合に発生します。一般的な原因としては、サポートされていないカスタムURLスキーム、処理されていない target="_blank" 要求、パッケージ可視性の宣言の欠落、拒否されたあるいはループしているフォールバックリダイレクトなどが挙げられます。

AndroidのWebViewおよびiOSのWKWebViewコンテナがリダイレクトをドロップする理由

レイヤード構成のWebViewリダイレクトアーキテクチャにより、ネイティブポリシーとOSディスパッチの失敗が明らかになります。

リダイレクト失敗のデバッグにおいて、開発チームはWebViewエンジンの動作(ChromiumやWebKitがURL、フレームターゲット、ポップアップイベントを解析する方法)とホストアプリケーションのポリシー(アプリケーション側が提供する WebViewClient、WebChromeClient、WKNavigationDelegate、または WKUIDelegate がユーザーインタラクションの種類、許可リスト、外部アプリへの引き渡しを評価する方法)を明確に分離する必要があります。スタンドアロンブラウザには組み込みのURIディスパッチャやリンクハンドオフハンドラが備わっていますが、android.webkit.WebView やAppleの WKWebView は、デフォルトで標準的な http:// または https:// のネットワーク応答を想定している組み込みレンダリングコンポーネントです。

ウェブページがカスタムスキーム(myapp://product/42 など)やAndroidの intent:// リンクをアクティブなデリゲートオーバーライドなしでトリガーした場合、デフォルトのコンテナ動作はプラットフォーム間で異なります:

  • Android Chromium WebView:Androidの WebViewClient 仕様に基づき、カスタム WebViewClient が割り当てられていない場合、WebViewは利用可能なシステムハンドラを通じてURLを解決するようActivity Managerに要求する場合があります。カスタム WebViewClient が割り当てられており、かつサポートされていないカスタムスキームに対して shouldOverrideUrlLoading が false を返す場合、WebViewはChromium内でそのロードを継続し、net::ERR_UNKNOWN_URL_SCHEME をレンダリングします。
  • iOS WebKit WKWebView:WebKitは内部的にHTTP以外のスキームを拒否し、ホストの WKNavigationDelegate が要求をインターセプトして UIApplication に転送しない限り、ナビゲーションを中断します。多くの場合、これはサイレント失敗となるか、NSURLErrorUnsupportedURL を発生させます。

また、Appleの スマートバナーによるアプリの促進(Promoting Apps with Smart App Banners) は、アプリ内のカスタムURLスキームリダイレクトとは個別に評価すべきものであり、組み込みの WKWebView ナビゲーションAPIではなく、スタンドアロンのSafariブラウジング向けに設計されたSafariのサポート機能である点にも注意してください。

一目でわかるポイント

  • エンジン動作とホストポリシーの分離:ナビゲーションの失敗がウェブエンジン内(Chromium/WebKit)、ネイティブデリゲートのオーバーライド内、またはOSパッケージ解決の境界のどこで発生したかを切り分けます。
  • コーディング前のライブリダイレクトの検査:Chrome DevTools(chrome://inspect)やSafari Web Inspector(isInspectable = true)を使用して、3xxリダイレクトチェーン、targetFrameの状態、ジェスチャフラグをキャプチャします。
  • プラットフォームに適したURIおよびインテント検証の適用:Androidでは、ウェブページ側から提供されたタスクフラグを使用せず、IntentSanitizerを介してカスタムスキームと intent:// のターゲットを検証済みパッケージへと1対1でバインドします。iOSでは、完全なカスタムURI構造を検証し(アプリとドメインの整合性が検証されている場合はユニバーサルリンクに依存)、両方のプラットフォームで重複するクエリキーを拒否します。
  • ポップアップおよび競合状態に対する多層防御の適用:shouldInterceptRequest と shouldOverrideUrlLoading にわたるコールバック境界を理解した上で、Androidのポップアップセッション状態をUIスレッドに厳格に閉じ込めます。また、iOSの WKWebView では、アクションレベルの重複排除とナビゲーション生成トークンを使用して、純粋なポリシーチェックと外部ディスパッチの副作用を分離します。

WebViewリダイレクトエラーの一般的な原因と検証手順

観測されたクライアントエラーと背後にあるコンテナ障害メカニズムの紐付け

以下の診断マトリクスを使用して、観測されたWebViewの症状を一般的なプラットフォームの根本原因、検証手順、および対象を絞った修正策に紐付けます:

観測された症状またはエラー 対象プラットフォーム 一般的な根本原因 診断の検証手順 対象を絞った修正策
WebViewに net::ERR_UNKNOWN_URL_SCHEME が表示される Android WebView カスタム WebViewClient が false を返すか、スキームの許可リストが不足している shouldOverrideUrlLoading 内で request.url を検査する 許可リストに登録されたURIをインターセプトし、パッケージに1対1で紐づけられた Intent.ACTION_VIEW をディスパッチする
カスタムスキームのリンクをタップした際にサイレントハングが発生する iOS WKWebView WKNavigationDelegate が .allow を返した際に、WebKitがHTTP以外のURIをアボートする decidePolicyForNavigationAction 内で navigationAction.request.url をログに記録する 検証済みスキームを UIApplication.shared.open 経由でルーティングし、.cancel を渡す
target="_blank" によってWebView内の現在のページが置き換わる Android WebView setSupportMultipleWindows(false) により、新しいウインドウがトップレベルのロードとして扱われる webView.settings.supportMultipleWindows() を確認する 別個のポップアップコンテナが必要な場合にのみ、setSupportMultipleWindows(true) を有効にする
target="_blank" が何も実行されないか、OAuthの302リダイレクトがドロップされる Android WebView onCreateWindow が欠落しているか、子クライアントが hasGesture() を欠いた isRedirect ホップをブロックしている onCreateWindow、request.isRedirect、および shouldInterceptRequest のログを確認する UIスレッドのセッション状態と制限された isRedirect ホップを持つ、ビューホスト型のポップアップWebViewをアタッチする
target="_blank" または window.open() を持つリンクが何も実行されない iOS WKWebView 新規ウインドウナビゲーションにより targetFrame == nil が設定され、WKUIDelegate が必要になる navigationAction.targetFrame == nil を確認する decidePolicyForNavigationAction 内で targetFrame == nil を検出し、WKUIDelegate を介して処理する
ターゲットアプリがインストールされているにもかかわらず、フォールバックページが開く Android 11以降(targetSdk >= 30) <queries> 宣言の欠落により、非表示のパッケージに対して resolveActivity() や queryIntentActivities() が不完全な結果を返す resolveActivity() 周辺のアプリケーションレベルのログを追加し、adb logcat で出力を検査する 事前チェックを行う場合は <queries> インテントを宣言するか、ActivityNotFoundException のキャッチを伴う startActivity を直接呼び出す
JavaScriptタイマーによるリダイレクトが外部アプリの起動に失敗する iOS / Android 自動化されたスクリプトのリダイレクトにユーザーインタラクションのシグナルが欠けている request.hasGesture()(Android)または navigationType(iOS)を確認する リダイレクトをユーザーの直接タップに紐付け、明示的なホストジェスチャポリシーを定義する
ユニバーサルリンクがターゲットアプリではなく WKWebView 内でロードされる iOS WKWebView ブラウジングコンテキスト、ドメイン関係、またはJSナビゲーションにより、ロードがWebKit内に留まる decidePolicyForNavigationAction 内で navigationType とホストを確認する 許可された外部ホストに対し、.universalLinksOnly: true を指定して UIApplication.shared.open を呼び出す

5分で完了するWebViewリダイレクトのクイックトリアージチェックリスト

  • ステップ1:DevToolsでのプロトコルスキームの確認:ページが https://、カスタムスキーム、または intent:// URIのどれを出力したかを確認し、コンテンツセキュリティポリシー(CSP)によってブロックされていないことを確認します。
  • ステップ2:フレーム階層の検査:トリガーがサードパーティの <iframe> 内(!isMainFrame)から発生していないか確認します。ホストアプリケーションは、サードパーティのiframeから開始された外部アプリの起動を意図的にブロックする場合があります。
  • ステップ3:リダイレクトとタイマーの区別:ジェスチャを伴わないナビゲーションが、承認されたHTTP 3xxサーバーリダイレクト(Androidの request.isRedirect)であるか、それともプロンプトなしのJavaScriptタイマーであるかを確認します。
  • ステップ4:新規ウインドウトリガーの確認:target="_blank" または window.open() が新規ウインドウ要求を作成したかどうかを確認します(iOSの場合は targetFrame == nil、Androidの場合は onCreateWindow)。
  • ステップ5:OSパッケージ解決の検証:Android 11以降のAPI 30+をターゲットとするアプリの場合、事前フライトの resolveActivity() 呼び出しが <queries> 宣言の欠落により失敗していないか確認します。

以下の診断ワークフローは、コンテナリダイレクトの失敗を切り分けるための順次トリアージパスを示しています:

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

リモートデバッグツールを使用したWebViewナビゲーションイベントの検査方法

AndroidでのChrome DevToolsおよびADB Logcatを介したリモートデバッグの有効化

ネイティブデリゲートを変更する前に、ロードされたウェブページが期待されるリダイレクトを出力しているかどうかを確認します。Android Chrome DevToolsリモートデバッグガイドに従い、ApplicationInfo.FLAG_DEBUGGABLE を検査して WebView.setWebContentsDebuggingEnabled(true) を呼び出すことにより、開発ビルドでリモートWebViewデバッグを明示的に有効にします。プロダクションリリースでは絶対にデバッグを有効にした状態で出荷しないでください:

// Android - デバッグ可能なビルドでのみWebViewデバッグを有効にする
if (applicationInfo.flags and ApplicationInfo.FLAG_DEBUGGABLE != 0) {
    WebView.setWebContentsDebuggingEnabled(true)
}

デバイスをUSBで接続し、デスクトップ版Chromeで chrome://inspect/#devices を開き、Preserve logにチェックを入れた状態でNetworkタブを監視します。同時に、adb logcat を介してネイティブランタイムログをフィルタリングし、ActivityNotFoundException、SecurityException、またはカスタムラッパーログをキャプチャします。なお、レガシーな shouldOverrideUrlLoading(WebView, String) シグネチャに関する非推奨警告は、ランタイムの adb logcat 内ではなく、Android Studio / Gradleのコンパイル時に表示されます:

# ターミナル - カスタムWebViewタグとActivityTaskManagerインテント解決のためにlogcatをフィルタリングする
adb logcat -s "WebViewDebug" "ActivityTaskManager" "PackageManager"

iOSでの isInspectable の設定とSafari Web InspectorおよびXcodeコンソールの接続

iOS 16.4およびmacOS 13.3以降、Appleは WKWebView.isInspectable(デフォルトは false)を介してオプトインすることを求めています。#if DEBUG ブロック内で webView.isInspectable = true を有効にします:

// iOS - iOS 16.4以降のデバッグビルドでSafari Web Inspectorのオプトインを有効にする
#if DEBUG
if #available(iOS 16.4, *) {
    webView.isInspectable = true
}
#endif

物理iOSデバイスで、「設定」>「アプリ」>「Safari」>「詳細」(古いiOSリリースでは「設定」>「Safari」>「詳細」)に移動し、「Webインスペクタ」を有効にします。USBで接続し、デスクトップ版Safariの「開発」メニューを開き、ネイティブの decidePolicyForNavigationAction、createWebViewWith、および UIApplication.shared.open の完了出力を確認するために、同時にXcodeコンソールを監視します。

AndroidのWebViewとiOSのWKWebViewは、それぞれ異なるネイティブナビゲーションおよびポップアップハンドラを使用します。

iOS WKWebViewにおけるサイレントな新規ウインドウのドロップとユーザージェスチャ欠落の解決

WKNavigationDelegate と WKUIDelegate にわたるポリシー評価と副作用の分離

ウェブリンクが target="_blank" または window.open() を指定した場合、WebKitは新規ウインドウナビゲーション要求を作成します。この際、navigationAction.targetFrame は nil となり、WKNavigationDelegate と WKUIDelegate の両方が関与します。ホストアプリが webView(_:createWebViewWithConfiguration:for:windowFeatures:) を実装していない場合、WebKitはセカンダリWebViewを生成できず、ナビゲーションがサイレントに失敗するように見えることがあります。

両方のデリゲートが要求を検査する際に、外部アプリの重複起動や世代トークンの二重インクリメントを防ぐため、純粋なポリシー評価(evaluateNavigationPolicy)と実行時の副作用を分離し、単にユーザーによる意図的な急速な連続タップを抑制してしまうような荒い時間的閾値に頼るのではなく、特定の WKNavigationAction インスタンス(ObjectIdentifier(navigationAction))によって重複排除を行います。decidePolicyForNavigationAction 内で navigationAction.targetFrame == nil を直接評価します。評価結果が外部ハンドオフプランを返す場合は、それを一度実行して(WKNavigationAction識別子を記録).cancelを渡し、許可リストに登録されたポップアップURLに対して .allowInWebView を返す場合は .allow を渡すことで createWebViewWith がポップアップを安全にロードできるようにします。対象となるiOSバージョンにおいて、厳密なデリゲートコールバックの順序を常に検証してください。

ユニバーサルリンクのコンテキスト、非同期の競合安全性、およびカスタムスキームの整合性

ユニバーサルリンクのハンドオフは、ソースとなるブラウジングコンテキスト、ドメイン関係、および関連ドメイン(Associated Domains)の設定(ターゲットサーバーの apple-app-site-association ファイルを介して検証されます)に依存します。Appleの技術ノート TN3155: デバッグユニバーサルリンク(TN3155: Debugging universal links) では、Safari内での同一ドメインナビゲーションがブラウザ内に留まる傾向にある一方、異なるサブドメインが適格性に影響を与える仕組みについて解説されています。ターゲットとなるiOSリリース上の WKWebView 内で、常に関連ドメインの挙動をテストしてください。

UIApplication.shared.open(url, options: [.universalLinksOnly: true]) を呼び出す際、非同期ナビゲーションの競合状態に対するガードを行います。システムがユニバーサルリンクのハンドオフを処理している間にユーザーが後続のメインフレームナビゲーション試行を開始した場合、false を返すガードされていない完了ハンドラーがユーザーのより新しいナビゲーション状態を上書きしてしまう可能性があります。すべての新しいメインフレームナビゲーション評価(ブロックまたはリダイレクトされた試行を含む)ごとに単調増加する activeNavigationGeneration トークンをインクリメントすることで、保留中の以前の非同期フォールバックが即座に無効化されるようにします。フォールバックURLをリロードする前に、self.isViewLoaded && self.view.window != nil と並行して self.activeNavigationGeneration == requestGeneration を検証してください。

2つの厳格なセキュリティ境界を遵守してください:

  • WKNavigationType の分類:Appleの WKNavigationType ドキュメントによると、formSubmitted はリンクのタップではなくフォーム送信要求を表しており、ページスクリプトはプログラムによってフォームを送信できます。.linkActivated を単離された暗号学的ジェスチャトークンとして扱うのではなく、外部アプリへの引き渡しを、WebKitで分類された .linkActivated イベントと sourceFrame.isMainFrame および完全なURI許可リストの組み合わせに制限します。
  • カスタムスキームの一意性とパラメータ汚染:Appleのガイド アプリのカスタムURLスキームの定義(Defining a Custom URL Scheme for Your App) によると、複数のアプリが同一のカスタムスキームを主張する可能性があります。isAllowedCustomURL(_:) はターゲットのBundle IDのアイデンティティではなく、URI構造(スキーム、ホスト、デフォルトのポート nil、パスパターン、ユーザー情報/フラグメントの不在、重複するクエリキーの拒否)を検証します。アプリIDのバインドが必要な場合は、常にドメイン検証済みのユニバーサルリンクを使用してください。

リファレンスアーキテクチャの免責事項: 以下の実装は、防御的なリファレンスアーキテクチャです。アプリケーションで使用されている実際のAndroidXおよびiOSのバージョンに対して、APIの可用性、デリゲートの順序、ライフサイクルの動作を検証してください。

// iOS - WebViewContainerController.swift
// リファレンスアーキテクチャ:特定プロジェクトのターゲット(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!

    // 外部のカスタムURLスキーム、ホスト、クエリキーに対する明示的な許可リスト
    private let allowedCustomSchemes: Set<String> = ["myapp", "partnerapp"]
    private let allowedCustomHosts: Set<String> = ["open", "product", "promo"]
    private let allowedCustomQueryKeys: Set<String> = ["id", "ref", "promo"]

    // プライマリWebViewコンテナ内での許可対象となるHTTPSホストの明示的な許可リスト
    private let allowedWebHosts: Set<String> = [
        "example.com",
        "m.example.com",
        "links.example.com"
    ]

    // 子ポップアップウインドウ(target="_blank")専用に分離された許可リスト
    private let allowedPopupHosts: Set<String> = ["example.com", "auth.example.com"]
    private let allowedPopupPathPrefixes: [String] = ["/oauth", "/popup", "/window"]

    // リンクアクティベーション時にネイティブアプリへの引き渡しを試みる外部ユニバーサルリンクホスト
    private let externalUniversalLinkHosts: Set<String> = ["links.example.com"]
    
    // すべての新しいメインフレームナビゲーション試行時にインクリメントされる単調なナビゲーション生成トークン
    private var activeNavigationGeneration: UInt64 = 0

    // 同一のWKNavigationActionに対する重複ディスパッチを防ぐアクションレベルの重複排除
    private var dispatchedActionIDs: [ObjectIdentifier] = []
    private let maxTrackedActionIDs = 16

    // 正規化されたユニバーサルリンクキーをキーとする、単調アップタイムTTL境界付きのバイパスカッシュ
    private var bypassedUniversalLinkKeys: [String: TimeInterval] = [:]
    private let maxBypassedKeys = 10
    private let bypassTTLSeconds: TimeInterval = 300
    // アプリケーションの実際のルーティングパラメータに合わせて主要なクエリキーを適応させます
    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)

        // 保留中の古い非同期ユニバーサルリンクフォールバックが即座に無効化されるよう、
        // すべてのメインフレームナビゲーション試行時(ブロックされた試行を含む)に生成トークンをインクリメントします。
        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 (target="_blank" および 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: - 純粋なナビゲーションポリシー評価(副作用なし)

    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. HTTP/HTTPS以外のカスタムURLスキームの評価
        // 注意:カスタムスキームの許可リストはURI構造を検証しますが、ターゲットのBundle IDのアイデンティティを保証することはできません。
        if scheme != "http" && scheme != "https" {
            guard isMainFrame, isLinkActivated, isAllowedCustomURL(url) else {
                return .block
            }
            return .launchCustomScheme(url)
        }

        // 2. HTTPSのみ、デフォルトポート(nilまたは443)、およびホスト許可リストの強制
        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. リンクアクティベーション時に指定された外部ホストに対するユニバーサルリンクハンドオフの評価
        if let host = targetHost,
           externalUniversalLinkHosts.contains(host),
           isMainFrame,
           isLinkActivated,
           let loopKey = universalLinkLoopKey(for: url),
           !isBypassedKeyActive(loopKey) {
            return .attemptUniversalLink(url)
        }

        return .allowInWebView
    }

    // MARK: - アクションレベルで重複排除された外部ディスパッチの実行

    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
                // 古い非同期フォールバックによる上書きを防ぐため、ビューのライフサイクルと生成トークンの両方を検証します
                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] カスタムスキームの起動に失敗しました(アプリがインストールされていない可能性があります)")
                }
            }
        }
    }

    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, // カスタムスキーム上の明示的なポートを拒否
              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
    }
}

Android WebViewにおけるERR_UNKNOWN_URL_SCHEMEとパッケージ可視性に関する障害の修正

非推奨となったコールバック、hasGesture()、および POST の境界

Androidでは、APIレベル24において shouldOverrideUrlLoading(WebView, String) が非推奨となり、代わりに shouldOverrideUrlLoading(WebView, WebResourceRequest) が導入されました。WebResourceRequest は、isForMainFrame、isRedirect、および hasGesture() を提供します。ここで公式のプラットフォーム制約が2つあります。shouldOverrideUrlLoading は、ホスト側が開始する webView.loadUrl() 呼び出しや HTTP POST ナビゲーション時には呼び出されません。また、正当な非同期JavaScriptリダイレクトやサーバー側の302ホップに対しては、hasGesture() が false を返す場合があります。

WebChromeClient.onCreateWindow における多層防御のポップアップ処理とスレッド分離

Androidのポップアップ動作は WebSettings.setSupportMultipleWindows に依存します。アプリに対話型ポップアップが不要な場合は、setSupportMultipleWindows(false) を維持する(または onCreateWindow から false を返す)ことで、サードパーティのiframeがセカンダリコンテナを開くのを防ぐことができます。あるいは、明示的でホスト制御のエントリポイントを介して検証済みの宛先を開きます。

setSupportMultipleWindows(true) が有効な場合、WebChromeClient.onCreateWindow はコールバックシグネチャ内で宛先URLを提供せず、すべてのナビゲーションベクターをカバーする単一のコールバックも存在しません。多層防御のリファレンスアプローチを実現するには、正確なスレッドモデルとコールバック境界を理解することが不可欠です:

  • shouldOverrideUrlLoading(UIスレッド - ナビゲーションおよびセッション状態の所有者):UIスレッド上で排他的に実行され、すべての変更可能なポップアップセッション状態(isInitialTransportLoad、isAuthorizedPopupSession、popupRedirectHops、popupChainStartMs)を所有します。検証済みの初期ロードまたは直接的なユーザーインタラクションが policy.isAllowedPopupUri に一致した場合にのみ、shouldOverrideUrlLoading は後続の制限されたHTTP 302リダイレクト(request.isRedirect)に対するセッションを承認します。これにより、任意の信頼できないリダイレクトを信頼するのではなく、リダイレクトチェーンが承認されたセッションに確実に結びつけられます。
  • shouldInterceptRequest(バックグラウンドWebView IOスレッド - ステートレスで読み取り専用のガード):UIスレッドではないWebViewスレッド上で実行されます。UIスレッドのセッション状態を変更してはならないため、safeClient.policy に対するステートレスで読み取り専用のポリシーチェックとして厳密に動作します(isAllowedPopupUri のチェックに失敗したメインフレームのHTTP/HTTPS要求をブロックし、メインスレッド上で disposeActivePopup() をディスパッチします)。Androidのドキュメントによると、shouldInterceptRequest は初期リソースURLに対してのみ呼び出され、後続のHTTP 302リダイレクトURLに対しては呼び出されない点に注意してください。後続のリダイレクトURLは shouldOverrideUrlLoading によって評価される必要があります。
  • onPageStarted(UIスレッド - ナビゲーション開始時のフォールバックチェック):メインフレームのロードが開始されたときに実行されます(事前ナビゲーションフィルタではありません)。ユーザーの透明性を高めるために可視のオリジンバナーを更新し、承認されていない宛先のロードが開始された場合に stopLoading() と disposeActivePopup() を呼び出すナビゲーション開始時のフォールバックチェックを提供します。

対象となる物理WebViewビルド上で、悪意のある初期URL、クロスドメインのHTTP 302チェーン、連続する302リダイレクト、target="_blank"、window.open()、およびサードパーティのiframeトリガーを必ずテストしてください。

Android 11以降のパッケージ可視性と非推奨となった canOpenURL のガイダンス

Androidのパッケージ可視性ルールに基づき、Android 11(APIレベル30)以降を実行し、APIレベル30以降をターゲットとするアプリ(targetSdk >= 30)では、ターゲットアプリが AndroidManifest.xml 内の <queries> の下に宣言されていない限り、intent.resolveActivity() や queryIntentActivities() から null または空の結果が返されます。Androidでは、<queries> を過度に拡張するのではなく、ActivityNotFoundException および SecurityException に対する try/catch の中で startActivity(intent) を直接呼び出すことが推奨されています。

iOSでは、Appleが UIApplication.canOpenURL(_:) を非推奨としており、代わりに UIApplication.shared.open(_:options:completionHandler:) を直接試行し、完了ハンドラーでエラーを処理する(あるいはスキームの事前検証を不要にするためにユニバーサルリンクに移行する)ことを推奨しています。Info.plist 内の LSApplicationQueriesSchemes は、レガシーコードが引き続き canOpenURL(_:) を呼び出す場合にのみ必要であり、open(_:options:completionHandler:) では Info.plist 内でのスキーム宣言は必要ありません。<queries> と LSApplicationQueriesSchemes はどちらもクエリの可視性を制御するものであり、信頼できないウェブURIを検証するためのセキュリティ許可リストではありません。

<!-- マニフェストの断片:既存のAndroidManifest.xmlに<queries>をマージします -->
<!-- resolveActivityまたはqueryIntentActivitiesを呼び出す場合にのみ、Android 11以降の targetSdk >= 30 で必要です -->
<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の断片:Info.plist内のルートの<dict>の下に挿入します -->
<!-- レガシー:非推奨のUIApplication.shared.canOpenURLを呼び出す場合にのみiOSで必要です。open(_:options:completionHandler:)はこのキーを必要としません -->
<key>LSApplicationQueriesSchemes</key>
<array>
    <string>myapp</string>
    <string>partnerapp</string>
<array>

ChromeインテントURIを安全に解析し、リダイレクトループを防ぐ方法

インテントリダイレクトの脆弱性に対する Intent.parseUri の保護

Androidの intent:// URIは、ターゲットのスキーム、パッケージ、およびフォールバックURL(S.browser_fallback_url)をエンコードします。信頼できないウェブURIを Intent.parseUri(rawUri, Intent.URI_INTENT_SCHEME) 経由で解析すると、Androidインテントリダイレクトセキュリティガイドや OWASPモバイルアプリケーションセキュリティテストガイド(MASTG)で詳述されているインテントリダイレクトのリスクが生じます。Android 16(API 36)でプラットフォームレベルのデフォルトのハードニングが追加された場合でも、アプリケーションはインテントをディスパッチする前に厳格な検証を強制する必要があります。

階層化されたURI検証により、外部アプリケーションへのディスパッチ前に安全ではないWebViewインテントがブロックされます。

AndroidX IntentSanitizer(androidx.core:core:1.9.0+、または androidx.core:core をバンドルする androidx.core:core-ktx:1.9.0+)を使用して、allowAnyComponent() とパッケージ/コンポーネント許可リストメソッドの間のビルダー相互排他衝突を引き起こすことなく、失敗クローズの検証を実装するには:

  • 事前サニタイズチェック:非nullの component または selector フィールドを持つインテントを即座に拒否します(シグネチャ:parsedIntent.component != null || parsedIntent.selector != null)。サニタイズの前に browser_fallback_url を抽出して削除し、customSchemeTargetPackages を介して parsedIntent.data?.scheme が parsedIntent.package と1対1でマップされることをネイティブに検証します(これにより、myapp:// が他のパートナーパッケージではなく、com.example.target に厳格に解決されるようになります)。
  • サニタイザーの実行:信頼されていないコピー上で一時的に parsedIntent.package = null とクリアし、IntentSanitizer.Builder().allowAnyComponent().allowAction(Intent.ACTION_VIEW).allowCategory(Intent.CATEGORY_BROWSABLE).allowData { ... }.build().sanitizeByThrowing(parsedIntent)(ウェブページから提供されたタスクフラグはゼロ)を実行します。そして、サニタイズ後のアサーションの前に、検証済みの expectedPackage と CATEGORY_BROWSABLE をホストが所有するサニタイズ済みインテントに再割り当てします。
  • コンテキストを認識する起動フラグ:ネイティブディスパッチャ(launchWithContextSafety)内で、view.context !is Activity の場合にのみ Intent.FLAG_ACTIVITY_NEW_TASK をインジェクトします。ドメインとアプリの関連付け検証には、検証済みのHTTPS Android App Links(assetlinks.json)を優先的に使用します。

単調なチェーン状態による無限フォールバックループの防止

startActivity が ActivityNotFoundException をスローした場合は、専用の isAllowedFallbackUri(uri) チェック(厳格なHTTPS、デフォルトポート、検証済みホスト、明示的なフォールバックパスプレフィックス、重複するクエリキーの不在、フラグメントの不在)を用いて browser_fallback_url を検証します。カスタムスキーム上の明示的なポート表現は、uri.port == -1 と !uri.encodedAuthority.orEmpty().contains(":") の両方を検証することで拒否します。

フォールバックチェーンの追跡には SystemClock.elapsedRealtime() を使用し(ウォールクロックの System.currentTimeMillis() のジャンプを回避)、fallbackLoopKey() を介してチェーンを分離し(完全な IETF RFC 3986 の正規化ではなく)、明示的なホストラッパー loadNewNavigation(webView, url) を介して状態をリセットします。また、ポップアップダイアログ内で許可されていないドメインが決してロードされないよう、ポップアップのフォールバックを onPopupFallbackHandoff 経由でプライマリコンテナへとルーティングします。

リファレンスアーキテクチャの免責事項: 以下の実装は、防御的なリファレンスアーキテクチャです。アプリケーションで使用されている実際のAndroidXおよびiOSのバージョンに対して、APIの可用性、デリゲートの順序、ライフサイクルの動作を検証してください。

// Android - SafeWebViewModules.kt
// リファレンスアーキテクチャ:特定のプロジェクトターゲットに対してコンパイルおよびテストを行ってください。
// IntentSanitizerを利用するには androidx.core:core:1.9.0+(または androidx.core:core-ktx:1.9.0+)が必要です。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. ポリシーモジュール(IOスレッドおよびUIスレッドからの読み取り専用アクセスに対して不変 / スレッドセーフ)
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"),
    // ポップアップウインドウ専用に分離された許可リスト。一般的なウェブホストとは区別されます
    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
        }

        // クエリキーの検証、値の構文の強制、および重複キーの拒否
        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

        // uri.port == -1 と生の権限部分でのコロンの不在の両方をチェックして、ネットワークポートを厳格に拒否する
        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

        // クエリキーの検証、値の構文の強制、および重複キーの拒否
        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. フォールバックマネージャー:単調な経過時間ベースのチェーン状態(アクティブなチェーンをリピートセッションから分離)
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
    }

    // デフォルトのHTTPSポートを正規化し、重要なクエリキーを保持するアプリケーションレベルのループキー
    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. ルーターおよびフェイルクローズな IntentSanitizer を使用する WebViewClient(UIスレッド専用)
class SafeRedirectWebViewClient(
    val policy: CustomUriPolicy = CustomUriPolicy(),
    val loopGuard: FallbackLoopGuard = FallbackLoopGuard(),
    private val onPopupFallbackHandoff: ((fallbackUri: Uri) -> Unit)? = null
) : WebViewClient() {

    // loadUrl() の呼び出し前にフォールバックチェーンの状態をリセットする、明示的なホスト側ナビゲーションAPI
    fun loadNewNavigation(webView: WebView, url: String) {
        val targetUri = Uri.parse(url)
        if (!policy.isAllowedWebUri(targetUri)) {
            Log.w("WebViewDebug", "信頼されていないURLへのホスト側ナビゲーションがブロックされました")
            return
        }
        loopGuard.resetChain()
        webView.loadUrl(url)
    }

    // アクティブなチェーンの状態を保持しつつ内部検証を行う、専用のフォールバックローダー
    fun loadFallbackNavigation(webView: WebView, fallbackUri: Uri) {
        if (!policy.isAllowedFallbackUri(fallbackUri)) {
            Log.w("WebViewDebug", "信頼されていないフォールバックナビゲーションの試行がブロックされました")
            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. すべてのHTTP/HTTPSナビゲーションにおけるHTTPS専用&ウェブホスト許可リストの強制
        if (scheme == "http" || scheme == "https") {
            if (!policy.isAllowedWebUri(targetUri)) {
                Log.w("WebViewDebug", "非HTTPS、カスタムポート、または信頼されていないウェブホストがブロックされました")
                return true
            }
            if (hasUserGesture && isForMainFrame) {
                loopGuard.resetChain()
            }
            return false
        }

        // 2. 外部アプリ起動に関するメインフレームおよびユーザージェスチャ制約の強制
        if (!isForMainFrame || !hasUserGesture) {
            Log.w("WebViewDebug", "非メインフレームまたは非ジェスチャのスキームがブロックされました: $scheme")
            return true
        }

        // 3. Chromeの intent:// URIの解析とフェイルクローズなサニタイズ
        if (scheme == "intent") {
            return handleIntentUri(view, targetUri.toString(), isPopupContext)
        }

        // 4. 許可リストに登録されたカスタムURLスキームを検証し、1-to-1で検証済みのターゲットパッケージに明示的にバインドする
        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. 認識されないすべてのスキームをブロックする
        Log.w("WebViewDebug", "認識されないURLスキームがブロックされました: $scheme")
        return true
    }

    // 302リダイレクトを承認されたセッションに結びつける、子ポップアップWebView用のUIスレッドナビゲーションエバリュエーター
    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", "ポップアップ内のサブフレームHTTPSナビゲーションがブロックされました")
                return true
            }
            if (!policy.isAllowedPopupUri(targetUri)) {
                Log.w("WebViewDebug", "信頼されていないポップアップのHTTPSホストまたはパスナビゲーションがブロックされました")
                return true
            }
            // 初期ロードまたはユーザータップが許可リストに一致する場合にのみ、UIスレッド上でセッションを承認する
            if (isInitialTransportLoad || hasUserGesture) {
                onAuthorizedInitialSession()
                return false
            }
            // 以前に承認されたポップアップセッションに対してのみ、制限付きのサーバー側302リダイレクトを許可する
            if (isRedirect && isAuthorizedPopupSession && canProceedPopupRedirect()) {
                return false
            }

            Log.w("WebViewDebug", "承認されていないリダイレクトまたは非ジェスチャのポップアップナビゲーションがブロックされました")
            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", "不正なインテントURI構文です")
            return true
        }

        val fallbackUrl = parsedIntent.getStringExtra("browser_fallback_url")
        parsedIntent.removeExtra("browser_fallback_url")

        // 1-to-1バインディング:ターゲットスキームを抽出し、期待されるターゲットパッケージに対してネイティブに検証する
        val dataUri = parsedIntent.data ?: return true
        val targetScheme = dataUri.scheme?.lowercase() ?: return true
        val expectedPackage = policy.customSchemeTargetPackages[targetScheme] ?: run {
            Log.w("WebViewDebug", "マッピングされていないカスタムスキームを持つインテントがブロックされました: $targetScheme")
            return true
        }

        val rawPackage = parsedIntent.`package`
        if (rawPackage != expectedPackage) {
            Log.w("WebViewDebug", "インテントパッケージの不一致が検出されブロックされました: 予期されたパッケージ $expectedPackage")
            return true
        }

        // ウェブページによって指定された明示的なコンポーネントおよびセレクターを即座に拒否する
        if (parsedIntent.component != null || parsedIntent.selector != null) {
            Log.w("WebViewDebug", "明示的なコンポーネントまたはセレクターを持つインテントがブロックされました")
            return true
        }

        // 信頼されていないフラグ/拡張機能を厳格に拒否しつつビルダーの相互排他制約を回避するため、
        // allowAnyComponent() を用いた IntentSanitizer の呼び出し前に、検証済みパッケージを一時的にクリアする。
        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 が SecurityException をスローしました")
            return true
        } catch (e: IllegalArgumentException) {
            Log.w("WebViewDebug", "IntentSanitizerが無効なインテント引数を拒否しました")
            return true
        }

        // 検証済みターゲットパッケージの再バインド + ホストによって強制されるカテゴリ + サニタイズ後のアサーション
        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", "サニタイズ後のインテントアサーションに失敗しました")
            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", "信頼されていない、あるいはループしているフォールバックURLがブロックされました")
                }
            }
        } catch (e: SecurityException) {
            Log.w("WebViewDebug", "SecurityExceptionによりインテントの起動がブロックされました")
        }
        return true
    }

    private fun launchIntentSafely(view: WebView, intent: Intent) {
        try {
            launchWithContextSafety(view, intent)
        } catch (e: ActivityNotFoundException) {
            Log.i(
                "WebViewDebug",
                "ターゲットパッケージ/スキームを処理できるインストール済みのアプリケーションが見つかりませんでした"
            )
        } catch (e: SecurityException) {
            Log.w("WebViewDebug", "SecurityExceptionによりカスタムスキームの起動がブロックされました")
        }
    }

    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. ライフサイクル管理されるポップアップ WebChromeClient(厳格なUIスレッドセッション状態 & ステートレスなバックグラウンドガード)
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 = "宛先をロード中..."
        }
        popupRoot.addView(originBanner)

        // 以下のすべてのポップアップセッション状態変数は、UIスレッド上で厳格に読み取りおよび変更されます
        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スレッド:ナビゲーション、リダイレクト、およびセッション承認状態を所有します
                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
                }

                // バックグラウンドWebView IOスレッド:厳格なステートレスかつ読み取り専用のポリシーチェック。
                // UIスレッドのセッション状態を変更することは一切なく、初期リソースURLのみをカバーします(後続の302ホップは対象外)。
                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", "shouldInterceptRequest内で承認されていないポップアップのメインフレーム要求がブロックされました")
                            childView.post { disposeActivePopup() }
                            return WebResourceResponse("text/plain", "utf-8", ByteArrayInputStream(ByteArray(0)))
                        }
                    }
                    return super.shouldInterceptRequest(childView, request)
                }

                // UIスレッド:ナビゲーション開始時のフォールバックチェック & オリジョンの表示(事前ナビゲーションフィルタではありません)
                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", "ナビゲーション開始時のフォールバックチェックにより、承認されていないポップアップURLが終了させられました")
                        childView.stopLoading()
                        disposeActivePopup()
                        return
                    }
                    isAuthorizedPopupSession = true
                    val scheme = uri.scheme?.lowercase() ?: "https"
                    val host = uri.host?.lowercase() ?: "Unknown"
                    originBanner.text = "オリジン: $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. 完全なホストアクティビティの登録 & ライフサイクルクリーンアップの例(メインWebViewでJavaScriptが有効)
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 {
                // JSリダイレクトや window.open() を必要とする信頼されたランディングページに対して、明示的にJavaScriptを有効にする
                javaScriptEnabled = true
                allowFileAccess = false
                allowContentAccess = false
                // インタラクティブなポップアップコンテナをホストする場合にのみ、複数ウインドウを有効にする
                setSupportMultipleWindows(true)
            }
            webViewClient = safeClient
            webChromeClient = popupChromeClient
        }
        setContentView(webView)

        // 単なる webView.loadUrl() ではなく、明示的なホスト側ラッパーを使用する
        safeClient.loadNewNavigation(webView, "https://example.com/landing")
    }

    override fun onDestroy() {
        popupChromeClient.destroyPopups()
        (webView.parent as? ViewGroup)?.removeView(webView)
        webView.destroy()
        super.onDestroy()
    }
}

よくある質問(FAQ)

ターゲットアプリがインストールされているにもかかわらず、AndroidのWebViewに net::ERR_UNKNOWN_URL_SCHEME が表示されるのはなぜですか?
このエラーは、ChromiumがカスタムURLスキームをAndroidのActivity Managerに転送する代わりに、ネットワークスタック経由でフェッチしようとした場合に発生します。5つのチェックポイントを確認してください:カスタムの `WebViewClient` が割り当てられていることを確認する;`shouldOverrideUrlLoading(WebView, WebResourceRequest)` がインターセプトされたスキームに対して `true` を返すことを確認する;URI構造と1対1のターゲットパッケージが許可リストを通過していることを確認する;`startActivity(intent)` が正常に実行されることを確認する(`resolveActivity()` を呼び出す場合は `ActivityNotFoundException` をキャッチするか、`targetSdk >= 30` のために `<queries>` を設定する);そして、ターゲットアプリのマニフェストに `CATEGORY_BROWSABLE` を持つ一致する `<intent-filter>` が宣言されていることを確認する。
アプリから webView.loadUrl を直接呼び出した際に shouldOverrideUrlLoading が呼び出されないのはなぜですか?
Androidフレームワークの設計上、`shouldOverrideUrlLoading` は、アプリ側が開始する `webView.loadUrl()` の呼び出しや、HTTPの `POST` ナビゲーション時には呼び出されません。これは主に、ウェブコンテンツ、ユーザーインタラクション、またはサポートされているHTTP 3xxサーバーリダイレクトによって開始されたナビゲーションに対して実行されます。DOMインタラクションやページ内のサーバー応答からテストリダイレクトをトリガーし、アプリ側が開始するロードを監査する際には明示的なホストラッパー(`loadNewNavigation` など)を使用してください。
カスタムスキームを持つ target blank リンクが WKWebView 内でサイレントに失敗するのはなぜですか?
ウェブリンクが `target="_blank"` または `window.open()` を使用している場合、WebKitは新規ウインドウナビゲーション要求を作成します。このとき `navigationAction.targetFrame` は `nil` になります。`WKWebView` は新しいタブを自動的に開かないため、ホストアプリが `decidePolicyForNavigationAction` 内で `targetFrame == nil` を検出し、統合されたナビゲーションポリシーの下で要求を評価およびルーティングするための `WKUIDelegate.webView(_:createWebViewWith:for:windowFeatures:)` を実装しない限り、これらのナビゲーションはサイレントに失敗する可能性があります。

まとめと決定フレームワーク

WebViewのディープリンクおよびリダイレクト失敗を解決するには、WebViewエンジンの動作をホストアプリケーションのナビゲーションポリシーから切り離す必要があります。Chrome DevToolsやSafari Web Inspectorでナビゲーションイベントを再現し、ステートレスな初期要求のスクリーニングとセッション承認済みの302リダイレクトチェックを組み合わせながらAndroidのポップアップセッション状態をUIスレッドに厳格に閉じ込め、フェイルクローズな IntentSanitizer 許可リストを強制し、さらに古い非同期の上書きや重複するデリゲート起動からiOSのユニバーサルリンクのフォールバックを保護することで、開発チームはユーザーの離脱を減らし、クライアント側のリダイレクト脆弱性を防ぐことができます。

コンテナレベルのネイティブデリゲートとフォールバックパスが検証された後、開発チームは OpoInstall などのプラットフォームを利用して、エンドツーエンドの計測ランディングページやワンクリック起動ルーティングチェーンを検証し、ブラウザからアプリへの移行全体を通じてパラメータが保持されていることを確認する必要があります。

エンティティ用語集

用語 定義 関連エンティティ 検索意図の役割
WebView モバイルアプリケーション内でウェブページをレンダリングするために使用される組み込みのネイティブUIコンポーネント。 WebViewClient / WKWebView 情報収集 / 技術的
カスタムURLスキーム ネイティブ画面への外部ナビゲーションを可能にする、アプリに登録されたURIプレフィックス(例:myapp://)。 Intent.ACTION_VIEW 技術的 / 情報収集
WKNavigationDelegate ホストアプリが WKWebView 内でのナビゲーションアクションの承諾、キャンセル、またはリダイレクトを行えるようにするWebKitプロトコル。 decidePolicyForNavigationAction 技術的
WKUIDelegate WKWebView 内での新規ウインドウ作成要求の処理を担当するWebKitプロトコル。 createWebViewWith 技術的
WebResourceRequest URL、フレーム、HTTPメソッド、リダイレクト、およびジェスチャのメタデータをカプセル化する、Android API 24以降のオブジェクト。 shouldOverrideUrlLoading 技術的
WebChromeClient JavaScriptのダイアログ、進行状況、および onCreateWindow を処理するAndroid WebViewのコールバックインターフェイス。 WebViewTransport 技術的
IntentSanitizer ディスパッチ前に信頼されていないインテントのフィールドをフィルタリングまたは厳格に検証するために使用されるAndroidX Coreのユーティリティ。 インテントリダイレクトの防御 技術的 / セキュリティ
ユニバーサルリンク(Universal Links) 検証済みのウェブドメインをインストール済みのiOSアプリケーションに結びつける、AppleのHTTPSベースのディープリンク標準。 関連ドメイン(Associated Domains) 技術的 / 情報収集
パッケージ可視性(Package Visibility) ホストアプリが PackageManager を介してクエリできるインストール済みアプリを制限する、Android 11以降(targetSdk >= 30)のOSフィルタリング機能。 <queries> マニフェストタグ 技術的
インテントURI(Intent URI) ターゲットパッケージ、スキーム、およびブラウザのフォールバックURLをエンコードする、構造化されたAndroidのURI(intent://)。 Intent.URI_INTENT_SCHEME 技術的

互換性の基準と検証ステータス

  • 想定される互換性ターゲット:Android minSdk 24、compileSdk 34/35、targetSdk 34/35(Android 14/15)、Android 16(API 36)インテントリダイレクトのハードニングコンテキスト、androidx.core:core:1.9.0+(IntentSanitizer);iOS 15.0〜18.0(isInspectable はiOS 16.4以降でゲート)、Xcode 15/16、Swift 5.9/6.0。

  • 検証ステータス:

    • 静的APIおよび仕様レビュー:公式のAndroid Developers、AndroidX Core、Apple Developer、IETF RFC 3986、およびOWASP MASTGの仕様に対して完了しています。

    • コンパイルおよび物理デバイス検証:このレビューサイクルではまだ実行されていません。チームは、本番環境へのロールアウト前に、悪意のある初期ポップアップURL、クロスドメインの302チェーン、連続する302ホップ、サードパーティのiframeウインドウ作成、Android App Links(assetlinks.json)、iOS関連ドメイン(AASAキャッシュ)、古い非同期ユニバーサルリンクのキャンセル、intent:// フォールバックチェーン、および ActivityNotFoundException のディスパッチをカバーする、物理デバイスでのコンパイルとリグレッションテストを実行する必要があります。

参考文献

Share this article