Ce blog n'a d'autre prétention que de me permettre de mettre à la disposition de tous des petits textes que j'écris. On y parle surtout d'informatique mais d'autres sujets apparaissent parfois.
Première rédaction de cet article le 8 novembre 2026
Les publications expliquant que l'Internet est foutu, que tout était mieux avant, abondent. Dans un article de la revue « Internet Histories », Kieran Hegarty se demande quand cette tendance est apparue et quelles sont ses caractéristiques.
Dans on article « When did the internet become this awful? », l'auteur appelle ces publications des IDN, les « Internet Decline Narratives ». Ces IDN sont très favorisés par les médias traditionnels, qui n'ont jamais pardonné à l'Internet d'avoir écorné leur monopole de la parole, et aussi par les politiciens qui aiment bien présenter l'Internet comme essentiellement négatif, ce qui leur permet de promouvoir ensuite contrôle et interdiction.
Ces IDN ne sont pas, en général, une critique argumentée du numérique. La critique est tournée vers le futur, vers ce qu'il faudrait changer. Au contraire, les IDN parlent du passé, un passé en général mythifié. Ils fixent de manière assez arbitraire une date à partir de laquelle les choses n'ont fait qu'aller mal (le septembre éternel ? Le Web ? L'IA générative ?).
Kieran Hegarty n'en parle pas beaucoup mais je note que ce discours « IDN », qui suppose qu'il y a eu un Internet parfait à une époque, rencontre souvent un discours réactionnaire qui estime que l'Internet, voire le numérique, a toujours été mauvais. Les IDN s'inscrivent dans la longue histoire des paniques morales qui avaient accompagné tous les nouveaux outils de communication à leurs débuts.
Et ces IDN ont des faiblesses : d'abord, ils invisibilisent complètement les utilisateurices, les réduisant au statut de victimes passives. Alors que ces utilisateurices agissent, choisissent, et ne suivent pas aveuglément (pour le cas des enfants, cf. par exemple les livres d'Anne Cordier, plutôt que les textes réactionnaires qui traitent ouvertement les utilisateurices de crétins). Oublier ces humain·es tend à écarter toute réflexion sur comment on pourrait améliorer les choses. D'accord, les utilisateurices manquent de culture numérique, et peuvent être trompés, et le sont souvent. Mais cela ne les réduit pas à de simples poupées qui feraient exactement ce que les GAFA prévoient pour eux.
Ensuite, les IDN ignorent la variété des usages de l'Internet. Politiciens et journalistes qui parlent de l'« Internet » ne connaissent en général que deux ou trois réseaux sociaux capitalistes et basent tout leur discours sur ces services, qui sont loin d'être la totalité des usages du Web, sans même parler de l'Internet en général.
Enfin, ces IDN sont souvent occidentalo-centrés, faisant comme si les usages et les phénomènes constatés dans le pays de l'auteur de l'IDN était universel. L'Internet est divers, et ses utilisateurices aussi. La technostalgie est parfois une nostalgie d'un monde passé où l'accès à l'Internet était limité à une population très homogène…
Au sujet de cet occidentalo-centrisme, l'auteur de l'article cite Payal Arora, la référence classique des tenants d'un discours techno-optimiste, s'appuyant sur un point de vue « du Sud ». Mais je trouve qu'Arora, citée ici de manière acritique, a aussi ses limites, notamment en allant franchement du côté de l'optimisme béat ; or, ce n'est pas parce qu'un paysan indien a un smartphone et est connecté qu'il devient libre et enpouvoiré. Son vécu demeure très influencé par des organisations puissantes sur lesquelles il n'a pas complètement prise.
Je rajoute aux remarques d'Hegarty que les IDN présentent souvent l'Internet comme un acteur en soi, ayant ses propres objectifs et sa propre dynamique, ce qui conduit à oublier qu'il y a des humains derrière, qui sont à l'origine des décisions. Ce n'est pas « l'Internet » qui capture des données en masse, ce sont Meta, Alphabet et les autres. Et ces entreprises ne font pas cela en raison d'idées transhumanistes fumeuses (contrairement à ce que racontent les intellectuells français, qui aiment bien se mettre dans la posture de défenseurs de l'humanité), mais parce que ce sont des entreprises capitalistes, que leurs dirigeants pilotent en fonction du profit.
Tout cela ne doit pas conduire à ignorer les critiques, qui sont parfaitement légitimes, et en général justifiées, quand on dit du mal des GAFA. Mais il faut faire attention à ne pas les inscrire dans une démarche de déclin obligatoire et inévitable.
Date de publication du RFC : Novembre 2026
Auteur(s) du RFC : M. Ounsworth, J. Gray (Entrust), M. Pala (OpenCA Labs), J. Klaussner (Bundesdruckerei), S. Fluhrer (Cisco Systems)
Chemin des normes
Réalisé dans le cadre du groupe de travail IETF lamps
Première rédaction de cet article le 7 novembre 2026
C'est bien joli d'utiliser des algorithmes post-quantiques pour que ses signatures ne soient pas attaquées par les futurs calculateurs quantiques. Mais si l'algorithme post-quantique cède devant une attaque cryptanalytique classique, n'aura t-on pas échangé la proie pour l'ombre ? La solution hybride est de mettre dans ses certificats X.509 deux clés et deux signatures, traditionnelle et post-quantique, et d'exiger que les deux signatures soient valides.
Ce RFC normalise donc les clés et signatures pour une configuration hybride, un algorithme traditionnel, qui peut être RSA, ECDSA ou EdDSA, et un algorithme post-quantique, actuellement uniquement ML-DSA. Le RFC utilise le terme de composé plutôt qu'hybride pour insister sur le fait que les deux algorithmes sont toujours utilisés ensemble.
Si vous voulez un arrière-plan sur ce post-quantique et ses motivations, voyez le RFC 9958. Tout le projet de transition vers le post-quantique est soumis à deux incertitudes, la date à laquelle on aura des CRQC (Cryptographically Relevant Quantum Computers) et la sécurité des algorithmes post-quantiques, plus récents et moins testés. N'utiliser que l'algorithme traditionnel est imprudent, car des CRQC pourraient arriver un jour, n'utiliser que l'algorithme post-quantique est imprudent car on ne peut pas encore être parfaitement sûr de sa sécurité, à la fois face à la cryptanalyse, et face à une éventuelle erreur de programmation. D'où l'hybride, tel que décrit dans le RFC 9794. Certaines régulations, par exemple en France ou en Allemagne exigent ces systèmes hybrides.
Notre RFC 10073 pousse le concept d'hybride un peu plus loin avec un système composé, c'est-à-dire que les deux clés et les deux signatures seront toujours vues comme une (RFC 9794, section 2). Cela permet l'utilisation dans des protocoles qui ne connaissent pas le concept d'hybride et qui ne s'attendent pas à devoir faire deux vérifications. (L'idée originelle vient de cet article, ce qui n'a pas empêché des brevets comme US20220353061A1 ou US11968316B1 d'être déposés après.) Et les composés ont aussi l'avantage de moins changer les logiciels, facilitant une éventuelle re-certification.
Donc, résumons : ce RFC normalise un schéma hybride de signature qui inclus un algorithme post-quantique, ML-DSA (normalisé dans FIPS 204 et aussi un peu dans le RFC 9881), avec, au choix, RSA tel que décrit dans le RFC 8017, ECDSA tel que normalisé dans FIPS 186.5 ou encore Ed25519 (voir le RFC 8410). Les signatures, pour ce RFC, sont toujours combinées en une seule. Une vérification réussie implique que les deux signatures soient valides.
Je ne vais pas reprendre les parties purement cryptographiques du RFC (trop dur pour moi), regardez par exemple la section 4 si vous voulez voir l'encodage exact des clés et signatures. Point amusant : on met toujours clé et signature ML-DSA en premier car, contrairement à RSA, leurs tailles sont fixes et cette règle permet donc facilement de retrouver les deux clés ou les deux signatures. (Sinon, l'annexe A détaille les tailles de différents objets, vous y verrez que l'augmentation de taille due à l'utilisation d'une clé ou d'une signature composées est négligeable par rapport à ML-DSA seul.)
Le but de ce RFC est l'utilisation de ce schéma composé dans
X.509/PKIX donc la
section 5 décrit comment représenter clés et signatures dans un
certificat. (Notez que le cas de CMS est repoussé à
une future norme.) Comme ML-DSA ne permet que la signature, pas le
chiffrement, le certificat peut avoir les utilisations
digitalSignature ou
keyCertSign mais pas
keyEncipherment ou
encipherOnly (même si le composant traditionnel
l'aurait permis ; rappelez-vous qu'un schéma composé doit utiliser
les deux algorithmes, le post-quantique et le traditionnel, sinon il
ne fournit pas la sécurité attendue). Des identifiants sont réservés
pour toutes les variantes possibles, par exemple
id-MLDSA65-Ed25519-SHA512 identifie un composé
ML-DSA 65 avec Ed25519. Le module ASN.1
complet est en section 7 du RFC, avec, pour reprendre cet exemple :
id-MLDSA65-Ed25519-SHA512 OBJECT IDENTIFIER ::= {
iso(1) identified-organization(3) dod(6) internet(1) security(5)
mechanisms(5) pkix(7) alg(6) 48 }
Et comme la sécurité est compliquée, la section 9 précise un certain nombre de points pour faire proprement du composé avec ML-DSA. Elle rappelle qu'un schéma hybride de cryptographie peut servir à augmenter la sécurité (imposant à un attaquant de devoir casser l'algorithme post-quantique et le traditionnel) ou bien à permettre une transition en douceur au fur et à mesure de la disponibilité de logiciel qui connait la cryptographie post-quantique. Dans le premier cas, celui de notre RFC, on impose que les deux signatures soient valides. Dans le second, qui n'est pas le choix du RFC, qu'une seule le soit. (Je crois me souvenir qu'au début de ce RFC, le projet était d'avoir les deux possibilités. Quelqu'un a mieux suivi les débats que moi ?)
Certains experts n'aiment pas l'idée de l'hybride en disant que, si un attaquant ne sait attaquer qu'un seul des deux algorithmes, il ne va pas s'embêter, il va simplement génerer un faux document avec une seule signature, celle de l'algorithme qu'il sait casser. La réponse à cet argument est que le vérificateur choisit sa politique : il peut décider de n'accepter que les hybrides.
Si vous voulez une analyse de sécurité plus détaillée, avec notamment la prise en compte des modèles de menace EUF-CMA et SUF-CMA, elle se trouve en section 9.2 (les systèmes décrits dans ce RFC résistent face à EUF-CMA mais pas face à SUF-DMA).
Autre question amusante (section 9.5), que se passe t-il lorsqu'un algorithme utilisé dans l'hybride est considéré comme dépassé ? Avec les systèmes à un seul algorithme, c'est clair : si on connait (ou soupçonne sérieusement) une attaque faisable contre l'algorithme, on arrête de l'utiliser. Mais avec un hybride, c'est plus compliqué de décider puisque, après tout, le deuxième algorithme tient toujours. Cela peut compliquer, par exemple, les analyses de sécurité puisqu'un audit trop sommaire verra l'algorithme vulnérable, sans tenir compte du fait qu'il n'est utilisé qu'au sein d'un système hybride.
La section 10 du RFC se penche ensuite sur quelques problèmes concrets. Par exemple, le bon sens nous dit que, dans un système hybride, il faut que les deux composants, le post-quantique et le traditionnel, aient à peu près la même « force », le même niveau de sécurité, sinon, le plus faible n'apportera pas grand'chose. Mais on ne sait pas quantifier cette « force » entre deux algorithmes aussi différents que, par exemple, ML-DSA et Ed25519. Et d'autant plus que ML-DSA, plus récent, est moins étudié ou testé « au feu ». Donc, le RFC ne prétend pas que tous les hybrides normalisés soient « équilibrés ». Le choix des combinaisons a plutôt été fait sur la base du réalisme (algorithmes courants). Lors de la discussion à l'IETF, plusieurs personnes ont estimé que ce RFC créait trop de composés et qu'il aurait fallu réduire le choix à quelques combinaisons bien choisies, mais le groupe de travail a finalement décidé de « donner » à chacun sa combinaison favorite.
Sinon, vous savez que les décideurs, en matière de sécurité, se
préoccupent souvent davantage de conformité que de sécurité. Il y a
des régulations diverses et il est plus important de les respecter
que de choisir le « meilleur » système. La section 10.2 vient à leur
aide en expliquant comment utiliser les systèmes composés de ce RFC
si on doit respecter FIPS. Si un seul des deux algorithmes du
composé est conforme à FIPS, il faudra présenter le système comme
ayant la sécurité de ce composant, pas celle du composé complet. Si
on n'a pas ce problème de conformité, et qu'on n'est pas expert en
cryptographie soi-même, le composé recommandé par ce RFC est
id-MLDSA65-ECDSA-P256-SHA512.
Enfin, l'annexe E contient les vecteurs de test, qui forment, en nombre de pages, la grande majorité du RFC. Plutôt que d'essayer de les extraire laborieusement du RFC, il vaut mieux aller les chercher en ligne.
Date de publication du RFC : Octobre 2026
Auteur(s) du RFC : B. Billon (Splio), J. Levine
(Standcore)
Chemin des normes
Réalisé dans le cadre du groupe de travail IETF mailmaint
Première rédaction de cet article le 31 octobre 2026
Ce RFC
normalise le champ Expires: dans l'en-tête d'un
message. Il
existait déjà mais n'avait apparemment jamais été spécifié
officiellement. Il indique quand un message cesse d'être
utile et n'a plus besoin d'être montré.
L'utilisation envisagée est que le MUA peut déclasser un message expiré, voire le masquer complètement (le détruire n'est pas recommandé, un message expiré n'est plus valide mais peut garder, par exemple, un intérêt historique). Notre RFC n'essaie pas de donner une signification trop précise à ce champ, encore moins de requérir des actions spécifiques par le logiciel.
Donc, le champ garde sa syntaxe (section 3), la forme de la date-et-heure étant tirée du RFC 5322, section 3.3 :
Expires: Thu, 16 Jul 2026 11:28:03 +0000
(Si vous utilisez le logiciel GNU date, l'option
--rfc-email permet d'afficher une date-et-heure
au bon format.)
On l'a dit, ce RFC n'est pas trop normatif, mais il donne quand
même des avis. La section 4 conseille aux logiciels de création de
messages de mettre un Expires: quand on sait
que le message perdra son intérêt après un certain moment. C'est par
exemple le cas d'une promotion commerciale qui a une date de fin,
d'un message qui annonce un évènement ou d'un message périodique,
qui n'est valable que jusqu'à l'émission du suivant.
La section 5, elle, consacrée aux logiciels de lecture, leur
suggère de diminuer la priorité d'affichage des messages expirés,
voire de ne pas les montrer du tout. Elle estime qu'il ne faut pas
refuser un message uniquement sur la base du champ
Expires:, et ne pas, par défaut, détruire les
messages expirés (mais on peut avoir une option du logiciel pour
activer cette destruction).
On notera qu'il existe un projet Email Expiration
Date pour développer l'utilisation du champ
Expires:. Ce projet, porté par plusieurs
acteurs spécialisés dans l'envoi massif de messages, a développé
un
greffon Thunderbird mettant en œuvre l'expiration des
messages. Jusqu'à présent, je n'ai vu ce champ dans des vrais
messages que dans les spams de la SNCF, par
exemple un message expédié en juin qui indiquait Expires:
Monday, 21 December 2026 14:38:28 +0000 (cette date était
sans rapport avec le contenu de la publicité, mais était à six mois
dans le futur donc je suppose qu'un Expires:
d'une demi-année est mis automatiquement).
Ce champ Expires: a une histoire. Le RFC 1327 décrit déjà, dans le contexte de
l'interopérabilité avec X.400, un champ
Expiry-date:. Le RFC 2156 le renomme Expires:, en
indiquant juste sa syntaxe (une date-et-heure, au format du - à
l'époque - RFC 822) et peu de sémantique à
part qu'on ne pouvait pas compter que ce champ soit appliqué
automatiquement. Puis le RFC 4021 l'a placé
dans le
registre de l'en-tête du courrier. Notez qu'un autre format,
celui des News, a un champ
Expires: (RFC 5536,
section 3.2.5), avec une syntaxe et une sémantique proche. Comme,
dans le contexte du courrier
électronique, ce champ existe depuis longtemps, mais
avec peu ou pas de spécification, il aurait été difficile de définir
une spécification stricte, cela aurait cassé certains usages
existants (cf. section 6).
Première rédaction de cet article le 28 octobre 2026
Cet article explique le concept de « DNS menteur », terme souvent entendu, par exemple dans le contexte de la censure de l'Internet.
Si vous lisez souvent ce blog, vous n'apprendrez rien de nouveau ici. Le but de cet article est juste d'avoir une référence stable pour expliquer ce terme de « DNS menteur », sinon pour un large public, du moins pour une population plus large que les seuls experts DNS.
Donc, pour commencer, tout petit rappel sur le DNS (Domain Name
System) : le DNS permet de distribuer de l'information aux
machines connectées à l'Internet. (Les humain·es normaux ne
regardent en général pas cette information, qui est purement
technique.) La clé d'accès à cette information est un nom
de domaine comme www.bortzmeyer.org
ou phy.cam.ac.uk. Le point important est que
quasiment toute interaction sur l'Internet
commence par une utilisation du DNS, que votre machine fait pour
vous. Si le DNS est en panne, c'est quasiment comme si vous n'avez
plus d'Internet. Et, ce qui nous intéresse ici, si le DNS vous ment
sur les informations techniques récupérées, vous n'avez guère
d'autre choix que de le croire. (Avis aux expert·es : oui, je
simplifie. J'ai indiqué quelques ressources plus complètes à la fin
de cet article.)
Votre machine (ordinateur, ordiphone,
brosse à dents connectée) fait des requêtes DNS pour vous et elle
les fait à un serveur nommé résolveur
DNS. C'est une machine en général gérée par l'organisation
qui vous fournit l'accès à l'Internet. Normalement, en l'absence de
« DNS menteur », votre résolveur ne fabrique pas d'information, il
se contente de vous transmettre ce qu'il a appris d'une autre
famille de serveurs DNS, les serveurs faisant
autorité. Ceux-ci sont gérés par diverses organisations, par
exemple les serveurs faisant autorité pour
cnrs.fr sont gérés par le CNRS, alors que ceux faisant autorité pour
sephora.fr sont gérés par l'hébergeur
Akamai.
Donc, normalement, lorsque vous voulez envoyer du courrier à
QuelqUn@cnrs.fr, une machine va demander à un
résolveur DNS quel est le serveur de messagerie du CNRS et cette
réponse viendra des serveurs faisant autorité pour
cnrs.fr. Mais ça, c'est le comportement
normal. Or, puisque presque toute interaction sur l'Internet
commence par un appel au DNS, un certain nombre de gens se sont dit
qu'ils pouvaient utiliser ce qui était conçu comme un service
technique en outil de contrôle. Après tout, qui
contrôle le résolveur, contrôle la quasi-entièreté du vécu de
l'utilisateurice.
Un « DNS menteur » ou, plus rigoureusement, un « résolveur DNS menteur » est donc un résolveur qui, au lieu de relayer sincèrement les réponses des serveurs faisant autorité, invente des réponses, en général, dans le but de bloquer l'accès à un service Internet.
Notez bien que les résolveurs DNS menteurs ne sont pas tous pareils. Ils diffèrent par :
Vous noterez donc que « résolveur DNS menteur » est une simple description factuelle, les motivations et les acteurs étant variés. Des exemples d'utilisation pour la censure sont communs en Europe. Au moment de l'écriture de cet article, le gouvernement français a annoncé son intention de pouvoir bloquer les réseaux sociaux sur simple demande de sa part, et, si cela se fait, ce sera sans doute via des résolveurs DNS menteurs. (D'autres pays dans le monde utilisent d'autres techniques de censure de l'Internet.) Si vous voulez par contre un exemple dans le domaine du blocage de ces insupportables (et dangereuses) publicités , le système Pi-hole est un résolveur configuré pour mentir sur les noms de domaine utilisés par les services de publicité.
On fait souvent remarquer que, comme technique de censure, le résolveur DNS menteur n'est pas efficace car il est toujours possible de changer de résolveur. C'est techniquement exact mais il y a deux limites :
(Oui, je sais, on peut aussi utiliser un VPN.)
Le reste de cet article est consacré à un certain nombre de
détails, en général de nature technique.
D'abord, que se passe-t-il précisément quand un résolveur vous
ment. Essayons avec le domaine
tarjetarojatvlive.net. Ironiquement, le site
Web ne marche plus (il semble rediriger vers des choses assez
louches, ne l'essayez pas) mais, à une époque, une décision de
justice au profit des ayants-droit exigeait sa censure. Avec les
résolveurs de Free :
% dig @212.27.40.240 tarjetarojatvlive.net … ;; Got answer: ;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 35658 ;; flags: qr rd ra; QUERY: 1, ANSWER: 1, AUTHORITY: 0, ADDITIONAL: 1 ;; OPT PSEUDOSECTION: ; EDNS: version: 0, flags: do; udp: 512 ;; QUESTION SECTION: ;tarjetarojatvlive.net. IN A ;; ANSWER SECTION: tarjetarojatvlive.net. 600 IN A 127.0.0.1 ;; Query time: 5 msec ;; SERVER: 212.27.40.240#53(212.27.40.240) (UDP) ;; WHEN: Wed Oct 28 16:26:09 CET 2026 ;; MSG SIZE rcvd: 66
La réponse est clairement mensongère, l'adresse 127.0.0.1 étant
l'adresse locale de la machine. (Les vraies adresses sont
172.104.149.86 et quelques autres.)
Ensuite, comment savoir si le résolveur que vous utilisez ment ? Une solution possible est évidemment de lire sa documentation mais, par exemple, en France, je ne connais aucun FAI qui documente les censures pratiquées. Il existe une solution technique pour que le résolveur indique qu'il a menti, les EDE (Extended DNS Error), normalisées dans le RFC 8914 mais, là encore, je ne connais pas de FAI français qui les utilise (comme vous le voyez dans la réponse de Free ci-dessus). Par contre, Google Public DNS le fait. Regardons avec dig :
% dig @8.8.8.8 tarjetarojatvlive.net … ;; Got answer: ;; ->>HEADER<<- opcode: QUERY, status: REFUSED, id: 65388 ;; flags: qr rd ra; QUERY: 1, ANSWER: 0, AUTHORITY: 0, ADDITIONAL: 1 ;; OPT PSEUDOSECTION: ; EDNS: version: 0, flags:; udp: 512 ; EDE: 16 (Censored): (The requested domain is subject to a judicial injunction or other governmental blocking order for FR (ISO country code). To learn more about this specific removal, please visit https://lumendatabase.org/notices/41939614.) ;; QUESTION SECTION: ;tarjetarojatvlive.net. IN A ;; Query time: 6 msec ;; SERVER: 8.8.8.8#53(8.8.8.8) (UDP) ;; WHEN: Wed Oct 28 16:22:46 CET 2026 ;; MSG SIZE rcvd: 276
Il ne s'agit pas réellement d'un résolveur DNS menteur car Google a
été franc : le domaine est censuré (code EDE 16) et Google renvoie
même à la
page Lumen décrivant ce cas. Mais le résultat va être le même
pour l'utilisateurice, simplement plus clair. D'ailleurs, je ne sais
pas pourquoi Free, dans l'exemple plus haut, renvoie une adresse
bidon (le 127.0.0.1) au lieu d'un code REFUSED
(comme Google) ou à la rigueur NXDOMAIN (indiquant que le domaine
n'existe pas). Certains résolveurs DNS menteurs renvoient une
adresse IP qui est celle d'un serveur Web contenant des explications
mais c'est la pire solution de toutes, par exemple pour la vie privée.
La censure dépend évidemment du pays et, pour étudier la censure dans d'autres pays que le vôtre, vous pouvez utiliser, par exemple, les sondes RIPE Atlas (attention toutefois aux questions éthiques).
J'ai dit qu'on pouvait toujours (plus ou moins facilement) changer de résolveur. Je ne vais pas donner de liste de résolveurs, car, dès qu'ils sont largement utilisés, ils deviennent des cibles pour la censure. Il faut au contraire, dans ce cas comme dans beaucoup, plein de résolveurs un peu partout. (Et les résolveurs publics des GAFA sont évidemment à éviter.)
Et quelques lectures supplémentaires :
Première rédaction de cet article le 22 octobre 2026
Vous avez sans doute déjà lu des articles sur la faille de l'AC eMudhra (sinon, vous avez des liens à la fin). Une des conséquences de cette faille est que tout le monde peut générer des vrais/faux certificats. Exemple.
La faille (depuis éclipsée par deux grosses failles PHP) venait d'un générateur de nombres aléatoire trop faibles. Un certificat est une clé cryptographique publique signée par une AC. La clé privée correspondant à cette clé publique doit être choisie de manière à être imprévisible pour l'attaquant. (On dit souvent qu'elle doit être choisie aléatoirement ce qui, en pratique, est juste un peu plus fort que de dire « imprévisible ».) Mais un générateur imprévisible est difficile à faire sur une machine déterministe comme un ordinateur. Et les logiciels ont des bogues. Une bogue frappait apparemment l'AC eMudhra : les clés générées ne faisaient qu'un octet (le reste étant toujours nul), ce qui ne faisait que 256 clés possibles, rendant triviale une énumération de toutes les clés possibles. L'une d'elles était juste le chiffre 4, que vous trouverez souvent dans les articles sur cette faille.
Le fonctionnement du système X.509 étant ce qu'il est, si on peut générer les clés d'une AC qui est largement présente dans les magasins d'AC de plusieurs systèmes d'exploitation / logiciels / langages, on peut se faire passer pour n'importe qui.
Démonstration avec le service
emudhra.insecureoldshit.com:443. Il n'a pas de
lien avec l'AC eMudhra mais, comme n'importe qui peut générer les
clés « privées » d'eMudhra, il peut se faire passer pour elle. Ne
cherchez pas forcément à vous connecter en HTTPS, c'est
déjà intéressant avec juste du TLS nu. Essayons avec
GnuTLS :
% gnutls-cli emudhra.insecureoldshit.com:443 Processed 152 CA certificate(s). Resolving 'emudhra.insecureoldshit.com:443'... Connecting to '2.29.115.248:443'... - Certificate type: X.509 - Got a certificate list of 3 certificates. - Certificate[0] info: - subject `CN=192.134.4.66:6621,OU=You,O=Penguin Association,C=AQ', issuer `CN=EM OV TLS CA - G3C,O=eMudhra Inc,C=US', serial 0x00, EC/ECDSA key 256 bits, signed using ECDSA-SHA384, activated `2026-10-22 12:35:47 UTC', expires `2026-10-22 12:36:17 UTC', pin-sha256="Ma4OU2jrnyfraVMqehw9AlMFRBOGdaRziAjvPGDwKKc=" Public Key ID: sha1:779bc70e16304e65523397a5e1ccdc14cb673c39 sha256:31ae0e5368eb9f27eb69532a7a1c3d02530544138675a4738808ef3c60f028a7 Public Key PIN: pin-sha256:Ma4OU2jrnyfraVMqehw9AlMFRBOGdaRziAjvPGDwKKc= - Certificate[1] info: - subject `CN=EM OV TLS CA - G3C,O=eMudhra Inc,C=US', issuer `CN=emSign Root TLS CA - G3,O=eMudhra Technologies Limited,C=IN', serial 0x296926c227a3a1526392b19482a504, EC/ECDSA key 384 bits, signed using ECDSA-SHA384, activated `2025-04-30 15:37:41 UTC', expires `2040-04-28 18:30:00 UTC', pin-sha256="Y+zv7kMdSVI7wRNsTnLQIGpHcIbK9gbNXPAlaGwQnPg=" - Certificate[2] info: - subject `CN=emSign Root TLS CA - G3,O=eMudhra Technologies Limited,C=IN', issuer `CN=emSign ECC Root CA - G3,O=eMudhra Technologies Limited,OU=emSign PKI,C=IN', serial 0x00961a3efb1359576ed04005b4684a5b, EC/ECDSA key 384 bits, signed using ECDSA-SHA384, activated `2024-07-11 15:43:36 UTC', expires `2039-07-09 18:30:00 UTC', pin-sha256="xhnkeA7Y4KvtokrXMlZ95Dg6fqlBM49tGn0bSax5L+k=" - Status: The certificate is trusted. - Description: (TLS1.3-X.509)-(ECDHE-X25519)-(ECDSA-SECP256R1-SHA256)-(AES-128-GCM) - Session ID: 8A:5F:E1:E3:6A:6D:00:01:5E:09:1E:78:5B:79:A8:BB:09:31:29:7F:9F:6B:C4:F3:6E:E0:72:F4:8E:45:7C:D2 - Options: - Handshake was completed
Notons plusieurs choses :
CN=192.134.4.66:6621,OU=You,O=Penguin
Association,C=AQ. À la syntaxe du RFC 4514 (qui normalise la forme texte du modèle de données
de X.500), cela veut dire que le nom est
192.134.4.66 (l'adresse IP du client du
service, ici moi), l'organisation est la fictive « Penguin
Association » et le pays est
l'Antarctique. (Rappelez-vous que c'est un
vrai/faux certificat, généré lors de ma connexion.)CN=EM OV TLS CA - G3C,O=eMudhra Inc,C=US)… En fait,
c'est une vraie/fausse signature, faite en récupérant une des clés
privées de eMudhra, grâce à l'énumération des clés
possibles.
Si maintenant je mets à jour mon système (les certificats des AC
sont dans le paquetage Debian ca-certificates) :
% gnutls-cli emudhra.insecureoldshit.com:443 Processed 150 CA certificate(s). Resolving 'emudhra.insecureoldshit.com:443'... Connecting to '2.29.115.248:443'... - Certificate type: X.509 - Got a certificate list of 3 certificates. - Certificate[0] info: - subject `CN=192.134.4.66:8801,OU=You,O=Penguin Association,C=AQ', issuer `CN=EM OV TLS CA - G3C,O=eMudhra Inc,C=US', serial 0x00, EC/ECDSA key 256 bits, signed using ECDSA-SHA384, activated `2026-10-22 12:37:50 UTC', expires `2026-10-22 12:38:20 UTC', pin-sha256="Ma4OU2jrnyfraVMqehw9AlMFRBOGdaRziAjvPGDwKKc=" Public Key ID: sha1:779bc70e16304e65523397a5e1ccdc14cb673c39 sha256:31ae0e5368eb9f27eb69532a7a1c3d02530544138675a4738808ef3c60f028a7 Public Key PIN: pin-sha256:Ma4OU2jrnyfraVMqehw9AlMFRBOGdaRziAjvPGDwKKc= - Certificate[1] info: - subject `CN=EM OV TLS CA - G3C,O=eMudhra Inc,C=US', issuer `CN=emSign Root TLS CA - G3,O=eMudhra Technologies Limited,C=IN', serial 0x296926c227a3a1526392b19482a504, EC/ECDSA key 384 bits, signed using ECDSA-SHA384, activated `2025-04-30 15:37:41 UTC', expires `2040-04-28 18:30:00 UTC', pin-sha256="Y+zv7kMdSVI7wRNsTnLQIGpHcIbK9gbNXPAlaGwQnPg=" - Certificate[2] info: - subject `CN=emSign Root TLS CA - G3,O=eMudhra Technologies Limited,C=IN', issuer `CN=emSign ECC Root CA - G3,O=eMudhra Technologies Limited,OU=emSign PKI,C=IN', serial 0x00961a3efb1359576ed04005b4684a5b, EC/ECDSA key 384 bits, signed using ECDSA-SHA384, activated `2024-07-11 15:43:36 UTC', expires `2039-07-09 18:30:00 UTC', pin-sha256="xhnkeA7Y4KvtokrXMlZ95Dg6fqlBM49tGn0bSax5L+k=" - Status: The certificate is NOT trusted. The certificate issuer is unknown. *** PKI verification of server certificate failed... *** Fatal error: Error in the certificate.
Vous noterez :
Le certificat généré est disponible ici et voici son analyse par OpenSSL. Notez les dates de validité :
% openssl x509 -text -in ../files/emudhra-false-cert.pem
Certificate:
Data:
Version: 3 (0x2)
Serial Number: 0 (0x0)
Signature Algorithm: ecdsa-with-SHA384
Issuer: C=US, O=eMudhra Inc, CN=EM OV TLS CA - G3C
Validity
Not Before: Oct 22 13:21:32 2026 GMT
Not After : Oct 22 13:22:02 2026 GMT
Subject: C=AQ, O=Penguin Association, OU=You, CN=192.134.4.66:63823
Subject Public Key Info:
Public Key Algorithm: id-ecPublicKey
Public-Key: (256 bit)
pub:
04:95:61:11:86:61:1c:97:dd:0f:b5:e3:75:9b:07:
…
ASN1 OID: prime256v1
NIST CURVE: P-256
X509v3 extensions:
X509v3 Authority Key Identifier:
34:EA:EA:0C:EB:C9:0A:DA:F9:D0:C5:E2:ED:9B:78:C9:87:9E:1B:6C
X509v3 Subject Alternative Name:
DNS:eXample.com, DNS:emudhra.insecureoldshit.com, DNS:*.emudhra.insecureoldshit.com, IP Address:192.134.4.66
Signature Algorithm: ecdsa-with-SHA384
Signature Value:
30:66:02:31:00:bd:8a:fa:91:fc:cd:c0:af:9f:85:0b:13:16:
…
-----BEGIN CERTIFICATE-----
MIICIzCCAaigAwIBAgIBADAKBggqhkjOPQQDAzBAMQswCQYDVQQGEwJVUzEUMBIG
…
Si vous tenez à faire du HTTP avec ce service, allez-y, il y a un gag.
D'autres ont utilisé cette possibilité pour permettre de générer de vrais/faux certificats, par exemple mitmproxy avec ce code.
Quelques lectures, si vous voulez apprendre ou approfondir :
Plusieurs mathématiciens en ont profité pour faire remarquer que, contrairement à une simplification courante, 4 n'est pas « moins aléatoire » que, par exemple, 1012818637039180068205. Les deux ont la même probabilité d'être sélectionnés. Le problème vient du fait que les clés ne faisaient qu'un octet, pas spécialement du fait qu'elle avait la valeur 4.
Date de publication du RFC : Octobre 2026
Auteur(s) du RFC : M. Duke (Google)
Pour information
Réalisé dans le cadre du groupe de travail IETF tsvwg
Première rédaction de cet article le 16 octobre 2026
Un RFC un peu inhabituel que voici. Il ne spécifie pas un protocole ou un format, il explique simplement comment activer la notification de congestion (ECN) sur les systèmes d'exploitation courants.
Cette notification (ECN = Explicit Congestion Notification) est normalisée dans le RFC 3168 et permet de signaler en aval de la machine qui met l'ECN qu'elle voit de la congestion. Elle est surtout utilisée avec TCP (où, de toute façon, c'est le noyau qui s'en occupe) mais la normalisation de QUIC (RFC 9000) a suscité davantage d'intérêt pour son utilisation avec UDP, où l'application doit gérer cela elle-même. Apparemment, un certain nombre de programmereuses ne savent pas bien comment mettre de l'ECN sur UDP donc l'auteur de ce RFC a testé pour vous, dans le cadre du développement de Chromium, sur Linux, FreeBSD, macOS et Windows (par la suite, je vais surtout parler de Linux car c'est ce que j'ai testé ; voyez le RFC pour les autres systèmes). Le code de Chromium est en ligne.
Si vous avez la flemme de relire le RFC 3168, il définit deux bits pour l'ECN, qui se trouvent après le champ DSCP (Differentiated Services Code Point, RFC 2474, l'octet qui les contient était appelé ToS - Type of Service - au millénaire précédent) de l'en-tête IP. Si ces deux bits sont à 1, c'est que de la congestion a été vue. (Les options UDP du RFC 9868 sont autre chose, et ne sont pas dans la même couche.)
Outre l'UDP utilisé seul, ce RFC est une bonne lecture si vous mettez en œuvre QUIC (RFC 9000), ou SCTP sur UDP (RFC 9260). Pour ce dernier cas, il semble que ça n'ait pas encore été utilisé. Il y a aussi RTP sur UDP (RFC 6679 et RFC 8888).
Ce RFC ne développe pas de nouvelles API, il explique juste ce qu'on peut faire avec les API actuelles, en C et C++.
Donc, d'abord, si vous voulez recevoir les
notifications (section 3 du RFC), vous devez utiliser
setsockopt avec les options
IP_RECVTOS (en IPv4) ou
IP_RECVTCLASS (en
IPv6) :
result = setsockopt(socketfd, IPPROTO_IPV6, IPV6_RECVTCLASS, &enable, sizeof(enable));
Il faudra ensuite lire le paquet avec recvmsg et
utiliser les messages auxiliaires avec cmsg (type de
message IPV6_TCLASS) :
numbytes = recvmsg(socketfd, &mh, 0);
for (struct cmsghdr * cmsg = CMSG_FIRSTHDR(&mh);
cmsg != NULL; cmsg = CMSG_NXTHDR(&mh, cmsg)) {
if (cmsg->cmsg_level != IPPROTO_IPV6 || cmsg->cmsg_type != IPV6_TCLASS) {
continue;
}
tclass = (int *) CMSG_DATA(cmsg);
(Dans le monde Apple, il faudra plutôt lire leur documentation.)
Et pour envoyer de l'ECN ? La section 4 du
RFC nous dit qu'il faut utiliser
setsockopt pour indiquer la valeur
(apparemment, il faut écrire l'octet complet, DSCP et ECN) :
result = setsockopt
(sd, IPPROTO_IPV6, IPV6_TCLASS, &dscp_value, sizeof(dscp_value))
Si vous voulez le code complet, je l'ai mis dans les programmes
et
udp-ecn-sender.c (uniquement
IPv6). Ils ont évidemment été écrits en lisant le livre de
Stevens et le RFC 3542. Compilons-les et
testons-les :
udp-receiver.c
% make udp-ecn-receiver cc udp-ecn-receiver.c -o udp-ecn-receiver % ./udp-ecn-receiver
et dans une autre fenêtre :
% make udp-ecn-sender cc udp-ecn-sender.c -o udp-ecn-sender % ./udp-ecn-sender --verbose ::1 Connecting to ::1 port 4242... Sending 11 bytes with DSCP 3...
et on voit dans la première fenêtre :
Message received, 11 bytes. Received DSCP 3
Analysé avec tshark, cette communication montre :
Frame 1: 73 bytes on wire (584 bits), 73 bytes captured (584 bits)
…
Internet Protocol Version 6, Src: ::1, Dst: ::1
…
.... 0000 0011 .... .... .... .... .... = Traffic Class: 0x03 (DSCP: CS0, ECN: CE)
.... 0000 00.. .... .... .... .... .... = Differentiated Services Codepoint: Default (0)
.... .... ..11 .... .... .... .... .... = Explicit Congestion Notification: Congestion Experienced (3)
On voit bien que l'expéditeur a dit qu'il voyait de la
congestion. Vous pouvez jouer avec l'option
--ecn de l'expéditeur pour essayer d'autres
valeurs que 3 (les deux bits ECN à 1).
Ces programmes devraient (?) fonctionner sur FreeBSD (mais je n'ai pas testé). Si vous les portez sur Rust ou Zig, le résultat m'intéresse.
Première rédaction de cet article le 11 octobre 2026
Aujourd'hui, la racine du DNS, qui était signée avec la clé 20326 a changé, et utilise désormais la clé 38696.
Rien d'extraordinaire et aucun problème sérieux n'est
attendu. Après tout, ce n'est pas le premier remplacement de la clé
DNSSEC de la racine. Notez que, malgré la
demande de bien des gens, la nouvelle clé est toujours du RSA (alors que les gros
TLD
utilisent souvent ECDSA). La nouvelle clé, 38696, a été
largement publiée depuis longtemps donc est normalement connue de
tous les résolveurs (en particulier grâce au RFC 5011 mais aussi à la mise à jour de
paquetages comme
dns-root-data sur Debian ou
dnssec-anchors sur
Arch).
La situation avant le remplacement peut être vue sur DNSviz, ou bien avec dig :
% dig . DNSKEY
;; Truncated, retrying in TCP mode.
; <<>> DiG 9.18.39-0ubuntu0.24.04.7-Ubuntu <<>> . DNSKEY
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 7696
;; flags: qr rd ra ad; QUERY: 1, ANSWER: 5, AUTHORITY: 0, ADDITIONAL: 1
;; OPT PSEUDOSECTION:
; EDNS: version: 0, flags: do; udp: 1232
;; QUESTION SECTION:
;. IN DNSKEY
;; ANSWER SECTION:
. 83906 IN DNSKEY 256 3 8 (
AwEAAcorNxNc9t0ue1ZenPjVMRujlQ2YLBJ0pR/4XMjH
by9vr03cRxFSKnWpxeg5PL384D9VeqdS1bjrGyTsHtoa
gzI3NiXFd8sjHMOnZxu5pp/+UBIg7tasYgVMMdUiM1Yu
/c+t30d1Qw/v6NYLNnOnywTu6HuUh7Y1sZRq/GZcrxLE
NXHQoyKpOrOr8R3+qd6wK69IKB80ZBZtkX9rdEqKJk+y
YXjEZzZ0zkAFthmNgCreAoU9PVlU66dyOsaLjf3wKUlU
m9SNOKs+tK6LuSmRbK6+1T/tPaRaMBSEuv2G6vXfnJ1u
yMbGvtpRn/YDcvTjrp6DzE6XyF44QdwJ3oKx4ek=
) ; ZSK; alg = RSASHA256 ; key id = 8763
. 83906 IN DNSKEY 256 3 8 (
AwEAAeCYD6Z7WWKVLeuWgowKP+3g+Gs1cnLKq7a3CaQx
Qpv8bfuFVI0WnG33qaSH/Mw9IBgifrdzf4XY/DQLnyBJ
9MfaOyAWuEaEmYJ+GQPiwVVfstGwSA1McfFJUttTgq2H
uu74KARhtA8wPo/N3XcyYQtNhz+qCM5NBb3ecx/naw6s
Yab9LxS6f2cU0q03++BP5Ks0Uef8WJCa/1izCYE+vMkw
oltV+tENa3hpXiZ7jle/xdgaZrPi5ZGmyLVI34g1XVYr
NlsCCTmNvFQIfzW5STFQFsQpizczyFn9r3LzSxxPCNwd
lCG84bER0BmdwqbF6Tanv+FxMOavrahkj4wIy5k=
) ; ZSK; alg = RSASHA256 ; key id = 57780
. 83906 IN DNSKEY 257 3 8 (
AwEAAaz/tAm8yTn4Mfeh5eyI96WSVexTBAvkMgJzkKTO
iW1vkIbzxeF3+/4RgWOq7HrxRixHlFlExOLAJr5emLvN
7SWXgnLh4+B5xQlNVz8Og8kvArMtNROxVQuCaSnIDdD5
LKyWbRd2n9WGe2R8PzgCmr3EgVLrjyBxWezF0jLHwVN8
efS3rCj/EWgvIWgb9tarpVUDK/b58Da+sqqls3eNbuv7
pr+eoZG+SrDK6nWeL3c6H5Apxz7LjVc1uTIdsIXxuOLY
A4/ilBmSVIzuDWfdRUfhHdY6+cn8HFRm+2hM8AnXGXws
9555KrUB5qihylGa8subX2Nn6UwNR1AkUTV74bU=
) ; KSK; alg = RSASHA256 ; key id = 20326
. 83906 IN DNSKEY 257 3 8 (
AwEAAa96jeuknZlaeSrvyAJj6ZHv28hhOKkx3rLGXVaC
6rXTsDc449/cidltpkyGwCJNnOAlFNKF2jBosZBU5eeH
spaQWOmOElZsjICMQMC3aeHbGiShvZsx4wMYSjH8e7Vr
hbu6irwCzVBApESjbUdpWWmEnhathWu1jo+siFUiRAAx
m9qyJNg/wOZqqzL/dL/q8PkcRU5oUKEpUge71M3ej2/7
CPqpdVwuMoTvoB+ZOT4YeGyxMvHmbrxlFzGOHOijtzN+
u1TQNatX2XBuzZNQ1K+s2CXkPIZo7s6JgZyvaBevYtxP
vYLw4z9mR7K2vaF18UYH9Z9GNUUeayffKC73PYc=
) ; KSK; alg = RSASHA256 ; key id = 38696
. 83906 IN RRSIG DNSKEY 8 0 172800 (
20261022000000 20261001000000 20326 .
ARGOmBDyLkr5oQdR5OaIeoeBti1KWEX/LY/jZlRRXwF0
f0eRZaljFpyVKFuZMzpafSYVs7eLOYjVyWJ3iENn4AEh
vX9iaKmWu3XpSSV0D6bhv5D6bk4GVPJ7NGTnA2lr4fC9
lq9UD1kK1Q3jYJsxZSoQgjExDBfzwQUw1eYLLPPi7TQf
+zA1wakHy2mkWnX1+bKDyrQ/p5ra4fgo/Pu7F47FXqRZ
EJ+K9o/TwA+nJn3RMS6dPaS46ERBSWHIeJAzQvNQELI4
pAbdVp3d3N33R2C5MxX6kUzNku8CtyXGYukSi9LK9GT3
nrH9O97tDADq01z78aPnjl+6hLTgMkiupw== )
;; Query time: 2 msec
;; SERVER: 192.168.2.254#53(192.168.2.254) (TCP)
;; WHEN: Sat Oct 10 13:00:22 CEST 2026
;; MSG SIZE rcvd: 1414
Les deux clés (KSK, Key Signing Zone) sont publiées (ainsi que les clés de signature de la zone, ZSK Zone Signing Zone, 8763, et la 57780 qui va bientôt être retirée) mais seule 20326 signe les clés.
Depuis le remplacement, DNSviz nous montre la nouvelle situation. Et avec dig, nous avons (on demande directement à un serveur faisant autorité car les résolveurs ont presque tous encore l'ancienne signature en mémoire) :
% dig @k.root-servers.net . DNSKEY
; <<>> DiG 9.18.39-0ubuntu0.24.04.7-Ubuntu <<>> @k.root-servers.net . DNSKEY
; (2 servers found)
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 35242
;; flags: qr aa rd; QUERY: 1, ANSWER: 4, AUTHORITY: 0, ADDITIONAL: 1
;; WARNING: recursion requested but not available
;; OPT PSEUDOSECTION:
; EDNS: version: 0, flags: do; udp: 1232
;; QUESTION SECTION:
;. IN DNSKEY
;; ANSWER SECTION:
. 172800 IN DNSKEY 256 3 8 (
AwEAAcorNxNc9t0ue1ZenPjVMRujlQ2YLBJ0pR/4XMjH
by9vr03cRxFSKnWpxeg5PL384D9VeqdS1bjrGyTsHtoa
gzI3NiXFd8sjHMOnZxu5pp/+UBIg7tasYgVMMdUiM1Yu
/c+t30d1Qw/v6NYLNnOnywTu6HuUh7Y1sZRq/GZcrxLE
NXHQoyKpOrOr8R3+qd6wK69IKB80ZBZtkX9rdEqKJk+y
YXjEZzZ0zkAFthmNgCreAoU9PVlU66dyOsaLjf3wKUlU
m9SNOKs+tK6LuSmRbK6+1T/tPaRaMBSEuv2G6vXfnJ1u
yMbGvtpRn/YDcvTjrp6DzE6XyF44QdwJ3oKx4ek=
) ; ZSK; alg = RSASHA256 ; key id = 8763
. 172800 IN DNSKEY 257 3 8 (
AwEAAaz/tAm8yTn4Mfeh5eyI96WSVexTBAvkMgJzkKTO
iW1vkIbzxeF3+/4RgWOq7HrxRixHlFlExOLAJr5emLvN
7SWXgnLh4+B5xQlNVz8Og8kvArMtNROxVQuCaSnIDdD5
LKyWbRd2n9WGe2R8PzgCmr3EgVLrjyBxWezF0jLHwVN8
efS3rCj/EWgvIWgb9tarpVUDK/b58Da+sqqls3eNbuv7
pr+eoZG+SrDK6nWeL3c6H5Apxz7LjVc1uTIdsIXxuOLY
A4/ilBmSVIzuDWfdRUfhHdY6+cn8HFRm+2hM8AnXGXws
9555KrUB5qihylGa8subX2Nn6UwNR1AkUTV74bU=
) ; KSK; alg = RSASHA256 ; key id = 20326
. 172800 IN DNSKEY 257 3 8 (
AwEAAa96jeuknZlaeSrvyAJj6ZHv28hhOKkx3rLGXVaC
6rXTsDc449/cidltpkyGwCJNnOAlFNKF2jBosZBU5eeH
spaQWOmOElZsjICMQMC3aeHbGiShvZsx4wMYSjH8e7Vr
hbu6irwCzVBApESjbUdpWWmEnhathWu1jo+siFUiRAAx
m9qyJNg/wOZqqzL/dL/q8PkcRU5oUKEpUge71M3ej2/7
CPqpdVwuMoTvoB+ZOT4YeGyxMvHmbrxlFzGOHOijtzN+
u1TQNatX2XBuzZNQ1K+s2CXkPIZo7s6JgZyvaBevYtxP
vYLw4z9mR7K2vaF18UYH9Z9GNUUeayffKC73PYc=
) ; KSK; alg = RSASHA256 ; key id = 38696
. 172800 IN RRSIG DNSKEY 8 0 172800 (
20261101000000 20261011000000 38696 .
llXxlp+gWc4h/F9G8UPj3VXhNDQoZrco3Piivk7YMKS7
pi8B+CBQHHPO/QNw+VfpNq7CtBDA6gxucyia1ZZx8yM0
oLve7qJKgPuRVNnw5AOegtdxy+NKSy8rT6XNtCdM2gL9
EmqKux+/JNATbZG2efGkVpHuirkq0Vs1bvYglVl6fvHb
qoHpfjbnHVheuKpq+HvdsZOphoEJu74Y4lpYNBNTJijG
gajnJ64AUMPbMfu76uLi68CcWKDGWhzCNeSwnSjK7CA6
aKte5StW61Nuz0Nv8mvzqMX0epPQ7lXJ9Yc/685081Bd
zAYK3yMAfTOqL4EgluNZQAtAAh9bseJVyw== )
;; Query time: 25 msec
;; SERVER: 2001:7fd::1#53(k.root-servers.net) (UDP)
;; WHEN: Sun Oct 11 16:03:26 CEST 2026
;; MSG SIZE rcvd: 1139
Toujours les deux clés publiées, mais seule 38696 signe.
Vu la mémorisation des données par les résolveurs, tout va continuer à marcher comme avant. Voici la situation sur un résolveur quelconque, il reste 83 548 secondes avant l'expiration :
% dig . DNSKEY ;; Truncated, retrying in TCP mode. ; <<>> DiG 9.18.39-0ubuntu0.24.04.7-Ubuntu <<>> . DNSKEY ;; global options: +cmd ;; Got answer: ;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 30170 ;; flags: qr rd ra ad; QUERY: 1, ANSWER: 5, AUTHORITY: 0, ADDITIONAL: 1 ;; OPT PSEUDOSECTION: ; EDNS: version: 0, flags: do; udp: 1232 ;; QUESTION SECTION: ;. IN DNSKEY ;; ANSWER SECTION: . 83548 IN DNSKEY 257 3 8 ( AwEAAaz/tAm8yTn4Mfeh5eyI96WSVexTBAvkMgJzkKTO iW1vkIbzxeF3+/4RgWOq7HrxRixHlFlExOLAJr5emLvN 7SWXgnLh4+B5xQlNVz8Og8kvArMtNROxVQuCaSnIDdD5 LKyWbRd2n9WGe2R8PzgCmr3EgVLrjyBxWezF0jLHwVN8 efS3rCj/EWgvIWgb9tarpVUDK/b58Da+sqqls3eNbuv7 pr+eoZG+SrDK6nWeL3c6H5Apxz7LjVc1uTIdsIXxuOLY A4/ilBmSVIzuDWfdRUfhHdY6+cn8HFRm+2hM8AnXGXws 9555KrUB5qihylGa8subX2Nn6UwNR1AkUTV74bU= ) ; KSK; alg = RSASHA256 ; key id = 20326 . 83548 IN DNSKEY 257 3 8 ( AwEAAa96jeuknZlaeSrvyAJj6ZHv28hhOKkx3rLGXVaC 6rXTsDc449/cidltpkyGwCJNnOAlFNKF2jBosZBU5eeH spaQWOmOElZsjICMQMC3aeHbGiShvZsx4wMYSjH8e7Vr hbu6irwCzVBApESjbUdpWWmEnhathWu1jo+siFUiRAAx m9qyJNg/wOZqqzL/dL/q8PkcRU5oUKEpUge71M3ej2/7 CPqpdVwuMoTvoB+ZOT4YeGyxMvHmbrxlFzGOHOijtzN+ u1TQNatX2XBuzZNQ1K+s2CXkPIZo7s6JgZyvaBevYtxP vYLw4z9mR7K2vaF18UYH9Z9GNUUeayffKC73PYc= ) ; KSK; alg = RSASHA256 ; key id = 38696 . 83548 IN DNSKEY 256 3 8 ( AwEAAcorNxNc9t0ue1ZenPjVMRujlQ2YLBJ0pR/4XMjH by9vr03cRxFSKnWpxeg5PL384D9VeqdS1bjrGyTsHtoa gzI3NiXFd8sjHMOnZxu5pp/+UBIg7tasYgVMMdUiM1Yu /c+t30d1Qw/v6NYLNnOnywTu6HuUh7Y1sZRq/GZcrxLE NXHQoyKpOrOr8R3+qd6wK69IKB80ZBZtkX9rdEqKJk+y YXjEZzZ0zkAFthmNgCreAoU9PVlU66dyOsaLjf3wKUlU m9SNOKs+tK6LuSmRbK6+1T/tPaRaMBSEuv2G6vXfnJ1u yMbGvtpRn/YDcvTjrp6DzE6XyF44QdwJ3oKx4ek= ) ; ZSK; alg = RSASHA256 ; key id = 8763 . 83548 IN DNSKEY 256 3 8 ( AwEAAeCYD6Z7WWKVLeuWgowKP+3g+Gs1cnLKq7a3CaQx Qpv8bfuFVI0WnG33qaSH/Mw9IBgifrdzf4XY/DQLnyBJ 9MfaOyAWuEaEmYJ+GQPiwVVfstGwSA1McfFJUttTgq2H uu74KARhtA8wPo/N3XcyYQtNhz+qCM5NBb3ecx/naw6s Yab9LxS6f2cU0q03++BP5Ks0Uef8WJCa/1izCYE+vMkw oltV+tENa3hpXiZ7jle/xdgaZrPi5ZGmyLVI34g1XVYr NlsCCTmNvFQIfzW5STFQFsQpizczyFn9r3LzSxxPCNwd lCG84bER0BmdwqbF6Tanv+FxMOavrahkj4wIy5k= ) ; ZSK; alg = RSASHA256 ; key id = 57780 . 83548 IN RRSIG DNSKEY 8 0 172800 ( 20261022000000 20261001000000 20326 . ARGOmBDyLkr5oQdR5OaIeoeBti1KWEX/LY/jZlRRXwF0 f0eRZaljFpyVKFuZMzpafSYVs7eLOYjVyWJ3iENn4AEh vX9iaKmWu3XpSSV0D6bhv5D6bk4GVPJ7NGTnA2lr4fC9 lq9UD1kK1Q3jYJsxZSoQgjExDBfzwQUw1eYLLPPi7TQf +zA1wakHy2mkWnX1+bKDyrQ/p5ra4fgo/Pu7F47FXqRZ EJ+K9o/TwA+nJn3RMS6dPaS46ERBSWHIeJAzQvNQELI4 pAbdVp3d3N33R2C5MxX6kUzNku8CtyXGYukSi9LK9GT3 nrH9O97tDADq01z78aPnjl+6hLTgMkiupw== ) ;; Query time: 2 msec ;; SERVER: 192.168.2.254#53(192.168.2.254) (TCP) ;; WHEN: Sun Oct 11 16:31:33 CEST 2026 ;; MSG SIZE rcvd: 1414
Au fur et à mesure que le TTL expire, les résolveurs vont récupérer la nouvelle signature des clés (et, normalement, tout se passera bien, les utilisateurs ne verront rien).
Sinon, si vous voulez une vue plus générale sur les remplacements de clés DNSSEC, je vous recommande l'article de Jan-Piet Mens (en anglais).
Première rédaction de cet article le 8 octobre 2026
Hier, l'ICANN a publié la liste des candidatures pour obtenir un TLD lors du cycle d'enregistrements actuel. Quelques données.
Après un petit traitement du CSV par un script Python bâclé (mais bio) :
% python process.py 2783 applications (1614 if we exclude the replacement strings), by 480 applicants, for 1430 different strings Longest string (17 characters) is superintelligence 27 IDNs, 13 french
2 783 candidatures, donc. L'ICANN annonce 1 615 car certaines candidatures sont des remplacements au cas où la candidature principale ne serait pas retenue (merci à Nicolas Pawlak pour l'explication). Il y a beaucoup de doublons (des candidatures multiples pour une même chaine de caractères, voyez le paragraphe plus loin) et il n'y a donc que 1 430 demandes différentes. (Vous pouvez récupérer la liste.)
Treize ont été déposés par des organisations françaises :
aiagent - THE BEST airliquide - L'Air Liquide, société anonyme pour l'Étude et l'Exploitation des procédés Georges Claude atos - ATOS GROUP SE avocat - ORDRE DES AVOCATS COUR APPEL bpce - BPCE cnp - CNP ASSURANCES cnpassurances - CNP ASSURANCES conex - CONEX SAS ledger - LEDGER mbda - MBDA michelin - Compagnie générale des Etablissements Michelin socialmedia - THE BEST sodexo - SODEXO
Et les doublons ?
20 most demanded: agent: 13 applications brand: 12 applications bit: 11 applications hub: 11 applications zen: 11 applications api: 10 applications human: 10 applications pop: 10 applications robot: 10 applications connect: 9 applications find: 9 applications gym: 9 applications key: 9 applications max: 9 applications mind: 9 applications pod: 9 applications vibe: 9 applications air: 8 applications fix: 8 applications form: 8 applications gen: 8 applications
Notez le succès de l'agent…
27 demandes sont des IDN, tous en caractères chinois à part le
.québec (avec l'accent). Les chinois sont
(merci à Élise Gerriet pour les traductions, mais elle a dû
travailler vite et les erreurs sont
de moi) :
中文网 - Internet 人工智能 - IA 名片 - Carte de visite 品牌 - Marque 商标 - Marque déposée 在线 - En ligne 地址 - Adresse 官网 - Site Internet officiel 抖音 - Douyin, le Tiktok chinois 数字人 智能体 - Agent (au sens de l'agentique de l'IA) 机器人 - Robot 株式会社 - Du japonais (société par actions) 海信 海尔 海尔兄弟 瑞幸 瑞幸咖啡 番茄 - Tomate (?) 红果 - Aubépine (???) 网络 - Internet 购物 - Shopping 酒店 - Hôtel ou bar (c'est différent à Taïwan ou en Chine) 钱包 - Portefeuille (pour les cryptomonnaies ?) 防伪 餐厅 - Restaurant
Et quelles organisations (attention, beaucoup sont des façades comme Charleston qui est en fait Google ou Identity Digital qui a créé une boite écran par candidature) demandent le plus de TLD (ce qui représente une importante dépense, vu les frais de dossier de 227 k$) ?
20 most demanding applicants: Link Freedom Group Ltd: 316 applications XYZ.COM LLC: 278 applications Registry Services, LLC: 153 applications Intercap Registry Inc.: 140 applications Radix Technologies Inc SEZC: 92 applications ShortDot (Ireland) Limited: 80 applications Oinkadot Inc: 50 applications Suffix Inc.: 48 applications NextGEN TLDs GmbH: 44 applications Charleston Road Registry Inc.: 39 applications Aruba PEC S.P.A.: 39 applications Toddler Logic, LLC: 38 applications Pirin Tablet, LLC: 30 applications Squarespace Registry LLC: 30 applications Hair Apparent, LLC: 28 applications XRegistry Incorporated: 28 applications Knock Knock WHOIS There, LLC: 27 applications 101130013 Saskatchewan Ltd.: 26 applications Oyster Dream, LLC: 26 applications ECHO Domain Co L.L.C.: 25 applications Endpoint Domains, Inc.: 24 applications
Première rédaction de cet article le 8 octobre 2026
Dernière mise à jour le 27 octobre 2026
Du 22 au 27 septembre, un inconnu a piraté trois registres de noms de domaine. L'occasion de rappeler, face à plusieurs commentaires erronés, que si un attaquant prend le contrôle du nom de domaine, il peut tout faire (et, non, TLS ne protège pas).
Les faits, d'abord, tels que résumés dans cet
article d'Ars Technica. Un attaquant a piraté, par le biais
d'une faille de sécurité dans le logiciel CoCCA,
trois ccTLD,
.gh,
.sl et
.as. Ayant apparemment
le contrôle complet de la base de données, il pouvait modifier les
noms qu'il voulait, notamment google.TLD. (Voir
le
communiqué de Google.)
On peut confirmer indépendamment cet article avec DNSDB ou un autre service présentant l'historique du DNS. Par exemple pour la Sierra Leone :
% isc-dnsdb-query rrset google.sl/NS ;; bailiwick: sl. ;; count: 105533 ;; first seen: 2010-07-09 12:58:00 -0000 ;; last seen: 2026-10-07 03:41:01 -0000 google.sl. IN NS ns1.google.com. google.sl. IN NS ns2.google.com. google.sl. IN NS ns3.google.com. google.sl. IN NS ns4.google.com. ;; bailiwick: sl. ;; count: 12 ;; first seen: 2026-09-25 04:37:33 -0000 ;; last seen: 2026-09-25 04:47:46 -0000 google.sl. IN NS betty.ns.cloudflare.com. google.sl. IN NS edward.ns.cloudflare.com.
Notez le bailiwick montrant que c'est bien le
TLD qui
était piraté. On voit dans le premier groupe, les serveurs de noms
normaux, chez Google, le deuxième
groupe étant le piratage. Il a été très vite détecté et corrigé, les
pirates devraient savoir que quand on pirate un registre, il ne faut
surtout pas toucher à
google.TLD, c'est le plus surveillé et Google
est très réactif.
Et aux Samoa ?
% isc-dnsdb-query rrset google.as/NS ;; bailiwick: as. ;; count: 10000346 ;; first seen: 2010-06-24 04:28:33 -0000 ;; last seen: 2026-10-08 02:20:05 -0000 google.as. IN NS ns1.google.com. google.as. IN NS ns2.google.com. google.as. IN NS ns3.google.com. google.as. IN NS ns4.google.com. ;; bailiwick: as. ;; count: 549 ;; first seen: 2026-09-27 03:18:09 -0000 ;; last seen: 2026-09-27 05:30:26 -0000 google.as. IN NS duke.ns.cloudflare.com. google.as. IN NS mckinley.ns.cloudflare.com.
Même chose, deux jours plus tard. (Et
google.com.gh, puisque ce
TLD enregistre au troisième niveau de l'arbre
des noms de domaine, le 22
septembre. Merci à Rémy Grünblatt du rappel.)
Certaines personnes, par exemple dans les commentaires à l'article
d'Ars Technica n'ont pas compris les conséquences du piratage
et se sont demandés pourquoi c'est grave puisque TLS aurait protégé de
toute façon. (Notons qu'un commentaire confond registre
de noms de domaine et AC… Il ne
faut pas lire les commentaires si on
ne veut pas devenir misanthrope.) TLS n'aurait pas protégé tout
simplement parce que, quand on contrôle le DNS, on contrôle
tout et on peut obtenir facilement et
automatiquement un certificat (il y a bien
longtemps que les certificats alloués « manuellement », avec examen
par un humain, ne sont presque plus utilisés). C'est ce que dit
l'article d'Ars Technica et on peut le vérifier avec les journaux
Certificate Transparency
(RFC 9162). Si on a la chance de tomber à un
moment où
fonctionne (c'est rare), on peut trouver les certificats créés (je n'en vois pas pour https://crt.sh/google.com.gh) :

Cette difficulté de certains à comprendre l'ampleur des choses qu'on peut faire une fois qu'on a le contrôle d'un TLD est en partie liée au cliché souvent répété « Le DNS, c'est pour traduire des noms en adresses IP ». Ce n'est en fait qu'une partie de son rôle mais le DNS sert à bien d'autres choses. Par exemple, un commentaire a cité la possibilité, pour Google, de mettre un enregistrement CAA (RFC 8659), sans comprendre que cela n'aurait servi à rien pendant le détournement. (Modulo la mémorisation du CAA dans certains résolveurs.) Bref, la sécurité des TLD contre ce genre de piratage est cruciale.
Un autre bon article fait à partir du communiqué de Google est celui d'IT news. Notez que le journaliste a contacté les gérants des trois TLD concernés (et n'a évidemment eu aucune réponse). Depuis, ont été publiés le communiqué du .as et un article sur un site sierraléonais (le titre est ridiculement faux). Vous avez aussi le communiqué de la société CoCCA.
Date de publication du RFC : Octobre 2026
Auteur(s) du RFC : W. Ladd (Akamai
Technologies), M. Dansarie
(Netnod)
Expérimental
Réalisé dans le cadre du groupe de travail IETF ntp
Première rédaction de cet article le 7 octobre 2026
Dernière mise à jour le 14 octobre 2026
Ce nouveau protocole de synchronisation d'horloges, Roughtime est, officiellement, encore expérimental. Deux de ses buts essentiels sont la possibilité d'une synchronisation sécurisée (avec de la cryptographie, donc), même quand le client n'a aucune idée de l'heure et du jour, et un moyen de signaler les erreurs et problèmes rencontrés. Il concernera notamment les objets connectés qui, souvent, n'ont pas de batterie pour garder l'heure pendant un arrêt.
Si vous connaissez NTP (RFC 5905), vous savez qu'il n'offre pas de solution à ces deux problèmes. Roughtime est donc une alternative à NTP. Par contre, Roughtime, comme son nom l'indique, ne donne qu'une heure assez approximative.
La synchronisation des horloges est un problème très ancien sur l'Internet (cf. RFC 738). Elle est à la fois cruciale, notamment en sécurité, et très difficile à réaliser. Pour comprendre son importance en sécurité, pensez par exemple à l'estampillage de journaux. Ou aux signatures DNSSEC. Ou à TOTP (RFC 6238). Ou encore à la vérification qu'un certificat n'est pas expiré. Mais c'est justement aussi cela qui rend difficile de la sécuriser. NTP a un mécanisme de sécurité, NTS, normalisé dans le RFC 8915, mais qui dépend d'un certificat, donc d'avoir l'heure correcte. C'est un intéressant problème d'œuf et de poule : pour vérifier le certificat du serveur de temps, vous avez besoin de connaitre l'heure, justement ce que vous vouliez demander au serveur (section 6 du RFC).
Roughtime, spécifié dans ce RFC 10049, résout le problème en partant d'une liste de serveurs et de leurs clés publiques. Celles-ci sont censées durer assez longtemps pour que, dans la liste des serveurs, il y en ait plusieurs qui soient correctes. En prime, l'utilisation de réponses signées par les serveurs Roughtime permet à un client de prouver à un tiers qu'un serveur est malveillant (ou complètement déconnant ; on ne peut pas distinguer les deux cas). Le client obtient cette preuve en chainant les réponses de plusieurs serveurs. J'insiste : si on n'utilise qu'un seul serveur Roughtime, le client ne peut pas être sûr que l'heure obtenue est correcte. La sécurité ne vient que lorsqu'on a « suffisamment » de serveurs. (Évidemment, s'ils sont tous malveillants ou déconnants, on est fichu. Comme dit lors d'une discussion IETF, « Ideally, you would use 3 servers run by 3 different organizations using 3 different software implementations running on 3 different operating systems in 3 different well guarded buildings in 3 different countries... ».) Cette possibilité de prouver à un tiers qu'un des serveurs ne servait pas l'heure correcte est une importante différence avec un autre concurrent de NTP, Khronos (RFC 9523).
Ce RFC décrit le format des paquets et le protocole mais pour que Roughtime sorte de son statut expérimental, il faudra aussi déployer un écosystème de serveurs et un mécanisme pour obtenir une liste (avec les clés, souvenez-vous). Aucune méthode n'est prévue pour l'instant pour changer les clés, il faudra donc vraiment qu'elles durent longtemps, ou que l'objet connecté puisse facilement mettre à jour de manière sécurisée sa liste de serveurs.
La section 3 du RFC décrit le protocole en termes généraux. Signer les réponses n'est pas suffisant car il faut aussi que la réponse dépende de la requête du client (pour qu'il s'assure qu'on ne lui serve pas une vieille réponse rassise) et qu'on puisse la chainer avec celle des autres serveurs, pour qu'un tiers puisse repérer le serveur qui ne répond pas correctement. S'il n'y a qu'un serveur utilisé, le client peut tout juste vérifier que le message est correctement signé, et correspond à la question (celle-ci inclut un numnique) mais s'il y en a plusieurs (au moins trois), le client peut les comparer et repérer un serveur qui est trop à l'écart (que ce soit par erreur ou par malveillance, en général, on ne peut pas distinguer les deux) et il peut prouver à des tiers cette déviation. Une fois le serveur anormal repéré, on peut le signaler sur un forum, le faire virer des listes de serveurs qui circulent, etc.
La section 4 décrit le format des messages. Parmi les points à noter, la notion d'étiquette (tag). Les valeurs transportées sont toutes étiquetées, chaque étiquette étant sur quatre octets, en général choisis pour être une valeur en ASCII. NONC va ainsi indiquer que la valeur qui suit est le numnique (nonce), VER (avec un octet nul à la fin) indique la version (actuellement version 1), etc. Les étiquettes connues figurent dans un registre IANA et on peut en ajouter selon la politique « Spécification nécessaire » du RFC 8126.
Autre notion cruciale, les valeurs temporelles (timestamp) sont un entier sur 64 bits, indiquant le nombre de secondes depuis le 1 janvier 1970. Le message complet est composé d'un nombre magique (0x4d49544847554f52, ce qui fait "ROUGHTIM"), du nombre de valeurs, d'une liste de décalages des valeurs, d'une liste d'étiquettes, puis des valeurs. Les deux listes sont triées selon l'ordre des étiquettes. La première valeur a pour décalage zéro.
Le message est ensuite transmis en UDP (avec du remplissage obligatoire pour éviter les attaques avec amplification, section 9.7 du RFC). L'algorithme cryptographique est forcément Ed25519, décrit dans le RFC 8032. Il n'y a pas d'agilité cryptographique - RFC 7696, il faudra changer de version du protocole pour, par exemple, passer à la cryptographie post-quantique (section 9.5). Dans une requête, les étiquettes VER (version du protocole), NONC (le numnique du client, qui doit évidemment être aussi imprédictible que possible, cf. RFC 4086) et TYPE (0 pour une requête) sont obligatoires. On peut y ajouter SRV, qui indique la clé publique que le client compte utiliser (cela permet au serveur, entre autres, de sélectionner la bonne clé si on en a plusieurs, mais aussi de voir qu'un client a toujours une vieille clé).
La réponse a les étiquettes NONC (celui qui avait été envoyé par le client), TYPE (1 pour une réponse), SIG (la signature du message), PATH (des valeurs d'un arbre de Merkle décrit plus loin), CERT (un certificat) et SREP (la partie utile de la réponse). La valeur associée à l'étiquette SREP est elle-même un message Roughtime avec notamment les étiquettes MIDP (l'heure sur le serveur, c'est-à-dire l'information principale pour le client), RADI (une estimation de la précision de l'heure, en secondes, donc la précision sera toujours rough, ±1s) et ROOT (la racine de l'arbre de Merkle des réponses, cf. section 5.3 du RFC). L'utilisation d'un arbre de Merkle dans les réponses permet au serveur d'éviter de signer chaque réponse : il peut se contenter de condenser chaque réponse (ce qui est plus rapide que de signer) et de signer seulement la racine de l'arbre. Merci au passage à Kim Minh Kaplan pour avoir corrigé de grosses erreurs dans les explications sur cet arbre.
On peut noter qu'il n'existe pas de réponse pour une requête erronée (pas de FORMERR comme dans le DNS ou de Kiss o' Death comme dans NTP). L'expérience de NTP (section 7.4 du RFC 5905, section 5.4 du RFC 8633 et section 8.3 et 8.7 du RFC 8915) est que cela facilite trop certaines attaques par déni de service en faisant croire qu'un serveur a un problème.
Pour éviter l'ossification du protocole, la section 7 du RFC demande de graisser (RFC 9170) les réponses en envoyant de temps en temps des réponses invalides (absence d'étiquettes obligatoires, par exemple, présence d'étiquettes non définies et surtout heures délibérément incorrectes mais avec des signatures invalides ; un client bien fait ignorera ces réponses - mais pourra réessayer, les autres se feront tromper).
Côté client, maintenant, le protocole prévoit que le client
vérifie les signatures et signale (par un moyen non normalisé) les
serveurs qui s'écarteraient trop des autres. La section 8.4 décrit
un format en JSON pour produire des rapports, au type
application/roughtime-malfeasance+json (avec un
exemple dans l'annexe B) mais, pour l'instant, il n'y a pas
grand'chose de spécifié et encore moins de déployé.
Notez que, si les réponses sont signées, Roughtime ne fournit en revanche aucune confidentialité.
Sur ma machine au logiciel pas tout à fait récent, Wireshark ne connait pas encore Roughtime mais, quand on analyse un paquet, on voit bien la liste des étiquettes (attention, la session utilisait une version temporaire du protocole, en cours de développement) :
Frame 10: 434 bytes on wire (3472 bits), 434 bytes captured (3472 bits)
…
User Datagram Protocol, Src Port: 2002, Dst Port: 47639
Data (392 bytes)
0000 52 4f 55 47 48 54 49 4d 7c 01 00 00 07 00 00 00 ROUGHTIM|.......
0010 40 00 00 00 44 00 00 00 64 00 00 00 64 00 00 00 @...D...d...d...
0020 a8 00 00 00 40 01 00 00 53 49 47 00 56 45 52 00 ....@...SIG.VER.
0030 4e 4f 4e 43 50 41 54 48 53 52 45 50 43 45 52 54 NONCPATHSREPCERT
0040 49 4e 44 58 73 d4 d3 56 32 f7 d1 03 28 31 35 bf INDXs..V2...(15.
0050 18 14 ea 6e 62 74 99 58 ca b2 85 bf 1f 0b ca a1 ...nbt.X........
0060 4e 06 1c 4a ea 0b e0 9c 93 12 5b 7d 79 23 16 c3 N..J......[}y#..
0070 32 d9 41 d9 b0 94 5b 68 c0 e3 f1 c3 61 ab 00 6f 2.A...[h....a..o
0080 58 a8 d9 0c 0b 00 00 80 ac 90 f3 d2 69 b9 f8 d6 X...........i...
0090 7a 0d b7 37 42 e3 27 ab ed e3 fb d2 e8 41 f9 25 z..7B.'......A.%
00a0 75 de be 60 0a d6 59 80 03 00 00 00 04 00 00 00 u..`..Y.........
00b0 0c 00 00 00 52 41 44 49 4d 49 44 50 52 4f 4f 54 ....RADIMIDPROOT
00c0 03 00 00 00 3c 2c c6 6a 00 00 00 00 28 68 0c 3e ....<,.j....(h.>
00d0 99 9c 8d c3 1c 86 9b 1f b9 05 4b 3d a5 92 0d 4c ..........K=...L
00e0 48 4f a0 7c 16 ae e4 1e 0b 24 2e d1 02 00 00 00 HO.|.....$......
00f0 40 00 00 00 53 49 47 00 44 45 4c 45 cc 05 f4 6c @...SIG.DELE...l
0100 56 46 12 eb 4d 45 47 c9 77 21 f4 9b 78 8f 46 2c VF..MEG.w!..x.F,
0110 fa e1 08 8b 49 40 2e 70 e2 c3 15 f1 fe 2e 50 ab ....I@.p......P.
0120 00 ab 77 18 3e f2 e0 56 7b 41 9a 39 78 de 4a e4 ..w.>..V{A.9x.J.
0130 aa 8d bf c8 79 b3 f9 86 75 8a 18 0f 03 00 00 00 ....y...u.......
0140 20 00 00 00 28 00 00 00 50 55 42 4b 4d 49 4e 54 ...(...PUBKMINT
0150 4d 41 58 54 b4 f2 07 3c f9 a5 f4 f0 d2 e5 03 51 MAXT...<.......Q
0160 1a cb b0 31 2f e3 cd 83 b7 14 ef 64 eb bb 9c 3b ...1/......d...;
0170 4c 69 3a ea dc 8e c5 6a 00 00 00 00 5c e0 c6 6a Li:....j....\..j
0180 00 00 00 00 00 00 00 00 ........
Data [truncated]: 524f55474854494d7c0100000700000040000000440000006400000064000000a80000004001000053494700564552004e4f4e4350415448535
2455043455254494e445873d4d35632f7d103283135bf1814ea6e62749958cab285bf1f0bcaa14e061c4aea0be09c93125b7d79231
[Length: 392]
Voyons maintenant les mises en œuvre concrètes de ce protocole, côté client et côté serveur. D'abord, un avertissement : le RFC vient de sortir, le projet de norme a eu plusieurs itérations et vous trouverez donc en ligne divers programmes qui n'interagissent pas toujours entre eux (par exemple, le logiciel client de Cloudflare ne fonctionne pas avec le serveur public de Cloudflare). Il faudra donc attendre un peu que tout soit d'équerre. En attendant, jouons un peu. D'abord, le logiciel de Cloudflare, écrit en Go (vous pouvez aussi lire leur documentation) :
% git clone https://github.com/cloudflare/roughtime.git % cd roughtime % cd cmd/getroughtime % go build main.go % ./main Either provide a configuration via -config or an address via -ping
Ah, c'est logique, rappelez-vous ce que j'ai écrit sur la liste de
serveurs (et leurs clés, cf. sections 8.1 et 8.3 du
RFC). getroughtime sait utiliser une liste écrite en JSON. Le RFC décrit le
format dans sa section 8.3, et on utilise le
type
application/roughtime-server+json si on la
distribue en ligne. Un exemple figure dans l'annexe A. Il y a une
liste fournie dans le logiciel, utilisons-la :
% ./main -config ../../ecosystem.json skipped Cloudflare-Roughtime-2: protocol: response is missing NONC tag skipped int08h-Roughtime: no reply skipped roughtime.se: no reply time.txryan.com: 2026-10-06 09:36:47 +0000 UTC ±3s (in 96ms) Delta: -741ms
Bon, plusieurs des serveurs ne répondent pas, ou pas correctement selon les clients (ma remarque ci-dessus à propos des différentes versions qui trainent). Mais le dernier marche, et on a bien l'heure. Le même logiciel contient aussi un serveur de test :
% cd ../testserver % go build main.go % ./main main.go:64: Root public key: zFVzPprRDxDOMdsrifp+/XPkVkDEhllv6QDJxOWWYd0=
Le serveur tourne (par défaut, sur
127.0.0.1:2002). Notez que le
port officiellement enregistré
à l'IANA est désormais 5319. Et le serveur nous affiche sa
clé. Essayons en indiquant cette clé :
% cd ../getroughtime % ./main -ping localhost:2002 -pubkey zFVzPprRDxDOMdsrifp+/XPkVkDEhllv6QDJxOWWYd0= Ping response: 2026-10-06 11:37:57.754243 +0200 CEST ±1s (in 1ms)
Parfait, tout va bien. Si on avait indiqué une mauvaise clé :
% ./main -ping localhost:2002 -pubkey kMe//FBOFOwPXjx8NYjPtkdlH94IoxAX98RDsiVXcEc= Ping error: protocol: invalid delegation signature
Le client vérifie donc bien les signatures du serveur. Essayons avec un autre logiciel, écrit en C :
% git clone https://github.com/nahojkap/craggy.git % cd craggy % cmake -E make_directory ./build % cmake -S . -B ./build/ -DCRAGGY_WITH_ORLP_ED25519_BINDINGS=ON % cd build % make
Le client ne fonctionne pas avec le serveur de test de Cloudflare (qui meurt avec « main.go:97: Error while handling request: no version in common: [] ») mais il marche avec au moins un serveur public :
% ./cli/craggy-cli -h time.txryan.com:2002 -k iBVjxg/1j7y1+kQUTBYdTabxCppesU/07D4PMDJk2WA= Received reply in 105898μs. (105ms) Current time is 1791281389ms from the epoch, ±3s System clock differs from that estimate by -796785μs. (-796ms)
Il existe aussi d'autres mises en œuvre que je n'ai pas testées,
chez
Google en Go, une autre en C
et une
dernière, en Clojure. Si vous cherchez
des serveurs publics pour tester, vous avez une
liste (pas à jour…) dans le code de Cloudflare. Ou bien vous
en trouvez quelque part sur le réseau, par exemple le serveur expérimental de SIDN. Je
copie la configuration qu'ils indiquent, je l'édite pour changer la
version en IETF-Roughtime (car le client testé ne
connait pas encore la version 1) et ça marche avec le logiciel de
Cloudflare :
% ./main -config /tmp/sidn.json TimeNL-Roughtime: 2026-10-07 17:06:30 +0200 CEST ±3s (in 24ms) Delta: -658ms
Autres lectures :
Première rédaction de cet article le 5 octobre 2026
Du 30 septembre au 2 octobre, j'ai eu le plaisir de participer à la conférence Histories of Tracking à l'université du Luxembourg. Cette conférence était consacrée à la surveillance exercée sur les utilisateurices, notamment dans le contexte du numérique. Voici quelques notes sommaires.
La conférence n'était pas diffusée en ligne ni enregistrée (donc
pas de surveillance possible 🤣). On y retrouvait des vieux
souvenirs comme le champ de l'en-tête HTTP Do Not
Track, jamais réellement respecté par les
serveurs. Sebastian Gießmann a dit qu'aujourd'hui, c'était plutôt
Do Always Track. (La technique de préservation de
la vie privée recommandée
aujourd'hui est le champ Sec-GPC, enregistré
à l'IANA.) ![]()
Matthew L. Jones a commencé par une introduction sur l'histoire de la surveillance via les métadonnées. L'orateur a bien insisté sur le fait frappant que les lois sur la capture de données et la surveillance, même rejetées, finissent toujours par revenir sur la table au premier fait divers. Lutter contre ces lois est épuisant, c'est un jour de la marmotte perpétuel.
Cecilia Passanti a expliqué l'histoire de la biométrie en Afrique depuis les indépendances, lorsque des entreprises européennes comme Sinorg or Gallia profitaient de ces nouveaux marchés, sous prétexte, par exemple, de garantir l'absence de fraude aux élections, pour tester leurs produits, qu'elles allaient ensuite vendre dans le « Nord global ».
Rebecca Ciesielski a parlé entre autres de l'affirmation souvent entendue comme quoi les ordiphones écoutent en permanence et qu'on reçoit ensuite de la publicité en fonction de conversations qu'on a eu près d'un ordiphone allumé. Elle conclut que c'est techniquement possible (les applications doivent notifier qu'elles écoutent mais, si l'écran est éteint, cela ne se voit pas) mais pas prouvé, on n'a que des anecdotes (« je parlais de chaussures de sport avec ma compagne et j'ai eu tout à coup des publicités pour Nike »), et il est difficile de savoir si la régie publicitaire n'avait pas d'autre source (une utilisation d'un moteur de recherche juste avant ?).
Une partie particulièrement intéressante pour moi, car je ne connaissais pas le sujet, a été celle sur la surveillance des animaux. Christoph Borbach a décrit les systèmes de suivi de la faune sauvage, qui doivent être bien acceptés par ces « utilisateurs involontaires ». J'ai appris que les ratons laveurs sont particulièrement efficaces pour retirer leurs dispositifs de surveillance et que les pies coopèrent pour s'enlever ces exaspérants bagues et colliers. Et Vesna Schierbaum a fait un très bon exposé sur un sujet que je ne connaissais pas du tout, le « virtual fencing » ou, au lieu de mettre le bétail derrière des barrières physiques, on équipe les animaux d'un dispositif (connecté à l'Internet) qui les guide. C'est très peu utilisé en Europe mais courant en Argentine, en Nouvelle-Zélande, aux États-Unis, etc. Elle a cité deux entreprises, Monil et Halter. Le plus gros investisseur de la deuxième est Peter Thiel… Outre les questions sur le bien-être animal et sur la déshumanisation du travail des paysans, je note que ces dispositifs sont chers et enferment davantage les fermiers dans la dépendance technologique. Sans compter ce qui se passerait en cas de panne ou de piratage.
Moritz Feichtinger a présenté ses travaux sur les systèmes de surveillance militaires. (Et a rappelé qu'on pouvait déduire beaucoup de choses des métadonnées.) Saviez-vous que l'armée étatsunienne utilisait des drones de surveillance pendant la guerre du Vietnam ? Par contre, contrairement à ce qu'on voit aujourd'hui, en Ukraine, les vidéos n'étaient pas publiées. Un étudiant présent a demandé comment ils pouvaient piloter le drone à distance puisqu'il n'y avait pas encore d'Internet 😊.
La session de clôture a vu Azadeh Akbari présenter un triste bilan de la surveillance en Iran des années 1920 (sous le chah, donc) à aujourd'hui. Dans les prisons (aussi bien celles du chah que celles des mollahs), c'était souvent les prisonniers qui surveillaient, chaque groupe politique ou religieux observant en permanence les membres du groupe.
Ah, et il y a eu aussi l'intervention d'une, artiste, Clio Van Aerde, qui a notamment présenté sa curieuse performance de tour du Luxembourg en suivant strictement la frontière.
De mon côté, je présentais l'évolution, qui est loin d'être linéaire, de la réflexion sur la surveillance et la vie privée à l'IETF, depuis ses débuts. Vous pouvez accéder aux supports (et à leur source, en Typst).
Première rédaction de cet article le 5 octobre 2026
Vous le savez, en ce moment, c'est la fête des fuites de données personnelles en France. Tout le monde (et son chat) a déjà été victime d'au moins une fuite. Au moins, grâce au RGPD, on est informé qu'il y a eu une fuite. Mais que s'est-il passé derrière ? En général, on ne le sait pas. Aucune enquête indépendante publiée et, souvent, rien du tout n'est publié, on doit se fier aux rumeurs propagées par des influenceurs en cybersécurité sur les réseaux sociaux, par des ministres menteurs et par des journalistes ignorants. Mais le piratage de la DGFIP, il est vrai particulièrement scandaleux, fait, lui, l'objet d'une publication assez détaillée, par l'ANSSI.
Je vous recommande fortement la lecture de ce
rapport. Bien sûr, ce n'est pas une enquête indépendante
(l'ANSSI, c'est l'État) mais c'est bien
écrit (il y a beaucoup de sigles spécifiques à l'État mais un
glossaire est présent), sérieux, modeste (l'ANSSI note bien ses
propres faiblesses) et détaillé (attention, certaines parties ont
été censurées par un gros pavé noir). Mais voici quelques points qui
m'ont frappé (le principal étant le fait que ce rapport existe et
ait été publié). 
Le rapport contient un certain nombre de bons avis de sécurité. Mais beaucoup de gens l'ont interprété de manière binaire, s'indignant que le ministère n'ait pas mis en œuvre telle ou telle mesure. C'est oublier le principe de base de la sécurité (pas seulement informatique) : il n'y a pas de solution idéale, seulement des compromis. Par exemple, un EDR (mentionné par l'ANSSI) consomme des ressources informatiques importantes, a des faux positifs (j'en ai vu un protester contre du code binaire SuperH, considéré comme forcément suspect, alors que du code Sparc ou Alpha dans le même répertoire ne posait pas de problème), et peut avoir des bogues (c'était d'ailleurs le scénario du dernier exercice Remparts). Pire, ce sont souvent des logiciels privateurs. Bref, ne pas avoir d'EDR a des inconvénients, en avoir un a des inconvénients. On peut juste choisir son poison.
Le même raisonnement peut être appliqué aux autres conseils de l'ANSSI. Bien sûr, ils sont tous raisonnables mais tous ont un coût, pas seulement financier, mais aussi en gêne des employés pour leur travail. Les organisations qui déploient les mesures citées ont souvent été victimes d'une « auto-attaque par déni de service », les mesures de sécurité empêchant de travailler.
J'ai quand même trouvé que le cas cité par le rapport d'une soi-disant « authentification à deux facteurs » qui consistait en l'envoi par courrier du second facteur… alors que le courrier était traité sur la machine qui servait à se connecter, était en effet assez incroyable. Si les deux facteurs sont sur la même machine, ce ne sont pas réellement deux facteurs (le rapport insiste, à juste titre, sur ce point).
Le rapport détaille les techniques mises en œuvre mais pas l'arrière-plan organisationnel. Par exemple, au moins une partie des accès pirates ont été faits depuis le ministère de l'Éducation nationale, apparemment moins protégé, mais le rapport ne dit pas pourquoi ce ministère avait accès aux données des impôts. Même chose pour des accès par des entités privées extérieures (comme le géomètre-expert mentionné dans le rapport).
La sécurité ne dépend pas uniquement du budget (on peut avoir un budget très élevé et le dépenser essentiellement dans du théâtre sécuritaire, par exemple l'achat de dispositifs techniques très chers, opaques mais bénéficiant d'un bon marketing). Mais il ne faut pas se faire d'illusion, la sécurité aura un coût : si on déploie toutes les mesures proposées par le rapport, il faudra embaucher beaucoup de fonctionnaires (par exemple pour les investigations suite à une alarme). Les mêmes politiciens qui s'indignent « comment se fait-il qu'il n'y ait pas davantage de sécurité dans les ministères » seront peut-être les premiers à râler si on leur demande d'augmenter le budget de l'État.
Je recommande de bien lire le rapport jusqu'au bout, les annexes contiennent des détails précis, notamment chronologiques. Ils montrent que de nombreuses alarmes avaient été levées et traitées, mais que l'ampleur et le sérieux de l'attaque n'avaient pas été clairement notés (le fameux problème de « relier les points »).
GuiGui a répondu à certains points de cet article.
Auteur(s) du livre : Jim Hall
Éditeur : Apress / Springer
978-8-8688-2930-7
Publié en 2026
Première rédaction de cet article le 30 septembre 2026
Dernière mise à jour le 4 octobre 2026
Aujourd'hui, bien des gens croient que la seule façon d'écrire un texte (sans le faire générer par un LLM) est d'utiliser un logiciel de traitement de texte graphique comme Writer. Mais il existe une autre méthode, plus ancienne mais toujours valable, les langages de marquage. C'est pour cela que j'ai acheté ce livre, qui retrace l'histoire de ces langages de marquage et vise surtout leur utilisation pour l'écriture de textes technique et scientifiques.
Je le dis tout de suite, j'ai été déçu. Le livre est cher (un peu moins en EPUB ou PDF mais quand même) pour un contenu qui semble surtout fait de divers articles de blog mis bout à bout. Certains de ces articles sont très intéressants, parlant de sujets peu ou pas abordés dans la plupart des sources, mais d'autres sont vraiment minces (TeX et LaTeX expédiés en 16 pages, dont de longs copier-coller de la sortie de ces programmes très bavards, ce qui est tout à fait inutile). De même, l'auteur a choisi de publier l'intégralité des programmes d'exemple. Ces programmes sont une très bonne idée, ils rendent plus concrets les cas discutés mais les mettre dans le livre, plutôt que sur un site Web à part, était une mauvaise idée.
Le livre commence avec Runoff, ancêtre de ces langages de marquage. Vous plongerez dans l'archéologie avec ce système, créé « juste après que nous ayons cessé de chasser les mammouths avec des outils de pierre ». (Vous pouvez d'ailleurs lire sa très intéressante histoire sur le blog de l'auteur.) Runoff date de l'époque où les impressions sortaient d'une grosse imprimante à laquelle les utilisateurs n'avaient pas accès directement. Pour vous dire mon âge, j'ai travaillé avec un tel système à l'INRETS dans les années 1980 et il y avait encore des opérateurs dont le principal travail était de sortir les listings de l'imprimante et de les déposer dans des casiers au nom des utilisateurs. Runoff était écrit en MAD et vous avez du code source en MAD p. 14 à 16. Dans les pages suivantes, l'auteur ré-implémente Runoff en C. L'exercice est intéressant (et fournira sans doute des bonnes idées de travaux pratiques à bien des enseignants) mais est sans doute trop détaillé, surtout si vous connaissez déjà C. L'auteur dit que cette partie est lisible par quelqu'un qui n'est pas programmeur, que tout est expliqué, ce qui est vrai mais me laisse quand même sceptique. C n'est pas le langage le plus lisible…
Puis Runoff évolue, des descendants apparaissent, l'auteur détaille nroff et même ses macros -ms. (Là encore, point personnel, j'ai écrit des documentations en -ms. Des RFC ont été écrits avec nroff, cf. RFC 2223, section 20.) Autant cette partie est importante historiquement, autant lister autant de macros -ms était à mon avis excessif.
Puis le monde change et les traitements de
texte modernes apparaissent. (Mais sans jamais avoir
remplacé les langages de marquage.) Le premier cité est évidemment
WordStar. J'apprends dans ce livre qu'en plus
de ses menus, il avait aussi des marques (dot
commands), très inspirées de celles de nroff, comme les
premiers navires à vapeur, qui gardaient mâts et voiles au cas
où. On pouvait donc formater ses documents Wordstar avec des
.PA et .HE inclus dans le
texte (p. 155 à 156)… L'auteur décrit ensuite le format sous lequel
WordStar enregistre ses documents et écrit un programme en
C pour les lire. (Les
logiciels de traitement de texte modernes ont un format bien trop
complexe pour que cet exercice soit encore réaliste.) Parmi les
points rigolos de ce format, le remplissage
pour que tout fichier, même vide, contienne toujours un multiple de
128 octets, ce qui facilitait la tâche du programme de
relecture. (Dans cette heureuse époque où on lisait en C des
fichiers venus de l'extérieur sans se demander s'ils ne
déclencheraient pas une faille de sécurité latente.) Mais bon, là
encore, avoir mis tout le code source dans le livre est une mauvaise
idée. (Même remarque pour les affichages de débogage, avec
l'intégralité des octets de remplissage, p. 177.)
Le livre détaille aussi l'histoire de l'impression puisque, à l'époque, il n'était guère envisageable de lire un long texte sur l'écran (et du temps de Runoff, on n'avait même pas toujours un écran). Le papier était donc crucial, et le livre explique le fonctionnement d'une imprimante matricielle puis crée une émulation en logiciel (toujours en C) d'une telle imprimante, permettant d'afficher sur l'écran à quoi aurait ressemblé un texte imprimé sur une telle machine. S'il y a dans ce livre de nombreuses pages passionnantes sur des points peu connus, là encore, l'auteur détaille trop.
Enfin on en arrive à HTML mais la partie sur le Web contient vraiment des erreurs énormes. Dire (p. 231) que le premier navigateur Web date de 1994 alors qu'il a cinq ans de plus, par exemple. Ou ne pas citer le CERN une seule fois et prétendre que le Web a été inventé à l'UIUC, ce qui est grave. Sinon, sur le Web, notez qu'on peut parfaitement écrire des documents complexes, y compris des livres, joliment formatés avec les techniques du Web comme le fait C&F Éditions. L'auteur décrit aussi Markdown, une alternative légère à XML et HTML (RFC 7764), et développe un logiciel de conversion de Markdown vers HTML.
Le livre se termine par une présentation du système de gestion de documents XML DITA dont je ne vois pas trop l'intérêt, il ne semble pas faire grand'chose de plus que XInclude ou des techniques similaires comme les entités XML. Puisqu'on parle de XML, j'en profite pour me faire de la publicité et dire que mon livre a été écrit en XML.
Le livre concerne surtout le passé, vous n'y trouverez pas des systèmes récents comme Typst. Les langages de marquage ne sont pas une survivance du passé mais un domaine très actif et très utilisé (par exemple pour ce blog).
Plusieurs personnes ont proposé des ajouts intéressants à cet article. Thierry Stoehr recommande de lire les articles sur le blog de l'auteur, qui parle de beaucoup de sujets liés à l'écriture, entre autres de documentation technique (comme cet article sur le Linotron). Il recommande aussi les vidéos de Computerphile comme celle sur SGML, XML et HTML.
De son côté, Bertrand Petit recommande, sur les techniques d'impression, « Literature for Composing Linecasters » et « Photocomposition Systems », ainsi qu'une série de vidéos. Il suggère aussi un article sur la reconstruction d'un article historique Joe Condon, Brian Kernighan et Ken Thompson, « Experience with the Mergenthaler Linotron 202 Phototypesetter, or, How We Spent Our Summer Vacation ».
Date de publication du RFC : Septembre 2026
Auteur(s) du RFC : R. Stepanek (Fastmail), M. Loffredo (IIT-CNR)
Chemin des normes
Réalisé dans le cadre du groupe de travail IETF calext
Première rédaction de cet article le 24 septembre 2026
La norme JSContact décrit un modèle de données et un format pour stocker des informations de contact sur une entité (personne physique ou morale). Elle est riche, avec beaucoup d'informations dont toutes les applications n'ont pas forcément besoin. Ce RFC normalise la notion de profil : un profil est une spécialisation de JSContact, indiquant les éléments obligatoires et les autres. Un nouveau registre IANA stocke les profils existants.
JSContact est normalisé dans le RFC 9553. Il peut servir par exemple comme modèle de données et format pour un carnet d'adresses, ou dans des protocoles d'accès à l'information sur les contacts d'un objet enregistré, comme RDAP (RFC 9083). On peut échanger du JSContact avec des protocoles comme CardDAV (RFC 6352) ou JMAP (RFC 9610). JSContact vise à remplacer vCard (RFC 6350) et sa déclinaison jCard (RFC 7095), complexes et difficiles à traiter.
Mais JSContact a ses propres complications ; comme il a un modèle de données riche, pour pouvoir gérer tous les cas prévisibles, une mise en œuvre de JSContact doit traiter des données même quand l'application n'en a pas l'usage (sans compter les problèmes de vie privée que peut poser cette absence de minimisation des données). Le RFC 9553 permet d'ignorer certaines données, mais uniquement celles d'extension de JSON, pas les données du cœur.
La solution de notre RFC est de permettre la définition de profils, un profil étant une définition de ce qui est nécessaire dans un objet JSContact. Ainsi, une application qui n'a besoin que de peu de données peut utiliser JSContact au lieu de définir son propre format. Le registre central permettra de trouver et de référencer facilement les profils. (Aujourd'hui, aucun n'est enregistré.)
Un profil est donc un ensemble d'éléments JSContact, stocké dans le registre IANA. Il a un nom (restreint à ASCII). Notez bien qu'un même objet JSContact peut être valide selon plusieurs profils et c'est pour cela que le profil n'est pas affiché dans l'objet.
Un profil liste plusieurs propriétés, qui ont notamment un nom, un contexte (à quel type d'objets s'applique le profil), des restrictions sur les attributs… Par exemple, cette propriété :
Property Name: kind Property Context: Card Restricted Enum Values: individual,org
s'applique aux objets
Card et dit que kind (RFC 9553, section 2.1.4) ne peut être que
individual ou org (et pas,
comme normalement en JSContact, group,
application, etc).
Je l'ai dit, le registre actuel est vide donc, pour avoir des exemples, il faut regarder les annexes A.1, A.3 et A.4 (profil) ainsi que A.2 (objet JSContact correspondant à ce profil) du RFC. Pour ajouter des profils au registre, la politique à suivre (RFC 8126) est « Spécification nécessaire ».
Date de publication du RFC : Septembre 2026
Auteur(s) du RFC : F. Denis (Fastly), S. Lucas
Pour information
Réalisé dans le cadre du groupe de recherche IRTF cfrg
Première rédaction de cet article le 19 septembre 2026
L'imagination des cryptologues est sans fin, voici une nouvelle famille d'algorithmes de chiffrement, fondés sur le classique AES, la famille AEGIS (qui, au moment d'écrire cet article, n'a pas encore de page Wikipédia). AEGIS permet de réutiliser le jeu d'instructions AES mais est plus rapide qu'AES et fournit du chiffrement intègre.
AEGIS est issu du concours CAESAR. Il existe en plusieurs versions, AEGIS-128, AEGIS-128L, AEGIS-128X, AEGIS-256 et AEGIS-256X (ils sont désormais dans le registre IANA des algorithmes de chiffrement intègre). Comme leurs noms l'indiquent, ces algorithmes diffèrent par la taille des clés utilisées mais tous utilisent les fonctions de base d'AES (norme NIST.FIPS.197-upd1), ce qui leur permet d'utiliser les mises en œuvre matérielles d'AES. AEGIS peut être vu comme de l'AES plus rapide.
En outre, AEGIS est normalement plus sûr qu'AES en mode GCM (les autres modes d'AES n'offrent pas de chiffrement intègre et ne sont donc pas vraiment comparables). Avec AES-GCM, on peut trouver des textes chiffrés qui se déchiffrent correctement avec plusieurs clés, ce qui facilite certaines attaques (cf. « Partitioning Oracle Attacks). Ce n'est pas possible avec AEGIS. D'autre part, la clé utilisée ne sert qu'au tout début, le chiffrement ou déchiffrement sera fait après une dérivation, on pourra donc effacer la clé de la mémoire rapidement, diminuant les risques qu'un méchant ne la copie.
Si vous voulez en savoir plus, ne comptez pas sur mes faibles connaissances en cryptographie, lisez les sections 2 à 8 du RFC, qui expliquent les algorithmes de la famille AEGIS, avec pseudo-code. Puis, pour approfondir, « Analyzing the Linear Keystream Biases in AEGIS », « Guess-and-Determine Attacks on AEGIS », « Weak Keys in Reduced AEGIS and Tiaoxin » ou « MILP-based security evaluation for AEGIS/Tiaoxin-346/ Rocca ».
AEGIS est aujourd'hui mis en œuvre dans plusieurs bibliothèques logicielles, dans de très nombreux langages de programmation. Si vous voulez contribuer à ces codes, ou bien en créer un nouveau, n'oubliez pas de tester avec les vecteurs de test de l'annexe A (également disponibles en ligne).
Les fans de cryptologie liront avec plaisir la section 9 qui analyse les problèmes de sécurité potentiels d'AEGIS. J'ai noté que cette section estime qu'AEGIS est résistant aux calculateurs quantiques, en tout cas s'il n'y a pas de lien quantique avec le système qui fait tourner AEGIS (ce qu'on appelle traditionnellement le « modèle Q1 d'attaquant », le modèle Q2 étant un attaquant complètement quantique).
Première rédaction de cet article le 18 septembre 2026
Le 16 septembre 2026 est sortie la version 18 d'Unicode. Une description officielle des principaux changements est disponible mais voici ceux qui m'ont intéressé particulièrement. (Il n'y a pas de changement radical.)
Pour explorer plus facilement la grande base Unicode, j'utilise un programme qui la convertit en SQL et permet ensuite de faire des analyses variées. Faisons quelques requêtes SQL :
ucd=> SELECT count(*) AS Total FROM Characters; total -------- 172873
Combien de caractères sont arrivés avec la version 18 ?
ucd=> SELECT version,count(version) FROM Characters GROUP BY version ORDER BY version::float; ... 15.0 | 4489 15.1 | 627 16.0 | 5185 17.0 | 4803 18.0 | 13007
13 007 nouveaux caractères, c'est beaucoup par rapport aux précédentes versions, mais ce sont presque tous des sinogrammes du petit sceau. Autrement, quels sont ces nouveaux caractères ?
ucd=> SELECT To_U(codepoint) AS Code_point, name FROM Characters WHERE version='18.0' ORDER BY Codepoint; code_point | name -----------+---------------------------------------------------------------------------- … U+20C3 | UAE DIRHAM SIGN U+20C4 | OMANI RIAL SIGN … U+A7E2 | LATIN CAPITAL LETTER R WITH LONG LEG … U+10EF3 | ARABIC SMALL HIGH NOON WITH FATHA … U+12477 | CUNEIFORM NUMERIC SIGN ASH TIMES ONE DISH TENU … U+18E17 | JURCHEN CHARACTER-18E17 … U+1FA8B | METEOR U+1FA8C | ERASER U+1FA8D | NET WITH HANDLE U+1FACC | MONARCH BUTTERFLY U+1FADD | PICKLE … U+3D005 | SEAL CHARACTER-3D005 …
On y voit quelques nouveaux caractères, ainsi que les trois nouvelles écritures de cette version d'Unicode, les anciens chiffres cunéiformes, le jurchen et le petit sceau. Et il y a aussi quelques changements de comportement, qui nécessiteront un peu de mise à jour des bibliothèques logicielles.
En plus futile, il y a l'habituelle arrivée d'emojis comme le cornichon (comme dans la chanson) et le météore. Le trognon de pomme n'a toujours pas été intégré (il avait déjà été retiré d'Unicode 17).
Si vous avez les bonnes polices de caractères, vous allez pouvoir voir quelques exemples (sinon, le lien mène vers Uniview). Voici par exemple, le rial omanais , une nouvelle lettre R utilisée pour le xhosa, , une marque utilisée pour l'arabe, un chiffre cunéiforme , une lettre jurchen , une lettre du petit sceau , la gomme et le monarque .
Et sinon, en bien plus détaillé qu'ici, vous pouvez aussi lire l'article d'Ysabeau.
Date de publication du RFC : Septembre 2026
Auteur(s) du RFC : T. Wiggers (PQShield), K. Bashiri
(BSI), S. Kölbl (Google), J. Goodman
(Crypto4A Technologies), S. Kousidis
(BSI)
Pour information
Réalisé dans le cadre du groupe de travail IETF pquip
Première rédaction de cet article le 15 septembre 2026
Certains algorithmes de cryptographie sont à état, c'est-à-dire que les programmes qui les utilisent doivent se souvenir des exécutions précédentes de l'algorithme ; refaire tourner l'algorithme dans les mêmes conditions serait une faille de sécurité. Cette nécessité de mémoriser un état complique évidemment leur utilisation. Ce nouveau RFC documente les bonnes pratiques à ce sujet.
La question des algorithmes à état est particulièrement cruciale dans le contexte de la cryptographie post-quantique. Un problème de beaucoup d'algorithmes post-quantiques est la grande taille de leurs clés et de leurs signatures, ce qui pose problème pour certaines applications sur l'Internet. Une solution possible serait d'utiliser des algorithmes comme ceux fondés sur la condensation, qui ont des clés et des signatures de taille plus raisonnable, et reposant sur ces algorithmes de condensation, qui sont bien connus. Mais ces algorithmes sont à état, ce qui est vraiment pénible à gérer.
Il existe plusieurs algorithmes dans cette famille fondée sur la condensation : LMS (Leighton–Micali Signatures), HSS (Hierarchical Signature System), XMSS (eXtended Merkle Signature Scheme), etc. Tous résistent aux futurs calculateurs quantiques mais tous ont un défaut : signer deux fois avec la même clé permet à la cryptanalyse de découvrir la clé privée. Il faut donc dériver une nouvelle clé à chaque signature et se souvenir des clés précédentes, pour ne pas risquer de réutilisation. C'est évidemment très contraignant et cela explique pourquoi, par exemple, ces algorithmes n'ont pas été sérieusement envisagés pour DNSSEC.
Si vous voulez vous instruire sur ces algorithmes utilisant la condensation, lisez les RFC 8391 (sur XMSS), RFC 8554 (sur LMS) et la norme NIST SP 800-208. Dans ces algorithmes, la clé privée est en fait une série de clés, partant d'une graine et créées par dérivations successives. L'état est simplement un index vers cette liste, indiquant la dernière clé utilisée. Si on réutilise une clé, on dévoile la graine. Il est donc très important de garder trace de l'index, de l'état. À chaque signature effectuée, il faut le mettre à jour. Imaginez par exemple un dispositif de signature qui signerait, diffuserait le message signé mais subirait ensuite une coupure de courant qui l'empêcherait de mettre à jour l'état. Une fois le courant revenu, la signature suivante utilisera le même index, donc la même clé et paf, le ou la cryptanalyste qui lira les deux signatures et connait la clé publique pourra trouver la graine, donc la clé privée. (Si ça vous semble magique, lisez « State Management for Hash- Based Signatures », « State management for stateful authentication mechanisms », « Oops, I did it again – Security of One-Time Signatures under Two-Message Attacks » et « Oops, I did it again revisited: another look at reusing one-time signatures ».) Notre RFC est donc consacré à décrire les mesures qui peuvent empêcher cette situation. Il faut s'assurer que l'état est bien mis à jour à chaque signature, que, dans le cas où il y a plusieurs signeurs, ils ne puissent jamais utiliser la même clé et que si on restaure les sauvegardes, on ne se trouve pas à réutiliser une clé. C'est compliqué ? Oui, et c'est pour cela que les algorithmes à état sont peu populaires. (Ils avaient été envisagés pour DNSSEC mais avaient fait peur à tout le monde.) Comme le note la section 1.1 du RFC, ces algorithmes ne conviennent pas pour un usage généraliste, il faut les réserver à des cas bien précis.
On peut même se demander pourquoi ces algorithmes n'ont pas été jetés à la poubelle tout de suite. C'est parce qu'ils ont quand même certains avantages, comme des tailles de clés et de signatures raisonnables. (DNSSEC, cité plus haut, ne peut pas envisager les énormes clés et signatures de ML-DSA.) Un exemple d'utilisation des systèmes à état est donné dans le RFC 9802.
La section 2 du RFC rappelle la terminologie utilisée. La clé privée à proprement parler est la graine dont dérivent les clés de signature. Elle-même est sans état et a potentiellement une longue durée de vie. Elle se gère comme n'importe quelle clé privée (donc, vous ne la mettez pas sur GitHub). L'état est au contraire à courte durée de vie et est mis à jour à chaque signature. Sa gestion (le mettre à jour, le sauvegarder, le distribuer…) est toute la difficulté des algorithmes de cryptographie à état.
Place à la pratique en section 3. Par exemple, les sauvegardes. Sauvegarder une clé qui peut servir pendant 10 ou 20 ans est une chose. Mais, ici, il faut sauvegarder du matériel cryptographique qui change tout le temps, puisque sauvegarder l'état est indispensable. La section 3.2 est une bonne lecture si vous vous intéressez aux questions de préservation de contenu numérique.
Mais il y a aussi le problème des procédures à suivre. Gérer des clés avec état est plus complexe et nécessite du personnel qualifié et consciencieux. Cela a des conséquences lorsqu'on calcule le coût total d'une solution cryptographique. D'autant plus que la sécurité peut nécessiter davantage de personnel, par exemple lorsqu'on déploie une solution M-sur-N pour contrer le risque d'une attaque menée de l'intérieur.
La section 4 liste les conséquences de ces exigences sous forme d'exigences ACID : la solution déployée doit permettre des transactions tout-ou-rien : l'utilisation de la signature et la mise à jour de l'état doivent être dans la même transaction (atomicité).
Suivre ces exigences en logiciel va être difficile : il peut y avoir une mémorisation de certaines informations, ce qui signifie que la version stockée sur un support stable n'a pas été mise à jour, il peut y avoir copie d'une machine virtuelle vers une autre, l'état étant alors dupliqué, etc. Le RFC conseille de plutôt utiliser un composant matériel dédié pour cette tâche délicate de maintien de l'état. Mais si vous voulez vraiment étudier la question en détail, et notamment les différents moyens d'atteindre nos objectifs, la section 5 discute de nombreuses solutions possibles.
Le RFC note aussi que ces exigences ne s'appliquent qu'au signeur. Le vérificateur des signatures, lui, peut complètement ignorer le problème et ne pas connaitre l'état.
Première rédaction de cet article le 9 septembre 2026
Hier, j'ai cherché à faire un lien
symbolique « immuable » sur
Linux, plus exactement un lien que son ou sa
propriétaire ne risquerait pas de supprimer par accident, tout en
lui permettant de créer et détruire d'autres objets dans ce
répertoire. Si vous connaissez Linux, vous allez probablement crier
« chattr +i, chattr
+i ! ». Mais, non, cela ne marche pas.
Essayons quand même, sur le compte d'un utilisateur nommé Bob. D'abord avec un fichier ordinaire :
$ echo "Contenu sans intérêt" > myfile $ sudo chattr +i myfile $ ls -l myfile -rw-rw-r-- 1 bob bob 23 Sep 9 15:12 myfile $ lsattr myfile ----i---------e------- myfile $ rm myfile rm: cannot remove 'myfile': Operation not permitted
Parfait, tout marche (une alternative à sudo aurait été
la capacité
CAP_LINUX_IMMUTABLE mais c'est une autre
histoire). Essayons maintenant avec un lien symbolique :
$ ln -s /etc/motd mylink $ sudo chattr +i mylink chattr: Operation not supported while reading flags on mylink
Bon, c'est raté, chattr ne marche pas sur les liens symboliques. (Le message exact dépend de votre libc ; vous aurez peut-être plutôt « Symbolic link loop ».) En tout cas, ça ne marche pas sur Linux. (Il parait que cela fonctionne sur FreeBSD.)
Comment faire, alors ? Changer le propriétaire du lien ne change rien car la suppression est une opération sur le répertoire. Le propriétaire du répertoire peut supprimer des fichiers qui ne lui appartiennent pas. Et changer le propriétaire du répertoire ne suffit pas, car on veut que Bob puisse continuer à lire et à écrire dans ce répertoire. Le sticky bit seul ne suffirait pas non plus, il empêche de supprimer les fichiers des autres, pas les siens.
ChatGPT a finalement trouvé une solution, mais à la troisième itération, après quelques idées qui ne marchaient pas (ChatGPT, comme tout utilisateur des réseaux sociaux, ne teste pas ses idées avant de les publier ; « You're right », « Yes. Your suspicion is exactly correct ») :
$ ln -s /etc/motd mylink $ sudo chown root:bob . $ sudo chmod +t . $ sudo chmod g+w . $ sudo chown --no-dereference root:root mylink $ rm mylink rm: cannot remove 'mylink': Operation not permitted $ ls -alt total 8 drwxrwxr-t 2 root bob 4096 Sep 9 15:26 . lrwxrwxrwx 1 root root 9 Sep 9 15:26 mylink -> /etc/motd drwxr-x--- 3 bob bob 4096 Sep 9 15:25 ..
Détaillons cette solution. On met
root comme propriétaire
du répertoire (on peut aussi utiliser un autre utilisateur que
root) mais le groupe est bob, un groupe
qui inclut Bob. On met ensuite le sticky bit. On
donne au groupe le droit d'écriture dans le répertoire. Et enfin on
change le propriétaire du lien pour que cela ne soit pas Bob (notez
le --no-dereference sans lequel
chown essaierait de changer la
cible du lien et pas le lien). Et Bob ne peut plus supprimer le
lien, tout en pouvant lire et écrire dans le répertoire.
Première rédaction de cet article le 5 septembre 2026
En 1981, la société BBN a écrit pour la DARPA (ex-ARPA) un rapport de 184 pages « A history of the Arpanet - The first decade » qui faisait le bilan des dix (en fait plutôt onze et demi) premières années du réseau Arpanet. Cela reste un des meilleurs documents pour celles et ceux qui veulent comprendre comment marchait l'Arpanet, qui n'était pas du tout un Internet en plus petit, mais un réseau assez différent.
Rappelez-vous la date, 1981. Le rapport
est tapé à la machine et vous ne trouverez
pas de version
machine-readable, vous
n'aurez qu'une image. 
Le rapport détaille les objectifs (vous n'y trouverez pas la légendaire « nécessité de résister à une attaque nucléaire »), l'histoire, et la technique. Arpanet était très expérimental et les débuts ont été plutôt agités.
Contrairement à l'Internet, l'Arpanet
était un réseau très homogène (je parle du réseau, pas des
ordinateurs qui y étaient connectés) et très centralisé. Par
exemple, tout l'Arpanet était supervisé depuis un point unique (le
routage, par contre, était décentralisé). Et le
choix des liens entre les sites était décidé centralement, optimisé
par un programme développé spécialement (dont l'histoire ne semble
pas avoir gardé le code source…). La technique a évidemment beaucoup
progressé et on rit aujourd'hui des efforts pour développer du
matériel spécifique nécessaire pour calculer des sommes
de contrôle à la vitesse ébouriffante de 50 kb/s. Bon,
je rigole mais il faut se rappeler que, pour les concepteurs de
l'Arpanet, presque tout était nouveau et que plein de choses ont dû
être inventées. Le code des IMP (en très gros
l'équivalent des routeurs)
était écrit en langage d'assemblage, pour les
performances, et très optimisé. 
Le rapport est globalement positif mais il est intéressant de noter qu'il mentionne aussi les points où l'Arpanet a des problèmes et des limites : le problème de la congestion (qui ne sera traité que bien plus tard, le rapport parle d'ailleurs du développement de TCP), la difficulté à concevoir des protocoles pour les machines terminales (les IMP étaient tous identiques donc leur cas était plus facile) ou la difficulté de la gestion centralisée des ressources (la liste des services disponibles aurait dû être un document unique, centralisé, ce qui a craqué rapidement).
Si certains points portent la marque de leur époque et font
sourire aujourd'hui, d'autres sont toujours très importants comme la
constatation que « it is possible that this social
feasibility demonstration is as important as the many technical
feasability demonstrations », conclusion qui reste très
vraie sur l'Internet aujourd'hui. 
Outre son grand intérêt historique, je recommande la lecture de
ce rapport à toutes celles et tous ceux qui s'intéressent à la
conception de réseaux informatiques, et aux innombrables choix qu'il
faut faire. Tout est intéressant dans ce rapport mais je vous
signale particulièrement, vers la fin, la discussion sur pourquoi
Arpanet a été un succès (en gros, des gens brillants, beaucoup
d'argent, et pas trop de bureaucratie). 
Les origines militaires de l'Arpanet font que ce rapport était à l'origine à diffusion restreinte mais a été déclassifié depuis. Malgré cela, il n'est pas toujours facile à trouver. Voici quelques endroits possibles :
Date de publication du RFC : Août 2026
Auteur(s) du RFC : P. Kampanakis (AWS), D. Stebila
(University of Waterloo), T. Hansen
(AWS)
Pour information
Réalisé dans le cadre du groupe de travail IETF sshm
Première rédaction de cet article le 31 août 2026
Tout le monde (et son chat) se met à la cryptographie post-quantique en ce moment et plus précisément à des systèmes hybrides, c'est-à-dire utilisant à la fois un algorithme traditionnel (comme ECDH) et un algorithme post-quantique (comme ML-KEM). Ce RFC décrit l'échange de clés avec un système hybride dans le protocole SSH.
Au début d'une connexion SSH (RFC 4251, section 1), les deux parties qui communiquent procèdent en effet à un échange de clés (section 7 du RFC 4253) afin de parvenir à un accord sur la clé partagée qui sera utilisée pour chiffrer la communication. Jusqu'à récemment, cet échange de clés était fait en utilisant un algorithme reposant sur les courbes elliptiques (RFC 5656 et RFC 8731), algorithme qui est vulnérable aux futurs calculateurs quantiques. Si des calculateurs quantiques réellement utilisables (les CRQC, Cryptographically Relevant Quantum Computers) apparaissent un jour, l'ancien algorithme devra être abandonné. Et on ne peut pas attendre pour voir si des CRQC deviennent réellement disponibles : des attaquants sont peut-être aujourd'hui en train d'enregistrer des sessions SSH, afin de les décrypter plus tard lorsqu'on aura enfin des CRQC (RFC 9958, section 1). Bref, il vaut mieux passer à des algorithmes post-quantiques dès maintenant.
Mais les algorithmes post-quantiques existants ne sont pas forcément sûrs face à la cryptanalyse ; on manque de recul à ce sujet. D'où l'idée de systèmes hybrides (RFC 9794), ou PQ/T (pour PostQuantum/Traditional) combinant algorithme post-quantique et algorithme traditionnel, et obligeant l'attaquant à casser les deux s'il veut décrypter la communication. (Si vous voulez creuser la question de la sécurité des systèmes hybrides, regardez « Security of Hybrid Key Encapsulation » et « Security of Hybrid Key Establishment using Concatenation ».) C'est ce genre de système que normalise notre RFC. Il est sûr face à un attaquant actif, même si ce dernier dispose d'un calculateur quantique ou bien s'il a trouvé une faille dans l'algorithme post-quantique.
Plus précisément, ce RFC va utiliser l'algorithme post-quantique ML-KEM avec un choix d'algorithmes traditionnels.
La section 2 du RFC décrit concrètement l'échange de clés avec le
système hybride (relire les RFC 4251 et RFC 4253 peut être utile). Le client SSH, au lieu
de commencer par SSH_MSG_KEXDH_INIT (RFC 4253) ou
SSH_MSG_KEX_ECDH_INIT (RFC 5656), envoie un message
SSH_MSG_KEX_HYBRID_INIT (valeur 30 dans le
protocole) qui contient la concaténation des deux clés du client. Et
la réponse, au lieu de SSH_MSG_KEXDH_REPLY ou
SSH_MSG_KEX_ECDH_REPLY sera un
SSH_MSG_KEX_HYBRID_REPLY (valeur 31 dans le
protocole) contenant la concaténation des deux clés du serveur. Le
choix du mécanisme hybride utilisé est indiqué dans le message
SSH_MSG_KEXINIT (RFC 4253, section 7.1) et peut valoir
mlkem768nistp256-sha256,
mlkem1024nistp384-sha384 ou
mlkem768x25519-sha256 (désormais enregistrés
à l'IANA). Rappelez-vous qu'on parle d'échange de clés (symétriques), pas
d'authentification, la réponse
SSH_MSG_KEX_HYBRID_REPLY contient aussi la clé
publique du serveur, celle qui sert à vérifier qu'on parle au bon
serveur, mais celle-ci n'est pas concernée par ce RFC.
Le mécanisme hybride va nous donner deux secrets partagés, un pour chaque algorithme (le post-quantique et le traditionnel) et le secret qui servira (après dérivation) de clé pour le chiffrement symétrique est la concaténation de ces deux secrets (c'est très proche de ce que fait TLS, dans le RFC 9954).
Un problème classique de la cryptographie post-quantique est la taille des clés, bien plus importante qu'avec les algorithmes traditionnels. (L'hybride est même un tout petit peu plus grand, avec la clé traditionnelle.) SSH a des limites de taille (section 6.1 du RFC 4253) mais les algorithmes spécifiés dans notre RFC ne les atteignent pas.
La section 6 du RFC détaille les conséquences de ce schéma hybride sur la sécurité. Elle conseille par exemple d'utiliser X25519 (RFC 8731) plutôt que les courbes NIST comme P256, pour sa rapidité et sa meilleure résistance aux attaques par canal auxiliaire, sauf si on veut de la conformité plutôt que de la sécurité et qu'on doit utiliser les courbes NIST.
Côté mise en œuvre de ce système hybride,
OpenSSH le connait (ssh -Q
kex pour avoir la liste des algorithmes connus)
et, depuis la version
10.4, « the hybrid post-quantum algorithm
mlkem768x25519-sha256 is now used by default for key
agreement ». Par exemple :
% ssh -v something.bortzmeyer.org debug1: OpenSSH_10.4p1, OpenSSL 3.6.3 9 Jun 2026 … debug1: kex: algorithm: mlkem768x25519-sha256 debug1: kex: host key algorithm: ssh-ed25519 debug1: kex: server->client cipher: chacha20-poly1305@openssh.com MAC: <implicit> compression: none debug1: kex: client->server cipher: chacha20-poly1305@openssh.com MAC: <implicit> compression: none debug1: expecting SSH2_MSG_KEX_ECDH_REPLY debug1: SSH2_MSG_KEX_ECDH_REPLY received …
Hmmm, ça aurait dû être
SSH_MSG_KEX_HYBRID_REPLY, bizarre…
Articles des différentes années : 2026 2025 2024 2023 2022 2021 2020 Précédentes années
Syndication : Flux Atom avec seulement les résumés et Flux Atom avec tout le contenu.