7 échecs de sécurité avec Claude Code: causes, reprise et prévention

Claude Code n’est pas seulement une fenêtre de chat qui propose du code. Il peut modifier des fichiers, lancer des tests, lire l’état Git et proposer des commandes de déploiement. Cette puissance est utile, mais une validation distraite peut exécuter une action dangereuse plus vite qu’une commande tapée à la main.

Ce guide transforme les incidents de sécurité fréquents en garde-fous concrets. Pour débuter simplement: une permission définit ce que l’agent peut faire, un hook est un point de contrôle avant ou après un appel d’outil, et un sandbox est un espace isolé qui limite les dégâts. Les exemples ci-dessous fournissent un settings.json, un scanner de secrets en Node.js et un workflow GitHub Actions.

flowchart TD
  Request["User request"] --> Plan["Claude Code plan"]
  Plan --> Permission["Permission rules"]
  Permission --> Hook["PreToolUse hook"]
  Hook --> Execute["Tool execution"]
  Execute --> Audit["Log, review, recovery"]
  Hook -->|block risky command| Stop["Stop before damage"]

Carte des échecs

Cas d’échec	Moment typique	Dommage	Garde-fou à installer
Commit de .env	”Ajoute aussi le fichier pour la CI”	Fuite de clés et dépenses imprévues	.gitignore plus scan des fichiers staged
Suppression de données prod	Migration lancée sur la mauvaise URL	Perte de données	Vérification d’environnement avant DB
git push --force	Résolution de conflit dans l’urgence	Commits d’équipe écrasés	Règles ask et protection de branche
Revue IA en boucle dans CI	Chaque PR déclenche une automatisation large	Coûts Actions et API	max-turns, timeout, moindre privilège
Logs non fiables collés	Le log contient des instructions cachées	Prompt injection	Refuser les fetch web et shell risqués
Accès MCP trop large	Serveur externe accepté trop vite	Lecture excessive de données locales	Autoriser seulement les MCP fiables
Fatigue d’approbation	L’utilisateur valide sans lire	Commandes dangereuses acceptées	Hooks qui bloquent par défaut

Le message n’est pas que Claude Code est dangereux par défaut. La documentation officielle Security décrit les permissions orientées lecture, les confirmations, le sandboxing et la responsabilité utilisateur. Le risque opérationnel vient surtout des moments où l’équipe est pressée. La configuration doit rendre le chemin sûr plus simple que le chemin risqué.

Cas pratique 1: éviter les fuites d’API keys

L’erreur la plus courante consiste à traiter .env comme un coffre-fort. Ce n’en est pas un: c’est un fichier texte local. Il n’est relativement sûr que tant qu’il ne se retrouve pas dans Git, les logs, les captures d’écran ou les prompts. Une clé Stripe, SendGrid, Anthropic ou GitHub publiée doit être considérée comme compromise.

Commitez uniquement la forme de la configuration, jamais les valeurs réelles.

# .gitignore
.env
.env.*
!.env.example
secrets/
*.pem
*.key
*service-account*.json
credentials.json

# .env.example
ANTHROPIC_API_KEY=replace_me
DATABASE_URL=postgres://app_user:password@localhost:5432/app_dev
STRIPE_SECRET_KEY=sk_test_replace_me

Ensuite, resserrez les permissions de Claude Code. deny bloque, ask demande confirmation et allow autorise les commandes sûres et répétitives. Les pages officielles Settings et Configure permissions expliquent l’évaluation de ces règles.

{
  "$schema": "https://json.schemastore.org/claude-code-settings.json",
  "permissions": {
    "allow": [
      "Bash(npm run lint)",
      "Bash(npm run test *)",
      "Bash(git status)",
      "Bash(git diff *)"
    ],
    "ask": [
      "Bash(git push *)",
      "Bash(npm run deploy *)",
      "Write(./migrations/**)"
    ],
    "deny": [
      "Read(./.env)",
      "Read(./.env.*)",
      "Read(./secrets/**)",
      "Bash(rm -rf *)",
      "Bash(curl *)",
      "Bash(wget *)",
      "WebFetch"
    ]
  }
}

Cette configuration ne bloque pas Claude Code. Elle fluidifie les commandes à faible risque et rend les actions destructrices visibles. Si votre projet a besoin d’accès web, commencez étroit: domaine autorisé, objectif clair et revue humaine avant d’ouvrir davantage.

Cas pratique 2: garder les PR d’équipe vérifiables

En équipe, le danger est souvent un glissement de processus. On finit par penser que “l’IA a relu” signifie que personne ne doit regarder les fichiers de permissions, les workflows ou les secrets. C’est précisément là que les problèmes passent.

Ajoutez un scanner sans dépendance externe. Par défaut il analyse les fichiers staged; en CI, --all analyse tout le dépôt.

// scripts/claude-security-check.mjs
import { execFileSync } from "node:child_process";
import fs from "node:fs";

const args = process.argv.slice(2);
const scanAll = args.includes("--all");
const explicitFiles = args.filter((arg) => arg !== "--all");

function runGit(args) {
  return execFileSync("git", args, { encoding: "utf8", maxBuffer: 10 * 1024 * 1024 });
}

function filesToScan() {
  if (explicitFiles.length > 0) return explicitFiles;
  if (scanAll) return runGit(["ls-files"]).split(/\r?\n/).filter(Boolean);
  return runGit(["diff", "--cached", "--name-only"]).split(/\r?\n/).filter(Boolean);
}

function readTrackedOrWorkingTree(file) {
  if (scanAll || explicitFiles.length > 0) return fs.readFileSync(file, "utf8");
  return runGit(["show", `:${file}`]);
}

const forbiddenPath = [
  /^\.env$/,
  /^\.env\./,
  /(^|\/)secrets\//,
  /(^|\/).*service-account.*\.json$/i,
  /(^|\/)credentials\.json$/i,
  /\.(pem|key)$/i
];

const secretPattern =
  /(sk-ant-[A-Za-z0-9_-]{20,}|sk_live_[A-Za-z0-9_-]{20,}|AKIA[0-9A-Z]{16}|-----BEGIN (?:RSA |EC |OPENSSH )?PRIVATE KEY-----)/;

let failed = false;

for (const file of filesToScan()) {
  if (forbiddenPath.some((pattern) => pattern.test(file))) {
    console.error(`[blocked] forbidden secret path: ${file}`);
    failed = true;
    continue;
  }

  try {
    const text = readTrackedOrWorkingTree(file);
    if (secretPattern.test(text)) {
      console.error(`[blocked] secret-like value found in: ${file}`);
      failed = true;
    }
  } catch {
    // Ignore deleted or binary files.
  }
}

if (failed) process.exit(1);
console.log("security check passed");

{
  "scripts": {
    "security:staged": "node scripts/claude-security-check.mjs",
    "security:all": "node scripts/claude-security-check.mjs --all"
  }
}

Le piège est de s’arrêter à “nous avons un script”. Placez npm run security:staged dans la routine de commit, le modèle de PR ou la CI. Demander à Claude Code de s’en souvenir est moins fiable qu’une commande qui échoue automatiquement.

Cas pratique 3: protéger la production et le budget CI

Les incidents de production viennent souvent d’une confusion d’environnement. Le problème n’est pas seulement DROP TABLE; c’est de l’exécuter sur le DATABASE_URL de production en pensant être en développement. Avant de demander à Claude Code de supprimer d’anciennes données, affichez le label de base, le projet cloud, la branche et l’heure du backup en clair.

Pour GitHub Actions, la documentation officielle Claude Code GitHub Actions recommande d’utiliser Secrets pour les clés API et de limiter les permissions. Ce workflow relit uniquement le diff d’une PR sans droit d’écriture sur le dépôt.

name: Claude Code guarded review

"on":
  pull_request:
    types: [opened, synchronize, reopened]

permissions:
  contents: read
  pull-requests: write

jobs:
  claude-security-review:
    runs-on: ubuntu-latest
    timeout-minutes: 15
    steps:
      - uses: actions/checkout@v4
        with:
          persist-credentials: false

      - name: Run repository secret scan
        run: node scripts/claude-security-check.mjs --all

      - uses: anthropics/claude-code-action@v1
        with:
          anthropic_api_key: "${{ secrets.ANTHROPIC_API_KEY }}"
          prompt: >
            Review only the pull request diff for secret handling, auth checks,
            destructive commands, and permission changes. Do not modify files.
          claude_args: |
            --max-turns 3
            --disallowedTools "Bash(git push *)" "Bash(npm run deploy *)" "Bash(rm -rf *)"

permissions: contents: read compte, car une revue seule n’a pas besoin d’écrire dans le dépôt. timeout-minutes et --max-turns sont aussi des contrôles de sécurité: une automatisation sans limites peut devenir un incident de coût ou de disponibilité.

Récupération après incident

Si une API key a fuité, ne commencez pas par réécrire l’historique Git. Révoquez ou faites tourner la clé chez le fournisseur. Un dépôt nettoyé ne sert pas si quelqu’un a déjà copié la valeur.

1. Révoquez ou remplacez la clé exposée.
2. Vérifiez les logs d’usage et la facturation pendant la fenêtre d’exposition.
3. Remplacez GitHub Secrets, variables de déploiement et valeurs CI.
4. Retirez la valeur de l’historique Git et demandez un nettoyage de cache si nécessaire.
5. Ajoutez .gitignore, permissions et scanner dans la même PR de remédiation.

Si des données de production ont été endommagées, suspendez les écritures ou passez en lecture seule avant de corriger. Décidez d’abord du backup, de la cible de restauration et de la perte acceptable. Les commandes de reprise doivent être exécutées une par une, avec confirmation humaine et journaux.

Documentation, liens internes et suite

Gardez les pages officielles Security, Configure permissions, Settings, Hooks et GitHub Actions comme référence. Les hooks sont particulièrement utiles parce qu’ils vérifient avant l’exécution des outils.

Pour approfondir sur le site, lisez /fr/blog/claude-code-security-best-practices/, /fr/blog/claude-code-permissions-guide/ et /fr/blog/claude-code-secrets-management/.

Pour des modèles prêts à adapter, consultez /products/. Pour transformer ces garde-fous en plan d’adoption, politique CI et processus de revue d’équipe, utilisez les options de conseil et formation sur /training/.

Dans le dépôt de test local de Masa, cette configuration a bloqué un .env staged par erreur, une fausse chaîne sk_live_ et un job GitHub Actions trop permissif avant publication. Un scanner par regex ne trouvera jamais tous les formats de secrets; la réponse durable reste donc en couches: rotation côté fournisseur, moindre privilège, contrôles automatiques et revue humaine avant d’approuver les actions Claude Code.