0Pricing
Swift Academy · Lezione

Autenticazione biometrica

Autentichi gli utenti con Face ID e Touch ID.

Autenticazione biometrica è una lezione Swift Academy gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Swift Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Swift Academy include 4 lezioni in totale.

Dati biometrici con LocalAuthentication

Face ID e Touch ID consentono agli utenti di dimostrare la propria identità senza digitare una password. Il framework LocalAuthentication espone questa funzionalità tramite LAContext, che valuta una policy di autenticazione e comunica se l'utente l'ha superata.

import LocalAuthentication
let context = LAContext()
// One LAContext object drives a single auth attempt

Verificare prima la disponibilità

Chiami sempre canEvaluatePolicy prima di mostrare la richiesta di autenticazione. Il dispositivo potrebbe non avere hardware biometrico, l'utente potrebbe non aver registrato i propri dati biometrici oppure la biometria potrebbe essere stata bloccata. Il metodo restituisce un Bool e, in caso di errore, un errore che ne spiega il motivo.

import LocalAuthentication
func canUseBiometrics() -> Bool {
    let context = LAContext()
    var error: NSError?
    return context.canEvaluatePolicy(
        .deviceOwnerAuthenticationWithBiometrics,
        error: &error)
}

Le due policy

.deviceOwnerAuthenticationWithBiometrics richiede Face ID o Touch ID senza fallback al codice. .deviceOwnerAuthentication prova a usare i dati biometrici, ma in alternativa utilizza il codice del dispositivo. Scelga in base al fatto che il codice sia accettabile o meno.

import LocalAuthentication
// Biometrics only (no passcode fallback):
let strict = LAPolicy.deviceOwnerAuthenticationWithBiometrics
// Biometrics with passcode fallback:
let lenient = LAPolicy.deviceOwnerAuthentication
_ = (strict, lenient)

Valutare la policy

evaluatePolicy esegue l'autenticazione mostrando la schermata biometrica di sistema. La stringa localizedReason spiega all'utente perché viene richiesta l'autenticazione. La versione asincrona restituisce un Bool oppure genera un errore.

import LocalAuthentication
func authenticate() async -> Bool {
    let context = LAContext()
    do {
        return try await context.evaluatePolicy(
            .deviceOwnerAuthentication,
            localizedReason:
                String(localized: "Unlock your account"))
    } catch {
        return false
    }
}

Rilevare il tipo di biometria

Dopo canEvaluatePolicy, context.biometryType indica se il dispositivo utilizza .faceID, .touchID, .opticID o .none. Lo utilizzi per mostrare l'icona e il testo corretti nella propria interfaccia.

import LocalAuthentication
func biometryLabel() -> String {
    let context = LAContext()
    _ = context.canEvaluatePolicy(
        .deviceOwnerAuthenticationWithBiometrics, error: nil)
    switch context.biometryType {
    case .faceID:  return "Face ID"
    case .touchID: return "Touch ID"
    case .opticID: return "Optic ID"
    default:       return "Passcode"
    }
}

Gestire gli errori

Gli errori vengono restituiti come codici LAError: .userCancel, .userFallback (l'utente ha scelto il codice), .biometryLockout dopo troppi tentativi non riusciti e .biometryNotEnrolled. Gestisca questi casi separatamente per fornire indicazioni utili invece di un errore generico.

import LocalAuthentication
func describe(_ error: Error) -> String {
    guard let la = error as? LAError else { return "failed" }
    switch la.code {
    case .userCancel:        return "cancelled"
    case .biometryLockout:   return "locked out"
    case .biometryNotEnrolled: return "not set up"
    default:                 return "failed"
    }
}

La stringa di utilizzo di Face ID

Per utilizzare Face ID deve aggiungere a Info.plist la chiave NSFaceIDUsageDescription con una spiegazione del motivo. Se la omette, l'app va in crash la prima volta che valuta una policy Face ID. Touch ID non richiede una chiave analoga.

// Info.plist:
// NSFaceIDUsageDescription =
//   "We use Face ID to unlock your saved passwords."
let required = "NSFaceIDUsageDescription is mandatory"
_ = required

Personalizzare la schermata

Può personalizzare la richiesta: localizedCancelTitle rinomina il pulsante di annullamento, mentre localizedFallbackTitle imposta o nasconde, se vuoto, l'opzione di fallback. Impostando una stringa di fallback vuota, l'opzione del codice viene nascosta.

import LocalAuthentication
func configured() -> LAContext {
    let context = LAContext()
    context.localizedCancelTitle =
        String(localized: "Not now")
    context.localizedFallbackTitle = "" // hide fallback
    return context
}

Riutilizzare un'autenticazione riuscita

Per impostazione predefinita, ogni chiamata a evaluatePolicy mostra nuovamente la richiesta di autenticazione. Impostando touchIDAuthenticationAllowableReuseDuration, uno sblocco riuscito recente può soddisfare un controllo successivo senza una nuova richiesta: è utile per raggruppare azioni sensibili in una breve finestra temporale.

import LocalAuthentication
func reusableContext() -> LAContext {
    let context = LAContext()
    context.touchIDAuthenticationAllowableReuseDuration = 30
    return context
}

Biometria e protezione del Keychain

LAContext verifica l'utente, ma da solo non protegge i dati. Per una sicurezza reale, lo abbini al SecAccessControl del Keychain, così il segreto rimane illeggibile a livello crittografico finché l'autenticazione non ha esito positivo, invece di essere semplicemente nascosto dietro un Bool verificato.

import LocalAuthentication
// A bare evaluatePolicy == true is bypassable if your
// logic is tampered with. Prefer SecAccessControl so
// the data is encrypted until auth succeeds.
let pairing = "combine LAContext with Keychain ACL"
_ = pairing

Un flusso completo di sblocco

Combini il controllo della disponibilità, messaggi adattati al tipo di biometria, valutazione e gestione degli errori in un'unica procedura robusta che l'interfaccia possa chiamare.

import LocalAuthentication
func unlock() async -> Bool {
    let context = LAContext()
    var err: NSError?
    guard context.canEvaluatePolicy(
        .deviceOwnerAuthentication, error: &err) else {
        return false
    }
    return (try? await context.evaluatePolicy(
        .deviceOwnerAuthentication,
        localizedReason:
            String(localized: "Access your vault"))) ?? false
}

Verifica rapida

Ricordi la differenza tra le due policy principali.

Riepilogo

Ha imparato l'autenticazione biometrica:

  • Utilizzi LAContext e chiami canEvaluatePolicy prima di evaluatePolicy.
  • .deviceOwnerAuthenticationWithBiometrics utilizza esclusivamente i dati biometrici; .deviceOwnerAuthentication aggiunge il fallback al codice.
  • Legga biometryType per usare il testo corretto e gestisca i codici LAError come .biometryLockout.
  • Aggiunga NSFaceIDUsageDescription e abbini SecAccessControl del Keychain per una protezione reale.

Domande Frequenti

La lezione «Autenticazione biometrica» è gratuita?

Sì — il testo completo di «Autenticazione biometrica» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Swift Academy, passa a CoddyKit PRO. Il corso Swift Academy include 4 lezioni in totale.

Cosa imparerò in «Autenticazione biometrica»?

Autentichi gli utenti con Face ID e Touch ID. Eserciti Swift Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Swift Academy?

Non è richiesta alcuna esperienza precedente. Swift Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.

Quanto tempo richiede la lezione «Autenticazione biometrica»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Swift Academy?

Sì. Ogni lezione Swift Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Memorizzazione dei segreti nel portachiavi
  2. Controllo degli accessi al portachiavi
  3. Autenticazione biometrica
  4. Protezione dei dati e crittografia
← Torna a Swift Academy