Aperçu
Claude Code dispose d’un sandboxing natif pour fournir un environnement plus sécurisé pour l’exécution des agents tout en réduisant le besoin de demandes de permission constantes. Au lieu de demander une permission pour chaque commande bash, le sandboxing crée des limites définies à l’avance où Claude Code peut travailler plus librement avec un risque réduit. L’outil bash en sandbox utilise des primitives au niveau du système d’exploitation pour appliquer à la fois l’isolation du système de fichiers et du réseau.Pourquoi le sandboxing est important
La sécurité basée sur les permissions traditionnelles nécessite une approbation constante de l’utilisateur pour les commandes bash. Bien que cela offre un contrôle, cela peut entraîner :- Fatigue d’approbation : Cliquer répétitivement sur « approuver » peut amener les utilisateurs à prêter moins attention à ce qu’ils approuvent
- Productivité réduite : Les interruptions constantes ralentissent les flux de travail de développement
- Autonomie limitée : Claude Code ne peut pas fonctionner aussi efficacement en attendant les approbations
- Définissant des limites claires : Spécifiez exactement quels répertoires et hôtes réseau Claude Code peut accéder
- Réduisant les demandes de permission : Les commandes sûres dans le sandbox ne nécessitent pas d’approbation
- Maintenant la sécurité : Les tentatives d’accès aux ressources en dehors du sandbox déclenchent des notifications immédiates
- Permettant l’autonomie : Claude Code peut fonctionner plus indépendamment dans les limites définies
Comment ça marche
Isolation du système de fichiers
L’outil bash en sandbox restreint l’accès au système de fichiers à des répertoires spécifiques :- Comportement d’écriture par défaut : Accès en lecture et écriture au répertoire de travail actuel et à ses sous-répertoires
- Comportement de lecture par défaut : Accès en lecture à l’ensemble de l’ordinateur, sauf certains répertoires refusés
- Accès bloqué : Impossible de modifier les fichiers en dehors du répertoire de travail actuel sans permission explicite
- Configurable : Définissez des chemins autorisés et refusés personnalisés via les paramètres
sandbox.filesystem.allowWrite dans vos paramètres. Ces restrictions sont appliquées au niveau du système d’exploitation (Seatbelt sur macOS, bubblewrap sur Linux), elles s’appliquent donc à toutes les commandes de sous-processus, y compris les outils comme kubectl, terraform et npm, pas seulement aux outils de fichiers de Claude.
Isolation réseau
L’accès réseau est contrôlé via un serveur proxy s’exécutant en dehors du sandbox :- Restrictions de domaine : Seuls les domaines approuvés peuvent être accédés
- Confirmation de l’utilisateur : Les nouvelles demandes de domaine déclenchent des demandes de permission (sauf si
allowManagedDomainsOnlyest activé, ce qui bloque automatiquement les domaines non autorisés) - Support de proxy personnalisé : Les utilisateurs avancés peuvent implémenter des règles personnalisées sur le trafic sortant
- Couverture complète : Les restrictions s’appliquent à tous les scripts, programmes et sous-processus générés par les commandes
Application au niveau du système d’exploitation
L’outil bash en sandbox exploite les primitives de sécurité du système d’exploitation :- macOS : Utilise Seatbelt pour l’application du sandbox
- Linux : Utilise bubblewrap pour l’isolation
- WSL2 : Utilise bubblewrap, comme Linux
Démarrage
Prérequis
Sur macOS, le sandboxing fonctionne directement en utilisant le framework Seatbelt intégré. Sur Linux et WSL2, installez d’abord les packages requis :- Ubuntu/Debian
- Fedora
Activer le sandboxing
Vous pouvez activer le sandboxing en exécutant la commande/sandbox :
bubblewrap ou socat sur Linux), le menu affiche les instructions d’installation pour votre plateforme.
Par défaut, si le sandbox ne peut pas démarrer (dépendances manquantes, plateforme non supportée ou restrictions de plateforme), Claude Code affiche un avertissement et exécute les commandes sans sandboxing. Pour en faire un échec dur à la place, définissez sandbox.failIfUnavailable sur true. Ceci est destiné aux déploiements gérés qui nécessitent le sandboxing comme porte de sécurité.
Modes de sandbox
Claude Code offre deux modes de sandbox : Mode auto-allow : Les commandes Bash tenteront de s’exécuter dans le sandbox et sont automatiquement autorisées sans nécessiter de permission. Les commandes qui ne peuvent pas être sandboxées (comme celles nécessitant un accès réseau à des hôtes non autorisés) reviennent au flux de permission régulier. Les règles d’ask/deny explicites que vous avez configurées sont toujours respectées. Mode permissions régulières : Toutes les commandes bash passent par le flux de permission standard, même lorsqu’elles sont sandboxées. Cela offre plus de contrôle mais nécessite plus d’approbations. Dans les deux modes, le sandbox applique les mêmes restrictions de système de fichiers et de réseau. La différence réside uniquement dans le fait que les commandes sandboxées sont auto-approuvées ou nécessitent une permission explicite.Le mode auto-allow fonctionne indépendamment de votre paramètre de mode de permission. Même si vous n’êtes pas en mode « accepter les modifications », les commandes bash sandboxées s’exécuteront automatiquement lorsque l’auto-allow est activé. Cela signifie que les commandes bash qui modifient les fichiers dans les limites du sandbox s’exécuteront sans invite, même lorsque les outils de modification de fichiers nécessiteraient normalement une approbation.
Configurer le sandboxing
Personnalisez le comportement du sandbox via votre fichiersettings.json. Consultez Paramètres pour la référence de configuration complète.
Accorder l’accès en écriture des sous-processus à des chemins spécifiques
Par défaut, les commandes sandboxées ne peuvent écrire que dans le répertoire de travail actuel. Si les commandes de sous-processus commekubectl, terraform ou npm doivent écrire en dehors du répertoire du projet, utilisez sandbox.filesystem.allowWrite pour accorder l’accès à des chemins spécifiques :
excludedCommands.
Lorsque allowWrite (ou denyWrite/denyRead/allowRead) est défini dans plusieurs portées de paramètres, les tableaux sont fusionnés, ce qui signifie que les chemins de chaque portée sont combinés, non remplacés. Par exemple, si les paramètres gérés autorisent les écritures à /opt/company-tools et qu’un utilisateur ajoute ~/.kube dans ses paramètres personnels, les deux chemins sont inclus dans la configuration finale du sandbox. Cela signifie que les utilisateurs et les projets peuvent étendre la liste sans dupliquer ou remplacer les chemins définis par les portées de priorité plus élevée.
Les préfixes de chemin contrôlent la façon dont les chemins sont résolus :
| Préfixe | Signification | Exemple |
|---|---|---|
/ | Chemin absolu à partir de la racine du système de fichiers | /tmp/build reste /tmp/build |
~/ | Relatif au répertoire personnel | ~/.kube devient $HOME/.kube |
./ ou pas de préfixe | Relatif à la racine du projet pour les paramètres du projet, ou à ~/.claude pour les paramètres utilisateur | ./output dans .claude/settings.json se résout en <project-root>/output |
//path pour les chemins absolus fonctionne toujours. Si vous aviez précédemment utilisé un seul slash /path en s’attendant à une résolution relative au projet, passez à ./path. Cette syntaxe diffère des règles de permission Read et Edit, qui utilisent //path pour absolu et /path pour relatif au projet. Les chemins du système de fichiers du sandbox utilisent les conventions standard : /tmp/build est un chemin absolu.
Vous pouvez également refuser l’accès en écriture ou en lecture en utilisant sandbox.filesystem.denyWrite et sandbox.filesystem.denyRead. Ceux-ci sont fusionnés avec tous les chemins des règles de permission Edit(...) et Read(...). Pour réautoriser la lecture de chemins spécifiques dans une région refusée, utilisez sandbox.filesystem.allowRead, qui a priorité sur denyRead. Lorsque allowManagedReadPathsOnly est activé dans les paramètres gérés, seules les entrées allowRead gérées sont respectées ; les entrées allowRead utilisateur, projet et local sont ignorées.
Par exemple, pour bloquer la lecture de l’ensemble du répertoire personnel tout en autorisant les lectures du projet actuel, ajoutez ceci au .claude/settings.json de votre projet :
. dans allowRead se résout à la racine du projet car cette configuration se trouve dans les paramètres du projet. Si vous aviez placé la même configuration dans ~/.claude/settings.json, . se résoudrait à ~/.claude à la place, et les fichiers du projet resteraient bloqués par la règle denyRead.
Claude Code inclut un mécanisme d’échappatoire intentionnel qui permet aux commandes de s’exécuter en dehors du sandbox si nécessaire. Lorsqu’une commande échoue en raison des restrictions du sandbox (comme les problèmes de connectivité réseau ou les outils incompatibles), Claude est invité à analyser l’échec et peut réessayer la commande avec le paramètre
dangerouslyDisableSandbox. Les commandes qui utilisent ce paramètre passent par le flux de permissions normal de Claude Code nécessitant une permission de l’utilisateur pour s’exécuter. Cela permet à Claude Code de gérer les cas limites où certains outils ou opérations réseau ne peuvent pas fonctionner dans les contraintes du sandbox.Vous pouvez désactiver cet échappatoire en définissant "allowUnsandboxedCommands": false dans vos paramètres de sandbox. Lorsqu’il est désactivé, le paramètre dangerouslyDisableSandbox est complètement ignoré et toutes les commandes doivent s’exécuter sandboxées ou être explicitement listées dans excludedCommands.Avantages de sécurité
Protection contre l’injection de prompt
Même si un attaquant manipule avec succès le comportement de Claude Code par injection de prompt, le sandbox garantit que votre système reste sécurisé : Protection du système de fichiers :- Impossible de modifier les fichiers de configuration critiques tels que
~/.bashrc - Impossible de modifier les fichiers au niveau du système dans
/bin/ - Impossible de lire les fichiers qui sont refusés dans vos paramètres de permission Claude
- Impossible d’exfiltrer les données vers des serveurs contrôlés par l’attaquant
- Impossible de télécharger des scripts malveillants à partir de domaines non autorisés
- Impossible de faire des appels API inattendus vers des services non approuvés
- Impossible de contacter des domaines non explicitement autorisés
- Toutes les tentatives d’accès en dehors du sandbox sont bloquées au niveau du système d’exploitation
- Vous recevez des notifications immédiates lorsque les limites sont testées
- Vous pouvez choisir de refuser, d’autoriser une fois ou de mettre à jour définitivement votre configuration
Surface d’attaque réduite
Le sandboxing limite les dommages potentiels causés par :- Dépendances malveillantes : Packages NPM ou autres dépendances avec du code nuisible
- Scripts compromis : Scripts de construction ou outils avec des vulnérabilités de sécurité
- Ingénierie sociale : Attaques qui trompent les utilisateurs pour qu’ils exécutent des commandes dangereuses
- Injection de prompt : Attaques qui trompent Claude pour qu’il exécute des commandes dangereuses
Fonctionnement transparent
Lorsque Claude Code tente d’accéder à des ressources réseau en dehors du sandbox :- L’opération est bloquée au niveau du système d’exploitation
- Vous recevez une notification immédiate
- Vous pouvez choisir de :
- Refuser la demande
- L’autoriser une fois
- Mettre à jour votre configuration de sandbox pour l’autoriser définitivement
Limitations de sécurité
- Limitations du sandboxing réseau : Le système de filtrage réseau fonctionne en restreignant les domaines auxquels les processus sont autorisés à se connecter. Il n’inspecte pas autrement le trafic passant par le proxy et les utilisateurs sont responsables de s’assurer qu’ils n’autorisent que les domaines de confiance dans leur politique.
- Escalade de privilèges via les sockets Unix : La configuration
allowUnixSocketspeut accorder involontairement l’accès à des services système puissants qui pourraient entraîner des contournements du sandbox. Par exemple, si elle est utilisée pour autoriser l’accès à/var/run/docker.sock, cela accorderait effectivement l’accès au système hôte en exploitant le socket docker. Les utilisateurs sont encouragés à examiner attentivement tous les sockets Unix qu’ils autorisent via le sandbox. - Escalade de permissions du système de fichiers : Les permissions d’écriture du système de fichiers trop larges peuvent permettre des attaques d’escalade de privilèges. Autoriser les écritures dans les répertoires contenant des exécutables dans
$PATH, les répertoires de configuration système ou les fichiers de configuration du shell utilisateur (.bashrc,.zshrc) peut entraîner l’exécution de code dans différents contextes de sécurité lorsque d’autres utilisateurs ou processus système accèdent à ces fichiers. - Force du sandbox Linux : L’implémentation Linux fournit une isolation forte du système de fichiers et du réseau mais inclut un mode
enableWeakerNestedSandboxqui lui permet de fonctionner à l’intérieur des environnements Docker sans espaces de noms privilégiés. Cette option affaiblit considérablement la sécurité et ne doit être utilisée que dans les cas où une isolation supplémentaire est autrement appliquée.
Comment le sandboxing se rapporte aux permissions
Le sandboxing et les permissions sont des couches de sécurité complémentaires qui fonctionnent ensemble :- Les permissions contrôlent quels outils Claude Code peut utiliser et sont évaluées avant l’exécution de tout outil. Elles s’appliquent à tous les outils : Bash, Read, Edit, WebFetch, MCP et autres.
- Le sandboxing fournit une application au niveau du système d’exploitation qui restreint ce que les commandes Bash peuvent accéder au niveau du système de fichiers et du réseau. Il s’applique uniquement aux commandes Bash et à leurs processus enfants.
- Utilisez
sandbox.filesystem.allowWritepour accorder l’accès en écriture des sous-processus à des chemins en dehors du répertoire de travail - Utilisez
sandbox.filesystem.denyWriteetsandbox.filesystem.denyReadpour bloquer l’accès des sous-processus à des chemins spécifiques - Utilisez
sandbox.filesystem.allowReadpour réautoriser la lecture de chemins spécifiques dans une région refusée - Utilisez les règles de refus
ReadetEditpour bloquer l’accès à des fichiers ou répertoires spécifiques - Utilisez les règles d’autorisation/refus
WebFetchpour contrôler l’accès au domaine - Utilisez les
allowedDomainsdu sandbox pour contrôler quels domaines les commandes Bash peuvent atteindre
sandbox.filesystem et des règles de permission sont fusionnés dans la configuration finale du sandbox.
Ce référentiel inclut des configurations de paramètres de démarrage pour les scénarios de déploiement courants, y compris des exemples spécifiques au sandbox. Utilisez-les comme points de départ et ajustez-les selon vos besoins.
Utilisation avancée
Configuration de proxy personnalisée
Pour les organisations nécessitant une sécurité réseau avancée, vous pouvez implémenter un proxy personnalisé pour :- Déchiffrer et inspecter le trafic HTTPS
- Appliquer des règles de filtrage personnalisées
- Enregistrer toutes les demandes réseau
- Intégrer avec l’infrastructure de sécurité existante
Intégration avec les outils de sécurité existants
L’outil bash en sandbox fonctionne aux côtés de :- Règles de permission : Combinez avec les paramètres de permission pour une défense en profondeur
- Conteneurs de développement : Utilisez avec devcontainers pour une isolation supplémentaire
- Politiques d’entreprise : Appliquez les configurations de sandbox via les paramètres gérés
Meilleures pratiques
- Commencez restrictif : Commencez avec des permissions minimales et développez selon les besoins
- Surveillez les journaux : Examinez les tentatives de violation du sandbox pour comprendre les besoins de Claude Code
- Utilisez des configurations spécifiques à l’environnement : Différentes règles de sandbox pour les contextes de développement par rapport à la production
- Combinez avec les permissions : Utilisez le sandboxing aux côtés des politiques IAM pour une sécurité complète
- Testez les configurations : Vérifiez que vos paramètres de sandbox ne bloquent pas les flux de travail légitimes
Open source
Le runtime du sandbox est disponible en tant que package npm open source pour une utilisation dans vos propres projets d’agent. Cela permet à la communauté plus large des agents IA de construire des systèmes autonomes plus sûrs et plus sécurisés. Cela peut également être utilisé pour sandboxer d’autres programmes que vous souhaitez exécuter. Par exemple, pour sandboxer un serveur MCP, vous pouvez exécuter :Limitations
- Surcharge de performance : Minimale, mais certaines opérations du système de fichiers peuvent être légèrement plus lentes
- Compatibilité : Certains outils qui nécessitent des modèles d’accès système spécifiques peuvent nécessiter des ajustements de configuration, ou même devront être exécutés en dehors du sandbox
- Support de plateforme : Supporte macOS, Linux et WSL2. WSL1 n’est pas supporté. Le support natif de Windows est prévu.
Ce que le sandboxing ne couvre pas
Le sandbox isole les sous-processus Bash. Les autres outils fonctionnent sous des limites différentes :- Outils de fichiers intégrés : Read, Edit et Write utilisent le système de permissions directement plutôt que de s’exécuter via le sandbox. Consultez permissions.
- Utilisation de l’ordinateur sur le bureau : Lorsque Claude ouvre des applications et contrôle votre écran sur macOS, il s’exécute sur votre bureau réel plutôt que dans un environnement isolé. Les invites de permission par application contrôlent chaque application. Consultez utilisation de l’ordinateur.
Voir aussi
- Sécurité - Fonctionnalités de sécurité complètes et meilleures pratiques
- Permissions - Configuration des permissions et contrôle d’accès
- Paramètres - Référence de configuration complète
- Référence CLI - Options de ligne de commande