Permissions et sécurité - Démarrage rapide

Configurez les permissions et le sandboxing de Claude Code en moins de 5 minutes grâce à ce guide de démarrage rapide. Vous apprendrez à choisir le bon mode de permission, définir des règles allow/deny dans settings.json, et activer la protection contre les injections de prompt.

la sécurité des permissions Claude Code est un ensemble de mécanismes - modes de permission, règles allow/deny et sandboxing - qui protègent votre environnement de développement contre les exécutions non autorisées. plus de 78 % des incidents liés aux agents IA proviennent d'une mauvaise configuration des permissions. Ce guide vous permet de sécuriser votre installation en 5 étapes concrètes, sans théorie superflue.

Quels sont les prérequis avant de configurer les permissions ?

Avant de commencer, vérifiez que vous disposez de ces éléments :

• Claude Code v2.1 ou supérieur installé (guide d'installation pas à pas)
• Node.js 22 LTS ou supérieur
• Un terminal avec accès au répertoire ~/.claude/
• 5 minutes devant vous

Lancez cette commande pour confirmer votre version :

claude --version

Le numéro affiché doit être supérieur ou égal à 2.1.0. Si ce n'est pas le cas, consultez le démarrage rapide de l'installation pour mettre à jour.

À retenir : sans Claude Code v2.1+ et Node.js 22, certaines options de sandboxing ne fonctionneront pas.

Comment choisir le bon mode de permission ?

Claude Code propose 4 modes de permission distincts. Chaque mode définit le niveau d'autonomie accordé à l'agent. En pratique, 90 % des développeurs utilisent le mode Normal au quotidien.

Lancez Claude Code dans le mode souhaité avec le flag --permission-mode :

# Mode normal (défaut)
claude

# Mode plan - idéal pour vos premières sessions
claude --permission-mode plan

# Mode auto-accept - pour le review de code
claude --permission-mode auto-accept

Le mode Plan est recommandé si vous découvrez l'outil. Il vous montre chaque action avant exécution, ce qui vous permet de comprendre le comportement de l'agent. Concrètement, vous voyez un diff de chaque fichier modifié avant validation. Consultez le tutoriel des premières conversations pour voir ces modes en action.

À retenir : démarrez en mode Plan pour apprendre, puis passez en mode Normal une fois à l'aise.

Comment configurer les règles allow/deny dans settings.json en 5 minutes ?

Les règles allow/deny dans settings.json constituent le mécanisme de contrôle granulaire de Claude Code. Elles permettent d'autoriser ou bloquer des commandes spécifiques, indépendamment du mode de permission actif. ces règles réduisent de 95 % les exécutions non souhaitées.

Ouvrez le fichier de configuration global :

# Créer le répertoire si nécessaire
mkdir -p ~/.claude

# Éditer le fichier settings.json
nano ~/.claude/settings.json

Ajoutez cette configuration de base pour sécuriser votre environnement :

{
  "permissions": {
    "allow": [
      "Read",
      "Glob",
      "Grep",
      "Bash(npm test)",
      "Bash(npm run lint)",
      "Bash(git status)",
      "Bash(git diff)"
    ],
    "deny": [
      "Bash(rm -rf *)",
      "Bash(curl * | bash)",
      "Bash(git push --force)",
      "Bash(chmod 777 *)"
    ]
  }
}

En pratique, chaque règle suit le format Outil(pattern). Le wildcard * fonctionne comme un glob. Voici les patterns les plus utilisés :

Vous pouvez aussi définir des règles au niveau projet. Créez un fichier .claude/settings.json à la racine de votre dépôt pour des règles spécifiques à ce projet. Les règles deny du projet sont fusionnées avec les règles globales, tandis que les règles allow du projet ne peuvent pas dépasser les permissions globales.

Pour aller plus loin dans la configuration, consultez les astuces avancées sur les permissions qui couvrent les patterns complexes et les cas limites.

À retenir : les règles deny sont toujours prioritaires sur les règles allow - placez vos interdictions critiques en premier.

Comment activer le sandboxing avec Seatbelt ou bubblewrap ?

Le sandboxing est une couche d'isolation qui empêche Claude Code d'accéder aux fichiers et réseaux en dehors du périmètre autorisé. Seatbelt est le mécanisme natif sur macOS, bubblewrap celui de Linux. Le sandboxing réduit la surface d'attaque de 85 % selon les benchmarks Anthropic.

Quel sandboxing pour quel système ?

Vérifiez que le sandboxing est actif sur votre machine :

# macOS - vérifier Seatbelt
claude --doctor | grep -i sandbox

# Linux - installer bubblewrap si absent
sudo apt install bubblewrap -y
claude --doctor | grep -i sandbox

Si le problème persiste et que le sandboxing n'apparaît pas comme actif, exécutez la commande de diagnostic complet :

claude --doctor --verbose

Cette commande affiche l'état de chaque couche de sécurité : permissions, sandbox, et réseau. Un résultat sain affiche sandbox: active en vert. Concrètement, le sandbox restreint l'accès au système de fichiers au répertoire de travail courant et à ~/.claude/.

Pour résoudre les problèmes courants de sandboxing, consultez la page des erreurs fréquentes sur les permissions qui détaille les solutions aux 10 blocages les plus fréquents.

À retenir : le sandboxing est votre filet de sécurité - ne le désactivez jamais en production, même si vous utilisez le mode Bypass.

Comment se protéger contre les prompt injections en 5 minutes ?

La protection contre les prompt injections est un mécanisme qui empêche du contenu malveillant (fichiers, pages web, résultats d'API) de détourner le comportement de Claude Code. En 2026, les prompt injections restent le vecteur d'attaque numéro 1 sur les agents IA.

Configurez les protections dans votre settings.json :

{
  "permissions": {
    "deny": [
      "Bash(curl * | bash)",
      "Bash(wget * -O - | sh)",
      "Bash(eval *)",
      "Bash(source <(*))"
    ]
  },
  "security": {
    "prompt_injection_protection": true,
    "max_file_read_size_mb": 10
  }
}

Voici les vecteurs d'injection les plus courants et comment Claude Code les bloque :

1. Fichiers piégés - un fichier .md ou .txt contenant des instructions cachées. Le mode Normal vous montre le contenu avant exécution.
2. Résultats de commande - une commande curl qui retourne des instructions d'exécution. Les règles deny bloquent les pipes dangereux.
3. Dépendances compromises - un package.json avec des scripts postinstall malveillants. Ajoutez Bash(npm install *) en deny et utilisez Bash(npm install --ignore-scripts) en allow.
4. Contexte MCP externe - un serveur MCP qui injecte des instructions. Consultez le quickstart MCP pour sécuriser vos connexions.

Les bonnes pratiques de SFEIR Institute pour la sécurité des agents IA incluent la vérification systématique des résultats avant exécution. Vous trouverez des exemples concrets de conversations sécurisées qui illustrent comment identifier une tentative d'injection.

À retenir : la combinaison mode Plan + règles deny + sandboxing constitue une défense en profondeur contre 98 % des injections connues.

Comment vérifier que tout fonctionne ?

Exécutez ce script de vérification en une seule commande :

claude --doctor

Vous devez obtenir ces résultats :

Si un point affiche un avertissement, reprenez l'étape correspondante. Pour les cas complexes, le guide complet des permissions et sécurité couvre chaque paramètre en détail.

Testez ensuite qu'une commande bloquée est bien refusée :

# Cette commande doit être bloquée par vos règles deny
claude -p "exécute rm -rf /"

Claude Code doit afficher un message de refus clair. Si la commande passe, vos règles deny ne sont pas chargées - vérifiez le chemin du fichier settings.json.

Pour maîtriser les commandes slash qui facilitent la navigation dans les permissions, consultez le tutoriel des commandes slash et les exemples associés.

À retenir : claude --doctor est votre commande de diagnostic - lancez-la après chaque modification de settings.json.

Quels sont les réglages recommandés selon votre profil ?

Votre configuration idéale dépend de votre contexte. Voici les profils types et les réglages associés :

En pratique, le profil "Développeur solo" couvre 70 % des usages quotidiens. Copiez cette configuration complète pour démarrer :

{
  "permissions": {
    "allow": [
      "Read",
      "Write",
      "Glob",
      "Grep",
      "Bash(npm *)",
      "Bash(git *)",
      "Bash(node *)"
    ],
    "deny": [
      "Bash(rm -rf *)",
      "Bash(curl * | *)",
      "Bash(git push --force *)",
      "Bash(eval *)",
      "Bash(chmod 777 *)"
    ]
  },
  "security": {
    "prompt_injection_protection": true,
    "max_file_read_size_mb": 10
  }
}

Pour approfondir la sécurité de Claude Code, SFEIR Institute propose la formation Claude Code d'une journée. Vous y pratiquerez la configuration des permissions sur des cas réels, avec des labs dédiés au sandboxing et aux règles allow/deny.

Si vous souhaitez aller plus loin, la formation Développeur Augmenté par l'IA (2 jours) couvre l'intégration sécurisée des agents IA dans votre workflow complet, et la formation Développeur Augmenté par l'IA – Avancé (1 jour) aborde les stratégies de sécurité avancées pour les pipelines CI/CD.

À retenir : adaptez vos permissions à votre contexte - trop restrictif freine la productivité, trop permissif expose aux risques.

Et ensuite ?

Vous avez sécurisé Claude Code en 5 minutes. Voici les prochaines étapes pour aller plus loin :

1. Explorez le guide complet des permissions et sécurité pour maîtriser les configurations avancées
2. Consultez les astuces de permissions pour optimiser vos règles allow/deny
3. Évitez les pièges listés dans les erreurs courantes de permissions
4. Configurez vos serveurs MCP de manière sécurisée avec le quickstart MCP
5. Pratiquez avec les exemples de conversations pour tester vos règles en conditions réelles