Aktivieren von HTTPS auf express.js

Question

Ich versuche, HTTPS auf express.js für Knoten zu erhalten, und ich kann es nicht herausfinden.

Dies ist mein app.js Code.

var express = require('express');
var fs = require('fs');

var privateKey = fs.readFileSync('sslcert/server.key');
var certificate = fs.readFileSync('sslcert/server.crt');

var credentials = {key: privateKey, cert: certificate};

var app = express.createServer(credentials);

app.get('/', function(req,res) {
    res.send('hello');
});

app.listen(8000);

Wenn ich ihn ausführe, scheint er nur auf HTTP-Anfragen zu reagieren.

Ich schrieb einfache Vanille node.js basierte HTTPS-Anwendung:

var   fs = require("fs"),
      http = require("https");

var privateKey = fs.readFileSync('sslcert/server.key').toString();
var certificate = fs.readFileSync('sslcert/server.crt').toString();

var credentials = {key: privateKey, cert: certificate};

var server = http.createServer(credentials,function (req, res) {
  res.writeHead(200, {'Content-Type': 'text/plain'});
  res.end('Hello World\n');
});

server.listen(8000);

Und wenn ich diese Anwendung ausführe, dann tut auf HTTPS-Anfragen reagieren. Beachten Sie, dass ich nicht glaube, dass die toString() auf das fs-Ergebnis zählt, da ich Kombinationen von beiden und immer noch keine es bueno verwendet habe.

---

ÄNDERUNG ZUM ZUSATZ:

Für Produktionssysteme ist es wahrscheinlich besser, Nginx oder HAProxy als Proxy für Anfragen an Ihre Nodejs-Anwendung zu verwenden. Sie können Nginx so einrichten, dass es die SSL-Anfragen bearbeitet und nur http zu Ihrer nodejs-App spricht.

BEARBEITEN, UM HINZUZUFÜGEN (4/6/2015)

Für Systeme, die AWS nutzen, ist es besser, EC2 Elastic Load Balancers zu verwenden, um SSL-Termination zu handhaben und regulären HTTP-Verkehr zu Ihren EC2-Webservern zu ermöglichen. Für noch mehr Sicherheit richten Sie Ihre Sicherheitsgruppe so ein, dass nur der ELB HTTP-Datenverkehr an die EC2-Instanzen senden darf, wodurch verhindert wird, dass externer unverschlüsselter HTTP-Datenverkehr auf Ihre Rechner gelangt.

---

Answer 1

In express.js (seit Version 3) sollten Sie die folgende Syntax verwenden:

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

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

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

Auf diese Weise stellen Sie eine Express-Middleware für den nativen http/https-Server bereit

Wenn Sie Ihre Anwendung auf Ports unter 1024 laufen lassen wollen, müssen Sie sudo (nicht empfohlen) oder verwenden Sie einen Reverse-Proxy (z. B. nginx, haproxy).

Answer 2

Zunächst müssen Sie Folgendes erstellen selbstsigniert.schlüssel y selbstsigniert.crt Dateien. Gehe zu Ein selbstsigniertes SSL-Zertifikat erstellen Oder führen Sie folgende Schritte aus.

Gehen Sie zum Terminal und führen Sie den folgenden Befehl aus.

sudo openssl req -x509 -nodes -days 365 -newkey rsa:2048 -keyout ./selfsigned.key -out selfsigned.crt

• Danach geben Sie folgende Informationen ein
• Name des Landes (2-Buchstaben-Code) [AU]: US
• Name des Staates oder der Provinz (vollständiger Name) [Some-State]: NY
• Name des Ortes (z. B. Stadt) []: NY
• Name der Organisation (z. B. Unternehmen) [Internet Widgits Pty Ltd]: xyz (Ihre - Organisation)
• Name der Organisationseinheit (z. B. Abteilung) []: xyz (Name Ihrer Einheit)
• Common Name (z. B. Server-FQDN oder IHR Name) []: www.xyz.com (Ihre URL)
• E-Mail Adresse []: Deine E-Mail

Nach der Erstellung fügen Sie die Schlüssel- und Zertifizierungsdatei in Ihren Code ein und übergeben die Optionen an den Server.

const express = require('express');
const https = require('https');
const fs = require('fs');
const port = 3000;

var key = fs.readFileSync(__dirname + '/../certs/selfsigned.key');
var cert = fs.readFileSync(__dirname + '/../certs/selfsigned.crt');
var options = {
  key: key,
  cert: cert
};

app = express()
app.get('/', (req, res) => {
   res.send('Now using https..');
});

var server = https.createServer(options, app);

server.listen(port, () => {
  console.log("server starting on port : " + port)
});

• Führen Sie schließlich Ihre Anwendung mit https .

Weitere Informationen https://github.com/sagardere/set-up-SSL-in-nodejs

Answer 3

Ich bin auf ein ähnliches Problem gestoßen, als ich SSL an einem anderen Port als Port 443 zum Laufen bringen wollte. In meinem Fall hatte ich sowohl ein Bündelzertifikat als auch ein Zertifikat und einen Schlüssel. Das Bündelzertifikat ist eine Datei, die mehrere Zertifikate enthält. Der Knoten erfordert, dass Sie diese Zertifikate in separate Elemente eines Arrays aufteilen.

    var express = require('express');
    var https = require('https');
    var fs = require('fs');

    var options = {
      ca: [fs.readFileSync(PATH_TO_BUNDLE_CERT_1), fs.readFileSync(PATH_TO_BUNDLE_CERT_2)],
      cert: fs.readFileSync(PATH_TO_CERT),
      key: fs.readFileSync(PATH_TO_KEY)
    };

    app = express()

    app.get('/', function(req,res) {
        res.send('hello');
    });

    var server = https.createServer(options, app);

    server.listen(8001, function(){
        console.log("server running at https://IP_ADDRESS:8001/")
    });

In app.js müssen Sie https angeben und den Server entsprechend erstellen. Stellen Sie außerdem sicher, dass der Port, den Sie zu verwenden versuchen, tatsächlich eingehenden Datenverkehr zulässt.

Answer 4

Einschließlich Punkte:

1. SSL-Einrichtung
   1. In config/local.js
   2. In config/env/production.js

Handhabung von HTTP und WS

1. Die Anwendung muss in der Entwicklung über HTTP laufen, damit wir unsere Anwendung leicht debuggen können. App debuggen können.
2. Aus Sicherheitsgründen muss die Anwendung in der Produktion über HTTPS laufen.
3. Die HTTP-Anfrage der App-Produktion sollte immer auf https umgeleitet werden.

SSL-Konfiguration

In Sailsjs gibt es zwei Möglichkeiten, um alle Sachen zu konfigurieren, ist erstens in config Ordner mit jeder hat ihre separaten Dateien (wie Datenbankverbindung in Bezug auf Einstellungen liegt innerhalb connections.js ) zu konfigurieren. Und die zweite ist die Konfiguration auf der Basis der Umgebungsdateistruktur, jede Umgebungsdatei befindet sich in config/env und jede Datei enthält Einstellungen für bestimmte Umgebungen.

Sails schaut zuerst in den Ordner config/env und dann weiter zu config/ *.js

Jetzt können wir ssl einrichten in config/local.js .

var local = {
   port: process.env.PORT || 1337,
   environment: process.env.NODE_ENV || 'development'
};

if (process.env.NODE_ENV == 'production') {
    local.ssl = {
        secureProtocol: 'SSLv23_method',
        secureOptions: require('constants').SSL_OP_NO_SSLv3,
        ca: require('fs').readFileSync(__dirname + '/path/to/ca.crt','ascii'),
        key: require('fs').readFileSync(__dirname + '/path/to/jsbot.key','ascii'),
        cert: require('fs').readFileSync(__dirname + '/path/to/jsbot.crt','ascii')
    };
    local.port = 443; // This port should be different than your default port
}

module.exports = local;

Alternativ können Sie dies hinzufügen in config/env/production.js zu. (Dieses Snippet zeigt auch, wie man mehrere CARoot-Zertifikate handhabt)

Oder in produktion.js

module.exports = {
    port: 443,
    ssl: {
        secureProtocol: 'SSLv23_method',
        secureOptions: require('constants').SSL_OP_NO_SSLv3,
        ca: [
            require('fs').readFileSync(__dirname + '/path/to/AddTrustExternalCARoot.crt', 'ascii'),
            require('fs').readFileSync(__dirname + '/path/to/COMODORSAAddTrustCA.crt', 'ascii'),
            require('fs').readFileSync(__dirname + '/path/to/COMODORSADomainValidationSecureServerCA.crt', 'ascii')
        ],
        key: require('fs').readFileSync(__dirname + '/path/to/jsbot.key', 'ascii'),
        cert: require('fs').readFileSync(__dirname + '/path/to/jsbot.crt', 'ascii')
    }
};

http/https & ws/wss-Umleitung

Hier steht ws für Web Socket und wss für Secure Web Socket. Wenn wir ssl einrichten, werden http- und ws-Anfragen sicher und verwandeln sich in https bzw. wss.

Es gibt viele Quellen, aus denen unsere App Anfragen erhält, wie z.B. Blog-Posts, Social-Media-Posts, aber unser Server läuft nur auf https, wenn also eine Anfrage von http kommt, gibt es die Fehlermeldung "This site can't be reached" im Client-Browser. Und wir verlieren unseren Website-Verkehr. Wir müssen also http-Anfragen auf https umleiten, dieselben Regeln gelten auch für Websocket, sonst schlägt Socket fehl.

Wir müssen also denselben Server an Port 80 (http) betreiben und alle Anfragen an Port 443 (https) umleiten. Sails kompiliert zunächst die Datei config/bootstrap.js, bevor es den Server anhebt. Hier können wir unseren Express-Server auf Port 80 starten.

In config/bootstrap.js (http-Server erstellen und alle Anfragen auf https umleiten)

module.exports.bootstrap = function(cb) {
    var express = require("express"),
        app = express();

    app.get('*', function(req, res) {  
        if (req.isSocket) 
            return res.redirect('wss://' + req.headers.host + req.url)  

        return res.redirect('https://' + req.headers.host + req.url)  
    }).listen(80);
    cb();
};

Jetzt können Sie besuchen http://www.yourdomain.com wird er umgeleitet zu https://www.yourdomain.com

Answer 5

So funktioniert es bei mir. Die Umleitung verwendet wird, um alle normalen http als gut umleiten.

const express = require('express');
const bodyParser = require('body-parser');
const path = require('path');
const http = require('http');
const app = express();
var request = require('request');
//For https
const https = require('https');
var fs = require('fs');
var options = {
  key: fs.readFileSync('certificates/private.key'),
  cert: fs.readFileSync('certificates/certificate.crt'),
  ca: fs.readFileSync('certificates/ca_bundle.crt')
};

// API file for interacting with MongoDB
const api = require('./server/routes/api');

// Parsers
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: false }));

// Angular DIST output folder
app.use(express.static(path.join(__dirname, 'dist')));

// API location
app.use('/api', api);

// Send all other requests to the Angular app
app.get('*', (req, res) => {
  res.sendFile(path.join(__dirname, 'dist/index.html'));
});
app.use(function(req,resp,next){
  if (req.headers['x-forwarded-proto'] == 'http') {
      return resp.redirect(301, 'https://' + req.headers.host + '/');
  } else {
      return next();
  }
});

http.createServer(app).listen(80)
https.createServer(options, app).listen(443);