@sun-asterisk/sunlint 1.3.47 → 1.3.49

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)

package/skill-assets/sunlint-code-quality/rules/swift/S041-logout-invalidation.md

@@ -0,0 +1,103 @@
+---
+title: Xóa token và invalidate session hoàn toàn khi logout
+impact: HIGH
+impactDescription: Logout không xóa token khỏi Keychain hoặc không revoke token trên server cho phép tái sử dụng token cũ để truy cập API, đặc biệt nguy hiểm khi thiết bị bị mất hoặc chia sẻ.
+tags: swift, ios, logout, session-invalidation, keychain, token-revocation, security
+---
+
+## Xóa token và invalidate session hoàn toàn khi logout
+
+Logout phải thực hiện đầy đủ 4 bước: (1) revoke token trên server, (2) xóa tất cả token khỏi Keychain, (3) xóa cache nhạy cảm trong memory và disk, (4) reset navigation stack về login screen. Không được chỉ navigate về login mà token vẫn còn.
+
+**Incorrect (logout không đầy đủ):**
+
+```swift
+import UIKit
+
+class SettingsViewController: UIViewController {
+
+    // !! Chỉ navigate về login, không xóa token
+    @IBAction func logoutTapped(_ sender: UIButton) {
+        let loginVC = LoginViewController()
+        navigationController?.setViewControllers([loginVC], animated: true)
+        // Token vẫn còn trong UserDefaults/Keychain!
+    }
+}
+
+class AuthManager {
+    // !! Chỉ xóa UserDefaults, bỏ sót Keychain
+    func logout() {
+        UserDefaults.standard.removeObject(forKey: "access_token")  // Sai: token nên chỉ ở Keychain
+        // Không revoke token trên server!
+        // Không xóa Keychain entries!
+        // Không xóa URLSession cookie!
+    }
+}
+```
+
+**Correct (logout đầy đủ):**
+
+```swift
+import UIKit
+
+class AuthManager {
+    private let keychainService = KeychainService.self
+    private let tokenKeys = ["access_token", "refresh_token", "id_token"]
+
+    // SAFE: Logout hoàn toàn
+    func logout() async {
+        // Bước 1: Revoke token trên server (best effort, không block logout nếu fail)
+        if let refreshToken = try? keychainService.readToken(key: "refresh_token") {
+            await revokeTokenOnServer(refreshToken: refreshToken)
+        }
+
+        // Bước 2: Xóa tất cả credentials khỏi Keychain
+        tokenKeys.forEach { key in
+            keychainService.deleteToken(key: key)
+        }
+
+        // Bước 3: Xóa URLSession cookies và cache
+        URLSession.shared.configuration.urlCache?.removeAllCachedResponses()
+        HTTPCookieStorage.shared.cookies?.forEach {
+            HTTPCookieStorage.shared.deleteCookie($0)
+        }
+
+        // Bước 4: Xóa sensitive data trong UserDefaults
+        let sensitiveKeys = ["user_profile_cache", "last_search_query"]
+        sensitiveKeys.forEach { UserDefaults.standard.removeObject(forKey: $0) }
+
+        // Bước 5: Navigate về login ở main thread
+        await MainActor.run {
+            self.resetToLoginScreen()
+        }
+    }
+
+    private func revokeTokenOnServer(refreshToken: String) async {
+        guard let url = URL(string: "https://api.example.com/auth/revoke") else { return }
+        var request = URLRequest(url: url)
+        request.httpMethod = "POST"
+        request.httpBody = try? JSONEncoder().encode(["refresh_token": refreshToken])
+        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
+        _ = try? await URLSession.shared.data(for: request)
+    }
+
+    private func resetToLoginScreen() {
+        guard let window = UIApplication.shared.connectedScenes
+            .compactMap({ $0 as? UIWindowScene })
+            .first?.windows.first else { return }
+
+        let loginVC = UINavigationController(rootViewController: LoginViewController())
+        window.rootViewController = loginVC
+        window.makeKeyAndVisible()
+    }
+}
+
+// Gọi khi app nhận được 401 Unauthorized
+extension AuthManager {
+    func handleUnauthorizedResponse() {
+        Task { await logout() }
+    }
+}
+```
+
+**Tools:** Proxyman (verify token unusable after logout), OWASP MASVS-AUTH-4, Instruments (memory inspection)

package/skill-assets/sunlint-code-quality/rules/swift/S043-password-hashing.md

@@ -0,0 +1,116 @@
+---
+title: Hash PIN/passcode cục bộ bằng CryptoKit với salt - không lưu plaintext
+impact: HIGH
+impactDescription: Lưu PIN hoặc passcode dưới dạng plaintext trong Keychain vẫn bị lộ nếu device bị extract bằng jailbreak tools. Hash với salt và iteration count ngăn dictionary attack và brute force.
+tags: swift, ios, password-hashing, cryptokit, pbkdf2, pin, local-auth, security
+---
+
+## Hash PIN/passcode cục bộ bằng CryptoKit với salt - không lưu plaintext
+
+Khi lưu PIN/passcode để xác thực cục bộ (không dùng Face ID/Touch ID), phải hash bằng thuật toán có cost factor như PBKDF2 hoặc bcrypt với salt ngẫu nhiên. Không so sánh plaintext PIN. Ưu tiên dùng `LocalAuthentication.framework` với Secure Enclave thay vì tự implement.
+
+**Incorrect (lưu PIN plaintext hoặc hash yếu):**
+
+```swift
+import Foundation
+import CryptoKit
+
+class LocalAuthManager {
+    // !! Lưu PIN plaintext trong Keychain
+    func savePIN(_ pin: String) throws {
+        try KeychainService.saveToken(pin, key: "user_pin")  // Plaintext!
+    }
+
+    // !! MD5/SHA1 hash không có salt - rainbow table attack
+    func savePINHash(_ pin: String) throws {
+        let digest = Insecure.MD5.hash(data: Data(pin.utf8))
+        let hash = digest.map { String(format: "%02x", $0) }.joined()
+        try KeychainService.saveToken(hash, key: "user_pin_hash")  // MD5, rainbow table!
+    }
+
+    // !! So sánh timing-inequal - timing attack
+    func validatePIN(_ input: String, stored: String) -> Bool {
+        return input == stored  // Timing attack possible
+    }
+}
+```
+
+**Correct (PBKDF2 với salt ngẫu nhiên):**
+
+```swift
+import Foundation
+import CryptoKit
+import CommonCrypto
+
+struct PINHasher {
+    private static let saltKey = "com.app.pinSalt"
+    private static let hashKey = "com.app.pinHash"
+    private static let iterations: UInt32 = 100_000  // 100k iterations
+    private static let keyLength = 32  // 256 bits
+
+    // Sinh salt ngẫu nhiên và hash PIN bằng PBKDF2
+    static func hashAndStorePIN(_ pin: String) throws {
+        // Sinh 16-byte salt ngẫu nhiên
+        var saltBytes = [UInt8](repeating: 0, count: 16)
+        SecRandomCopyBytes(kSecRandomDefault, saltBytes.count, &saltBytes)
+        let salt = Data(saltBytes)
+
+        let hash = try derivePINKey(pin: pin, salt: salt)
+
+        try KeychainService.saveToken(salt.base64EncodedString(), key: saltKey)
+        try KeychainService.saveToken(hash.base64EncodedString(), key: hashKey)
+    }
+
+    // SAFE: PBKDF2-SHA256 với salt
+    static func derivePINKey(pin: String, salt: Data) throws -> Data {
+        guard let pinData = pin.data(using: .utf8) else {
+            throw CryptoError.invalidInput
+        }
+
+        var derivedKey = [UInt8](repeating: 0, count: keyLength)
+        let result = pinData.withUnsafeBytes { pinBytes in
+            salt.withUnsafeBytes { saltBytes in
+                CCKeyDerivationPBKDF(
+                    CCPBKDFAlgorithm(kCCPBKDF2),
+                    pinBytes.baseAddress, pin.count,
+                    saltBytes.baseAddress, salt.count,
+                    CCPseudoRandomAlgorithm(kCCPRFHmacAlgSHA256),
+                    iterations,
+                    &derivedKey, keyLength
+                )
+            }
+        }
+        guard result == kCCSuccess else { throw CryptoError.hashFailed }
+        return Data(derivedKey)
+    }
+
+    // SAFE: Constant-time comparison để tránh timing attack
+    static func validatePIN(_ pin: String) throws -> Bool {
+        let saltBase64 = try KeychainService.readToken(key: saltKey)
+        let storedHashBase64 = try KeychainService.readToken(key: hashKey)
+        guard let salt = Data(base64Encoded: saltBase64),
+              let storedHash = Data(base64Encoded: storedHashBase64) else {
+            throw CryptoError.invalidStoredData
+        }
+        let inputHash = try derivePINKey(pin: pin, salt: salt)
+        // Constant-time comparison
+        return inputHash.withUnsafeBytes { inputBytes in
+            storedHash.withUnsafeBytes { storedBytes in
+                guard inputBytes.count == storedBytes.count else { return false }
+                return zip(inputBytes, storedBytes).reduce(0) { $0 | ($1.0 ^ $1.1) } == 0
+            }
+        }
+    }
+}
+
+enum CryptoError: Error {
+    case invalidInput, hashFailed, invalidStoredData
+}
+
+// BEST PRACTICE: Dùng LAContext thay vì PIN khi có thể
+// import LocalAuthentication
+// let context = LAContext()
+// context.evaluatePolicy(.deviceOwnerAuthenticationWithBiometrics, ...)
+```
+
+**Tools:** CryptoKit (iOS 13+), CommonCrypto, OWASP MASVS-AUTH-3, NIST SP 800-132 (PBKDF2)

package/skill-assets/sunlint-code-quality/rules/swift/S044-critical-changes-reauth.md

@@ -0,0 +1,145 @@
+---
+title: Yêu cầu xác thực lại khi thực hiện thao tác quan trọng
+impact: HIGH
+impactDescription: Không yêu cầu re-authentication cho thao tác nhạy cảm cho phép attacker có quyền truy cập vật lý vào device đang unlock thực hiện chuyển tiền, đổi mật khẩu, hoặc xóa account.
+tags: swift, ios, re-authentication, biometrics, local-authentication, face-id, touch-id, security
+---
+
+## Yêu cầu xác thực lại khi thực hiện thao tác quan trọng
+
+Các thao tác nhạy cảm (chuyển tiền, đổi email/password, xóa account, xem số tài khoản đầy đủ) phải yêu cầu xác thực lại bằng Face ID/Touch ID hoặc PIN ngay cả khi user đã đăng nhập. Đây là yêu cầu bắt buộc của OWASP MASVS và nhiều quy định tài chính.
+
+**Incorrect (không yêu cầu re-auth):**
+
+```swift
+import UIKit
+
+class BankingViewController: UIViewController {
+
+    // !! Chuyển tiền không cần xác thực lại - chỉ cần app đang mở
+    @IBAction func transferFundsTapped(_ sender: UIButton) {
+        let amount = amountField.text ?? "0"
+        let recipient = recipientField.text ?? ""
+        // Gọi API ngay không cần confirm identity!
+        transferFunds(amount: amount, recipient: recipient)
+    }
+
+    // !! Xem account number đầy đủ không cần re-auth
+    @IBAction func showFullAccountNumber(_ sender: UIButton) {
+        accountNumberLabel.text = fullAccountNumber  // Hiển thị ngay
+    }
+}
+```
+
+**Correct (require biometric re-auth):**
+
+```swift
+import LocalAuthentication
+import UIKit
+
+class ReAuthenticationService {
+    enum AuthPurpose {
+        case transferFunds(amount: Decimal)
+        case changePassword
+        case viewSensitiveData(type: String)
+        case deleteAccount
+
+        var reason: String {
+            switch self {
+            case .transferFunds(let amount):
+                return "Confirm transfer of \(amount) by authenticating"
+            case .changePassword:
+                return "Authenticate to change your password"
+            case .viewSensitiveData(let type):
+                return "Authenticate to view your \(type)"
+            case .deleteAccount:
+                return "Authenticate to permanently delete your account"
+            }
+        }
+    }
+
+    // SAFE: Require biometric/device passcode re-auth
+    func requireAuthentication(for purpose: AuthPurpose) async throws {
+        let context = LAContext()
+        context.localizedCancelTitle = "Cancel"
+
+        var error: NSError?
+        guard context.canEvaluatePolicy(.deviceOwnerAuthentication, error: &error) else {
+            throw AuthError.biometricNotAvailable(error?.localizedDescription ?? "")
+        }
+
+        try await withCheckedThrowingContinuation { (continuation: CheckedContinuation<Void, Error>) in
+            context.evaluatePolicy(
+                .deviceOwnerAuthentication,  // Fallback to passcode
+                localizedReason: purpose.reason
+            ) { success, evalError in
+                if success {
+                    continuation.resume()
+                } else {
+                    continuation.resume(throwing: AuthError.authenticationFailed(
+                        evalError?.localizedDescription ?? "Authentication failed"
+                    ))
+                }
+            }
+        }
+    }
+}
+
+class BankingViewController: UIViewController {
+    private let reAuthService = ReAuthenticationService()
+
+    // SAFE: Require biometric before transfer
+    @IBAction func transferFundsTapped(_ sender: UIButton) {
+        guard let amount = Decimal(string: amountField.text ?? "0") else { return }
+        let recipient = recipientField.text ?? ""
+
+        Task {
+            do {
+                try await reAuthService.requireAuthentication(for: .transferFunds(amount: amount))
+                // Auth passed - thực hiện transfer
+                await performTransfer(amount: amount, recipient: recipient)
+            } catch AuthError.authenticationFailed {
+                await MainActor.run {
+                    showAlert("Authentication required to transfer funds.")
+                }
+            } catch {
+                await MainActor.run {
+                    showAlert("Authentication unavailable. Please use PIN.")
+                }
+            }
+        }
+    }
+
+    // SAFE: Re-auth trước khi hiện số tài khoản
+    @IBAction func showFullAccountNumber(_ sender: UIButton) {
+        Task {
+            do {
+                try await reAuthService.requireAuthentication(for: .viewSensitiveData(type: "account number"))
+                await MainActor.run {
+                    accountNumberLabel.text = fullAccountNumber
+                    // Auto-hide sau 30 giây
+                    DispatchQueue.main.asyncAfter(deadline: .now() + 30) {
+                        self.accountNumberLabel.text = "•••• •••• 1234"
+                    }
+                }
+            } catch {
+                // Không hiển thị nếu auth fail
+            }
+        }
+    }
+}
+
+enum AuthError: LocalizedError {
+    case biometricNotAvailable(String)
+    case authenticationFailed(String)
+
+    var errorDescription: String? {
+        switch self {
+        case .biometricNotAvailable(let msg): return "Biometric not available: \(msg)"
+        case .authenticationFailed(let msg): return "Authentication failed: \(msg)"
+        }
+    }
+}
+```
+
+**Tools:** LocalAuthentication.framework, OWASP MASVS-AUTH-2, Apple Human Interface Guidelines (biometrics)

package/skill-assets/sunlint-code-quality/rules/swift/S045-debug-info-exposure.md

@@ -0,0 +1,116 @@
+---
+title: Không log thông tin nhạy cảm trong production build
+impact: HIGH
+impactDescription: print() và NSLog() trong iOS production build có thể bị đọc bởi device console (nếu device chưa enable device pairing protection) hoặc lộ trong crash report. Data nhạy cảm không được log ở bất kỳ level nào.
+tags: swift, ios, logging, debug, print, nslog, sensitive-data, security
+---
+
+## Không log thông tin nhạy cảm trong production build
+
+`print()` và `NSLog()` trong iOS production build vẫn in ra Console.app khi device được kết nối. Không log token, password, PII (tên, email, phone, địa chỉ), response body của API authentication, hoặc private key. Dùng conditional compilation `#if DEBUG` để chỉ log trong debug.
+
+**Incorrect (log sensitive data):**
+
+```swift
+import Foundation
+
+class AuthService {
+    // !! Log access token - đọc được qua Console.app
+    func handleLoginResponse(data: Data) {
+        if let json = try? JSONDecoder().decode(LoginResponse.self, from: data) {
+            print("Login success. Token: \(json.accessToken)")  // !! Token trong log!
+            NSLog("User logged in: %@, token: %@", json.username, json.accessToken)  // !!
+        }
+    }
+}
+
+class PaymentService {
+    // !! Log card number trong error
+    func processPayment(cardNumber: String, amount: Decimal) {
+        print("Processing payment for card: \(cardNumber), amount: \(amount)")  // Card number!
+        guard amount > 0 else {
+            NSLog("Invalid amount for card: %@", cardNumber)  // !! PCI violation
+            return
+        }
+    }
+}
+
+class NetworkLogger: URLProtocol {
+    // !! Log toàn bộ request/response body
+    override func startLoading() {
+        if let body = request.httpBody {
+            print("Request body: \(String(data: body, encoding: .utf8) ?? "")") // Có thể chứa password!
+        }
+    }
+}
+```
+
+**Correct (conditional logging, mask sensitive data):**
+
+```swift
+import Foundation
+import OSLog
+
+// SAFE: Dùng OSLog với privacy levels (iOS 14+)  
+private let logger = Logger(subsystem: Bundle.main.bundleIdentifier ?? "app", category: "Auth")
+
+class AuthService {
+    func handleLoginResponse(data: Data) {
+        if let json = try? JSONDecoder().decode(LoginResponse.self, from: data) {
+            // Log với private để tự động mask trong production
+            logger.info("Login success for user: \(json.userId, privacy: .public)")
+            // Token KHÔNG được log ở bất kỳ level nào
+        }
+    }
+}
+
+// SAFE: Wrapper log chỉ bật trong DEBUG
+struct AppLogger {
+    static func debug(_ message: String, file: String = #file, line: Int = #line) {
+        #if DEBUG
+        let filename = URL(fileURLWithPath: file).lastPathComponent
+        print("[\(filename):\(line)] \(message)")
+        #endif
+    }
+
+    static func info(_ message: @autoclosure () -> String) {
+        #if DEBUG
+        print("[INFO] \(message())")
+        #endif
+        // Trong production: dùng logging service như Crashlytics, DataDog
+    }
+
+    static func error(_ error: Error, context: [String: String] = [:]) {
+        // Log error nhưng mask sensitive fields
+        var safeContext = context
+        // Xóa các key nhạy cảm
+        ["token", "password", "card", "ssn", "email"].forEach { safeContext.removeValue(forKey: $0) }
+        logger.error("Error: \(error.localizedDescription, privacy: .public), context: \(safeContext)")
+    }
+}
+
+class PaymentService {
+    func processPayment(cardToken: String, amount: Decimal) {
+        // Log với masked card (chỉ 4 số cuối), không log full number
+        let maskedToken = String(cardToken.prefix(8)) + "..."
+        AppLogger.debug("Processing payment, token: \(maskedToken), amount: \(amount)")
+    }
+}
+
+// SAFE: Network logger mask sensitive headers
+class SafeNetworkLogger {
+    private let sensitiveHeaders = ["Authorization", "Cookie", "X-API-Key"]
+
+    func logRequest(_ request: URLRequest) {
+        #if DEBUG
+        var headers = request.allHTTPHeaderFields ?? [:]
+        sensitiveHeaders.forEach { key in
+            if headers[key] != nil { headers[key] = "[REDACTED]" }
+        }
+        AppLogger.debug("Request: \(request.url?.absoluteString ?? "") headers: \(headers)")
+        #endif
+    }
+}
+```
+
+**Tools:** OSLog privacy levels (iOS 14+), Crashlytics, OWASP MASVS-STORAGE-2, Console.app (verify logs)