So schützen Sie Node.js-Apps vor CSRF-Angriffen

Ein Cross-Site-Request-Forgery-Angriff (CSRF) nutzt eine Sicherheitslücke aus, die auf dem Vertrauen zwischen einem Webbrowser und einer legitimen Website beruht. Raffinierte Angreifer bringen Browser dazu, böswillige Aktionen auf Websites auszuführen, bei denen sich Nutzer authentifizieren und anmelden. Häufig beginnen diese Angriffe damit, dass Nutzer auf einen Link in einer betrügerischen E-Mail klicken oder eine manipulierte Website aufrufen, ohne zu wissen, dass im Hintergrund bestimmte Logik ausgeführt wird.

Die Folgen erfolgreicher CSRF-Angriffe reichen von finanziellen Verlusten und Reputationsschäden für Einzelpersonen und Unternehmen bis hin zu kompromittierten Nutzerkonten, nicht autorisierten Transaktionen und sogar rechtlicher Haftung. Da sich CSRF-Angriffe ständig weiterentwickeln und immer ausgefeilter werden, müssen Webentwickler und Unternehmen wirksame Gegenmaßnahmen ergreifen, um die Integrität ihrer Webanwendungen zu schützen.

In diesem Artikel erfahren Sie, wie CSRF-Angriffe auf Node.js-Anwendungen funktionieren und wie Sie sich davor schützen können. Wir sehen uns Praxisbeispiele, praktische Schritte und Code-Snippets, Methoden zum Testen der Schutzmaßnahmen sowie Best Practices für den Schutz von Node.js-Anwendungen vor CSRF-Angriffen an.

Wenn Sie direkt mit einer Lektion loslegen möchten, bieten wir bei Snyk Learn eine kostenlose, praxisorientierte CSRF-Lektion an.

CSRF-Angriffe verstehen

CSRF-Angriffe nutzen das Vertrauen aus, das Webanwendungen in authentifizierte Nutzersitzungen setzen. Indem sie Nutzer zu unbeabsichtigten Aktionen verleiten, können Angreifer sensible Daten manipulieren oder offenlegen, ohne dass die Nutzer davon wissen. Bevor wir uns ansehen, wie Sie Node.js-Anwendungen vor solchen Bedrohungen schützen, werfen wir einen Blick auf die Funktionsweise dieser Angriffe und ihre möglichen Folgen.

Wenn sich Nutzer auf einer Website anmelden, bleiben sie für einen bestimmten Zeitraum angemeldet – von Tagen bis Monaten –, bevor sie sich erneut authentifizieren müssen. Dieser Zeitraum, in dem sie authentifiziert sind, wird als Sitzung bezeichnet. Während einer aktiven Sitzung erstellt der Server einen eindeutigen, zufälligen Bezeichner oder Token – eine Sitzungs-ID – und ordnet ihn dieser Sitzung zu. Anschließend sendet der Server die Sitzungs-ID an den Nutzer. Sie wird in Browser-Cookies gespeichert (Daten, die während einer Sitzung an den Browser des Nutzers angehängt werden).

Bei jeder Anfrage, mit der der Nutzer den Zustand der Website ändert (zum Beispiel beim Absenden eines Formulars), wird die Sitzungs-ID mitgesendet. Der Server vergleicht sie mit dem serverseitig gespeicherten Token. Stimmen die Werte überein, autorisiert er die Anfrage und die Anwendung führt die Aktion aus. Andernfalls verweigert er den Zugriff.

Bei einem typischen CSRF-Angriff nutzen Angreifer das Vertrauen in authentifizierte Nutzersitzungen aus, indem sie böswillige Anfragen erstellen, die eine Aktion im Namen eines angemeldeten Opfers nachahmen. Angreifer können CSRF-Angriffe mithilfe von Social-Engineering-Methoden erfolgreich ausführen, zum Beispiel indem sie schädliche Links in E-Mails oder auf Websites platzieren, die von den ausgewählten Nutzern besucht werden. Ungeschützte Webanwendungen autorisieren solche Anfragen möglicherweise versehentlich als legitime Nutzeraktionen, weil gültige Anmeldedaten mitgesendet werden.

Bei CSRF-Angriffen steht viel auf dem Spiel. So waren beispielsweise 2018 mehr als 50 Millionen Konten weltweit von einer Sicherheitsverletzung bei Facebook betroffen. Die Ursache? Unzureichend geschützte Zugriffstoken, die anfällig für den Missbrauch durch ursprungsübergreifende clientseitige Anfragen sind. Durch diesen unzureichenden Schutz wurden sensible Nutzerdaten kompromittiert, was zu finanziellen Verlusten, Reputationsschäden und rechtlichen Konsequenzen führte. Sicherheitsverletzungen können das Vertrauen der Kunden beeinträchtigen und den Ruf eines Unternehmens und seiner Dienste schädigen.

Die Folgen erfolgreicher CSRF-Angriffe hängen von der Zielanwendung und den Funktionen ab, die sie Nutzern bereitstellt. Zu den möglichen Folgen eines erfolgreichen CSRF-Angriffs gehören:

• Datenmanipulation – CSRF-Angriffe können es Angreifern ermöglichen, sensible Daten in einer Webanwendung zu manipulieren. Dazu kann gehören, Profileinstellungen eines Nutzers zu ändern, Kontoeinstellungen und Präferenzen anzupassen oder Daten zu verfälschen, die innerhalb der jeweiligen Zugriffsrechte bearbeitet werden können.

• Nicht autorisierte Aktionen – Angreifer können Anfragen fälschen, um Aktionen auszuführen, die der authentifizierte Nutzer nicht autorisiert hat. Beispiele sind das Absenden von Formularen, das Ausführen von Finanztransaktionen und das Löschen von Inhalten.

• Offenlegung von Informationen – Angreifer können Sicherheitslücken ausnutzen und Nutzer dazu verleiten, vertrauliche Daten wie private Nachrichten und Finanzinformationen preiszugeben. Außerdem können sie Nutzer dazu bringen, geschützte Daten offenzulegen, die in der Anwendung gespeichert sind.

• Übernahme von Konten – Indem Angreifer Nutzer dazu verleiten, Aktionen auszuführen, die ihre Kontozugangsdaten ändern, etwa ihre Anmeldedaten zu aktualisieren, können sie sich unbefugten Zugriff auf kompromittierte Konten verschaffen und diese kontrollieren. So können sie sich als legitime Nutzer ausgeben, auf geschützte Ressourcen zugreifen und möglicherweise weitere Angriffe innerhalb der Anwendung oder auf andere Nutzer starten.

Strategien zum Schutz vor CSRF

Zu den wichtigsten Maßnahmen, mit denen Sie Node.js-Anwendungen vor CSRF-Angriffen schützen können, gehören:

Synchronizer-Token-Pattern (STP) verwenden

Beim Synchronizer-Token-Pattern wird für jede Nutzersitzung ein eindeutiges Token generiert. Es wird in Formularübermittlungen eingebettet oder über eine AJAX-Anfrage als benutzerdefinierter Header-Wert oder als Teil einer JSON-Nutzlast übermittelt. Der Server validiert dieses Token beim Empfang der Anfrage.

Beim STP wird für jede Nutzersitzung ein eindeutiges, zufälliges Token generiert – ein CSRF-Token. Der Server sendet das CSRF-Token als Teil der Antwortnutzlast, beispielsweise in einer HTML- oder JSON-Antwort, an den Nutzer. Bei jeder nachfolgenden Anfrage fügt die Anwendung das Token in die Anfrage-Header oder als benutzerdefinierten POST-Parameter ein. Anschließend überprüft der Server, ob das empfangene Token vorhanden ist und mit dem Token der Nutzersitzung übereinstimmt. Ist das der Fall, stammt die Anfrage von einem legitimen Nutzer mit einer gültigen Sitzung.

Das STP ist einfach umzusetzen und schützt wirksam vor gängigen Angriffsvektoren. Allerdings kann es zusätzliche serverseitige Zustandsverwaltung erfordern. Wenn Sie CSRF-Token beim STP in Cookies speichern, versehen Sie sie mit dem Präfix __Host-, um die Sicherheit der Cookies zu erhöhen und sie auf andere Domains als die festgelegte Domain zu beschränken.

SameSite-Cookies implementieren

Bei der SameSite-Cookie-Strategie wird für Sitzungscookies das Attribut SameSite festgelegt. Dadurch sendet die Anwendung sie nur mit Anfragen, die von derselben Domain wie die Zielwebsite stammen. So wird verhindert, dass Anfragen ursprungsübergreifende Cookies enthalten. Für das Attribut SameSite sind zwei Werte möglich: strict und lax.

Bei der Einstellung strict sendet der Browser Sitzungscookies nur in Erstanbieter-Kontexten – beim Wechsel eines Nutzers zu einer anderen Website werden sie nicht gesendet. So werden CSRF-Angriffe von böswilligen Drittanbieter-Websites wirksam verhindert.

Bei der Einstellung lax sendet der Browser das Cookie mit Anfragen, die von derselben Website (Domain) stammen, die das Cookie gesetzt hat, sowie mit Top-Level-GET-Anfragen.

Moderne Browser setzen SameSite-Cookie-Attribute zwar automatisch durch, doch ältere Browser und Nicht-Web-Clients wie mobile Apps bieten nur eingeschränkte Unterstützung. Das beeinträchtigt die Wirksamkeit von SameSite-Cookies als Schutz vor CSRF-Angriffen erheblich. Entwickler müssen daher alternative Schutzmaßnahmen gegen CSRF berücksichtigen und einen umfassenden Schutz über verschiedene Client-Umgebungen hinweg sicherstellen.

Double-Submit-Cookie-Pattern verwenden

Beim Double-Submit-Cookie-Pattern wird zusätzlich zu den üblichen Sitzungskennungen ein weiteres Cookie mit einem eindeutigen Token ausgegeben. Bei Übermittlungen wird dieses Cookie an clientseitige Anfrage-Header oder Formulardaten angehängt. Das Double-Submit-Cookie-Pattern verringert den Aufwand für die Zustandsverwaltung, ohne die Gesamtleistung wesentlich zu beeinträchtigen. Daher eignet es sich ideal für zustandslose Anwendungen mit verschiedenen Content-Delivery-Netzwerken oder Microservices-Architekturen.

Diese Methode schützt jedoch nicht vor fortgeschrittenen Angriffen auf browserbasierte Speichermethoden, in denen sekundäre Token abgelegt werden. Ein solcher Angriffsvektor ist Cross-Site-Scripting (XSS). Bei anfälligen für XSS-Angriffe Anwendungen können Angreifer das eindeutige Token aus einem Cookie auslesen und für nachfolgende böswillige Anfragen verwenden.

Darüber hinaus ist das Double-Submit-Cookie-Pattern anfällig für Man-in-the-Middle-Angriffe (MITM), wenn Nutzer keine geeigneten Sicherheitsmaßnahmen ergreifen. Angreifer können das ursprüngliche CSRF-Token aus der ersten Anfrage des Clients abfangen und damit böswillige Anfragen erstellen.

Mit signierten Double-Submit-Cookies können Sie das Double-Submit-Cookie-Pattern robuster gestalten. Bei dieser Strategie kommt ein geheimer Schlüssel zum Einsatz, der ausschließlich dem Server bekannt ist. So wird sichergestellt, dass Angreifer kein eigenes CSRF-Token generieren und einfügen können.

Zu den zusätzlichen Schutzmaßnahmen gehören die Durchsetzung des HTTP-Response-Headers HTTP Strict-Transport-Security (HSTS) und die Verwendung von Cookie-Präfixen wie __Host-. Zum Zeitpunkt der Veröffentlichung dieses Artikels unterstützten 25 % der Browser jedoch keine Cookie-Präfixe.

CSRF-Schutz in einer Node.js-App implementieren

Nachdem wir uns Strategien zum Schutz unserer Anwendungen vor CSRF-Angriffen angesehen haben, geht es nun um ihre Umsetzung. Für die folgenden Schritte benötigen Sie:

• Node.js, installiert auf Ihrem Computer.

• Einen Code-Editor. In dieser Anleitung verwenden wir Visual Studio (VS) Code

• Einen Webbrowser

• Ein kostenloses Snyk-Konto, die Snyk-Code-Kommandozeilenschnittstelle (CLI) und die Snyk-VS-Code-Erweiterung

Wir erstellen eine einfache Node.js-App, mit der Nutzer Geld an andere Nutzer überweisen können. Die Anwendung verwendet das Express-Webframework.

Erstellen Sie zunächst einen Projektordner mit dem Namen nodejs-csrf-strategies. Öffnen Sie diesen Ordner in einem Terminal und führen Sie den Befehl npm init -y aus, um ein Node.js-Projekt zu initialisieren. Installieren Sie anschließend mit dem Befehl npm i express das Express-Webframework.

Erstellen Sie eine Datei mit dem Namen index.js und fügen Sie den folgenden Code ein.

// import dependencies
const express = require('express');

// create express app
const app = express();

// enable parsing of request body
app.use(express.urlencoded({ extended: false }));

// home route to render the form
app.get('/', (req, res) => {
 res.send(`
   <html>
     <body>
       <h1>CSRF Demo App</h1>
       <form method="POST" action="/transfer">
         <input type="text" name="amount" placeholder="Amount" /><br />
         <input type="submit" value="Transfer" />
       </form>
     </body>
   </html>
 `);
});

// process the transfer
app.post('/transfer', function (req, res) {
   // Perform the transfer operation
   // (in a real application, you would validate and process the data here)
   res.send('Successfully transferred the set amount')
})

// Start the server
app.listen(3000, () => {
   console.log('Server listening on port 3000');
});

In dieser Beispielanwendung rendert die Route / das HTML-Formular, in dem der zu überweisende Betrag erfasst wird. Die Route /transfer gibt anschließend eine Meldung zurück, die bestätigt, dass der im Formular eingegebene Betrag erfolgreich überwiesen wurde. In einer realen Anwendung würden wir hier die Überweisungslogik implementieren. Beachten Sie, dass der in dieser Anwendung verwendete Code anfällig für CSRF-Angriffe ist – verwenden Sie ihn nicht in einer Produktionsumgebung.

Nachdem Sie die Snyk CLI auf Ihrem Computer installiert haben, aktivieren Sie Snyk Code und scannen Sie das Beispielprojekt mit Snyk Code auf Sicherheitslücken. Mit der Snyk CLI können Sie die Funktionen von Snyk Code in Ihren Entwicklungsworkflow integrieren und lokal Snyk-Code-Tests ausführen, um Ihren Anwendungscode auf Sicherheitslücken zu prüfen.

Öffnen Sie dazu den Projektordner im Terminal. Führen Sie den Befehl snyk code test aus. Die Ausgabe sollte wie im folgenden Screenshot aussehen und Details zu unverschlüsselter Übertragung sensibler Informationen, der Verwendung eines Passwort-Hashes mit unzureichendem Rechenaufwand, der Offenlegung von Informationen, CSRF, Regular-Expression-Denial-of-Service (ReDOS) und XSS enthalten.

Dieses Ergebnis bedeutet, dass die Anwendung anfällig für CSRF-Angriffe und die weiteren aufgeführten Angriffe ist.

Bewegen Sie den Mauszeiger über die Zeile, in der die Express-App initialisiert wird – const app = express() –, um die ausführlichen Informationen von Snyk zu CSRF-Angriffen und Best Practices zu ihrer Vermeidung anzuzeigen, wie im folgenden Screenshot. Diese Funktion zur Erkennung von Sicherheitslücken in Echtzeit wird durch die Snyk-VS-Code-Erweiterung ermöglicht und hilft Ihnen, Sicherheitslücken beim Schreiben von Code zu entdecken.

Nachdem Snyk Code unsere Node.js-App als anfällig für CSRF-Angriffe erkannt hat, sehen wir uns an, wie die erwähnten CSRF-Schutzmaßnahmen helfen.

Unsere App mit dem STP schützen

Implementieren wir das STP in der Beispielanwendung mit Node.js. Installieren Sie zunächst die csurf-Middleware mit dem Befehl `npm install csurf`. Diese Middleware setzt voraus, dass Sie eine Session-Middleware oder einen Cookie-Parser initialisieren. In diesem Beispiel verwenden wir den Cookie-Parser.

Installieren Sie einen Cookie-Parser mit dem Befehl npm install cookie-parser.

Importieren Sie als Nächstes die Middleware und den Cookie-Parser am Anfang Ihrer JavaScript-Datei.

const cookieParser = require('cookie-parser')
const csrf = require('csurf')

Aktivieren Sie das Parsen von Cookies und richten Sie Route-Middleware ein, indem Sie den folgenden Code direkt vor der GET-Route hinzufügen.

app.use(cookieParser())

const csrfProtection = csrf({ cookie: true })

Wir müssen Cookies parsen, da die Cookie-Option in csrfProtection auf true gesetzt ist.

Fügen Sie nun das generierte CSRF-Token als verstecktes Eingabefeld ein, wenn Sie das HTML-Formular bereitstellen. Dadurch wird das CSRF-Token in einem HTML-Formular zur Übermittlung ausgegeben. Ersetzen Sie den Code der GET-Route durch den folgenden Code.

app.get('/', csrfProtection, function (req, res) {
   // retrieves the CSRF token
   const csrfToken = req.csrfToken()

   // Render the form with the csrf token as a hidden field
   res.send(`
       <html>
       <head>
           <title>CSRF Demo</title>
       </head>
       <body>
           <h1>CSRF Demo</h1>
           <form action="/transfer" method="POST">
           <input type="text" name="amount" placeholder="Amount" required>
           <input type="submit" value="Transfer">
           <input type="hidden" name="_csrf" value="${csrfToken}">
           </form>
       </body>
       </html>
   `);
})

Ändern Sie die POST-Route mit dem folgenden Code, um die csrfProtection-Middleware anzuwenden.

app.post('/transfer', csrfProtection, function (req, res) {
   // Perform the transfer operation
   // (in a real application, you would validate and process the data here)
   res.send('Successfully transferred the set amount')
})

Diese Middleware überprüft eingehende POST-Anfragen, indem sie den Wert des Felds _csrf, das die Anwendung im Request-Body übermittelt hat, mit dem CSRF-Token vergleicht, das in der Session des Benutzers gespeichert ist. Dieses Token ist den Cookies des Benutzers zugeordnet.

Unsere Anwendung mit SameSite-Cookies schützen

Implementieren wir SameSite-Cookies in der zuvor erstellten Node.js-Anwendung. Installieren Sie zunächst die cookie-parser-Middleware mit dem Befehl npm install cookie-parser. Importieren Sie die cookie-parser-Middleware in die Anwendung und initialisieren Sie sie mit einem geheimen Schlüssel. Verwenden Sie dazu den folgenden Code.

const cookieParser = require('cookie-parser');
// …
app.use(cookieParser('<your-secret-key>', {
   sameSite: 'strict'
}))

Der Wert von <your-secret-key> sollte eine eindeutige Zeichenfolge sein, die zum Signieren von Cookies verwendet wird – ein unvorhersehbarer, großer Zufallswert, der mit einer kryptografisch sicheren Methode erzeugt wurde.

Beim Signieren eines Cookies mit der eindeutigen Zeichenfolge wird dessen Inhalt gehasht und eine eindeutige Signatur erstellt. Wenn der Server das Cookie später vom Browser erhält, kann er dessen Integrität überprüfen, indem er die Signatur mit demselben geheimen Schlüssel abgleicht.

Diese Methode hilft gegen Session-Hijacking, bei dem Angreifer versuchen, die Session eines Benutzers zu stehlen oder sich als dieser auszugeben. Verändert ein Angreifer das Cookie, stimmt die Cookie-Signatur nicht mehr überein, und der Server erkennt die Manipulation. Angreifer können daher keine sitzungsbezogenen Daten ändern, die in Cookies gespeichert sind.

Unsere Anwendung mit dem Double-Submit-Cookie-Muster schützen

Installieren Sie zur Implementierung des Double-Submit-Cookie-Musters cookie-parser. Fügen Sie der Anwendung anschließend den folgenden Code hinzu, um die erforderlichen Pakete zu importieren und das Parsen von Cookies zu aktivieren.

const cookieParser = require('cookie-parser');
const crypto = require('crypto');

app.use(cookieParser());

Erstellen Sie nun mit dem folgenden Code Middleware-Funktionen zum Generieren und Validieren von CSRF-Tokens.

// generate CSRF token middleware
function generateCSRFToken(req, res, next) {
 const csrfToken = crypto.randomBytes(16).toString('hex');
 console.log(csrfToken)
 res.cookie('mycsrfToken', csrfToken);
 req.csrfToken = csrfToken;
 next();
}

// validate CSRF token middleware
function validateCSRFToken(req, res, next) {
 const csrfToken = req.cookies.mycsrfToken;
 if (req.body.csrfToken === csrfToken) {
   next();
 } else {
   res.status(403).send('Invalid CSRF token');
 }
}

Wenden Sie dann die generateCSRFToken-Middleware auf die GET-Route an.

 app.get('/', generateCSRFToken, (req, res) => {
 res.send(`
   <html>
     <body>
       <h1>CSRF Demo App</h1>
       <form method="POST" action="/transfer">
         <input type="hidden" name="csrfToken" value="${req.csrfToken}" />
         <input type="text" name="amount" placeholder="Amount" /><br />
         <input type="submit" value="Transfer" />
       </form>
     </body>
   </html>
 `);
});

Wenden Sie abschließend die Middleware-Funktion validateCSRFToken auf die POST-Route an.

app.post('/transfer', validateCSRFToken, (req, res) => {
 // Perform the transfer operation
 // (in a real application, you would validate and process the data here)
 res.send(`Successfully transferred the set amount`);
});

CSRF-Schutz testen

Das Testen des CSRF-Schutzes ist entscheidend, um:

• Unbefugte Aktionen zu verhindern — Sie können überprüfen, ob die Node.js-Anwendung und weitere implementierte Strategien Anfragen ordnungsgemäß validieren und überprüfen, um unbefugte Aktionen zu verhindern.

• Schützen Sie Benutzerdaten und die Privatsphäre – Sie können sicherstellen, dass Benutzerdaten bei CSRF-Angriffen, die auf die Offenlegung oder Manipulation vertraulicher Daten abzielen, sicher und geschützt bleiben.

• Sicherheitsstandards einzuhalten — Viele Sicherheitsstandards und Vorschriften, etwa der Payment Card Industry Data Security Standard (PCI DSS), verlangen von Unternehmen, CSRF-Schutzmaßnahmen zu implementieren. Durch das Testen des CSRF-Schutzes stellen Sie die Einhaltung dieser Standards sicher und vermeiden mögliche Strafen oder rechtliche Probleme.

• Schwachstellen aufzudecken — Indem Sie Angriffe simulieren und die Wirksamkeit der CSRF-Sicherheitsmaßnahmen testen, können Sie Schwachstellen erkennen und beheben, bevor Angreifer sie ausnutzen.

Mit einem benutzerdefinierten HTML-Formular können wir einen CSRF-Angriff auf den ursprünglichen, unveränderten Code index.js vom Anfang dieses Tutorials simulieren. Betrachten Sie das folgende HTML-Formular.

<html>
<body>
  <h1>Welcome to the Lucky Prize Game!</h1>
  <p>Congratulations! You have won $100!</p>
  <p>Click the button below to claim your prize:</p>
  <form id="csrfForm" action="http://localhost:3000/transfer" method="POST">
	<input type="hidden" name="amount" value="100" />
	<input type="submit" value="Claim Prize" />
  </form>
  <script>
	document.getElementById('csrfForm').submit();
  </script>
</body>
</html>

Dieses benutzerdefinierte HTML-Formular zeigt dem Benutzer eine verlockende Nachricht. Darin steht, dass er einen Preis im Wert von 100 $ gewonnen hat und ihn durch einen Klick auf die Schaltfläche einfordern soll. Gleichzeitig übermittelt ein verstecktes Formular den Betrag ohne Wissen des Benutzers an den Endpunkt /transfer. Der Code im Tag <script> des HTML-Formulars übermittelt das Formular automatisch, sobald die Seite geladen wird. Im ursprünglichen Code wäre die Überweisung erfolgreich, da der Server CSRF-Bedrohungen nicht erkennen könnte.

Um eine der implementierten CSRF-Schutzstrategien zu testen, starten Sie den Server, nachdem Sie die STP-Strategie angewendet haben. Versuchen Sie dann, das benutzerdefinierte HTML-Formular zu übermitteln. Der Server gibt den Fehler ForbiddenError: invalid csrf token aus, und die Überweisung wird nicht verarbeitet. Das zeigt, dass die CSRF-Schutzstrategie wie erwartet funktioniert.

So testen Sie die einzelnen implementierten Strategien:

• STP — Erstellen Sie eine Anfrage ohne das korrekte Token oder mit einem abgelaufenen Token. Prüfen Sie, ob der Server sie ablehnt.

• SameSite-Cookies — Führen Sie Cross-Origin-Anfragen von verschiedenen Domains aus. Prüfen Sie, ob Server den unbefugten Zugriff aufgrund fehlender Session-Cookies verhindern.

• Double-Submit-Cookies — Senden Sie eine Anfrage mit nicht übereinstimmenden Tokens in den übermittelten Daten oder Headern und den Session-Cookies. Stellen Sie sicher, dass Server sie ordnungsgemäß validieren.

Testen Sie nun den aktualisierten Code mit Snyk auf Schwachstellen. Sie können auch Code für andere Strategien testen. In dieser Demonstration konzentrieren wir uns jedoch auf den Code, der die STP-Strategie implementiert.

Führen Sie den Befehl snyk code test aus, um nach Schwachstellen zu suchen. Sie sollten ein Ergebnis wie im folgenden Screenshot erhalten.

Die Ergebnisse zeigen, dass der Code Schwachstellen durch Informationspreisgabe und XSS enthält, aber keine CSRF-Schwachstellen. Das bedeutet, dass wir die zuvor erkannte CSRF-Schwachstelle behoben haben.

Best Practices für den CSRF-Schutz in Node.js-Anwendungen

Ergänzend zu den oben beschriebenen Strategien können Sie den CSRF-Schutz mit diesen Best Practices verstärken:

• Aktualisieren Sie Abhängigkeiten und Middleware regelmäßig, damit die Sicherheitskonfigurationen auf dem neuesten Stand bleiben. Tools wie Snyk Open Source vereinfachen diesen Prozess, indem sie veraltete Komponenten identifizieren und Patches vorschlagen.

• Implementieren Sie eine Content Security Policy (CSP), die Anfragen auf vertrauenswürdige Quellen beschränkt und so potenzielle Angriffsvektoren reduziert.

• Kombinieren Sie mehrere CSRF-Schutztechniken, etwa STP mit SameSite-Cookies, oder setzen Sie Double-Submit-Cookies zusammen mit einer CSP-Durchsetzung ein. Dieser mehrschichtige Ansatz minimiert Schwachstellen, die entstehen, wenn Sie sich ausschließlich auf eine einzelne Strategie verlassen.

Nächste Schritte

Das Verständnis von CSRF-Angriffen und ihren Auswirkungen ist entscheidend für die Absicherung von Node.js-Anwendungen. Mit robusten Schutzstrategien, wirksamen Tests und Best Practices stärken Sie die Abwehr der Anwendung gegen Bedrohungen.

Regelmäßige Tests auf Schwachstellen wie CSRF und die Implementierung robuster Sicherheitsmechanismen helfen, Risiken zu mindern und unbefugte Aktionen zu verhindern. Nutzen Sie proaktive Sicherheitsmaßnahmen und aktuelle Techniken, um sichere Node.js-Anwendungen zu entwickeln und Schwachstellen zu beheben, bevor Angreifer sie ausnutzen.

Sichern Sie Ihre Node.js-Anwendungen, indem Sie die in diesem Artikel behandelten Konzepte und Strategien anwenden und Snyk Code ausprobieren.