@sun-asterisk/sunlint 1.3.48 → 1.3.49

package/skill-assets/sunlint-code-quality/rules/swift/S051-token-expiry.md

@@ -0,0 +1,134 @@
+---
+title: Xử lý token hết hạn và implement silent refresh - không để user bị logout đột ngột
+impact: MEDIUM
+impactDescription: Không kiểm tra expiry trước khi dùng token dẫn đến 401 errors gây UX xấu, hoặc ngược lại không refresh token đúng cách dẫn đến sử dụng token đã hết hạn mà không detect.
+tags: swift, ios, token-expiry, refresh-token, jwt, oauth, api-security
+---
+
+## Xử lý token hết hạn và implement silent refresh - không để user bị logout đột ngột
+
+Kiểm tra JWT expiry (`exp` claim) trước mỗi request quan trọng. Implement silent refresh: khi access token sắp hết hạn (ví dụ còn <5 phút), dùng refresh token để lấy token mới tự động. Khi refresh token cũng hết hạn, mới force logout.
+
+**Incorrect (không kiểm tra expiry):**
+
+```swift
+import Foundation
+
+class APIClient {
+    // !! Dùng token mà không kiểm tra còn hạn không
+    func fetchUserProfile() async throws -> UserProfile {
+        let token = try KeychainService.readToken(key: "access_token")
+        var request = URLRequest(url: URL(string: "https://api.example.com/profile")!)
+        request.setValue("Bearer \(token)", forHTTPHeaderField: "Authorization")
+        let (data, _) = try await URLSession.shared.data(for: request)
+        return try JSONDecoder().decode(UserProfile.self, from: data)
+        // Nếu 401 → crash hoặc hiển thị error mà không cố refresh
+    }
+}
+```
+
+**Correct (proactive token check và silent refresh):**
+
+```swift
+import Foundation
+
+struct JWTTokenManager {
+    // Parse JWT claims mà không verify signature (signature verify ở server)
+    static func expiryDate(from jwtToken: String) -> Date? {
+        let parts = jwtToken.components(separatedBy: ".")
+        guard parts.count == 3 else { return nil }
+
+        var base64 = parts[1]
+        // Pad base64
+        let padded = base64.count % 4 == 0 ? base64 : base64 + String(repeating: "=", count: 4 - base64.count % 4)
+        guard let payloadData = Data(base64Encoded: padded),
+              let payload = try? JSONDecoder().decode([String: AnyCodable].self, from: payloadData),
+              let exp = payload["exp"]?.value as? TimeInterval else { return nil }
+        return Date(timeIntervalSince1970: exp)
+    }
+
+    static func isTokenExpiringSoon(_ token: String, withinSeconds: TimeInterval = 300) -> Bool {
+        guard let expiry = expiryDate(from: token) else { return true }
+        return expiry.timeIntervalSinceNow < withinSeconds
+    }
+}
+
+actor TokenRefreshManager {
+    private var refreshTask: Task<String, Error>?
+
+    // SAFE: Single refresh task để tránh thundering herd
+    func getValidAccessToken() async throws -> String {
+        let currentToken = try KeychainService.readToken(key: "access_token")
+
+        // Nếu token còn hạn đủ dùng, return luôn
+        if !JWTTokenManager.isTokenExpiringSoon(currentToken) {
+            return currentToken
+        }
+
+        // Nếu đang refresh, chờ task hiện tại
+        if let existing = refreshTask {
+            return try await existing.value
+        }
+
+        // Tạo refresh task mới
+        let task = Task<String, Error> {
+            defer { self.refreshTask = nil }
+            return try await performTokenRefresh()
+        }
+        self.refreshTask = task
+        return try await task.value
+    }
+
+    private func performTokenRefresh() async throws -> String {
+        guard let refreshToken = try? KeychainService.readToken(key: "refresh_token") else {
+            throw TokenError.noRefreshToken
+        }
+
+        var request = URLRequest(url: URL(string: "https://api.example.com/auth/refresh")!)
+        request.httpMethod = "POST"
+        request.httpBody = try? JSONEncoder().encode(["refresh_token": refreshToken])
+        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
+
+        let (data, response) = try await URLSession.shared.data(for: request)
+        guard let httpResponse = response as? HTTPURLResponse else {
+            throw TokenError.networkError
+        }
+
+        if httpResponse.statusCode == 401 {
+            // Refresh token hết hạn → force logout
+            throw TokenError.sessionExpired
+        }
+
+        let tokenResponse = try JSONDecoder().decode(TokenResponse.self, from: data)
+        try KeychainService.saveToken(tokenResponse.accessToken, key: "access_token")
+        if let newRefresh = tokenResponse.refreshToken {
+            try KeychainService.saveToken(newRefresh, key: "refresh_token")
+        }
+        return tokenResponse.accessToken
+    }
+}
+
+class APIClient {
+    private let tokenManager = TokenRefreshManager()
+
+    // SAFE: Auto-refresh trước khi dùng token
+    func fetchUserProfile() async throws -> UserProfile {
+        do {
+            let token = try await tokenManager.getValidAccessToken()
+            var request = URLRequest(url: URL(string: "https://api.example.com/profile")!)
+            request.setValue("Bearer \(token)", forHTTPHeaderField: "Authorization")
+            let (data, _) = try await URLSession.shared.data(for: request)
+            return try JSONDecoder().decode(UserProfile.self, from: data)
+        } catch TokenError.sessionExpired {
+            // Xử lý logout khi session thực sự hết hạn
+            await AuthManager.shared.logout()
+            throw TokenError.sessionExpired
+        }
+    }
+}
+
+enum TokenError: Error { case noRefreshToken, networkError, sessionExpired }
+struct TokenResponse: Decodable { let accessToken: String; let refreshToken: String? }
+```
+
+**Tools:** JWTDecode.swift (library), OWASP MASVS-AUTH-3, OAuth 2.0 RFC 6749

package/skill-assets/sunlint-code-quality/rules/swift/S053-jwt-validation.md

@@ -0,0 +1,139 @@
+---
+title: Validate JWT đầy đủ - kiểm tra signature, issuer, audience và expiry
+impact: CRITICAL
+impactDescription: Chấp nhận JWT chỉ dựa vào decode mà không verify signature cho phép attacker forge token với bất kỳ claims nào. Missing audience/issuer check cho phép token của service khác được dùng.
+tags: swift, ios, jwt, token-validation, signature, claims, security
+---
+
+## Validate JWT đầy đủ - kiểm tra signature, issuer, audience và expiry
+
+JWT phải được validate server-side. Client-side chỉ nên đọc claims để biết expiry, user ID cho UX - không dùng claims để ra quyết định security. Khi nhận JWT từ server, phải đảm bảo server đã validate đầy đủ trước khi trust bất kỳ claim nào.
+
+**Incorrect (decode JWT mà không verify, dùng claims cho security decision):**
+
+```swift
+import Foundation
+
+struct JWTDecoder {
+    // !! Decode không verify signature
+    static func decode(token: String) -> [String: Any]? {
+        let parts = token.components(separatedBy: ".")
+        guard parts.count == 3 else { return nil }
+        var base64 = parts[1]
+        let padded = base64 + String(repeating: "=", count: (4 - base64.count % 4) % 4)
+        guard let data = Data(base64Encoded: padded) else { return nil }
+        return try? JSONSerialization.jsonObject(with: data) as? [String: Any]
+    }
+}
+
+class AuthorizationChecker {
+    // !! Dùng JWT claims (không verify) để kiểm tra quyền - attacker có thể forge!
+    func isAdmin(token: String) -> Bool {
+        let claims = JWTDecoder.decode(token: token)
+        return claims?["role"] as? String == "admin"  // Không verify signature!
+    }
+
+    // !! Không check issuer/audience - token của service khác có thể dùng được
+    func validateToken(_ token: String) -> Bool {
+        guard let claims = JWTDecoder.decode(token: token),
+              let exp = claims["exp"] as? TimeInterval else { return false }
+        return Date().timeIntervalSince1970 < exp  // Chỉ check expiry!
+        // Không check: iss (issuer), aud (audience), alg, nbf
+    }
+}
+```
+
+**Correct (validate server-side, client chỉ đọc claims cho UX):**
+
+```swift
+import Foundation
+
+// SAFE: Server-side validation là bắt buộc. Client chỉ đọc non-security claims.
+struct JWTClaims: Decodable {
+    let sub: String       // Subject (user ID)
+    let exp: TimeInterval // Expiry
+    let iat: TimeInterval // Issued at
+    let iss: String       // Issuer - phải match expected value
+    let aud: String       // Audience - phải match app's client_id
+    let jti: String?      // JWT ID - để detect reuse nếu cần
+}
+
+struct ClientSideJWTReader {
+    private let expectedIssuer: String
+    private let expectedAudience: String
+
+    init(issuer: String, audience: String) {
+        self.expectedIssuer = issuer
+        self.expectedAudience = audience
+    }
+
+    // Client-side decode CHỈ để đọc UX data (user ID, expiry)
+    // KHÔNG dùng cho security decision - server phải verify signature
+    func readClaimsForUX(from token: String) throws -> JWTClaims {
+        let parts = token.components(separatedBy: ".")
+        guard parts.count == 3 else { throw JWTError.malformedToken }
+
+        let base64 = parts[1]
+        let padded = base64 + String(repeating: "=", count: (4 - base64.count % 4) % 4)
+        guard let data = Data(base64Encoded: padded) else { throw JWTError.malformedToken }
+
+        let decoder = JSONDecoder()
+        let claims = try decoder.decode(JWTClaims.self, from: data)
+
+        // Validate claims cơ bản cho UX (không thay thế server validation)
+        guard claims.iss == expectedIssuer else {
+            throw JWTError.invalidIssuer(claims.iss)
+        }
+        guard claims.aud == expectedAudience else {
+            throw JWTError.invalidAudience(claims.aud)
+        }
+        guard Date().timeIntervalSince1970 < claims.exp else {
+            throw JWTError.tokenExpired
+        }
+
+        // NOTE: Signature chưa được verify ở đây!
+        // Tất cả API request phải gửi token để SERVER verify signature
+        return claims
+    }
+}
+
+class AuthManager {
+    private let jwtReader = ClientSideJWTReader(
+        issuer: "https://auth.example.com",
+        audience: "com.example.myapp"
+    )
+
+    // SAFE: Server verify full JWT, client chỉ dùng userId từ claims để hiển thị UI
+    func setupAfterLogin(accessToken: String) throws {
+        let claims = try jwtReader.readClaimsForUX(from: accessToken)
+        // Chỉ dùng sub (user ID) để fetch profile UI, không phải security check
+        currentUserId = claims.sub
+        tokenExpiryDate = Date(timeIntervalSince1970: claims.exp)
+    }
+
+    // SAFE: Authorization check thông qua server API, không phải local JWT claims
+    func checkAdminAccess() async throws -> Bool {
+        let token = try KeychainService.readToken(key: "access_token")
+        // Server endpoint sẽ verify JWT và check role
+        var request = URLRequest(url: URL(string: "https://api.example.com/admin/verify")!)
+        request.setValue("Bearer \(token)", forHTTPHeaderField: "Authorization")
+        let (_, response) = try await URLSession.shared.data(for: request)
+        return (response as? HTTPURLResponse)?.statusCode == 200
+    }
+}
+
+enum JWTError: LocalizedError {
+    case malformedToken, invalidIssuer(String), invalidAudience(String), tokenExpired
+
+    var errorDescription: String? {
+        switch self {
+        case .malformedToken: return "Malformed JWT token"
+        case .invalidIssuer(let iss): return "Invalid issuer: \(iss)"
+        case .invalidAudience(let aud): return "Invalid audience: \(aud)"
+        case .tokenExpired: return "Token has expired"
+        }
+    }
+}
+```
+
+**Tools:** JWTDecode.swift, Auth0 SDK, OWASP MASVS-AUTH-1, jwt.io (debug)

package/skill-assets/sunlint-code-quality/rules/swift/S059-background-snapshot-protection.md

@@ -0,0 +1,113 @@
+---
+title: Che nội dung nhạy cảm khi app vào background để tránh lộ qua App Switcher
+impact: HIGH
+impactDescription: iOS chụp screenshot app khi vào background để hiển thị trong App Switcher. Màn hình chứa số dư tài khoản, tin nhắn riêng tư, hoặc thông tin cá nhân sẽ bị lưu trong bộ nhớ và có thể bị trích xuất từ device backup trên jailbroken device.
+tags: swift, ios, background-snapshot, app-switcher, data-privacy, ui-security, security
+---
+
+## Che nội dung nhạy cảm khi app vào background để tránh lộ qua App Switcher
+
+Khi app vào background (`applicationWillResignActive`/`sceneWillResignActive`), iOS chụp snapshot để hiển thị trong App Switcher. Phải che màn hình chứa dữ liệu nhạy cảm bằng cách thêm blur overlay hoặc splash screen trước khi app vào background.
+
+**Incorrect (không che màn hình khi vào background):**
+
+```swift
+import UIKit
+
+// !! App không làm gì khi vào background
+// Màn hình banking balance, tin nhắn, health data bị capture trong App Switcher snapshot
+@main
+class AppDelegate: UIResponder, UIApplicationDelegate {
+    // Không có xử lý background snapshot protection
+}
+
+// !! Màn hình hiển thị số dư tiền mà không bảo vệ
+class AccountBalanceViewController: UIViewController {
+    @IBOutlet weak var balanceLabel: UILabel!  // "$12,345.67" hiển thị trong snapshot!
+
+    override func viewDidLoad() {
+        super.viewDidLoad()
+        balanceLabel.text = "$12,345.67"
+        // Không register notification để hide khi background
+    }
+}
+```
+
+**Correct (blur overlay khi vào background):**
+
+```swift
+import UIKit
+
+// SAFE: Scene-based approach (iOS 13+)
+class SceneDelegate: UIResponder, UISceneDelegate {
+    private var privacyOverlay: UIView?
+
+    func sceneWillResignActive(_ scene: UIScene) {
+        addPrivacyOverlay(to: scene)
+    }
+
+    func sceneDidBecomeActive(_ scene: UIScene) {
+        removePrivacyOverlay()
+    }
+
+    private func addPrivacyOverlay(to scene: UIScene) {
+        guard let windowScene = scene as? UIWindowScene,
+              let window = windowScene.windows.first else { return }
+
+        if privacyOverlay != nil { return }  // Đã có overlay
+
+        let overlay = UIView(frame: window.bounds)
+        overlay.backgroundColor = .systemBackground
+        overlay.autoresizingMask = [.flexibleWidth, .flexibleHeight]
+
+        // Thêm logo app thay vì màn trắng để đẹp hơn
+        let imageView = UIImageView(image: UIImage(named: "AppLogo"))
+        imageView.contentMode = .scaleAspectFit
+        imageView.center = CGPoint(x: overlay.bounds.midX, y: overlay.bounds.midY)
+        overlay.addSubview(imageView)
+
+        window.addSubview(overlay)
+        privacyOverlay = overlay
+    }
+
+    private func removePrivacyOverlay() {
+        privacyOverlay?.removeFromSuperview()
+        privacyOverlay = nil
+    }
+}
+
+// SAFE: Màn hình cụ thể tự bảo vệ
+class SensitiveDataViewController: UIViewController {
+    @IBOutlet weak var balanceLabel: UILabel!
+    private var blurView: UIVisualEffectView?
+
+    override func viewDidLoad() {
+        super.viewDidLoad()
+        let nc = NotificationCenter.default
+        nc.addObserver(self, selector: #selector(appWillResignActive),
+                       name: UIApplication.willResignActiveNotification, object: nil)
+        nc.addObserver(self, selector: #selector(appDidBecomeActive),
+                       name: UIApplication.didBecomeActiveNotification, object: nil)
+    }
+
+    @objc private func appWillResignActive() {
+        let blur = UIBlurEffect(style: .systemThickMaterial)
+        let blurView = UIVisualEffectView(effect: blur)
+        blurView.frame = view.bounds
+        blurView.autoresizingMask = [.flexibleWidth, .flexibleHeight]
+        view.addSubview(blurView)
+        self.blurView = blurView
+    }
+
+    @objc private func appDidBecomeActive() {
+        blurView?.removeFromSuperview()
+        blurView = nil
+    }
+
+    deinit {
+        NotificationCenter.default.removeObserver(self)
+    }
+}
+```
+
+**Tools:** OWASP MASVS-PLATFORM-4, iMazing (inspect snapshots in backup), Simulator App Switcher testing

package/skill-assets/sunlint-code-quality/rules/swift/S060-data-protection-api.md

@@ -0,0 +1,106 @@
+---
+title: Bật Data Protection (NSFileProtectionComplete) cho file chứa dữ liệu nhạy cảm
+impact: HIGH
+impactDescription: File không có Data Protection class có thể bị đọc ngay cả khi device bị khóa (accessible after first unlock). Với NSFileProtectionComplete, file chỉ accessible khi device đang mở khóa, được mã hóa bằng user passcode.
+tags: swift, ios, data-protection, file-encryption, nsdatawritingoptions, secure-storage, security
+---
+
+## Bật Data Protection (NSFileProtectionComplete) cho file chứa dữ liệu nhạy cảm
+
+iOS Data Protection mã hóa file bằng key kết hợp từ passcode device và hardware key. Khi tạo hoặc ghi file nhạy cảm, phải set attribute `NSFileProtectionComplete` (mạnh nhất - chỉ decrypt khi device đang unlock). Database CoreData và SQLite cũng cần bật encryption.
+
+**Incorrect (không set data protection):**
+
+```swift
+import Foundation
+
+class DocumentManager {
+    // !! Ghi file không có data protection - accessible mọi lúc
+    func savePrivateDocument(content: Data, filename: String) throws {
+        let url = documentsDirectory.appendingPathComponent(filename)
+        // Không set protection attribute - mặc định là NSFileProtectionCompleteUntilFirstUserAuthentication
+        try content.write(to: url)
+    }
+
+    // !! SQLite database không có data protection
+    func openDatabase() -> OpaquePointer? {
+        let dbPath = documentsDirectory.appendingPathComponent("app.db").path
+        var db: OpaquePointer?
+        sqlite3_open(dbPath, &db)  // Không có encryption!
+        return db
+    }
+}
+```
+
+**Correct (NSFileProtectionComplete + FMDB encryption):**
+
+```swift
+import Foundation
+
+class SecureDocumentManager {
+    private let documentsDirectory = FileManager.default
+        .urls(for: .documentDirectory, in: .userDomainMask)[0]
+
+    // SAFE: Data Protection Complete cho file nhạy cảm
+    func savePrivateDocument(content: Data, filename: String) throws {
+        let url = documentsDirectory.appendingPathComponent(filename)
+        // NSFileProtectionComplete: chỉ accessible khi device unlocked
+        try content.write(
+            to: url,
+            options: [.atomic, .completeFileProtection]  // .completeFileProtection = NSFileProtectionComplete
+        )
+    }
+
+    // SAFE: Set protection cho file đã tồn tại
+    func upgradeFileProtection(at url: URL) throws {
+        try FileManager.default.setAttributes(
+            [.protectionKey: FileProtectionType.complete],
+            ofItemAtPath: url.path
+        )
+    }
+
+    // SAFE: Kiểm tra data protection của file
+    func verifyFileProtection(at url: URL) throws -> Bool {
+        let attributes = try FileManager.default.attributesOfItem(atPath: url.path)
+        let protection = attributes[.protectionKey] as? FileProtectionType
+        return protection == .complete || protection == .completeUnlessOpen
+    }
+
+    // SAFE: Tạo directory với data protection
+    func createSecureDirectory(named name: String) throws -> URL {
+        let dirURL = documentsDirectory.appendingPathComponent(name)
+        try FileManager.default.createDirectory(
+            at: dirURL,
+            withIntermediateDirectories: true,
+            attributes: [.protectionKey: FileProtectionType.complete]
+        )
+        return dirURL
+    }
+}
+
+// SAFE: CoreData với data protection (trong NSPersistentStoreDescription)
+class CoreDataStack {
+    lazy var persistentContainer: NSPersistentContainer = {
+        let container = NSPersistentContainer(name: "AppModel")
+        let description = NSPersistentStoreDescription()
+        description.url = FileManager.default
+            .urls(for: .documentDirectory, in: .userDomainMask)[0]
+            .appendingPathComponent("AppModel.sqlite")
+        // SAFE: Enable SQLite data protection
+        description.setOption(
+            FileProtectionType.complete as NSObject,
+            forKey: NSPersistentStoreFileProtectionKey
+        )
+        container.persistentStoreDescriptions = [description]
+        container.loadPersistentStores { _, error in
+            if let error = error { fatalError("CoreData load error: \(error)") }
+        }
+        return container
+    }()
+}
+
+// SAFE: App entitlement - trong Xcode → Signing & Capabilities → Data Protection
+// Chọn "Complete Protection" trong Data Protection capability
+```
+
+**Tools:** OWASP MASVS-STORAGE-4, iMazing (verify protection class), `filecmds` on jailbroken device, Xcode Capabilities (Data Protection entitlement)

package/skill-assets/sunlint-code-quality/rules/swift/S061-jailbreak-detection.md

@@ -0,0 +1,132 @@
+---
+title: Hạn chế tính năng nhạy cảm trên jailbroken device
+impact: MEDIUM
+impactDescription: Trên jailbroken device, Keychain có thể bị extract, SSL pinning bị bypass bởi SSL Kill Switch, và file system accessible không có restriction. Banking/healthcare app cần detect jailbreak để warn hoặc restrict.
+tags: swift, ios, jailbreak-detection, root-detection, security-posture, masvs, security
+---
+
+## Hạn chế tính năng nhạy cảm trên jailbroken device
+
+Jailbreak detection giúp app nhận biết môi trường không tin cậy để warn user hoặc disable tính năng có rủi ro cao (như lưu credential, xem sensitive data). Lưu ý: detection không 100% và có thể bị bypass, nhưng vẫn là lớp bảo vệ quan trọng cho app tài chính/y tế.
+
+**Incorrect (không có jailbreak awareness):**
+
+```swift
+// App banking hoạt động bình thường trên device đã jailbreak
+// Keychain contents bị extract bằng keychain-dumper
+// Certificate pinning bị bypass bằng SSL Kill Switch 2
+// File sandbox bị đọc bởi bất kỳ process nào có root
+```
+
+**Correct (basic jailbreak detection với graceful response):**
+
+```swift
+import UIKit
+import Foundation
+
+struct JailbreakDetector {
+    // Chỉ run trong production build
+    #if !targetEnvironment(simulator)
+    static func isJailbroken() -> Bool {
+        return hasJailbreakFiles()
+            || canWriteOutsideSandbox()
+            || hasSuspiciousApps()
+            || hasDynamicLibraryInjection()
+    }
+    #else
+    static func isJailbroken() -> Bool { return false }
+    #endif
+
+    // Kiểm tra file đặc trưng của jailbreak tools
+    private static func hasJailbreakFiles() -> Bool {
+        let jailbreakPaths = [
+            "/Applications/Cydia.app",
+            "/Applications/Sileo.app",
+            "/Library/MobileSubstrate/MobileSubstrate.dylib",
+            "/bin/bash",
+            "/usr/sbin/sshd",
+            "/etc/apt",
+            "/private/var/lib/apt/",
+            "/private/var/lib/cydia",
+            "/usr/bin/ssh",
+            "/var/jb"  // Palera1n
+        ]
+        return jailbreakPaths.contains { FileManager.default.fileExists(atPath: $0) }
+    }
+
+    // Thử ghi file ngoài sandbox - chỉ jailbroken device cho phép
+    private static func canWriteOutsideSandbox() -> Bool {
+        let testPath = "/private/jailbreak_test_\(UUID().uuidString)"
+        do {
+            try "test".write(toFile: testPath, atomically: true, encoding: .utf8)
+            try FileManager.default.removeItem(atPath: testPath)
+            return true
+        } catch {
+            return false
+        }
+    }
+
+    // Kiểm tra app jailbreak phổ biến qua URL scheme
+    private static func hasSuspiciousApps() -> Bool {
+        let schemes = ["cydia://", "sileo://", "zbra://", "filza://"]
+        return schemes.contains { scheme in
+            guard let url = URL(string: scheme) else { return false }
+            return UIApplication.shared.canOpenURL(url)
+        }
+    }
+
+    // Kiểm tra DYLD injection
+    private static func hasDynamicLibraryInjection() -> Bool {
+        if let dyldEnv = ProcessInfo.processInfo.environment["DYLD_INSERT_LIBRARIES"],
+           !dyldEnv.isEmpty {
+            return true
+        }
+        return false
+    }
+}
+
+// SAFE: Respond gracefully - warn, không block hoàn toàn (tránh false positive)
+class SecurityCheckManager {
+    enum SecurityRisk {
+        case jailbroken
+        case clean
+    }
+
+    func assessSecurityRisk() -> SecurityRisk {
+        return JailbreakDetector.isJailbroken() ? .jailbroken : .clean
+    }
+
+    // Tùy từng loại app mà quyết định hành động
+    func handleJailbreakDetected(in viewController: UIViewController) {
+        let alert = UIAlertController(
+            title: "Security Risk Detected",
+            message: "Your device appears to be modified (jailbroken). " +
+                     "This app's security features may not work as expected. " +
+                     "Sensitive features have been disabled for your protection.",
+            preferredStyle: .alert
+        )
+        // Tài chính/banking: offer option để proceed với risk accepted
+        alert.addAction(UIAlertAction(title: "I Understand", style: .destructive) { _ in
+            // Disable high-risk features: biometric storage, show account numbers, etc.
+            SecurityFeatureFlags.disableHighRiskFeatures()
+        })
+        alert.addAction(UIAlertAction(title: "Exit", style: .cancel) { _ in
+            exit(0)  // Hoặc chỉ close app, không kill process
+        })
+        viewController.present(alert, animated: true)
+    }
+}
+
+struct SecurityFeatureFlags {
+    static var highRiskFeaturesEnabled = true
+
+    static func disableHighRiskFeatures() {
+        highRiskFeaturesEnabled = false
+        // Disable: show full card number, biometric auto-fill, remember device, etc.
+    }
+}
+```
+
+**Tools:** IOSSecuritySuite (library - comprehensive detection), DTTJailbreakDetection, OWASP MASVS-RESILIENCE-1, frida-ios-dump (test bypass)
+
+**Note:** Jailbreak detection là một lớp bảo vệ trong defense-in-depth, không phải giải pháp duy nhất. Thiết kế hệ thống sao cho server-side security không phụ thuộc vào integrity của client.