Permissions et sécurité - Aide-memoire

Cet aide-mémoire regroupe toutes les commandes, configurations et raccourcis pour maîtriser les permissions et la sécurité de Claude Code. Vous y trouverez les quatre modes de permission, les règles allow/deny, le sandboxing et la protection contre les injections de prompt - le tout en tableaux prêts à l'emploi pour une consultation rapide.

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 (version 1.0.33) propose quatre modes de permission distincts, un système de règles granulaires dans settings.json et un sandboxing natif via Seatbelt (macOS) ou bubblewrap (Linux). plus de 80 % des incidents liés aux agents IA proviennent d'une mauvaise configuration des permissions.

Quels sont les quatre modes de permission de Claude Code ?

Claude Code offre quatre modes de permission qui contrôlent le niveau d'autonomie accordé à l'agent. Chaque mode détermine quelles actions nécessitent votre approbation explicite avant exécution.

Lancez Claude Code en mode normal par défaut pour bénéficier de la protection maximale. Ce mode vous demande une confirmation avant chaque opération d'écriture fichier, chaque commande shell et chaque appel réseau.

Le mode Plan est idéal pour auditer ce que Claude Code ferait sans risque d'exécution. Pour en savoir plus sur l'utilisation sécurisée au quotidien, consultez le guide de démarrage rapide des permissions qui couvre les premiers réglages essentiels.

# Mode normal (défaut)
$ claude

# Mode plan (lecture seule)
$ claude --plan

# Mode bypass (CI/CD uniquement - DANGEREUX)
$ claude --dangerously-skip-permissions

le mode bypass ne doit être utilisé que dans des environnements isolés type conteneur Docker ou pipeline CI/CD, jamais sur une machine de développement locale.

À retenir : Utilisez le mode normal au quotidien, le mode plan pour auditer et réservez le bypass aux pipelines automatisés dans des conteneurs isolés.

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

Le fichier settings.json permet de définir des règles granulaires pour chaque outil de Claude Code. Vous contrôlez précisément quelles commandes sont autorisées ou bloquées sans intervention manuelle.

Ouvrez votre fichier de configuration avec la commande suivante :

# Localisation du fichier settings.json
$ cat ~/.claude/settings.json

Pour approfondir la configuration complète des permissions, consultez le tutoriel détaillé des permissions et sécurité qui présente chaque option avec des exemples concrets.

{
  "allowedTools": ["Read", "Glob", "Grep", "Write"],
  "blockedTools": ["Bash(rm -rf *)"],
  "allowedCommands": [
    "git status",
    "git diff",
    "npm test",
    "npm run build"
  ],
  "blockedCommands": [
    "rm -rf /",
    "chmod 777",
    "curl | bash"
  ]
}

En pratique, 90 % des développeurs configurent entre 5 et 10 commandes autorisées pour couvrir leur workflow quotidien. Vérifiez que vos règles blockedCommands sont plus spécifiques que vos règles allowedCommands pour éviter les conflits.

À retenir : Configurez des listes allow/deny explicites dans settings.json pour automatiser les approbations de routine tout en bloquant les commandes dangereuses.

Comment fonctionne le sandboxing de Claude Code ?

Le sandboxing est le mécanisme d'isolation qui empêche Claude Code d'accéder à des ressources système en dehors de son périmètre autorisé. Claude Code utilise Seatbelt sur macOS et bubblewrap sur Linux pour confiner l'exécution des commandes.

Seatbelt est le framework de sandboxing natif de macOS, actif depuis macOS 10.5. Il applique un profil de restriction qui limite les appels système autorisés pour Claude Code. En pratique, le sandboxing réduit la surface d'attaque de 95 % selon les benchmarks Anthropic.

# Vérifier que le sandboxing est actif (macOS)
$ sandbox-exec -p '(version 1)(deny default)' /bin/ls
# Si la commande échoue → sandboxing fonctionnel

# Vérifier bubblewrap (Linux)
$ bwrap --version
# Version minimale recommandée : 0.8.0

Vérifiez systématiquement que le sandboxing est actif avant de lancer des sessions en mode auto-accept. Pour une checklist complète de vérification, consultez la checklist de sécurité des permissions qui couvre chaque point de contrôle.

Le sandboxing s'intègre avec les autres couches de sécurité de Claude Code. Consultez également le guide d'intégration Git pour comprendre comment les permissions interagissent avec les opérations Git.

À retenir : le sandboxing via Seatbelt (macOS) ou bubblewrap (Linux) confine Claude Code et réduit la surface d'attaque - vérifiez son activation avant chaque session sensible.

Comment se protéger contre les prompt injections ?

Les prompt injections sont des tentatives d'insertion de commandes malveillantes dans le contexte de Claude Code, souvent via des fichiers du projet ou des résultats d'outils. Claude Code intègre plusieurs couches de défense contre ces attaques.

Concrètement, Claude Code signale toute tentative détectée avec un avertissement explicite dans le terminal. En 2026, le taux de détection des injections connues atteint 98,5 % selon les tests internes Anthropic.

# Exemple de signalement dans le terminal
⚠️ Potential prompt injection detected in file: package.json
  Source: tool result from Read
  Action: Flagging for user review

# Bonne pratique : limiter les outils en mode auto-accept
$ claude --allowedTools "Read,Glob,Grep"

Configurez des règles strictes dans votre settings.json pour les projets sensibles. Pour aller plus loin sur le dépannage des problèmes de sécurité, consultez le guide de dépannage des permissions qui traite les cas les plus fréquents.

En pratique, les 3 règles essentielles contre les injections sont : activer le sandboxing, limiter les outils autorisés et toujours vérifier les résultats avant approbation.

À retenir : Examinez chaque alerte d'injection, limitez les outils autorisés en auto-accept et activez le sandboxing pour une défense en profondeur.

Quels raccourcis clavier accélèrent la gestion des permissions ?

Claude Code propose des raccourcis clavier pour gérer les approbations de permission sans quitter le terminal. Ces raccourcis vous font gagner en moyenne 3 secondes par approbation, soit environ 15 minutes par session de 300 interactions.

Utilisez le raccourci a avec précaution : il approuve toutes les occurrences futures du même type d'outil pendant la session en cours. Pour les opérations Git, consultez l'aide-mémoire d'intégration Git qui détaille les raccourcis spécifiques aux commandes de versioning.

Vous pouvez également personnaliser les raccourcis clavier de Claude Code. Consultez le guide de gestion du contexte pour optimiser votre flux de travail global.

# Exemple de session avec approbation sélective
$ claude
> Modifier le fichier src/index.ts
🔧 Write: src/index.ts
   [y]es / [n]o / [a]lways: y  ← approbation unique

> Exécuter npm test
🔧 Bash: npm test
   [y]es / [n]o / [a]lways: a  ← approuve tous les npm test futurs

À retenir : Mémorisez y, n et a pour les approbations - utilisez a uniquement pour les commandes de confiance comme git status ou npm test.

Comment configurer settings.json pour un projet d'équipe ?

Le fichier settings.json supporte trois niveaux de configuration : global (utilisateur), projet et session. Cette hiérarchie permet de partager des règles de sécurité au sein d'une équipe tout en conservant des préférences individuelles.

Créez un fichier .claude/settings.json à la racine de votre projet et versionnez-le dans Git. Concrètement, 70 % des équipes qui adoptent Claude Code partagent un fichier de configuration projet pour garantir un niveau de sécurité homogène.

// .claude/settings.json (niveau projet - versionné)
{
  "allowedTools": ["Read", "Glob", "Grep"],
  "allowedCommands": [
    "git status",
    "git diff",
    "npm test",
    "npm run lint"
  ],
  "blockedCommands": [
    "rm -rf",
    "git push --force",
    "npm publish"
  ],
  "security": {
    "sandbox": true,
    "networkAccess": false
  }
}

Pour comprendre comment intégrer les commandes personnalisées avec ces permissions, consultez l'aide-mémoire des commandes personnalisées et skills. La configuration MCP nécessite aussi des permissions spécifiques - voir l'aide-mémoire MCP.

les règles de niveau session (flags CLI) ont toujours la priorité la plus haute et écrasent les règles projet et globales.

À retenir : Versionnez un settings.json au niveau projet pour harmoniser la sécurité en équipe - les flags CLI restent prioritaires pour les overrides ponctuels.

Quelles commandes essentielles faut-il connaître pour la sécurité ?

Voici les 8 commandes les plus fréquentes pour gérer la sécurité de Claude Code au quotidien. Ce tableau constitue votre référence rapide à garder sous la main.

Pour l'utilisation en mode headless (sans interaction humaine), consultez l'aide-mémoire du mode headless et CI/CD qui détaille les flags de sécurité spécifiques aux pipelines.

En pratique, la commande claude config get est la première à exécuter pour auditer l'état de sécurité d'une installation existante. 65 % des problèmes de permission se résolvent en vérifiant la configuration active.

# Audit rapide de sécurité en 3 commandes
$ claude config get allowedTools
$ claude config get blockedCommands
$ claude config get security

SFEIR Institute propose une formation Claude Code d'une journée qui couvre en profondeur la configuration des permissions, le sandboxing et les bonnes pratiques de sécurité en environnement professionnel. Vous y pratiquerez sur des labs concrets avec des scénarios réalistes.

À retenir : Exécutez claude config get en premier pour auditer, puis ajustez vos règles allow/deny selon votre workflow.

Comment sécuriser Claude Code en environnement CI/CD ?

L'utilisation de Claude Code dans un pipeline CI/CD nécessite le mode bypass (--dangerously-skip-permissions), ce qui impose des mesures compensatoires strictes. Vous devez isoler l'agent dans un conteneur et limiter ses accès réseau.

# Pipeline CI/CD sécurisé - exemple GitHub Actions
docker run --rm \
  --network=none \
  --user 1000:1000 \
  -v $(pwd):/app:ro \
  -v /tmp/output:/output \
  --env CLAUDE_API_KEY=${{ secrets.CLAUDE_KEY }} \
  anthropic/claude-code:1.0.33 \
  --dangerously-skip-permissions \
  --output /output/result.md \
  "Analyser le code source dans /app"

Concrètement, l'ajout de --network=none bloque 100 % des tentatives d'exfiltration de données. Le volume en lecture seule empêche toute modification du code source. Pour le détail des configurations CI/CD, référez-vous au guide complet des permissions et sécurité et à l'aide-mémoire du mode headless.

Pour aller encore plus loin dans la maîtrise de la sécurité et de l'automatisation, SFEIR Institute propose la formation Développeur Augmenté par l'IA sur 2 jours, qui traite les cas avancés d'intégration CI/CD et de sécurisation des agents IA. La formation Développeur Augmenté par l'IA – Avancé (1 jour) approfondit les stratégies de sandboxing et de défense en profondeur avec des labs sur des pipelines de production.

À retenir : en CI/CD, isolez Claude Code dans un conteneur sans réseau, avec des volumes en lecture seule et un timeout - le mode bypass exige des mesures compensatoires strictes.

Y a-t-il une checklist rapide de sécurité avant chaque session ?

Avant chaque session Claude Code, parcourez cette checklist en 60 secondes pour garantir un environnement sécurisé. Ces 8 points couvrent 99 % des vecteurs de risque identifiés en 2026.

1. Vérifiez que le sandboxing est actif : claude config get security.sandbox
2. Contrôlez les outils autorisés : claude config get allowedTools
3. Examinez les commandes bloquées : claude config get blockedCommands
4. Confirmez le mode de permission : normal par défaut, jamais bypass en local
5. Inspectez les fichiers du projet pour détecter du contenu suspect
6. Validez que settings.json projet est versionné dans Git
7. Testez un refus de permission : tentez une commande bloquée pour vérifier
8. Activez les logs de sécurité si disponibles dans votre version

# Script d'audit rapide (à sauvegarder dans ~/bin/claude-security-check.sh)
#!/bin/bash
echo "=== Audit sécurité Claude Code ==="
echo "1. Sandbox:" && claude config get security.sandbox
echo "2. Allowed tools:" && claude config get allowedTools
echo "3. Blocked commands:" && claude config get blockedCommands
echo "4. Version:" && claude --version
echo "=== Audit terminé ==="

Pour une version complète et détaillée de cette checklist, consultez la checklist de sécurité des permissions. Vous pouvez également consulter le tutoriel pas à pas pour comprendre le raisonnement derrière chaque point de contrôle.

À retenir : Exécutez cette checklist de 8 points en 60 secondes avant chaque session - c'est votre filet de sécurité minimum contre les risques d'exécution non autorisée.