0Pricing
Swift Academy · Aula

Proteção e criptografia de dados

Proteja arquivos e aprenda os fundamentos do CryptoKit.

Proteção e criptografia de dados é uma aula grátis de Swift Academy no CoddyKit. Esta é a aula 4 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.

Proteção de dados no iOS

O iOS criptografa os arquivos armazenados em disco por padrão, mas você pode escolher quando o conteúdo de um arquivo poderá ser descriptografado usando as classes de Proteção de Dados. Elas vinculam o acesso aos arquivos ao estado de bloqueio do dispositivo, assim como as classes de acessibilidade do chaveiro fazem com os segredos.

import Foundation
// File-level protection ties decryption to lock state.
// Set a protection class when writing sensitive files.

As classes de proteção

Os principais níveis de proteção de arquivos são .complete (ilegível enquanto o dispositivo está bloqueado), .completeUnlessOpen (continua legível se já estiver aberto quando o dispositivo for bloqueado), .completeUntilFirstUserAuthentication (legível após o primeiro desbloqueio) e .none.

import Foundation
// FileProtectionType:
//   .complete
//   .completeUnlessOpen
//   .completeUntilFirstUserAuthentication (default)
//   .none
let level = FileProtectionType.complete
_ = level

Gravando um arquivo protegido

Passe .completeFileProtection nas opções de gravação para marcar um arquivo como totalmente protegido. Enquanto o dispositivo estiver bloqueado, o sistema operacional tornará o conteúdo inacessível até mesmo para o seu próprio aplicativo.

import Foundation
func writeSecure(_ data: Data, to url: URL) throws {
    try data.write(
        to: url,
        options: [.completeFileProtection])
}

Definindo a proteção de arquivos existentes

Você pode alterar a proteção de um arquivo depois de criá-lo, definindo o atributo FileAttributeKey.protectionKey por meio de FileManager. Isso é útil para reforçar a proteção de arquivos recebidos ou migrados.

import Foundation
func protect(_ url: URL) throws {
    try FileManager.default.setAttributes(
        [.protectionKey: FileProtectionType.complete],
        ofItemAtPath: url.path)
}

CryptoKit para criptografia no aplicativo

Quando você precisa criptografar os dados por conta própria — antes de enviá-los ou para adicionar uma camada sobre a proteção do disco — use CryptoKit. Ele oferece primitivas modernas resistentes ao uso incorreto, com padrões seguros e sem a necessidade de manipular manualmente o vetor de inicialização das cifras AEAD.

import CryptoKit
// CryptoKit offers hashing, symmetric & public-key
// crypto with safe, hard-to-misuse APIs.

Hash com SHA-256

Para verificações de integridade e impressões digitais, SHA256 produz um resumo de tamanho fixo. Lembre-se de que o hash é unidirecional e não substitui a criptografia — nunca gere o hash de uma senha sem um sal e um KDF lento.

import CryptoKit
import Foundation
func fingerprint(_ data: Data) -> String {
    let digest = SHA256.hash(data: data)
    return digest.map { String(format: "%02x", $0) }
        .joined()
}

Chaves simétricas

A criptografia simétrica usa uma única chave compartilhada. SymmetricKey(size: .bits256) gera uma chave aleatória forte. Armazene a chave no chaveiro — nunca junto ao texto cifrado que ela protege.

import CryptoKit
let key = SymmetricKey(size: .bits256)
// Persist this key in the Keychain, not in a file.
_ = key

Criptografando com AES-GCM

AES.GCM é uma forma de criptografia autenticada: ela criptografa os dados e também detecta adulterações. seal retorna uma caixa selada que contém o texto cifrado, o nonce e a etiqueta de autenticação reunidos.

import CryptoKit
import Foundation
func encrypt(_ data: Data, key: SymmetricKey)
    throws -> Data {
    let sealed = try AES.GCM.seal(data, using: key)
    return sealed.combined! // nonce + ciphertext + tag
}

Descriptografando e verificando

Para descriptografar, reconstrua um SealedBox a partir dos dados combinados e chame open. Se o texto cifrado ou a etiqueta tiver sido alterado, open lançará um erro — a etiqueta de autenticação garante a integridade, portanto os dados corrompidos nunca são descriptografados silenciosamente.

import CryptoKit
import Foundation
func decrypt(_ combined: Data, key: SymmetricKey)
    throws -> Data {
    let box = try AES.GCM.SealedBox(combined: combined)
    return try AES.GCM.open(box, using: key)
}

Derivando chaves a partir de senhas

Nunca use uma senha bruta como chave. Derive uma com HKDF, para entradas com alta entropia, ou com um KDF baseado em senha. O HKDF amplia e adiciona sal ao material da chave, transformando-o em uma chave simétrica adequada.

import CryptoKit
import Foundation
func deriveKey(from secret: Data, salt: Data)
    -> SymmetricKey {
    return HKDF<SHA256>.deriveKey(
        inputKeyMaterial: SymmetricKey(data: secret),
        salt: salt,
        outputByteCount: 32)
}

Combinando camadas de proteção

Aplicativos robustos combinam camadas: a Proteção de Dados criptografa os arquivos armazenados, vinculando-os ao estado de bloqueio; o chaveiro protege as chaves com biometria; e o CryptoKit acrescenta criptografia no nível do aplicativo para dados em trânsito ou na nuvem. Cada camada falha de forma segura por conta própria.

import CryptoKit
import Foundation
// 1. Key lives in Keychain (biometric-gated)
// 2. Plaintext file written with .completeFileProtection
// 3. Uploads encrypted with AES.GCM before leaving device
let layers = "defense in depth"
_ = layers

Verificação rápida

Relembre por que AES-GCM é preferido para a criptografia no nível do aplicativo.

Recapitulação

Você aprendeu sobre proteção de dados e criptografia:

  • As classes de Proteção de Dados de arquivos (.complete, .completeUntilFirstUserAuthentication) vinculam a descriptografia do disco ao estado de bloqueio.
  • CryptoKit fornece hashing SHA-256, geração de SymmetricKey e criptografia autenticada AES-GCM por meio de seal/open.
  • Derive chaves com HKDF; armazene-as no Keychain, nunca junto do texto cifrado.
  • Combine Proteção de Dados, Keychain e CryptoKit para obter defesa em profundidade.

Perguntas Frequentes

A aula “Proteção e criptografia de dados” é grátis?

Sim — o texto completo de “Proteção e criptografia de dados” é 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 “Proteção e criptografia de dados”?

Proteja arquivos e aprenda os fundamentos do CryptoKit. 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 4 de 4.

Quanto tempo leva a aula “Proteção e criptografia de dados”?

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