# Propriétés attendues d'une fonction de hachage cryptographique
1. Déterministe       : même entrée -> toujours la même sortie
2. Rapide à calculer   (pour l'intégrité, PAS pour les mots de passe)
3. Effet avalanche     : un bit d'entrée changé -> sortie totalement différente
4. Résistance aux collisions : difficile de trouver deux entrées avec le même hash
5. Irréversibilité     : impossible de retrouver l'entrée à partir de la sortie

import hashlib

data = b"Technologik e-learning platform"

print(hashlib.sha256(data).hexdigest())
print(hashlib.sha3_256(data).hexdigest())     # SHA-3, famille Keccak
print(hashlib.blake2b(data).hexdigest())      # BLAKE2, très performant

# MD5 et SHA1 sont OBSOLÈTES pour la sécurité (collisions démontrées) : n'utiliser que pour
# des checksums non-sécuritaires (ex: détection de corruption de fichier, PAS d'intégrité adverse)
print(hashlib.md5(data).hexdigest())   # à éviter en contexte sécurité

# Vérifier l'intégrité d'un fichier téléchargé (checksum)
sha256sum technologik-release-v2.3.0.tar.gz
# Comparer avec la valeur publiée par l'éditeur (souvent dans un fichier .sha256 signé)

echo "b2c4e1... technologik-release-v2.3.0.tar.gz" | sha256sum -c -

# HMAC (Hash-based Message Authentication Code) : hachage AVEC une clé secrète
# Garantit l'authenticité ET l'intégrité (pas seulement l'intégrité comme un hash simple)
import hmac
import hashlib

secret_key = b"clé-secrète-partagée-longue-et-aleatoire"
message = b'{"amount": 100, "currency": "EUR"}'

signature = hmac.new(secret_key, message, hashlib.sha256).hexdigest()

def verify_hmac(message: bytes, signature: str, key: bytes) -> bool:
    expected = hmac.new(key, message, hashlib.sha256).hexdigest()
    return hmac.compare_digest(expected, signature)  # comparaison en temps constant, anti-timing-attack

assert verify_hmac(message, signature, secret_key) is True

# Utilisation typique : signer un webhook pour prouver qu'il vient bien de l'émetteur attendu
# (ex: Stripe, GitHub envoient un header X-Hub-Signature-256 = HMAC du corps de la requête)
from fastapi import FastAPI, Request, HTTPException
import hmac, hashlib

WEBHOOK_SECRET = b"secret-partage-avec-le-fournisseur"

@app.post("/webhooks/payment")
async def handle_webhook(request: Request):
    body = await request.body()
    signature_header = request.headers.get("X-Signature-256", "")
    expected = "sha256=" + hmac.new(WEBHOOK_SECRET, body, hashlib.sha256).hexdigest()
    if not hmac.compare_digest(expected, signature_header):
        raise HTTPException(status_code=401, detail="Signature invalide")
    # ... traiter l'événement en confiance ...

# Pièges classiques à éviter
- Comparer deux hash avec "==" au lieu de hmac.compare_digest -> vulnérable aux timing attacks
- Utiliser un hash rapide (sha256) pour des mots de passe -> utiliser bcrypt/argon2 (voir leçon dédiée)
- Réutiliser la même clé HMAC pour plusieurs usages différents -> dériver des clés distinctes (HKDF)
- Oublier de versionner l'algorithme utilisé -> stocker "argon2id$v=19$..." pas juste le hash brut