5 Node.js-Sicherheitscode-Snippets, die jeder Backend-Entwickler kennen sollte

Als Backend-Entwickler tragen wir die wichtige Verantwortung, die Sicherheit unserer Anwendungen zu gewährleisten. Node.js ist davon nicht ausgenommen. Seine wachsende Beliebtheit macht es zu einem attraktiven Ziel für Hacker. Daher ist es unerlässlich, bei der Arbeit mit Node.js bewährte Sicherheitspraktiken zu befolgen.

In diesem Blogbeitrag stellen wir einige wichtige Node.js-Sicherheitscode-Snippets vor, die jeder Backend-Entwickler 2024 kennen sollte. Sicherheitslücken in Node.js-Software können eine erhebliche Bedrohung für jede Anwendung darstellen. Sie können zu unbefugtem Zugriff, Datenlecks und im schlimmsten Fall zur vollständigen Kompromittierung des Systems führen. Deshalb sind bewährte Sicherheitspraktiken nicht nur eine Empfehlung, sondern eine Voraussetzung.

Im Kontext von Node.js bedeutet das, sicherzustellen, dass Ihr Code keine Schwachstellen aufweist, die ausgenutzt werden könnten. Dazu gehört, Benutzereingaben zu bereinigen, um Injection-Angriffe zu verhindern, Passwörter angemessen als vertrauliche Daten zu behandeln und Abhängigkeiten zu verwalten, um Sicherheitslücken in Drittanbieterkomponenten zu vermeiden.

Wir sehen uns die folgenden Node.js-Sicherheitskonzepte und die zugehörigen Code-Snippets an. Im Mittelpunkt stehen ihre Wirksamkeit beim Verhindern gängiger Sicherheitslücken und ihre einfache Anwendung durch Entwickler ohne zusätzliche Sicherheitsexpertise:

1. Mit dem Node.js Permissions Model den Zugriff auf Ressourcen zur Laufzeit einschränken

2. Eingabevalidierung mit einem Fastify-JSON-Schema implementieren

3. Passwörter sicher mit Bcrypt hashen

4. SQL-Injection-Angriffe mit Knex.js verhindern

5. Rate-Limiting mit fastify-rate-limit implementieren

1. Mit dem Node.js Permissions Model den Zugriff auf Ressourcen zur Laufzeit einschränken

Das Node.js Permissions Model kann eine entscheidende Rolle bei der Sicherung Ihrer Anwendungen spielen. Es ist ein wichtiger Bestandteil des Node.js-Kernsicherheitsmodells und schützt Ihre Anwendungen vor Angriffen und böswilligen Aktivitäten. Ähnlich wie Deno mit prozessbezogenen Ressourcenbeschränkungen für Sicherheit sorgte, bietet Node.js inzwischen (bis zu einem gewissen Grad) ein vergleichbares Berechtigungsmodell.

Stellen Sie sich ein Szenario vor, in dem eine Node.js-Anwendung PDF-Dateien in PNG-Bilder umwandeln muss. Dafür können wir das npm-Paket pdf-image verwenden. Das Paket pdf-image führt die Konvertierung mithilfe von Kindprozessen aus. Dazu müssen wir das Flag --allow-child-process in der Node.js-Laufzeitumgebung verwenden, das vom Berechtigungsmodell bereitgestellt wird.

Das folgende Code-Snippet veranschaulicht dies:

1const { PDFImage } = require('pdf-image');
2const path = require('path');
3
4const pdfPath = path.resolve(__dirname, 'sample.pdf');
5const pdfImage = new PDFImage(pdfPath, {
6  convertOptions: {
7    '-density': '300',
8    '-quality': '80'
9  },
10  combinedImage: true
11});
12pdfImage.convertFile().then(() => {
13  console.log('PDF converted to PNG successfully');
14}).catch((err) => {
15  console.error(`Failed to convert PDF to PNG: ${err}`);
16});

In diesem Snippet erstellen wir eine neue Instanz von PDFImage mit dem Pfad zu unserer PDF-Datei und einigen Konvertierungsoptionen. Anschließend rufen wir convertFile() auf, um die PDF-Datei in ein PNG-Bild umzuwandeln.

Wenn Sie das experimentelle Berechtigungsmodell in Node.js aktivieren, müssen Sie die Node.js-Laufzeitumgebung explizit mit dem zuvor genannten Befehlszeilen-Flag --allow-child-process starten. Denn die Bibliothek pdf-image erzeugt im Hintergrund einen Kindprozess, um diese PDFs zu konvertieren.

Das Node.js Permissions Model bietet zwar eine gute Möglichkeit, den Zugriff auf Systemressourcen einzuschränken, doch müssen Sie sich auch möglicher Sicherheitslücken in den verwendeten Paketen bewusst sein. Hier kommt die Snyk-Erweiterung für Visual Studio Code ins Spiel. Die Snyk-Erweiterung kann unsicheren Code und anfällige Abhängigkeiten in einer Node.js-Anwendung erkennen. So ist beispielsweise das zuvor erwähnte Paket pdf-image bekanntermaßen aufgrund der Verwendung von Kindprozessen anfällig für Command-Injection. Diese Sicherheitslücke ist seit 2018 bekannt, doch leider gibt es bislang keine Lösung dafür.

Das zeigt, wie wichtig es ist, Tools wie Snyk zu verwenden, um über Sicherheitslücken in den Paketen informiert zu bleiben, von denen wir abhängig sind. Es erinnert uns auch daran, bei der Verwendung bestimmter Funktionen wie Kindprozessen vorsichtig zu sein, da sie bei unsachgemäßem Einsatz Sicherheitsrisiken bergen können.

Als Node.js-Entwickler tragen wir die Verantwortung dafür, dass unser Code nicht nur funktioniert, sondern auch sicher ist. Eine wichtige Möglichkeit, die Sicherheit einer Node.js-Anwendung zu verbessern, ist die Verwendung des integrierten Berechtigungsmodells, um den Zugriff auf Systemressourcen zur Laufzeit einzuschränken. Wenn Ihre Node.js-Anwendung keine Funktionen für Kindprozesse benötigt, aktivieren Sie diese Ressource nicht, um die Angriffsfläche nicht unnötig zu vergrößern.

FAQ zum Node.js Permissions Model

2. Eingabevalidierung mit einem Fastify-JSON-Schema implementieren

Eingabevalidierung ist ein entscheidender Aspekt der Backend-Entwicklung. Wenn Sie bereits APIs mit Express, Fastify oder anderen Frameworks entwickelt haben, ist Ihnen die Bedeutung wahrscheinlich bewusst. Diese Sicherheitspraktik stellt sicher, dass nur korrekt formatierte Daten in Ihr System gelangen, und verhindert so potenzielle Sicherheitsrisiken. Eine Möglichkeit, die Eingabevalidierung in Ihren Node.js-Anwendungen umzusetzen, ist die Verwendung des Fastify-Schemas in Ihren Fastify-Webanwendungen.

Der schema-basierte Ansatz von Fastify

Fastify verwendet einen schema-basierten Ansatz für die Eingabevalidierung. Die Verwendung eines JSON-Schemas ist zwar nicht verpflichtend, wird aber empfohlen, um Ihre Routen zu validieren und Ihre Ausgaben zu serialisieren. Ein JSON-Schema legt einen Vertrag für Ihre Daten fest und beschreibt das erwartete Datenformat, die Datentypen, Pflichtfelder und weitere Einschränkungen. Sie können sich das JSON-Schema der Fastify-Route wie den Einsatz von TypeScript vorstellen, um beim Build-Prozess für starke Typisierung in Ihrem Code zu sorgen.

Betrachten wir eine einfache Fastify-Anwendung, in der wir einen neuen Benutzer erstellen. Zur Validierung der Eingabedaten können wir ein Fastify-Schema verwenden.

1const fastify = require('fastify')({ logger: true });
2
3const UserSchema = {
4  body: {
5    type: 'object',
6    properties: {
7      name: { type: 'string' },
8      email: { type: 'string', format: 'email' },
9      password: { type: 'string', minLength: 8 }
10    },
11    required: ['name', 'email', 'password']
12  }
13};
14
15// User creation route
16fastify.post('/users', { schema: UserSchema }, async (request, reply) => {
17  // Example user creation logic
18  // In a real application, you would replace this with actual database logic
19  const user = request.body;
20
21  // Simulating user creation
22  console.log("Creating user:", user);
23
24  // Responding with the created user (in real applications, never send the password back)
25  return reply
26    .code(201)
27    .send({ success: true, message: "User created", user: { name: user.name, email: user.email } });
28});
29
30// Server startup
31const start = async () => {
32  try {
33    await fastify.listen({ port: 6000, host: 'localhost' });
34    console.log(`Server running at http://localhost:3000/`);
35  } catch (err) {
36    fastify.log.error(err);
37    process.exit(1);
38  }
39};
40
41start();

Im obigen Code definieren wir ein UserSchema, das einen Namen, eine E-Mail-Adresse und ein Passwort voraussetzt. Die E-Mail-Adresse muss ein gültiges Format haben, und das Passwort muss mindestens 8 Zeichen lang sein.

Wenn Sie die Eingabevalidierung vernachlässigen, kann Ihre Anwendung verschiedenen Sicherheitsrisiken ausgesetzt sein, darunter serverseitige Request-Forgery (SSRF) oder HTTP-Parameter-Pollution-Angriffe. SSRF-Angriffe können den Server dazu verleiten, unbefugte Anfragen zu stellen, was möglicherweise zur Offenlegung von Daten führt. HTTP-Parameter-Pollution kann Anfragen manipulieren oder beschädigen und so unerwartetes Verhalten hervorrufen.

Tools wie Snyk können diese Sicherheitslücken aufdecken, indem sie Ihren Code auf Sicherheitsmängel untersuchen. Sie können außerdem Empfehlungen zur Behebung geben, damit Sie die Sicherheitslücken schließen und die Sicherheit Ihrer Anwendung insgesamt verbessern können.

FAQ zur Eingabevalidierung mit Fastify

3. Passwörter sicher mit Bcrypt hashen

Die sichere Speicherung von Benutzerpasswörtern ist in der Softwareentwicklung entscheidend. Im Falle einer Datenschutzverletzung möchten Sie sicherstellen, dass sich die Passwortinformationen der Benutzer nicht einfach entschlüsseln lassen. Hier kommt das Hashing von Passwörtern ins Spiel. Beim Hashing wird ein bestimmter Schlüssel in einen anderen Wert umgewandelt. Dazu wird eine Hash-Funktion verwendet, die für jeden eindeutigen Eingabewert möglichst eine eindeutige Ausgabe (oder einen Hash-Code) erzeugt.

Wenn Sie die Authentifizierung selbst implementieren möchten, anstatt einen Dienst oder eine andere Bibliothek zu verwenden, müssen Sie unbedingt verstehen, dass der Umgang mit der Passwortsicherheit die Gesamtsicherheit Ihrer Anwendung unmittelbar beeinflussen kann.

Einführung in Bcrypt für das Passwort-Hashing in Node.js

Bcrypt ist ein Algorithmus und ein npm-Paket, das eine als äußerst sicher geltende Funktion zum Hashing von Passwörtern bereitstellt. Es verwendet einen Salt (zufällige Daten), um vor Rainbow-Table-Angriffen zu schützen, und ermöglicht die Konfiguration eines Arbeitsfaktors. Damit können Sie festlegen, wie CPU-intensiv der Hashing-Prozess ist – eine nützliche Funktion zum Schutz vor Brute-Force-Angriffen.

Sehen wir uns einen einfachen Anwendungsfall an:

1const bcrypt = require('bcrypt');
2const saltRounds = 10;
3const myPlaintextPassword = 'my_password';
4
5// Define an async function
6async function hashPassword(plaintextPassword) {
7  try {
8    const hash = await bcrypt.hash(plaintextPassword, saltRounds);
9    // Store hash in your password DB.
10    console.log(hash); // Example of how to use the hash
11  } catch (err) {
12    // Handle error
13    console.error(err);
14  }
15}
16
17// Call the async function
18hashPassword(myPlaintextPassword);

Der Parameter saltRounds bestimmt die Komplexität des Hashing-Prozesses. Je höher der Wert, desto länger dauert der Prozess, was zum Schutz vor Brute-Force-Angriffen beitragen kann. Die Funktion hash versieht das Klartextpasswort automatisch mit einem Salt und hasht es. Der resultierende Hash kann anschließend in Ihrer Datenbank gespeichert werden.

FAQ zu Passwort-Hashing und Authentifizierungsverwaltung in Node.js

4. SQL-Injection-Angriffe mit Knex.js verhindern

SQL-Injection ist eine weit verbreitete Sicherheitslücke, die ein erhebliches Risiko für Anwendungsdaten darstellt. Node.js-Entwickler können dieses Risiko mindern, indem sie mit Knex.js, einem vielversprechenden SQL-Query-Builder, sicherere SQL-Abfragen erstellen. Beachten Sie jedoch, dass Knex.js auch das Erstellen und Ausführen von rohen SQL-Abfragen ermöglicht. In diesem Fall bleibt SQL-Injection ein Sicherheitsrisiko, da sie durch die Verkettung von Benutzereingaben in die Abfrage gelangen kann.

Knex.js ist ein leistungsstarker SQL-Query-Builder für Node.js. Er unterstützt Transaktionen, Verbindungspooling, Migrationen und Seeds und ist daher bei Entwicklern beliebt, die sichere, robuste und skalierbare SQL-Abfragen schreiben möchten. Knex.js schützt vor SQL-Injection-Angriffen, indem es parametrisierte Abfragen verwendet und Werte maskiert, die in die SQL-Anweisungen eingefügt werden.

Das folgende Code-Snippet zeigt, wie Knex.js vor SQL-Injection-Angriffen schützt:

1const knex = require('knex')({
2  client: 'pg',
3  connection: {
4    host : '127.0.0.1',
5    user : 'your_database_user',
6    password : 'your_database_password',
7    database : 'myapp_test'
8  }
9});
10
11// This value is provided by the user and could be malicious
12// such as applying an OR 1=1 SQL injection or other
13// techniques that escape the original context of the query
14// and create a new one
15let userProvidedValue = 'maliciousValue';
16
17knex('users')
18  .where('id', '=', userProvidedValue)
19  .select()
20  .then(rows => {
21    // process result
22  })
23  .catch(err => {
24    // handle error
25  });

In diesem Beispiel maskiert Knex.js den Wert userProvidedValue automatisch und verhindert so potenzielle SQL-Injection-Angriffe.

Wie bereits erwähnt, bietet Knex.js allein keine vollständige Sandbox und keinen umfassenden Schutz vor SQL-Injection. Hier ein Beispiel für eine potenziell unsichere Verwendung von Knex.js, die zu einem SQL-Injection-Angriff führen könnte:

1knex.raw(`SELECT * FROM users WHERE id = ${userProvidedValue}`)

In diesem Fall wird userProvidedValue weder maskiert noch parametrisiert. Dadurch ist die Abfrage anfällig für SQL-Injection, wenn userProvidedValue schädlichen SQL-Code enthält. Snyk kann Entwicklern dabei helfen, solche Sicherheitslücken in ihrer Codebasis zu erkennen. Snyk untersucht Ihren Code und liefert konkrete Erkenntnisse zur Behebung von Sicherheitslücken, darunter potenzielle SQL-Injection-Angriffe.

FAQ zur Prävention von SQL-Injection mit Knex.js

5. Rate-Limiting mit fastify-rate-limit implementieren

Rate-Limiting ist ein wichtiger Sicherheitsmechanismus, der Ihre Webanwendungen vor Denial-of-Service-Angriffen (DoS) schützt. Indem Sie die Anzahl der Anfragen begrenzen, die ein Client innerhalb eines bestimmten Zeitraums an Ihre Anwendung senden kann, verhindern Sie, dass böswillige Clients Ihren Server mit einer großen Anzahl von Anfragen überlasten. So bleibt Ihre Anwendung für andere legitime Benutzer verfügbar.

fastify-rate-limit ist ein Plugin für das Fastify-Webframework, das eine einfache Möglichkeit bietet, Rate-Limiting in Ihren Node.js-Anwendungen zu implementieren. Mit dem Plugin können Sie die maximale Anzahl von Anfragen festlegen, die ein Client innerhalb eines bestimmten Zeitraums senden darf, sowie die Antwort, die bei Überschreitung dieses Limits gesendet wird.

Hier sehen Sie ein einfaches Beispiel dafür, wie Sie mit fastify-rate-limit Rate-Limiting in Ihrer Node.js-Anwendung implementieren können:

1const fastify = require('fastify')()
2
3fastify.register(require('@fastify/rate-limit'), {
4  // max number of connections during windowMs milliseconds before sending a 429 response
5  max: 100,
6  timeWindow: '1 minute'
7})
8
9fastify.get('/', (req, reply) => {
10  reply.send({ hello: 'world' })
11})
12
13fastify.listen(3000, err => {
14  if (err) throw err
15  console.log('Server listening at http://localhost:3000')
16})

In diesem Code-Snippet wird das Rate-Limit-Paket von Fastify so konfiguriert, dass jeder Client höchstens 100 Anfragen pro Minute senden kann. Überschreitet ein Client dieses Limit, antwortet der Server mit dem Statuscode 429 („Too Many Requests“).

FAQ zu Rate-Limiting

Warum Entwickler Snyk für JavaScript-Sicherheit nutzen sollten

In diesem Blogbeitrag haben wir fünf wichtige Node.js-Sicherheitscode-Snippets vorgestellt, die jeder Backend-Entwickler kennen sollte. Wir haben die Bedeutung sicherer Programmierpraktiken wie der Vermeidung von SQL-Injection erläutert und gezeigt, wie sie die Anwendungssicherheit verbessern. Angesichts der technologischen Entwicklung und der zunehmenden Komplexität von Cyberbedrohungen kann die Bedeutung sicherer Programmierung gar nicht genug betont werden.

Als Entwickler sollten Sie leistungsstarke Sicherheitstools nutzen, mit denen sich potenzielle Sicherheitslücken in Ihrem Code erkennen und beheben lassen. Ein solches Tool ist Snyk, eine leistungsstarke Developer-Security-Plattform, mit der Entwickler Sicherheitslücken in Code, Abhängigkeiten, Containern und mehr finden und beheben können. Mit Snyk können Sie Ihre Anwendung kontinuierlich auf Sicherheitslücken überwachen und erhalten automatische Fix-PRs, sobald eine neue Sicherheitslücke entdeckt wird.

1// Install Snyk CLI
2npm install -g snyk
3
4// Then run Snyk to find vulnerabilities
5snyk test

Snyk lässt sich nahtlos in Ihre IDEs und Ihre CI/CD-Pipeline integrieren. So können Sie während des gesamten Entwicklungszyklus Ihrer Anwendung kontinuierlich für Sicherheit sorgen. Snyk unterstützt zahlreiche Programmiersprachen, darunter Node.js, und ist damit ein vielseitiges Tool für Entwickler auf unterschiedlichen Plattformen.

Sicheres Programmieren ist eine grundlegende Praxis in der Softwareentwicklung, die alle Backend-Entwickler priorisieren sollten. Sicherheitstools wie Snyk unterstützen diese Praxis zusätzlich, indem sie Schwachstellen automatisch erkennen und beheben. Angesichts der sich ständig wandelnden Cyberbedrohungen sind solche Praktiken und Tools entscheidend, um die Sicherheit und Integrität unserer Anwendungen zu gewährleisten.