Hol tárolnád a felhasználó védett adatait?

Az iOS felhasználói adatok védett tárolására a következő helyeket használnám, az adatok típusától és a biztonsági szinttől függően:

1. Keychain Services:

   • Ideális kis mennyiségű bizalmas információ, például jelszavak, hitelesítési tokenek, titkosítási kulcsok tárolására.
   • A rendszer démon securityd kezeli a keychain-t, és titkosított formában tárolja az adatokat a lemezen.
   • Támogat különböző hozzáférési szinteket (például csak a készülék feloldása után elérhető).
   • Az adatok automatikusan szinkronizálódnak az iCloud Keychain segítségével, ha be van kapcsolva.

   import Foundation
   import Security
   
   func savePassword(service: String, account: String, password: String) -> OSStatus {
       let data = password.data(using: .utf8)!
       let query: [String: Any] = [
           kSecClass as String: kSecClassGenericPassword,
           kSecAttrService as String: service,
           kSecAttrAccount as String: account,
           kSecValueData as String: data
       ]
   
       SecItemDelete(query as CFDictionary) // Létező rekord törlése
       return SecItemAdd(query as CFDictionary, nil) // Új rekord hozzáadása
   }
   

2. Encrypted Core Data / Realm:

   • Strukturált adatok tárolására, amelyek titkosítást igényelnek az adatbázis szintjén.
   • A Core Data támogat külső titkosítási kiegészítéseket (például RNCryptor).
   • A Realm adatbázis beépített titkosítással rendelkezik.
   • A titkosítási kulcsot a Keychain-ben kell tárolni.

   // Példa a Realm titkosításának inicializálására
   import RealmSwift
   
   func setupEncryptedRealm() throws {
       var config = Realm.Configuration()
       if let key = KeychainHelper.getRealmEncryptionKey() { // Kulcs lekérése a Keychain-ből
           config.encryptionKey = key
       } else {
           // Új kulcs generálása, tárolása a Keychain-ben, majd használata
           let newKey = NSMutableData(length: 64)!
           _ = SecRandomCopyBytes(kSecRandomDefault, newKey.length, newKey.mutableBytes)
           KeychainHelper.saveRealmEncryptionKey(key: newKey as Data)
           config.encryptionKey = newKey as Data
       }
   
       let realm = try Realm(configuration: config)
       // Realm használata
   }
   

3. File Protection APIs:

   • Fájlok titkosítására, amelyek az alkalmazás fájlrendszerében tárolódnak.
   • iOS automatikusan titkosítja a fájlokat a fájlrendszer szintjén a Secure Enclave által kezelt kulcsok segítségével.
   • Különböző védelmi módokat lehet beállítani (például complete, completeUnlessOpen, completeUntilFirstUserAuthentication, none) a hozzáférés szabályozására a készülék zárolási állapotától függően.

   func saveProtectedDataToFile(data: Data, fileName: String) throws {
       let fileManager = FileManager.default
       let urls = fileManager.urls(for: .documentDirectory, in: .userDomainMask)
       guard let documentDirectory = urls.first else { throw NSError(domain: "MyApp", code: 1, userInfo: [NSLocalizedDescriptionKey: "Dokumentum könyvtár nem található"]) }
   
       let fileURL = documentDirectory.appendingPathComponent(fileName)
   
       // Védelmi mód beállítása
       let options: Data.WritingOptions = .atomicWrite
       let protectedOptions: Data.WritingOptions = options.union(.writingWithoutOverwriting) // Csak példa, a valódi védelmi opciók a fájl attribútumaiban vagy az info.plist-ben állíthatók be
   
       try data.write(to: fileURL, options: options)
   
       // Fájlrendszer védelmi attribútumok beállítása (példa)
       var attributes: [FileAttributeKey : Any] = [:]
       attributes[.protectionKey] = FileProtectionType.complete
       try fileManager.setAttributes(attributes, ofItemAtPath: fileURL.path)
   }
   

4. Secure Enclave:

   • Hardveres alrendszer, amely elkülönül a fő processzortól, és a kriptográfiai kulcsok és adatok tárolására, feldolgozására szolgál.
   • Touch ID / Face ID és más érzékeny műveletekhez használják.
   • A Secure Enclave-ben tárolt kulcsok soha nem hagyják el azt, és nem elérhetők a fő processzor vagy az operációs rendszer számára.
   • Ideális a kulcsok generálására, tárolására és használatára aláíráshoz vagy titkosításhoz, ahol a védelem a szoftveres támadások ellen fontos.

   import CryptoKit
   import LocalAuthentication
   
   func generateAndStoreKeyInSecureEnclave() throws -> P256.Signing.PrivateKey {
       let accessControl = SecAccessControlCreateWithFlags(
           kCFAllocatorDefault,
           kSecAttrAccessibleWhenPasscodeSetThisDeviceOnly, // Hozzáférés jelszóval
           [.userPresence], // Felhasználói hitelesítés szükséges (Touch ID/Face ID)
           nil
       )!
   
       let attributes: [String: Any] = [
           kSecAttrKeyType as String: kSecAttrKeyTypeECSECPrimeRandom,
           kSecAttrKeySizeInBits as String: 256,
           kSecAttrTokenID as String: kSecAttrTokenIDSecureEnclave,
           kSecPrivateKeyAttrs as String: [
               kSecAttrIsPermanent as String: true, // A kulcs állandó lesz
               kSecAttrApplicationTag as String: "com.yourapp.signingkey".data(using: .utf8)!, // Egyedi címke
               kSecAttrAccessControl as String: accessControl
           ]
       ]
   
       var error: Unmanaged<CFError>?
       guard let privateKey = SecKeyCreateRandomKey(attributes as CFDictionary, &error) else {
           throw error!.takeRetainedValue() as Error
       }
   
       // A kulcsok elérhetők a Secure Enclave-ből a címke segítségével
       return try P256.Signing.PrivateKey(rawRepresentation: privateKeyData) // Példa, átalakítás SecKey-ből Data-ra szükséges
   }
   

A tárolási hely kiválasztása függ:

• Az adatok méretétől (kis mennyiség vs strukturált adatok).
• Az adatok típusától (jelszó vs fájl vs kriptográfiai kulcs).
• A védelmi szinttől, amit igényel.
• Az eszközök közötti szinkronizáció szükségességétől (Keychain).
• A felhasználói hitelesítés szükségességétől a hozzáféréshez (Secure Enclave, File Protection).