Erreurs fréquentes en crypto côté développeur : top 12 à éviter

# VULNÉRABLE
import hashlib
 
def hash_password(password: str) -> str:
    return hashlib.sha256(password.encode()).hexdigest()
# Sur GPU RTX 4090 : 20 Ghash/s. Base de 100k mdp moyens crackée en heures.

# CORRIGÉ - Argon2id recommandé OWASP 2025
from argon2 import PasswordHasher
 
ph = PasswordHasher(
    time_cost=3,        # itérations
    memory_cost=65536,  # 64 MB
    parallelism=4,
)
 
def hash_password(password: str) -> str:
    return ph.hash(password)
 
def verify_password(stored_hash: str, password: str) -> bool:
    try:
        ph.verify(stored_hash, password)
        return True
    except Exception:
        return False

# VULNÉRABLE - ECB
from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
 
cipher = Cipher(algorithms.AES(key), modes.ECB())  # JAMAIS ECB
 
# CORRIGÉ - GCM (AEAD authentifié)
from cryptography.hazmat.primitives.ciphers.aead import AESGCM
import os
 
aesgcm = AESGCM(key)
nonce = os.urandom(12)  # 96 bits - standard GCM
ciphertext = aesgcm.encrypt(nonce, plaintext, associated_data=b"ctx-v1")
# Stocker [nonce, ciphertext] ensemble

AES-GCM avec nonce reuse = catastrophe :
  - Récupération du stream keystream
  - Forge de ciphertext arbitraire
  - Authentication bypass
 
Moyens d'assurer l'unicité :
  Random 96 bits (AES-GCM standard)        : OK si RNG crypto sûr
  Compteur atomique persistant              : OK si jamais réinitialisé
  XChaCha20-Poly1305 (24 octets random)     : OK même sous contention
  AES-GCM-SIV (RFC 8452)                   : résistant nonce reuse

// VULNÉRABLE
function generateToken() {
    return Math.random().toString(36).substr(2);  // PRÉVISIBLE
}
 
// CORRIGÉ (Node.js)
const crypto = require('crypto');
function generateToken() {
    return crypto.randomBytes(32).toString('base64url');
}
 
// CORRIGÉ (navigateur)
function generateToken() {
    const arr = new Uint8Array(32);
    crypto.getRandomValues(arr);
    return btoa(String.fromCharCode(...arr));
}

Navigateur : crypto.getRandomValues()
Node.js    : crypto.randomBytes(), crypto.randomUUID()
Python     : secrets module (pas random!), os.urandom()
Java       : SecureRandom (jamais Random)
Go         : crypto/rand (jamais math/rand pour sécurité)
Linux      : /dev/urandom, getrandom(2)
Windows    : BCryptGenRandom

Attaque : header { "alg": "none" } + signature vide.
Si le validateur accepte "none", tout token forgé passe.
 
Parade : whitelister explicitement les algorithmes.

# VULNÉRABLE - on accepte l'algo du header
import jwt
payload = jwt.decode(token, key, algorithms=None)  # JAMAIS
 
# Attaquant peut signer HS256 avec la clé publique RS256 comme secret HMAC
 
# CORRIGÉ - algorithme whitelisté
payload = jwt.decode(token, public_key, algorithms=["RS256"])

Règles 2026 :
  Si HS256 : secret >= 256 bits d'entropie (32 octets random)
  Préférer RS256 ou ES256 pour éviter la symétrie
  JWT alg:none interdit dans TOUTES les configs

Fréquence : 1ère cause de compromission cloud en 2024-2025
  (GitGuardian, Snyk, Mandiant)
 
Outils de détection SAST/CI 2026 :
  gitleaks (OSS)
  trufflehog (OSS)
  GitHub Secret Scanning + Push Protection (natif, gratuit public)
  Snyk secrets
  Semgrep p/secrets

# VULNÉRABLE
export DATABASE_PASSWORD="p@ssw0rd123"  # commit dans .env
 
# CORRIGÉ
# Vault, AWS Secrets Manager, GCP Secret Manager injecté à l'exécution
# OIDC Workload Identity Federation pour CI/CD (sans secret long-durée)

// VULNÉRABLE
function checkToken(userToken, validToken) {
    return userToken === validToken;  // timing attack possible
}
 
// CORRIGÉ (Node.js)
const crypto = require('crypto');
function checkToken(userToken, validToken) {
    const a = Buffer.from(userToken);
    const b = Buffer.from(validToken);
    if (a.length !== b.length) return false;
    return crypto.timingSafeEqual(a, b);
}

Node.js   : crypto.timingSafeEqual(a, b)
Python    : hmac.compare_digest(a, b)
Java      : MessageDigest.isEqual(a, b) depuis JDK 6u17
Go        : subtle.ConstantTimeCompare(a, b)
Ruby      : ActiveSupport::SecurityUtils.secure_compare
Rust      : subtle crate, CtEq trait

Configuration TLS 2026 acceptable (Mozilla Intermediate) :
  Protocoles : TLS 1.2 + TLS 1.3 uniquement
  Ciphers TLS 1.3 : toutes les suites standard acceptables
  Ciphers TLS 1.2 : ECDHE-RSA-AES-GCM, ECDHE-ECDSA-AES-GCM,
                    ECDHE-CHACHA20-POLY1305
  HSTS activé avec preload
  OCSP stapling
  Certificates ECDSA P-256 ou RSA 2048+
 
À bannir : TLS 1.0, 1.1, SSLv3, RC4, 3DES, EXPORT ciphers, NULL ciphers

# VULNÉRABLE
import requests
requests.get('https://api.example.com', verify=False)  # JAMAIS en prod
 
# CORRIGÉ
requests.get('https://api.example.com', verify=True)
# Si certificat auto-signé : verify='/path/to/ca-bundle.crt'

Parade 2026 :
  Toujours utiliser AEAD (Authenticated Encryption with Associated Data) :
    AES-GCM (standard)
    ChaCha20-Poly1305 (RFC 8439)
    AES-CCM (contextes IoT)
    XChaCha20-Poly1305
 
  Si CBC obligatoire (legacy) : encrypt-then-MAC avec HMAC-SHA-256 constant-time

Incidents historiques :
  Sony PS3 (2010)           : k fixe → clé extraite
  Android Bitcoin (2013)    : SecureRandom mal initialisé → wallets vidés
 
Parade 2026 :
  Déterministic ECDSA (RFC 6979) : k dérivé de hash(message + privateKey)
  EdDSA / Ed25519 (RFC 8032)      : déterministe par design
  Bibliothèques à jour            : toutes implémentent RFC 6979 par défaut

Parade 2026 :
  Désactiver tous les protocoles et ciphers faibles côté serveur ET client
  TLS_FALLBACK_SCSV activé sur clients compatibles
  Monitoring SSL Labs / testssl.sh sur endpoints publics
  Pas d'acceptation de « legacy clients » sans analyse de risque documentée

Exemples de « maison » qui ont mal tourné :
 
  Telegram MTProto 1.0        : corrections après plusieurs audits
  WhatsApp protocole custom   : remplacé par Signal Protocol
  Projets blockchain maison   : souvent vulnérables dans les 6 premiers mois
  Custom SAML validator       : XSW partout
  Custom session cookie crypto: timing, padding oracle, key reuse
 
Règle universelle :
  Composer des primitives auditées via une bibliothèque haut niveau.
  libsodium + Tink couvrent 99 % des besoins applicatifs modernes.

Semgrep
  Rules p/owasp-top-ten et p/security-audit
  Détection JWT.decode sans algorithms, bcrypt missing, etc.
 
CodeQL
  Queries CWE-327 (Use of broken cryptographic algorithm)
  Queries CWE-328 (Reversible one-way hash)
  Queries CWE-330 (Use of insufficiently random values)
 
Bandit (Python)
  B301-B505 : hashlib.md5, ECB mode, random, SSL verify
 
gosec (Go)
  G401 : weak cryptographic primitives
  G501-G505 : MD5, SHA1, DES, RC4, CTR
 
Snyk Code
  Couverture large crypto misuse par langage
 
SonarQube
  Rules crypto : hash weak, IV reuse, weak RNG

testssl.sh (OSS)        : analyse CLI complète d'un endpoint
SSL Labs SSL Test       : note A+ à F, rapport détaillé
Mozilla Observatory      : audit TLS + headers
hardenize.com           : audit complet stack web
nmap --script=ssl-enum-ciphers

gitleaks, trufflehog, GitGuardian, Snyk Secrets
GitHub Secret Scanning + Push Protection (natif)