ฉันจะเปิดใช้งาน Universal Links ภายใน WKWebView ของ iOS ได้อย่างไร? Universal Links สามารถทำงานได้จากลิงก์ที่เข้าเกณฑ์ภายใน WKWebView อยู่แล้ว การใช้งาน WKNavigationDelegate จะช่วยให้แอปพลิเคชันหลักปรับแต่งนโยบายการกำหนดเส้นทาง (Routing Policy) ได้ เช่น การดักจับปลายทางที่เป็นของแอปเอง, การควบคุมการส่งต่อไปยังภายนอกผ่าน decidePolicyForNavigationAction และการบังคับใช้ความปลอดภัยระดับเฟรม
ในสถาปัตยกรรมแอปพลิเคชัน iOS การดักจับการนำทางใน WKWebView ช่วยให้แอปสามารถปรับแต่งนโยบายการกำหนดเส้นทางสำหรับ Universal Links, custom URL schemes และปลายทางบนเว็บได้ โดยการตรวจสอบเมตาข้อมูลของคำขอการนำทางผ่าน WKNavigationDelegate แอปจะสามารถกำหนดเส้นทางปลายทางที่เป็นของแอปเองไว้ภายใน ส่งต่อปลายทางภายนอกไปยังตัวจัดการของระบบ และบังคับใช้นโยบายความปลอดภัยระดับเฟรมได้
| คำศัพท์ | คำนิยาม | เอนทิตีที่เกี่ยวข้อง | บทบาทของ Search Intent |
|---|---|---|---|
| WebView | องค์ประกอบมุมมองที่ใช้ WebKit ซึ่งฝังไว้เพื่อแสดงผลเนื้อหาเว็บแบบโต้ตอบภายในแอปพลิเคชัน iOS | iOS SDK | เชิงให้ข้อมูล / เชิงพาณิชย์ |
| Universal Links | กลไกมาตรฐาน HTTPS ที่เชื่อมโยงโดเมนเว็บที่ผ่านการยืนยันเข้ากับมุมมองในแอปพลิเคชัน iOS โดยตรง | การกำหนดเส้นทาง Deep Link | เชิงเทคนิค / เชิงให้ข้อมูล |
| Custom URL Scheme | รูปแบบ URI ที่แอปกำหนดขึ้นเองเพื่อใช้สำหรับนำทาง URL เข้าสู่แอปพลิเคชันเนทีฟ | Mobile Deep Linking | เชิงให้ข้อมูล |
การโต้ตอบระหว่าง WKWebView และการกำหนดเส้นทาง Universal Link บน iOS

วงจรการนำทางของ WebKit และนโยบายการกำหนดเส้นทางของแอป
Apple ใช้ Universal Links เป็นกลไกการกำหนดเส้นทางระดับระบบที่รองรับทั้งใน Safari และสภาพแวดล้อม WKWebView เมื่อผู้ใช้แตะลิงก์ที่เข้าเกณฑ์ภายใน WKWebView ที่ฝังอยู่ ระบบจะสามารถแก้ไขความสัมพันธ์ของโดเมนและดำเนินการกำหนดเส้นทางตามนโยบายของระบบปฏิบัติการ
แม้ว่า Universal Links ที่ระบบรู้จักจะสามารถส่งต่อการดำเนินการไปยังตัวจัดการเนทีฟได้ แต่สภาพแวดล้อมของเบราว์เซอร์ที่ฝังอยู่มักต้องการตรรกะการกำหนดเส้นทางเฉพาะของแอปพลิเคชัน ตัวอย่างเช่น เมื่อลิงก์ชี้ไปยังโดเมนของแอปเอง นักพัฒนามักต้องการให้มีการนำทางผ่าน view controllers ของเนทีฟโดยตรงแทนที่จะเปิดแอปภายนอกขึ้นมาใหม่ทั้งหมด การใช้งาน WKNavigationDelegate ช่วยให้แอปพลิเคชันหลักสามารถควบคุมการประเมินลิงก์ได้อย่างละเอียด ช่วยให้ทีมสามารถบังคับใช้ allowlist ที่กำหนดเองและกำหนดเส้นทางภายในได้อย่างแม่นยำ
อุปสรรคด้านประสบการณ์ผู้ใช้: เมื่อการท่องเว็บในแอปติดลูปการเปลี่ยนเส้นทาง
WebView ที่ฝังอยู่มักถูกใช้เพื่อแสดงไมโครไซต์โปรโมชัน, ศูนย์ช่วยเหลือ, แคตตาล็อกพันธมิตร และหน้า Landing Page ของการตลาดภายในแอป iOS เมื่อหน้าเว็บภายในแอปมีลิงก์ที่ตั้งใจจะพาผู้ใช้ไปยังส่วนอื่นๆ ของแอปหลัก (เช่น ปุ่ม "ดูในแอป") หรือไปยังแอปพันธมิตร การนำทางโดยค่าเริ่มต้นอาจนำไปสู่การแสดงผลที่ซ้ำซ้อน:
- การแสดงผลเว็บที่ซ้ำซ้อน: แทนที่จะโหลดหน้าจอเนทีฟ ผู้ใช้อาจถูกนำไปยังหน้าเว็บที่ปรับขนาดตามอุปกรณ์ของหน้าในแอป ทำให้ต้องล็อกอินซ้ำและเสียความสอดคล้องทางภาพ
- การติดลูปบนเว็บ: ผู้ใช้อาจติดอยู่ใน Stack การนำทางของเว็บโดยไม่มีทางกลับไปยังอินเทอร์เฟซหลักของแอปเนทีฟได้ง่าย
- การเปลี่ยนจากแอปหนึ่งไปอีกแอปหนึ่งล้มเหลว: การแตะลิงก์ที่ชี้ไปยังบริการของบุคคลที่สาม (เช่น แอปนำทาง, หน้าต่างแชร์โซเชียล หรือเกตเวย์ชำระเงิน) จำเป็นต้องมีการมอบหมายสิทธิ์ที่ชัดเจนหากบริการเหล่านั้นอาศัย Custom URL schemes
เปรียบเทียบ WKWebView กับ SFSafariViewController สำหรับการส่งต่อ Web-to-App
เมื่อออกแบบการท่องเว็บภายในแอปบน iOS ทีมวิศวกรต้องเลือกระหว่าง WKWebView และ SFSafariViewController:
SFSafariViewController: มอบอินเทอร์เฟซเบราว์เซอร์ Safari ที่จัดการโดยระบบและเป็นอิสระ พร้อมคุณสมบัติเช่น AutoFill และการบล็อกเนื้อหา แอปพลิเคชันหลักไม่สามารถตรวจสอบกิจกรรมการท่องเว็บหรือข้อมูลเว็บไซต์ได้ และการปรับแต่ง UI จำกัดเพียงแค่สีพื้นหลังWKWebView: เป็นองค์ประกอบมุมมองที่ฝังอยู่ภายในกระบวนการ UI ของแอปขณะที่รันเนื้อหาเว็บในกระบวนการ WebKit แยกต่างหาก ช่วยให้สามารถปรับแต่ง UI ได้อย่างลึกซึ้ง, ใช้ JavaScript bridges และรวมเลย์เอาต์ที่กำหนดเองได้ โดยจำเป็นต้องมีการตั้งค่าWKNavigationDelegateอย่างชัดเจนเพื่อกำหนดนโยบายการกำหนดเส้นทางและจัดการ Custom Schemes
decidePolicyForNavigationAction ดักจับการนำทางของ WebKit อย่างไร
ไปป์ไลน์นโยบายการนำทาง: ทำความเข้าใจ WKNavigationAction, request และ decisionHandler
ในการควบคุมลำดับการนำทางภายใน WKWebView นักพัฒนาจะมอบหมาย delegate ที่เป็นไปตาม คำแนะนำของ Apple เกี่ยวกับ WKNavigationDelegate จุดดักจับหลักคือเมธอด delegate:
func webView(
_ webView: WKWebView,
decidePolicyFor navigationAction: WKNavigationAction,
decisionHandler: @escaping (WKNavigationActionPolicy) -> Void
)
การดำเนินการนำทางที่เกิดจากการโต้ตอบของผู้ใช้, การเปลี่ยนเส้นทางโดยโปรแกรม หรือการส่งฟอร์ม จะผ่านเมธอดนี้ โดยออบเจกต์ WKNavigationAction จะให้เมตาข้อมูลที่สำคัญ:
navigationAction.request.url:URLปลายทางที่ถูกร้องขอnavigationAction.navigationType: ประเภทของตัวกระตุ้น (.linkActivated,.other,.formSubmitted)navigationAction.sourceFrame: ข้อมูลเกี่ยวกับเฟรมที่เริ่มคำขอการนำทางnavigationAction.targetFrame: ข้อมูลเกี่ยวกับเฟรมปลายทางที่ต้องการโหลดเนื้อหา
decisionHandler คือ closure ที่แจ้งให้ WebKit ทราบว่าจะอนุญาตหรือยกเลิกการนำทางที่ร้องขอ
เมื่อใดที่ควรส่งคืน .allow เทียบกับ .cancel: การควบคุมวงจรการโหลดทรัพยากรของ WebKit
WKNavigationActionPolicy ที่ส่งไปยัง decisionHandler จะควบคุมว่า WebKit จะดำเนินการนำทางต่อหรือไม่:
.allow: แจ้งให้ WebKit ดำเนินการนำทางต่อไปภายใน web view.cancel: สั่งให้ WebKit ยกเลิกการนำทางที่ร้องขอ นโยบายนี้จะดำเนินการเมื่อแอปพลิเคชันดักจับ Custom Scheme, กำหนดเส้นทาง Universal Link ภายใน, หรือส่งต่อเป้าหมายภายนอกไปยังUIApplication.shared.open()
decisionHandler จะต้องถูกเรียกใช้งานหนึ่งครั้งต่อการกระทำหนึ่งอย่าง เพื่อให้แน่ใจว่านโยบายการนำทางดำเนินไปโดยไม่หยุดชะงัก
การประเมินประเภทการนำทาง: การแยกแยะการคลิกของผู้ใช้ (.linkActivated) จากการ Redirect อัตโนมัติ
WKNavigationAction.navigationType ช่วยให้นักพัฒนาแยกแยะการโต้ตอบของผู้ใช้ที่ชัดเจนจากสคริปต์อัตโนมัติ:
.linkActivated: ผู้ใช้แตะลิงก์ HTML anchor tag (<a href="...">) โดยตรง.other: แสดงถึงการนำทางโดยโปรแกรม เช่น การอัปเดตwindow.location.href, meta refresh หรือการเรียกwebView.load()ครั้งแรก.formSubmitted/.formResubmitted: แสดงถึงการส่งฟอร์มแบบ POST หรือ GET
การประเมิน navigationType ช่วยให้แอปพลิเคชันบังคับใช้นโยบายการเปิดลิงก์ที่ชัดเจน สำหรับการเรียก Custom Scheme ภายนอกหรือการส่งต่อไปยังแอปอื่น การกำหนดให้ต้องเป็น .linkActivated จะช่วยป้องกันไม่ให้สคริปต์เบื้องหลังที่ไม่ได้ตั้งใจเรียกการเปิดแอปภายนอกโดยอัตโนมัติ
การจัดการนโยบายการตัดสินใจแบบ Asynchronous โดยไม่เกิด Retain Cycle
เมื่อการตรวจสอบเส้นทางหรือสิทธิ์ต้องมีการสอบถามแคชในเครื่องหรือตัวตรวจสอบความปลอดภัยก่อนส่งคืนการตัดสินใจ:
- ตรวจสอบให้แน่ใจว่า
decisionHandlerถูกเรียกใช้งานในทุกเส้นทาง รวมถึงกรณีที่มีข้อผิดพลาด - ใช้ weak references (
[weak self]) ภายใน escaping closures เพื่อป้องกัน retain cycles ระหว่างWKWebView, delegate ของมัน และUIViewControllerแม่
การแยกความแตกต่างระหว่าง Associated Domains ของแอปกับ Universal Links ภายนอก

การจัดการปลายทางที่เป็นของแอปเทียบกับการมอบหมายลิงก์ระดับระบบ
สำหรับเส้นทางที่เป็นของแอปเอง ให้หลีกเลี่ยงการพยายามกลับเข้าสู่แอปเดิมผ่านการค้นหา Universal Link ซ้ำซ้อน ให้จัดการปลายทางที่เป็นของแอปโดยตรงผ่านตัวกำหนดเส้นทางภายในของแอป และใช้การเปิดระบบหลักสำหรับปลายทางที่ควรออกจากแอปปัจจุบันหรือควรแก้ไขโดยบริการภายนอก
สถาปัตยกรรมที่แยกส่วนนี้ช่วยให้การนำทางราบรื่น:
- Associated Domains ของแอป: หาก URL host ตรงกับโดเมนที่เกี่ยวข้องของแอป (
app.example.com) ให้ยกเลิกการนำทางของ web view (decisionHandler(.cancel)), ตรวจสอบ path ของเส้นทาง, และส่งพารามิเตอร์ที่แยกวิเคราะห์แล้วไปยังตัวกำหนดเส้นทางภายในของแอปโดยตรง - แอปพลิเคชันภายนอก: หาก URL ชี้ไปยังปลายทางของพันธมิตรภายนอกหรือ Custom Scheme ที่ได้รับอนุญาต ให้ใช้นโยบายการเปิดลิงก์ที่ชัดเจนระดับแอป (
navigationType == .linkActivated), ยกเลิกการนำทาง web view, และส่งต่อคำขอไปยังUIApplication.shared.open(url)เพื่อให้ระบบปฏิบัติการเปิดแอปภายนอก
การออกแบบการตรวจสอบเส้นทางภายใน: การสกัด Path และ Query Parameters ผ่าน AppRouteValidator
เมื่อ URL ที่เข้ามาตรงกับโดเมนที่เกี่ยวข้องของแอปพลิเคชัน สตริงของ URL จะต้องผ่านการตรวจสอบเส้นทางที่เข้มงวดก่อนที่จะเปิดใช้การเปลี่ยนหน้าของ view controller
โมเดล AppRouteValidator:
- ตรวจสอบ Path ของ URL เทียบกับ allowlist ของเส้นทางภายในที่รองรับ (เช่น
/open/,/product/,/promo/,/checkout/) - สกัด Query Parameters (เช่น
id,promo,utm_source) - บังคับใช้ข้อจำกัดของชุดอักขระ, ขอบเขตความยาว และการปฏิเสธคีย์ที่ซ้ำกัน โดยส่งคืนโครงสร้างข้อมูล
ValidatedAppRouteที่สะอาด
การจัดการ Universal Links ของบุคคลที่สามผ่านระบบ UIApplication Delegation

เมื่อหน้าเว็บภายใน WKWebView เชื่อมโยงไปยังบริการภายนอก (เช่น แอปพันธมิตร, แพลตฟอร์มโซเชียล หรือยูทิลิตี้ภายนอก) แอปพลิเคชันหลักสามารถมอบหมายการกำหนดเส้นทางให้กับระบบ iOS ได้:
let options: [UIApplication.OpenExternalURLOptionsKey: Any] = [
.universalLinksOnly: true
]
UIApplication.shared.open(url, options: options) { success in
if !success {
// นโยบายสำรอง: โหลดปลายทางเว็บหากไม่มีแอปเนทีฟจัดการ Universal Link
}
}
การจัดการ Custom URL Scheme (myapp://) ควบคู่กับ HTTPS Universal Links
ในขณะที่ HTTPS Universal Links เป็นมาตรฐานของ Deep Linking บน iOS แต่ Custom Scheme ที่แอปกำหนดขึ้น (เช่น myapp:// หรือ partnerapp://) ก็ยังคงพบเห็นได้ทั่วไปในแคมเปญโปรโมชันและการเชื่อมต่อกับพันธมิตร
ในการใช้งาน WKNavigationDelegate แบบรวมศูนย์:
- ตรวจสอบ Scheme ที่ไม่ใช่ HTTP/HTTPS ก่อน หาก scheme ตรงกับโปรโตคอลที่ได้รับอนุญาตและเป็นไปตามนโยบายการเปิดลิงก์ (
navigationType == .linkActivated) delegate จะตรวจสอบ host, path และพารามิเตอร์ก่อนส่งไปยังUIApplication.shared.open() - Scheme ที่ไม่รู้จักหรือไม่ได้รับคำสั่งให้เปิดจะถูกยกเลิกทันที เพื่อป้องกันข้อผิดพลาดในการนำทางหรือการเรียกใช้งานสคริปต์โดยไม่ตั้งใจ
[ผู้ใช้โต้ตอบกับลิงก์ภายใน iOS WKWebView]
│
▼
[WKNavigationDelegate: decidePolicyForNavigationAction]
│
┌─────────────┴─────────────┐
▼ ▼
[!action.sourceFrame.isMainFrame] [action.sourceFrame.isMainFrame]
│ │
▼ ▼
[ความปลอดภัยของ Subframe] [ตรวจสอบ Scheme & Host ปลายทาง]
├─ HTTP(S) -> .allow │
└─ Non-Web -> .cancel ┌───────────┼───────────┐
(ระงับ Subframe) ▼ ▼ ▼
[Host Domain] [เว็บภายนอก] [Custom Scheme]
│ │ │
▼ ▼ ▼
[AppRoute] [ตรวจสอบลิงก์] [ตรวจสอบลิงก์]
├─ ถูกต้อง -> ├─ พันธมิตร-> ├─ ถูกต้อง & คลิก->
│ ภายใน │ เปิดแอป │ เปิดแอป
└─ ไม่ถูกต้อง-> └─ เว็บ -> └─ ไม่ถูกต้อง/Auto->
.cancel .allow .cancel
วิธีบังคับใช้ความปลอดภัยของ Main Frame และป้องกัน Iframe Hijacking

การปฏิบัติต่อการนำทางเว็บที่ฝังตัวว่าเป็นอินพุตที่ไม่น่าเชื่อถือ: มาตรฐานความปลอดภัย Deep Link ของ OWASP
ตาม แนวทางปฏิบัติของ OWASP เกี่ยวกับ Deep Links ที่ไม่ปลอดภัย URL และพารามิเตอร์ทั้งหมดที่ประมวลผลโดยตัวจัดการการนำทางบนมือถือจะต้องได้รับการปฏิบัติว่าเป็นอินพุตภายนอกที่ไม่น่าเชื่อถือ
หน้าเว็บที่แสดงผลภายใน WKWebView อาจโหลดสคริปต์ของบุคคลที่สาม, แบนเนอร์โฆษณา หรือเนื้อหาที่ผู้ใช้สร้างขึ้น หาก navigation delegate ส่งต่อ URL ตามอำเภอใจไปยัง native view controller หรือ UIApplication.shared.open() โดยไม่มีการตรวจสอบ พารามิเตอร์ที่ไม่คาดคิดอาจกำหนดเป้าหมายไปยังเส้นทางภายในแอปที่ละเอียดอ่อนได้
การแยกการนำทางของ Main Frame ออกจาก Iframe และเป้าหมายหน้าต่างใหม่
ตาม เอกสารของ Apple เกี่ยวกับ WKNavigationAction การประเมินความปลอดภัยของเฟรมต้องมีการตรวจสอบเฟรมที่เป็นต้นทาง:
sourceFrame.isMainFrame == true: การนำทางถูกเริ่มต้นโดยตรงจากเฟรมหลักของเอกสารsourceFrame.isMainFrame == false: การนำทางถูกเริ่มต้นโดย subframe หรือ iframe ที่ฝังอยู่targetFrame == nil: การนำทางร้องขอเป้าหมายหน้าต่างใหม่ (เช่น anchor ที่มีtarget="_blank")
เพื่อป้องกัน iframe hijacking (ที่ iframe พยายามเปิดแอปภายนอกหรือเรียกการเปลี่ยนหน้าจอในพื้นหลัง) delegate จะต้องประเมิน sourceFrame.isMainFrame หากเฟรมที่เริ่มต้นเป็น iframe (sourceFrame.isMainFrame == false) ให้ยอมรับการนำทาง HTTP/HTTPS ปกติ (.allow) แต่บล็อก Custom Scheme ที่ไม่ใช่เว็บ หรือการส่งต่อเส้นทางเนทีฟ (.cancel)
การป้องกันการเรียกใช้โปรโตคอล Subframe ที่ประสงค์ร้ายและการยิงสคริปต์
การบังคับใช้การตรวจสอบเฟรมต้นทางจะช่วยป้องกันไม่ให้ subframe เรียกใช้ Custom Scheme ภายนอกโดยไม่ได้ตั้งใจ:
if !navigationAction.sourceFrame.isMainFrame {
let scheme = url.scheme?.lowercased() ?? ""
if scheme == "http" || scheme == "https" {
decisionHandler(.allow) // อนุญาตการนำทาง Subframe แบบปกติ
} else {
decisionHandler(.cancel) // ระงับ Custom Scheme ที่ไม่ใช่เว็บจาก Subframe
}
return
}
การบังคับใช้ Allowlists ของ Path และพารามิเตอร์อย่างเข้มงวดในการกำหนดเส้นทาง
ทั้ง URL โดเมนภายในและ Custom Scheme ภายนอกจะต้องผ่านโมเดลการตรวจสอบที่เข้มงวดก่อนการดำเนินการ:
- Path Prefix Allowlists: บังคับใช้ Prefix เส้นทางที่ได้รับอนุมัติ (เช่น
/open/,/product/,/promo/,/checkout/) และปฏิเสธเส้นทางที่ผิดปกติ - Query Key Filtering: ทิ้ง Query Key ที่ไม่คาดคิดและปฏิเสธคีย์พารามิเตอร์ซ้ำเพื่อป้องกันปัญหาพารามิเตอร์ที่ไม่ถูกต้อง
- ข้อจำกัดด้านชนิดข้อมูลและความยาว: จำกัดพารามิเตอร์ให้อยู่ในชุดอักขระตัวเลขและตัวอักษร และจำกัดความยาวสูงสุดไม่เกิน 64 ตัวอักษร
การใช้งาน WKNavigationDelegate ในขั้นตอนการผลิตด้วย Swift
การจัดโครงสร้าง CustomWebViewController และสถาปัตยกรรม Delegate ใน Swift
คอนโทรลเลอร์ WKWebView ที่พร้อมใช้งานในขั้นตอนการผลิตจะประสานการตั้งค่าเว็บ, การประเมินนโยบาย, การกำหนดเส้นทางภายใน และการส่งต่อภายนอก การใช้งานนี้จะห่อหุ้มกฎการตรวจสอบภายในคลาส validator (AppRouteValidator และ CustomSchemeValidator) เพื่อให้ delegate callback สะอาด, ทดสอบได้ และปลอดภัย
การใช้งานโมเดล AppRouteValidator และ CustomSchemeValidator
โมเดล validator จะบังคับใช้ความปลอดภัยแบบปิดเมื่อเกิดข้อผิดพลาด:
AppRouteValidatorตรวจสอบโดเมนที่เกี่ยวข้องภายใน โดยตรวจสอบ Path Prefix และตรวจสอบพารามิเตอร์ให้อยู่ในออบเจกต์ValidatedAppRouteCustomSchemeValidatorตรวจสอบ Custom Scheme ที่ได้รับอนุญาต (myapp), ตรวจสอบ Host ที่ได้รับอนุญาต (open,product,event) และล้างค่าพารามิเตอร์
OpoInstall สามารถรวมเข้ากับเลเยอร์การกำหนดเส้นทางของแอปพลิเคชันเพื่อการระบุแหล่งที่มา (Attribution) และการกู้คืนพารามิเตอร์ที่ล่าช้า ตรวจสอบ เอกสารประกอบการรวม SDK สำหรับคำแนะนำแบบครบถ้วน
การดำเนินการทางเทคนิคด้านล่างแสดงวิธีการตั้งค่า WKNavigationDelegate ที่ปลอดภัยใน Swift:
// iOS: CustomWebViewController พร้อมการกำหนดเส้นทางและความปลอดภัยของเฟรมที่เข้มงวด
import UIKit
import WebKit
struct ValidatedAppRoute {
let path: String
let queryParams: [String: String]
}
// 1. Validator สำหรับโดเมนของแอปเอง (Internal Routes)
class AppRouteValidator {
private static let allowedPrefixes = ["/open/", "/product/", "/promo/", "/checkout/"]
private static let allowedQueryKeys = Set(["target", "id", "promo", "utm_source"])
static func validate(url: URL) -> ValidatedAppRoute? {
let path = url.path
guard allowedPrefixes.contains(where: { path.hasPrefix($0) }) else {
return nil
}
var sanitizedParams: [String: String] = [:]
var seenKeys = Set<String>()
if let components = URLComponents(url: url, resolvingAgainstBaseURL: false),
let queryItems = components.queryItems {
let validChars = CharacterSet(charactersIn: "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_-")
for item in queryItems {
guard allowedQueryKeys.contains(item.name), !seenKeys.contains(item.name) else { return nil }
seenKeys.insert(item.name)
let value = item.value ?? ""
if value.count <= 64 && value.rangeOfCharacter(from: validChars.inverted) == nil {
sanitizedParams[item.name] = value
} else {
return nil
}
}
}
return ValidatedAppRoute(path: path, queryParams: sanitizedParams)
}
}
// 2. Validator สำหรับ Custom Schemes (myapp://)
class CustomSchemeValidator {
private static let allowedSchemes = Set(["myapp"])
private static let allowedHosts = Set(["open", "product", "event"])
private static let allowedPathPrefixes = ["/detail/", "/view/", "/main/"]
private static let allowedQueryKeys = Set(["target", "id", "promo", "utm_source"])
static func validate(url: URL) -> URL? {
guard let scheme = url.scheme?.lowercased(), allowedSchemes.contains(scheme) else {
return nil
}
guard let host = url.host?.lowercased(), allowedHosts.contains(host) else {
return nil
}
let path = url.path
if !path.isEmpty && !allowedPathPrefixes.contains(where: { path.hasPrefix($0) }) {
return nil
}
var seenKeys = Set<String>()
if let components = URLComponents(url: url, resolvingAgainstBaseURL: false),
let queryItems = components.queryItems {
let validChars = CharacterSet(charactersIn: "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_-")
for item in queryItems {
guard allowedQueryKeys.contains(item.name), !seenKeys.contains(item.name) else { return nil }
seenKeys.insert(item.name)
let value = item.value ?? ""
if value.count > 64 || value.rangeOfCharacter(from: validChars.inverted) != nil {
return nil
}
}
}
return url
}
}
// 3. UIViewController ที่โฮสต์ WKWebView พร้อมการดักจับนโยบายความปลอดภัย
class CustomWebViewController: UIViewController, WKNavigationDelegate {
var webView: WKWebView!
private let hostAssociatedDomain = "app.example.com"
private let allowedExternalPartnerHosts = Set(["partner.example.com"])
override func viewDidLoad() {
super.viewDidLoad()
let configuration = WKWebViewConfiguration()
webView = WKWebView(frame: view.bounds, configuration: configuration)
webView.navigationDelegate = self
view.addSubview(webView)
}
func webView(
_ webView: WKWebView,
decidePolicyFor navigationAction: WKNavigationAction,
decisionHandler: @escaping (WKNavigationActionPolicy) -> Void
) {
guard let url = navigationAction.request.url else {
decisionHandler(.allow)
return
}
if !navigationAction.sourceFrame.isMainFrame {
let scheme = url.scheme?.lowercased() ?? ""
if scheme == "http" || scheme == "https" {
decisionHandler(.allow)
} else {
decisionHandler(.cancel)
}
return
}
let scheme = url.scheme?.lowercased() ?? ""
let isExplicitLinkActivation = (navigationAction.navigationType == .linkActivated)
if scheme == "https", let host = url.host?.lowercased(), host == hostAssociatedDomain {
if let validatedRoute = AppRouteValidator.validate(url: url) {
AppInternalRouter.shared.navigate(to: validatedRoute)
}
decisionHandler(.cancel)
return
}
if scheme != "http" && scheme != "https" && scheme != "about" {
if isExplicitLinkActivation, let validatedURL = CustomSchemeValidator.validate(url: url) {
UIApplication.shared.open(validatedURL, options: [:], completionHandler: nil)
}
decisionHandler(.cancel)
return
}
if scheme == "http" || scheme == "https" {
let host = url.host?.lowercased() ?? ""
if allowedExternalPartnerHosts.contains(host) && isExplicitLinkActivation {
let options: [UIApplication.OpenExternalURLOptionsKey: Any] = [
.universalLinksOnly: true
]
UIApplication.shared.open(url, options: options) { [weak self] success in
if !success {
guard let self = self else { return }
self.webView.load(navigationAction.request)
}
}
decisionHandler(.cancel)
return
}
if navigationAction.targetFrame == nil {
webView.load(navigationAction.request)
decisionHandler(.cancel)
return
}
decisionHandler(.allow)
return
}
decisionHandler(.allow)
}
}
class AppInternalRouter {
static let shared = AppInternalRouter()
func navigate(to route: ValidatedAppRoute) {}
}
การดำเนินการที่ปลอดภัย (Thread-Safe): การเปลี่ยนหน้า UI บน Main Actor
ในโมเดล concurrency ของ Swift ปัจจุบัน callback ของ WKNavigationDelegate จะถูกแยกส่วนบน main-actor การกำหนดเส้นทางของแอปและการเปลี่ยน view controller จะดำเนินการบน main-actor เพื่อคงความปลอดภัยของ Thread ตลอดขั้นตอนการนำทาง
ข้อผิดพลาดในการนำทาง Deep Link ใน WKWebView และตารางวิเคราะห์
คู่มือแก้ไขปัญหา Deep Linking สำหรับ iOS WKWebView
| อาการของข้อผิดพลาด | สาเหตุหลัก | เวอร์ชัน iOS | จุดตรวจสอบ | วิธีแก้ไข |
|---|---|---|---|---|
| Universal Link โหลดเป็นเว็บ | โดเมนของแอปไม่ถูกดักจับ | iOS 9+ | ไม่ได้จัดการ decidePolicyForNavigationAction |
ดักจับโดเมนโฮสต์, สกัด path, กำหนดเส้นทางภายใน, .cancel |
| ลิงก์ของตัวเองกำหนดเส้นทางไม่สำเร็จ | เรียก UIApplication.open ไปยังโดเมนตัวเอง |
iOS 9+ | เรียกใช้ UIApplication.shared.open บนโฮสต์ตัวเอง |
หลีกเลี่ยงการเปิดตัวเองผ่านภายนอก; ส่งตรงไปยัง router ภายใน |
| Custom Scheme เงียบหายไป | WebKit ไม่รู้จักโปรโตคอลที่ไม่ใช่ HTTP | iOS 9+ | Scheme ไม่ถูกส่งต่อให้ UIApplication |
ดักจับ scheme ใน delegate, ตรวจสอบ allowlist, เปิดผ่าน UIApplication |
| Iframe ปลอมแปลงโปรโตคอล | Subframe เรียก Custom Scheme ภายนอก | iOS 9+ | sourceFrame.isMainFrame ไม่ได้ตรวจสอบ |
ใช้ if !sourceFrame.isMainFrame เพื่อระงับ scheme ที่ไม่ใช่เว็บ |
| ปัญหาการส่งต่อ UI | การเปลี่ยน UI ไม่ได้อยู่บน thread หลัก | iOS 9+ | ขาดการ dispatch บน main-actor | ตรวจสอบการใช้ main-actor สำหรับ router และการเปลี่ยนหน้าจอ |
คำถามที่พบบ่อย (FAQ)
นักพัฒนาจะดักจับ Universal Links ใน WKWebView ได้อย่างไร?
ฉันสามารถใช้ UIApplication.shared.open เพื่อเปิดแอปของตัวเองจาก WKWebView ได้หรือไม่?
ฉันจะป้องกันไม่ให้ Iframe ใน WKWebView เรียกการเปิดแอปภายนอกได้อย่างไร?
สรุปและเฟรมเวิร์กการตัดสินใจ
การจัดการ Universal Links และ Custom Schemes ภายใน WKWebView ของ iOS จำเป็นต้องเชื่อมช่องว่างระหว่างคอนเทนเนอร์แสดงผลเว็บของ WebKit และวงจรการนำทางของ UIKit การพึ่งพานโยบายการนำทางเริ่มต้นอาจทำให้การส่งต่อข้อมูลไม่ราบรื่นเมื่อต้องการตรรกะการกำหนดเส้นทางเฉพาะของแอปพลิเคชัน
ด้วยการใช้งาน WKNavigationDelegate ที่แข็งแกร่งซึ่งตรวจสอบขอบเขตเฟรม, บังคับใช้นโยบายการเปิดลิงก์ที่ปลอดภัยสำหรับการส่งต่อภายนอก, แยกวิเคราะห์โดเมนภายในผ่านเครื่องมือตรวจสอบเส้นทางที่เข้มงวด และส่งต่อเป้าหมายภายนอกไปยัง UIApplication.shared.open อย่างปลอดภัย ทีมวิศวกรจะสามารถควบคุมการนำทางในขณะที่ป้องกันการโจมตีแบบ iframe ได้
หากต้องการสำรวจสถาปัตยกรรมการกำหนดเส้นทางพารามิเตอร์และ Deep Linking สำหรับ iOS โปรดดู เอกสารประกอบการรวม SDK
เนื้อหาที่เกี่ยวข้อง
-
แนวคิด: iOS WebView Routing, Universal Links Interception, WKNavigationDelegate, Frame Boundary Isolation
-
เทคโนโลยี: Apple WebKit, iOS UIKit, WKWebView, OpoInstall iOS SDK
-
มาตรฐาน: IETF RFC 3986 Uniform Resource Identifier, Apple Associated Domains Specification, OWASP Mobile Application Security Testing Guide (MASTG)
-
API:
WKNavigationDelegate.decidePolicyForNavigationAction,WKNavigationAction.sourceFrame,UIApplication.shared.open -
เอกสารอย่างเป็นทางการและการอ้างอิง:
Share this article



