Pourquoi maîtriser la cryptographie comme développeur en 2026 (informations vérifiées en avril 2026, susceptibles d’évoluer) ?

Aucune startup ou projet pro ne peut se passer aujourd’hui de cryptographie correcte : hash de mots de passe (loi 2008-12 sur les données personnelles), chiffrement de tokens API, signature de webhooks Wave/PayDunya, TLS sur tous les endpoints. Une mauvaise implémentation (MD5 pour mot de passe, AES-ECB, comparaison == sur signatures) crée des failles silencieuses qui resteront exploitables tant que personne ne les détecte. Cet article couvre les 10 primitives essentielles que tout dev doit savoir utiliser correctement avec les libs validées (cryptography, argon2-cffi, age).

Ce que vous saurez faire à la fin

Distinguer hachage, chiffrement symétrique et asymétrique
Hasher des mots de passe avec Argon2id
Chiffrer/déchiffrer avec AES-GCM
Signer avec Ed25519
Déployer TLS/HTTPS correctement

Vue d’ensemble 1 — Hash avec SHA-256

import hashlib
h = hashlib.sha256(b"Hello").hexdigest()
# 185f8db32271fe25f561a6fc938b2e264306ec304eda518007d1764826381969

Vue d’ensemble 2 — Argon2id pour mots de passe

pip install argon2-cffi

from argon2 import PasswordHasher
from argon2.exceptions import VerifyMismatchError

ph = PasswordHasher(memory_cost=65536, time_cost=3, parallelism=2)
hash_pwd = ph.hash("M0t-De-P4sse-Long!")

try:
    ph.verify(hash_pwd, "M0t-De-P4sse-Long!")
    print("OK")
except VerifyMismatchError:
    print("Mauvais mot de passe")

Argon2id est le standard OWASP. Évitez MD5, SHA-1, SHA-256 nu pour les mots de passe (trop rapides).

Vue d’ensemble 3 — HMAC pour signer un message

import hmac, hashlib, secrets

cle = secrets.token_bytes(32)
payload = b'{"montant":150000}'
sig = hmac.new(cle, payload, hashlib.sha256).hexdigest()

# Vérification côté récepteur
attendue = hmac.new(cle, payload, hashlib.sha256).hexdigest()
if not hmac.compare_digest(sig, attendue):
    raise Exception("Signature invalide")

Utilisez toujours hmac.compare_digest, jamais ==.

Vue d’ensemble 4 — AES-GCM chiffrement symétrique

pip install cryptography

from cryptography.hazmat.primitives.ciphers.aead import AESGCM
import os

cle = AESGCM.generate_key(bit_length=256)
aesgcm = AESGCM(cle)
nonce = os.urandom(12)

message = b"Solde 487 321 FCFA"
chiffre = aesgcm.encrypt(nonce, message, associated_data=b"compte:42")

clair = aesgcm.decrypt(nonce, chiffre, associated_data=b"compte:42")
print(clair.decode())

Vue d’ensemble 5 — Signature Ed25519

from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey
from cryptography.exceptions import InvalidSignature

sk = Ed25519PrivateKey.generate()
pk = sk.public_key()

message = b"Facture F-042"
signature = sk.sign(message)

try:
    pk.verify(signature, message)
    print("Authentique")
except InvalidSignature:
    print("Signature forgée")

Vue d’ensemble 6 — X25519 + dérivation de clé partagée

from cryptography.hazmat.primitives.asymmetric.x25519 import X25519PrivateKey
from cryptography.hazmat.primitives.kdf.hkdf import HKDF
from cryptography.hazmat.primitives import hashes

alice_priv = X25519PrivateKey.generate()
bob_priv = X25519PrivateKey.generate()

partage = alice_priv.exchange(bob_priv.public_key())
cle = HKDF(algorithm=hashes.SHA256(), length=32, salt=None,
           info=b"itsc-v1").derive(partage)

Vue d’ensemble 7 — TLS avec Let’s Encrypt

sudo apt install -y certbot python3-certbot-nginx
sudo certbot --nginx -d example.sn -d www.example.sn

# Renouvellement auto via timer systemd
sudo systemctl list-timers | grep certbot

Vue d’ensemble 8 — Configuration TLS stricte

ssl_protocols TLSv1.2 TLSv1.3;
ssl_ciphers ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256;
add_header Strict-Transport-Security "max-age=63072000; includeSubDomains; preload" always;

Testez avec ssllabs.com/ssltest. Cible : A ou A+.

Vue d’ensemble 9 — Gestion des secrets avec age

brew install age
age-keygen -o ~/.age/key.txt

# Chiffrer
age -r age1xxx... -o secrets.yaml.age secrets.yaml

# Déchiffrer
age -d -i ~/.age/key.txt secrets.yaml.age

Vue d’ensemble 10 — Règles d’or

✓ Jamais inventer son propre algo
✓ Argon2id pour mots de passe
✓ AES-GCM ou ChaCha20-Poly1305 pour chiffrement
✓ Ed25519 pour signatures
✓ TLS 1.2+ uniquement
✓ Rotation des clés tous les 90 jours
✓ secrets.token_bytes() pour aléatoire
✓ hmac.compare_digest pour comparer hashs
✓ Ne jamais logger un mot de passe ou token

Sur un angle proche

Les bases du chiffrement expliquées simplement — la version théorique.
Le chiffrement de bout en bout expliqué — application en messagerie.
Les certificats SSL/TLS pour votre site — TLS en pratique côté serveur.
Créer des mots de passe inviolables — côté utilisateur des hashs Argon2id.
Référence officielle : OWASP Cryptographic Storage Cheat Sheet et cryptography.io.
Outils : age, mkcert (TLS local pour dev), SSL Labs.

Hébergement recommandé pour les lecteurs

Si vous n’avez pas encore d’hébergeur, Hostinger est celui que nous utilisons et que nous recommandons après plusieurs années d’usage.

Profiter de l’offre →

Lien d affiliation. Si vous achetez via ce lien, le blog reçoit une petite commission sans surcoût pour vous.

Pourquoi la cryptographie concerne tout developpeur en 2026

A Bamako, un freelance qui developpe une application de transfert d’argent entre Mixx by Yas et un wallet local s’interroge : comment proteger les jetons d’authentification, chiffrer les SMS de confirmation, et signer les requetes API ? La cryptographie repond a trois besoins fondamentaux : la confidentialite (rendre un message illisible aux tiers), l’integrite (detecter toute alteration), et l’authentification (prouver l’identite de l’emetteur).

Comprendre les bases vous evite les erreurs critiques : stocker un mot de passe en clair, signer avec MD5, ou chiffrer un cookie avec une cle codee en dur dans le repo Git. Ce tutoriel couvre les concepts, les algorithmes modernes recommandes en 2026, et la mise en pratique avec OpenSSL et Node.js.

Etape 1 : Distinguer chiffrement symetrique et asymetrique

Le chiffrement symetrique utilise une cle unique pour chiffrer et dechiffrer. Rapide, ideal pour les gros volumes, il pose un probleme : comment partager la cle de maniere sure ? L’algorithme de reference est AES (Advanced Encryption Standard) en variante 256 bits, mode GCM pour combiner chiffrement et authentification.

Le chiffrement asymetrique utilise une paire cle publique / cle privee. La cle publique chiffre, seule la cle privee dechiffre. Plus lent, il sert au partage de secrets et a la signature numerique. RSA 2048 bits est encore largement deploye, mais ECDSA et Ed25519 sur courbes elliptiques sont desormais preferes pour leur compacite et leur vitesse.

Etape 2 : Generer une cle AES-256 et chiffrer un fichier

OpenSSL est l’outil universel pour pratiquer. Sous Linux ou WSL, generez une cle aleatoire et chiffrez un fichier texte. Ces commandes illustrent un cycle complet :

# Generer une cle 256 bits en hexadecimal
openssl rand -hex 32 > cle.hex

# Chiffrer un fichier avec AES-256-GCM
openssl enc -aes-256-cbc -salt -pbkdf2 -in message.txt -out message.enc -pass file:cle.hex

# Dechiffrer
openssl enc -d -aes-256-cbc -pbkdf2 -in message.enc -out message_clair.txt -pass file:cle.hex

Le flag -pbkdf2 active la derivation moderne de cle (Password-Based Key Derivation Function 2), qui ralentit les attaques par force brute. L’absence de -pbkdf2 sur d’anciens tutoriels est un mauvais reflexe a abandonner. Le sel (-salt) garantit qu’un meme texte chiffre deux fois produira deux fichiers differents.

Etape 3 : Comprendre le hashing avec SHA-256

Une fonction de hachage produit une empreinte de taille fixe a partir d’une entree de taille variable. Elle est unidirectionnelle : impossible de retrouver l’entree depuis l’empreinte. SHA-256, membre de la famille SHA-2, produit 32 octets et reste robuste. SHA-1 et MD5 sont casses cryptographiquement et ne doivent plus servir a aucun usage securitaire.

# Calculer le SHA-256 d'un fichier
sha256sum mon_fichier.pdf

# Verifier l'integrite d'un telechargement
echo "abc123...  ubuntu-24.04.iso" | sha256sum -c

Le hashing sert a verifier l’integrite d’un telechargement, a stocker les empreintes de fichiers dans Git, ou a indexer un cache. Pour stocker des mots de passe, le SHA-256 simple est insuffisant : il faut un algorithme de stretching comme bcrypt, scrypt ou Argon2id.

Etape 4 : Stocker un mot de passe avec Argon2id

Argon2id est le vainqueur de la Password Hashing Competition et la recommandation OWASP 2025. Il combine resistance aux GPU, aux ASIC et aux attaques par canal auxiliaire. En Node.js, le package argon2 (npm install argon2) implemente la spec officielle.

const argon2 = require('argon2');

async function enregistrer(motDePasse) {
  const hash = await argon2.hash(motDePasse, {
    type: argon2.argon2id,
    memoryCost: 19456,
    timeCost: 2,
    parallelism: 1
  });
  return hash; // a stocker en base
}

async function verifier(hash, motDePasse) {
  return await argon2.verify(hash, motDePasse);
}

Les parametres recommandes par OWASP en 2025 : memoryCost 19 MiB, timeCost 2 iterations, parallelism 1. La sortie inclut deja le sel et les parametres : un seul champ VARCHAR(255) en base suffit. Ne jamais coder votre propre fonction de hachage de mot de passe.

Etape 5 : Generer une paire de cles RSA et signer un message

La signature numerique prouve qu’un message provient bien du detenteur de la cle privee. Elle sert dans JWT, dans le code signing, dans les certificats TLS, et dans la verification de packages. Generez une paire de cles RSA 2048 bits :

# Generer la cle privee
openssl genpkey -algorithm RSA -out private.pem -pkeyopt rsa_keygen_bits:2048

# Extraire la cle publique
openssl rsa -in private.pem -pubout -out public.pem

# Signer un fichier
openssl dgst -sha256 -sign private.pem -out message.sig message.txt

# Verifier la signature avec la cle publique
openssl dgst -sha256 -verify public.pem -signature message.sig message.txt

La sortie attendue de la verification est exactement Verified OK. Tout autre message signale une alteration ou une cle incorrecte. La cle privee ne quitte jamais votre serveur ; seule la cle publique se distribue.

Etape 6 : Adopter les courbes elliptiques avec Ed25519

Pour les nouveaux projets, Ed25519 (Curve25519 + EdDSA) est plus rapide, plus court et offre une securite equivalente a RSA 3072 bits avec seulement 32 octets de cle. C’est le standard recommande pour SSH, pour les certificats modernes, et pour les jetons signes.

# Generer une cle SSH Ed25519
ssh-keygen -t ed25519 -C "dev@exemple.sn"

# Generer une paire Ed25519 avec OpenSSL 3+
openssl genpkey -algorithm ED25519 -out ed25519_priv.pem
openssl pkey -in ed25519_priv.pem -pubout -out ed25519_pub.pem

OpenSSH a fait d’Ed25519 le defaut depuis la version 7.0. Si votre fournisseur cloud propose encore RSA par defaut, basculez explicitement sur Ed25519 lors de la creation des cles SSH.

Etape 7 : Securiser une connexion avec TLS 1.3

TLS combine asymetrique (echange de cles via Diffie-Hellman ephemeral) et symetrique (chiffrement de session avec AES-GCM ou ChaCha20-Poly1305). Pour activer TLS 1.3 sur Nginx, votre fichier de configuration doit inclure :

ssl_protocols TLSv1.2 TLSv1.3;
ssl_ciphers TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256:TLS_AES_128_GCM_SHA256;
ssl_prefer_server_ciphers off;

Apres rechargement (sudo nginx -s reload), testez via ssllabs.com/ssltest. L’objectif est un grade A ou A+. TLS 1.0 et 1.1 sont obsoletes et doivent etre desactives. ChaCha20-Poly1305 brille particulierement sur mobile, ou il bat AES-GCM en l’absence d’acceleration materielle AES-NI.

Etape 8 : Eviter les pieges classiques du debutant

La premiere regle : ne jamais inventer son propre algorithme. Utilisez des bibliotheques eprouvees (libsodium, OpenSSL, Tink, BoringSSL). Ne stockez jamais une cle dans le code source ; utilisez un gestionnaire de secrets (HashiCorp Vault, AWS Secrets Manager, ou variables d’environnement chiffrees).

Generez l’alea avec /dev/urandom, crypto.randomBytes en Node.js, ou secrets en Python ; jamais avec Math.random ou rand(). Pour creuser ce sujet sur la protection des comptes utilisateurs, consultez notre guide anti-phishing avance qui prolonge ces bases. La cryptographie est un domaine ou l’humilite paie : suivre les recommandations NIST, OWASP et IETF reste la voie la plus sure.

Cryptographie a courbes elliptiques pour applications ouest-africaines

Les courbes elliptiques (ECC) ont remplace RSA dans la majorite des nouveaux systemes de chiffrement et de signature numerique parce qu’elles offrent un niveau de securite equivalent avec des cles beaucoup plus courtes. Une cle ECC de 256 bits sur la courbe P-256 (NIST) ou Curve25519 (Bernstein) protege au meme niveau qu’une cle RSA de 3072 bits. Pour les applications mobiles distribuees a Dakar et Abidjan ou la bande passante reste un facteur de cout, c’est un argument decisif : le handshake TLS est plus court, la signature est plus petite, et les batteries des smartphones sous Android Go souffrent moins lors des operations cryptographiques.

Les courbes que vous rencontrerez en pratique sont quatre. P-256 (alias secp256r1) est le standard NIST utilise par TLS, ECDSA dans les certificats X.509, et la majorite des HSM commerciaux. Curve25519 et son cousin Ed25519 pour la signature sont privilegies par les protocoles modernes (SSH, Signal, WireGuard) parce que la courbe a ete concue pour resister aux implementations naives qui leak des informations par canal auxiliaire. Secp256k1 est la courbe utilisee par Bitcoin et Ethereum, donc indispensable si vous developpez sur blockchain. Et la courbe BLS12-381 sert au zero-knowledge proofs et a l’agregation de signatures, sujet pointu mais en croissance rapide pour les rollups Ethereum.

Pour generer une paire de cles Ed25519 sur Linux, OpenSSH 9.6 ou superieur depuis Ubuntu 24.04 LTS suffit avec la commande ssh-keygen -t ed25519 -C « votre_email@itskillscenter.io ». Le fichier prive fait moins de 400 octets et la cle publique tient sur une ligne, contre plusieurs kilooctets pour une cle RSA 4096. Cette compacite est appreciable quand vous devez rotater massivement les cles SSH d’un parc de serveurs heberges chez Hetzner (5 EUR par mois soit 3 280 FCFA) ou OVH Strasbourg.

Le piege classique avec ECC est de mal configurer le mode de signature. ECDSA classique requiert un nombre aleatoire k different a chaque signature, et une faute d’implementation Sony sur la PlayStation 3 en 2010 a permis l’extraction de la cle privee parce que k etait reutilise. Preferer EdDSA (Ed25519) qui est deterministe par construction et n’a pas ce piege. Si vous devez utiliser ECDSA pour compatibilite legacy, exigez RFC 6979 qui definit un k deterministe derive de la cle privee et du message.

Gestion de cles avec HashiCorp Vault et migration post-quantum

Stocker les cles privees en clair sur un serveur est une faute professionnelle. HashiCorp Vault est l’outil standard pour centraliser la gestion des secrets : cles API, certificats X.509, mots de passe de bases de donnees, tokens OAuth. Vault chiffre les secrets au repos avec une cle maitre (master key) elle-meme protegee par un mecanisme de scellage (seal) qui peut s’appuyer sur un HSM, sur AWS KMS, sur Google Cloud KMS, ou sur trois cles Shamir distribuees a trois operateurs differents.

L’edition Community est gratuite et suffisante pour 90 pourcent des cas. L’edition Enterprise (facture sur devis, typiquement 2 500 USD par an et par node soit 1,5 million FCFA) ajoute la replication multi-datacenter et les namespaces. Pour un projet senegalais ou ivoirien debutant, la version Community sur un serveur dedie ou un cluster Kubernetes a trois nodes suffit. La haute disponibilite passe par un backend Consul ou par le backend integre Raft introduit dans Vault 1.4. Le mode Raft est plus simple a operer et nous le recommandons pour toute nouvelle installation 2026.

vault kv put secret/itskc/db \
  username="appuser" \
  password="$(openssl rand -base64 32)"

vault kv get -field=password secret/itskc/db

L’authentification dans Vault se fait par tokens, par AppRole pour les services, ou par des integrations SSO via OIDC. Pour les serveurs Kubernetes, l’auth Kubernetes injectee via un sidecar Vault Agent est la pratique recommandee. L’application n’a jamais a manipuler la cle directement : Vault Agent recupere le secret, l’expose dans un fichier ou une variable d’environnement, et le rotate transparentement.

La menace post-quantum n’est plus theorique. NIST a finalise en aout 2024 trois standards : ML-KEM (anciennement Kyber) pour l’echange de cles, ML-DSA (Dilithium) et SLH-DSA (SPHINCS+) pour la signature. Ces algorithmes resistent aux attaques d’un futur ordinateur quantique cryptographiquement utile (CRQC). Les estimations actuelles placent l’arrivee d’un tel ordinateur entre 2030 et 2040, mais la regle « harvest now, decrypt later » oblige les organisations qui manipulent des donnees sensibles a long terme (medical, juridique, secret defense) a migrer des aujourd’hui.

Concretement, OpenSSL 3.5 publie debut 2025 inclut le support natif de ML-KEM et ML-DSA. Cloudflare propose deja le hybride X25519+Kyber768 sur tout son edge depuis 2023. Pour 99 pourcent des sites WordPress africains, vous n’avez rien a faire activement : votre certificat Let’s Encrypt sera automatiquement migre vers PQC quand l’autorite de certification le supportera (annonces 2026-2027). Pour les applications bancaires senegalaises ou ivoiriennes regulees par la BCEAO, lancez des aujourd’hui un audit de votre stack TLS et identifiez les composants legacy qui freineront la migration. Voir notre guide cryptographie pour les fondamentaux symetriques et asymetriques.