Swift Academy · Lección

Autenticación biométrica

Autentique a los usuarios con Face ID y Touch ID.

Autenticación biométrica es una lección gratuita de Swift Academy en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Swift Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Swift Academy incluye 4 lecciones en total.

Datos biométricos con LocalAuthentication

Face ID y Touch ID permiten que los usuarios demuestren su identidad sin escribir una contraseña. El framework LocalAuthentication ofrece esta función mediante LAContext, que evalúa una política de autenticación e indica si el usuario la ha superado.

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

Comprobar primero la disponibilidad

Llame siempre a canEvaluatePolicy antes de mostrar la solicitud. Es posible que el dispositivo no tenga hardware biométrico, que el usuario no esté registrado o que los datos biométricos estén bloqueados. Devuelve un Bool y un error que explica el motivo si falla.

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

Las dos políticas

.deviceOwnerAuthenticationWithBiometrics exige Face ID o Touch ID sin posibilidad de recurrir al código. .deviceOwnerAuthentication intenta usar datos biométricos, pero recurre al código del dispositivo si es necesario. Elija una u otra según si acepta el uso de un código.

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

Evaluar la política

evaluatePolicy realiza la autenticación y muestra la hoja biométrica del sistema. La cadena localizedReason explica al usuario por qué se lo solicita. La forma asíncrona devuelve un Bool o lanza un error.

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

Detectar el tipo de datos biométricos

Después de canEvaluatePolicy, context.biometryType indica si el dispositivo utiliza .faceID, .touchID, .opticID o .none. Úselo para mostrar el icono y el texto adecuados en su propia interfaz.

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

Gestionar errores

Los fallos llegan como códigos de LAError: .userCancel, .userFallback (el usuario eligió el código), .biometryLockout después de demasiados intentos fallidos y .biometryNotEnrolled. Distinga estos casos para ofrecer indicaciones útiles en lugar de mostrar un fallo genérico.

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 cadena de uso de Face ID

Para usar Face ID debe añadir NSFaceIDUsageDescription a Info.plist y explicar el motivo. Si la omite, la app se cierra inesperadamente la primera vez que evalúa una política de Face ID. Touch ID no necesita esta clave.

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

Personalizar la hoja

Puede personalizar el aviso: localizedCancelTitle cambia el nombre del botón de cancelación y localizedFallbackTitle establece o, si está vacío, oculta la opción alternativa. Establecer una cadena de alternativa vacía suprime la opción del código.

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

Reutilizar una autenticación correcta

De forma predeterminada, cada llamada a evaluatePolicy vuelve a solicitar la autenticación. Establecer touchIDAuthenticationAllowableReuseDuration permite que un desbloqueo correcto reciente satisfaga una comprobación posterior sin mostrar una nueva solicitud, lo que resulta útil para agrupar acciones sensibles dentro de un intervalo breve.

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

Datos biométricos frente al control de acceso de Keychain

LAContext verifica al usuario, pero no protege los datos por sí mismo. Para obtener una seguridad real, combínelo con SecAccessControl de Keychain, de modo que el secreto no se pueda leer criptográficamente hasta que la autenticación se complete correctamente, en lugar de limitarse a ocultarlo detrás de un Bool comprobado.

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

Flujo completo de desbloqueo

Combine la comprobación de disponibilidad, los mensajes adaptados al tipo de datos biométricos, la evaluación y la gestión de errores en una única rutina sólida que pueda llamar desde la interfaz.

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
}

Comprobación rápida

Recuerde la diferencia entre las dos políticas principales.

Resumen

Ha aprendido la autenticación biométrica:

Utilice LAContext y llame a canEvaluatePolicy antes de evaluatePolicy.
.deviceOwnerAuthenticationWithBiometrics solo permite datos biométricos; .deviceOwnerAuthentication añade la posibilidad de recurrir al código.
Lea biometryType para mostrar el texto adecuado y gestione códigos de LAError como .biometryLockout.
Añada NSFaceIDUsageDescription y combínelo con SecAccessControl de Keychain para obtener una protección real.

Preguntas frecuentes

¿La lección «Autenticación biométrica» es gratis?

Sí — el texto completo de «Autenticación biométrica» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Swift Academy, actualiza a CoddyKit PRO. El curso de Swift Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Autenticación biométrica»?

Autentique a los usuarios con Face ID y Touch ID. Practicas Swift Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Swift Academy?

No se requiere experiencia previa. Swift Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.

¿Cuánto tiempo toma la lección «Autenticación biométrica»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Swift Academy?

Sí. Cada lección de Swift Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a Swift Academy