Skip to content

scellement

diapason.mesh.scellement

Sceller ce qu'une commande DIT, sans toucher à ce qui la route.

26 août 2026. Les enveloppes de commande étaient signées mais pas chiffrées : personne ne pouvait en fabriquer une sans la clé privée, mais quiconque était sur le même Wi-Fi lisait le verbe et ses arguments — titres de notification, adresses ouvertes, noms de fichiers. Sur la loopback c'était sans objet ; le maillage a été ouvert au réseau le jour même.

Aucun champ nouveau sur le fil. Le triplet tool / arguments / requiresConfirmation est remplacé par une sentinelle et un blob, dans les champs qui existent déjà. C'est tout le mécanisme, et ce n'est pas un raffinement : un champ ajouté au niveau supérieur ne serait pas reproduit par RemoteCommand.from_dict, qui lit une liste fixe de clés — le récepteur réémettrait donc une enveloppe amputée et la signature tomberait. Ici il n'y a rien à arracher.

Une SECONDE paire X25519 statique, jamais une conversion. L'en-tête de coffre.py refuse de convertir Ed25519 → X25519, pour deux raisons qui tiennent : la conversion n'existe pas dans cryptography, l'écrire serait de l'arithmétique de corps à la main — la cryptographie maison qu'interdit le §40 ; et détourner une clé de signature pour de l'accord de clé se paie. On ne convertit rien : on génère. Une clé, un usage.

Statique et non éphémère, et c'est un prix assumé. Une commande est POUSSÉE : un pair endormi ne peut pas fournir de moitié éphémère, et une commande attend jusqu'à QUEUED_TTL_MS (six heures) dans la file. Un design éphémère laisserait donc partir en clair, en silence, précisément le chemin qui compte. Le prix : plus de confidentialité persistante côté destinataire — qui archive le trafic puis vole seal_key déchiffre rétroactivement. Atténué côté émetteur, dont la moitié reste éphémère, et relativisé par le fait que ce voleur tient aussi la clé Ed25519 et la base du maillage.

Sceller PUIS signer. La signature reste la créance et doit rester vérifiable SANS la clé de déchiffrement : un pair révoqué, une enveloppe expirée ou mal adressée sont refusés sur l'identité avant qu'un octet de chiffré ne soit touché — un inconnu du réseau ne peut pas nous faire calculer un X25519 par paquet.

Ce que ce module NE protège pas est écrit dans docs/spatial-mesh/, et la première ligne de cette liste mérite d'être répétée ici : le client mobile ne publie aucune clé, donc rien ne lui est scellé. L'exclusion est structurelle — on ne scelle que vers un pair dont on DÉTIENT une clé fraîche — et non une règle qu'il faudrait penser à respecter.

ScellementExige

Bases: RuntimeError

Le réglage exige le chiffrement et ce pair n'a pas de clé fraîche.

Une exception plutôt qu'un None de plus : sous exige, partir en clair serait exactement la panne silencieuse que ce réglage veut empêcher. L'appelant doit avoir à s'en occuper, pas à y penser.

bloc_sceau()

La clé publique de cette machine, signée par son identité.

Ce bloc s'attache à des corps de RÉPONSE qui circulent déjà — celui de /v1/mesh/presence, celui du jumelage — plutôt qu'à une route neuve. Une route de plus coûterait une porte au mur du réseau, un seau de limitation, une régénération d'instantané de contrat, et rendrait faux trois commentaires qui comptent les dix portes. Un corps de réponse ne coûte rien de tout cela.

Il n'est JAMAIS servi à un inconnu : la route qui le porte refuse en 403 avant de répondre quoi que ce soit. Ce dépôt vient de colmater une fuite d'identifiant sur une route ouverte — la remarque n'est pas théorique.

contenu_scelle(tool, arguments, requires_confirmation, *, cle_pair_b64, command_id, associe)

Le triplet, chiffré vers un pair, prêt à occuper arguments.

Le sel de dérivation est command_id — neuf à chaque commande — donc la clé AES est neuve elle aussi, ce qui rend sûr le nonce constant de coffre. Deux garanties indépendantes de fraîcheur : le sel ET la moitié éphémère.

desceller_commande(command)

La commande rouverte, ses champs portant de nouveau le clair.

_extra["scelle"] conserve ce qui a été signé, pour que to_dict réémette l'enveloppe exacte : celle que le récepteur range dans sa file doit encore vérifier sa propre signature.

doit_sceller(device, *, registry=None, maintenant_ms=None)

La clé vers laquelle sceller — ou None pour partir en clair.

LE point de décision, et le seul. Il ne lit QUE trois choses : le réglage, le registre, et l'horloge. Jamais un corps de réponse.

C'est la correction la plus importante du plan. La première version rendait obligatoire une rétrogradation vers le clair quand le pair répondait « je ne connais pas cet outil » — mais cette réponse est un corps HTTP NON SIGNÉ. Un paquet forgé suffisait alors à éteindre le chiffrement, commande par commande, et de façon persistante. Un chiffrement qu'un attaquant coupe à volonté est pire que pas de chiffrement, parce qu'on croit l'avoir.

Le seul repli est donc l'expiration d'un fait SIGNÉ : la clé d'un pair vue il y a plus de FRAICHEUR_MS ne s'emploie plus. Un attaquant qui supprime les publications doit tenir sept jours, pas une seconde — une usure, pas un interrupteur. Et le repli se voit, au lieu de se taire.

entete_de_routage(command)

Les octets qui collent un sceau à SON enveloppe.

Construits depuis les CHAMPS de l'objet, jamais depuis son dictionnaire : confirmationId est conditionnel dans to_dict mais toujours présent dans la dataclasse. Les deux côtés doivent calculer les mêmes octets, et « parfois absent » n'est pas la même chose que « vide ».

Ce qui est ici est authentifié sans être chiffré : déplacer le blob vers une autre commande casse le tag avant même que la signature ait son mot à dire.

etat_de_chiffrement(device, *, registry=None)

Ce qui arrivera VRAIMENT à la prochaine commande vers ce pair.

Calculé à chaque lecture, jamais stocké : une colonne dirait ce qui a été décidé un jour, pas ce qui se passera tout à l'heure.

CINQ réponses, et il en faut cinq. La première version n'en avait que trois et rangeait sous « CLAIR » des situations opposées : un pair qui ne publie pas de clé, un chiffrement désactivé localement, et un pair auquel plus RIEN n'est envoyé. Le commentaire du code avouait lui-même « CLAIR serait faux, et rassurant à tort » — deux lignes avant de rendre « CLAIR ». Constaté le 26 août 2026.

  • SCELLE : une clé fraîche est détenue, la commande partira chiffrée.
  • CLAIR : aucune clé fraîche. La commande partira lisible par quiconque écoute — c'est le seul état qui décrit une fuite réelle.
  • DESACTIVE : le réglage local vaut « jamais ». Le pair publie peut-être une clé ; c'est nous qui refusons de nous en servir. Envoyer quelqu'un vérifier la machine d'en face serait l'envoyer au mauvais endroit.
  • BLOQUE : le réglage vaut « exige » et ce pair n'a pas de clé. Rien ne lui est envoyé du tout — dire « CLAIR » décrirait un trafic qui n'existe pas.
  • INCONNU : on n'a pas pu le déterminer.

C'est la moitié VISIBLE du repli. Un repli qu'on ne voit pas est celui qu'on ne corrige jamais — mais un repli mal nommé envoie le chercher ailleurs, ce qui n'est pas mieux.

kid(publique)

Huit hexadécimaux qui désignent une clé sans la révéler.

Le destinataire s'en sert pour choisir entre sa clé courante et la précédente, sans essayer les deux à l'aveugle.

lire_bloc_sceau(corps, *, registry=None, pair_attendu='')

Enregistrer la clé qu'un pair vient de publier. NE LÈVE JAMAIS.

Appelée depuis announce_to, qui promet de ne jamais lever : une annonce qui n'aboutit pas n'est pas une erreur que l'utilisateur doive entendre. Un corps malformé ne doit donc pas remonter d'ici.

Le contrôle qui compte : la clé est rangée sous le device_id que verify_payload RETOURNE, et l'on vérifie qu'il vaut bien celui qu'on interrogeait. Sans cela, un sceau capté chez A et recollé dans une réponse de B écrirait la clé de A dans la ligne de B — et l'on scellerait ensuite vers A ce qui était destiné à B.

mode_de_chiffrement()

Ce que la configuration demande. « opportuniste » à défaut.

oublier_locale()

Effacer les deux clés. Le prochain appel en frappera une neuve.

ouvrir_contenu(scelle, *, command_id, associe)

Rouvrir un triplet scellé, avec la clé courante ou la précédente.

Le kid désigne laquelle : sans lui, il faudrait les essayer à l'aveugle et un échec ne dirait pas s'il vient de la clé ou du contenu.

paire_locale()

La paire de scellement de CETTE machine, créée au premier appel.

Écrite par le chemin durci d'identity — dossier 0700, fichier 0600, O_EXCL, O_NOFOLLOW — et non par une copie de ce durcissement : deux copies divergent.

paire_precedente()

La paire d'avant un renouvellement — TANT QU'ELLE EST CONSERVÉE.

Cette dernière proposition n'était qu'une phrase : RETENTION_PRECEDENTE_MS était déclarée, exportée, documentée comme un invariant… et lue par aucun code. La clé précédente survivait en réalité jusqu'au renouvellement SUIVANT — une minute ou dix ans — pendant que l'aide de la commande promettait sept jours à l'utilisateur. Constaté le 26 août 2026, dans du code écrit le jour même.

Et ce n'est pas qu'une question d'exactitude : renouveler existe pour fermer la fenêtre de déchiffrement rétroactif. Une clé précédente qui vit indéfiniment ne la ferme qu'à moitié.

La date du fichier fait foi — elle est posée par le renommage, sans fichier supplémentaire à tenir d'accord avec elle.

renouveler()

Frapper une clé neuve, en gardant la précédente déchiffrable.

Geste EXPLICITE, jamais automatique : une rotation périodique n'achèterait rien qu'une clé statique n'ait déjà perdu, et créerait une panne différée — un kid périmé refusé des heures après coup.

sceller_commande(command, cle_pair_b64)

La même commande, dont le triplet part chiffré.

Les champs de l'objet gardent le CLAIR ; _extra["scelle"] porte ce qui voyagera. C'est l'invariant décrit au-dessus de to_dict.