Les passerelles de réseaux privés virtuels interconnectées aux dorsales publiques d'Internet sont confrontées à une asymétrie de calcul majeure. Lorsqu'un poste distant amorce une connexion sécurisée, les protocoles cryptographiques doivent exécuter des opérations mathématiques asymétriques exigeantes — telles que les multiplications scalaires sur la courbe elliptique Curve25519 — pour convenir de clés de session authentifiées.

Alors que le calcul d'une multiplication Curve25519 prend moins d'une milliseconde sur les processeurs de serveurs modernes, l'émission d'un paquet UDP forgé de 148 octets sur un lien réseau à 10 Gbit/s ne requiert que quelques nanosecondes. Un assaillant générant un flot massif de requêtes d'initialisation avec usurpation d'adresses IP sources peut saturer les cœurs du processeur hôte, créant une famine de calcul qui empêche les clients légitimes d'achever leur négociation.

Afin de contrer les risques de déni de service (DoS) cryptographique et d'épuisement mémoire, WireGuard intègre un limiteur de débit à seau à jetons (token bucket) au cœur même du chemin de données réseau du noyau Linux (drivers/net/wireguard/ratelimiter.c). En régulant le flux des poignées de main non authentifiées par adresse IP source avant toute sollicitation de calculs elliptiques, WireGuard préserve un débit nominal constant même sous de violentes attaques volumétriques.

+-----------------------------------------------------------------------------+
|          PIPELINE DE LIMITATION DES POIGNÉES DE MAIN DANS LE NOYAU          |
|                                                                             |
| Paquet UDP entrant (Type 1 : Initialisation de poignée de main)             |
| [ Vérification valide du tag MAC1 via BLAKE2s ]                             |
|                     |                                                       |
|                     v                                                       |
|        wg_ratelimiter_allow_ip(net, ip_addr)                                |
|                     |                                                       |
|                     v                                                       |
|        Entrée en section critique rcu_read_lock()                           |
|        Calcul de l'alvéole via SipHash : siphash(&ip, secret_key)           |
|                     |                                                       |
|                     v                                                       |
|        Parcours de la liste hlist dans table_v4 ou table_v6                 |
|                     |                                                       |
|         +-----------+-----------+                                           |
|         |                       |                                           |
|         v                       v                                           |
|    [ Entrée IP trouvée ]   [ Entrée absente ]                               |
|         |                       |                                           |
|         |                       v                                           |
|         |                Allocation d'un nouveau ratelimiter_entry          |
|         |                Insertion dans l'alvéole (verrou atomique)         |
|         |                       |                                           |
|         +----------->+<---------+                                           |
|                      |                                                      |
|                      v                                                      |
|         Reconstitution des jetons selon le temps écoulé                     |
|         (Capacité : 20 jetons, Rechargement : 1 jeton / 100 ms)             |
|                      |                                                      |
|         +------------+------------+                                         |
|         |                         |                                         |
|         v                         v                                         |
|   [ Jetons >= 1 ]           [ Seau vide (Jetons < 1) ]                      |
|         |                         |                                         |
|         v                         v                                         |
|   Déduction d'un jeton      Refus du calcul cryptographique direct          |
|   rcu_read_unlock()         Exigence du défi Cookie MAC2 (cookie.c)         |
|   Exécution de la           Rejet silencieux si le Cookie est invalide      |
|   multiplication Curve25519               |                                 |
|                                           v                                 |
|                                     rcu_read_unlock()                       |
+-----------------------------------------------------------------------------+

L'asymétrie des poignées de main dans les protocoles traditionnels

Les architectures de tunnelisation classiques amorcent les sessions via des échanges multi-étapes qui imposent une gestion d'état fastidieuse au serveur. Dans le protocole IPsec IKEv2 (RFC 7296), le serveur réserve une structure d'état dès réception de la requête initiale IKE_SA_INIT, conservant des aléas et des propositions cryptographiques en mémoire avant toute authentification. Des flots massifs de requêtes saturent rapidement la mémoire slab du noyau, provoquant des arrêts d'urgence du système d'exploitation par épuisement de mémoire vive.

OpenVPN s'appuie quant à lui sur les moteurs d'états d'OpenSSL ou de mbedTLS en espace utilisateur. Chaque trame TLS Client Hello entraîne des décodages ASN.1 coûteux, des validations de chaînes de certificats et des vérifications de signatures asymétriques RSA ou ECDSA. Comme ces opérations nécessitent de multiples bascules de contexte entre le noyau et les processus utilisateurs, un flux de quelques milliers de paquets par seconde suffit à monopoliser 100 % des ressources processeur, provoquant la déconnexion en cascade des sessions existantes.

Par ailleurs, les limiteurs de débit simplistes basés sur des règles de pare-feu généralistes présentent des lacunes structurelles :

  1. Saturation des tables de suivi d'état : Le suivi de centaines de milliers d'adresses IP forgées émanant de réseaux de bots sature les capacités de suivi de connexion.
  2. Contention sur les verrous globaux : Les mécanismes multithreads partageant des verrous mutex centraux subissent une contention sévère qui paralyse les cœurs du processeur lors de la synchronisation des caches.
  3. Vulnérabilité aux attaques Hash-DoS : L'usage de fonctions de hachage sans clé secrète permet à un attaquant de forger des paquets qui s'accumulent dans une même chaîne d'alvéoles, dégradant la complexité de recherche de $O(1)$ à $O(N)$.

Architecture interne de ratelimiter.c : le seau à jetons en noyau

WireGuard résout ces difficultés grâce à un composant sur mesure implémenté dans drivers/net/wireguard/ratelimiter.c. Le pilote initialise deux tables de hachage dédiées : table_v4 pour IPv4 et table_v6 pour IPv6.

struct ratelimiter_entry {
    u64 last_time_ns;
    u32 tokens;
    spinlock_t lock;
    struct hlist_node hash;
    struct rcu_head rcu;
    union {
        __be32 ip;
        struct in6_addr ip6;
    };
};

Chaque élément de la table représente un seau de jetons affecté à une adresse IP distante :

  • Capacité de rafale (PACKETS_BURST) : Fixée à 20 jetons, permettant aux clients légitimes de supporter des pics d'émissions lors des reconnexions ou des transitions mobiles sans ressentir de délai artificiel.
  • Cadence de réapprovisionnement (PACKETS_PER_SECOND) : Réinjecte 10 jetons par seconde (1 jeton toutes les 100 millisecondes), calculée dynamiquement au moyen de l'horloge monotone en nanosecondes du noyau (ktime_get_coarse_boottime_ns()).
  • Empreinte mémoire réduite : Une structure concise garantit que des dizaines de milliers d'entrées simultanées ne mobilisent qu'une fraction négligeable de mémoire vive.

1. Protection contre les collisions via SipHash

Afin d'empêcher que le limiteur de débit ne devienne lui-même la cible d'attaques par complexité algorithmique, les index d'alvéoles sont calculés par la fonction pseudo-aléatoire SipHash (siphash_1u32 pour IPv4 et siphash_2u64 pour IPv6). À l'activation de l'interface, WireGuard tire une clé secrète de 128 bits depuis le générateur d'entropie du noyau :

static inline u32 entry_hash(const struct ratelimiter_entry *entry)
{
    return siphash_1u32((__force u32)entry->ip, &table_key);
}

La clé table_key demeurant strictement confidentielle dans la mémoire protégée du système d'exploitation, un assaillant externe ne peut prédire les adresses qui convergeraient vers une alvéole commune. Les chaînes de collision obéissent à une distribution de Poisson idéale, garantissant un temps de recherche stable en $O(1)$.

2. Parcours sans verrou RCU et verrous tournants individuels

Pour traiter d'importants volumes de données, l'exploration de la table de hachage s'opère dans des sections protégées par Read-Copy Update (RCU) :

bool wg_ratelimiter_allow_ip(struct ratelimiter *limiter, struct sk_buff *skb)
{
    struct ratelimiter_entry *entry;
    u32 hash;

    rcu_read_lock();
    hash = entry_hash_from_skb(skb);
    hlist_for_each_entry_rcu(entry, &limiter->table_v4[hash & limiter->mask], hash) {
        if (entry->ip == ip) {
            bool allowed = deduct_token(entry);
            rcu_read_unlock();
            return allowed;
        }
    }
    rcu_read_unlock();
    return allocate_and_insert_entry(limiter, ip);
}

Sur le chemin d'exécution rapide, les cœurs processeur localisent les adresses IP sans solliciter de verrou global. Dès que la structure ratelimiter_entry ciblée est identifiée, le fil d'exécution n'acquiert que le verrou tournant propre à cette entrée (entry->lock) afin de décrémenter le solde de jetons. Les opérations relatives à des adresses IP distinctes s'exécutent ainsi en parallèle sur des lignes de cache indépendantes.

Quand le rythme d'émission d'une adresse IP excède la réserve de jetons, WireGuard ne supprime pas aveuglément la requête. Le protocole bascule alors vers un mécanisme d'atténuation réfléchi :

Régime nominal (Jetons disponibles) :
Paquet client [ Type 1 | Non authentifié | MAC1 ]
    --> Validation par le seau à jetons
    --> Calcul de la clé Curve25519
    --> Émission de la réponse Type 2

Régime de surcharge (Seau épuisé) :
Paquet client [ Type 1 | Débit excessif | MAC1 ]
    --> Refus du calcul asymétrique direct
    --> Si MAC2 absent : Envoi d'un Cookie Type 3 (Défi sans état)
    --> Le client calcule le Cookie MAC2 et réémet le Type 1 [ MAC1 + MAC2 ]
    --> La passerelle valide le Cookie et finalise l'accord

Lors d'un déferlement de paquets, la passerelle refuse d'engager des calculs Curve25519 pour des émetteurs non validés. Elle exige que le client transmette un Cookie sans état, généré à partir de l'IP, du port et d'une clé secrète périodiquement renouvelée. L'émission et le contrôle d'un Cookie ne nécessitant qu'une opération de hachage symétrique BLAKE2s légère et efficace, le serveur traite les requêtes à la vitesse nominale du matériel. Les clients légitimes renvoient le Cookie et s'associent de façon transparente, tandis que les flots usurpés sont neutralisés immédiatement.

Recyclage automatique de la mémoire en arrière-plan

Lors d'attaques distribuées massives impliquant des millions d'adresses IP aléatoires, la table de suivi risquerait de croître de manière désordonnée si aucune purge n'était programmée.

Afin de maintenir l'usage de la mémoire dans des limites rigoureuses, WireGuard emploie les files de travail différées de Linux (schedule_delayed_work) pour nettoyer périodiquement les entrées obsolètes :

static void cleanup_entries(struct work_struct *work)
{
    struct ratelimiter_entry *entry;
    struct hlist_node *n;
    u64 now = ktime_get_coarse_boottime_ns();

    spin_lock_bh(&table_lock);
    for (int i = 0; i < HASH_SIZE; ++i) {
        hlist_for_each_entry_safe(entry, n, &table[i], hash) {
            if (now - entry->last_time_ns > EXPIRATION_INTERVAL_NS) {
                hlist_del_rcu(&entry->hash);
                kfree_rcu(entry, rcu);
            }
        }
    }
    spin_unlock_bh(&table_lock);
}

Ce mécanisme d'assainissement assure les fonctions suivantes :

  • Élimination par inactivité : Toute entrée n'ayant reçu aucun paquet durant la fenêtre d'expiration (quelques secondes) est dissociée de la table via hlist_del_rcu().
  • Restitution sécurisée via RCU : La désallocation physique n'intervient qu'au moyen de kfree_rcu(), après que tous les cœurs ont franchi leur état de repos, écartant tout bogue d'accès mémoire concurrent.
  • Plafond adaptatif de capacité : Si le volume global d'entrées approche le seuil critique lors d'une agression majeure, le pilote expulse en priorité les entrées les plus anciennes afin de préserver l'intégrité de la mémoire du serveur.

Diagnostic opérationnel et ajustement des files réseau

Les administrateurs d'infrastructures Linux peuvent observer les tampons de réception et calibrer les options du noyau avec les outils usuels du système.

Vérification des tampons de réception UDP sur le port WireGuard :

# Surveiller les files d'attente du socket UDP
ss -u -a -m -p | grep 51820

Suivi de la distribution des interruptions logicielles réseau (softirq) sur les cœurs de calcul :

# Analyser la répartition de charge d'interruption sur le processeur
mpstat -P ALL 1 5

Ajustement des paramètres système pour absorber les pointes de charge :

# Augmentation des tampons et des files de réception réseau
sysctl -w net.core.netdev_max_backlog=100000
sysctl -w net.core.rmem_max=67108864
sysctl -w net.core.wmem_max=67108864
sysctl -w net.ipv4.udp_rmem_min=16384

Résilience et haute disponibilité au sein du réseau VPNRice

Offrir un service de réseau privé virtuel haut de gamme requiert une robustesse à toute épreuve face aux surcharges coordonnées. L'architecture Anycast de VPNRice tire pleinement parti de cette régulation en noyau :

  1. Filtrage à vitesse filaire : Grâce au traitement token bucket au niveau de la couche réseau, les passerelles VPNRice éliminent les flots d'initialisations illégitimes avant l'étape de chiffrement asymétrique, préservant la puissance de calcul pour le transit des utilisateurs.

  2. Défis Cookie dynamiques : Lors d'augmentations brusques de trafic, les nœuds basculent instantanément sur la validation Cookie MAC2, maintenant des connexions limpides pour les usagers sans dégrader la latence.

  3. Compartimentation des clés SipHash : Chaque domaine de routage de nœud VPNRice emploie un sel SipHash distinct, empêchant toute interaction malveillante par collisions calculées entre clients.

En conjuguant le formalisme du seau à jetons, la protection de SipHash et la souplesse du modèle sans verrou RCU, les infrastructures VPN modernes garantissent une connectivité fluide, réactive et pérenne même sous de fortes contraintes réseau.