11 · 보안과 암호학

import CryptoKit

let raw = Data("hello".utf8)

// 1) Encoding — 보안 아님, 규칙만 알면 복원
let b64 = raw.base64EncodedString()        // "aGVsbG8="
let back = Data(base64Encoded: b64)        // 원본 복원, 키 불필요

// 2) Hashing — 단방향, 무결성/지문
let digest = SHA256.hash(data: raw)        // 256비트(32바이트) 고정
// 비밀번호엔 이대로 쓰지 말 것: salt + 느린 KDF 필요

// 3) Encryption — 키로 잠그고 키로 연다
let key = SymmetricKey(size: .bits256)
let sealed = try AES.GCM.seal(raw, using: key)
let plain  = try AES.GCM.open(sealed, using: key)   // 같은 키로만 복호화

import Foundation
import CryptoKit

// SHA-256 한 방은 초당 수십억 번 시도할 수 있어 무차별 대입에 무력하다.
// 비밀번호 저장은 '느린 것'이 기능이다.

// ❌ 절대 하지 말 것
func hashBad(_ password: String) -> Data {
    Data(SHA256.hash(data: Data(password.utf8)))
}

// ✅ 비밀번호 검증은 원칙적으로 서버 몫이다 (bcrypt / scrypt / Argon2)
//    클라이언트가 직접 해야 한다면 PBKDF2를 충분한 반복 횟수로 쓴다
import CommonCrypto

func derive(password: String, salt: Data, rounds: UInt32 = 600_000   // PBKDF2-HMAC-SHA256 기준 OWASP 권고치(SHA-512 PRF면 210,000)) -> Data {
    var out = Data(count: 32)
    let passwordData = Data(password.utf8)

    // ⚠️ 반환값(CCStatus)을 버리면 실패 시 out이 0으로 채워진 채 '파생 키'로 쓰인다
    let status = out.withUnsafeMutableBytes { outBuf in
        salt.withUnsafeBytes { saltBuf in
            CCKeyDerivationPBKDF(
                CCPBKDFAlgorithm(kCCPBKDF2),
                password, passwordData.count,
                saltBuf.bindMemory(to: UInt8.self).baseAddress, salt.count,
                CCPseudoRandomAlgorithm(kCCPRFHmacAlgSHA256),
                rounds,
                outBuf.bindMemory(to: UInt8.self).baseAddress, 32)
        }
    }
    guard status == kCCSuccess else { fatalError("PBKDF2 실패: \(status)") }
    return out
}

// ✅ salt는 사용자마다 새로 만든다 (레인보우 테이블 방어)
func newSalt() -> Data {
    var bytes = [UInt8](repeating: 0, count: 16)
    _ = SecRandomCopyBytes(kSecRandomDefault, bytes.count, &bytes)
    return Data(bytes)
}

// ✅ 비교는 타이밍 공격에 안전하게 (조기 종료가 없는 비교)
func constantTimeEquals(_ a: Data, _ b: Data) -> Bool {
    guard a.count == b.count else { return false }
    var diff: UInt8 = 0
    for (x, y) in zip(a, b) { diff |= x ^ y }
    return diff == 0
}

// ⚠️ 반복 횟수는 기기 성능에 맞춰 조정한다 — 로그인에 0.5~1초 정도가 기준이다

import Foundation

// 인코딩은 '표현 형식 변환'이다. 키가 없고, 누구나 즉시 되돌린다.

func demonstrateEncoding() {
    let secret = "Bearer eyJhbGciOiJIUzI1NiJ9"

    let encoded = Data(secret.utf8).base64EncodedString()
    print(encoded)     // "QmVhcmVyIGV5SmhiR2NpT2lKSVV6STFOaUo5"

    // ✅ 누구나 한 줄로 복원한다 — 키도, 권한도 필요 없다
    let decoded = String(data: Data(base64Encoded: encoded)!, encoding: .utf8)
    print(decoded!)    // "Bearer eyJhbGciOiJIUzI1NiJ9"
}

// ❌ "인코딩해서 저장했으니 안전하다"는 착각
func storeBad(_ token: String) {
    let obscured = Data(token.utf8).base64EncodedString()
    UserDefaults.standard.set(obscured, forKey: "token")   // 💥 평문과 다를 바 없다
}

// ✅ 기밀성이 필요하면 암호화(키 필요) 또는 Keychain(OS가 보호)
import CryptoKit

func encryptProperly(_ token: String, using key: SymmetricKey) throws -> Data {
    let sealed = try AES.GCM.seal(Data(token.utf8), using: key)
    return sealed.combined!        // nonce + 암호문 + 태그
}

// ⚠️ 같은 오해가 반복되는 다른 사례들
//   · URL 인코딩       → 표현 형식일 뿐
//   · JWT의 payload   → Base64URL 인코딩이라 그냥 읽힌다 (서명은 위조만 막는다)
//   · hex 문자열      → 마찬가지
//
// ✅ JWT payload에 민감 정보를 넣지 않는다 — 누구나 디코딩할 수 있다
func inspectJWT(_ jwt: String) -> String? {
    let parts = jwt.split(separator: ".")
    guard parts.count == 3 else { return nil }
    var payload = String(parts[1])
        .replacingOccurrences(of: "-", with: "+")
        .replacingOccurrences(of: "_", with: "/")
    while payload.count % 4 != 0 { payload += "=" }
    return Data(base64Encoded: payload).flatMap { String(data: $0, encoding: .utf8) }
}

import Foundation
import CryptoKit

// 키 없는 해시는 "데이터와 해시를 함께" 바꿔치기하면 검증을 통과한다.
// 검증자만 아는 키가 들어가야 위조를 막을 수 있다.

// ❌ 순수 해시 — 공격자가 payload와 digest를 동시에 교체하면 그만이다
struct BadEnvelope {
    let payload: Data
    let digest: Data          // SHA256(payload)

    var isValid: Bool { Data(SHA256.hash(data: payload)) == digest }
}

// ✅ HMAC — 키를 모르면 유효한 태그를 만들 수 없다
struct Envelope {
    let payload: Data
    let tag: Data

    init(payload: Data, key: SymmetricKey) {
        self.payload = payload
        self.tag = Data(HMAC<SHA256>.authenticationCode(for: payload, using: key))
    }

    func isValid(key: SymmetricKey) -> Bool {
        // ✅ 이 API는 상수 시간 비교를 내부에서 해 준다
        HMAC<SHA256>.isValidAuthenticationCode(
            tag, authenticating: payload, using: key)
    }
}

// ✅ 웹훅 서명 검증이 대표적인 사용처
func verifyWebhook(body: Data, signatureHeader: String, secret: SymmetricKey) -> Bool {
    guard let provided = Data(base64Encoded: signatureHeader) else { return false }
    return HMAC<SHA256>.isValidAuthenticationCode(
        provided, authenticating: body, using: secret)
}

// ✅ 순수 해시가 맞는 용도: 무결성이 아니라 '식별·중복 제거'
func contentAddress(of data: Data) -> String {
    Data(SHA256.hash(data: data)).base64EncodedString()   // 캐시 키·파일 지문
}

// ⚠️ 다운로드 파일 검증도 해시만으로는 부족하다.
//    해시 자체가 같은 채널로 오면 둘 다 바꿔치기당한다.
//    → 해시를 서명된 채널(TLS + 서버 인증)로 받거나, 코드 서명을 검증한다

import Foundation
import CryptoKit

// AES-GCM에서 같은 키로 nonce를 재사용하면 기밀성만이 아니라
// 무결성까지 무너진다 — 인증 키가 복구되어 임의 메시지 위조가 가능해진다.

// ❌ 고정 nonce — 치명적이다
func encryptBad(_ data: Data, key: SymmetricKey) throws -> Data {
    let fixed = try AES.GCM.Nonce(data: Data(repeating: 0, count: 12))
    return try AES.GCM.seal(data, using: key, nonce: fixed).combined!   // 💥
}

// ✅ ① 가장 안전: nonce를 지정하지 않고 CryptoKit이 매번 새로 만들게 둔다
func encrypt(_ data: Data, key: SymmetricKey) throws -> Data {
    let sealed = try AES.GCM.seal(data, using: key)      // nonce 자동 생성
    return sealed.combined!                               // nonce가 함께 담긴다
}

func decrypt(_ combined: Data, key: SymmetricKey) throws -> Data {
    let box = try AES.GCM.SealedBox(combined: combined)
    return try AES.GCM.open(box, using: key)
}

// ✅ ② 직접 관리해야 한다면 카운터로. 단 아래처럼 세션마다 새로 뽑는 4바이트 prefix + 0부터 시작하는 카운터로는 부족하다 —
//    prefix가 겹치는 순간(2^16 세션 부근에서 50%) nonce가 그대로 재사용된다.
//    prefix와 카운터를 키와 함께 영속화해 키 수명 전체에서 유일함을 보장하거나, 그냥 ①을 써라
actor NonceSequence {
    private var counter: UInt64 = 0
    private let prefix: Data          // 세션마다 무작위 4바이트

    init() {
        var bytes = [UInt8](repeating: 0, count: 4)
        _ = SecRandomCopyBytes(kSecRandomDefault, 4, &bytes)
        prefix = Data(bytes)
    }

    func next() throws -> AES.GCM.Nonce {
        counter += 1
        var value = counter.bigEndian
        let counterData = Data(bytes: &value, count: 8)
        return try AES.GCM.Nonce(data: prefix + counterData)   // 4 + 8 = 12바이트
    }
}

// ✅ ③ 키를 자주 바꾸는 것도 방어가 된다 (같은 키로 쓰는 메시지 수를 제한)
func rotateKeyIfNeeded(messageCount: Int) -> Bool {
    messageCount > 1_000_000        // GCM 권장 한계 훨씬 아래에서 교체
}

// ⚠️ ChaChaPoly도 같은 제약이 있다. AEAD 전반의 규칙이다.

import Foundation
import Security

// 접근성 속성이 "언제 이 항목을 읽을 수 있는가"를 정한다. 좁을수록 안전하다.

enum Accessibility {
    // ⚠️ 하나의 축으로 줄 세울 수 없다 — 두 축이 독립이다.
    //    ① 시간: WhenPasscodeSet ≈ WhenUnlocked → AfterFirstUnlock 순으로 넓어진다
    //    ② 기기 한정: ThisDeviceOnly가 붙으면 백업·이전이 막힌다
    //    그래서 WhenUnlocked와 AfterFirstUnlockThisDeviceOnly는 우열을 매길 수 없다.
    // kSecAttrAccessibleWhenPasscodeSetThisDeviceOnly  기기에 암호가 설정된 경우만, 백업 불가
    // kSecAttrAccessibleWhenUnlockedThisDeviceOnly     잠금 해제 상태 + 이 기기만
    // kSecAttrAccessibleWhenUnlocked                   잠금 해제 상태 (백업 이동 가능)
    // kSecAttrAccessibleAfterFirstUnlockThisDeviceOnly 첫 해제 후 (백그라운드 작업용)
    // kSecAttrAccessibleAfterFirstUnlock               가장 넓음
}

func store(token: String, account: String, needsBackgroundAccess: Bool) throws {
    let accessible: CFString = needsBackgroundAccess
        ? kSecAttrAccessibleAfterFirstUnlockThisDeviceOnly   // 백그라운드 갱신이 필요하면
        : kSecAttrAccessibleWhenUnlockedThisDeviceOnly       // 아니면 더 좁게

    let query: [String: Any] = [
        kSecClass as String: kSecClassGenericPassword,
        kSecAttrAccount as String: account,
        kSecValueData as String: Data(token.utf8),
        kSecAttrAccessible as String: accessible
    ]
    SecItemDelete(query as CFDictionary)
    let status = SecItemAdd(query as CFDictionary, nil)
    guard status == errSecSuccess else { throw KeychainError.status(status) }
}

// ✅ 고민감 항목은 생체인증 게이트를 건다
func storeWithBiometry(_ secret: Data, account: String) throws {
    var error: Unmanaged<CFError>?
    guard let access = SecAccessControlCreateWithFlags(
        nil,
        kSecAttrAccessibleWhenPasscodeSetThisDeviceOnly,
        .biometryCurrentSet,          // 지문·얼굴이 바뀌면 무효화된다
        &error) else { throw KeychainError.accessControl }

    let query: [String: Any] = [
        kSecClass as String: kSecClassGenericPassword,
        kSecAttrAccount as String: account,
        kSecValueData as String: secret,
        kSecAttrAccessControl as String: access
    ]
    SecItemDelete(query as CFDictionary)
    let status = SecItemAdd(query as CFDictionary, nil)
    guard status == errSecSuccess else { throw KeychainError.status(status) }
}

enum KeychainError: Error { case status(OSStatus), accessControl }

import Foundation

// 파일 보호 클래스는 "기기가 어떤 상태일 때 이 파일을 열 수 있는가"를 정한다.
// 잠금 상태에서는 키가 메모리에서 지워져 아예 읽히지 않는다.

// ✅ 클래스별 의미
//   .complete                        잠기면 접근 불가 (가장 강함)
//   .completeUnlessOpen              잠기기 전에 열어 뒀으면 계속 접근 가능
//   .completeUntilFirstUserAuthentication  재부팅 후 첫 해제 이후로는 접근 가능
//   .none                            보호 없음

func saveSensitiveDocument(_ data: Data, to url: URL) throws {
    try data.write(to: url, options: [.atomic, .completeFileProtection])
}

// ✅ 기존 파일의 보호 클래스를 바꾸려면 FileManager를 쓴다
//    (URLResourceValues.fileProtection은 읽기 전용이라 대입할 수 없다)
func upgradeProtection(_ url: URL) throws {
    try FileManager.default.setAttributes(
        [.protectionKey: FileProtectionType.complete],
        ofItemAtPath: url.path)
}

// ✅ 현재 보호 클래스 확인은 URLResourceValues로 (읽기는 가능하다)
func currentProtection(_ url: URL) throws -> URLFileProtection? {
    try url.resourceValues(forKeys: [.fileProtectionKey]).fileProtection
}

// ⚠️ 백그라운드에서 열어야 하는 파일에 .complete를 걸면
//    잠금 중 백그라운드 작업이 실패한다
func chooseProtection(needsBackgroundAccess: Bool) -> Data.WritingOptions {
    needsBackgroundAccess
        ? [.atomic, .completeFileProtectionUntilFirstUserAuthentication]
        : [.atomic, .completeFileProtection]
}

// ✅ 접근 가능 여부를 먼저 확인해 우아하게 실패한다
func isProtectedDataAvailable() -> Bool {
    // UIApplication.shared.isProtectedDataAvailable (메인에서)
    // 또는 알림 구독:
    //   .protectedDataDidBecomeAvailableNotification
    //   .protectedDataWillBecomeUnavailableNotification
    true
}

func readWhenAvailable(_ url: URL) throws -> Data? {
    guard isProtectedDataAvailable() else { return nil }   // 잠금 중이면 나중에
    return try Data(contentsOf: url)
}

import CoreData
import Foundation

// Core Data·SQLite 파일은 그냥 파일이다. 아무것도 안 하면 보호 클래스만
// 기본값이고, 내용은 평문으로 저장된다.

// ✅ ① 스토어 파일에 보호 클래스를 명시한다 (가장 간단한 방어)
func makeProtectedContainer(name: String, storeURL: URL) -> NSPersistentContainer {
    let container = NSPersistentContainer(name: name)
    let description = NSPersistentStoreDescription(url: storeURL)

    description.setOption(FileProtectionType.complete as NSObject,
                          forKey: NSPersistentStoreFileProtectionKey)

    container.persistentStoreDescriptions = [description]
    container.loadPersistentStores { _, error in precondition(error == nil) }
    return container
}
// ⚠️ -wal, -shm 파일도 함께 보호되는지 확인해야 한다

// ✅ ② 더 강한 보호가 필요하면 DB 자체를 암호화한다 (SQLCipher 등)
//    키는 Keychain에 두고, 앱 시작 시 꺼내 DB를 연다
func openEncryptedDatabase(keyFromKeychain key: String) throws {
    // SQLCipher: PRAGMA key = '...';
    // GRDB + SQLCipher 조합이 흔하다
}

// ✅ ③ 컬럼 단위 암호화 — DB 전체가 아니라 민감 필드만
import CryptoKit

struct EncryptedField {
    static func encrypt(_ value: String, key: SymmetricKey) throws -> Data {
        try AES.GCM.seal(Data(value.utf8), using: key).combined!
    }
    static func decrypt(_ data: Data, key: SymmetricKey) throws -> String {
        let box = try AES.GCM.SealedBox(combined: data)
        return String(data: try AES.GCM.open(box, using: key), encoding: .utf8) ?? ""
    }
}
// ⚠️ 암호화한 컬럼은 인덱스·정렬·LIKE 검색이 안 된다. 검색이 필요하면
//    별도의 결정적 해시 컬럼(HMAC)을 두고 그걸로 조회한다.

// ✅ 파일 보호 클래스 확인
func checkProtection(_ url: URL) throws -> URLFileProtection? {
    try url.resourceValues(forKeys: [.fileProtectionKey]).fileProtection
}

import Foundation
import Security

// Keychain 항목은 앱을 지워도 남는다. 재설치하면 이전 사용자의 자격증명이
// 그대로 읽혀 "지웠는데 로그인돼 있다"가 된다.

enum FirstRunCleaner {
    private static let flagKey = "hasRunBefore"

    /// 앱 시작 시 가장 먼저 호출한다
    static func cleanIfFreshInstall() {
        // UserDefaults는 앱 삭제와 함께 사라진다 → 이걸 설치 감지에 쓴다
        guard !UserDefaults.standard.bool(forKey: flagKey) else { return }

        purgeAllKeychainItems()
        UserDefaults.standard.set(true, forKey: flagKey)
    }

    private static func purgeAllKeychainItems() {
        let classes: [CFString] = [
            kSecClassGenericPassword,
            kSecClassInternetPassword,
            kSecClassCertificate,
            kSecClassKey,
            kSecClassIdentity
        ]
        for cls in classes {
            let query: [String: Any] = [kSecClass as String: cls,
                kSecAttrSynchronizable as String: kSecAttrSynchronizableAny   // ✅ iCloud 동기화 항목까지 포함해야 진짜 전체 삭제다]
            let status = SecItemDelete(query as CFDictionary)
            if status != errSecSuccess && status != errSecItemNotFound {
                print("Keychain 정리 실패(\(cls)): \(status)")
            }
        }
    }
}

// AppDelegate / App 진입점에서
func applicationDidFinishLaunching() {
    FirstRunCleaner.cleanIfFreshInstall()      // ✅ 다른 초기화보다 먼저
}

// ⚠️ 판단이 갈리는 지점이다
//   · 정리한다  → 재설치 시 반드시 재로그인. 보안상 안전하고 예측 가능.
//   · 남겨 둔다 → 재설치 후에도 로그인 유지. 편의성은 좋지만 기기 양도 시 위험.
//
// ✅ 남기기로 했다면 최소한 ThisDeviceOnly 접근성을 써서
//    백업을 통해 다른 기기로 넘어가지 않게 한다.

// ⚠️ App Group·Keychain access group을 쓰면 다른 앱·확장의 항목까지
//    지울 수 있으므로, 정리 쿼리에 access group을 명시해 범위를 좁힌다.

actor TokenProvider {
    private var cached: String?
    private var inflight: Task<String, Error>?

    // 유효한 access token 반환 — 동시 호출은 하나의 refresh에 합류한다
    func validToken() async throws -> String {
        if let t = cached { return t }
        if let task = inflight { return try await task.value }  // 진행 중 갱신에 합류
        let task = Task { try await self.refresh() }
        inflight = task
        defer { inflight = nil }
        let token = try await task.value
        cached = token
        return token
    }

    private func refresh() async throws -> String {
        // Keychain에서 refresh token 로드 → 서버에 갱신 요청
        // 새 refresh token(rotation)도 Keychain에 덮어쓰기
        // 실패(무효화)면 로그아웃 처리
        ...
    }
}

import Foundation

// 매 요청마다 Keychain을 읽으면 느리고(SecItemCopyMatching은 IPC다)
// 플래시에도 좋지 않다. 메모리를 1차 소스로 둔다.

actor TokenStore {
    private var cachedAccess: String?
    private var expiresAt: Date?

    /// 유효한 access token을 돌려준다
    func accessToken() async throws -> String {
        // ① 메모리에 유효한 게 있으면 그대로
        if let cachedAccess, let expiresAt, expiresAt > Date().addingTimeInterval(30) {
            return cachedAccess
        }
        // ② 없으면 갱신 (Keychain의 refresh token 사용)
        return try await refresh()
    }

    func store(access: String, expiresIn: TimeInterval, refresh: String) {
        cachedAccess = access
        expiresAt = Date().addingTimeInterval(expiresIn)
        Keychain.save(refresh, account: "refreshToken")   // ✅ 긴 것만 디스크에
        // ⚠️ access token은 수명이 짧으므로 굳이 Keychain에 안 써도 된다.
        //    앱 재시작 시 refresh로 새로 받으면 그만이다.
    }

    func clear() {
        cachedAccess = nil
        expiresAt = nil
        Keychain.delete(account: "refreshToken")
    }

    private func refresh() async throws -> String { "" }
}

// ✅ 만료를 서버 응답으로 관리한다 — 클라가 추측하지 않는다
struct TokenResponse: Decodable {
    let accessToken: String
    let refreshToken: String
    let expiresIn: TimeInterval      // 초 단위
}

// ✅ 만료 30초 전에 미리 갱신하면 요청 중 만료를 피할 수 있다
func needsRefresh(expiresAt: Date) -> Bool {
    expiresAt <= Date().addingTimeInterval(30)
}

enum Keychain {
    static func save(_ v: String, account: String) {}
    static func delete(account: String) {}
}

import Foundation

// 앱 복귀 순간 수십 개 요청이 동시에 401을 받으면, 각자 refresh를 시도해
// refresh token rotation이 꼬이거나 서버가 전부 거부한다.

actor TokenProvider {
    private var cached: String?
    private var refreshTask: Task<String, Error>?

    func token() async throws -> String {
        if let cached { return cached }

        // ✅ 이미 진행 중인 갱신이 있으면 그 결과에 '합류'한다
        if let existing = refreshTask {
            return try await existing.value
        }

        let task = Task<String, Error> { try await self.performRefresh() }
        refreshTask = task

        defer { refreshTask = nil }        // 성공·실패 모두 정리

        let fresh = try await task.value
        cached = fresh
        return fresh
    }

    /// 401을 받은 쪽이 무효화를 알린다
    func invalidate() { cached = nil }

    private func performRefresh() async throws -> String {
        guard let refresh = Keychain.read("refreshToken") else {
            throw AuthError.noSession
        }
        let pair = try await api.refresh(refresh)
        Keychain.write(pair.refresh, "refreshToken")     // rotation
        return pair.access
    }
}

// 사용 — 401을 받으면 무효화 후 한 번만 재시도한다
func authorizedRequest(_ request: URLRequest, provider: TokenProvider) async throws -> Data {
    var req = request
    req.setValue("Bearer \(try await provider.token())", forHTTPHeaderField: "Authorization")

    let (data, response) = try await URLSession.shared.data(for: req)
    guard (response as? HTTPURLResponse)?.statusCode == 401 else { return data }

    await provider.invalidate()
    var retry = request
    retry.setValue("Bearer \(try await provider.token())", forHTTPHeaderField: "Authorization")
    return try await URLSession.shared.data(for: retry).0    // ✅ 한 번만
}

enum AuthError: Error { case noSession, sessionExpired }
struct TokenPair { let access: String; let refresh: String }
enum api {
    static func refresh(_ t: String) async throws -> TokenPair {
        TokenPair(access: "", refresh: "")
    }
}
enum Keychain {
    static func read(_ k: String) -> String? { nil }
    static func write(_ v: String, _ k: String) {}
}

import Foundation

// refresh가 무효(만료·회수·재사용 탐지)면 더 해 볼 게 없다.
// 여기서 재시도 루프를 만들면 배터리를 태우고 서버 부하만 늘린다.

actor SessionManager {
    private var cached: String?

    func token() async throws -> String {
        if let cached { return cached }
        do {
            let fresh = try await refresh()
            cached = fresh
            return fresh
        } catch AuthError.invalidGrant {
            // ✅ 세션이 끝났다 — 정리하고 로그인으로 보낸다
            await endSession()
            throw AuthError.sessionExpired
        } catch {
            // ⚠️ 네트워크 오류는 세션 종료가 아니다 — 구분해야 한다
            throw error
        }
    }

    private func endSession() async {
        cached = nil
        Keychain.deleteAll()
        await MainActor.run { AppRouter.shared.showLogin() }
    }

    private func refresh() async throws -> String { "" }
}

// ✅ 에러를 계층으로 구분한다 — 이걸 뭉치면 잘못된 로그아웃이 생긴다
enum AuthError: Error {
    case invalidGrant       // refresh token 무효 → 세션 종료
    case sessionExpired
    case network(Error)     // 일시적 → 재시도 가능, 로그아웃하면 안 된다
}

func classify(status: Int, error: Error?) -> AuthError? {
    if let urlError = error as? URLError { return .network(urlError) }
    switch status {
    case 400, 401: return .invalidGrant     // OAuth는 보통 400 invalid_grant
    default:       return nil
    }
}

// ❌ 하지 말 것: 무한 재시도
// while true { if let t = try? await refresh() { return t } }

// ✅ 재사용 탐지에 걸린 경우도 즉시 세션 종료다
//    (서버가 "이 refresh token은 이미 쓰였다"고 하면 탈취 정황이므로
//     그 세션 전체를 무효화하는 것이 표준 대응이다)

enum Keychain { static func deleteAll() {} }
@MainActor final class AppRouter {
    static let shared = AppRouter()
    func showLogin() {}
}

import Foundation
import OSLog

private let log = Logger(subsystem: "com.app", category: "auth")

// ❌ ① 쿼리스트링 — TLS로 암호화돼도 서버 접근 로그·Referer·프록시에 평문으로 남는다
func badURL(_ token: String) -> URL {
    URL(string: "https://api.example.com/me?access_token=\(token)")!
}

// ✅ 헤더로 보낸다
func request(_ url: URL, token: String) -> URLRequest {
    var r = URLRequest(url: url)
    r.setValue("Bearer \(token)", forHTTPHeaderField: "Authorization")
    return r
}

// ❌ ② 로그에 그대로
func badLog(_ token: String, _ request: URLRequest) {
    print("token=\(token)")                                  // stdout
    NSLog("headers=%@", request.allHTTPHeaderFields ?? [:])   // 시스템 로그에 영속
}

// ✅ 마스킹하거나 아예 찍지 않는다
func safeLog(_ request: URLRequest) {
    var redacted = request.allHTTPHeaderFields ?? [:]
    redacted["Authorization"] = "[redacted]"
    log.debug("headers \(redacted, privacy: .private)")
}

func masked(_ token: String) -> String {
    guard token.count > 8 else { return "***" }
    return token.prefix(4) + "…" + token.suffix(4)
}

// ❌ ③ UserDefaults — 평문 plist. 백업·파일 접근으로 노출된다
func badStore(_ token: String) {
    UserDefaults.standard.set(token, forKey: "token")
}

// ❌ ④ 놓치기 쉬운 자리들
//   · URLCache — 응답에 토큰이 담기면 디스크 캐시에 남는다
//   · 크래시 리포트의 breadcrumb·커스텀 키
//   · 스크린샷(앱 전환 시 스냅샷) — 토큰이 화면에 보이면 안 된다
//   · 웹뷰 쿠키·로컬스토리지

// ✅ 민감 화면은 백그라운드 스냅샷을 가린다
func obscureOnBackground(_ window: UIWindow?) {
    let blur = UIVisualEffectView(effect: UIBlurEffect(style: .systemMaterial))
    blur.frame = window?.bounds ?? .zero
    window?.addSubview(blur)
}

// ✅ 인증 응답은 캐시하지 않는다
func noCacheConfig() -> URLSessionConfiguration {
    let c = URLSessionConfiguration.ephemeral      // 디스크 캐시·쿠키 없음
    c.urlCache = nil
    return c
}

import UIKit

import Foundation

/*  ATS(App Transport Security)는 기본으로 평문 HTTP를 차단하고 TLS 1.2+를 요구한다.
    예외를 열면 그 도메인에 대한 다운그레이드 공격 창이 열린다.

    ❌ 최악 — 전체를 연다 (심사에서 정당화를 요구받는다)
    <key>NSAppTransportSecurity</key>
    <dict>
        <key>NSAllowsArbitraryLoads</key><true/>
    </dict>

    ✅ 꼭 필요하면 도메인 단위로, 필요한 항목만
    <key>NSAppTransportSecurity</key>
    <dict>
        <key>NSExceptionDomains</key>
        <dict>
            <key>legacy.partner.com</key>
            <dict>
                <key>NSExceptionAllowsInsecureHTTPLoads</key><true/>
                <key>NSIncludesSubdomains</key><false/>
            </dict>
        </dict>
    </dict>

    ✅ TLS 버전만 낮춰야 하면 그것만 낮춘다 (평문 허용까지 열지 않는다)
            <!-- TLS 1.0/1.1은 RFC 8996이 금지했고 Apple도 iOS 15부터 deprecated로 선언해 제거를 예고했다.
                 낮춰야 한다면 여기까지가 현실적 하한이고, 만료일과 담당자를 함께 못 박아 둔다. -->
            <key>NSExceptionMinimumTLSVersion</key>
            <string>TLSv1.2</string>                                        */

// ✅ 현재 설정이 실제로 어떻게 동작하는지 검증한다
//    nscurl --ats-diagnostics --verbose https://api.example.com

// ✅ 예외를 코드로도 추적 가능하게 남긴다
enum ATSExceptions {
    /// 2026-12-31까지 한시적. 파트너사 TLS 업그레이드 완료 시 제거.
    /// 담당: 인프라팀 / 티켓: SEC-1234
    static let temporary = ["legacy.partner.com"]
}

// ✅ 예외 도메인으로 가는 요청에는 민감 정보를 싣지 않는다
func isSafeToSendCredentials(to host: String) -> Bool {
    !ATSExceptions.temporary.contains(host)
}

import Foundation
import CryptoKit

// 피닝은 강력하지만 잘못 다루면 앱이 통째로 접속 불가가 된다.
// 도입 전에 로테이션 절차를 먼저 정해야 한다.

enum Pinning {
    /// 현재 + 차기 공개키 해시. 인증서 교체 전에 백업 핀을 먼저 배포해 둔다.
    static let pins: Set<String> = [
        "sha256/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=",   // 현재
        "sha256/BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB="    // 백업(차기)
    ]

    static func validate(_ trust: SecTrust) -> Bool {
        // ① 시스템 기본 검증(체인·호스트명·만료)을 먼저 통과시킨다
        var error: CFError?
        guard SecTrustEvaluateWithError(trust, &error) else { return false }

        // ② 그다음 공개키를 핀과 대조한다
        guard let chain = SecTrustCopyCertificateChain(trust) as? [SecCertificate]
        else { return false }

        for cert in chain {
            guard let key = SecCertificateCopyKey(cert),
                  let data = SecKeyCopyExternalRepresentation(key, nil) as Data?
            else { continue }
            // ⚠️ SecKeyCopyExternalRepresentation은 SPKI DER가 아니라 원시 키 바이트를 준다
            //    (RSA: PKCS #1, EC: 04||X||Y). RFC 7469의 sha256/… 핀과 대조하려면
            //    키 알고리즘·크기에 맞는 ASN.1 SubjectPublicKeyInfo 헤더를 앞에 붙여 DER를
            //    복원한 뒤 해시해야 한다. 이 단계를 빼면 정상 서버에서도 전 연결이 막힌다.
            let hash = "sha256/" + Data(SHA256.hash(data: data)).base64EncodedString()
            if pins.contains(hash) { return true }
        }
        return false
    }
}

/*  로테이션 절차 (문서로 못 박아 둘 것)
      1) 차기 키 생성 → 그 핀을 앱에 '추가'해 배포 (현재 + 백업 둘 다 유효)
      2) 사용자 대부분이 그 버전으로 올라올 때까지 대기 (보통 수 주)
      3) 서버 인증서를 차기 키로 교체
      4) 다음 릴리스에서 옛 핀 제거 + 새 백업 핀 추가

    ⚠️ 강제 업데이트 수단(원격 최소 버전 설정)이 없으면 피닝을 켜지 않는다.
    ⚠️ 강제 업데이트 안내 화면 자체는 피닝된 API를 거치지 않아야 한다.       */

// ✅ 공개키(SPKI)를 핀한다 — 인증서를 갱신해도 키를 유지하면 핀이 유효하다
//    인증서 자체를 핀하면 갱신마다 앱을 올려야 한다

import Foundation

// TLS가 지키는 것: 회선(기밀성·무결성·서버 신원)
// TLS가 지키지 않는 것: 클라이언트가 보낸 내용의 타당성

// ❌ "HTTPS로 보냈으니 서버는 그대로 믿어도 된다"
struct BadCheckoutRequest: Encodable {
    let itemID: String
    let price: Decimal        // 💥 클라이언트가 가격을 정한다
    let discount: Decimal     // 💥 할인율도
}

// ✅ 서버가 스스로 계산할 수 있는 값은 클라이언트에서 받지 않는다
struct CheckoutRequest: Encodable {
    let itemID: String
    let quantity: Int
    let couponCode: String?   // 코드만 받고 유효성·할인율은 서버가 판정
}

// ✅ 권한도 마찬가지 — 클라이언트가 보낸 역할을 믿지 않는다
struct BadDeleteRequest: Encodable {
    let postID: String
    let isAdmin: Bool         // 💥 누구나 true로 보낼 수 있다
}
struct DeleteRequest: Encodable {
    let postID: String        // ✅ 권한은 서버가 토큰에서 확인한다
}

// ⚠️ 앱은 공격자의 기기에서 돈다. 프록시·리버싱·수정된 클라이언트로
//    어떤 값이든 보낼 수 있다. 클라이언트 검증은 UX이지 보안이 아니다.

// ✅ 클라이언트 검증은 '빠른 피드백'을 위해 유지하되, 서버가 다시 한다
func validateLocally(_ email: String) -> Bool {
    email.contains("@")       // 사용자에게 즉시 알려 주기 위한 것
}

// ✅ 요청의 정당성이 필요하면 App Attest로 '정품 앱'임을 서버가 검증한다
//    (그것도 클라 값을 믿는 게 아니라, 하드웨어 증명을 검증하는 것이다)

import Foundation

// TLS는 URL 경로·쿼리를 암호화한다. 하지만 그 URL은 여러 곳에 평문으로 남는다.
//   · 서버 접근 로그 (거의 항상 전체 URL을 기록한다)
//   · 프록시·게이트웨이 로그
//   · Referer 헤더 (외부 링크로 이동 시)
//   · 브라우저·웹뷰 히스토리
//   · 앱 내 URL 로깅·크래시 리포트

// ❌ 쿼리스트링에 민감 정보
func badRequests(token: String, email: String, ssn: String) -> [URL] {
    [
        URL(string: "https://api.example.com/me?token=\(token)")!,
        URL(string: "https://api.example.com/search?email=\(email)")!,
        URL(string: "https://api.example.com/verify?ssn=\(ssn)")!
    ]
}

// ✅ 인증은 헤더로
func authorized(_ url: URL, token: String) -> URLRequest {
    var r = URLRequest(url: url)
    r.setValue("Bearer \(token)", forHTTPHeaderField: "Authorization")
    return r
}

// ✅ 민감한 조회 조건은 본문으로 (POST 또는 POST-as-query)
func search(email: String) throws -> URLRequest {
    var r = URLRequest(url: URL(string: "https://api.example.com/search")!)
    r.httpMethod = "POST"
    r.setValue("application/json", forHTTPHeaderField: "Content-Type")
    r.httpBody = try JSONEncoder().encode(["email": email])
    return r
}

// ✅ 경로 파라미터도 조심 — /users/010-1234-5678 같은 건 로그에 남는다
//    불투명한 식별자를 쓴다: /users/{uuid}

// ⚠️ 딥링크·유니버설 링크도 같은 문제다
// ❌ myapp://reset?token=abc123      → 다른 앱이 가로챌 수 있고 로그에 남는다
// ✅ 짧은 일회용 코드를 쓰고 서버에서 교환한다

// ✅ 웹뷰에 토큰을 넘겨야 하면 URL이 아니라 헤더나 postMessage로
import WebKit
func loadAuthenticated(_ webView: WKWebView, url: URL, token: String) {
    var request = URLRequest(url: url)
    request.setValue("Bearer \(token)", forHTTPHeaderField: "Authorization")
    webView.load(request)
}

import Foundation

// 클라이언트에 박힌 키는 반드시 추출된다. 유일한 구조적 해법은
// 그 키를 클라이언트에 두지 않는 것이다.

// ❌ 지도·결제·번역 API 키를 앱에
enum BadConfig {
    static let mapsAPIKey = "AIzaSyD-1234567890abcdefghijk"   // strings 한 줄에 노출
}

// ✅ 우리 서버가 대신 호출하고, 앱은 우리 서버만 부른다
struct PlacesClient {
    func search(_ query: String) async throws -> [Place] {
        var request = URLRequest(url: URL(string: "https://api.myapp.com/proxy/places")!)
        request.httpMethod = "POST"
        request.setValue("Bearer \(try await session.token())",
                         forHTTPHeaderField: "Authorization")   // ✅ 우리 인증만
        request.httpBody = try JSONEncoder().encode(["q": query])

        let (data, _) = try await URLSession.shared.data(for: request)
        return try JSONDecoder().decode([Place].self, from: data)
    }
    private let session = SessionProvider()
}

/*  프록시가 주는 이득
      · 제3자 키가 서버에만 존재한다
      · 사용량·비용을 서버에서 통제한다 (레이트리밋, 쿼터)
      · 키 로테이션이 앱 배포 없이 가능하다
      · 응답을 캐시해 제3자 호출 자체를 줄일 수 있다
      · 어떤 사용자가 얼마나 썼는지 추적된다                                  */

// ⚠️ 프록시 자체가 공개돼 있으면 그것도 남용된다 →
//    반드시 우리 앱의 인증 + App Attest로 보호한다(다음 항목)

// ✅ 클라이언트에 둬도 되는 것: '공개된 식별자'
//    예) Firebase의 apiKey는 사실 식별자다(보안은 규칙으로 한다).
//        하지만 그 판단은 서비스 문서를 확인하고 내려야 한다.

struct Place: Decodable {}
struct SessionProvider { func token() async throws -> String { "" } }

import Foundation
import DeviceCheck
import CryptoKit

// App Attest는 "이 요청이 정품 앱, 정품 기기에서 왔다"를 하드웨어로 증명한다.
// 리버싱한 클라이언트나 스크립트 봇을 걸러낼 수 있다.

actor AttestationService {
    private var keyID: String?

    /// 최초 1회 — 키를 만들고 서버에 등록한다
    func register() async throws {
        let service = DCAppAttestService.shared
        guard service.isSupported else { throw AttestError.unsupported }

        let keyID = try await service.generateKey()
        self.keyID = keyID

        // 서버가 준 challenge에 대해 증명서를 만든다
        let challenge = try await api.challenge()
        let hash = Data(SHA256.hash(data: Data(challenge.utf8)))
        let attestation = try await service.attestKey(keyID, clientDataHash: hash)

        try await api.registerAttestation(keyID: keyID, attestation: attestation)
        UserDefaults.standard.set(keyID, forKey: "attestKeyID")
    }

    /// 이후 요청마다 — 훨씬 가벼운 assertion을 붙인다
    func assertion(for body: Data) async throws -> Data {
        guard let keyID = keyID ?? UserDefaults.standard.string(forKey: "attestKeyID")
        else { throw AttestError.notRegistered }

        let hash = Data(SHA256.hash(data: body))
        return try await DCAppAttestService.shared
        .generateAssertion(keyID, clientDataHash: hash)
    }
}

// 요청에 붙인다
func attestedRequest(_ body: Data, service: AttestationService) async throws -> URLRequest {
    var r = URLRequest(url: URL(string: "https://api.myapp.com/proxy/places")!)
    r.httpMethod = "POST"
    r.httpBody = body
    let assertion = try await service.assertion(for: body)
    r.setValue(assertion.base64EncodedString(), forHTTPHeaderField: "X-App-Attest")
    return r
}

// ⚠️ 서버가 반드시 검증해야 의미가 있다 — 클라가 헤더를 붙이는 것만으로는 아무것도 아니다.
// ⚠️ 시뮬레이터·일부 기기에서는 지원되지 않는다 → 폴백 경로가 필요하다.

enum AttestError: Error { case unsupported, notRegistered }
enum api {
    static func challenge() async throws -> String { "" }
    static func registerAttestation(keyID: String, attestation: Data) async throws {}
}

import Foundation

// 난독화는 추출 '시간'을 늘린다. 방어선이 아니라 속도 조절 장치다.

// ❌ 이런 걸 '보안'이라고 부르면 안 된다
enum WeakObfuscation {
    private static let parts = ["sk_", "live_", "abc", "123"]
    static var key: String { parts.joined() }        // 문자열 결합
}

enum XORObfuscation {
    private static let cipher: [UInt8] = [0x12, 0x34, 0x56]
    private static let mask: UInt8 = 0x5A
    static var key: String {
        String(bytes: cipher.map { $0 ^ mask }, encoding: .utf8) ?? ""
    }
    // 디버거로 이 함수의 반환값을 한 번 찍으면 끝난다
}

/*  실제로 얼마나 쉬운지
      strings MyApp.app/MyApp | grep -i 'sk_\|api\|key'
      class-dump / Hopper / Ghidra 로 로직 확인
      Frida로 런타임에 함수 반환값 후킹:
        Interceptor.attach(addr, { onLeave(retval) { console.log(retval) } })

    → 난독화된 키는 '메모리에 평문으로 존재하는 순간'에 그대로 잡힌다.        */

// ✅ 난독화가 정당한 위치: 다층 방어의 '한 겹'
//    ① 키를 서버로 옮긴다            ← 근본 해결
//    ② App Attest로 요청을 검증한다   ← 남용 차단
//    ③ 서버에서 레이트리밋·이상 탐지  ← 피해 제한
//    ④ 난독화                        ← 여기. 앞의 셋이 있을 때만 의미가 있다

// ✅ 정말 클라이언트에 있어야 하는 값이면 '유출을 전제로' 설계한다
//    · 그 값으로 할 수 있는 일의 범위를 최소화 (읽기 전용, 특정 엔드포인트만)
//    · 서버에서 사용량 상한을 건다
//    · 유출 탐지 시 로테이션할 수 있는 구조를 미리 만든다

# 이미 커밋된 키는 히스토리에 영구히 남는다. 지워도 과거 커밋에서 복구된다.
# → 유출된 순간 rotate가 유일한 대응이다.

# ✅ ① 로컬 pre-commit 훅으로 1차 차단
cat > .git/hooks/pre-commit <<'HOOK'
#!/bin/sh
if git diff --cached | grep -nE '(sk_live_|AIza[0-9A-Za-z_-]{35}|-----BEGIN.*PRIVATE KEY)'; then
  echo "❌ 시크릿으로 보이는 문자열이 있습니다. 커밋을 중단합니다."
  exit 1
fi
HOOK
chmod +x .git/hooks/pre-commit

# ✅ ② 훅은 우회 가능하므로 CI에서도 검사한다 (이게 진짜 방어선)
#    GitHub Actions 예:
#      - uses: gitleaks/gitleaks-action@v2
#    또는
brew install gitleaks
gitleaks detect --source . --redact

# ✅ ③ 설정 파일은 커밋하지 않고 템플릿만 둔다
#    Secrets.xcconfig        → .gitignore
#    Secrets.xcconfig.sample → 커밋 (키 자리는 비워 둠)
echo "Secrets.xcconfig" >> .gitignore

# ✅ ④ CI에서는 환경변수·시크릿 저장소에서 주입한다
#    xcodebuild ... API_BASE="$API_BASE"

# ⚠️ xcconfig·Info.plist에 넣은 값도 결국 바이너리에 박힌다.
#    "소스에 안 보인다"와 "앱에서 추출 불가"는 전혀 다른 이야기다.
strings MyApp.app/MyApp | grep -i 'api_key'

# ✅ ⑤ 이미 커밋된 키를 발견했다면
#    1) 즉시 해당 키를 서비스 콘솔에서 폐기(rotate)
#    2) 새 키는 서버로 옮기거나 시크릿 저장소에 둔다
#    3) 히스토리 정리는 부차적이다 — 이미 노출됐다고 가정하고 대응한다
git log -S 'sk_live_' --oneline        # 언제 들어왔는지 확인

import os
let log = Logger(subsystem: "co.finda.app", category: "auth")

// 동적 문자열은 릴리스에서 기본 <private>로 가려진다
log.debug("access token = \(token)")

// 스칼라(숫자/불리언)는 기본 public — 민감하면 명시적으로 가릴 것
log.info("status = \(statusCode, privacy: .private)")

// 상관관계 추적은 하되 원문은 숨기기
log.notice("user = \(userId, privacy: .private(mask: .hash))")

// 절대 이렇게 찍지 말 것 — NSLog는 통합 로깅으로 릴리스 시스템 로그에 남고,
// print는 stdout(개발 중 Xcode 콘솔)에 노출된다. 둘 다 privacy 가림이 없다
print("token=\(token)")   // ✗

SentrySDK.start { options in
    options.sendDefaultPii = false                 // 자동 PII 수집 차단
    options.beforeSend = { event in
        event.request?.headers?["Authorization"] = nil   // 토큰 헤더 제거
        // breadcrumb/extra에서 민감 필드 마스킹
        return event
    }
}

import Foundation
import OSLog

private let log = Logger(subsystem: "com.app", category: "network")

// os.Logger는 동적 값을 기본적으로 <private>로 가려 준다.
// 하지만 스칼라는 기본 public이고, .public을 명시하면 무엇이든 노출된다.

func logging(_ url: URL, status: Int, token: String, userID: Int) {
    // ✅ 동적 문자열 — 기본 private이지만 의도를 명시하는 편이 안전하다
    log.debug("요청 \(url.absoluteString, privacy: .private)")

    // ⚠️ 숫자는 기본 public이다 — 민감하면 반드시 명시해야 한다
    log.info("상태 \(status, privacy: .public)")
    log.info("사용자 \(userID, privacy: .private)")     // ✅ ID도 PII일 수 있다

    // ✅ 원문은 감추고 동일성(상관관계)만 남기는 해시 마스킹
    log.debug("토큰 \(token, privacy: .private(mask: .hash))")
}

// ❌ 이런 것들은 릴리스에서도 남는다
func badLogging(_ token: String) {
    NSLog("token=%@", token)      // 통합 로깅 → sysdiagnose로 회수된다
    print("token=\(token)")       // 릴리스 기기에선 시스템 로그에 안 남지만
                                   // Xcode 콘솔·디바이스 로그로 노출된다
}

// ✅ 로그 레벨도 의미에 맞게 쓴다
//   .debug   개발 중에만. 릴리스에서는 기본적으로 저장되지 않는다.
//   .info    문제 진단에 도움. 메모리에만 남는다.
//   .notice  기본. 디스크에 영속 저장된다.
//   .error / .fault  항상 저장된다.
//
// ⚠️ .notice 이상은 디스크에 남으므로 민감 정보를 절대 넣지 않는다

// ✅ 카테고리를 나눠 필요할 때만 켠다
private let authLog = Logger(subsystem: "com.app", category: "auth")
// 콘솔에서 필터:  subsystem:com.app category:auth

import Foundation
import OSLog

// 런타임 플래그로만 끄면 코드와 문자열이 바이너리에 그대로 남는다.
// strings로 추출되고, 후킹으로 다시 켤 수도 있다.

// ❌ 런타임 스위치 — 코드가 남는다
enum BadLogger {
    static var isVerbose = false
    static func dump(_ request: URLRequest) {
        guard isVerbose else { return }
        print(request.allHTTPHeaderFields ?? [:])    // 이 문자열이 바이너리에 있다
    }
}

// ✅ 컴파일 단계에서 제거 — 릴리스 바이너리에 흔적이 없다
enum NetworkLogger {
#if DEBUG
    static func dump(_ request: URLRequest) {
        let logger = Logger(subsystem: "com.app", category: "net")
        logger.debug("""
            \(request.httpMethod ?? "GET", privacy: .public) \
            \(request.url?.absoluteString ?? "", privacy: .private)
            headers: \(request.allHTTPHeaderFields ?? [:], privacy: .private)
            """)
    }

    static func dump(_ response: URLResponse, body: Data) {
        let logger = Logger(subsystem: "com.app", category: "net")
        logger.debug("body \(String(data: body, encoding: .utf8) ?? "", privacy: .private)")
    }
#else
    @inline(__always) static func dump(_ request: URLRequest) {}
    @inline(__always) static func dump(_ response: URLResponse, body: Data) {}
#endif
}

// ✅ 검증: 릴리스 바이너리에 로깅 문자열이 남지 않았는지 확인한다
//    strings MyApp.app/MyApp | grep -i 'headers:'
//    (결과가 없어야 한다)

// ⚠️ 서드파티 네트워크 로거(Alamofire의 EventMonitor 등)도 마찬가지로
//    DEBUG에서만 붙인다
func makeSession() -> URLSession {
    let config = URLSessionConfiguration.default
#if DEBUG
    // 디버그 전용 프로토콜·모니터를 여기서만 붙인다
#endif
    return URLSession(configuration: config)
}

import Foundation

// 크래시 리포터는 자동으로 많은 걸 수집한다. 기본값 그대로 두면
// 요청 헤더·사용자 정보·breadcrumb에 시크릿이 실려 나간다.

// Sentry 예시 (다른 SDK도 개념은 같다)
func configureCrashReporter() {
    /*
    SentrySDK.start { options in
        options.dsn = "https://…"

        // ✅ ① 자동 PII 수집을 끈다 (IP·사용자 정보 등)
        options.sendDefaultPii = false

        // ✅ ② 전송 직전에 민감 필드를 지운다
        options.beforeSend = { event in
            event.request?.headers?["Authorization"] = "[redacted]"
            event.request?.headers?["Cookie"] = "[redacted]"
            event.request?.queryString = nil          // 쿼리에 토큰이 있을 수 있다
            event.user?.email = nil
            event.user?.ipAddress = nil

            // 커스텀 컨텍스트도 훑는다
            if var extra = event.extra {
                for key in extra.keys where key.lowercased().contains("token") {
                    extra[key] = "[redacted]"
                }
                event.extra = extra
            }
            return event
        }

        // ✅ ③ breadcrumb도 스크러빙한다 — 여기가 특히 새기 쉽다
        options.beforeBreadcrumb = { crumb in
            if crumb.category == "http", var data = crumb.data {
                data["url"] = (data["url"] as? String)
                    .map { $0.components(separatedBy: "?").first ?? $0 }   // 쿼리 제거
                crumb.data = data
            }
            return crumb
        }
    }
    */
}

// ✅ 우리가 직접 넣는 컨텍스트도 규칙을 정한다
enum CrashContext {
    /// 허용 목록 방식 — 넣어도 되는 것만 명시한다
    static let allowedKeys: Set<String> = ["screen", "feature_flag", "build_number"]

    static func set(_ key: String, _ value: String) {
        guard allowedKeys.contains(key) else {
            assertionFailure("허용되지 않은 크래시 컨텍스트 키: \(key)")
            return
        }
        // SentrySDK.configureScope { $0.setTag(value: value, key: key) }
    }
}

// ⚠️ 로그를 크래시 리포트에 첨부하는 기능이 있으면 그 로그도 스크러빙 대상이다

# 사람의 주의력에 의존하면 반드시 새어 나간다. 자동화가 유일한 방어선이다.

# ✅ ① 위험한 로깅 호출 자체를 금지한다 (SwiftLint 커스텀 룰)
cat >> .swiftlint.yml <<'YAML'
custom_rules:
  no_print_in_production:
    name: "print 사용 금지"
    regex: '(^|\s)print\('
    match_kinds: [identifier]
    message: "print 대신 Logger를 쓰세요. 디버그 전용이면 #if DEBUG로 감싸세요."
    severity: error
    excluded: ".*Tests?\.swift"

  no_nslog:
    name: "NSLog 사용 금지"
    regex: 'NSLog\('
    message: "NSLog는 릴리스 시스템 로그에 영속 저장됩니다. Logger를 쓰세요."
    severity: error

  no_public_privacy_on_secrets:
    name: "민감 값에 privacy: .public 금지"
    regex: '(token|password|secret|apiKey|email|ssn)[^)]*privacy:\s*\.public'
    message: "민감 값을 public으로 로깅하고 있습니다."
    severity: error
YAML

# ✅ ② 커밋되는 코드에서 시크릿 패턴을 잡는다
gitleaks detect --source . --redact --exit-code 1

# ✅ ③ 빌드 산출물에서 실제로 문자열이 남았는지 검사한다 (가장 확실하다)
strings "$BUILT_PRODUCTS_DIR/$EXECUTABLE_PATH" \
  | grep -nE 'sk_live_|AIza[0-9A-Za-z_-]{35}|BEGIN PRIVATE KEY' \
  && { echo "❌ 바이너리에 시크릿 문자열이 있습니다"; exit 1; }

# ✅ ④ CI 파이프라인에 전부 묶어 머지 게이트로 만든다
#    - swiftlint --strict
#    - gitleaks detect
#    - 위 strings 검사를 Run Script Phase 또는 CI 스텝으로

# ⚠️ 룰은 만들어 놓고 warning으로 두면 아무도 안 고친다.
#    error + 머지 차단이어야 실제로 작동한다.