HTTP Strict Transport Security (HSTS)-Header sollten in Ihrem Node.js-Server zum Einsatz kommen

Bei den meisten Websites und Apps ist der Einsatz sicherheitsrelevanter HTTP-Header mittlerweile Standard. Websites verwenden Header in HTTP-Anfragen und -Antworten, um Informationen zu einer Seite oder zu über das HTTP-Protokoll gesendeten Daten zu übermitteln. So kann ein Content-Encoding-Header beispielsweise angeben, dass der Inhalt eine komprimierte ZIP-Datei ist, oder ein Location-Header eine Weiterleitungs-URL festlegen.

Unter den zahlreichen Security-Headern, die moderne Webbrowser zum Schutz ihrer Nutzer einsetzen, ist der HTTP-Strict-Transport-Security-Header (HSTS) besonders wichtig. Mit dem HSTS-Header weist eine Website den Browser an, bei jedem späteren Besuch das HTTPS-Protokoll zu verwenden.

Trotz ihres Nutzens, der einfachen Implementierung und der Unterstützung durch praktisch alle Browser enthalten nur etwa 25 % der mobilen und 28 % der Desktop-HTTP-Antworten HSTS-Header.

Sehen wir uns HSTS-Header genauer an, um herauszufinden, wie sie die Websicherheit beeinflussen und warum sie in Node.js eingesetzt werden sollten. Anschließend erfahren Sie, wie Sie HSTS in einem Node.js-Server aktivieren.

Warum sollten Sie HSTS aktivieren?

HTTPS-Verbindungen sind sicher, weil sie übertragene Datenpakete mithilfe von SSL/TLS-Zertifikaten ver- und entschlüsseln, die von bekannten Zertifizierungsstellen (CAs) überprüft werden können. Dadurch können nur der Computer des Nutzers und der Server die übertragenen Datenpakete lesen – unabhängig davon, wer den Netzwerkverkehr abfängt.

Typische HTTP-Verbindungen sind unverschlüsselt. Das bedeutet, dass jeder, der auf die Daten zugreift, sie lesen kann. Zu diesen unbeabsichtigten Empfängern zählen Server, die die Daten des Nutzers an den Zielserver weiterleiten, oder Hacker, die den Netzwerkverkehr über einen öffentlichen WLAN-Router abfangen.

Sehen Sie sich dazu die Ergebnisse des Web-Almanac-Berichts 2022 an, an dem auch Snyk mitgewirkt hat.

Derzeit enthalten nur 34 % der mobilen und 37 % der Desktop-Antworten auf Anfragen die includeSubdomain-Direktive.

Die große Mehrheit ist daher weiterhin anfälliger für Man-in-the-Middle- (MITM-)Angriffe. Diese können von Kreditkarten- oder Identitätsdiebstahl bis hin zu kompromittierten Web-Zugangsdaten für unsere Node.js-Webanwendung führen. Wichtig ist: Angreifer müssen die Daten nicht genau in dem Moment abfangen, in dem wir unsere Anmeldedaten eingeben. Browser-Cookies speichern und senden häufig unsere Sitzungs- und Zugriffstoken. So können Angreifer sie durch Session-Hijacking erlangen.

Wie funktioniert HSTS?

Enthält der HTTP-Antwortheader einen HSTS-Header, wissen Webbrowser, dass sie stets eine HTTPS-Verbindung zum Server verwenden müssen. Nutzer, die sich zuerst über HTTP verbunden haben, werden automatisch weitergeleitet. Von da an bleiben die Verbindungen zur Webanwendung oder Website verschlüsselt und sicher. So kann die App sichere Cookies verwenden, und MITM-Angriffe werden erschwert.

Der HSTS-Header bietet drei verschiedene Parameter. Sehen wir sie uns an.

max - age = <expire-time>

Dieser erforderliche Parameter gibt in Sekunden an, wie lange der Browser sich merken soll, die Website über HTTPS aufzurufen. Nach Ablauf dieser Zeit lädt der Browser die Website beim nächsten Besuch wie gewohnt. Jedes Mal, wenn der Browser den HSTS-Header empfängt, wird die Ablaufzeit aktualisiert. Dadurch kann der Parameter unbegrenzt aktiv bleiben. Alternativ können bestimmte Websites HSTS sofort deaktivieren, indem sie diesen Wert auf 0 setzen.

Beim Testen Ihrer HSTS-Konfiguration können Sie eine kurze Dauer festlegen, beispielsweise 300 Sekunden (fünf Minuten). Sobald Sie überprüft haben, dass Ihre Website ordnungsgemäß funktioniert, können Sie die Dauer verlängern, etwa auf 31.536.000 Sekunden (ein Jahr).

includeSubDomains

Der Parameter includeSubDomains ist eine optionale Direktive, die den Browser anweist, HSTS für die Website und alle ihre Subdomains zu aktivieren. Da diese Einstellung umfassend gilt, sollten Sie vor der Implementierung sicherstellen, dass alle Ihre Subdomains HTTPS unterstützen.

preload

Bei einer ersten Verbindung könnte möglicherweise eine manipulierte HTTP-Verbindung zum Einsatz kommen. Als Gegenmaßnahme pflegt Google den inoffiziellen Parameter preload. Die meisten großen Browser unterstützen diesen Security-Header, der das Risiko erheblich verringert. Eine Website kann den Parameter preload zum HSTS-Header hinzufügen und die Domain anschließend beim Preload-Dienst registrieren. Browser können dann diese Referenzliste prüfen, um festzustellen, ob bereits die erste Verbindung über HTTPS erfolgen kann. Damit der Parameter preload funktioniert, muss der Wert für max-age mindestens 31.536.000 Sekunden betragen und der Parameter includeSubDomains aktiviert sein.

Beachten Sie, dass die Bearbeitung eines Antrags auf Entfernung mehrere Monate dauern kann, sobald der Preload-Dienst Ihre Domain hinzugefügt hat. Wenn Sie Ihre Domain für das Preloading registrieren möchten, sollten Sie sich mit den Anforderungen für die Einreichung und den Empfehlungen für die Bereitstellung vertraut machen.

Sicherheit mit HSTS verbessern

Sehen wir uns an, wie Sie mit einem Node.js-Servercode auf einen HSTS-Header antworten. Alle Codebeispiele in diesem Artikel sind öffentlich verfügbar und finden sich im folgenden Open-Source-Repository auf GitHub.

Voraussetzungen

Für dieses Projekt benötigen Sie Folgendes:

• Einen registrierten Domainnamen

• Einen Server mit Node.js und verfügbaren Netzwerkports 80 und 433

• Einen funktionsfähigen DNS-Eintrag für die Domain, der auf den Server verweist

Ein SSL/TLS-Zertifikat abrufen

Bevor Sie HTTPS aktivieren können, benötigen Sie ein Zertifikat und einen privaten Schlüssel für die Domain. Falls Sie noch keines haben, können Sie es über Let’s Encrypt mit den folgenden Schritten abrufen:

Installieren Sie zunächst certbot, indem Sie dieser Anleitung folgen. Wählen Sie im Dropdown-Menü Software die Option other und im Dropdown-Menü System das Betriebssystem Ihres Servers. Folgen Sie dann den angezeigten Anweisungen.

Stellen Sie als Nächstes sicher, dass die Ports 80 und 443 auf dem Server geöffnet sind, und führen Sie den folgenden Befehl mit Ihrer Serverdomain aus:

1certbot certonly --standalone -d your.domain.url

Möglicherweise müssen Sie dem Befehl sudo voranstellen und ihn mit privilegierten Benutzerrechten ausführen.

Führen Sie nun certbot certificates aus (bei Bedarf mit sudo), um die Dateipfade des Zertifikats und des privaten Schlüssels abzurufen.

Servercode einrichten

Erstellen Sie zunächst einen Projektordner auf dem Server, indem Sie den Befehl mkdir snyk-demo ausführen.

Wechseln Sie anschließend mit cd snyk-demo in den Ordner.

Initialisieren Sie den Ordner dann mit npm init -y als Node.js-Projekt.

Installieren Sie nun einige Projektabhängigkeiten für den Server. Folgen Sie dabei den passenden Anweisungen für Express oder Fastify.

Express:

1npm install express helmet

Fastify:

1npm install fastify @fastify/helmet

Jetzt können wir einen einfachen Express-Node.js-Server erstellen, der HTTP und HTTPS verwendet.

Erstellen Sie in diesem Ordner eine Datei namens index.js und fügen Sie am Anfang des Codes die folgenden Node-Module hinzu.

Express:

1const fs = require( "fs" );
2const http = require( "http" );
3const https = require( "https" );
4const express = require( "express" );
5const helmet = require( "helmet" );

Fastify:

1const fs = require( "fs" );
2const helmet = require( "@fastify/helmet" );

Fügen Sie den folgenden Code hinzu, um die Zertifikatsdateien zu laden, und ersetzen Sie den Wert von certificatePath durch den Pfad zum Zertifikat Ihrer Domain. Wenn Sie certbot von Let’s Encrypt verwendet haben, können Sie mit certbot certificates die Dateipfade abrufen.

Express:

1// Replace the following with your domain certificate path
2const certificatePath = `/etc/letsencrypt/live/snykdemo.instafluff.tv/;
3const privateKey = fs.readFileSync( `${certificatePath}/privkey.pem, "utf8" );
4const certificate = fs.readFileSync( `${certificatePath}/fullchain.pem, "utf8" );
5// Add the following if your certificate includes a certificate chain
6// const ca = fs.readFileSync( `${certificatePath}/chain.pem, "utf8" );
7
8const credentials = {
9    key: privateKey,
10    cert: certificate,
11    // ca: ca, // Add the ca if there is a certificate chain
12};

Fastify:

1// Replace the following with your own domain certificate path
2const certificatePath = `/etc/letsencrypt/live/snykdemo.instafluff.tv/`;
3const fastify = require( "fastify" )({
4    https: {
5        key: fs.readFileSync( `${certificatePath}/privkey.pem, "utf8" ),
6        cert: fs.readFileSync( `${certificatePath}/fullchain.pem, "utf8" ),
7        // // Add the following if your certificate includes a certificate chain
8        // ca: fs.readFileSync( `${certificatePath}/chain.pem, "utf8" ),
9    },
10});
11const fastifyHttp = require( "fastify" )();

Initialisieren Sie nun die Express-/Fastify-App und erstellen Sie eine einfache Route.

Der folgende Code zeigt alle drei HSTS-Parameter. Für den Anfang können Sie jedoch auch nur den Parameter max-age verwenden.

Option 1: Helmet-Middleware verwenden

HSTS lässt sich zunächst über die Helmet-Middleware bei der App-Initialisierung einrichten:

Express:

1const app = express();
2app.use( helmet() );
3app.use( helmet.hsts( { maxAge: 300, includeSubDomains: true, preload: true } ) );
4
5app.use( ( req, res ) => {
6res.send( "Hello secure web!" );
7});

Fastify:

1const hsts = { maxAge: 300, includeSubDomains: true, preload: true };
2fastify.register( helmet, { hsts } );
3fastifyHttp.register( helmet, { hsts } );

Option 2: Header manuell festlegen

Alternativ können Sie den HSTS-Header manuell über eine Middleware festlegen, die ihn auf jede Antwort anwendet:

Express:

1const app = express();
2
3app.use( ( req, res ) => {
4    if( req.secure ) {
5         res.setHeader( "Strict-Transport-Security", "max-age=300; includeSubDomains; preload" );
6    }
7    res.send( "Hello secure web!" );
8});

Fastify:

1fastify.get( "/", ( req, res ) => {
2    res.header( "Strict-Transport-Security", "max-age=300; includeSubDomains; preload" );
3    res.send( "Hello secure web!" );
4});
5fastifyHttp.get( "/", ( req, res ) => {
6    res.header( "Strict-Transport-Security", "max-age=300; includeSubDomains; preload" );
7    res.send( "Redirect to HTTPS" );
8});

Zum Abschluss erstellen Sie mit dem folgenden Code die HTTP- und HTTPS-Server:

Express:

1const httpServer = http.createServer( app );
2httpServer.listen( 80, () => {
3console.log( "HTTP server started." );
4});
5
6const httpsServer = https.createServer( credentials, app );
7httpsServer.listen( 443, () => {
8console.log( "HTTPS server started" );
9});

Fastify:

1fastifyHttp.listen( { port: 80, host: "0.0.0.0" }, ( err, address ) => {
2    console.log( "HTTP server started" );
3});
4
5fastify.listen( { port: 443, host: "0.0.0.0" }, ( err, address ) => {
6    console.log( "HTTPS server started" );
7});

Hier finden Sie die Links zu den Code-Repositories der Express- und Fastify-Projekte.

Führen Sie schließlich den Servercode mit node index.js aus und öffnen Sie anschließend Ihre Domain in einem Webbrowser.

1bitnami@ip-172-26-14-29:~/snyk-demo$ sudo node index.js
2HTTP server started.
3HTTPS server started

Öffnen Sie die DevTools Ihres Browsers und überprüfen Sie die Antwortheader im Tab Network. Dort sehen Sie, dass der HSTS-Header angegeben ist.

Wie geht es weiter?

Sie wissen nun, warum HTTP-Strict-Transport-Security-Header für die Sicherheit von Node.js-Anwendungen wichtig sind, wie sie MITM-Angriffe verhindern helfen und wie Sie sie in Ihrem Node.js-Code implementieren. Damit verfügen Sie über die nötigen Werkzeuge, um Ihre Webanwendungen für Ihre Nutzer abzusichern.

Ein weiterer wichtiger Punkt: In einer Produktionsumgebung sollten Sie HSTS nicht einrichten und SSL nicht über die Node.js-App bereitstellen. Stattdessen sollten Sie diese Aufgaben an HTTP-Server für statische Dateien wie NGINX oder Apache auslagern.