Giới thiệu dự án

Trong kỷ nguyên chuyển đổi số, ứng dụng di động đã trở thành phương tiện thiết yếu trong đời sống hàng ngày của hàng tỷ người dùng trên toàn cầu. Theo báo cáo State of Mobile 2023 từ data.ai, người dùng toàn cầu đã thiết lập kỷ lục với 255 tỷ lượt tải xuống ứng dụng di động, tương đương hơn 485.000 lượt tải mỗi phút, với tổng chi tiêu quảng cáo di động chạm mốc 362 tỷ USD. Song song với sự bùng nổ về số lượng người dùng (đạt hơn 7 tỷ thiết bị theo Statista), các ứng dụng di động ngày càng nắm giữ nhiều dữ liệu đặc biệt nhạy cảm: thông tin định danh cá nhân (PII), tài khoản ngân hàng, thẻ tín dụng, và giao dịch tài chính. Điều này biến ứng dụng di động thành mục tiêu tấn công hàng đầu của các tác nhân đe dọa trên không gian mạng.

Để bảo vệ tính bí mật và toàn vẹn của dữ liệu trên đường truyền, kỹ thuật SSL Pinning (Certificate Pinning) được triển khai rộng rãi như một lớp phòng thủ cửa ngõ (First Line of Defense) nhằm triệt tiêu hoàn toàn nguy cơ tấn công trung gian (Man-in-the-Middle - MitM). Tuy nhiên, cơ chế bảo vệ nghiêm ngặt này lại đặt ra thách thức lớn đối với các chuyên gia bảo mật và kiểm thử viên xâm nhập (Penetration Tester) khi thực hiện đánh giá an toàn thông tin (DAST / Dynamic Application Security Testing). Đặc biệt, vấn đề trở nên phức tạp gấp bội trên các ứng dụng phát triển bằng Flutter Framework – SDK đa nền tảng phổ biến nhất hiện nay.

+-------------------------------------------------------------------------------+
|                      BÀI TOÁN BẢO MẬT & ĐÁNH GIÁ AN TOÀN                      |
+-------------------------------------------------------------------------------+
|  [Ứng dụng Flutter] ---> [BoringSSL Engine] ---> [Tự chứa Root Certificate]   |
|         |                        |                                            |
|         v                        v                                            |
|  Không nhận System CA      Bỏ qua Proxy OS         Lỗi TLS Handshake          |
|  (User/System Store)     (dart:io Library)       (Remote Host Terminated)     |
+-------------------------------------------------------------------------------+

Vấn đề cốt lõi (Problem Statement)

Flutter Framework (sử dụng ngôn ngữ lập trình Dart) sở hữu kiến trúc mạng và cơ chế thực thi AOT (Ahead-of-Time) hoàn toàn khác biệt so với ứng dụng native (Java/Kotlin trên Android hay Swift/Objective-C trên iOS):

  1. Không sử dụng Trust Store của hệ điều hành: Flutter không tin tưởng các CA (Certificate Authority) được người dùng hoặc hệ thống cài đặt trong Android Trust Store. Thay vào đó, Flutter Engine tích hợp sẵn một bundle chứng chỉ gốc (dart-lang/root_certificates).
  2. Bỏ qua cấu hình System Proxy: Thư viện dart:io của Dart xử lý kết nối HTTP/HTTPS độc lập, không tự động nhận proxy được thiết lập qua Wi-Fi Settings của hệ điều hành mà dựa vào phương thức findProxyFromEnvironment.
  3. Mã máy biên dịch tĩnh (AOT Native Binary): Flutter biên dịch mã nguồn Dart và các thư viện liên quan thành thư viện native libflutter.so, nhúng thư viện mật mã BoringSSL của Google. Các công cụ hooking tầng Java (như Xposed Framework, JustTrustMe) hoàn toàn vô hiệu.

Hệ quả là khi kiểm thử viên chuyển tiếp lưu lượng qua các Interception Proxy (như Burp Suite), ứng dụng lập tức trả về lỗi bắt tay TLS (Handshake Error: Connection Verify Failed hoặc Remote host terminated the handshake), ngăn chặn toàn bộ quá trình giám sát và kiểm thử bảo mật tầng ứng dụng.

Mục tiêu của dự án (Project Objectives)

Đề tài "Nghiên cứu phương pháp vượt qua SSL Pinning trên ứng dụng di động sử dụng Flutter Framework" được thực hiện bởi sinh viên Vũ Lan Phương (ngành An toàn thông tin, Học viện Công nghệ Bưu chính Viễn thông) dưới sự hướng dẫn của TS. Nguyễn Ngọc Điệp, tập trung vào 5 mục tiêu cụ thể:

  1. Nghiên cứu toàn diện kiến trúc mạng, cơ chế biên dịch AOT và quy trình xử lý phiên TLS/SSL của Dart/Flutter Engine kết hợp thư viện BoringSSL.
  2. Phân tích nguyên nhân gốc rễ khiến các giải pháp bypass SSL Pinning truyền thống thất bại trên nền tảng Flutter.
  3. Xây dựng giải pháp kỹ thuật kết hợp: Ứng dụng công cụ dịch ngược (Ghidra) để phân tích tĩnh file nhị phân libflutter.so, xác định chính xác địa chỉ offset của hàm xác thực chứng chỉ ssl_crypto_x509_session_verify_cert_chain.
  4. Phát triển kịch bản Dynamic Instrumentation (Frida): Can thiệp vào runtime bộ nhớ của tiến trình Flutter, thao túng giá trị trả về của hàm xác thực chuỗi chứng chỉ nhằm cưỡng bức trả về trạng thái hợp lệ (ssl_verify_ok).
  5. Thiết lập quy trình định tuyến lưu lượng toàn diện: Giải quyết bài toán bắt gói tin dart:io thông qua cờ -http-proxy trên Android Emulator và đẩy chứng chỉ Burp Suite CA vào phân vùng hệ thống (System CA Store).

Phân tích và thiết kế giải pháp

Phân tích hiện trạng

Hiện nay, các phương pháp vượt qua SSL Pinning trên Android chủ yếu được thiết kế cho các framework native hoặc hybrid dựa trên Webview/Java Networking. Khi áp dụng vào Flutter, hiệu quả của các giải pháp truyền thống bị triệt tiêu hoàn toàn.

Phương pháp Cơ chế hoạt động Hiệu quả trên Native (Java/Kotlin) Hiệu quả trên Flutter Framework Hạn chế chính
Cài đặt System CA Chuyển Burp CA vào /system/etc/security/cacerts Thành công với ứng dụng không pin Thất bại Flutter không tham chiếu kho chứng chỉ của OS
Xposed / JustTrustMe Hook vào các class TrustManagerImpl, OkHttpClient tầng Java Thành công Hoàn toàn vô hiệu Flutter không sử dụng framework Java/Android SDK Networking
Universal Frida Scripts Hook các API OpenSSL / Android CA chuẩn Thành công với đa số app Thất bại BoringSSL được compile tĩnh vào libflutter.so, địa chỉ hàm thay đổi theo build
Ghidra Binary Analysis + Frida Hooking Định vị offset hàm BoringSSL trong libflutter.so và hook native Thành công Thành công 100% Yêu cầu kỹ năng dịch ngược và phân tích mã máy

Phân loại yêu cầu kỹ thuật (MoSCoW Prioritization)

  • Must Have: Định vị chính xác offset của hàm ssl_crypto_x509_session_verify_cert_chain trong libflutter.so; Bắt và giải mã thành công 100% lưu lượng HTTPS/REST API trên Burp Suite.
  • Should Have: Giải pháp tương thích tốt trên môi trường Android Emulator (Android 11/12, API Level 31); Hỗ trợ kiến trúc nhị phân x86_64 và ARM64.
  • Could Have: Tự động hóa quy trình phân tích offset thông qua script quét mẫu bytecode (Pattern Matching / Signature Scanning).
  • Won't Have: Can thiệp trực tiếp vào mã nguồn (Whitebox Recompilation) hoặc can thiệp sâu vào kernel Android.
                    +-------------------------------------------------------+
                    |           KIẾN TRÚC TỔNG THỂ GIẢI PHÁP                |
                    +-------------------------------------------------------+
                                               |
         +-------------------------------------+-------------------------------------+
         |                                                                           |
         v                                                                           v
+---------------------------------+                               +---------------------------------+
|   PHÂN TÍCH TĨNH (STATIC ANALYSIS) |                               | DYNAMIC HOOKING & INTERCEPTION  |
+---------------------------------+                               +---------------------------------+
| 1. Trích xuất APK -> libflutter.so |                               | 1. Khởi chạy Android Emulator   |
| 2. Nạp vào Ghidra Disassembler  |                               |    (Flag: -http-proxy <IP:Port>)|
| 3. Tìm chuỗi: "ssl_x509.cc"     |                               | 2. Cài Magisk + Burp Suite CA   |
| 4. Xác định hàm 3 tham số:      |                               | 3. Chạy Frida Server trên máy ảo|
|    ssl_crypto_x509_session_...  |                               | 4. Inject JS Script qua Frida   |
| 5. Tính toán Target Offset:     |                               |    => Ghi đè hàm xác thực       |
|    Func_Address - Base_Address  |                               | 5. Giám sát Traffic HTTPS trên  |
|    (0x50e710 - 0x100000)        |                               |    Burp Suite Dashboard         |
+---------------------------------+                               +---------------------------------+

Thiết kế hệ thống và Công nghệ sử dụng

Giải pháp kết hợp chặt chẽ giữa các công cụ phân tích nhị phân và môi trường giả lập kiểm thử chuyên dụng:

  • Môi trường phân tích: Ghidra v10.x (Bộ công cụ dịch ngược mã nguồn mở phát triển bởi NSA).
  • Nền tảng can thiệp bộ nhớ: Frida Framework v16.x (Dynamic Binary Instrumentation toolkit), bao gồm frida-tools trên máy trạm và frida-server trên thiết bị di động.
  • Proxy chặn bắt gói tin: Burp Suite Community / Professional Edition v2023.3+.
  • Môi trường thử nghiệm: Android Studio Emulator chạy Android 12 (API level 31, Image google_apis_playstore/x86_64), root bằng Magisk (systemless root).
  • Công cụ cầu nối: Android Debug Bridge (adb) thuộc Android SDK Platform-Tools.

Implementation và kết quả

Quy trình triển khai chi tiết

Bước 1: Xử lý bài toán cấu hình Proxy trên Flutter

Do thư viện dart:io không tuân thủ cấu hình Proxy mặc định trên Wi-Fi Android, giải pháp là ép toàn bộ lưu lượng của máy ảo đi qua Proxy ở tầng mạng cấp thấp (Network Layer) khi khởi động emulator bằng dòng lệnh:

emulator -avd Pixel_6a_API_31 -http-proxy 192.168.1.116:8080 -writable-system

Lệnh này đảm bảo mọi truy vấn TCP/HTTP từ emulator đều được định tuyến trực tiếp đến cổng 8080 của Burp Suite.

Bước 2: Phân tích mã nguồn BoringSSL trong Flutter Engine

Trong mã nguồn BoringSSL (handshake.cc), quá trình xác thực chứng chỉ TLS được điều khiển bởi logic:

// Logic xác thực chuỗi chứng chỉ SSL trong BoringSSL
if (hs->config->custom_verify_callback != nullptr) {
    ret = hs->config->custom_verify_callback(ssl, &alert);
} else {
    ret = ssl_crypto_x509_session_verify_cert_chain(hs->new_session.get(), hs, &alert);
}

// Nếu kết quả trả về không hợp lệ, hệ thống bắn lỗi cảnh báo
if (ret == ssl_verify_invalid) {
    OPENSSL_PUT_ERROR(SSL, SSL_R_CERTIFICATE_VERIFY_FAILED);
    ssl_send_alert(ssl, SSL3_AL_FATAL, alert);
}

Mục tiêu kỹ thuật: Cần ép hàm ssl_crypto_x509_session_verify_cert_chain luôn trả về giá trị ssl_verify_ok (tương đương 0x1 hoặc true).

+-----------------------------------------------------------------------------------+
|               PHÂN TÍCH NHỊ PHÂN TRÊN GHIDRA (DISASSEMBLY VIEW)                   |
+-----------------------------------------------------------------------------------+
|  Address   | Machine Code (Hex)  | Assembly Instruction                           |
|------------|---------------------|------------------------------------------------|
|  0050e710  | 55                  | PUSH RBP                                       |
|  0050e711  | 41 57               | PUSH R15                                       |
|  0050e713  | 41 56               | PUSH R14                                       |
|  0050e715  | 41 55               | PUSH R13                                       |
|  0050e717  | 41 54               | PUSH R12                                       |
|  0050e71a  | 48 83 ec 38         | SUB RSP, 0x38                                  |
|  0050e71e  | c6 02 50            | MOV byte ptr [RDX], 0x50                       |
|  0050e728  | 48 85 ed            | TEST RBP, RBP                                  |
+-----------------------------------------------------------------------------------+
|  Ghidra Base Address : 0x100000                                                   |
|  Function Address    : 0x50e710                                                   |
|  CALCULATED OFFSET   : 0x50e710 - 0x100000 = 0x40e710                             |
+-----------------------------------------------------------------------------------+

Bước 3: Xác định Offset bằng Ghidra Disassembler

  1. Trích xuất file libflutter.so từ gói tin APK mục tiêu (chuyển đổi định dạng .apk sang .zip và giải nén thư mục lib/x86_64/).
  2. Nạp libflutter.so vào Ghidra, tiến hành phân tích chuỗi ký tự (Search Strings) với từ khóa ssl_x509.cc.
  3. Kết quả trả về 10 vị trí chuỗi mã nguồn liên quan đến ./third_party/boringssl/src/ssl/ssl_x509.cc.
  4. Lần theo các tham chiếu chéo (XREFs), xác định hàm nhận 3 tham số (param_1, param_2, param_3) tương ứng với ssl_crypto_x509_session_verify_cert_chain tại địa chỉ 0x0050e710.
  5. Tính toán độ dời tương đối (Offset): $$\text{Target Offset} = \text{Function Address} - \text{Ghidra Base Address} = \text{0x50e710} - \text{0x100000} = \text{0x40e710}$$

Bước 4: Xây dựng và thực thi kịch bản Frida Hooking

Sử dụng mã JavaScript can thiệp runtime qua Frida để ghi đè giá trị trả về của hàm tại offset 0x40e710:

// Script Frida hook bypass SSL Pinning Flutter Engine
function hook_flutter_ssl() {
    var libflutter = Process.findModuleByName("libflutter.so");
    if (!libflutter) {
        console.log("[-] libflutter.so chua duoc nap. Dang cho...");
        setTimeout(hook_flutter_ssl, 500);
        return;
    }
    
    // Offset da duoc tinh toan tu Ghidra
    var offset = 0x40e710;
    var targetAddress = libflutter.base.add(offset);
    
    console.log("[+] Tim thay libflutter.so tai: " + libflutter.base);
    console.log("[+] Dang hook ham xac thuc tai dia chi: " + targetAddress);
    
    Interceptor.attach(targetAddress, {
        onEnter: function(args) {
            console.log("[*] Dang goi ham ssl_crypto_x509_session_verify_cert_chain");
        },
        onLeave: function(retval) {
            console.log("[*] Gia tri tra ve ban dau: " + retval);
            // Cuong buc tra ve gia tri 0x1 (ssl_verify_ok)
            retval.replace(0x1);
            console.log("[+] Da ghi de gia tri tra ve thanh: 0x1 (ssl_verify_ok)");
        }
    });
}

setImmediate(hook_flutter_ssl);

Khởi chạy Frida để tiêm script vào tiến trình ứng dụng:

frida -U -f com.example.flutter_test_app -l hook_flutter.js --no-pause

Kết quả thử nghiệm và Đánh giá thực nghiệm

Thử nghiệm được tiến hành trên ứng dụng mẫu NVISO Flutter TLS Verification App.

+-------------------------------------------------------------------------------+
|                       KẾT QUẢ ĐÁNH GIÁ THỰC NGHIỆM                            |
+-------------------------------------------------------------------------------+
| Trạng thái trước can thiệp:                                                  |
|   - HTTP Request   : [ SUCCESS 200 OK ]                                       |
|   - HTTPS Request  : [ ERROR - Connection Refused / Handshake Failed ]        |
|   - Pinned Request : [ ERROR - TLS Negotiation Terminated ]                   |
|                                                                               |
| Trạng thái sau khi Hook Frida (Offset 0x40e710):                              |
|   - HTTP Request   : [ SUCCESS 200 OK ]                                       |
|   - HTTPS Request  : [ SUCCESS 200 OK ]  <--- Bắt trọn vẹn Header & Body      |
|   - Pinned Request : [ SUCCESS 200 OK ]  <--- Bypass thành công 100%          |
|                                                                               |
| Logcat Burp Suite:                                                            |
|   HTTP/2 200 OK (User-Agent: Dart/2.x; Host: play.googleapis.com)             |
+-------------------------------------------------------------------------------+
  • Khả năng chặn bắt: 100% lưu lượng HTTPS và Pinned Requests đều được chuyển tiếp thành công qua Burp Suite Proxy mà không làm sập ứng dụng.
  • Thời gian thực thi: Quá trình phân tích offset trên Ghidra chỉ mất 3 - 5 phút; thời gian hooking của Frida diễn ra gần như tức thì (< 1.5ms mỗi handshake).
  • Độ ổn định: Không xuất hiện hiện tượng memory leak hay race condition trong các luồng isolate của Dart.

Đổi mới và đóng góp

  1. Giải mã rào cản kỹ thuật đặc thù: Đề tài đã làm sáng tỏ cấu trúc nội bộ của Flutter Engine và thư viện BoringSSL trên nền tảng Dart AOT, giải quyết triệt để bài toán "hộp đen nhị phân" vốn gây bế tắc cho các phương pháp phân tích ứng dụng di động thông thường.
  2. Phương pháp luận tối ưu cho Blackbox/Graybox Pentest: Không đòi hỏi quyền truy cập mã nguồn Dart, không cần can thiệp decompile/repack APK (tránh kích hoạt cơ chế phát hiện sửa đổi chữ ký/Integrity Protection).
  3. Hiệu quả vượt trội so với các giải pháp khác:
    • So với việc biên dịch lại Flutter Engine (Rebuilding Custom Engine): Tiết kiệm 4 - 6 giờ biên dịch mã nguồn C++, giảm thiểu dung lượng lưu trữ và loại bỏ các lỗi không tương thích phiên bản.
    • So với các script Frida Generic: Loại bỏ tỷ lệ lỗi 100% của các script Java-hooking trên Flutter, nâng tỷ lệ thành công lên 100%.
  4. Quy trình chuẩn hóa có thể tái lập: Cung cấp bộ quy trình 5 bước mạch lạc, cho phép các kỹ sư an ninh mạng dễ dàng áp dụng trên bất kỳ phiên bản Flutter và kiến trúc CPU nào (x86, x86_64, ARM, ARM64).

Ứng dụng thực tế và triển khai

Kịch bản áp dụng thực tiễn

  • Kiểm thử xâm nhập ứng dụng Ngân hàng và Ví điện tử: Đánh giá an toàn các API giao dịch tài chính, xác thực OIDC/OAuth2, phát hiện các lỗ hổng Logic, IDOR, và Broken Object Level Authorization (BOLA).
  • Phân tích mã độc di động (Mobile Malware Forensics): Hỗ trợ các kỹ sư DFIR/SOC giải mã lưu lượng C2 (Command & Control) ẩn sau các ứng dụng độc hại được ngụy trang dưới dạng Flutter app.
  • Kiểm thử chất lượng phần mềm (QA/QC Performance & Security Testing): Cho phép đội ngũ QA theo dõi và phân tích chi tiết payload API trong môi trường Staging/UAT.

Hướng dẫn quy trình triển khai chuẩn (Deployment Checklist)

  1. Thiết lập thiết bị: Cài đặt Magisk trên Android Emulator API 31, cấp quyền Superuser cho adb shell.
  2. Cài đặt chứng chỉ Burp CA: 
    openssl x509 -inform DER -in cacert.der -out cacert.pem
openssl x509 -inform PEM -subject_hash_old -in cacert.pem | head -1
mv cacert.pem 9a5ba575.0
adb push 9a5ba575.0 /system/etc/security/cacerts/
  3. Chạy Emulator với Proxy Flag: 
    emulator -avd <Device_Name> -http-proxy <Proxy_IP>:<Proxy_Port> -writable-system
  4. Phân tích Offset libflutter.so và thực thi Frida: Chạy kịch bản hooking để mở cổng giám sát dữ liệu an toàn.

Hạn chế và hướng phát triển

Hạn chế kỹ thuật

  • Sự thay đổi Offset theo từng phiên bản: Mỗi bản phát hành Flutter Engine hoặc mỗi phiên bản NDK/Clang compiler khác nhau sẽ tạo ra offset hàm ssl_crypto_x509_session_verify_cert_chain khác nhau, đòi hỏi phải phân tích tĩnh lại file libflutter.so.
  • Cơ chế chống can thiệp nâng cao (Anti-Hooking / Anti-Frida): Một số ứng dụng tài chính tích hợp các giải pháp bảo vệ chuyên sâu (như RASP, Obfuscator-LLVM, Frida Detection) có thể phát hiện và đóng tiến trình khi Frida Server can thiệp.

Hướng nghiên cứu tiếp theo

  • Phát triển Plugin Ghidra / Frida Tự động hóa: Tự động quét mẫu byte (AOB / Pattern Scanning) để xác định signature của hàm xác thực trong runtime mà không cần tìm offset thủ công.
  • Mở rộng sang nền tảng iOS: Nghiên cứu kỹ thuật hooking trên binary Mach-O (App.framework / Flutter.framework) đối với các thiết bị iPhone/iPad đã Jailbreak.

Đối tượng hưởng lợi

+--------------------------------------------------------------------------------+
|                           ĐỐI TƯỢNG HƯỞNG LỢI                                  |
+--------------------------------------------------------------------------------+
|  [Sinh viên / Học viên ATTT]   --> Tài liệu tham khảo chuẩn mực về Native Hook |
|  [Chuyên gia Penetration Test] --> Bộ công cụ & quy trình vượt SSL Pinning tối ưu |
|  [Nhà phát triển Flutter]      --> Nắm bắt nguy cơ, củng cố phòng thủ RASP/Code|
|  [Doanh nghiệp & Tổ chức]      --> Nâng cao năng lực đánh giá bảo mật di động  |
+--------------------------------------------------------------------------------+
  • Sinh viên và Học viên ngành An toàn thông tin: Nguồn tài liệu học thuật và thực nghiệm giá trị cao về kỹ thuật dịch ngược nhị phân (Reverse Engineering), Native Hooking và kiến trúc mạng di động.
  • Chuyên gia kiểm thử bảo mật (Pentester / Red Team): Sở hữu giải pháp chuẩn hóa, tin cậy để vượt qua rào cản SSL Pinning trên Flutter, rút ngắn thời gian thiết lập môi trường kiểm thử từ nhiều ngày xuống dưới 15 phút.
  • Nhà phát triển ứng dụng di động (Flutter Developers): Hiểu rõ cơ chế tấn công và can thiệp bộ nhớ để chủ động triển khai các biện pháp phòng thủ đa tầng: tích hợp RASP (Runtime Application Self-Protection), kiểm tra tính toàn vẹn bộ nhớ và làm rối mã nguồn (Code Obfuscation).

Câu hỏi thường gặp

1. Yêu cầu phần cứng và phần mềm tối thiểu để triển khai giải pháp là gì?

Máy tính cần tối thiểu 8GB RAM (khuyến nghị 16GB), CPU hỗ trợ ảo hóa (VT-x/AMD-V), cài đặt sẵn JDK 11+, Python 3.8+, Android Studio (với SDK Platform-Tools), Ghidra 10.x, Frida-tools và Burp Suite.

2. Tại sao các công cụ tự động như JustTrustMe hoặc SSLUnpinning không hoạt động trên Flutter?

Do các công cụ này được thiết kế để hook vào tầng Java Virtual Machine / Android Framework API (javax.net.ssl.*). Trong khi đó, Flutter biên dịch mã máy AOT trực tiếp và sử dụng thư viện BoringSSL viết bằng C/C++ nhúng trong libflutter.so, hoàn toàn độc lập với runtime Java.

3. Có thể tự động hóa việc tìm kiếm offset cho nhiều ứng dụng Flutter khác nhau không?

Hoàn toàn có thể. Bằng cách sử dụng các script Python kết hợp Capstone Disassembler hoặc Frida Pattern Scanning để tìm chuỗi byte signature đại diện cho đoạn mã ASM khởi đầu hàm ssl_crypto_x509_session_verify_cert_chain (như chuỗi opcode 55 41 57 41 56 41 55 41 54 48 83 ec), hệ thống có thể tự động hook mà không cần mở Ghidra.

4. Giải pháp này có áp dụng được trên thiết bị thật (Physical Device) không?

Có. Giải pháp áp dụng hoàn hảo trên thiết bị Android thật đã được Root (qua Magisk) và cài đặt frida-server. Đối với cấu hình proxy, có thể sử dụng các ứng dụng như ProxyDroid kết hợp iptables để điều hướng lưu lượng.

5. Chi phí triển khai và hiệu quả đầu tư (ROI) của phương pháp này như thế nào?

Giải pháp sử dụng 100% công cụ mã nguồn mở và phiên bản miễn phí (Ghidra, Frida, Magisk, Burp Suite Community), giúp doanh nghiệp và chuyên gia tiết kiệm hàng ngàn USD chi phí bản quyền phần mềm trong khi vẫn đảm bảo hiệu năng kiểm thử bảo mật chuyên sâu.

Kết luận

Đề tài tốt nghiệp "Nghiên cứu phương pháp vượt qua SSL Pinning trên ứng dụng di động sử dụng Flutter Framework" của sinh viên Vũ Lan Phương đã giải quyết thành công một trong những bài toán phức tạp và cấp thiết nhất trong lĩnh vực kiểm thử bảo mật ứng dụng di động hiện đại. Bằng việc kết hợp nhuần nhuyễn giữa kỹ thuật phân tích tĩnh nhị phân trên Ghidra và can thiệp động bộ nhớ với Frida, nghiên cứu đã xây dựng thành công quy trình chuẩn hóa giúp vô hiệu hóa cơ chế xác thực chứng chỉ BoringSSL trên Flutter Engine mà không cần mã nguồn.

Kết quả của đề tài không chỉ khẳng định năng lực nghiên cứu ứng dụng chuyên sâu của sinh viên Khoa An toàn thông tin - Học viện Công nghệ Bưu chính Viễn thông, mà còn đóng góp một phương pháp luận thực tiễn, tin cậy cho cộng đồng an ninh mạng trong việc nâng cao chất lượng và độ an toàn của hệ sinh thái ứng dụng di động Flutter tại Việt Nam.