Interviewfragen für Application Security Engineer

Nein. Clientseitige Validierung ist reiner UX-Komfort — ein Angreifer kann JavaScript abschalten, die Anfrage im Browser oder in Burp bearbeiten oder die API direkt mit curl aufrufen und sie so vollständig umgehen. Sicherheitsprüfungen (Validierung, Autorisierung, Bereinigung) müssen auf dem Server erzwungen werden, dem einzigen Ort, den du kontrollierst. Der Irrtum ist, den Browser für eine Vertrauensgrenze zu halten; das ist er nicht, denn der Client läuft auf dem Rechner des Angreifers. Clientprüfungen sind toll für schnelles Feedback, nie für Sicherheit.

Gar nicht — kryptografische Hashes sind Einwegfunktionen ohne Inverse. Einen Hash zu „cracken“ heißt, Kandidaten-Eingaben zu raten, jede zu hashen und zu vergleichen (Wörterbuch, Brute Force, Rainbow Tables), und genau deshalb nutzt man langsame, gesalzene Hashes für Passwörter. Es gibt keinen Schlüssel, der einen Hash „entschlüsselt“. Wenn sich etwas entschlüsseln lässt, wurde es verschlüsselt, nicht gehasht — und Base64 ist umkehrbare Kodierung, kein Hashing.

Nein. Das Löschen des Cookies entfernt nur die Anmeldedaten aus deinem Browser — der Session-Datensatz (oder ein noch gültiges JWT) auf dem Server bleibt typischerweise nutzbar, bis er abläuft oder explizit invalidiert wird. Ein Angreifer, der das Token bereits abgegriffen hat, kann es weiter nutzen. Der Irrtum hält das Cookie für die Session selbst; es ist nur ein Zeiger auf serverseitigen Zustand. Echtes Abmelden muss die Session serverseitig invalidieren oder das Token widerrufen und mit kurzer TTL versehen.

Nein. TLS/HTTPS sichert Daten bei der Übertragung zwischen Client und Server; nach dem Empfang werden sie von der App entschlüsselt und im Klartext verarbeitet und dann je nach Datenbankkonfiguration gespeichert. Daten im Ruhezustand zu schützen ist ein eigenes Thema — Datenträger-/Spaltenverschlüsselung, ein KMS und Zugriffskontrolle. „Wir nutzen HTTPS“ mit „unsere gespeicherten Daten sind verschlüsselt“ zu verwechseln ist ein verbreiteter und gefährlicher Irrtum.

Nein. HTTPS verschlüsselt den Kanal, sodass Angreifer den Verkehr unterwegs nicht lesen oder manipulieren können, aber die bösartige Eingabe kommt an, wird entschlüsselt und von deiner App genau wie zuvor verarbeitet. SQL-Injection und XSS sind Fehler der Anwendungsschicht, die durch parametrisierte Abfragen und Output-Encoding behoben werden, nicht durch Transportverschlüsselung. Der Irrtum unterstellt, Verschlüsselung bereinige Inhalte — tut sie nicht; der Angreifer sendet die Payload einfach über die HTTPS-Verbindung.

Nein. POST trägt die Parameter einfach im Anfrage-Body statt in der URL; dieser Body ist Klartext und für jeden, der den Verkehr sieht, voll sichtbar, sofern kein HTTPS genutzt wird. POST ist vorzuziehen für zustandsändernde Aktionen und hält Parameter aus URLs, Logs und Verlauf heraus, bietet aber für sich keine Vertraulichkeit. Der Irrtum verwechselt „nicht in der URL” mit „verschlüsselt” — nur TLS verschlüsselt die Daten beider Methoden bei der Übertragung.

Nein. Ein Salt ist ein eindeutiger Zufallswert, der direkt neben dem Hash gespeichert wird; seine Aufgabe ist es, identische Passwörter unterschiedlich hashen zu lassen und vorberechnete Rainbow Tables zu vereiteln — nicht geheim zu bleiben. Es ist unproblematisch, wenn ein Angreifer, der die Datenbank stiehlt, auch die Salts erhält. Was Passwörter wirklich schützt, ist ein langsamer, gesalzener Hash (bcrypt, scrypt, Argon2). Ein separater, optionaler geheimer „Pepper“ ist ein anderes Konzept.

Grenzenlose Autonomie plus Tool-Zugriff ist die „exzessive Handlungsmacht

Nicht vertrauenswürdiger Inhalt, den das Modell aufnimmt, kann Anweisungen tragen — das ist indirekte Prompt-Injection. Sie können nicht vollständig verhindern, dass das Modell beeinflusst wird, also isolieren Sie abgerufenen Inhalt als Daten, begrenzen Sie die Tools/Berechtigungen des Agenten, verlangen Sie Bestätigung für sensible Aktionen und geben Sie ihm keine Geheimnisse, zu deren Preisgabe er gezwungen werden könnte. Anzunehmen, das Modell ignoriere injizierte Anweisungen einfach, ist genau der ausgenutzte Fehlermodus.

Ein Drittanbieter-Modell ist eine Lieferketten-Abhängigkeit: Prüfen Sie, dass es aus einer vertrauenswürdigen Quelle mit übereinstimmenden Prüfsummen/Signaturen stammt, dass seine Lizenz Ihre Nutzung erlaubt und dass das Dateiformat beim Laden keinen beliebigen Code ausführt (bevorzugen Sie sichere Serialisierung gegenüber Pickle-artigen Formaten). „Es lädt” und „Download-Geschwindigkeit” sagen nichts über Vertrauen aus, und anzunehmen, öffentliche Modelle seien sicher, ignoriert reale Vergiftungs- und Deserialisierungsrisiken.

Das ist die „unsachgemäße Ausgabebehandlung

Kunden-PII an eine externe API zu senden, setzt sie der Verarbeitung und Aufbewahrung durch einen Dritten aus und kann Datenschutzpflichten verletzen. Minimieren und redigieren Sie, was gesendet wird, bestätigen Sie die Nutzungs-/Aufbewahrungsbedingungen des Anbieters und einen Auftragsverarbeitungsvertrag (oder Kein-Training-Garantien), oder wechseln Sie für sensible Daten zu einer privaten Bereitstellung. Die Schlüssellänge ist irrelevant, und mehr PII zu senden erhöht die Exposition.

Wenn der Abruf jedes indexierte Dokument liefert, egal wer fragt, gibt das Modell getreu Daten preis, die der Nutzer nicht sehen sollte — das ist ein Autorisierungsfehler, keine Halluzination. Erzwingen Sie die dokumentbezogenen Berechtigungen des Nutzers zum Zeitpunkt des Abrufs, sodass nur autorisierte Fragmente in den Kontext gelangen. Ein längerer System-Prompt ist umgehbar und implementiert keine Zugriffskontrolle, die Temperatur ist irrelevant, und ein anderes Modell hat dieselbe Lücke.

Das Training auf ungeprüften Nutzerdaten erlaubt einem Angreifer, das Modell zu vergiften — Hintertüren, Trigger oder verzerrtes Verhalten zu implantieren, das später auftaucht. Beherrschen Sie es durch Datenprüfung und -filterung, Herkunftsverfolgung, Anomalieerkennung im Datensatz und Evaluierung des Modellverhaltens nach dem Training. „Mehr Daten ist besser” ignoriert die Integrität, und das eigentliche Problem ist die Vergiftung, nicht Geschwindigkeit oder Speicherplatz.

Passwortspeicherung braucht einen absichtlich langsamen, gesalzenen, speicherharten Hash — bcrypt, scrypt oder Argon2 — damit das Knacken gestohlener Hashes teuer ist und Rainbow Tables nicht greifen. Ein schneller Hash wie SHA-256 lässt sich im großen Maßstab trivial per Brute Force knacken; reversible Verschlüsselung bedeutet, dass eine einzige Schlüsselkompromittierung alle Passwörter auf einmal offenlegt; und Klartext ist unhaltbar, egal wie abgeriegelt die Datenbank ist. Wählen Sie Argon2id (oder bcrypt) mit einem abgestimmten Kostenfaktor und einem einzigartigen Salt pro Benutzer.

Ein Open Redirect in einem Authentifizierungsfluss erlaubt einem Angreifer, einen vertrauenswürdig wirkenden Login-Link zu basteln, der den Benutzer nach der Authentifizierung — und möglicherweise einen Autorisierungscode oder ein Token — an eine vom Angreifer kontrollierte Domain sendet und so Kontoübernahme und überzeugendes Phishing ermöglicht. Beheben Sie es, indem Sie exakte Redirect-URIs serverseitig streng per Allow-List freigeben und alles andere ablehnen. Es ist weder kosmetisch noch ein Performance-Problem, und HTTPS hilft nicht, weil das Ziel des Angreifers ebenfalls eine gültige HTTPS-Site sein kann.

Wenn der Browser das Sitzungs-Cookie automatisch anhängt, kann eine bösartige Seite die Überweisung im Namen des Opfers auslösen — das ist Cross-Site Request Forgery (CSRF). Schützen Sie zustandsändernde Anfragen mit Anti-CSRF-Token und SameSite-Cookies und prüfen Sie den Origin/Referer-Header. Das Cookie beweist die Identität, aber nicht die Absicht, ein Login-CAPTCHA schützt keine bereits authentifizierte Aktion, und HTTPS schützt die Transportvertraulichkeit, nicht die Anfragenfälschung.

Wenn ein Angreifer eine serverseitig ausführbare Datei (oder HTML/SVG) in ein ausgeliefertes Verzeichnis hochladen kann, kann er Remote Code Execution oder Stored-XSS erreichen. Validieren Sie den echten Inhaltstyp, speichern Sie Uploads außerhalb des Web-Roots oder in einem nicht ausführenden Speicher, randomisieren Sie Dateinamen und liefern Sie sie so aus, dass sie weder ausgeführt noch als Markup interpretiert werden. Langsamere Seitenladezeiten und Speicherplatz sind Betriebsfragen, nicht das hier ausgenutzte Sicherheitsrisiko.

Das serverseitige Abrufen von durch Angreifer kontrollierten URLs ist Server-Side Request Forgery (SSRF): Es ermöglicht den Zugriff auf interne Dienste oder den Cloud-Metadaten-Endpunkt, um Zugangsdaten zu stehlen. Mildern Sie es durch eine Allow-List erlaubter Hosts und Schemata, das Sperren privater und Link-Local-Bereiche (mit erneuter Prüfung nach jeder Weiterleitung) und das Härten des Metadatenzugriffs mit IMDSv2. Zu sagen, es gebe kein Risiko, ignoriert den Zugriff, den die Anfrage gewährt, und ein Lade-Spinner oder Caching ändert nichts daran, wohin der Server sich verbinden darf.

Das ist fehlerhafte Zugriffskontrolle (IDOR): Der Server prüft nicht, ob der authentifizierte Benutzer auf das angeforderte Objekt zugreifen darf. Die Behebung ist eine objektbezogene Autorisierung, die serverseitig bei jeder Anfrage erzwungen wird. Das Bereinigen der Zahl belegt keine Eigentümerschaft. Das Verschlüsseln oder Verschleiern der ID ist Obskurität und bleibt erratbar, leakbar oder wiederholbar. Die HTTP-Methode ist für die Autorisierung irrelevant. Prüfe stets das Recht des Aufrufers auf das konkrete Objekt, bevor du es zurückgibst.

`alg: none` erlaubt jedem, ein gültig aussehendes, unsigniertes Token zu fälschen und sich als beliebiger Benutzer auszugeben — eine vollständige Authentifizierungsumgehung, kein Nebenfund. Behebe es, indem du serverseitig eine Allow-Liste der erwarteten Algorithmen führst und die Signatur stets mit dem richtigen Schlüssel prüfst; vertraue niemals dem alg-Header des Tokens für die Wahl der Prüfmethode. Längere Gültigkeit oder ein anderer Speicherort ändert nichts an gefälschten, unsignierten Tokens. Es ist kritisch und ausnutzbar, also ist Dokumentieren keine Behebung.

Prompt Injection lässt sich nicht vollständig mit mehr Prompt-Text lösen; nimm an, dass das Modell unterwandert werden kann, und begrenze, was es TUN darf. Gib Tools least privilege, sichere wirkungsstarke Aktionen mit menschlicher Bestätigung ab und validiere oder sandboxe Tool-Aufrufe vor dem Handeln (OWASP LLM „Excessive Agency“ und „Improper Output Handling“). Im System-Prompt zu flehen ist umgehbar. Höhere Temperature fügt nur Zufall hinzu, und reines Logging hält den Schaden fest, ohne die injizierte Aktion zu verhindern.

Das ist eine Mass-Assignment-Schwachstelle (Over-Posting): Der Server mappt das Client-JSON blind auf sensible Modellfelder. Behebe es, indem du nur eine explizite Allow-Liste erlaubter Felder bindest (DTOs / Strong Params), sodass privilegierte Attribute wie isAdmin nicht vom Client gesetzt werden können. Das Feld im Frontend zu verstecken und clientseitige Validierung werden beide mit einer rohen Anfrage umgangen. isAdmin umzubenennen ist Obskurität, leicht zu entdecken. Steuere serverseitig, welche Felder gebunden werden.

Parametrisierte Abfragen sind die eigentliche Behebung: Sie trennen Code von Daten, sodass Benutzereingaben stets als Wert behandelt werden, niemals als SQL, das die Abfragestruktur ändern kann. Manuelles Escaping ist fehleranfällig und je nach Kodierung und Dialekt umgehbar. Ein WAF ist eine kompensierende Maßnahme, keine Behebung, und Kodierungstricks hebeln es aus. Eine Längenprüfung stoppt Injection überhaupt nicht. Behebe es auf der Abfrageebene.

Stored XSS wird behoben, indem Daten für den genauen Kontext kodiert werden, in dem sie gerendert werden (HTML-Body, Attribut, JavaScript, URL), sodass der Browser sie als Text behandelt, mit einer Content-Security-Policy als zweiter Schicht. Das Wort „script“ auf eine Blacklist zu setzen, wird trivial über Event-Handler, gemischte Groß-/Kleinschreibung und Kodierungen umgangen. Du kannst deine Benutzer nicht zwingen, JavaScript zu deaktivieren. Benutzer zu bitten, kein HTML einzugeben, ist keine durchsetzbare Maßnahme. Kodiere bei der Ausgabe, bei jedem Rendern.

Transitiver Code läuft in deiner Anwendung, also ist eine kritische CVE dein Risiko. Bewerte, ob der verwundbare Codepfad tatsächlich erreichbar ist, dann behebe durch Anheben oder Überschreiben der Version (oder Mitigation) und verifiziere in Produktion. Sie zu ignorieren, weil sie transitiv ist, lässt eine bekannte Lücke offen, die ein Angreifer ausnutzen kann. Die Warnung zu unterdrücken verbirgt nur das Signal. node_modules neu zu installieren zieht dieselbe verwundbare Version. Verfolge sie über SCA, bringe sie nicht zum Schweigen.

Bedrohungsmodellierung ist in der Designphase am günstigsten und wirksamsten, bevor Code Entscheidungen festzurrt: gehe die Datenflüsse durch, zähle Bedrohungen mit einem Rahmenwerk wie STRIDE auf, baue Gegenmaßnahmen ein und überarbeite sie, während sich das Design entwickelt. Sie erst nach einem Vorfall oder beim jährlichen Pentest zu machen, findet Probleme, wenn sie teuer zu beheben und bereits exponiert sind. Und sich auf „sorgfältige Entwickler" zu verlassen ist Hoffnung, keine wiederholbare, prüfbare Kontrolle.

Geheimnisse gehören in einen verwalteten Speicher mit Zugriffskontrolle, Audit und Rotation, zur Laufzeit injiziert – niemals in die Versionskontrolle eingecheckt. Nutze einen Secrets Manager (AWS Secrets Manager, HashiCorp Vault) und entferne die eingecheckten Werte aus der Historie, dann rotiere sie, weil sie als kompromittiert gelten müssen. Base64 ist Kodierung, kein Schutz – jeder kann es dekodieren. Ein privates Repo verteilt das Geheimnis weiterhin an alle mit Clone-Zugriff sowie an CI-Systeme und Forks. Es ins Binary zu kompilieren versteckt nur ein Geheimnis, das weiterhin trivial extrahierbar ist.

Sensible Daten sollten niemals in Logs gelangen: redigiere oder maskiere zuerst an der Quelle, um die Blutung zu stoppen, behebe dann die historischen Logs und verschärfe die Zugriffe. PCI DSS verbietet, vollständige PANs und CVVs so zu speichern, und Passwörter sollten überhaupt nie protokolliert werden. „Interne" Logs sind weiterhin ein erstrangiges Angriffsziel. Den Speicher zu verschlüsseln oder mit ACLs zu versehen lässt trotzdem Klartext-Geheimnisse in den Logs liegen, lesbar für jeden mit Lesezugriff — Backups, SIEM-Pipelines und Administratoren sehen sie alle.

Direkte Prompt Injection liegt vor, wenn ein Nutzer gegnerische Anweisungen direkt in den Prompt tippt, um den System-Prompt oder Sicherheitsregeln zu überschreiben. Indirekte Prompt Injection verbirgt bösartige Anweisungen in externen Inhalten, die das Modell später einliest — eine Webseite, eine E-Mail, ein PDF oder ein RAG-Dokument —, sodass der Angriff auslöst, ohne dass das Opfer ihn je tippt. Indirekte Injection ist das größere Risiko, weil Angreifer und Opfer verschiedene Personen sind und die Payload in Daten mitreist, denen die App implizit vertraut.

Unsichere Ausgabeverarbeitung bedeutet, dem zu vertrauen, was das Modell zurückgibt, und es ohne Validierung oder Codierung an ein nachgelagertes System weiterzureichen. Weil die Modellausgabe von Angreifern beeinflussbar ist, führt das Rendern als rohes HTML zu XSS, das Einspeisen in einen URL-Fetcher zu SSRF und das Übergeben an eine Shell oder SQL-Abfrage zu Command- oder SQL-Injection. Die Lösung ist, die Modellausgabe genauso wie nicht vertrauenswürdige Benutzereingaben zu behandeln: kontextbewusste Ausgabecodierung, Allowlisting, Sanitization und Parametrisierung, bevor sie einen Sink erreicht.

Ein Jailbreak zielt auf das Sicherheits-Alignment des Modells: Er bringt das Modell dazu, Inhalte zu erzeugen, die der Anbieter zu verbieten versuchte, etwa schädliche Anleitungen. Prompt Injection zielt auf die Anweisungshierarchie der Anwendung: Sie überschreibt den System-Prompt des Entwicklers oder kapert das Verhalten des Modells innerhalb einer App, oft über nicht vertrauenswürdige Daten. Jailbreaks greifen das Modell an; Prompt Injection greift das umgebende System an. Sie überschneiden sich, aber das Ziel und die überschrittene Vertrauensgrenze unterscheiden sich.

Die LLM-Supply-Chain umfasst Basismodelle, fine-getunte Varianten, Datensätze, Embeddings, Plugins, Bibliotheken und die Hosting-Plattform — jede davon ein Punkt, an dem Risiko entstehen kann. Zu den Bedrohungen zählen das Herunterladen manipulierter oder mit Backdoors versehener Modellgewichte, bösartige Fine-Tunes, vergiftete oder lizenzbelastete Datensätze, anfällige oder überberechtigte Plugins sowie typosquattete Modell-Repos. Verteidigung: Modelle aus vertrauenswürdigen Registries beziehen, Integrität und Provenienz prüfen, eine AI Bill of Materials pflegen, Abhängigkeiten scannen und pinnen, Plugins prüfen und das Least-Privilege-Prinzip auf alles anwenden, mit dem das Modell integriert wird.

Die OWASP Top 10 für LLM-Anwendungen sind die Konsensliste der kritischsten Risiken beim Entwickeln mit großen Sprachmodellen. Die Ausgabe 2025 umfasst Prompt Injection, Offenlegung sensibler Informationen, Supply Chain, Daten- und Modellvergiftung, unsichere Ausgabeverarbeitung, übermäßige Handlungsvollmacht, Leakage von System-Prompts, Schwachstellen in Vektoren und Embeddings, Fehlinformation sowie unbegrenzten Ressourcenverbrauch. Sie existiert, weil klassische AppSec-Listen die LLM-spezifischen Fehlerbilder nicht erfassen, und gibt Teams ein gemeinsames Vokabular sowie eine Checkliste, um Maßnahmen zu priorisieren.

RAG-Sicherheit bedeutet, jedes abgerufene Dokument als nicht vertrauenswürdige Eingabe zu behandeln. Zentrale Risiken: indirekte Prompt Injection, die in abgerufenen Inhalten versteckt ist, Vergiftung der Wissensbasis oder der Embeddings sowie fehlende benutzerbezogene Autorisierung, sodass das Modell Daten zurückgibt, auf die der Benutzer keinen Zugriff hat. Zu den Verteidigungsmaßnahmen zählen Zugriffskontrolle beim Retrieval, Inhaltsprovenienz und Prüfung der Ingestion, Behandeln von abgerufenem Text als Daten statt als Anweisungen, Ausgabevalidierung und Isolierung der Vektordatenbank pro Mandant.

Ein LLM-Agent verwandelt Text über Tools und Function Calls in Aktionen, sodass eine Prompt Injection zu einer realen Aktion wird — das Risiko übermäßiger Handlungsvollmacht. Sichere ihn ab, indem du jedem Tool das geringste benötigte Privileg und den engsten Geltungsbereich gibst, Tool-Argumente validierst und einschränkst, menschliche Bestätigung für sensible oder irreversible Aktionen verlangst, die Ausführung sandboxt, Aufrufe rate-limitierst und budgetierst und jeden Tool-Aufruf protokollierst. Lass niemals zu, dass die von nicht vertrauenswürdigen Daten beeinflusste Ausgabe des Modells direkt eine folgenschwere Aktion autorisiert.

LLM-Apps geben Daten auf mehrere Arten preis: Das Modell memoriert und gibt sensible Trainings- oder Fine-Tuning-Daten wieder, der System-Prompt (der Geheimnisse oder Logik enthalten kann) wird extrahiert, abgerufene RAG-Dokumente legen Daten offen, die der Benutzer nicht sehen sollte, und Kontext aus einer Benutzer- oder Sitzung blutet in eine andere über. Vorbeugung bedeutet Datenminimierung vor dem Training, niemals Geheimnisse in Prompts, das Erzwingen benutzerbezogener Autorisierung beim Retrieval, Ausgabefilterung und PII-Redaktion sowie Mandantenisolierung.

Trainingsdaten-Vergiftung liegt vor, wenn ein Angreifer die Daten manipuliert, die zum Pre-Training, Fine-Tuning oder Einbetten eines Modells verwendet werden, sodass das resultierende Modell sich bösartig verhält — durch Einbetten eines Backdoor-Triggers, Einschleusen von Verzerrungen oder Verschlechtern der Genauigkeit. Es nutzt aus, dass Modelle große, oft aus dem Web stammende Datensätze scrapen und ihnen vertrauen. Zu den Verteidigungsmaßnahmen zählen das Kuratieren und Signieren von Datenquellen, Provenienz- und Integritätsprüfungen, Anomalieerkennung in Trainingsdaten, Datensatz-Versionierung und das Beschränken, wer zu Trainings- und RAG-Korpora beitragen darf.

Betten Sie Sicherheit in jede SDLC-Phase ein, statt am Ende zu testen: Anforderungen umfassen Sicherheits- und Datenschutzanforderungen, das Design umfasst Bedrohungsmodellierung, die Entwicklung folgt sicheren Codierstandards mit SAST, das Testen ergänzt DAST und Reviews, und das Release erfordert eine Freigabe — alles gesteuert durch Richtlinie, Funktionstrennung und Änderungskontrolle. Fehler früh zu beheben ist drastisch günstiger als nach dem Release.

Beginne mit einem minimalen, vertrauenswürdigen Basis-Image (distroless oder slim), um die Angriffsfläche zu verkleinern, scanne Images in der CI und in der Registry auf bekannte CVEs, fixiere und verifiziere Image-Digests, führe als Nicht-Root-Benutzer aus und vermeide es, Secrets einzubacken. Signiere Images und erzwinge Admission-Richtlinien, sodass nur gescannte, signierte Images laufen. Baue regelmäßig neu, damit gepatchte Basis-Layer durchfließen.

RBAC steuert, was Identitäten gegen die Kubernetes-API tun können — Roles und ClusterRoles gewähren Verben auf Ressourcen, über RoleBindings an Subjekte gebunden — und sollte geringste Rechte befolgen, indem cluster-admin und Wildcards vermieden werden. Network Policies steuern den Pod-zu-Pod-Verkehr, der standardmäßig alles erlaubt, bis du ein Default-Deny anwendest und dann erforderliche Flüsse explizit zulässt. Zusammen begrenzen sie den Wirkungsradius, wenn ein Pod oder Token kompromittiert wird.

Speichere Secrets in einem dedizierten verwalteten Dienst (Secrets Manager, Parameter Store, Vault), verschlüsselt mit einem KMS-Schlüssel, und gewähre den Zugriff über IAM-Rollen, sodass Workloads sie zur Laufzeit mit kurzlebigen Anmeldedaten abrufen. Backe Secrets niemals in Code, Container-Images oder eingecheckte .env-Dateien ein. Füge automatische Rotation, eingegrenzte Schlüsselrichtlinien und Audit-Logging hinzu, sodass jeder Abruf nachvollziehbar ist.

CI/CD ist hochwertig, weil sie Deployment-Anmeldedaten hält und nicht vertrauenswürdigen Code ausführt. Risiken umfassen kompromittierte Abhängigkeiten und Build-Actions, geleakte oder zu weit gefasste Secrets, veränderliche Drittanbieter-Actions sowie überprivilegierte Runner oder OIDC-Vertrauen. Reduziere sie mit fixierten und verifizierten Abhängigkeiten, kurzlebiger OIDC-Föderation statt langlebiger Schlüssel, geringsten Rechten eingegrenzt auf konkrete Repos/Branches, isolierten ephemeren Runnern und signierten Artefakten mit nachverfolgter Provenienz (SLSA).

Eine digitale Signatur ist der mit dem privaten Schlüssel des Unterzeichners umgewandelte Hash einer Nachricht. Der Prüfer berechnet den Hash neu, wendet den öffentlichen Schlüssel des Unterzeichners an und prüft auf Übereinstimmung. Da nur der Unterzeichner den privaten Schlüssel besitzt, beweist eine gültige Signatur, dass die Nachricht von ihm stammt (Authentizität), nicht verändert wurde (Integrität) und dass er es nicht glaubhaft abstreiten kann (Nichtabstreitbarkeit).

Ein HMAC ist ein schlüsselbasierter Nachrichtenauthentifizierungscode: Er hasht die Nachricht zusammen mit einem geheimen Schlüssel über eine verschachtelte Konstruktion (innerer und äußerer Hash mit schlüsselabgeleiteten Pads). Er beweist sowohl Integrität (die Nachricht wurde nicht verändert) als auch Authentizität (sie stammt von jemandem mit dem Schlüssel). Ein einfacher Hash beweist keines von beiden, da ihn jeder neu berechnen kann; HMAC widersteht zudem Length-Extension-Angriffen.

Ein JWT besteht aus drei base64url-Teilen – Header, Payload (Claims) und Signatur – durch Punkte verbunden. Der Server signiert Header und Payload mit einem Geheimnis oder privaten Schlüssel und verifiziert diese Signatur bei jeder Anfrage, um den Claims ohne serverseitigen Sitzungszustand zu vertrauen. Fallstricke: alg=none akzeptieren, RS256-zu-HS256-Schlüsselverwechslung, Ablauf/Aussteller/Zielgruppe nicht zu validieren, Geheimnisse in die lesbare Payload zu legen und keinen Widerrufsweg zu haben.

Die App leitet den Benutzer zum Autorisierungsserver weiter, um sich anzumelden und einzuwilligen. Der Server leitet mit einem kurzlebigen Autorisierungscode zurück. Das Backend der App tauscht diesen Code (plus sein Client-Geheimnis) dann am Token-Endpunkt über einen Server-zu-Server-Back-Channel gegen ein Access-Token. Das hält Tokens aus Browser/URL fern. Öffentliche Clients ergänzen PKCE, um den Code an den ursprünglichen Anforderer zu binden.

Speichere Passwörter mit einer bewusst langsamen, gesalzenen, adaptiven Passwort-Hashfunktion – bcrypt, scrypt oder Argon2 – nie mit einem schnellen Allzweck-Hash wie SHA-256 oder MD5. Schnelle Hashes sind auf Geschwindigkeit ausgelegt, sodass Angreifer mit GPUs Milliarden Versuche pro Sekunde gegen eine geleakte Datenbank testen können. Langsame Hashes haben einen einstellbaren Arbeitsfaktor (und Speicherkosten), der jeden Versuch teuer macht und Brute Force selbst nach einem Leak unpraktikabel hält.

Ein Salt ist ein einzigartiger Zufallswert, der pro Benutzer erzeugt und vor dem Hashing mit dem Passwort kombiniert wird. Er sorgt dafür, dass identische Passwörter unterschiedliche Hashes ergeben, und macht vorberechnete Angriffe wie Rainbow Tables nutzlos, da der Angreifer pro Salt eine eigene Tabelle bräuchte. Salts werden neben dem Hash gespeichert. Ein Pepper ist ein zusätzlicher geheimer Wert, für alle Benutzer gleich, getrennt aufbewahrt (z. B. in der App-Konfiguration oder einem HSM), sodass ein Datenbankleck allein nicht genügt.

TOTP (Time-based One-Time Password) kombiniert ein bei der Einrichtung festgelegtes gemeinsames Geheimnis mit der aktuellen, in feste Fenster (meist 30 Sekunden) unterteilten Zeit. Es führt HMAC über den Zeitschritt-Zähler mit dem Geheimnis aus und kürzt das Ergebnis dann auf einen 6-stelligen Code. Sowohl App als auch Server halten dasselbe Geheimnis und dieselbe Uhr, sodass sie unabhängig denselben Code berechnen – ohne Netzwerkaufruf. Der Code wechselt mit jedem Fenster.

Die Signierung bindet ein Artefakt kryptografisch an seinen Hersteller, sodass Konsumenten überprüfen können, dass es nicht manipuliert oder ausgetauscht wurde. Die Provenienz sind signierte Metadaten, die beschreiben, wie, wo und aus welcher Quelle das Artefakt gebaut wurde. Zusammen — über Tools wie Sigstore für schlüssellose Signierung und das SLSA-Framework für Provenienzstufen — ermöglichen sie es einem Deployer zu überprüfen, dass ein Image aus der erwarteten Pipeline und Quelle stammt, und vereiteln so Manipulation und Angriffe durch Abhängigkeitssubstitution.

Scannen Sie Images auf bekannte CVEs in OS-Paketen und App-Bibliotheken sowie auf Fehlkonfigurationen und eingebettete Secrets, sowohl zur Build-Zeit als auch fortlaufend in der Registry — weil neue CVEs auftauchen, nachdem ein Image gebaut wurde. Verwenden Sie minimale oder distroless Basis-Images, um die Angriffsfläche zu verkleinern, pinnen und referenzieren Sie Basis-Images per Digest und führen Sie den Container als Nicht-Root aus. Scannen ist notwendig, ersetzt aber nicht den Laufzeitschutz.

Lockfiles pinnen exakte Abhängigkeitsversionen und Hashes, sodass jeder Build dieselben verifizierten Bytes auflöst — das macht Builds reproduzierbar und blockiert stille bösartige Updates. Pinning per Digest, das Prüfen von Integritäts-Hashes und das Scoping interner Pakete auf eine private Registry schützen zudem vor Dependency Confusion, bei der ein Angreifer ein öffentliches Paket mit höherer Version veröffentlicht, das einem internen Namen entspricht, um die Auflösung zu kapern. Das Prinzip: Den Build niemals still ungeprüften Code ziehen lassen.

IaC-Scanning analysiert Terraform-, CloudFormation-, Kubernetes- und ähnliche Definitionen statisch gegen eine Richtlinie, um Fehlkonfigurationen zu finden — öffentliche S3-Buckets, offene Security Groups, fehlende Verschlüsselung — bevor sie überhaupt bereitgestellt werden. Da dieselbe Vorlage viele Ressourcen bereitstellt, verhindert eine einmalige Korrektur wiederkehrende Drift, und das Erkennen vor dem Anwenden ist weitaus günstiger als das Beheben aktiver Cloud-Ressourcen. Zu den Tools gehören Checkov, tfsec und KICS, idealerweise als Policy-as-Code-Gates durchgesetzt.

SAST liest den Quellcode, ohne ihn auszuführen, und findet Fehler wie Injection-Sinks früh, aber mit vielen Fehlalarmen. DAST greift die laufende Anwendung von außen ohne Code-Einblick an und findet echte ausnutzbare Probleme, aber spät und mit oberflächlicher Abdeckung. IAST instrumentiert die laufende Anwendung, um Laufzeitverhalten mit dem Code zu korrelieren, und liefert präzise Ergebnisse mit Code-Kontext, benötigt aber eine ausgeübte Anwendung und Agent-Unterstützung.

Setzen Sie auf Defense in Depth: Pre-Commit-Hooks (z. B. gitleaks) fangen Secrets ab, bevor sie landen, serverseitiges CI-Scanning fängt, was durchrutscht, und regelmäßige Scans des gesamten Verlaufs finden alte Lecks. Entscheidend: Ein Secret, das ein Remote-Repository erreicht hat, muss als kompromittiert behandelt und rotiert werden — den Commit zu löschen hilft nicht, da es im Verlauf, in Forks und Logs lebt. Kombinieren Sie das mit einem echten Secrets-Manager, damit Secrets gar nicht erst im Code stehen.

Brich den Build nur bei hochgradig zuverlässigen, schwerwiegenden, neu eingeführten Befunden; warne (blockiere nicht) bei allem anderen, damit Entwickler dem Gate weiter vertrauen. Manage False Positives mit getunten Regeln, Baselining bereits bestehender Probleme und dokumentierten, befristeten, geprüften Unterdrückungen statt Scanner zu deaktivieren. Ein Gate, das ständig fälschlich Alarm schlägt, wird ignoriert oder umgangen — Signalqualität ist also das Ganze.

Shift-Left bedeutet, Sicherheit nach vorn zu verlagern — ins Design, in die IDE und in den Pull Request —, wo Probleme billiger zu beheben sind als in der Produktion. Du vermeidest es, Entwickler zu blockieren, indem du den sicheren Pfad zum einfachen Pfad machst: schnelles kontextbezogenes Feedback, Gates mit wenigen False Positives, die nur bei schwerwiegenden neuen Problemen hart fehlschlagen, sichere Defaults und Paved-Road-Templates und das Behandeln von Sicherheit als Ermöglicher statt als spätes Veto.

SCA inventarisiert die Open-Source- und Drittanbieter-Komponenten, die eine Anwendung einbindet — einschließlich transitiver Abhängigkeiten — und markiert jene mit bekannten CVEs oder problematischen Lizenzen. Sie ist wichtig, weil der meiste moderne Code aus Abhängigkeiten besteht, die du nicht geschrieben hast, und ein einziges anfälliges transitives Paket (wie Log4j) die gesamte App gefährden kann. Gute SCA priorisiert nach Erreichbarkeit und Ausnutzbarkeit, nicht nur nach reinen CVE-Zahlen.

Ein SBOM ist ein maschinenlesbares Inventar jeder Komponente, Bibliothek und Abhängigkeit in einer Software, mit Versionen und idealerweise Hashes. Es ist wichtig, weil man bei einer neuen Schwachstelle seine SBOMs abfragen kann, um sofort zu beantworten «Sind wir betroffen und wo?», statt in Hektik zu verfallen. Die beiden dominierenden Standards sind SPDX und CycloneDX, und SBOMs werden zunehmend durch Regulierung und Beschaffung gefordert.

Kodierung (wie Base64) ist eine reversible Formatänderung ohne Geheimnis — keine Sicherheit. Verschlüsselung ist mit einem Schlüssel reversibel und schützt die Vertraulichkeit. Hashing ist eine Einwegfunktion, die einen Digest fester Länge erzeugt, für Integritätsprüfungen und Passwortspeicherung verwendet wird und nicht zur Eingabe zurückgerechnet werden kann.

Es bestätigt XSS. Wenn alert() überhaupt ausgelöst hat, hat der Browser Ihr eingeschleustes JavaScript im Seitenkontext geparst und ausgeführt — das ist die Schwachstelle. Ein leeres Popup bedeutet nur, dass das übergebene String-Argument nicht wie erwartet angezeigt wurde (Anführungszeichen-Behandlung, Kodierung oder Kontext-Verstümmelung haben die Nachricht zerstört), nicht dass die Payload blockiert wird. Der Ausführungspunkt ist aktiv; von hier aus verfeinern Sie die Payload.

Zuerst komprimieren, dann verschlüsseln. Gute Verschlüsselung erzeugt eine Ausgabe, die statistisch nicht von Zufall zu unterscheiden ist, sodass im Chiffretext keine Muster mehr zum Komprimieren übrig bleiben — danach zu komprimieren ist sinnlos. Der wichtige Vorbehalt: geheime und vom Angreifer kontrollierte Daten vor der Verschlüsselung gemeinsam zu komprimieren kann über die Chiffretext-Länge Informationen verraten, genau das sind die Angriffe CRIME und BREACH.

Nein. CORS ist keine Abwehr gegen CSRF — es lockert tatsächlich die Same-Origin-Policy, damit eine Seite Cross-Origin-Antworten lesen kann, die sie sonst nicht lesen dürfte. CSRF muss die Antwort nicht lesen; es genügt, dass der Browser des Opfers eine authentifizierte zustandsändernde Anfrage sendet. Die echten Abwehrmechanismen sind Anti-CSRF-Tokens, das SameSite-Cookie-Attribut und das Prüfen von Origin/Referer.

Kodierung wandelt Daten zur Kompatibilität in ein anderes Format um und ist von jedem ohne Schlüssel vollständig umkehrbar (z. B. Base64, URL-Kodierung) — sie bietet keine Vertraulichkeit. Verschlüsselung ist nur mit einem Schlüssel umkehrbar und sorgt für Vertraulichkeit. Hashing ist eine Einwegfunktion: Man kann die Eingabe nicht aus der Ausgabe wiederherstellen, weshalb es sich für Integritätsprüfungen und die Passwortspeicherung eignet (mit Salt und einer langsamen KDF).

Weil sie schnell sind. MD5 und SHA-256 sind auf Geschwindigkeit ausgelegt, was für Passwörter genau falsch ist: Ein Angreifer, der die Hashes stiehlt, kann auf einer GPU Milliarden von Versuchen pro Sekunde berechnen. Die Lösung ist eine bewusst langsame, speicherharte Schlüsselableitungsfunktion — bcrypt, scrypt oder Argon2 — kombiniert mit einem Salt pro Nutzer und einem einstellbaren Arbeitsfaktor.

Der WSTG ist eine checklistengestützte Methodik, die eine App durch Testkategorien führt: Informationsbeschaffung, Konfiguration und Deployment, Identität und Authentifizierung, Autorisierung, Session-Management, Eingabevalidierung (Injection/XSS), Fehlerbehandlung, Kryptografie, Geschäftslogik und Client-seitig. Er bietet systematische Abdeckung mit stabilen Test-IDs, sodass Befunde reproduzierbar sind und nichts Offensichtliches übersprungen wird.

Beginnen Sie damit, das Bedrohungsmodell der App zu verstehen und wo sie nicht vertrauenswürdige Eingaben, Geheimnisse, Authentifizierung und Autorisierung verarbeitet. Nutzen Sie SAST zum breiten Scannen und DAST gegen die laufende App, behandeln Sie die Tool-Ausgabe aber als Hinweise, nicht als Befunde — sortieren Sie False Positives aus. Verwenden Sie dann die menschliche Zeit auf die wertvollen, kontextabhängigen Bereiche, die Tools verpassen: Autorisierungslogik, Geschäftslogik, Krypto-Nutzung und Vertrauensgrenzen. Verfolgen Sie den Datenfluss von der Source bis zum Sink.

Ein sicherer SDLC bettet Sicherheit in jede Phase ein, statt am Ende zu testen: Anforderungen (Sicherheits- und Missbrauchsfälle), Design (Threat Modeling), Implementierung (sichere Coding-Standards, SAST/SCA in der IDE und CI), Test (DAST, Pentest), Release (Gates und Freigabe) und Betrieb (Monitoring, Patching, Feedback). Shift-Left verlagert Defekte nach vorne, wo sie billig zu beheben sind; Reifegradmodelle wie OWASP SAMM und BSIMM messen, wie gut man es tatsächlich tut.

Threat Modeling beantwortet vier Fragen: Was bauen wir, was kann schiefgehen, was tun wir dagegen und haben wir gute Arbeit geleistet. Sie diagrammieren das System (oft ein Datenflussdiagramm mit Vertrauensgrenzen), zählen Bedrohungen mit einem Framework wie STRIDE auf, priorisieren nach Risiko und weisen Gegenmaßnahmen zu. PASTA fügt eine risiko- und angreiferzentrierte Note hinzu; Angriffsbäume zerlegen ein einzelnes Ziel. Es zur Designzeit zu tun ist weit billiger, als Produktion zu patchen.

Ein Forward-Proxy steht vor den Clients und stellt ausgehende Anfragen in deren Namen — für Egress-Kontrolle, Filterung, Caching und Anonymität. Ein Reverse-Proxy steht vor den Servern und empfängt eingehende Anfragen in deren Namen — für Lastausgleich, TLS-Terminierung, Caching und als Sicherheitsfassade für eine WAF. Die Richtung, in die er zeigt, clientseitig oder serverseitig, ist die entscheidende Unterscheidung.

Bestimme den Stack aus Headern und Quellcode, dann brute-force Verzeichnisse und Dateien mit gobuster oder feroxbuster unter Nutzung einer guten Wortliste und relevanter Endungen. Suche nach Admin-Panels, Backups, Konfigurationsdateien und Upload-Punkten und prüfe virtuelle Hosts, wenn die Seite auf einen Hostnamen reagiert.

Einzeln legt SQLi Daten offen oder verändert sie und kann RCE erreichen; Stored XSS kapert Sitzungen im Browser der Opfer. Verkettet können Sie SQLi nutzen, um eine Stored-XSS-Payload zu platzieren, die in der Sitzung eines Admins ausgelöst wird, dessen Sitzung zu stehlen und zur vollständigen Anwendungskontrolle zu eskalieren.

Verschlüsselung ist umkehrbar – mit dem Schlüssel erhältst du den Klartext zurück; sie schützt die Vertraulichkeit. Hashing ist eine Einwegfunktion, die einen Digest fester Größe erzeugt, den man nicht umkehren kann; es verifiziert Integrität und Identität. Passwörter sollten mit einem langsamen, gesalzenen Algorithmus wie bcrypt oder Argon2 gehasht, niemals verschlüsselt werden.

Secrets niemals fest im Quellcode codieren oder in Git committen. In einem dedizierten Secrets Manager oder Vault speichern, zur Laufzeit injizieren, den Zugriff mit geringsten Rechten begrenzen, regelmäßig rotieren und kurzlebige dynamische Anmeldeinformationen langlebigen statischen vorziehen. Jeden Zugriff auditieren.

Ein sicherer SDLC verankert Sicherheit in jeder Phase, statt sie am Ende anzuflanschen. Anforderungen umfassen Sicherheits- und Missbrauchsfälle, Design ergänzt Threat Modeling, Entwicklung nutzt sicheres Coding und SAST plus Dependency Scanning, Tests ergänzen DAST und Penetrationstests, und Betrieb ergänzt Monitoring, Patching und Incident Response – Sicherheit nach links verlagert.

Überall TLS erzwingen, jede Anfrage authentifizieren (z. B. OAuth2/OIDC-Tokens) und pro Objekt autorisieren, sodass Benutzer nur ihre eigenen Daten erreichen. Eingabevalidierung, Rate Limiting und Kontingente, Schemavalidierung sowie gründliches Logging ergänzen. Der häufigste API-Fehler ist gebrochene objektbezogene Autorisierung, also prüfe bei jedem Ressourcenzugriff die Eigentümerschaft.

Content-Security-Policy ist ein HTTP-Antwort-Header, der dem Browser mitteilt, welche Quellen von Skripten, Stilen, Bildern und anderen Inhalten auf einer Seite geladen und ausgeführt werden dürfen. Indem sie Inline-Skripte und nicht vertrauenswürdige Quellen untersagt — idealerweise über Nonces oder Hashes — dient sie als Defense-in-Depth-Absicherung, die eingeschleuste XSS-Payloads neutralisiert, selbst wenn eine durchrutscht.

CSRF bringt den Browser eines angemeldeten Nutzers dazu, eine zustandsändernde Anfrage an eine Website zu senden, bei der er authentifiziert ist, und nutzt dabei aus, dass Cookies automatisch mitgesendet werden. Verhindert wird es mit Anti-CSRF-Tokens (ein geheimer Wert pro Sitzung, den der Angreifer weder lesen noch erraten kann) und dem SameSite-Cookie-Attribut, das verhindert, dass Cookies bei Cross-Site-Anfragen mitgeschickt werden.

Die OWASP Top 10 sind ein von der Community getragenes Bewusstseinsdokument, das die kritischsten Sicherheitsrisiken von Webanwendungen einstuft und alle paar Jahre auf Basis realer Daten aktualisiert wird. Es ist weder eine Checkliste noch ein Standard, sondern ein Ausgangspunkt — aktuelle Einträge sind unter anderem fehlerhafte Zugriffskontrolle (Nr. 1), kryptografische Fehler, Injection und unsicheres Design.

Speichere Passwörter niemals im Klartext oder umkehrbar verschlüsselt und niemals mit schnellen Allzweck-Hashes wie MD5 oder SHA-256. Verwende eine langsame, speicherintensive Passwort-Hashfunktion — Argon2id (bevorzugt) oder bcrypt — mit einem eindeutigen Zufalls-Salt pro Passwort und einem abgestimmten Arbeitsfaktor, sodass ein Angreifer, der die Datenbank stiehlt, die Hashes nicht realistisch knacken kann.

Prepared Statements senden zuerst die Abfragevorlage mit Platzhaltern an die Datenbank, sodass die Struktur feststeht, bevor irgendwelche Nutzerdaten eintreffen. Parameter werden danach als reine Daten gebunden und können niemals als SQL geparst werden — eine Eingabe wie ' OR 1=1 wird also als Zeichenkettenliteral behandelt, nicht als Code. Diese Trennung ist die kanonische, zuverlässige Lösung gegen Injection.

Die primäre Verteidigung ist kontextbezogene Ausgabecodierung — nicht vertrauenswürdige Daten genau für die Stelle codieren, an der sie landen (HTML-Körper, Attribut, JavaScript, URL). Kombiniere das mit sicheren DOM-APIs (textContent statt innerHTML), dem automatischen Escaping von Frameworks, Eingabevalidierung und einer Content-Security-Policy als Defense-in-Depth-Absicherung, die begrenzt, welche Skripte laufen dürfen.

Die Same-Origin Policy ist die Browser-Regel, dass ein Skript aus einem Origin (Schema + Host + Port) die Antworten eines anderen Origins nicht lesen kann, was authentifizierte Sitzungen schützt. CORS ist eine kontrollierte Lockerung: Ein Server gibt Access-Control-Allow-Origin-Header zurück, um bestimmten Origins ausdrücklich das Lesen seiner Antworten zu erlauben, und lockert so die SOP, statt sie zu umgehen.

HttpOnly verbirgt das Cookie vor JavaScript, sodass XSS es nicht über document.cookie stehlen kann. Secure stellt sicher, dass das Cookie nur über HTTPS gesendet wird, und blockiert das Abfangen im Netzwerk. SameSite steuert, ob das Cookie bei Cross-Site-Anfragen gesendet wird, und mildert CSRF ab. Zusammen härten sie Sitzungs-Cookies gegen die häufigsten Diebstahl- und Missbrauchswege.

Zu den wichtigsten Sicherheits-Headern zählen Strict-Transport-Security (erzwingt HTTPS, blockiert SSL-Stripping), Content-Security-Policy (begrenzt Skriptquellen, mildert XSS), X-Frame-Options oder CSP frame-ancestors (blockiert Clickjacking), X-Content-Type-Options: nosniff (stoppt MIME-Sniffing) und Referrer-Policy (steuert das Durchsickern des Referrers). Jeder adressiert eine bestimmte Angriffsklasse.

SQL-Injection erlaubt einer Angreifereingabe, eine Abfrage zu verändern. In-Band-Techniken geben Daten direkt zurück: Die UNION-basierte hängt ein UNION SELECT an, um zusätzliche Spalten zu ziehen, und die fehlerbasierte lässt Daten über Datenbank-Fehlermeldungen durchsickern. Wenn keine Ausgabe sichtbar ist, nutzen Angreifer blinde SQLi — die boolesche schließt Daten aus Unterschieden in Wahr/Falsch-Antworten, die zeitbasierte nutzt Verzögerungen wie SLEEP(), um Daten Bit für Bit zu lesen.

SSRF bringt einen Server dazu, HTTP- (oder andere) Anfragen an ein vom Angreifer gewähltes Ziel zu stellen, und missbraucht die Netzwerkposition des Servers, um interne Dienste hinter der Firewall zu erreichen. In der Cloud ist es besonders gravierend, weil der Instanz-Metadaten-Dienst (z. B. 169.254.169.254) IAM-Anmeldedaten zurückgeben kann und so ein SSRF zur Kompromittierung des Cloud-Kontos macht.

HTTP ist zustandslos — jede Anfrage ist unabhängig und hat keine Erinnerung an vorherige. Sitzungen fügen darauf Zustand hinzu: Nach der Anmeldung gibt der Server eine Kennung aus, die der Browser in einem Cookie speichert und bei jeder Anfrage erneut sendet. Serverseitige Sitzungen halten den Zustand auf dem Server, indiziert über eine undurchsichtige Sitzungs-ID; zustandslose Tokens wie JWTs legen signierten Zustand in das Token selbst, sodass der Server ohne Speicher prüfen kann.

Jedes XSS schleust vom Angreifer kontrolliertes Skript in den Browser eines Opfers ein. Stored XSS speichert die Payload dauerhaft auf dem Server (z. B. einen Kommentar) und trifft jeden, der sie ansieht; Reflected XSS spiegelt die Payload in einer einzelnen Antwort vom Server zurück, meist über einen präparierten Link; DOM-basiertes XSS erreicht nie die Serverlogik — verwundbares clientseitiges JavaScript schreibt nicht vertrauenswürdige Eingaben in die Seite.

XXE missbraucht einen XML-Parser, der externe Entitäten auflöst, die in der DTD eines Dokuments definiert sind. Ein Angreifer deklariert eine Entität, die auf eine lokale Datei oder interne URL zeigt, und der Parser ruft sie ab — was Dateioffenlegung, SSRF und Dienstverweigerung ermöglicht. Die Lösung ist, DTD-Verarbeitung und externe Entitätsauflösung in der Parser-Konfiguration zu deaktivieren.