npm - @sun-asterisk/sunlint - Versions diffs - 1.3.48 → 1.3.49 - Mend

@sun-asterisk/sunlint 1.3.48 → 1.3.49

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (152) hide show

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

@@ -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 ADDED Viewed

@@ -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 ADDED Viewed

@@ -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 ADDED Viewed

@@ -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 ADDED Viewed

@@ -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 ADDED Viewed

@@ -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

package/skill-assets/sunlint-code-quality/rules/swift/S017-parameterized-queries.md ADDED Viewed

@@ -0,0 +1,86 @@
+---
+title: Dùng parameterized predicate trong Core Data - không ghép string người dùng
+impact: CRITICAL
+impactDescription: Dùng string interpolation trong NSPredicate format string cho phép attacker bypass filter, truy cập records không được phép hoặc crash app bằng cách inject ký tự đặc biệt.
+tags: swift, ios, coredata, nspredicate, injection, parameterized-query, security
+---
+## Dùng parameterized predicate trong Core Data - không ghép string người dùng
+`NSPredicate(format:)` xử lý %@ như placeholder và tự escape. Không bao giờ dùng string interpolation `\(variable)` trong format string của NSPredicate vì nó không được escape và dẫn đến injection.
+**Incorrect (string interpolation trong predicate format):**
+```swift
+import CoreData
+class MessageRepository {
+    let context: NSManagedObjectContext
+    init(context: NSManagedObjectContext) {
+        self.context = context
+    }
+    // !! String interpolation - NSPredicate injection
+    func searchMessages(keyword: String) -> [Message] {
+        // Nếu keyword = "' OR '1'='1" thì trả về tất cả messages!
+        let predicate = NSPredicate(format: "content CONTAINS '\(keyword)'")
+        let request = Message.fetchRequest() as NSFetchRequest<Message>
+        request.predicate = predicate
+        return (try? context.fetch(request)) ?? []
+    }
+    // !! Concat string để build predicate
+    func findByStatus(status: String) -> [Task] {
+        let predicateStr = "status == '" + status + "'"  // Injection!
+        let predicate = NSPredicate(format: predicateStr)
+        let request = Task.fetchRequest() as NSFetchRequest<Task>
+        request.predicate = predicate
+        return (try? context.fetch(request)) ?? []
+    }
+}
+```
+**Correct (placeholder %@ với argumentArray):**
+```swift
+import CoreData
+class MessageRepository {
+    let context: NSManagedObjectContext
+    init(context: NSManagedObjectContext) {
+        self.context = context
+    }
+    // SAFE: %@ placeholder tự escape giá trị
+    func searchMessages(keyword: String) -> [Message] {
+        let predicate = NSPredicate(format: "content CONTAINS %@", keyword)
+        let request = Message.fetchRequest() as NSFetchRequest<Message>
+        request.predicate = predicate
+        request.sortDescriptors = [NSSortDescriptor(key: "createdAt", ascending: false)]
+        return (try? context.fetch(request)) ?? []
+    }
+    // SAFE: Multiple conditions dùng argumentArray
+    func findMessages(from senderId: UUID, after date: Date) -> [Message] {
+        let predicate = NSPredicate(
+            format: "senderId == %@ AND createdAt > %@",
+            argumentArray: [senderId as CVarArg, date as CVarArg]
+        )
+        let request = Message.fetchRequest() as NSFetchRequest<Message>
+        request.predicate = predicate
+        return (try? context.fetch(request)) ?? []
+    }
+    // SAFE: Enum status dùng Int value, không phải string từ user
+    func findByStatus(_ status: TaskStatus) -> [Task] {
+        let predicate = NSPredicate(format: "statusRaw == %d", status.rawValue)
+        let request = Task.fetchRequest() as NSFetchRequest<Task>
+        request.predicate = predicate
+        return (try? context.fetch(request)) ?? []
+    }
+}
+```
+**Tools:** SwiftLint custom regex rule (detect `NSPredicate(format: ".*\\\(`), OWASP MASVS-CODE-4