Swift Academy · Lekcja

Uwierzytelnianie biometryczne

Uwierzytelniaj użytkowników za pomocą Face ID i Touch ID.

Uwierzytelnianie biometryczne to bezpłatna lekcja Swift Academy na CoddyKit. To lekcja 3 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Swift Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Swift Academy zawiera 4 lekcji w sumie.

Biometria za pomocą LocalAuthentication

Face ID i Touch ID pozwalają użytkownikom potwierdzić swoją tożsamość bez wpisywania hasła. Framework LocalAuthentication udostępnia tę funkcję za pośrednictwem LAContext, który ocenia politykę uwierzytelniania i informuje, czy użytkownik przeszedł uwierzytelnianie.

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

Najpierw sprawdzanie dostępności

Przed wyświetleniem monitu zawsze należy wywołać canEvaluatePolicy. Urządzenie może nie mieć sprzętu biometrycznego, użytkownik może nie być zarejestrowany lub biometria może być zablokowana. Ta funkcja zwraca wartość Bool oraz błąd wyjaśniający przyczynę niepowodzenia.

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

Dwie polityki

.deviceOwnerAuthenticationWithBiometrics wymaga Face ID lub Touch ID i nie pozwala użyć kodu jako rozwiązania zastępczego. .deviceOwnerAuthentication próbuje użyć biometrii, ale w razie potrzeby przechodzi na kod urządzenia. Należy wybrać wariant w zależności od tego, czy kod jest akceptowalny.

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

Ocenianie polityki

evaluatePolicy przeprowadza uwierzytelnianie i wyświetla systemowy ekran biometryczny. Ciąg localizedReason wyjaśnia użytkownikowi, dlaczego aplikacja prosi o uwierzytelnienie. Wersja asynchroniczna zwraca wartość Bool albo zgłasza błąd.

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

Ustalanie rodzaju biometrii

Po wywołaniu canEvaluatePolicy właściwość context.biometryType informuje, czy urządzenie używa .faceID, .touchID, .opticID czy .none. Należy wykorzystać ją do wyświetlenia właściwej ikony i treści we własnym interfejsie.

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

Obsługa błędów

Niepowodzenia są zwracane jako kody LAError: .userCancel, .userFallback (użytkownik wybrał kod), .biometryLockout po zbyt wielu nieudanych próbach oraz .biometryNotEnrolled. Należy obsłużyć je osobno, aby zamiast ogólnego komunikatu o niepowodzeniu przekazywać użytkownikowi pomocne wskazówki.

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

Ciąg użycia Face ID

Aby używać Face ID, należy dodać do Info.plist klucz NSFaceIDUsageDescription z wyjaśnieniem przyczyny. Jego pominięcie powoduje awarię aplikacji przy pierwszej ocenie polityki Face ID. Touch ID nie wymaga takiego klucza.

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

Dostosowywanie ekranu uwierzytelniania

Monit można dostosować: localizedCancelTitle zmienia nazwę przycisku anulowania, a localizedFallbackTitle ustawia lub ukrywa, gdy jest pusty, opcję zastępczą. Ustawienie pustego tytułu opcji zastępczej ukrywa możliwość użycia kodu urządzenia.

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

Ponowne użycie pomyślnego uwierzytelnienia

Domyślnie każde wywołanie evaluatePolicy ponownie wyświetla monit. Ustawienie touchIDAuthenticationAllowableReuseDuration pozwala, aby niedawne pomyślne odblokowanie spełniło wymagania późniejszego sprawdzenia bez wyświetlania nowego monitu — jest to przydatne przy grupowaniu poufnych operacji wykonywanych w krótkim czasie.

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

Biometria a ograniczanie dostępu przez Keychain

LAContext weryfikuje użytkownika, ale sam nie chroni danych. Aby zapewnić rzeczywiste bezpieczeństwo, należy połączyć go z SecAccessControl w Keychain, tak aby sekret był kryptograficznie nieczytelny do czasu pomyślnego uwierzytelnienia — a nie tylko ukryty za sprawdzeniem wartości Bool.

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

Kompletny proces odblokowywania

Sprawdzanie dostępności, komunikaty uwzględniające rodzaj biometrii, ocenianie polityki i obsługę błędów należy połączyć w jedną solidną procedurę, którą interfejs może wywołać.

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
}

Szybkie sprawdzenie

Proszę przypomnieć sobie różnicę między dwiema głównymi politykami.

Podsumowanie

Poznali Państwo uwierzytelnianie biometryczne:

Należy używać LAContext i wywoływać canEvaluatePolicy przed evaluatePolicy.
.deviceOwnerAuthenticationWithBiometrics ogranicza się do biometrii, a .deviceOwnerAuthentication dodaje możliwość użycia kodu.
Należy odczytywać biometryType, aby wyświetlać właściwe komunikaty, oraz obsługiwać kody LAError, takie jak .biometryLockout.
Należy dodać NSFaceIDUsageDescription i połączyć rozwiązanie z SecAccessControl w Keychain, aby zapewnić rzeczywistą ochronę.

Często zadawane pytania

Czy lekcja „Uwierzytelnianie biometryczne” jest bezpłatna?

Tak — pełny tekst „Uwierzytelnianie biometryczne” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Swift Academy, przejdź na CoddyKit PRO. Kurs Swift Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Uwierzytelnianie biometryczne”?

Uwierzytelniaj użytkowników za pomocą Face ID i Touch ID. Ćwiczysz Swift Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Swift Academy?

Nie wymagamy żadnego doświadczenia. Swift Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 3 z 4.

Ile czasu zajmuje lekcja „Uwierzytelnianie biometryczne”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Swift Academy?

Tak. Każda lekcja Swift Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do Swift Academy