Wo würden Sie die geschützten Benutzerdaten aufbewahren?

Um Daten des Benutzers auf iOS geschützt speichern, würde ich je nach Datentyp und Sicherheitsniveau die folgenden Orte verwenden:

1. Keychain Services:

   • Ideal zum Speichern kleiner Mengen vertraulicher Informationen wie Passwörter, Autorisierungstokens, Verschlüsselungsschlüssel.
   • Der System-Daemon securityd verwaltet den Keychain und speichert die Daten verschlüsselt auf der Festplatte.
   • Unterstützt verschiedene Zugriffslevel (z.B. nur bei entsperrtem Gerät verfügbar).
   • Daten werden automatisch über iCloud Keychain synchronisiert, wenn aktiviert.

   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) // Bestehenden Eintrag löschen
       return SecItemAdd(query as CFDictionary, nil) // Neuen Eintrag hinzufügen
   }
   

2. Encrypted Core Data / Realm:

   • Für strukturierte Daten, die auf Datenbankebene verschlüsselt werden müssen.
   • Core Data unterstützt Drittanbieter-Erweiterungen für Verschlüsselung (z.B. RNCryptor).
   • Realm Database hat integrierte Verschlüsselung für die Datenbankdatei.
   • Der Verschlüsselungsschlüssel sollte im Keychain gespeichert werden.

   // Beispiel für die Initialisierung von Realm mit Verschlüsselung
   import RealmSwift
   
   func setupEncryptedRealm() throws {
       var config = Realm.Configuration()
       if let key = KeychainHelper.getRealmEncryptionKey() { // Schlüssel aus dem Keychain holen
           config.encryptionKey = key
       } else {
           // Neuer Schlüssel generieren, im Keychain speichern und verwenden
           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 verwenden
   }
   

3. File Protection APIs:

   • Für die Verschlüsselung von Dateien im Dateisystem der App.
   • iOS verschlüsselt Dateien automatisch auf Systemebene mit Schlüsseln, die vom Secure Enclave verwaltet werden.
   • Verschiedene Schutzmodi (z.B. complete, completeUnlessOpen, completeUntilFirstUserAuthentication, none) können gesetzt werden, um den Zugriff je nach Gerätestatus zu steuern.

   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: "Dokumentverzeichnis nicht gefunden"]) }
   
       let fileURL = documentDirectory.appendingPathComponent(fileName)
   
       // Schutzmodus setzen
       let options: Data.WritingOptions = .atomicWrite
       let protectedOptions: Data.WritingOptions = options.union(.writingWithoutOverwriting) // Nur ein Beispiel, echte Schutzoptionen werden durch Dateiattribute oder info.plist gesetzt
   
       try data.write(to: fileURL, options: options)
   
       // Dateisystem-Attribute setzen (Beispiel)
       var attributes: [FileAttributeKey : Any] = [:]
       attributes[.protectionKey] = FileProtectionType.complete
       try fileManager.setAttributes(attributes, ofItemAtPath: fileURL.path)
   }
   

4. Secure Enclave:

   • Hardware-Coprocessor, getrennt vom Hauptprozessor, zum Speichern und Verarbeiten kryptografischer Schlüssel und Daten.
   • Wird für Touch ID / Face ID und andere sensible Operationen verwendet.
   • Schlüssel im Secure Enclave verlassen diese niemals und sind für den Hauptprozessor oder das Betriebssystem nicht zugänglich.
   • Ideal zum Generieren, Speichern und Verwenden von Schlüsseln für Signaturen oder Verschlüsselung, bei denen Schutz vor Softwareangriffen wichtig ist.

   import CryptoKit
   import LocalAuthentication
   
   func generateAndStoreKeyInSecureEnclave() throws -> P256.Signing.PrivateKey {
       let accessControl = SecAccessControlCreateWithFlags(
           kCFAllocatorDefault,
           kSecAttrAccessibleWhenPasscodeSetThisDeviceOnly, // Verfügbar bei gesetztem Passcode
           [.userPresence], // Benutzer-Authentifizierung erforderlich (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, // Schlüssel ist dauerhaft
               kSecAttrApplicationTag as String: "com.yourapp.signingkey".data(using: .utf8)!, // Einzigartiges Tag
               kSecAttrAccessControl as String: accessControl
           ]
       ]
   
       var error: Unmanaged<CFError>?
       guard let privateKey = SecKeyCreateRandomKey(attributes as CFDictionary, &error) else {
           throw error!.takeRetainedValue() as Error
       }
   
       // Schlüssel aus Secure Enclave durch Tag für Nutzung abrufen
       return try P256.Signing.PrivateKey(rawRepresentation: privateKeyData) // Beispiel, Umwandlung von SecKey in Data erforderlich
   }
   

Die Wahl des Speicherorts hängt ab von:

• Datenmenge (klein vs strukturierte Daten).
• Datentyp (Passwort vs Datei vs kryptografischer Schlüssel).
• Erforderlichem Schutzniveau.
• Notwendigkeit der Synchronisation zwischen Geräten (Keychain).
• Notwendigkeit der Benutzerauthentifizierung für Zugriff (Secure Enclave, Dateischutz).