Cryptographie en Rust : chiffrement et hachage

Cryptographie en Rust : chiffrement et hachage avec les bibliothèques ring et sha2

Le langage Rust a acquis la réputation d'être l'un des langages de programmation système les plus sûrs. Son système de types strict, sa gestion de la mémoire sans ramasse-miettes et ses abstractions à coût nul en font un choix idéal pour implémenter des algorithmes cryptographiques. Dans cet article, nous examinerons deux bibliothèques clés pour la cryptographie en Rust : ring (haut niveau, sécurisée) et sha2 (implémentation pure des hachages). Vous apprendrez à effectuer du chiffrement symétrique (AES-GCM) et du hachage (SHA-256), et découvrirez également HMAC.

Pourquoi Rust pour la cryptographie ?

La cryptographie exige une fiabilité sans compromis. Rust empêche des classes entières de vulnérabilités (débordement de tampon, conditions de concurrence) dès la compilation. Les bibliothèques ring et sha2 sont écrites selon ces principes et sont activement maintenues par la communauté.

Sécurité mémoire — Rust garantit que les clés et les données chiffrées ne seront pas accidentellement copiées ou laissées en mémoire.
Performance — les opérations cryptographiques en Rust sont comparables à celles en C/C++, et souvent plus rapides.
Facilité d'utilisation — les bibliothèques fournissent une API propre avec un risque minimal d'erreur (par exemple, gestion automatique du nonce).

Bibliothèque ring : un outil universel

ring est une bibliothèque cryptographique multiplateforme qui se concentre sur la sécurité et la simplicité. Elle inclut le support d'AES-GCM, ChaCha20-Poly1305, ECDSA, Ed25519 et de nombreux autres algorithmes. ring ne prend pas en charge les protocoles obsolètes ou non sécurisés, ce qui protège le développeur d'un choix accidentel de chiffrement faible.

Installation :

[dependencies]ring = "0.17"

Exemple : chiffrement et déchiffrement AES-GCM

AES-GCM (Galois/Counter Mode) assure à la fois la confidentialité et l'authentification des données. Dans l'exemple ci-dessous, nous générons une clé aléatoire et un nonce, chiffrons un message, puis le déchiffrons avec succès.

use ring::{aead, rand};use ring::rand::SecureRandom;

fn main() -> Result<(), Box<dyn std::error::Error>> {    // Génération d'une clé aléatoire (256 bits)    let rng = rand::SystemRandom::new();    let mut key_bytes = [0u8; 32];    rng.fill(&mut key_bytes)?;    let key = aead::UnboundKey::new(&aead::AES_256_GCM, &key_bytes)?;    let sealing_key = aead::SealingKey::new(key.clone());    let opening_key = aead::OpeningKey::new(key);

    // Données à chiffrer    let plaintext = b"Message secret pour PythonLib";    let mut nonce_bytes = [0u8; 12]; // 96 bits pour GCM    rng.fill(&mut nonce_bytes)?;    let nonce = aead::Nonce::assume_unique_for_key(nonce_bytes);

    // Chiffrement (sur place)    let mut ciphertext = plaintext.to_vec();    let tag = sealing_key.seal_in_place_separate_tag(nonce, aead::Aad::empty(), &mut ciphertext)?;    ciphertext.extend_from_slice(tag.as_ref());

    println!("Chiffré : {:02x?}", ciphertext);

    // Déchiffrement    let mut opened = ciphertext.clone();    let plaintext_len = opening_key.open_in_place(nonce, aead::Aad::empty(), &mut opened)?;    let decrypted = &opened[..plaintext_len];

    println!("Déchiffré : {}", String::from_utf8(decrypted.to_vec())?);    Ok(())}

Important : Le nonce (nombre à usage unique) doit être unique pour chaque chiffrement avec la même clé. ring ne génère pas automatiquement le nonce — c'est la responsabilité du développeur. Dans l'exemple, nous utilisons SystemRandom pour générer un nonce aléatoire.