Cryptographie dans Node.js : chiffrement et hachage avec crypto

Cryptographie dans Node.js : le module crypto pour le chiffrement et le hachage

Dans le développement web moderne, la sécurité des données est un aspect crucial. Node.js fournit le module intégré crypto, qui implémente des fonctions cryptographiques, incluant le chiffrement symétrique et asymétrique, le hachage, ainsi que le calcul de codes d'authentification de messages (HMAC). Dans cet article, nous allons détailler les principales fonctionnalités du module crypto avec des exemples pratiques.

Installation et importation

Le module crypto fait partie de la bibliothèque standard de Node.js, donc aucune installation supplémentaire n'est nécessaire. Pour l'utiliser, il suffit de l'importer :

const crypto = require('crypto');

Hachage de données

Le hachage est une transformation unidirectionnelle de données en une chaîne de longueur fixe. L'algorithme le plus populaire est SHA-256. Les hachages sont utilisés pour vérifier l'intégrité des données et stocker les mots de passe (en combinaison avec un sel).

const data = "Message secret";const hash = crypto.createHash('sha256')    .update(data)    .digest('hex');

console.log(`Hachage SHA-256 : ${hash}`);// Sortie : chaîne de 64 caractères

Pour renforcer la sécurité des mots de passe, utilisez impérativement un sel (salt) et l'algorithme PBKDF2 ou bcrypt. Exemple avec PBKDF2 :

const password = "mot_de_passe_utilisateur";const salt = crypto.randomBytes(16).toString('hex');

crypto.pbkdf2(password, salt, 100000, 64, 'sha512', (err, derivedKey) => {    if (err) throw err;    console.log(`Hachage du mot de passe : ${derivedKey.toString('hex')}`);    console.log(`Sel : ${salt}`);});

Chiffrement symétrique (AES)

Le chiffrement symétrique utilise la même clé pour chiffrer et déchiffrer. L'algorithme le plus courant est AES (Advanced Encryption Standard). Voyons le chiffrement et le déchiffrement avec AES-256-CBC.

const algorithm = 'aes-256-cbc';const key = crypto.randomBytes(32); // Clé de 256 bitsconst iv = crypto.randomBytes(16);  // Vecteur d'initialisation

// Chiffrementfunction encrypt(text) {    const cipher = crypto.createCipheriv(algorithm, key, iv);    let encrypted = cipher.update(text, 'utf8', 'hex');    encrypted += cipher.final('hex');    return { iv: iv.toString('hex'), encryptedData: encrypted };}

// Déchiffrementfunction decrypt(encryptedData, ivHex) {    const decipher = crypto.createDecipheriv(algorithm, key, Buffer.from(ivHex, 'hex'));    let decrypted = decipher.update(encryptedData, 'hex', 'utf8');    decrypted += decipher.final('utf8');    return decrypted;}

// Exemple d'utilisationconst message = "Données confidentielles";const encrypted = encrypt(message);console.log(`Chiffré : ${encrypted.encryptedData}`);

const decrypted = decrypt(encrypted.encryptedData, encrypted.iv);console.log(`Déchiffré : ${decrypted}`);

Important : N'utilisez jamais le même IV pour différents messages. Générez un nouveau IV aléatoire pour chaque opération de chiffrement.

Chiffrement asymétrique (RSA)

Le chiffrement asymétrique utilise une paire de clés : une clé publique pour chiffrer et une clé privée pour déchiffrer. RSA est l'algorithme le plus populaire.

const { generateKeyPairSync, publicEncrypt, privateDecrypt } = crypto;

// Génération des clésconst { publicKey, privateKey } = generateKeyPairSync('rsa', {    modulusLength: 2048,    publicKeyEncoding: { type: 'spki', format: 'pem' },    privateKeyEncoding: { type: 'pkcs8', format: 'pem' }});

// Chiffrement avec la clé publiqueconst dataToEncrypt = "Message secret pour RSA";const encryptedData = publicEncrypt(publicKey, Buffer.from(dataToEncrypt));console.log(`Chiffré RSA : ${encryptedData.toString('base64')}`);

// Déchiffrement avec la clé privéeconst decryptedData = privateDecrypt(privateKey, encryptedData);co