420-5D3 – Protection des mots de passe

28 septembre 2023

Stratégies de Protection

Introduction

La protection des mots de passe est essentielle pour la sécurité des données dans les applications. Les mots de passe mal gérés peuvent entraîner des violations de données graves. Dans ce cours, nous examinerons les meilleures pratiques pour stocker et gérer les mots de passe de manière sécurisée.

Stratégies de Protection des Mots de Passe

1. Utilisation de l’Algorithme de Hachage

Un hachage est une fonction qui prend une entrée (dans ce cas, un mot de passe) et la transforme en une chaîne de caractères de longueur fixe, généralement sous forme de nombre hexadécimal. Les hachages sont unidirectionnels, ce qui signifie qu’il est difficile de retrouver le mot de passe d’origine à partir du hachage.

Exemple en Node.js :

const crypto = require('crypto');
const password = 'MotDePasseSecret';
const hash = crypto.createHash('sha256').update(password).digest('hex');

2. Utilisation du Sel (Salt)

Un sel est une valeur aléatoire générée pour chaque utilisateur. Il est ajouté au mot de passe avant le hachage, ce qui rend les attaques par dictionnaire et par force brute plus difficiles.

Exemple en PHP :

$password = 'MotDePasseSecret';
$salt = bin2hex(random_bytes(16)); // Génère un sel de 16 octets $hashed_password = hash('sha256', $salt . $password);

3. Utilisation d’une Fonction de Dérivation de Clé (KDF)

Une KDF est une fonction spécialement conçue pour transformer un mot de passe en une clé sécurisée. Il est recommandé d’utiliser des KDF telles que PBKDF2 ou bcrypt.

Exemple en Python (avec la bibliothèque Passlib) :

from passlib.hash import pbkdf2_sha256 password = 'MotDePasseSecret'
hashed_password = pbkdf2_sha256.using(salt_size=16).hash(password)

4. Stockage Sécurisé

Les hachages de mots de passe doivent être stockés de manière sécurisée. Évitez de les stocker en texte brut dans la base de données. Utilisez plutôt des bases de données sécurisées avec des contrôles d’accès appropriés.

5. Itérations

Utilisez un grand nombre d’itérations lors de la création de hachages pour ralentir les attaques par force brute.

Exemple en C++ (avec la bibliothèque OpenSSL) :

#include <openssl/evp.h>

const char* password = "MotDePasseSecret";
constunsigned char* salt = ...; // Sel généré aléatoirement
int iterations = 10000;
unsigned char key[32];
PKCS5_PBKDF2_HMAC_SHA1(password, strlen(password), salt, strlen(salt), iterations, 32, key);

Voici des exemples pour les algorithmes de hachage et de dérivation de clé suivants : Argon2, PBKDF2, scrypt et bcrypt, dans différents langages de programmation.

Exemple avec Argon2 en Python

Argon2 est un algorithme de hachage de mots de passe moderne et recommandé. Vous pouvez l’implémenter en utilisant la bibliothèque « argon2-cffi » en Python.

import argon2 password = "MotDePasseSecret"
hasher = argon2.PasswordHasher()
hashed_password = hasher.hash(password) # Vérification du mot de passe try: if hasher.verify(hashed_password, "MotDePasseIncorrect"):
print("Mot de passe correct.")
else: print("Mot de passe incorrect.") except argon2.exceptions.VerifyMismatchError:
print("Mot de passe incorrect.")

Exemple avec PBKDF2 en Node.js

PBKDF2 est un algorithme de dérivation de clé basé sur le hachage. Voici comment l’utiliser en Node.js :

const crypto = require('crypto');
const password = 'MotDePasseSecret';
const salt = crypto.randomBytes(16).toString('hex');
const iterations = 10000;
const keyLength = 64;
const digest = 'sha512';
crypto.pbkdf2(password, salt, iterations, keyLength, digest, (err, derivedKey) => { if (err) throw err;
const hashedPassword = derivedKey.toString('hex');
console.log('Mot de passe haché :', hashedPassword); });

Exemple avec scrypt en PHP

scrypt est un autre algorithme de dérivation de clé, réputé pour sa résistance aux attaques par force brute. Voici comment l’utiliser en PHP :

$password = 'MotDePasseSecret';
$salt = random_bytes(16); // Génère un sel de 16 octets
$n = 16384; // NOMBRE DE BOUCLES
$r = 8;
$p = 1;
$keyLength = 64;
$hashedPassword = scrypt($password, $salt, $n, $r, $p, $keyLength);
echo 'Mot de passe haché : ' . bin2hex($hashedPassword);

Exemple avec bcrypt en C++

bcrypt est un algorithme de hachage de mots de passe largement utilisé. Vous pouvez l’implémenter en C++ à l’aide de la bibliothèque « bcrypt ».

#include <iostream>
#include <bcrypt.h>
int main() {
const char* password = "MotDePasseSecret";
const char* salt = bcrypt_gensalt(12); // Génère un sel avec un coût de 12
const char* hashed_password = bcrypt(password, salt);
std::cout << "Mot de passe haché : " << hashed_password << std::endl;
return 0;
}

Ces exemples illustrent comment utiliser différents algorithmes de hachage et de dérivation de clé pour sécuriser les mots de passe dans vos applications. Assurez-vous de choisir l’algorithme le mieux adapté à vos besoins de sécurité.

Conclusion

La protection des mots de passe est essentielle pour la sécurité des applications. En utilisant des hachages, des sels, des KDF, un stockage sécurisé et des itérations appropriées, vous pouvez renforcer la sécurité de vos mots de passe. Il est important de suivre ces meilleures pratiques pour protéger les données sensibles de vos utilisateurs.