Node.js
Sicherung von Node.js-Anwendungen

Verhindern von Cross Site Request Forgery (CSRF)

CSRF ist ein Angriff, der den Endbenutzer zwingt, unerwünschte Aktionen in einer Webanwendung auszuführen, in der er derzeit authentifiziert ist.

Dies kann passieren, weil bei jeder Anfrage Cookies an eine Website gesendet werden - auch wenn diese Anfragen von einer anderen Website stammen.

Wir können das csurf Modul verwenden, um ein csrf-Token zu erstellen und es zu überprüfen.

Beispiel

var express = require('express')
var cookieParser = require('cookie-parser')    //for cookie parsing
var csrf = require('csurf')    //csrf module
var bodyParser = require('body-parser')    //for body parsing

// setup route middlewares
var csrfProtection = csrf({ cookie: true })
var parseForm = bodyParser.urlencoded({ extended: false })

// create express app
var app = express()

// parse cookies
app.use(cookieParser())

app.get('/form', csrfProtection, function(req, res) {
  // generate and pass the csrfToken to the view
  res.render('send', { csrfToken: req.csrfToken() })
})

app.post('/process', parseForm, csrfProtection, function(req, res) {
  res.send('data is being processed')
})

Wenn wir also auf GET /form zugreifen, wird das csrf-Token csrfToken an die Ansicht übergeben.

Legen Sie nun in der Ansicht den csrfToken-Wert als Wert eines versteckten Eingabefelds mit dem Namen _csrf .

zB für handlebar

<form action="/process" method="POST">
    <input type="hidden" name="_csrf" value="{{csrfToken}}">
    Name: <input type="text" name="name">
    <button type="submit">Submit</button>
</form>

zB für jade Templates

form(action="/process" method="post")
    input(type="hidden", name="_csrf", value=csrfToken)

    span Name:
    input(type="text", name="name", required=true)
    br

    input(type="submit")

zB für ejs Vorlagen

<form action="/process" method="POST">
    <input type="hidden" name="_csrf" value="<%= csrfToken %>">
    Name: <input type="text" name="name">
    <button type="submit">Submit</button>
</form>

SSL / TLS in Node.js

Wenn Sie SSL / TLS in Ihrer Node.js-Anwendung verwenden möchten, müssen Sie an dieser Stelle auch für die Aufrechterhaltung des Schutzes gegen SSL / TLS-Angriffe verantwortlich sein. In vielen Server-Client-Architekturen wird SSL / TLS auf einem Reverse-Proxy beendet, um sowohl die Anwendungskomplexität als auch den Umfang der Sicherheitskonfiguration zu reduzieren.

Wenn Ihre Node.js-Anwendung SSL / TLS verarbeiten soll, kann dies durch Laden der Schlüssel- und Zertifizierungsdateien gesichert werden.

Wenn Ihr Zertifikatsanbieter eine Zertifizierungsstellenkette (Certificate Authority, CA) benötigt, kann er der Option " ca " als Array hinzugefügt werden. Eine Kette mit mehreren Einträgen in einer einzigen Datei muss in mehrere Dateien aufgeteilt und in derselben Reihenfolge in das Array eingefügt werden, da Node.js derzeit nicht mehrere ca-Einträge in einer Datei unterstützt. Im folgenden Code finden Sie ein Beispiel für die Dateien 1_ca.crt und 2_ca.crt . Wenn das ca Array erforderlich und nicht ordnungsgemäß festgelegt ist, zeigen Client-Browser möglicherweise Meldungen an, dass sie die Authentizität des Zertifikats nicht überprüfen konnten.

Beispiel

const https = require('https');
const fs = require('fs');

const options = {
  key: fs.readFileSync('privatekey.pem'),
  cert: fs.readFileSync('certificate.pem'),
  ca: [fs.readFileSync('1_ca.crt'), fs.readFileSync('2_ca.crt')]
};

https.createServer(options, (req, res) => {
  res.writeHead(200);
  res.end('hello world\n');
}).listen(8000);

HTTPS verwenden

Das minimale Setup für einen HTTPS-Server in Node.js wäre ungefähr so:

const https = require('https');
const fs = require('fs');

const httpsOptions = {
    key: fs.readFileSync('path/to/server-key.pem'),
    cert: fs.readFileSync('path/to/server-crt.pem')
};

const app = function (req, res) {
  res.writeHead(200);
  res.end("hello world\n");
}

https.createServer(httpsOptions, app).listen(4433);

Wenn Sie auch HTTP-Anfragen unterstützen möchten, müssen Sie nur diese kleine Änderung vornehmen:

const http = require('http');
const https = require('https');
const fs = require('fs');

const httpsOptions = {
    key: fs.readFileSync('path/to/server-key.pem'),
    cert: fs.readFileSync('path/to/server-crt.pem')
};

const app = function (req, res) {
  res.writeHead(200);
  res.end("hello world\n");
}

http.createServer(app).listen(8888);
https.createServer(httpsOptions, app).listen(4433);

Einrichten eines HTTPS-Servers

Nachdem Sie node.js auf Ihrem System installiert haben, folgen Sie den nachstehenden Anweisungen, um einen einfachen Webserver mit Unterstützung für HTTP und HTTPS zu starten!

Schritt 1: Erstellen Sie eine Zertifizierungsstelle

1. Erstellen Sie den Ordner, in dem Sie Ihren Schlüssel und Ihr Zertifikat speichern möchten:

   mkdir conf

2. Gehen Sie zu diesem Verzeichnis:

   cd conf

3. ca.cnf diese ca.cnf Datei, um sie als Konfigurationsverknüpfung zu verwenden:

   wget https://raw.githubusercontent.com/anders94/https-authorized-clients/master/keys/ca.cnf

4. Erstellen Sie eine neue Zertifizierungsstelle mit dieser Konfiguration:

   openssl req -new -x509 -days 9999 -config ca.cnf -keyout ca-key.pem -out ca-cert.pem

5. Jetzt, da wir unsere Zertifizierungsstelle in ca-key.pem und ca-cert.pem , generieren wir einen privaten Schlüssel für den Server:

   openssl genrsa -out key.pem 4096

6. server.cnf diese server.cnf Datei, um sie als Konfigurationsverknüpfung zu verwenden:

   wget https://raw.githubusercontent.com/anders94/https-authorized-clients/master/keys/server.cnf

7. Generieren Sie die Zertifikatsignierungsanforderung mit dieser Konfiguration:

   openssl req -new -config server.cnf -key key.pem -out csr.pem

8. unterschreibe die Anfrage:

   openssl x509 -req -extfile server.cnf -days 999 -passin "pass:password" -in csr.pem -CA ca-cert.pem -CAkey ca-key.pem -CAcreateserial -out cert.pem

Schritt 2: Installieren Sie Ihr Zertifikat als Stammzertifikat

1. Kopieren Sie Ihr Zertifikat in den Ordner Ihrer Stammzertifikate:

   sudo cp ca-crt.pem /usr/local/share/ca-certificates/ca-crt.pem

2. CA Store aktualisieren:

   sudo update-ca-certificates

Sichere express.js 3 Anwendung

Die Konfiguration zum Herstellen einer sicheren Verbindung mit express.js (Seit Version 3):

var fs = require('fs');
var http = require('http');
var https = require('https');
var privateKey  = fs.readFileSync('sslcert/server.key', 'utf8');
var certificate = fs.readFileSync('sslcert/server.crt', 'utf8');

// Define your key and cert

var credentials = {key: privateKey, cert: certificate};
var express = require('express');
var app = express();

// your express configuration here

var httpServer = http.createServer(app);
var httpsServer = https.createServer(credentials, app);

// Using port 8080 for http and 8443 for https 

httpServer.listen(8080);
httpsServer.listen(8443);

Auf diese Weise stellen Sie dem nativen http / https-Server Express-Middleware zur Verfügung

Wenn Sie möchten, dass Ihre App auf Ports unter 1024 ausgeführt wird, müssen Sie den Befehl sudo (nicht empfohlen) oder einen Reverse-Proxy (z. B. nginx, haproxy) verwenden.