@sun-asterisk/sunlint 1.3.48 → 1.3.49

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)

package/skill-assets/sunlint-code-quality/rules/swift/S046-unvalidated-redirect.md

@@ -0,0 +1,140 @@
+---
+title: Validate Universal Link và URL Scheme để tránh open redirect và hijacking
+impact: HIGH
+impactDescription: Xử lý deep link không validate cho phép attacker craft URL độc hại dẫn user đến webview chứa phishing page, hoặc trigger sensitive actions như logout/approve bằng custom URL scheme.
+tags: swift, ios, deeplink, universal-link, url-scheme, open-redirect, hijacking, security
+---
+
+## Validate Universal Link và URL Scheme để tránh open redirect và hijacking
+
+Custom URL scheme (`myapp://`) có thể bị hijack bởi app khác. Universal Links an toàn hơn nhưng vẫn cần validate parameters. Không bao giờ render URL từ deep link trực tiếp trong WKWebView hay navigate đến destination không thuộc domain whitelist.
+
+**Incorrect (không validate deep link destination):**
+
+```swift
+import UIKit
+
+class SceneDelegate: UIResponder, UISceneDelegate {
+
+    // !! Xử lý universal link - mở URL tùy ý trong webview
+    func scene(_ scene: UIScene, continue userActivity: NSUserActivity) {
+        guard userActivity.activityType == NSUserActivityTypeBrowsingWeb,
+              let incomingURL = userActivity.webpageURL else { return }
+
+        // !! Lấy "redirect" param từ URL và mở trong WebView không validate
+        let components = URLComponents(url: incomingURL, resolvingAgainstBaseURL: false)
+        let redirectURL = components?.queryItems?.first(where: { $0.name == "redirect" })?.value ?? ""
+        openWebView(urlString: redirectURL)  // Open redirect! Phishing!
+    }
+
+    // !! Custom scheme - trigger hành động nhạy cảm không xác nhận
+    func application(_ app: UIApplication, open url: URL, options: [UIApplication.OpenURLOptionsKey: Any]) -> Bool {
+        // myapp://approve?transactionId=123
+        if url.host == "approve" {
+            let transactionId = url.queryParameters["transactionId"] ?? ""
+            approveTransaction(id: transactionId)  // Trigger action không confirm!
+        }
+        return true
+    }
+}
+```
+
+**Correct (validate source, destination và require user confirmation):**
+
+```swift
+import UIKit
+
+struct DeepLinkValidator {
+    // Whitelist domain cho redirect
+    private static let allowedRedirectHosts: Set<String> = [
+        "app.example.com",
+        "www.example.com",
+        "help.example.com"
+    ]
+
+    // Validate redirect URL chỉ đến domain của mình
+    static func validateRedirectURL(_ urlString: String) throws -> URL {
+        guard let url = URL(string: urlString),
+              let host = url.host,
+              url.scheme == "https" else {
+            throw DeepLinkError.invalidURL(urlString)
+        }
+        guard allowedRedirectHosts.contains(host) else {
+            throw DeepLinkError.untrustedHost(host)
+        }
+        return url
+    }
+
+    // Validate transaction ID là UUID format
+    static func validateTransactionId(_ id: String) throws -> UUID {
+        guard let uuid = UUID(uuidString: id) else {
+            throw DeepLinkError.invalidParameter("transactionId must be UUID")
+        }
+        return uuid
+    }
+}
+
+enum DeepLinkError: LocalizedError {
+    case invalidURL(String), untrustedHost(String), invalidParameter(String)
+
+    var errorDescription: String? {
+        switch self {
+        case .invalidURL(let u): return "Invalid URL: \(u)"
+        case .untrustedHost(let h): return "Untrusted host: \(h)"
+        case .invalidParameter(let p): return "Invalid parameter: \(p)"
+        }
+    }
+}
+
+class SceneDelegate: UIResponder, UISceneDelegate {
+
+    // SAFE: Validate trước khi open webview
+    func scene(_ scene: UIScene, continue userActivity: NSUserActivity) {
+        guard userActivity.activityType == NSUserActivityTypeBrowsingWeb,
+              let incomingURL = userActivity.webpageURL else { return }
+
+        let components = URLComponents(url: incomingURL, resolvingAgainstBaseURL: false)
+        let rawRedirect = components?.queryItems?.first(where: { $0.name == "redirect" })?.value ?? ""
+
+        do {
+            let safeURL = try DeepLinkValidator.validateRedirectURL(rawRedirect)
+            openWebView(url: safeURL)  // Đã validate
+        } catch {
+            logger.warning("Rejected deep link redirect: \(error.localizedDescription)")
+            // Không navigate, hoặc mở trang default thay thế
+        }
+    }
+
+    // SAFE: Require user confirmation trước action nhạy cảm từ URL scheme
+    func application(_ app: UIApplication, open url: URL, options: [UIApplication.OpenURLOptionsKey: Any]) -> Bool {
+        guard url.scheme == "myapp" else { return false }
+
+        if url.host == "approve" {
+            do {
+                let rawId = url.queryParameters["transactionId"] ?? ""
+                let transactionId = try DeepLinkValidator.validateTransactionId(rawId)
+                // SAFE: Hiển thị confirmation alert trước
+                showApprovalConfirmation(transactionId: transactionId)
+            } catch {
+                logger.warning("Invalid approve deep link: \(error.localizedDescription)")
+            }
+        }
+        return true
+    }
+
+    private func showApprovalConfirmation(transactionId: UUID) {
+        let alert = UIAlertController(
+            title: "Confirm Transaction",
+            message: "Approve transaction \(transactionId.uuidString.prefix(8))...?",
+            preferredStyle: .alert
+        )
+        alert.addAction(UIAlertAction(title: "Approve", style: .default) { _ in
+            self.approveTransaction(id: transactionId)
+        })
+        alert.addAction(UIAlertAction(title: "Cancel", style: .cancel))
+        topViewController?.present(alert, animated: true)
+    }
+}
+```
+
+**Tools:** OWASP MASVS-PLATFORM-1, Apple App Review Guidelines (2.5.9), URLComponents, Proxyman