Node.js
Node.js-applicaties beveiligen

Cross-site request-vervalsing (CSRF) voorkomen

CSRF is een aanval die de eindgebruiker dwingt om ongewenste acties uit te voeren op een webtoepassing waarin hij / zij momenteel is geverifieerd.

Het kan gebeuren omdat cookies bij elk verzoek naar een website worden verzonden - zelfs wanneer die verzoeken van een andere site komen.

We kunnen de csurf module gebruiken om csrf-token te maken en te valideren.

Voorbeeld

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')
})

Dus wanneer we GET /form , geeft dit het csrf-token csrfToken aan de weergave.

Stel nu in de weergave de csrfToken-waarde in als de waarde van een verborgen invoerveld met de naam _csrf .

bijv. voor 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>

bijv. voor jade

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")

bijvoorbeeld voor ejs sjablonen

<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

Als u ervoor kiest om SSL / TLS in uw Node.js-toepassing af te handelen, moet u er rekening mee houden dat u op dit moment ook verantwoordelijk bent voor het handhaven van SSL / TLS-aanvalpreventie. In veel server-client-architecturen eindigt SSL / TLS op een reverse proxy, zowel om de complexiteit van applicaties te verminderen als om de reikwijdte van de beveiligingsconfiguratie te verminderen.

Als uw Node.js-applicatie SSL / TLS moet verwerken, kan deze worden beveiligd door de sleutel- en cert-bestanden te laden.

Als het certificaat provider een certificaatautoriteit (CA) keten vereist, kan het in de worden toegevoegd ca optie als een array. Een keten met meerdere vermeldingen in één bestand moet in meerdere bestanden worden gesplitst en in dezelfde volgorde in de array worden ingevoerd als Node.js ondersteunt momenteel niet meerdere CA-vermeldingen in één bestand. Een voorbeeld wordt gegeven in de onderstaande code voor bestanden 1_ca.crt en 2_ca.crt . Als de ca array vereist is en niet correct is ingesteld, kunnen clientbrowsers berichten weergeven die de authenticiteit van het certificaat niet konden verifiëren.

Voorbeeld

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 gebruiken

De minimale installatie voor een HTTPS-server in Node.js zou er ongeveer zo uitzien:

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);

Als u ook http-aanvragen wilt ondersteunen, moet u alleen deze kleine wijziging aanbrengen:

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);

Een HTTPS-server instellen

Nadat u node.js op uw systeem hebt geïnstalleerd, volgt u de onderstaande procedure om een eenvoudige webserver te laten werken met ondersteuning voor zowel HTTP als HTTPS!

Stap 1: Bouw een certificaatautoriteit

1. maak de map waarin u uw sleutel en certificaat wilt opslaan:

   mkdir conf

2. ga naar die map:

   cd conf

3. pak dit ca.cnf bestand om te gebruiken als een configuratiesnelkoppeling:

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

4. maak een nieuwe certificaatautoriteit met behulp van deze configuratie:

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

5. Nu we onze certificaatautoriteit hebben in ca-key.pem en ca-cert.pem , laten we een privésleutel voor de server genereren:

   openssl genrsa -out key.pem 4096

6. pak dit server.cnf bestand om als configuratiesnelkoppeling te gebruiken:

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

7. genereer het certificaatverzoek met deze configuratie:

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

8. teken de aanvraag:

   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

Stap 2: Installeer uw certificaat als rootcertificaat

1. kopieer uw certificaat naar de map van uw rootcertificaten:

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

2. update CA store:

   sudo update-ca-certificates

Secure express.js 3 Toepassing

De configuratie om een beveiligde verbinding te maken met express.js (sinds versie 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);

Op die manier biedt u express middleware aan de native http / https-server

Als u wilt dat uw app op poorten onder 1024 draait, moet u de opdracht sudo gebruiken (niet aanbevolen) of een omgekeerde proxy gebruiken (bijvoorbeeld nginx, haproxy).