Cryptographie en Go : chiffrement et hachage

Cryptographie en Go (Golang) : guide complet du chiffrement et du hachage

Go (Golang) fournit une bibliothèque standard puissante crypto, qui inclut tous les outils nécessaires pour implémenter la protection cryptographique des données. Dans cet article, nous allons détailler les principales fonctionnalités de chiffrement et de hachage en Go, notamment le chiffrement symétrique (AES), asymétrique (RSA), les fonctions de hachage (SHA-256) et la protection des mots de passe avec bcrypt.

1. Hachage de données en Go

Le hachage est une transformation unidirectionnelle de données en une sortie de longueur fixe. En Go, on utilise le package crypto/sha256 (et d'autres familles SHA).

Exemple : hachage SHA-256 d'une chaîne

package main

import (    "crypto/sha256"    "fmt")

func main() {    data := "PythonLib.ru — site éducatif"    hash := sha256.Sum256([]byte(data))    fmt.Printf("SHA-256 : %x", hash)}

Sortie : SHA-256 : 3c4a5b6c7d8e9f0a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6e7f8a9b0c1d2e3f4

Pour le hachage en flux (gros fichiers), utilisez l'interface hash.Hash :

package main

import (    "crypto/sha256"    "fmt"    "io"    "strings")

func main() {    h := sha256.New()    reader := strings.NewReader("Flux de données à hacher")    io.Copy(h, reader)    fmt.Printf("SHA-256 en flux : %x", h.Sum(nil))}

2. Protection des mots de passe avec bcrypt

Pour stocker les mots de passe, n'utilisez jamais de hachages simples (SHA-256). Utilisez bcrypt — un algorithme avec sel et complexité adaptative. En Go, cela est implémenté par le package golang.org/x/crypto/bcrypt.

Installation :

go get golang.org/x/crypto/bcrypt

Exemple de hachage et vérification de mot de passe :

package main

import (    "fmt"    "golang.org/x/crypto/bcrypt")

func main() {    password := "MySecurePass123!"

    // Hachage (coût par défaut = 10)    hash, err := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)    if err != nil {        panic(err)    }    fmt.Printf("hash bcrypt : %s", hash)

    // Vérification du mot de passe    err = bcrypt.CompareHashAndPassword(hash, []byte(password))    if err != nil {        fmt.Println("Mot de passe incorrect")    } else {        fmt.Println("Mot de passe correct !")    }}

3. Chiffrement symétrique AES-GCM

AES (Advanced Encryption Standard) est un algorithme symétrique. Le mode recommandé est GCM (Galois/Counter Mode), qui assure l'authentification (AEAD). Utilisez les packages crypto/aes et crypto/cipher.

Exemple de chiffrement et déchiffrement AES-256-GCM :

package main

import (    "crypto/aes"    "crypto/cipher"    "crypto/rand"    "encoding/hex"    "fmt"    "io")

func main() {    key := []byte("Clé de 32 octets pour AES-256!!!") // 32 octets    plaintext := []byte("Message secret pour PythonLib")

    // Chiffrement    ciphertext, nonce := encryptAESGCM(key, plaintext)    fmt.Printf("Chiffré : %s", hex.EncodeToString(ciphertext))

    // Déchiffrement    decrypted, err := decryptAESGCM(key, ciphertext, nonce)    if err != nil {        panic(err)    }    fmt.Printf("Déchiffré : %s", decrypted)}

func encryptAESGCM(key, plaintext []byte) (ciphertext, nonce []byte) {    block, _ := aes.NewCipher(key)    gcm, _ := cipher.NewGCM(block)    nonce = make([]byte, gcm.NonceSize())    io.ReadFull(rand.Reader, nonce)    return gcm.Seal(nil, nonce, plaintext, nil), nonce}

func decryptAESGCM(key, ciphertext, nonce []byte) ([]byte, error) {    block, _ := aes.NewCipher(key)    gcm, _ := cipher.NewGCM(block)    return gcm.Open(nil, nonce, ciphertext, nil)}