0Pricing
Swift Academy · Aula

Autenticação biométrica

Autentique usuários com Face ID e Touch ID.

Autenticação biométrica é uma aula grátis de Swift Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Swift Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Swift Academy inclui 4 aulas no total.

Biometria com LocalAuthentication

Face ID e Touch ID permitem que os usuários comprovem sua identidade sem digitar uma senha. O framework LocalAuthentication oferece esse recurso por meio de LAContext, que avalia uma política de autenticação e informa se o usuário foi aprovado.

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

Verificando a disponibilidade primeiro

Sempre chame canEvaluatePolicy antes de solicitar a autenticação. O dispositivo pode não ter hardware biométrico, o usuário pode não estar cadastrado ou a biometria pode estar bloqueada. Essa chamada retorna um valor booleano e, em caso de falha, um erro que explica o motivo.

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

As duas políticas

.deviceOwnerAuthenticationWithBiometrics exige Face ID ou Touch ID, sem alternativa por código de acesso. .deviceOwnerAuthentication tenta usar a biometria, mas oferece o código de acesso do dispositivo como alternativa. Escolha com base em aceitar ou não o código de acesso.

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

Avaliando a política

evaluatePolicy executa a autenticação e exibe a tela biométrica do sistema. A string localizedReason explica ao usuário por que a solicitação está sendo feita. A forma assíncrona retorna um valor booleano ou lança um erro.

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

Detectando o tipo de biometria

Depois de chamar canEvaluatePolicy, context.biometryType informa se o dispositivo usa .faceID, .touchID, .opticID ou .none. Use esse valor para mostrar o ícone e o texto corretos na sua própria 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"
    }
}

Lidando com erros

As falhas chegam como códigos de LAError: .userCancel, .userFallback (o usuário escolheu o código de acesso), .biometryLockout após muitas falhas e .biometryNotEnrolled. Trate esses casos separadamente para oferecer orientações úteis em vez de uma falha genérica.

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

A string de uso do Face ID

Para usar o Face ID, você precisa adicionar NSFaceIDUsageDescription a Info.plist, explicando o motivo. Se ela estiver ausente, o aplicativo será encerrado na primeira vez que você avaliar uma política do Face ID. O Touch ID não precisa dessa chave.

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

Personalizando a tela de autenticação

Você pode personalizar a solicitação: localizedCancelTitle renomeia o botão de cancelamento, e localizedFallbackTitle define ou oculta, quando vazio, a opção alternativa. Definir um título alternativo vazio suprime a opção de usar o código de acesso.

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

Reutilizando uma autenticação bem-sucedida

Por padrão, cada chamada a evaluatePolicy solicita a autenticação novamente. Definir touchIDAuthenticationAllowableReuseDuration permite que um desbloqueio recente bem-sucedido satisfaça uma verificação posterior sem uma nova solicitação — algo útil para agrupar ações sensíveis em um intervalo curto.

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

Biometria versus proteção do chaveiro

LAContext verifica o usuário, mas não protege os dados por si só. Para obter segurança real, associe-o a SecAccessControl no chaveiro, para que o segredo permaneça criptograficamente ilegível até que a autenticação seja bem-sucedida — em vez de ficar apenas oculto atrás de um valor booleano verificado.

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

Um fluxo completo de desbloqueio

Combine a verificação de disponibilidade, as mensagens adaptadas ao tipo de biometria, a avaliação e o tratamento de erros em uma única rotina robusta que a interface possa chamar.

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ção rápida

Relembre a diferença entre as duas principais políticas.

Recapitulação

Você aprendeu sobre autenticação biométrica:

  • Use LAContext e chame canEvaluatePolicy antes de evaluatePolicy.
  • .deviceOwnerAuthenticationWithBiometrics usa apenas biometria; .deviceOwnerAuthentication acrescenta o código de acesso como alternativa.
  • Leia biometryType para usar o texto correto e trate códigos de LAError como .biometryLockout.
  • Adicione NSFaceIDUsageDescription e associe-o a SecAccessControl no chaveiro para obter proteção real.

Perguntas Frequentes

A aula “Autenticação biométrica” é grátis?

Sim — o texto completo de “Autenticação biométrica” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Swift Academy, atualize para CoddyKit PRO. O curso de Swift Academy inclui 4 aulas no total.

O que vou aprender em “Autenticação biométrica”?

Autentique usuários com Face ID e Touch ID. Você pratica Swift Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Swift Academy?

Nenhuma experiência prévia é necessária. Swift Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “Autenticação biométrica”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Swift Academy?

Sim. Cada aula de Swift Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Armazenamento de Segredos no Keychain
  2. Controle de Acesso ao Keychain
  3. Autenticação biométrica
  4. Proteção e criptografia de dados
← Voltar para Swift Academy