Cryptographie en Rust : chiffrement et hachage avec ring et sha2

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

Rust est un langage de programmation système qui garantit la sécurité mémoire et des performances comparables à C/C++. Grâce à son système de types strict et à son modèle de possession, Rust est idéal pour implémenter des algorithmes cryptographiques, où les erreurs peuvent entraîner de graves vulnérabilités. Dans cet article, nous allons voir comment utiliser les bibliothèques populaires ring et sha2 pour effectuer des opérations cryptographiques de base : chiffrement symétrique, hachage et calcul HMAC.

Bibliothèque ring : un outil polyvalent pour la cryptographie

La bibliothèque ring est l'une des bibliothèques cryptographiques les plus populaires pour Rust. Elle fournit des implémentations sécurisées de nombreux algorithmes, notamment AES-GCM pour le chiffrement, SHA-256 pour le hachage et HMAC pour l'authentification des messages. ring est écrite en Rust et en C, ce qui garantit des performances et une sécurité élevées.

Pour commencer, ajoutez la dépendance dans votre Cargo.toml :

[dependencies]ring = "0.17"

Chiffrement symétrique avec AES-GCM

AES-GCM (Galois/Counter Mode) est un mode de chiffrement qui assure à la fois la confidentialité et l'authentification des données. Il est largement utilisé dans les protocoles modernes, comme TLS.

Exemple de chiffrement et déchiffrement d'une chaîne avec ring :

use ring::aead::{Aad, LessSafeKey, Nonce, UnboundKey, AES_256_GCM};use ring::error::Unspecified;use ring::rand::{SecureRandom, SystemRandom};

fn encrypt(plaintext: &[u8], key: &[u8; 32]) -> Result<Vec<u8>, Unspecified> {    let rng = SystemRandom::new();    let unbound_key = UnboundKey::new(&AES_256_GCM, key)?;    let key = LessSafeKey::new(unbound_key);

    // Génération d'un nonce aléatoire (12 octets)    let mut nonce_bytes = [0u8; 12];    rng.fill(&mut nonce_bytes)?;    let nonce = Nonce::assume_unique_for_key(nonce_bytes);

    // Tampon pour les données chiffrées + tag d'authentification    let mut in_out = plaintext.to_vec();    key.seal_in_place_append_tag(nonce, Aad::empty(), &mut in_out)?;

    // Retourne le nonce + les données chiffrées    let mut result = nonce_bytes.to_vec();    result.extend_from_slice(&in_out);    Ok(result)}

fn decrypt(ciphertext: &[u8], key: &[u8; 32]) -> Result<Vec<u8>, Unspecified> {    let unbound_key = UnboundKey::new(&AES_256_GCM, key)?;    let key = LessSafeKey::new(unbound_key);

    // Extraction du nonce (12 premiers octets)    let (nonce_bytes, encrypted) = ciphertext.split_at(12);    let nonce = Nonce::assume_unique_for_key(nonce_bytes.try_into().unwrap());

    let mut in_out = encrypted.to_vec();    let plaintext = key.open_in_place(nonce, Aad::empty(), &mut in_out)?;    Ok(plaintext.to_vec())}

fn main() {    let key = b"01234567890123456789012345678901"; // 32 octets pour AES-256    let data = b"Message secret";

    let encrypted = encrypt(data, key).unwrap();    println!("Chiffré : {:?}", encrypted);

    let decrypted = decrypt(&encrypted, key).unwrap();    println!("Déchiffré : {}", String::from_utf8(decrypted).unwrap());}

Ce code illustre le cycle complet de chiffrement : génération d'un nonce aléatoire, chiffrement avec tag d'authentification et déchiffrement ultérieur. Notez que le nonce doit être unique pour chaque chiffrement avec la même clé.

Hachage avec la bibliothèque sha2

La bibliothèque sha2 fournit des implémentations des algorithmes de la famille SHA-2, notamment SHA-256, SHA-384 et SHA-512. Le hachage est utilisé pour vérifier l'intégrité des données, stocker les mots de passe et créer des signatures numériques.

Ajoutez la dépendance :

[dependencies]sha2 = "0.10"

Exemple de hachage d'une chaîne avec SHA-256 :

use sha2: