Hachage sécurisé des mots de passe en Go

Les identifiants utilisateur sont les informations nécessaires pour authentifier l’identité d’un utilisateur et lui accorder l’accès à un système ou à une application. Il s’agit généralement d’un nom d’utilisateur ou d’une adresse e-mail, ainsi que d’un mot de passe. Un nom d’utilisateur peut être stocké en texte brut dans une base de données, mais les informations sensibles comme les adresses e-mail ou les mots de passe ne devraient pas l’être.

Si un acteur malveillant accède à la base de données dans laquelle vous stockez ces informations, vous ne voulez pas les lui livrer facilement. Vous devez plutôt vous assurer qu’il ne puisse pas y accéder, même en mobilisant toutes ses ressources et en faisant preuve de détermination. C’est là que le hachage entre en jeu.

Dans la continuité de notre précédent article sur le hachage des mots de passe en Java, nous abordons ici le hachage des mots de passe en Go. Commençons par revoir certains concepts et bonnes pratiques du hachage des mots de passe.

Utilisez le hachage pour les mots de passe 

Une fonction de hachage est une fonction mathématique qui prend une entrée (ici, un mot de passe) et produit une chaîne de caractères de taille fixe, généralement composée de lettres et de chiffres. La sortie, appelée valeur de hachage ou code de hachage, est propre à l’entrée. Les fonctions de hachage sont conçues pour être unidirectionnelles : il est donc pratiquement impossible, d’un point de vue computationnel, de retrouver l’entrée d’origine à partir de la valeur de hachage. Pour sécuriser les mots de passe, ceux-ci sont hachés et stockés sous forme de valeurs de hachage plutôt qu’en texte brut.

La différence entre le hachage et le chiffrement, c’est que le hachage est une fonction unidirectionnelle, tandis que le chiffrement est bidirectionnel et permet de retrouver la valeur d’origine à partir de la valeur chiffrée. Le chiffrement est couramment utilisé pour les données sensibles comme les adresses e-mail et les autres informations personnelles identifiables (IPI), mais pour les mots de passe, le hachage est la méthode recommandée.

Mais si le hachage est une fonction unidirectionnelle, comment vérifier les identifiants utilisateur ? Le processus est simple : nous créons le hachage du mot de passe en texte brut fourni par l’utilisateur, puis nous le comparons au hachage stocké dans notre base de données. Si les hachages correspondent, le mot de passe est correct. Dans le cas contraire, les identifiants sont incorrects. L’avantage du hachage, c’est que nous n’avons jamais besoin de connaître le mot de passe réel de l’utilisateur !

Techniques d’attaque

Nous avons dit plus tôt qu’il faut s’assurer qu’un acteur malveillant ne puisse pas accéder à ces informations, même en mobilisant toutes ses ressources et en faisant preuve de détermination. Il existe des méthodes qui lui permettent de retrouver le mot de passe à partir du hachage.

Un pirate peut avoir accès à une liste de vos mots de passe provenant d’autres sources, comme des comptes piratés. Il peut utiliser une rainbow table pour tenter de casser le hachage. Si les hachages correspondent, le mot de passe est compromis. Des attaques par force brute peuvent également être menées : différentes combinaisons de mots de passe sont alors testées pour vérifier si le hachage du mot de passe généré correspond à celui du mot de passe d’origine.

Même si ces méthodes nécessitent des ressources à haut débit ou une grande puissance de calcul, elles ont fait leurs preuves contre d’anciens algorithmes de hachage, comme ceux de la famille SHA1, compte tenu de la puissance de calcul disponible aujourd’hui .

Il est donc extrêmement important d’utiliser des algorithmes de hachage plus récents et d’autres bonnes pratiques pour que le hachage généré soit impossible à casser, ou qu’il faille plusieurs décennies de permutations et de combinaisons pour y parvenir.

Bonnes pratiques de hachage

Voici quelques bonnes pratiques pour utiliser des méthodes de hachage modernes.

Salage

Un sel est une valeur générée aléatoirement (généralement des données binaires aléatoires, comme des octets) qui est ajoutée au mot de passe lors de la création du hachage. Chaque mot de passe possède son propre sel. Cela ajoute une couche de sécurité, car l’acteur malveillant doit casser le sel en plus du hachage. Le cassage du hachage se déroule donc en deux étapes et demande davantage de ressources.

La longueur du sel dépend de l’algorithme de hachage utilisé. Avec les algorithmes récents, le sel est généré automatiquement : il n’est donc pas nécessaire d’en fournir un. Pour en savoir plus, consultez cette fiche de prévention OWASP sur le stockage des mots de passe.

Algorithmes de hachage

Les algorithmes de hachage jouent un rôle essentiel dans le hachage des mots de passe. Il est indispensable d’en choisir un qui résiste au cassage. Les algorithmes modernes permettent de personnaliser des paramètres comme le facteur de coût et le nombre d’itérations, ce qui rend le hachage plus difficile à casser. Compte tenu de la puissance de calcul disponible, il est conseillé de choisir des valeurs élevées. En règle générale, plus le facteur de coût ou le nombre d’itérations est élevé, plus le hachage est difficile à casser.

Par bonne pratique, choisissez la valeur maximale du facteur de coût ou du nombre d’itérations que votre système peut gérer sans incidence importante sur les performances.

Points à prendre en compte pour les algorithmes de hachage

Voici quelques éléments à prendre en compte lors de l’implémentation d’un algorithme de hachage.

Gestion des collisions de hachage

Une collision de hachage se produit lorsque deux entrées différentes produisent la même valeur de hachage. Les algorithmes de hachage modernes sont conçus pour réduire au minimum le risque de collision, mais celui-ci existe toujours. Pour l’atténuer, il est recommandé d’utiliser des valeurs de hachage plus longues, comme SHA-256 ou SHA-512, qui offrent un espace de sortie plus vaste et réduisent la probabilité de collisions.

Nombre d’itérations

Le nombre d’itérations est un facteur important pour le hachage des mots de passe. Plus ce nombre est élevé, plus le cassage du hachage demande de ressources et plus l’attaque est ralentie. Toutefois, il est important de trouver un équilibre entre sécurité et performances, car un nombre trop élevé d’itérations peut ralentir le processus d’authentification pour les utilisateurs légitimes. Il est recommandé de choisir une valeur qui assure une sécurité suffisante sans nuire de manière importante aux performances.

Mettez régulièrement à jour les algorithmes de hachage

Avec les progrès technologiques et l’augmentation de la puissance de calcul, de nouveaux algorithmes de hachage sont mis au point, tandis que les anciens sont abandonnés. En effet, ces derniers ne suivent plus le rythme des avancées et deviennent des cibles faciles pour les attaquants.

Hachage des mots de passe en Go

Le package crypto de Go fournit des fonctions de hachage intégrées pour des algorithmes populaires tels que argon2, scrypt, bcrypt, pbkdf2, et bien d’autres. Ces fonctions sont particulièrement utiles pour implémenter le hachage des mots de passe. Le package bcrypt fournit même une fonction CompareHashAndPassword permettant de comparer les mots de passe en texte brut aux mots de passe hachés et de vérifier s’ils correspondent.

Argon2

Argon2 est actuellement considéré comme l’algorithme de hachage le plus sûr (même si cela pourrait changer à l’avenir). Il existe en trois variantes : Argon2d, qui maximise la résistance aux attaques de cassage par GPU ; Argon2i, optimisé pour résister aux attaques par canal auxiliaire ; et Argon2id, qui combine les deux.

La fiche de prévention OWASP sur le stockage des mots de passe recommande l’algorithme hybride Argon2id pour stocker les mots de passe. Elle préconise une taille minimale de mémoire (m), un nombre minimal d’itérations (t) et un degré de parallélisme (p) comme suit :

• m=47104 (46 MiB), t=1, p=1 (Ne pas utiliser avec Argon2i)

• m=19456 (19 MiB), t=2, p=1 (Ne pas utiliser avec Argon2i)

• m=12288 (12 MiB), t=3, p=1

• m=9216 (9 MiB), t=4, p=1

• m=7168 (7 MiB), t=5, p=1

Implémentation en Go

Examinons maintenant un exemple d’implémentation d’Argon2id pour générer un hachage à partir d’un mot de passe en texte brut et le comparer au hachage.

Configuration

Pour commencer, nous allons créer une structure qui stockera tous les paramètres de configuration nécessaires au hachage avec Argon2id :

1type Argon2idHash struct {
2	// time represents the number of 
3	// passed over the specified memory.
4	time    uint32
5	// cpu memory to be used.
6	memory  uint32
7	// threads for parallelism aspect
8	// of the algorithm.
9	threads uint8
10	// keyLen of the generate hash key.
11	keyLen  uint32
12	// saltLen the length of the salt used.
13	saltLen uint32
14}

La structure Argon2idHash contient les paramètres suivants : time, memory (coût de calcul), threads (parallélisme), keyLen et saltLen. Ces paramètres permettent de générer un hachage à partir d’un mot de passe en texte brut.

Nous allons ensuite écrire une fonction constructeur pour initialiser la structure avec les valeurs fournies.

1// NewArgon2idHash constructor function for 
2// Argon2idHash.
3func NewArgon2idHash(time, saltLen uint32, memory uint32, threads uint8, keyLen uint32) *Argon2idHash {
4	return &Argon2idHash{
5		time:    time,
6		saltLen: saltLen,
7		memory:  memory,
8		threads: threads,
9		keyLen:  keyLen,
10	}
11}

Génération du sel

Pour faciliter la génération de valeurs aléatoires, notamment celle du sel, nous avons créé la fonction randomSecret. Elle prend la longueur souhaitée pour la valeur secrète aléatoire et utilise la fonction rand.Read pour la générer.

1func randomSecret(length uint32) ([]byte, error) {
2	secret := make([]byte, length)
3
4	_, err := rand.Read(secret)
5	if err != nil {
6		return nil, err
7	}
8
9	return secret, nil
10}

Génération du hachage

Nous créons ensuite une méthode de hachage, GenerateHash, pour la structure Argon2idHash. Cette méthode permet de générer un hachage à partir des valeurs configurées. Si aucun sel aléatoire n’est fourni, nous en générons un de la longueur définie dans la configuration. Nous utilisons ensuite toutes les valeurs configurées pour générer le hachage avec la fonction argon2.IDKey. Si la génération réussit, nous renvoyons la paire hachage-sel.

1// GenerateHash using the password and provided salt.
2// If not salt value provided fallback to random value
3// generated of a given length.
4func (a *Argon2idHash) GenerateHash(password, salt []byte) (*HashSalt, error) {
5	var err error
6	// If salt is not provided generate a salt of
7	// the configured salt length.
8	if len(salt) == 0 {
9		salt, err = randomSecret(a.saltLen)
10	}
11	if err != nil {
12		return nil, err
13	}
14	// Generate hash
15	hash := argon2.IDKey(password, salt, a.time, a.memory, a.threads, a.keyLen)
16	// Return the generated hash and salt used for storage.
17	return &HashSalt{Hash: hash, Salt: salt}, nil
18}

Comparaison des mots de passe

Pour comparer les mots de passe, nous créons une autre méthode, Compare, pour la structure Argon2idHash. Cette méthode prend le hachage et le sel enregistrés, ainsi que le mot de passe à comparer.

Nous générons d’abord un hachage à l’aide de la fonction GenerateHash créée à l’étape précédente. Cette fonction prend en entrée le mot de passe et le sel fournis.

Nous comparons ensuite le hachage généré au hachage stocké à l’aide de la fonction bytes.Equal. Si les deux hachages sont identiques, ils correspondent. Sinon, le hachage stocké ne correspond pas au mot de passe fourni.

1// Compare generated hash with store hash.
2func (a *Argon2idHash) Compare(hash, salt, password []byte) error {
3	// Generate hash for comparison.
4	hashSalt, err := a.GenerateHash(password, salt)
5	if err != nil {
6		return err
7	}
8	// Compare the generated hash with the stored hash.
9	// If they don't match return error.
10	if !bytes.Equal(hash, hashSalt.Hash) {
11		return errors.New("hash doesn't match")
12	}
13	return nil
14}

Dans cet exemple, nous avons utilisé la fonction argon2.IDKey function pour générer le hachage. Comme indiqué précédemment, d’autres packages crypto fournis par Go proposent des fonctions similaires permettant de générer des hachages de mots de passe sécurisés, comme celui de notre exemple.

Scrypt

Scrypt arrive en deuxième position parmi les algorithmes de hachage. Argon2id doit être votre premier choix ; s’il n’est pas disponible, scrypt constitue une solution de repli.

Comme pour Argon2id, la fiche de prévention OWASP sur le stockage des mots de passe recommande les valeurs suivantes pour les champs : le paramètre de coût minimal en CPU/mémoire (N), la taille de bloc (r) et le degré de parallélisme (p).

• N = 2^17 (128 MiB), r = 8 (1024 bytes), p = 1

• N = 2^16 (64 MiB), r = 8 (1024 bytes), p = 2

• N = 2^15 (32 MiB), r = 8 (1024 bytes), p = 3

• N = 2^14 (16 MiB), r = 8 (1024 bytes), p = 5

• N = 2^13 (8 MiB), r = 8 (1024 bytes), p = 10

La documentation du package Go scrypt fournit un exemple de génération d’une clé de hachage avec scrypt. Les opérations de génération et de comparaison devraient être très similaires à leur implémentation pour la structure ^Argon2idHash.

Bcrypt

bcrypt doit être votre dernier recours, tout comme PBKDF2 (que nous verrons ensuite) si vous devez respecter la norme FIPS 140. Selon la fiche de prévention OWASP sur le stockage des mots de passe, le facteur de coût doit être aussi élevé que les performances du serveur de vérification le permettent, avec une valeur minimale de 10.

Le package Go bcrypt inclut des fonctions de génération et de comparaison de hachages. Nous ne présenterons donc pas d’exemple ici. Consultez la documentation du package Go pour découvrir des exemples.

PBKDF2 (conforme à FIPS 140)

Selon la fiche de prévention OWASP sur le stockage des mots de passe, le facteur de coût de PBKDF2 est défini par un nombre d’itérations, à ajuster en fonction de l’algorithme de hachage interne utilisé.

• PBKDF2-HMAC-SHA1 : 1 300 000 itérations

• PBKDF2-HMAC-SHA256 : 600 000 itérations

• PBKDF2-HMAC-SHA512 : 210 000 itérations

Exemple de hachage

Comme PBKDF2 est le seul algorithme de notre liste conforme à FIPS 140, nous allons voir comment l’utiliser pour hacher des mots de passe en Go. Commençons.

Voici la fonction Key du package pbkdf2, que nous utiliserons pour générer un hachage à partir d’un mot de passe en texte brut :

1func Key(password, salt []byte, iter, keyLen int, h func() hash.Hash) []byte

Pour effectuer le hachage, vous aurez besoin du mot de passe et du sel sous forme de tranches d’octets, ainsi que du nombre d’itérations et de la longueur souhaitée de la clé ou du hachage généré. Une fonction de hachage est également nécessaire. Dans notre cas, le mot de passe désigne le mot de passe en clair que nous voulons hacher, tandis que le sel est une valeur générée aléatoirement. Vous pouvez configurer le nombre d’itérations et la longueur de la clé. Pour la fonction de hachage, nous utiliserons sha3.New256.

Configuration

1// PBKDF2Hash used to generate hash
2// from plain text password and also
3// compare plain text password with
4// stored hash.
5type PBKDF2Hash struct {
6	// itr the number of iterations.
7	itr int
8	// keyLen the length of the generated key.
9	keyLen int
10	// saltLen the length of the salt used.
11	saltLen int
12}

Génération du hachage

1// GenerateHash using the password and provided salt.
2// If not salt value provided fallback to random value
3// generated of a given length.
4func (p *PBKDF2Hash) GenerateHash(password, salt []byte) (*HashSalt, error) {
5	var err error
6	// If salt is not provided generate a salt of
7	// the configured salt length.
8	if len(salt) == 0 {
9		salt, err = randomSecret(p.saltLen)
10	}
11	if err != nil {
12		return nil, err
13	}
14	// Generate hash using pbkdf2 exported key method.
15	hash := pbkdf2.Key(password, salt, p.itr, p.keyLen, sha3.New256)
16	// Return the generated hash and salt used for storage.
17	return &HashSalt{Hash: hash, Salt: salt}, nil
18}

Comparaison des mots de passe

1// Compare generated hash with store hash.
2func (p *PBKDF2Hash) Compare(hash, salt, password []byte) error {
3	// Generate hash for comparison.
4	hashSalt, err := p.GenerateHash(password, salt)
5	if err != nil {
6		return err
7	}
8	// Compare the generated hash with the stored hash.
9	// If they don't match return error.
10	if !bytes.Equal(hash, hashSalt.Hash) {
11		return errors.New("hash doesn't match")
12	}
13	return nil
14}

Cette implémentation est très similaire à celle de Argon2idHash. Vous pouvez donc modifier l’exemple de code complet pour utiliser PBKDF2Hash à la place.

Code complet

Rassemblons maintenant tous les éléments.

Structure du projet

./hashing
|_main.go
|_argon2id.go
|_go.mod
|_go.sum

Le fichier argon2id.go :

1package main
2
3import (
4	"bytes"
5	"context"
6	"errors"
7
8	"golang.org/x/crypto/argon2"
9)
10
11// HashSalt struct used to store
12// generated hash and salt used to
13// generate the hash.
14type HashSalt struct {
15	Hash, Salt []byte
16}
17
18type Argon2idHash struct {
19	// time represents the number of 
20	// passed over the specified memory.
21	time    uint32
22	// cpu memory to be used.
23	memory  uint32
24	// threads for parallelism aspect
25	// of the algorithm.
26	threads uint8
27	// keyLen of the generate hash key.
28	keyLen  uint32
29	// saltLen the length of the salt used.
30	saltLen uint32
31}
32
33// NewArgon2idHash constructor function for 
34// Argon2idHash.
35func NewArgon2idHash(time, saltLen uint32, memory uint32, threads uint8, keyLen uint32) *Argon2idHash {
36	return &Argon2idHash{
37		time:    time,
38		saltLen: saltLen,
39		memory:  memory,
40		threads: threads,
41		keyLen:  keyLen,
42	}
43}
44
45// GenerateHash using the password and provided salt.
46// If not salt value provided fallback to random value
47// generated of a given length.
48func (a *Argon2idHash) GenerateHash(password, salt []byte) (*HashSalt, error) {
49	var err error
50	// If salt is not provided generate a salt of
51	// the configured salt length.
52	if len(salt) == 0 {
53		salt, err = randomSecret(a.saltLen)
54	}
55	if err != nil {
56		return nil, err
57	}
58	// Generate hash
59	hash := argon2.IDKey(password, salt, a.time, a.memory, a.threads, a.keyLen)
60	// Return the generated hash and salt used for storage.
61	return &HashSalt{Hash: hash, Salt: salt}, nil
62}
63
64// Compare generated hash with store hash.
65func (a *Argon2idHash) Compare(hash, salt, password []byte) error {
66	// Generate hash for comparison.
67	hashSalt, err := a.GenerateHash(password, salt)
68	if err != nil {
69		return err
70	}
71	// Compare the generated hash with the stored hash.
72	// If they don't match return error.
73	if !bytes.Equal(hash, hashSalt.Hash) {
74		return errors.New("hash doesn't match")
75	}
76	return nil
77}

Le fichier main.go :

1package main
2
3import (
4	"context"
5	"crypto/rand"
6
7	"fmt"
8	"os"
9)
10
11func main() {
12	password := []byte("super-secret-password")
13
14	argon2IDHash := NewArgon2idHash(1, 32, 64*1024, 32, 256)
15
16	hashSalt, err := argon2IDHash.GenerateHash(password, nil)
17	if err != nil {
18		fmt.Fprintln(os.Stderr, err)
19		os.Exit(1)
20	}
21
22	fmt.Println(hashSalt.Hash)
23	fmt.Println(hashSalt.Salt)
24
25	err = argon2IDHash.Compare(hashSalt.Hash, hashSalt.Salt, password)
26	if err != nil {
27		fmt.Fprintln(os.Stderr, err)
28		os.Exit(1)
29	}
30	fmt.Println("argon2IDHash Password and Hash match")
31}
32
33func randomSecret(length uint32) ([]byte, error) {
34	secret := make([]byte, length)
35
36	_, err := rand.Read(secret)
37	if err != nil {
38		return nil, err
39	}
40
41	return secret, nil
42}

Choisissez votre algorithme avec soin

Les exemples ci-dessus vous donnent un excellent aperçu de l’implémentation d’algorithmes de hachage sécurisés pour le stockage des mots de passe en Go. Gardez à l’esprit que tous les algorithmes de hachage ne se valent pas : choisissez le vôtre avec soin, en fonction de vos besoins et du niveau de sécurité actuel de l’algorithme. Ce qui est considéré comme un algorithme robuste aujourd’hui évoluera avec le temps. Il est donc judicieux de réévaluer régulièrement votre choix.

Sachez également que les outils SAST comme Snyk Code peuvent vous aider à repérer les algorithmes obsolètes et vous conseiller sur la marche à suivre pour les mettre à jour, si nécessaire. Choisissez votre algorithme de hachage des mots de passe avec soin, restez informé et bon codage !