Exécution de code d'agent non fiable sans bac à sable

Exécuter du code d'agent non fiable sans bac à sable

Exécuter du code d'agent non fiable—provenant de sources externes ou d'agents IA fournis par l'utilisateur—est un défi croissant dans les déploiements IA modernes. Les approches traditionnelles de bac à sable (par exemple, les conteneurs Docker, gVisor ou Firecracker) offrent un isolement solide mais introduisent des surcharges, latences et complexités significatives. Cet article explore des techniques pratiques pour exécuter du code d'agent non fiable sans bac à sable complet, en tirant parti d'un isolement léger, d'une analyse statique et d'une surveillance à l'exécution. Nous nous appuyons sur des informations issues de discussions récentes dans l'industrie, notamment l'examen de la sécurité des agents par le blog LangChain et les travaux en cours d'OpenAI sur les environnements d'exécution sécurisés. L'objectif est de fournir une approche pratique et déployable pour les développeurs qui ont besoin de rapidité et de simplicité sans compromettre la sécurité.

Prérequis

Avant de commencer, assurez-vous que votre système répond aux exigences suivantes :

• **Système basé sur Linux** (Ubuntu 22.04+ ou similaire) — la plupart des outils d'isolement léger sont natifs sous Linux.
• **Python 3.10+** — pour exécuter le code d'agent et nos scripts d'exemple.
• **Support `seccomp`** — filtrage des appels système au niveau du noyau (activé par défaut sur les Linux modernes).
• **`nsjail`** — un bac à sable léger axé sur la sécurité pour exécuter du code non fiable. Installez via le gestionnaire de paquets.
• **`cgroups` v2** — pour les limites de ressources (CPU, mémoire). Vérifiez avec `mount | grep cgroup`.
• **`apparmor` ou `selinux`** — optionnel mais recommandé pour un renforcement supplémentaire du MAC (Contrôle d'Accès Obligatoire).

Installation étape par étape

Nous allons installer et configurer `nsjail` comme outil principal. `nsjail` utilise les espaces de noms Linux, seccomp-bpf et cgroups pour restreindre le code non fiable avec une surcharge minimale.

1. Installer nsjail

Commencez par mettre à jour votre liste de paquets et installer `nsjail` :

sudo apt-get update
sudo apt-get install -y nsjail

Vérifiez l'installation :

nsjail --version

Si vous avez besoin de la dernière version, compilez à partir des sources (instructions disponibles sur le dépôt GitHub de `nsjail`). Pour la plupart des cas d'usage, la version du paquet suffit.

2. Installer Python et les dépendances

Assurez-vous que Python 3.10+ est installé :

python3 --version

Installez les bibliothèques Python nécessaires pour notre exemple :

pip install requests pyyaml

3. Configurer les profils seccomp

Créez un profil seccomp personnalisé pour restreindre les appels système. Enregistrez le contenu suivant sous `agent_seccomp.policy` :

# Politique seccomp de base pour le code d'agent non fiable
# Autoriser uniquement les appels système sûrs
[whitelist]
read
write
open
close
mmap
munmap
brk
exit_group
clone
execve
stat
fstat
lseek
getdents64

Cette politique bloque les appels système dangereux comme `ptrace`, `socket` (réseau), `mount` et `process_vm_writev`. Vous pouvez l'étendre en fonction des besoins de votre agent.

4. Configurer les cgroups pour les limites de ressources

Créez un cgroup pour l'isolement des ressources :

sudo mkdir -p /sys/fs/cgroup/agent_limits
echo "100000" | sudo tee /sys/fs/cgroup/agent_limits/memory.max  # Limite mémoire de 100 Mo
echo "50000" | sudo tee /sys/fs/cgroup/agent_limits/cpu.max      # Limite CPU de 50 %

Ces limites empêchent les agents incontrôlés d'épuiser les ressources système.

Exemples d'utilisation

Nous allons maintenant exécuter du code d'agent non fiable en utilisant `nsjail` avec notre politique seccomp et nos limites cgroups.

Exemple 1 : Exécuter un script Python simple

Créez un script de test `agent_code.py` qui simule un comportement d'agent non fiable :

# agent_code.py - Exemple de code d'agent non fiable
import os

def run_agent():
    print("Agent : Bonjour, je suis un agent non fiable !")
    # Tentative d'opération dangereuse (sera bloquée)
    try:
        os.system("rm -rf /")  # Cela échouera à cause de seccomp
    except Exception as e:
        print(f"Opération dangereuse bloquée : {e}")
    return "Agent terminé en toute sécurité"

if __name__ == "__main__":
    result = run_agent()
    print(f"Résultat : {result}")

Exécutez-le dans `nsjail` :

nsjail --config /dev/stdin <<EOF
{
  "chroot": "/",
  "cwd": "/tmp",
  "seccomp_policy_file": "/chemin/vers/agent_seccomp.policy",
  "cgroup_memory_max": 104857600,  # 100 Mo
  "cgroup_cpu_max": 50000,          # 50 %
  "exec_bin": "/usr/bin/python3",
  "exec_args": ["/tmp/agent_code.py"]
}
EOF

Explication de chaque paramètre :

• `chroot` : Restreint l'accès au système de fichiers à un répertoire spécifique.
• `cwd` : Répertoire de travail à l'intérieur du bac à sable.
• `seccomp_policy_file` : Chemin vers notre politique personnalisée.
• `cgroup_memory_max` et `cgroup_cpu_max` : Limites de ressources.
• `exec_bin` et `exec_args` : La commande à exécuter.

Le script s'exécutera, mais toute tentative d'exécuter des commandes shell (comme `os.system`) sera bloquée par seccomp, et l'agent échouera gracieusement.

Exemple 2 : Exécuter du code d'agent avec restrictions réseau

L'accès réseau est souvent inutile pour les agents non fiables. Nous pouvons désactiver complètement le réseau en utilisant l'isolement de l'espace de noms réseau de `nsjail`.

Créez un script qui tente de récupérer des données :

# network_agent.py
import requests

def fetch_data():
    try:
        response = requests.get("https://api.example.com/data")
        return response.text
    except Exception as e:
        return f"Réseau bloqué : {e}"

if __name__ == "__main__":
    print(fetch_data())

Exécutez-le avec le réseau désactivé :

nsjail --config /dev/stdin <<EOF
{
  "chroot": "/",
  "cwd": "/tmp",
  "seccomp_policy_file": "/chemin/vers/agent_seccomp.policy",
  "cgroup_memory_max": 104857600,
  "cgroup_cpu_max": 50000,
  "disable_network": true,  # Désactiver tout le réseau
  "exec_bin": "/usr/bin/python3",
  "exec_args": ["/tmp/network_agent.py"]
}
EOF

Le paramètre `disable_network` crée un espace de noms réseau sans interfaces. L'agent ne pourra pas se connecter, empêchant l'exfiltration de données ou les appels externes.

Exemple 3 : Limiter le temps d'exécution

Les agents peuvent boucler indéfiniment. Utilisez la limite de temps de `nsjail` :

nsjail --config /dev/stdin <<EOF
{
  "chroot": "/",
  "cwd": "/tmp",
  "seccomp_policy_file": "/chemin/vers/agent_seccomp.policy",
  "cgroup_memory_max": 104857600,
  "cgroup_cpu_max": 50000,
  "time_limit": 5,  # 5 secondes maximum d'exécution
  "exec_bin": "/usr/bin/python3",
  "exec_args": ["/tmp/agent_code.py"]
}
EOF

Si l'agent dépasse 5 secondes, `nsjail` le tue et renvoie une erreur de dépassement de temps.

Exemple 4 : Surveiller le comportement de l'agent

Pour une utilisation en production, enregistrez toutes les actions de l'agent. Modifiez la politique seccomp pour journaliser les appels système bloqués :

# agent_seccomp_log.policy
[whitelist]
read
write
open
close
mmap
munmap
brk
exit_group
clone
execve
stat
fstat
lseek
getdents64

[audit]
ptrace
socket
connect

Exécutez ensuite avec journalisation :

nsjail --config /dev/stdin <<EOF
{
  "chroot": "/",
  "cwd": "/tmp",
  "seccomp_policy_file": "/chemin/vers/agent_seccomp_log.policy",
  "seccomp_log": true,  # Journaliser les appels système bloqués
  "cgroup_memory_max": 104857600,
  "cgroup_cpu_max": 50000,
  "exec_bin": "/usr/bin/python3",
  "exec_args": ["/tmp/agent_code.py"]
}
EOF

Consultez les journaux avec `dmesg | tail -20` ou `journalctl -xe`. Cela aide à identifier les comportements malveillants ou bogués de l'agent.

Bonnes pratiques et mises en garde

Exécuter du code non fiable sans bac à sable complet est un compromis entre performance et sécurité. Voici les considérations clés :

• **Utilisez une approche en couches** : Combinez `nsjail` avec des profils AppArmor et des systèmes de fichiers en lecture seule pour une défense en profondeur. Le blog IA de Microsoft souligne l'importance de multiples couches d'isolement.
• **Évitez d'accorder des privilèges inutiles** : Supprimez `CAP_NET_ADMIN`, `CAP_SYS_ADMIN` et autres capacités. `nsjail` le fait par défaut.
• **Mettez régulièrement à jour les politiques seccomp** : À mesure que le code de l'agent évolue, de nouveaux appels système peuvent être nécessaires. Examinez les journaux et ajustez la liste blanche.
• **Prévoyez des délais d'attente** : Fixez toujours un temps d'exécution maximum pour éviter les dénis de service.
• **Testez avec des charges de travail d'agent réelles** : Les recherches d'Anthropic sur la sécurité de l'IA suggèrent que les tests avec des entrées adversariales aident à découvrir les lacunes d'isolement.
• **Surveillez l'utilisation des ressources** : Utilisez les cgroups pour suivre la mémoire, le CPU et les E/S. Des pics soudains peuvent indiquer une activité malveillante.

Limitations

Cette approche ne convient pas à tous les scénarios :

• **Exploits du noyau** : Si le code de l'agent exploite une vulnérabilité du noyau, les espaces de noms et seccomp peuvent ne pas protéger l'hôte. Un bac à sable complet (par exemple, gVisor) offre un isolement plus fort.
• **Attaques par canaux auxiliaires** : Les modèles d'utilisation des ressources peuvent divulguer des informations. Pour les applications hautement sécurisées, envisagez un isolement renforcé par le matériel.
• **Dépendances complexes de l'agent** : Certains agents nécessitent des bibliothèques partagées, des bases de données ou un accès GPU. Ceux-ci peuvent nécessiter des politiques personnalisées ou un bac à sable partiel.

Conclusion

Exécuter du code d'agent non fiable sans bac à sable complet est réalisable en utilisant des primitives Linux légères comme `nsjail`, seccomp et cgroups. Cette approche offre une faible surcharge (généralement <5 % d'impact sur les performances) tout en bloquant les appels système dangereux, l'accès réseau et l'épuisement des ressources. En suivant les étapes d'installation et les exemples ci-dessus, vous pouvez exécuter en toute sécurité du code d'agent IA dans des environnements de production, en vous appuyant sur les informations de l'industrie provenant de LangChain, OpenAI, Microsoft et Anthropic. Commencez par une politique restrictive, surveillez les journaux et élargissez progressivement les autorisations selon les besoins. La clé est de refuser par défaut : donnez aux agents uniquement les capacités minimales requises pour leur tâche. Cette stratégie pragmatique équilibre sécurité, rapidité et simplicité pour les déploiements IA modernes.