L'adoption fulgurante des infrastructures mutualisées pour les grands modèles de langage (LLM) a conduit les moteurs d'inférence — tels que vLLM, TensorRT-LLM et SGLang — à déployer des optimisations d'ordonnancement intensives. Afin de rentabiliser les grappes d'accélérateurs graphiques (notamment NVIDIA H100 et B200), les architectures modernes s'appuient sur le groupement continu (Continuous Batching) associé au découpage de la pré-alimentation (Chunked Prefill).

Bien que ces mécanismes augmentent considérablement le débit global et lissent les pics de latence liés au traitement de requêtes étendues, ils engendrent une vulnérabilité matérielle subtile : les interférences d'exécution entre utilisateurs hébergés sur une même machine. Dans un environnement cloud partagé, un acteur malveillant peut analyser les infimes fluctuations temporelles de réception des jetons pour reconstituer la longueur des requêtes confidentielles et les limites du contexte système. Neutraliser ce canal auxiliaire émergent exige une isolation architecturale, un lissage temporel des itérations et une encapsulation réseau chiffrée via VPNRice.

Mécanique du chunked prefill et du continuous batching dans l'inférence LLM

Dans les environnements traditionnels par lots, le moteur d'inférence regroupait les requêtes de façon statique. Une nouvelle demande devait patienter jusqu'à l'achèvement complet de toutes les séquences en cours, provoquant une sous-utilisation critique des processeurs graphiques durant la génération textuelle. Le continuous batching a résolu cette contrainte en opérant à l'échelle de chaque itération (iteration-level) : dès qu'une séquence se termine, elle quitte le lot et une nouvelle requête s'y intègre immédiatement.

Toutefois, une dissymétrie matérielle majeure subsiste entre les deux étapes de l'inférence des transformeurs :

  • Phase de pré-alimentation (Prefill) : Opération dépendante de la puissance brute de calcul, où l'ensemble de la séquence d'entrée est évalué en parallèle pour initialiser la mémoire cache Key-Value (KV).
  • Phase de décodage (Decode) : Opération dépendante de la bande passante mémoire, où chaque jeton est produit de façon séquentielle par des lectures répétées dans la mémoire haute bande passante (HBM).
+-------------------------------------------------------------------------+
|                  Ordonnancement par Chunked Prefill                     |
|                                                                         |
|  Requêtes utilisateurs entrantes :                                      |
|    Requête A (Cible) :     [================ 2048 Jetons ================] |
|    Requête B (Attaquant) : [= 128 Jetons =]                             |
|                                                                         |
|  Ordonnanceur par morceaux (Taille de morceau Chunk = 512 Jetons) :     |
|  +-------------------------------------------------------------------+  |
|  | Itération 1 : [Req A: Morceau 1 (512)] + [Req B: Décodage Jeton 1]|  |
|  | Itération 2 : [Req A: Morceau 2 (512)] + [Req B: Décodage Jeton 2]|  |
|  | Itération 3 : [Req A: Morceau 3 (512)] + [Req B: Décodage Jeton 3]|  |
|  | Itération 4 : [Req A: Morceau 4 (512)] + [Req B: Décodage Jeton 4]|  |
|  | Itération 5 : [Req A: Décodage Jeton 1] + [Req B: Décodage Jeton 5]|  |
|  +-------------------------------------------------------------------+  |
|                                                                         |
|  Constat de latence inter-jetons (ITL) côté client attaquant :          |
|  Latence Jetons 1 à 4 : ~42ms (Ralentissement par charge de calcul)    |
|  Latence Jeton 5 et + : ~11ms (Retour au débit nominal de décodage)    |
+-------------------------------------------------------------------------+

Lorsqu'une longue consigne arrive sur le serveur, son traitement intégral en une seule passe figerait toutes les générations en cours, détériorant le délai d'obtention du premier jeton (TTFT) et la régularité d'émission.

La technique du chunked prefill segmente la consigne en blocs uniformes (par exemple 512 jetons). À chaque cycle de calcul, le système alloue un quota de jetons et planifie conjointement le traitement d'un bloc de pré-alimentation avec les jetons en cours de décodage. Les deux traitements se partagent ainsi simultanément les unités de calcul SM et les cœurs tenseurs du processeur graphique.

Exploitation des interférences GPU et de la gigue de latence inter-tokens

Dans la mesure où les unités de traitement, les antémémoires de niveau 2 (L2) et les canaux de mémoire HBM sont physiquement partagés, l'exécution d'un bloc de calcul intensif ralentit le décodage des autres flux traités simultanément.

Un utilisateur malveillant disposant d'un compte ordinaire sur l'infrastructure peut mettre à profit cette contention matérielle :

  1. Établissement du profil de référence : L'attaquant soumet des requêtes minimalistes afin de mesurer la latence normale de décodage (par exemple 10 à 12 ms par jeton sur un ensemble de serveurs H100).
  2. Émission d'un flux de sondage : L'attaquant maintient une génération continue via le protocole Server-Sent Events (SSE) en relevant l'horodatage précis de chaque paquet reçu.
  3. Détection de la contention : Lorsqu'un utilisateur tiers envoie une requête volumineuse, l'ordonnanceur la fragmente sur plusieurs itérations consécutives. Durant chacune de ces passes, la latence mesurée par l'attaquant bondit de 11 ms à plus de 40 ms.
  4. Calcul de la taille de la requête : La taille des blocs étant fixe et déterminée par la configuration du serveur, le nombre d'itérations ralenties consécutives indique précisément le nombre de fragments nécessaires au traitement de la requête tierce.
+-------------------------------------------------------------------------+
|                  Analyse du signal de gigue de latence inter-jetons     |
|                                                                         |
|  Latence inter-jetons observée (Millisecondes)                          |
|   50ms +                                                                |
|        |      +-------+-------+-------+-------+                         |
|   40ms |      | Itér 1| Itér 2| Itér 3| Itér 4|                         |
|        |      | (A_1) | (A_2) | (A_3) | (A_4) |                         |
|   20ms |      |       |       |       |       |                         |
|        |------+       |       |       |       +----------------------   |
|   10ms | Base |       |       |       |       | Débit nominal de décodage|
|    0ms +-------------------------------------------------------------   |
|        Jeton : 1       2       3       4       5       6       7       8 |
|                                                                         |
|  Extraction du profil de données :                                      |
|    Nombre d'itérations à forte latence (K) = 4 passes                   |
|    Taille nominale des blocs (C) = 512 jetons                           |
|    Taille estimée de la consigne cible = (K - 1) * C < Taille <= K * C  |
|                                        = Entre 1537 et 2048 Jetons      |
+-------------------------------------------------------------------------+

Par ce simple relevé temporel externe, l'attaquant cartographie la charge de calcul des requêtes concurrentes sans nécessiter d'accès privilégié au système d'exploitation de l'hôte.

Reconstitution de la longueur des requêtes et du contexte système des tiers

La divulgation de la volumétrie des requêtes engendre des risques concrets pour la confidentialité des données d'entreprise :

  • Révélation des instructions système dissimulées : De nombreuses plateformes ajoutent des directives de modération ou des modèles de raisonnement en amont des saisies des utilisateurs. Les variations du nombre de jetons selon les profils d'utilisateurs révèlent l'ampleur et l'évolution de ces consignes internes.
  • Déduction des documents extraits dans les architectures RAG : Dans les systèmes de génération augmentée par récupération, l'envergure du contexte dépend du volume des documents internes extraits. Un pic de latence signale directement l'intégration de pièces confidentielles (contrats, dossiers médicaux).
  • Surveillance du fil des échanges : L'incrémentation progressive de la taille des échanges au sein d'une session permet de surveiller la progression d'une conversation et de repérer les transactions sensibles.

Combiné aux spécificités du décodage spéculatif ou de la mise en mémoire tampon des requêtes, ce canal temporel permet de vérifier la présence de textes ciblés au sein des contextes des utilisateurs.

Vulnérabilités de l'inférence désagrégée sur les réseaux d'interconnexion

Pour déployer les architectures aux paramètres les plus denses, les exploitants de centres de données séparent physiquement les étapes de pré-alimentation et de décodage sur des serveurs distincts : c'est le modèle de l'inférence désagrégée.

Dans cette topologie :

  1. Nœuds de pré-alimentation : Des serveurs pourvus d'accélérateurs traitent les entrées à haute cadence pour générer les tenseurs KV.
  2. Nœuds de décodage : Des serveurs optimisés pour la mémoire reçoivent le cache KV et génèrent les jetons de sortie.
  3. Transfert réseau des tenseurs KV : Les flux massifs de données de cache transitent à travers le réseau local via les protocoles RoCEv2 ou TCP.
+-------------------------------------------------------------------------+
|              Fuite d'informations sur le réseau du cluster              |
|                                                                         |
|  [ Nœud de pré-alimentation ]                 [ Nœud de décodage ]      |
|    +----------------------+                     +---------------------+ |
|    | Calcul du cache KV   |                     | Décodage séquentiel | |
|    +----------------------+                     +---------------------+ |
|               |                                            ^            |
|               | Flux réseau de transfert de cache KV       |            |
|               v (Gigaoctets de tenseurs sur le réseau ToR) |            |
|  =====================================================================  |
|  [ Commutateurs de haut de baie / Réseau physique d'interconnexion ]    |
|    - Les paquets non chiffrés traversent les commutateurs réseau        |
|    - Le volume et la durée des rafales révèlent la dimension du tenseur |
|    - Un attaquant colocalisé analyse le trafic pour profiler les calculs|
+-------------------------------------------------------------------------+

Si les interconnexions internes ne bénéficient pas d'un chiffrement robuste, les rafales d'échange sur les commutateurs ToR dévoilent le volume précis des données transférées, permettant l'analyse du trafic à l'insu des mécanismes de contrôle applicatifs.

Isolation matérielle et défense par encapsulation WireGuard dans le noyau

Éliminer les canaux auxiliaires liés à l'ordonnancement et aux flux réseau impose une stratégie globale associant la régularisation des calculs au chiffrement du réseau de transport.

+-------------------------------------------------------------------------+
|         Architecture combinant isolation matérielle et noyau WireGuard  |
|                                                                         |
|  [ Grappe d'accélérateurs mutualisés ]                                  |
|    +-----------------------------------------------------------------+  |
|    | Partitionnement matériel MIG / Lissage temporel des itérations  |  |
|    | - Quotas de blocs fixes et égalisation du temps de calcul       |  |
|    | - Cloisonnement des bus mémoire et des unités de calcul         |  |
|    +-----------------------------------------------------------------+  |
|                                |                                        |
|                                | Transfert sécurisé du cache KV          |
|                                v                                        |
|    +-----------------------------------------------------------------+  |
|    | Interface réseau WireGuard (wg0 / Maillage VPNRice)             |  |
|    | - Négociation via le protocole Noise et chiffrement ChaCha20   |  |
|    | - Paquets à taille constante et injection de trafic de leurre   |  |
|    +-----------------------------------------------------------------+  |
|                                |                                        |
|                                v Datagrammes UDP chiffrés et uniformes   |
|  =====================================================================  |
|  [ Infrastructure réseau isolée ]                                       |
|    - Absence totale de variations temporelles mesurables sur les switchs|
|    - Débit régulé empêchant le profilage par volume d'échange           |
|    - Règles de filtrage bloquant les flux non autorisés                 |
+-------------------------------------------------------------------------+

Pour assurer une imperméabilité totale, les infrastructures d'intelligence artificielle doivent mettre en place des mesures coordonnées :

  1. Égalisation de la durée des itérations : Les ordonnanceurs doivent standardiser le temps d'exécution de chaque cycle en introduisant des micro-pauses ou des calculs factices afin que toutes les itérations présentent une durée rigoureusement identique.
  2. Cloisonnement matériel (MIG) : Grâce aux technologies de découpage matériel telles que NVIDIA MIG, la mémoire et les cœurs de calcul sont isolés physiquement pour chaque environnement, prévenant toute compétition sur les composants partagés.
  3. Maillage chiffré au niveau du noyau avec VPNRice : Les flux de données de cache entre serveurs d'inférence doivent impérativement transiter au sein de tunnels WireGuard directs dans le noyau Linux. Le chiffrement authentifié ChaCha20-Poly1305 masque entièrement la taille des tenseurs aux sondes réseau intermédiaires.
  4. Régulation et lissage du trafic réseau : L'injection de paquets factices et la diffusion à débit constant éliminent les rafales caractéristiques, interdisant toute corrélation entre les flux réseau et la volumétrie des requêtes traitées.

En unissant un ordonnancement homogène à l'isolation réseau permise par VPNRice, les hébergeurs de modèles suppriment les canaux auxiliaires temporels et préservent la confidentialité absolue des données au sein des plateformes d'IA partagées.