@sun-asterisk/sunlint 1.3.48 → 1.3.49

package/skill-assets/sunlint-code-quality/rules/swift/S019-session-management.md

@@ -0,0 +1,131 @@
+---
+title: Lưu token và session credential trong Keychain - không dùng UserDefaults
+impact: CRITICAL
+impactDescription: UserDefaults và NSFileManager lưu plaintext trong app sandbox, có thể bị đọc trên jailbroken device, iTunes backup không mã hóa, hoặc ADB pull. Keychain mã hóa bằng Secure Enclave.
+tags: swift, ios, keychain, userdefaults, session-management, token-storage, security
+---
+
+## Lưu token và session credential trong Keychain - không dùng UserDefaults
+
+Access token, refresh token, user password, và session identifier phải được lưu trong **iOS Keychain** với accessibility phù hợp (`kSecAttrAccessibleWhenUnlockedThisDeviceOnly`). Không dùng `UserDefaults`, `NSFileManager`, hay bất kỳ file plaintext nào.
+
+**Incorrect (lưu token trong UserDefaults):**
+
+```swift
+import Foundation
+
+class AuthManager {
+    // !! UserDefaults - plaintext, backup leak, jailbreak accessible
+    func saveAccessToken(_ token: String) {
+        UserDefaults.standard.set(token, forKey: "access_token")
+    }
+
+    func getAccessToken() -> String? {
+        return UserDefaults.standard.string(forKey: "access_token")
+    }
+
+    // !! NSFileManager - file dễ bị đọc qua iTunes backup
+    func saveRefreshToken(_ token: String) {
+        let path = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask)[0]
+            .appendingPathComponent("refresh.token")
+        try? token.write(to: path, atomically: true, encoding: .utf8)
+    }
+}
+```
+
+**Correct (Keychain với Secure Enclave):**
+
+```swift
+import Foundation
+import Security
+
+enum KeychainError: Error {
+    case duplicateEntry
+    case unknown(OSStatus)
+    case noData
+    case unexpectedData
+}
+
+struct KeychainService {
+    static let service = Bundle.main.bundleIdentifier ?? "com.app"
+
+    // SAFE: Lưu token vào Keychain
+    static func saveToken(_ token: String, key: String) throws {
+        guard let data = token.data(using: .utf8) else { return }
+
+        let query: [CFString: Any] = [
+            kSecClass: kSecClassGenericPassword,
+            kSecAttrService: service,
+            kSecAttrAccount: key,
+            kSecValueData: data,
+            // Chỉ accessible khi device unlocked, không sync iCloud, không backup
+            kSecAttrAccessible: kSecAttrAccessibleWhenUnlockedThisDeviceOnly
+        ]
+
+        // Nếu đã tồn tại, update
+        let status = SecItemAdd(query as CFDictionary, nil)
+        if status == errSecDuplicateItem {
+            let updateQuery: [CFString: Any] = [
+                kSecClass: kSecClassGenericPassword,
+                kSecAttrService: service,
+                kSecAttrAccount: key
+            ]
+            let updateAttributes: [CFString: Any] = [kSecValueData: data]
+            let updateStatus = SecItemUpdate(updateQuery as CFDictionary, updateAttributes as CFDictionary)
+            guard updateStatus == errSecSuccess else {
+                throw KeychainError.unknown(updateStatus)
+            }
+        } else if status != errSecSuccess {
+            throw KeychainError.unknown(status)
+        }
+    }
+
+    // SAFE: Đọc token từ Keychain
+    static func readToken(key: String) throws -> String {
+        let query: [CFString: Any] = [
+            kSecClass: kSecClassGenericPassword,
+            kSecAttrService: service,
+            kSecAttrAccount: key,
+            kSecReturnData: true,
+            kSecMatchLimit: kSecMatchLimitOne
+        ]
+
+        var result: AnyObject?
+        let status = SecItemCopyMatching(query as CFDictionary, &result)
+        guard status == errSecSuccess,
+              let data = result as? Data,
+              let token = String(data: data, encoding: .utf8) else {
+            throw KeychainError.noData
+        }
+        return token
+    }
+
+    // SAFE: Xóa token khi logout
+    static func deleteToken(key: String) {
+        let query: [CFString: Any] = [
+            kSecClass: kSecClassGenericPassword,
+            kSecAttrService: service,
+            kSecAttrAccount: key
+        ]
+        SecItemDelete(query as CFDictionary)
+    }
+}
+
+// Usage
+class AuthManager {
+    private let accessTokenKey = "com.app.accessToken"
+    private let refreshTokenKey = "com.app.refreshToken"
+
+    func saveTokens(accessToken: String, refreshToken: String) throws {
+        try KeychainService.saveToken(accessToken, key: accessTokenKey)
+        try KeychainService.saveToken(refreshToken, key: refreshTokenKey)
+    }
+
+    func clearSession() {
+        KeychainService.deleteToken(key: accessTokenKey)
+        KeychainService.deleteToken(key: refreshTokenKey)
+    }
+}
+```
+
+**Tools:** Keychain-Swift (library), OWASP MASVS-STORAGE-1, iMazing (backup inspection), objection (jailbreak inspection)

package/skill-assets/sunlint-code-quality/rules/swift/S020-kvc-injection.md

@@ -0,0 +1,91 @@
+---
+title: Không dùng value(forKeyPath:) với input người dùng - tránh KVC injection
+impact: HIGH
+impactDescription: Truyền string người dùng vào value(forKeyPath:) hoặc NSPredicate(value:) dạng keyPath expression cho phép attacker truy cập private properties hoặc trigger unintended method calls.
+tags: swift, ios, kvc, keypathinjection, nspredicate, dynamic-code, security
+---
+
+## Không dùng value(forKeyPath:) với input người dùng - tránh KVC injection
+
+Key-Value Coding (KVC) trong Objective-C runtime cho phép truy cập bất kỳ property nào theo tên string. Truyền input người dùng vào `value(forKeyPath:)` hoặc dùng KVC trong NSPredicate format với keyPath không được validate là nguy hiểm.
+
+**Incorrect (KVC với input người dùng):**
+
+```swift
+import Foundation
+
+class ProfileViewController: UIViewController {
+    var user: User!
+
+    // !! KVC với field name từ user input - truy cập private properties!
+    func displayField(fieldName: String) {
+        // Nếu fieldName = "privateSSN" hoặc "password" → lộ dữ liệu nhạy cảm
+        let value = user.value(forKeyPath: fieldName)
+        print("Field value: \(value ?? "nil")")
+    }
+
+    // !! NSPredicate với dynamic keyPath từ server
+    func filterUsers(sortField: String, sortOrder: String, users: [User]) -> [User] {
+        // sortField từ server response không được validate
+        let predicate = NSPredicate(format: "%K == %@", sortField, "active")
+        return (users as NSArray).filtered(using: predicate) as? [User] ?? []
+    }
+}
+```
+
+**Correct (whitelist keyPath được phép):**
+
+```swift
+import Foundation
+
+// SAFE: Whitelist các field được phép truy cập
+enum UserDisplayField: String, CaseIterable {
+    case displayName = "displayName"
+    case email = "email"
+    case bio = "bio"
+    case avatarURL = "avatarURL"
+    // Không có: password, ssn, internalId, etc.
+}
+
+class ProfileViewController: UIViewController {
+    var user: User!
+
+    // SAFE: Validate field name trước khi dùng
+    func displayField(fieldName: String) {
+        guard let allowedField = UserDisplayField(rawValue: fieldName) else {
+            // Field không được phép - log và return
+            print("Warning: Attempted access to field '\(fieldName)'")
+            return
+        }
+        let value = user.value(forKeyPath: allowedField.rawValue)
+        displayLabel.text = value as? String
+    }
+
+    // SAFE: Enum-based sort column, không dùng raw string từ server
+    func filterActiveUsers(from users: [User]) -> [User] {
+        return users.filter { $0.status == .active }
+    }
+}
+
+// SAFE: Dùng Swift keypath thay vì KVC string
+struct UserSorter {
+    enum SortField {
+        case name
+        case createdAt
+        case lastActive
+    }
+
+    func sortUsers(_ users: [User], by field: SortField, ascending: Bool) -> [User] {
+        switch field {
+        case .name:
+            return users.sorted { ascending ? $0.name < $1.name : $0.name > $1.name }
+        case .createdAt:
+            return users.sorted { ascending ? $0.createdAt < $1.createdAt : $0.createdAt > $1.createdAt }
+        case .lastActive:
+            return users.sorted { ascending ? $0.lastActive < $1.lastActive : $0.lastActive > $1.lastActive }
+        }
+    }
+}
+```
+
+**Tools:** OWASP MASVS-CODE-4, SwiftLint custom rule (detect `value(forKeyPath:` with non-literal argument)

package/skill-assets/sunlint-code-quality/rules/swift/S025-input-validation.md

@@ -0,0 +1,125 @@
+---
+title: Validate toàn bộ input từ người dùng và URL scheme - không tin dữ liệu bên ngoài
+impact: HIGH
+impactDescription: Không validate URL scheme parameters, deep link payload hoặc form input dẫn đến injection, logic bypass, hoặc truy cập unauthorized. Input từ bất kỳ source nào đều phải được validate ở server-side layer.
+tags: swift, ios, input-validation, deeplink, url-scheme, universal-link, security
+---
+
+## Validate toàn bộ input từ người dùng và URL scheme - không tin dữ liệu bên ngoài
+
+Mọi input từ người dùng, URL scheme, universal link, clipboard, hoặc push notification payload đều phải được validate: kiểm tra type, length, format và phạm vi cho phép trước khi xử lý. Đặc biệt cẩn thận với navigation target từ deep link.
+
+**Incorrect (không validate deep link parameters):**
+
+```swift
+import UIKit
+
+class AppDelegate: UIResponder, UIApplicationDelegate {
+
+    // !! Không validate parameter từ deep link - open URL tùy ý
+    func application(_ app: UIApplication,
+                     open url: URL,
+                     options: [UIApplication.OpenURLOptionsKey: Any] = [:]) -> Bool {
+        guard url.scheme == "myapp" else { return false }
+
+        if url.host == "product" {
+            // !! productId có thể là "../../../etc" hoặc SQL injection
+            let productId = url.queryParameters["id"] ?? ""
+            navigateToProduct(id: productId)  // Không validate!
+        }
+
+        if url.host == "webview" {
+            // !! Mở URL tùy ý trong WKWebView - open redirect!
+            let targetURL = url.queryParameters["url"] ?? ""
+            openInWebView(urlString: targetURL)  // Nguy hiểm!
+        }
+        return true
+    }
+}
+```
+
+**Correct (validate trước khi xử lý):**
+
+```swift
+import UIKit
+
+// SAFE: Validator tập trung
+enum ValidationError: LocalizedError {
+    case invalidFormat(String)
+    case outOfRange(String)
+    case suspiciousInput(String)
+
+    var errorDescription: String? {
+        switch self {
+        case .invalidFormat(let f): return "Invalid format: \(f)"
+        case .outOfRange(let f): return "Out of range: \(f)"
+        case .suspiciousInput(let f): return "Suspicious input: \(f)"
+        }
+    }
+}
+
+struct InputValidator {
+    // Chỉ accept UUID format cho product ID
+    static func validateProductId(_ id: String) throws -> UUID {
+        guard let uuid = UUID(uuidString: id) else {
+            throw ValidationError.invalidFormat("productId must be UUID")
+        }
+        return uuid
+    }
+
+    // Chỉ accept HTTPS URL trong domain whitelist
+    static func validateInternalURL(_ urlString: String) throws -> URL {
+        guard let url = URL(string: urlString),
+              url.scheme == "https" else {
+            throw ValidationError.invalidFormat("URL must be HTTPS")
+        }
+        let allowedHosts = ["app.example.com", "static.example.com"]
+        guard let host = url.host, allowedHosts.contains(host) else {
+            throw ValidationError.suspiciousInput("URL host not in whitelist: \(url.host ?? "nil")")
+        }
+        return url
+    }
+
+    static func validatePhoneNumber(_ number: String) throws -> String {
+        let regex = #"^\+?[0-9]{10,15}$"#
+        let predicate = NSPredicate(format: "SELF MATCHES %@", regex)
+        guard predicate.evaluate(with: number) else {
+            throw ValidationError.invalidFormat("Invalid phone number")
+        }
+        return number
+    }
+}
+
+class AppDelegate: UIResponder, UIApplicationDelegate {
+
+    func application(_ app: UIApplication,
+                     open url: URL,
+                     options: [UIApplication.OpenURLOptionsKey: Any] = [:]) -> Bool {
+        guard url.scheme == "myapp" else { return false }
+
+        do {
+            if url.host == "product" {
+                let rawId = url.queryParameters["id"] ?? ""
+                let productId = try InputValidator.validateProductId(rawId)
+                navigateToProduct(id: productId)  // UUID-typed, safe
+            }
+
+            if url.host == "webview" {
+                let rawURL = url.queryParameters["url"] ?? ""
+                let safeURL = try InputValidator.validateInternalURL(rawURL)
+                openInWebView(url: safeURL)  // Validated URL, whitelist
+            }
+        } catch {
+            // Log attempt nhưng không crash
+            logger.warning("Invalid deep link parameter", metadata: [
+                "url": "\(url)",
+                "error": "\(error.localizedDescription)"
+            ])
+            return false
+        }
+        return true
+    }
+}
+```
+
+**Tools:** OWASP MASVS-PLATFORM-1, SwiftLint, URLComponents (safer URL parsing)

package/skill-assets/sunlint-code-quality/rules/swift/S029-brute-force-protection.md

@@ -0,0 +1,120 @@
+---
+title: Implement lockout sau nhiều lần xác thực thất bại (PIN/password/biometrics)
+impact: HIGH
+impactDescription: Không giới hạn số lần thử đăng nhập cho phép brute force tấn công PIN 4-6 chữ số trong vài giây. Lockout mechanism và exponential backoff là bắt buộc cho local auth.
+tags: swift, ios, brute-force, lockout, pin, local-authentication, security
+---
+
+## Implement lockout sau nhiều lần xác thực thất bại (PIN/password/biometrics)
+
+Với local authentication (PIN, passcode), phải implement lockout sau N lần thất bại với exponential backoff, và wipe data hoặc reroute về server auth sau threshold. Server API cũng cần rate limiting cho login attempts.
+
+**Incorrect (không giới hạn số lần thử):**
+
+```swift
+import LocalAuthentication
+
+class PINViewController: UIViewController {
+    var enteredPIN = ""
+
+    // !! Không giới hạn số lần thử - brute force 0000-9999 trong vài giây
+    func validatePIN(_ pin: String) {
+        guard let storedPIN = UserDefaults.standard.string(forKey: "user_pin") else { return }
+        if pin == storedPIN {
+            navigateToHome()
+        } else {
+            showError("Wrong PIN")
+            // Không đếm số lần thất bại!
+        }
+    }
+}
+```
+
+**Correct (lockout với exponential backoff):**
+
+```swift
+import LocalAuthentication
+import Foundation
+
+struct AuthAttemptTracker {
+    private let maxAttempts = 5
+    private let lockoutKey = "auth_lockout_until"
+    private let attemptCountKey = "auth_attempt_count"
+    private let keychain = KeychainService.self
+
+    var isLockedOut: Bool {
+        guard let lockoutDate = UserDefaults.standard.object(forKey: lockoutKey) as? Date else {
+            return false
+        }
+        return Date() < lockoutDate
+    }
+
+    var remainingLockoutSeconds: TimeInterval {
+        guard let lockoutDate = UserDefaults.standard.object(forKey: lockoutKey) as? Date else {
+            return 0
+        }
+        return max(0, lockoutDate.timeIntervalSinceNow)
+    }
+
+    var failureCount: Int {
+        return UserDefaults.standard.integer(forKey: attemptCountKey)
+    }
+
+    mutating func recordFailure() {
+        let count = failureCount + 1
+        UserDefaults.standard.set(count, forKey: attemptCountKey)
+
+        if count >= maxAttempts {
+            // Exponential backoff: 30s, 60s, 120s, 240s...
+            let lockoutDuration = TimeInterval(30 * pow(2.0, Double(count - maxAttempts)))
+            let lockoutUntil = Date().addingTimeInterval(min(lockoutDuration, 3600)) // Max 1h
+            UserDefaults.standard.set(lockoutUntil, forKey: lockoutKey)
+        }
+    }
+
+    func resetAfterSuccess() {
+        UserDefaults.standard.removeObject(forKey: attemptCountKey)
+        UserDefaults.standard.removeObject(forKey: lockoutKey)
+    }
+}
+
+class PINViewController: UIViewController {
+    private var tracker = AuthAttemptTracker()
+
+    // SAFE: Validate với lockout mechanism
+    func validatePIN(_ pin: String) {
+        guard !tracker.isLockedOut else {
+            let seconds = Int(tracker.remainingLockoutSeconds)
+            showError("Too many attempts. Try again in \(seconds)s")
+            return
+        }
+
+        do {
+            let storedPINHash = try KeychainService.readToken(key: "user_pin_hash")
+            // Compare hash, không phải plaintext
+            let inputHash = hashPIN(pin)
+            if inputHash == storedPINHash {
+                tracker.resetAfterSuccess()
+                navigateToHome()
+            } else {
+                tracker.recordFailure()
+                let remaining = 5 - tracker.failureCount
+                if remaining > 0 {
+                    showError("Wrong PIN. \(remaining) attempts remaining.")
+                } else {
+                    showError("Account locked. Use biometrics or contact support.")
+                }
+            }
+        } catch {
+            showError("Authentication error")
+        }
+    }
+
+    private func hashPIN(_ pin: String) -> String {
+        // Dùng CryptoKit với salt từ Keychain
+        return CryptoPINHasher.hash(pin: pin)
+    }
+}
+```
+
+**Tools:** OWASP MASVS-AUTH-2, OWASP Testing Guide (OTG-AUTHN-003), Instruments (brute force simulation)

package/skill-assets/sunlint-code-quality/rules/swift/S036-path-traversal.md

@@ -0,0 +1,102 @@
+---
+title: Prevent path traversal khi xử lý file trong app sandbox
+impact: HIGH
+impactDescription: Dùng filename từ user input hoặc server response để truy cập file mà không sanitize cho phép đọc file tùy ý trong sandbox, hoặc ghi đè file quan trọng như database và plist.
+tags: swift, ios, path-traversal, file-access, sandbox, security
+---
+
+## Prevent path traversal khi xử lý file trong app sandbox
+
+Khi tạo đường dẫn file từ input người dùng hoặc data từ server, phải validate path không chứa `../` và kết quả phải nằm trong thư mục cho phép. Luôn dùng `URL.appendingPathComponent` thay vì string concatenation cho path.
+
+**Incorrect (path traversal qua tên file từ server):**
+
+```swift
+import Foundation
+
+class FileDownloadManager {
+    let downloadsDir = FileManager.default.urls(
+        for: .documentDirectory, in: .userDomainMask
+    )[0].appendingPathComponent("downloads")
+
+    // !! filename từ server không được validate
+    func saveDownloadedFile(data: Data, filename: String) throws {
+        // Nếu filename = "../../Library/Application Support/default.realm" thì ghi đè DB!
+        let filePath = downloadsDir.path + "/" + filename  // Path traversal!
+        FileManager.default.createFile(atPath: filePath, contents: data)
+    }
+
+    // !! Đọc file theo path từ server response
+    func readCachedFile(relativePath: String) -> Data? {
+        let cacheDir = FileManager.default.urls(for: .cachesDirectory, in: .userDomainMask)[0]
+        let fullPath = cacheDir.appendingPathComponent(relativePath)  // Unsafe!
+        return try? Data(contentsOf: fullPath)
+    }
+}
+```
+
+**Correct (sanitize và validate path):**
+
+```swift
+import Foundation
+
+enum FileStorageError: LocalizedError {
+    case pathTraversalDetected(String)
+    case fileOutsideAllowedDirectory(URL)
+    case invalidFilename(String)
+
+    var errorDescription: String? {
+        switch self {
+        case .pathTraversalDetected(let name): return "Path traversal detected: \(name)"
+        case .fileOutsideAllowedDirectory(let url): return "File outside allowed dir: \(url.path)"
+        case .invalidFilename(let name): return "Invalid filename: \(name)"
+        }
+    }
+}
+
+struct SafeFileManager {
+    let baseDirectory: URL
+
+    // Validate filename: không có path separator, không có ".."
+    func sanitizeFilename(_ filename: String) throws -> String {
+        // Chỉ accept alphanumeric, dash, underscore, dot (không phải đầu)
+        let allowedPattern = #"^[a-zA-Z0-9][a-zA-Z0-9._\-]{0,254}$"#
+        let predicate = NSPredicate(format: "SELF MATCHES %@", allowedPattern)
+        guard predicate.evaluate(with: filename) else {
+            throw FileStorageError.invalidFilename(filename)
+        }
+        // Từ chối path separator và traversal
+        if filename.contains("/") || filename.contains("..") || filename.contains("\0") {
+            throw FileStorageError.pathTraversalDetected(filename)
+        }
+        return filename
+    }
+
+    // Verify resolved path nằm trong baseDirectory
+    func validatePathContainment(_ url: URL) throws -> URL {
+        let resolved = url.standardized
+        let base = baseDirectory.standardized
+        guard resolved.path.hasPrefix(base.path + "/") || resolved.path == base.path else {
+            throw FileStorageError.fileOutsideAllowedDirectory(resolved)
+        }
+        return resolved
+    }
+
+    func saveFile(data: Data, filename: String) throws -> URL {
+        let safeName = try sanitizeFilename(filename)
+        let fileURL = baseDirectory.appendingPathComponent(safeName)
+        let validatedURL = try validatePathContainment(fileURL)
+        try data.write(to: validatedURL, options: [.atomic, .completeFileProtection])
+        return validatedURL
+    }
+
+    func readFile(filename: String) throws -> Data {
+        let safeName = try sanitizeFilename(filename)
+        let fileURL = baseDirectory.appendingPathComponent(safeName)
+        let validatedURL = try validatePathContainment(fileURL)
+        return try Data(contentsOf: validatedURL)
+    }
+}
+```
+
+**Tools:** OWASP MASVS-STORAGE-3, SwiftLint custom rule (detect path + "/" + variable), Instruments

package/skill-assets/sunlint-code-quality/rules/swift/S039-tls-certificate-validation.md

@@ -0,0 +1,109 @@
+---
+title: Implement certificate pinning cho API quan trọng
+impact: CRITICAL
+impactDescription: Không pin certificate cho phép attacker dùng proxy (Charles, Proxyman) hoặc cài root CA để đọc toàn bộ API traffic và đánh cắp token, dữ liệu người dùng.
+tags: swift, ios, certificate-pinning, tls, ssl-pinning, urlsession, alamofire, security
+---
+
+## Implement certificate pinning cho API quan trọng
+
+Certificate pinning đảm bảo app chỉ chấp nhận certificate của server đã biết trước, ngăn chặn MITM attack ngay cả khi attacker cài root CA. Implement bằng `URLSessionDelegate` hoặc Alamofire `ServerTrustManager`.
+
+**Incorrect (không pin certificate - chấp nhận mọi certificate):**
+
+```swift
+import Foundation
+
+// !! Không pin - chấp nhận certificate bất kỳ trust chain nào phát hành
+class InsecureNetworkManager: NSObject {
+    lazy var session = URLSession(configuration: .default, delegate: self, delegateQueue: nil)
+
+    func fetchUserData(token: String) {
+        var request = URLRequest(url: URL(string: "https://api.example.com/user")!)
+        request.setValue("Bearer \(token)", forHTTPHeaderField: "Authorization")
+        session.dataTask(with: request).resume()
+    }
+}
+
+extension InsecureNetworkManager: URLSessionDelegate {
+    // !! Không implement - mặc định không pin
+    // Proxy như Charles/Proxyman đọc được hết traffic
+}
+
+// !! Hoặc tệ hơn: disable validation hoàn toàn (chỉ thấy trong dev code nhưng sót production)
+extension InsecureNetworkManager: URLSessionDelegate {
+    func urlSession(_ session: URLSession,
+                    didReceive challenge: URLAuthenticationChallenge,
+                    completionHandler: @escaping (URLSession.AuthChallengeDisposition, URLCredential?) -> Void) {
+        // !! CHỚ BAO GIỜ: accept mọi certificate
+        completionHandler(.useCredential, URLCredential(trust: challenge.protectionSpace.serverTrust!))
+    }
+}
+```
+
+**Correct (certificate pinning với public key hash):**
+
+```swift
+import Foundation
+import CryptoKit
+
+class PinnedNetworkManager: NSObject {
+    // SAFE: Hardcode SHA256 hash của public key server certificate
+    // Nên pin ít nhất 2 hashes (primary + backup) để rollover không gây outage
+    private let pinnedKeyHashes: Set<String> = [
+        "BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB=",  // Primary cert
+        "CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC="   // Backup cert
+    ]
+
+    lazy var session: URLSession = {
+        URLSession(configuration: .default, delegate: self, delegateQueue: nil)
+    }()
+}
+
+extension PinnedNetworkManager: URLSessionDelegate {
+    func urlSession(_ session: URLSession,
+                    didReceive challenge: URLAuthenticationChallenge,
+                    completionHandler: @escaping (URLSession.AuthChallengeDisposition, URLCredential?) -> Void) {
+        guard challenge.protectionSpace.authenticationMethod == NSURLAuthenticationMethodServerTrust,
+              let serverTrust = challenge.protectionSpace.serverTrust else {
+            completionHandler(.cancelAuthenticationChallenge, nil)
+            return
+        }
+
+        // Evaluate server trust
+        var error: CFError?
+        guard SecTrustEvaluateWithError(serverTrust, &error) else {
+            completionHandler(.cancelAuthenticationChallenge, nil)
+            return
+        }
+
+        // Lấy certificate chain và kiểm tra public key hash
+        let certificateCount = SecTrustGetCertificateCount(serverTrust)
+        for index in 0..<certificateCount {
+            guard let certificate = SecTrustGetCertificateAtIndex(serverTrust, index) else { continue }
+            let publicKey = SecCertificateCopyKey(certificate)
+            guard let keyData = publicKey.flatMap({ SecKeyCopyExternalRepresentation($0, nil) as Data? }) else { continue }
+
+            let hash = SHA256.hash(data: keyData)
+            let hashBase64 = Data(hash).base64EncodedString()
+
+            if pinnedKeyHashes.contains(hashBase64) {
+                completionHandler(.useCredential, URLCredential(trust: serverTrust))
+                return
+            }
+        }
+
+        // Không match pin nào → reject
+        completionHandler(.cancelAuthenticationChallenge, nil)
+    }
+}
+
+// SAFE: Với Alamofire, dùng ServerTrustManager
+// import Alamofire
+// let evaluators: [String: ServerTrustEvaluating] = [
+//     "api.example.com": PublicKeysTrustEvaluator()
+// ]
+// let session = Session(serverTrustManager: ServerTrustManager(evaluators: evaluators))
+```
+
+**Tools:** TrustKit (library), Alamofire ServerTrustManager, OWASP MASVS-NETWORK-2, SSL Labs, Proxyman (test pinning)