NewbieToNode
Créateur vérifié
Planting tokens 🌱 Waiting for sun 🌞 Watering with hope 💧 Soft degen vibes only
Trade régulièrement
4 an(s)
142 Suivis
32.4K+ Abonnés
25K J’aime
2.2K+ Partagé(s)
Publications
Tous
Citations
Vidéos
Direct
SIGN et le certificat qui pourrait être révoqué par la mauvaise entité
Je regardais un certificat ce matin pour voir comment il se comporterait après l'émission.
Pas si cela a été vérifié.
Cette partie était déjà faite.
Cela avait passé.
schemaId correspondait.
l'attesteur a été vérifié.
attestTimestamp était récent.
Tout à son sujet semblait propre.
Ce que je voulais voir, c'était ce qui se passe après cela.
Alors j'ai essayé de le révoquer.
Rien n'a changé.
Pas d'erreur.
Pas de rejet.
Le certificat est resté valide.
Pendant un instant, j'ai supposé que j'avais appelé le mauvais chemin.
Ou j'ai frappé la mauvaise adresse.
Alors j'ai vérifié où se trouve réellement l'autorité de révocation.
Pas si cela a été vérifié.
Cette partie était déjà faite.
Cela avait passé.
schemaId correspondait.
l'attesteur a été vérifié.
attestTimestamp était récent.
Tout à son sujet semblait propre.
Ce que je voulais voir, c'était ce qui se passe après cela.
Alors j'ai essayé de le révoquer.
Rien n'a changé.
Pas d'erreur.
Pas de rejet.
Le certificat est resté valide.
Pendant un instant, j'ai supposé que j'avais appelé le mauvais chemin.
Ou j'ai frappé la mauvaise adresse.
Alors j'ai vérifié où se trouve réellement l'autorité de révocation.
@SignOfficial
Je décodais une attestation par rapport à son schéma ce matin quand quelque chose ne correspondait pas.
Le schéma semblait propre.
Les champs avaient du sens.
Puis j'ai extrait l'attestation.
Les données ne suivaient pas.
Pas lâchement.
Pas même proche.
Je pensais avoir raté le décodage.
Je l'ai relancé.
Même octets.
Rien n'a changé.
Toujours vérifié.
Pas d'erreur.
Pas de rejet.
Rien n'indiquant même que quelque chose n'allait pas.
C'est là que ça a commencé à ne pas avoir de sens.
Le schéma disait une chose.
Les données en faisaient une autre.
Et le système s'en fichait.
J'ai essayé un autre.
Émetteur différent.
Même motif.
schemaId tient.
Attestation.data dérive.
Passe toujours.
Je suis resté dessus plus longtemps que prévu.
Parce que j'avais l'impression de manquer une règle quelque part.
Mais il n'y en avait pas.
C'est là que ça a cliqué.
Fantôme de schéma.
La vérification n'est pas entre le schéma et les données.
C'est entre l'existence et la référence.
Ça pointe.
C'est suffisant.
La structure apparaît.
Qu'elle soit suivie ou non... cela n'a pas d'importance.
Une attestation qui semble structurée de l'extérieur...
mais qui n'est pas tenue en dessous.
Le schéma est là.
Mais il ne fait rien.
Et une fois que cela se produit...
cela cesse d'être une règle.
Cela devient juste une étiquette.
$SIGN n'a d'importance que si Attestation.data est réellement validée par rapport à Schema.schema au moment de la vérification...
pas juste attachée à lui par référence.
Parce que si les attestations peuvent s'éloigner des structures qu'elles prétendent suivre...
la vérification commence à sembler correcte...
sans réellement être correcte.
Donc, la vraie question devient celle-ci.
Si le respect du schéma n'est pas requis pour passer...
que signifie exactement "valide" ici ?
#SignDigitalSovereignInfra #Sign
Je décodais une attestation par rapport à son schéma ce matin quand quelque chose ne correspondait pas.
Le schéma semblait propre.
Les champs avaient du sens.
Puis j'ai extrait l'attestation.
Les données ne suivaient pas.
Pas lâchement.
Pas même proche.
Je pensais avoir raté le décodage.
Je l'ai relancé.
Même octets.
Rien n'a changé.
Toujours vérifié.
Pas d'erreur.
Pas de rejet.
Rien n'indiquant même que quelque chose n'allait pas.
C'est là que ça a commencé à ne pas avoir de sens.
Le schéma disait une chose.
Les données en faisaient une autre.
Et le système s'en fichait.
J'ai essayé un autre.
Émetteur différent.
Même motif.
schemaId tient.
Attestation.data dérive.
Passe toujours.
Je suis resté dessus plus longtemps que prévu.
Parce que j'avais l'impression de manquer une règle quelque part.
Mais il n'y en avait pas.
C'est là que ça a cliqué.
Fantôme de schéma.
La vérification n'est pas entre le schéma et les données.
C'est entre l'existence et la référence.
Ça pointe.
C'est suffisant.
La structure apparaît.
Qu'elle soit suivie ou non... cela n'a pas d'importance.
Une attestation qui semble structurée de l'extérieur...
mais qui n'est pas tenue en dessous.
Le schéma est là.
Mais il ne fait rien.
Et une fois que cela se produit...
cela cesse d'être une règle.
Cela devient juste une étiquette.
$SIGN n'a d'importance que si Attestation.data est réellement validée par rapport à Schema.schema au moment de la vérification...
pas juste attachée à lui par référence.
Parce que si les attestations peuvent s'éloigner des structures qu'elles prétendent suivre...
la vérification commence à sembler correcte...
sans réellement être correcte.
Donc, la vraie question devient celle-ci.
Si le respect du schéma n'est pas requis pour passer...
que signifie exactement "valide" ici ?
#SignDigitalSovereignInfra #Sign
SIGN et la revendication qui a perdu la raison pour laquelle elle était vraie
@SignOfficial
J'étais plongé dans un flux de vérification cet après-midi lorsque un certificat a continué à passer d'une manière qui ne semblait pas complète.
Tout a été vérifié.
Émetteur.
Schéma.
Horodatage.
Rien n'a échoué.
Cela ne semblait toujours pas correct.
Alors j'ai essayé de le retracer.
J'ai commencé avec l'attesteur.
Alors attestezTimestamp.
Alors peu importe ce qui est venu avant.
Il n'y avait rien là-dedans.
Je pensais avoir sauté quelque chose d'évident.
Je l'ai vérifié à nouveau.
Même résultat.
Allé directement à linkedAttestationId.
Cela pointait en arrière.
Celui-là a aussi réussi.
Je l'ai suivi à nouveau et je me suis arrêté à mi-chemin.
J'étais plongé dans un flux de vérification cet après-midi lorsque un certificat a continué à passer d'une manière qui ne semblait pas complète.
Tout a été vérifié.
Émetteur.
Schéma.
Horodatage.
Rien n'a échoué.
Cela ne semblait toujours pas correct.
Alors j'ai essayé de le retracer.
J'ai commencé avec l'attesteur.
Alors attestezTimestamp.
Alors peu importe ce qui est venu avant.
Il n'y avait rien là-dedans.
Je pensais avoir sauté quelque chose d'évident.
Je l'ai vérifié à nouveau.
Même résultat.
Allé directement à linkedAttestationId.
Cela pointait en arrière.
Celui-là a aussi réussi.
Je l'ai suivi à nouveau et je me suis arrêté à mi-chemin.
@SignOfficial
Je m'attendais à ce que cette révocation soit acceptée.
Ce ne fut pas le cas.
Pas d'erreur.
Juste... pas de changement.
Même identifiant.
Toujours valide.
Exactement comme si rien n'avait été appelé.
Pendant un instant, j'ai pensé que j'avais touché le mauvais enregistrement.
Je l'ai relancé.
Rien n'a bougé.
Alors j'ai vérifié l'attester.
Correspondant.
Puis j'ai vérifié le schéma.
Adresse différente.
Cela ne me convenait pas.
J'ai essayé à nouveau du côté de l'attester.
Toujours rien.
On aurait dit qu'il n'avait même pas essayé.
Je l'ai changé.
Appelé depuis le côté du schéma.
Cette fois, cela a fonctionné.
C'est là que cela a basculé.
L'attester pouvait l'émettre.
Mais ne pouvait pas l'annuler.
Le registrant pouvait.
J'en ai exécuté un autre.
Identifiant différent.
Même comportement.
Émis à un endroit.
Contrôlé à un autre.
Je suis resté dessus plus longtemps que prévu.
Parce que rien ne faillait.
Tout était juste... ignorant l'appelant erroné.
Je reviens toujours à cela comme une autorité séparée.
L'entité créant l'identifiant...
n'est pas celle qui peut l'arrêter.
De l'extérieur, cela ressemble à un contrôle d'émetteur.
À l'intérieur, le contrôle se trouve ailleurs.
Deux autorités.
Une seule visible lorsque l'identifiant est créé.
$SIGN n'a d'importance que si la même entité qui émet un identifiant est aussi celle qui peut le révoquer lors d'une utilisation réelle...
pas seulement celle qui a défini le schéma sous lequel il vit.
Parce qu'une fois que ces séparations...
la révocation cesse d'être une action.
Et devient une dépendance.
Donc la vraie question devient celle-ci.
Quand quelque chose doit être désactivé rapidement...
qui attendez-vous réellement ?
#SignDigitalSovereignInfra #Sign
Je m'attendais à ce que cette révocation soit acceptée.
Ce ne fut pas le cas.
Pas d'erreur.
Juste... pas de changement.
Même identifiant.
Toujours valide.
Exactement comme si rien n'avait été appelé.
Pendant un instant, j'ai pensé que j'avais touché le mauvais enregistrement.
Je l'ai relancé.
Rien n'a bougé.
Alors j'ai vérifié l'attester.
Correspondant.
Puis j'ai vérifié le schéma.
Adresse différente.
Cela ne me convenait pas.
J'ai essayé à nouveau du côté de l'attester.
Toujours rien.
On aurait dit qu'il n'avait même pas essayé.
Je l'ai changé.
Appelé depuis le côté du schéma.
Cette fois, cela a fonctionné.
C'est là que cela a basculé.
L'attester pouvait l'émettre.
Mais ne pouvait pas l'annuler.
Le registrant pouvait.
J'en ai exécuté un autre.
Identifiant différent.
Même comportement.
Émis à un endroit.
Contrôlé à un autre.
Je suis resté dessus plus longtemps que prévu.
Parce que rien ne faillait.
Tout était juste... ignorant l'appelant erroné.
Je reviens toujours à cela comme une autorité séparée.
L'entité créant l'identifiant...
n'est pas celle qui peut l'arrêter.
De l'extérieur, cela ressemble à un contrôle d'émetteur.
À l'intérieur, le contrôle se trouve ailleurs.
Deux autorités.
Une seule visible lorsque l'identifiant est créé.
$SIGN n'a d'importance que si la même entité qui émet un identifiant est aussi celle qui peut le révoquer lors d'une utilisation réelle...
pas seulement celle qui a défini le schéma sous lequel il vit.
Parce qu'une fois que ces séparations...
la révocation cesse d'être une action.
Et devient une dépendance.
Donc la vraie question devient celle-ci.
Quand quelque chose doit être désactivé rapidement...
qui attendez-vous réellement ?
#SignDigitalSovereignInfra #Sign
@SignOfficial
J'ai vérifié une attestation plus tôt qui est revenue plus courte que ce qui a été soumis.
L'attesteur avait poussé la valeur plus loin.
La certification ne l'a pas fait.
J'ai pensé avoir tiré le mauvais.
Je l'ai relancée.
Même attestation.
Même schemaId.
Toujours plus courte.
Cela ne semblait pas juste.
Alors je suis resté dessus.
Ce qui est entré...
et ce qui est apparu...
n'étaient pas les mêmes.
Rien n'a échoué.
Pas de rejet.
Pas d'avertissement.
Cela s'est résolu proprement.
C'est à ce moment-là que j'ai regardé le schéma à nouveau.
"maxValidFor" était plus bas que ce qui a été soumis.
Il ne rejetait pas l'entrée.
Il la coupait.
J'ai essayé à nouveau.
Attesteur différent.
Même schéma.
Même résultat.
C'est là que ça a fait tilt.
L'attesteur ne définit pas la certification.
Ils négocient avec le schéma.
Et le schéma décide de ce qui survit réellement.
De l'extérieur, cela ressemble à ce que l'attesteur a fixé la valeur.
À l'intérieur, une partie ne passe jamais.
Pas de signal.
Pas de trace.
Juste un état final propre.
Deux soumissions différentes.
Même certification.
Je reviens toujours à cela comme une illusion de contournement de l'attesteur.
On dirait que le contrôle est entre les mains de l'émetteur.
Mais la forme finale est déjà délimitée ailleurs.
$SIGN n'a d'importance que si les contraintes du schéma comme "maxValidFor" ne redessinent pas silencieusement ce qui est soumis...
mais exposent clairement cette limite.
Parce qu'une fois que les entrées sont modifiées sans visibilité...
la source de vérité change.
Et vous ne le voyez pas se produire.
Donc la vraie question devient celle-ci.
Si une partie de l'entrée ne survit jamais au schéma...
qu'est-ce que vous vérifiez exactement ?
#SignDigitalSovereignInfra #Sign
J'ai vérifié une attestation plus tôt qui est revenue plus courte que ce qui a été soumis.
L'attesteur avait poussé la valeur plus loin.
La certification ne l'a pas fait.
J'ai pensé avoir tiré le mauvais.
Je l'ai relancée.
Même attestation.
Même schemaId.
Toujours plus courte.
Cela ne semblait pas juste.
Alors je suis resté dessus.
Ce qui est entré...
et ce qui est apparu...
n'étaient pas les mêmes.
Rien n'a échoué.
Pas de rejet.
Pas d'avertissement.
Cela s'est résolu proprement.
C'est à ce moment-là que j'ai regardé le schéma à nouveau.
"maxValidFor" était plus bas que ce qui a été soumis.
Il ne rejetait pas l'entrée.
Il la coupait.
J'ai essayé à nouveau.
Attesteur différent.
Même schéma.
Même résultat.
C'est là que ça a fait tilt.
L'attesteur ne définit pas la certification.
Ils négocient avec le schéma.
Et le schéma décide de ce qui survit réellement.
De l'extérieur, cela ressemble à ce que l'attesteur a fixé la valeur.
À l'intérieur, une partie ne passe jamais.
Pas de signal.
Pas de trace.
Juste un état final propre.
Deux soumissions différentes.
Même certification.
Je reviens toujours à cela comme une illusion de contournement de l'attesteur.
On dirait que le contrôle est entre les mains de l'émetteur.
Mais la forme finale est déjà délimitée ailleurs.
$SIGN n'a d'importance que si les contraintes du schéma comme "maxValidFor" ne redessinent pas silencieusement ce qui est soumis...
mais exposent clairement cette limite.
Parce qu'une fois que les entrées sont modifiées sans visibilité...
la source de vérité change.
Et vous ne le voyez pas se produire.
Donc la vraie question devient celle-ci.
Si une partie de l'entrée ne survit jamais au schéma...
qu'est-ce que vous vérifiez exactement ?
#SignDigitalSovereignInfra #Sign
L'information d'identification qui a changé sans changer
@SignOfficial
Je vérifiais à nouveau une information d'identification ce matin.
Le même que j'avais vérifié il y a quelques jours.
Je n'attendais rien de différent.
Cela avait passé proprement auparavant.
Je l'ai tiré à nouveau.
Même certificateur.
Même données.
Même référence.
Mais cela ne s'est pas résolu de la même manière.
Pas cassé.
Juste... différent.
Cette partie ne me convenait pas.
Alors j'ai tiré le résultat précédent côte à côte.
Je les ai comparés ligne par ligne.
C'est alors qu'il est apparu.
Les informations d'identification n'avaient pas changé.
Mais quelque chose derrière avait changé.
Je suis retourné au schéma.
Je l'ai tiré directement du registre.
Je vérifiais à nouveau une information d'identification ce matin.
Le même que j'avais vérifié il y a quelques jours.
Je n'attendais rien de différent.
Cela avait passé proprement auparavant.
Je l'ai tiré à nouveau.
Même certificateur.
Même données.
Même référence.
Mais cela ne s'est pas résolu de la même manière.
Pas cassé.
Juste... différent.
Cette partie ne me convenait pas.
Alors j'ai tiré le résultat précédent côte à côte.
Je les ai comparés ligne par ligne.
C'est alors qu'il est apparu.
Les informations d'identification n'avaient pas changé.
Mais quelque chose derrière avait changé.
Je suis retourné au schéma.
Je l'ai tiré directement du registre.
L'identifiant qui a expiré sans changer
@SignOfficial
Je vérifiais un identifiant SIGN plus tôt sur deux réseaux.
Je ne m'attendais à rien d'inhabituel.
Cela a réussi sur le premier.
Propre.
Ensuite, j'ai vérifié les mêmes identifiants sur un autre réseau.
Cela a échoué.
À ce moment-là, je pensais que j'avais manqué quelque chose d'évident.
Je l'ai récupéré à nouveau.
Même résultat.
Cela n'avait pas de sens.
Rien n'avait changé.
Aucune révocation.
Pas de mise à jour.
Même identifiant.
Alors je l'ai ralenti.
Vérifié où cela a été émis.
Alors où cela était-il vérifié.
`validUntil` était toujours dans la plage.
Mais seulement sur le réseau d'où cela provient.
Je vérifiais un identifiant SIGN plus tôt sur deux réseaux.
Je ne m'attendais à rien d'inhabituel.
Cela a réussi sur le premier.
Propre.
Ensuite, j'ai vérifié les mêmes identifiants sur un autre réseau.
Cela a échoué.
À ce moment-là, je pensais que j'avais manqué quelque chose d'évident.
Je l'ai récupéré à nouveau.
Même résultat.
Cela n'avait pas de sens.
Rien n'avait changé.
Aucune révocation.
Pas de mise à jour.
Même identifiant.
Alors je l'ai ralenti.
Vérifié où cela a été émis.
Alors où cela était-il vérifié.
`validUntil` était toujours dans la plage.
Mais seulement sur le réseau d'où cela provient.
@SignOfficial
Je suivais un "linkedAttestationId" plus tôt.
Je m'attendais à ce qu'il se résolve.
Ça ne l’a pas fait.
Je pensais avoir tiré le mauvais.
Je l'ai exécuté à nouveau.
Même ID.
Toujours vide.
Cela n'avait pas de sens.
J'avais l'impression de manquer quelque chose d'évident.
Alors j'ai vérifié le registre directement.
Rien là non plus.
J'ai attendu.
J'ai essayé à nouveau.
Pas de changement.
Mais la crédential...
était correcte.
Elle a été vérifiée proprement.
Pas d'erreurs.
Pas d'avertissements.
C'est là que ça a basculé.
La référence manquait.
La crédential n'était pas.
Alors j'ai essayé une autre.
Attestation différente.
Même modèle.
"linkedAttestationId" défini.
Rien derrière.
Pas de retour.
Pas d'échec.
Pas de signal que quoi que ce soit ne va pas.
C'est à ce moment-là que j'ai arrêté de poursuivre l'enregistrement.
Et j'ai commencé à observer ce qui est réellement vérifié.
Le lien n'entre jamais en jeu.
La vérification ne le suit pas.
N'attend pas qu'il se résolve.
Ne se soucie pas de sa résolution.
La crédential se tient seule.
À quoi elle pointe...
n'est jamais tiré.
C'est là que tout a fait sens.
Ce n'était pas cassé.
C'était ignoré.
Fantôme avant.
Une référence qui existe...
sans jamais avoir besoin de se résoudre.
De l'extérieur...
tout semble complet.
La crédential vérifie.
La structure tient.
Mais la connexion...
n'est pas appliquée.
C'est là que cela devient risqué.
Un système voit le lien...
et suppose la continuité.
Mais rien ne le garantit.
Rien ne le prouve.
Rien ne l'attache.
Deux crédentials peuvent sembler connectés.
Rien ne les lie réellement ensemble.
Et parce que la vérification ne vérifie jamais...
il n'y a aucun signal que quoi que ce soit manque.
$SIGN n'a d'importance que si des références comme "linkedAttestationId" sont nécessaires pour se résoudre...
pas seulement exister.
Parce qu'une fois que les liens n'ont pas besoin de tenir...
la structure cesse de signifier connexion.
Donc la vraie question devient celle-ci.
Si une crédential peut pointer vers l'avant...
sans rien là...
que traite exactement le système comme connecté ?
#SignDigitalSovereignInfra #Sign
Je suivais un "linkedAttestationId" plus tôt.
Je m'attendais à ce qu'il se résolve.
Ça ne l’a pas fait.
Je pensais avoir tiré le mauvais.
Je l'ai exécuté à nouveau.
Même ID.
Toujours vide.
Cela n'avait pas de sens.
J'avais l'impression de manquer quelque chose d'évident.
Alors j'ai vérifié le registre directement.
Rien là non plus.
J'ai attendu.
J'ai essayé à nouveau.
Pas de changement.
Mais la crédential...
était correcte.
Elle a été vérifiée proprement.
Pas d'erreurs.
Pas d'avertissements.
C'est là que ça a basculé.
La référence manquait.
La crédential n'était pas.
Alors j'ai essayé une autre.
Attestation différente.
Même modèle.
"linkedAttestationId" défini.
Rien derrière.
Pas de retour.
Pas d'échec.
Pas de signal que quoi que ce soit ne va pas.
C'est à ce moment-là que j'ai arrêté de poursuivre l'enregistrement.
Et j'ai commencé à observer ce qui est réellement vérifié.
Le lien n'entre jamais en jeu.
La vérification ne le suit pas.
N'attend pas qu'il se résolve.
Ne se soucie pas de sa résolution.
La crédential se tient seule.
À quoi elle pointe...
n'est jamais tiré.
C'est là que tout a fait sens.
Ce n'était pas cassé.
C'était ignoré.
Fantôme avant.
Une référence qui existe...
sans jamais avoir besoin de se résoudre.
De l'extérieur...
tout semble complet.
La crédential vérifie.
La structure tient.
Mais la connexion...
n'est pas appliquée.
C'est là que cela devient risqué.
Un système voit le lien...
et suppose la continuité.
Mais rien ne le garantit.
Rien ne le prouve.
Rien ne l'attache.
Deux crédentials peuvent sembler connectés.
Rien ne les lie réellement ensemble.
Et parce que la vérification ne vérifie jamais...
il n'y a aucun signal que quoi que ce soit manque.
$SIGN n'a d'importance que si des références comme "linkedAttestationId" sont nécessaires pour se résoudre...
pas seulement exister.
Parce qu'une fois que les liens n'ont pas besoin de tenir...
la structure cesse de signifier connexion.
Donc la vraie question devient celle-ci.
Si une crédential peut pointer vers l'avant...
sans rien là...
que traite exactement le système comme connecté ?
#SignDigitalSovereignInfra #Sign
@SignOfficial
Je vérifiais une référence plus tôt.
Je supposais que l'attesteur était la source de vérité.
Puis j'ai regardé le schéma.
Adresse différente.
`registrant` sur le schéma.
`attester` sur la référence.
Pas la même chose.
Cela n'avait pas de sens.
Alors j'en ai tiré un autre.
Puis un autre.
Schémas différents.
Attesteurs différents.
Même séparation.
À ce moment-là, je pensais que je manquais quelque chose.
Un lien entre eux.
Quelque chose reliant l'émetteur aux règles.
Je ne pouvais pas trouver.
La référence venait de l'attesteur.
Mais les règles ne venaient pas.
J'ai retracé plus loin.
Le schéma se trouve là en premier.
Enregistré une fois.
Puis réutilisé.
Encore et encore.
Quiconque émettant sous cela...
ne le définit pas.
C'est là que cela a basculé.
L'attesteur contrôle l'émission.
Le registrant contrôle ce que signifie même l'émission.
Deux autorités différentes.
Aucune frontière visible entre elles.
Vous lisez la référence et faites confiance à l'attesteur...
mais ils n'ont pas décidé des règles derrière cela.
Et rien dans le flux ne vous le dit.
Cela semble juste valide.
C'est là que cela commence à devenir inconfortable.
Si le schéma change...
l'attesteur ne peut pas l'arrêter.
Si le registrant disparaît...
les règles ne partent pas avec eux.
Donc ce à quoi vous faites confiance...
et ce qui définit réellement la référence...
ne sont pas la même chose.
Je reviens toujours à cela en tant que séparation d'autorité.
Pas partagé.
Pas superposé.
Séparé.
$SIGN n'a d'importance que si un système où `registrant` et `attester` sont séparés peut maintenir les règles de référence stables...
even lorsque l'émetteur ne les contrôle pas.
Parce qu'une fois que cet écart compte...
il n'y a plus de source unique de vérité.
Donc la vraie question devient celle-ci.
Quand l'émetteur et le faiseur de règles ne sont pas la même chose...
à quoi faites-vous vraiment confiance lorsque vous vérifiez ?
#SignDigitalSovereignInfra #Sign
Je vérifiais une référence plus tôt.
Je supposais que l'attesteur était la source de vérité.
Puis j'ai regardé le schéma.
Adresse différente.
`registrant` sur le schéma.
`attester` sur la référence.
Pas la même chose.
Cela n'avait pas de sens.
Alors j'en ai tiré un autre.
Puis un autre.
Schémas différents.
Attesteurs différents.
Même séparation.
À ce moment-là, je pensais que je manquais quelque chose.
Un lien entre eux.
Quelque chose reliant l'émetteur aux règles.
Je ne pouvais pas trouver.
La référence venait de l'attesteur.
Mais les règles ne venaient pas.
J'ai retracé plus loin.
Le schéma se trouve là en premier.
Enregistré une fois.
Puis réutilisé.
Encore et encore.
Quiconque émettant sous cela...
ne le définit pas.
C'est là que cela a basculé.
L'attesteur contrôle l'émission.
Le registrant contrôle ce que signifie même l'émission.
Deux autorités différentes.
Aucune frontière visible entre elles.
Vous lisez la référence et faites confiance à l'attesteur...
mais ils n'ont pas décidé des règles derrière cela.
Et rien dans le flux ne vous le dit.
Cela semble juste valide.
C'est là que cela commence à devenir inconfortable.
Si le schéma change...
l'attesteur ne peut pas l'arrêter.
Si le registrant disparaît...
les règles ne partent pas avec eux.
Donc ce à quoi vous faites confiance...
et ce qui définit réellement la référence...
ne sont pas la même chose.
Je reviens toujours à cela en tant que séparation d'autorité.
Pas partagé.
Pas superposé.
Séparé.
$SIGN n'a d'importance que si un système où `registrant` et `attester` sont séparés peut maintenir les règles de référence stables...
even lorsque l'émetteur ne les contrôle pas.
Parce qu'une fois que cet écart compte...
il n'y a plus de source unique de vérité.
Donc la vraie question devient celle-ci.
Quand l'émetteur et le faiseur de règles ne sont pas la même chose...
à quoi faites-vous vraiment confiance lorsque vous vérifiez ?
#SignDigitalSovereignInfra #Sign
La crédential qui n'a jamais été acceptée
@SignOfficial
Je vérifiais une adresse de destinataire sur une attestation ce matin.
Aucune transaction.
Aucun historique.
La crédential était valide.
L'adresse n'avait jamais fait quoi que ce soit.
J'en ai tiré un autre.
Schéma différent.
Émetteur différent.
Même résultat.
Le champ `recipients` a été peuplé. Encodé en ABI. La structure semblait propre. La crédential a passé chaque contrôle requis par le système.
Mais le destinataire n'est jamais apparu ailleurs en dehors de l'attestation elle-même.
C'est à ce moment-là que ça a commencé à sembler étrange.
Alors j'ai retracé l'origine.
Je vérifiais une adresse de destinataire sur une attestation ce matin.
Aucune transaction.
Aucun historique.
La crédential était valide.
L'adresse n'avait jamais fait quoi que ce soit.
J'en ai tiré un autre.
Schéma différent.
Émetteur différent.
Même résultat.
Le champ `recipients` a été peuplé. Encodé en ABI. La structure semblait propre. La crédential a passé chaque contrôle requis par le système.
Mais le destinataire n'est jamais apparu ailleurs en dehors de l'attestation elle-même.
C'est à ce moment-là que ça a commencé à sembler étrange.
Alors j'ai retracé l'origine.
SIGN et la validité qui ne passe jamais
@SignOfficial
Un certificat a expiré alors que l'émetteur était encore actif.
Rien n'a été révoqué.
Alors je l'ai tiré à nouveau.
`validUntil`
Plus tôt que ce qui avait été fixé.
Je suis revenu.
Même attestation.
Même valeur.
Alors j'ai vérifié un niveau plus haut.
Schéma.
`maxValidFor`
Plus bas.
J'en ai exécuté un autre.
Même schéma.
Attesteur différent.
Ils ont repoussé la fenêtre plus loin.
Cela ne s'est pas présenté.
Le certificat est revenu plus court.
Pas de retour.
Pas d'avertissement.
Il manque juste du temps.
Je pensais que cela pourrait être incohérent.
Alors j'ai continué à le pousser.
Plus d'attestations.
Même frontière.
Un certificat a expiré alors que l'émetteur était encore actif.
Rien n'a été révoqué.
Alors je l'ai tiré à nouveau.
`validUntil`
Plus tôt que ce qui avait été fixé.
Je suis revenu.
Même attestation.
Même valeur.
Alors j'ai vérifié un niveau plus haut.
Schéma.
`maxValidFor`
Plus bas.
J'en ai exécuté un autre.
Même schéma.
Attesteur différent.
Ils ont repoussé la fenêtre plus loin.
Cela ne s'est pas présenté.
Le certificat est revenu plus court.
Pas de retour.
Pas d'avertissement.
Il manque juste du temps.
Je pensais que cela pourrait être incohérent.
Alors j'ai continué à le pousser.
Plus d'attestations.
Même frontière.
@SignOfficial
J'ai rechargé la même attestation et les données avaient changé.
Même `dataLocation`.
Contenu différent.
Je l'ai vérifié à nouveau.
Même pointeur.
Toujours différent.
Alors j'ai extrait le timestamp.
`attestTimestamp`
Plus ancien que ce que je voyais maintenant.
Je pensais que j'avais mélangé quelque chose.
Alors j'ai essayé un autre.
Attestation différente.
Même modèle.
Même emplacement.
Nouvelles données.
C'est à ce moment-là que cela a commencé à ne plus ressembler à une erreur.
L'attestation a été vérifiée.
Propre.
Rien n'a échoué.
Rien n'a été signalé.
Mais ce à quoi cela s'est résolu n'était pas ce qui était là quand cela a été émis.
J'ai continué.
Plus d'attestations utilisant `dataLocation` hors chaîne.
Même comportement.
La référence reste fixe.
Le contenu derrière lui change.
Et le système le considère comme la même chose.
Je reviens toujours à cela.
Dérive du pointeur.
Le système ancre l'emplacement…
pas l'état des données à `attestTimestamp`.
Donc ça vérifie toujours.
Juste pas par rapport à ce que l'émetteur a réellement vu.
C'est la rupture.
La certification passe…
mais elle ne prouve plus ce contre quoi elle a été émise.
$SIGN n’a d’importance ici que si un système qui vérifie contre un `dataLocation` au lieu de l'état à `attestTimestamp` est encore suffisant une fois que ces deux commencent à diverger à grande échelle.
Parce qu'une fois qu'ils s'éloignent...
rien ne casse.
Rien n'échoue.
Rien ne se met à jour.
Ça vérifie toujours.
Donc la vraie question devient celle-ci.
Quand le pointeur reste stable mais que les données changent…
que prouve exactement encore l'attestation ?
#SignDigitalSovereignInfra #Sign
J'ai rechargé la même attestation et les données avaient changé.
Même `dataLocation`.
Contenu différent.
Je l'ai vérifié à nouveau.
Même pointeur.
Toujours différent.
Alors j'ai extrait le timestamp.
`attestTimestamp`
Plus ancien que ce que je voyais maintenant.
Je pensais que j'avais mélangé quelque chose.
Alors j'ai essayé un autre.
Attestation différente.
Même modèle.
Même emplacement.
Nouvelles données.
C'est à ce moment-là que cela a commencé à ne plus ressembler à une erreur.
L'attestation a été vérifiée.
Propre.
Rien n'a échoué.
Rien n'a été signalé.
Mais ce à quoi cela s'est résolu n'était pas ce qui était là quand cela a été émis.
J'ai continué.
Plus d'attestations utilisant `dataLocation` hors chaîne.
Même comportement.
La référence reste fixe.
Le contenu derrière lui change.
Et le système le considère comme la même chose.
Je reviens toujours à cela.
Dérive du pointeur.
Le système ancre l'emplacement…
pas l'état des données à `attestTimestamp`.
Donc ça vérifie toujours.
Juste pas par rapport à ce que l'émetteur a réellement vu.
C'est la rupture.
La certification passe…
mais elle ne prouve plus ce contre quoi elle a été émise.
$SIGN n’a d’importance ici que si un système qui vérifie contre un `dataLocation` au lieu de l'état à `attestTimestamp` est encore suffisant une fois que ces deux commencent à diverger à grande échelle.
Parce qu'une fois qu'ils s'éloignent...
rien ne casse.
Rien n'échoue.
Rien ne se met à jour.
Ça vérifie toujours.
Donc la vraie question devient celle-ci.
Quand le pointeur reste stable mais que les données changent…
que prouve exactement encore l'attestation ?
#SignDigitalSovereignInfra #Sign
@SignOfficial
J'ai essayé de révoquer une attestation plus tôt et cela n'a pas fonctionné.
Pas d'erreur.
Juste pas de chemin.
Je l'ai vérifiée à nouveau.
Toujours valide.
Alors je suis monté d'un cran.
Schéma.
`revocable = false`
J'en ai exécuté une autre sous le même schéma.
Attestation différente.
Même résultat.
Deux credentials.
Aucun n'a pu être révoqué.
C'est là que cela a changé.
Ce n'était pas une révocation échouée.
Il n'y avait rien à exécuter.
Le credential n'était pas verrouillé après émission.
Il a été émis de cette façon.
J'ai continué.
Plus d'attestations.
Même schéma.
Même comportement.
Chacune d'elles pouvait être émise.
Aucune d'elles ne pouvait être reprise.
Et rien dans l'attestation ne vous le dit.
Vous ne le voyez que lorsque vous essayez de révoquer...
et rien ne se passe.
Je reviens toujours à cela.
Un verrou de révocation.
Pas un retard.
Pas une restriction.
Juste une absence.
La capacité d'émettre existe.
La capacité de corriger n'existe pas.
Et cette décision n'est pas prise lorsque le credential est créé.
Elle a déjà été prise avant même qu'il n'existe.
$SIGN n'a d'importance ici que si un système où `revocable = false` supprime complètement la révocation au niveau du schéma reste suffisant une fois que les conditions autour de ces credentials commencent à changer.
Parce qu'une fois que vous atteignez cette limite...
rien ne casse.
Rien ne échoue.
Rien ne se met à jour.
Cela reste simplement.
Alors la vraie question devient celle-ci.
Si la révocation n'a jamais existé au départ...
à quoi s'attend exactement le système pour s'adapter plus tard ?
#SignDigitalSovereignInfra #Sign
J'ai essayé de révoquer une attestation plus tôt et cela n'a pas fonctionné.
Pas d'erreur.
Juste pas de chemin.
Je l'ai vérifiée à nouveau.
Toujours valide.
Alors je suis monté d'un cran.
Schéma.
`revocable = false`
J'en ai exécuté une autre sous le même schéma.
Attestation différente.
Même résultat.
Deux credentials.
Aucun n'a pu être révoqué.
C'est là que cela a changé.
Ce n'était pas une révocation échouée.
Il n'y avait rien à exécuter.
Le credential n'était pas verrouillé après émission.
Il a été émis de cette façon.
J'ai continué.
Plus d'attestations.
Même schéma.
Même comportement.
Chacune d'elles pouvait être émise.
Aucune d'elles ne pouvait être reprise.
Et rien dans l'attestation ne vous le dit.
Vous ne le voyez que lorsque vous essayez de révoquer...
et rien ne se passe.
Je reviens toujours à cela.
Un verrou de révocation.
Pas un retard.
Pas une restriction.
Juste une absence.
La capacité d'émettre existe.
La capacité de corriger n'existe pas.
Et cette décision n'est pas prise lorsque le credential est créé.
Elle a déjà été prise avant même qu'il n'existe.
$SIGN n'a d'importance ici que si un système où `revocable = false` supprime complètement la révocation au niveau du schéma reste suffisant une fois que les conditions autour de ces credentials commencent à changer.
Parce qu'une fois que vous atteignez cette limite...
rien ne casse.
Rien ne échoue.
Rien ne se met à jour.
Cela reste simplement.
Alors la vraie question devient celle-ci.
Si la révocation n'a jamais existé au départ...
à quoi s'attend exactement le système pour s'adapter plus tard ?
#SignDigitalSovereignInfra #Sign
SIGN et le certificat délivré à quelqu'un qui n'était jamais là
@SignOfficial
Je traçais un ensemble d'attestations plus tôt quand une adresse de destinataire continuait à se répéter.
Aucune activité.
Je l'ai vérifié.
Rien.
Aucune transaction.
Aucune interaction.
Toujours en train de recevoir des identifiants.
Au début, je pensais que j'avais la mauvaise adresse.
Alors j'ai vérifié à nouveau.
Même résultat.
J'ai extrait les champs d'attestation.
`recipients`
Codé.
Résolu proprement.
Aucune erreur.
Aucune donnée manquante.
Alors j'ai élargi le champ.
Émetteurs différents.
Schémas différents.
Même schéma.
Adresses recevant des identifiants...
sans jamais apparaître ailleurs dans le système.
Je traçais un ensemble d'attestations plus tôt quand une adresse de destinataire continuait à se répéter.
Aucune activité.
Je l'ai vérifié.
Rien.
Aucune transaction.
Aucune interaction.
Toujours en train de recevoir des identifiants.
Au début, je pensais que j'avais la mauvaise adresse.
Alors j'ai vérifié à nouveau.
Même résultat.
J'ai extrait les champs d'attestation.
`recipients`
Codé.
Résolu proprement.
Aucune erreur.
Aucune donnée manquante.
Alors j'ai élargi le champ.
Émetteurs différents.
Schémas différents.
Même schéma.
Adresses recevant des identifiants...
sans jamais apparaître ailleurs dans le système.
Midnight et la preuve qui est restée après que son origine a disparu
@MidnightNetwork
Je traçais une preuve à travers la couche de vérification de Midnight plus tôt quand quelque chose ne s'est pas aligné.
Je ne pouvais pas revenir à d'où cela venait.
La preuve était toujours là.
Il a été vérifié proprement.
Mais il n'y avait rien autour qui me disait comment cela avait été produit.
Aucun état intermédiaire.
Aucun témoin visible.
Rien que je pouvais suivre en arrière.
Je l'ai exécuté à nouveau en m'attendant à quelque chose qui l'ancre.
Une référence.
Une trace.
Tout ce qui relie le résultat à son origine.
Rien.
La preuve a été maintenue.
Le processus ne l’a pas fait.
Je traçais une preuve à travers la couche de vérification de Midnight plus tôt quand quelque chose ne s'est pas aligné.
Je ne pouvais pas revenir à d'où cela venait.
La preuve était toujours là.
Il a été vérifié proprement.
Mais il n'y avait rien autour qui me disait comment cela avait été produit.
Aucun état intermédiaire.
Aucun témoin visible.
Rien que je pouvais suivre en arrière.
Je l'ai exécuté à nouveau en m'attendant à quelque chose qui l'ancre.
Une référence.
Une trace.
Tout ce qui relie le résultat à son origine.
Rien.
La preuve a été maintenue.
Le processus ne l’a pas fait.
@MidnightNetwork
J'ai vérifié la confirmation du validateur à minuit juste après qu'un lot de preuves ait été validé plus tôt et quelque chose à propos de ce qu'il contenait m'a arrêté.
Il a renvoyé un résultat valide.
Pas de drapeaux.
Mais il n'y avait rien qui me disait ce qui avait réellement été vérifié.
J'ai fait défiler à nouveau en m'attendant à ce que le contexte apparaisse quelque part.
Une référence. Quelque chose.
Il n'y avait rien de plus à trouver.
La confirmation tenait.
Le sens ne tenait pas.
Je devais vérifier cela deux fois.
Je m'attendais à ce que la vérification me dise quelque chose sur l'état sous-jacent.
Elle ne l'a pas fait.
C'est à ce moment-là que cela a commencé à sembler comme des données manquantes.
Et a commencé à sembler structurel.
Le validateur ne confirme pas ce qui s'est passé.
Il confirme que quelque chose de valide s'est produit.
Sans jamais avoir besoin de le comprendre.
Je reviens toujours à cela comme un écart de compréhension.
Où la vérification reste intacte.
Mais la compréhension n'arrive jamais.
Deux états sous-jacents complètement différents peuvent passer la même confirmation.
Et rien dans la sortie ne les sépare.
Cela tient tant que le volume est bas.
Cela devient plus difficile à raisonner lorsque les preuves commencent à s'accumuler.
$NIGHT n'a d'importance ici que si cette couche de vérification peut encore séparer ce qui reste valide de ce qui reste significatif une fois que les confirmations commencent à s'accumuler.
Parce qu'un système qui peut vérifier tout sans rien comprendre ne se casse pas immédiatement.
Il compresse les différences dans le même résultat.
Ainsi, le véritable test devient ceci.
Lorsque les confirmations commencent à se chevaucher sous charge, de quoi le réseau est-il exactement certain ?
#night #Night
J'ai vérifié la confirmation du validateur à minuit juste après qu'un lot de preuves ait été validé plus tôt et quelque chose à propos de ce qu'il contenait m'a arrêté.
Il a renvoyé un résultat valide.
Pas de drapeaux.
Mais il n'y avait rien qui me disait ce qui avait réellement été vérifié.
J'ai fait défiler à nouveau en m'attendant à ce que le contexte apparaisse quelque part.
Une référence. Quelque chose.
Il n'y avait rien de plus à trouver.
La confirmation tenait.
Le sens ne tenait pas.
Je devais vérifier cela deux fois.
Je m'attendais à ce que la vérification me dise quelque chose sur l'état sous-jacent.
Elle ne l'a pas fait.
C'est à ce moment-là que cela a commencé à sembler comme des données manquantes.
Et a commencé à sembler structurel.
Le validateur ne confirme pas ce qui s'est passé.
Il confirme que quelque chose de valide s'est produit.
Sans jamais avoir besoin de le comprendre.
Je reviens toujours à cela comme un écart de compréhension.
Où la vérification reste intacte.
Mais la compréhension n'arrive jamais.
Deux états sous-jacents complètement différents peuvent passer la même confirmation.
Et rien dans la sortie ne les sépare.
Cela tient tant que le volume est bas.
Cela devient plus difficile à raisonner lorsque les preuves commencent à s'accumuler.
$NIGHT n'a d'importance ici que si cette couche de vérification peut encore séparer ce qui reste valide de ce qui reste significatif une fois que les confirmations commencent à s'accumuler.
Parce qu'un système qui peut vérifier tout sans rien comprendre ne se casse pas immédiatement.
Il compresse les différences dans le même résultat.
Ainsi, le véritable test devient ceci.
Lorsque les confirmations commencent à se chevaucher sous charge, de quoi le réseau est-il exactement certain ?
#night #Night
Minuit et les données qui existent seulement assez longtemps pour disparaître
@MidnightNetwork
Je traversais un flux de preuve plus tôt aujourd'hui quand quelque chose ne s'est pas aligné.
Les données avaient disparu.
La preuve n'était pas.
Je m'attendais à ce que la preuve échoue une fois que les entrées avaient disparu.
Ça ne l'a pas fait.
Je l'ai vérifié à nouveau.
Même résultat.
Le témoin tenait toujours.
Cela semblait à l'envers.
Sur la plupart des systèmes, supprimer les données et tout ce qui en dépend s'effondre.
Ici, ça ne l'a pas fait.
Alors, j'ai ralenti.
Pas à pas.
Où les entrées vivaient réellement.
Où ils se sont arrêtés.
Où la preuve est apparue.
Les entrées privées n'ont jamais touché la chaîne.
Je traversais un flux de preuve plus tôt aujourd'hui quand quelque chose ne s'est pas aligné.
Les données avaient disparu.
La preuve n'était pas.
Je m'attendais à ce que la preuve échoue une fois que les entrées avaient disparu.
Ça ne l'a pas fait.
Je l'ai vérifié à nouveau.
Même résultat.
Le témoin tenait toujours.
Cela semblait à l'envers.
Sur la plupart des systèmes, supprimer les données et tout ce qui en dépend s'effondre.
Ici, ça ne l'a pas fait.
Alors, j'ai ralenti.
Pas à pas.
Où les entrées vivaient réellement.
Où ils se sont arrêtés.
Où la preuve est apparue.
Les entrées privées n'ont jamais touché la chaîne.
@MidnightNetwork
Ce matin, je parcourais un contrat Compact et quelque chose ne s'alignait pas.
Une condition évaluée comme vraie.
Le circuit se comportait comme s'il n'existait pas.
Pas d'erreur.
Pas d'échec.
Juste… parti.
J'ai vérifié les entrées.
Correct.
Vérifié les conditions.
Toujours vrai.
Mais quand je l'ai suivi à travers la compilation, cette branche n'est jamais devenue des contraintes.
Un chemin conditionnel dépendant d'une entrée externe évaluée comme vrai, mais n'est jamais entré dans le circuit.
Pas rejeté.
Pas cassé.
Juste effacé.
C'est là que cela a échoué pour moi.
Le circuit n'exécute pas votre logique.
Il définit quelle logique est autorisée à exister.
Si quelque chose ne peut pas être réduit à des contraintes, Compact ne le rejette pas.
Il l'efface.
Je reviens toujours à cela comme une exclusion de contraintes.
Pas de logique incorrecte.
Juste une logique que le système n'a jamais été conçu pour représenter.
Ce qui signifie que quelque chose peut être vrai…
et être quand même non prouvable.
Et le vérificateur ne saura jamais faire la différence.
Parce que de son point de vue, la preuve est complète.
Mais complète sur quoi ?
Pas la réalité.
Seulement ce que le circuit a permis d'exister.
C'est là que cela commence à compter.
Parce que maintenant le système peut prouver la correction…
sur une version incomplète de la réalité.
$NIGHT n'a d'importance que si ce que Compact exclut ne fait jamais partie de ce que le vérificateur suppose être complet.
Parce que si c'est le cas, rien ne se casse.
La preuve passe toujours.
Seule la vérité disparaît.
Alors la vraie question devient celle-ci.
Si quelque chose peut être vrai mais jamais prouvable, qu'est-ce que le système vérifie exactement ?
#night #Night
Ce matin, je parcourais un contrat Compact et quelque chose ne s'alignait pas.
Une condition évaluée comme vraie.
Le circuit se comportait comme s'il n'existait pas.
Pas d'erreur.
Pas d'échec.
Juste… parti.
J'ai vérifié les entrées.
Correct.
Vérifié les conditions.
Toujours vrai.
Mais quand je l'ai suivi à travers la compilation, cette branche n'est jamais devenue des contraintes.
Un chemin conditionnel dépendant d'une entrée externe évaluée comme vrai, mais n'est jamais entré dans le circuit.
Pas rejeté.
Pas cassé.
Juste effacé.
C'est là que cela a échoué pour moi.
Le circuit n'exécute pas votre logique.
Il définit quelle logique est autorisée à exister.
Si quelque chose ne peut pas être réduit à des contraintes, Compact ne le rejette pas.
Il l'efface.
Je reviens toujours à cela comme une exclusion de contraintes.
Pas de logique incorrecte.
Juste une logique que le système n'a jamais été conçu pour représenter.
Ce qui signifie que quelque chose peut être vrai…
et être quand même non prouvable.
Et le vérificateur ne saura jamais faire la différence.
Parce que de son point de vue, la preuve est complète.
Mais complète sur quoi ?
Pas la réalité.
Seulement ce que le circuit a permis d'exister.
C'est là que cela commence à compter.
Parce que maintenant le système peut prouver la correction…
sur une version incomplète de la réalité.
$NIGHT n'a d'importance que si ce que Compact exclut ne fait jamais partie de ce que le vérificateur suppose être complet.
Parce que si c'est le cas, rien ne se casse.
La preuve passe toujours.
Seule la vérité disparaît.
Alors la vraie question devient celle-ci.
Si quelque chose peut être vrai mais jamais prouvable, qu'est-ce que le système vérifie exactement ?
#night #Night
SIGN et le schéma qui n'a pas fixé de plafond
@SignOfficial
`validUntil` a été fixé à zéro.
Je m'attendais à ce qu'il expire lors du prochain contrôle.
Ça ne l'a pas fait.
Zéro signifiait simplement pas d'expiration au niveau de l'attestation.
Alors j'ai monté d'un niveau.
Vérifié le schéma.
`maxValidFor`
Aussi zéro.
C'est là que cela a cessé de faire sens.
Il n'y avait aucun plafond nulle part.
Pas sur l'attestation.
Pas dans le schéma.
J'en ai exécuté un autre.
Schéma différent.
Même configuration.
`validUntil = 0`
`maxValidFor = 0`
Même résultat.
Le credential continuait simplement à se résoudre.
Pas d'expiration.
Pas de vérification.
Aucun signal forçant l'arrêt.
C'était la première anomalie.
`validUntil` a été fixé à zéro.
Je m'attendais à ce qu'il expire lors du prochain contrôle.
Ça ne l'a pas fait.
Zéro signifiait simplement pas d'expiration au niveau de l'attestation.
Alors j'ai monté d'un niveau.
Vérifié le schéma.
`maxValidFor`
Aussi zéro.
C'est là que cela a cessé de faire sens.
Il n'y avait aucun plafond nulle part.
Pas sur l'attestation.
Pas dans le schéma.
J'en ai exécuté un autre.
Schéma différent.
Même configuration.
`validUntil = 0`
`maxValidFor = 0`
Même résultat.
Le credential continuait simplement à se résoudre.
Pas d'expiration.
Pas de vérification.
Aucun signal forçant l'arrêt.
C'était la première anomalie.
@SignOfficial
`attestTimestamp` correspond à `revokeTimestamp`.
Pas de lacune.
Cela ne devrait pas arriver.
Je l'ai remarqué en vérifiant les horodatages.
J'en ai vérifié un autre.
Même modèle.
Émetteur différent.
Même résultat.
Au début, cela ressemblait à un problème de timing.
Comme si la révocation intervenait juste après l'émission.
Ce n'était pas le cas.
Il n'y avait pas de "après".
Les enregistrements SIGN des deux événements de manière indépendante.
Ils se sont simplement résolus au même moment.
Ce qui signifie que cette attestation n'a jamais eu d'état valide.
Pas brièvement.
Pas même pour un bloc.
Ce qui signifie qu'il n'y a jamais eu d'état pour qu'un système puisse le lire.
C'est là que cela a changé.
Ce n'était pas une attestation révoquée.
C'était une qui a complètement sauté la validité.
Annulation instantanée.
Une attestation qui existe dans la structure, mais n'a jamais existé dans le temps.
J'ai suivi comment le système le traite.
Il se résout.
Le schéma se charge.
L'émetteur est vérifié.
Tout passe à la surface.
Sauf qu'il n'y a jamais eu de point où il pouvait réellement être utilisé.
Cela ne se montre que si vous lisez les horodatages directement.
C'est ici que $SIGN commence à avoir de l'importance.
$SIGN n'a d'importance que si le protocole peut faire la distinction entre une attestation où `attestTimestamp == revokeTimestamp` et une qui est devenue invalide plus tard.
Parce qu'en ce moment, les deux se résolvent de la même manière, même si une seule a jamais été valide.
Alors la question devient celle-ci.
Si l'émission peut produire quelque chose qui n'a jamais été valide même pendant une seconde, que signifie exactement "émis" à l'intérieur du système ?
#SignDigitalSovereignInfra #Sign
`attestTimestamp` correspond à `revokeTimestamp`.
Pas de lacune.
Cela ne devrait pas arriver.
Je l'ai remarqué en vérifiant les horodatages.
J'en ai vérifié un autre.
Même modèle.
Émetteur différent.
Même résultat.
Au début, cela ressemblait à un problème de timing.
Comme si la révocation intervenait juste après l'émission.
Ce n'était pas le cas.
Il n'y avait pas de "après".
Les enregistrements SIGN des deux événements de manière indépendante.
Ils se sont simplement résolus au même moment.
Ce qui signifie que cette attestation n'a jamais eu d'état valide.
Pas brièvement.
Pas même pour un bloc.
Ce qui signifie qu'il n'y a jamais eu d'état pour qu'un système puisse le lire.
C'est là que cela a changé.
Ce n'était pas une attestation révoquée.
C'était une qui a complètement sauté la validité.
Annulation instantanée.
Une attestation qui existe dans la structure, mais n'a jamais existé dans le temps.
J'ai suivi comment le système le traite.
Il se résout.
Le schéma se charge.
L'émetteur est vérifié.
Tout passe à la surface.
Sauf qu'il n'y a jamais eu de point où il pouvait réellement être utilisé.
Cela ne se montre que si vous lisez les horodatages directement.
C'est ici que $SIGN commence à avoir de l'importance.
$SIGN n'a d'importance que si le protocole peut faire la distinction entre une attestation où `attestTimestamp == revokeTimestamp` et une qui est devenue invalide plus tard.
Parce qu'en ce moment, les deux se résolvent de la même manière, même si une seule a jamais été valide.
Alors la question devient celle-ci.
Si l'émission peut produire quelque chose qui n'a jamais été valide même pendant une seconde, que signifie exactement "émis" à l'intérieur du système ?
#SignDigitalSovereignInfra #Sign
Connectez-vous pour découvrir d’autres contenus