webentwicklung-frage-antwort-db.com.de

Aktivieren von HTTPS in express.js

Ich versuche HTTPS dazu zu bringen, an express.js für node zu arbeiten, und ich kann es nicht herausfinden.

Das 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 es starte, scheint es nur auf HTTP-Anfragen zu antworten.

Ich habe eine einfache Vanilla node.js-basierte HTTPS-App geschrieben:

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 App starte, reagiert sie auf HTTPS-Anfragen. Beachten Sie, dass ich nicht denke, dass das toString () auf dem fs-Ergebnis von Bedeutung ist, da ich Kombinationen von beiden und immer noch kein es bueno verwendet habe.

BEARBEITEN ZU HINZUFÜGEN:

Für Produktionssysteme ist es wahrscheinlich besser, Nginx oder HAProxy zu verwenden, um Anforderungen an die NodeJS-App zu übermitteln. Sie können nginx so einrichten, dass es die SSL-Anforderungen verarbeitet, und einfach http mit Ihrer Node-App.js sprechen.

BEARBEITEN ZU HINZUFÜGEN (06.04.2015)

Für Systeme, die AWS verwenden, ist es besser, EC2 Elastic Load Balancers zu verwenden, um die SSL-Beendigung zu handhaben und regelmäßigen HTTP-Verkehr zu Ihren EC2-Webservern zuzulassen. Richten Sie aus Sicherheitsgründen Ihre Sicherheitsgruppe so ein, dass nur der ELB HTTP-Datenverkehr an die EC2-Instanzen senden kann, um zu verhindern, dass unverschlüsselter HTTP-Datenverkehr von außen auf Ihre Computer gelangt.

node.jshttpsexpress
331
Alan

In express.js (seit Version 3) sollten Sie 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 dem nativen http/https-Server Express-Middleware zur Verfügung

Wenn Ihre App auf Ports unter 1024 ausgeführt werden soll, müssen Sie den Befehl Sudo verwenden (nicht empfohlen) oder einen Reverse-Proxy (z. B. Nginx, Haproxy) verwenden.

536
codename-

Zuerst müssen Sie selfsigned.key und selfsigned.crt Dateien erstellen. Gehen Sie zu Selbstsigniertes SSL-Zertifikat erstellen

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 die folgenden Informationen ein
  • Country Name (2 Buchstaben Code) [AU]: [~ # ~] us [~ # ~]
  • Name des Bundesstaates oder der Provinz (vollständiger Name) [Some-State]: [~ # ~] ny [~ # ~]
  • Ortsname (zB Stadt) []: [~ # ~] ny [~ # ~]
  • Name der Organisation (zB Firma) [Internet Widgits Pty Ltd]: xyz (Ihre - Organisation)
  • Name der Organisationseinheit (z. B. Abschnitt) []: xyz (Name Ihrer Organisationseinheit)
  • Common Name (z. B. Server-FQDN oder IHR Name) []: www.xyz.com (Ihre URL)
  • E-Mail-Adresse []: Ihre E-Mail

Nach der Erstellung fügen Sie Ihrem Code die Datei key & cert hinzu 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 aus.

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

25
Dere Sagar

Ich hatte ein ähnliches Problem damit, dass SSL für einen anderen Port als Port 443 verwendet wurde. In meinem Fall hatte ich ein Bundle-Zertifikat sowie ein Zertifikat und einen Schlüssel. Das Bundle-Zertifikat ist eine Datei, die mehrere Zertifikate enthält. Für den Knoten müssen 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 verwendete Port tatsächlich eingehenden Datenverkehr zulässt. 

24
eomoto

Einschließlich Punkte:

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

HTTP- und WS-Behandlung

  1. Die App muss in der Entwicklung auf HTTP ausgeführt werden, damit wir unsereapp problemlos debuggen können. 
  2. Die App muss aus Sicherheitsgründen auf HTTPS in der Produktion ausgeführt werden.
  3. Die App-Produktions-HTTP-Anforderung sollte immer zu https umleiten.

SSL-Konfiguration

In Sailsjs gibt es zwei Möglichkeiten, alles zu konfigurieren. Zuerst müssen Sie den Konfigurationsordner mit den jeweils separaten Dateien konfigurieren (z. B. hat die Datenbankverbindung, die sich auf Einstellungen bezieht, eine Verbindung innerhalb von connections.js. Zweitens ist das Konfigurieren der Umgebungsbasis-Dateistruktur erforderlich. Jede Umgebungsdatei wird im Ordner config/env angezeigt, und jede Datei enthält Einstellungen für bestimmte Umgebungen.

Sails sucht zuerst im Ordner config/env und freut sich dann auf config/* .js

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

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 auch in config/env/production.js hinzufügen. (Dieses Snippet zeigt auch den Umgang mit mehreren CARoot-Zertifikaten.)

Oder in production.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

Ws is Web Socket und wss stellen Secure Web Socket dar, da wir ssl einrichten, dann werden http und ws beide Anforderungen sicher und wandeln sie in https bzw. wss um.

Es gibt viele Quellen aus unserer App, die eine Anfrage erhalten, wie jeder Blogbeitrag, ein Social-Media-Beitrag. Unser Server wird jedoch nur über https ausgeführt. Wenn eine Anfrage von http kommt, wird der Fehler "Diese Website kann nicht erreicht werden" im Client-Browser angezeigt. Und wir verlieren unseren Websiteverkehr. Daher müssen wir die http-Anfrage an https umleiten. Dieselben Regeln erlauben Websocket, andernfalls schlägt Socket fehl.

Wir müssen also denselben Server auf Port 80 (http) ausführen und alle Anforderungen an Port 443 (https) umleiten. Sails kompilieren zuerst die Datei config/bootstrap.js, bevor der Server angehoben wird. Hier können wir unseren Express-Server an Port 80 starten.

In config/bootstrap.js (http-Server erstellen und alle Anforderungen an 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 http://www.IhreDomain.com besuchen, es wird zu https://www.IhreDomain.com umgeleitet.

8
Nishchit Dhanani

So funktioniert es für mich. Die verwendete Umleitung leitet auch alle normalen http-Adressen um.

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);
3
shantanu Chandra

Nutzen Sie greenlock-express: Freies SSL, automatisiertes HTTPS

Greenlock behandelt das Ausstellen und Erneuern von Zertifikaten (über Let's Encrypt) und http => https-Umleitung, sofort einsatzbereit.

express-app.js:

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

app.use('/', function (req, res) {
  res.send({ msg: "Hello, Encrypted World!" })
});

// DO NOT DO app.listen()
// Instead export your app:
module.exports = app;

server.js:

require('greenlock-express').create({
  // Let's Encrypt v2 is ACME draft 11
  version: 'draft-11'
, server: 'https://acme-v02.api.letsencrypt.org/directory'

  // You MUST change these to valid email and domains
, email: '[email protected]'
, approveDomains: [ 'example.com', 'www.example.com' ]
, agreeTos: true
, configDir: "/path/to/project/acme/"

, app: require('./express-app.j')

, communityMember: true // Get notified of important updates
, telemetry: true       // Contribute telemetry data to the project
}).listen(80, 443);

Screencast

Sehen Sie sich die QuickStart-Demo an: https://youtu.be/e8vaR4CEZ5s

 

Für Localhost

Beantworten Sie diese Frage nur im Voraus, da es sich um eine häufig gestellte Frage handelt:

Sie können auf localhost keine SSL-Zertifikate haben. Sie können jedoch etwas wie Telebit verwenden, mit dem Sie lokale Apps als echte ausführen können.

Sie können private Domänen mit Greenlock auch über DNS-01-Challenges verwenden, die in README zusammen mit verschiedenen Plugins, die dies unterstützen, erwähnt werden.

Nichtstandardisierte Ports (d. H. Keine 80/443)

Lesen Sie den obigen Hinweis zu localhost - Sie können mit Let's Encrypt auch keine Standardports verwenden.

Sie können jedoch Ihre internen Nicht-Standard-Ports als externe Standardports über Port-Forward, Sni-Route oder über Telebit bereitstellen, das SNI-Routing und Port-Forwarding/Relaying für Sie übernimmt.

Sie können auch DNS-01-Herausforderungen verwenden. In diesem Fall müssen Sie keine Ports freigeben und Domains in privaten Netzwerken auf diese Weise sichern.

3
CoolAJ86

Dies ist mein Arbeitscode für Express 4.0 .

express 4.0 unterscheidet sich stark von 3.0 und anderen.

4.0 Sie haben/bin/www-Datei, die Sie hier https hinzufügen werden.

"npm start" ist die Standardmethode, mit der Sie den Express 4.0-Server starten.

die Funktion readFileSync () sollte __ dirname verwenden, um das aktuelle Verzeichnis abzurufen

while require () use ./ bezieht sich auf das aktuelle Verzeichnis.

Zuerst legen Sie private.key und public.cert im Ordner/bin ab. Dies ist derselbe Ordner wie die WWW-Datei .

0
hoogw