Claude Code Sicherheits-Best-Practices: API-Schlüssel, Berechtigungen & Produktionsschutz

Claude Code verfügt über leistungsstarke Dateimanipulations- und Befehlsausführungsfähigkeiten — aber falsche Konfiguration kann zu irreversiblen Unfällen führen. Eine .env-Datei committen, versehentlich eine Produktionsdatenbank löschen, einen API-Schlüssel in Logs ausgeben — das sind reale Vorfälle, die durch den ungeschützten Einsatz von Claude Code entstanden sind.

Dieser Artikel bietet eine implementierungsnahe Erklärung der Sicherheits-Best-Practices für Claude Code. Der Fokus liegt nicht auf Theorie, sondern auf kopierfertige Konfigurationen und präventivem Code.

Warum Claude Code Sicherheitsmaßnahmen benötigt

Anders als ein normaler Texteditor hat Claude Code folgende Fähigkeiten:

• Beliebige Dateien lesen, schreiben und löschen (Read / Write / Edit / Bash(rm))
• Shell-Befehle ausführen (Bash)
• Netzwerkzugriff (WebFetch / API-Aufrufe)
• An externe Dienste posten (GitHub, Slack, etc.)

All das kann mit Benutzerbestätigung ausgeführt werden. Das Problem: Wer mechanisch jeden Prompt bestätigt, lässt unbeabsichtigte Operationen durch. Sicherheitsmaßnahmen bedeuten, strukturell keinen Raum für Fehler zu lassen.

Maßnahme 1: API-Schlüsselverwaltung — .env + .gitignore als Grundlage

Was man NICHT tun sollte

// ❌ Direkt im Quellcode
const client = new Anthropic({ apiKey: "sk-ant-api03-..." });

// ❌ In CLAUDE.md oder Konfigurationsdateien geschrieben
// ANTHROPIC_API_KEY=sk-ant-api03-...

// ❌ Im Prompt von claude -p angegeben
// Verwende QIITA_TOKEN=abc123 zum Posten

Der richtige Ansatz

# .env (aus git ausgeschlossen, nur lokal auf dem Rechner)
ANTHROPIC_API_KEY=sk-ant-api03-...
QIITA_TOKEN=06b4441b...
SLACK_BOT_TOKEN=xoxb-...
DATABASE_URL=postgresql://...

# Unbedingt zu .gitignore hinzufügen
.env
.env.*
.env.local
!.env.example   # ← Beispieldatei darf committet werden
*.pem
*.key
credentials.json
*-service-account.json

# .env.example (sicher zu committen, Werte leer lassen)
ANTHROPIC_API_KEY=
QIITA_TOKEN=
SLACK_BOT_TOKEN=
DATABASE_URL=

Variablen im Code lesen

// ✅ Aus Umgebungsvariablen lesen
import { config } from "dotenv";
config();

const token = process.env.QIITA_TOKEN;
if (!token) throw new Error("QIITA_TOKEN ist nicht gesetzt. Bitte .env-Datei prüfen.");

Verbote in CLAUDE.md dokumentieren

## Sicherheitsverbote
- API-Schlüssel oder Tokens niemals in Prompts einbeziehen
- Den Inhalt von .env-Dateien niemals lesen und ausgeben
- Werte von Umgebungsvariablen niemals in Logs oder Kommentare schreiben
- Den Inhalt von process.env niemals per console.log ausgeben

Maßnahme 2: Pre-Commit-Scan auf Geheimnisse

Auch mit .env in .gitignore können versehentliche Einträge in anderen Dateien oder Copy-Paste-Fehler auftreten. Fügen Sie einen automatischen Pre-Commit-Scan hinzu.

Pre-Commit-Prüfung mit Hooks

.claude/settings.json:

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash(git commit*)",
        "hooks": [
          {
            "type": "command",
            "command": "node scripts/secret-scan.mjs"
          }
        ]
      }
    ]
  }
}

scripts/secret-scan.mjs:

import { execSync } from "child_process";

// Gestagete Änderungen abrufen
const diff = execSync("git diff --cached").toString();

const PATTERNS = [
  { name: "Anthropic API-Schlüssel", re: /sk-ant-api\d+-[A-Za-z0-9_-]{80,}/ },
  { name: "OpenAI API-Schlüssel", re: /sk-[A-Za-z0-9]{48}/ },
  { name: "AWS Access Key", re: /AKIA[0-9A-Z]{16}/ },
  { name: "Slack Token", re: /xox[baprs]-[0-9A-Za-z-]{10,}/ },
  { name: "Generisches Geheimnis", re: /[Ss]ecret[_-]?[Kk]ey\s*[:=]\s*['"][^'"]{10,}['"]/ },
];

const found = PATTERNS.filter(({ re }) => re.test(diff));

if (found.length > 0) {
  console.error("🚨 Geheimnis erkannt! Commit wird abgebrochen:");
  found.forEach(({ name }) => console.error(`  - ${name}`));
  console.error("\nLösung: `git reset HEAD <file>` ausführen, um die Datei zu unstagen");
  process.exit(1);  // Exit-Code 1 → Hook blockiert den Befehl
}

console.log("✓ Geheimnis-Scan: Keine Probleme gefunden");
process.exit(0);

Das bedeutet: Sobald Claude Code versucht, git commit auszuführen, läuft automatisch ein Scan und erkannte Lecks werden blockiert.

Maßnahme 3: Konfiguration der Berechtigungsmodi

Die Erlaubnis-/Ablehnungseinstellungen von Claude Code können auf Dateiebene detailliert gesteuert werden.

Berechtigungseinstellungen in .claude/settings.json

{
  "permissions": {
    "allow": [
      "Read(**)",
      "Glob(**)",
      "Grep(**)"
    ],
    "deny": [
      "Bash(rm -rf*)",
      "Bash(git push --force*)",
      "Bash(git reset --hard*)",
      "Bash(DROP TABLE*)",
      "Bash(truncate*)",
      "Bash(curl * | bash)",
      "Bash(wget * | sh)"
    ],
    "ask": [
      "Write(**)",
      "Edit(**)",
      "Bash(git commit*)",
      "Bash(git push*)",
      "Bash(npm publish*)",
      "Bash(wrangler pages deploy*)"
    ]
  }
}

Einstellung	Bedeutung
allow	Ohne Bestätigung ausführen
deny	Niemals ausführen (vollständig blockiert)
ask	Erfordert jedes Mal eine Genehmigung

Grundprinzip: Destruktive Befehle in deny, Schreiboperationen in ask, Leseoperationen in allow.

Produktionsspezifische Konfigurationsdatei

Für Produktionsumgebungen ist die Beschränkung auf Lesezugriff am sichersten.

// .claude/settings.production.json
{
  "permissions": {
    "allow": ["Read(**)", "Glob(**)", "Grep(**)", "Bash(git log*)", "Bash(git diff*)"],
    "deny": ["Write(**)", "Edit(**)", "Bash(git push*)", "Bash(rm*)", "Bash(*deploy*)"],
    "ask": []
  }
}

# Bei Produktionsarbeiten explizit angeben
CLAUDE_SETTINGS=.claude/settings.production.json claude

Maßnahme 4: Schutz der Produktionsumgebung

Verbindungsziele explizit trennen

## CLAUDE.md — Regeln für die Produktionsumgebung

## Umgebungserkennung
- Enthält DATABASE_URL 'prod' oder 'production', handelt es sich um eine **Produktionsumgebung**
- In der Produktion niemals ausführen:
  - DROP / TRUNCATE / DELETE (ohne WHERE-Klausel)
  - Migrationen (vorherige Bestätigung erforderlich)
  - Massenhafte Dateilöschungen

## Bestätigungsablauf
Alle Produktionsänderungen müssen:
1. Zuerst in einer Staging-Umgebung getestet werden
2. Benutzerbestätigung erhalten
3. Ergebnisse nach der Ausführung berichten

Verbindungen mit Umgebungsvariablen steuern

// scripts/db-query.mjs
const env = process.env.NODE_ENV ?? "development";
const dbUrl = process.env.DATABASE_URL;

if (env === "production" && process.argv.includes("--write")) {
  console.error("❌ Schreiben in Produktion erfordert das Flag --force-production");
  process.exit(1);
}

Maßnahme 5: Sicherheitsmechanismen für Dateioperationen

Backups vor dem Löschen automatisieren

// Hooks in .claude/settings.json
{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash(rm *)",
        "hooks": [
          {
            "type": "command",
            "command": "echo '⚠️  Ein Löschbefehl wird gleich ausgeführt. Drücken Sie Ctrl+C zum Abbrechen.' && sleep 3"
          }
        ]
      }
    ]
  }
}

Kritische Dateien vor versehentlichen Bearbeitungen schützen

## CLAUDE.md — Dateien, die nicht geändert werden dürfen

Folgende Dateien dürfen **niemals bearbeitet** werden:
- .env (enthält Umgebungsvariablen und geheime Schlüssel)
- wrangler.toml (Cloudflare-Produktionskonfiguration)
- scripts/deploy.sh (Deployment-Skript)
- .github/workflows/*.yml (CI/CD-Konfiguration)

Falls Änderungen notwendig sind, zuerst den Benutzer fragen.

5 häufige Fallstricke

1. .gitignore nachträglich hinzufügen ist zu spät Eine bereits committete .env-Datei bleibt in der Git-Historie, auch wenn man sie später zur .gitignore hinzufügt.

# Vollständige Entfernung aus der Historie (Achtung: Force-Push erforderlich)
git filter-branch --force --index-filter \
  "git rm --cached --ignore-unmatch .env" \
  --prune-empty --tag-name-filter cat -- --all

# Alternativ BFG Repo Cleaner verwenden

Wenn die Datei bereits auf GitHub gepusht wurde, immer zuerst die API-Schlüssel rotieren, bevor die Historie bereinigt wird.

2. Service-Account-JSON-Dateien im Repository ablegen Service-Account-Schlüssel für Google Cloud oder AWS werden oft als .json-Dateien verteilt, aber sie im Repository zu speichern ist gefährlich. Konvertieren Sie sie in Umgebungsvariablen oder migrieren Sie zu einem Secret Manager (AWS Secrets Manager / GCP Secret Manager).

3. Interaktive Befehle mit dem Bash-Tool ausführen Bei der headlosen Ausführung mit claude -p führen Befehle, die interaktive Eingabe erfordern (wie sudo oder vim), zum Hängen des Prozesses. Verwenden Sie nur nicht-interaktive Befehle.

4. Anmeldeinformationen in Fehlermeldungen einbeziehen

// ❌ Gefährlich: API-Schlüssel erscheint in Logs
throw new Error(`Authentifizierung fehlgeschlagen: token=${process.env.TOKEN}`);

// ✅ Sicher: Wert nicht preisgeben
throw new Error(`Authentifizierung fehlgeschlagen: bitte TOKEN-Umgebungsvariable prüfen`);

5. Dieselben Berechtigungseinstellungen für alle Projekte wiederverwenden Werden dieselben settings.json für persönliche und geschäftliche Projekte verwendet, können die lockeren Einstellungen des persönlichen Projekts die strengeren Anforderungen des Geschäftsprojekts überschreiben. Verwalten Sie .claude/settings.json für jedes Projekt separat.

Sicherheits-Checkliste

Eine Checkliste für die Einrichtung eines Claude Code-Projekts:

### Grundkonfiguration
- [ ] .env erstellt und zu .gitignore hinzugefügt
- [ ] .env.example erstellt und mit dem Team geteilt
- [ ] Per git log überprüft, ob in bestehenden Commits keine Geheimnisse enthalten sind

### Berechtigungseinstellungen
- [ ] Deny-Liste in .claude/settings.json konfiguriert
- [ ] Destruktive Befehle (rm -rf, DROP TABLE usw.) zu deny hinzugefügt
- [ ] Produktions-Deployment-Befehle auf ask gesetzt

### Automatisierung
- [ ] Pre-Commit-Geheimnis-Scan-Hook konfiguriert
- [ ] Sicherheitsverbote in CLAUDE.md dokumentiert

### Betrieb
- [ ] API-Schlüssel-Rotationsplan festgelegt (Empfehlung: alle 90 Tage)
- [ ] Dedizierte settings.production.json für Produktion verwendet
- [ ] Incident-Response-Prozess dokumentiert

Zusammenfassung

Sicherheit bei Claude Code bedeutet nicht „Einschränkungen auferlegen” — sondern eine Struktur zu schaffen, in der Unfälle strukturell nicht passieren können.

Bedrohung	Gegenmaßnahme
API-Schlüssel-Leck	.env + .gitignore + Geheimnis-Scan-Hook
Unbeabsichtigtes Löschen	Deny-Liste + Pre-Lösch-Hook
Produktionsfehler	Produktionsspezifische Einstellungen + CLAUDE.md-Verbote
Commit-Kontamination	PreToolUse-Hook für Pre-Commit-Scan

Einmal konfiguriert sind diese Einstellungen praktisch wartungsfrei. 30 Minuten Aufwand heute können einen großen Vorfall in der Zukunft verhindern.

Verwandte Artikel

• Claude Code Berechtigungsleitfaden
• Claude Code Sicherheitsfehler-Fallstudien
• Claude Code + SaaS-Integration Komplettleitfaden
• CLAUDE.md Best Practices

Referenzen

• Claude Code Berechtigungen Offizielle Dokumentation
• Geheimnisse aus der Historie entfernen mit git-filter-branch
• BFG Repo Cleaner