Wie du Laravel und Symfony richtig sicher machst

Wenn du mit modernen PHP-Frameworks arbeitest, dann kennst du sicher das Gefühl: Eigentlich läuft alles sauber, die Struktur ist klar, Models, Controller, Routing, alles wirkt ordentlich. Und trotzdem bleibt da dieser kleine Gedanke im Hinterkopf: „Hoffentlich ist das Ding dicht.“ Und ja, genau darum geht’s. Laravel und Symfony sind mächtig, aber eben nur so sicher wie die Person, die sie konfiguriert.

Lass uns das einmal richtig durchgehen, so, dass du am Ende weißt, wo die typischen Schwachstellen sitzen und was du konkret dagegen tun kannst.

1. Grundlegend: Nimm die Defaults ernst, aber blind vertrauen solltest du ihnen nicht

Beide Frameworks bringen solide Sicherheitsfeatures mit. Aber Defaults reichen selten, wenn die Anwendung größer wird.
Laravel hat CSRF-Schutz, Hashing, Middleware. Symfony bietet Security-Bundles, Authenticator-Systeme, Zugriffskontrollen.

Das Problem: Viele entwickeln munter drauf los und merken erst später, dass sie unabsichtlich Türen offen gelassen haben.

Was du dir angewöhnen solltest:

• Environment nicht mischen: .env gehört nicht ins Repo.
• APP_DEBUG niemals live setzen.
• Cache-Konfigurationen vor Live-Deploys prüfen.

Klingt trivial, aber sind genau die Stellen, an denen Projekte in der Praxis am häufigsten stolpern.

2. Eingaben filtern: Vertrauen ist gut, validieren ist Gesetz

Ganz egal, ob du ein Formular, eine API oder irgendeinen versteckten Callback hast: Alles, was reinkommt, muss durch die Schleuse.
Laravel bietet dafür die Request-Klassen. Symfony hat Validator Constraints.

Entscheidend ist: Validierung muss zentral passieren, nicht irgendwo verstreut in Controllern.

Worauf du achten solltest:

• Keine freie Textannahme ohne Regeln
• Datentypen erzwingen (integer, boolean, email, uuid…)
• Grenzen setzen (Min/Max, Länge, erlaubte Werte)
• Mehrstufige Validierung bei sensiblen Daten

Wenn du das nicht machst, lädst du SQL-Injection, XSS oder Manipulation regelrecht ein.

3. Passwörter & Auth: Nicht tricksen, nicht kreativ werden

Laravel macht’s mit Hash::make(), Symfony mit password_hash() über die Security-Komponente und das ist gut so.
Finger weg von eigenen Hash-Methoden, eigenen Salt-Ideen oder irgendwelchen MD5-Überbleibseln aus Projekten von 2010.

Wichtige Punkte sind dabei:

• Immer bcrypt, argon2 oder höherwertige Methoden nutzen.
• Password-Policies einbauen (Länge, Komplexität, Ausweichregeln).
• Brute-Force-Schutz durch Rate Limiting.
• Sessions nur über HTTPS, mit Secure/Cookie-Flags.

Die häufigsten Leaks entstehen nicht durch Technik, sondern durch schlechte Entscheidungen.

4. Zugriffskontrolle: Rollen, Rechte und vor allem klare Grenzen

Viele Projekte scheitern nicht am Code, sondern daran, dass niemand sauber definiert hat, wer was darf.

Laravel: Gates, Policies
Symfony: Voter, Access Control

Die Systeme sind da, sie müssen nur genutzt werden.

Typische Fallen wären zB.:

• Ein globaler Admin-Check, der viel zu viel freischaltet
• Rechte direkt im Controller statt in einer Policy
• Fehlende Trennung zwischen „lesen“ und „bearbeiten“
• Versteckte Admin-Routen ohne zusätzlichen Schutz

Was du brauchst, ist ein einfaches, aber sauberes System:

• Klare Rollen (User, Editor, Admin)
• Konkrete Policies pro Feature
• Explizite Checks an allen kritischen Punkten

Wenn Zugriffskontrolle chaotisch ist, bringt dir der Rest wenig.

5. Datenbank-Sicherheit: Nutze ORM richtig, kein Raw SQL ohne Grund

Beide Frameworks setzen stark auf ORM und Prepared Statements. Wenn du dem ORM treu bleibst, bist du gegen SQL-Injection nahezu komplett geschützt. Die Probleme kommen erst, wenn jemand meint, er müsse „mal eben“ einen Raw-Query schreiben.

Wenn Raw SQL unvermeidbar ist:

• Immer bind parameters nutzen
• Niemals User-Input direkt als Teil eines Queries zusammenbauen
• Logging aktivieren, um Auffälligkeiten schneller zu finden

Und ganz wichtig: Datenbanksichtbarkeit einschränken. Der DB-User sollte nur so viele Rechte bekommen, wie absolut nötig.

6. Fehler & Logging: Zeige Angriffen nicht die Tür Nummer 3

Der Klassiker: Live-Website zeigt Voll-Fehlermeldung mit Stack-Trace.

Um Gottes Willen, nein.

Laravel: APP_DEBUG=false
Symfony: Prod-Environment aktiv, kein Debug-Modus.

Fehler sollten:

• geloggt,
• anonymisiert,
• intern eingesehen werden.

Nicht dem Besucher. Nicht dem Angreifer. Nicht dem Zufalls-Klicker.

7. API-Security: Tokens, Throttling und klare Regeln

Wenn dein Projekt eine API enthält (und das tun heute fast alle), musst du mehr tun als „Auth per Token“.

Wichtige Bausteine:

• Rate Limiting für alle API-Routen
• Saubere Token-Lebensdauer (nicht unendlich gültig)
• Scopes/Rollen für jede API-Funktion
• CORS bewusst konfigurieren, nicht einfach * freigeben

Laravel hilft dir da mit Sanctum oder Passport.
Symfony mit API Platform oder JWT-Bundles.

Sobald mehrere Systeme miteinander reden, muss jede offene Tür doppelt geprüft werden.

8. Uploads & Dateien: Ein Bereich, den viele unterschätzen

Datei-Uploads sind ein Risikogebiet.

Was zu beachten ist:

• Uploads niemals direkt im Public-Ordner speichern
• Strikte Dateityp-Checks (MIME + Endung)
• Größe limitieren
• Keine ausführbaren Dateien akzeptieren
• Bilder serverseitig „neu speichern“ (zB. re-encode)

Viele Angriffe beginnen mit einer Datei, die eigentlich nie hätte angenommen werden dürfen.

9. Deployment & Serverebene: Das Framework schützt dich nicht vor schlechten Servern

Sicherheit endet nicht im Framework. Wenn der Server unsauber aufgebaut ist, bringt dir die ganze Arbeit nichts.

Wichtig und immer beachten:

• HTTPS erzwingen
• Firewall-Regeln definieren
• PHP-Version aktuell halten
• Public-Ordner korrekt setzen (alles andere außerhalb der Webroot)
• Rechte minimal halten (z. B. kein „777“, egal wie dringend es wirkt)

Ein Framework ist gut, aber es zaubert keinen sicheren Server.

10. Updates: Kleine Updates wirken harmlos, ignorierst du sie, wirst du es bereuen

Sicherheits-Patches kommen nicht ohne Grund. Grade Laravel und Symfony patchen regelmäßig kleine Lücken.

Guter Rhythmus:

• Abhängigkeiten monatlich prüfen
• Sicherheits-Updates zeitnah einspielen
• Alte Pakete entfernen
• Composer-Audit nutzen (zeigt Schwachstellen an)

Viele Angriffe passieren, weil Projekte auf alten Versionen rumdümpeln.

Fazit: Laravel und Symfony sind stark, aber nur, wenn du es ihnen ermöglichst

Beide Frameworks bringen extrem viel Sicherheit bereits mit. Aber kein Framework ist sicher, wenn man die Features nicht benutzt oder bewusst ignoriert. Es geht nicht darum, paranoid zu werden, sondern strukturiert.

Wenn du:

• sauber validierst,
• deine Auth-Mechanismen nutzt,
• Zugriff klar regelst,
• Datenbankzugriffe im Griff hast,
• Logs schützt,
• Uploads streng behandelst
• und deinen Server ordentlich pflegst,

dann baust du Anwendungen, die nicht nur funktionieren, sondern auch stabil stehen, wenn jemand daran rüttelt. Probiere es mal aus.