Swift Academy · Leçon

Authentification biométrique

Authentifiez les utilisateurs avec Face ID et Touch ID.

Authentification biométrique est une leçon Swift Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Swift Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Swift Academy comprend 4 leçons au total.

Données biométriques avec LocalAuthentication

Face ID et Touch ID permettent aux utilisateurs de prouver leur identité sans saisir de mot de passe. Le framework LocalAuthentication fournit cette fonctionnalité via LAContext, qui évalue une politique d’authentification et vous indique si l’utilisateur a réussi.

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

Vérifier d’abord la disponibilité

Appelez toujours canEvaluatePolicy avant de demander l’authentification. L’appareil peut ne pas disposer de matériel biométrique, l’utilisateur peut ne pas être enregistré ou les données biométriques peuvent être temporairement bloquées. Cette méthode renvoie un booléen et une erreur expliquant la cause de l’échec, le cas échéant.

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

Les deux politiques

.deviceOwnerAuthenticationWithBiometrics exige Face ID ou Touch ID, sans solution de secours par code d’accès. .deviceOwnerAuthentication essaie d’abord les données biométriques, puis utilise le code d’accès de l’appareil en solution de secours. Faites votre choix selon que vous acceptez ou non le code d’accès.

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

Évaluer la politique

evaluatePolicy effectue l’authentification et affiche la feuille système des données biométriques. La chaîne localizedReason explique à l’utilisateur pourquoi vous faites cette demande. La forme asynchrone renvoie un booléen ou lève une erreur.

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
    }
}

Détecter le type de données biométriques

Après canEvaluatePolicy, context.biometryType vous indique si l’appareil utilise .faceID, .touchID, .opticID ou .none. Utilisez cette information pour afficher l’icône et le texte appropriés dans votre propre interface.

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"
    }
}

Gérer les erreurs

Les échecs arrivent sous forme de codes LAError : .userCancel, .userFallback (l’utilisateur a choisi le code d’accès), .biometryLockout après trop d’échecs et .biometryNotEnrolled. Traitez ces cas séparément pour fournir des indications utiles plutôt qu’un échec générique.

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 chaîne d’utilisation de Face ID

Pour utiliser Face ID, vous devez ajouter NSFaceIDUsageDescription à Info.plist en expliquant pourquoi. Son absence provoque l’arrêt de l’application lors de la première évaluation d’une politique Face ID. Touch ID ne nécessite aucune clé de ce type.

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

Personnaliser la feuille

Vous pouvez personnaliser la demande : localizedCancelTitle renomme le bouton d’annulation et localizedFallbackTitle définit l’option de secours ou la masque lorsqu’elle est vide. Définir un titre de secours vide supprime l’option de saisie du code d’accès.

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

Réutiliser une authentification réussie

Par défaut, chaque appel à evaluatePolicy affiche une nouvelle demande. Définir touchIDAuthenticationAllowableReuseDuration permet à un déverrouillage réussi récent de satisfaire une vérification ultérieure sans nouvelle demande — ce qui est utile pour regrouper des actions sensibles dans un court intervalle.

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

Données biométriques et protection du Trousseau

LAContext vérifie l’utilisateur, mais ne protège pas les données à lui seul. Pour une véritable sécurité, associez-le à SecAccessControl du Trousseau afin que le secret soit cryptographiquement illisible tant que l’authentification n’a pas réussi, plutôt que simplement masqué derrière un booléen vérifié.

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 flux de déverrouillage complet

Réunissez la vérification de disponibilité, les messages adaptés au type, l’évaluation et la gestion des erreurs dans une seule routine robuste que votre interface pourra appeler.

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
}

Vérification rapide

Rappelez-vous la différence entre les deux principales politiques.

Récapitulatif

Vous avez appris l’authentification biométrique :

Utilisez LAContext et appelez canEvaluatePolicy avant evaluatePolicy.
.deviceOwnerAuthenticationWithBiometrics utilise uniquement les données biométriques ; .deviceOwnerAuthentication ajoute une solution de secours par code d’accès.
Lisez biometryType pour employer le texte approprié et gérez les codes LAError tels que .biometryLockout.
Ajoutez NSFaceIDUsageDescription et associez-le à SecAccessControl du Trousseau pour une véritable protection.

Questions Fréquemment Posées

La leçon « Authentification biométrique » est-elle gratuite ?

Oui — le texte complet de « Authentification biométrique » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Swift Academy, passe à CoddyKit PRO. Le cours Swift Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Authentification biométrique » ?

Authentifiez les utilisateurs avec Face ID et Touch ID. Tu pratiques Swift Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Swift Academy ?

Aucune expérience préalable n'est requise. Swift Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « Authentification biométrique » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Swift Academy ?

Oui. Chaque leçon Swift Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Swift Academy