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 plusieurs mécanismes de permission, un système de règles granulaires dans settings.json et un sandboxing natif via Seatbelt (macOS) ou bubblewrap (Linux). 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(wget *)"
 ]
 }
}

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. Claude Code découpe les commandes composées (séparées par |, &&, etc.) et applique les règles à chaque sous-commande indépendamment : une règle ne doit donc cibler qu'une seule sous-commande. Bloquer Bash(curl *) suffit ainsi à neutraliser le motif curl ... | bash, sans imbriquer de pipe dans le spécificateur.

À 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.

Le sandbox intégré de Claude Code repose uniquement sur Seatbelt (macOS) et bubblewrap (Linux et WSL2). Les conteneurs (Docker, dev containers) constituent une approche d'isolation distincte qui encapsule l'ensemble du processus Claude Code, et non une technologie du sandbox intégré : les commandes docker sont d'ailleurs incompatibles avec le sandbox et doivent être listées dans excludedCommands. 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 l'état du sandbox Claude Code (en session)
> /sandbox
# Consultez l'onglet Dependencies (bubblewrap et socat installés ?)
# et l'onglet Config (paramètres du sandbox)

# Activer le sandbox dans settings.json
# "sandbox": { "enabled": true }

Vérifiez systématiquement l'état du sandbox avec la commande /sandbox en session (onglets Dependencies et Config) avant de lancer des sessions en mode auto-accept. Sur Linux, les paquets bubblewrap et socat doivent être installés. 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 combine plusieurs garde-fous documentés : un système de permissions qui exige votre approbation explicite, une analyse contextuelle de la requête complète, la sanitisation des entrées, une blocklist des commandes type curl/wget et une fenêtre de contexte isolée pour WebFetch. Ces couches réduisent la surface d'attaque, mais la vigilance de l'utilisateur reste la dernière barrière : examinez chaque action avant de l'approuver.

# 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 accélèrent sensiblement le traitement des approbations au fil d'une session.

Utilisez l'option « Oui, ne plus demander » avec précaution : sa portée dépend de l'outil (par projet et par commande pour Bash, jusqu'à la fin de session pour les éditions). 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 (menu illustratif)
> Modifier le fichier src/index.ts
🔧 Write: src/index.ts
  ❯ Oui
    Oui, ne plus demander (portée selon l'outil)
    Non

À retenir : au moment de l'approbation, choisissez « Oui » pour une action ponctuelle et « Oui, ne plus demander » uniquement pour les commandes de confiance comme git status ou npm test, en gardant à l'esprit que la portée de cette mémorisation dépend de l'outil.

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
# Image construite à partir d'une base node avec Claude Code installé
# (npm install -g @anthropic-ai/claude-code)
docker run --rm \
 --network=none \
 --user 1000:1000 \
 -v $(pwd):/app:ro \
 -v /tmp/output:/output \
 --env ANTHROPIC_API_KEY=${{ secrets.ANTHROPIC_API_KEY }} \
 mon-image-claude-code \
 claude --dangerously-skip-permissions \
 -p "Analyser le code source dans /app" > /tmp/output/result.md

Concrètement, l'ajout de --network=none empêche l'agent d'effectuer des connexions réseau sortantes, ce qui réduit fortement le risque 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.