@sun-asterisk/sunlint 1.3.47 → 1.3.49

package/skill-assets/sunlint-code-quality/rules/swift/S005-server-authorization.md

@@ -0,0 +1,73 @@
+---
+title: Luôn kiểm tra quyền truy cập phía server - không tin vào UI ẩn
+impact: HIGH
+impactDescription: Ẩn nút/màn hình ở client không ngăn được attacker gọi trực tiếp vào API. Server phải luôn là nơi kiểm tra quyền cuối cùng.
+tags: swift, ios, authorization, server-side, api-security, security
+---
+
+## Luôn kiểm tra quyền truy cập phía server - không tin vào UI ẩn
+
+iOS app thường ẩn tính năng theo role, nhưng đây chỉ là UX. Server phải enforce authorization: kiểm tra token/role trong mỗi API request và trả về 401/403 khi vi phạm. Client không được là người quyết định quyền cuối cùng.
+
+**Incorrect (chỉ kiểm tra phía client):**
+
+```swift
+// !! Chỉ ẩn nút theo role cục bộ - không gọi server check
+struct AdminDashboardView: View {
+    @EnvironmentObject var authManager: AuthManager
+
+    var body: some View {
+        if authManager.currentUser?.role == "admin" {  // Check phía client
+            Button("Delete User") { deleteUser() }
+        }
+    }
+
+    // API bên trong không gửi kèm authorization header
+    func deleteUser() {
+        let url = URL(string: "https://api.example.com/admin/users/1")!
+        var request = URLRequest(url: url)
+        request.httpMethod = "DELETE"
+        // Không có Authorization header!
+        URLSession.shared.dataTask(with: request).resume()
+    }
+}
+```
+
+**Correct (server enforces authorization):**
+
+```swift
+struct AdminDashboardView: View {
+    @EnvironmentObject var authManager: AuthManager
+
+    var body: some View {
+        // UI ẩn chỉ là UX - server vẫn sẽ reject nếu gọi sai
+        if authManager.currentUser?.role == "admin" {
+            Button("Delete User") { deleteUser() }
+        }
+    }
+
+    // SAFE: Luôn gửi Bearer token để server kiểm tra quyền
+    func deleteUser() {
+        guard let token = authManager.accessToken else { return }
+        let url = URL(string: "https://api.example.com/admin/users/1")!
+        var request = URLRequest(url: url)
+        request.httpMethod = "DELETE"
+        request.setValue("Bearer \(token)", forHTTPHeaderField: "Authorization")
+        URLSession.shared.dataTask(with: request) { data, response, error in
+            guard let httpResponse = response as? HTTPURLResponse else { return }
+            if httpResponse.statusCode == 403 {
+                // Server từ chối - xử lý gracefully
+                DispatchQueue.main.async {
+                    authManager.handleUnauthorized()
+                }
+            }
+        }.resume()
+    }
+}
+
+// Server-side (ví dụ Vapor): kiểm tra role trong middleware
+// app.grouped(RoleMiddleware(requiredRole: "admin"))
+//    .delete("admin", "users", ":userId", use: deleteUserHandler)
+```
+
+**Tools:** Proxyman (intercept requests), OWASP MASVS-AUTH-1, Burp Suite Mobile

package/skill-assets/sunlint-code-quality/rules/swift/S006-default-credentials.md

@@ -0,0 +1,76 @@
+---
+title: Không để credential mặc định hoặc hardcode mật khẩu trong app
+impact: HIGH
+impactDescription: Credential mặc định hoặc mật khẩu hardcode trong source code có thể bị phát hiện qua reverse engineering hoặc static analysis, cho phép truy cập trái phép.
+tags: swift, ios, credentials, hardcode, default-password, security
+---
+
+## Không để credential mặc định hoặc hardcode mật khẩu trong app
+
+Không hardcode username/password, API key hoặc encryption key dưới dạng string literals trong code Swift. Đây là lỗi phổ biến nhất trong mobile app security. Dùng Keychain hoặc load từ server sau khi authenticate.
+
+**Incorrect (hardcode credential):**
+
+```swift
+// !! Credential hardcode trong code
+struct AuthService {
+    private let adminUsername = "admin"
+    private let adminPassword = "admin123"  // Hardcode!
+
+    func loginAdmin() {
+        let credentials = "\(adminUsername):\(adminPassword)"
+            .data(using: .utf8)!
+            .base64EncodedString()
+        // Bất kỳ ai có binary app đều đọc được qua strings command
+    }
+}
+
+// !! API key hardcode
+class AnalyticsService {
+    private let apiKey = "AIzaSyD-hardcoded-key-abc123"  // Lộ sau khi decompile!
+    private let encryptionKey = "mySecretKey1234"  // Nguy hiểm!
+}
+
+// !! Default profile cho testing còn sót lại production
+let defaultPIN = "1234"
+let testAccountPassword = "Test@123"
+```
+
+**Correct (load từ secure source):**
+
+```swift
+// SAFE: Load API key từ xcconfig / remote config
+class AnalyticsService {
+    private let apiKey: String
+
+    init() {
+        // Load từ Info.plist (giá trị inject qua xcconfig trong CI/CD)
+        guard let key = Bundle.main.infoDictionary?["ANALYTICS_API_KEY"] as? String,
+              !key.isEmpty else {
+            fatalError("ANALYTICS_API_KEY not configured")
+        }
+        self.apiKey = key
+    }
+}
+
+// SAFE: Encryption key sinh ngẫu nhiên và lưu Keychain
+class EncryptionKeyManager {
+    private let keychainKey = "com.app.encryptionKey"
+
+    func getOrCreateKey() throws -> SymmetricKey {
+        if let keyData = try KeychainHelper.read(key: keychainKey) {
+            return SymmetricKey(data: keyData)
+        }
+        // Sinh key ngẫu nhiên, không hardcode
+        let newKey = SymmetricKey(size: .bits256)
+        let keyData = newKey.withUnsafeBytes { Data($0) }
+        try KeychainHelper.save(key: keychainKey, data: keyData)
+        return newKey
+    }
+}
+
+// Test credentials phải dùng environment variable trong CI
+// Không commit file chứa test password vào Git
+```
+
+**Tools:** SwiftLint (no_hardcoded_strings custom rule), `strings` binary analysis, OWASP MASVS-STORAGE-2, detect-secrets

package/skill-assets/sunlint-code-quality/rules/swift/S007-output-encoding.md

@@ -0,0 +1,96 @@
+---
+title: Encode output khi render nội dung người dùng trong WKWebView
+impact: HIGH
+impactDescription: Render chuỗi người dùng trực tiếp vào HTML trong WKWebView dẫn đến XSS - attacker có thể đọc dữ liệu nhạy cảm, thực hiện localStorage/cookie theft hoặc gọi native bridge.
+tags: swift, ios, xss, wkwebview, output-encoding, javascript, security
+---
+
+## Encode output khi render nội dung người dùng trong WKWebView
+
+Khi inject nội dung từ người dùng vào WKWebView bằng `evaluateJavaScript` hoặc `loadHTMLString`, phải escape các ký tự HTML/JS đặc biệt. Không tin vào bất kỳ chuỗi nào từ server response hoặc user input khi render vào web context.
+
+**Incorrect (inject thẳng vào HTML/JS):**
+
+```swift
+import WebKit
+
+class ChatViewController: UIViewController {
+    var webView: WKWebView!
+
+    // !! Inject tên người dùng thẳng vào JS - XSS!
+    func displayMessage(_ message: String, from sender: String) {
+        // Nếu sender = "</script><script>alert(1)</script>" thì XSS!
+        let js = "displayMessage('\(message)', '\(sender)')"
+        webView.evaluateJavaScript(js, completionHandler: nil)
+    }
+
+    // !! loadHTMLString với nội dung không được sanitize
+    func renderUserProfile(bio: String) {
+        let html = "<html><body><p>\(bio)</p></body></html>"  // XSS!
+        webView.loadHTMLString(html, baseURL: nil)
+    }
+}
+```
+
+**Correct (escape trước khi inject):**
+
+```swift
+import WebKit
+
+extension String {
+    // Escape cho JavaScript string context
+    var jsEscaped: String {
+        var result = self
+            .replacingOccurrences(of: "\\", with: "\\\\")
+            .replacingOccurrences(of: "'", with: "\\'")
+            .replacingOccurrences(of: "\"", with: "\\\"")
+            .replacingOccurrences(of: "\n", with: "\\n")
+            .replacingOccurrences(of: "\r", with: "\\r")
+        return result
+    }
+
+    // Escape cho HTML context
+    var htmlEscaped: String {
+        return self
+            .replacingOccurrences(of: "&", with: "&amp;")
+            .replacingOccurrences(of: "<", with: "&lt;")
+            .replacingOccurrences(of: ">", with: "&gt;")
+            .replacingOccurrences(of: "\"", with: "&quot;")
+            .replacingOccurrences(of: "'", with: "&#x27;")
+    }
+}
+
+class ChatViewController: UIViewController {
+    var webView: WKWebView!
+
+    // SAFE: Escape JS string trước khi inject
+    func displayMessage(_ message: String, from sender: String) {
+        let safeMessage = message.jsEscaped
+        let safeSender = sender.jsEscaped
+        let js = "displayMessage('\(safeMessage)', '\(safeSender)')"
+        webView.evaluateJavaScript(js, completionHandler: nil)
+    }
+
+    // SAFER: Truyền data qua postMessage thay vì concat string
+    func sendDataToWebView(data: [String: Any]) {
+        guard let jsonData = try? JSONSerialization.data(withJSONObject: data),
+              let jsonStr = String(data: jsonData, encoding: .utf8) else { return }
+        // JSON tự escape, không bị inject
+        let js = "window.dispatchEvent(new CustomEvent('nativeMessage', {detail: \(jsonStr)}))"
+        webView.evaluateJavaScript(js, completionHandler: nil)
+    }
+
+    // SAFE: loadHTMLString với escaping
+    func renderUserProfile(bio: String) {
+        let safeBio = bio.htmlEscaped
+        let html = """
+        <html><body>
+        <p>\(safeBio)</p>
+        </body></html>
+        """
+        webView.loadHTMLString(html, baseURL: nil)
+    }
+}
+```
+
+**Tools:** SwiftLint, OWASP MASVS-PLATFORM-2, Burp Suite (intercept WebView traffic)

package/skill-assets/sunlint-code-quality/rules/swift/S009-approved-crypto.md

@@ -0,0 +1,86 @@
+---
+title: Chỉ dùng thuật toán mã hóa an toàn (CryptoKit)
+impact: CRITICAL
+impactDescription: Thuật toán MD5, SHA1, DES đã bị bẻ gãy và không đảm bảo bảo mật. Dữ liệu mã hóa bằng thuật toán yếu có thể bị giải mã bởi attacker.
+tags: swift, ios, cryptography, cryptokit, security, hashing, encryption
+---
+
+## Chỉ dùng thuật toán mã hóa an toàn (CryptoKit)
+
+Dùng Apple **CryptoKit** (iOS 13+) thay vì CommonCrypto cho mã hóa mới. Tránh hoàn toàn MD5, SHA1, DES, và chế độ ECB. Dùng AES-GCM hoặc ChaChaPoly cho encryption, SHA-256+ cho hashing.
+
+**Incorrect (thuật toán yếu):**
+
+```swift
+import CommonCrypto
+
+// !! MD5 - đã bị bẻ gãy, tìm collision dễ dàng
+func md5Hash(_ string: String) -> String {
+    let data = string.data(using: .utf8)!
+    var digest = [UInt8](repeating: 0, count: Int(CC_MD5_DIGEST_LENGTH))
+    CC_MD5(data.bytes, CC_LONG(data.count), &digest)
+    return digest.map { String(format: "%02x", $0) }.joined()
+}
+
+// !! SHA1 - không đủ bảo mật
+func sha1Hash(_ data: Data) -> Data {
+    var digest = [UInt8](repeating: 0, count: Int(CC_SHA1_DIGEST_LENGTH))
+    data.withUnsafeBytes { CC_SHA1($0.baseAddress, CC_LONG(data.count), &digest) }
+    return Data(digest)
+}
+
+// !! DES - key chỉ 56 bit, có thể brute force
+func desEncrypt(_ data: Data, key: Data) -> Data? {
+    return symmetric(data: data, key: key, algorithm: kCCAlgorithmDES, operation: kCCEncrypt)
+}
+```
+
+**Correct (CryptoKit với thuật toán an toàn):**
+
+```swift
+import CryptoKit
+
+// SHA-256 cho hashing dữ liệu (không phải password)
+func sha256Hash(_ data: Data) -> String {
+    let digest = SHA256.hash(data: data)
+    return digest.map { String(format: "%02x", $0) }.joined()
+}
+
+// AES-GCM cho symmetric encryption (authenticated + encrypted)
+func encryptData(_ data: Data, using key: SymmetricKey) throws -> Data {
+    let sealedBox = try AES.GCM.seal(data, using: key)
+    return sealedBox.combined!
+}
+
+func decryptData(_ encryptedData: Data, using key: SymmetricKey) throws -> Data {
+    let sealedBox = try AES.GCM.SealedBox(combined: encryptedData)
+    return try AES.GCM.open(sealedBox, using: key)
+}
+
+// Tạo key an toàn
+func generateEncryptionKey() -> SymmetricKey {
+    return SymmetricKey(size: .bits256)  // 256-bit AES key
+}
+
+// Cho password hashing - dùng bên server, trên iOS verify
+// Dùng PBKDF2 nếu cần derive key từ password
+func deriveKey(from password: String, salt: Data) -> SymmetricKey {
+    let keyData = PKCS5.PBKDF2(password: Array(password.utf8),
+                                salt: Array(salt),
+                                iterations: 100_000,
+                                keyLength: 32,
+                                variant: .sha2(.sha256)).calculate()
+    return SymmetricKey(data: Data(keyData))
+}
+```
+
+**Approved vs Prohibited:**
+
+| Mục đích | Nên dùng | Không dùng |
+|---------|----------|------------|
+| Hash | SHA-256, SHA-3, BLAKE2 | MD5, SHA-1 |
+| Mã hóa | AES-GCM (256-bit), ChaChaPoly | DES, 3DES, AES-ECB |
+| Chữ ký | P-256, P-384, Curve25519 | RSA < 2048-bit |
+
+**Tools:** CryptoKit, Code Review, MobSF
+

package/skill-assets/sunlint-code-quality/rules/swift/S010-csprng.md

@@ -0,0 +1,71 @@
+---
+title: Dùng SecRandomCopyBytes cho random bảo mật
+impact: HIGH
+impactDescription: arc4random, drand48 và random() không phải CSPRNG thực sự và có thể bị predict. Dùng chúng để tạo token hay nonce là lỗ hổng bảo mật.
+tags: swift, ios, csprng, random, security, nonce, token
+---
+
+## Dùng SecRandomCopyBytes cho random bảo mật
+
+Khi cần số ngẫu nhiên cho mục đích bảo mật (token, nonce, IV, session ID), phải dùng `SecRandomCopyBytes` (Security framework) hoặc `CryptoKit`'s `random()`. `arc4random_uniform()`, `Int.random()`, hay `drand48()` là PRNG thông thường, không phù hợp cho mục đích security.
+
+**Incorrect (PRNG không an toàn cho security):**
+
+```swift
+// !! arc4random không đủ entropy cho security token
+func generateSessionToken() -> String {
+    let chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
+    return String((0..<32).map { _ in chars.randomElement()! })  // randomElement() dùng PRNG
+}
+
+// !! Int.random không phải CSPRNG
+func generateOTPCode() -> String {
+    return String(format: "%06d", Int.random(in: 100000...999999))
+}
+
+// !! drand48 hoàn toàn không an toàn
+func generateNonce() -> Double {
+    return drand48()
+}
+```
+
+**Correct (CSPRNG cho security-sensitive randomness):**
+
+```swift
+import Security
+import CryptoKit
+
+// Secure random bytes dùng Security framework
+func generateSecureToken(length: Int = 32) -> Data? {
+    var randomBytes = [UInt8](repeating: 0, count: length)
+    let status = SecRandomCopyBytes(kSecRandomDefault, length, &randomBytes)
+    guard status == errSecSuccess else { return nil }
+    return Data(randomBytes)
+}
+
+// Tạo session token dạng hex string (64 chars = 32 bytes = 256-bit entropy)
+func generateSessionToken() -> String {
+    guard let tokenData = generateSecureToken(length: 32) else {
+        fatalError("Security framework unavailable")
+    }
+    return tokenData.map { String(format: "%02x", $0) }.joined()
+}
+
+// Nonce cho AES-GCM (CryptoKit tự tạo random nonce)
+func encryptWithRandomNonce(_ data: Data, key: SymmetricKey) throws -> AES.GCM.SealedBox {
+    // CryptoKit tự tạo random nonce dùng CSPRNG
+    return try AES.GCM.seal(data, using: key)
+}
+
+// PKCE code verifier cho OAuth
+func generatePKCECodeVerifier() -> String {
+    guard let bytes = generateSecureToken(length: 32) else { fatalError() }
+    return bytes.base64EncodedString()
+        .replacingOccurrences(of: "+", with: "-")
+        .replacingOccurrences(of: "/", with: "_")
+        .replacingOccurrences(of: "=", with: "")
+}
+```
+
+**Tools:** Security framework (`SecRandomCopyBytes`), CryptoKit, Code Review
+

package/skill-assets/sunlint-code-quality/rules/swift/S011-insecure-deserialization.md

@@ -0,0 +1,74 @@
+---
+title: Không deserialize dữ liệu không tin cậy bằng NSKeyedUnarchiver
+impact: HIGH
+impactDescription: NSKeyedUnarchiver không giới hạn lớp có thể unarchive mặc định, cho phép gadget chain attacks dẫn đến arbitrary code execution khi xử lý dữ liệu từ server không đáng tin hoặc từ clipboard.
+tags: swift, ios, deserialization, nskeyedunarchiver, codable, security
+---
+
+## Không deserialize dữ liệu không tin cậy bằng NSKeyedUnarchiver
+
+`NSKeyedUnarchiver.unarchiveObject(with:)` (deprecated nhưng vẫn phổ biến) không an toàn vì không giới hạn class. Phải dùng `unarchivedObject(ofClass:from:)` với whitelist class cụ thể, hoặc ưu tiên dùng `Codable`/`JSONDecoder` cho server data.
+
+**Incorrect (unarchive không có class restriction):**
+
+```swift
+import Foundation
+
+// !! Unsafe - không giới hạn class, vulnerable to gadget chain
+func restoreCart(from data: Data) -> ShoppingCart? {
+    // Deprecated API, không an toàn với data từ server
+    return NSKeyedUnarchiver.unarchiveObject(with: data) as? ShoppingCart
+}
+
+// !! Unarchive data từ UserDefaults (attacker có thể sửa trên jailbroken device)
+func loadCachedUser() -> User? {
+    guard let data = UserDefaults.standard.data(forKey: "cached_user") else { return nil }
+    return try? NSKeyedUnarchiver.unarchivedObject(
+        ofClasses: [NSObject.self],  // !! Quá rộng - accept mọi class
+        from: data
+    ) as? User
+}
+```
+
+**Correct (whitelist class hoặc dùng Codable):**
+
+```swift
+import Foundation
+
+// SAFE: Whitelist class cụ thể
+func restoreCart(from data: Data) throws -> ShoppingCart? {
+    return try NSKeyedUnarchiver.unarchivedObject(
+        ofClass: ShoppingCart.self,  // Chỉ accept ShoppingCart
+        from: data
+    )
+}
+
+// BEST: Dùng Codable cho server data - an toàn hơn nhiều
+struct ShoppingCart: Codable {
+    let id: UUID
+    let items: [CartItem]
+    let totalAmount: Decimal
+}
+
+struct CartItem: Codable {
+    let productId: String
+    let quantity: Int
+    let price: Decimal
+}
+
+func parseCartResponse(data: Data) throws -> ShoppingCart {
+    let decoder = JSONDecoder()
+    decoder.dateDecodingStrategy = .iso8601
+    return try decoder.decode(ShoppingCart.self, from: data)
+}
+
+// SAFE: Nếu bắt buộc dùng NSKeyedUnarchiver, whitelist rõ ràng
+func loadUserFromCache(data: Data) throws -> User? {
+    return try NSKeyedUnarchiver.unarchivedObject(
+        ofClasses: [User.self, NSString.self, NSNumber.self, NSUUID.self],
+        from: data
+    ) as? User
+}
+```
+
+**Tools:** OWASP MASVS-CODE-4, Instruments, Static analysis (semgrep rule: use-of-nskeyedunarchiver)

package/skill-assets/sunlint-code-quality/rules/swift/S012-secrets-management.md

@@ -0,0 +1,81 @@
+---
+title: Quản lý secret bằng xcconfig - không commit vào Git
+impact: CRITICAL
+impactDescription: Secret hardcode trong source code bị lộ qua Git history vĩnh viễn, kể cả sau khi xóa. Hàng nghìn app iOS thực tế đã bị leak API key vì vấn đề này.
+tags: swift, ios, secrets, api-keys, xcconfig, security, git
+---
+
+## Quản lý secret bằng xcconfig - không commit vào Git
+
+API key, client secret, private key không được xuất hiện trong file `.swift`, `.plist` hay bất kỳ file nào được commit. Dùng `.xcconfig` file riêng theo môi trường và thêm vào `.gitignore`. Với runtime secrets (token), lưu trong Keychain.
+
+**Incorrect (secret trong source code):**
+
+```swift
+// !! Sẽ bị lộ qua git log dù đã xóa sau này
+struct APIConfig {
+    static let googleMapsKey = "AIzaSyD-actual-real-key-here"
+    static let stripePublishableKey = "pk_live_actual-stripe-key"
+    static let firebaseWebAPIKey = "AIzaSyB-firebase-key"
+}
+
+// !! Secret trong plist cũng không an toàn nếu commit
+// GoogleService-Info.plist với CURRENT_KEY hardcode và commit vào git
+```
+
+**Correct (xcconfig + Keychain cho runtime secrets):**
+
+```swift
+// Bước 1: Tạo file Secrets.xcconfig (thêm vào .gitignore ngay)
+// Secrets.xcconfig (KHÔNG commit):
+// GOOGLE_MAPS_API_KEY = AIzaSyD-actual-key
+// STRIPE_PUBLISHABLE_KEY = pk_live_key
+
+// Bước 2: Config.xcconfig (commit được, reference tới Secrets)
+// #include "Secrets.xcconfig"
+// API_KEY = $(GOOGLE_MAPS_API_KEY)
+
+// Bước 3: Info.plist - đọc từ build setting
+// <key>GoogleMapsAPIKey</key>
+// <string>$(API_KEY)</string>
+
+// Bước 4: Đọc trong Swift code
+struct APIConfig {
+    static var googleMapsKey: String {
+        guard let key = Bundle.main.infoDictionary?["GoogleMapsAPIKey"] as? String,
+              !key.isEmpty else {
+            #if DEBUG
+            fatalError("GoogleMapsAPIKey not configured. Create Secrets.xcconfig")
+            #else
+            return ""
+            #endif
+        }
+        return key
+    }
+}
+
+// Bước 5: CI/CD - inject via environment variable
+// fastlane/Fastfile:
+// xcconfig_contents = "GOOGLE_MAPS_API_KEY = #{ENV['GOOGLE_MAPS_API_KEY']}"
+// File.write("Secrets.xcconfig", xcconfig_contents)
+
+// Runtime secrets (OAuth tokens) - lưu Keychain sau khi nhận từ server
+class SecureStorage {
+    static func saveToken(_ token: String, key: String) throws {
+        let query: [String: Any] = [
+            kSecClass as String: kSecClassGenericPassword,
+            kSecAttrAccount as String: key,
+            kSecValueData as String: token.data(using: .utf8)!,
+            kSecAttrAccessible as String: kSecAttrAccessibleWhenUnlockedThisDeviceOnly
+        ]
+        SecItemDelete(query as CFDictionary)
+        let status = SecItemAdd(query as CFDictionary, nil)
+        guard status == errSecSuccess else {
+            throw KeychainError.saveFailed(status)
+        }
+    }
+}
+```
+
+**Tools:** `.gitignore`, `git-secrets`, `detect-secrets`, Fastlane environment variables
+

package/skill-assets/sunlint-code-quality/rules/swift/S013-tls-connections.md

@@ -0,0 +1,67 @@
+---
+title: Bắt buộc TLS cho mọi kết nối mạng - không tắt App Transport Security
+impact: CRITICAL
+impactDescription: Tắt ATS hoặc cho phép HTTP cleartext khiến dữ liệu người dùng bị đọc dễ dàng qua man-in-the-middle attack trên mạng WiFi công cộng.
+tags: swift, ios, tls, ats, app-transport-security, https, security
+---
+
+## Bắt buộc TLS cho mọi kết nối mạng - không tắt App Transport Security
+
+App Transport Security (ATS) bắt buộc HTTPS cho tất cả kết nối theo mặc định. Không được set `NSAllowsArbitraryLoads = YES` trừ trường hợp đặc biệt có lý do. Nếu cần exception, phải hạn chế theo domain cụ thể.
+
+**Incorrect (tắt hoàn toàn ATS):**
+
+```xml
+<!-- Info.plist - NGUY HIỂM: tắt hoàn toàn ATS -->
+<key>NSAppTransportSecurity</key>
+<dict>
+    <key>NSAllowsArbitraryLoads</key>
+    <true/>  <!-- Cho phép HTTP tất cả domains! -->
+</dict>
+```
+
+```swift
+// !! Kết nối HTTP thuần
+let url = URL(string: "http://api.example.com/users")!  // HTTP!
+let task = URLSession.shared.dataTask(with: url) { data, _, _ in
+    // Dữ liệu truyền cleartext
+}
+```
+
+**Correct (giữ ATS mặc định, exception theo domain nếu cần):**
+
+```xml
+<!-- Info.plist - không cần khai báo nếu chỉ dùng HTTPS -->
+<!-- Nếu cần exception cho domain cụ thể (legacy, third-party) -->
+<key>NSAppTransportSecurity</key>
+<dict>
+    <!-- KHÔNG để NSAllowsArbitraryLoads = true -->
+    <key>NSExceptionDomains</key>
+    <dict>
+        <!-- Chỉ exception domain cụ thể với lý do rõ ràng -->
+        <key>legacy.thirdparty.com</key>
+        <dict>
+            <key>NSExceptionAllowsInsecureHTTPLoads</key>
+            <true/>
+            <!-- Và document lý do trong code review -->
+        </dict>
+    </dict>
+</dict>
+```
+
+```swift
+// Luôn dùng HTTPS
+let url = URL(string: "https://api.example.com/users")!
+
+// Kiểm tra scheme trước khi request
+func makeSecureRequest(urlString: String) throws -> URLRequest {
+    guard let url = URL(string: urlString),
+          url.scheme == "https" else {
+        throw NetworkError.insecureURL(urlString)
+    }
+    return URLRequest(url: url)
+}
+```
+
+**Tools:** Xcode ATS Checker, Apple App Review Guidelines, MASVS-NETWORK
+