Stockage des mots de passe et sessions sûres

Un site ne doit jamais garder les mots de passe tels quels. Il garde une empreinte, appelée hachage, d'où l'on ne peut pas retrouver le mot de passe. À la connexion, il compare les empreintes.

C'est important, car une base de données finit parfois par fuir. Avec des empreintes bien faites, la fuite ne livre pas les mots de passe des clients, qui servent souvent ailleurs.

Un hachage transforme un texte en une suite de lettres et de chiffres, l'empreinte. Le même texte donne toujours la même empreinte. Un texte à peine différent en donne une toute autre.

Le calcul ne se défait pas : de l'empreinte, on ne retrouve pas le texte. On peut seulement essayer des textes jusqu'à retomber sur la même empreinte.

Voyez-le avec la commande sha256sum, qui calcule une empreinte. La première commande hache motdepasse. La seconde hache Motdepasse, avec une seule majuscule de plus.

Chacune affiche 64 signes suivis de deux espaces et d'un tiret. Comparez le début des deux lignes : rien ne se ressemble.

printf 'motdepasse' | sha256sum

printf 'Motdepasse' | sha256sum

Deux clients qui choisissent le même mot de passe auraient la même empreinte. Un attaquant qui voit la base le remarque, et en casse deux d'un seul essai.

Le sel règle cela : on ajoute au mot de passe un texte aléatoire propre à chaque compte avant le hachage. Les deux empreintes diffèrent. Le sel se range à côté de l'empreinte, car il n'est pas secret.

Un attaquant qui a la base essaie des millions de textes par seconde. Un hachage ordinaire est trop rapide pour l'arrêter. On choisit donc un hachage lent, qui répète son calcul des milliers de fois.

Une connexion d'un client coûte alors une fraction de seconde. Un million d'essais coûte des heures. Python propose hashlib.pbkdf2_hmac, et on ne l'écrit jamais soi-même.

import hashlib
import secrets
# Le sel est tiré au hasard, propre à chaque compte.
sel = secrets.token_hex(16)
mot_de_passe = "bleu-citron-42"
empreinte = hashlib.pbkdf2_hmac("sha256", mot_de_passe.encode(), sel.encode(), 200000).hex()
print("sel :", len(sel), "signes")
print("empreinte :", len(empreinte), "signes")
# On range sel et empreinte, jamais le mot de passe.
verification = hashlib.pbkdf2_hmac("sha256", "bleu-citron-42".encode(), sel.encode(), 200000).hex()
print("même mot de passe, même empreinte :", verification == empreinte)

Regardons comment la boutique de votre laboratoire crée sa table de comptes. La commande suivante affiche la ligne du programme qui la crée, sans rien lire dans la table.

Elle montre une colonne nommée password de type texte. Le programme y range les mots de passe tels quels, sans empreinte ni sel. C'est le contraire de ce que vous venez d'apprendre.

docker exec app grep -n "password TEXT" /tmp/app/app.py

Après la connexion, le navigateur reçoit un jeton : sans lui, il faudrait redonner le mot de passe à chaque page. Si quelqu'un devine ou vole le jeton, il devient ce client.

Le jeton est donc long, tiré au hasard par une fonction faite pour la sécurité, comme secrets.token_hex. Il expire, après une durée totale et après un temps sans activité.