Onde moram as falhas reais em aplicativos financeiros
O iOS entrega camadas sólidas de proteção em hardware e sistema operacional, mas quase nenhuma falha grave que já vi em auditorias de segurança mobile vem de alguém quebrando criptografia AES na força bruta. Os problemas acontecem nas decisões cotidianas de arquitetura: salvar tokens de sessão no UserDefaults, tratar o retorno booleano do Face ID como autorização final, deixar respostas JSON sensíveis gravadas no cache SQLite padrão do URLSession ou esquecer de invalidar a sessão quando o aplicativo passa vários minutos em segundo plano.
Em aplicativos financeiros de grande porte, o modelo de ameaça precisa assumir que o aparelho pode cair em mãos erradas, sofrer inspeção de tráfego com proxy local ou rodar em ambiente com jailbreak e ferramentas de instrumentação dinâmica como Frida. Quando a autenticação depende apenas de um if authenticated == true em memória, um atacante altera o retorno da função em tempo de execução e pula a biometria sem digitar uma única senha.
A proteção de verdade nasce quando combinamos camadas independentes: armazenamento preso ao hardware do aparelho, chaves protegidas pelo Secure Enclave, tokens curtos mantidos somente na RAM e controle rígido do ciclo de vida da sessão.
Princípio prático de defesa em camadas: biometria no iOS não deve apenas liberar um fluxo condicional no código Swift. Ela precisa destravar uma operação criptográfica protegida pelo hardware, como a leitura de um segredo no Keychain ou a assinatura de um desafio enviado pelo servidor.
Keychain, Secure Enclave e autenticação amarrada a hardware
Toda credencial persistente, como um refresh token ou uma chave privada de vínculo de dispositivo, deve ficar no Keychain Services com política explícita de acessibilidade. Nunca aceite o valor padrão de acessibilidade e evite chaves que permitam sincronização pelo iCloud Keychain ou restauração em backups de outro aparelho. Em fluxos financeiros, o vínculo pertence exclusivamente àquele dispositivo físico.
Um salto importante de maturidade ocorre quando você acopla a biometria diretamente ao controle de acesso do item no Keychain (SecAccessControl) ou a uma chave assimétrica gerada dentro do Secure Enclave. Nesse desenho, o servidor envia um desafio único (nonce), o aplicativo pede ao Secure Enclave que assine esse desafio, o hardware exige a validação biométrica real do usuário e devolve a assinatura para o backend verificar. Mesmo que alguém altere o fluxo de telas via instrumentação, não consegue produzir uma assinatura válida sem a chave privada, que nunca sai do coprocessador seguro.
Implementação segura de Keychain com controle biométrico em Swift
Um detalhe que muita gente deixa passar na API C do Keychain é passar kSecValueData e kSecAttrAccessControl dentro do dicionário enviado ao SecItemDelete. A consulta de remoção deve conter apenas os atributos de identificação (kSecClass, kSecAttrService e kSecAttrAccount). Outro ponto importante é a flag .biometryCurrentSet: se alguém cadastrar um novo rosto ou uma nova digital nas configurações do iPhone, o iOS invalida o item automaticamente e força novo login com senha ou fator forte.
import Foundation
import Security
import LocalAuthentication
public enum VaultError: Error {
case accessControlCreationFailed
case itemNotFound
case authenticationCanceled
case unexpectedStatus(OSStatus)
}
public final class BiometricKeychainVault {
private let service: String
public init(service: String) {
self.service = service
}
public func store(secret: Data, account: String) throws {
var cfError: Unmanaged<CFError>?
guard let accessControl = SecAccessControlCreateWithFlags(
kCFAllocatorDefault,
kSecAttrAccessibleWhenPasscodeSetThisDeviceOnly,
.biometryCurrentSet,
&cfError
) else {
throw VaultError.accessControlCreationFailed
}
// Remove registro anterior usando somente chaves de identificação
let deleteQuery: [String: Any] = [
kSecClass as String: kSecClassGenericPassword,
kSecAttrService as String: service,
kSecAttrAccount as String: account
]
SecItemDelete(deleteQuery as CFDictionary)
let addQuery: [String: Any] = [
kSecClass as String: kSecClassGenericPassword,
kSecAttrService as String: service,
kSecAttrAccount as String: account,
kSecValueData as String: secret,
kSecAttrAccessControl as String: accessControl
]
let status = SecItemAdd(addQuery as CFDictionary, nil)
guard status == errSecSuccess else {
throw VaultError.unexpectedStatus(status)
}
}
public func load(account: String, prompt: String) throws -> Data {
let context = LAContext()
context.localizedReason = prompt
context.localizedFallbackTitle = ""
let query: [String: Any] = [
kSecClass as String: kSecClassGenericPassword,
kSecAttrService as String: service,
kSecAttrAccount as String: account,
kSecReturnData as String: true,
kSecMatchLimit as String: kSecMatchLimitOne,
kSecUseAuthenticationContext as String: context
]
var result: AnyObject?
let status = SecItemCopyMatching(query as CFDictionary, &result)
switch status {
case errSecSuccess:
guard let data = result as? Data else {
throw VaultError.itemNotFound
}
return data
case errSecItemNotFound:
throw VaultError.itemNotFound
case errSecUserCanceled, errSecAuthFailed:
throw VaultError.authenticationCanceled
default:
throw VaultError.unexpectedStatus(status)
}
}
} Note que SecItemCopyMatching com LAContext bloqueia a thread enquanto aguarda a confirmação biométrica do usuário. Sempre execute a leitura fora da main thread (por exemplo, dentro de uma task assíncrona dedicada) e atualize a interface no retorno.
Escolhendo a flag certa de acessibilidade no Keychain
Cada nível de acessibilidade do Keychain carrega um trade-off claro entre segurança e conveniência de execução em segundo plano. Escolher uma flag relaxada demais abre brecha em dispositivos bloqueados; escolher uma restritiva demais quebra extensões ou tarefas silenciosas em background.
| Atributo de acessibilidade | Entra em backup / iCloud | Disponível com aparelho bloqueado | Uso recomendado em mobile banking |
|---|---|---|---|
WhenPasscodeSetThisDeviceOnly | Não | Não; apaga o item se o usuário remover a senha do iPhone | Chaves de assinatura, refresh tokens sensíveis e dados biométricos |
WhenUnlockedThisDeviceOnly | Não | Não | Segredos acessados apenas com o app em primeiro plano |
AfterFirstUnlockThisDeviceOnly | Não | Sim, após o primeiro desbloqueio depois do boot | Apenas tokens técnicos de baixa sensibilidade necessários para push ou widgets |
WhenUnlocked (sem ThisDeviceOnly) | Sim (backup criptografado) | Não | Evitar em aplicativos financeiros por permitir migração para outro hardware |
Ciclo de vida da sessão, memória volátil e vazamentos comuns
Proteger o armazenamento em disco resolve só metade do problema. Em revisões de código de apps bancários, quatro vazamentos em tempo de execução aparecem com frequência impressionante.
O primeiro é o cache automático de rede. Por padrão, URLSession.shared grava respostas HTTP em disco no arquivo Cache.db. Se uma API de saldo ou extrato não enviar o cabeçalho Cache-Control: no-store, o corpo inteiro da resposta fica salvo em SQLite dentro da sandbox do aplicativo. A prevenção do lado iOS consiste em criar uma URLSessionConfiguration.ephemeral ou configurar explicitamente urlCache = nil e httpCookieStorage = nil na sessão autenticada.
O segundo erro é controlar timeout de inatividade usando Date(). Se o usuário coloca o app em segundo plano, avança ou atrasa manualmente o relógio do iPhone nos ajustes do sistema e volta para o app, uma comparação simples com Date() pode falhar e manter a sessão viva indefinidamente. Use o relógio monotônico do sistema operacional com ProcessInfo.processInfo.systemUptime (ou ContinuousClock no iOS 16+), que não sofre alteração quando o usuário muda a hora local:
import Foundation
public final class SessionTimeoutTracker {
private let maxIdleSeconds: TimeInterval
private var lastActivityUptime: TimeInterval
private let uptimeProvider: () -> TimeInterval
public init(
maxIdleSeconds: TimeInterval = 180,
uptimeProvider: @escaping () -> TimeInterval = { ProcessInfo.processInfo.systemUptime }
) {
self.maxIdleSeconds = maxIdleSeconds
self.uptimeProvider = uptimeProvider
self.lastActivityUptime = uptimeProvider()
}
public func registerUserInteraction() {
lastActivityUptime = uptimeProvider()
}
public func isSessionExpired() -> Bool {
let elapsed = uptimeProvider() - lastActivityUptime
return elapsed < 0 || elapsed >= maxIdleSeconds
}
} O terceiro ponto envolve captura de tela na multitarefa. O iOS tira um screenshot automático da janela ativa quando o app sai de primeiro plano para exibir no seletor de tarefas. Se você só adiciona a tela de privacidade (blur ou marca) em sceneDidEnterBackground, às vezes o sistema já capturou o saldo na tela. Aplique a camada opaca em sceneWillResignActive e remova-a em sceneDidBecomeActive.
O quarto cuidado diz respeito a senhas em memória. Em Swift, String é imutável com otimizações internas de cópia sob demanda (Copy-on-Write), o que impede limpar com garantia todos os trechos da heap depois do uso. Sempre que manipular PINs ou dados binários críticos antes de criptografar o payload, prefira buffers mutáveis em Data e zere os bytes com resetBytes(in: 0..<buffer.count) no bloco defer.
Integrações externas, pinning e o risco de derrubar o app inteiro
Apps financeiros quase sempre consomem SDKs de terceiros para prova de vida, coleta antifraude ou validação de integridade do aparelho (como App Attest). Misturar a lógica desses fornecedores direto na camada de autenticação cria risco operacional duplo: dificuldade de auditar o que sai pela rede e acoplamento difícil de atualizar em emergências. Recomendo confinar esses componentes conforme explico em estratégias de isolamento para SDKs proprietários e legados.
Outro trade-off delicado em produção é o Certificate Pinning. Fazer pinning do certificado folha (leaf certificate) já tirou aplicativos inteiros do ar quando a equipe de infraestrutura renovou o TLS antes do previsto e os usuários com versões antigas do app pararam de conseguir logar. Quando o pinning for obrigatório por requisito regulatório, fixe o hash da chave pública (SPKI pinning) e mantenha sempre pelo menos uma chave reserva (backup pin) pré-gerada e testada. E, caso algo falhe em produção, tenha um roteiro claro de contenção como o descrito em protocolos de resposta a incidentes e hotfixes sem quebra de sessão.
Checklist de segurança para revisão de PR de autenticação
Antes de aprovar alterações em login, renovação de token ou armazenamento local, vale conferir estes pontos objetivos:
- Nenhuma credencial, token JWT, CPF ou dado bancário é gravado em
UserDefaults, logs de console (print/os_logpúblico) ou arquivos sem proteção. - Todos os itens do Keychain usam flag
ThisDeviceOnlye especificação explícita dekSecAttrService. - A sessão autenticada utiliza
URLSessionsem persistência de cache em disco e remove credenciais da RAM imediatamente no logout ou na expiração. - O temporizador de inatividade usa relógio monotônico e não pode ser enganado alterando o relógio do sistema.
- O aplicativo cobre o conteúdo sensível em
sceneWillResignActivee limpa a pasteboard caso ofereça cópia de código temporário (OTP ou linha digitável) com expiração curta. - Qualquer falha de biometria ou de App Attest oferece caminho de recuperação controlado sem expor mensagens técnicas internas da API ao usuário final.
