Annexe CContre quoi la chaîne d'empreintes protège-t-elle ?

Le chapitre 03 de l'article principal dit que chaque modification conserve la version précédente, reliée à la précédente par une empreinte cryptographique. Cette annexe ouvre le mécanisme : ce qui est haché, comment c'est chaîné, ce qui se passe quand deux personnes écrivent en même temps, qui pourrait le réécrire, et ce que cela coûte.

État au 2 novembre 2026

Cette annexe est un instantané d'un travail en cours. Fait : le mécanisme vérifié d'après ses migrations et essayé sur une base jetable. Ouvert : une bifurcation quand une transaction modifie plusieurs fois une ligne (OPEN-110), aucun vérificateur (OPEN-111), aucune protection contre un administrateur (OPEN-112), et les améliorations classées à la fin. Une version ultérieure dira ce qui en a été fait. Les numéros de la forme OPEN-nnn sont des entrées du registre des points ouverts du projet, qui fait partie de son système qualité (chapitre 06).

Comment cela fonctionne-t-il ?

Onze tables du dispositif contiennent des données : le dossier du patient et ses adresses, la configuration que le dispositif reçoit de l'outil de configuration, le catalogue d'actions et les restrictions déployées. Chacune a une table d'archive jumelle avec les mêmes colonnes et quatre de plus : son propre identifiant, l'identifiant de la ligne d'origine, l'heure d'archivage et une empreinte. Un déclencheur s'exécute avant chaque modification. Il prend la ligne telle qu'elle était, calcule une empreinte sur ce contenu et sur l'empreinte précédente de la même ligne, écrit le tout dans l'archive, et laisse la modification se faire, le tout dans la même instruction. Si la modification échoue, l'entrée d'archive disparaît avec elle.

Le déclencheur, pour la table des patients
PERFORM pg_advisory_xact_lock((8::bigint << 48) | OLD.id);
SELECT content_hash INTO previous_hash FROM patient_archive
    WHERE source_id = OLD.id ORDER BY archived_at DESC LIMIT 1;
INSERT INTO patient_archive (source_id, name, gender, photo, marital_status, version, active,
        content_hash)
VALUES (OLD.id, OLD.name, OLD.gender, OLD.photo, OLD.marital_status, OLD.version, OLD.active,
        encode(digest(COALESCE(previous_hash, '') || '|' || to_jsonb(OLD)::text, 'sha256'), 'hex'));
RETURN NEW;

Ce qui est haché

Toute la ligne sortante, sérialisée par la base en JSON, après l'empreinte précédente de cette ligne et un séparateur, par SHA-256. La sérialisation est déterministe, ce qui permet à chacun de recalculer plus tard une empreinte à partir des colonnes archivées. Le commentaire du code dit que le JSON garde les colonnes dans l'ordre de la table ; en réalité, PostgreSQL ordonne les clés de ce type de JSON par longueur, puis par ordre alphabétique. Le résultat est tout aussi déterministe, mais un vérificateur écrit d'après le commentaire échouerait.

Comment c'est chaîné

Une chaîne par ligne, partant d'une empreinte précédente vide : chaque version du dossier d'un patient pointe vers la version d'avant. Modifier une version archivée change son empreinte, et toutes les empreintes suivantes de cette ligne cessent de concorder.

Quand la table change de forme

Quand une colonne a été ajoutée au catalogue d'actions puis retirée, l'archive l'a gardée, si bien que l'historique est resté complet, et les migrations disent en quoi le JSON haché diffère avant et après chaque changement. Un vérificateur devra reconstruire chaque version avec les colonnes de son époque.

Qui peut écrire où

Trois rôles de base de données interviennent. Le rôle propre de l'application peut insérer, modifier et lire les tables de données, et seulement lire les archives. L'identifiant de l'outil de configuration peut insérer et modifier les tables de configuration et les restrictions déployées, et ne peut pas lire les patients du tout. Aucun des deux n'a le droit de supprimer quoi que ce soit. L'archive est écrite par le déclencheur, qui s'exécute avec les droits d'un troisième rôle, propriétaire des tables. Chacun de ces points a été vérifié en l'essayant : une suppression ou une modification d'archive par l'un ou l'autre rôle d'écriture est refusée par la base.

Que se passe-t-il quand deux personnes écrivent en même temps ?

Deux sessions qui modifient la même ligne sont sérialisées deux fois : par le verrou de ligne que prend toute modification, et par un verrou pris dans le déclencheur, dont la clé combine la table et la ligne. Essayé avec deux sessions, la seconde a attendu que la première valide, a archivé la version que la première avait écrite, et la chaîne s'est vérifiée de bout en bout. L'application refuse aussi un enregistrement fait sur une version qui a changé entre-temps, si bien que la seconde personne serait prévenue, et rien ne serait écrasé en silence.

La clé de ce verrou comporte une erreur. Chaque table y a un numéro, et la table des patients et le catalogue d'actions utilisent tous deux le 8, alors que la migration de la table des patients note le 8 comme le prochain numéro libre. Une modification du patient 42 et une autre de l'entrée 42 du catalogue s'attendent donc l'une l'autre. La chaîne n'en est pas affectée ; c'est un petit coût, et une convention gardée dans un commentaire que rien ne vérifiait.

L'anomalie : plusieurs modifications dans une transaction

Le déclencheur trouve l'empreinte précédente en prenant l'entrée d'archive la plus récente de la ligne, ordonnée par son horodatage. Cet horodatage est le début de la transaction, si bien que toutes les entrées écrites dans une même transaction portent le même, et que leur ordre n'est pas défini. Essayé avec quatre modifications d'un patient dans une seule transaction : la deuxième entrée s'est chaînée correctement, et la troisième et la quatrième se sont toutes deux chaînées à la première. L'historique bifurque alors, et une entrée d'une branche pourrait être modifiée ou retirée sans briser les empreintes de l'autre.

Rien dans le code actuel n'est connu pour modifier une ligne trois fois dans une transaction ; l'enregistrement d'un agent administratif modifie un dossier une fois. Le seul test de la chaîne fait deux modifications, chacune dans sa propre transaction, et les relit dans le même ordre d'horodatage, si bien qu'il ne pouvait pas voir cela. Le correctif tient en une ligne par déclencheur : ordonner par l'identifiant propre de l'entrée d'archive, qui ne fait que croître. Il est consigné comme OPEN-110, avec un test qui fait plusieurs modifications dans une transaction.

Qui vérifie la chaîne, et qui pourrait la réécrire ?

Rien ne la vérifie

Le module de contrôle d'accès a une fonction qui vérifie sa propre chaîne d'audit ; le dispositif n'en a pas, et le seul code qui recalcule les empreintes du dispositif est ce test. Une modification de l'historique se verrait pour quiconque recalculerait la chaîne, mais rien ne le fait. Un vérificateur, exécuté selon un calendrier et à chaque déploiement, est la pièce manquante. Il est consigné comme OPEN-111.

Le propriétaire des tables pourrait la réécrire

Le rôle propriétaire des tables, et tout superutilisateur de la base, peut modifier l'archive et recalculer toutes les empreintes qui suivent. La chaîne protège contre les rôles qu'utilise l'application. Contre un administrateur, il lui faut une clé que la base ne détient pas, et la dernière empreinte de chaque chaîne exportée selon un calendrier vers un stockage que l'administrateur de la base ne peut pas modifier. C'est une décision de conception encore à prendre, avec l'informatique de l'hôpital, et elle est consignée comme OPEN-112, à côté d'OPEN-91 pour la même lacune dans le journal d'audit du module de contrôle d'accès.

Que cela coûte-t-il ?

Mesuré sur un ordinateur portable, dans un conteneur : modifier 10 000 lignes de patients a pris environ 1,45 seconde avec le déclencheur et environ 0,08 seconde sur une table identique sans lui, soit environ 0,14 milliseconde de plus par ligne. Une modification seule a pris 0,45 milliseconde, dont 0,29 dans le déclencheur. Pour un agent qui enregistre un dossier, c'est imperceptible. Pour un chargement massif de centaines de milliers de lignes, ce serait des minutes, et cela vaudrait d'être prévu.

Qu'est-ce que j'ai appris ?

Ce qu'ont apporté Claude et BMAD se voit dans le mécanisme lui-même. Il a été spécifié une seule fois, dans l'architecture, et Claude l'a appliqué à onze tables de la même manière, avec les détails qu'un relecteur cherche : le déclencheur exécuté avec les droits du propriétaire et un chemin de recherche figé, aucune suppression accordée à qui que ce soit, l'historique conservé quand les colonnes changent. Et la revue qui a trouvé ses faiblesses a pris une séance, sur une base jetable.

Sur la méthode, chaque constat montre comment le travail a été fait :

Constat Ce qu'il dit de la méthode
L'historique que l'article disait d'abord infalsifiable ne l'est que face aux rôles propres de l'application La décision d'architecture énumère ce que la chaîne empêche, la perte d'historique et les accès concurrents parmi d'autres, et ne nomme personne contre qui elle protège, si bien que personne n'a vérifié le cas de l'administrateur
Le contrôle a été construit sans son vérificateur L'architecture prévoyait « une future tâche de vérification », et rien ne l'a planifiée : un contrôle et sa vérification n'ont pas été spécifiés ensemble
La bifurcation dans une transaction est passée inaperçue Le seul test faisait une modification par transaction, et lisait la chaîne dans l'ordre qui masque la bifurcation
Deux tables partagent un numéro de verrou qu'un commentaire déclarait libre Une convention vivait dans un commentaire, sans rien pour la vérifier

Que changerais-je ?

Les corrections sont consignées comme OPEN-110 à OPEN-112. Les améliorations de la méthode ci-dessous changeraient la façon dont chaque contrôle suivant est construit. Chacune est une proposition, classée selon le bénéfice que j'en attends, avec la mesure qu'une vérification ultérieure lirait.

Rang Amélioration Pourquoi à ce rang Mesure
1 Chaque contrôle de sécurité de l'architecture dit contre qui il protège, et contre qui il ne protège pas Cela aurait montré la lacune de l'administrateur dès la conception, pour chaque contrôle Contrôles avec une menace énoncée, rapportés aux contrôles recensés
2 Un contrôle est spécifié avec sa vérification, et les deux sont livrés ensemble Tant que rien ne recalcule la chaîne, une modification de l'historique passe inaperçue Contrôles dont la vérification s'exécute
3 Les tests d'un contrôle incluent le cas fait pour le casser : plusieurs écritures dans une transaction, deux sessions, un administrateur La bifurcation et l'ancrage se seraient tous deux montrés dans les tests Cas de rupture par contrôle
4 Les numéros et les noms qui doivent rester uniques sont attribués en un seul endroit, et le build les vérifie Peu coûteux, et cela supprime une catégorie d'erreurs Doublons trouvés par le build

Où cela laisse-t-il le projet ?

Le projet en est à un jalon, et le mécanisme avec lui. Il fait ce que dit le chapitre 03 pour les cas que le produit rencontre aujourd'hui : chaque modification conserve la version précédente dans la même instruction, les rôles d'écriture ne peuvent ni supprimer ni modifier l'historique, et deux personnes qui écrivent en même temps sont sérialisées. Contre un administrateur, il ne protège encore de rien, et c'est pourquoi l'article parle d'un historique chaîné par empreintes. Devant, les trois points ouverts et ces quatre propositions, et aucun n'a encore de date. Une version ultérieure de cette annexe dira ce qui a été fait.