Contao Headless API-Sicherheit & Formularverarbeitung

1<?php
2
3declare(strict_types=1);
4
5namespace App\Controller\Api;
6
7use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
8use Symfony\Component\HttpFoundation\JsonResponse;
9use Symfony\Component\HttpFoundation\Request;
10use Symfony\Component\Routing\Annotation\Route;
11
12#[Route('/​api/​v1/​form/​contact', name: 'api_form_contact', methods: ['POST'], defaults: ['_scope' => 'frontend'])]
13final class ContactFormController extends AbstractController
14{
15    // Wir holen uns den in der .env.local definierten API-Key über Dependency Injection
16    public function __construct(
17        private readonly string $apiSharedSecret
18    ) {}
19
20    public function __invoke(Request $request): JsonResponse
21    {
22        // 1. Die harte Zugangskontrolle (API-Key Validierung)
23        $authHeader = $request->headers->get('Authorization');
24        
25        if (!$authHeader || !str_starts_with($authHeader, 'Bearer ')) {
26            return new JsonResponse(['error' => 'Unauthorized. Missing authentication header.'], 401);
27        }
28
29        $token = substr($authHeader, 7); // Das Wort "Bearer " abschneiden
30
31        // Timing-Attacken durch hash_equals verhindern! Niemals einfach == verwenden.
32        if (!hash_equals($this->apiSharedSecret, $token)) {
33            return new JsonResponse(['error' => 'Forbidden. Invalid API key.'], 403);
34        }
35
36        // 2. Payload extrahieren (nur wenn die Zugangskontrolle bestanden wurde)
37        $payload = json_decode($request->getContent(), true);
38
39        if (!$payload) {
40            return new JsonResponse(['error' => 'Bad Request. Invalid JSON payload.'], 400);
41        }
42
43        // ... Hier folgt später die Geschäftslogik (Validierung, Mail-Versand) ...
44
45        return new JsonResponse(['success' => true, 'message' => 'Secure payload received.']);
46    }
47}

1services:
2    _defaults:
3        autowire: true
4        autoconfigure: true
5        # Wir binden die Umgebungsvariable API_SHARED_SECRET an den Parameter
6        bind:
7            $apiSharedSecret: '%env(string:API_SHARED_SECRET)%'
8
9    App\:
10        resource: '../​src/'
11        exclude:
12            - '../​src/​DependencyInjection/'
13            - '../​src/​Entity/'
14            - '../​src/​Kernel.php'

1'use server';
2
3// Diese Funktion läuft AUSSCHLIESSLICH auf dem serverseitigen Node.js Backend!
4export async function submitContactForm(prevState: any, formData: FormData) {
5  // 1. Daten aus dem Frontend-Formular extrahieren
6  const email = formData.get('email');
7  const message = formData.get('message');
8
9  // 2. Eigene Validierung auf dem Next.js Server (optional, aber empfohlen)
10  if (!email || !message) {
11    return { error: 'Bitte füllen Sie alle Felder aus.' };
12  }
13
14  try {
15    // 3. Den sicheren Server-to-Server Request an Contao abfeuern
16    // process.env.CONTAO_API_URL und process.env.CONTAO_API_KEY liegen nur auf dem Server!
17    const response = await fetch(`${process.env.CONTAO_API_URL}/​api/​v1/​form/​contact`, {
18      method: 'POST',
19      headers: {
20        'Content-Type': 'application/​json',
21        // Hier injizieren wir das Token, das wir im Contao Controller validieren
22        'Authorization': `Bearer ${process.env.CONTAO_API_KEY}`, 
23      },
24      body: JSON.stringify({ email, message }),
25      // Wir wollen diese POST-Anfrage niemals cachen
26      cache: 'no-store', 
27    });
28
29    const data = await response.json();
30
31    if (!response.ok) {
32      return { error: data.error || 'Fehler bei der Übermittlung an die API.' };
33    }
34
35    // 4. Erfolgreiche Antwort an die React-Komponente zurückgeben
36    return { success: true, message: data.message };
37
38  } catch (error) {
39    console.error('BFF Fetch Error:', error);
40    return { error: 'Ein interner Serverfehler ist aufgetreten.' };
41  }
42}

1<?php
2
3declare(strict_types=1);
4
5namespace App\Controller\Api;
6
7use Contao\StringUtil;
8use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
9use Symfony\Component\HttpFoundation\JsonResponse;
10use Symfony\Component\HttpFoundation\Request;
11use Symfony\Component\Routing\Annotation\Route;
12use Symfony\Component\Validator\Constraints as Assert;
13use Symfony\Component\Validator\Validator\ValidatorInterface;
14
15#[Route('/​api/​v1/​form/​contact', name: 'api_form_contact', methods: ['POST'], defaults: ['_scope' => 'frontend'])]
16final class ContactFormController extends AbstractController
17{
18    public function __construct(
19        private readonly string $apiSharedSecret,
20        // Wir injizieren den Symfony Validator
21        private readonly ValidatorInterface $validator 
22    ) {}
23
24    public function __invoke(Request $request): JsonResponse
25    {
26        // ... (Zugangskontrolle aus Abschnitt 1 hier beibehalten) ...
27
28        $payload = json_decode($request->getContent(), true);
29
30        // 1. Validierung: Wir definieren strikte Regeln für unseren Payload
31        $constraints = new Assert\Collection([
32            'email' => [
33                new Assert\NotBlank(['message' => 'Die E-Mail-Adresse darf nicht leer sein.']),
34                new Assert\Email(['message' => 'Die angegebene E-Mail-Adresse ist ungültig.']),
35            ],
36            'message' => [
37                new Assert\NotBlank(['message' => 'Die Nachricht darf nicht leer sein.']),
38                new Assert\Length([
39                    'min' => 10, 
40                    'max' => 5000,
41                    'minMessage' => 'Die Nachricht muss mindestens 10 Zeichen lang sein.',
42                    'maxMessage' => 'Die Nachricht ist zu lang.'
43                ]),
44            ],
45        ]);
46
47        // Symfony prüft den Array-Payload gegen unsere Regeln
48        $violations = $this->validator->validate($payload, $constraints);
49
50        if (count($violations) > 0) {
51            // Fehlermeldungen sauber für das Frontend aggregieren
52            $errors = [];
53            foreach ($violations as $violation) {
54                // Den Feldnamen bereinigen (Symfony gibt z.B. "[email]" zurück)
55                $field = trim($violation->getPropertyPath(), '[]');
56                $errors[$field] = $violation->getMessage();
57            }
58
59            return new JsonResponse(['success' => false, 'errors' => $errors], 422);
60        }
61
62        // 2. Sanitization: Die Daten sind formal gültig, aber noch potenziell gefährlich!
63        // Wir nutzen Contaos StringUtil, um HTML-Tags und Insert-Tags rigoros zu entfernen.
64        $safeEmail = StringUtil::stripInsertTags(strip_tags($payload['email']));
65        $safeMessage = StringUtil::stripInsertTags(strip_tags($payload['message']));
66        
67        // Optional: Kodierung für die sichere HTML-Ausgabe (verhindert XSS komplett)
68        $safeMessage = StringUtil::specialchars($safeMessage);
69
70        // 3. Verarbeitung der sauberen Daten (z.B. E-Mail versenden oder in DB speichern)
71        // ... $this->mailer->send(...) mit $safeEmail und $safeMessage
72
73        return new JsonResponse(['success' => true, 'message' => 'Anfrage sicher verarbeitet.']);
74    }
75}

1<?php
2
3declare(strict_types=1);
4
5namespace App\Controller\Api;
6
7use Contao\Dbafs;
8use Contao\File;
9use Contao\Folder;
10use Contao\StringUtil;
11use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
12use Symfony\Component\HttpFoundation\File\UploadedFile;
13use Symfony\Component\HttpFoundation\JsonResponse;
14use Symfony\Component\HttpFoundation\Request;
15use Symfony\Component\Routing\Annotation\Route;
16use Symfony\Component\Validator\Constraints as Assert;
17use Symfony\Component\Validator\Validator\ValidatorInterface;
18
19#[Route('/​api/​v1/​form/​upload', name: 'api_form_upload', methods: ['POST'], defaults: ['_scope' => 'frontend'])]
20final class ContactFormController extends AbstractController
21{
22    public function __construct(
23        private readonly string $apiSharedSecret,
24        private readonly ValidatorInterface $validator,
25        private readonly string $projectDir // Der absolute Pfad zur Contao-Installation
26    ) {}
27
28    public function __invoke(Request $request): JsonResponse
29    {
30        // 1. Authentifizierung (wie in Abschnitt 1)
31        if ($request->headers->get('Authorization') !== 'Bearer ' . $this->apiSharedSecret) {
32            return new JsonResponse(['error' => 'Unauthorized'], 401);
33        }
34
35        // 2. Die Datei aus dem multipart/​form-data Request greifen
36        /** @var UploadedFile|null $uploadedFile */
37        $uploadedFile = $request->files->get('attachment');
38
39        if (!$uploadedFile) {
40            return new JsonResponse(['error' => 'Keine Datei gefunden.'], 400);
41        }
42
43        // 3. Strikte Datei-Validierung über Symfony
44        $fileConstraints = new Assert\File([
45            'maxSize' => '5M', // Maximal 5 Megabyte
46            'mimeTypes' => [
47                'application/​pdf',
48                'image/​jpeg',
49                'image/​png',
50            ],
51            'mimeTypesMessage' => 'Bitte laden Sie nur PDF- oder JPG/​PNG-Bilder hoch.',
52        ]);
53
54        $violations = $this->validator->validate($uploadedFile, $fileConstraints);
55        if (count($violations) > 0) {
56            return new JsonResponse(['error' => $violations[0]->getMessage()], 422);
57        }
58
59        // 4. Dateinamen bereinigen (Sanitization: Verhindert Path Traversal Attacken wie "../../../")
60        $originalFilename = pathinfo($uploadedFile->getClientOriginalName(), PATHINFO_FILENAME);
61        $safeFilename = StringUtil::standardize($originalFilename);
62        $extension = $uploadedFile->guessExtension();
63        $finalFilename = $safeFilename . '_' . uniqid() . '.' . $extension;
64
65        // 5. Den sicheren Zielordner in Contao anlegen (falls er nicht existiert)
66        // WICHTIG: Speichere sensible User-Uploads NIE in /​public, sondern in geschützten /​files Unterordnern!
67        $uploadDirectory = 'files/​secure_uploads/' . date('Y-m');
68        new Folder($uploadDirectory);
69
70        try {
71            // 6. Die Datei physisch in das Contao-Verzeichnis verschieben
72            $movedFile = $uploadedFile->move(
73                $this->projectDir . '/' . $uploadDirectory,
74                $finalFilename
75            );
76
77            // 7. Datenbank-Synchronisation (Dbafs)
78            // Dies ist der wichtigste Contao-spezifische Schritt! Ohne Dbafs "weiß" Contao nicht, 
79            // dass diese Datei existiert (z.B. für die Anzeige im Backend-Dateimanager).
80            $contaoFile = new File($uploadDirectory . '/' . $finalFilename);
81            $fileModel = Dbafs::addResource($contaoFile->path);
82
83            return new JsonResponse([
84                'success' => true,
85                'message' => 'Datei erfolgreich hochgeladen und gesichert.',
86                'uuid' => StringUtil::binToUuid($fileModel->uuid) // Optional: UUID für spätere Verknüpfungen zurückgeben
87            ]);
88
89        } catch (\Exception $e) {
90            return new JsonResponse(['error' => 'Dateiverarbeitung fehlgeschlagen.'], 500);
91        }
92    }
93}

1framework:
2    rate_limiter:
3        # Wir definieren einen "contact_form" Limiter
4        contact_form:
5            # Die Sliding-Window-Strategie ist ideal für APIs
6            policy: 'sliding_window'
7            limit: 5
8            interval: '15 minutes'

1<?php
2
3declare(strict_types=1);
4
5namespace App\Controller\Api;
6
7use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
8use Symfony\Component\HttpFoundation\JsonResponse;
9use Symfony\Component\HttpFoundation\Request;
10use Symfony\Component\Routing\Annotation\Route;
11use Symfony\Component\RateLimiter\RateLimiterFactory; // Neu importieren
12
13#[Route('/​api/​v1/​form/​contact', name: 'api_form_contact', methods: ['POST'], defaults: ['_scope' => 'frontend'])]
14final class ContactFormController extends AbstractController
15{
16    public function __construct(
17        private readonly string $apiSharedSecret,
18        // Symfony injiziert automatisch die Factory für unseren konfigurierten Limiter
19        private readonly RateLimiterFactory $contactFormLimiter 
20    ) {}
21
22    public function __invoke(Request $request): JsonResponse
23    {
24        // 1. Rate Limiting (Noch VOR der Payload-Prüfung!)
25        // Wir nutzen die Client-IP als Identifikator (oder den API-Key, je nach Architektur)
26        $limiter = $this->contactFormLimiter->create($request->getClientIp());
27        
28        $limit = $limiter->consume(1);
29        
30        if (!$limit->isAccepted()) {
31            return new JsonResponse([
32                'error' => 'Too Many Requests. Bitte warten Sie 15 Minuten, bevor Sie eine neue Anfrage senden.'
33            ], 429, [
34                // Dem Client mitteilen, wann er wieder senden darf
35                'Retry-After' => $limit->getRetryAfter()->getTimestamp() 
36            ]);
37        }
38
39        // 2. Zugangskontrolle (API-Key)
40        if ($request->headers->get('Authorization') !== 'Bearer ' . $this->apiSharedSecret) {
41            return new JsonResponse(['error' => 'Unauthorized'], 401);
42        }
43
44        // ... restliche Validierung und Verarbeitung (aus Abschnitt 3 & 4) ...
45
46        return new JsonResponse(['success' => true, 'message' => 'Anfrage sicher verarbeitet.']);
47    }
48}