# CSP-Header einrichten: So schützt du deine Website richtig

Quelle: https://madpublishing.ch/blog/csp-header-einrichten
Stand: 2026-11-16

> Was eine Content Security Policy ist, ob sie als Header oder Meta-Tag gehört und wie du sie testest und scharf schaltest, ohne die Website zu stören.

Einen CSP-Header richtest du in wenigen Schritten ein. Zuerst listest du auf, welche fremden Dienste deine Website wirklich lädt. Daraus entsteht eine kurze Regel, die du zuerst testest und erst dann scharf schaltest. Von Hand tippen muss sie niemand: Wenn du deine Website mit Claude oder ChatGPT baust, schreibt der KI-Assistent die Content Security Policy passend zu deinem Code. Entscheidend ist der Weg ins Netz. Mit einer Vorschau vor dem Veröffentlichen und Versionen, die du zurückholen kannst, wird aus einem Fehler keine kaputte Website, sondern eine Korrektur von wenigen Minuten.

**Das Wichtigste in Kürze**

- Eine **Content Security Policy (CSP)** ist eine Anweisung deiner Website an den Browser: Nur Inhalte aus erlaubten Quellen dürfen geladen werden. Das bremst eingeschleuste Schadskripte.
- Am besten wird sie als **HTTP-Header** gesendet. Ein Meta-Tag im HTML funktioniert auch, kann aber nicht alles.
- Starte mit einer engen Grundregel wie `default-src 'self'` und gib nur frei, was du wirklich brauchst.
- Teste zuerst, ohne dass Besucher etwas merken, und schalte erst dann scharf.
- Vermeide `'unsafe-inline'`, `'unsafe-eval'` und breite Platzhalter wie `*`. Sie heben den Schutz weitgehend auf.

## Was eine Content Security Policy macht

CSP steht für Content Security Policy, auf Deutsch etwa «Richtlinie für die Sicherheit von Inhalten». Laut der [Erklärung von MDN zur Content Security Policy](https://developer.mozilla.org/de/docs/Web/HTTP/Guides/CSP) schickt die Website dem Browser Anweisungen, die festlegen, was der Code auf der Seite darf. Der wichtigste Zweck: steuern, von wo Skripte, Bilder, Schriften und andere Dateien geladen werden.

Warum das zählt, zeigt der häufigste Angriff, gegen den CSP hilft: **Cross-Site-Scripting (XSS)**. Dabei schleust jemand fremden JavaScript-Code in deine Seite ein, etwa über ein Eingabefeld. Der Browser führt diesen Code aus, als käme er von dir. Eine CSP sagt dem Browser: Skripte nur von meiner eigenen Adresse. Der fremde Code bleibt dann liegen.

Daneben schützt eine CSP vor **Clickjacking**. So nennt man den Trick, deine Seite unsichtbar in eine fremde Seite einzubetten, damit Besucher unbemerkt auf etwas klicken. Die [Web Security Academy von PortSwigger](https://portswigger.net/web-security/cross-site-scripting/content-security-policy) beschreibt CSP deshalb als Browser-Mechanismus, der sowohl die ladbaren Quellen als auch das Einbetten in fremde Seiten einschränkt.

Google bezeichnet eine strenge CSP im [Artikel zu XSS und strenger CSP auf web.dev](https://web.dev/articles/strict-csp?hl=de) als zusätzliche Sicherheitsebene, die kein Ersatz dafür ist, Fehler im Code zu vermeiden und zu beheben. Sauber geschriebener Code, der Eingaben prüft, bleibt die Grundlage. Die CSP ist das zweite Schloss an der Tür.

### Wie ein HTTP-Header aufgebaut ist

Jedes Mal, wenn ein Browser eine Seite anfragt, antwortet der Server mit zwei Teilen: den **Headern**, also kurzen Zusatzinformationen, und dem eigentlichen Inhalt. Ein Header ist eine einzelne Zeile aus Name und Wert, getrennt durch einen Doppelpunkt. Eine CSP sieht so aus:

```
Content-Security-Policy: default-src 'self'; img-src 'self' data:
```

Links steht der Name, rechts die Regel. Die Regel besteht aus **Direktiven**, also einzelnen Anweisungen, die durch Semikolons getrennt sind. Jede Direktive nennt eine Art von Inhalt und die erlaubten Quellen.

## Header oder Meta-Tag: Wo die Regel hingehört

Es gibt zwei Wege, die CSP an den Browser zu bringen.

**Als HTTP-Header.** Das ist der vollständige Weg. MDN rät, den Header in allen Antworten auf alle Anfragen zu senden, nicht nur beim Hauptdokument. Wo du ihn einträgst, hängt von deinem Hosting ab. Auf einem klassischen Webspace mit Apache-Server steht er meist in der Datei `.htaccess`, einer kleinen Konfigurationsdatei im Hauptordner der Website. Bei dynamischen Seiten kann auch der Code selbst den Header senden, zum Beispiel PHP mit der Funktion `header()`.

**Als Meta-Tag im HTML.** Hier steht die Regel im Kopfbereich jeder Seite, als erstes Meta-Tag:

```html
<meta http-equiv="Content-Security-Policy" content="default-src 'self'; img-src 'self' data:">
```

Das funktioniert auf jeder statischen Website. Der Haken: Laut dem [OWASP Web Security Testing Guide](https://wstg.owasp.org/latest/4-Web_Application_Security_Testing/02-Configuration_and_Deployment_Management/12-Content_Security_Policy/) unterstützt der Meta-Tag die Direktiven `frame-ancestors`, `report-uri`, `report-to` und `sandbox` nicht. Gerade der Schutz vor Clickjacking fehlt also. Und den Testmodus, um den es weiter unten geht, gibt es laut MDN ebenfalls nur als Header.

Für die Praxis heisst das:

| Deine Website | Wo die CSP hinkommt |
|---|---|
| Statische Website (nur HTML, CSS, Bilder) | Meta-Tag in jeder Seite, oder Header, wenn der Server es erlaubt |
| Website mit PHP | Header per `header()` am Anfang jeder PHP-Seite oder in einer gemeinsamen Startdatei |
| Webspace mit Apache | Zeile `Header set Content-Security-Policy "…"` in der `.htaccess` |

Den Code für jede dieser Varianten schreibt dir dein KI-Assistent, wenn du ihm sagst, wo deine Website läuft. Wer mit Claude baut und noch unsicher ist, wie weit man ohne Programmierkenntnisse kommt, findet einen ehrlichen Erfahrungsbericht über die [ersten Tage mit Claude als Webdesigner](https://digitalhandwerk.rocks/ki/vom-code-legastheniker-zum-web-designer-meine-ersten-tage-mit-claude).

## Die wichtigsten Direktiven verständlich erklärt

Eine gute CSP für eine kleine Firmenwebsite ist kurz. Diese Direktiven decken das meiste ab:

| Direktive | Was sie regelt | Sinnvoller Startwert |
|---|---|---|
| `default-src` | Grundregel für alle Inhalte ohne eigene Direktive | `'self'` (nur die eigene Adresse) |
| `script-src` | Woher JavaScript kommen darf | `'self'` plus nötige Dienste |
| `img-src` | Woher Bilder kommen dürfen | `'self' data:` |
| `style-src` | Woher Stylesheets (Gestaltungsdateien) kommen dürfen | `'self'` |
| `connect-src` | Wohin Skripte Daten senden dürfen | `'self'` |
| `frame-src` | Welche fremden Inhalte in Rahmen erscheinen dürfen, etwa eine Karte | nur der konkrete Dienst |
| `object-src` | Alte Plug-in-Einbettungen | `'none'` |
| `base-uri` | Ob relative Links umgebogen werden dürfen | `'self'` |
| `frame-ancestors` | Wer deine Seite einbetten darf (Clickjacking-Schutz) | `'self'` oder `'none'` |

Drei Regeln helfen beim Lesen:

1. **`'self'` heisst: die eigene Adresse.** Laut MDN erlaubt `'self'` nur Inhalte vom selben Ursprung wie die Seite, also derselben Domain mit demselben Protokoll.
2. **Spezielle Direktiven ersetzen die Grundregel.** `default-src` ist laut der [englischen CSP-Anleitung von MDN](https://developer.mozilla.org/en-US/docs/Web/HTTP/Guides/CSP) der Rückfall für alle Inhaltsarten, die keine eigene Direktive haben. Setzt du `img-src`, gilt für Bilder nur noch diese Zeile. Wer also `img-src` setzt, muss `'self'` dort nochmals nennen.
3. **Manche Direktiven haben keine Grundregel.** `frame-ancestors`, `base-uri` und `form-action` fallen nicht auf `default-src` zurück. Fehlen sie, ist dieser Bereich unbeschränkt. OWASP nennt ein fehlendes `object-src` oder `base-uri` deshalb als typische Schwachstelle.

Ein Startpunkt für eine Firmenwebsite ohne fremde Dienste sieht so aus:

```
Content-Security-Policy: default-src 'self'; img-src 'self' data:; object-src 'none'; base-uri 'self'; frame-ancestors 'self'
```

Nutzt du eine eingebettete Karte, ein Video oder eine Schriftart von einem externen Anbieter, kommt genau dessen Adresse in die passende Direktive. Nicht mehr.

## CSP einrichten: Schritt für Schritt

### 1. Fremde Dienste auflisten

Bevor eine Zeile Regel entsteht, brauchst du eine Liste: Welche Inhalte lädt deine Website von fremden Adressen? Typisch sind Videos, Karten, Schriften, Buchungs-Widgets oder ein Zahlungsknopf. Jeder dieser Dienste braucht später einen Eintrag.

Hier zeigt sich der Unterschied zwischen einer gewachsenen CMS-Website und einer schlanken Website: Jedes Plug-in, jedes Theme kann eigene Skripte von eigenen Adressen nachladen, oft direkt im HTML. Bei einer Website, die dein KI-Assistent baut, kannst du einfach fragen: «Liste mir alle externen Quellen auf, die meine Website lädt.» Die Antwort ist kurz, weil der Assistent den ganzen Code vor sich hat.

### 2. Die Regel vom KI-Assistenten schreiben lassen

Gib Claude oder ChatGPT die Liste und den Auftrag: eine Content Security Policy mit `default-src 'self'`, ohne `'unsafe-inline'` und `'unsafe-eval'`, mit `object-src 'none'`, `base-uri 'self'` und `frame-ancestors 'self'`. Sag dazu, ob deine Website statisch ist oder PHP verwendet, damit der Assistent Header oder Meta-Tag passend setzt.

Bitte ihn zugleich, Code anzupassen, der mit einer strengen CSP nicht läuft. Die [MDN-Praxisanleitung zur CSP-Implementierung](https://developer.mozilla.org/de/docs/Web/Security/Practical_implementation_guides/CSP) nennt die üblichen Fälle: Inline-Event-Handler wie `onclick="…"` direkt im HTML werden durch `addEventListener` in einer eigenen Skriptdatei ersetzt, und `eval()` wird entfernt. Für einen KI-Assistenten ist das Routinearbeit.

### 3. Testen, ohne dass Besucher etwas merken

MDN empfiehlt, eine CSP vor dem Scharfschalten mit dem Header `Content-Security-Policy-Report-Only` zu testen. In diesem Modus blockiert der Browser nichts, meldet aber jeden Verstoss. Du siehst also, was die Regel kaputt machen würde, ohne dass Besucher etwas merken. Diesen Modus gibt es nur als Header, nicht als Meta-Tag.

Steht deine CSP im Meta-Tag, testest du stattdessen in einer Vorschau: einer Fassung der Website unter einer eigenen Adresse, die Besucher nicht sehen. Dort gilt die Regel schon scharf, aber nur für dich.

Die Meldungen findest du in beiden Fällen in der Browser-Konsole: In Chrome, Edge oder Firefox öffnest du mit F12 die Entwicklerwerkzeuge und wählst den Reiter «Konsole». Jede Zeile nennt die Direktive und die blockierte Adresse. Kopiere die Meldungen in den Chat, und dein KI-Assistent passt die Regel an.

### 4. Alle wichtigen Seiten durchklicken

Öffne jede Seitenart: Startseite, Kontaktseite, Seiten mit Karte oder Video, Formulare, Bestellablauf. OWASP rät, zu prüfen, ob die Policy überall gleich angewendet wird. Eine Unterseite ohne Regel ist eine offene Hintertür.

Ob der Header ankommt, siehst du ebenfalls in den Entwicklerwerkzeugen: Reiter «Netzwerk», Seite neu laden, erste Anfrage anklicken, dann unter den Antwort-Headern nach `content-security-policy` suchen. Ein Meta-Tag steht stattdessen im Quelltext der Seite.

### 5. Scharf schalten

Bleibt die Konsole ruhig, ersetzt du `Content-Security-Policy-Report-Only` durch `Content-Security-Policy`, oder du veröffentlichst die geprüfte Vorschau. Ab jetzt blockiert der Browser bei allen Besuchern, was nicht erlaubt ist.

Genau hier lohnen sich Versionen. Wird jede Änderung als eigene Version gespeichert, holst du den vorherigen Stand zurück, wenn dir nach dem Veröffentlichen auffällt, dass die Karte auf der Kontaktseite fehlt, und korrigierst in Ruhe.

### 6. Bei jeder Änderung neu prüfen

Eine CSP ist kein einmaliges Projekt. OWASP empfiehlt, die Policy zu überprüfen, sobald neue Skripte oder Dienste dazukommen und wenn das Frontend grösser umgebaut wird. Bindest du einen neuen Buchungskalender ein, gehört seine Adresse in die Regel. Wenn du deine Website ohnehin im Chat pflegst, sagst du dem Assistenten einfach: «Passe die CSP an den neuen Dienst an.»

## Die häufigsten Fehler vermeiden

Die meisten schwachen Richtlinien scheitern nicht an fehlenden Zeilen, sondern an zu grosszügigen Freigaben:

- **`'unsafe-inline'`** erlaubt Skripte direkt im HTML. OWASP hält fest, dass das den XSS-Schutz erheblich schwächt, denn eingeschleuster Code ist meist genau solcher Inline-Code.
- **`'unsafe-eval'`** erlaubt, Text als Code auszuführen. MDN rät davon ab, weil es die CSP deutlich schwächt.
- **Platzhalter wie `*` oder `https://*`** öffnen die Tür für jede Adresse. OWASP verlangt, auch Teil-Platzhalter genau zu prüfen.
- **Öffentliche Sammeldomains.** PortSwigger warnt davor, CDNs ohne eigene Adresse pro Kunde zu vertrauen, also Servernetzen, auf denen viele Anbieter Dateien bereitstellen. Wer dort Dateien ablegen kann, kann sie auf deine Seite bringen. Erlaube möglichst nur die konkrete Quelle oder liefere die Datei von der eigenen Adresse aus.

Brauchst du trotzdem ein Skript direkt im HTML, gibt es zwei saubere Wege:

- **Nonce:** eine Zufallszahl, die der Server bei jedem Seitenaufruf neu erzeugt und sowohl in die CSP als auch ins Skript schreibt. Laut der [web.dev-Kurzübersicht zu Sicherheitsheadern](https://web.dev/articles/security-headers?hl=de) ist eine Nonce-basierte CSP nur sicher, wenn für jede Antwort eine andere Nonce erzeugt wird. Das setzt eine dynamische Website voraus, etwa mit PHP.
- **Hash:** ein digitaler Fingerabdruck des Skriptinhalts. Er passt zu statischen Seiten. MDN empfiehlt Hashes für statische und Nonces für dynamische Inhalte. Ändert sich das Skript, muss laut PortSwigger auch der Hash neu berechnet werden. Das erledigt dein KI-Assistent bei jeder Änderung mit.

Für Fortgeschrittene gibt es noch die Meldefunktion: Mit `report-to` und `report-uri` schickt der Browser Verstösse an eine Adresse, die du festlegst. Laut [MDN zur Direktive report-to](https://developer.mozilla.org/docs/Web/HTTP/Headers/Content-Security-Policy/report-to) soll `report-to` das ältere `report-uri` ablösen. Bis es überall unterstützt wird, kannst du beide setzen. Für eine kleine Website reicht meist der Test in der Konsole.

Und schliesslich: Eine CSP ergänzt HTTPS, sie ersetzt es nicht. Ohne gültiges SSL-Zertifikat, also die Verschlüsselung zwischen Browser und Server, hilft die beste Regel wenig. Mehr dazu in [SSL-Verwaltung](https://madpublishing.ch/blog/ssl-verwaltung) und [HSTS aktivieren](https://madpublishing.ch/blog/hsts-aktivieren-https). Wie du Bilder und Skripte findest, die noch über `http://` kommen, steht in [Mixed Content beheben](https://madpublishing.ch/blog/mixed-content-beheben).

## Warum eine Website ohne CMS es leichter hat

Eine strenge CSP verträgt sich schlecht mit Inline-Skripten und vielen fremden Quellen. Beides bringen klassische Redaktionssysteme mit ihren Erweiterungen häufig mit. Wer dort eine strenge Regel setzt, muss oft Kompromisse wie `'unsafe-inline'` eingehen, damit Erweiterungen und Verwaltung weiter funktionieren.

![Vergleich «CMS und KI-Website»: Beim CMS laden Plug-ins fremde Skripte nach und erschweren eine strenge CSP, bei der KI-Website bleibt der Code überschaubar, die fremden Quellen sind bekannt, und es gibt kein Login und keine Plug-in-Updates](https://data.madpublishing.ch/bilder/csp-header-einrichten-cms.jpg)

Bei einer Website, die dein KI-Assistent baut, ist das deutlich einfacher. Der Code ist überschaubar, fremde Quellen sind bekannt, und der Assistent kann ihn von Anfang an so schreiben, dass er zu einer strengen CSP passt. Dazu kommt: Ohne Redaktionssystem gibt es kein Login, das angegriffen werden kann, und keine Plug-in-Updates, die neue Skripte nachladen.

## So ist es bei MADLAB // Publishing

Bei MADLAB // Publishing ist Claude oder ChatGPT dein Redaktor: Der Assistent baut und ändert die Website im Gespräch. Wir veröffentlichen, hosten und verwalten sie, mit Vorschau, Versionen und Zurückholen. Für die CSP heisst das:

- **Die Liste der fremden Dienste liefert die Prüfung.** Bevor du veröffentlichst, prüft dein Assistent die Website mit `check_site`. Fremde Server, von denen die Website etwas lädt, meldet die Prüfung als Hinweis zum Datenschutz. Das ist zugleich die Liste für deine CSP.
- **Statische Website: CSP im Meta-Tag.** Bei einer Website aus HTML, CSS und Bildern setzt der Assistent die Regel als Meta-Tag in jede Seite. Was der Meta-Tag nicht kann, siehe oben, gilt auch hier.
- **Mit PHP: CSP als echter Header.** Mit dem Zusatzpaket PHP läuft deine Website auf unserem Hosting mit Apache, und die `.htaccess` gilt vollständig, auch für Header. Damit gehen `frame-ancestors`, der Testmodus und Nonces, die bei jedem Aufruf neu entstehen. Siehe [PHP und Daten](https://madpublishing.ch/hilfe/php-und-daten).
- **Testen in der Vorschau.** Jede Änderung siehst du zuerst in einer Vorschau unter einer eigenen Adresse, die Suchmaschinen nicht aufnehmen. Dort prüfst du in der Konsole, ob die Regel etwas blockiert, bevor ein Besucher es merkt.
- **Zurückholen statt flicken.** Jede Änderung ist eine Version mit Zeitpunkt und Autor. Blockiert die neue Regel doch etwas, holst du den vorherigen Stand zurück. Siehe [Versionen und Zurückrollen](https://madpublishing.ch/hilfe/versionen).
- **HTTPS ist eingerichtet.** Jede Adresse bekommt ein Zertifikat, das sich selbst erneuert, `http://` wird auf `https://` weitergeleitet, und jede Antwort trägt den HSTS-Header.

Veröffentlichst du mit «Website – eigenes Hosting» auf deinen bestehenden Webspace, gilt dort, was dein Anbieter erlaubt, auf Apache meist die `.htaccess`. Eine Grenze gehört dazu: Ohne CMS gibt es keine Oberfläche, in der jemand ohne Assistent Texte bearbeitet. Wie du Claude anbindest, steht in [Claude verbinden](https://madpublishing.ch/hilfe/claude-verbinden). Bestehende Websites, etwa aus WordPress oder Wix, lassen sich [übernehmen](https://madpublishing.ch/bestehende-website-uebernehmen). Was die Pläne und Zusatzpakete kosten, steht unter [Pläne und Zusatzpakete](https://madpublishing.ch/hilfe/plaene-und-zusatzpakete).

## Quellen

- [MDN: Content Security Policy (CSP)](https://developer.mozilla.org/de/docs/Web/HTTP/Guides/CSP)
- [MDN: Content Security Policy (CSP), englische Anleitung](https://developer.mozilla.org/en-US/docs/Web/HTTP/Guides/CSP)
- [MDN: Content Security Policy (CSP) Implementierung](https://developer.mozilla.org/de/docs/Web/Security/Practical_implementation_guides/CSP)
- [MDN: Content-Security-Policy: report-to](https://developer.mozilla.org/docs/Web/HTTP/Headers/Content-Security-Policy/report-to)
- [OWASP Web Security Testing Guide: Content Security Policy](https://wstg.owasp.org/latest/4-Web_Application_Security_Testing/02-Configuration_and_Deployment_Management/12-Content_Security_Policy/)
- [PortSwigger Web Security Academy: Content security policy](https://portswigger.net/web-security/cross-site-scripting/content-security-policy)
- [web.dev: Cross-Site-Scripting (XSS) mit einer strengen CSP abschwächen](https://web.dev/articles/strict-csp?hl=de)
- [web.dev: Kurzübersicht zu Sicherheitsheadern](https://web.dev/articles/security-headers?hl=de)

## Häufige Fragen

### Wofür steht CSP?

CSP steht für Content Security Policy. Es ist eine Regel, die deine Website an den Browser schickt und die festlegt, aus welchen Quellen Skripte, Bilder und andere Inhalte geladen werden dürfen. Sie schützt vor allem vor eingeschleustem Code (XSS) und, als Header, vor Clickjacking.

### Reicht ein Meta-Tag statt eines Headers?

Für den Grundschutz vor fremden Skripten ja. Der Meta-Tag unterstützt aber `frame-ancestors`, die Meldefunktion und den Report-Only-Modus nicht. Wenn dein Hosting Header erlaubt, ist der Header die bessere Wahl.

### Kann eine CSP meine Website kaputt machen?

Ja, wenn sie etwas blockiert, das deine Seite braucht, zum Beispiel eine eingebettete Karte. Darum testest du zuerst, mit `Content-Security-Policy-Report-Only` oder in einer Vorschau, und schaltest erst scharf, wenn die Konsole keine Verstösse mehr meldet. Mit Versionen holst du im Notfall den vorherigen Stand zurück.

### Wie oft muss ich die CSP anpassen?

Immer dann, wenn du einen neuen fremden Dienst einbindest oder den Code grösser umbaust. Pflegst du die Website im Chat, nennst du die Änderung einfach mit, und der KI-Assistent ergänzt die Regel.

### Ersetzt eine CSP andere Sicherheitsmassnahmen?

Nein. Sie ist eine zusätzliche Schutzschicht. Sauberer Code, der Eingaben prüft, und HTTPS mit gültigem Zertifikat bleiben die Grundlage.