Créer une API de Chiffrement avec Express et Node.js

Salutations ! Ce post, suggéré par un utilisateur astucieux (merci à lui/elle !), va vous guider dans la création d'une API de chiffrement robuste avec Express.js et Node.js. On va plonger dans le code, mais avant, un petit rappel théorique s'impose.

Qu'est-ce que le Chiffrement ?

Le chiffrement, c'est comme transformer un message secret en charabia incompréhensible pour quiconque ne possède pas la clé magique (la clé de déchiffrement, bien sûr !). On utilise des algorithmes cryptographiques pour brouiller les données et les protéger des regards indiscrets.

Méthode Utilisée : Chiffrement Symétrique avec AES-256-CBC

Dans ce tutoriel, on va utiliser le chiffrement symétrique avec l'algorithme AES-256-CBC. "Symétrique" signifie qu'on utilise la même clé pour chiffrer et déchiffrer. AES-256-CBC est un algorithme robuste, largement utilisé et considéré comme sûr (pour le moment !).

Installation des Dépendances

On commence par installer les modules nécessaires. On va utiliser crypto (module natif de Node.js pour la cryptographie) et bien sûr express:

npm install express crypto

Le Code (le moment tant attendu !)

const express = require('express');
const crypto = require('crypto');
const app = express();
const port = 3000;

// Notre clé secrète (à ne JAMAIS divulguer en production, évidemment LISEZ LE NOTE DE FIN !)
// En production, utilisez des variables d'environnement ou un coffre-fort de secrets.
const secretKey = 'uneCléSuperSecrèteEtDifficileÀDeviner';

// Algorithme de chiffrement (on peut choisir AES-256-CBC, par exemple)
const algorithm = 'aes-256-cbc';

// Fonction de chiffrement
function encrypt(text) {
  const iv = crypto.randomBytes(16); // Vecteur d'initialisation aléatoire
  const cipher = crypto.createCipheriv(algorithm, Buffer.from(secretKey), iv);
  let encrypted = cipher.update(text);
  encrypted = Buffer.concat([encrypted, cipher.final()]);
  return iv.toString('hex') + ':' + encrypted.toString('hex');
}

// Fonction de déchiffrement
function decrypt(text) {
  const textParts = text.split(':');
  const iv = Buffer.from(textParts.shift(), 'hex');
  const encryptedText = Buffer.from(textParts.join(':'), 'hex');
  const decipher = crypto.createDecipheriv(algorithm, Buffer.from(secretKey), iv);
  let decrypted = decipher.update(encryptedText);
  decrypted = Buffer.concat([decrypted, decipher.final()]);
  return decrypted.toString();
}

app.use(express.json()); // Pour parser les requêtes JSON

app.post('/encrypt', (req, res) => {
  const data = req.body.data;
  const encryptedData = encrypt(data);
  res.json({ encrypted: encryptedData });
});

app.post('/decrypt', (req, res) => {
  const encryptedData = req.body.data;
  const decryptedData = decrypt(encryptedData);
  res.json({ decrypted: decryptedData });
});

app.listen(port, () => {
  console.log(`Serveur en écoute sur le port ${port}`);
});
  

Explications (pour les plus curieux)

On utilise crypto.createCipheriv et crypto.createDecipheriv pour chiffrer et déchiffrer avec un vecteur d'initialisation (IV). C'est crucial pour la sécurité. Le IV doit être aléatoire et unique pour chaque chiffrement. On le concatène au texte chiffré (séparé par ':').

N'oubliez pas que la clé secrète est codée en dur ici, c'est juste pour l'exemple. En production, utilisez une méthode plus sécurisée (variables d'environnement, coffre-fort de secrets).

Exemples d'Utilisation avec cURL

Chiffrement :

curl -X POST -H "Content-Type: application/json" -d '{"data": "Mon message super secret"}' http://localhost:3000/encrypt
  

Déchiffrement :

curl -X POST -H "Content-Type: application/json" -d '{"data": "Valeur_chiffrée_obtenue_après_chiffrement"}' http://localhost:3000/decrypt
  

Remplacez Valeur_chiffrée_obtenue_après_chiffrement par la valeur renvoyée par l'appel de chiffrement.