Das .env-Setup, das verhindert, dass Claude Code Ihre Geheimnisse preisgibt (inklusive vollständiger Konfiguration)

Claude Code liest deine .env-Dateien, sobald es dein Projekt öffnet.

Deine API-Schlüssel, Datenbank-Passwörter, Stripe-Tokens – alles in der .env-Datei wird in den Speicher geladen und kann in Konversationsprotokollen landen, die an die Server von Anthropic gesendet werden.

Das Einzige, was den Zugriff tatsächlich blockiert, ist eine Zeile in der settings.json, die die meisten Leute nicht haben und von der sie nichts wissen.

Hier ist die vollständige Sicherheitskonfiguration 👇

Bevor wir loslegen: Ich teile tägliche Notizen zu KI & Vibe Coding in meinem Telegram-Kanal: **https://t.me/zodchixquant**🧠

Warum CLAUDE.md-Regeln dich nicht schützen

Die meisten Leute fügen „.env-Dateien niemals lesen“ in ihre CLAUDE.md ein und gehen davon aus, dass sie sicher sind (sind sie nicht).

CLAUDE.md ist ein Vorschlag. Claude folgt ihm meistens, aber unter Druck (komplexe Aufgaben, langer Kontext, mehrdeutige Anweisungen) kann und wird es die Hinweisregeln ignorieren.

Ein GitHub-Issue vom April 2026 hat bestätigt: Claude liest .env-Inhalte und gibt sie in der Konversation wieder, selbst wenn CLAUDE.md es explizit verbietet.

Der einzig zuverlässige Schutz ist eine Deny-Regel in der settings.json. Deny-Regeln werden auf Systemebene durchgesetzt, bevor Claude die Datei überhaupt sieht.

Der Unterschied zwischen „Bitte lies das nicht“ und „Du kannst das physisch nicht lesen“.

Die 3 Wege, wie deine Geheimnisse durchsickern

Es geht nicht nur darum, dass Claude .env direkt liest. Es gibt drei Wege:

1. Direktes Dateilesen. Claude scannt dein Projekt, öffnet .env, und die Inhalte werden Teil des Konversationskontexts. Das ist der offensichtliche Weg und der am einfachsten mit Deny-Regeln zu blockierende.

2. Erfassung von Laufzeitausgaben. Claude führt deine Tests aus oder startet deine App. Eine fehlgeschlagene HTTP-Anfrage protokolliert den vollständigen Authorization: Bearer sk-live-abc123...-Header. Ein Datenbank-Timeout gibt den Verbindungsstring mit dem Passwort aus. Claude erfasst alle Befehlsausgaben. Deine Geheimnisse sind jetzt in der Konversation, obwohl Claude .env nie geöffnet hat.

3. Grep- und Suchwerkzeuge. Claude verwendet grep, um in deiner Codebasis nach einem Funktionsnamen zu suchen. Die Suche trifft auf eine Konfigurationsdatei mit Anmeldeinformationen. Die grep-Ausgabe enthält die übereinstimmenden Zeilen mit deinen sichtbaren Geheimnissen.

Die meisten Leute schützen sich nur gegen Weg 1. Weg 2 und 3 sind die, bei denen der eigentliche Schaden entsteht.

Die Deny-Regeln, die tatsächlich funktionieren

Füge diese in ~/.claude/settings.json ein, für globalen Schutz in jedem Projekt:

json

1{
2  "permissions": {
3    "deny": [
4      "Read(**/.env*)",
5      "Read(**/.dev.vars*)",
6      "Read(**/*.pem)",
7      "Read(**/*.key)",
8      "Read(**/secrets/**)",
9      "Read(**/credentials/**)",
10      "Read(**/.aws/**)",
11      "Read(**/.ssh/**)",
12      "Read(**/config/database.yml)",
13      "Read(**/config/credentials.json)",
14      "Read(**/.npmrc)",
15      "Read(**/.pypirc)",
16      "Write(**/.env*)",
17      "Write(**/secrets/**)",
18      "Write(**/.ssh/**)"
19    ]
20  }
21}

Dies blockiert Claude daran, .env-Dateien, PEM-Schlüssel, SSH-Schlüssel, AWS-Konfigurationen, Credential-Dateien und npm-/PyPI-Tokens zu lesen oder zu schreiben. Der **-Wildcard bedeutet, dass es für jedes Unterverzeichnis in deinem Projekt gilt.

Laufzeitlecks blockieren

Deny-Regeln stoppen direkte Dateizugriffe, aber keine Laufzeitausgaben. Verwende dafür testspezifische .env-Dateien mit Dummy-Werten:

1# .env.test — sicher zu lesen, sicher zu leaken
2STRIPE_SECRET_KEY=sk_test_not_a_real_key
3DATABASE_URL=postgres://test:test@localhost:5432/testdb
4OPENAI_API_KEY=sk-test-dummy-key-for-mocking
5AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
6AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY

Richte dein Test-Framework auf .env.test anstelle von .env aus. Wenn Claude jetzt deine Tests ausführt und die Ausgabe erfasst, sind nur Dummy-Schlüssel sichtbar.

Der Pre-Commit-Hook, der alles abfängt

Selbst mit Deny-Regeln passieren Fehler. Füge einen Git-Pre-Commit-Hook hinzu, der vor jedem Commit nach Geheimnissen sucht:

bash

1#!/bin/bash
2# .git/hooks/pre-commit — blockiert Commits, die Geheimnisse enthalten
3
4PATTERNS=(
5  'sk-ant-'           # Anthropic-API-Schlüssel
6  'sk-live-'          # Stripe-Live-Schlüssel
7  'sk_live_'          # Stripe-Live-Schlüssel (alternatives Format)
8  'ghp_'              # GitHub-Personal-Tokens
9  'gho_'              # GitHub-OAuth-Tokens
10  'AKIA'              # AWS-Zugriffsschlüssel
11  'xox[bpors]-'       # Slack-Tokens
12  'SG\.'              # SendGrid-Schlüssel
13  'eyJ'               # JWTs
14  'BEGIN.*PRIVATE KEY' # Privates Schlüsselmaterial
15)
16
17BLOCKED_FILES=('.env' 'credentials.json' 'id_rsa' '*.pem' '*.key')
18
19for pattern in "${PATTERNS[@]}"; do
20  if git diff --cached --diff-filter=ACM | grep -qE "$pattern"; then
21    echo "BLOCKIERT: Mögliches Geheimnis gefunden, das auf '$pattern' passt"
22    echo "Entferne das Geheimnis und versuche es erneut."
23    exit 1
24  fi
25done
26
27for file in "${BLOCKED_FILES[@]}"; do
28  if git diff --cached --name-only | grep -q "$file"; then
29    echo "BLOCKIERT: Versuch, sensible Datei zu committen: $file"
30    exit 1
31  fi
32done
33
34echo "Pre-Commit-Sicherheitsprüfung bestanden."
35exit 0

Mach es ausführbar: chmod +x .git/hooks/pre-commit

Dies fängt Anthropic-API-Schlüssel, Stripe-Schlüssel, GitHub-Tokens, AWS-Schlüssel, Slack-Tokens, SendGrid-Schlüssel, JWTs und privates Schlüsselmaterial ab. Wenn eines davon in einer bereitgestellten Datei auftaucht, wird der Commit blockiert.

Container-Isolation (die Atomoption)

Für maximale Sicherheit führe Claude Code in einem Container aus, in dem .env-Dateien buchstäblich nicht existieren:

bash

1# Mounte /dev/null über .env, damit Claude es nicht sehen kann
2docker run -v /dev/null:/app/.env:ro your-dev-container

Aus Claudes Perspektive ist .env eine leere Datei. Deine Geheimnisse gelangen nie in das Dateisystem des Containers. Das ist für die meisten Projekte übertrieben, aber für Kundenarbeit mit Produktionsanmeldedaten unerlässlich.

Die vollständige Sicherheitskonfiguration (copy-paste-bereit)

Vollständige ~/.claude/settings.json mit allen Sicherheitsschutzmaßnahmen:

json

1{
2  "permissions": {
3    "allow": [
4      "Read",
5      "Glob",
6      "Grep",
7      "LS",
8      "Edit",
9      "MultiEdit",
10      "Write(src/**)",
11      "Write(tests/**)",
12      "Bash(npm run *)",
13      "Bash(npm test *)",
14      "Bash(npx tsc *)",
15      "Bash(git status)",
16      "Bash(git diff *)",
17      "Bash(git log *)",
18      "Bash(git add *)",
19      "Bash(git commit *)"
20    ],
21    "deny": [
22      "Read(**/.env*)",
23      "Read(**/.dev.vars*)",
24      "Read(**/*.pem)",
25      "Read(**/*.key)",
26      "Read(**/secrets/**)",
27      "Read(**/credentials/**)",
28      "Read(**/.aws/**)",
29      "Read(**/.ssh/**)",
30      "Read(**/config/database.yml)",
31      "Read(**/config/credentials.json)",
32      "Read(**/.npmrc)",
33      "Read(**/.pypirc)",
34      "Write(**/.env*)",
35      "Write(**/secrets/**)",
36      "Write(**/.ssh/**)",
37      "Write(.github/workflows/*)",
38      "Bash(rm -rf *)",
39      "Bash(sudo *)",
40      "Bash(git push *)",
41      "Bash(npm publish *)",
42      "Bash(curl * | sh)",
43      "Bash(wget *)",
44      "Bash(chmod *)"
45    ],
46    "defaultMode": "acceptEdits"
47  }
48}

Das ist die settings.json aus meinem vorherigen Artikel plus alle Sicherheitsregeln aus diesem. Allow-Regeln für den täglichen Workflow, Deny-Regeln für Geheimnisse und gefährliche Operationen. Eine Datei, vollständiger Schutz.

Die Checkliste

Vor deiner nächsten Claude Code-Sitzung:

1. Hast du Deny-Regeln für .env-Dateien in der settings.json?

1. Verwenden deine Tests .env.test mit Dummy-Werten?

1. Gibt es einen Pre-Commit-Hook, der nach Geheimnismustern sucht?

1. Werden Produktionsanmeldedaten in einem Tresor und nicht in Klartextdateien gespeichert?

1. Ist .env in deiner .gitignore?

1. Befinden sich .env-Dateien aus zusätzlicher Sicherheit außerhalb deines Projektverzeichnisses?

Wenn du alle 6 abgehakt hast, sind deine Geheimnisse so gut geschützt, wie es nur geht. Wenn du 0 abgehakt hast, bist du nur eine mehrdeutige Claude-Eingabe davon entfernt, dass deine API-Schlüssel in einem Konversationsprotokoll auf den Servern von Anthropic auftauchen.

Ich teile tägliche Notizen zu KI, Finanzen und Vibe Coding in meinem Telegram-Kanal: **https://t.me/zodchixquant**

Danke fürs Lesen 🙏🏼