Cryptographie en Swift : chiffrement et hachage pour iOS/macOS

Cryptographie en Swift (iOS/macOS) : chiffrement et hachage

La sécurité des données est un aspect clé du développement pour iOS et macOS. Swift fournit des outils puissants pour la protection cryptographique : du framework intégré CryptoKit (depuis iOS 13 / macOS 10.15) à la bibliothèque bas niveau CommonCrypto (bibliothèque C). Dans cet article, nous aborderons les opérations principales : le chiffrement symétrique (AES), asymétrique (RSA), le hachage (SHA-256) et l'authentification des messages (HMAC).

1. Configuration du projet

Pour utiliser CryptoKit, aucune configuration supplémentaire n'est nécessaire — il fait partie de la bibliothèque standard Foundation. Si vous travaillez avec CommonCrypto, ajoutez-le dans le Bridging-Header (pour Swift + ObjC) ou importez le module directement :

// Pour CommonCrypto dans Swift 5+, vous pouvez utiliser :import CommonCrypto// Ou configurer un pont modulaire (modulemap)

2. Chiffrement symétrique (AES-GCM) avec CryptoKit

CryptoKit fournit une API de haut niveau pour AES en mode GCM (Galois/Counter Mode) — une méthode de chiffrement sécurisée et simple.

import CryptoKitimport Foundation

// Fonction de chiffrement d'une chaînefunc encryptString(_ plaintext: String, using key: SymmetricKey) throws -> Data {    let plaintextData = plaintext.data(using: .utf8)!    let sealedBox = try AES.GCM.seal(plaintextData, using: key)    return sealedBox.combined! // combined = nonce + ciphertext + tag}

// Fonction de déchiffrementfunc decryptData(_ combinedData: Data, using key: SymmetricKey) throws -> String {    let sealedBox = try AES.GCM.SealedBox(combined: combinedData)    let decryptedData = try AES.GCM.open(sealedBox, using: key)    return String(data: decryptedData, encoding: .utf8)!}

// Exemple d'utilisationlet key = SymmetricKey(size: .bits256) // Clé de 256 bitslet original = "Message secret pour iOS"let encrypted = try encryptString(original, using: key)print("Chiffré : \\(encrypted.base64EncodedString())")

let decrypted = try decryptData(encrypted, using: key)print("Déchiffré : \\(decrypted)")

Important : SymmetricKey est généré aléatoirement. Pour une application réelle, la clé doit être stockée dans le Keychain ou utiliser Secure Enclave.

3. Hachage (SHA-256) et HMAC

Le hachage est une fonction unidirectionnelle, indispensable pour vérifier l'intégrité des données et stocker les mots de passe. CryptoKit prend en charge SHA-256, SHA-384, SHA-512.

import CryptoKit

func sha256Hash(of data: Data) -> String {    let digest = SHA256.hash(data: data)    return digest.compactMap { String(format: "%02x", $0) }.joined()}

// Exemple pour une chaînelet message = "Bonjour, Swift Crypto !"let hash = sha256Hash(of: message.data(using: .utf8)!)print("SHA-256 : \\(hash)")

Pour l'authentification des messages (HMAC), utilisez HMAC avec une clé :

func hmacSHA256(key: SymmetricKey, data: Data) -> Data {    let authenticationCode = HMAC<SHA256>.authenticationCode(for: data, using: key)    return Data(authenticationCode)}

let hmacKey = SymmetricKey(size: .bits256)let hmacResult = hmacSHA256(key: hmacKey, data: "Données importantes".data(using: .utf8)!)print("HMAC : \\(hmacResult.base64EncodedString())")

4. Chiffrement asymétrique (RSA) via le framework Security

Pour RSA, utilisez le framework Security (SecKey). CryptoKit ne prend pas en charge RSA directement, mais vous pouvez combiner les approches.

import Security

// Génération d'une paire de clés RSA (2048 bits)func generateRSAKeyPair() -> (privateKey: SecKey, publicKey: SecKey)? {    let attributes: [String: Any] = [        kSecAttrKeyType as String: kSecAttrKeyTypeRSA,        kSecAttrKeySizeInBits as String: 2048,        kS