@sun-asterisk/sunlint 1.3.47 → 1.3.49

package/skill-assets/sunlint-code-quality/rules/swift/S046-unvalidated-redirect.md

@@ -0,0 +1,140 @@
+---
+title: Validate Universal Link và URL Scheme để tránh open redirect và hijacking
+impact: HIGH
+impactDescription: Xử lý deep link không validate cho phép attacker craft URL độc hại dẫn user đến webview chứa phishing page, hoặc trigger sensitive actions như logout/approve bằng custom URL scheme.
+tags: swift, ios, deeplink, universal-link, url-scheme, open-redirect, hijacking, security
+---
+
+## Validate Universal Link và URL Scheme để tránh open redirect và hijacking
+
+Custom URL scheme (`myapp://`) có thể bị hijack bởi app khác. Universal Links an toàn hơn nhưng vẫn cần validate parameters. Không bao giờ render URL từ deep link trực tiếp trong WKWebView hay navigate đến destination không thuộc domain whitelist.
+
+**Incorrect (không validate deep link destination):**
+
+```swift
+import UIKit
+
+class SceneDelegate: UIResponder, UISceneDelegate {
+
+    // !! Xử lý universal link - mở URL tùy ý trong webview
+    func scene(_ scene: UIScene, continue userActivity: NSUserActivity) {
+        guard userActivity.activityType == NSUserActivityTypeBrowsingWeb,
+              let incomingURL = userActivity.webpageURL else { return }
+
+        // !! Lấy "redirect" param từ URL và mở trong WebView không validate
+        let components = URLComponents(url: incomingURL, resolvingAgainstBaseURL: false)
+        let redirectURL = components?.queryItems?.first(where: { $0.name == "redirect" })?.value ?? ""
+        openWebView(urlString: redirectURL)  // Open redirect! Phishing!
+    }
+
+    // !! Custom scheme - trigger hành động nhạy cảm không xác nhận
+    func application(_ app: UIApplication, open url: URL, options: [UIApplication.OpenURLOptionsKey: Any]) -> Bool {
+        // myapp://approve?transactionId=123
+        if url.host == "approve" {
+            let transactionId = url.queryParameters["transactionId"] ?? ""
+            approveTransaction(id: transactionId)  // Trigger action không confirm!
+        }
+        return true
+    }
+}
+```
+
+**Correct (validate source, destination và require user confirmation):**
+
+```swift
+import UIKit
+
+struct DeepLinkValidator {
+    // Whitelist domain cho redirect
+    private static let allowedRedirectHosts: Set<String> = [
+        "app.example.com",
+        "www.example.com",
+        "help.example.com"
+    ]
+
+    // Validate redirect URL chỉ đến domain của mình
+    static func validateRedirectURL(_ urlString: String) throws -> URL {
+        guard let url = URL(string: urlString),
+              let host = url.host,
+              url.scheme == "https" else {
+            throw DeepLinkError.invalidURL(urlString)
+        }
+        guard allowedRedirectHosts.contains(host) else {
+            throw DeepLinkError.untrustedHost(host)
+        }
+        return url
+    }
+
+    // Validate transaction ID là UUID format
+    static func validateTransactionId(_ id: String) throws -> UUID {
+        guard let uuid = UUID(uuidString: id) else {
+            throw DeepLinkError.invalidParameter("transactionId must be UUID")
+        }
+        return uuid
+    }
+}
+
+enum DeepLinkError: LocalizedError {
+    case invalidURL(String), untrustedHost(String), invalidParameter(String)
+
+    var errorDescription: String? {
+        switch self {
+        case .invalidURL(let u): return "Invalid URL: \(u)"
+        case .untrustedHost(let h): return "Untrusted host: \(h)"
+        case .invalidParameter(let p): return "Invalid parameter: \(p)"
+        }
+    }
+}
+
+class SceneDelegate: UIResponder, UISceneDelegate {
+
+    // SAFE: Validate trước khi open webview
+    func scene(_ scene: UIScene, continue userActivity: NSUserActivity) {
+        guard userActivity.activityType == NSUserActivityTypeBrowsingWeb,
+              let incomingURL = userActivity.webpageURL else { return }
+
+        let components = URLComponents(url: incomingURL, resolvingAgainstBaseURL: false)
+        let rawRedirect = components?.queryItems?.first(where: { $0.name == "redirect" })?.value ?? ""
+
+        do {
+            let safeURL = try DeepLinkValidator.validateRedirectURL(rawRedirect)
+            openWebView(url: safeURL)  // Đã validate
+        } catch {
+            logger.warning("Rejected deep link redirect: \(error.localizedDescription)")
+            // Không navigate, hoặc mở trang default thay thế
+        }
+    }
+
+    // SAFE: Require user confirmation trước action nhạy cảm từ URL scheme
+    func application(_ app: UIApplication, open url: URL, options: [UIApplication.OpenURLOptionsKey: Any]) -> Bool {
+        guard url.scheme == "myapp" else { return false }
+
+        if url.host == "approve" {
+            do {
+                let rawId = url.queryParameters["transactionId"] ?? ""
+                let transactionId = try DeepLinkValidator.validateTransactionId(rawId)
+                // SAFE: Hiển thị confirmation alert trước
+                showApprovalConfirmation(transactionId: transactionId)
+            } catch {
+                logger.warning("Invalid approve deep link: \(error.localizedDescription)")
+            }
+        }
+        return true
+    }
+
+    private func showApprovalConfirmation(transactionId: UUID) {
+        let alert = UIAlertController(
+            title: "Confirm Transaction",
+            message: "Approve transaction \(transactionId.uuidString.prefix(8))...?",
+            preferredStyle: .alert
+        )
+        alert.addAction(UIAlertAction(title: "Approve", style: .default) { _ in
+            self.approveTransaction(id: transactionId)
+        })
+        alert.addAction(UIAlertAction(title: "Cancel", style: .cancel))
+        topViewController?.present(alert, animated: true)
+    }
+}
+```
+
+**Tools:** OWASP MASVS-PLATFORM-1, Apple App Review Guidelines (2.5.9), URLComponents, Proxyman

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)