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

Quels sont les modes de permission de Claude Code ?

Claude Code offre les 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.

En session, Shift+Tab ou Alt+M cycle entre les modes de permission disponibles.

Lancez Claude Code en mode default 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.

Utilisez Shift+Tab ou Alt+M pour cycler entre les modes en session. 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 default (défaut)
$ claude

# Mode acceptEdits
$ claude --permission-mode acceptEdits

# Mode plan (analyse avant action)
$ claude --permission-mode plan

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

# En session, Shift+Tab ou Alt+M pour cycler entre les modes

Vous pouvez aussi définir le mode par défaut dans settings.json : "defaultMode": "plan".

Le mode bypassPermissions 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 default au quotidien, Shift+Tab/Alt+M pour cycler entre les modes en session, et réservez bypassPermissions 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.

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

En pratique, la grande majorité des développeurs configurent entre 5 et 10 commandes autorisées pour couvrir leur workflow quotidien. Vérifiez que vos règles deny sont plus spécifiques que vos règles allow 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 significativement la surface d'attaque.

# 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. Claude Code intègre une détection native des tentatives d'injection.

# 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, la majorité des équipes qui adoptent Claude Code partagent un fichier de configuration projet pour garantir un niveau de sécurité homogène.

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

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 cat ~/.claude/settings.json est la première à exécuter pour auditer l'état de sécurité d'une installation existante. la majorité des problèmes de permission se résolvent en vérifiant la configuration active.

# Audit rapide de sécurité en 3 commandes
$ cat ~/.claude/settings.json | jq '.permissions.allow'
$ cat ~/.claude/settings.json | jq '.permissions.deny'
$ cat ~/.claude/settings.json

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 cat ~/.claude/settings.json 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 la quasi-totalité des vecteurs de risque connus.

1. Vérifiez que le sandboxing est actif : le sandboxing natif
2. Contrôlez les outils autorisés : cat ~/.claude/settings.json | jq '.permissions.allow'
3. Examinez les commandes bloquées : cat ~/.claude/settings.json | jq '.permissions.deny'
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:" &&
echo "2. Allow rules:" && cat ~/.claude/settings.json | jq '.permissions.allow'
echo "3. Deny rules:" && cat ~/.claude/settings.json | jq '.permissions.deny'
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.