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.