@sun-asterisk/sunlint 1.3.48 → 1.3.49

package/skill-assets/sunlint-code-quality/rules/swift/C041-no-hardcoded-secrets.md

@@ -0,0 +1,65 @@
+---
+title: Không hardcode thông tin nhạy cảm trong source code
+impact: CRITICAL
+impactDescription: Secret hardcode trong source sẽ bị lộ qua Git history, binary dump hay reverse engineering, gây rò rỉ toàn bộ hệ thống.
+tags: swift, ios, secrets, security, api-keys, hardcoded
+---
+
+## Không hardcode thông tin nhạy cảm trong source code
+
+API key, token, password, private key không được viết trực tiếp trong `.swift` file hay `.plist`. Dùng biến môi trường (CI/CD), `.xcconfig` file (không commit), hay Keychain để lưu runtime secrets.
+
+**Incorrect (hardcode secrets):**
+
+```swift
+// !! API key visible trong source code
+struct APIConfig {
+    static let apiKey = "sk_live_AbC123XyZ789"
+    static let secretToken = "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9..."
+    static let databasePassword = "MyS3cr3tPass!"
+}
+
+class AnalyticsService {
+    private let firebaseKey = "AIzaSyC-abc123-real-key"  // hardcode
+    private let mixpanelToken = "a1b2c3d4e5f6"            // hardcode
+}
+```
+
+**Correct (lấy secret từ xcconfig hay environment):**
+
+```swift
+// Config.xcconfig (được thêm vào .gitignore)
+// API_KEY = sk_live_AbC123XyZ789
+
+// Info.plist (đọc giá trị từ xcconfig - không commit secret)
+// <key>APIKey</key>
+// <string>$(API_KEY)</string>
+
+struct APIConfig {
+    // Đọc từ Info.plist (value đến từ xcconfig không commit)
+    static var apiKey: String {
+        Bundle.main.infoDictionary?["APIKey"] as? String ?? ""
+    }
+}
+
+// Secrets nhạy cảm hơn (user token, refresh token) - lưu Keychain
+class TokenManager {
+    func saveAccessToken(_ token: String) throws {
+        try KeychainManager.save(key: "access_token", value: token)
+    }
+
+    func retrieveAccessToken() -> String? {
+        return try? KeychainManager.load(key: "access_token")
+    }
+}
+```
+
+**Kiểm tra trước khi commit:**
+
+```bash
+# Dùng git-secrets hoặc truffleHog để scan
+git secrets --scan
+```
+
+**Tools:** `git-secrets`, `truffleHog`, `.gitignore` cho `.xcconfig`, SwiftLint custom rule
+

package/skill-assets/sunlint-code-quality/rules/swift/C042-boolean-naming.md

@@ -0,0 +1,60 @@
+---
+title: Biến Boolean phải bắt đầu bằng is, has, hoặc should
+impact: LOW
+impactDescription: Tiền tố is/has/should làm rõ biến là kiểu Boolean, tránh nhầm lẫn với biến trạng thái khác và cải thiện tính đọc của code.
+tags: swift, ios, naming, boolean, code-quality, readability
+---
+
+## Biến Boolean phải bắt đầu bằng is, has, hoặc should
+
+Property/biến kiểu `Bool` phải có tên bắt đầu bằng `is`, `has`, `should`, `can`, `will` hoặc `allow`. Điều này là convention của Swift API Design Guidelines.
+
+**Incorrect (tên Boolean không rõ):**
+
+```swift
+class UserSession {
+    var login: Bool = false          // isLoggedIn?
+    var premium: Bool = false        // isPremium?
+    var notification: Bool = true    // hasNotification? isNotificationEnabled?
+    var error: Bool = false          // hasError?
+    var loaded: Bool = false         // isLoaded?
+}
+
+struct FeatureFlags {
+    var darkMode: Bool = false       // isDarkModeEnabled?
+    var biometric: Bool = false      // isBiometricEnabled?
+    var analytics: Bool = true       // shouldTrackAnalytics?
+}
+```
+
+**Correct (tên Boolean rõ ràng):**
+
+```swift
+class UserSession {
+    var isLoggedIn: Bool = false
+    var isPremiumUser: Bool = false
+    var hasUnreadNotifications: Bool = true
+    var hasError: Bool = false
+    var isDataLoaded: Bool = false
+}
+
+struct FeatureFlags {
+    var isDarkModeEnabled: Bool = false
+    var isBiometricEnabled: Bool = false
+    var shouldTrackAnalytics: Bool = true
+    var canAccessPremiumContent: Bool = false
+    var willShowOnboarding: Bool = true
+}
+
+// SwiftUI @State
+struct ContentView: View {
+    @State private var isShowingAlert = false
+    @State private var isLoading = false
+    @State private var hasCompletedOnboarding = false
+
+    var body: some View { ... }
+}
+```
+
+**Tools:** SwiftLint (`identifier_name`), Code Review
+

package/skill-assets/sunlint-code-quality/rules/swift/C052-controller-parsing.md

@@ -0,0 +1,67 @@
+---
+title: Không để logic parsing/mapping trong ViewController
+impact: HIGH
+impactDescription: Logic phân tích dữ liệu trong ViewController làm phình to class, khó test và vi phạm Single Responsibility Principle.
+tags: swift, ios, mvc, mvvm, viewcontroller, parsing, architecture
+---
+
+## Không để logic parsing/mapping trong ViewController
+
+ViewController chỉ nên lo presentation: bind data lên UI, xử lý user interaction. Logic parse JSON, map model sang ViewModel, validate, hay transform dữ liệu phải nằm trong tầng riêng (ViewModel, Mapper, UseCase).
+
+**Incorrect (parsing/mapping trong ViewController):**
+
+```swift
+class OrderListViewController: UIViewController {
+
+    // !! Logic mapping trong VC
+    func configureCell(_ cell: OrderCell, with orderData: [String: Any]) {
+        let id = orderData["id"] as? String ?? ""
+        let status = orderData["status"] as? String ?? "unknown"
+        let amount = orderData["total_amount"] as? Double ?? 0.0
+        let dateString = orderData["created_at"] as? String ?? ""
+
+        // Date parsing trực tiếp trong VC
+        let formatter = ISO8601DateFormatter()
+        let date = formatter.date(from: dateString) ?? Date()
+        let displayDate = DateFormatter.medium.string(from: date)
+
+        cell.orderIdLabel.text = "#\(id)"
+        cell.statusLabel.text = status.capitalized
+        cell.amountLabel.text = "$\(String(format: "%.2f", amount))"
+        cell.dateLabel.text = displayDate
+    }
+}
+```
+
+**Correct (VC chỉ bind, ViewModel lo mapping):**
+
+```swift
+// OrderViewModel - lo mapping và formatting
+struct OrderViewModel {
+    let displayId: String
+    let statusText: String
+    let formattedAmount: String
+    let displayDate: String
+
+    init(order: Order) {
+        self.displayId = "#\(order.id)"
+        self.statusText = order.status.localizedTitle
+        self.formattedAmount = NumberFormatter.currency.string(from: NSNumber(value: order.totalAmount)) ?? ""
+        self.displayDate = DateFormatter.medium.string(from: order.createdAt)
+    }
+}
+
+// ViewController - chỉ bind data lên UI
+class OrderListViewController: UIViewController {
+    func configureCell(_ cell: OrderCell, with viewModel: OrderViewModel) {
+        cell.orderIdLabel.text = viewModel.displayId
+        cell.statusLabel.text = viewModel.statusText
+        cell.amountLabel.text = viewModel.formattedAmount
+        cell.dateLabel.text = viewModel.displayDate
+    }
+}
+```
+
+**Tools:** Code Review, Unit Tests (ViewModel test không cần UIKit)
+

package/skill-assets/sunlint-code-quality/rules/swift/C060-superclass-logic.md

@@ -0,0 +1,95 @@
+---
+title: Không đặt quá nhiều logic trong superclass
+impact: MEDIUM
+impactDescription: Superclass phình to tạo coupling cao giữa subclasses, khó bảo trì và dễ vô tình break subclass khi thay đổi base class.
+tags: swift, ios, inheritance, superclass, composition, architecture
+---
+
+## Không đặt quá nhiều logic trong superclass
+
+Thay vì nhồi logic vào `BaseViewController` hay `BaseViewModel`, hãy dùng **composition** qua protocol extension hoặc delegate. Superclass chỉ nên chứa logic thực sự chung cho mọi subclass.
+
+**Incorrect (BaseViewController quá nặng):**
+
+```swift
+class BaseViewController: UIViewController {
+    // Networking
+    func makeAPICall<T>(url: URL, completion: @escaping (Result<T, Error>) -> Void) { ... }
+
+    // Analytics
+    func trackScreenView(name: String) { ... }
+    func trackEvent(_ event: String, parameters: [String: Any]) { ... }
+
+    // Loading
+    func showLoading() { ... }
+    func hideLoading() { ... }
+
+    // Alert
+    func showAlert(title: String, message: String) { ... }
+    func showErrorAlert(_ error: Error) { ... }
+
+    // Navigation
+    func pushViewController(_ vc: UIViewController, animated: Bool) { ... }
+
+    // Keyboard
+    func setupKeyboardDismissal() { ... }
+    var keyboardHeight: CGFloat { ... }
+
+    // Tất cả ViewController đều kế thừa hết dù không cần!
+}
+```
+
+**Correct (composition qua protocol + extension):**
+
+```swift
+// Tách thành protocol có thể opt-in
+protocol LoadingDisplayable: UIViewController {
+    func showLoading()
+    func hideLoading()
+}
+
+extension LoadingDisplayable {
+    func showLoading() {
+        LoadingOverlay.show(in: view)
+    }
+    func hideLoading() {
+        LoadingOverlay.hide(from: view)
+    }
+}
+
+protocol ErrorAlertDisplayable: UIViewController {
+    func showErrorAlert(_ error: Error)
+}
+extension ErrorAlertDisplayable {
+    func showErrorAlert(_ error: Error) {
+        let alert = UIAlertController(title: "Lỗi", message: error.localizedDescription, preferredStyle: .alert)
+        alert.addAction(UIAlertAction(title: "OK", style: .default))
+        present(alert, animated: true)
+    }
+}
+
+// BaseViewController chỉ giữ thứ thực sự dùng ở MỌI VC
+class BaseViewController: UIViewController {
+    override func viewDidLoad() {
+        super.viewDidLoad()
+        setupNavigationBar()
+    }
+    private func setupNavigationBar() { /* common nav bar style */ }
+}
+
+// Từng VC chỉ opt-in vào tính năng cần
+class OrderListViewController: BaseViewController, LoadingDisplayable, ErrorAlertDisplayable {
+    func loadOrders() async {
+        showLoading()
+        defer { hideLoading() }
+        do {
+            orders = try await orderService.fetchOrders()
+        } catch {
+            showErrorAlert(error)
+        }
+    }
+}
+```
+
+**Tools:** Code Review, SwiftLint (`type_body_length`)
+

package/skill-assets/sunlint-code-quality/rules/swift/C067-no-hardcoded-config.md

@@ -0,0 +1,80 @@
+---
+title: Không hardcode cấu hình trong code - dùng xcconfig hoặc environment
+impact: MEDIUM
+impactDescription: Config hardcode làm khó switch giữa môi trường development/staging/production và dễ gây lỗi khi deploy.
+tags: swift, ios, configuration, environment, xcconfig, code-quality
+---
+
+## Không hardcode cấu hình trong code - dùng xcconfig hoặc environment
+
+URL của API, timeout, feature flags, và các thông số khác biệt giữa môi trường không được hardcode. Dùng `.xcconfig` file theo scheme, đọc qua `Info.plist`, hoặc dùng build setting `$(VAR_NAME)`.
+
+**Incorrect (config hardcode):**
+
+```swift
+class APIClient {
+    // !! Hardcode URL - phải sửa code khi switch môi trường
+    private let baseURL = "https://api.example.com/v2"
+    private let timeout: TimeInterval = 30
+
+    init() {
+        // !! Hardcode môi trường
+        #if DEBUG
+        let url = "https://dev-api.example.com/v2"
+        #else
+        let url = "https://api.example.com/v2"
+        #endif
+    }
+}
+
+struct Config {
+    static let maxRetries = 3      // magic number
+    static let sessionTimeout = 1800  // 30 phút? hardcode
+}
+```
+
+**Correct (đọc từ xcconfig / Info.plist theo scheme):**
+
+```swift
+// Development.xcconfig
+// API_BASE_URL = https://dev-api.example.com/v2
+// REQUEST_TIMEOUT = 30
+// MAX_RETRIES = 3
+
+// Production.xcconfig
+// API_BASE_URL = https://api.example.com/v2
+// REQUEST_TIMEOUT = 15
+// MAX_RETRIES = 2
+
+// Info.plist
+// <key>APIBaseURL</key><string>$(API_BASE_URL)</string>
+// <key>RequestTimeout</key><string>$(REQUEST_TIMEOUT)</string>
+
+struct AppConfiguration {
+    static var apiBaseURL: URL {
+        guard let urlString = Bundle.main.infoDictionary?["APIBaseURL"] as? String,
+              let url = URL(string: urlString) else {
+            fatalError("APIBaseURL configuration missing")
+        }
+        return url
+    }
+
+    static var requestTimeout: TimeInterval {
+        let value = Bundle.main.infoDictionary?["RequestTimeout"] as? String
+        return Double(value ?? "30") ?? 30
+    }
+
+    static var maxRetries: Int {
+        let value = Bundle.main.infoDictionary?["MaxRetries"] as? String
+        return Int(value ?? "3") ?? 3
+    }
+}
+
+class APIClient {
+    private let baseURL = AppConfiguration.apiBaseURL
+    private let timeout = AppConfiguration.requestTimeout
+}
+```
+
+**Tools:** Xcode Build Schemes + xcconfig, `Configuration.swift` helper
+

package/skill-assets/sunlint-code-quality/rules/swift/S003-sql-injection.md

@@ -0,0 +1,65 @@
+---
+title: Tránh SQL Injection khi dùng SQLite, FMDB hoặc CoreData NSPredicate
+impact: CRITICAL
+impactDescription: Ghép chuỗi trực tiếp vào câu lệnh SQL hoặc NSPredicate format string cho phép attacker đọc, xóa hoặc sửa toàn bộ database của app.
+tags: swift, ios, sql-injection, sqlite, fmdb, coredata, nspredicate, security
+---
+
+## Tránh SQL Injection khi dùng SQLite, FMDB hoặc CoreData NSPredicate
+
+Trong iOS, SQL injection xảy ra khi ghép chuỗi trực tiếp vào câu lệnh SQLite/FMDB, hoặc dùng `NSPredicate(format:)` với giá trị người dùng chưa được escape. Phải dùng parameterized query hoặc `NSPredicate(format:argumentArray:)`.
+
+**Incorrect (ghép chuỗi trực tiếp):**
+
+```swift
+import FMDB
+
+// !! Ghép chuỗi tên đăng nhập trực tiếp vào SQL
+func findUser(username: String, db: FMDatabase) -> [String: Any]? {
+    let query = "SELECT * FROM users WHERE username = '\(username)'"  // SQL Injection!
+    let result = db.executeQuery(query, withArgumentsIn: [])
+    return nil
+}
+
+// !! NSPredicate với format string không an toàn
+func fetchMessages(senderName: String, context: NSManagedObjectContext) -> [Message] {
+    let predicate = NSPredicate(format: "sender == '\(senderName)'")  // Injection!
+    let request = Message.fetchRequest()
+    request.predicate = predicate
+    return (try? context.fetch(request)) ?? []
+}
+```
+
+**Correct (parameterized query):**
+
+```swift
+import FMDB
+
+// SAFE: Dùng parameterized query với ?
+func findUser(username: String, db: FMDatabase) -> FMResultSet? {
+    let query = "SELECT * FROM users WHERE username = ?"
+    return db.executeQuery(query, withArgumentsIn: [username])
+}
+
+// SAFE: NSPredicate với argumentArray
+func fetchMessages(senderName: String, context: NSManagedObjectContext) -> [Message] {
+    let predicate = NSPredicate(format: "sender == %@", argumentArray: [senderName])
+    let request = Message.fetchRequest()
+    request.predicate = predicate
+    return (try? context.fetch(request)) ?? []
+}
+
+// SAFE: SQLite3 với bound parameters
+func insertNote(title: String, body: String, db: OpaquePointer) {
+    var stmt: OpaquePointer?
+    let sql = "INSERT INTO notes (title, body) VALUES (?, ?)"
+    if sqlite3_prepare_v2(db, sql, -1, &stmt, nil) == SQLITE_OK {
+        sqlite3_bind_text(stmt, 1, (title as NSString).utf8String, -1, nil)
+        sqlite3_bind_text(stmt, 2, (body as NSString).utf8String, -1, nil)
+        sqlite3_step(stmt)
+    }
+    sqlite3_finalize(stmt)
+}
+```
+
+**Tools:** SwiftLint custom rule, OWASP MASVS-CODE-4, Instruments (SQLite profiler)

package/skill-assets/sunlint-code-quality/rules/swift/S004-no-log-credentials.md

@@ -0,0 +1,67 @@
+---
+title: Không log thông tin nhạy cảm (token, password, PII)
+impact: HIGH
+impactDescription: Log trong iOS có thể đọc được qua Console.app, thiết bị bị jailbreak, hoặc crash logs gửi lên server. Credentials trong log đồng nghĩa với data breach.
+tags: swift, ios, logging, security, credentials, privacy, pii
+---
+
+## Không log thông tin nhạy cảm (token, password, PII)
+
+`NSLog`, `print()`, và `os_log` đều có thể bị capture bởi tool như Console.app hoặc bởi attacker khi thiết bị bị jailbreak. Không bao giờ log: password, access token, refresh token, thẻ tín dụng, số CMND/CCCD, hay thông tin cá nhân nhạy cảm.
+
+**Incorrect (log thông tin nhạy cảm):**
+
+```swift
+func login(email: String, password: String) async {
+    print("Attempting login with email: \(email), password: \(password)")  // !! password trong log
+
+    do {
+        let response = try await authService.login(email: email, password: password)
+        // !! Token trong log
+        NSLog("Login success. accessToken: %@, refreshToken: %@", response.accessToken, response.refreshToken)
+
+        UserDefaults.standard.set(response.accessToken, forKey: "access_token")
+    } catch {
+        // !! Email trong log
+        logger.error("Login failed for email: \(email), error: \(error)")
+    }
+}
+
+func processPayment(cardNumber: String, cvv: String) {
+    logger.info("Processing card: \(cardNumber), CVV: \(cvv)")  // !! PCI DSS violation
+}
+```
+
+**Correct (log không chứa thông tin nhạy cảm):**
+
+```swift
+import OSLog
+
+private let logger = Logger(subsystem: "com.app.auth", category: "Authentication")
+
+func login(email: String, password: String) async {
+    // Log action không log credentials
+    logger.info("Login attempt initiated")
+
+    do {
+        let response = try await authService.login(email: email, password: password)
+        // Chỉ log metadata - không log token value
+        logger.info("Login succeeded. userId=\(response.userId, privacy: .public), tokenExpiry=\(response.expiresIn)")
+
+        // Lưu token vào Keychain, không log
+        try tokenManager.saveAccessToken(response.accessToken)
+    } catch {
+        // Log loại lỗi, không log email
+        logger.warning("Login failed: \(error.localizedDescription, privacy: .public)")
+    }
+}
+
+func processPayment(cardNumber: String, cvv: String) {
+    // Chỉ log metadata về payment, không log card data
+    let maskedCard = String(cardNumber.suffix(4))
+    logger.info("Processing payment for card ending in \(maskedCard, privacy: .public)")
+}
+```
+
+**Tools:** Code Review, `os.Logger` privacy API, MobSF static analysis
+

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