Swift Academy · Leçon

Protection des données et chiffrement

Protégez les fichiers et découvrez les bases de CryptoKit.

Protection des données et chiffrement est une leçon Swift Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Swift Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Swift Academy comprend 4 leçons au total.

Protection des données sur iOS

iOS chiffre par défaut les fichiers sur le disque, mais vous pouvez choisir quand leur contenu peut être déchiffré à l’aide des classes de protection des données. Celles-ci associent l’accès aux fichiers à l’état de verrouillage de l’appareil, tout comme les classes d’accessibilité du Trousseau le font pour les secrets.

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

Les classes de protection

Les principaux niveaux de protection des fichiers sont .complete (illisible lorsque l’appareil est verrouillé), .completeUnlessOpen (reste lisible s’il était déjà ouvert lors du verrouillage), .completeUntilFirstUserAuthentication (lisible après le premier déverrouillage) et .none.

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

Écrire un fichier protégé

Passez .completeFileProtection dans les options d’écriture pour marquer un fichier comme entièrement protégé. Lorsque l’appareil est verrouillé, le système rend son contenu inaccessible, même pour votre propre application.

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

Définir la protection de fichiers existants

Vous pouvez modifier la protection d’un fichier après sa création en définissant l’attribut FileAttributeKey.protectionKey via FileManager. Cette possibilité est pratique pour renforcer la protection des fichiers que vous recevez ou migrez.

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

CryptoKit pour le chiffrement dans l’application

Lorsque vous devez chiffrer vous-même des données — avant leur envoi ou pour ajouter une couche au-dessus de la protection du disque — utilisez CryptoKit. Il fournit des primitives modernes et résistantes aux erreurs d’utilisation, avec des valeurs par défaut sûres et sans manipulation manuelle des IV pour les chiffrements AEAD.

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

Hachage avec SHA-256

Pour les contrôles d’intégrité et les empreintes, SHA256 produit un condensé de taille fixe. Notez que le hachage est irréversible et ne remplace pas le chiffrement : ne hachez jamais un mot de passe sans sel ni KDF lent.

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

Clés symétriques

Le chiffrement symétrique utilise une clé partagée. SymmetricKey(size: .bits256) génère une clé aléatoire robuste. Stockez la clé dans le Trousseau, jamais à côté du texte chiffré qu’elle protège.

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

Chiffrer avec AES-GCM

AES.GCM est un chiffrement authentifié : il chiffre les données et détecte les manipulations. seal renvoie une boîte scellée contenant ensemble le texte chiffré, le nonce et le tag d’authentification.

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
}

Déchiffrer et vérifier

Pour déchiffrer, reconstruisez un SealedBox à partir des données combinées et appelez open. Si le texte chiffré ou le tag a été modifié, open lève une erreur : le tag d’authentification garantit l’intégrité, de sorte que les données corrompues ne sont jamais déchiffrées silencieusement.

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

Dériver des clés à partir de mots de passe

N’utilisez jamais un mot de passe brut comme clé. Dérivez-en une avec HKDF (pour les entrées à forte entropie) ou avec une KDF fondée sur un mot de passe. Le HKDF de CryptoKit étend et sale le matériau de clé pour produire une clé symétrique appropriée.

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

Superposer les défenses

Les applications robustes combinent plusieurs couches : la protection des données chiffre les fichiers au repos en fonction de l’état de verrouillage, le Trousseau protège les clés derrière les données biométriques et CryptoKit ajoute un chiffrement au niveau de l’application pour les données en transit ou dans le cloud. Chaque couche reste sûre même si elle est utilisée seule.

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

Vérification rapide

Rappelez-vous pourquoi AES-GCM est privilégié pour le chiffrement au niveau de l’application.

Récapitulatif

Vous avez appris à protéger les données et à les chiffrer :

Les classes de protection des données des fichiers (.complete, .completeUntilFirstUserAuthentication) lient le déchiffrement du disque à l’état de verrouillage.
CryptoKit fournit le hachage SHA-256, la génération de clés SymmetricKey et le chiffrement authentifié AES-GCM via seal/open.
Dérivez les clés avec HKDF ; stockez-les dans le trousseau, jamais à côté du texte chiffré.
Combinez la protection des données, le trousseau et CryptoKit pour une défense en profondeur.

Questions Fréquemment Posées

La leçon « Protection des données et chiffrement » est-elle gratuite ?

Oui — le texte complet de « Protection des données et chiffrement » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Swift Academy, passe à CoddyKit PRO. Le cours Swift Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Protection des données et chiffrement » ?

Protégez les fichiers et découvrez les bases de CryptoKit. Tu pratiques Swift Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Swift Academy ?

Aucune expérience préalable n'est requise. Swift Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Protection des données et chiffrement » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Swift Academy ?

Oui. Chaque leçon Swift Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Swift Academy