Authority Proof

Authority Proof est une fonctionnalité du moteur Authority. Elle signe l’affirmation qu’un événement figure dans un journal, et permet à quiconque détient les bons fichiers de vérifier cette affirmation hors ligne. Ce n’est pas une preuve automatique que des événements ont eu lieu ni qu’une action a été exécutée.

État : Expérimental · V1 en construction. Aucune revue ni aucun audit indépendants. Rédigé d’après le commit 397ba8c d’authority-graph ; le code source reste la référence.

Ce qu’est une attestation

Une attestation (authority-attestation/v1) est un document JSON signé en Ed25519. Elle dit : le détenteur de la clé K affirme que cet événement CAPABILITY_ISSUED ou CAPABILITY_REDEEMED figure dans le journal dont la tête de chaîne est H, et que le validateur d’Authority l’a accepté au moment où l’attestation a été construite.

Ce n’est pas une preuve que la décision était juste, que les événements du journal sont vrais ou complets, que le signataire est bien celui que l’on croit, ni qu’un effet a eu lieu.

Ce qu’elle contient

  • proof_version et kind : ISSUANCE ou REDEMPTION.
  • engine : un identifiant fixe avec les versions du protocole et du schéma d’événements. Ce n’est pas une version logicielle.
  • statement : l’événement (séquence, identifiant, instant d’autorité), la capacité, l’action et son empreinte, le principal, la séquence de décision et le point d’application. Une émission porte aussi la chaîne accordée et l’expiration.
  • journal : le schéma authority-journal-chain/v1, la séquence de tête et le hachage de tête.
  • signature : Ed25519, un key_id et la signature elle-même.

Chaque objet est fermé : un membre inconnu, à n’importe quel niveau, est une erreur. principal_id est l’identité affirmée par l’appelant, pas une identité vérifiée.

Comment elle est signée

bytes = utf8("authority-attestation/v1\n") || utf8( JCS( attestation with signature = { alg, key_id } ) )

JCS est la RFC 8785. Tout est signé sauf signature.sig, et le préfixe sépare cet usage de tout autre. Les signatures sont des Ed25519 calculées via node:crypto.

key_id est la forme base64url du SHA-256 de la clé publique brute. Il désigne une clé, pas une personne, un service ni une organisation. Les clés auxquelles se fier sont choisies par le vérificateur dans un fichier de clés de confiance ; une attestation n’y ajoute jamais de clé. Les clés sont uniquement des JWK Ed25519.

La chaîne de hachage du journal

digest_i = SHA-256( "authority-journal-event/v1\n" || JCS(event_i) )
h_0      = SHA-256( "authority-journal-chain/v1" )
h_i      = SHA-256( h_{i-1} || digest_i )

La tête dit que cette suite exacte d’événements produit cette valeur. Elle ne dit pas que les événements sont vrais, que le journal est complet, ni qu’aucun autre journal n’existe avec une histoire différente.

Niveaux de vérification L0 à L3

Ce que vérifie chaque niveau
NiveauCe qu’il vérifieMot de résultat
L0 formeJSON strict (pas de clé dupliquée, entiers exacts seulement, taille et profondeur bornées), schéma fermé, encodages canoniques, et un énoncé cohérent avec lui-même.aucun ; un échec est REJECTED
L1 signatureUn algorithme fixe, un key_id parmi les clés de confiance du vérificateur, la fenêtre et la révocation de la clé, et la signature Ed25519 de l’entrée de signature.CONSISTENT_L1
L2 contexteL’attestation correspond au contexte attendu par le vérificateur : nature, capacité, action, empreinte, principal, point d’application, tête du journal. Un contexte attendu vide est refusé, jamais accepté par défaut.CONSISTENT_L2
L3 rejeuRejoue le journal que vous fournissez avec les validateurs du moteur, vérifie qu’il produit la tête attestée, redérive l’énoncé et revalide la décision. Il ne s’exécute jamais si L1 ou L2 a échoué.CONSISTENT_L3

Un échec à un niveau laisse les niveaux suivants à NOT_CHECKED. Il n’existe pas de simple « valide » : le résultat global est REJECTED ou l’un des mots CONSISTENT_L*, et chaque résultat liste ce qu’il n’établit pas. Une clé révoquée ALWAYS, ou hors de sa fenêtre, reste rejetée : L3 n’est jamais utilisé pour la sauver.

Vérifier par soi-même

Il faut un clone du dépôt et Node.js 20 ou 22. L’installation des dépendances demande un réseau.

git clone https://github.com/theoadam2506-rgb/authority-graph.git
cd authority-graph && npm ci

Vérifiez ensuite l’attestation de rédemption publiée par rapport au journal et à la clé de confiance publiés :

npm run authority -- proof verify proof/vectors/redemption.json \
  --keys proof/vectors/trusted-keys.json \
  --journal proof/vectors/journals/journal.json

La commande affiche result: CONSISTENT_L3, les niveaux (L0 PASS | L1 PASS | L2 NOT_CHECKED | L3 PASS), chaque contrôle, la portée (FULL_JOURNAL), anchored: NO, et la liste intitulée « NOT ESTABLISHED by this result ». Codes de sortie : 0 cohérent, 1 rejeté, 2 entrée illisible, 64 usage. Nous avons lancé cette commande sans aucun accès réseau, sous Linux avec Node.js 22, après l’installation des dépendances.

Pour vérifier aussi un contexte attendu (L2 passe alors de NOT_CHECKED à PASS) :

npm run authority -- proof verify proof/vectors/redemption.json \
  --keys proof/vectors/trusted-keys.json \
  --journal proof/vectors/journals/journal.json \
  --expect-kind REDEMPTION --expect-capability-id cap-proof-1 \
  --expect-enforcement-point ep-proof-1

Pour fournir une ancre, une liste de têtes que vous avez choisi de croire :

npm run authority -- proof verify proof/vectors/redemption.json \
  --keys proof/vectors/trusted-keys.json \
  --journal proof/vectors/journals/journal.json \
  --trusted-heads proof/vectors/trusted-heads.json

Le rapport indique alors anchored: YES, et sur la même ligne independence NOT_ESTABLISHED : l’outil ne peut pas savoir d’où vient votre ancre. Pour voir seule la tête de chaîne d’un journal :

npm run authority -- proof head proof/vectors/journals/journal.json

Vecteurs de test

proof/vectors/ contient une clé de test fixe, un fichier de clés de confiance, un journal de cinq événements avec sa tête après chaque préfixe, une attestation d’émission et une attestation de rédemption authentiques, les entrées de signature exactes, et 15 cas négatifs avec le contrôle qui doit échouer. npm run proof:vectors les régénère et la suite de tests échoue s’ils dérivent. La clé de test est celle de la RFC 8032 : sa moitié privée est publique, elle ne protège donc rien et ne doit jamais être crue pour une vraie attestation.

Deux cas négatifs, tels que nous les avons lancés : le document dont un bit de signature a été modifié est REJECTED à L1 ; validly-signed-lie, un énoncé signé par la clé de confiance mais que le journal ne soutient pas, passe L1 et est REJECTED à L3.HEAD.

La suite de tests du projet exécute aussi des cas de test d’interopérabilité : les entrées de signature sont vérifiées avec OpenSSL, et la chaîne du journal, l’identifiant de clé et les entrées de signature sont recalculés avec la bibliothèque standard de Python, sans aucun code partagé avec le dépôt. Ce sont nos propres tests, pas une validation indépendante.

Ce que signifie CONSISTENT_L3

Cela signifie que l’énoncé a été signé par une clé à laquelle vous faites confiance, que le journal fourni se rejoue selon les règles du moteur, que ses premiers événements produisent la tête attestée, que l’énoncé signé est égal à ce que le moteur en déduit, et que le validateur du moteur accepte la décision sur ce préfixe.

Cela ne signifie pas qu’une action réelle a été exécutée, que les événements ont réellement eu lieu, que le journal est complet, ni qu’aucune autre histoire n’existe. Un journal fabriqué de façon cohérente, avec une attestation signée par une clé de confiance, passe. Sans ancre, le rapport le dit exactement.

Ce qui n’est pas établi

  • L’authenticité des événements du journal : ils sont affirmés et non authentifiés. L’identité d’un principal n’est pas vérifiée.
  • La complétude du journal : un journal tronqué, ramené à un état plus ancien, ou dont un événement (une révocation, par exemple) a été omis, est invisible sans un témoin extérieur à Authority Proof.
  • L’indépendance d’une ancre : une ancre est choisie par le vérificateur, rapportée comme SUPPLIED_BY_VERIFIER, et son indépendance est NOT_ESTABLISHED.
  • L’identité du signataire : une clé désigne une clé. L’instant de signature est une déclaration du signataire, et les fenêtres de clé et la révocation sont évaluées sur cet instant déclaré.
  • L’équivocation : un signataire détenant deux journaux incompatibles peut signer des attestations contre chacun, et chacune est cohérente en interne.
  • La non-répudiation, l’horodatage de confiance et la certification ne sont pas fournis, et aucune conformité à JWS, COSE ou WIMSE n’est revendiquée.
  • Qu’un effet a eu lieu, ou a eu lieu une seule fois.

Une clé volée peut signer aujourd’hui un énoncé qui prétend à un instant antérieur. revoked_from: "ALWAYS" rejette tout ce que cette clé a signé, y compris les attestations passées authentiques. La commande corroborate, destinée à aider à les départager, est différée et non disponible.

Le rejeu est borné

Le coût du rejeu croît plus vite que linéairement avec le nombre d’événements. Le plafond par défaut est de 10 000 événements (--max-events le modifie) ; un journal plus grand est refusé, pas tronqué. Mesuré une fois sur une machine de développement avec un journal synthétique, 10 000 événements ont demandé environ 7 secondes de bout en bout et 277 Mo au pic. Lisez les rapports, pas les valeurs absolues.

État de la revue

Authority Proof n’a pas fait l’objet d’une revue indépendante. Une revue cryptographique indépendante est préparée et n’a pas commencé. Aucune garantie de sécurité n’est revendiquée.

Sources au commit épinglé