Einwilligung, die tatsächlich zurückhält, und Pflichtseiten

Ein Hinweis, der nur fragt und sonst nichts ändert, ist Theater. Deshalb zwei
Hälften, und die zweite ist die wichtigere.

Die Frage: serverseitig gerendert, per Formular beantwortet, ohne JavaScript -
die öffentlichen Seiten laufen mit script-src 'none', und ein Banner mit
Skript wäre das eine, was diese Regel bricht. "Alle akzeptieren" und "Nur
notwendige" sind dieselbe Art Knopf, gleich groß, nebeneinander. Die
Entscheidung steht in einem eigenen Cookie: Fassung der Frage, gewährte
Gruppen, Zeitpunkt. Keine Kennung, kein Serverabgleich, ein halbes Jahr. Kein
CSRF-Token, absichtlich: die Anfrage ändert nichts auf dem Server, und ein
Token bräuchte für jeden Besucher eine Sitzung - genau das, was ein
Einwilligungshinweis vermeiden soll. Geprüft wird stattdessen das
Rücksprungziel.

Das Zurückhalten: der neue Block "Externer Inhalt" (Dokumentschema v14) lädt
ohne Einwilligung nichts - kein iframe, keine Adresse im Markup, frame-src
'none'. Der Platzhalter nennt den Anbieter; sein Knopf gewährt genau diese
Gruppe und nimmt die vorher gewährten mit. Erst danach kommt der Host in die
Sicherheitsrichtlinie, und nur dieser. Im Editor bleibt es immer ein
Platzhalter.

Datenschutz und Impressum sind keine Einstellung mehr: fehlen sie, warnt die
Verwaltung und legt sie auf Knopfdruck als Gerüst an, mit NOCH AUSZUFÜLLEN an
jeder Pflichtangabe. Den Text schreibt das CMS nicht - das ist eine rechtliche
Aussage über eine Firma. Verlinkt werden beide aus dem Template, nicht aus dem
Fußbereich: ein Pflichtlink, den man löschen kann, ist keiner.

Dazu der Fehler, den Umut im Screenshot gesehen hat: die Wortmarke stand als
Buchstabenkolonne in einem 60 Pixel breiten Kasten. .site-header war noch ein
Flexcontainer aus der Zeit des handgeschriebenen Markups und quetschte die
Sektion zusammen, und design.css band jede Designklasse an #main - wo Kopf-
und Fußbereich seit ADR 026 nicht mehr liegen. Beides behoben.

Neu im Ausbauplan: Statistik (serverseitige, wiedererkennungsfreie Zählung,
die deshalb keine Einwilligung braucht), Inhalte und Ladeverhalten prüfen
(Blättern überall, minimal laden, Ladebudget), Installer (Schritt für Schritt
im Browser, Migration inklusive).

245 PHP-Tests / 976 Assertions unter PHP 8.2.12 und 8.4.22. Der Browsertest
fand zwei Fehler von mir: grauer Text auf dunklem Fußbereich mit 2,24:1, und
das fixierte Banner verdeckte den Einwilligungsknopf am Seitenende.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

src/Controller/ConsentController.php

@@ -0,0 +1,76 @@
+<?php
+
+namespace App\Controller;
+
+use App\Content\Consent;
+use App\Content\SiteSettings;
+use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
+use Symfony\Component\HttpFoundation\Request;
+use Symfony\Component\HttpFoundation\Response;
+use Symfony\Component\Routing\Attribute\Route;
+
+/**
+ * Recording and changing the consent decision.
+ *
+ * **No CSRF token here, deliberately.** The request changes nothing on the server: it sets a
+ * cookie that only affects the browser that sent it. A token would need a session, and starting a
+ * session for every visitor is exactly what a consent banner exists to avoid. What is checked is
+ * the target of the redirect, so the form cannot be used to bounce someone to another site.
+ */
+final class ConsentController extends AbstractController
+{
+    public function __construct(private Consent $consent, private SiteSettings $settings)
+    {
+    }
+
+    #[Route('/einwilligung', name: 'consent_save', methods: ['POST'])]
+    public function save(Request $request): Response
+    {
+        $choice = $request->request->getString('choice');
+        $groups = match ($choice) {
+            'all' => array_keys(Consent::GROUPS),
+            'none' => [],
+            default => array_map(static fn (mixed $group): string => (string) $group, (array) $request->request->all('groups')),
+        };
+        $response = $this->redirect($this->backTo($request));
+        $this->consent->remember($request, $response, $groups);
+
+        return $response;
+    }
+
+    #[Route('/einwilligung', name: 'consent_page', methods: ['GET'])]
+    public function page(Request $request): Response
+    {
+        if ([] === $this->consent->askedGroups()) {
+            throw $this->createNotFoundException('Diese Website fragt nichts ab.');
+        }
+        // Deliberately without header and footer: this is a page about a decision, not a page of
+        // the website, and it must work even when an area is broken.
+        $response = $this->render('consent.html.twig', [
+            'consent' => $this->consent->state($request),
+            'settings' => $this->settings->load(),
+        ]);
+        $response->headers->set('Cache-Control', 'no-store');
+        $response->headers->set('X-Robots-Tag', 'noindex, follow');
+        $response->headers->set('X-Content-Type-Options', 'nosniff');
+        $response->headers->set('Referrer-Policy', 'strict-origin-when-cross-origin');
+        // The page carries no embeds and no own styles, so it keeps the strictest policy.
+        $response->headers->set('Content-Security-Policy', "default-src 'self'; script-src 'none'; style-src 'self'; img-src 'self' https: data:; object-src 'none'; base-uri 'none'; frame-ancestors 'none'; form-action 'self'");
+
+        return $response;
+    }
+
+    /**
+     * Back to where the form was submitted from, but only within this site: an open redirect
+     * would turn a consent button into a way to send people anywhere.
+     */
+    private function backTo(Request $request): string
+    {
+        $target = $request->request->getString('back');
+        if ('' === $target || !str_starts_with($target, '/') || str_starts_with($target, '//')) {
+            return '/';
+        }
+
+        return $target;
+    }
+}

src/Controller/PageController.php

@@ -2,6 +2,7 @@
 
 namespace App\Controller;
 
+use App\Content\Consent;
 use App\Content\CustomCode;
 use App\Content\FormRepository;
 use App\Content\MenuRepository;
@@ -19,13 +20,13 @@ use Symfony\Component\Routing\Attribute\Route;
 
 final class PageController extends AbstractController
 {
-    public function __construct(private PageRepository $pages, private MenuRepository $menus, private PostRepository $posts, private FormRepository $forms, private RedirectRepository $redirects, private SiteSettings $settings, private PartialRepository $partials, private CustomCode $code, private Theme $theme, private StyleCompiler $styles, private string $secret, private string $siteOrigin)
+    public function __construct(private PageRepository $pages, private MenuRepository $menus, private PostRepository $posts, private FormRepository $forms, private RedirectRepository $redirects, private SiteSettings $settings, private PartialRepository $partials, private CustomCode $code, private Consent $consent, private Theme $theme, private StyleCompiler $styles, private string $secret, private string $siteOrigin)
     {
     }
 
     // A segment is a slug; up to four of them form the public path. The leading lookahead keeps
     // the CMS routes (/admin, /media, /assets) out of the catch-all, which matches before them.
-    private const PATH = '(?!admin(?:/|$)|media/|assets/|kategorie/|schlagwort/|beitraege(?:/|$)|feed\.xml$|sitemap\.xml$|robots\.txt$|llms\.txt$)[a-z0-9]+(?:-[a-z0-9]+)*(?:/[a-z0-9]+(?:-[a-z0-9]+)*){0,3}';
+    private const PATH = '(?!admin(?:/|$)|media/|assets/|kategorie/|schlagwort/|beitraege(?:/|$)|einwilligung$|feed\.xml$|sitemap\.xml$|robots\.txt$|llms\.txt$)[a-z0-9]+(?:-[a-z0-9]+)*(?:/[a-z0-9]+(?:-[a-z0-9]+)*){0,3}';
 
     #[Route('/', name: 'home', methods: ['GET'])]
     #[Route('/{path}', name: 'page', requirements: ['path' => self::PATH], methods: ['GET'])]
@@ -80,8 +81,9 @@ final class PageController extends AbstractController
         }
 
         $wantsScript = null !== $page && ($this->hasType($page['document'], 'tabs') || [] !== $this->code->scriptsOf($page['document']));
+        $frames = null === $page ? [] : $this->frameHosts($request, $page['document'], ...array_values($areas), ...array_values($sections));
 
-        return $this->shell($response, $wantsScript, $styles, null !== $googleFonts);
+        return $this->shell($response, $wantsScript, $styles, null !== $googleFonts, $frames);
     }
 
     /**
@@ -92,7 +94,12 @@ final class PageController extends AbstractController
      * The generated stylesheet is inline for speed, so it is allowed by its own hash rather than
      * by 'unsafe-inline' – any other inline style, injected or not, stays blocked.
      */
-    private function shell(Response $response, bool $allowScript = false, string $styles = '', bool $googleFonts = false): Response
+    /**
+     * @param list<string> $frameHosts Hosts of embeds that are actually rendered on this response.
+     *                                 Nothing is added to the policy for an embed still waiting
+     *                                 for consent.
+     */
+    private function shell(Response $response, bool $allowScript = false, string $styles = '', bool $googleFonts = false, array $frameHosts = []): Response
     {
         $styleSources = ["'self'"];
         if ('' !== $styles) {
@@ -108,10 +115,11 @@ final class PageController extends AbstractController
         $response->headers->set('X-Content-Type-Options', 'nosniff');
         $response->headers->set('Referrer-Policy', 'strict-origin-when-cross-origin');
         $response->headers->set('Content-Security-Policy', sprintf(
-            "default-src 'self'; script-src %s; style-src %s; font-src %s; img-src 'self' https: data:; object-src 'none'; base-uri 'none'; frame-ancestors 'none'; form-action 'self'",
+            "default-src 'self'; script-src %s; style-src %s; font-src %s; img-src 'self' https: data:; frame-src %s; object-src 'none'; base-uri 'none'; frame-ancestors 'none'; form-action 'self'",
             $allowScript ? "'self'" : "'none'",
             implode(' ', $styleSources),
             implode(' ', $fontSources),
+            [] === $frameHosts ? "'none'" : implode(' ', array_map(static fn (string $host): string => 'https://'.$host, $frameHosts)),
         ));
 
         return $response;
@@ -253,6 +261,8 @@ final class PageController extends AbstractController
         $result = $this->posts->published($page, $term['id'] ?? null);
         $base = null === $term ? '/beitraege' : '/'.PostRepository::ARCHIVE_PREFIX[$kind].'/'.$term['slug'];
 
+        $frames = $this->frameHosts($request, ...array_values($this->areas()));
+
         return $this->shell($this->render('archive.html.twig', [
             'areas' => $this->areas(),
             'navigation' => $this->navigation(''),
@@ -262,7 +272,7 @@ final class PageController extends AbstractController
             'base' => $base,
             'canonical' => rtrim($this->siteOrigin, '/').$base.($result['page'] > 1 ? '?seite='.$result['page'] : ''),
             'navigation' => $this->navigation(''),
-        ]));
+        ]), frameHosts: $frames);
     }
 
     #[Route('/feed.xml', name: 'feed', methods: ['GET'])]
@@ -329,6 +339,35 @@ final class PageController extends AbstractController
         return $response;
     }
 
+    /**
+     * The hosts of embeds that may load on this request.
+     *
+     * An embed whose group is not granted contributes nothing: its host must not appear in the
+     * policy, because the frame is not rendered either.
+     *
+     * @return list<string>
+     */
+    private function frameHosts(Request $request, array ...$documents): array
+    {
+        $hosts = [];
+        $walk = function (array $blocks) use (&$walk, &$hosts, $request): void {
+            foreach ($blocks as $block) {
+                if ('embed' === ($block['type'] ?? null) && $this->consent->granted($request, $block['props']['group'] ?? '')) {
+                    $host = parse_url($block['props']['url'] ?? '', PHP_URL_HOST);
+                    if (is_string($host)) {
+                        $hosts[$host] = true;
+                    }
+                }
+                $walk($block['children'] ?? []);
+            }
+        };
+        foreach ($documents as $document) {
+            $walk($document['blocks'] ?? []);
+        }
+
+        return array_keys($hosts);
+    }
+
     /**
      * The header and footer documents. Absent areas simply render nothing, so a site without a
      * header is a valid site rather than a broken one.

src/Controller/SettingsController.php

@@ -2,6 +2,8 @@
 
 namespace App\Controller;
 
+use App\Content\Consent;
+use App\Content\DemoContent;
 use App\Content\PageRepository;
 use App\Content\RedirectRepository;
 use App\Content\SiteSettings;
@@ -33,6 +35,9 @@ final class SettingsController extends AbstractController
             'settings' => $this->settings->load(),
             'redirects' => $this->redirects->all(),
             'choosableHome' => $choosable,
+            'consentGroups' => Consent::GROUPS,
+            'missingLegal' => $this->settings->missingLegalPages(),
+            'consentGroupHelp' => Consent::GROUP_HELP,
         ]);
     }
 
@@ -78,6 +83,60 @@ final class SettingsController extends AbstractController
         return $this->back('Die Weiterleitung wurde gespeichert.', 'success');
     }
 
+    /**
+     * Creates the privacy statement and the imprint, with a skeleton whose gaps are marked.
+     *
+     * The pages are mandatory, the text is not something a CMS can write: what gets created is the
+     * structure with every required item named and marked as still to be filled in.
+     */
+    #[Route('/admin/settings/rechtliches', name: 'admin_legal_pages', methods: ['POST'])]
+    public function legalPages(Request $request): Response
+    {
+        $this->denyAccessUnlessGranted('ROLE_EDITOR');
+        if (!$this->isCsrfTokenValid('settings', $request->request->getString('_csrf_token'))) {
+            return $this->back('Deine Sitzung ist abgelaufen. Bitte melde dich erneut an.');
+        }
+        $settings = $this->settings->load();
+        $created = [];
+        try {
+            foreach (DemoContent::LEGAL as $slug => $label) {
+                $key = 'datenschutz' === $slug ? 'privacyPath' : 'imprintPath';
+                // An existing page is never overwritten - it may already carry the real text.
+                $existing = null !== $this->pages->findPublished($slug) || $this->pageExists($slug);
+                if (!$existing) {
+                    $id = $this->pages->createPage($slug, null, 'page', DemoContent::legalPage($slug));
+                    $page = $this->pages->findForEditor($id);
+                    $this->pages->publish($id, $page['draft_revision_id'], $page['version']);
+                    $created[] = $label;
+                }
+                $settings[$key] = $slug;
+            }
+            $this->settings->save([...$settings, 'consentGroups' => $settings['consentGroups'], 'sameAs' => implode('
+', $settings['sameAs'])]);
+        } catch (InvalidPage $e) {
+            return $this->back($e->getMessage());
+        }
+
+        return $this->back(
+            [] === $created
+                ? 'Die Seiten waren schon vorhanden und sind jetzt verknüpft. Der Inhalt bleibt unverändert.'
+                : sprintf('%s angelegt und verknüpft. Beide Seiten sind veröffentlicht und müssen noch ausgefüllt werden – die Pflichtangaben sind darin markiert.', implode(' und ', $created)),
+            'success',
+        );
+    }
+
+    /** Also finds a page that exists but is not published yet. */
+    private function pageExists(string $path): bool
+    {
+        foreach ($this->pages->listForEditor() as $page) {
+            if ($path === $page['path']) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
     private function back(string $message, string $type = 'error'): Response
     {
         $this->addFlash($type, $message);