plpv.org

Le squelette d’un programme VPN, de l’interface TUN au socket chiffré

Sous la diversité des protocoles, tous les programmes VPN ont la même charpente : deux boucles symétriques, et tout un appareil autour pour les alimenter en clés.

Interface tun0 Programme VPN Socket UDP Pair distant read() : paquet sortant trouve le pair, chiffre sendto() datagramme chiffré datagramme chiffré recvfrom() vérifie, déchiffre write() : paquet entrant
Une boucle sortante, une boucle entrante. Le reste du programme sert à leur fournir des clés valides.

Une fois acquis ce qu’il faut apprendre avant d’écrire un VPN, du réseau IP à la cryptographie, reste à assembler le tout. Cette page décrit la structure d’un programme VPN minimal mais correct : ses pièces, ses deux boucles, leurs conditions d’erreur, puis les choix de concurrence et de langage. Le pseudo-code est volontairement neutre ; il suit de près ce que font WireGuard et les implémentations d’IPsec en espace utilisateur.

Les pièces du programme

  • La configuration : clé privée, liste des pairs avec leurs clés publiques et leurs adresses autorisées.
  • L’interface virtuelle, ouverte au démarrage, par laquelle passent les paquets en clair. Son fonctionnement sur chaque système est décrit dans la page sur TUN et ses équivalents.
  • Le socket UDP, par lequel passent les paquets chiffrés.
  • La table des sessions : pour chaque pair, les clés d’envoi et de réception, le compteur d’envoi, la fenêtre anti-rejeu et la dernière adresse connue.
  • La machine à états de la poignée de main, qui établit et renouvelle les sessions.
  • Les minuteries : renouvellement des clés, relance d’une poignée de main sans réponse, maintien des traductions NAT.

La boucle sortante

répéter :
    paquet = lire(tun)
    pair = table_des_routes.chercher(destination(paquet))
    si pair absent : jeter ; continuer
    si pair.session absente ou expirée :
        lancer_poignée_de_main(pair) ; mettre en attente(paquet) ; continuer
    n = pair.session.compteur_envoi
    pair.session.compteur_envoi = n + 1          # ne recule jamais
    chiffré = aead_chiffrer(pair.session.clé_envoi, nonce = n, paquet)
    envoyer(socket, pair.adresse, en_tête(pair.session.index_distant, n) + chiffré)

Le compteur sert de nonce : il garantit qu’aucune paire clé-nonce ne servira deux fois. Il faut programmer le renouvellement de session bien avant qu’il n’approche de sa limite, et ne jamais le remettre à zéro sans changer de clé. La file d’attente des paquets en attente de poignée de main doit être bornée, sinon un pair muet suffit à épuiser la mémoire.

La boucle entrante

répéter :
    datagramme, source = recevoir(socket)
    session = sessions.chercher(index(datagramme))
    si session absente : ignorer, sans répondre ; continuer
    n = compteur(datagramme)
    si non session.fenêtre.acceptable(n) : ignorer ; continuer
    paquet = aead_déchiffrer(session.clé_réception, nonce = n, données(datagramme))
    si échec : ignorer ; continuer
    session.fenêtre.marquer(n)                    # seulement après authentification
    si source_intérieure(paquet) hors des adresses du pair : ignorer ; continuer
    session.pair.adresse = source                 # suit le pair s'il change de réseau
    écrire(tun, paquet)

L’ordre de ces lignes est le cœur de la sécurité du programme. Rien n’est interprété avant l’authentification, hormis l’index et le compteur, qui servent seulement à retrouver une clé et à écarter les doublons. La fenêtre et l’adresse du pair ne bougent qu’après le succès du déchiffrement. Et la source intérieure est contrôlée, sans quoi un pair pourrait se faire passer pour un autre. C’est exactement ce que fait le serveur décrit dans le trajet d’un paquet côté serveur.

La poignée de main, une machine à états

Pour chaque pair, le programme connaît un petit nombre d’états : aucune session, poignée de main envoyée en attente de réponse, session établie, session à renouveler. Chaque transition a sa minuterie. Une initiation sans réponse est renvoyée après quelques secondes, avec un léger délai aléatoire pour éviter que tous les clients d’un serveur redémarré ne se présentent en même temps ; WireGuard relance ainsi toutes les cinq secondes, et abandonne au bout d’une minute et demie.

Deux cas demandent du soin. Si les deux pairs lancent une poignée de main au même instant, il faut une règle pour les départager, ou accepter les deux sessions. Et lors d’un renouvellement, l’ancienne session doit rester valable en réception quelques instants, le temps que les paquets déjà partis arrivent ; sinon, chaque changement de clé perd des paquets.

Threads, événements ou coroutines

La version la plus simple utilise deux fils d’exécution, un par boucle. Elle fonctionne, mais le chiffrement devient vite le goulot d’étranglement sur un seul cœur. Les implémentations performantes répartissent le chiffrement sur plusieurs cœurs puis remettent les paquets dans l’ordre avant de les envoyer, ce que fait le module WireGuard de Linux. Une boucle d’événements, epoll sous Linux, kqueue sous BSD et macOS, IOCP sous Windows, permet de surveiller l’interface, le socket et les minuteries sans multiplier les fils. En Go, les goroutines rendent ce découpage naturel ; en Rust, un environnement asynchrone comme tokio joue le même rôle.

À éviter : un fil par client, hérité des serveurs des années 2000. Au-delà de quelques centaines de pairs, la commutation entre fils coûte plus que le travail utile.

Quel langage choisir

LangageAtoutsLimitesExemple réel
Ccontrôle total, seul choix dans un noyauerreurs mémoire, première source de faillesWireGuard pour Linux, OpenVPN
Rustperformances du C, sécurité mémoirecourbe d’apprentissageboringtun
Godéveloppement rapide, concurrence simpleramasse-miettes, binaires lourdswireguard-go
Java, Kotlinimposés sur Android avec VpnServicesur ordinateur, pas d’accès TUN sans code natifclients Android
Pythonprototypage, outils comme Scapytrop lent pour transporter du traficbancs d’essai, tests

Les erreurs qui transforment un prototype en passoire

  • Réutiliser un nonce, par exemple en repartant de zéro après un redémarrage avec la même clé.
  • Analyser un paquet avant de l’avoir authentifié : chaque champ lu est une surface d’attaque.
  • Répondre à un paquet inconnu par un message plus gros que lui, ce qui fait du serveur un amplificateur d’attaques.
  • Comparer des étiquettes d’authentification avec une comparaison ordinaire, dont la durée trahit le nombre d’octets corrects.
  • Journaliser des clés, ou les adresses réelles des utilisateurs sans en avoir besoin.
  • Garder les droits d’administrateur après l’ouverture de l’interface : il faut les abandonner dès qu’ils ne servent plus.
  • Ne pas limiter le nombre de poignées de main par seconde, chacune coûtant un calcul asymétrique.

La plupart de ces erreurs touchent à l’assemblage des briques décrites dans la page sur les algorithmes.

Tester sans casser son réseau

Sous Linux, les espaces de noms réseau permettent de simuler deux machines sur un seul ordinateur : chacune a ses interfaces, ses routes et son pare-feu.

ip netns add a
ip netns add b
ip link add veth-a type veth peer name veth-b
ip link set veth-a netns a
ip link set veth-b netns b
ip netns exec a ip addr add 192.0.2.1/24 dev veth-a
ip netns exec b ip addr add 192.0.2.2/24 dev veth-b
ip netns exec a ip link set veth-a up
ip netns exec b ip link set veth-b up

On lance ensuite une instance du programme dans chaque espace, et l’on observe le lien avec tcpdump ou Wireshark. Il faut aussi soumettre l’analyse des paquets à un fuzzer comme AFL++ ou libFuzzer, et vérifier la cryptographie avec les vecteurs de test des RFC. Pour comparer votre squelette à une implémentation de référence, lisez les fichiers send et receive de WireGuard ; pour passer à une machine réelle, voyez le serveur de test sous Linux.