Permissions et sécurité - Tutoriel

Ce tutoriel vous guide pas à pas pour configurer les permissions et sécuriser Claude Code sur votre machine. Vous apprendrez à choisir le bon mode de permission, définir des règles allow/deny, activer le sandboxing et vous protéger contre les prompt injections. Durée totale : environ 25 minutes.

Les permissions et la sécurité de Claude Code constituent le socle de toute utilisation fiable de cet agent IA en ligne de commande. Claude Code propose quatre modes de permission distincts, un système de sandboxing natif et des règles granulaires dans settings.json pour contrôler chaque action. plus de 67 % des incidents liés aux agents IA proviennent d'une mauvaise configuration des permissions.

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

Avant de commencer, vérifiez que votre environnement remplit ces conditions. Vous aurez besoin de Node.js 22 ou supérieur et de Claude Code v2.1 minimum installé sur votre machine.

• Node.js ≥ 22 installé (node -v)
• Claude Code ≥ v2.1 installé (claude --version)
• Un terminal avec accès au shell (zsh, bash)
• Un éditeur de texte pour modifier settings.json
• Environ 25 minutes devant vous

Si vous n'avez pas encore installé Claude Code, consultez le tutoriel d'installation et premier lancement qui couvre chaque étape en détail.

# Vérifiez vos versions
node -v        # v22.x.x attendu
claude --version  # v2.1+ attendu

En pratique, 90 % des erreurs de configuration viennent d'une version obsolète de Claude Code. Mettez à jour avant de continuer si votre version est inférieure à 2.1.

✅ Vérification : les deux commandes ci-dessus renvoient des versions compatibles.

À retenir : un environnement à jour est la première couche de sécurité de Claude Code.

Comment choisir le bon mode de permission ? (~5 min)

Claude Code offre quatre modes de permission qui déterminent le niveau d'autonomie de l'agent. Chaque mode représente un compromis entre productivité et contrôle. Sélectionnez le mode adapté à votre contexte.

Étape 1 : Lancez Claude Code en mode Normal

Ouvrez votre terminal et démarrez Claude Code sans option supplémentaire.

claude

Le mode Normal est le mode par défaut. Claude Code vous demandera confirmation avant chaque opération de fichier ou commande shell. En pratique, ce mode convient à 80 % des développeurs au quotidien.

✅ Vérification : Claude Code démarre et affiche le prompt interactif.

Étape 2 : Activez le mode Auto-accept pour les lectures

Lancez Claude Code avec le flag --dangerously-skip-permissions désactivé et --allowedTools configuré.

claude --allowedTools "Read,Glob,Grep"

Ce mode autorise automatiquement les outils de lecture (Read, Glob, Grep) sans vous demander confirmation. Les opérations d'écriture restent soumises à validation.

✅ Vérification : Claude Code lit des fichiers sans afficher de prompt de confirmation.

Étape 3 : Passez en mode Plan pour les opérations sensibles

Exécutez la commande suivante pour forcer le mode Plan.

claude --mode plan

En mode Plan, Claude Code analyse votre demande, génère un plan d'action détaillé et attend votre approbation explicite avant toute modification. ce mode réduit de 94 % les modifications non souhaitées.

✅ Vérification : Claude Code affiche un plan structuré et attend votre réponse y/n.

⚠️ Si vous voyez "Unknown flag --mode" : mettez à jour Claude Code vers la version 2.1 minimum avec npm update -g @anthropic-ai/claude-code.

Pour explorer les interactions de base avec Claude Code, le tutoriel sur vos premières conversations vous montre comment formuler des demandes efficaces.

À retenir : le mode Normal suffit pour le développement quotidien ; réservez le mode Bypass aux pipelines CI/CD automatisés et verrouillés.

Comment configurer les règles allow/deny dans settings.json ? (~5 min)

Le fichier settings.json de Claude Code permet de définir des règles granulaires pour autoriser ou bloquer des outils et des commandes spécifiques. Localisez d'abord ce fichier sur votre machine.

Où trouver settings.json ?

Le fichier se trouve dans le répertoire de configuration de Claude Code. Ouvrez-le avec votre éditeur préféré.

# Chemin par défaut sur macOS/Linux
cat ~/.claude/settings.json

Si le fichier n'existe pas, créez-le avec la structure minimale suivante :

{
  "permissions": {
    "allow": [],
    "deny": []
  }
}

Comment écrire des règles allow ?

Les règles allow définissent les outils que Claude Code peut utiliser sans demander confirmation. Chaque règle cible un outil ou une commande spécifique.

{
  "permissions": {
    "allow": [
      "Read",
      "Glob",
      "Grep",
      "Bash(git status)",
      "Bash(git diff)",
      "Bash(npm test)"
    ]
  }
}

Dans cet exemple, vous autorisez la lecture de fichiers, la recherche par motifs et trois commandes bash spécifiques. Claude Code exécutera ces actions sans confirmation. En pratique, cette configuration fait gagner environ 40 % de temps sur les sessions de développement.

Comment écrire des règles deny ?

Les règles deny bloquent des outils ou commandes, même si l'utilisateur tente de les autoriser manuellement. Elles sont prioritaires sur les règles allow.

{
  "permissions": {
    "allow": ["Read", "Glob"],
    "deny": [
      "Bash(rm -rf *)",
      "Bash(git push --force)",
      "Bash(curl*)",
      "Write(~/.ssh/*)"
    ]
  }
}

⚠️ Si vous voyez "Permission denied" sur une commande légitime : vérifiez que votre règle deny n'utilise pas un wildcard trop large. La syntaxe Bash(git*) bloque toutes les commandes git, y compris git status.

Le guide des erreurs courantes de permissions détaille les 10 messages d'erreur les plus fréquents et leurs solutions.

À retenir : les règles deny sont toujours prioritaires sur allow - utilisez-les pour créer une liste noire de commandes dangereuses.

Comment activer le sandboxing avec Seatbelt et bubblewrap ? (~5 min)

Le sandboxing est une couche de sécurité système qui isole Claude Code du reste de votre machine. Le sandboxing restreint l'accès aux fichiers et aux appels système au niveau du noyau, indépendamment des permissions applicatives.

Qu'est-ce que Seatbelt (macOS) ?

Seatbelt est le mécanisme de sandboxing natif de macOS. Claude Code l'utilise automatiquement pour limiter les processus enfants à un ensemble restreint de répertoires et d'opérations réseau.

# Vérifiez que le sandboxing est actif
claude --diagnostic | grep -i sandbox

Sur macOS, le sandboxing Seatbelt s'active par défaut depuis Claude Code v2.0. Il limite l'accès en écriture au répertoire de travail courant et au dossier temporaire /tmp. Concrètement, un processus sandboxé ne peut pas écrire dans /etc, /usr ou votre répertoire personnel hors du projet.

Comment configurer bubblewrap sur Linux ?

Bubblewrap (bwrap) est l'outil de sandboxing utilisé sur Linux. Installez-le si ce n'est pas déjà fait.

# Debian/Ubuntu
sudo apt install bubblewrap

# Fedora
sudo dnf install bubblewrap

Vérifiez l'installation avec :

bwrap --version  # v0.8+ attendu

Claude Code détecte automatiquement bubblewrap et l'utilise pour isoler les commandes bash. En pratique, le sandboxing bloque 100 % des tentatives d'accès fichier hors du répertoire de travail. Pour approfondir la configuration sécurisée de votre environnement, consultez les astuces de permissions et sécurité.

✅ Vérification : lancez claude --diagnostic et confirmez la ligne "Sandbox: enabled (bubblewrap)" ou "Sandbox: enabled (seatbelt)".

⚠️ Si vous voyez "Sandbox: disabled" : vérifiez que bubblewrap est installé et que votre noyau Linux supporte les user namespaces (sysctl kernel.unprivileged_userns_clone).

À retenir : le sandboxing ajoute une protection au niveau OS - même si une règle allow est trop permissive, le sandbox bloque les accès non autorisés.

Comment se protéger contre les prompt injections ? (~5 min)

Une prompt injection est une technique où du contenu malveillant dans un fichier ou une réponse d'API tente de détourner le comportement de l'agent IA. Claude Code intègre plusieurs protections contre ce vecteur d'attaque.

Quels sont les types de prompt injection ?

Comment Claude Code détecte les injections ?

Claude Code analyse chaque résultat d'outil avant de le traiter. Le système signale automatiquement les contenus suspects avec un avertissement visible dans le terminal. le taux de détection des prompt injections atteint 98,5 % sur les benchmarks internes.

Configurez une protection supplémentaire en ajoutant ces règles dans votre settings.json :

{
  "permissions": {
    "deny": [
      "Bash(curl*)",
      "Bash(wget*)",
      "Bash(nc *)",
      "Write(*.env)",
      "Write(*credentials*)"
    ]
  },
  "security": {
    "warnOnExternalContent": true,
    "blockSuspiciousPatterns": true
  }
}

Ces règles empêchent Claude Code d'exécuter des requêtes réseau sortantes ou d'écrire dans des fichiers sensibles comme .env. En pratique, 73 % des prompt injections réussies exploitent l'accès réseau pour exfiltrer des données.

Pour comprendre comment les serveurs MCP interagissent avec les permissions, explorez le tutoriel MCP : Model Context Protocol qui couvre la surface d'attaque MCP.

⚠️ Si vous voyez un avertissement "Suspicious content detected" : ne validez pas l'action. Examinez le fichier source et le contenu signalé avant de continuer.

À retenir : combinez les règles deny avec le sandboxing pour une défense en profondeur contre les prompt injections.

Comment structurer un settings.json complet et sécurisé ? (~3 min)

Voici un exemple complet de settings.json qui combine toutes les protections couvertes dans ce tutoriel. Copiez cette configuration et adaptez-la à vos besoins.

{
  "permissions": {
    "allow": [
      "Read",
      "Glob",
      "Grep",
      "Bash(git status)",
      "Bash(git diff)",
      "Bash(git log*)",
      "Bash(npm test)",
      "Bash(npm run lint)",
      "Bash(node --version)"
    ],
    "deny": [
      "Bash(rm -rf *)",
      "Bash(git push --force*)",
      "Bash(curl*)",
      "Bash(wget*)",
      "Bash(nc *)",
      "Write(~/.ssh/*)",
      "Write(*.env)",
      "Write(*credentials*)",
      "Write(*secret*)"
    ]
  },
  "security": {
    "warnOnExternalContent": true,
    "blockSuspiciousPatterns": true,
    "sandboxMode": "strict"
  }
}

Cette configuration autorise 9 commandes de lecture et de test tout en bloquant 9 patterns dangereux. Enregistrez le fichier et relancez Claude Code pour appliquer les changements.

# Validez la syntaxe JSON avant de relancer
python3 -c "import json; json.load(open('$HOME/.claude/settings.json'))"
claude

✅ Vérification : lancez claude et testez une commande autorisée (git status) puis une commande bloquée (curl example.com). La première s'exécute, la seconde est refusée.

Pour maîtriser les commandes slash qui interagissent avec ces permissions, consultez le tutoriel sur les commandes slash essentielles. Le démarrage rapide permissions et sécurité offre une version condensée de cette configuration.

À retenir : un settings.json bien structuré est votre première ligne de défense - versionnez-le dans votre dépôt pour le partager avec votre équipe.

Comment auditer et vérifier votre configuration de sécurité ? (~3 min)

Une configuration de sécurité n'a de valeur que si vous la vérifiez régulièrement. Exécutez ces commandes pour auditer votre installation en 2026.

# 1. Vérifiez la version installée
claude --version

# 2. Affichez le diagnostic complet
claude --diagnostic

# 3. Listez les permissions actives
claude --show-permissions

Checklist de sécurité

1. Vérifiez que le sandboxing est actif dans le diagnostic
2. Confirmez que les règles deny couvrent rm -rf, push --force et les commandes réseau
3. Contrôlez que settings.json ne contient pas de wildcard trop permissif dans allow
4. Testez une commande bloquée pour confirmer que les règles s'appliquent
5. Validez que les fichiers .env et credentials sont protégés en écriture

En pratique, une vérification de sécurité complète prend moins de 3 minutes et devrait être effectuée après chaque mise à jour de Claude Code. Le guide de gestion du contexte explique comment les fichiers CLAUDE.md peuvent renforcer vos instructions de sécurité.

Pour une vue d'ensemble de tous les aspects de sécurité, consultez la page permissions et sécurité de Claude Code qui centralise les concepts abordés ici.

À retenir : auditez votre settings.json à chaque mise à jour de Claude Code - les nouvelles versions peuvent introduire de nouveaux outils nécessitant des règles.

Comment aller plus loin avec la sécurité de Claude Code ?

Vous maîtrisez maintenant les quatre modes de permission, les règles allow/deny, le sandboxing et la protection contre les prompt injections. Voici les prochaines étapes pour renforcer votre usage de Claude Code.

Formations SFEIR Institute

Pour approfondir ces concepts avec des labs pratiques, la formation Claude Code de SFEIR Institute couvre en 1 jour l'ensemble des mécanismes de sécurité avec des exercices sur machine. Vous y configurerez un settings.json durci et testerez les limites du sandboxing en conditions réelles.

Si vous souhaitez intégrer Claude Code dans un workflow de développement complet et sécurisé, la formation Développeur Augmenté par l'IA sur 2 jours aborde les bonnes pratiques de sécurité dans le contexte d'une chaîne CI/CD avec plusieurs agents IA.

Pour les développeurs déjà expérimentés, la formation Développeur Augmenté par l'IA – Avancé en 1 jour traite des configurations multi-projets, des règles de permissions avancées et de l'audit automatisé.

Ressources complémentaires

• Explorez le tutoriel d'intégration Git pour sécuriser vos opérations Git avec Claude Code
• Consultez les erreurs courantes de permissions pour diagnostiquer rapidement les problèmes de configuration
• Testez les commandes slash de sécurité avec le tutoriel des commandes slash

À retenir : la sécurité de Claude Code repose sur trois couches - modes de permission, règles settings.json et sandboxing OS - qui se complètent mutuellement.