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.

1. App ClientPede challenge (nonce)2. Secure EnclaveFace ID libera assinatura3. Auth BackendValida assinatura públicaAccess Token em RAMVida curta (5 a 10 min), nunca em discoTimeout monotônico por inatividadeKeychain Access ControlFlag .biometryCurrentSetInvalida se nova biometria for cadastradaEmite token de acesso curto após validação
Fluxo de autenticação resistente a bypass de UI: a biometria libera a operação criptográfica no hardware e o token de acesso permanece apenas em memória volátil.

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 acessibilidadeEntra em backup / iCloudDisponível com aparelho bloqueadoUso recomendado em mobile banking
WhenPasscodeSetThisDeviceOnlyNãoNão; apaga o item se o usuário remover a senha do iPhoneChaves de assinatura, refresh tokens sensíveis e dados biométricos
WhenUnlockedThisDeviceOnlyNãoNãoSegredos acessados apenas com o app em primeiro plano
AfterFirstUnlockThisDeviceOnlyNãoSim, após o primeiro desbloqueio depois do bootApenas tokens técnicos de baixa sensibilidade necessários para push ou widgets
WhenUnlocked (sem ThisDeviceOnly)Sim (backup criptografado)NãoEvitar 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_log público) ou arquivos sem proteção.
  • Todos os itens do Keychain usam flag ThisDeviceOnly e especificação explícita de kSecAttrService.
  • A sessão autenticada utiliza URLSession sem 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 sceneWillResignActive e 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.