SSL/TLS-Pinning in Node.js implementieren

Da Angreifer Man-in-the-Middle-Angriffe (MITM) durchführen, reicht ein SSL/TLS-Zertifikat nicht mehr aus, um einer eingehenden Verbindung zu vertrauen. Deshalb setzen Entwickler zunehmend auf SSL/TLS-Pinning, auch Certificate- oder Public-Key-Pinning genannt, um die Authentizität und Integrität einer Verbindung zusätzlich zu bestätigen.

In einer Node.js-Anwendung bietet SSL/TLS-Pinning eine zusätzliche Sicherheitsebene, indem es Angreifer daran hindert, die Kommunikation zwischen Client und Server abzufangen und zu manipulieren.

Dieser Artikel erklärt Certificate-Pinning und beleuchtet dessen Vorteile und Einsatzmöglichkeiten in Node.js-Anwendungen.

Wann und warum Sie SSL/TLS-Pinning verwenden sollten

SSL/TLS-Pinning ist ein Sicherheitsmechanismus, der vor MITM- und anderen zertifikatsbezogenen Angriffen schützt. Dazu stellt es sicher, dass ein Client, beispielsweise eine Node.js-Anwendung, nur eine Verbindung zu einem Server mit einem zuvor verifizierten digitalen Zertifikat herstellt. Bei dieser Technik werden bestimmte Zertifikate oder öffentliche Schlüssel in Host-Anwendungen gespeichert und mit dem öffentlichen Schlüssel oder Zertifikat des Servers verglichen. Die Zertifikate oder öffentlichen Schlüssel können fest in den Anwendungen hinterlegt, über Umgebungsvariablen eingebunden oder für mehr Flexibilität extern in einem Key-Vault-Service gespeichert werden.

Certificate-Pinning verringert das Risiko von MITM-Angriffen, indem es alle Anfragen ohne passendes gepinntes Zertifikat als bösartig einstuft und abbricht – selbst wenn die Anfrage HTTPS verwendet. Außerdem hilft es, andere zertifikatsbezogene Schwachstellen zu verhindern, etwa Zertifikatsfälschung oder -manipulation und kompromittierte Zertifizierungsstellen (CAs).

Laut der Stack Overflow Developer Survey verwenden 47,12 % der Entwickler Node.js. Damit ist es eine etablierte Webtechnologie für serverseitige Anwendungen. In Node.js integrierte Module wie HTTPS bieten zusätzlichen Schutz, indem sie gepinnte Zertifikate validieren. Eine Node.js-Anwendung mit Certificate-Pinning vergleicht das während des TLS-Handshakes präsentierte Zertifikat mit dem vordefinierten Zertifikat oder den öffentlichen Schlüsseln. Bei einer Abweichung bricht sie die Anfrage auf der Transportschicht ab.

Ein Anwendungsfall für Certificate-Pinning sind Finanzanwendungen auf Mobilgeräten. Ein MITM-Angriff auf ein solches Gerät kann für den Besitzer katastrophale Folgen haben, da das Gerät sensible persönliche Daten wie Kreditkarten- oder Kontaktinformationen übertragen könnte. Neuere mobile Betriebssystemversionen wie Android Pie verfügen über Sicherheitsfunktionen, die es Anwendungen nur erlauben, sichere Verbindungen herzustellen. Angreifer könnten jedoch Phishing-Angriffe starten, indem sie selbstsignierte Zertifikate erstellen, um auf das Gerät zuzugreifen. Certificate-Pinning stellt sicher, dass die Anwendung keine nicht vertrauenswürdige Verbindung zulässt, selbst wenn das Gerät dem selbstsignierten Zertifikat vertraut.

Vorbereitung auf die Implementierung von SSL/TLS-Pinning

Wenn ein Client eine Netzwerkanfrage an einen Server sendet, initiiert die Transportschicht einen sicheren Handshake über das SSL/TLS-Protokoll. Der Server präsentiert sein digitales Zertifikat, das den für Verschlüsselung und Authentifizierung verwendeten öffentlichen Schlüssel enthält. Während des Handshakes ruft die Anwendung den öffentlichen Schlüssel des Servers aus dem präsentierten Zertifikat ab.

Die Anwendung vergleicht den abgerufenen öffentlichen Schlüssel mit einer vorkonfigurierten oder fest hinterlegten Kopie. Stimmen die Schlüssel überein, gilt die Verbindung als sicher und die Kommunikation kann fortgesetzt werden. Stimmen sie nicht überein, kann die Anwendung die Verbindung beenden oder gemäß ihrer Sicherheitsrichtlinien geeignete Maßnahmen ergreifen, etwa einen Alarm auslösen oder die Übertragung sensibler Daten verweigern.

CAs spielen eine wichtige Rolle beim Certificate-Pinning, da sie die SSL/TLS-Zertifikate für den Aufbau einer sicheren Verbindung bereitstellen. Die CA signiert das Zertifikat, das bei webbasierten Anwendungen vom Browser oder über die Vertrauenskette des Betriebssystems validiert wird. Certificate-Pinning bietet einen zusätzlichen Schritt, um zu bestätigen, dass dem Zertifikat vertraut werden kann.

TLS ist ein integriertes Modul in Node.js, das von einem Host ein Zertifikatsobjekt mit einem Feld für den öffentlichen Schlüssel extrahieren kann. Der folgende Code zeigt, wie Sie mit dem TLS-Modul eine Anfrage an einen Host senden und das Zertifikat als Objekt abrufen:

1const tls = require("tls");
2const host = "example.com";
3const port = 443;
4
5const socket = tls.connect(port, host, () => { 
6const certificate = socket.getPeerCertificate();
7 const publicKey = certificate.pubkey;
8
9 console.log("Public Key:", publicKey);
10 console.log("Certificate:", certificate);
11});
12
13socket.on("error", (error) => {
14 console.error("Connection error:", error);
15});

In diesem Code extrahiert die Methode getPeerCertificate das Zertifikat. Mit der Methode getPeerX509Certificate können wir das Peer-Zertifikat auch als Objekt im Format x509Certificate abrufen.

SSL/TLS-Pinning in Node.js implementieren

Um SSL/TLS-Pinning in einer Node.js-Anwendung zu verwenden, müssen Sie den Schlüssel oder das Zertifikat in den Anfrageoptionen angeben. Bei HTTPS unterstützen die Eigenschaften ca, cert und key in den Optionen von https.request das SSL/TLS-Pinning. Beim Pinning eines Zertifikats sollte die Eigenschaft `ca` ein Array mit vertrauenswürdigen, im Privacy-Enhanced-Mail-Format (PEM) codierten Zertifikaten oder CA-Zertifikaten enthalten. Die Eigenschaft `key` sollte ein Array mit privaten Schlüsseln enthalten, die zu einem vertrauenswürdigen Serverzertifikat gehören.

Snyk Code ist ein statisches Testtool für Anwendungssicherheit (SAST), das Sicherheitslücken in einer Codebasis während der Entwicklung in Echtzeit erkennt. Es ist über Befehle für die Befehlszeile (CLI), Software Development Kits (SDKs) für CI/CD-Pipelines, Weboberflächen, Erweiterungen für integrierte Entwicklungsumgebungen (IDEs) und Code-Editoren verfügbar. In einem Node.js-Projekt kann Snyk Code fehlende Unterstützung für SSL/TLS-Zertifikate erkennen und Sie darauf hinweisen.

Um fehlende SSL/TLS-Unterstützung zu erkennen, verwenden Sie den folgenden Befehl code test, um die Codebasis des Projekts über Ihr Terminal zu scannen. Mit dem Befehl snyk ignore --file-path=<file_path> können Sie Dateien oder Verzeichnisse vom Snyk-Scan ausschließen, beispielsweise das Verzeichnis node_modules mit den Node.js-Paketen:

snyk code test

SSL/TLS-Pinning bietet zwar Sicherheitsvorteile, kann bei mangelhafter Implementierung ohne Fehlerbehandlung aber auch verheerende Folgen haben. Ihre Pinning-Implementierung sollte einen Fail-Safe-Plan für Sonderfälle vorsehen, etwa wenn ein gepinntes Zertifikat widerrufen wird oder abläuft. Durch Fehlerbehandlung stürzt nicht die gesamte Anwendung ab, wenn ein Zertifikat oder öffentlicher Schlüssel nicht bestätigt werden kann. Audits können dabei helfen, solche Fälle zu protokollieren.

Erstellen Sie zunächst ein Verzeichnis namens snyk-tls und verwenden Sie:

npm init -y

Der folgende Code zeigt einen gepinnten Fingerabdruck des öffentlichen Schlüssels in einer Node.js-Anwendung. Dieser stimmt mit dem Fingerabdruck des öffentlichen Zertifikatsschlüssels für eine GET-Anfrage überein, die mit dem nativen Node.js-Modul https erstellt wurde. Stimmen die Fingerabdrücke der öffentlichen Schlüssel nicht überein, bricht der Code die Anfrage ab. Erstellen Sie eine Datei index.js und fügen Sie den folgenden Code ein, um es auszuprobieren:

1const https = require("https");
2
3const PINNED_CERT_FINGERPRINTS = [
4    "44:0C:58:51:4C:73:7C:67:DA:A2:72:29:81:68:CD:FC:51:B5:79:65:66:F0:55:FA:55:C4:45:30:BB:DD:09:82",
5];
6
7const options = {
8    hostname: "google.com",
9    port: 443,
10    path: "/",
11    method: "GET",
12    headers: {
13        "User-Agent": "Node.js/https"
14    }
15};
16
17const req = https.request(options, (res) => {
18    res.on("data", d => {
19        console.log("Request succeeded and received a response after certificate pinning validation")
20    });
21});
22
23req.on("error", console.error);
24
25req.on("socket", (socket) => {
26    socket.on("secureConnect", () => {
27        // Uses the sha256 fingerprint hash of the certificate instead of the certificate itself or
28        // the public key info. The one downside to this is that if/when the certificate
29        // changes the fingerprint will too and the PINNED_CERT_FINGERPRINTS will need to be updated.
30        // Reference: https://owasp.org/www-community/controls/Certificate_and_Public_Key_Pinning
31        const fingerprint256 = socket.getPeerCertificate().fingerprint256;
32
33        if (!PINNED_CERT_FINGERPRINTS.includes(fingerprint256)) {
34            req.emit("error", new Error("The certificate fingerprint received does not match any pinned certificate fingerprints"));
35            return req.destroy();
36        } else {
37            console.log("All OK. Server matched one of our pinned certificate fingerprints");
38        }
39    });
40});
41
42req.end();

Im obigen Code wird das Array PINNED_CERT_FINGERPRINTS geprüft, um festzustellen, ob der Fingerabdruck des öffentlichen Zertifikats zu den zulässigen Fingerabdrücken gehört. Ist er nicht enthalten, bricht die Methode destroy die Anfrage ab.

In der Produktionsumgebung sollten Sie den öffentlichen Schlüssel oder das Zertifikat in Umgebungsvariablen oder einem separaten Key-Vault-Service speichern. So verhindern Sie, dass der öffentliche Schlüssel offengelegt wird, wenn Sie den Code in ein Code-Repository übertragen.

SSL/TLS-Pinning testen und warten

Eine gute Möglichkeit, die Wirksamkeit einer Pinning-Implementierung zu testen, ist die Simulation eines MITM-Angriffs. Mit Tools wie Mitmproxy oder Wireshack können Sie eine Testumgebung einrichten, um Netzwerkanfragen für einen Test-Host zu überwachen, abzufangen und über einen Proxy weiterzuleiten.

Um die Wirksamkeit Ihres SSL/TLS-Pinnings zu testen, deaktivieren Sie die gepinnten Zertifikate und starten Sie über einen Proxy einen MITM-Angriff. So können Sie das Basisverhalten der Anwendung ohne Pinning aufzeichnen. Wiederholen Sie den Test anschließend mit aktiviertem Pinning, um festzustellen, ob die Anwendung den Proxy erkennt und die Verbindung beendet.

Eine weitere Möglichkeit, SSL/TLS-Pinning zu testen, ist der Vergleich des Zertifikatsschlüssel-Hashes. Ein Zertifikat-Hash ist für jedes Zertifikat eindeutig, da eine kryptografische Hashfunktion Daten beliebiger Größe in Werte fester Länge umwandelt, die das Zertifikat repräsentieren. Damit eignet er sich zur Validierung eines Zertifikats. Mit dem Node.js-Modul crypto können Sie einen Hash des Host-Zertifikats erzeugen und mit dem erwarteten Hash des öffentlichen Schlüssels vergleichen.

Eine dritte Möglichkeit, SSL/TLS-Pinning zu testen, ist ein SSL-Portscan mit Netzwerkscanning-Tools wie Nmap. Nmap stellt den Befehl ssl-enum-chipers bereit, um einen SSL-Port auf einem angegebenen Ziel zu scannen.

Gepinnte Zertifikate oder öffentliche Schlüssel zu pflegen und zu aktualisieren, ist entscheidend für das Vertrauen, die Sicherheit und die Integrität der Kommunikationskanäle. Durch regelmäßige Aktualisierungen können Sie die Risiken im Zusammenhang mit kompromittierten, abgelaufenen oder widerrufenen Zertifikaten verringern und zugleich sichere, authentifizierte Verbindungen gewährleisten.

Öffnen Sie den Ordner snyk-tls im Terminal und führen Sie den folgenden Befehl aus.

echo -n | openssl s_client -connect google.com:443 -servername google.com | sed -ne '/-BEGIN CERTIFICATE-/,/-END CERTIFICATE-/p' > cert.pem

Dieser Befehl erzeugt eine Datei cert.pem, die das öffentliche Zertifikat für google.com enthält.

Erstellen Sie anschließend im Projektordner eine Datei main.js. Fügen Sie den folgenden Code ein.

1// import the required modules
2const tls = require('node:tls');
3const https = require('node:https');
4const { exec } = require('child_process');
5
6// setting up the variables
7const certPath = 'cert.pem';
8const command = `openssl x509 -noout -in ${certPath} -fingerprint -sha256`;
9
10// generate SHA256 fingerprint of the certificate
11const generate_SHA256_fingerprint = () => {
12 return new Promise((resolve, reject) => {
13   exec(command, (error, stdout, stderr) => {
14     if (error) {
15       reject(new Error('Error executing OpenSSL command: ' + error));
16       return;
17     }
18
19     if (stderr) {
20       reject(new Error('OpenSSL command returned an error: ' + stderr));
21       return;
22     }
23
24     resolve(stdout.split('=')[1].trim());
25   });
26 });
27};
28
29// verify the certificate
30const verifyCertificate = async () => {
31 try {
32   const cert256 = await generate_SHA256_fingerprint();
33   console.log('Pinned Certificate Fingerprint:', cert256);
34
35   const options = {
36     hostname: 'google.com',
37     port: 443,
38     path: '/',
39     method: 'GET',
40     checkServerIdentity: function (host, cert) {
41       // Make sure the certificate is issued to the host we are connected to
42       const err = tls.checkServerIdentity(host, cert);
43       if (err) {
44         return err;
45       }
46
47       // Pin the exact certificate
48       if (cert.fingerprint256 !== cert256) {
49         const msg = 'Certificate verification error: ' +
50           `The certificate of '${cert.subject.CN}' ` +
51           'does not match our pinned fingerprint';
52         return new Error(msg);
53       }
54     },
55   };
56
57   options.agent = new https.Agent(options);
58   const req = https.request(options, (res) => {
59     console.log('All OK. Server matched our pinned cert');
60   });
61
62   req.on('error', (e) => {
63     console.error(e.message);
64   });
65
66   req.end();
67 } catch (error) {
68   console.error('Error generating SHA256 fingerprint:', error);
69 }
70};
71
72verifyCertificate();

Der obige Code importiert die erforderlichen Module und definiert zwei Variablen – certPath und command. certPath gibt den Pfad zur Zertifikatsdatei an. command enthält den Wert des Shell-Befehls, der den SHA-256-Fingerabdruck des Zertifikats erzeugt.

Die Funktion generate_SHA256_fingerprint() verwendet die Funktion exec, um den openssl-Befehl auszuführen, der den SHA-256-Fingerabdruck des Zertifikats erzeugt. Diese Funktion gibt ein Promise zurück, das mit dem Fingerabdruck aufgelöst wird.

Die Funktion verifyCertificate() definiert ein Optionsobjekt zur Konfiguration der HTTPS-Anfrage. Dieses Objekt legt hostname, port, path und method fest. Außerdem definiert es eine Funktion checkServerIdentity(), die das Serverzertifikat überprüft. Diese Funktion stellt sicher, dass das Zertifikat zum Host gehört, mit dem Sie eine Verbindung herstellen, und prüft, ob der Fingerabdruck mit dem gepinnten Fingerabdruck übereinstimmt.

Führen Sie zum Testen dieses Skripts den Befehl node main.js in Ihrem Terminal aus. Die folgende Ausgabe sollte angezeigt werden.

1All OK. Server matched our pinned cert

Um ein gepinntes Zertifikat oder einen Schlüssel zu aktualisieren, öffnen Sie die API-Datei und führen den Befehl openssl aus, der die Datei cert.pem erzeugt. Wenn Sie einen externen Vault-Service zum Speichern gepinnter Zertifikate oder öffentlicher Schlüssel verwenden, können Sie die Werte dort bearbeiten, ohne den Anwendungscode zu ändern. In folgenden Fällen müssen gepinnte Zertifikate möglicherweise aktualisiert werden:

• Zertifikate oder öffentliche Schlüssel laufen ab

• Datenlecks

• Widerruf durch den Aussteller

• Compliance-Richtlinien, die Nutzer dazu verpflichten, das Zertifikat nach einer festgelegten Dauer zu erneuern

Fazit

In diesem Artikel haben Sie erfahren, wie Sie SSL/TLS-Pinning in Node.js-Anwendungen implementieren. SSL/TLS-Pinning bietet eine zusätzliche Sicherheitsebene, indem der öffentliche Schlüssel oder das Zertifikat des Servers mit einer lokal gespeicherten Kopie abgeglichen wird. So schützt es Ihre Anwendungen vor MITM-Angriffen und anderen zertifikatsbezogenen Schwachstellen.

Node.js verfügt über integrierte Module wie HTTPS, die Certificate-Pinning unterstützen. Sie können SSL/TLS-Pinning implementieren, indem Sie den öffentlichen Schlüssel während des TLS-Handshakes vergleichen und die Verbindung bei einer Abweichung beenden. Eine angemessene Fehlerbehandlung ist ebenfalls wichtig, damit Sie in Sonderfällen nicht ausgesperrt werden, etwa wenn ein Zertifikat oder öffentlicher Schlüssel abläuft oder vom Aussteller widerrufen wird. Eine bewährte Vorgehensweise ist es, SSL/TLS-Pinning in Ihren Anwendungen durch simulierte Angriffe zu testen, Schlüssel-Hashes zu vergleichen und Zertifikate oder Schlüssel zu aktualisieren, um die Wirksamkeit sicherzustellen. Öffentliche Schlüssel sollten außerdem sicher gespeichert werden.

Mit SSL/TLS-Pinning können Sie die allgemeine Sicherheit Ihrer Node.js-Anwendungen verbessern und so ein zuverlässiges und sicheres Nutzungserlebnis gewährleisten.