Introduzione all'autenticazione biometrica su iOS

Per gli sviluppatori iOS, il framework LocalAuthentication fornisce un API semplice ma potente per integrare Touch ID, Face ID e controllo del codice di accesso ai dispositivi nelle applicazioni. Questo articolo passa attraverso il processo completo di autenticazione biometrica utilizzando LocalAuthentication, dalla configurazione iniziale alle best practice di produzione, garantendo che la tua applicazione soddisfi i più elevati standard di privacy e sicurezza degli utenti.

Alla fine di questa guida, capirete come controllare la disponibilità biometrica, richiedere agli utenti l'autenticazione, gestire gli errori con grazia e fornire meccanismi di fallback, tutto seguendo le linee guida di Apple per la privacy degli utenti e la protezione dei dati.

Comprendere il quadro di autenticazione locale

Il framework LocalAuthentication, introdotto in iOS 8, fornisce un'interfaccia unificata per valutare l'identità dell'utente attraverso biometrici o un codice di accesso al dispositivo.

I componenti chiave del quadro includono:

  • LAContext:[] L'oggetto centrale che gestisce le politiche di autenticazione, le stringhe di ragione localizzate e il comportamento di fallback.
  • LAPolicy:[] Criteri predefiniti che determinano il metodo di autenticazione. I due più comuni sono (solo biometrici) e (biometrici con il codice di accesso fallback).
  • LAError:[] Codici di errore che informano la tua app perché l'autenticazione non è stata trovata – la biometria non è disponibile, l'utente ha cancellato, il codice di accesso non impostato, e altri.

Mentre il framework è semplice da usare, l'implementazione corretta richiede un'attenzione attenta all'esperienza degli utenti, alla gestione degli errori e alla sicurezza.

Politiche di autenticazione Spiegate

  • – Se la biometria (Touch ID o Face ID) è iscritta e disponibile, questa politica richiede all'utente solo la verifica biometrica. Se la biometria non è disponibile, la valutazione politica non riesce a offrire un dropback di codice di accesso.
  • – Questa politica tenta prima la verifica biometrica. Se la biometria non è disponibile, l'utente non si iscrive, o l'utente cancella il prompt biometrico, la tua app può tornare al codice del pass del dispositivo. Questa è la politica consigliata per la maggior parte degli scenari di autenticazione perché assicura che anche quando la biometria non è un'opzione, l'utente può ancora autenticarsi utilizzando il codice di accesso.

È importante notare che il dropback del codice di accesso appare solo dopo che l'utente cancella il prompt biometrico o se la biometria non riesce e l'utente tocca “Enter Passcode”. È necessario gestire questi eventi correttamente per evitare di confondere l'utente.

Attuazione passo-passo

L'implementazione dell'autenticazione biometrica comporta cinque passaggi chiari: importare il framework, creare un'istanza , verificare se la politica desiderata può essere valutata, eseguire la valutazione e gestire il risultato.

1. Importare il quadro

Inizia importando in qualsiasi file Swift dove si intende utilizzare l'autenticazione. Questa importazione ti dà accesso a [, , e tutti i tipi di errore.

import LocalAuthentication

2. Creare un LAContext

è l'oggetto che interroga lo stato del sistema e esegue la valutazione dell'autenticazione. È possibile configurare in modo facoltativo le proprietà come il [ (il messaggio mostrato all'utente) e il (il testo per il pulsante di fallback). Ad esempio, è possibile modificare il titolo di fallback per “Usa Passcode” invece della password di default “Enter”.

let context = LAContext()
context.localizedFallbackTitle = "Use Passcode"

3. Controllare la disponibilità biometrica

Prima di richiedere l'utente, è necessario verificare se la politica scelta può essere valutata. Questo controllo è essenziale per evitare un brusco fallimento che potrebbe confondere l'utente. Utilizzare il metodo , passando la politica che si intende utilizzare. Il metodo restituisce un valore Boolean. Se ritorna , il parametro (un ] indica che dettagli di valutazione non contengono.

var error: NSError?
let canEvaluate = context.canEvaluatePolicy(.deviceOwnerAuthentication, error: &error)

if !canEvaluate {
 // Handle the error – see section on error handling below
 print("Authentication not available: \(error?.localizedDescription ?? "Unknown error")")
 return
}

Tra le ragioni comuni per il fallimento: il dispositivo non supporta la biometria, non è registrata alcuna impronta digitale o la faccia, il codice del pass del dispositivo non è impostato, o l'applicazione non ha un diritto per Face ID (vedi best practice).

4. Valutare la politica

Una volta confermata la valutazione della politica, chiama . Il parametro è una stringa che spiega perché la tua applicazione ha bisogno di autenticazione. Questa stringa deve essere chiara e facile da usare perché viene visualizzata nel prompt del sistema. Per Face ID, viene sempre mostrato il motivo; per Touch ID, può essere mostrato in base alla configurazione del dispositivo.

context.evaluatePolicy(.deviceOwnerAuthentication, localizedReason: "Authenticate to access your secure data") { success, evaluateError in
 DispatchQueue.main.async {
 if success {
 // Authentication successful
 print("User authenticated successfully")
 } else {
 // Authentication failed or was cancelled
 print("Authentication failed: \(evaluateError?.localizedDescription ?? "Unknown error")")
 }
 }
}

Si noti che il gestore di completamento non è garantito per essere eseguito sul thread principale.

5. Maneggiare il Risultato

Quando l'autenticazione riesce, è possibile consentire con fiducia l'accesso a contenuti o azioni protetti. Quando non riesce, è necessario determinare la causa ispezionando []. L'errore sarà di tipo , che è un enum conforme a .

  • .userCancel:[]] L'utente ha cliccato “Cancella” sul prompt biometrico. Si potrebbe semplicemente annullare il flusso di login o riprovare.
  • .userFallback: The user tapped the fallback button (e.g., “Enter Password”). This triggers the passcode entry if using .deviceOwnerAuthentication, but if you only used .deviceOwnerAuthenticationWithBiometrics, no fallback occurs. In that case, you should present your own passcode entry screen.
  • .biometryNotAvailable: Biometry is not available on this device (e.g., missing hardware). You should switch to passcode-only authentication.
  • .biometryNotEnrolled: No biometric data is enrolled. Prompt the user to set up Touch ID or Face ID in Settings.
  • .biometryLockout: Too many failed attempts; the system has locked biometry. You need to fall back to the passcode. The system passcode will reset the lockout.
  • .passcodeNotSet: The device has no passcode configured. The user must set a passcode for biometry to work. Display an alert directing them to Settings.

Handling each of these cases gracefully is essential for a smooth user experience. For a production app, consider centralising your authentication logic in a manager class and providing clear feedback to the user.

Complete Example with Error Handling

Below is a more complete example that demonstrates a real-world authentication flow. It checks availability, handles errors with appropriate user alerts, and provides a fallback to a custom passcode entry if the user cancels biometry.

import LocalAuthentication
import UIKit

class BiometricAuthManager {
 static let shared = BiometricAuthManager()

 private let context = LAContext()

 func authenticate(completion: @escaping (Bool, String?) -> Void) {
 var error: NSError?
 context.localizedFallbackTitle = "Use Passcode"

 guard context.canEvaluatePolicy(.deviceOwnerAuthentication, error: &error) else {
 // Determine the reason why authentication is unavailable
 let message = errorMessage(for: error)
 completion(false, message)
 return
 }

 // Possibly show a loading state
 context.evaluatePolicy(.deviceOwnerAuthentication, localizedReason: "Authenticate to access your account") { success, evaluateError in
 DispatchQueue.main.async {
 if success {
 completion(true, nil)
 } else {
 let message = self.errorMessage(for: evaluateError as? LAError)
 completion(false, message)
 }
 }
 }
 }

 private func errorMessage(for error: LAError?) -> String {
 guard let error = error else {
 return "Authentication could not be completed."
 }
 switch error.code {
 case .biometryNotAvailable:
 return "Biometric authentication is not available on this device."
 case .biometryNotEnrolled:
 return "No biometric data is enrolled. Please set up Face ID or Touch ID in Settings."
 case .biometryLockout:
 return "Too many failed attempts. Please use your passcode to unlock biometrics."
 case .passcodeNotSet:
 return "A device passcode is required to use biometric authentication."
 case .userCancel:
 return "Authentication cancelled by user."
 case .userFallback:
 return "User chose to use the passcode."
 default:
 return "Authentication failed: \(error.localizedDescription)"
 }
 }
}

Questa classe incapsula la logica di autenticazione e restituisce un risultato di successo/fallimento pulito con un messaggio facile da usare. I controller di vista possono chiamare e reagire di conseguenza.

Migliori Pratiche e Considerazioni di Produzione

Mentre il codice sopra fornisce una solida base, diverse pratiche aggiuntive garantiranno la vostra implementazione è robusta, sicura e facile da usare.

Fornisci sempre un codice di accesso

Anche se si utilizza la politica , si dovrebbe avere la propria schermata di accesso codice di accesso pronto. Molti utenti potrebbero non avere biometri iscritti o potrebbero preferire utilizzare un codice di accesso in determinate situazioni.

Utilizzare una ragione descrittiva localizzata

La stringa è mostrata nel prompt del sistema. Questa stringa dovrebbe essere concisa e specifica per l'azione che l'utente sta per autorizzare. Ad esempio, "Inserire nel tuo account" è meglio di un vago "Authentication richiesto".

Rispettare la privacy dell'utente

Non memorizzare mai i dati biometrici (modelli di impronte digitali o mappe facciali) da soli. Il sistema gestisce in modo sicuro questi dati sul Secure Enclave. La tua app riceve solo un risultato di successo booleano/fallimento, non i dati biometrici effettivi.

Prova su dispositivi reali

Per l'ID del viso, è necessario includere anche il tasto ] nel vostro ; altrimenti, l'applicazione si schianta quando si tenta di valutare Face ID.

Maneggiare il ciclo di vita dell'app

Se l'applicazione utilizza l'autenticazione biometrica per garantire uno stato di sfondo, considerare di ri-autentico quando l'applicazione ritorna in primo piano. È possibile osservare e richiedere nuovamente l'autenticazione. Tuttavia, evitare di chiedere l'autenticazione troppo frequentemente - un modello comune è quello di richiedere la ri-autenzione solo dopo un periodo di timeout.

Combina con Keychain per una maggiore sicurezza

Per una sicurezza persistente (ad esempio, memorizzare i gettoni API), combinare biometrici con la Keychain. Utilizzare la classe con la ] o ] per garantire che i segreti memorizzati possano essere accessibili solo dopo aver eseguito l'autenticazione con codice a volte sicuro.

Fallback dopo il blocco

Quando la biometria è bloccata a causa di troppi tentativi falliti, è necessario rientrare nel codice di accesso del dispositivo. L'ingresso del codice di accesso del sistema resetterà automaticamente il blocco biometrico, quindi dopo un'entrata del codice di accesso di successo, i futuri tentativi biometrici funzioneranno di nuovo.

Differenze tra ID tocco e ID viso

Sebbene il quadro di autenticazione locale astratti la maggior parte delle differenze, ci sono alcune sfumature da tenere a mente:

  • Face ID richiede un dispositivo con una fotocamera TrueDepth.] Si dovrebbe controllare [ dopo aver chiamato per determinare quale tipo biometrico è disponibile. Questo consente di regolare le etichette e le icone UI di conseguenza.
  • Face ID ha una maggiore sensibilità al viaggio.] L'utente deve guardare direttamente al dispositivo. Assicurarsi che il spiega perché l'applicazione ha bisogno di Face ID.
  • Alternare l'aspetto per Face ID:[ iOS 15.4 e successivamente consentire agli utenti di impostare un aspetto alternativo (ad esempio, con occhiali o una maschera). La tua applicazione non ha bisogno di fare nulla di speciale; il sistema lo gestisce automaticamente.
  • Supporto per il viso ID:[] Le versioni iOS recenti supportano lo sblocco con una maschera utilizzando l'Apple Watch. Per l'autenticazione a livello app, il prompt standard Face ID potrebbe ancora richiedere il pieno riconoscimento del viso a meno che l'utente non abbia optato per l'uso della maschera con Apple Watch.

Dive profonda di gestione di errore

Abbiamo brevemente coperto errori comuni, ma vale la pena elaborare su come rispondere a ciascuno in modo user-friendly.

Error CodeUser Feedback
biometryNotAvailableShow an alert: “Face ID / Touch ID is not available on this device. Please use your passcode.” Then offer your custom passcode screen.
biometryNotEnrolledPresent an alert that directs the user to Settings > Face ID & Passcode (or Touch ID & Passcode). You can open Settings directly using UIApplication.openSettingsURLString.
biometryLockoutPrompt the user to authenticate using the device passcode. The system passcode entry will reset the lockout. If you use the .deviceOwnerAuthentication policy, the system automatically handles the passcode prompt. If you used .deviceOwnerAuthenticationWithBiometrics, you must fall back to your own passcode entry or invoke the .deviceOwnerAuthentication policy again to trigger the system passcode UI.
passcodeNotSetAlert the user that a device passcode is required. Direct them to Settings to set one. You cannot continue until the passcode is configured.
userCancelSimply dismiss or return to the previous screen. Do not show an error; the user intentionally cancelled.
userFallbackThe user chose the fallback option. Present your own passcode entry screen (or rely on the system passcode if you used the combined policy).

Prestazioni e filettatura

Il metodo è asincrono e non blocca il thread principale. Tuttavia, il gestore di completamento può essere chiamato su un thread di sfondo. Invio sempre aggiornamenti UI alla coda principale. Inoltre, evitare di creare un nuovo per ogni tentativo di autenticazione; riutilizzare un'istanza se possibile, ma essere consapevoli che il contesto più recente può diventare invalido dopo un blocco biometrico o un dispositivo riavvio.

Test di autenticazione biometrica

Per Touch ID, è possibile scegliere “Touch ID” e poi “Matching Touch” o “Non-matching Touch”. Per Face ID, il simulatore consente di iscrivere un volto e quindi eseguire tentativi di corrispondenza o non-matching. Tuttavia, alcuni scenari (come lockout) non sono completamente simulati. Pertanto, il test reale del dispositivo è indispensabile.

Inoltre, è possibile utilizzare i piani di test di Xcode per scrivere test unità intorno al vostro manager di autenticazione mocking la classe [[] – fornito di progettare il codice con iniezione di dipendenza.

Risorse esterne

Per ulteriori informazioni e documentazione ufficiale, fare riferimento al seguente:

Conclusioni

L’implementazione dell’autenticazione biometrica con il framework LocalAuthentication è un processo semplice che migliora significativamente la postura di sicurezza dell’app iOS mantenendo un’esperienza di utilizzo fluida. Controllando la disponibilità, maneggiando gli errori con grazia e fornendo opzioni di fallback affidabili, è possibile creare un sistema di autenticazione che rispetti la privacy degli utenti e soddisfi le linee guida stringenti di Apple.

Ricorda che l'autenticazione biometrica è solo un pezzo di una strategia di sicurezza completa. Combinalo con lo storage sicuro tramite Keychain, la sicurezza della rete e la corretta gestione della sessione per offrire ai tuoi utenti il più alto livello di protezione. Con il codice e le migliori pratiche condivise in questo articolo, sei ben equipaggiato per integrare Touch ID e Face ID nel tuo prossimo progetto iOS.