Cryptographie en Go : chiffrement et hachage pour débutants

Cryptographie en Go (Golang) : chiffrement et hachage

Go (Golang) est un langage compilé moderne réputé pour ses performances et son support intégré des algorithmes cryptographiques. La bibliothèque standard crypto fournit tout le nécessaire pour protéger les données : du simple hachage au chiffrement asymétrique complexe. Dans cet article, nous allons explorer les outils principaux et présenter des exemples de code pratiques.

Pourquoi la cryptographie en Go ?

La cryptographie en Go est utilisée pour :

• Stocker les mots de passe (hachage) ;
• Transmettre des données sur le réseau (TLS/SSL) ;
• Les signatures numériques et l'authentification ;
• Chiffrer des fichiers confidentiels.

Go garantit la sécurité grâce à une API bien conçue — il est difficile d'utiliser accidentellement un algorithme obsolète ou non sécurisé.

Hachage en Go

Le hachage est une transformation unidirectionnelle des données en une chaîne de longueur fixe. En Go, cela est géré par les paquets crypto/md5, crypto/sha1, crypto/sha256 et crypto/sha512.

Exemple : hachage SHA-256

package main

import (    "crypto/sha256"    "fmt")

func main() {    data := []byte("Données secrètes")    hash := sha256.Sum256(data)    fmt.Printf("SHA256 : %x", hash)}

Sortie : SHA256 : 3c3b... (64 caractères)

Hachage avec sel pour les mots de passe

Pour stocker les mots de passe en toute sécurité, utilisez crypto/rand pour générer un sel et crypto/sha256 :

package main

import (    "crypto/rand"    "crypto/sha256"    "fmt")

func main() {    password := []byte("MonMotDePasse123")    salt := make([]byte, 16)    rand.Read(salt)        salted := append(salt, password...)    hash := sha256.Sum256(salted)    fmt.Printf("Sel : %x", salt)    fmt.Printf("Haché : %x", hash)}

En pratique, pour les mots de passe, il est préférable d'utiliser bcrypt (paquet golang.org/x/crypto/bcrypt), mais SHA-256 avec sel est une bonne option pour l'apprentissage.

Chiffrement symétrique : AES

AES (Advanced Encryption Standard) est l'algorithme symétrique le plus populaire. En Go, il est implémenté dans le paquet crypto/aes en combinaison avec les modes de chiffrement (crypto/cipher).

Exemple : chiffrement AES-GCM

package main

import (    "crypto/aes"    "crypto/cipher"    "crypto/rand"    "fmt")

func main() {    key := []byte("0123456789abcdef0123456789abcdef") // 32 octets pour AES-256    plaintext := []byte("Message confidentiel")        block, _ := aes.NewCipher(key)    aead, _ := cipher.NewGCM(block)        nonce := make([]byte, aead.NonceSize())    rand.Read(nonce)        ciphertext := aead.Seal(nil, nonce, plaintext, nil)    fmt.Printf("Chiffré : %x", ciphertext)        // Déchiffrement    decrypted, _ := aead.Open(nil, nonce, ciphertext, nil)    fmt.Printf("Déchiffré : %s", decrypted)}

GCM (Galois/Counter Mode) assure la confidentialité et l'authentification — le meilleur choix pour la plupart des tâches.

Chiffrement asymétrique : RSA

RSA utilise une paire de clés (publique et privée). En Go, il est implémenté dans crypto/rsa et crypto/rand.

Génération de clés et chiffrement

package main

import (    "crypto/rand"    "crypto/rsa"    "crypto/sha256"    "fmt")

func main() {    privateKey, _ := rsa.GenerateKey(rand.Reader, 2048)    publicKey := &privateKey.PublicKey        message := []byte("Secret pour RSA")    label := []byte("")        // Chiffrement avec la clé publique    ciphertext, _ := rsa.EncryptOAEP(sha256.New(), rand.Reader, publicKey, message, label)    fmt.Printf("Chiffré RSA : %x", ciphertext)        // Déchiffrement avec la clé privée    plaintext, _ := rsa.DecryptOAEP(sha