AI Coding Tools & Datenschutz: Sensible Daten in Contao & Shopware schützen | Leitfaden 2026

AI-Coding-Tools wie Claude Code, Cursor oder GitHub Copilot haben meine tägliche Arbeit grundlegend verändert. Code-Reviews, Refactoring, Debugging – vieles geht heute schneller und präziser als noch vor zwei Jahren. Doch bei aller Begeisterung gibt es eine Frage, die ich mir bei jedem neuen Projekt stelle: Was passiert eigentlich mit meinen sensiblen Daten?

Denn die Realität ist: Diese Tools lesen Ihre Projektdateien. Alle. Auch die .env mit den Datenbankzugangsdaten. Auch den SQL-Dump mit Kundenadressen. Auch die auth.json mit dem privaten GitLab-Token. Und diese Daten werden zur Verarbeitung an externe Server übertragen.

In diesem Artikel zeige ich, wie Sie AI-Coding-Tools verantwortungsvoll einsetzen – mit konkreten Konfigurationen für Contao- und Shopware-Projekte, die Sie direkt übernehmen können.

Das Problem: Warum .gitignore nicht reicht

Ein weit verbreiteter Irrtum: „Die .env steht doch in der .gitignore, also ist sie sicher." Falsch. .gitignore verhindert lediglich, dass eine Datei in Git committet wird. Lokal ist sie weiterhin vorhanden – und AI-Coding-Tools arbeiten mit Ihrem lokalen Dateisystem, nicht mit dem Git-Repository.

Wenn Claude Code, Cursor oder Copilot Ihren Projektkontext analysieren, können sie auf jede Datei zugreifen, die auf Ihrer Festplatte liegt. Das bedeutet:

• .env und .env.local mit Datenbankpasswörtern und API-Secrets
• Datenbank-Dumps (*.sql, *.sql.gz) mit personenbezogenen Kundendaten
• SSH-Keys und JWT-Zertifikate für Server- und API-Zugang
• auth.json mit Composer-Repository-Credentials

All diese Daten können im Rahmen der Kontextanalyse an die Server des jeweiligen AI-Anbieters übertragen werden. Und spätestens hier wird es DSGVO-relevant.

Übersicht: Schutzmechanismen im Vergleich

Bevor wir in die Details gehen, ein Überblick über die verschiedenen Schutzschichten:

Die ehrliche Wahrheit: Kein einzelner Mechanismus reicht aus. Effektiver Schutz entsteht durch das Zusammenspiel mehrerer Schichten:

Schicht 1: .gitignore              → Verhindert Commit (nicht AI-Zugriff)
Schicht 2: permissions.deny        → Verhindert AI-Lesezugriff (Claude Code)
Schicht 3: Tool-Privacy-Mode       → Verhindert Datenübertragung (Cursor/Windsurf)
Schicht 4: Keine Secrets im Code   → Eliminiert das Risiko an der Quelle

Claude Code absichern: permissions.deny

Für Claude Code ist permissions.deny in der .claude/settings.json der empfohlene Weg. Diese Einstellung greift zuverlässiger als die ältere .claudeignore-Datei, bei der dokumentierte Sicherheitsprobleme bekannt sind.

Projekt-Level-Konfiguration

Die folgende Datei gehört ins Projekt-Repository und schützt das gesamte Team:

// .claude/settings.json
{
  "permissions": {
    "deny": [
      "Read(.env)",
      "Read(.env.*)",
      "Read(.env.local)",
      "Read(auth.json)",
      "Read(config/parameters.yml)",
      "Read(hosts.yaml)",
      "Read(**/*.sql)",
      "Read(**/*.sql.gz)",
      "Read(**/secrets/**)",
      "Read(**/credentials.*)",
      "Read(**/*.pem)",
      "Read(**/*.key)",
      "Read(**/.ssh/**)"
    ]
  }
}

Globale User-Level-Konfiguration

Zusätzlich empfehle ich eine globale Absicherung unter ~/.claude/settings.json, die für alle Projekte greift:

// ~/.claude/settings.json
{
  "permissions": {
    "deny": [
      "Read(~/.ssh/**)",
      "Read(~/.gnupg/**)",
      "Read(~/.aws/**)",
      "Read(~/.config/gcloud/**)",
      "Read(**/*.env)",
      "Read(**/*.env.*)",
      "Read(**/auth.json)"
    ]
  }
}

Hooks: Warnung bei sensiblen Dateien

Claude Code unterstützt Hooks, die bei Dateioperationen ausgelöst werden. Ein Warn-Hook als zusätzliche Sicherheitsschicht:

<!-- .claude/hooks/warn-sensitive-files.local.md -->
---
name: warn-sensitive-files
enabled: true
event: file
conditions:
  - field: file_path
    operator: regex_match
    pattern: \.(env|env\.local|env\..*|pem|key)$
action: warn
---

**Achtung:** Diese Datei kann sensible Daten enthalten (Zugangsdaten, API-Keys, Zertifikate).
Stelle sicher, dass keine Secrets in den AI-Kontext gelangen.

Sensible Dateien in Contao-Projekten

In meiner täglichen Arbeit mit Contao begegnen mir immer wieder die gleichen kritischen Dateien. Hier das vollständige Inventar:

Empfohlene .claude/settings.json für Contao

{
  "permissions": {
    "deny": [
      "Read(.env)",
      "Read(.env.*)",
      "Read(.env.local)",
      "Read(auth.json)",
      "Read(config/parameters.yml)",
      "Read(hosts.yaml)",
      "Read(deploy-assets-sync.php)",
      "Read(**/*.sql)",
      "Read(**/*.sql.gz)",
      "Read(var/backups/**)",
      "Read(files/**)"
    ]
  }
}

Tipp: Pflegen Sie eine .env.sample mit Platzhaltern statt echten Werten. So kann Claude Code die Struktur Ihrer Umgebungsvariablen verstehen, ohne Zugriff auf die eigentlichen Secrets zu benötigen.

Sensible Dateien in Shopware-Projekten

Shopware-Projekte bringen zusätzliche Angriffsflächen mit – insbesondere durch JWT-Keys und die direkte Integration von Payment-Providern:

Empfohlene .claude/settings.json für Shopware

{
  "permissions": {
    "deny": [
      "Read(.env)",
      "Read(.env.*)",
      "Read(.env.local)",
      "Read(auth.json)",
      "Read(config/jwt/private.pem)",
      "Read(config/jwt/*.pem)",
      "Read(**/*.sql)",
      "Read(**/*.sql.gz)",
      "Read(var/backups/**)",
      "Read(files/**)",
      "Read(public/media/**)"
    ]
  }
}

Shopware Secrets Vault nutzen

Shopware 6 bietet einen integrierten Secrets Vault, der Secrets aus der Dateisystem-Ebene entfernt. Das reduziert die Angriffsfläche erheblich:

# Shopware PaaS
shopware secret:set DATABASE_URL --env prod
shopware secret:set APP_SECRET --env prod

# Lokal: Symfony Vault
bin/console secrets:set DATABASE_URL --env=prod

Ein Vault-Secret überschreibt automatisch gleichnamige .env-Variablen. Damit liegen sensible Werte nicht mehr als Klartext in Dateien – und können von AI-Tools gar nicht erst gelesen werden.

Tool-Vergleich: Privacy-Einstellungen

Neben Claude Code gibt es weitere populäre AI-Coding-Tools. Hier ein Überblick über deren Privacy-Optionen:

Cursor

Settings → Privacy Mode → Enable

• Privacy Mode aktiv: Zero Data Retention, kein Speichern, kein Training
• SOC 2 Type II zertifiziert
• Jährliche Penetrationstests

GitHub Copilot

Organization Settings → Copilot → Content Exclusions

# Beispiel Content Exclusion (Organization-Level)
- "**/.env"
- "**/.env.*"
- "**/config/jwt/**"
- "**/*.sql"
- "**/auth.json"

• Enterprise: Code Referencing deaktivierbar
• SOC 1/2/3, ISO 27001 zertifiziert

Windsurf (Codeium)

Settings → Privacy → Zero-Data Mode → Enable

• Zero-Data-Modus: Kein Code wird an externe Server gesendet
• Self-Hosted-Deployment möglich (Air-Gapped)
• Wichtig: Muss manuell aktiviert werden

Vergleichsübersicht

DSGVO: Was Entwickler wissen müssen

Das Thema ist nicht nur technisch relevant – es hat auch eine rechtliche Dimension. Sobald personenbezogene Daten (Kundennamen, E-Mail-Adressen, Bestelldaten aus DB-Dumps) an einen AI-Anbieter übertragen werden, greifen die Regeln der DSGVO.

Auftragsverarbeitung (Art. 28 DSGVO)

Der Einsatz von AI-Coding-Tools, die Code an externe Server senden, kann eine Auftragsverarbeitung darstellen. Prüfen Sie, ob ein Data Processing Agreement (DPA) vorliegt:

• Anthropic (Claude): DPA verfügbar
• Microsoft (Copilot): DPA über Microsoft Enterprise Agreement
• Cursor: DPA auf Anfrage

Technische Maßnahmen (Art. 32 DSGVO)

1. Zugangskontrolle: permissions.deny für sensible Dateien konfigurieren
2. Datenminimierung: Keine Datenbank-Dumps im Projektverzeichnis belassen
3. Pseudonymisierung: Für die Entwicklung anonymisierte Testdaten verwenden
4. Transparenz: Team über AI-Tool-Nutzung und Datenfluss informieren

Meine Empfehlung

Für Projekte mit personenbezogenen Daten – und das sind praktisch alle E-Commerce- und CMS-Projekte:

• AI-Tools nur mit Privacy Mode oder permissions.deny einsetzen
• Datenbank-Dumps nach dem Import sofort löschen
• Anonymisierte Entwicklungsdatenbanken verwenden, keine Produktionsdaten lokal

Checkliste: Projekt-Setup in 4 Schritten

Diese Schritte können Sie direkt in Ihr nächstes Projekt übernehmen:

Schritt 1: .claude/settings.json erstellen

mkdir -p .claude

{
  "permissions": {
    "deny": [
      "Read(.env)",
      "Read(.env.*)",
      "Read(.env.local)",
      "Read(auth.json)",
      "Read(config/parameters.yml)",
      "Read(hosts.yaml)",
      "Read(**/*.sql)",
      "Read(**/*.sql.gz)",
      "Read(**/*.pem)",
      "Read(**/*.key)",
      "Read(var/backups/**)"
    ]
  }
}

Schritt 2: .gitignore ergänzen

# AI-Tool lokale Konfiguration
.claude/*.local.md
.claude/*.local.json

Schritt 3: .env.sample pflegen

APP_ENV=dev
APP_SECRET=CHANGE_ME
DATABASE_URL="mysql://user:password@127.0.0.1:3306/dbname"
MAILER_DSN=null://
ADMIN_EMAIL=admin@example.com

Schritt 4: Team dokumentieren

Ergänzen Sie Ihr CLAUDE.md oder README.md:

## AI-Tools & Datenschutz

Dieses Projekt verwendet `.claude/settings.json` mit `permissions.deny`,
um den Zugriff auf sensible Dateien durch AI-Coding-Tools zu verhindern.

**Nicht von AI-Tools lesen lassen:**
- `.env`, `.env.local` (Zugangsdaten)
- `auth.json` (Composer-Credentials)
- `hosts.yaml` (Server-Zugangsdaten)
- `*.sql` / `*.sql.gz` (Datenbank-Dumps mit personenbezogenen Daten)

Fazit

AI-Coding-Tools sind ein enormer Produktivitätsgewinn – aber sie erfordern ein Bewusstsein für Datenschutz, das über die übliche .gitignore hinausgeht. Die gute Nachricht: Mit wenigen Konfigurationsschritten lässt sich das Risiko erheblich reduzieren.

Mein Ansatz ist pragmatisch: Ich nutze Claude Code täglich und intensiv. Aber ich stelle sicher, dass sensible Dateien über permissions.deny geschützt sind, keine Produktionsdaten lokal herumliegen und mein Team weiß, welche Regeln gelten.

Für Contao- und Shopware-Projekte ist das besonders relevant, weil wir regelmäßig mit Kundendaten, Payment-Credentials und Server-Zugangsdaten arbeiten. Die vier Schritte aus der Checkliste oben dauern keine zehn Minuten – und ersparen Ihnen im Ernstfall eine Menge Ärger.

Mein Rat? Richten Sie permissions.deny ein. Heute noch. Es ist die beste Investition von zehn Minuten, die Sie in Ihrem nächsten Projekt machen können.