<?xml version="1.0" encoding="utf-8"?>
<rfcdesc title="Near Real Time Mirroring (NRTM) version 4" num="10063" status="standards" wg="grow">
  <authors><author>S. Romijn (Reliably Coded)</author><author>J. Snijders (BSD)</author><author>E. Shryane (RIPE NCC)</author><author>S. Konstantaras (AMS-IX)</author></authors>
  <rfcdate><month>November</month><year>2026</year></rfcdate>
  <date>2026-11-17</date>
<content>
  <p>Ce <wikipedia name="Request for comments">RFC</wikipedia>
  normalise enfin le protocole NRTM (<foreign>Near Real Time
  Mirroring</foreign>), qui permet de synchroniser les
  <wikipedia xml:lang="en" name="Internet Routing Registry">IRR</wikipedia>, les registres de routes Internet. Ce
  protocole joue donc un grand rôle dans la sécurité du
  <wikipedia>routage</wikipedia>.</p>
  <p>Le titre annonce NRTM version 4. Ne cherchez pas les <wikipedia
  name="Request for comments">RFC</wikipedia> des versions 1, 2 et 3,
  ils n'ont jamais été écrits (ce qui n'a pas empêché la version 3
  d'être <link
  url="https://docs.db.ripe.net/RIPE-Database-Mirror/Access-to-NRTM/">largement
  déployée</link><!--
  https://docs.db.ripe.net/RIPE-Database-Mirror/Near-Real-Time-Mirroring-v3#near-real-time-Mirroring-v3
  -->). Mais cette fois, on a une norme technique correcte pour le
  protocole NRTM. À quoi sert-il ? Pour le comprendre, il faut
  expliquer les <wikipedia xml:lang="en" name="Internet Routing Registry">IRR</wikipedia> (<foreign><link
  url="https://irr.net/">Internet Routing Registries</link></foreign>)
  et pour comprendre leur utilité, il faut revenir sur la façon dont
  se fait le <wikipedia>routage</wikipedia> sur
  l'<wikipedia>Internet</wikipedia>. (Je vous recommande la lecture du
  <rfc num="7682" local="true"/> pour une vision générale des IRR,
  ainsi qu'une visite de <computer><link
  url="https://irr.net/"/></computer>.)</p>
  <p>L'Internet est un réseau de réseaux, décentralisé. Chacun des
  réseaux qui composent l'Internet détient un certain nombre de
  préfixes d'<wikipedia name="Adresse IP">adresses IP</wikipedia>. Par
  exemple, <wikipedia>Gitoyen</wikipedia> a les préfixes
  <computer>80.67.160.0/19</computer> et
  <computer>2001:910::/32</computer>. Les <wikipedia
  name="Routeur">routeurs</wikipedia> de chaque réseau vont annoncer
  aux routeurs des réseaux voisins les préfixes qu'ils savent
  joindre. Cela peut être transitif : un réseau va annoncer non
  seulement ses propres préfixes mais aussi ceux des réseaux qu'il
  sait joindre. Cela dépend de la politique de routage de chaque
  réseau. Mais vos voyez se poindre un problème de sécurité : comment
  savoir si une annonce est légitime ? Si l'opérateur Gitoyen annonce
  une route vers le préfixe <computer>2a0f:6780::/29</computer>,
  comment savoir s'il a le droit de le faire, ou bien s'il est en
  train d'essayer de capter méchamment le trafic à destination de ce
  réseau, chose qui <link local="pakistan-pirate-youtube">se produit
  parfois</link> ? Il existe plusieurs techniques pour diminuer ce
  risque et l'une des plus anciennes est le registre de routes, ou IRR
  (<foreign>Internet Routing Registry</foreign>).</p>
  <p>Dans ces registres, dont l'accès est authentifié, on stocke les
  routes légitimes, décrites dans le langage <wikipedia name="Routing
  Policy Specification Language">RPSL</wikipedia> (<rfc num="2622"
  local="false"/>) et indiquant notamment l'<wikipedia name="Autonomous
  System">AS</wikipedia> d'origine. Lorsqu'un routeur reçoit en
  <wikipedia name="Border Gateway Protocol">BGP</wikipedia> une
  annonce de route, il peut vérifier dans le registre si elle semble
  légitime. Bon, j'ai simplifié : dans la réalité, le routeur ne
  regarde pas en temps réel, on utilise plutôt les IRR pour construire
  une liste de préfixes acceptés et cette liste est chargée dans la
  mémoire du routeur. Voici, vu avec <wikipedia>whois</wikipedia>, un
  exemple d'objet de type route au <wikipedia name="RIPE Network Coordination Centre">RIPE</wikipedia>,
  montrant que l'AS 207666 est autorisé comme origine du préfixe :
<code>
% whois 2a0f:6780::/29
…
route6:         2a0f:6780::/29
descr:          Route to Gitoyen IPv6
origin:         AS20766
mnt-by:         Gitoyen-NCC
created:        2020-08-14T10:34:23Z
last-modified:  2020-08-14T10:34:23Z
</code>
  </p>
  <p>Les registres de routes sont de grande taille (il y a
  actuellement dans les 1,4 millions de routes sur la <wikipedia
  name="Default-free zone">DFZ</wikipedia>) et si on veut les copier,
  il faut pouvoir le faire de manière efficace, d'autant plus qu'ils
  changent en permanence. En outre, il existe de nombreux IRR (au
  moins une douzaine de gros IRR connus actuellement, gérés par des
  organisations différentes, pas seulement les <wikipedia
  name="Registre Internet régional">RIR</wikipedia>), et qui
  souhaitent parfois enrichir leur base avec les données d'autres
  IRR. Se copier les uns les autres est classique pour les IRR. Un
  mécanisme de synchronisation est donc nécessaire, et s'il est
  standard, c'est encore mieux.</p>
  <p>C'est précisément ce que fournit NRTM. Le <wikipedia
  name="Request for comments">RFC</wikipedia> note d'ailleurs que ces
  IRR ne servent pas qu'au filtrage d'annonces de routes mais ils sont
  aussi très utiles pour les chercheurs qui étudient le fonctionnement
  du routage.</p>
  <p>Le principe de base de NRTM ? Un IRR publie en <wikipedia
  name="Hypertext Transfer Protocol">HTTP</wikipedia> ses données
  complètes, ainsi que des changements d'une version à l'autre (ce qui
  évite de télécharger la base entière à chaque fois). Un nouveau
  client va télécharger la base, le <foreign>snapshot</foreign>, puis
  la tenir à jour avec les changement successifs. NRTM a donc des
  points communs avec le protocole Delta du <rfc num="8182"/>. NRTM
  ajoute à cela des mécanismes de vérification
  d'<wikipedia name="Intégrité (cryptographie)">intégrité</wikipedia> et de passage à l'échelle.</p>
  <p>Un serveur NRTM fournit un fichier <foreign>Update
  Notification</foreign> qui indique le numéro de la version actuelle
  de la base, ainsi que les endroits où récupérer
  <foreign>snapshots</foreign> et changements (<foreign>Delta
  Files</foreign>). Il y a à chaque moment un <foreign>Snapshot
  File</foreign> (la totalité de la base) et zéro, un ou plus
  <foreign>Delta Files</foreign> (les changements par rapport à un
  <foreign>snapshot</foreign>). Le <foreign>Update Notification
  File</foreign> est du <wikipedia name="JavaScript Object
  Notation">JSON</wikipedia>, plus précisement au format
  <wikipedia name="JSON Web Signature">JWS</wikipedia> (<rfc num="7515" local="true"/> ; JWS
  fait partie de l'ensemble des <link local="jose">normes
  cryptographiques de JSON, JOSE</link>). Les <foreign>Snapshot
  File</foreign> et <foreign>Delta Files</foreign> sont également du
  JSON, en l'occurrence du <foreign>JSON Text Sequences</foreign>
  (<rfc num="7464" local="true"/>). Tous peuvent être comprimés en
  <wikipedia>gzip</wikipedia> (<rfc num="1952" local="false"/>).</p>
  <p>Le client doit connaitre l'adresse de l'<foreign>Update
  Notification File</foreign>, et la <wikipedia name="Cryptographie
  asymétrique">clé publique</wikipedia> utilisée pour la signer. Il
  charge l'<foreign>Update Notification File</foreign> (le RFC suggère
  de le faire toutes les minutes, c'est un petit fichier), et, en le
  lisant, il trouve les éventuelles <foreign>Delta Files</foreign> à
  télécharger, avec leur <wikipedia name="Fonction de hachage cryptographique">condensat
  cryptographique</wikipedia>. Contrairement à l'<foreign>Update
  Notification File</foreign>, <foreign>Snapshot File</foreign> et
  <foreign>Delta Files</foreign> ne sont jamais modifiées et peuvent
  donc être mémorisées par des intermédiaires HTTP.</p>
  <p>Le gérant du serveur NRTM doit, la première fois, générer une clé
  publique (<foreign>JSON Web Key</foreign>, <rfc num="7517"
  local="true"/>), dont il annoncera la partie publique au format
  <foreign>Textual Encoding of Subject Public Key</foreign>, de la
  section 13 du <rfc num="7468" local="false"/>. Il ne reste plus qu'à
  mettre cette clé et les autres informations utiles au client sur le
  site Web de l'IRR. (Bon, il faudra aussi gérer les clés : faire des
  sauvegardes, remplacer les clés de temps en temps, etc.)</p>
  <p>Le serveur doit aussi générer un
  <computer>session_id</computer>. C'est un identificateur qui servira
  aux clients à détecter un changement de serveur, ou bien une
  réinitialisation complète du serveur. Il est au format <wikipedia
  name="Universal Unique Identifier">UUID</wikipedia> (section 5.4 du
  <rfc num="9562" local="true"/>).</p>
  <p>Enfin, le serveur initialise sa base, en partant du numéro de
  version 1. À partir de là, le <foreign>snapshot</foreign> portera
  des numéros de version croissants, et chaque <foreign>Delta
  File</foreign> un numéro de version qui indique à quelle version du
  <foreign>snapshot</foreign> il faut l'appliquer. Si le
  <foreign>snapshot</foreign> est à la version 3, il faut appliquer
  (s'ils existent), les <foreign>Delta Files</foreign> 4, puis
  5, puis 6, etc. (Le RFC suggère de publier un <foreign>Delta
  File</foreign> par minute, sauf s'il n'y a eu aucun changement.) Le
  <foreign>Delta File</foreign> contient tous les changements qui ont
  eu lieu, même s'ils s'annulent (création suivie d'une destruction,
  par exemple). Un <foreign>Delta File</foreign> ne diffuse donc pas
  les différences avec le <foreign>snapshot</foreign> mais les
  changements. Et, de temps en temps (le RFC suggère de le faire tous
  les jours), le serveur regénère un
  <foreign>snapshot</foreign> complet, avec la version actuelle. À
  chaque fois, on met à jour l'<foreign>Update Notification
  File</foreign>.</p>
  <p>Voici l'exemple (que j'ai un peu raccourci) donné par le RFC d'un
  <foreign>Update Notification File</foreign> :
  <code>
   {
     "nrtm_version": 4,
     "timestamp": "2025-12-01T15:00:00Z",
     "session_id": "ca128382-78d9-41d1-8927-1ecef15275be",
     "version": 4,
     "snapshot": {
       "version": 3,
       "url":
         "ca128382-78d9-41d1-8927-1ecef15275be/nrtm-snapshot.3.04759.json.gz",
       "hash": "9a..86"
     },
     "deltas": [
       {
         "version": 3,
         "url":
           "ca128382-78d9-41d1-8927-1ecef15275be/nrtm-delta.3.0f681f0.json",
         "hash": "25..9a"
       },
       {
         "version": 4,
         "url":
           "ca128382-78d9-41d1-8927-1ecef15275be/nrtm-delta.4.d9c194a.json",
         "hash": "b4..13"
       }
     ]
   }
  </code>
  Vous y voyez le <computer>session_id</computer> (s'il change, il
  indique au client qu'il faut repartir de zéro, le serveur a changé
  ou la base a été réinitialisée) et la version actuelle, la 4. Si on
  télécharge le <foreign>snapshot</foreign> indiqué
  (<computer>nrtm-snapshot.3.04759.json.gz</computer>), on aura la
  version 3, il faut donc aussi télécharger le <foreign>Delta
  File</foreign> de version 4
  (<computer>nrtm-delta.4.d9c194a.json</computer>) et l'appliquer. Le
  <foreign>Delta File</foreign> de la version 3 est toujours là ; il
  est inutile si on a téléchargé le <foreign>snapshot</foreign> de
  version 3 mais peut servir aux clients qui avaient téléchargé le
  <foreign>snapshot</foreign> de version 2, et qui doivent donc
  appliquer les <foreign>Delta Files</foreign> de version 3 et 4. Ah
  et, sinon, dans la réalité, le JSON ci-dessus serait dans un
  document signé <wikipedia name="JSON Web Signature">JWS</wikipedia> (<rfc num="7515"
  local="true"/>). Après avoir vérifié la signature, le client devra
  aussi vérifier les <wikipedia name="Fonction de hachage cryptographique">condensats</wikipedia> des fichiers
  téléchargés.</p>
  <p>Et voici l'exemple de <foreign>snapshot</foreign> dans le RFC :
  <code>
␞{
   "nrtm_version": 4,
   "type": "snapshot"
   "source": "EXAMPLE",
   "session_id": "ca128382-78d9-41d1-8927-1ecef15275be",
   "version": 3
}
␞{"object": "route: 192.0.2.0/24\norigin: AS64500\nsource: EXAMPLE"}
␞{"object": "route6: 2001:db8::/32\norigin: AS64500\nsource: EXAMPLE"}
  </code>
  C'est du <foreign>JSON Text Sequences</foreign> (<rfc num="7464"
  local="true"/>) et le caractère bizarre au début des objets est RS
  (<foreign>Record Separator</foreign>, <link
  url="https://r12a.github.io/uniview/?char=001E">U+001E</link>). Ici,
  l'IRR nous dit (en <wikipedia name="Routing Policy Specification
  Language">RPSL</wikipedia>, <rfc num="2622" local="false"/>) que le
  préfixe <wikipedia name="Internet Protocol">IP</wikipedia>
  <computer>2001:db8::/32</computer> peut avoir comme origine des
  annonces l'<wikipedia name="Autonomous System">AS</wikipedia>
  64500.</p>
  <p>Et les <foreign>Delta Files</foreign>, elles ressemblent à quoi ?
  Elles sont aussi en <foreign>JSON Text Sequences</foreign> et voici
  un exemple :
  <code>
␞{
     "nrtm_version": 4,
     "type": "delta",
     "source": "EXAMPLE",
     "session_id": "ca128382-78d9-41d1-8927-1ecef15275be",
     "version": 3
   }
␞{
     "action": "delete",
     "object_class": "person",
     "primary_key": "PRSN1-EXAMPLE"
   }
␞{
     "action": "delete",
     "object_class": "route",
     "primary_key": "192.0.2.0/24AS64500"
   }
␞{
     "action": "add_modify",
     "object": "route6: 2001:db8::/32\norigin: AS64500\nsource: EXAMPLE"
   }
  </code>
  On y voit la version qui sera celle de la base de données après
  l'application de ce <foreign>Delta File</foreign> (version 3), deux
  suppressions d'objet et un ajout (le terme utilisé pour les ajouts
  sert aussi pour les modifications).</p>
  <p>D'un point de vue plus opérationnel, quelques point sont à garder
  en tête. D'abord, les IRR actuels ne respectent pas tous la norme
  <wikipedia name="Routing Policy Specification
  Language">RPSL</wikipedia>. Il y a eu des ajouts non normalisés, des
  déviations par rapport à la norme, etc. Copier les objets d'un IRR
  vers un autre peut toujours déclencher des problèmes, s'ils ne
  suivent pas la même variante de la norme. NRTM v4 serre les boulons
  sur certains points mais pas tous. Le RFC recommande donc aux
  clients d'être tolérants quand ils copient des données d'un IRR.</p>
  <p>Ah, et pour revenir à NRTM v3, cette ancienne version est
  totalement incompatible avec la v4 de notre RFC. Il n'existe pas de
  moyen pour un client v4 et un serveur v3 (ou l'inverse) de se
  parler.</p>
  <p>Passons maintenant au concret, avec les mises en œuvre de ce
  protocole (attention en lisant les documentations d'un logiciel :
  s'il annonce qu'il parle NRTM, cela ne veut pas forcémen dire qu'il
  connait la v4, radicalement différente des versions précédentes). Il
  existe une <link
  url="https://wiki.ietf.org/en/group/grow/implementations/draft-ietf-grow-nrtm-v4">liste
  apparemment assez complète</link> des mises en œuvre de NRTM v4 :
  <enum>
    <item><link url="https://github.com/irrdnet/irrd/">Le classique irrd</link> (et
    <link url="https://irrd.readthedocs.io/">sa
    documentation</link>). Le code actuellement dans
    <wikipedia>git</wikipedia> fait du NRTM v4 (mais
    je n'ai pas l'impression que la v4 soit déjà dans les
    versions officiellement publiées).</item>
    <item><link
    url="https://github.com/petchells/nrtm4tools">nrtm4tools</link>,
    un client écrit en <wikipedia name="Go
    (langage)">Go</wikipedia>. Il copie les données d'un serveur NRTM
    dans une base <wikipedia>PostgreSQL</wikipedia>.</item>
    <item><link
	      url="https://github.com/telekom/nrtm4-client">nrtm4-client</link>
    est une bibliothèque <wikipedia name="Python (langage)">Python</wikipedia>.</item>
    <item><link
	      url="https://github.com/mxsasha/nrtm4-validator/">nrtm4-validator</link>
    sert à valider un serveur NRTM, en suivant les étapes décrites
    plus haut (récupérer l'<foreign>Update Norification
    File</foreign>, vérifier sa signature, récupérer
    <foreign>snapshot</foreign> et <foreign>Delta Files</foreign>,
    vérifier les condensats…). Il est écrit en
    <wikipedia name="Rust (langage)">Rust</wikipedia>.</item>
  </enum>
  Pratiquons un peu. Le <wikipedia name="RIPE Network Coordination
  Centre">RIPE-NCC</wikipedia> publie <link
  url="https://docs.db.ripe.net/RIPE-Database-Mirror/Near-Real-Time-Mirroring-v4">son
  IRR en NRTM v4</link>. Récupérons d'abord la clé publique :
  <code>
wget https://ftp.ripe.net/ripe/dbase/nrtmv4/nrtmv4_public_key.txt
    </code>
   Puis compilons nrtm4-validator. Un coup de <computer>cargo
   build</computer> et :
   <code>
% ./target/debug/nrtm4-validator  https://nrtm.db.ripe.net/nrtmv4/RIPE/update-notification-file.jose RIPE "$(cat ../nrtmv4_public_key.txt )"
…
Delta loaded for version 820641 with 4 entries
NRTMv4 syntax is valid.
</code>
  C'est parfait, l'IRR est correct. (Comme l'<wikipedia name="Uniform
  Resource Locator">URL</wikipedia> de la clé, celui de
  l'<foreign>Update Notification File</foreign> a été trouvé dans
  <link
  url="https://docs.db.ripe.net/RIPE-Database-Mirror/Near-Real-Time-Mirroring-v4#near-real-time-mirroring-v4">la
  documentation</link>.)</p>
  <p>Et avec des outils génériques (comme la bibliothèque
  <wikipedia name="Python (langage)">Python</wikipedia> <link
  url="https://github.com/latchset/jwcrypto">jwcrypto</link> pour le
  JWS) ? Regardons l'<foreign>Update Notification File</foreign> du RIPE :
<code>
% wget https://nrtm.db.ripe.net/nrtmv4/RIPE/update-notification-file.jose
% wget https://ftp.ripe.net/ripe/dbase/nrtmv4/nrtmv4_public_key.txt
% python dump-jose-jwcrypto.py | jq .
{
  "nrtm_version": 4,
  "timestamp": "2026-07-08T13:19:00Z",
  "type": "notification",
  "source": "RIPE",
  "session_id": "db44e038-1f07-4d54-a307-1b32339f141a",
  "version": 820574,
  "snapshot": {
    "version": 820003,
    "url": "nrtm-snapshot.820003.RIPE.db44e038-1f07-4d54-a307-1b32339f141a.fb6d20b59f550e41842f77c89969eb63.json.gz",
    "hash": "349412f3d51b8e5f212b045ddea24fce253a29ed2f6316701ba1944e2e180575"
  },
  "deltas": [
    {
      "version": 819581,
      "url": "nrtm-delta.819581.RIPE.db44e038-1f07-4d54-a307-1b32339f141a.27da23b725673ebccbb96707df9ef3.json",
      "hash": "c16d84843519c01c4d151985d96d92b0edebfdb6235a15c72e8aa88946a83fce"
    },
    {
      "version": 819582,
      "url": "nrtm-delta.819582.RIPE.db44e038-1f07-4d54-a307-1b32339f141a.8a606d5c55451f0ead6e5a09114cddf5.json",
      "hash": "e48cd45b03ee45c28990158645ee422b1e5c12b98395a2cade6542d1a7dd10f8"
    },
…
</code>
  On y voit bien ce que décrit le RFC, la version (820574), le
  <foreign>snapshot</foreign> (version 820003, il faudra en appliquer,
  des <foreign>Delta Files</foreign>, pour être à jour), et les
  <foreign>Delta Files</foreign>. Récupérons-en un pour voir :
<code>
wget https://nrtm.db.ripe.net/nrtmv4/RIPE/nrtm-delta.819586.RIPE.db44e038-1f07-4d54-a307-1b32339f141a.b4e8374b5d705856707c2f4902c6e02c.json
</code>
  On a utilisé le programme Python suivant (avec <link url="https://github.com/latchset/jwcrypto">jwcrypto</link>) :
<code>
#!/usr/bin/env python3

# https://jwcrypto.readthedocs.io/
from jwcrypto import jwk, jws

jwstoken = jws.JWS()
jwstoken.deserialize(open("update-notification-file.jose", "r").read())
key = jwk.JWK.from_pem(open("nrtmv4_public_key.txt", "r").read().encode())
jwstoken.verify(key) # Obligatoire, sinon, paf, exception.
payload = jwstoken.payload.decode()
print(payload)
</code>
  Et <link local="jq">jq</link> nous sert pour formater le JSON
  produit. (Oui, il y a d'autres moyens de lire du JWS, cf. mon
  article sur le <rfc num="7515" local="true"/>.)
  </p>
</content>
</rfcdesc>
