Chiffrer des données de santé : pourquoi ne pas dériver les clés de la clé maîtresse, et ce que le chiffrement ne fait pas
CODEUR SENIOR
NOV 18, 2026
« Une clé par patient, calculée à partir d'une clé maîtresse » : l'idée revient dans presque tous les premiers prototypes de chiffrement applicatif. Elle est simple, sans stockage, et chaque patient a bien sa clé. Elle est aussi en contradiction avec tout ce qu'on attend d'un système de gestion de clés.
Sur une application qui traite des données de santé, nous avions un prototype de chiffrement des champs sensibles (nom, téléphone, antécédents…) dans la base documentaire. Au moment de le reprendre pour la production, avec un coffre de clés par pays, il a fallu jeter sa pièce centrale : la dérivation de clé. Cet article explique pourquoi, ce qui la remplace, et surtout les limites qui restent une fois le chiffrement en place, celles qu'on oublie de dire aux équipes et aux auditeurs.
1. Le point de départ : une clé par patient, dérivée
Le prototype faisait ceci :
def _derive_patient_key(self, patient_id: str) -> bytes:
context = b"app-patient-kek-v1"
key_material = self._master_key + patient_id.encode("utf-8") + context
return hashlib.sha256(key_material).digest()
Autrement dit : clé_patient = SHA-256(clé_maîtresse || id_patient || contexte), puis AES-256-GCM sur chaque champ avec cette clé. La clé maîtresse venait d'une variable d'environnement. Et si cette variable manquait, le service ne refusait pas de démarrer : il prenait une clé de développement fixe, dérivée d'une phrase écrite en clair dans le code, avec un simple avertissement dans les logs.
Ça fonctionne. Les tests passent. Et pourtant presque tout est à revoir.
2. Cinq raisons d'abandonner la dérivation (de la plus grave à la moins grave)
2.1 Elle exige que l'application détienne la clé maîtresse
Pour calculer SHA-256(clé_maîtresse || …), il faut avoir la clé maîtresse en mémoire, donc dans un .env, une variable d'environnement, un secret Kubernetes. C'est exactement ce qu'un KMS (AWS KMS, Google Cloud KMS, HashiCorp Vault, OpenBao) est conçu pour empêcher : une clé maîtresse non exportable, qui ne sort jamais du coffre. On ne peut pas dériver depuis une clé qu'on ne voit pas.
2.2 Une fuite de la clé maîtresse ouvre tous les dossiers
L'identifiant du patient n'est pas secret. Quiconque obtient la clé maîtresse (un dump mémoire, une sauvegarde de .env, un dépôt Git) recalcule la clé de chaque patient en une ligne. Le « une clé par patient » n'apporte alors aucun cloisonnement.
2.3 La rotation oblige à tout rechiffrer
Changer la clé maîtresse change toutes les clés patients. Il faut donc relire et rechiffrer toute la base, de façon cohérente, sans coupure. En pratique, on ne fait jamais la rotation.
2.4 Ni effacement ni renouvellement ciblé
Tant que la clé maîtresse existe, la clé d'un patient est recalculable. Impossible de :
- détruire la clé d'un seul patient pour rendre ses données illisibles (crypto-shredding, utile pour le droit à l'effacement) ;
- renouveler la clé d'un seul dossier après un incident.
2.5 Ce n'est pas une fonction de dérivation standard
Le commentaire du code disait « HKDF-like ». Ce n'en est pas une : c'est un SHA-256 sur une concaténation. La construction standard est HKDF (RFC 5869), ou au minimum un HMAC avec la clé maîtresse comme clé. En pratique, avec une clé maîtresse aléatoire de 256 bits, le risque concret est faible, mais aucun auditeur ne validera une construction maison. C'est le moins grave des cinq défauts, et le seul que corrige « remplacer par HKDF ».
Quand la dérivation a du sens. HKDF est l'outil normal pour tirer plusieurs sous-clés d'une clé que vous détenez légitimement : séparer une clé de chiffrement et une clé d'authentification issues d'un échange Diffie-Hellman, ou dériver des clés par usage à partir d'un secret de session. Le problème n'est pas la dérivation en soi, c'est de l'appliquer à la clé maîtresse d'un KMS.
Et le repli sur une clé de développement fixe ? À proscrire sans discussion. Une production mal configurée « chiffrerait » avec une clé lisible dans le dépôt. Sans coffre, un service de chiffrement doit refuser de démarrer, et répondre 503 si le coffre devient injoignable, jamais écrire en clair « en attendant ».
3. Ce qui la remplace : le chiffrement par enveloppe
Le modèle standard de tous les KMS s'appelle envelope encryption :
- une clé maîtresse (KEK), non exportable, versionnée, reste dans le coffre ;
- pour chaque sujet (un patient, un médecin), l'application génère une clé de données (DEK) aléatoire de 256 bits ;
- elle demande au coffre d'envelopper (chiffrer) cette DEK, et ne stocke que l'enveloppe, à côté des données ;
- pour relire, elle demande au coffre de désenvelopper la DEK, la garde quelques minutes en mémoire, et déchiffre les champs localement.
Avec OpenBao ou Vault, le moteur transit fait exactement cela :
import base64, os
import hvac
from cryptography.hazmat.primitives.ciphers.aead import AESGCM
vault = hvac.Client(url=VAULT_URL) # authentifié par AppRole, jeton court
KEY = "patient-data-prod" # clé maîtresse par usage ET par environnement
def new_subject_key() -> tuple[bytes, str]:
dek = AESGCM.generate_key(bit_length=256)
wrapped = vault.secrets.transit.encrypt_data(
name=KEY, plaintext=base64.b64encode(dek).decode()
)["data"]["ciphertext"] # "vault:v3:…"
return dek, wrapped # on ne stocke QUE `wrapped`
def unwrap(wrapped: str) -> bytes:
plain = vault.secrets.transit.decrypt_data(name=KEY, ciphertext=wrapped)
return base64.b64decode(plain["data"]["plaintext"])
def encrypt_field(dek: bytes, value: str, aad: bytes) -> str:
nonce = os.urandom(12) # 96 bits, unique par chiffrement
ct = AESGCM(dek).encrypt(nonce, value.encode(), aad)
return "enc:v1:" + base64.b64encode(nonce + ct).decode()
Ce que l'on gagne, point par point :
| Problème de la dérivation | Avec l'enveloppe |
|---|---|
| L'application détient la clé maîtresse | Elle ne la voit jamais ; elle n'a que des DEK, en mémoire, quelques minutes |
| Une fuite ouvre tout | Une fuite de la mémoire expose les DEK en cache à cet instant, pas les autres |
| Rotation = tout rechiffrer | Rotation = réenvelopper les DEK (rewrap), les données ne bougent pas |
| Ni effacement ni renouvellement ciblé | Supprimer l'enveloppe d'un patient rend ses données illisibles ; on peut renouveler une DEK seule |
| Construction maison | Primitives standard (AES-256-GCM, moteur transit), versionnées, auditées par le coffre |
Deux détails qui comptent :
- Le nonce GCM. Avec des nonces aléatoires de 96 bits, le NIST (SP 800-38D) limite une même clé à environ 2³² chiffrements. Une DEK par sujet reste très loin de cette limite ; une clé unique pour toute la base, non.
- Les données associées (AAD). Passer l'identifiant du document et le nom du champ en AAD empêche de copier un champ chiffré d'un patient vers un autre : il ne se déchiffrerait plus.
4. Une hiérarchie, pas une clé
« Une seule clé ou plusieurs ? » La réponse est une hiérarchie, séparée par usage et par environnement :
- une clé du dev ne peut pas déchiffrer la prod ;
- la clé de recherche (HMAC) ne sert qu'à calculer des empreintes, jamais à chiffrer ;
- un coffre par pays quand la souveraineté des données de santé l'exige : aucune clé, aucune sauvegarde ne traverse la frontière.
5. Les limites : ce que le chiffrement ne fait pas
C'est la partie qu'on oublie. Le chiffrement applicatif côté serveur est indispensable (RGPD article 32, hébergement de données de santé), mais il ne protège pas de tout.
5.1 Le serveur voit les données en clair
C'est l'application qui déchiffre pour l'utilisateur autorisé. Un attaquant qui contrôle l'application en fonctionnement lit ce qu'elle lit. Le chiffrement protège contre le vol de la base, d'une sauvegarde, d'un disque, et contre un administrateur de base de données curieux, pas contre la compromission du backend. Le contrôle d'accès et l'audit restent la première ligne.
5.2 Le cache des clés est un compromis assumé
Sans cache, chaque requête appelle le coffre (quelques millisecondes à quelques dizaines de millisecondes). Le seul cache utile garde des DEK déchiffrées en mémoire. Mettre en cache des DEK encore enveloppées, comme on le voit parfois dans des spécifications, ne sert à rien : il faut quand même appeler le coffre. Il faut donc borner ce cache : quelques minutes, un nombre d'entrées limité, jamais sur disque ni dans un cache partagé type Redis.
5.3 L'effacement par destruction de clé ne couvre pas les sauvegardes
C'est l'erreur la plus fréquente, et je l'ai faite moi-même en première analyse. Si la DEK enveloppée est stockée dans la base, elle est aussi dans chaque sauvegarde de la base. Et la clé maîtresse, elle, est toujours dans le coffre. Restaurer une sauvegarde d'avant l'effacement permet donc de tout relire.
- avec la DEK enveloppée dans la base, l'effacement est effectif à l'expiration des sauvegardes de la base ;
- avec une clé par patient dans le coffre, il est effectif à l'expiration des sauvegardes du coffre, au prix d'autant de clés que de patients.
Dans les deux cas, la durée de conservation des sauvegardes devient la limite de l'effacement : il faut la borner et l'écrire noir sur blanc pour le DPO. Et pour un dossier médical, les obligations légales de conservation (20 ans pour les établissements de santé en France) priment sur la destruction de clé.
5.4 Chercher dans des données chiffrées
Une vue « recherche par e-mail » ne fonctionne plus sur un champ chiffré. La solution classique est l'index aveugle : on stocke à côté du champ chiffré un HMAC(clé_recherche, valeur_normalisée), et on cherche sur cette empreinte. Ses limites :
- égalité exacte seulement : pas de « commence par », pas de recherche floue ;
- l'empreinte révèle l'égalité : deux comptes avec le même téléphone ont la même empreinte ;
- pour les valeurs à faible entropie (téléphones, dates de naissance), si la clé HMAC fuit, on retrouve les valeurs par force brute en quelques secondes. Elle doit donc rester dans le coffre, comme les autres.
5.5 Une clé par relation patient–médecin n'apporte rien côté serveur
« Le médecin n'accède au dossier qu'une fois l'invitation acceptée : faut-il une clé partagée entre le patient et lui ? » Tant que le chiffrement est côté serveur, non : le serveur détient toutes les clés, une clé par relation ne protège rien de plus, et il faudrait la redistribuer à chaque délégation à un membre de l'équipe soignante, ou à chaque révocation. L'accès reste une décision d'autorisation, tracée par l'audit.
Une clé partagée n'a de sens qu'avec un chiffrement de bout en bout, où le serveur ne voit jamais les données. Mais alors le serveur ne peut plus envoyer d'alertes, générer de documents PDF, ingérer des mesures envoyées par des appareils, faire tourner un modèle d'IA, ni aider un patient qui a perdu sa clé. Et quel que soit le modèle, la révocation ne fait pas oublier : ce qu'un médecin a déjà lu, il l'a lu. Le bout en bout se justifie pour un périmètre étroit (messagerie, coffre de documents), rarement pour tout le dossier.
5.6 Le coffre devient une dépendance critique
Coffre injoignable ou scellé après un redémarrage : plus rien ne se déchiffre. Il faut donc :
- échouer proprement (503), jamais de repli en clair ;
- une procédure de déverrouillage écrite et testée (parts Shamir réparties entre plusieurs personnes, ou déverrouillage automatique adossé à un service tiers, à choisir en connaissance de cause) ;
- des sauvegardes quotidiennes et avant chaque rotation, une restauration testée régulièrement. Perdre le coffre, c'est perdre définitivement les données.
5.7 Les métadonnées restent en clair
Identifiants de documents, dates, structure, type de ressource, taille des champs : tout cela reste lisible. Savoir qu'un patient a de nombreux documents rattachés à une spécialité donnée en dit déjà beaucoup. Le chiffrement des champs ne remplace ni la minimisation des données ni le chiffrement du disque et des sauvegardes.
6. En résumé
| Question | Réponse |
|---|---|
| Dériver les clés patients de la clé maîtresse ? | Non : DEK aléatoire par sujet, enveloppée par le coffre |
| HKDF à la place de SHA-256 ? | Ne règle que le moins grave des cinq problèmes |
| Une seule clé ? | Non : une hiérarchie par usage, environnement et pays |
| Repli en clair si le coffre tombe ? | Jamais : 503, et refus de démarrer sans coffre |
| Effacement par destruction de clé ? | Effectif à l'expiration des sauvegardes, à documenter |
| Recherche sur champs chiffrés ? | Index aveugle HMAC, égalité exacte, clé dans le coffre |
| Clé par relation patient–médecin ? | Inutile côté serveur ; l'accès est une affaire d'autorisation |
| Le chiffrement protège-t-il d'un serveur compromis ? | Non : il protège la base, les sauvegardes et les disques |
Le chiffrement applicatif est un maillon, pas une armure. Bien fait, il réduit l'impact d'une fuite de base ou de sauvegarde à presque rien. Mal présenté, il donne une fausse impression de sécurité sur tout le reste : l'accès, l'audit, les sauvegardes et la disponibilité du coffre.