PricingLoginStart free
Swift Academy · Aula

Controle de Acesso ao Keychain

Proteja itens com biometria e desbloqueio do dispositivo.

Aula 2 de 413 etapas

Controle de Acesso ao Keychain é uma aula grátis de Swift Academy no CoddyKit. Esta é a aula 2 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.

Controlando quando os segredos podem ser lidos

Armazenar um segredo é apenas metade do trabalho — você também precisa controlar quando ele pode ser lido. O chaveiro oferece classes de acessibilidade e flags de controle de acesso que protegem os itens por meio do desbloqueio do dispositivo, do código de acesso ou da biometria. Isso protege os dados caso o dispositivo seja perdido.

import Security
// Two layers of control:
//   kSecAttrAccessible  -> when readable (lock state)
//   SecAccessControl    -> user presence / biometrics

A chave kSecAttrAccessible

kSecAttrAccessible define a classe de acessibilidade durante a adição. Ela determina se um item estará sempre disponível, somente após o primeiro desbloqueio ou apenas enquanto o dispositivo estiver desbloqueado. Escolha o nível mais rigoroso permitido pelo recurso.

import Security
let query: [String: Any] = [
    kSecClass as String: kSecClassGenericPassword,
    kSecAttrAccount as String: "user",
    kSecValueData as String: Data("secret".utf8),
    kSecAttrAccessible as String:
        kSecAttrAccessibleWhenUnlocked
]
_ = query

WhenUnlocked

kSecAttrAccessibleWhenUnlocked torna o item legível somente enquanto o dispositivo está desbloqueado. Tarefas em segundo plano executadas enquanto o dispositivo está bloqueado não conseguem acessá-lo. Essa é a opção padrão adequada para a maioria dos tokens de sessão.

import Security
// Readable only while unlocked; blocked when locked.
let level = kSecAttrAccessibleWhenUnlocked
_ = level

AfterFirstUnlock

kSecAttrAccessibleAfterFirstUnlock mantém o item legível desde o primeiro desbloqueio após a inicialização até a próxima reinicialização — mesmo quando o dispositivo é bloqueado depois disso. Use essa opção para segredos necessários a um processo em segundo plano, como um token para lidar com notificações push.

import Security
// Available after the first unlock post-boot,
// including while subsequently locked.
let level = kSecAttrAccessibleAfterFirstUnlock
_ = level

Variantes ThisDeviceOnly

Cada classe de acessibilidade tem uma versão ...ThisDeviceOnly. Esses itens são excluídos dos backups criptografados e nunca são migrados para um novo dispositivo. Use essas versões para chaves que nunca devem sair deste hardware.

import Security
// Never backed up, never migrated:
let local = kSecAttrAccessibleWhenUnlockedThisDeviceOnly
_ = local

Quando há um código de acesso

kSecAttrAccessibleWhenPasscodeSetThisDeviceOnly armazena o item somente se o usuário tiver um código de acesso e o exclui se o código for removido. Isso garante que o segredo esteja sempre protegido por código de acesso.

import Security
let level =
    kSecAttrAccessibleWhenPasscodeSetThisDeviceOnly
// Item vanishes if the user disables their passcode.
_ = level

SecAccessControl para presença do usuário

Além do estado de bloqueio, SecAccessControlCreateWithFlags cria uma política que exige autenticação ativa do usuário — por biometria ou código de acesso — no momento da leitura. Você a associa por meio de kSecAttrAccessControl, em vez da chave de acessibilidade ou junto com ela.

import Security
func makeControl() -> SecAccessControl? {
    return SecAccessControlCreateWithFlags(
        nil,
        kSecAttrAccessibleWhenUnlockedThisDeviceOnly,
        .userPresence,
        nil)
}

Flags de controle de acesso

Os flags refinam o requisito: .userPresence permite biometria ou uma alternativa com código de acesso; .biometryCurrentSet invalida o item se as impressões digitais ou os rostos cadastrados mudarem; .devicePasscode força a inserção do código de acesso. Combine-os para expressar suas necessidades de segurança.

import Security
// .userPresence        -> biometric OR passcode
// .biometryAny         -> any enrolled biometric
// .biometryCurrentSet  -> invalidate on biometric change
// .devicePasscode      -> passcode only
let flags: SecAccessControlCreateFlags = [.userPresence]
_ = flags

Adicionando um item protegido

Para armazenar um segredo protegido por biometria, coloque o objeto SecAccessControl em kSecAttrAccessControl. Qualquer leitura posterior solicitará que o usuário se autentique antes que os dados sejam retornados.

import Security
func saveProtected(_ data: Data, account: String,
                   control: SecAccessControl) -> Bool {
    let query: [String: Any] = [
        kSecClass as String: kSecClassGenericPassword,
        kSecAttrAccount as String: account,
        kSecValueData as String: data,
        kSecAttrAccessControl as String: control]
    return SecItemAdd(query as CFDictionary, nil)
        == errSecSuccess
}

A leitura solicita a autenticação do usuário

A leitura de um item protegido aciona automaticamente a interface de autenticação. Você pode fornecer uma string de motivo por meio de kSecUseOperationPrompt para que a solicitação explique por que o acesso é necessário. A leitura fica bloqueada até que o usuário se autentique ou cancele.

import Security
func readProtected(account: String) -> Data? {
    let query: [String: Any] = [
        kSecClass as String: kSecClassGenericPassword,
        kSecAttrAccount as String: account,
        kSecReturnData as String: true,
        kSecUseOperationPrompt as String:
            String(localized: "Unlock your saved key")]
    var out: CFTypeRef?
    return SecItemCopyMatching(query as CFDictionary,
        &out) == errSecSuccess ? out as? Data : nil
}

Escolhendo o nível adequado

Associe a política ao risco:

  • Token de sessão usado em segundo plano: AfterFirstUnlock.
  • Token usado apenas na interface: WhenUnlocked.
  • Segredo de alto valor: SecAccessControl com .userPresence e uma classe ThisDeviceOnly.

Uma proteção mais rigorosa é mais segura, mas impede o acesso em segundo plano — equilibre os dois aspectos.

import Security
// High-value: biometric-gated, device-bound, no backup
let control = SecAccessControlCreateWithFlags(
    nil,
    kSecAttrAccessibleWhenPasscodeSetThisDeviceOnly,
    .userPresence, nil)
_ = control

Verificação rápida

Relembre qual classe de acessibilidade é adequada para um segredo necessário em segundo plano.

Responda na aula interativa

Recapitulação

Você aprendeu a proteger itens do chaveiro:

  • kSecAttrAccessible define a disponibilidade conforme o estado de bloqueio: WhenUnlocked, AfterFirstUnlock e as variantes ...ThisDeviceOnly, que não incluem os itens nos backups.
  • WhenPasscodeSetThisDeviceOnly vincula o item à existência de um código de acesso.
  • SecAccessControl com flags como .userPresence ou .biometryCurrentSet exige autenticação no momento da leitura.
  • Escolha o nível mais rigoroso que ainda permita o seu padrão de acesso.
Grátis para começar

Aprenda Swift com um tutor de IA — grátis

Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.

Cursos
122
Aulas
409
Começar a aprender grátisVer o curso completo

Perguntas Frequentes

A aula “Controle de Acesso ao Keychain” é grátis?

Sim — o texto completo de “Controle de Acesso ao Keychain” é 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 “Controle de Acesso ao Keychain”?

Proteja itens com biometria e desbloqueio do dispositivo. 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 2 de 4.

Quanto tempo leva a aula “Controle de Acesso ao Keychain”?

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